From 5d7f99643462cb95701bfccefc8494314cca8e54 Mon Sep 17 00:00:00 2001 From: David Arias Date: Wed, 14 Oct 2026 14:56:53 -0500 Subject: [PATCH 1/2] Record exact P104 interleaved schedule checkpoint --- research/p104-interleaved-search/CHAINS.json | 791 +++++++++++++ research/p104-interleaved-search/README.md | 142 +++ research/p104-interleaved-search/RESULT.json | 1028 +++++++++++++++++ research/p104-interleaved-search/SOURCES.json | 108 ++ research/p104-interleaved-search/TASK.json | 117 ++ research/p104-interleaved-search/VERIFY.json | 29 + research/p104-interleaved-search/budget.py | 320 +++++ research/p104-interleaved-search/delivery.py | 363 ++++++ .../p104-interleaved-search/scalar_surgery.py | 355 ++++++ research/p104-interleaved-search/verify.py | 109 ++ 10 files changed, 3362 insertions(+) create mode 100644 research/p104-interleaved-search/CHAINS.json create mode 100644 research/p104-interleaved-search/README.md create mode 100644 research/p104-interleaved-search/RESULT.json create mode 100644 research/p104-interleaved-search/SOURCES.json create mode 100644 research/p104-interleaved-search/TASK.json create mode 100644 research/p104-interleaved-search/VERIFY.json create mode 100644 research/p104-interleaved-search/budget.py create mode 100644 research/p104-interleaved-search/delivery.py create mode 100644 research/p104-interleaved-search/scalar_surgery.py create mode 100644 research/p104-interleaved-search/verify.py diff --git a/research/p104-interleaved-search/CHAINS.json b/research/p104-interleaved-search/CHAINS.json new file mode 100644 index 0000000000..a9878bb7de --- /dev/null +++ b/research/p104-interleaved-search/CHAINS.json @@ -0,0 +1,791 @@ +{ + "schema": "p104-interleaved-delivery-v1", + "source_sha256": { + "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + "chains": [ + { + "pair_hamming_root_indices": [ + 3, + 113 + ], + "contacts": [ + { + "before_B_event": 0, + "register": 228, + "coefficient": "-4", + "frame": [ + 455, + 33, + 21, + 11 + ] + }, + { + "before_B_event": 6, + "register": 450, + "coefficient": "4", + "frame": [ + 42, + 30 + ] + }, + { + "before_B_event": 168, + "register": 220, + "coefficient": "-2", + "frame": [ + 42, + 30 + ] + }, + { + "before_B_event": 524, + "register": 134, + "coefficient": "-2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 548, + "register": 139, + "coefficient": "2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 551, + "register": 127, + "coefficient": "2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 553, + "register": 125, + "coefficient": "2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 653, + "register": 119, + "coefficient": "-2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 656, + "register": 154, + "coefficient": "-2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 658, + "register": 128, + "coefficient": "-2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 882, + "register": 580, + "coefficient": "2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 883, + "register": 581, + "coefficient": "2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 884, + "register": 582, + "coefficient": "2", + "frame": [ + 52 + ] + }, + { + "before_B_event": 885, + "register": 583, + "coefficient": "2", + "frame": [ + 52 + ] + } + ], + "query_cleanup": [ + { + "register": 115, + "coefficient": "-2" + }, + { + "register": 126, + "coefficient": "-2" + }, + { + "register": 146, + "coefficient": "-2" + }, + { + "register": 188, + "coefficient": "2" + }, + { + "register": 228, + "coefficient": "2" + }, + { + "register": 232, + "coefficient": "2" + }, + { + "register": 308, + "coefficient": "2" + }, + { + "register": 310, + "coefficient": "2" + }, + { + "register": 316, + "coefficient": "-2" + }, + { + "register": 318, + "coefficient": "-2" + }, + { + "register": 324, + "coefficient": "2" + }, + { + "register": 326, + "coefficient": "2" + }, + { + "register": 332, + "coefficient": "-2" + }, + { + "register": 334, + "coefficient": "-2" + }, + { + "register": 450, + "coefficient": "-4" + }, + { + "register": 504, + "coefficient": "2" + }, + { + "register": 505, + "coefficient": "2" + }, + { + "register": 516, + "coefficient": "2" + }, + { + "register": 517, + "coefficient": "2" + }, + { + "register": 580, + "coefficient": "-2" + }, + { + "register": 581, + "coefficient": "-2" + }, + { + "register": 582, + "coefficient": "-2" + }, + { + "register": 583, + "coefficient": "-2" + } + ], + "final_frame_overrides": { + "115": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "126": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "133": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "146": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "151": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "173": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "188": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "205": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "325": [ + 266, + 138, + 75, + 42, + 30 + ], + "450": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "580": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "581": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "582": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "583": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + } + }, + { + "pair_hamming_root_indices": [ + 4, + 57 + ], + "contacts": [ + { + "before_B_event": 0, + "register": 32, + "coefficient": "2", + "frame": [ + 74, + 24, + 6 + ] + }, + { + "before_B_event": 41, + "register": 587, + "coefficient": "-4", + "frame": [ + 76, + 30 + ] + }, + { + "before_B_event": 459, + "register": 113, + "coefficient": "2", + "frame": [ + 76, + 30 + ] + }, + { + "before_B_event": 464, + "register": 198, + "coefficient": "2", + "frame": [ + 76, + 30 + ] + }, + { + "before_B_event": 494, + "register": 144, + "coefficient": "4", + "frame": [ + 76, + 30 + ] + }, + { + "before_B_event": 569, + "register": 203, + "coefficient": "2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 572, + "register": 165, + "coefficient": "2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 574, + "register": 148, + "coefficient": "2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 674, + "register": 122, + "coefficient": "2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 677, + "register": 217, + "coefficient": "2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 679, + "register": 132, + "coefficient": "2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 766, + "register": 498, + "coefficient": "4", + "frame": [ + 82 + ] + }, + { + "before_B_event": 767, + "register": 499, + "coefficient": "-4", + "frame": [ + 82 + ] + }, + { + "before_B_event": 774, + "register": 530, + "coefficient": "-2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 874, + "register": 572, + "coefficient": "-2", + "frame": [ + 82 + ] + }, + { + "before_B_event": 875, + "register": 573, + "coefficient": "2", + "frame": [ + 82 + ] + } + ], + "query_cleanup": [ + { + "register": 32, + "coefficient": "-2" + }, + { + "register": 48, + "coefficient": "2" + }, + { + "register": 115, + "coefficient": "2" + }, + { + "register": 126, + "coefficient": "-2" + }, + { + "register": 133, + "coefficient": "-2" + }, + { + "register": 205, + "coefficient": "-2" + }, + { + "register": 242, + "coefficient": "2" + }, + { + "register": 243, + "coefficient": "-2" + }, + { + "register": 247, + "coefficient": "-2" + }, + { + "register": 249, + "coefficient": "2" + }, + { + "register": 252, + "coefficient": "-2" + }, + { + "register": 304, + "coefficient": "-2" + }, + { + "register": 308, + "coefficient": "2" + }, + { + "register": 311, + "coefficient": "-4" + }, + { + "register": 317, + "coefficient": "-2" + }, + { + "register": 456, + "coefficient": "4" + }, + { + "register": 457, + "coefficient": "-4" + }, + { + "register": 498, + "coefficient": "4" + }, + { + "register": 499, + "coefficient": "2" + }, + { + "register": 502, + "coefficient": "-2" + }, + { + "register": 503, + "coefficient": "2" + }, + { + "register": 530, + "coefficient": "2" + }, + { + "register": 572, + "coefficient": "2" + }, + { + "register": 573, + "coefficient": "-2" + }, + { + "register": 587, + "coefficient": "4" + } + ], + "final_frame_overrides": { + "115": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "126": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "133": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "146": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "151": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "173": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "188": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "205": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "307": [ + 385, + 74, + 42, + 24, + 6 + ], + "311": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "314": [ + 385, + 74, + 42, + 24, + 6 + ], + "339": [ + 416, + 65, + 19, + 10, + 7 + ], + "498": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "572": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "573": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "587": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + } + } + ] +} diff --git a/research/p104-interleaved-search/README.md b/research/p104-interleaved-search/README.md new file mode 100644 index 0000000000..d6be4bbe23 --- /dev/null +++ b/research/p104-interleaved-search/README.md @@ -0,0 +1,142 @@ +# P104 interleaved schedule search checkpoint + +**No complete P104 schedule or improved κ was found in this bounded follow-up.** +This package preserves exact partial constructions and their remaining costs. +It does not promote a local fragment, an oracle-assisted identity, or an +optimistic packing bound into a multiplication supplier. + +The starting point is canonical main +`0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. The selected result remains +κ = `836330098538459/500000000000000000`. The requested objective was a +significant, fully verified gain; the working search threshold was a 1% +relative improvement. That objective is **not achieved**. + +## What is retained + +1. **Conditional dirty-register surgery.** `scalar_surgery.py` replays the + selected 112-port word on all 704 independent input columns. It converts + eight source/target pairs into sixteen arbitrary dirty helper roles and + derives a 104-port identity, including actual compensation and restoration + gates. Its replacement cut reads eight explicitly hypothetical pure-source + queries. The checker reports the cut's incompatible survivor reads; it is + not a frame-legal implementation of those queries. +2. **An interleaved two-query delivery channel.** `delivery.py` checks the supplied + coefficient schedules against the selected scalar B word, propagates changed + frames through the later tail, and accounts for changed helper endpoints and + query-residual cancellation. These change the frame paths that were frozen + in the temporal-cut obstruction. Each fragment has an explicit external + query-input contract. It also replays both queries together: 30 contacts, + two simultaneous private copies, and zero remaining query perturbation in + every other register after cleanup. The two supplied query registers incur + two rank-one boundary moves, reported separately from the public-profile + deltas. This does not establish an + eight-query schedule, query construction, or concurrent native admission. +3. **A conditional cost screening tool.** `budget.py` uses exact rational interval + arithmetic in the pinned packing-ceiling engine. It distinguishes helper + boundary work that replaces an idle/remainder invoice from genuinely extra + transport work. Every reported candidate κ is an optimistic **upper bound** + under the stated retained template, not an achieved saving. + +The native fixture maps to removed selected port positions +`3, 14, 21, 34, 39, 61, 76, 93`. This differs from the puncture chosen in the +selected-port adapter package; the coordinate map and puncture are checked +directly, rather than conflating the two fixtures. +Both constructions use the same decoder orientation. For the two retained +delivery pairs, the supplied query must equal the scalar surgery's raw source +query divided by eight; the aggregate checker binds this normalization. This +agreement does not construct the queries or assemble the missing six terms. + +The selected contract already allocates **eight distinct private-centre +families**, separately from its ordinary helper families. The two simultaneous +private copies fit that stock; their overlap does not imply that ambient width +`m=73` must increase. The checker binds this count through the selected source +manifest to `complex-t16-rare-pattern-exchanges/data/SPEC.json`. The old emitter +still assumes sequential centre lifetimes, and the two external public query +registers need their own actual placement and construction. Physical private +stock sufficiency alone does not close those obligations. + +## Reproduce + +From the repository root, with Python 3.12 and the standard library: + +```sh +python3 -I -O -B research/p104-interleaved-search/verify.py +python3 scripts/research_package.py --package research/p104-interleaved-search +``` + +The registered command is read-only. It checks source hashes, recomputes the +exact receipt, compares it with `RESULT.json`, and runs rejecting controls. +The receipt separates the conditional scalar identity, delivery contracts, +and favorable cost models. It contains no admitted exponent claim. + +Validation on October 14, 2026 on macOS arm64 passed the registered replay with Python 3.12.14 +and a separate Python 3.14.7 replay from a read-only export containing only the +ten package files and eight declared inputs. The export replay ran outside the +checkout with `-I -O -B`; its file set and hashes were unchanged afterwards. +Four scalar-error controls, three delivery-error controls, and the cost +accounting checks all passed. No complete supplier or outer-theorem replay was +run, because this checkpoint does not supply their missing inputs. + +Discovery also explored persistent helper routes, changed packet timing, +alternative decoders, and constrained delivery-chain searches. Finite-field +and numerical optimization screens were used only to nominate candidates; +they are not evidence of rational identities or impossibility. Only the exact +replays retained here are acceptance evidence. Failure to find the other +chains is not a universal lower bound. +The final source-storage probe also found that simply dropping the punctured +source roles' old reads loses live-input transfers. Those roles carry selected +word intermediates; using them as query banks requires a replacement prefix, +not just new compensation for dirty inputs. + +## Remaining admission obligations + +The eight queries must be constructed from the actual source values at legal +chronological frames while preserving arbitrary dirty state. The remaining +six delivery terms must be scheduled, and all eight must coexist with query +construction and each other. Their combined frame changes, helper entrances, +cleanup and residual widths must be recomputed; separate profile deltas cannot +simply be added as a substitute for combined replay. + +A completed local word would still need its backward interface, native phase +recipes, chronological whole-call hosting, residual/idle children, precision +and reserve accounting, two exact moment checks, and the retained outer +inequalities. None of those missing obligations is waived here. With the +selected bit supplier unchanged, even a successful complex replacement remains +subject to the bit-side cap recorded by the budget checker. + +## Open next questions + +- **Can the source packet prefix produce the four non-coordinate queries + within the remaining budget?** This is necessary before a delivery fragment + can become a supplier. The first experiment should change the packet prefix + or later packet routing and replay its full dirty-state matrix; reusing a + register must also remove or preserve its existing lifetime. A scalar span + calculation alone does not supply storage or frame availability. +- **Can the remaining delivery terms share one legal chronological schedule?** + Start with the two exact fragments, add one term, then propagate every frame + through the tail and cleanup before pricing it. The blocker is the combined + lifetime and frame contract, not the decoder identity. +- **Does a completed candidate survive the full supplier invoice?** Only after + the first two questions are closed should whole-call hosting and the outer + certificate be rebuilt. An optimistic ceiling leaves unpriced obligations; + it cannot be used as a lower bound on κ. + +## Provenance and scope + +This follows the native P104 channel in PR1991 (Chafik Boukhalfa), the scalar +channel in PR1972 (Rohan Arun), and the chronological gather schedule in PR1940 +(Adam Gall). The P104 geometry and decoder work originate in PR1071 (Josie +Elliston), PR1125 (Ali Romman), PR717 and PR968. The selected scalar architecture +and Hamming packet construction retain their predecessor attribution, including +icekylinx's frame-sa504 work and the selected PR1042/PR1094 lineage. The packing +ceiling engine is Douglas Colkitt's existing work, not a new theorem here. + +The earlier temporal-cut result in PR2082 concerns a frozen native schedule; +this search explicitly changes that hypothesis. The live overlap check also +found the independent cut work in PR2090 and terminal-correction work in +PR2083/PR2089. Those results are not recast here as a new gain. Exact source +blobs, hashes and the local task record are in `SOURCES.json` and `TASK.json`. + +Prepared for David Arias with substantial OpenAI Codex assistance, including +parallel construction and checking. Apache-2.0. No formal proof assistant or +human independent review is claimed. diff --git a/research/p104-interleaved-search/RESULT.json b/research/p104-interleaved-search/RESULT.json new file mode 100644 index 0000000000..c81d719fc4 --- /dev/null +++ b/research/p104-interleaved-search/RESULT.json @@ -0,0 +1,1028 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "budget": { + "additional_hosted_width9_helper_count_upper_bounds_at_one_percent": { + "saved_helpers": { + "H1_plus_H8": 16, + "H2_plus_H7": 14 + }, + "two_delivery_profiles": { + "H1_plus_H8": 5, + "H2_plus_H7": 5 + } + }, + "chain_profile_inputs": [ + { + "a_root": 3, + "b_root": 113, + "descent": { + "1": 1, + "2": 1, + "4": 1 + }, + "injections": 14, + "local_tail_cleanup_delta": { + "1": 33, + "2": 19, + "3": -13, + "4": -4, + "5": -2 + }, + "residual_width_delta": { + "1": -5, + "4": 1, + "5": -1 + } + }, + { + "a_root": 4, + "b_root": 57, + "descent": { + "1": 2, + "5": 1 + }, + "injections": 16, + "local_tail_cleanup_delta": { + "1": 40, + "2": 24, + "3": -12, + "4": -6, + "5": -4 + }, + "residual_width_delta": { + "1": -5, + "4": 3, + "5": -3 + } + } + ], + "controls": { + "each_delivery_local_plus_residual_mass_is_zero": true, + "exact_difference_is_one_rank_of_idle_child_cost": true, + "full_coverage_and_zero_saving_moment_cases": 8, + "incorrect_idle_substitution_would_pass_same_target": true, + "incorrectly_hosted_moment": { + "lower": "57891720981567734905252852423419285193104348009634088233257706783548970156305/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "lower_decimal": "0.999925320682633137384792", + "upper": "57891720981567734905252852423419285193104348009634088233257706783548970156325/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "0.999925320682633137384792" + }, + "one_true_excess_H1_excludes_one_percent_target": true, + "saved_helpers_have_full_rank9_lifetimes": true, + "true_excess_moment": { + "lower": "96346108116882448203832110145750767808752820820385845656001055562602326917941235/96339018245447074592411059527228339333920627241812949280828709894583723860426752", + "lower_decimal": "1.00007359293840124506957", + "upper": "24086527029220612050958027536437691952188205205096461414000263890650581729493423/24084754561361768648102764881807084833480156810453237320207177473645930965106688", + "upper_decimal": "1.00007359293840124506957" + } + }, + "fixed_bit_gain_upper_percent_decimal": "3.45361675058909225751538", + "fixed_bit_kappa_upper_bound": "1733427039589844234749/1001733427039589844234749", + "hypotheses": [ + "Retain m=73, nine stages, four pairs, 104 ports, and all-helpers-hosted coverage.", + "Use the full retained local profile with sixteen deleted X/Y roles converted to dirty helpers.", + "Shorten eight H8 paths to H7 and charge centre COPY rank56.", + "The sixteen saved F2 partials each have an H2+H7 lifetime.", + "All remaining idle mass may be packed fractionally at rank51, even if no such owner packing exists.", + "Source-query formation, storage, the other six deliveries, and additional transport are uncharged.", + "The two-query perturbation profile is supplied by the combined delivery replay; this pricing module does not independently prove its schedule.", + "Two private-copy lifetimes fit the count of eight already allocated private-centre families; overlapping copies alone do not force m74. Concurrent native admission and actual public-query placement remain unproved.", + "The two supplied-query H_b-to-FULL rank1 boundaries are omitted unless included in an already charged query lifetime.", + "The fixed-bit and complex kappa caps use the retained balanced-transfer necessary inequalities." + ], + "necessary_complex_saving_for_target": "84469339952384359/49915530660047615641", + "optional_COPY_fallback_table": [ + { + "centre_COPY_rank": 56, + "complex_saving_root_interval": { + "lower": "217870899569/125000000000000", + "lower_decimal": "0.001742967196552", + "upper": "1742967196553/1000000000000000", + "upper_decimal": "0.001742967196553" + }, + "kappa_upper_bound": "1733427039589844234749/1001733427039589844234749", + "kappa_upper_bound_decimal": "0.00173042746982360296214729", + "local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 8 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "1118", + "local_mass": "5594", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115773834938015212677470049248794032622163692293682565629115918287226374900619/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.999842352794381570307066", + "upper": "57886917469007606338735024624397016311081846146841282814557959143613187450329/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "0.999842352794381570307066" + }, + "name": "retained_roles_COPY56", + "one_percent_target_excluded": false, + "per_call_margin_at_one_percent_target": { + "lower": "118652945456387849656082439310189002190900417726989667220827184463905805307/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "lower_decimal": "0.0145736083416148338356415", + "upper": "237305890912775699312164878620378004381800835453979334441654368927811611121/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "0.0145736083416148338356415" + }, + "relative_gain_upper_percent_decimal": "3.45361675058909225751538", + "status": "CEILING_NOT_SUPPLIER" + }, + { + "centre_COPY_rank": 57, + "complex_saving_root_interval": { + "lower": "847593984737/500000000000000", + "lower_decimal": "0.001695187969474", + "upper": "67807518779/40000000000000", + "upper_decimal": "0.001695187969475" + }, + "kappa_upper_bound": "67807518779/40067807518779", + "kappa_upper_bound_decimal": "0.00169231917037686522526826", + "local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 7, + "8": 1 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "319/9", + "idle_mass": "1118", + "local_mass": "5595", + "total_mass": "6713", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "7236939396873536688085292995177054983092566783232091319730364287582031709909/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "lower_decimal": "0.999990855270454286201000", + "upper": "115791030349976587009364687922832879729481068531713461115685828601312507358583/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "0.999990855270454286201000" + }, + "name": "retained_roles_COPY57", + "one_percent_target_excluded": false, + "per_call_margin_at_one_percent_target": { + "lower": "4588511804969794893954038705121869751969913684112669677606761936029885863/5427754182999196660479889922282245680622030531201901439349574250370927951872", + "lower_decimal": "0.000845379442448208974217955", + "upper": "286781987810612180872127419070116859498119605257041854850422621001867877/339234636437449791279993120142640355038876908200118839959348390648182996992", + "upper_decimal": "0.000845379442448208974217955" + }, + "relative_gain_upper_percent_decimal": "1.17531183765253421098632", + "status": "CEILING_NOT_SUPPLIER" + }, + { + "centre_COPY_rank": 58, + "complex_saving_root_interval": { + "lower": "102962883531/62500000000000", + "lower_decimal": "0.001647406136496", + "upper": "1647406136497/1000000000000000", + "upper_decimal": "0.001647406136497" + }, + "kappa_upper_bound": "1647406136497/1001647406136497", + "kappa_upper_bound_decimal": "0.00164469665313794447238516", + "local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 6, + "8": 2 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "310/9", + "idle_mass": "1118", + "local_mass": "5596", + "total_mass": "6714", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "28952056440484490335314831649217931709199611192436089150563934728849659954117/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "1.00013935774652700209493", + "upper": "28952056440484490335314831649217931709199611192436089150563934728849659954127/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "upper_decimal": "1.00013935774652700209493" + }, + "name": "retained_roles_COPY58", + "one_percent_target_excluded": true, + "per_call_margin_at_one_percent_target": { + "lower": "-52443705020739232487110161597411696467495338337325829094003449327908073859/4070815637249397495359917441711684260466522898401426079512180687778195963904", + "lower_decimal": "-0.0128828494567184158872056", + "upper": "-52443705020739232487110161597411696467495338337325829094003449327908073729/4070815637249397495359917441711684260466522898401426079512180687778195963904", + "upper_decimal": "-0.0128828494567184158872056" + }, + "relative_gain_upper_percent_decimal": "-1.67180064354024991460031", + "status": "CEILING_NOT_SUPPLIER" + }, + { + "centre_COPY_rank": 59, + "complex_saving_root_interval": { + "lower": "799810849029/500000000000000", + "lower_decimal": "0.001599621698058", + "upper": "1599621698059/1000000000000000", + "upper_decimal": "0.001599621698059" + }, + "kappa_upper_bound": "1599621698059/1001599621698059", + "kappa_upper_bound_decimal": "0.00159706699504047936386853", + "local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 5, + "8": 3 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "301/9", + "idle_mass": "1118", + "local_mass": "5597", + "total_mass": "6715", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115825421173899335673153965270910573944115821007775252088825649229484772274393/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00028786022259971798887", + "upper": "115825421173899335673153965270910573944115821007775252088825649229484772274433/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00028786022259971798887" + }, + "name": "retained_roles_COPY59", + "one_percent_target_excluded": true, + "per_call_margin_at_one_percent_target": { + "lower": "-433315175580823244578743408894659180995872447750944641784847880431354248461/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "lower_decimal": "-0.0266110783558850407486291", + "upper": "-48146130620091471619860378766073242332874716416771626864983097825706027549/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "upper_decimal": "-0.0266110783558850407486291" + }, + "relative_gain_upper_percent_decimal": "-4.51934004100430269034094", + "status": "CEILING_NOT_SUPPLIER" + }, + { + "centre_COPY_rank": 60, + "complex_saving_root_interval": { + "lower": "775917327301/500000000000000", + "lower_decimal": "0.001551834654602", + "upper": "1551834654603/1000000000000000", + "upper_decimal": "0.001551834654603" + }, + "kappa_upper_bound": "1551834654603/1001551834654603", + "kappa_upper_bound_decimal": "0.00154943019513130694938796", + "local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 4, + "8": 4 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "292/9", + "idle_mass": "1118", + "local_mass": "5598", + "total_mass": "6716", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "57921308292930355002524301972474710525716598622903073787697779771785452366159/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "lower_decimal": "1.00043636269867243388280", + "upper": "57921308292930355002524301972474710525716598622903073787697779771785452366179/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00043636269867243388280" + }, + "name": "retained_roles_COPY60", + "one_percent_target_excluded": true, + "per_call_margin_at_one_percent_target": { + "lower": "-109475921846448259868174361899945262686960590358764327865613660591846033581/2713877091499598330239944961141122840311015265600950719674787125185463975936", + "lower_decimal": "-0.0403393072550516656100527", + "upper": "-328427765539344779604523085699835788060881771076292983596840981775538100483/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "upper_decimal": "-0.0403393072550516656100527" + }, + "relative_gain_upper_percent_decimal": "-7.36730641172447686732784", + "status": "CEILING_NOT_SUPPLIER" + } + ], + "scenarios": [ + { + "centre_COPY_rank": 56, + "complex_saving_root_interval": { + "lower": "217870899569/125000000000000", + "lower_decimal": "0.001742967196552", + "upper": "1742967196553/1000000000000000", + "upper_decimal": "0.001742967196553" + }, + "kappa_upper_bound": "1733427039589844234749/1001733427039589844234749", + "kappa_upper_bound_decimal": "0.00173042746982360296214729", + "local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 8 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "1118", + "local_mass": "5594", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115773834938015212677470049248794032622163692293682565629115918287226374900619/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.999842352794381570307066", + "upper": "57886917469007606338735024624397016311081846146841282814557959143613187450329/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "0.999842352794381570307066" + }, + "name": "retained_16_dirty_roles", + "one_percent_target_excluded": false, + "per_call_margin_at_one_percent_target": { + "lower": "118652945456387849656082439310189002190900417726989667220827184463905805307/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "lower_decimal": "0.0145736083416148338356415", + "upper": "237305890912775699312164878620378004381800835453979334441654368927811611121/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "0.0145736083416148338356415" + }, + "relative_gain_upper_percent_decimal": "3.45361675058909225751538", + "status": "CEILING_NOT_SUPPLIER" + }, + { + "centre_COPY_rank": 56, + "complex_saving_root_interval": { + "lower": "107263628807/62500000000000", + "lower_decimal": "0.001716218060912", + "upper": "1716218060913/1000000000000000", + "upper_decimal": "0.001716218060913" + }, + "kappa_upper_bound": "1716218060913/1001716218060913", + "kappa_upper_bound_decimal": "0.00171327770277613606061312", + "local_profile": { + "1": 2428, + "2": 434, + "3": 432, + "4": 142, + "5": 82, + "7": 24 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "974", + "local_mass": "5738", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115783327347977389221210417047728581911922583946072498840132615042446973140399/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.999924330846808984620578", + "upper": "57891663673988694610605208523864290955961291973036249420066307521223486570219/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "0.999924330846808984620578" + }, + "name": "retained_roles_plus_16_saved_F2_helpers", + "one_percent_target_excluded": false, + "per_call_margin_at_one_percent_target": { + "lower": "18984093567413438447897248745206206252701559064141265204099425176672415579/2713877091499598330239944961141122840311015265600950719674787125185463975936", + "lower_decimal": "0.00699519282832497729763977", + "upper": "12656062378275625631931499163470804168467706042760843469399616784448277109/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "upper_decimal": "0.00699519282832497729763977" + }, + "relative_gain_upper_percent_decimal": "2.42831782391903518879046", + "status": "CEILING_NOT_SUPPLIER" + }, + { + "centre_COPY_rank": 56, + "complex_saving_root_interval": { + "lower": "53145654041/31250000000000", + "lower_decimal": "0.001700660929312", + "upper": "1700660929313/1000000000000000", + "upper_decimal": "0.001700660929313" + }, + "kappa_upper_bound": "1700660929313/1001700660929313", + "kappa_upper_bound_decimal": "0.00169777359209809937612154", + "local_profile": { + "1": 2504, + "2": 478, + "3": 407, + "4": 133, + "5": 77, + "7": 22 + }, + "m": 73, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "960", + "local_mass": "5752", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115788985266229093106790713682277970314566176612024164643752082334056744222285/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.999973193582501644652368", + "upper": "57894492633114546553395356841138985157283088306012082321876041167028372111163/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "0.999973193582501644652368" + }, + "name": "saved_helpers_plus_two_query_delivery_profile", + "one_percent_target_excluded": false, + "per_call_margin_at_one_percent_target": { + "lower": "6725270688721686357254540554864667191584116168865357361920293355501738155/2713877091499598330239944961141122840311015265600950719674787125185463975936", + "lower_decimal": "0.00247810437318129435886559", + "upper": "40351624132330118143527243329188003149504697013192144171521760133010429463/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "0.00247810437318129435886559" + }, + "relative_gain_upper_percent_decimal": "1.50140447324977661489782", + "status": "CEILING_NOT_SUPPLIER" + } + ], + "scope": "Necessary optimistic moment screens; no supplier, native-word, owner, or kappa improvement assertion.", + "selected_bit_lower": "1733427039589844234749/1000000000000000000000000", + "selected_kappa": "836330098538459/500000000000000000", + "selected_private_centre_stock": { + "scope": "Capacity only: the eight private centres are separate from ordinary helpers. Their count is not the ambient width m. No concurrent native admission or public-query placement is established.", + "selected_live_families": 14336, + "selected_ordinary_helper_families": 480, + "selected_physical_families": 14826, + "selected_private_centre_families": 8 + }, + "sources": [ + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } + ], + "status": "CEILING_NOT_SUPPLIER", + "target_kappa": "84469339952384359/50000000000000000000" + }, + "chain_input_sha256": "8d74eb0473a347d29e3f6e0dc5b9a4dea00bcf400f3725535c21e4e613a099f2", + "cross_checks": { + "delivery_pairs_belong_to_scalar_decoder": true, + "no_oracle_or_optimistic_ceiling_claimed_as_supplier": true, + "priced_single_chain_deltas_equal_replayed_deltas": true, + "priced_sum_equals_joint_chronological_replay": true, + "private_copy_peak_fits_selected_eight_centre_stock": true, + "retained_delivery_sources_need_raw_query_divided_by_eight": true, + "same_exact_104_port_puncture": true + }, + "delivery": { + "chains": [ + { + "all_live_output_query_coefficients_exact": true, + "all_other_query_perturbations_zero": true, + "contact_count": 14, + "local_B_tail_endpoint_cleanup_profile_delta": { + "1": 33, + "2": 19, + "3": -13, + "4": -4, + "5": -2 + }, + "pair_hamming_root_indices": [ + 3, + 113 + ], + "private_descent_mass": 7, + "private_descent_profile": { + "1": 1, + "2": 1, + "4": 1 + }, + "public_plus_residual_rank_mass_delta": 0, + "query_cleanup_count": 23, + "residual_width_profile_delta": { + "1": -5, + "4": 1, + "5": -1 + }, + "supplied_query_remaining_boundary_profile": { + "1": 1 + }, + "terminal_changes": [ + { + "after_rank": 5, + "before_rank": 4, + "register": 325 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 450 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 580 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 581 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 582 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 583 + } + ] + }, + { + "all_live_output_query_coefficients_exact": true, + "all_other_query_perturbations_zero": true, + "contact_count": 16, + "local_B_tail_endpoint_cleanup_profile_delta": { + "1": 40, + "2": 24, + "3": -12, + "4": -6, + "5": -4 + }, + "pair_hamming_root_indices": [ + 4, + 57 + ], + "private_descent_mass": 7, + "private_descent_profile": { + "1": 2, + "5": 1 + }, + "public_plus_residual_rank_mass_delta": 0, + "query_cleanup_count": 25, + "residual_width_profile_delta": { + "1": -5, + "4": 3, + "5": -3 + }, + "supplied_query_remaining_boundary_profile": { + "1": 1 + }, + "terminal_changes": [ + { + "after_rank": 5, + "before_rank": 4, + "register": 307 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 311 + }, + { + "after_rank": 5, + "before_rank": 4, + "register": 314 + }, + { + "after_rank": 5, + "before_rank": 4, + "register": 339 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 498 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 572 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 573 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 587 + } + ] + } + ], + "combined_two_query_channel": { + "all_other_query_perturbations_zero": true, + "all_query_coefficients_exact": true, + "changed_terminal_roles": [ + 307, + 311, + 314, + 325, + 339, + 450, + 498, + 572, + 573, + 580, + 581, + 582, + 583, + 587 + ], + "external_query_registers_required": 2, + "global_owner_hosting_verified": false, + "local_B_tail_endpoint_cleanup_profile_delta": { + "1": 73, + "2": 43, + "3": -25, + "4": -10, + "5": -6 + }, + "peak_simultaneous_private_copies": 2, + "private_copy_lifetimes": [ + { + "copy": 0, + "discarded_after_B_contact": 885, + "initialized_before_B_event": 0 + }, + { + "copy": 1, + "discarded_after_B_contact": 875, + "initialized_before_B_event": 0 + } + ], + "private_descent_mass": 14, + "public_plus_residual_rank_mass_delta": 0, + "query_count": 2, + "residual_width_profile_delta": { + "1": -10, + "4": 4, + "5": -4 + }, + "supplied_query_remaining_boundary_profile": { + "1": 2 + } + }, + "negative_controls": { + "corrupt_contact_coefficient": "rejected: query perturbation endpoint mismatch", + "drop_query_cleanup": "rejected: query perturbation endpoint mismatch", + "drop_terminal_frame_overrides": "rejected: terminal frame exceeded: (('early cleanup', 55), 325)" + }, + "query_input_contract": "One independent exact scalar q already available in H_b; forming q, its dirty-input compensation, and its initial boundary are not included. Its remaining H_b-to-FULL boundary is one rank-one child per query.", + "removed_selected_positions": [ + 3, + 14, + 21, + 34, + 39, + 61, + 76, + 93 + ], + "retained_role_baseline_profile_delta_from_selected": { + "1": 16 + }, + "schema": "p104-single-query-delivery-report-v1", + "scope": "One exact two-query delivery perturbation channel on a modified selected B schedule, with separate and joint invoices; no eight-query program or improved kappa.", + "source_sha256": { + "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + } + }, + "requested_verified_kappa_gain_achieved": false, + "scalar_surgery": { + "baseline_all_columns_pass": true, + "controls": { + "corrupted_hypothetical_query_bad_registers": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 137, + 138, + 139, + 140, + 141, + 142, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 191, + 192, + 193, + 194, + 195, + 196, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209 + ], + "corrupted_hypothetical_query_term_and_source": [ + 0, + 1 + ], + "corrupted_hypothetical_query_with_fixed_repairs_rejected": true, + "corrupted_original_cut_bad_registers": [ + 113, + 118 + ], + "corrupted_original_cut_coefficient_rejected": true, + "omitted_final_restoration_bad_registers": [ + 115, + 126, + 133, + 146, + 151, + 173, + 188, + 205 + ], + "omitted_final_restoration_rejected": true, + "omitted_new_compensation_bad_registers": [ + 112, + 113, + 114, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 127, + 128, + 129, + 130, + 131, + 132, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 147, + 148, + 149, + 150, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223 + ], + "omitted_new_compensation_live_dirty_entries": 6790, + "omitted_new_compensation_rejected": true + }, + "converted_dirty_roles": 16, + "decoder_hamming_root_pairs": [ + [ + 1, + 28 + ], + [ + 2, + 47 + ], + [ + 3, + 113 + ], + [ + 4, + 57 + ], + [ + 12, + 7 + ], + [ + 65, + 0 + ], + [ + 82, + 6 + ], + [ + 97, + 5 + ] + ], + "endpoint_role_changes": { + "removed_X_start_rank": [ + 1, + 0 + ], + "removed_Y_final_rank": [ + 8, + 9 + ] + }, + "hypothetical_cut_illegal_survivor_reads_by_term": [ + 0, + 0, + 0, + 0, + 26, + 0, + 26, + 28 + ], + "hypothetical_query_count": 8, + "hypothetical_query_definition": "q_k = sum over live s of dot(root_s,b_k)*initial_X_s; endpoint coefficient is dot(root_t,a_k)/(4*dot(a_k,b_k)). A delivery source may absorb the constant 1/(4*dot(a_k,b_k)); no assembled schedule is asserted.", + "hypothetical_scatter_additions": 296, + "input_columns": 704, + "live_ports": 104, + "live_target_transfer_rank": 104, + "new_full_frame_restoration_additions": 779, + "new_zero_frame_compensation_additions": 6790, + "original_ports": 112, + "query_scale_for_delivery_output_dot_a": [ + "-1/8", + "-1/8", + "1/8", + "1/8", + "1/8", + "1/8", + "1/8", + "-1/8" + ], + "removed_selected_positions": [ + 3, + 14, + 21, + 34, + 39, + 61, + 76, + 93 + ], + "repair_max_coefficient_denominator": 2, + "restoration_sources_without_retained_full_endpoint": [], + "retained_old_helpers": 480, + "scope": "Exact rational scalar identity under hypothetical pure-source query-cut access; no legal native schedule or kappa gain claimed.", + "sources": [ + { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "research/frame-sa504/inputs/hamming/PROTOTYPE.json", + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + } + ], + "status": "PASS_CONDITIONAL_SCALAR_SURGERY", + "unproved_obligations": [ + "Form and store the eight pure-source queries with restored dirty helpers.", + "Replace the hypothetical cut by legal native common-frame operations.", + "Check actual added transport, storage lifetimes, backward supplier, and whole-call hosting.", + "Establish a complete paid recurrence and a kappa improvement." + ] + }, + "schema_version": 1, + "selected_kappa_unchanged": "836330098538459/500000000000000000", + "status": "VERIFIED_PARTIAL_CHECKPOINT_NOT_A_SUPPLIER" +} diff --git a/research/p104-interleaved-search/SOURCES.json b/research/p104-interleaved-search/SOURCES.json new file mode 100644 index 0000000000..77065483e8 --- /dev/null +++ b/research/p104-interleaved-search/SOURCES.json @@ -0,0 +1,108 @@ +{ + "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-sw4-frame8/code/audit_allcold.py", + "usage": "provenance", + "git_blob": "c86f7b0235f738b4325c04c51abaf1aa5f015aaa", + "sha256": "a87d7f4844ca963516637d249b14a0654f67f8047b6b265ae25b0cf30963e503" + }, + { + "path": "research/complex-sw4-frame8/code/invoice_allcold.py", + "usage": "provenance", + "git_blob": "b244cd59940659465c07b013ebe3225077496f45", + "sha256": "141bd2fd58bbfb5b8d0fc8f56f61c45586d5608a5af3487c6b883dd987f998ec" + }, + { + "path": "research/complex-sw4-frame8/local/hpe_emit_local.py", + "usage": "provenance", + "git_blob": "534fdc71f7641c704575efc038363d7eb206b2df", + "sha256": "7e4a6fbc38c8228157b6311457d1496bf460291393043932d2c365f004f77805" + }, + { + "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/README.md", + "usage": "provenance", + "git_blob": "f187d1ac0b7792d08d2dedf4561380b798e541b5", + "sha256": "ef874f86415c98b553bda9199d5f8f2f7a4dd4f6a23e53712c3c1f7268ec5b23" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "usage": "input", + "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + { + "path": "research/selected-p104-port-adapter/README.md", + "usage": "provenance", + "git_blob": "e3cc3e1dfd71eba181cdd402c793f7822efb12bc", + "sha256": "eb2b31b6a8b6a93a2bc3c2d0b7092fb0228bee62d1e0a4c15456b2501c03a987" + } + ] +} diff --git a/research/p104-interleaved-search/TASK.json b/research/p104-interleaved-search/TASK.json new file mode 100644 index 0000000000..a0103af85c --- /dev/null +++ b/research/p104-interleaved-search/TASK.json @@ -0,0 +1,117 @@ +{ + "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": "changed", + "actual_scope": "Construct a P104 schedule with changed chronological frame access, persistent helper routes or a rebuilt selected-word centre, then require an exact completed moment and actual full supplier/outer verification before a kappa claim.", + "scope_change_reason": "User explicitly requests a constructive escape from PR2082, rather than another obstruction. No task reroll. Old frozen timeline and checkpoint-preserving insertion hypotheses must change.", + "bottleneck_link": "P104 COPY56 can beat the selected complex budget only if a complete side correction, dirty restoration, native compilation and chronological hosting retain the saving.", + "budget_minutes": 60, + "stop_rule": "Screen complete optimistic cost first. Investigate the smallest exact constructive candidates; one bounded pivot allowed. Stop construction of a candidate when a proved identity/access or full-cost failure rules it out. Do not present partial local success as the requested verified gain.", + "outcome": "partial", + "evidence": "RESULT.json: exact conditional 704-column surgery and a combined two-query delivery channel with two simultaneous private copies; all remaining query formation, six deliveries and global admission are unproved. Requested kappa gain not achieved.", + "author": "David Arias", + "ai_assistance": "Substantial OpenAI Codex assistance and parallel mathematical research; no human review or formal proof assistant.", + "open_questions": [ + { + "question": "Can a changed source packet prefix form all eight actual queries within the complete budget?", + "why_it_matters": "The current scalar cut is hypothetical and delivery starts with externally supplied queries.", + "first_step": "Compile one non-coordinate query with complete dirty-state replay and register lifetimes; then price all new boundary and excess work.", + "blocked_by": "Existing helper roles are not automatically free to hold new query values." + }, + { + "question": "Can the other six delivery terms coexist with the checked two-query channel?", + "why_it_matters": "The existing joint replay covers two of eight terms and already needs overlapping private copies.", + "first_step": "Add one term, replay every chronological frame through tail and cleanup, and recount peak live storage.", + "blocked_by": "No complete legal eight-term chronology or native supplier exists in this checkpoint." + }, + { + "question": "Can a completed local word be hosted and yield a strict new outer certificate?", + "why_it_matters": "A favorable packing ceiling is only a necessary screen, not an achieved exponent.", + "first_step": "After local completion, build actual owner windows, residual children, native recipes, reverse interface and exact moment/outer checks.", + "blocked_by": "Local query construction, six deliveries and workspace invoices remain open." + } + ], + "target": { + "minimum_desired_relative_kappa_gain": "1/100", + "selected_kappa": "836330098538459/500000000000000000", + "fixed_bit_outer_cap": "0.001730427469823602", + "acceptance": "Requested objective not achieved. An improved kappa still requires both supplier interfaces, native/frame/dirty-state/hosting invoices, two exact moment checks and outer constraints." + }, + "coordination": "No public Discussion messages or new PR. Local checkpoint only; prior PR2082 remains unchanged.", + "optimistic_budget": "P104 retained template m73 W832 N9 has36.444... spare ranks/call before moment effects. Existing terminal corrections costing104 or208 exceed this. New timing must reuse boundary progress or replace original work.", + "overlap_check": { + "searched_at": "2026-10-14T19:12:58.117087+00:00", + "open_prs": 363, + "discussions": 750, + "complete_pagination": true, + "related_prs": [ + 1972, + 1991, + 2082, + 2083, + 2089, + 2090 + ] + }, + "final_freshness": { + "main_checked_at": "2026-10-14T19:48:08.978442+00:00", + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "scientific_inputs_changed": false, + "overlap_searched_at": "2026-10-14T19:50:44.911060+00:00", + "open_prs": 380, + "discussion_records": 780, + "complete_pagination": true, + "new_related_prs": [ + 2096, + 2113 + ], + "new_related_discussions": [ + 2107 + ], + "decision": "Continue changed selected-word frame paths; new fixed-native-path retiming obstruction does not cover these fragments." + } +} diff --git a/research/p104-interleaved-search/VERIFY.json b/research/p104-interleaved-search/VERIFY.json new file mode 100644 index 0000000000..ecefdb0816 --- /dev/null +++ b/research/p104-interleaved-search/VERIFY.json @@ -0,0 +1,29 @@ +{ + "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/SPEC.json", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json", + "research/p104-native-channel/inputs/P104-FIXTURE.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Exact 704-column conditional scalar surgery; separate and joint two-query frame/cleanup replay; arithmetic/profile cross-checks; rejecting coefficient, cleanup, frame and cost-accounting controls. No supplier or improved kappa." + } + ] +} diff --git a/research/p104-interleaved-search/budget.py b/research/p104-interleaved-search/budget.py new file mode 100644 index 0000000000..35cd097202 --- /dev/null +++ b/research/p104-interleaved-search/budget.py @@ -0,0 +1,320 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact optimistic pricing of the retained-role P104 interleaving scenarios. + +This is CEILING_NOT_SUPPLIER: a feasible relaxation is not an admitted word, +owner allocation, or exponent improvement. Query formation is uncharged. +The package's aggregate verifier checks that the two-query chronological +replay gives exactly the public and residual deltas priced here. Thus their +sum is an actual joint perturbation invoice, not an assumption that separate +invoices can be added. This module prices that invoice without replaying it. +Source-query formation remains uncharged, as do the two final query H1 +boundaries unless already included in charged query lifetimes. Hosting the +two overlapping owned COPY lifetimes remains unproved. + +The interval engine is Douglas Colkitt's attributed complex-local-word-ceiling +work. The selected local profile is retained from PR1042 through the selected +PR1094 assembly and complex-block-rank-optimum. New scenario accounting was +prepared with substantial OpenAI Codex assistance. + +Run from any directory, standard library only: + python3 -I -B research/p104-interleaved-search/budget.py +Add --copy-table for the separate COPY56..60 fallback screen. +""" + +from __future__ import annotations + +import argparse +import gzip +import hashlib +import importlib.util +import json +from collections import Counter +from decimal import Decimal, localcontext +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +INPUTS = { + "engine": ( + "research/complex-local-word-ceiling/ceiling.py", + "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + ), + "word": ( + "research/complex-block-rank-optimum/inputs/selected.json.gz", + "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + ), + "assembly": ( + "research/community-frontier1094-audit/ASSEMBLY.json", + "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + ), + "selection": ( + "certificates/selected-result.json", + "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + ), + "stock": ( + "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d", + ), + "source_manifest": ( + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + ), +} +SELECTED_PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +SELECTED_KAPPA = Q(836330098538459, 500000000000000000) +BIT_LOWER = Q(1733427039589844234749, 1000000000000000000000000) +M, FAMILIES, STAGES, CENTRE = 73, 832, 9, 56 + +# Final early-placement variants replayed separately and jointly in delivery.py. +# Each descent has mass seven and replaces one hypothetical H7 child. +CHAIN_PROFILES = ( + { + "a_root": 3, + "b_root": 113, + "injections": 14, + "descent": {1: 1, 2: 1, 4: 1}, + "local_tail_cleanup_delta": {1: 33, 2: 19, 3: -13, 4: -4, 5: -2}, + "residual_width_delta": {1: -5, 4: 1, 5: -1}, + }, + { + "a_root": 4, + "b_root": 57, + "injections": 16, + "descent": {1: 2, 5: 1}, + "local_tail_cleanup_delta": {1: 40, 2: 24, 3: -12, 4: -6, 5: -4}, + "residual_width_delta": {1: -5, 4: 3, 5: -3}, + }, +) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def decimal(value: Q) -> str: + with localcontext() as context: + context.prec = 24 + return str(Decimal(value.numerator) / Decimal(value.denominator)) + + +def interval(bounds: tuple[Q, Q]) -> dict: + return { + "lower": str(bounds[0]), + "upper": str(bounds[1]), + "lower_decimal": decimal(bounds[0]), + "upper_decimal": decimal(bounds[1]), + } + + +def profile_json(profile: dict) -> dict[str, int]: + return {str(rank): int(count) for rank, count in sorted(profile.items()) if count} + + +def mass(profile: dict) -> int: + return sum(rank * count for rank, count in profile.items()) + + +def changed(profile: dict, delta: dict) -> dict[int, int]: + result = Counter(profile) + result.update(delta) + require(all(count >= 0 for count in result.values()), "negative local child count") + return {rank: count for rank, count in sorted(result.items()) if count} + + +def load_inputs() -> tuple[object, dict, dict, dict]: + loaded = {} + for name, (relative, expected) in INPUTS.items(): + data = (ROOT / relative).read_bytes() + require(hashlib.sha256(data).hexdigest() == expected, f"input hash: {relative}") + if name != "engine": + loaded[name] = json.loads(gzip.decompress(data) if relative.endswith(".gz") else data) + spec = importlib.util.spec_from_file_location("p104_budget_ceiling", ROOT / INPUTS["engine"][0]) + require(spec is not None and spec.loader is not None, "cannot load exact ceiling engine") + engine = importlib.util.module_from_spec(spec) + spec.loader.exec_module(engine) + # Repeated scenarios share most binary-search grid points. This caches + # exact interval results only; the pinned arithmetic is unchanged. + engine.child_cost = lru_cache(maxsize=8192)(engine.child_cost) + word, assembly = loaded["word"], loaded["assembly"] + require((word["v"], word["R"], word["h"]) == (112, 480, 9), "selected word dimensions") + require({int(r): n for r, n in word["local_profile"].items()} == SELECTED_PROFILE, + "selected profile changed") + require(Q(assembly["kappa"]) == SELECTED_KAPPA, "selected kappa changed") + require(Q(assembly["bit_lower"]) == BIT_LOWER, "selected bit supplier changed") + stock = loaded["stock"] + require(loaded["selection"]["source_manifest"] == INPUTS["source_manifest"][0], + "selected source-manifest path changed") + require(loaded["source_manifest"]["files"][INPUTS["stock"][0]] == INPUTS["stock"][1], + "stock is not bound by the selected source manifest") + contract, expected = stock["providers"]["gauge44"]["complete_contract"], stock["expected"] + require((contract["helpers"], contract["centres"], contract["n"]) == (480, 8, 704), + "selected private-centre stock changed") + require(expected["physical"] - expected["live"] == contract["helpers"] + contract["centres"] + 2, + "selected physical stock identity changed") + require(Q(expected["kappa"]) == SELECTED_KAPPA, "stock certificate selected result differs") + return engine, word, assembly, { + "selected_private_centre_families": contract["centres"], + "selected_ordinary_helper_families": contract["helpers"], + "selected_physical_families": expected["physical"], + "selected_live_families": expected["live"], + "scope": "Capacity only: the eight private centres are separate from ordinary helpers. Their count is not the ambient width m. No concurrent native admission or public-query placement is established.", + } + + +def retained_profile(copy_cost: int = CENTRE) -> dict[int, int]: + """Retain all16 deleted X/Y roles; shorten 64-COPY of eight H8 paths.""" + require(56 <= copy_cost <= 64, "COPY screen domain") + shortened = 64 - copy_cost + return changed(SELECTED_PROFILE, {1: 16, 8: -shortened, 7: shortened}) + + +def verify(include_copy_table: bool = False) -> dict: + engine, _, _, stock = load_inputs() + target_kappa = SELECTED_KAPPA * Q(101, 100) + target_a = target_kappa / (1 - target_kappa) + bit_cap = BIT_LOWER / (1 + BIT_LOWER) + rank_cap = engine.max_idle_rank(M) + require(rank_cap == 51, "outer rank cap changed") + w = Q(FAMILIES, STAGES) + require(FAMILIES == 2 * 4 * 104, "four-pair P104 family count") + zero_checks = 0 + + def describe(name: str, local: dict, centre: int = CENTRE, m: int = M) -> dict: + nonlocal zero_checks + model = engine.model(local, m, FAMILIES, STAGES, centre) + total = (m - 1) * w + centre + require(model["local_mass"] + model["idle_mass"] == total, "full coverage mass identity") + zero = engine.relax(local, m, FAMILIES, STAGES, centre, Q(0)) + require(zero[0] <= total / (m * w) <= zero[1], "zero-saving coverage moment") + zero_checks += 1 + bounds = engine.ceiling(local, m, FAMILIES, STAGES, centre) + require(engine.relax(local, m, FAMILIES, STAGES, centre, bounds[0])[1] < 1, + "lower root bracket is not certified") + require(engine.relax(local, m, FAMILIES, STAGES, centre, bounds[1])[0] > 1, + "upper root bracket is not certified") + moment = engine.relax(local, m, FAMILIES, STAGES, centre, target_a) + kappa_cap = min(bounds[1] / (1 + bounds[1]), bit_cap) + return { + "name": name, + "status": "CEILING_NOT_SUPPLIER", + "m": m, + "local_profile": profile_json(local), + "centre_COPY_rank": centre, + "model": {key: str(value) for key, value in model.items()}, + "complex_saving_root_interval": interval(bounds), + "kappa_upper_bound": str(kappa_cap), + "kappa_upper_bound_decimal": decimal(kappa_cap), + "relative_gain_upper_percent_decimal": decimal(100 * (kappa_cap / SELECTED_KAPPA - 1)), + "moment_at_one_percent_target": interval(moment), + "per_call_margin_at_one_percent_target": interval(((1 - moment[1]) * w, (1 - moment[0]) * w)), + "one_percent_target_excluded": moment[0] > 1, + } + + retained = retained_profile() + # Each additional dirty save enters at rank2 and finishes at FULL: H2+H7. + # These 144 units are hosted mass replacing idle mass, not excess travel. + saved = changed(retained, {2: 16, 7: 16}) + require(mass(saved) - mass(retained) == 16 * 9, "saved-helper lifetime mass") + chains = saved + for chain in CHAIN_PROFILES: + require(mass(chain["descent"]) == 7, "delivery descent mass") + require(mass(chain["local_tail_cleanup_delta"]) + mass(chain["residual_width_delta"]) == 0, + "delivery local/residual mass cancellation") + delta = Counter(chain["local_tail_cleanup_delta"]) + delta.update(chain["descent"]) + delta[7] -= 1 + chains = changed(chains, delta) + scenarios = [ + describe("retained_16_dirty_roles", retained), + describe("retained_roles_plus_16_saved_F2_helpers", saved), + describe("saved_helpers_plus_two_query_delivery_profile", chains), + ] + + # A genuine extra transport increases paid mass beyond the fixed coverage + # identity. Calling relax(local+H1) would silently subtract one idle rank. + # This control makes that error change the 1% screening verdict. + original_moment = engine.relax(saved, M, FAMILIES, STAGES, CENTRE, target_a) + child = engine.child_cost(1, M, target_a) + true_excess = tuple(original_moment[i] + child[i] / w for i in (0, 1)) + falsely_hosted = engine.relax(changed(saved, {1: 1}), M, FAMILIES, STAGES, CENTRE, target_a) + idle_child = engine.child_cost(rank_cap, M, target_a) + gap = (true_excess[0] - falsely_hosted[1], true_excess[1] - falsely_hosted[0]) + expected_gap = tuple(x / (rank_cap * w) for x in idle_child) + require(gap[0] <= expected_gap[0] <= expected_gap[1] <= gap[1], "excess/idle substitution gap") + require(true_excess[0] > 1 and falsely_hosted[1] < 1, "excess-transport control did not separate verdicts") + + # Upper counts only: favorable rank51 idle, hypothetical legal lifetimes, + # and all omitted query/gather/remaining delivery work still free. + helper_limits = {} + for label, local in (("saved_helpers", saved), ("two_delivery_profiles", chains)): + moment = engine.relax(local, M, FAMILIES, STAGES, CENTRE, target_a) + margin = ((1 - moment[1]) * w, (1 - moment[0]) * w) + helper_limits[label] = {} + for name, shape in (("H1_plus_H8", {1: 1, 8: 1}), ("H2_plus_H7", {2: 1, 7: 1})): + costs = {r: engine.child_cost(r, M, target_a) for r in shape} + penalty = ( + sum(n * costs[r][0] for r, n in shape.items()) - Q(9, rank_cap) * idle_child[1], + sum(n * costs[r][1] for r, n in shape.items()) - Q(9, rank_cap) * idle_child[0], + ) + require(penalty[0] > 0, "helper substitution penalty") + limit_lo, limit_hi = margin[0] // penalty[1], margin[1] // penalty[0] + require(limit_lo == limit_hi and limit_lo >= 0, "helper count not separated by exact intervals") + helper_limits[label][name] = int(limit_lo) + + fallback = [] + if include_copy_table: + fallback = [describe(f"retained_roles_COPY{copy}", retained_profile(copy), copy) for copy in range(56, 61)] + require(all(item["one_percent_target_excluded"] for item in fallback if item["centre_COPY_rank"] >= 58), + "COPY58..60 fallback control changed") + return { + "status": "CEILING_NOT_SUPPLIER", + "scope": "Necessary optimistic moment screens; no supplier, native-word, owner, or kappa improvement assertion.", + "sources": [{"path": path, "sha256": digest} for path, digest in INPUTS.values()], + "selected_kappa": str(SELECTED_KAPPA), + "selected_bit_lower": str(BIT_LOWER), + "fixed_bit_kappa_upper_bound": str(bit_cap), + "fixed_bit_gain_upper_percent_decimal": decimal(100 * (bit_cap / SELECTED_KAPPA - 1)), + "target_kappa": str(target_kappa), + "necessary_complex_saving_for_target": str(target_a), + "hypotheses": [ + "Retain m=73, nine stages, four pairs, 104 ports, and all-helpers-hosted coverage.", + "Use the full retained local profile with sixteen deleted X/Y roles converted to dirty helpers.", + "Shorten eight H8 paths to H7 and charge centre COPY rank56.", + "The sixteen saved F2 partials each have an H2+H7 lifetime.", + "All remaining idle mass may be packed fractionally at rank51, even if no such owner packing exists.", + "Source-query formation, storage, the other six deliveries, and additional transport are uncharged.", + "The two-query perturbation profile is supplied by the combined delivery replay; this pricing module does not independently prove its schedule.", + "Two private-copy lifetimes fit the count of eight already allocated private-centre families; overlapping copies alone do not force m74. Concurrent native admission and actual public-query placement remain unproved.", + "The two supplied-query H_b-to-FULL rank1 boundaries are omitted unless included in an already charged query lifetime.", + "The fixed-bit and complex kappa caps use the retained balanced-transfer necessary inequalities.", + ], + "chain_profile_inputs": [ + {key: profile_json(value) if isinstance(value, dict) else value for key, value in chain.items()} + for chain in CHAIN_PROFILES + ], + "scenarios": scenarios, + "additional_hosted_width9_helper_count_upper_bounds_at_one_percent": helper_limits, + "controls": { + "full_coverage_and_zero_saving_moment_cases": zero_checks, + "each_delivery_local_plus_residual_mass_is_zero": True, + "saved_helpers_have_full_rank9_lifetimes": True, + "one_true_excess_H1_excludes_one_percent_target": True, + "incorrect_idle_substitution_would_pass_same_target": True, + "true_excess_moment": interval(true_excess), + "incorrectly_hosted_moment": interval(falsely_hosted), + "exact_difference_is_one_rank_of_idle_child_cost": True, + }, + "optional_COPY_fallback_table": fallback, + "selected_private_centre_stock": stock, + } + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--copy-table", action="store_true", help="also price retained-role COPY56..60 scenarios") + args = parser.parse_args() + print(json.dumps(verify(include_copy_table=args.copy_table), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/delivery.py b/research/p104-interleaved-search/delivery.py new file mode 100644 index 0000000000..7314413eb7 --- /dev/null +++ b/research/p104-interleaved-search/delivery.py @@ -0,0 +1,363 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact single and joint delivery checks; no full P104 schedule is claimed. + +Each recorded chain starts with an independently supplied scalar query in H_b. +It replays one selected B word with monotone frame joins, the early cleanup +(tail), original full-frame cleanup, and explicit extra query cleanup. The +remaining six decoder terms, forming these queries, native transport recipes, +and global ownership are outside this certificate. +""" +from collections import Counter, defaultdict +from copy import deepcopy +from fractions import Fraction +import gzip +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +FULL = frozenset(range(512)) + + +class VerificationError(ValueError): + """A literal contract, endpoint, or source pin failed.""" + + +def require(condition, message): + if not condition: + raise VerificationError(message) + + +def span(basis): + out = {0} + for value in basis: + require(type(value) is int and 0 < value < 512, "invalid frame vector") + require(value not in out, "dependent frame basis") + out |= {x ^ value for x in tuple(out)} + return frozenset(out) + + +def join(left, right): + out = set(left) + for value in sorted(right): + if value not in out: + out |= {x ^ value for x in tuple(out)} + return frozenset(out) + + +def dimension(frame): + return len(frame).bit_length() - 1 + + +def pairing(a, b): + return (a & b).bit_count() % 2 + + +def profile(values): + return {str(k): v for k, v in sorted(values.items()) if v} + + +def difference(left, right): + return Counter({k: left[k] - right[k] for k in set(left) | set(right) + if left[k] != right[k]}) + + +def load_sources(data): + for name, digest in data["source_sha256"].items(): + require(hashlib.sha256((ROOT / name).read_bytes()).hexdigest() == digest, + "source hash mismatch: " + name) + word = json.loads(gzip.decompress((ROOT / "research/complex-block-rank-optimum/inputs/selected.json.gz").read_bytes())) + prototype = json.loads((ROOT / "research/frame-sa504/inputs/hamming/PROTOTYPE.json").read_text()) + fixture = json.loads((ROOT / "research/p104-native-channel/inputs/P104-FIXTURE.json").read_text())["section4_explicit_P104"] + tau = lambda x: x ^ (43 if pairing(x, 43) else 0) + root_index = {tuple(r): i for i, r in enumerate(prototype["root_lines"])} + def convert(c): + values = [sum(x * y for x, y in zip(c, r)) for r in fixture["F0"]] + require(all(v % 4 == 0 for v in values), "nonintegral root conversion") + return tuple(v // 4 for v in values) + def canonical(r): + return tuple(-x for x in r) if next(x for x in r if x) < 0 else r + removed_labels = {tau(prototype["binary_ports"][root_index[canonical(convert(c))]]) + for c in fixture["C"]} + live = [i for i, label in enumerate(word["ports"]) if label not in removed_labels] + require(len(live) == 104, "P104 puncture cardinality") + root_by_label = {tau(q): r for q, r in zip(prototype["binary_ports"], prototype["root_lines"])} + roots = [root_by_label[q] for q in word["ports"]] + labels = [tau(q) for q in prototype["binary_ports"]] + return word, prototype, live, roots, labels + + +def replay(word, prototype, live, roots, labels, chain=None): + v = word["v"] + n = 2 * v + word["R"] + require((v, n, word["h"]) == (112, 704, 9), "selected word dimensions") + frames = [span(f) for f in word["frames"]] + live_outputs = {v + t for t in live} + removed = [t for t in range(v) if t not in live] + current = [frames[i] for i in word["start"]] + terminal = [frames[i] for i in word["final"]] + # The sixteen punctured port roles are retained as dirty helpers in both + # the comparison baseline and the candidate, so this common cost cancels. + for t in removed: + current[t] = frozenset({0}) + terminal[v + t] = FULL + baseline_terminal = list(terminal) + coefficients = [Fraction(0)] * n + paid = Counter() + copy_paid = Counter() + by_cut = defaultdict(list) + query_frame = None + copy_frame = None + copy_label = None + if chain is not None: + ai, bi = chain["pair_hamming_root_indices"] + require(0 <= ai < 120 and 0 <= bi < 120, "invalid root index") + copy_label, query_label = labels[ai], labels[bi] + query_frame = frozenset(x for x in range(512) if not pairing(x, query_label)) + require(copy_label in query_frame, "private endpoint outside query frame") + copy_frame = query_frame + for contact in chain["contacts"]: + k, r = contact["before_B_event"], contact["register"] + require(type(k) is int and 0 <= k < len(word["B"]), "invalid contact cut") + require(type(r) is int and 0 <= r < n, "invalid contact role") + by_cut[k].append(contact) + for key, basis in chain["final_frame_overrides"].items(): + r = int(key) + require(0 <= r < n and r not in live_outputs, "illegal terminal override") + changed = span(basis) + require(terminal[r] <= changed, "terminal override shrinks") + terminal[r] = changed + + def climb(r, target, where): + require(current[r] <= target, "nonmonotone public transport: " + str((where, r))) + require(target <= terminal[r], "terminal frame exceeded: " + str((where, r))) + rank = dimension(target) - dimension(current[r]) + if rank: + paid[rank] += 1 + current[r] = target + + def event(e, where, promote=False): + require(e[0] in {"add", "scale"}, "unknown scalar event") + registers = e[1:3] if e[0] == "add" else e[1:2] + require(all(type(r) is int and 0 <= r < n for r in registers), "invalid scalar role") + if e[0] == "add": + require(e[1] != e[2], "self addition") + target = frames[e[-1]] + if promote: + for r in registers: + target = join(target, current[r]) + for r in registers: + climb(r, target, where) + if e[0] == "add": + coefficients[e[1]] += Fraction(e[3], e[4]) * coefficients[e[2]] + else: + coefficients[e[1]] *= Fraction(e[2], e[3]) + + for k, e in enumerate(word["A"]): + event(e, ("A", k)) + a_profile = paid.copy() + paid.clear() + for k, e in enumerate(word["B"]): + for contact in by_cut[k]: + target = span(contact["frame"]) + require(copy_label in target and target <= copy_frame, + "private copy does not descend to prescribed endpoint") + rank = dimension(copy_frame) - dimension(target) + if rank: + copy_paid[rank] += 1 + copy_frame = target + r = contact["register"] + climb(r, target, ("query contact", k)) + coefficients[r] += Fraction(contact["coefficient"]) + event(e, ("B", k), chain is not None) + if chain is not None: + endpoint = frozenset({0, copy_label}) + require(endpoint <= copy_frame, "invalid private erasure frame") + rank = dimension(copy_frame) - 1 + if rank: + copy_paid[rank] += 1 + copy_frame = endpoint + require(sum(k * m for k, m in copy_paid.items()) == 7, "private descent rank mass") + for k, e in enumerate(word["tail"]): + event(e, ("early cleanup", k), chain is not None) + for r in range(n): + climb(r, terminal[r], ("endpoint", r)) + for k, e in enumerate(word["cleanup"]): + event(e, ("original full cleanup", k), chain is not None) + if chain is not None: + # The caller must also pay for the supplied query register's remaining + # H_b -> FULL rank-one boundary. This is reported separately below. + require(dimension(query_frame) == 8, "query entry rank") + query_frame = FULL + for c in chain["query_cleanup"]: + r = c["register"] + require(0 <= r < n and r not in live_outputs, "cleanup writes live output") + require(current[r] == query_frame, "query cleanup is not in common FULL frame") + coefficients[r] += Fraction(c["coefficient"]) + a = prototype["root_lines"][chain["pair_hamming_root_indices"][0]] + wanted = {v + t: sum(x * y for x, y in zip(roots[t], a)) for t in live} + require(all(coefficients[r] == wanted.get(r, 0) for r in range(n)), + "query perturbation endpoint mismatch") + else: + require(not any(coefficients), "baseline query perturbation") + residual = Counter(9 - dimension(terminal[r]) for r in range(2 * v, n) + if dimension(terminal[r]) < 9) + changes = [{"register": r, "before_rank": dimension(baseline_terminal[r]), + "after_rank": dimension(terminal[r])} + for r in range(n) if terminal[r] != baseline_terminal[r]] + return {"local_profile": paid, "A_profile": a_profile, "residual_width_profile": residual, + "private_descent_profile": copy_paid, "terminal_changes": changes, + "contact_count": len(chain["contacts"]) if chain else 0, + "query_cleanup_count": len(chain["query_cleanup"]) if chain else 0, + "removed_selected_positions": removed} + + +def verify_combined(sources, chains, baseline): + """Replay both supplied queries together, including mutual frame effects.""" + word, prototype, live, roots, labels = sources + v, n = word["v"], 2 * word["v"] + word["R"] + frames = [span(f) for f in word["frames"]] + current = [frames[i] for i in word["start"]] + terminal = [frames[i] for i in word["final"]] + for t in range(v): + if t not in live: + current[t] = frozenset({0}) + terminal[t + v] = FULL + original_terminal = list(terminal) + for chain in chains: + for key, basis in chain["final_frame_overrides"].items(): + terminal[int(key)] = join(terminal[int(key)], span(basis)) + count = len(chains) + rows = [[Fraction(0)] * count for _ in range(n)] + paid = Counter() + copies = [] + by_cut = defaultdict(list) + for j, chain in enumerate(chains): + ai, bi = chain["pair_hamming_root_indices"] + copies.append(frozenset(x for x in range(512) if not pairing(x, labels[bi]))) + for contact in chain["contacts"]: + by_cut[contact["before_B_event"]].append((j, contact)) + def climb(r, target): + require(current[r] <= target <= terminal[r], "combined frame contract") + rank = dimension(target) - dimension(current[r]) + if rank: + paid[rank] += 1 + current[r] = target + def event(e): + registers = e[1:3] if e[0] == "add" else e[1:2] + target = frames[e[-1]] + for r in registers: + target = join(target, current[r]) + for r in registers: + climb(r, target) + if e[0] == "add": + rows[e[1]] = [x + Fraction(e[3], e[4]) * y for x, y in zip(rows[e[1]], rows[e[2]])] + else: + rows[e[1]] = [Fraction(e[2], e[3]) * x for x in rows[e[1]]] + for e in word["A"]: + event(e) + paid.clear() + for k, e in enumerate(word["B"]): + for j, contact in by_cut[k]: + target = span(contact["frame"]) + require(target <= copies[j], "combined private copy ascends") + copies[j] = target + r = contact["register"] + climb(r, target) + rows[r][j] += Fraction(contact["coefficient"]) + event(e) + for e in word["tail"]: + event(e) + for r, target in enumerate(terminal): + climb(r, target) + for e in word["cleanup"]: + event(e) + for j, chain in enumerate(chains): + for cleanup in chain["query_cleanup"]: + r = cleanup["register"] + require(current[r] == FULL, "combined cleanup outside FULL") + rows[r][j] += Fraction(cleanup["coefficient"]) + a = prototype["root_lines"][chain["pair_hamming_root_indices"][0]] + desired = {v + t: sum(x * y for x, y in zip(roots[t], a)) for t in live} + require(all(rows[r][j] == desired.get(r, 0) for r in range(n)), "combined scalar endpoint") + residual = Counter(9 - dimension(terminal[r]) for r in range(2 * v, n) + if dimension(terminal[r]) < 9) + local_delta = difference(paid, baseline["local_profile"]) + residual_delta = difference(residual, baseline["residual_width_profile"]) + mass_delta = sum(k * m for k, m in local_delta.items()) + sum(k * m for k, m in residual_delta.items()) + require(mass_delta == 0, "combined public plus residual rank mass") + return {"query_count": count, "all_query_coefficients_exact": True, + "all_other_query_perturbations_zero": True, + "local_B_tail_endpoint_cleanup_profile_delta": profile(local_delta), + "residual_width_profile_delta": profile(residual_delta), + "public_plus_residual_rank_mass_delta": mass_delta, + "private_descent_mass": 7 * count, + "private_copy_lifetimes": [{"copy": j, "initialized_before_B_event": 0, + "discarded_after_B_contact": max(c["before_B_event"] for c in chain["contacts"])} + for j, chain in enumerate(chains)], + "peak_simultaneous_private_copies": count, + "external_query_registers_required": count, + "global_owner_hosting_verified": False, + "supplied_query_remaining_boundary_profile": {"1": count}, + "changed_terminal_roles": [r for r in range(n) if terminal[r] != original_terminal[r]]} + + +def verify(data=None, controls=True): + if data is None: + data = json.loads((HERE / "CHAINS.json").read_text()) + require(data["schema"] == "p104-interleaved-delivery-v1", "unknown schema") + sources = load_sources(data) + baseline = replay(*sources) + baseline_recount = baseline["A_profile"] + baseline["local_profile"] + Counter({8: 8}) + inherited = Counter({int(k): v for k, v in sources[0]["local_profile"].items()}) + require(baseline_recount == inherited + Counter({1: 16}), + "retained sixteen-helper baseline differs from selected invoice") + reports = [] + for chain in data["chains"]: + out = replay(*sources, chain) + local_delta = difference(out["local_profile"], baseline["local_profile"]) + residual_delta = difference(out["residual_width_profile"], baseline["residual_width_profile"]) + mass_delta = sum(k * m for k, m in local_delta.items()) + sum(k * m for k, m in residual_delta.items()) + require(mass_delta == 0, "public plus residual rank mass changed") + reports.append({"pair_hamming_root_indices": chain["pair_hamming_root_indices"], + "contact_count": out["contact_count"], + "query_cleanup_count": out["query_cleanup_count"], + "private_descent_profile": profile(out["private_descent_profile"]), + "private_descent_mass": 7, + "supplied_query_remaining_boundary_profile": {"1": 1}, + "local_B_tail_endpoint_cleanup_profile_delta": profile(local_delta), + "residual_width_profile_delta": profile(residual_delta), + "public_plus_residual_rank_mass_delta": mass_delta, + "terminal_changes": out["terminal_changes"], + "all_live_output_query_coefficients_exact": True, + "all_other_query_perturbations_zero": True}) + control_results = {} + if controls: + for name in ("corrupt_contact_coefficient", "drop_query_cleanup", "drop_terminal_frame_overrides"): + altered = deepcopy(data["chains"][0]) + if name == "corrupt_contact_coefficient": + altered["contacts"][0]["coefficient"] = str(Fraction(altered["contacts"][0]["coefficient"]) + 1) + elif name == "drop_query_cleanup": + altered["query_cleanup"].pop() + else: + altered["final_frame_overrides"] = {} + try: + replay(*sources, altered) + except VerificationError as error: + expected = "terminal frame exceeded" if name == "drop_terminal_frame_overrides" else "query perturbation endpoint mismatch" + require(expected in str(error), "control failed for unrelated reason") + control_results[name] = "rejected: " + str(error) + else: + raise VerificationError("negative control was accepted: " + name) + return {"schema": "p104-single-query-delivery-report-v1", "source_sha256": data["source_sha256"], + "scope": "One exact two-query delivery perturbation channel on a modified selected B schedule, with separate and joint invoices; no eight-query program or improved kappa.", + "query_input_contract": "One independent exact scalar q already available in H_b; forming q, its dirty-input compensation, and its initial boundary are not included. Its remaining H_b-to-FULL boundary is one rank-one child per query.", + "removed_selected_positions": baseline["removed_selected_positions"], + "retained_role_baseline_profile_delta_from_selected": {"1": 16}, + "chains": reports, "combined_two_query_channel": verify_combined(sources, data["chains"], baseline), "negative_controls": control_results} + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/scalar_surgery.py b/research/p104-interleaved-search/scalar_surgery.py new file mode 100644 index 0000000000..e9309ffedf --- /dev/null +++ b/research/p104-interleaved-search/scalar_surgery.py @@ -0,0 +1,355 @@ +#!/usr/bin/env python3 +"""Exact conditional P104 scalar surgery; no native schedule or gain claim. + +Run from any directory with Python 3.12+ and the standard library: + python3 -I -B research/p104-interleaved-search/scalar_surgery.py + +The old 112-port scalar word is retained except for its centre cut. Eight X +ports and eight Y ports become arbitrary dirty helpers. The hypothetical new +cut supplies eight *pure initial-live-X* queries and adds their specified +linear combinations into live Y registers. This is an oracle contract, not a +claim that those queries occupy available registers or have legal frames. + +The verifier constructs initial-zero-frame compensation and final-full-frame +restoration, then replays every generated scalar operation on all 704 initial +columns. It also reports the native survivor-mask violations of the proposed +cut. Query construction, query storage/restoration, legal interleaving, native +transports, and a complete hosted cost remain unproved. + +Sources: retained PR1042 local word used by the selected PR1094 assembly, via +complex-block-rank-optimum; icekylinx's frame-sa504 Hamming coordinates; Josie +Elliston's PR1071 P104 fixture, retained through PR1940/1972 and the native +channel package. Their notices and attribution remain in those packages. +New verifier prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" + +from __future__ import annotations + +import gzip +import hashlib +import json +from fractions import Fraction +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +INPUTS = { + "word": ( + "research/complex-block-rank-optimum/inputs/selected.json.gz", + "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + ), + "coordinates": ( + "research/frame-sa504/inputs/hamming/PROTOTYPE.json", + "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + ), + "fixture": ( + "research/p104-native-channel/inputs/P104-FIXTURE.json", + "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4", + ), +} +REMOVED = (3, 14, 21, 34, 39, 61, 76, 93) +DECODER_ROOT_PAIRS = ((1, 28), (2, 47), (3, 113), (4, 57), + (12, 7), (65, 0), (82, 6), (97, 5)) +Q = Fraction +Row = dict[int, Fraction] +Rows = list[Row] + + +def require(condition: bool, message: str) -> None: + """Keep all checks active under python -O as well.""" + if not condition: + raise ValueError(message) + + +def load_inputs() -> dict: + result = {} + for name, (relative, expected) in INPUTS.items(): + data = (ROOT / relative).read_bytes() + require(hashlib.sha256(data).hexdigest() == expected, f"input hash: {relative}") + result[name] = json.loads(gzip.decompress(data) if relative.endswith(".gz") else data) + return result + + +def identity(n: int) -> Rows: + return [{i: Q(1)} for i in range(n)] + + +def add_row(target: Row, source: Row, coefficient: Fraction) -> None: + for column, value in list(source.items()): + updated = target.get(column, Q(0)) + coefficient * value + if updated: + target[column] = updated + else: + target.pop(column, None) + + +def apply(event: list, rows: Rows) -> None: + kind, target = event[:2] + if kind == "scale": + coefficient = Q(event[2], event[3]) + require(bool(coefficient), "zero scaling is not invertible") + rows[target] = {j: coefficient * value for j, value in rows[target].items()} + elif kind == "add": + source = event[2] + require(target != source, "self-add is outside the retained operation contract") + add_row(rows[target], rows[source], Q(event[3], event[4])) + else: + raise ValueError(f"unknown scalar operation: {kind}") + + +def run(rows: Rows, *parts: list) -> Rows: + for part in parts: + for event in part: + apply(event, rows) + return rows + + +def endpoint_failures(rows: Rows, v: int, live: list[int]) -> list[int]: + """All non-live-Y registers must be restored, including the sixteen roles.""" + live_set = set(live) + bad = [] + for register, row in enumerate(rows): + wanted = {register: Q(1)} + if v <= register < 2 * v and register - v in live_set: + wanted[register - v] = Q(1) + if row != wanted: + bad.append(register) + return bad + + +def solve(left: list[list[Fraction]], right: list[list[Fraction]]) -> list[list[Fraction]]: + """Exact square solve, rejecting a singular live-target transfer matrix.""" + n = len(left) + augmented = [a.copy() + b.copy() for a, b in zip(left, right)] + for column in range(n): + pivot = next((r for r in range(column, n) if augmented[r][column]), None) + require(pivot is not None, f"singular target transfer at column {column}") + augmented[column], augmented[pivot] = augmented[pivot], augmented[column] + coefficient = augmented[column][column] + augmented[column] = [x / coefficient for x in augmented[column]] + for row in range(n): + if row == column: + continue + coefficient = augmented[row][column] + if coefficient: + augmented[row] = [x - coefficient * y for x, y in zip(augmented[row], augmented[column])] + require( + all(augmented[i][:n] == [Q(i == j) for j in range(n)] for i in range(n)), + "target solve did not reduce to the identity", + ) + answer = [row[n:] for row in augmented] + require( + all(sum(left[i][j] * answer[j][k] for j in range(n)) == right[i][k] + for i in range(n) for k in range(len(right[0]))), + "target solve residual", + ) + return answer + + +def dot(a: list | tuple, b: list | tuple) -> int: + return sum(x * y for x, y in zip(a, b)) + + +def coordinate_data(word: dict, prototype: dict, fixture: dict) -> tuple: + native = fixture["section4_explicit_P104"] + + def transform(label: int) -> int: + return label ^ (43 if (label & 43).bit_count() % 2 else 0) + + def coordinates(vector: list) -> tuple[int, ...]: + products = [dot(vector, basis_vector) for basis_vector in native["F0"]] + require(all(value % 4 == 0 for value in products), "nonintegral fixture coordinates") + return tuple(value // 4 for value in products) + + def canonical(vector: tuple) -> tuple: + first = next(x for x in vector if x) + return tuple(-x for x in vector) if first < 0 else vector + + roots = prototype["root_lines"] + labels = prototype["binary_ports"] + index = {tuple(root): i for i, root in enumerate(roots)} + root_by_label = {transform(label): root for label, root in zip(labels, roots)} + selected_roots = [root_by_label[label] for label in word["ports"]] + removed_labels = {transform(labels[index[canonical(coordinates(c))]]) for c in native["C"]} + derived_removed = tuple(i for i, label in enumerate(word["ports"]) if label in removed_labels) + require(derived_removed == REMOVED, "fixture/selected puncture mismatch") + terms = [] + # This orientation is shared with the retained two-query delivery fragment. + # The pinned native fixture supplies the puncture, not its old orientation. + for ai, bi in DECODER_ROOT_PAIRS: + a, b = tuple(roots[ai]), tuple(roots[bi]) + ab_dot = dot(a, b) + require(ab_dot != 0, "zero decoder denominator") + terms.append((a, b, transform(labels[ai]), ab_dot)) + require(len(terms) == 8, "expected eight decoder terms") + return selected_roots, terms + + +def verify() -> dict: + inputs = load_inputs() + word = inputs["word"] + v, n = word["v"], 2 * word["v"] + word["R"] + require((v, n, word["R"]) == (112, 704, 480), "unexpected retained word dimensions") + live = [i for i in range(v) if i not in REMOVED] + prefix = [word[key] for key in ("precondition", "compensation", "A")] + suffix = [word[key] for key in ("B", "tail", "cleanup")] + baseline = run(identity(n), *prefix, word["cut"], *suffix) + require(not endpoint_failures(baseline, v, list(range(v))), "original full-column baseline failed") + + # Mutate one actual centre coefficient. The original full-column identity + # must detect it, independently of any surgery-derived compensation. + corrupted_cut = [event.copy() for event in word["cut"]] + require(corrupted_cut[0][0] == "add", "control expects a centre addition") + corrupted_cut[0][3] += corrupted_cut[0][4] + corrupt_bad = endpoint_failures(run(identity(n), *prefix, corrupted_cut, *suffix), v, list(range(v))) + require(bool(corrupt_bad), "corrupted baseline gate was accepted") + + # This invariant permits scalar restoration using restored X/helper values: + # no scalar gate sends Y data back into those registers. Their frame access + # is checked separately below, not inferred from scalar independence. + require( + all(not (event[0] == "add" and v <= event[2] < 2 * v and not v <= event[1] < 2 * v) + for part in prefix + suffix + [word["cut"]] for event in part), + "Y data flows into a source/helper register", + ) + frames = word["frames"] + require(frames[0] == [], "frame index zero is not the zero frame") + require(all(word["start"][v + t] == 0 for t in range(v)), "targets do not all start at zero") + require(all(len(frames[word["start"][t]]) == 1 for t in REMOVED), "removed X is not a line") + require(all(len(frames[word["final"][v + t]]) == 8 for t in REMOVED), "removed Y is not rank eight") + + target_inputs = [{i - v: Q(1)} if v <= i < 2 * v else {} for i in range(n)] + target_transfer = run(target_inputs, word["B"]) + matrix = [target_transfer[v + i] for i in range(v)] + roots, terms = coordinate_data(word, inputs["coordinates"], inputs["fixture"]) + decoder = [[Q(dot(roots[t], a), 4 * denominator) for a, b, label, denominator in terms] for t in live] + scatter = solve([[matrix[i].get(j, Q(0)) for j in live] for i in live], decoder) + queries = [{s: Q(dot(roots[s], b)) for s in live if dot(roots[s], b)} for a, b, label, denominator in terms] + require( + all(sum(decoder[i][k] * queries[k].get(s, Q(0)) for k in range(8)) == Q(dot(roots[t], roots[s]), 4) + for i, t in enumerate(live) for s in live), + "decoder does not give the required live G/2 endpoint", + ) + + def hypothetical_cut(rows: Rows, query_rows: Rows) -> None: + # Query dictionaries index *initial* source columns, not rows currently + # stored in registers. No physical realization is hidden in this step. + for i, target in enumerate(live): + for k, query in enumerate(query_rows): + if scatter[i][k]: + add_row(rows[v + target], query, scatter[i][k]) + + def surgery(initial_compensation: list, query_rows: Rows | None = None) -> Rows: + rows = run(identity(n), initial_compensation, *prefix) + hypothetical_cut(rows, queries if query_rows is None else query_rows) + return run(rows, *suffix) + + uncorrected = surgery([]) + new_compensation = [] + for target in live: + row = uncorrected[v + target] + require(all(row.get(s, Q(0)) == Q(s == target) for s in live), "wrong live source endpoint") + require(row.get(v + target) == 1, "wrong initial target coefficient") + for source, coefficient in sorted(row.items()): + if source in (target, v + target): + continue + require(source in REMOVED or (source >= 2 * v and word["start"][source] == 0), + f"nuisance column {source} cannot be compensated at frame zero") + q = -coefficient + new_compensation.append(["add", v + target, source, q.numerator, q.denominator, 0]) + + # Replay the new gates before the old precondition, rather than assuming + # that deleting their predicted endpoint coefficients proves correctness. + compensated = surgery(new_compensation) + require(all(compensated[v + t] == {v + t: Q(1), t: Q(1)} for t in live), + "actual initial compensation replay failed") + require(all(compensated[r] == {r: Q(1)} for r in list(range(v)) + list(range(2 * v, n))), + "source/helper restoration failed before final Y repair") + full_frame = word["final"][0] + restores = [] + for target in REMOVED: + require(compensated[v + target].get(v + target) == 1, "removed Y lost its initial value") + for source, coefficient in sorted(compensated[v + target].items()): + if source == v + target: + continue + require(source < v or source >= 2 * v, "restoration needs a non-full live Y input") + q = -coefficient + restores.append(["add", v + target, source, q.numerator, q.denominator, full_frame]) + omitted_bad = endpoint_failures(compensated, v, live) + require(bool(restores) and bool(omitted_bad), "omitted-restoration control was accepted") + require(all(v + t in omitted_bad for t in REMOVED), "not every removed Y needs restoration") + completed = run([row.copy() for row in compensated], restores) + require(not endpoint_failures(completed, v, live), "conditional all-column endpoint failed") + nonfull_restore_sources = sorted({event[2] for event in restores + if len(frames[word["final"][event[2]]]) != 9}) + require(not nonfull_restore_sources, "final restoration needs a source outside the retained full endpoint") + + # Keep all derived repair coefficients fixed in both controls. A new solve + # would conceal precisely the dirty-input and query errors being tested. + without_compensation = run([row.copy() for row in uncorrected], restores) + dirty_columns = set(REMOVED) | {r for r in range(2 * v, n) if word["start"][r] == 0} + uncompensated_live_dirty_entries = sum( + bool(without_compensation[v + t].get(source)) for t in live for source in dirty_columns + ) + require(uncompensated_live_dirty_entries > 0, "omitted compensation did not expose live-Y dirty columns") + uncompensated_bad = endpoint_failures(without_compensation, v, live) + require(bool(uncompensated_bad), "omitted-compensation control was accepted") + + corrupted_queries = [row.copy() for row in queries] + corrupt_query_source = min(corrupted_queries[0]) + corrupted_queries[0][corrupt_query_source] += 1 + corrupted_query_endpoint = run(surgery(new_compensation, corrupted_queries), restores) + query_bad = endpoint_failures(corrupted_query_endpoint, v, live) + require(bool(query_bad), "corrupted hypothetical query was accepted with fixed repairs") + require(any(corrupted_query_endpoint[v + t].get(corrupt_query_source, Q(0)) != Q(t == corrupt_query_source) + for t in live), "query corruption was not detected on a live source column") + + illegal_reads = [sum(bool(scatter[i][k]) and bool((word["ports"][t] & label).bit_count() % 2) + for i, t in enumerate(live)) for k, (a, b, label, denominator) in enumerate(terms)] + require(illegal_reads == [0, 0, 0, 0, 26, 0, 26, 28], f"survivor-mask diagnostic changed: {illegal_reads}") + return { + "status": "PASS_CONDITIONAL_SCALAR_SURGERY", + "scope": "Exact rational scalar identity under hypothetical pure-source query-cut access; no legal native schedule or kappa gain claimed.", + "sources": [{"path": relative, "sha256": digest} for relative, digest in INPUTS.values()], + "input_columns": n, + "original_ports": v, + "live_ports": len(live), + "retained_old_helpers": word["R"], + "converted_dirty_roles": 2 * len(REMOVED), + "removed_selected_positions": list(REMOVED), + "baseline_all_columns_pass": True, + "live_target_transfer_rank": len(live), + "hypothetical_query_count": len(queries), + "decoder_hamming_root_pairs": [list(pair) for pair in DECODER_ROOT_PAIRS], + "query_scale_for_delivery_output_dot_a": [str(Q(1, 4 * denominator)) for a, b, label, denominator in terms], + "hypothetical_query_definition": "q_k = sum over live s of dot(root_s,b_k)*initial_X_s; endpoint coefficient is dot(root_t,a_k)/(4*dot(a_k,b_k)). A delivery source may absorb the constant 1/(4*dot(a_k,b_k)); no assembled schedule is asserted.", + "hypothetical_scatter_additions": sum(bool(q) for row in scatter for q in row), + "new_zero_frame_compensation_additions": len(new_compensation), + "new_full_frame_restoration_additions": len(restores), + "restoration_sources_without_retained_full_endpoint": nonfull_restore_sources, + "repair_max_coefficient_denominator": max(event[4] for event in new_compensation + restores), + "endpoint_role_changes": {"removed_X_start_rank": [1, 0], "removed_Y_final_rank": [8, 9]}, + "hypothetical_cut_illegal_survivor_reads_by_term": illegal_reads, + "controls": { + "corrupted_original_cut_coefficient_rejected": True, + "corrupted_original_cut_bad_registers": corrupt_bad, + "omitted_final_restoration_rejected": True, + "omitted_final_restoration_bad_registers": omitted_bad, + "omitted_new_compensation_rejected": True, + "omitted_new_compensation_bad_registers": uncompensated_bad, + "omitted_new_compensation_live_dirty_entries": uncompensated_live_dirty_entries, + "corrupted_hypothetical_query_with_fixed_repairs_rejected": True, + "corrupted_hypothetical_query_bad_registers": query_bad, + "corrupted_hypothetical_query_term_and_source": [0, corrupt_query_source], + }, + "unproved_obligations": [ + "Form and store the eight pure-source queries with restored dirty helpers.", + "Replace the hypothetical cut by legal native common-frame operations.", + "Check actual added transport, storage lifetimes, backward supplier, and whole-call hosting.", + "Establish a complete paid recurrence and a kappa improvement.", + ], + } + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/verify.py b/research/p104-interleaved-search/verify.py new file mode 100644 index 0000000000..5c21e6050a --- /dev/null +++ b/research/p104-interleaved-search/verify.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Replay the bounded P104 checkpoint; never assert an improved exponent.""" + +import argparse +from collections import Counter +from fractions import Fraction +import hashlib +import importlib.util +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def load(name): + spec = importlib.util.spec_from_file_location("p104_checkpoint_" + name, HERE / (name + ".py")) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def construct(): + sources = json.loads((HERE / "SOURCES.json").read_text()) + for source in sources["files"]: + if source["usage"] == "input": + require(hashlib.sha256((ROOT / source["path"]).read_bytes()).hexdigest() == source["sha256"], + "source drift: " + source["path"]) + scalar = load("scalar_surgery").verify() + delivery = load("delivery").verify() + budget = load("budget").verify(include_copy_table=True) + + require(scalar["removed_selected_positions"] == delivery["removed_selected_positions"], + "scalar and delivery punctures differ") + by_pair = {tuple(row["pair_hamming_root_indices"]): row for row in delivery["chains"]} + require(len(by_pair) == 2, "expected two independently replayed delivery fragments") + query_scales = dict(zip(map(tuple, scalar["decoder_hamming_root_pairs"]), + scalar["query_scale_for_delivery_output_dot_a"])) + require(set(by_pair) <= set(query_scales), "delivery and scalar decoder orientations differ") + require(all(Fraction(query_scales[pair]) == Fraction(1, 8) for pair in by_pair), + "delivery source normalization changed") + for row in budget["chain_profile_inputs"]: + actual = by_pair[(row["a_root"], row["b_root"])] + require(row["injections"] == actual["contact_count"], "budget injection count drift") + require(row["descent"] == actual["private_descent_profile"], "budget descent profile drift") + require(row["local_tail_cleanup_delta"] == actual["local_B_tail_endpoint_cleanup_profile_delta"], + "budget local profile differs from actual delivery replay") + require(row["residual_width_delta"] == actual["residual_width_profile_delta"], + "budget residual profile differs from actual delivery replay") + joint = delivery["combined_two_query_channel"] + for source_key, joint_key in ( + ("local_tail_cleanup_delta", "local_B_tail_endpoint_cleanup_profile_delta"), + ("residual_width_delta", "residual_width_profile_delta"), + ): + total = Counter() + for row in budget["chain_profile_inputs"]: + total.update(row[source_key]) + total = {key: count for key, count in total.items() if count} + require(total == joint[joint_key], "priced sum differs from joint chronological replay") + require(joint["query_count"] == joint["peak_simultaneous_private_copies"] == 2, + "simultaneous private-copy contract changed") + require(not joint["global_owner_hosting_verified"], "this checkpoint must not assert global hosting") + centres = budget["selected_private_centre_stock"]["selected_private_centre_families"] + require(joint["peak_simultaneous_private_copies"] <= centres, "fragment exceeds selected private-centre stock") + + return { + "schema_version": 1, + "status": "VERIFIED_PARTIAL_CHECKPOINT_NOT_A_SUPPLIER", + "requested_verified_kappa_gain_achieved": False, + "base_commit": sources["base_commit"], + "selected_kappa_unchanged": budget["selected_kappa"], + "chain_input_sha256": hashlib.sha256((HERE / "CHAINS.json").read_bytes()).hexdigest(), + "scalar_surgery": scalar, + "delivery": delivery, + "budget": budget, + "cross_checks": { + "same_exact_104_port_puncture": True, + "delivery_pairs_belong_to_scalar_decoder": True, + "retained_delivery_sources_need_raw_query_divided_by_eight": True, + "priced_single_chain_deltas_equal_replayed_deltas": True, + "priced_sum_equals_joint_chronological_replay": True, + "private_copy_peak_fits_selected_eight_centre_stock": True, + "no_oracle_or_optimistic_ceiling_claimed_as_supplier": True, + }, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true", help="explicitly regenerate the checked receipt") + args = parser.parse_args() + result = construct() + path = HERE / "RESULT.json" + if args.write_result: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + else: + require(result == json.loads(path.read_text()), "recorded result differs from exact replay") + print("PASS_P104_INTERLEAVED_CHECKPOINT: exact partial constructions and conditional cost screens; no improved kappa") + + +if __name__ == "__main__": + main() From 05f7aad0f08992ee48ec2dd93e896d9a4567847d Mon Sep 17 00:00:00 2001 From: David Arias Date: Wed, 14 Oct 2026 16:09:06 -0500 Subject: [PATCH 2/2] Construct exact P104 forward word and certify native hosting costs --- .../COALESCED-FRAMES.json | 3899 ++++++++++++++ .../p104-interleaved-search/FANOUT-PLANS.json | 798 +++ .../p104-interleaved-search/NATIVE-CHAIN.json | 102 + research/p104-interleaved-search/README.md | 283 +- research/p104-interleaved-search/RESULT.json | 4769 ++++++++++++++++- research/p104-interleaved-search/SOURCES.json | 48 + research/p104-interleaved-search/TASK.json | 112 +- research/p104-interleaved-search/VERIFY.json | 11 +- .../p104-interleaved-search/actual_queries.py | 231 + research/p104-interleaved-search/coalesced.py | 195 + .../coalesced_budget.py | 216 + research/p104-interleaved-search/fanout.py | 349 ++ .../p104-interleaved-search/fanout_budget.py | 152 + research/p104-interleaved-search/hosting.py | 174 + .../p104-interleaved-search/native_checks.py | 152 + .../p104-interleaved-search/natural_budget.py | 238 + .../natural_delivery.py | 384 ++ .../query_construction.py | 382 ++ research/p104-interleaved-search/verify.py | 140 +- 19 files changed, 12304 insertions(+), 331 deletions(-) create mode 100644 research/p104-interleaved-search/COALESCED-FRAMES.json create mode 100644 research/p104-interleaved-search/FANOUT-PLANS.json create mode 100644 research/p104-interleaved-search/NATIVE-CHAIN.json create mode 100644 research/p104-interleaved-search/actual_queries.py create mode 100644 research/p104-interleaved-search/coalesced.py create mode 100644 research/p104-interleaved-search/coalesced_budget.py create mode 100644 research/p104-interleaved-search/fanout.py create mode 100644 research/p104-interleaved-search/fanout_budget.py create mode 100644 research/p104-interleaved-search/hosting.py create mode 100644 research/p104-interleaved-search/native_checks.py create mode 100644 research/p104-interleaved-search/natural_budget.py create mode 100644 research/p104-interleaved-search/natural_delivery.py create mode 100644 research/p104-interleaved-search/query_construction.py diff --git a/research/p104-interleaved-search/COALESCED-FRAMES.json b/research/p104-interleaved-search/COALESCED-FRAMES.json new file mode 100644 index 0000000000..38e2192420 --- /dev/null +++ b/research/p104-interleaved-search/COALESCED-FRAMES.json @@ -0,0 +1,3899 @@ +{ + "changes": [ + { + "event": 9525, + "frame": [] + }, + { + "event": 9527, + "frame": [] + }, + { + "event": 9586, + "frame": [ + 499 + ] + }, + { + "event": 9587, + "frame": [ + 499 + ] + }, + { + "event": 9590, + "frame": [ + 478 + ] + }, + { + "event": 9591, + "frame": [ + 478 + ] + }, + { + "event": 9642, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9643, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9644, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9645, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9646, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9648, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9650, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9651, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9653, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9655, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9657, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9658, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9659, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9660, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9662, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9663, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9664, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9665, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9666, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9667, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9668, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9669, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9670, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9671, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9672, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9673, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9674, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9675, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9676, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9677, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9678, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9679, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9680, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9681, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9682, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9683, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9684, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9685, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9686, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9687, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9688, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9689, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9690, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9691, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9692, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9693, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9694, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9695, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9696, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9697, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9698, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9699, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9700, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9701, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9702, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9703, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9704, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9705, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9706, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9707, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9708, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9709, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9710, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9711, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9712, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9713, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9714, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9715, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9716, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9717, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9718, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9719, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9720, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9721, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9722, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9723, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9724, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9725, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9726, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9727, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9728, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9729, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9730, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9731, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9732, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9733, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9734, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9735, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9736, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9737, + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ] + }, + { + "event": 9974, + "frame": [] + }, + { + "event": 9976, + "frame": [] + }, + { + "event": 9989, + "frame": [] + }, + { + "event": 9990, + "frame": [] + }, + { + "event": 9991, + "frame": [] + }, + { + "event": 9992, + "frame": [] + }, + { + "event": 10023, + "frame": [ + 35 + ] + }, + { + "event": 10024, + "frame": [ + 35 + ] + }, + { + "event": 10031, + "frame": [ + 14 + ] + }, + { + "event": 10032, + "frame": [ + 14 + ] + }, + { + "event": 10047, + "frame": [ + 69 + ] + }, + { + "event": 10048, + "frame": [ + 69 + ] + }, + { + "event": 10423, + "frame": [] + }, + { + "event": 10425, + "frame": [] + }, + { + "event": 10438, + "frame": [] + }, + { + "event": 10439, + "frame": [] + }, + { + "event": 10440, + "frame": [] + }, + { + "event": 10441, + "frame": [] + }, + { + "event": 10464, + "frame": [ + 196 + ] + }, + { + "event": 10465, + "frame": [ + 196 + ] + }, + { + "event": 10472, + "frame": [ + 247 + ] + }, + { + "event": 10473, + "frame": [ + 247 + ] + }, + { + "event": 10836, + "frame": [] + }, + { + "event": 10838, + "frame": [] + }, + { + "event": 10897, + "frame": [ + 351 + ] + }, + { + "event": 10898, + "frame": [ + 351 + ] + }, + { + "event": 10901, + "frame": [ + 321 + ] + }, + { + "event": 10902, + "frame": [ + 321 + ] + }, + { + "event": 11067, + "frame": [] + }, + { + "event": 11069, + "frame": [] + }, + { + "event": 11082, + "frame": [] + }, + { + "event": 11083, + "frame": [] + }, + { + "event": 11084, + "frame": [] + }, + { + "event": 11085, + "frame": [] + }, + { + "event": 11116, + "frame": [ + 446 + ] + }, + { + "event": 11117, + "frame": [ + 446 + ] + }, + { + "event": 11124, + "frame": [ + 416 + ] + }, + { + "event": 11125, + "frame": [ + 416 + ] + }, + { + "event": 11496, + "frame": [] + }, + { + "event": 11498, + "frame": [] + }, + { + "event": 11561, + "frame": [ + 37 + ] + }, + { + "event": 11562, + "frame": [ + 37 + ] + }, + { + "event": 11565, + "frame": [ + 22 + ] + }, + { + "event": 11566, + "frame": [ + 22 + ] + }, + { + "event": 11929, + "frame": [] + }, + { + "event": 11931, + "frame": [] + }, + { + "event": 11990, + "frame": [ + 194 + ] + }, + { + "event": 11991, + "frame": [ + 194 + ] + }, + { + "event": 11994, + "frame": [ + 239 + ] + }, + { + "event": 11995, + "frame": [ + 239 + ] + }, + { + "event": 12046, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12047, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12048, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12049, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12050, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12052, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12054, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12055, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12057, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12059, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12061, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12062, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12063, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12064, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12066, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12067, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12068, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12069, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12070, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12071, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12072, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12073, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12074, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12075, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12076, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12077, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12078, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12079, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12080, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12081, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12082, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12083, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12084, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12085, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12086, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12087, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12088, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12089, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12090, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12091, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12092, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12093, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12094, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12095, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12096, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12097, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12098, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12099, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12100, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12101, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12102, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12103, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12104, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12105, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12106, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12107, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12108, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12109, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12110, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12111, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12112, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12113, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12114, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12115, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12116, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12117, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12118, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12119, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12120, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12121, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12122, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12123, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12124, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12125, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12126, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12127, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12128, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12129, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12130, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12131, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12132, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12133, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12134, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12135, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12136, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12137, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12138, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12139, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12140, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12141, + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ] + }, + { + "event": 12366, + "frame": [] + }, + { + "event": 12368, + "frame": [] + }, + { + "event": 12423, + "frame": [ + 268 + ] + }, + { + "event": 12424, + "frame": [ + 268 + ] + }, + { + "event": 12427, + "frame": [ + 274 + ] + }, + { + "event": 12428, + "frame": [ + 274 + ] + }, + { + "event": 12431, + "frame": [ + 319 + ] + }, + { + "event": 12432, + "frame": [ + 319 + ] + }, + { + "event": 12594, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12596, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12598, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12600, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12602, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12604, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12607, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12609, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12611, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12613, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12615, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12617, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12620, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12622, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12624, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12626, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12628, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12630, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12633, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12635, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12637, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12639, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12641, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 12643, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 13763, + "frame": [ + 7, + 25, + 35, + 75, + 131, + 259 + ] + }, + { + "event": 14123, + "frame": [ + 2, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 14186, + "frame": [ + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + { + "event": 14200, + "frame": [ + 82, + 268 + ] + }, + { + "event": 14232, + "frame": [ + 69 + ] + }, + { + "event": 14238, + "frame": [ + 9, + 36, + 69, + 146, + 272 + ] + }, + { + "event": 14264, + "frame": [ + 268 + ] + }, + { + "event": 14270, + "frame": [ + 14, + 35, + 66, + 149, + 258 + ] + }, + { + "event": 14297, + "frame": [ + 7, + 66 + ] + }, + { + "event": 14377, + "frame": [ + 2, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 14442, + "frame": [ + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + { + "event": 14542, + "frame": [ + 12, + 21, + 38, + 71, + 132, + 260 + ] + }, + { + "event": 14899, + "frame": [ + 1, + 30, + 32, + 76, + 128, + 256 + ] + }, + { + "event": 14995, + "frame": [ + 7, + 10, + 32, + 65, + 144, + 272 + ] + }, + { + "event": 15103, + "frame": [ + 1, + 6, + 8, + 16, + 96, + 418 + ] + }, + { + "event": 15124, + "frame": [ + 19, + 32, + 70, + 136, + 264 + ] + }, + { + "event": 15175, + "frame": [ + 4, + 9, + 32, + 66, + 403 + ] + }, + { + "event": 15187, + "frame": [ + 9, + 22, + 36, + 66, + 385 + ] + }, + { + "event": 15190, + "frame": [ + 9, + 36, + 66, + 131, + 276 + ] + }, + { + "event": 15353, + "frame": [ + 19, + 32, + 70, + 136, + 264 + ] + }, + { + "event": 15387, + "frame": [ + 4, + 9, + 32, + 66, + 403 + ] + }, + { + "event": 15395, + "frame": [ + 9, + 22, + 36, + 66, + 385 + ] + }, + { + "event": 15397, + "frame": [ + 9, + 36, + 66, + 131, + 276 + ] + }, + { + "event": 15482, + "frame": [ + 1, + 10, + 20, + 32, + 70, + 128, + 256 + ] + }, + { + "event": 15620, + "frame": [ + 2, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 15621, + "frame": [ + 2, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 15622, + "frame": [ + 2, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 15749, + "frame": [ + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + { + "event": 15750, + "frame": [ + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + { + "event": 15751, + "frame": [ + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + { + "event": 15822, + "frame": [ + 3, + 4, + 8, + 17, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 15823, + "frame": [ + 3, + 4, + 8, + 17, + 33, + 65, + 129, + 257 + ] + }, + { + "event": 15826, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 15832, + "frame": [ + 1, + 6, + 10, + 18, + 32, + 66, + 130, + 258 + ] + }, + { + "event": 15833, + "frame": [ + 1, + 6, + 10, + 18, + 32, + 66, + 130, + 258 + ] + }, + { + "event": 15835, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16086, + "frame": [ + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 256 + ] + }, + { + "event": 16289, + "frame": [ + 1, + 6, + 10, + 18, + 34, + 64, + 130, + 258 + ] + }, + { + "event": 16290, + "frame": [ + 1, + 6, + 10, + 18, + 34, + 64, + 130, + 258 + ] + }, + { + "event": 16296, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16307, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 64, + 160, + 288 + ] + }, + { + "event": 16308, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 64, + 160, + 288 + ] + }, + { + "event": 16312, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16423, + "frame": [ + 1, + 6, + 8, + 18, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16424, + "frame": [ + 1, + 6, + 8, + 18, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16427, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16451, + "frame": [ + 2, + 5, + 8, + 16, + 33, + 64, + 128, + 256 + ] + }, + { + "event": 16452, + "frame": [ + 2, + 5, + 8, + 16, + 33, + 64, + 128, + 256 + ] + }, + { + "event": 16454, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16577, + "frame": [ + 1, + 4, + 8, + 16, + 32, + 66, + 130, + 256 + ] + }, + { + "event": 16578, + "frame": [ + 1, + 4, + 8, + 16, + 32, + 66, + 130, + 256 + ] + }, + { + "event": 16581, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16587, + "frame": [ + 3, + 5, + 9, + 16, + 33, + 65, + 129, + 256 + ] + }, + { + "event": 16588, + "frame": [ + 3, + 5, + 9, + 16, + 33, + 65, + 129, + 256 + ] + }, + { + "event": 16590, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16772, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16774, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16776, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16778, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16808, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16911, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16931, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16937, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16940, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16943, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16959, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16960, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16962, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16964, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16965, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + }, + { + "event": 16966, + "frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + } + ], + "expected_public_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 6 + }, + "schema": "p104-coalesced-common-frames-v1", + "source_scalar_operations_sha256": "f1e9679ac6aa62639ae320a6392fdc4c4b05bc79814a378ba1e8c2a00535ec1c" +} diff --git a/research/p104-interleaved-search/FANOUT-PLANS.json b/research/p104-interleaved-search/FANOUT-PLANS.json new file mode 100644 index 0000000000..f067d9e3ad --- /dev/null +++ b/research/p104-interleaved-search/FANOUT-PLANS.json @@ -0,0 +1,798 @@ +{ + "plans": [ + { + "contacts": [ + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "129", + "register": 112, + "upper": "39582418600065" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "4465697122072208735540128334463234746957695352110052823111347045966422813410419345622921233023950988787239148771744972491259284800738951297", + "register": 560, + "upper": "13502736257576051013138175312219105614748416327368081243030416903752135644961632651971208193448492004490944533966398381548200914206405041125437007200385" + }, + { + "coefficient": "2", + "event": 507, + "helper": 1, + "lower": "113336795588871485128833", + "register": 470, + "upper": "13502736257571585316016103103483565486392308924178279900099393240050654137253841798670889021790937615993024078649186699895250784246295313837155015458945" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "4465697122072208735535045475663899859068772520062882162369475783765847786168716840916117815585363346805324932748899397223636592406208446593", + "register": 561, + "upper": "4465697122072208735540128334463234746887156516235800688550331070131737828788882170765265513693886486974197373095779664678096236288443154561" + }, + { + "coefficient": "-2", + "event": 789, + "helper": 2, + "lower": "18412823266905522739297359178803183057573624302223679431518605460580601515958801189680376708186245710589235463304743153297756408802181133342530653388965", + "register": 169, + "upper": "18412823266905522739297359178803183057573624302223679431518605460580601515958801189680376708186245710589235463304743153297756408802181133342530653388965" + }, + { + "coefficient": "2", + "event": 851, + "helper": 0, + "lower": "5229058725941446281173900722305", + "register": 469, + "upper": "13502736257571585213804407499746956737166859647993255829806965425185083957444252372048644187838098191487580086133409543491388022232950201810638503673985" + }, + { + "coefficient": "-2", + "event": 1294, + "helper": 2, + "lower": "18413104224291798011276225824391070767328082596296227342817085999489195207629986252213142271919252734356270174109549113451154828815970167817596263792805", + "register": 121, + "upper": "18413104224291798011276225824391070767328082596296227342817085999489195207629986252213142271919252734356270174109549113451154828815970167817596263792805" + }, + { + "coefficient": "-2", + "event": 507, + "helper": 0, + "lower": "129", + "register": 174, + "upper": "39582418600065" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "5229058725941446281173900722305", + "register": 468, + "upper": "292663926694335967296094459276608001648181713518321861739700067191963159774130426777225280129947988802856776199619329556055370438117754002210945" + }, + { + "coefficient": "-4", + "event": 1065, + "helper": 0, + "lower": "439000355653451169776188734432497295493234688165018691532022283971314906187264738031375657837362514797716236033526245236931920713985544404729985", + "register": 548, + "upper": "731670980893471285136521791582891134896524058498509436258869171308169403662917148366852739253642521635995509615583068701324259269612494590771395" + }, + { + "coefficient": "-4", + "event": 940, + "helper": 0, + "lower": "4465697122072208735535045475663899859068772520062882162369475783765847786168716840916117815585363346805324932748899397223636592406208446593", + "register": 549, + "upper": "4465697123631835438478003834176757837649257103245878017268372607299242550264441326556782228545348950238903450657740679330872382733907132545" + }, + { + "coefficient": "2", + "event": 507, + "helper": 1, + "lower": "113336795588871485128833", + "register": 471, + "upper": "292663926592124271692357850527382552371996689448029433924834497012153570347508181943272440705442544810340999043205008676816816024706632659239041" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "129", + "register": 182, + "upper": "39582418600065" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "129", + "register": 184, + "upper": "39582418600065" + }, + { + "coefficient": "-2", + "event": 507, + "helper": 2, + "lower": "16423602559200962585751886745835859978937776688614328740201845433225119702366226648689279105", + "register": 206, + "upper": "1559626702948041217312192866398868579372337983638953072485036693461725675468798152387194300330788766101588137197746775873191673985" + } + ], + "helpers": 3, + "pair": [ + 1, + 28 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "33554433", + "register": 139, + "upper": "780437230614354767683081297761738986101729932932336955691500955937088429826770283545010711518327484151693124557954421325932769412251079822802945" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "192024976249104975628006955453547693939957218362703932981887458701931454805254824159393066070170623912628972108202674080616373473466996752385", + "register": 568, + "upper": "192024976249104975628006955492326829066718752621615036596072991697958725052829001865296492332417820628095307095835187567418997042983232077825" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "192024976249104975628006955453547693939957218362703932981887458701931454805254824159393066070170623912628972108202674080616373473466996752385", + "register": 569, + "upper": "192024976249104975628006955453547693939957218362703932981895106537841401066172658534267784324238583965388689487558178602738742787744081117185" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "33554433", + "register": 119, + "upper": "3298963972020330478372667741334064770593334562027776233151129581909384841689086074843295639922200283378627986347306634063976766362650122686557690265601" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "2256197893750785", + "register": 449, + "upper": "52374255970027395528444602888064052977252431927825279180037667540833947451920201972468816541986065707468299889607452351068924569710734023159491910959105" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "33554433", + "register": 125, + "upper": "784637740307361292773920369159915625473322745052958556161" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "170141188531071632644604909702730481665", + "register": 491, + "upper": "77107350077630492538067426953802720026293767707070544725380998142908040953279134848325411033205922183136573128705" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "33554433", + "register": 128, + "upper": "842498358456864435130067276812521151381826427613814667890659426305" + }, + { + "coefficient": "4", + "event": 869, + "helper": 1, + "lower": "55673220722484956621172038312479415509584752591582988345525752814244288230697717874082395726918977509174412027647883543087322662006162781469441091702785", + "register": 448, + "upper": "55673220722484956621172038312479415509584752591582988345596682408991728595015362624993189572106009250397525441424473234245935057124869057900632445292545" + }, + { + "coefficient": "2", + "event": 1138, + "helper": 0, + "lower": "52580441267055993142346330523680874846184579366726577375723940012327108314235288048274468633857845717706895058497781734607668122093790714503499681497345", + "register": 630, + "upper": "52580441267055993142346330523680874846184579366726577375723940012327108314235288048274468633857845717706895058497781734607668122093790714503499681497345" + }, + { + "coefficient": "4", + "event": 1211, + "helper": 1, + "lower": "893867501539951882693037803589720513871472146963027281007617410135449671733963628717636287702618650902820303127773875695856208934236875867987171684258065", + "register": 231, + "upper": "893867501539951882693037803589720513871472146963027281007617410135449671733963628717636287702618650902820303127773875695856208934236875867987171684258065" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "192024976249104975628006955453547693939957218362703932981887458701931454805254824159393066070170623912628972108202674080616373473466996752385", + "register": 577, + "upper": "192024976249104980916454863383561271133196531741032652183580142735138290944231858147813012943548476502985101282989973619379185480534289547265" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "170141188531071632644604909702730481665", + "register": 490, + "upper": "1146749342237577927401793151685381766050443824396030796300708741096533224394589362161185687070510032093185" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "33554433", + "register": 213, + "upper": "2256197893750785" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "192024976249104975628006955453547693939957218362703932981887458701931454805254824159393066070170623912628972108202674080616373473466996752385", + "register": 576, + "upper": "6301098639243886525839949166161762701146038025808726731103330330893611226284059462532642237790947682342313480108697049482551231885160419950625" + }, + { + "coefficient": "-4", + "event": 1560, + "helper": 0, + "lower": "1735116051922695209033551180369343141123737188895840966947796685833341446194463495915796303560683666118687653792079668651709618501324644091108418940707105", + "register": 624, + "upper": "1735116051922695209033551180369343141123737188895840966947796685833341446194463495915796303560683666118687653792079668651709618501324644091108418940707105" + } + ], + "helpers": 2, + "pair": [ + 2, + 47 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 139, + "upper": "1636695303948163970363304686095789889555730687601929660835813660759782928947832399270513561097137831029934703800171813107374230343718193459272353841153" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 582, + "upper": "199792097756634754359436633797464598659787653277796205559583510511254127893825042016011394430866765583599005454478139083170973587900194046013865985" + }, + { + "coefficient": "-2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 119, + "upper": "25573388512849157703167352175193976135804279645634433237925329900414792357628229489444454786187556411272326905894462440748751187452044131268485447681" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 572, + "upper": "199792097756634044555994938868702977039492610898011159360685421283818001903978102408655975503435012041906007636121736288595989929025048370787385345" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 125, + "upper": "23384048498039645221882098859178805466456054038529" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 127, + "upper": "24980085567665273773379695020434770223929700372067161728652277467939742214735507315689246297365481652034786985946099480473926477266308492009930753" + }, + { + "coefficient": "-2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 128, + "upper": "883424374887525513249142333715680727277200499598572683458196734761500673" + }, + { + "coefficient": "-2", + "event": 706, + "helper": 0, + "lower": "4503599627370497", + "register": 134, + "upper": "4507998747623425" + }, + { + "coefficient": "4", + "event": 881, + "helper": 0, + "lower": "4507998747623425", + "register": 496, + "upper": "90111766381043463973588797381820008144359102989090454828229644516446280434050158673808611491721218193676409320630067890869883633665" + }, + { + "coefficient": "4", + "event": 837, + "helper": 0, + "lower": "4507998747623425", + "register": 450, + "upper": "52374449518439003685670305950004145168721942974196480665755708435952900716895930747199320239911427683242373586659450319923793720617634020149117157638145" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 573, + "upper": "199792097756634044555994938868702938560970934731519276669671129960810150222256744347243522212729169587197852291927474064202116198508060718560968705" + }, + { + "coefficient": "-4", + "event": 897, + "helper": 0, + "lower": "54036718210900016813736777988275129034413477941444044759829447426613098438201391375959278255794753070683580617365516595471916702148813472104504188995585", + "register": 451, + "upper": "54036718210900016813736777988275129034723749773447726225103898764464267777159146703113193975348050686431524449976801129438704746599416280320754367596545" + }, + { + "coefficient": "-4", + "event": 1227, + "helper": 0, + "lower": "159616751594008530757763467349584068897976722826198723229221943496852513283512637363780892810290518272947045850586824781177174549285661946271470258752515", + "register": 497, + "upper": "159616751594008530757763467349584068897976722826198723229221943496852513283512637363780892810290518272947045850586824781177174549285661946271470258752515" + }, + { + "coefficient": "-2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 154, + "upper": "709803441694928761660098816718546277195888291870664263562599854499129726591413776481120533951502177649997169545781882118328973000705" + }, + { + "coefficient": "2", + "event": 1340, + "helper": 0, + "lower": "159616751594008530757763467349584068898445794300687126685861579258405570477314830084080040631712494591823431673164231704208891869253795238015314695293955", + "register": 162, + "upper": "159616751594008530757763467349584068898445794300687126685861579258405570477314830084080040631712494591823431673164231704208891869253795238015314695293955" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4503599627370497", + "register": 583, + "upper": "224772183324299318329374633889137708784900635103586171399943917314930307508706050201974049314455766115099840938246587298823545129235931033126305825" + } + ], + "helpers": 1, + "pair": [ + 3, + 113 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 113, + "upper": "4911261142184432095985665" + }, + { + "coefficient": "-2", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 572, + "upper": "199791907220223680259282646438913695064939742454398779328216924436565015304615526453346426066207187141461695386283030685032887892278563057522704385" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 122, + "upper": "170141183460474067434965797416955019265" + }, + { + "coefficient": "2", + "event": 507, + "helper": 1, + "lower": "883423532389218057836307220451910995884826763677379054515457293249675265", + "register": 148, + "upper": "199791908708789387616686880395866434116771219328599350316862920055094070100443886802245629178723212707073480538182476704490269741455240086635413505" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 499, + "upper": "7442828536787100496501018525091030180771331793673314629891244996168253314624580407613057079783896185939565384235220027413349866297087754305" + }, + { + "coefficient": "2", + "event": 750, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 165, + "upper": "170141183460474067434965797416955019265" + }, + { + "coefficient": "2", + "event": 820, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 132, + "upper": "170141183460474067434965797416955019265" + }, + { + "coefficient": "-4", + "event": 975, + "helper": 0, + "lower": "4911261142184432095985665", + "register": 586, + "upper": "14355632401324375816415162809879869520798854673322188779623996361480863745" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 573, + "upper": "199791907220223680259282646438913656586418352975242172345897820820955800506598688018532997484997641793723266591598760977136330203767929777384587265" + }, + { + "coefficient": "2", + "event": 999, + "helper": 0, + "lower": "831134334036129953392717689592183244877100073194574364004468316831772880971916330730743915476987490445059531831092562037427396506009617054008925487105", + "register": 140, + "upper": "831134334423157037305642531287051270059580270568541325963913721641034798930703545074650260789277646216040115250071748390402704131533646350183515029505" + }, + { + "coefficient": "4", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 498, + "upper": "382561386790852549666280912133050345286347219842342518520355401563981939848644335817212483832545694687789146280118799348431318136096517259265" + }, + { + "coefficient": "2", + "event": 1221, + "helper": 0, + "lower": "53205583877057400765897509400464390532722713310926889074776214928516810993927306836500093006684876059025509030133150101912180837120279068060173252690945", + "register": 144, + "upper": "53205583877057400765897509400464390532879070469126094965281928210109200652154468707905127380179170616780044634757633086738343605585256173223969412875265" + }, + { + "coefficient": "-4", + "event": 976, + "helper": 0, + "lower": "4911261142184432095985665", + "register": 587, + "upper": "6739986673064761684053525132368066122273469921854123383140651106305" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 217, + "upper": "170141183460474067434965797416955019265" + }, + { + "coefficient": "-1", + "event": 507, + "helper": 1, + "lower": "278242447378767224885357789996598013897672839503967975515244116814538015277606942350525982858335397430425034368558687040775194217595282992681989062348805", + "register": 159, + "upper": "278242447378767224885357789996598013897672839503967975515244116814538015277606942350525982858335397430425034368558687040775194217595282992681989062348805" + }, + { + "coefficient": "2", + "event": 507, + "helper": 1, + "lower": "4245578030406765848086166015765372253906577409236142600876903542840683741533418427489917161606699093664216552759260084605090120010255272881139240965", + "register": 203, + "upper": "4245578030406765848086166015765372253906577409236142600876903542840683741533418427489917161606699093664216552759260084605090120010255272881139240965" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "4835703278458516698824705", + "register": 198, + "upper": "4911261142184432095985665" + } + ], + "helpers": 2, + "pair": [ + 4, + 57 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "-4", + "event": 507, + "helper": 0, + "lower": "6593132938267557391084437462911880075202265171020685990920697740269985890392486729183996688930946528131413914752267477302454612580103553946780442625", + "register": 338, + "upper": "19386058497462499411164616893765259025770777269854519424896626154539366036128760498517213184766452486370330370430580759657856884358581277238849709185" + }, + { + "coefficient": "-2", + "event": 917, + "helper": 1, + "lower": "52380643067369317254011972069116985884821187044778419622911679833358656482456030793072457203116924190330404937239841236890845118047189475719979620368385", + "register": 348, + "upper": "53198996962840453353677204778424062729087068017631442125086169463685312816678581283855574282239133627926807289716306119045121760606792643017052753757185" + }, + { + "coefficient": "-2", + "event": 915, + "helper": 2, + "lower": "52380643067369317072389630259810396925870596451268112027548973625475078473057343241572087336211203122404105983839668115977395731445261417174096509665281", + "register": 344, + "upper": "53198996962840453177555991272627067683602684359986707922231386093499914507387079855896677952122544416263077556627079741210034128313063898789641791734785" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 3, + "lower": "6553174556823330892116248904781814709027457221082307439883542289645580354130451989756546571550882345858708693810056782782124390545961968514965411201025", + "register": 345, + "upper": "7384308890859460663799285351241947306269963990585429359088284238576239325873826388457376868430506448260301015951820082061808459590815681594912141213825" + }, + { + "coefficient": "2", + "event": 507, + "helper": 3, + "lower": "6553174556823330892116248904781814709027457221082307439883542289645580354130451989756546571550882345858708693810056782782124390545961968514965411201025", + "register": 351, + "upper": "6553174556823330897794698099823228860310139926568156482362798517179904073646587690227014561665770853294756277311382327316035481375013261770540422529025" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 4, + "lower": "6393341031047152089869680356944414897814460686496717306345749524911600177095016860097977146956588052639856803374513330802798475320392677244169879553", + "register": 525, + "upper": "19386058497462311758461176212271850286943440495662429660837653810422667744589795506857967362514737499747041894183074798427321451874364830026815251585" + }, + { + "coefficient": "-4", + "event": 1030, + "helper": 4, + "lower": "6393341032535717797227083268789470689687984291346989474585011712451380837618011063923174700626840341204721007914879743193711608264655845564136554497", + "register": 388, + "upper": "19386058501975980236336895002951366615452312322067330872360293062650272577806076932150675438450352551949251683908728275960164459665638866941189825665" + } + ], + "helpers": 5, + "pair": [ + 12, + 7 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "781962918155878120125647338535133883443669233964238966474250204413953131879188338064120789345722375980545451026470051290846247689095461916903425", + "register": 7, + "upper": "806545185282534981649537909176952507199136867695772613127418428142401697114613946549351231633702430778662888117211258441500734743856512508369025" + }, + { + "coefficient": "2", + "event": 507, + "helper": 1, + "lower": "25573364124189335198202340113356167700500403989245797309198901131311326774610700599313660994219452418792015983312123817281116082942663203015129825281", + "register": 87, + "upper": "3298963996408991754555081344609683677676254213693233576362577385314608870252501965012002660510015039753209724797020094212487613999515370754383047294977" + }, + { + "coefficient": "-4", + "event": 708, + "helper": 1, + "lower": "25573364124189335198202340113356167700500403989245797309198901131311326774610700599313660994219452418792015983312123817281116082942663203015129825281", + "register": 76, + "upper": "28770034639805946599846933358654683444996633067731993861846654569683738180657262423195369377942220651751040497172221801891656880813746840575280152705" + }, + { + "coefficient": "2", + "event": 840, + "helper": 2, + "lower": "1636895097379583169682108147972692410435641306536004993384791802166990937675896967426199540850839682639118973793821610002619870795232063638252671729665", + "register": 236, + "upper": "4910291948963455117578218018392903402727297575009353339760569170883190982343553789212786973935556746026748175441996231891801561256052806810100052525185" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 3, + "lower": "54010945030287830147763711696174121576056956281001459637622355888291724414095251285475300875722313958452542789650575174058855972405694872088051588270081", + "register": 226, + "upper": "54014147968879651315678546095316779662740759167010357848449240805013894759346506580074161802186369558196792632898414167103888984347637626476953801590785" + }, + { + "coefficient": "-4", + "event": 837, + "helper": 4, + "lower": "52374450298682628449550625712470491195725224972124237209770465277690856954099211228712702320279511669964384678684851247285518743532781688718058988765185", + "register": 230, + "upper": "55651037577287807437565212543401250520851055909891704405581627982882991081794290627658286669161317948235771437284777052429033246018786929821141197656065" + } + ], + "helpers": 5, + "pair": [ + 65, + 0 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "-4", + "event": 507, + "helper": 0, + "lower": "5192296858534975204734885819318273", + "register": 67, + "upper": "669806294750993206809047194939687041" + }, + { + "coefficient": "-2", + "event": 699, + "helper": 0, + "lower": "5192296858534975204734885819318273", + "register": 3, + "upper": "5192455319695707011868606786043905" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 1, + "lower": "390220057355206386367919090828793839461770382148159693670565110255226640575104628646310317048237057818858660822014017014533420256494154787323905", + "register": 375, + "upper": "439000355585308479790403640637148712907863599217964786743108324952053894943013291858811125893431474556043186747630565406986509436211034193002625" + }, + { + "coefficient": "-4", + "event": 507, + "helper": 2, + "lower": "51146728249865782427699826771846746255315149334529030128347910316780591197583468126761639556578591443637882710730159600049201310882577971987594870785", + "register": 372, + "upper": "52745063510604701865055302234364553588734803337622912688429336709397606816065853378579457685299353289043708661697534479900549130972847191944526299265" + }, + { + "coefficient": "2", + "event": 507, + "helper": 3, + "lower": "52425396454586647159645087707339293409315815972250672759471349057181020125127769882237657636604646683624659872488617755819872658854768311949308758851585", + "register": 382, + "upper": "52425396503366945389747181129823843217670689418343889829276442129724234821955024250146320849105455528819076609673144346050577395254824050384826148061185" + }, + { + "coefficient": "2", + "event": 507, + "helper": 4, + "lower": "52374250116556838732423774248486537491854340284686525877502694817429349789156826989215524643358385140418079808636548418243981599507879370347457265270785", + "register": 376, + "upper": "52375848451817577651861129723949055299187759938689619760062776243821966804775309374467342461487105902263485634587516457737672388296285697852677042601985" + } + ], + "helpers": 5, + "pair": [ + 82, + 6 + ], + "source_ready": 507 + }, + { + "contacts": [ + { + "coefficient": "-4", + "event": 507, + "helper": 0, + "lower": "23384026371519018554779450616708327354744617041921", + "register": 14, + "upper": "784637740307383767743690763303550454439398937263788261377" + }, + { + "coefficient": "2", + "event": 507, + "helper": 0, + "lower": "23384026371519018554779450616708327354744617041921", + "register": 52, + "upper": "113078212988314930441788557014917378171482166191125060667468803894415458305" + }, + { + "coefficient": "2", + "event": 962, + "helper": 1, + "lower": "199791907220223504194757069767170073657730823797150658543066056664749774960066642371245562191258090875474868989718297452147033705531476574809882625", + "register": 412, + "upper": "199792097756634045942331108041047949147989667916054578860390259265282940766213320767140715410505956705561355471650402662715725138580904339123994625" + }, + { + "coefficient": "-4", + "event": 958, + "helper": 2, + "lower": "1488565707357402911845054560560829680835478329675871214710685873297733911603422199536264333950183171445362711714738337604884460012740542465", + "register": 402, + "upper": "192024976249104976950118932436051088524954382249993195417311219038990802378695999088226000936392754299479282975338147016599608849933537378305" + }, + { + "coefficient": "-4", + "event": 959, + "helper": 3, + "lower": "1488565708743737758905422588343840378427807902353997565956512352181171640220367552991174766041639164532907380140395654642510356585029566465", + "register": 406, + "upper": "192024976427942170898799513896355409103873453044059594425906112149353029425665171033438778240736607538232230014648191216482964203567059042305" + }, + { + "coefficient": "2", + "event": 961, + "helper": 4, + "lower": "199791907220223502808422222706802045874720126204821085864939705418923296078395760819078542849117073191315683731685737403238733075155116550839599105", + "register": 105, + "upper": "199792097756634222006855362600893353886288851650466227570536565368523093137175334960563760336484718345394288451546824879507815066336497281536098305" + } + ], + "helpers": 5, + "pair": [ + 97, + 5 + ], + "source_ready": 507 + } + ], + "schema": "p104-fanout-contact-proposals-v1", + "scope": "Finite proposals; every scalar coefficient and actual cumulative frame is checked by fanout.py. Original helper labels are initial allocations, not certified chains." +} diff --git a/research/p104-interleaved-search/NATIVE-CHAIN.json b/research/p104-interleaved-search/NATIVE-CHAIN.json new file mode 100644 index 0000000000..2f4299d1f3 --- /dev/null +++ b/research/p104-interleaved-search/NATIVE-CHAIN.json @@ -0,0 +1,102 @@ +{ + "schema": "natural-query-delivery-v1", + "source_sha256": { + "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + "pair_hamming_root_indices": [ + 3, + 113 + ], + "query_register": 146, + "query_copy_coefficient": "-1/2", + "query_hoist_root_order": [ + 113, + 47, + 28, + 57 + ], + "contacts": [ + { + "before_B_event": 548, + "register": 139, + "coefficient": "2" + }, + { + "before_B_event": 884, + "register": 582, + "coefficient": "2" + }, + { + "before_B_event": 653, + "register": 119, + "coefficient": "-2" + }, + { + "before_B_event": 874, + "register": 572, + "coefficient": "2" + }, + { + "before_B_event": 553, + "register": 125, + "coefficient": "2" + }, + { + "before_B_event": 551, + "register": 127, + "coefficient": "2" + }, + { + "before_B_event": 658, + "register": 128, + "coefficient": "-2" + }, + { + "before_B_event": 524, + "register": 134, + "coefficient": "-2" + }, + { + "before_B_event": 523, + "register": 220, + "coefficient": "-2" + }, + { + "before_B_event": 697, + "register": 450, + "coefficient": "4" + }, + { + "before_B_event": 875, + "register": 573, + "coefficient": "2" + }, + { + "before_B_event": 785, + "register": 451, + "coefficient": "-4" + }, + { + "before_B_event": 1192, + "register": 497, + "coefficient": "-4" + }, + { + "before_B_event": 656, + "register": 154, + "coefficient": "-2" + }, + { + "before_B_event": 1608, + "register": 162, + "coefficient": "2" + }, + { + "before_B_event": 885, + "register": 583, + "coefficient": "2" + } + ] +} diff --git a/research/p104-interleaved-search/README.md b/research/p104-interleaved-search/README.md index d6be4bbe23..8aedc8adaf 100644 --- a/research/p104-interleaved-search/README.md +++ b/research/p104-interleaved-search/README.md @@ -1,59 +1,134 @@ -# P104 interleaved schedule search checkpoint +# Exact P104 query construction and complete forward fanout word -**No complete P104 schedule or improved κ was found in this bounded follow-up.** -This package preserves exact partial constructions and their remaining costs. -It does not promote a local fragment, an oracle-assisted identity, or an -optimistic packing bound into a multiplication supplier. +**All eight delivery terms now have an exact finite forward construction, but +no κ improvement is certified.** Frame coalescing reduces its local cost; +the concrete owner-window packing still misses the selected result. No global +supplier or improved multiplication bound is claimed. The starting point is canonical main `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. The selected result remains -κ = `836330098538459/500000000000000000`. The requested objective was a -significant, fully verified gain; the working search threshold was a 1% -relative improvement. That objective is **not achieved**. - -## What is retained - -1. **Conditional dirty-register surgery.** `scalar_surgery.py` replays the - selected 112-port word on all 704 independent input columns. It converts - eight source/target pairs into sixteen arbitrary dirty helper roles and - derives a 104-port identity, including actual compensation and restoration - gates. Its replacement cut reads eight explicitly hypothetical pure-source - queries. The checker reports the cut's incompatible survivor reads; it is - not a frame-legal implementation of those queries. -2. **An interleaved two-query delivery channel.** `delivery.py` checks the supplied - coefficient schedules against the selected scalar B word, propagates changed - frames through the later tail, and accounts for changed helper endpoints and - query-residual cancellation. These change the frame paths that were frozen - in the temporal-cut obstruction. Each fragment has an explicit external - query-input contract. It also replays both queries together: 30 contacts, - two simultaneous private copies, and zero remaining query perturbation in - every other register after cleanup. The two supplied query registers incur - two rank-one boundary moves, reported separately from the public-profile - deltas. This does not establish an - eight-query schedule, query construction, or concurrent native admission. -3. **A conditional cost screening tool.** `budget.py` uses exact rational interval - arithmetic in the pinned packing-ceiling engine. It distinguishes helper - boundary work that replaces an idle/remainder invoice from genuinely extra - transport work. Every reported candidate κ is an optimistic **upper bound** - under the stated retained template, not an achieved saving. - -The native fixture maps to removed selected port positions -`3, 14, 21, 34, 39, 61, 76, 93`. This differs from the puncture chosen in the -selected-port adapter package; the coordinate map and puncture are checked -directly, rather than conflating the two fixtures. -Both constructions use the same decoder orientation. For the two retained -delivery pairs, the supplied query must equal the scalar surgery's raw source -query divided by eight; the aggregate checker binds this normalization. This -agreement does not construct the queries or assemble the missing six terms. - -The selected contract already allocates **eight distinct private-centre -families**, separately from its ordinary helper families. The two simultaneous -private copies fit that stock; their overlap does not imply that ambient width -`m=73` must increase. The checker binds this count through the selected source -manifest to `complex-t16-rare-pattern-exchanges/data/SPEC.json`. The old emitter -still assumes sequential centre lifetimes, and the two external public query -registers need their own actual placement and construction. Physical private -stock sufficiency alone does not close those obligations. +κ = `836330098538459/500000000000000000`. The requested significant, fully +verified gain (working threshold: 1% relative improvement) is **not achieved**. + +## Constructive result + +`query_construction.py` derives all sixteen admissible query banks from the +pinned selected word: eight coordinate centres and eight punctured Y roles. +For this decoder, four coordinate banks are ready before B. A dependency +permutation produces the other four after 94, 209, 337 and 507 of 1846 B events. +It preserves every register's incident-event order, all frame inclusions, the +704-column B transformation and its transport profile. Query construction uses +actual public registers; it requires no external pure-query oracle. + +`fanout.py`, with the exact rational contacts in `FANOUT-PLANS.json`, realizes +all eight decoder terms in one chronological word: + +1. At B prefix 507, copy each actual query at its hyperplane Hb, normalize it, + and descend through one rank-seven native child to its target line La. + The eight private copies are sequential; peak occupancy is one. +2. Seed ordinary dirty helpers at La and ascend through their public contacts. + The joint schedule needs 31 helpers: 28 from the separate contact plans and + three more to avoid incompatible shared-reader frame promotions. +3. Cancel the helper responses on non-output roles, restore every new helper + from its actual query bank, perform the old cleanup, and restore the eight + punctured Y roles. Initial frame-zero compensation removes the remaining + dirty contribution to live outputs. + +The checker replays all **735 independent public input columns**. Every live Y +ends as its initial Y plus its corresponding initial X; all other public roles +return to their initial values. It verifies actual query frames, arbitrary +helper dirt, common charts for scalar additions, monotone public paths, owned +private-copy lifetimes and fixed final boundaries. The word uses 832 initial +compensation additions, 276 helper-response cleanup additions and 911 punctured +Y restoration additions. Four controls change the source coefficient or omit +private initialization, response cleanup or compensation while keeping the +repair word fixed; each is rejected. + +`native_checks.py` lowers every literal transport from that verified word using +the pinned predecessor compiler. An independent interpreter checks signed Pauli +actions and exact global phases, 208 rank-zero intrinsic endpoint adapters, and +all 4096 Gaussian basis columns across the eight private paths. A deliberately +wrong global phase is rejected. `verify.py` binds the occurrence lists and paid +profiles to the scalar/frame replay and cost calculation. Counts and recipe +hashes are in `RESULT.json`. + +`coalesced.py` improves the same word by changing 339 common scalar frames, +recorded sparsely in `COALESCED-FRAMES.json`. Scalar coefficients and order, +every public boundary frame, and all private Hb/La copy and seed interfaces +stay fixed. Transports are rebuilt and all 735 columns are checked afresh. +The cheaper public histogram is +`2429 H1 + 558 H2 + 389 H3 + 112 H4 + 108 H5 + 16 H6 + 6 H7`, +plus the same `8 H7` private descents. Its native lowering is checked separately; +two additional controls corrupt a contact coefficient or a private seed chart. +The search heuristic is not part of the replay or an optimality claim. + +## Complete local cost and remaining admission + +Before coalescing, the public histogram is +`2611 H1 + 514 H2 + 378 H3 + 132 H4 + 81 H5 + 15 H6 + 6 H7`; +the eight private descents add `8 H7`. The total local rank mass is 5894. +All eight delivery terms, helper entrances and dirty restoration paths are +included. The 31 new helpers contribute 279 lifetime ranks; existing public +roles add a further 21 ranks compared with the retained punctured baseline. + +`fanout_budget.py` checks exact rational interval brackets under the retained +`m=73, W=832, N=9, COPY=56` coverage and balanced-transfer model. It grants all +818 remaining paid ranks the favorable fractional rank-51 idle packing, without +requiring that this packing exist. Even this relaxation gives: + +| Scenario | κ upper bound (approx.) | Relative to selected κ | +| --- | ---: | ---: | +| Actual complete forward profile | 0.00165721126536 | −0.92361448% | +| Also grant four unused old gathers' cost credit | 0.00166251958654 | −0.60625646% | + +The extra gather credit is deliberately favorable: its joint compatibility with +fanout cleanup is unproved. Both exact moments at the selected κ are strictly +above one. These are **upper bounds**, not achieved exponents. They rule out +this concrete profile within the stated model, not P104 schedules in general. + +The coalesced profile has a slightly positive **optimistic** ceiling: at most ++0.05455960% relative to selected κ, or +0.37824205% with the conditional gather +credit. Both exact target moments rule out a 1% gain for these fixed profiles. +A positive upper bound is not an achieved improvement. + +`hosting.py` constructs and checks a concrete owner-window packing for all +527 ordinary roles in each of the selected schedule's 144 calls: **75,888 +placements**. It uses the actual complete lifetime widths, including the 21 +extra ranks on 17 old helpers, 16 reclassified roles and 31 new helpers. It +checks window membership, distinct physical owner families within each call, +exclusion of active data, nonoverlapping offsets and complete role coverage. +The exact residual histogram has mass 117792, or 818 per call. It is reproduced +from pinned schedule and owner inputs; its assignment digest is recorded. + +`coalesced_budget.py` also prices that actual residual histogram. The resulting +fixed-invoice κ upper bound is **1.21466947% below selected κ**, or **0.89916793% +below** after additionally granting the conditional gather credit. Thus this +available packing does not turn the cheaper finite word into a gain. A better +packing is not excluded by that calculation. + +The owner certificate is conditional on the retained schedule windows. It does +not generate or admit a changed 104-port global emitter, backward supplier, +route/wrapper proof or recursive precision/reserve account. Those remaining +obligations cannot establish a gain for the rejected invoice. A cheaper local +word or packing must first pass the full cost screen. The selected frontier is +not modified. + +## Earlier checkpoints and scope + +The package retains its useful predecessor checkpoints separately. +`actual_queries.py` checks an eight-query 704-column scalar identity whose 302 +scatter additions are explicitly unframed. `natural_delivery.py` and +`NATIVE-CHAIN.json` check one actual-source rank-one increment through 16 +contacts; `natural_budget.py` prices it with the seven other deliveries mostly +free. `scalar_surgery.py` is the older pure-query-cut identity; `delivery.py` +and `CHAINS.json` check two externally supplied query fragments; `budget.py` +prices those fragments. None of their optimistic ceilings is promoted to a +supplier or substituted for the complete fanout invoice. + +The native fixture removes selected port positions +`3, 14, 21, 34, 39, 61, 76, 93`. This differs from the puncture in the selected +port adapter package. The aggregate checker binds the exact port set, decoder, +query rows and normalizations rather than conflating the fixtures. ## Reproduce @@ -64,64 +139,34 @@ python3 -I -O -B research/p104-interleaved-search/verify.py python3 scripts/research_package.py --package research/p104-interleaved-search ``` -The registered command is read-only. It checks source hashes, recomputes the -exact receipt, compares it with `RESULT.json`, and runs rejecting controls. -The receipt separates the conditional scalar identity, delivery contracts, -and favorable cost models. It contains no admitted exponent claim. - -Validation on October 14, 2026 on macOS arm64 passed the registered replay with Python 3.12.14 -and a separate Python 3.14.7 replay from a read-only export containing only the -ten package files and eight declared inputs. The export replay ran outside the -checkout with `-I -O -B`; its file set and hashes were unchanged afterwards. -Four scalar-error controls, three delivery-error controls, and the cost -accounting checks all passed. No complete supplier or outer-theorem replay was -run, because this checkpoint does not supply their missing inputs. - -Discovery also explored persistent helper routes, changed packet timing, -alternative decoders, and constrained delivery-chain searches. Finite-field -and numerical optimization screens were used only to nominate candidates; -they are not evidence of rational identities or impossibility. Only the exact -replays retained here are acceptance evidence. Failure to find the other -chains is not a universal lower bound. -The final source-storage probe also found that simply dropping the punctured -source roles' old reads loses live-input transfers. Those roles carry selected -word intermediates; using them as query banks requires a replacement prefix, -not just new compensation for dirty inputs. - -## Remaining admission obligations - -The eight queries must be constructed from the actual source values at legal -chronological frames while preserving arbitrary dirty state. The remaining -six delivery terms must be scheduled, and all eight must coexist with query -construction and each other. Their combined frame changes, helper entrances, -cleanup and residual widths must be recomputed; separate profile deltas cannot -simply be added as a substitute for combined replay. - -A completed local word would still need its backward interface, native phase -recipes, chronological whole-call hosting, residual/idle children, precision -and reserve accounting, two exact moment checks, and the retained outer -inequalities. None of those missing obligations is waived here. With the -selected bit supplier unchanged, even a successful complex replacement remains -subject to the bit-side cap recorded by the budget checker. +The registered replay is read-only: it checks pinned source hashes, recomputes +the receipt, compares it with `RESULT.json`, and runs the rejecting controls. +`--write-result` explicitly regenerates the receipt. The registered replay +passed on CPython 3.12.14 with assertions disabled. A separate CPython 3.14.7 +replay passed from a source-only export of the 23 package files and 13 declared +inputs, without changing the export. Both ran on macOS 27.0.1, arm64. Exact +commands and the receipt hash are recorded in `TASK.json`. Search optimizers are not +needed for replay. The exact contacts are checked evidence; unsuccessful route, +decoder, helper-reuse and frame-coalescing searches are not impossibility proofs. ## Open next questions -- **Can the source packet prefix produce the four non-coordinate queries - within the remaining budget?** This is necessary before a delivery fragment - can become a supplier. The first experiment should change the packet prefix - or later packet routing and replay its full dirty-state matrix; reusing a - register must also remove or preserve its existing lifetime. A scalar span - calculation alone does not supply storage or frame availability. -- **Can the remaining delivery terms share one legal chronological schedule?** - Start with the two exact fragments, add one term, then propagate every frame - through the tail and cleanup before pricing it. The blocker is the combined - lifetime and frame contract, not the decoder identity. -- **Does a completed candidate survive the full supplier invoice?** Only after - the first two questions are closed should whole-call hosting and the outer - certificate be rebuilt. An optimistic ceiling leaves unpriced obligations; - it cannot be used as a lower bound on κ. - -## Provenance and scope +- **Can existing helper lifetimes replace new fanout helpers?** The full local + identity now exists, but its helper and small-rank transport costs exceed the + useful budget. Replace one complete lifetime, replay every input column and + the joint frame chronology, then reprice. Existing helpers acquire old scalar + payloads after B prefix 507, so they cannot simply be treated as persistent + query-plus-dirt storage. +- **Can a different contact schedule reduce small-rank children?** The separate + flow plans minimize helper count without optimizing the joint native invoice. + Optimize the actual moment while preserving query-bank access and all dirty + restoration. Total rank mass alone does not measure the expense. +- **Can a favorable local word satisfy full admission?** Only after a complete + local profile passes the necessary cost screen, construct its backward dual, + actual owner windows, residual children, precision/reserves and both exact + moment checks. Physical register capacity alone is not a hosting proof. + +## Provenance This follows the native P104 channel in PR1991 (Chafik Boukhalfa), the scalar channel in PR1972 (Rohan Arun), and the chronological gather schedule in PR1940 @@ -130,12 +175,24 @@ Elliston), PR1125 (Ali Romman), PR717 and PR968. The selected scalar architectur and Hamming packet construction retain their predecessor attribution, including icekylinx's frame-sa504 work and the selected PR1042/PR1094 lineage. The packing ceiling engine is Douglas Colkitt's existing work, not a new theorem here. - -The earlier temporal-cut result in PR2082 concerns a frozen native schedule; -this search explicitly changes that hypothesis. The live overlap check also -found the independent cut work in PR2090 and terminal-correction work in -PR2083/PR2089. Those results are not recast here as a new gain. Exact source -blobs, hashes and the local task record are in `SOURCES.json` and `TASK.json`. +The native compiler and independent interpreter retain the notices pinned in +`SOURCES.json`. The inherited T16 owner schedule is Rohan Arun's +`complex-t16-rare-pattern-exchanges` package, following PR1087 and earlier +packing work by jeremykothe2, FanPUYen's PR858 and the retained +PR1018/PR1005 lineage. The archive and its notices remain unchanged. + +PR2082's earlier temporal-cut result concerns a frozen native schedule; this +construction changes that hypothesis. PR2090 and PR2083/PR2089 cover distinct +cut and terminal-correction questions. PR2139 (Jose Manuel, Discussion2121) independently publishes a distinct +836-register delayed-query word based on full120/PR697. This construction +instead rebuilds the selected P112 word on P104 and checks 735 public registers. Discussion2131 (Hope7Happiness) explores +dirty carriers starting from the native 72-helper G/2 channel; this package +uses the selected 480-helper word plus 16 reclassified roles. Discussion2123 +and PR2127 constrain retained transports; the changed paths here do not satisfy +that premise. PR2148 extends the retained-obligation obstruction to subdivided +intervals; this word replaces and coalesces original obligations. Discussion +proposals remain provisional evidence. Source blobs, +hashes and overlap snapshots are recorded in `SOURCES.json` and `TASK.json`. Prepared for David Arias with substantial OpenAI Codex assistance, including parallel construction and checking. Apache-2.0. No formal proof assistant or diff --git a/research/p104-interleaved-search/RESULT.json b/research/p104-interleaved-search/RESULT.json index c81d719fc4..98c26554a8 100644 --- a/research/p104-interleaved-search/RESULT.json +++ b/research/p104-interleaved-search/RESULT.json @@ -1,4 +1,149 @@ { + "actual_query_scalar_identity": { + "B_permutation_sha256": "83a06432e5f12916056a6880268569ab5235463dd0fc88cf04593880c422f1b9", + "actual_query_cut_before_reordered_B_event": 507, + "failure_controls_with_repairs_held_fixed": { + "changed_scatter_coefficient": { + "incorrect_endpoint_registers": 4, + "rejected": true + }, + "dropped_FULL_restoration": { + "incorrect_endpoint_registers": 1, + "rejected": true + }, + "dropped_frame_zero_compensation": { + "incorrect_endpoint_registers": 1, + "rejected": true + }, + "reversed_restoration_block_order": { + "incorrect_endpoint_registers": 4, + "rejected": true + } + }, + "full_704_column_identity": true, + "initial_frame_zero_compensation": { + "additions": 416, + "punctured_X_roles_start_at_frame_zero": [ + 3, + 14, + 21, + 34, + 39, + 61, + 76, + 93 + ], + "sha256": "dfbcb3e092d063bf36d6f5ce75c14b2dd41e5038280edd0ab28cd24befa95de3", + "source_registers": [ + 21, + 34, + 39, + 61, + 133, + 146, + 151, + 173 + ] + }, + "live_ports": 104, + "old_centre_cut_included": false, + "ordered_FULL_restoration": { + "additions": 776, + "all_eight_punctured_Y_roles_must_reach_FULL": true, + "boundary_cost_not_a_new_additional_invoice": "These boundaries are part of retaining the eight punctured Y roles; a complete native schedule still must charge them.", + "every_source_already_restored_when_read": true, + "register_order": [ + 173, + 151, + 146, + 133, + 115, + 126, + 188, + 205 + ], + "required_H8_to_FULL_boundary_profile": { + "1": 8 + }, + "sha256": "9114a553053568a08e724b58f1a8510a1635c9ff206027d6cf106bbcd8f8a9fd" + }, + "physical_registers": 704, + "source_sha256": { + "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + "sources": [ + { + "a_root": 1, + "b_root": 28, + "full_704_column_row_sha256": "32fc6587e350e2498cc60438bffeb98da61e1c8c275add8b74d88c1d4365946a", + "raw_query_coefficient": "-1/4", + "register": 173 + }, + { + "a_root": 2, + "b_root": 47, + "full_704_column_row_sha256": "90ee1e52461476aa621682566e4cb487b2d00219fb297aff04fe73936f41b84c", + "raw_query_coefficient": "-1/4", + "register": 151 + }, + { + "a_root": 3, + "b_root": 113, + "full_704_column_row_sha256": "3dbedbe3ab8697526fccda66b18798b22fcfd28090019b9fdcd70e48a63c746f", + "raw_query_coefficient": "-1/4", + "register": 146 + }, + { + "a_root": 4, + "b_root": 57, + "full_704_column_row_sha256": "f1e4a4452f16290a1365e81a8c51ad2c041fe7de0a5f3530f7ebe67ce49baf85", + "raw_query_coefficient": "-1/4", + "register": 133 + }, + { + "a_root": 12, + "b_root": 7, + "full_704_column_row_sha256": "53b7d1040c3b8e32bd2dd15aa927d82f75ab5fc743e1f8b0f003fb8401eddcbe", + "raw_query_coefficient": "1/2", + "register": 256 + }, + { + "a_root": 65, + "b_root": 0, + "full_704_column_row_sha256": "84336a6f81560076de13ac266fbaf371e75c88c99d4f1063325d3401e08a6541", + "raw_query_coefficient": "1/2", + "register": 92 + }, + { + "a_root": 82, + "b_root": 6, + "full_704_column_row_sha256": "f5abfcc79ca082cde85d5ec3148b941c613ce024aac685ada00304395b29a944", + "raw_query_coefficient": "1/2", + "register": 9 + }, + { + "a_root": 97, + "b_root": 5, + "full_704_column_row_sha256": "7870291f50d6a31df3479c03eb56fc459636565d68dac10a71d6e2e56dd4c1ae", + "raw_query_coefficient": "1/2", + "register": 240 + } + ], + "status": "ACTUAL_QUERY_SCALAR_IDENTITY_NOT_NATIVE_DELIVERY", + "unframed_scalar_scatter": { + "additions": 302, + "native_frame_certificate": false, + "sha256": "218aa5d08946b340e92461922514b009fdf5694ffcee27ac50b267951cc41fa7", + "source_frame_not_subset_live_target_endpoint": 302 + }, + "unproved_obligations": [ + "replace the unframed scalar scatter with legal delivery after query availability", + "verify the complete native word and its actual transport profile", + "host all public and private lifetimes and price the complete global supplier" + ] + }, "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", "budget": { "additional_hosted_width9_helper_count_upper_bounds_at_one_percent": { @@ -491,214 +636,3248 @@ "target_kappa": "84469339952384359/50000000000000000000" }, "chain_input_sha256": "8d74eb0473a347d29e3f6e0dc5b9a4dea00bcf400f3725535c21e4e613a099f2", - "cross_checks": { - "delivery_pairs_belong_to_scalar_decoder": true, - "no_oracle_or_optimistic_ceiling_claimed_as_supplier": true, - "priced_single_chain_deltas_equal_replayed_deltas": true, - "priced_sum_equals_joint_chronological_replay": true, - "private_copy_peak_fits_selected_eight_centre_stock": true, - "retained_delivery_sources_need_raw_query_divided_by_eight": true, - "same_exact_104_port_puncture": true - }, - "delivery": { - "chains": [ - { - "all_live_output_query_coefficients_exact": true, - "all_other_query_perturbations_zero": true, - "contact_count": 14, - "local_B_tail_endpoint_cleanup_profile_delta": { - "1": 33, - "2": 19, - "3": -13, - "4": -4, - "5": -2 - }, - "pair_hamming_root_indices": [ - 3, - 113 - ], - "private_descent_mass": 7, - "private_descent_profile": { - "1": 1, - "2": 1, - "4": 1 - }, - "public_plus_residual_rank_mass_delta": 0, - "query_cleanup_count": 23, - "residual_width_profile_delta": { - "1": -5, - "4": 1, - "5": -1 - }, - "supplied_query_remaining_boundary_profile": { - "1": 1 - }, - "terminal_changes": [ - { - "after_rank": 5, - "before_rank": 4, - "register": 325 + "coalesced_cost_screen": { + "actual_private_COPY_profile": { + "7": 8 + }, + "actual_profile_source": "coalesced.verify()", + "actual_public_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 6 + }, + "actual_scalar_and_native_frame_binding": { + "frame_changes_sha256": "5e3d129ec88b23173f75c3d7187c78e96676f43ef1606166f4eadf888adb7a69", + "scalar_operation_word_sha256": "65e580cd0f76d6ce123f470c2b9703520f34449eaac4efca4c447767bb867e82", + "source_scalar_operations_sha256": "f1e9679ac6aa62639ae320a6392fdc4c4b05bc79814a378ba1e8c2a00535ec1c", + "transport_occurrences_sha256": "5e7e18279dc378ba5b823844f70afc4a77dca46364ad803bcab62c71738eb596" + }, + "conditional_selected_window_invoice": { + "actual_ordinary_widths_sha256": "2bcbd8d810246b0207042b7daac61ea07810e2033188944d3434f3f9d0e399f7", + "assigned_roles": 75888, + "assignment_sha256": "660d86bd36395690c2e0f37084c1bf15ce8277cb354dec5b1589c681bf3ffb77", + "both_selected_threshold_moments_strictly_above_one": true, + "exact_actual_local_plus_idle_mass_binding": true, + "global_emitter_admitted": false, + "global_idle_rank_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 + }, + "ordinary_helpers": 527, + "per_call_idle_rank_mass": "818", + "scenarios": [ + { + "complex_kappa_upper_bound": "206884707511/125206884707511", + "complex_saving_root_interval": { + "lower": "1655077660087/1000000000000000", + "lower_decimal": "0.001655077660087", + "upper": "206884707511/125000000000000", + "upper_decimal": "0.001655077660088" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 450 + "explicit_per_call_idle_rank_mass": "818", + "finite_word_local_rank_mass": "5894", + "fixed_bit_capped_kappa_upper_bound": "206884707511/125206884707511", + "idle_invoice": "conditional_selected_window_packing", + "kappa_upper_bound_decimal": "0.00165234290426035376348678", + "local_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 14 }, - { - "after_rank": 9, - "before_rank": 8, - "register": 580 + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "0", + "local_mass": "6712", + "total_mass": "6712", + "w": "832/9" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 581 + "moment_at_one_percent_target": { + "lower": "115806175970668244112225686102154714207580210146774622734802577933379997176669/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00012165540361896304604", + "upper": "57903087985334122056112843051077357103790105073387311367401288966689998588355/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00012165540361896304604" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 582 + "moment_at_selected_kappa": { + "lower": "28949953738550108612664161769179381210926055752005100353634954731463147100131/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "1.00006672059322122731326", + "upper": "115799814954200434450656647076717524843704223008020401414539818925852588400565/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00006672059322122731326" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 583 - } - ] - }, - { - "all_live_output_query_coefficients_exact": true, - "all_other_query_perturbations_zero": true, - "contact_count": 16, - "local_B_tail_endpoint_cleanup_profile_delta": { - "1": 40, - "2": 24, - "3": -12, - "4": -6, - "5": -4 - }, - "pair_hamming_root_indices": [ - 4, - 57 - ], - "private_descent_mass": 7, - "private_descent_profile": { - "1": 2, - "5": 1 - }, - "public_plus_residual_rank_mass_delta": 0, - "query_cleanup_count": 25, - "residual_width_profile_delta": { - "1": -5, - "4": 3, - "5": -3 - }, - "supplied_query_remaining_boundary_profile": { - "1": 1 - }, - "terminal_changes": [ - { - "after_rank": 5, - "before_rank": 4, - "register": 307 + "name": "coalesced_word_with_selected_window_invoice", + "one_percent_target_excluded": true, + "optional_gather_credit_assumed": false, + "per_call_margin_at_one_percent_target": { + "lower": "-91563766788316476255557107534241303016465627371381519742460515534638989031/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "lower_decimal": "-0.0112463662012196949230924", + "upper": "-183127533576632952511114215068482606032931254742763039484921031069277977529/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "-0.0112463662012196949230924" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 311 + "positive_upper_bound_is_not_an_achieved_gain": true, + "relative_gain_upper_percent_decimal": "-1.21466947393559201476336", + "selected_kappa_excluded": true, + "status": "SCOPED_ONE_PERCENT_COST_REJECTION" + }, + { + "complex_kappa_upper_bound": "1660372439859/1001660372439859", + "complex_saving_root_interval": { + "lower": "830186219929/500000000000000", + "lower_decimal": "0.001660372439858", + "upper": "1660372439859/1000000000000000", + "upper_decimal": "0.001660372439859" }, - { - "after_rank": 5, - "before_rank": 4, - "register": 314 + "explicit_per_call_idle_rank_mass": "818", + "finite_word_local_rank_mass": "5894", + "fixed_bit_capped_kappa_upper_bound": "1660372439859/1001660372439859", + "idle_invoice": "conditional_selected_window_packing", + "kappa_upper_bound_decimal": "0.00165762017300798323717740", + "local_profile": { + "1": 2401, + "2": 558, + "3": 389, + "4": 84, + "5": 136, + "6": 16, + "7": 14 }, - { - "after_rank": 5, - "before_rank": 4, - "register": 339 + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "0", + "local_mass": "6712", + "total_mass": "6712", + "w": "832/9" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 498 + "moment_at_one_percent_target": { + "lower": "57902065313544154735078208313928466019770797322587543464720722874364902174103/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "lower_decimal": "1.00010399147170956718954", + "upper": "115804130627088309470156416627856932039541594645175086929441445748729804348247/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00010399147170956718954" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 572 + "moment_at_selected_kappa": { + "lower": "115797790005552224924110051669911715275958284899536950813177568510757573249793/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00004923279537987919753", + "upper": "57898895002776112462055025834955857637979142449768475406588784255378786624917/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00004923279537987919753" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 573 + "name": "same_with_conditional_old_four_gather_credit", + "one_percent_target_excluded": true, + "optional_gather_credit_assumed": true, + "per_call_margin_at_one_percent_target": { + "lower": "-17393118559720289512290116577479380170103303772088618865578070068530134227/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "lower_decimal": "-0.00961343382915110018868540", + "upper": "-78269033518741302805305524598657210765464866974398784895101315308385603755/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "upper_decimal": "-0.00961343382915110018868540" }, - { - "after_rank": 9, - "before_rank": 8, - "register": 587 - } - ] - } - ], - "combined_two_query_channel": { - "all_other_query_perturbations_zero": true, - "all_query_coefficients_exact": true, - "changed_terminal_roles": [ - 307, - 311, - 314, - 325, - 339, - 450, - 498, - 572, - 573, - 580, - 581, - 582, - 583, - 587 + "positive_upper_bound_is_not_an_achieved_gain": true, + "relative_gain_upper_percent_decimal": "-0.899167929936886089138424", + "selected_kappa_excluded": true, + "status": "SCOPED_ONE_PERCENT_COST_REJECTION" + } ], - "external_query_registers_required": 2, - "global_owner_hosting_verified": false, - "local_B_tail_endpoint_cleanup_profile_delta": { - "1": 73, - "2": 43, - "3": -25, - "4": -10, - "5": -6 - }, - "peak_simultaneous_private_copies": 2, - "private_copy_lifetimes": [ + "scope": "Conditional complete-window owner invoice; no global emitter, backward supplier, or recursive admission is asserted.", + "sources": [ { - "copy": 0, - "discarded_after_B_contact": 885, - "initialized_before_B_event": 0 + "path": "research/complex-t16-rare-pattern-exchanges/data/PLAN.json", + "sha256": "7bd786ba8e66408f02aa9ef446eaf20c1bfe981ea2e4dd1e5a929f0aa7767bc0" }, { - "copy": 1, - "discarded_after_B_contact": 875, - "initialized_before_B_event": 0 + "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" } ], - "private_descent_mass": 14, - "public_plus_residual_rank_mass_delta": 0, - "query_count": 2, - "residual_width_profile_delta": { - "1": -10, - "4": 4, - "5": -4 - }, - "supplied_query_remaining_boundary_profile": { - "1": 2 - } + "total_calls": 144 }, - "negative_controls": { - "corrupt_contact_coefficient": "rejected: query perturbation endpoint mismatch", - "drop_query_cleanup": "rejected: query perturbation endpoint mismatch", - "drop_terminal_frame_overrides": "rejected: terminal frame exceeded: (('early cleanup', 55), 325)" + "controls": { + "actual_full_735_column_receipt_required": true, + "both_exact_root_brackets_certified": true, + "both_one_percent_threshold_moments_strictly_above_one": true, + "complete_mass_and_zero_moment_identities": true, + "eight_private_rank7_children_charged": true }, - "query_input_contract": "One independent exact scalar q already available in H_b; forming q, its dirty-input compensation, and its initial boundary are not included. Its remaining H_b-to-FULL boundary is one rank-one child per query.", + "existing_public_lifetime_width_increase": 21, + "global_owner_packing_constructed": false, + "hypotheses": [ + "Keep m73, nine stages, four pairs, 104 live ports, and COPY rank56.", + "Use the actual complete public transport profile and all eight private rank-seven seeds.", + "Allow every remaining unit of paid mass to be a fractional rank51 idle child, without constructing such owners.", + "For the second scenario only, grant the old four-unused-gather profile credit without assembling it with the changed charts and cleanup.", + "Use the retained necessary complex and fixed-bit balanced-transfer inequalities." + ], + "necessary_complex_saving_for_target": "84469339952384359/49915530660047615641", + "new_helper_rank_mass": 279, + "new_kappa_gain_certified": false, + "one_percent_target_kappa": "84469339952384359/50000000000000000000", + "optional_old_gather_credit": { + "A_event_indices": [ + 3409, + 3410, + 3411, + 3412, + 3413, + 3414, + 3415, + 3416, + 3417, + 3418, + 3419, + 3420, + 3421, + 3422, + 3423, + 3424, + 3425, + 3426, + 3427, + 3428, + 3429, + 3430, + 3431, + 3432 + ], + "joint_coalesced_word_verified": false, + "profile_delta": { + "1": -28, + "4": -28, + "5": 28 + } + }, + "ordinary_fanout_helpers": 31, + "scenarios": [ + { + "complex_kappa_upper_bound": "1676378334989/1001676378334989", + "complex_saving_root_interval": { + "lower": "419094583747/250000000000000", + "lower_decimal": "0.001676378334988", + "upper": "1676378334989/1000000000000000", + "upper_decimal": "0.001676378334989" + }, + "explicit_per_call_idle_rank_mass": null, + "finite_word_local_rank_mass": "5894", + "fixed_bit_capped_kappa_upper_bound": "1676378334989/1001676378334989", + "idle_invoice": "fractional_rank51_relaxation", + "kappa_upper_bound_decimal": "0.00167357279381542081585612", + "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": "actual_coalesced_fanout", + "one_percent_target_excluded": true, + "optional_gather_credit_assumed": false, + "per_call_margin_at_one_percent_target": { + "lower": "-77185642102653291340441205681032869830951531015916316505308871365874878421/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "lower_decimal": "-0.00474018286386992501898782", + "upper": "-77185642102653291340441205681032869830951531015916316505308871365874877901/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "-0.00474018286386992501898782" + }, + "positive_upper_bound_is_not_an_achieved_gain": true, + "relative_gain_upper_percent_decimal": "0.0545596015315984530369420", + "selected_kappa_excluded": false, + "status": "SCOPED_ONE_PERCENT_COST_REJECTION" + }, + { + "complex_kappa_upper_bound": "420452659839/250420452659839", + "complex_saving_root_interval": { + "lower": "336362127871/200000000000000", + "lower_decimal": "0.001681810639355", + "upper": "420452659839/250000000000000", + "upper_decimal": "0.001681810639356" + }, + "explicit_per_call_idle_rank_mass": null, + "finite_word_local_rank_mass": "5894", + "fixed_bit_capped_kappa_upper_bound": "420452659839/250420452659839", + "idle_invoice": "fractional_rank51_relaxation", + "kappa_upper_bound_decimal": "0.00167898690132201726885543", + "local_profile": { + "1": 2401, + "2": 558, + "3": 389, + "4": 84, + "5": 136, + "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": "57897990625410540132725490121259717952993798102444203206144583945145540516425/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "lower_decimal": "1.00003361208464688939010", + "upper": "57897990625410540132725490121259717952993798102444203206144583945145540516445/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00003361208464688939010" + }, + "moment_at_selected_kappa": { + "lower": "115789721671216758482471631287717996555635100784409387624335095670569957859175/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.999979553300099935082179", + "upper": "7236857604451047405154476955482374784727193799025586726520943479410622366201/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper_decimal": "0.999979553300099935082179" + }, + "name": "same_with_optional_old_four_gather_credit", + "one_percent_target_excluded": true, + "optional_gather_credit_assumed": true, + "per_call_margin_at_one_percent_target": { + "lower": "-25298087781751472219969019904932342664475005110975423405295235456684054201/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "lower_decimal": "-0.00310725049180133028458085", + "upper": "-2810898642416830246663224433881371407163889456775047045032803939631561549/904625697166532776746648320380374280103671755200316906558262375061821325312", + "upper_decimal": "-0.00310725049180133028458085" + }, + "positive_upper_bound_is_not_an_achieved_gain": true, + "relative_gain_upper_percent_decimal": "0.378242051562869385012660", + "selected_kappa_excluded": false, + "status": "SCOPED_ONE_PERCENT_COST_REJECTION" + } + ], + "scope": "The two stated fixed-profile relaxations exclude a one-percent kappa gain under the retained m73/P104/COPY56 model. They do not establish a positive gain or exclude other words, profile changes, coverage laws, or outer recipes.", + "selected_kappa": "836330098538459/500000000000000000", + "sources": [ + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } + ], + "status": "SCOPED_ONE_PERCENT_COST_REJECTION" + }, + "coalesced_forward_word": { + "actual_query_Hb_frames_verified": true, + "all_public_scalar_adds_common_chart": true, + "candidate_public_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 6 + }, + "changed_scalar_frames": 339, + "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, + "frame_changes_sha256": "5e3d129ec88b23173f75c3d7187c78e96676f43ef1606166f4eadf888adb7a69", + "full_735_column_identity_verified": true, + "global_hosting_verified": false, + "helper_La_seed_frames_verified": true, + "kappa_improvement_claimed": false, + "live_ports": 104, + "native_phase_compilation_verified": false, + "negative_controls": { + "contact_coefficient": "full 735-column endpoint identity failed", + "seed_frame": "private source or seed common chart changed" + }, + "ordinary_fanout_helpers": 31, + "peak_private_copies": 1, + "private_COPY_profile": { + "7": 8 + }, + "private_copies_created": 8, + "public_boundary_frames_unchanged": true, + "public_rank_mass": 5838, + "public_registers": 735, + "scalar_coefficients_and_order_unchanged": true, + "scalar_operation_word_sha256": "65e580cd0f76d6ce123f470c2b9703520f34449eaac4efca4c447767bb867e82", + "schema": "p104-coalesced-forward-report-v1", + "scope": "Finite exact 735-column forward word; complete native, hosting and exponent admission are separate.", + "source_scalar_operations_sha256": "f1e9679ac6aa62639ae320a6392fdc4c4b05bc79814a378ba1e8c2a00535ec1c", + "transport_occurrences_sha256": "5e7e18279dc378ba5b823844f70afc4a77dca46364ad803bcab62c71738eb596" + }, + "coalesced_native_lowering": { + "distinct_transport_recipes": 2940, + "every_recipe_signed_pauli_action_and_global_phase_checked": true, + "intrinsic_monomial_endpoint_adapters": 208, + "literal_transport_occurrences": 3626, + "native_rank_mass": 5894, + "paid_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 14 + }, + "private_path_gaussian_columns": 4096, + "private_paths": 8, + "recipe_payload_sha256": "3e34f688eed37e80a072cc7471b91bb2081734b6314dc006289829c8c1fbf5d6", + "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 + }, + "complete_fanout_cost_rejection": { + "actual_private_COPY_profile": { + "7": 8 + }, + "actual_profile_source": "fanout.verify()", + "actual_public_profile": { + "1": 2611, + "2": 514, + "3": 378, + "4": 132, + "5": 81, + "6": 15, + "7": 6 + }, + "controls": { + "both_exact_root_brackets_certified": true, + "both_kappa_caps_strictly_below_selected": true, + "both_selected_threshold_moments_strictly_above_one": true, + "complete_mass_and_zero_moment_identities": true, + "eight_private_rank7_children_charged": true + }, + "existing_public_lifetime_width_increase": 21, + "global_hosting_constructed_by_this_module": false, + "hypotheses": [ + "Keep m73, nine stages, four pairs, 104 live ports, and COPY rank56.", + "Retain the complete actual public and private transport histogram; no omitted rank-seven delivery remains.", + "All remaining paid mass is allowed to form fractional rank51 idle children, regardless of whether such a packing exists.", + "The second scenario additionally grants the old four-unused-gather credit without proving its joint cleanup compatibility.", + "Use the retained necessary complex and fixed-bit balanced-transfer inequalities." + ], + "new_helper_rank_mass": 279, + "new_kappa_gain_certified": false, + "one_percent_complex_saving_threshold": "84469339952384359/49915530660047615641", + "one_percent_target_kappa": "84469339952384359/50000000000000000000", + "optional_old_gather_credit": { + "A_event_indices": [ + 3409, + 3410, + 3411, + 3412, + 3413, + 3414, + 3415, + 3416, + 3417, + 3418, + 3419, + 3420, + 3421, + 3422, + 3423, + 3424, + 3425, + 3426, + 3427, + 3428, + 3429, + 3430, + 3431, + 3432 + ], + "joint_fanout_cleanup_verified": false, + "profile_delta": { + "1": -28, + "4": -28, + "5": 28 + } + }, + "ordinary_fanout_helpers": 31, + "retained_16_local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 8 + }, + "scenarios": [ + { + "complex_kappa_upper_bound": "1659962173371/1001659962173371", + "complex_saving_root_interval": { + "lower": "165996217337/100000000000000", + "lower_decimal": "0.00165996217337", + "upper": "1659962173371/1000000000000000", + "upper_decimal": "0.001659962173371" + }, + "fixed_bit_capped_kappa_upper_bound": "1659962173371/1001659962173371", + "kappa_upper_bound_decimal": "0.00165721126535722271957372", + "local_profile": { + "1": 2611, + "2": 514, + "3": 378, + "4": 132, + "5": 81, + "6": 15, + "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": "115804289140763791715863017393029372348330974454437998581385223509110428274667/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00010536042252931940514", + "upper": "115804289140763791715863017393029372348330974454437998581385223509110428274709/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00010536042252931940514" + }, + "moment_at_selected_kappa": { + "lower": "115797946682590847478475404553265172021006138998600236909586357262286735140383/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00005058588469413661936", + "upper": "115797946682590847478475404553265172021006138998600236909586357262286735140425/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00005058588469413661936" + }, + "name": "actual_31_helper_fanout", + "optional_gather_credit_assumed": false, + "per_call_margin_at_one_percent_target": { + "lower": "-158598744818751799796420996439038435792867254366649045059313515564882252049/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "lower_decimal": "-0.00973998572715486056385891", + "upper": "-158598744818751799796420996439038435792867254366649045059313515564882251503/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "-0.00973998572715486056385891" + }, + "relative_gain_upper_percent_decimal": "-0.923614476311045658449848", + "selected_kappa_excluded": true, + "status": "SCOPED_COST_REJECTION" + }, + { + "complex_kappa_upper_bound": "416322040181/250416322040181", + "complex_saving_root_interval": { + "lower": "1665288160723/1000000000000000", + "lower_decimal": "0.001665288160723", + "upper": "416322040181/250000000000000", + "upper_decimal": "0.001665288160724" + }, + "fixed_bit_capped_kappa_upper_bound": "416322040181/250416322040181", + "kappa_upper_bound_decimal": "0.00166251958653956390467732", + "local_profile": { + "1": 2583, + "2": 514, + "3": 378, + "4": 104, + "5": 109, + "6": 15, + "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": "28950560949295964268448436979682897545073089738209615694006022831115058861551/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "1.00008769649061992354864", + "upper": "57901121898591928536896873959365795090146179476419231388012045662230117723123/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00008769649061992354864" + }, + "moment_at_selected_kappa": { + "lower": "28948980433485659487982202286614840613315050222529196577056026711797929997413/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "1.00003309808685278850363", + "upper": "57897960866971318975964404573229681226630100445058393154112053423595859994847/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00003309808685278850363" + }, + "name": "same_with_optional_four_unused_gather_credit", + "optional_gather_credit_assumed": true, + "per_call_margin_at_one_percent_target": { + "lower": "-66004639139800726447958915283935125645432866786341787682297557556187741015/8141631274498794990719834883423368520933045796802852159024361375556391927808", + "lower_decimal": "-0.00810705335508626582945194", + "upper": "-33002319569900363223979457641967562822716433393170893841148778778093870371/4070815637249397495359917441711684260466522898401426079512180687778195963904", + "upper_decimal": "-0.00810705335508626582945194" + }, + "relative_gain_upper_percent_decimal": "-0.606256462315266952992097", + "selected_kappa_excluded": true, + "status": "SCOPED_COST_REJECTION" + } + ], + "scope": "This actual finite-word profile cannot improve selected kappa under the retained m73/P104/COPY56 hosted coverage and balanced-transfer model. Other words, coverage laws, and outer recipes are not excluded.", + "selected_complex_saving_threshold": "836330098538459/499163669901461541", + "selected_kappa": "836330098538459/500000000000000000", + "selected_private_centre_stock": { + "scope": "Capacity only: the eight private centres are separate from ordinary helpers. Their count is not the ambient width m. No concurrent native admission or public-query placement is established.", + "selected_live_families": 14336, + "selected_ordinary_helper_families": 480, + "selected_physical_families": 14826, + "selected_private_centre_families": 8 + }, + "sources": [ + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } + ], + "status": "SCOPED_COST_REJECTION" + }, + "complete_fanout_forward_word": { + "actual_query_Hb_frames_verified": true, + "all_new_helpers_restored": true, + "all_public_scalar_adds_common_chart": true, + "candidate_public_profile": { + "1": 2611, + "2": 514, + "3": 378, + "4": 132, + "5": 81, + "6": 15, + "7": 6 + }, + "compensation_only_initial_frame_zero": true, + "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, + "contact_count": 89, + "contact_schedule_sha256": "43cd66b9e2b84281b576a75bd910f6bc9bc36a023e10ea6a404b7273d9e8981e", + "deterministic_clones": [ + [ + 3, + 113 + ], + [ + 2, + 47 + ], + [ + 4, + 57 + ] + ], + "entry_compensation_additions": 832, + "full_735_column_identity_verified": true, + "ghost_restoration_additions": 911, + "global_hosting_verified": false, + "kappa_improvement_claimed": false, + "live_ports": 104, + "native_phase_compilation_verified": false, + "negative_controls_repairs_held_fixed": { + "missing_entry_compensation": "full 735-column endpoint identity failed", + "missing_private_initialization": "scalar ADD crosses charts or reads an uninitialized private copy", + "missing_response_cleanup": "fixed ghost restoration reads a nonidentity source", + "query_coefficient": "dirty helper not restored" + }, + "ordinary_fanout_helpers": 31, + "peak_private_copies": 1, + "plans_sha256": "0c2ae264694bbe7c15b9261ba8adf68c9552849effd423894713c68ad23d28ca", + "private_COPY_profile": { + "7": 8 + }, + "private_copies_created": 8, + "public_rank_mass": 5838, + "public_registers": 735, + "query_sources": [ + { + "coefficient": "1/2", + "fanout_helpers": [ + 0, + 1, + 2 + ], + "frame": [ + 1, + 2, + 4, + 16, + 40, + 72, + 128, + 256 + ], + "pair": [ + 1, + 28 + ], + "scalar_row_sha256": "32fc6587e350e2498cc60438bffeb98da61e1c8c275add8b74d88c1d4365946a", + "source": 173 + }, + { + "coefficient": "1/2", + "fanout_helpers": [ + 3, + 4, + 29 + ], + "frame": [ + 1, + 4, + 8, + 16, + 34, + 64, + 130, + 256 + ], + "pair": [ + 2, + 47 + ], + "scalar_row_sha256": "90ee1e52461476aa621682566e4cb487b2d00219fb297aff04fe73936f41b84c", + "source": 151 + }, + { + "coefficient": "-1/2", + "fanout_helpers": [ + 5, + 28 + ], + "frame": [ + 1, + 4, + 10, + 16, + 32, + 64, + 128, + 258 + ], + "pair": [ + 3, + 113 + ], + "scalar_row_sha256": "3dbedbe3ab8697526fccda66b18798b22fcfd28090019b9fdcd70e48a63c746f", + "source": 146 + }, + { + "coefficient": "-1/2", + "fanout_helpers": [ + 6, + 7, + 30 + ], + "frame": [ + 2, + 4, + 8, + 16, + 33, + 64, + 128, + 257 + ], + "pair": [ + 4, + 57 + ], + "scalar_row_sha256": "f1e4a4452f16290a1365e81a8c51ad2c041fe7de0a5f3530f7ebe67ce49baf85", + "source": 133 + }, + { + "coefficient": "1/4", + "fanout_helpers": [ + 8, + 9, + 10, + 11, + 12 + ], + "frame": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "pair": [ + 12, + 7 + ], + "scalar_row_sha256": "53b7d1040c3b8e32bd2dd15aa927d82f75ab5fc743e1f8b0f003fb8401eddcbe", + "source": 256 + }, + { + "coefficient": "1/4", + "fanout_helpers": [ + 13, + 14, + 15, + 16, + 17 + ], + "frame": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "pair": [ + 65, + 0 + ], + "scalar_row_sha256": "84336a6f81560076de13ac266fbaf371e75c88c99d4f1063325d3401e08a6541", + "source": 92 + }, + { + "coefficient": "1/4", + "fanout_helpers": [ + 18, + 19, + 20, + 21, + 22 + ], + "frame": [ + 2, + 4, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "pair": [ + 82, + 6 + ], + "scalar_row_sha256": "f5abfcc79ca082cde85d5ec3148b941c613ce024aac685ada00304395b29a944", + "source": 9 + }, + { + "coefficient": "-1/4", + "fanout_helpers": [ + 23, + 24, + 25, + 26, + 27 + ], + "frame": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "pair": [ + 97, + 5 + ], + "scalar_row_sha256": "7870291f50d6a31df3479c03eb56fc459636565d68dac10a71d6e2e56dd4c1ae", + "source": 240 + } + ], + "response_cleanup_additions": 276, + "scalar_operation_word_sha256": "f1e9679ac6aa62639ae320a6392fdc4c4b05bc79814a378ba1e8c2a00535ec1c", + "schema": "p104-fanout-forward-report-v1", + "scope": "Finite forward 735-column identity and literal frame word; not a global supplier or exponent improvement.", + "source_availability_B_prefix": 507, + "sources": { + "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + "transport_occurrences_sha256": "8ac1848ae32e85c2c7fdb7051f39dadbb3d4bcaace0a2aa3742ace3a1040a143" + }, + "complete_fanout_native_lowering": { + "distinct_transport_recipes": 3049, + "every_recipe_signed_pauli_action_and_global_phase_checked": true, + "intrinsic_monomial_endpoint_adapters": 208, + "literal_transport_occurrences": 3745, + "native_rank_mass": 5894, + "paid_profile": { + "1": 2611, + "2": 514, + "3": 378, + "4": 132, + "5": 81, + "6": 15, + "7": 14 + }, + "private_path_gaussian_columns": 4096, + "private_paths": 8, + "recipe_payload_sha256": "bc3623b24fb6ceacccbc6259eac0f94483f13e860fc3115a78dee952ed5b0eeb", + "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 + }, + "conditional_owner_window_packing": { + "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 + }, + "cross_checks": { + "actual_eight_source_registers_match_decoder": true, + "actual_query_rows_equal_source_bank_rows": true, + "actual_query_sources_and_scalar_recipe_share_B_permutation": true, + "coalesced_native_and_cost_profiles_bind_full_identity": true, + "coalesced_scalar_word_and_boundaries_bind_original_fanout": true, + "complete_fanout_profile_binds_scalar_native_and_cost_replays": true, + "delivery_pairs_belong_to_scalar_decoder": true, + "eight_fanout_private_paths_partition_literal_private_occurrences": true, + "full_forward_identity_is_not_global_supplier_admission": true, + "native_ports_equal_pinned_p104_puncture": true, + "native_transport_occurrences_equal_scalar_frame_replay": true, + "no_oracle_or_optimistic_ceiling_claimed_as_supplier": true, + "priced_single_chain_deltas_equal_replayed_deltas": true, + "priced_sum_equals_joint_chronological_replay": true, + "private_copy_peak_fits_selected_eight_centre_stock": true, + "retained_delivery_sources_need_raw_query_divided_by_eight": true, + "same_exact_104_port_puncture": true + }, + "delivery": { + "chains": [ + { + "all_live_output_query_coefficients_exact": true, + "all_other_query_perturbations_zero": true, + "contact_count": 14, + "local_B_tail_endpoint_cleanup_profile_delta": { + "1": 33, + "2": 19, + "3": -13, + "4": -4, + "5": -2 + }, + "pair_hamming_root_indices": [ + 3, + 113 + ], + "private_descent_mass": 7, + "private_descent_profile": { + "1": 1, + "2": 1, + "4": 1 + }, + "public_plus_residual_rank_mass_delta": 0, + "query_cleanup_count": 23, + "residual_width_profile_delta": { + "1": -5, + "4": 1, + "5": -1 + }, + "supplied_query_remaining_boundary_profile": { + "1": 1 + }, + "terminal_changes": [ + { + "after_rank": 5, + "before_rank": 4, + "register": 325 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 450 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 580 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 581 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 582 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 583 + } + ] + }, + { + "all_live_output_query_coefficients_exact": true, + "all_other_query_perturbations_zero": true, + "contact_count": 16, + "local_B_tail_endpoint_cleanup_profile_delta": { + "1": 40, + "2": 24, + "3": -12, + "4": -6, + "5": -4 + }, + "pair_hamming_root_indices": [ + 4, + 57 + ], + "private_descent_mass": 7, + "private_descent_profile": { + "1": 2, + "5": 1 + }, + "public_plus_residual_rank_mass_delta": 0, + "query_cleanup_count": 25, + "residual_width_profile_delta": { + "1": -5, + "4": 3, + "5": -3 + }, + "supplied_query_remaining_boundary_profile": { + "1": 1 + }, + "terminal_changes": [ + { + "after_rank": 5, + "before_rank": 4, + "register": 307 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 311 + }, + { + "after_rank": 5, + "before_rank": 4, + "register": 314 + }, + { + "after_rank": 5, + "before_rank": 4, + "register": 339 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 498 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 572 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 573 + }, + { + "after_rank": 9, + "before_rank": 8, + "register": 587 + } + ] + } + ], + "combined_two_query_channel": { + "all_other_query_perturbations_zero": true, + "all_query_coefficients_exact": true, + "changed_terminal_roles": [ + 307, + 311, + 314, + 325, + 339, + 450, + 498, + 572, + 573, + 580, + 581, + 582, + 583, + 587 + ], + "external_query_registers_required": 2, + "global_owner_hosting_verified": false, + "local_B_tail_endpoint_cleanup_profile_delta": { + "1": 73, + "2": 43, + "3": -25, + "4": -10, + "5": -6 + }, + "peak_simultaneous_private_copies": 2, + "private_copy_lifetimes": [ + { + "copy": 0, + "discarded_after_B_contact": 885, + "initialized_before_B_event": 0 + }, + { + "copy": 1, + "discarded_after_B_contact": 875, + "initialized_before_B_event": 0 + } + ], + "private_descent_mass": 14, + "public_plus_residual_rank_mass_delta": 0, + "query_count": 2, + "residual_width_profile_delta": { + "1": -10, + "4": 4, + "5": -4 + }, + "supplied_query_remaining_boundary_profile": { + "1": 2 + } + }, + "negative_controls": { + "corrupt_contact_coefficient": "rejected: query perturbation endpoint mismatch", + "drop_query_cleanup": "rejected: query perturbation endpoint mismatch", + "drop_terminal_frame_overrides": "rejected: terminal frame exceeded: (('early cleanup', 55), 325)" + }, + "query_input_contract": "One independent exact scalar q already available in H_b; forming q, its dirty-input compensation, and its initial boundary are not included. Its remaining H_b-to-FULL boundary is one rank-one child per query.", "removed_selected_positions": [ 3, 14, @@ -709,16 +3888,1216 @@ 76, 93 ], - "retained_role_baseline_profile_delta_from_selected": { - "1": 16 + "retained_role_baseline_profile_delta_from_selected": { + "1": 16 + }, + "schema": "p104-single-query-delivery-report-v1", + "scope": "One exact two-query delivery perturbation channel on a modified selected B schedule, with separate and joint invoices; no eight-query program or improved kappa.", + "source_sha256": { + "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + } + }, + "natural_delivery_native_lowering": { + "distinct_transport_recipes": 2911, + "every_recipe_signed_pauli_action_and_global_phase_checked": true, + "intrinsic_monomial_endpoint_adapters": 208, + "literal_transport_occurrences": 3541, + "native_rank_mass": 5552, + "paid_profile": { + "1": 2465, + "2": 439, + "3": 419, + "4": 138, + "5": 80 + }, + "private_path_gaussian_columns": 512, + "private_paths": 1, + "recipe_payload_sha256": "c896b6c2af10607882703ab329ecaebef7b757f15fbfba45b2dec0aa72d84f8b", + "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 + }, + "natural_delivery_optimistic_cost": { + "actual_private_COPY_profile": { + "1": 3, + "2": 2 + }, + "actual_public_profile_delta": { + "1": 34, + "2": 19, + "3": -13, + "4": -4, + "5": -2 + }, + "actual_residual_width_delta": { + "0": 4, + "1": -2, + "2": -2, + "4": 1, + "5": -1 + }, + "assumptions": [ + "Retain m=73, nine stages, four pairs, 104 ports, and COPY rank56.", + "Retain all sixteen deleted X/Y roles as dirty helpers with the pinned public baseline.", + "Use the actual source-formed one-term invoice; no external public Q bank is added.", + "Each of the other seven terms costs only one H7 child; all its delivery overhead, dirty correction, and interactions are free.", + "Completion of the comparison baseline's punctured-Y restoration costs no additional paid transport; no complete eight-term endpoint proof is supplied.", + "All residual mass is fractionally packed at rank51; actual owners, chronology, backward admission, and primitive bounds remain unproved.", + "Only the second scenario assumes the old four-unused-gather saving remains valid jointly with the changed delivery and its rederived cleanup.", + "The fixed-bit and complex caps use the retained necessary balanced-transfer inequalities." + ], + "controls": { + "actual_private_mass_is_seven": true, + "actual_public_plus_residual_mass_is_zero": true, + "full_mass_and_zero_moment_identities": true, + "one_excess_H1_fits_only_with_conditional_credit": true + }, + "missing_deliveries": 7, + "necessary_complex_saving_for_target": "84469339952384359/49915530660047615641", + "optional_old_gather_credit": { + "A_event_indices": [ + 3409, + 3410, + 3411, + 3412, + 3413, + 3414, + 3415, + 3416, + 3417, + 3418, + 3419, + 3420, + 3421, + 3422, + 3423, + 3424, + 3425, + 3426, + 3427, + 3428, + 3429, + 3430, + 3431, + 3432 + ], + "full_old_paths_recounted": true, + "joint_changed_cleanup_verified": false, + "profile_delta": { + "1": -28, + "4": -28, + "5": 28 + } + }, + "retained_16_local_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 8 + }, + "scenarios": [ + { + "complex_kappa_upper_bound": "173521954767/100173521954767", + "complex_saving_root_interval": { + "lower": "1735219547669/1000000000000000", + "lower_decimal": "0.001735219547669", + "upper": "173521954767/100000000000000", + "upper_decimal": "0.00173521954767" + }, + "fixed_bit_capped_kappa_upper_bound": "1733427039589844234749/1001733427039589844234749", + "kappa_upper_bound_decimal": "0.00173042746982360296214729", + "local_profile": { + "1": 2465, + "2": 439, + "3": 419, + "4": 138, + "5": 80, + "7": 7 + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "1111", + "local_mass": "5601", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "28944138513683482787252463864297467436613034494798197723890866644245129981563/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "0.999865835544685398356836", + "upper": "28944138513683482787252463864297467436613034494798197723890866644245129981573/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "upper_decimal": "0.999865835544685398356836" + }, + "name": "one_actual_term_seven_free_H7_deliveries", + "one_true_excess_H1_moment": { + "lower": "96340472736903891087761242902422559287081409775941928646119524039334237843770931/96339018245447074592411059527228339333920627241812949280828709894583723860426752", + "lower_decimal": "1.00001509763627765880583", + "upper": "24085118184225972771940310725605639821770352443985482161529881009833559460951055/24084754561361768648102764881807084833480156810453237320207177473645930965106688", + "upper_decimal": "1.00001509763627765880583" + }, + "optional_gather_credit_assumed": false, + "per_call_margin_after_one_true_excess_H1": { + "lower": "-363622864204123837545843798554988290195633532244841322703536187628495844367/260532200783961439703034716269547792669857465497691269088779564017804541689856", + "lower_decimal": "-0.00139569259811245849436934", + "upper": "-161610161868499483353708354913328128975837125442151698979349416723775927131/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "-0.00139569259811245849436934" + }, + "per_call_margin_at_one_percent_target": { + "lower": "50489343392358892323671042368623847158001730955262717655881650530981569343/4070815637249397495359917441711684260466522898401426079512180687778195963904", + "lower_decimal": "0.0124027585357498407902724", + "upper": "5609927043595432480407893596513760795333525661695857517320183392331285497/452312848583266388373324160190187140051835877600158453279131187530910662656", + "upper_decimal": "0.0124027585357498407902724" + }, + "relative_gain_upper_percent_decimal": "3.45361675058909225751538", + "status": "CEILING_NOT_SUPPLIER", + "true_excess_H1_upper_count": 0 + }, + { + "complex_kappa_upper_bound": "174104097639/100174104097639", + "complex_saving_root_interval": { + "lower": "1741040976389/1000000000000000", + "lower_decimal": "0.001741040976389", + "upper": "174104097639/100000000000000", + "upper_decimal": "0.00174104097639" + }, + "fixed_bit_capped_kappa_upper_bound": "1733427039589844234749/1001733427039589844234749", + "kappa_upper_bound_decimal": "0.00173042746982360296214729", + "local_profile": { + "1": 2437, + "2": 439, + "3": 419, + "4": 110, + "5": 108, + "7": 7 + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "1111", + "local_mass": "5601", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115774508711153996506940585982892087578413522477593255090202334392330327097789/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.999848171612776002500334", + "upper": "115774508711153996506940585982892087578413522477593255090202334392330327097829/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "0.999848171612776002500334" + }, + "name": "same_with_optional_four_unused_gather_credit", + "one_true_excess_H1_moment": { + "lower": "96338771011045385465559610699806804523273281678611114856059062061705277410489715/96339018245447074592411059527228339333920627241812949280828709894583723860426752", + "lower_decimal": "0.999997433704368262949327", + "upper": "24084692752761346366389902674951701130818320419652778714014765515426319352630751/24084754561361768648102764881807084833480156810453237320207177473645930965106688", + "upper_decimal": "0.999997433704368262949327" + }, + "optional_gather_credit_assumed": true, + "per_call_margin_after_one_true_excess_H1": { + "lower": "6867622269142412540245206153744740204043422273178465823550913290179163993/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "0.000237239773956136240037630", + "upper": "247234401689126851448827421534810647345563201834424769647832878446449937037/1042128803135845758812138865078191170679429861990765076355118256071218166759424", + "upper_decimal": "0.000237239773956136240037630" + }, + "per_call_margin_at_one_percent_target": { + "lower": "25394093345398435132798592816184841459334271623890704479805000286270338599/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "lower_decimal": "0.0140356909078184355246793", + "upper": "228546840108585916195187335345663573134008444615016340318245002576433047911/16283262548997589981439669766846737041866091593605704318048722751112783855616", + "upper_decimal": "0.0140356909078184355246793" + }, + "relative_gain_upper_percent_decimal": "3.45361675058909225751538", + "status": "CEILING_NOT_SUPPLIER", + "true_excess_H1_upper_count": 1 + } + ], + "scope": "Conditional pricing of one actual-source term; seven deliveries and final completion remain unproved. No kappa improvement is certified.", + "selected_kappa": "836330098538459/500000000000000000", + "selected_private_centre_stock": { + "scope": "Capacity only: the eight private centres are separate from ordinary helpers. Their count is not the ambient width m. No concurrent native admission or public-query placement is established.", + "selected_live_families": 14336, + "selected_ordinary_helper_families": 480, + "selected_physical_families": 14826, + "selected_private_centre_families": 8 + }, + "sources": [ + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } + ], + "status": "CEILING_NOT_SUPPLIER", + "target_kappa": "84469339952384359/50000000000000000000", + "true_excess_H1_cost_at_target": { + "lower": "1597751485028930198338129115620850892581219694836291223413316365160585014363/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "0.0137984511338622992846417", + "upper": "399437871257232549584532278905212723145304923709072805853329091290146253591/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "upper_decimal": "0.0137984511338622992846417" + } + }, + "natural_source_delivery": { + "additional_public_query_registers": 0, + "baseline_profile": { + "1": 2428, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "candidate_public_profile": { + "1": 2462, + "2": 437, + "3": 419, + "4": 138, + "5": 80 + }, + "complete_eight_term_supplier": false, + "contacts": 16, + "endpoint_changes": [ + { + "new_frame": [ + 30, + 42, + 75, + 138, + 266 + ], + "old_frame": [ + 30, + 75, + 138, + 266 + ], + "register": 325 + }, + { + "new_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old_frame": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "register": 450 + }, + { + "new_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old_frame": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "register": 451 + }, + { + "new_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old_frame": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "register": 572 + }, + { + "new_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old_frame": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "register": 573 + }, + { + "new_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old_frame": [ + 1, + 2, + 4, + 24, + 40, + 72, + 128, + 256 + ], + "register": 582 + }, + { + "new_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old_frame": [ + 1, + 2, + 4, + 24, + 40, + 72, + 128, + 256 + ], + "register": 583 + } + ], + "entry_compensation_additions": 3536, + "full_704_column_increment_verified": true, + "global_hosting_verified": false, + "live_ports": 104, + "native_phase_compilation_verified": false, + "negative_controls": { + "late_copy": "private read before query copy initialization", + "removed_cleanup": "full-column rank-one increment mismatch at register 583", + "source_coefficient": "natural source coefficient or availability" + }, + "original_B_events": 1846, + "other_natural_query_observations": { + "113": { + "all_704_source_columns_preserved": true, + "at_original_B_event": 1616, + "frame_rank": 8, + "live_source_row_preserved": true, + "original_query_frame_preserved": true, + "register": 146 + }, + "28": { + "all_704_source_columns_preserved": true, + "at_original_B_event": 1493, + "frame_rank": 8, + "live_source_row_preserved": true, + "original_query_frame_preserved": true, + "register": 173 + }, + "47": { + "all_704_source_columns_preserved": true, + "at_original_B_event": 1553, + "frame_rank": 8, + "live_source_row_preserved": true, + "original_query_frame_preserved": true, + "register": 151 + }, + "57": { + "all_704_source_columns_preserved": true, + "at_original_B_event": 1840, + "frame_rank": 8, + "live_source_row_preserved": true, + "original_query_frame_preserved": true, + "register": 133 + }, + "coordinate_0": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 92 + }, + "coordinate_1": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 57 + }, + "coordinate_2": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 81 + }, + "coordinate_3": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 224 + }, + "coordinate_4": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 11 + }, + "coordinate_5": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 240 + }, + "coordinate_6": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 9 + }, + "coordinate_7": { + "all_704_source_columns_preserved": true, + "at_phase": "A end", + "frame_rank": 8, + "original_query_frame_preserved": true, + "register": 256 + } + }, + "pair_hamming_root_indices": [ + 3, + 113 + ], + "peak_private_copies": 1, + "private_COPY_profile": { + "1": 3, + "2": 2 + }, + "private_copies_created": 1, + "public_profile_delta": { + "1": 34, + "2": 19, + "3": -13, + "4": -4, + "5": -2 + }, + "public_rank_mass_delta": 7, + "public_registers": 704, + "query_cleanup_additions": 21, + "residual_rank_mass_delta": -7, + "residual_width_delta": { + "0": 4, + "1": -2, + "2": -2, + "4": 1, + "5": -1 + }, + "schema": "natural-query-delivery-report-v1", + "scope": "One exact rank-one difference against the centre-cut-omitted selected baseline; not a supplier or exponent improvement.", + "source_query_dirty_columns": 68, + "source_query_nonzero_columns": 120 + }, + "query_construction": { + "B_events": 1846, + "B_events_remaining_after_all_queries": 1339, + "B_permutation_sha256": "83a06432e5f12916056a6880268569ab5235463dd0fc88cf04593880c422f1b9", + "B_transport_profile": { + "1": 1072, + "2": 320, + "3": 354, + "4": 84, + "5": 26 + }, + "B_transport_profile_unchanged": true, + "all_queries_available_before_B_event": 507, + "all_sixteen_source_banks": { + "0": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "full_704_column_row_sha256": "84336a6f81560076de13ac266fbaf371e75c88c99d4f1063325d3401e08a6541", + "initial_frame_zero_dirty_columns": 55, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 92 + }, + "1": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "full_704_column_row_sha256": "82424972c25a290a429e680515e88a70ff9794b30b575bb0e67fd75c76c2401e", + "initial_frame_zero_dirty_columns": 50, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 57 + }, + "113": { + "available_before_reordered_B_event": 94, + "frame_basis": [ + 258, + 128, + 64, + 32, + 16, + 10, + 4, + 1 + ], + "full_704_column_row_sha256": "3dbedbe3ab8697526fccda66b18798b22fcfd28090019b9fdcd70e48a63c746f", + "initial_frame_zero_dirty_columns": 68, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 146 + }, + "12": { + "available_before_reordered_B_event": 1846, + "frame_basis": [ + 257, + 129, + 65, + 33, + 16, + 9, + 4, + 3 + ], + "full_704_column_row_sha256": "f174dbe76a175e1c1b1bb224a9dfd194a6246bfbb00d8aee6052558b8799a952", + "initial_frame_zero_dirty_columns": 57, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 205 + }, + "2": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 64, + 32, + 17, + 9, + 4, + 2 + ], + "full_704_column_row_sha256": "cbb035f4592681e6b9447ef3c697e4d1ed437ac52894d44b80e8ebf5bc34fdb5", + "initial_frame_zero_dirty_columns": 54, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 81 + }, + "28": { + "available_before_reordered_B_event": 337, + "frame_basis": [ + 256, + 128, + 72, + 40, + 16, + 4, + 2, + 1 + ], + "full_704_column_row_sha256": "32fc6587e350e2498cc60438bffeb98da61e1c8c275add8b74d88c1d4365946a", + "initial_frame_zero_dirty_columns": 66, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 173 + }, + "3": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "full_704_column_row_sha256": "fee8f00223c58ed55c5525fcfa06250965276a1ce17f826807320ddfa2aecf06", + "initial_frame_zero_dirty_columns": 51, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 224 + }, + "4": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 66, + 32, + 18, + 8, + 4, + 1 + ], + "full_704_column_row_sha256": "8fd234f52e24623f334a7006d1df88149862c8b9e10dfca08645e49671d5bb17", + "initial_frame_zero_dirty_columns": 48, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 11 + }, + "47": { + "available_before_reordered_B_event": 209, + "frame_basis": [ + 256, + 130, + 64, + 34, + 16, + 8, + 4, + 1 + ], + "full_704_column_row_sha256": "90ee1e52461476aa621682566e4cb487b2d00219fb297aff04fe73936f41b84c", + "initial_frame_zero_dirty_columns": 61, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 151 + }, + "5": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "full_704_column_row_sha256": "7870291f50d6a31df3479c03eb56fc459636565d68dac10a71d6e2e56dd4c1ae", + "initial_frame_zero_dirty_columns": 49, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 240 + }, + "57": { + "available_before_reordered_B_event": 507, + "frame_basis": [ + 257, + 128, + 64, + 33, + 16, + 8, + 4, + 2 + ], + "full_704_column_row_sha256": "f1e4a4452f16290a1365e81a8c51ad2c041fe7de0a5f3530f7ebe67ce49baf85", + "initial_frame_zero_dirty_columns": 58, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 133 + }, + "6": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 65, + 33, + 16, + 8, + 4, + 2 + ], + "full_704_column_row_sha256": "f5abfcc79ca082cde85d5ec3148b941c613ce024aac685ada00304395b29a944", + "initial_frame_zero_dirty_columns": 47, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 9 + }, + "65": { + "available_before_reordered_B_event": 1846, + "frame_basis": [ + 320, + 192, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "full_704_column_row_sha256": "ce108523ad7123aa4e43c86b5d02f8cc7ac891b547244e9a42ba4b95cd0d4f23", + "initial_frame_zero_dirty_columns": 62, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 188 + }, + "7": { + "available_before_reordered_B_event": 0, + "frame_basis": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "full_704_column_row_sha256": "53b7d1040c3b8e32bd2dd15aa927d82f75ab5fc743e1f8b0f003fb8401eddcbe", + "initial_frame_zero_dirty_columns": 50, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 4, + "raw_query_coefficient": "1/2", + "register": 256 + }, + "82": { + "available_before_reordered_B_event": 1846, + "frame_basis": [ + 256, + 128, + 65, + 32, + 16, + 8, + 4, + 3 + ], + "full_704_column_row_sha256": "840898e6c1a2784442ac35f7901fe849633b59339a3645da42972e7d5db0cf6e", + "initial_frame_zero_dirty_columns": 65, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 115 + }, + "97": { + "available_before_reordered_B_event": 1846, + "frame_basis": [ + 256, + 129, + 64, + 32, + 16, + 9, + 4, + 2 + ], + "full_704_column_row_sha256": "ec9c788e1581eb143b8bd422f5830b2b963dfeb5cac64371c7f506f1477eaecd", + "initial_frame_zero_dirty_columns": 66, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "other_nonzero_entrance_dirty_columns": 0, + "punctured_X_dirty_columns_reclassified_to_frame_zero": 0, + "raw_query_coefficient": "-1/4", + "register": 126 + } + }, + "chosen_eight_query_sources": [ + { + "a_root": 1, + "available_before_reordered_B_event": 337, + "b_root": 28, + "multiplier_for_query_over_four_a_dot_b": "1/2", + "raw_query_coefficient": "-1/4", + "register": 173 + }, + { + "a_root": 2, + "available_before_reordered_B_event": 209, + "b_root": 47, + "multiplier_for_query_over_four_a_dot_b": "1/2", + "raw_query_coefficient": "-1/4", + "register": 151 + }, + { + "a_root": 3, + "available_before_reordered_B_event": 94, + "b_root": 113, + "multiplier_for_query_over_four_a_dot_b": "-1/2", + "raw_query_coefficient": "-1/4", + "register": 146 + }, + { + "a_root": 4, + "available_before_reordered_B_event": 507, + "b_root": 57, + "multiplier_for_query_over_four_a_dot_b": "-1/2", + "raw_query_coefficient": "-1/4", + "register": 133 + }, + { + "a_root": 12, + "available_before_reordered_B_event": 0, + "b_root": 7, + "multiplier_for_query_over_four_a_dot_b": "1/4", + "raw_query_coefficient": "1/2", + "register": 256 + }, + { + "a_root": 65, + "available_before_reordered_B_event": 0, + "b_root": 0, + "multiplier_for_query_over_four_a_dot_b": "1/4", + "raw_query_coefficient": "1/2", + "register": 92 + }, + { + "a_root": 82, + "available_before_reordered_B_event": 0, + "b_root": 6, + "multiplier_for_query_over_four_a_dot_b": "1/4", + "raw_query_coefficient": "1/2", + "register": 9 + }, + { + "a_root": 97, + "available_before_reordered_B_event": 0, + "b_root": 5, + "multiplier_for_query_over_four_a_dot_b": "-1/4", + "raw_query_coefficient": "1/2", + "register": 240 + } + ], + "failure_controls": { + "missing_actual_B_write": { + "query_root": 113, + "rejected": true, + "removed_original_B_event": 1616 + }, + "wrong_query_coefficient_minus_one_eighth": true + }, + "full_704_column_B_equivalence": true, + "live_ports": 104, + "old_centre_cut_included": false, + "optional_unused_coordinate_gather_omission": { + "old_cleanup_not_reverified": true, + "omitted_A_events": [ + 3409, + 3410, + 3411, + 3412, + 3413, + 3414, + 3415, + 3416, + 3417, + 3418, + 3419, + 3420, + 3421, + 3422, + 3423, + 3424, + 3425, + 3426, + 3427, + 3428, + 3429, + 3430, + 3431, + 3432 + ], + "prefix_plus_B_profile_delta": { + "4": -28 + }, + "queries_and_all_live_Y_rows_unchanged_on_704_columns": true, + "remaining_prefix_frames_legal": true + }, + "per_register_B_event_order_preserved": true, + "physical_registers": 704, + "punctured_selected_positions": [ + 3, + 14, + 21, + 34, + 39, + 61, + 76, + 93 + ], + "queries": { + "113": { + "available_before_reordered_B_event": 94, + "dependency_closure_events": 94, + "frame_basis": [ + 258, + 128, + 64, + 32, + 16, + 10, + 4, + 1 + ], + "full_704_column_row_sha256": "3dbedbe3ab8697526fccda66b18798b22fcfd28090019b9fdcd70e48a63c746f", + "initial_frame_zero_dirty_columns": 68, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "live_Y_already_at_final_frame": 0, + "live_Y_frame_rank_counts": { + "0": 93, + "1": 6, + "2": 3, + "6": 1, + "7": 1 + }, + "multiplier_for_raw_query_over_8": "-1/2", + "nonzero_entrance_dirty_columns": 0, + "original_last_touch": 1616, + "original_last_write": 1616, + "raw_query_coefficient": "-1/4", + "register": 146, + "remaining_B_events": 1752 + }, + "28": { + "available_before_reordered_B_event": 337, + "dependency_closure_events": 128, + "frame_basis": [ + 256, + 128, + 72, + 40, + 16, + 4, + 2, + 1 + ], + "full_704_column_row_sha256": "32fc6587e350e2498cc60438bffeb98da61e1c8c275add8b74d88c1d4365946a", + "initial_frame_zero_dirty_columns": 66, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "live_Y_already_at_final_frame": 0, + "live_Y_frame_rank_counts": { + "0": 60, + "1": 25, + "2": 13, + "6": 3, + "7": 3 + }, + "multiplier_for_raw_query_over_8": "-1/2", + "nonzero_entrance_dirty_columns": 0, + "original_last_touch": 1493, + "original_last_write": 1493, + "raw_query_coefficient": "-1/4", + "register": 173, + "remaining_B_events": 1509 + }, + "47": { + "available_before_reordered_B_event": 209, + "dependency_closure_events": 115, + "frame_basis": [ + 256, + 130, + 64, + 34, + 16, + 8, + 4, + 1 + ], + "full_704_column_row_sha256": "90ee1e52461476aa621682566e4cb487b2d00219fb297aff04fe73936f41b84c", + "initial_frame_zero_dirty_columns": 61, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "live_Y_already_at_final_frame": 0, + "live_Y_frame_rank_counts": { + "0": 79, + "1": 15, + "2": 7, + "6": 1, + "7": 2 + }, + "multiplier_for_raw_query_over_8": "-1/2", + "nonzero_entrance_dirty_columns": 0, + "original_last_touch": 1553, + "original_last_write": 1553, + "raw_query_coefficient": "-1/4", + "register": 151, + "remaining_B_events": 1637 + }, + "57": { + "available_before_reordered_B_event": 507, + "dependency_closure_events": 289, + "frame_basis": [ + 257, + 128, + 64, + 33, + 16, + 8, + 4, + 2 + ], + "full_704_column_row_sha256": "f1e4a4452f16290a1365e81a8c51ad2c041fe7de0a5f3530f7ebe67ce49baf85", + "initial_frame_zero_dirty_columns": 58, + "initial_live_Y_columns": 0, + "live_X_columns": 52, + "live_Y_already_at_final_frame": 0, + "live_Y_frame_rank_counts": { + "0": 34, + "1": 26, + "2": 27, + "4": 8, + "6": 5, + "7": 4 + }, + "multiplier_for_raw_query_over_8": "-1/2", + "nonzero_entrance_dirty_columns": 0, + "original_last_touch": 1840, + "original_last_write": 1840, + "raw_query_coefficient": "-1/4", + "register": 133, + "remaining_B_events": 1339 + } }, - "schema": "p104-single-query-delivery-report-v1", - "scope": "One exact two-query delivery perturbation channel on a modified selected B schedule, with separate and joint invoices; no eight-query program or improved kappa.", + "query_priority": [ + 113, + 47, + 28, + 57 + ], "source_sha256": { "research/complex-block-rank-optimum/inputs/selected.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", "research/frame-sa504/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" - } + }, + "status": "FOUR_ACTUAL_DIRTY_QUERIES_NOT_COMPLETE_SUPPLIER", + "unproved_obligations": [ + "legal delivery after each actual query availability cut", + "complete eight-term scalar compensation and restoration with these carriers", + "native compilation, ownership, simultaneous lifetimes, and complete cost", + "replacement cleanup if the optional old-coordinate gathers are omitted" + ] }, "requested_verified_kappa_gain_achieved": false, "scalar_surgery": { @@ -1022,7 +5401,7 @@ "Establish a complete paid recurrence and a kappa improvement." ] }, - "schema_version": 1, + "schema_version": 3, "selected_kappa_unchanged": "836330098538459/500000000000000000", - "status": "VERIFIED_PARTIAL_CHECKPOINT_NOT_A_SUPPLIER" + "status": "VERIFIED_FINITE_FORWARD_WORD_COST_REJECTED_NOT_A_SUPPLIER" } diff --git a/research/p104-interleaved-search/SOURCES.json b/research/p104-interleaved-search/SOURCES.json index 77065483e8..c080c7166f 100644 --- a/research/p104-interleaved-search/SOURCES.json +++ b/research/p104-interleaved-search/SOURCES.json @@ -103,6 +103,54 @@ "usage": "provenance", "git_blob": "e3cc3e1dfd71eba181cdd402c793f7822efb12bc", "sha256": "eb2b31b6a8b6a93a2bc3c2d0b7092fb0228bee62d1e0a4c15456b2501c03a987" + }, + { + "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/p104-native-channel/notices/PR1862-NOTICE.md", + "usage": "provenance", + "git_blob": "24461eddc12e01eb817fd916debafdadfde8a63e", + "sha256": "d86f31a4c0bafd4271fe0c0e087a7fc1cd72d5b705e3739c4ba3e9241b7ba3f9" + }, + { + "path": "research/p104-native-channel/notices/FRAME-SA504-NOTICE.md", + "usage": "provenance", + "git_blob": "f7a8f861be860edd5a78114c5225dec90effa029", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "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" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/README.md", + "usage": "provenance", + "git_blob": "f205b7132243aedcb2aa85110a44f0c8cd1e4fe1", + "sha256": "da542711a6a3eb01ce1ebdf8f28a748e6195512687f61d003b95ac5ff281a7b2" } ] } diff --git a/research/p104-interleaved-search/TASK.json b/research/p104-interleaved-search/TASK.json index a0103af85c..84ea9f02fd 100644 --- a/research/p104-interleaved-search/TASK.json +++ b/research/p104-interleaved-search/TASK.json @@ -46,33 +46,27 @@ ] }, "scope_status": "changed", - "actual_scope": "Construct a P104 schedule with changed chronological frame access, persistent helper routes or a rebuilt selected-word centre, then require an exact completed moment and actual full supplier/outer verification before a kappa claim.", + "actual_scope": "Construct actual P104 query banks, a complete eight-term dirty-helper forward identity, native lowering, cheaper common-chart schedule, concrete conditional owner-window packing and exact cost checks. Preserve earlier fragments separately.", "scope_change_reason": "User explicitly requests a constructive escape from PR2082, rather than another obstruction. No task reroll. Old frozen timeline and checkpoint-preserving insertion hypotheses must change.", "bottleneck_link": "P104 COPY56 can beat the selected complex budget only if a complete side correction, dirty restoration, native compilation and chronological hosting retain the saving.", "budget_minutes": 60, "stop_rule": "Screen complete optimistic cost first. Investigate the smallest exact constructive candidates; one bounded pivot allowed. Stop construction of a candidate when a proved identity/access or full-cost failure rules it out. Do not present partial local success as the requested verified gain.", "outcome": "partial", - "evidence": "RESULT.json: exact conditional 704-column surgery and a combined two-query delivery channel with two simultaneous private copies; all remaining query formation, six deliveries and global admission are unproved. Requested kappa gain not achieved.", + "evidence": "All eight actual queries and the 735-input forward identity are verified, with 31 dirty fanout helpers. Changing 339 common scalar frames lowers the local invoice. Native operators and 75,888 conditional selected-window owner placements are checked. Actual residual costs erase the small positive ideal-packing ceiling; no admitted global supplier or improved kappa.", "author": "David Arias", "ai_assistance": "Substantial OpenAI Codex assistance and parallel mathematical research; no human review or formal proof assistant.", "open_questions": [ { - "question": "Can a changed source packet prefix form all eight actual queries within the complete budget?", - "why_it_matters": "The current scalar cut is hypothetical and delivery starts with externally supplied queries.", - "first_step": "Compile one non-coordinate query with complete dirty-state replay and register lifetimes; then price all new boundary and excess work.", - "blocked_by": "Existing helper roles are not automatically free to hold new query values." + "question": "Can existing helper lifetimes replace enough of the 31 new fanout helpers to make the completed forward word favorable?", + "why_it_matters": "All eight terms and dirty restoration now have an exact local construction, but even its optimistic cost misses the selected exponent.", + "first_step": "Replace one complete helper lifetime, then replay every input column and the joint frame chronology before repricing.", + "blocked_by": "An existing helper does not retain only query plus initial dirt after its original scalar writes." }, { - "question": "Can the other six delivery terms coexist with the checked two-query channel?", - "why_it_matters": "The existing joint replay covers two of eight terms and already needs overlapping private copies.", - "first_step": "Add one term, replay every chronological frame through tail and cleanup, and recount peak live storage.", - "blocked_by": "No complete legal eight-term chronology or native supplier exists in this checkpoint." - }, - { - "question": "Can a completed local word be hosted and yield a strict new outer certificate?", - "why_it_matters": "A favorable packing ceiling is only a necessary screen, not an achieved exponent.", - "first_step": "After local completion, build actual owner windows, residual children, native recipes, reverse interface and exact moment/outer checks.", - "blocked_by": "Local query construction, six deliveries and workspace invoices remain open." + "question": "Can a cheaper completed local word supply the backward interface and actual whole-call admission?", + "why_it_matters": "Finite forward operator identities do not establish a recursive multiplication supplier.", + "first_step": "Only after a favorable complete local budget, compile the backward block dual, actual owner windows, residual children, precision and moment checks.", + "blocked_by": "The current forward candidate already fails the favorable necessary cost screen." } ], "target": { @@ -81,7 +75,7 @@ "fixed_bit_outer_cap": "0.001730427469823602", "acceptance": "Requested objective not achieved. An improved kappa still requires both supplier interfaces, native/frame/dirty-state/hosting invoices, two exact moment checks and outer constraints." }, - "coordination": "No public Discussion messages or new PR. Local checkpoint only; prior PR2082 remains unchanged.", + "coordination": "No public Discussion messages. One focused research package prepared for a reviewable PR; prior PR2082 remains unchanged.", "optimistic_budget": "P104 retained template m73 W832 N9 has36.444... spare ranks/call before moment effects. Existing terminal corrections costing104 or208 exceed this. New timing must reuse boundary progress or replace original work.", "overlap_check": { "searched_at": "2026-10-14T19:12:58.117087+00:00", @@ -113,5 +107,89 @@ 2107 ], "decision": "Continue changed selected-word frame paths; new fixed-native-path retiming obstruction does not cover these fragments." + }, + "continuation": { + "started_at": "2026-10-14T19:59:32+00:00", + "from_commit": "5d7f99643462cb95701bfccefc8494314cca8e54", + "user_assignment": "Query construction first, then complete six delivery terms and native, hosting, full-cost verification for an actual kappa improvement.", + "priority_revision": 4, + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "changed_premises": [ + "Rebuild or replace coordinate-query gathering paths instead of adding work on top of all eight old gathers.", + "Allow new packet prefix and intermediate-role substitutions, preserving all dirty-input and boundary obligations.", + "Investigate a changed delivery scalar word; the prior frozen B chain searches are not rerun as new evidence." + ], + "target_unchanged": "At least 1% relative kappa gain, with full admission before any exponent claim.", + "new_overlap": { + "searched_at": "2026-10-14T20:02:55+00:00", + "open_prs": 378, + "discussion_records": 788, + "complete_pagination": true, + "related_discussion": 2121, + "distinction": "That delayed-pseudo-input proposal uses full120/PR697 geometry; this continuation rebuilds selectedP112 packet paths onP104." + }, + "bounded_work": "One further approximately 60-minute research session, followed by exact packaging and reproduction. Stop the concrete construction after the complete conditional invoice fails the selected threshold.", + "constructive_result": "All eight decoder terms realized by ordinary dirty fanout helpers seeded through eight private rank-seven descents; exact 735-column identity and joint monotone public frames. Query source formation no longer uses a pure-input oracle.", + "candidate_cost_failure": { + "new_helpers": 31, + "ideal_idle_relative_kappa_upper_percent_without_optional_credit": "-0.92361448", + "ideal_idle_relative_kappa_upper_percent_with_optional_credit": "-0.60625646", + "meaning": "Upper bounds in retained m73 W832 N9 template, not achieved exponents or a universal P104 barrier." + }, + "final_freshness": { + "checked_at": "2026-10-14T20:34:02.811991+00:00", + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "open_prs": 392, + "discussion_records": 804, + "complete_pagination": true, + "new_related_discussions": [ + 2123, + 2131 + ], + "new_related_prs": [ + 2127 + ], + "decision": "Continue distinct selected-P112 source reconstruction and complete fanout word. 2131 starts from the native72-helper G/2 channel; 2127 freezes retained transports. Neither supplies this construction or proves a universal obstruction." + }, + "coalesced_result": { + "changed_scalar_frames": 339, + "ideal_idle_gain_cap_percent_without_credit": "0.05455960", + "ideal_idle_gain_cap_percent_with_conditional_credit": "0.37824205", + "actual_owner_invoice_gain_cap_percent_without_credit": "-1.21466947", + "actual_owner_invoice_gain_cap_percent_with_conditional_credit": "-0.89916793", + "owner_placements": 75888, + "scope": "Exact finite word and conditional selected-window invoice. No global supplier admission or improved kappa; no optimality claim." + }, + "submission_overlap": { + "searched_at": "2026-10-14T21:03:58.826973+00:00", + "open_prs": 403, + "discussion_records": 826, + "complete_pagination": true, + "new_related_prs": [ + 2139, + 2148 + ], + "new_related_discussions": [ + 2144 + ], + "distinction": "PR2139 independently publishes a different 836-register delayed-query word. This package checks a 735-register word and a concrete conditional owner invoice. PR2148 retains original obligations; this construction replaces and coalesces them. Claims are provisional, not scientific inputs." + }, + "validation": { + "checked_at": "2026-10-14T21:08:59.304766+00:00", + "environment": "macOS 27.0.1 (26A434), arm64", + "registered_python": "3.12.14", + "registered_command": "python3 scripts/research_package.py --package research/p104-interleaved-search", + "registered_child_command": "python3 -I -O -B research/p104-interleaved-search/verify.py", + "registered_status": "PASS_REGISTERED_RESEARCH_PACKAGE", + "independent_python": "3.14.7", + "independent_command": "python3 -I -O -B /research/p104-interleaved-search/verify.py", + "source_only_export_files": 36, + "declared_scientific_inputs": 13, + "source_only_export_read_only": true, + "source_only_export_status": "PASS_P104_INTERLEAVED_CHECKPOINT", + "receipt_sha256": "a62468c1254de900aabb8ef7a59df1225941cd849532cb40b6aa71f6d235b0f4", + "unrun": "No admitted global 104-port emitter, backward supplier, route/wrapper proof, precision/reserve account or selected-frontier cold replay. The selected files are unchanged; this concrete invoice already fails the selected cost threshold." + } } } diff --git a/research/p104-interleaved-search/VERIFY.json b/research/p104-interleaved-search/VERIFY.json index ecefdb0816..2a7f2dbffd 100644 --- a/research/p104-interleaved-search/VERIFY.json +++ b/research/p104-interleaved-search/VERIFY.json @@ -11,7 +11,12 @@ "research/complex-local-word-ceiling/ceiling.py", "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", "research/frame-sa504/inputs/hamming/PROTOTYPE.json", - "research/p104-native-channel/inputs/P104-FIXTURE.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", + "research/complex-t16-rare-pattern-exchanges/data/PLAN.json", + "research/complex-t16-rare-pattern-exchanges/data/OWNERS.json.gz", + "research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz" ], "commands": [ { @@ -22,8 +27,8 @@ "-B", "{package}/verify.py" ], - "timeout_seconds": 300, - "checks": "Exact 704-column conditional scalar surgery; separate and joint two-query frame/cleanup replay; arithmetic/profile cross-checks; rejecting coefficient, cleanup, frame and cost-accounting controls. No supplier or improved kappa." + "timeout_seconds": 600, + "checks": "Actual query banks; original and coalesced eight-term 735-column forward identities with all dirty roles restored; all literal native transports, 208 adapters and 4096 private Gaussian columns per word; 75,888 conditional owner-window placements; exact ideal and concrete-idle cost screens; source/profile/normalization bindings and fixed-repair rejecting mutations. No global supplier admission or improved kappa." } ] } diff --git a/research/p104-interleaved-search/actual_queries.py b/research/p104-interleaved-search/actual_queries.py new file mode 100644 index 0000000000..16c2beb4b6 --- /dev/null +++ b/research/p104-interleaved-search/actual_queries.py @@ -0,0 +1,231 @@ +#!/usr/bin/env python3 +"""Exact P104 scalar identity using eight actual source registers. + +Run with Python 3.12+ and the standard library: + python3 -I -B research/p104-interleaved-search/actual_queries.py + +The four non-coordinate queries are punctured Y registers produced by the +reordered retained B prefix. Four old coordinate centres supply the other +queries. The verifier constructs frame-zero compensation and ordered FULL +restoration and checks all 704 initial columns. The intervening scalar scatter +is deliberately unframed: its direct source-to-live-Y additions violate the +native survivor frames. This is not a native word, COPY56 certificate, hosting +proof, cost certificate, or exponent improvement. + +Sources and predecessor attribution are retained in this package's README. +New verifier prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" +from __future__ import annotations + +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def load_module(name): + spec = importlib.util.spec_from_file_location("p104_actual_" + name, HERE / (name + ".py")) + if spec is None or spec.loader is None: + raise ValueError("cannot load local verifier " + name) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def digest(events): + return hashlib.sha256(json.dumps(events, separators=(",", ":")).encode()).hexdigest() + + +def build(): + """Derive the fixed recipe once; failure controls never re-fit its repairs.""" + qc, scalar = load_module("query_construction"), load_module("scalar_surgery") + require = qc.require + inputs = qc.load_inputs() + word, prototype = inputs["word"], inputs["coordinates"] + v, n = word["v"], 2 * word["v"] + word["R"] + selected, specs = qc.geometry(inputs) + roots, terms = scalar.coordinate_data(word, prototype, inputs["fixture"]) + require(roots == selected, "source coordinate bindings disagree") + pairs = scalar.DECODER_ROOT_PAIRS + require(tuple(b for _, b in pairs[:4]) == qc.QUERY_ROOTS, "chosen non-coordinate query basis") + order, availability, _, _ = qc.schedule(word, specs) + B = [word["B"][j] for j in order] + cut = max(availability.values()) + live = [i for i in range(v) if i not in qc.REMOVED] + live_set = set(live) + prefix = word["precondition"] + word["compensation"] + word["A"] + B[:cut] + suffix = B[cut:] + word["tail"] + word["cleanup"] + at_cut = qc.run(qc.identity(n), prefix) + registers, scales, source_records = {}, {}, [] + for aa, bb in pairs: + register = specs[bb]["register"] if bb in specs else word["centers"][bb] + scale = -Q(1, 4) if bb in specs else Q(1, 2) + raw = {i: Q(qc.dot(selected[i], prototype["root_lines"][bb])) for i in live + if qc.dot(selected[i], prototype["root_lines"][bb])} + clean = {i: x for i, x in at_cut[register].items() if i in live_set} + dirt = {i: x for i, x in at_cut[register].items() if i not in live_set} + require(clean == {i: scale * x for i, x in raw.items()}, f"actual query {bb} coefficients") + require(all(i in qc.REMOVED or not word["frames"][word["start"][i]] for i in dirt), + f"actual query {bb} nonzero-entrance dirt") + require(not any(v <= i < 2*v and i-v in live_set for i in dirt), f"query {bb} live initial Y") + registers[bb], scales[bb] = register, scale + source_records.append({ + "a_root": aa, "b_root": bb, "register": register, + "raw_query_coefficient": str(scale), + "full_704_column_row_sha256": qc.row_digest(at_cut[register]), + }) + require(len(set(registers.values())) == 8, "aliased source registers") + + # Invert the actual remaining live-Y transfer to obtain a scalar scatter + # into current live-Y coordinates. This matrix solve does not assign frames. + transfer = qc.run([{i-v: Q(1)} if v <= i < 2*v else {} for i in range(n)], B[cut:]) + decoder = [[Q(qc.dot(selected[t], a), 4*d) / scales[bb] + for (a, b, label, d), (aa, bb) in zip(terms, pairs)] for t in live] + scatter_matrix = scalar.solve( + [[transfer[v+t].get(j, Q(0)) for j in live] for t in live], decoder) + scatter = [] + for i, t in enumerate(live): + for k, (aa, bb) in enumerate(pairs): + coefficient = scatter_matrix[i][k] + if coefficient: + scatter.append(["add", v+t, registers[bb], coefficient.numerator, coefficient.denominator, None]) + require(all(e[1] not in registers.values() for e in scatter), "scatter overwrites source bank") + + def replay(compensation=(), restoration=(), scatter_override=None): + events = (list(compensation) + prefix + + (scatter if scatter_override is None else scatter_override) + suffix + list(restoration)) + return qc.run(qc.identity(n), events) + + uncorrected = replay() + compensation = [] + for t in live: + row = uncorrected[v+t] + require(all(row.get(i, Q(0)) == Q(i == t) for i in live), f"live-X identity before compensation at {t}") + require(row.get(v+t) == 1, "live-Y diagonal before compensation") + for i, coefficient in sorted(row.items()): + if i in (t, v+t): + continue + require(i in qc.REMOVED or not word["frames"][word["start"][i]], "nonzero-entrance compensation source") + require(not (v <= i < 2*v and i-v in live_set), "compensation reads another live Y") + compensation.append(["add", v+t, i, -coefficient.numerator, coefficient.denominator, 0]) + compensated = replay(compensation) + require(all(compensated[v+t] == {v+t: Q(1), t: Q(1)} for t in live), "compensated live-Y identity") + removed_Y = {v+t for t in qc.REMOVED} + require(all(compensated[r] == {r: Q(1)} for r in range(n) + if r not in removed_Y and not (v <= r < 2*v and r-v in live_set)), + "unrestored register outside punctured Y") + + # Restore the four natural query banks before the other four deleted Y + # roles: the latter may still contain the former's initial dirty values. + natural = [specs[q]["register"] for q in qc.QUERY_ROOTS] + restoration_order = natural + sorted(removed_Y - set(natural)) + full = next(i for i, frame in enumerate(word["frames"]) if len(frame) == 9) + restoration, restoration_blocks = [], [] + for register in restoration_order: + require(compensated[register].get(register) == 1, "restoration diagonal") + block = [] + for i, coefficient in sorted(compensated[register].items()): + if i == register: + continue + require(compensated[i] == {i: Q(1)}, "restoration reads an unrestored source") + require(len(word["frames"][word["final"][i]]) == 9 or i in removed_Y, + "restoration source cannot use FULL without extra promotion") + event = ["add", register, i, -coefficient.numerator, coefficient.denominator, full] + block.append(event) + qc.apply(event, compensated) + require(compensated[register] == {register: Q(1)}, "restoration row") + restoration.extend(block) + restoration_blocks.append(block) + require(not scalar.endpoint_failures(compensated, v, live), "constructed full-column endpoint identity") + require(replay(compensation, restoration) == compensated, "fresh replay of fixed recipe") + + # Exhibit the missing native obligation: every direct source chart is too + # large for the relevant live target's endpoint. None is a legal free ADD. + frame_sets = list(map(qc.span, word["frames"])) + current = list(word["start"]) + qc.native_run(prefix, current, frame_sets, word["frames"]) + violations = sum(not frame_sets[current[e[2]]] <= frame_sets[word["final"][e[1]]] + for e in scatter) + require(violations == len(scatter), "unexpected direct-scatter native classification") + require(all(len(word["frames"][word["final"][r]]) == 8 for r in removed_Y), + "punctured-Y restoration boundary rank") + return { + "qc": qc, "scalar": scalar, "inputs": inputs, "word": word, + "n": n, "v": v, "live": live, "prefix": prefix, "suffix": suffix, + "scatter": scatter, "compensation": compensation, "restoration": restoration, + "restoration_blocks": restoration_blocks, "restoration_order": restoration_order, + "sources": source_records, "cut": cut, "B_order": order, + "native_scatter_violations": violations, "replay": replay, + } + + +def verify(): + recipe = build() + qc, scalar, word = recipe["qc"], recipe["scalar"], recipe["word"] + compensation, restoration, scatter = (recipe[name] for name in ("compensation", "restoration", "scatter")) + replay = recipe["replay"] + v, n, live = recipe["v"], recipe["n"], recipe["live"] + controls = {} + altered_scatter = [event.copy() for event in scatter] + altered_scatter[0][3] += altered_scatter[0][4] + experiments = { + "changed_scatter_coefficient": (compensation, restoration, altered_scatter), + "dropped_frame_zero_compensation": (compensation[1:], restoration, scatter), + "dropped_FULL_restoration": (compensation, restoration[:-1], scatter), + "reversed_restoration_block_order": (compensation, + [event for block in reversed(recipe["restoration_blocks"]) for event in block], scatter), + } + for name, (comp, restore, additions) in experiments.items(): + failures = scalar.endpoint_failures(replay(comp, restore, additions), v, live) + qc.require(bool(failures), "fixed-repair failure control was accepted: " + name) + controls[name] = {"rejected": True, "incorrect_endpoint_registers": len(failures)} + result = replay(compensation, restoration) + qc.require(not scalar.endpoint_failures(result, v, live), "final fixed-recipe identity") + input_frames = word["start"].copy() + for t in qc.REMOVED: + input_frames[t] = 0 + qc.require(all(not word["frames"][input_frames[r]] for e in compensation for r in e[1:3]), + "compensation not in common initial frame zero") + return { + "status": "ACTUAL_QUERY_SCALAR_IDENTITY_NOT_NATIVE_DELIVERY", + "source_sha256": {relative: expected for relative, expected in qc.INPUTS.values()}, + "physical_registers": n, + "live_ports": len(live), + "full_704_column_identity": True, + "old_centre_cut_included": False, + "actual_query_cut_before_reordered_B_event": recipe["cut"], + "B_permutation_sha256": digest(recipe["B_order"]), + "sources": recipe["sources"], + "unframed_scalar_scatter": { + "additions": len(scatter), "sha256": digest(scatter), + "source_frame_not_subset_live_target_endpoint": recipe["native_scatter_violations"], + "native_frame_certificate": False, + }, + "initial_frame_zero_compensation": { + "additions": len(compensation), "sha256": digest(compensation), + "source_registers": sorted({e[2] for e in compensation}), + "punctured_X_roles_start_at_frame_zero": list(qc.REMOVED), + }, + "ordered_FULL_restoration": { + "additions": len(restoration), "sha256": digest(restoration), + "register_order": recipe["restoration_order"], + "every_source_already_restored_when_read": True, + "all_eight_punctured_Y_roles_must_reach_FULL": True, + "required_H8_to_FULL_boundary_profile": {"1": 8}, + "boundary_cost_not_a_new_additional_invoice": "These boundaries are part of retaining the eight punctured Y roles; a complete native schedule still must charge them.", + }, + "failure_controls_with_repairs_held_fixed": controls, + "unproved_obligations": [ + "replace the unframed scalar scatter with legal delivery after query availability", + "verify the complete native word and its actual transport profile", + "host all public and private lifetimes and price the complete global supplier", + ], + } + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/coalesced.py b/research/p104-interleaved-search/coalesced.py new file mode 100644 index 0000000000..b89b17164c --- /dev/null +++ b/research/p104-interleaved-search/coalesced.py @@ -0,0 +1,195 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact recharting of the finite 31-helper fanout word. + +The scalar operations and all public boundary frames are fixed. A sparse list +changes common scalar charts; eight private COPY paths keep their original Hb +sources and La seed frames. Every public transport is derived afresh from the +resulting chronological word. No optimizer or numerical solver is trusted. +This finite forward certificate alone is not a multiplication supplier or an +exponent improvement; native lowering and complete hosting are separate bills. +""" +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SPEC = importlib.util.spec_from_file_location('p104_fanout', HERE / 'fanout.py') +F = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(F) +D, QC, S = F.D, F.QC, F.S +FRAMES_SHA256 = '5e3d129ec88b23173f75c3d7187c78e96676f43ef1606166f4eadf888adb7a69' + + +def construct(fault=None, baseline=None): + """Replay the unchanged scalar word with the proposed exact common charts.""" + base = F.construct() if baseline is None else baseline + raw = (HERE / 'COALESCED-FRAMES.json').read_bytes() + D.require(hashlib.sha256(raw).hexdigest() == FRAMES_SHA256, 'coalesced frame input pin') + data = json.loads(raw) + original = base['scalar_operations'] + D.require(F.digest(original) == data['source_scalar_operations_sha256'], 'source scalar word pin') + assignments = {} + for entry in data['changes']: + k, vectors = entry['event'], entry['frame'] + D.require(type(k) is int and 0 <= k < len(original), 'changed event index') + D.require(k not in assignments, 'duplicate changed event') + e = original[k] + D.require(e['kind'] in ('add', 'scale', 'private_copy'), 'changed nonscalar event') + frame = QC.span(vectors) + D.require(F.basis(frame) == vectors, 'noncanonical changed frame') + D.require(frame != QC.span(e['frame']), 'redundant unchanged frame') + assignments[k] = frame + word = QC.load_inputs()['word'] + n = base['report']['public_registers'] + oldn = 2 * word['v'] + word['R'] + live = [i for i in range(word['v']) if i not in QC.REMOVED] + initial = [QC.span(word['frames'][i]) for i in word['start']] + [F.ZERO] * (n-oldn) + for r in QC.REMOVED: + initial[r] = F.ZERO + 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, edges, operations, paths = Counter(), Counter(), [], [], [] + active_path = None + peak, created = 0, 0 + mutated_frame = mutated_coefficient = False + + def transport(r, target, phase, private=False): + old = private_frames[r] if private else current[r] + D.require(target <= old if private else old <= target, 'nonmonotone recharted 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)) + (copy_paid if private else paid)[rank] += 1 + if private: + D.require(active_path is not None, 'private transport outside lifetime') + active_path.append(edge) + if private: + private_frames[r] = target + else: + current[r] = target + + for k, old_event in enumerate(original): + e = dict(old_event) + kind, phase = e['kind'], e['phase'] + if kind == 'transport': + old = old_edges[e['occurrence']] + if old['private']: + r = old['register'] + D.require(private_frames.get(r) == QC.span(old['source_frame']), 'private source frame changed') + transport(r, QC.span(old['target_frame']), phase, True) + continue + if kind == 'private_init': + r = e['register'] + D.require(r >= n and r not in private_frames, 'private lifetime initialization') + private_frames[r], private_rows[r] = QC.span(e['frame']), {} + created += 1 + peak = max(peak, len(private_frames)) + D.require(active_path is None, 'overlapping private paths') + active_path = [] + elif kind == 'private_discard': + r = e['register'] + D.require(private_frames.get(r) == QC.span(e['frame']), 'private discard frame changed') + paths.append(active_path) + active_path = None + del private_frames[r], private_rows[r] + elif kind in ('add', 'scale', 'private_copy'): + rr = e['registers'] + frame = assignments.get(k, QC.span(e['frame'])) + if fault == 'seed_frame' and phase == 'fanout helper seed' and not mutated_frame: + frame, mutated_frame = F.FULL, True + if fault == 'contact_coefficient' and phase == 'fanout contact' and not mutated_coefficient: + e['coefficient'] = str(Q(e['coefficient']) + 1) + mutated_coefficient = True + for r in rr: + if r < n: + transport(r, frame, phase) + else: + D.require(private_frames.get(r) == frame, 'private source or seed common chart changed') + D.require(all((current[r] if r < n else private_frames[r]) == frame for r in rr), + 'scalar operands have different charts') + e['frame'] = F.basis(frame) + coefficient = Q(e['coefficient']) + target = rows[rr[0]] if rr[0] < n else private_rows[rr[0]] + if kind == 'scale': + D.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 kind == 'private_copy': + D.require(rr[0] >= n and not target, 'COPY destination is not cleared private state') + private_rows[rr[0]] = {i:coefficient*x for i,x in source.items()} + else: + S.add_row(target, source, coefficient) + else: + raise D.VerificationError('unknown scalar event: '+kind) + operations.append(e) + for r, target in enumerate(base['final']): + transport(r, target, 'final public boundary') + D.require(not private_frames and not private_rows and active_path is None, 'private lifetime remains live') + D.require(not S.endpoint_failures(rows, word['v'], live), 'full 735-column endpoint identity failed') + D.require(created == 8 and peak == 1 and copy_paid == Counter({7:8}), 'private copy contract changed') + D.require(current == base['final'], 'public endpoint frames changed') + D.require(sum(k*v for k,v in paid.items()) == base['report']['public_rank_mass'], 'public boundary mass changed') + D.require(D.profile(paid) == data['expected_public_profile'], 'recorded coalesced profile changed') + D.require(Counter(e['rank'] for e in edges if not e['private']) == paid, 'transport occurrence recount') + report = dict(schema='p104-coalesced-forward-report-v1', + scope='Finite exact 735-column forward word; complete native, hosting and exponent admission are separate.', + source_scalar_operations_sha256=data['source_scalar_operations_sha256'], + frame_changes_sha256=FRAMES_SHA256, changed_scalar_frames=len(assignments), + scalar_coefficients_and_order_unchanged=True, public_boundary_frames_unchanged=True, + candidate_public_profile=D.profile(paid), private_COPY_profile=D.profile(copy_paid), + public_rank_mass=sum(k*v for k,v in paid.items()), + ordinary_fanout_helpers=n-oldn, public_registers=n, live_ports=len(live), + private_copies_created=created, peak_private_copies=peak, + full_735_column_identity_verified=True, all_public_scalar_adds_common_chart=True, + actual_query_Hb_frames_verified=True, helper_La_seed_frames_verified=True, + complete_public_widths=base['report']['complete_public_widths'], + native_phase_compilation_verified=False, global_hosting_verified=False, + completed_full_multiplication_supplier=False, kappa_improvement_claimed=False, + scalar_operation_word_sha256=F.digest(operations), transport_occurrences_sha256=F.digest(edges)) + return dict(report=report, scalar_operations=operations, transport_edges=edges, + private_paths=paths, final=current, initial=initial, ports=base['ports']) + + +def native_witness(built=None): + built = construct() if built is None else built + edges = [dict(register=str(e['register']), old=e['source_frame'], new=e['target_frame'], + occurrence=e['occurrence'], private=e['private'], rank=e['rank']) for e in built['transport_edges']] + lookup = {e['occurrence']:e for e in edges} + return dict(transports=edges, + private_paths=[[lookup[e['occurrence']] for e in path] for path in built['private_paths']], + scalar_operations=built['scalar_operations'], ports=built['ports'], + scalar_operation_word_sha256=built['report']['scalar_operation_word_sha256'], + transport_occurrences_sha256=built['report']['transport_occurrences_sha256'], + public_profile=built['report']['candidate_public_profile'], private_profile=built['report']['private_COPY_profile']) + + +def verify(): + baseline = F.construct() + built = construct(baseline=baseline) + controls = {} + for fault in ('seed_frame', 'contact_coefficient'): + try: + construct(fault=fault, baseline=baseline) + except ValueError as error: + controls[fault] = str(error) + else: + raise D.VerificationError('coalesced negative control accepted: '+fault) + built['report']['negative_controls'] = controls + return built['report'] + + +if __name__ == '__main__': + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/coalesced_budget.py b/research/p104-interleaved-search/coalesced_budget.py new file mode 100644 index 0000000000..478da67239 --- /dev/null +++ b/research/p104-interleaved-search/coalesced_budget.py @@ -0,0 +1,216 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact necessary cost screens for the coalesced finite P104 word. + +The actual profile comes from coalesced.verify(). Fractional rank-51 idle +packing and the optional old-gather credit are favorable relaxations, not an +owner construction. Both fixed profiles exclude the requested one-percent +kappa gain. A positive ceiling below that target is not an achieved gain. + +Run from any directory, standard library only: + python3 -I -B research/p104-interleaved-search/coalesced_budget.py +""" + +from __future__ import annotations + +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent + + +def module(name): + spec = importlib.util.spec_from_file_location("p104_coalesced_budget_" + name, + HERE / (name + ".py")) + if spec is None or spec.loader is None: + raise ValueError("cannot load " + name) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +B = module("budget") +NB = module("natural_budget") +require = B.require + + +def price(report, hosted_report=None): + engine, word, _, _ = B.load_inputs() + require(report["full_735_column_identity_verified"], "missing complete finite scalar identity") + require(report["ordinary_fanout_helpers"] == 31, "reassess changed helper inventory") + require(report["public_registers"] == 2 * word["v"] + word["R"] + 31 == 735, + "public register inventory differs") + binding_keys = ("source_scalar_operations_sha256", "frame_changes_sha256", + "scalar_operation_word_sha256", "transport_occurrences_sha256") + bindings = {key: report[key] for key in binding_keys} + require(all(isinstance(value, str) and len(value) == 64 and + all(character in "0123456789abcdef" for character in value) + for value in bindings.values()), "missing exact scalar/frame source binding") + require(bindings["frame_changes_sha256"] == hashlib.sha256( + (HERE / "COALESCED-FRAMES.json").read_bytes()).hexdigest(), + "priced report uses a different coalesced frame certificate") + frame_input = json.loads((HERE / "COALESCED-FRAMES.json").read_text()) + require(bindings["source_scalar_operations_sha256"] == frame_input["source_scalar_operations_sha256"], + "priced report uses a different original scalar word") + public = NB.integers(report["candidate_public_profile"]) + private = NB.integers(report["private_COPY_profile"]) + require(private == {7: 8} and B.mass(private) == B.CENTRE == 56, + "actual eight rank-seven private seed invoice") + require(B.profile_json(public) == frame_input["expected_public_profile"], + "priced public invoice differs from the checked frame certificate") + local = B.changed(public, private) + retained = B.retained_profile() + old_width_increase = B.mass(local) - B.mass(retained) - 31 * 9 + require(old_width_increase >= 0, "unexpected existing-public width reduction") + credit, omissions = NB.gather_credit(word) + width = Q(B.FAMILIES, B.STAGES) + total = (B.M - 1) * width + B.CENTRE + selected_a = B.SELECTED_KAPPA / (1 - B.SELECTED_KAPPA) + target_kappa = B.SELECTED_KAPPA * Q(101, 100) + target_a = target_kappa / (1 - target_kappa) + bit_cap = B.BIT_LOWER / (1 + B.BIT_LOWER) + require(engine.max_idle_rank(B.M) == 51, "idle-rank cap changed") + + def describe(name, profile, optional_credit, actual_idle=None): + effective = Counter(profile) + if actual_idle is not None: + effective.update(actual_idle) + require(B.mass(effective) == total, "actual selected-window mass does not cover the complete call") + model = engine.model(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + require(model["local_mass"] + model["idle_mass"] == total, "complete paid mass identity") + if actual_idle is not None: + require(model["idle_mass"] == 0, "unpriced idle mass after explicit owner invoice") + zero = engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, Q(0)) + require(zero[0] <= total / (B.M * width) <= zero[1], "zero-saving coverage moment") + root = engine.ceiling(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + require(engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[0])[1] < 1, + "uncertified lower saving bracket") + require(engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[1])[0] > 1, + "uncertified upper saving bracket") + selected_moment = 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) + require(target_moment[0] > 1, "one-percent target is no longer excluded") + require(target_moment[0] > selected_moment[1], "target moments are not separated and increasing") + complex_cap = root[1] / (1 + root[1]) + cap = min(complex_cap, bit_cap) + require(cap < target_kappa, "one-percent kappa cap is not excluded") + margin = ((1 - target_moment[1]) * width, (1 - target_moment[0]) * width) + return { + "name": name, "status": "SCOPED_ONE_PERCENT_COST_REJECTION", + "optional_gather_credit_assumed": optional_credit, + "idle_invoice": "conditional_selected_window_packing" if actual_idle is not None else "fractional_rank51_relaxation", + "local_profile": B.profile_json(profile), + "finite_word_local_rank_mass": str(B.mass(profile)), + "explicit_per_call_idle_rank_mass": str(B.mass(actual_idle)) if actual_idle is not None else None, + "model": {key: str(value) for key, value in model.items()}, + "complex_saving_root_interval": B.interval(root), + "complex_kappa_upper_bound": str(complex_cap), + "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_moment), + "selected_kappa_excluded": selected_moment[0] > 1, + "moment_at_one_percent_target": B.interval(target_moment), + "per_call_margin_at_one_percent_target": B.interval(margin), + "one_percent_target_excluded": True, + "positive_upper_bound_is_not_an_achieved_gain": True, + } + + scenarios = [describe("actual_coalesced_fanout", local, False), + describe("same_with_optional_old_four_gather_credit", + B.changed(local, credit), True)] + require(scenarios[0]["model"]["local_mass"] == scenarios[1]["model"]["local_mass"], + "optional credit changes paid rank mass") + hosted = None + if hosted_report is not None: + require(hosted_report["total_calls"] == 144, "selected T16 call count changed") + require(hosted_report["ordinary_helpers"] == 527 and + hosted_report["assigned_roles"] == 144 * 527, "complete ordinary owner inventory") + require(not hosted_report["global_emitter_admitted"], "conditional packing promoted to global admission") + removed = sorted(module("query_construction").REMOVED) + ordinary_registers = (list(range(224, 704)) + removed + + [112 + r for r in removed] + list(range(704, 735))) + require(hosted_report["actual_ordinary_registers"] == ordinary_registers, + "selected-window invoice uses different ordinary roles") + widths = [report["complete_public_widths"][r] for r in ordinary_registers] + widths_digest = hashlib.sha256(json.dumps(widths, sort_keys=True, + separators=(",", ":")).encode()).hexdigest() + require(widths_digest == hosted_report["actual_ordinary_widths_sha256"], + "selected-window invoice uses different coalesced boundary widths") + idle_global = NB.integers(hosted_report["remaining_idle_profile"]) + require(all(0 < rank <= 51 and count > 0 for rank, count in idle_global.items()), + "invalid explicit idle-child profile") + require(B.mass(idle_global) == hosted_report["idle_rank_mass"], "global idle rank mass differs") + idle = {rank: Q(count, 144) for rank, count in idle_global.items()} + require(B.mass(idle) == Q(hosted_report["per_call_idle_rank_mass"]), "per-call idle mass differs") + require(B.mass(local) + B.mass(idle) == total, "actual local plus idle coverage mismatch") + hosted_scenarios = [describe("coalesced_word_with_selected_window_invoice", local, False, idle), + describe("same_with_conditional_old_four_gather_credit", + B.changed(local, credit), True, idle)] + require(all(item["selected_kappa_excluded"] for item in hosted_scenarios), + "actual selected-window invoice is no longer a selected-kappa rejection") + hosted = { + "scope": "Conditional complete-window owner invoice; no global emitter, backward supplier, or recursive admission is asserted.", + "total_calls": 144, "ordinary_helpers": 527, "assigned_roles": 144 * 527, + "sources": hosted_report["sources"], + "actual_ordinary_widths_sha256": widths_digest, + "assignment_sha256": hosted_report["assignment_sha256"], + "global_remaining_idle_profile": B.profile_json(idle_global), + "global_idle_rank_mass": B.mass(idle_global), + "per_call_idle_rank_mass": str(B.mass(idle)), + "exact_actual_local_plus_idle_mass_binding": True, + "both_selected_threshold_moments_strictly_above_one": True, + "scenarios": hosted_scenarios, + "global_emitter_admitted": False, + } + return { + "status": "SCOPED_ONE_PERCENT_COST_REJECTION", + "scope": "The two stated fixed-profile relaxations exclude a one-percent kappa gain under the retained m73/P104/COPY56 model. They do not establish a positive gain or exclude other words, profile changes, coverage laws, or outer recipes.", + "sources": [{"path": path, "sha256": digest} for path, digest in B.INPUTS.values()], + "actual_profile_source": "coalesced.verify()", + "actual_scalar_and_native_frame_binding": bindings, + "selected_kappa": str(B.SELECTED_KAPPA), + "one_percent_target_kappa": str(target_kappa), + "necessary_complex_saving_for_target": str(target_a), + "actual_public_profile": B.profile_json(public), + "actual_private_COPY_profile": B.profile_json(private), + "ordinary_fanout_helpers": 31, + "new_helper_rank_mass": 31 * 9, + "existing_public_lifetime_width_increase": old_width_increase, + "hypotheses": [ + "Keep m73, nine stages, four pairs, 104 live ports, and COPY rank56.", + "Use the actual complete public transport profile and all eight private rank-seven seeds.", + "Allow every remaining unit of paid mass to be a fractional rank51 idle child, without constructing such owners.", + "For the second scenario only, grant the old four-unused-gather profile credit without assembling it with the changed charts and cleanup.", + "Use the retained necessary complex and fixed-bit balanced-transfer inequalities.", + ], + "optional_old_gather_credit": {"profile_delta": B.profile_json(credit), + "A_event_indices": omissions, + "joint_coalesced_word_verified": False}, + "scenarios": scenarios, + "conditional_selected_window_invoice": hosted, + "controls": {"actual_full_735_column_receipt_required": True, + "eight_private_rank7_children_charged": True, + "complete_mass_and_zero_moment_identities": True, + "both_exact_root_brackets_certified": True, + "both_one_percent_threshold_moments_strictly_above_one": True}, + "global_owner_packing_constructed": False, + "new_kappa_gain_certified": False, + } + + +def verify(coalesced_report=None, hosted_report=None): + if coalesced_report is None: + coalesced_report = module("coalesced").verify() + if hosted_report is None: + hosted_report = module("hosting").verify(coalesced_report) + return price(coalesced_report, hosted_report) + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/fanout.py b/research/p104-interleaved-search/fanout.py new file mode 100644 index 0000000000..66472a83f3 --- /dev/null +++ b/research/p104-interleaved-search/fanout.py @@ -0,0 +1,349 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Eight actual-query terms with 31 dirty fanout helpers: finite forward word. + +The selected centre cut is replaced. Exact rational replay checks every one of +735 independent public input columns, common-chart scalar operations, monotone +public transports, and eight literal rank-seven owned-copy paths. A copy seeds +ordinary dirty helpers at L_a; those helpers ascend to public contact charts, +then are restored at FULL. Public dirt is compensated at frame zero. + +This is not a multiplication supplier or a kappa improvement. Native lowering, +global ownership, the complete wrapper, and bit-side admission are separate. +The accompanying cost screen rejects this construction even optimistically. +Contact proposals are finite data, not an asserted search optimum. +""" +from collections import Counter, defaultdict +from copy import deepcopy +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PLANS_SHA256 = '0c2ae264694bbe7c15b9261ba8adf68c9552849effd423894713c68ad23d28ca' + + +def module(name): + spec = importlib.util.spec_from_file_location(name, HERE / (name + '.py')) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +QC, S, D = module('query_construction'), module('scalar_surgery'), module('delivery') +require, FULL, ZERO = D.require, D.FULL, frozenset({0}) + + +def basis(frame): + values, generated = [], ZERO + for x in sorted(frame): + if x not in generated: + values.append(x) + generated = D.join(generated, frozenset({0, x})) + require(generated == frame, 'frame is not a binary subspace') + return values + + +def digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +class NeedHelper(Exception): + """The deterministic cumulative-frame allocator needs another dirty role.""" + + +def construct(fault=None, fixed=None): + """Derive the forward word. Mutations consume the baseline's fixed repairs.""" + inputs = QC.load_inputs() + word, prototype = inputs['word'], inputs['coordinates'] + raw = (HERE / 'FANOUT-PLANS.json').read_bytes() + require(hashlib.sha256(raw).hexdigest() == PLANS_SHA256, 'fanout plans byte pin') + plans = json.loads(raw)['plans'] + require([tuple(p['pair']) for p in plans] == list(S.DECODER_ROOT_PAIRS), 'eight decoder pairs') + v, oldn = word['v'], 2 * word['v'] + word['R'] + _, specs = QC.geometry(inputs) + order, availability, _, _ = QC.schedule(word, specs) + bword, cut = [word['B'][j] for j in order], max(availability.values()) + require(cut == 507, 'actual-query common availability cut') + live = [i for i in range(v) if i not in QC.REMOVED] + live_y = {v + t for t in live} + frames = [QC.span(f) for f in word['frames']] + labels = {i: x ^ (43 if (x & 43).bit_count() % 2 else 0) + for i, x in enumerate(prototype['binary_ports'])} + helpers, contacts = [], defaultdict(list) + for p in plans: + a, b = p['pair'] + qreg = specs[b]['register'] if b in specs else word['centers'][b] + qscale = -Q(1, 4) if b in specs else Q(1, 2) + lam = Q(1, 4 * S.dot(prototype['root_lines'][a], prototype['root_lines'][b])) / qscale + offset = len(helpers) + require(type(p['helpers']) is int and p['helpers'] > 0, 'helper allocation') + for _ in range(p['helpers']): + helpers.append(dict(a=a, b=b, source=qreg, lam=lam, line=QC.span([labels[a]]))) + for c in p['contacts']: + require(cut <= c['event'] < len(bword), 'contact before actual source availability') + require(0 <= c['register'] < oldn and 0 <= c['helper'] < p['helpers'], 'contact role') + require(bool(Q(c['coefficient'])), 'zero contact') + contacts[c['event']].append(dict(c, helper=offset + c['helper'])) + require(len(helpers) == 28, 'initial proposal allocation') + cap = [frames[word['final'][r]] if r in live_y else FULL for r in range(oldn)] + caps = [] + for event in reversed(bword): + rr = QC.touched(event) + both = cap[rr[0]] + for r in rr: + both &= cap[r] + for r in rr: + cap[r] = both + caps.append(cap.copy()) + caps.reverse() + + def run(compensation=(), repairs=None, mutation=None): + n = oldn + len(helpers) + rows = QC.identity(n) + current = [frames[i] for i in word['start']] + [ZERO] * len(helpers) + for t in QC.REMOVED: + current[t] = ZERO + paid, copy_paid, edges, events = Counter(), Counter(), [], [] + response = [{} for _ in range(oldn)] + qrows, query_records, cleanup, ghost_restores = {}, [], [], [] + private_paths, private_rows, private_frames = [], {}, {} + routed_contacts = [] + + 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 literal transport') + if not private and r in live_y: + require(target <= frames[word['final'][r]], 'live Y endpoint frame exceeded') + rank = abs(D.dimension(target) - D.dimension(old)) + if rank: + (copy_paid if private else paid)[rank] += 1 + edge = dict(occurrence=len(edges), register=r, source_frame=basis(old), + target_frame=basis(target), rank=rank, private=private, phase=phase) + edges.append(edge) + events.append(dict(kind='transport', occurrence=edge['occurrence'], phase=phase)) + if private: + private_frames[r] = target + else: + current[r] = target + + def scalar_add(target, source, coefficient, phase, private_source=False): + source_frame = private_frames.get(source) if private_source else current[source] + require(source_frame is not None and current[target] == source_frame, + 'scalar ADD crosses charts or reads an uninitialized private copy') + source_row = private_rows.get(source) if private_source else rows[source] + require(source_row is not None, 'private COPY read without initialization') + S.add_row(rows[target], source_row, coefficient) + events.append(dict(kind='add', registers=[target, source], coefficient=str(coefficient), + frame=basis(current[target]), phase=phase)) + + def apply(event, phase): + rr, frame = QC.touched(event), frames[event[-1]] + for r in rr: + frame = D.join(frame, current[r]) + for r in rr: + transport(r, frame, phase) + if event[0] == 'add': + coefficient = Q(event[3], event[4]) + scalar_add(event[1], event[2], coefficient, phase) + S.add_row(response[event[1]], response[event[2]] if event[2] < oldn else {}, coefficient) + else: + require(event[0] == 'scale' and bool(Q(event[2], event[3])), 'invalid scale') + QC.apply(event, rows) + response[event[1]] = {j: x * Q(event[2], event[3]) for j, x in response[event[1]].items()} + events.append(dict(kind='scale', registers=[event[1]], coefficient=str(Q(event[2], event[3])), + frame=basis(frame), phase=phase)) + + for phase, sequence in [('entry compensation', compensation), ('precondition', word['precondition']), + ('old compensation', word['compensation']), ('A', word['A']), + ('B query prefix', bword[:cut])]: + for event in sequence: + apply(event, phase) + # At the common cut, seed one decoder term at a time. Each private copy + # is initialized, used at Hb, transported once to La, read only at La, + # and discarded before the next owned copy is created: peak is one. + for term, (a, b) in enumerate(S.DECODER_ROOT_PAIRS): + js = [j for j, h in enumerate(helpers) if (h['a'], h['b']) == (a, b)] + meta = helpers[js[0]] + source, line = meta['source'], meta['line'] + hb = frozenset(x for x in range(512) if not (x & labels[b]).bit_count() % 2) + require(current[source] == hb, 'actual query source is not in Hb') + require(line <= hb and (D.dimension(hb), D.dimension(line)) == (8, 1), 'rank-seven copy endpoints') + qrows.setdefault(source, rows[source].copy()) + query_records.append(dict(pair=[a,b], source=source, frame=basis(hb), coefficient=str(meta['lam']), + scalar_row_sha256=QC.row_digest(rows[source]), fanout_helpers=js)) + owned = n + term + if not (mutation == 'missing_private_initialization' and term == 0): + private_rows[owned], private_frames[owned] = {}, hb + events.append(dict(kind='private_init', register=owned, frame=basis(hb), phase='owned query copy')) + require(private_frames[owned] == current[source], 'COPY source chart mismatch') + private_rows[owned] = rows[source].copy() + events.append(dict(kind='private_copy', registers=[owned,source], coefficient='1', frame=basis(hb), phase='owned query copy')) + coefficient = meta['lam'] + (1 if mutation == 'query_coefficient' and term == 0 else 0) + private_rows[owned] = {j: coefficient*x for j,x in private_rows[owned].items()} + events.append(dict(kind='scale', registers=[owned], coefficient=str(coefficient), frame=basis(hb), phase='owned query scaling')) + transport(owned, line, 'owned Hb to La', True) + private_paths.append([edges[-1]]) + for j in js: + transport(oldn+j, line, 'fanout helper entrance') + scalar_add(oldn+j, owned, Q(1), 'fanout helper seed', True) + events.append(dict(kind='private_discard', register=owned, frame=basis(line), phase='owned copy end')) + del private_rows[owned], private_frames[owned] + require(not private_rows and not private_frames, 'private copy left live') + for k in range(cut, len(bword)): + for c in sorted(contacts[k], key=lambda z: (int(z['lower']).bit_count(), z['helper'], z['register'])): + r, term = c['register'], helpers[c['helper']]['a'] + cap_here = caps[k][r] + require(current[r] <= cap_here, 'public reader already exceeds future endpoint cap') + eligible = [j for j,h in enumerate(helpers) if h['a'] == term and current[oldn+j] <= cap_here] + if not eligible: + raise NeedHelper(c['helper']) + j = max(eligible, key=lambda z: D.dimension(current[oldn+z])) + helper = oldn+j + frame = D.join(current[helper], current[r]) + require(frame <= cap_here, 'cumulative helper frame exceeds contact cap') + transport(helper, frame, 'fanout contact') + transport(r, frame, 'fanout contact') + scalar_add(r, helper, Q(c['coefficient']), 'fanout contact') + response[r][j] = response[r].get(j, Q(0)) + Q(c['coefficient']) + routed_contacts.append(dict(event=k, target=r, helper=j, coefficient=c['coefficient'], frame=basis(frame))) + apply(bword[k], 'B suffix') + for event in word['tail']: + apply(event, 'tail') + for r, q in qrows.items(): + require(rows[r] == q, 'actual query bank changed before helper restoration') + for j in range(len(helpers)): + transport(oldn+j, FULL, 'fanout helper endpoint') + if repairs is None: + for r, rr in enumerate(response): + if r not in live_y: + cleanup.extend([r, oldn+j, str(-c)] for j,c in rr.items() if c) + else: + cleanup = deepcopy(repairs['cleanup']) + applied_cleanup = cleanup[1:] if mutation == 'missing_response_cleanup' else cleanup + for r,h,c in applied_cleanup: + transport(r, FULL, 'response cleanup') + scalar_add(r,h,Q(c),'response cleanup') + for j,h in enumerate(helpers): + transport(h['source'], FULL, 'query bank endpoint') + scalar_add(oldn+j,h['source'],-h['lam'],'helper restoration') + require(rows[oldn+j] == {oldn+j:Q(1)}, 'dirty helper not restored') + for event in word['cleanup']: + apply(event, 'old cleanup') + if repairs is None: + for t in QC.REMOVED: + r = v+t + transport(r,FULL,'ghost Y endpoint') + require(rows[r].get(r) == 1,'ghost Y diagonal changed') + for i,c in list(rows[r].items()): + if i == r: + continue + require(rows[i] == {i:Q(1)}, 'ghost restoration reads a nonidentity source') + transport(i,FULL,'ghost restoration') + scalar_add(r,i,-c,'ghost restoration') + ghost_restores.append([r,i,str(-c)]) + else: + ghost_restores = deepcopy(repairs['ghost_restoration']) + for r,i,c in ghost_restores: + transport(r,FULL,'ghost Y endpoint') + require(rows[i] == {i:Q(1)}, 'fixed ghost restoration reads a nonidentity source') + transport(i,FULL,'ghost restoration') + scalar_add(r,i,Q(c),'ghost restoration') + for r in range(oldn): + endpoint = FULL if v <= r < 2*v and r-v in QC.REMOVED else frames[word['final'][r]] + transport(r,D.join(current[r],endpoint),'final public boundary') + return dict(rows=rows, final=current, paid=paid, copy_paid=copy_paid, transport_edges=edges, + scalar_operations=events, private_paths=private_paths, query_records=query_records, + cleanup=cleanup, ghost_restoration=ghost_restores, contacts=routed_contacts) + + clones = [] + if fixed is None: + while True: + try: + preliminary = run() + break + except NeedHelper as missing: + helpers.append(helpers[missing.args[0]].copy()) + clones.append([helpers[-1]['a'],helpers[-1]['b']]) + require(len(helpers) <= 31, 'bounded allocator exceeded recorded helper stock') + require(clones == [[3,113],[2,47],[4,57]], 'deterministic helper cloning changed') + compensation = [] + for t in live: + row = preliminary['rows'][v+t] + require(all(row.get(i,0) == Q(i==t) for i in live), 'wrong initial-live-X transfer') + for i,c in row.items(): + if i in (t,v+t): + continue + require(i >= oldn or i in QC.REMOVED or frames[word['start'][i]] == ZERO, + 'dirty coefficient cannot be compensated at frame zero') + compensation.append(['add',v+t,i,-c.numerator,c.denominator,0]) + repairs = dict(cleanup=preliminary['cleanup'], ghost_restoration=preliminary['ghost_restoration']) + else: + helpers = deepcopy(fixed['helpers']) + compensation, repairs, clones = deepcopy(fixed['compensation']), deepcopy(fixed['repairs']), fixed['clones'] + applied_compensation = compensation[1:] if fault == 'missing_entry_compensation' else compensation + built = run(applied_compensation, repairs, fault) + require(len(helpers) == 31 and len(built['rows']) == 735, 'exact public stock') + require(not S.endpoint_failures(built['rows'],v,live),'full 735-column endpoint identity failed') + require(built['copy_paid'] == Counter({7:8}), 'eight complete rank-seven owned copies') + public_recount = Counter(e['rank'] for e in built['transport_edges'] if not e['private']) + require(public_recount == built['paid'], 'public transport occurrence invoice mismatch') + expected = {'1':2611,'2':514,'3':378,'4':132,'5':81,'6':15,'7':6} + require(D.profile(built['paid']) == expected,'recorded public invoice changed') + require(len(built['private_paths']) == 8, 'missing private path') + final_widths = [D.dimension(built['final'][r])-D.dimension(ZERO if r >= oldn or r in QC.REMOVED else frames[word['start'][r]]) + for r in range(735)] + # Added public helpers start at ZERO, outside the original start array. + report = dict(schema='p104-fanout-forward-report-v1', + scope='Finite forward 735-column identity and literal frame word; not a global supplier or exponent improvement.', + sources={relative:sha for relative,sha in QC.INPUTS.values()}, plans_sha256=PLANS_SHA256, + ordinary_fanout_helpers=31, public_registers=735, live_ports=104, + private_copies_created=8, peak_private_copies=1, source_availability_B_prefix=cut, + query_sources=built['query_records'], deterministic_clones=clones, + contact_count=len(built['contacts']), entry_compensation_additions=len(compensation), + response_cleanup_additions=len(repairs['cleanup']), ghost_restoration_additions=len(repairs['ghost_restoration']), + candidate_public_profile=D.profile(built['paid']), private_COPY_profile=D.profile(built['copy_paid']), + public_rank_mass=sum(k*n for k,n in built['paid'].items()), + full_735_column_identity_verified=True, all_new_helpers_restored=True, + compensation_only_initial_frame_zero=True, all_public_scalar_adds_common_chart=True, + actual_query_Hb_frames_verified=True, complete_public_widths=final_widths, + contact_schedule_sha256=digest(built['contacts']), scalar_operation_word_sha256=digest(built['scalar_operations']), + transport_occurrences_sha256=digest(built['transport_edges']), + native_phase_compilation_verified=False, global_hosting_verified=False, + completed_full_multiplication_supplier=False, kappa_improvement_claimed=False) + built.update(report=report, fixed=dict(helpers=helpers, compensation=compensation, repairs=repairs, clones=clones), + ports=[word['ports'][t] for t in live]) + return built + + +def native_witness(built=None): + built = construct() if built is None else built + edges = [dict(register=str(e['register']), old=e['source_frame'], new=e['target_frame'], + occurrence=e['occurrence'], private=e['private'], rank=e['rank']) for e in built['transport_edges']] + by_occurrence = {e['occurrence']:e for e in edges} + return dict(transports=edges, + private_paths=[[by_occurrence[e['occurrence']] for e in path] for path in built['private_paths']], + scalar_operations=built['scalar_operations'], ports=built['ports'], + scalar_operation_word_sha256=digest(built['scalar_operations']), + transport_occurrences_sha256=digest(built['transport_edges']), + public_profile=built['report']['candidate_public_profile'], private_profile=built['report']['private_COPY_profile']) + + +def verify(): + built = construct() + controls = {} + for fault in ('query_coefficient','missing_private_initialization','missing_response_cleanup','missing_entry_compensation'): + try: + construct(fault=fault,fixed=built['fixed']) + except (ValueError,NeedHelper) as error: + controls[fault] = str(error) + else: + raise D.VerificationError('fixed-repair negative control accepted: '+fault) + built['report']['negative_controls_repairs_held_fixed'] = controls + return built['report'] + + +if __name__ == '__main__': + print(json.dumps(verify(),indent=2,sort_keys=True)) diff --git a/research/p104-interleaved-search/fanout_budget.py b/research/p104-interleaved-search/fanout_budget.py new file mode 100644 index 0000000000..635af8b1b1 --- /dev/null +++ b/research/p104-interleaved-search/fanout_budget.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact cost rejection of the complete finite P104 fanout profile. + +Uses the actual public and private invoices returned by fanout.verify(), the +pinned selected result, and the attributed exact interval engine in budget.py. +Even fractional rank-51 residual packing fails to improve the selected kappa. +The optional old-gather credit is a further favorable, unassembled relaxation. +No global owner construction is needed for this model-specific cost rejection. + +Run from any directory, standard library only: + python3 -I -B research/p104-interleaved-search/fanout_budget.py +""" + +from __future__ import annotations + +from fractions import Fraction as Q +import importlib.util +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent + + +def module(name): + spec = importlib.util.spec_from_file_location("p104_fanout_budget_" + name, + HERE / (name + ".py")) + if spec is None or spec.loader is None: + raise ValueError("cannot load " + name) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +B = module("budget") +NB = module("natural_budget") +require = B.require + + +def price(fanout_report): + """Price a verified finite-word receipt, without promoting it to a supplier.""" + engine, word, _, stock = B.load_inputs() + require(fanout_report["full_735_column_identity_verified"], "missing complete scalar identity") + require(fanout_report["ordinary_fanout_helpers"] == 31, "reassess changed helper count") + require(fanout_report["public_registers"] == 2 * word["v"] + word["R"] + 31 == 735, + "public register and helper inventory differ") + public = NB.integers(fanout_report["candidate_public_profile"]) + private = NB.integers(fanout_report["private_COPY_profile"]) + require(private == {7: 8}, "eight actual rank-seven private seeds required") + require(B.mass(private) == B.CENTRE == 56, "private COPY coverage mass") + total_profile = B.changed(public, private) + retained = B.retained_profile() + helper_mass = 9 * fanout_report["ordinary_fanout_helpers"] + public_width_increase = B.mass(total_profile) - B.mass(retained) - helper_mass + require(public_width_increase >= 0, "unexpected public lifetime reduction") + credit, omissions = NB.gather_credit(word) + width = Q(B.FAMILIES, B.STAGES) + coverage_mass = (B.M - 1) * width + B.CENTRE + selected_a = B.SELECTED_KAPPA / (1 - B.SELECTED_KAPPA) + target_kappa = B.SELECTED_KAPPA * Q(101, 100) + target_a = target_kappa / (1 - target_kappa) + bit_cap = B.BIT_LOWER / (1 + B.BIT_LOWER) + require(engine.max_idle_rank(B.M) == 51, "outer idle-rank cap changed") + + def describe(name, profile, with_credit): + model = engine.model(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + require(model["local_mass"] + model["idle_mass"] == coverage_mass, + "complete paid mass identity") + zero = engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, Q(0)) + require(zero[0] <= coverage_mass / (B.M * width) <= zero[1], + "zero-saving coverage moment") + root = engine.ceiling(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + require(engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[0])[1] < 1, + "uncertified lower saving bracket") + require(engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[1])[0] > 1, + "uncertified upper saving bracket") + selected_moment = engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, selected_a) + target_moment = engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, target_a) + require(selected_moment[0] > 1, "cost rejection no longer excludes selected kappa") + require(target_moment[0] > selected_moment[1], "saving moment is not separated and increasing") + complex_cap = root[1] / (1 + root[1]) + cap = min(complex_cap, bit_cap) + require(cap < B.SELECTED_KAPPA, "profile is no longer a selected-kappa rejection") + margin = ((1 - target_moment[1]) * width, (1 - target_moment[0]) * width) + return { + "name": name, + "status": "SCOPED_COST_REJECTION", + "optional_gather_credit_assumed": with_credit, + "local_profile": B.profile_json(profile), + "model": {key: str(value) for key, value in model.items()}, + "complex_saving_root_interval": B.interval(root), + "complex_kappa_upper_bound": str(complex_cap), + "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_moment), + "moment_at_one_percent_target": B.interval(target_moment), + "per_call_margin_at_one_percent_target": B.interval(margin), + "selected_kappa_excluded": True, + } + + scenarios = [describe("actual_31_helper_fanout", total_profile, False), + describe("same_with_optional_four_unused_gather_credit", + B.changed(total_profile, credit), True)] + require(scenarios[0]["model"]["local_mass"] == scenarios[1]["model"]["local_mass"], + "optional gather credit must preserve rank mass") + return { + "status": "SCOPED_COST_REJECTION", + "scope": "This actual finite-word profile cannot improve selected kappa under the retained m73/P104/COPY56 hosted coverage and balanced-transfer model. Other words, coverage laws, and outer recipes are not excluded.", + "sources": [{"path": path, "sha256": digest} for path, digest in B.INPUTS.values()], + "actual_profile_source": "fanout.verify()", + "selected_kappa": str(B.SELECTED_KAPPA), + "selected_complex_saving_threshold": str(selected_a), + "one_percent_target_kappa": str(target_kappa), + "one_percent_complex_saving_threshold": str(target_a), + "actual_public_profile": B.profile_json(public), + "actual_private_COPY_profile": B.profile_json(private), + "ordinary_fanout_helpers": fanout_report["ordinary_fanout_helpers"], + "new_helper_rank_mass": helper_mass, + "existing_public_lifetime_width_increase": public_width_increase, + "retained_16_local_profile": B.profile_json(retained), + "hypotheses": [ + "Keep m73, nine stages, four pairs, 104 live ports, and COPY rank56.", + "Retain the complete actual public and private transport histogram; no omitted rank-seven delivery remains.", + "All remaining paid mass is allowed to form fractional rank51 idle children, regardless of whether such a packing exists.", + "The second scenario additionally grants the old four-unused-gather credit without proving its joint cleanup compatibility.", + "Use the retained necessary complex and fixed-bit balanced-transfer inequalities.", + ], + "optional_old_gather_credit": {"profile_delta": B.profile_json(credit), + "A_event_indices": omissions, + "joint_fanout_cleanup_verified": False}, + "scenarios": scenarios, + "controls": {"complete_mass_and_zero_moment_identities": True, + "eight_private_rank7_children_charged": True, + "both_exact_root_brackets_certified": True, + "both_selected_threshold_moments_strictly_above_one": True, + "both_kappa_caps_strictly_below_selected": True}, + "selected_private_centre_stock": stock, + "global_hosting_constructed_by_this_module": False, + "new_kappa_gain_certified": False, + } + + +def verify(fanout_report=None): + if fanout_report is None: + fanout_report = module("fanout").verify() + return price(fanout_report) + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/hosting.py b/research/p104-interleaved-search/hosting.py new file mode 100644 index 0000000000..6bf0615575 --- /dev/null +++ b/research/p104-interleaved-search/hosting.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Concrete complete-width owner packing in inherited selected idle windows. + +This checks 527 ordinary roles in each of 144 calls on retained P104 data +families. It does not emit or admit a new 104-port global wrapper. The stored +T8 data-owner routes are lifted into two disjoint replica banks solely to +check active-data exclusion. Native wrapper maps, the restricted data phases, +backward supplier and recursive accounting remain separate obligations. + +Schedule and frozen owner inputs: Rohan Arun's T16 rare-pattern exchanges, +following jeremykothe2's PR1087, FanPUYen's PR858 and the retained lineage. +Their source archive and notices are reused unchanged, not reauthored here. +""" +from collections import Counter, defaultdict +import gzip +import hashlib +import importlib.util +import io +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = 'research/complex-t16-rare-pattern-exchanges/' +INPUTS = { + 'plan': (BASE+'data/PLAN.json','7bd786ba8e66408f02aa9ef446eaf20c1bfe981ea2e4dd1e5a929f0aa7767bc0'), + 'owners': (BASE+'data/OWNERS.json.gz','87902c528dfab7d503dcf8a784260e3ab6fb7424c418a1820f7261f25be7b6bc'), + 'spec': (BASE+'data/SPEC.json','8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d'), + 'archive': (BASE+'upstream1087.tar.gz','d4acf04daef85d4514f80ec5fcd2492d0c60e5d6c49fa71b3e6523f8db2dea86'), +} + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def module(name): + spec = importlib.util.spec_from_file_location('p104_hosting_'+name,HERE/(name+'.py')) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +def digest(value): + return hashlib.sha256(json.dumps(value,sort_keys=True,separators=(',',':')).encode()).hexdigest() + + +def verify(fanout_report=None): + qc = module('query_construction') + word = qc.load_inputs()['word'] + if fanout_report is None: + fanout_report = module('fanout').verify() + require(fanout_report['full_735_column_identity_verified'], 'missing complete forward receipt') + require(fanout_report['ordinary_fanout_helpers'] == 31, 'unexpected fanout inventory') + raw = {} + for name,(path,expected) in INPUTS.items(): + raw[name] = (ROOT/path).read_bytes() + require(hashlib.sha256(raw[name]).hexdigest()==expected,'hosting source drift: '+path) + plan, owners, spec = json.loads(raw['plan']),json.loads(gzip.decompress(raw['owners'])),json.loads(raw['spec']) + with tarfile.open(fileobj=io.BytesIO(raw['archive']),mode='r:gz') as archive: + member = archive.extractfile('evidence/global/GLOBAL-TEMPLATE.json.gz') + require(member is not None,'missing inherited data routing template') + template_bytes = gzip.decompress(member.read()) + template = json.loads(template_bytes) + require(len(template['calls'])==72 and template['live']==7168,'inherited T8 data stock') + old_calls = {(c['stage'],c['replica']):c for c in template['calls']} + require(len(old_calls)==72,'duplicate inherited calls') + order = [tuple(x) for x in plan['order']] + require(len(order)==144 and set(order)=={(s,r)for s in range(9)for r in range(16)},'T16 call coverage') + old_widths = [len(word['frames'][word['final'][r]])-len(word['frames'][word['start'][r]]) + for r in range(224,704)] + require(old_widths==spec['providers']['gauge44']['complete_contract']['widths'],'selected width binding') + require(INPUTS['owners'][1]==spec['data']['owners_sha256'],'selected owner binding') + complete = fanout_report['complete_public_widths'] + require(len(complete)==735 and all(type(w)is int and 0<=w<=9 for w in complete),'public width vector') + removed = set(qc.REMOVED) + registers = list(range(224,704))+list(qc.REMOVED)+[112+i for i in qc.REMOVED]+list(range(704,735)) + widths = [complete[r] for r in registers] + require(len(widths)==527 and widths[480:]==[9]*47,'whole helper lifetimes') + require(sum(widths[:480])-sum(old_widths)==21,'existing helper width growth must be charged') + for i in range(112): + if i not in removed: + require(complete[i]==complete[112+i]==8,'live data boundary width changed') + bins, bykey, bytime = [],{},defaultdict(list) + for key,(rank,times) in plan['windows'].items(): + replica,child = map(int,key.split(',')) + group = 2*int(plan['pairs'][str(child)])+int(plan['sides'][str(child)]) + for port in range(112): + if port in removed: + continue + index = len(bins) + bins.append(dict(replica=replica,child=child,port=port,rank=rank,times=set(times), + family=replica*896+group*112+port)) + bykey[replica,child,port] = index + for time in times: + bytime[time].append(index) + free = [b['rank']for b in bins] + assignments, families = {},[set()for _ in order] + retained = 0 + for owner in owners: + h = owner['helper'] + if owner['port'] in removed or widths[h]!=old_widths[h]: + continue + time = owner['time'] + bi = bykey[owner['owner_replica'],owner['child'],owner['port']] + b = bins[bi] + require(time in b['times'] and b['family'] not in families[time],'retained owner conflict') + require((time,h)not in assignments,'duplicate retained role') + assignments[time,h] = bi + families[time].add(b['family']) + free[bi] -= widths[h] + require(free[bi]>=0,'retained width exceeds idle child') + retained += 1 + # A fixed deterministic completion, not a search dependency or a claim of + # packing optimality. Preserve unchanged old placements; fill narrowest + # compatible residual bins with largest missing complete roles first. + for time in sorted(range(144),key=lambda t:(len(bytime[t]),t)): + missing = [h for h in range(527)if(time,h)not in assignments] + for h in sorted(missing,key=lambda h:(-widths[h],h)): + options = [bi for bi in bytime[time] if free[bi]>=widths[h] and bins[bi]['family']not in families[time]] + require(bool(options),'deterministic complete-role packing failed') + bi = min(options,key=lambda i:(free[i]-widths[h],len(bins[i]['times']),i)) + assignments[time,h] = bi + free[bi] -= widths[h] + families[time].add(bins[bi]['family']) + slots = defaultdict(list) + for (time,h),bi in assignments.items(): + slots[bi].append((time,h)) + literal = [] + for bi,roles in sorted(slots.items()): + b, offset = bins[bi],0 + for time,h in sorted(roles): + stage,replica = order[time] + require(time in b['times'],'complete invocation outside owner window') + require(offset+widths[h]<=b['rank'],'owner rank interval exceeds idle child') + literal.append(dict(stage=stage,replica=replica,time=time,helper=h,width=widths[h], + owner_replica=b['replica'],child=b['child'],port=b['port'], + old_family_label=b['family'],offset=offset)) + offset += widths[h] + require(b['rank']-offset==free[bi],'residual width recount') + require(len(literal)==144*527==75888,'whole-role assignment coverage') + for time,(stage,replica) in enumerate(order): + require(len(families[time])==527,'one physical family serves two roles in a call') + old = old_calls[stage,replica%8] + active = {family+(replica//8)*7168 for family,route in old['owners'][:224]} + require(len(active)==224,'inherited active-data owner count') + require(not active.intersection(families[time]),'helper owner is active data in its call') + idle = Counter(r for r in free if r) + idle_mass = sum(r*n for r,n in idle.items()) + require(idle_mass==144*818==117792,'complete-width residual mass') + require(sum(complete)==fanout_report['public_rank_mass']==5838,'monotone public width invoice') + require(idle_mass+144*(5838+56)==144*6712,'full coverage identity') + return dict(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=[dict(path=p,sha256=s)for p,s in INPUTS.values()], + inherited_template_member_sha256=hashlib.sha256(template_bytes).hexdigest(), + total_calls=144,ordinary_helpers=527,assigned_roles=75888,retained_old_placements=retained, + actual_ordinary_registers=registers,actual_ordinary_widths_sha256=digest(widths), + complete_public_widths_sha256=digest(complete),assignment_sha256=digest(literal), + existing_helper_width_increase=21,retained_live_families=13312, + remaining_idle_profile={str(r):n for r,n in sorted(idle.items())}, + idle_rank_mass=idle_mass,per_call_idle_rank_mass='818', + all_complete_role_widths_checked=True,whole_call_window_membership_roles=75888, + within_bin_overlaps=0,active_data_aliases=0,per_call_owner_family_aliases=0, + live_data_boundaries_unchanged=True,removed_family_labels_used=0, + global_emitter_admitted=False,new_native_wrappers_verified=False, + optimal_packing_claimed=False,new_kappa_gain_certified=False) + + +if __name__=='__main__': + print(json.dumps(verify(),indent=2,sort_keys=True)) diff --git a/research/p104-interleaved-search/native_checks.py b/research/p104-interleaved-search/native_checks.py new file mode 100644 index 0000000000..9be088b882 --- /dev/null +++ b/research/p104-interleaved-search/native_checks.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact finite native lowering of a literal fragment transport witness. + +The compiler and independent Gaussian interpreter are retained from the P104 +native channel (PR1991), with their predecessor attribution and notices. This +does not supply a backward interface, global hosting, or recursive precision. +""" +from collections import Counter +from copy import deepcopy +from functools import lru_cache +import hashlib +import importlib.util +import json +from pathlib import Path +import sys + +ROOT = Path(__file__).resolve().parents[2] +INPUTS = { + "compiler": ("research/p104-native-channel/vendor/clifford_exact.py", + "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"), + "interpreter": ("research/p104-native-channel/vendor/native_verify.py", + "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38"), +} + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def load(name): + relative, digest = INPUTS[name] + path = ROOT / relative + require(hashlib.sha256(path.read_bytes()).hexdigest() == digest, "native source drift: " + relative) + spec = importlib.util.spec_from_file_location("p104_fragment_native_" + name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def span(basis): + values = {0} + for x in basis: + require(isinstance(x, int) and 0 < x < 512, "invalid native frame vector") + values |= {x ^ y for y in tuple(values)} + require(len(values) == 1 << len(basis), "dependent native frame basis") + return frozenset(values) + + +def verify(witness): + compiler, interpreter = load("compiler"), load("interpreter") + edges = witness["transports"] + require(bool(edges), "empty literal transport witness") + frames, recipes, profile = {}, {}, Counter() + + @lru_cache(None) + def chart(basis): + return compiler.canonical_frame(9, basis) + + def key(edge): + return tuple(edge["old"]), tuple(edge["new"]) + + for edge in edges: + old, new = key(edge) + old_span, new_span = span(old), span(new) + for basis, subspace in ((old, old_span), (new, new_span)): + require(frames.setdefault(subspace, basis) == basis, "inconsistent chart basis for one subspace") + require(old_span < new_span or new_span < old_span, "transport is not a strict nested frame change") + rank = abs(len(new) - len(old)) + require(edge["rank"] == rank, "declared occurrence rank differs from frame jump") + profile[rank] += 1 + if (old, new) in recipes: + continue + record, _ = compiler.lower_child(chart(old).adjoint().then(chart(new))) + require(record["rank"] == rank, "native rank differs from literal frame jump") + expected = interpreter.adjoint(interpreter.frame(old, 9)) + interpreter.frame(new, 9) + interpreter.equal(interpreter.recipe(record), expected, "literal fragment transport") + recipes[old, new] = record + + ports = witness["ports"] + require(len(ports) == len(set(ports)) == 104, "104 distinct native ports") + adapters = [] + for normal in ports: + require(0 < normal < 512 and normal.bit_count() % 2 == 1, "nonodd intrinsic port") + entry = (normal,) + hyperplane = frozenset(x for x in range(512) if not (x & normal).bit_count() % 2) + require(hyperplane in frames, "missing literal target endpoint chart") + exit_frame = frames[hyperplane] + for where, actual, expected in ( + ("entry", compiler.cgate(9, normal, 1).adjoint().then(chart(entry)), + interpreter.adjoint((("C", normal, 1),)) + interpreter.frame(entry, 9)), + ("exit", chart(exit_frame).adjoint().then(compiler.cgate(9, normal, -1).then(compiler.fourier(9))), + interpreter.adjoint(interpreter.frame(exit_frame, 9)) + (("C", normal, -1),) + interpreter.fourier(9)), + ): + record, _ = compiler.lower_child(actual) + require(record["rank"] == 0, "intrinsic endpoint adapter has positive rank") + interpreter.equal(interpreter.recipe(record), expected, "fragment intrinsic endpoint") + adapters.append({"normal": normal, "position": where, "recipe": record}) + + private_paths = witness.get("private_paths", [witness.get("private_transports", [])]) + require(bool(private_paths) and all(private_paths), "missing private descent witness") + require([edge for path in private_paths for edge in path] == + [edge for edge in edges if edge["private"]], "private path occurrence coverage mismatch") + gaussian_columns = 0 + for private in private_paths: + private_actual = () + for i, edge in enumerate(private): + old, new = key(edge) + require((old, new) in recipes, "private edge missing from literal occurrences") + require(span(new) < span(old), "private path is not descending") + if i: + require(tuple(private[i - 1]["new"]) == old, "discontinuous private path") + require(private[i - 1]["register"] == edge["register"], "private path changes owned register") + private_actual += interpreter.recipe(recipes[old, new]) + first, last = tuple(private[0]["old"]), tuple(private[-1]["new"]) + require((len(first), len(last)) == (8, 1), "expected complete rank-seven private path") + private_expected = interpreter.adjoint(interpreter.frame(first, 9)) + interpreter.frame(last, 9) + interpreter.equal(private_actual, private_expected, "composed private path") + for column in range(512): + require(interpreter.state(private_actual, column) == interpreter.state(private_expected, column), + "private path Gaussian basis column") + gaussian_columns += 1 + + one_key = next(iter(recipes)) + bad = deepcopy(recipes[one_key]) + bad["left"]["phase"] = (bad["left"]["phase"] + 1) % 4 + old, new = one_key + try: + interpreter.equal(interpreter.recipe(bad), + interpreter.adjoint(interpreter.frame(old, 9)) + interpreter.frame(new, 9), + "corrupted native phase") + except ValueError: + pass + else: + raise ValueError("wrong global phase accepted") + canonical = [{"old": a, "new": b, "recipe": recipes[a, b]} for a, b in sorted(recipes)] + return { + "status": "PASS_FINITE_NATIVE_LOWERING", + "literal_transport_occurrences": len(edges), + "distinct_transport_recipes": len(recipes), + "paid_profile": {str(k): v for k, v in sorted(profile.items())}, + "native_rank_mass": sum(k * v for k, v in profile.items()), + "intrinsic_monomial_endpoint_adapters": len(adapters), + "private_paths": len(private_paths), + "private_path_gaussian_columns": gaussian_columns, + "every_recipe_signed_pauli_action_and_global_phase_checked": True, + "recipe_payload_sha256": hashlib.sha256(json.dumps(canonical + adapters, sort_keys=True, separators=(",", ":")).encode()).hexdigest(), + "wrong_global_phase_control_rejected": True, + "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.", + } diff --git a/research/p104-interleaved-search/natural_budget.py b/research/p104-interleaved-search/natural_budget.py new file mode 100644 index 0000000000..984d81153f --- /dev/null +++ b/research/p104-interleaved-search/natural_budget.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Conditional cost screen for the actual-source, one-term delivery fragment. + +The actual one-term invoice is replayed by natural_delivery.verify(). Seven +missing deliveries are priced as bare H7 descents with every other requirement +free. Fractional rank-51 residual packing and the optional old-gather saving +are optimistic assumptions, not a complete supplier or a kappa improvement. + +Uses the pinned selected profile and attributed interval engine from budget.py. +Run from any directory, standard library only: + python3 -I -B research/p104-interleaved-search/natural_budget.py +""" + +from __future__ import annotations + +from collections import Counter +from fractions import Fraction as Q +import importlib.util +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent + + +def module(name): + spec = importlib.util.spec_from_file_location("p104_natural_budget_" + name, + HERE / (name + ".py")) + if spec is None or spec.loader is None: + raise ValueError("cannot load " + name) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +B = module("budget") +N = module("natural_delivery") +require = B.require + + +def integers(profile): + return {int(rank): int(count) for rank, count in profile.items() if count} + + +def gather_credit(word): + """Recount old full frame paths, not the changed fragment's cleanup. + + The source-construction verifier proves deletion of the four unused gathers + preserves its query rows and live-Y rows. Here only their old full-path + invoice is checked. Applying this credit jointly to the new delivery and + its required final restoration is an explicitly unproved assumption. + """ + frames = [N.D.span(frame) for frame in word["frames"]] + inputs = N.S.load_inputs() + coordinates = inputs["coordinates"] + tau = lambda x: x ^ (43 if (x & 43).bit_count() % 2 else 0) + hyperplane = lambda x: frozenset(y for y in range(512) + if not (x & y).bit_count() % 2) + axes = {frame: next(axis for axis in range(8) + if frames[frame] == hyperplane(tau(coordinates["binary_ports"][axis]))) + for frame in word["center_frames"]} + retained_axes = {0, 5, 6, 7} + omitted = [k for k, event in enumerate(word["A"]) + if k >= len(word["A"]) - 48 and axes[event[-1]] not in retained_axes] + require(len(omitted) == 24, "four unused coordinate gathers") + + def replay(skip): + current = [frames[index] for index in word["start"]] + paid = Counter() + + def climb(register, target): + require(current[register] <= target, "nonmonotone old gather path") + rank = N.D.dimension(target) - N.D.dimension(current[register]) + if rank: + paid[rank] += 1 + current[register] = target + + for phase in ("A", "B", "tail"): + for k, event in enumerate(word[phase]): + if phase == "A" and k in skip: + continue + for register in event[1:3] if event[0] == "add" else event[1:2]: + climb(register, frames[event[-1]]) + for register, index in enumerate(word["final"]): + climb(register, frames[index]) + for event in word["cleanup"]: + for register in event[1:3] if event[0] == "add" else event[1:2]: + climb(register, frames[event[-1]]) + # The comparison includes the eight old private H8 children. + paid[8] += len(word["center_frames"]) + return dict(paid) + + old, new = replay(set()), replay(set(omitted)) + require(old == B.SELECTED_PROFILE, "old gather replay does not bind selected profile") + delta = {rank: new.get(rank, 0) - old.get(rank, 0) + for rank in new.keys() | old.keys() if new.get(rank, 0) != old.get(rank, 0)} + require(delta == {1: -28, 4: -28, 5: 28}, "old gather credit changed") + require(B.mass(delta) == 0, "gather omission changes total rank mass") + return delta, omitted + + +def price(delivery, *, assume_seven_free_deliveries=False): + """Require an explicit relaxation; this function never certifies a supplier.""" + require(assume_seven_free_deliveries, + "incomplete fragment: explicitly assume seven otherwise-free H7 deliveries") + engine, word, _, stock = B.load_inputs() + require(delivery["full_704_column_increment_verified"], "unverified one-term increment") + require(delivery["pair_hamming_root_indices"] == [3, 113], "wrong delivered term") + require(not delivery["complete_eight_term_supplier"], "review scope before pricing complete supplier") + require(delivery["additional_public_query_registers"] == 0, "unpriced external query register") + require(delivery["private_copies_created"] == delivery["peak_private_copies"] == 1, + "one-copy fragment changed") + + retained = B.retained_profile() + baseline = integers(delivery["baseline_profile"]) + require(B.changed(retained, {7: -8}) == baseline, + "actual baseline is not pinned retained-16 public profile") + public_delta = integers(delivery["public_profile_delta"]) + private = integers(delivery["private_COPY_profile"]) + residual_delta = integers(delivery["residual_width_delta"]) + require(B.changed(baseline, public_delta) == integers(delivery["candidate_public_profile"]), + "candidate public invoice differs from its replay delta") + require(B.mass(private) == 7, "actual private descent is not rank seven") + require(B.mass(public_delta) == delivery["public_rank_mass_delta"], "public mass mismatch") + require(B.mass(residual_delta) == delivery["residual_rank_mass_delta"], "residual mass mismatch") + require(B.mass(public_delta) + B.mass(residual_delta) == 0, + "public increase does not replace the reported residual width") + delta = Counter(public_delta) + delta.update(private) + delta[7] -= 1 + local = B.changed(retained, delta) + require(B.mass(local) - B.mass(retained) == -B.mass(residual_delta), + "actual private replacement or residual cancellation is inconsistent") + credit, omissions = gather_credit(word) + target_kappa = B.SELECTED_KAPPA * Q(101, 100) + target_a = target_kappa / (1 - target_kappa) + bit_cap = B.BIT_LOWER / (1 + B.BIT_LOWER) + width = Q(B.FAMILIES, B.STAGES) + h1 = engine.child_cost(1, B.M, target_a) + total = (B.M - 1) * width + B.CENTRE + require(engine.max_idle_rank(B.M) == 51, "optimistic idle rank changed") + + def describe(name, profile, with_credit): + model = engine.model(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + require(model["local_mass"] + model["idle_mass"] == total, "full coverage mass identity") + zero = engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, Q(0)) + require(zero[0] <= total / (B.M * width) <= zero[1], "zero-saving moment identity") + root = engine.ceiling(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + require(engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[0])[1] < 1, + "uncertified lower root bracket") + require(engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[1])[0] > 1, + "uncertified upper root bracket") + moment = engine.relax(profile, B.M, B.FAMILIES, B.STAGES, B.CENTRE, target_a) + margin = ((1 - moment[1]) * width, (1 - moment[0]) * width) + require(margin[0] > 0, "one-percent target already excluded") + counts = (margin[0] // h1[1], margin[1] // h1[0]) + require(counts[0] == counts[1], "excess-H1 count not resolved by exact intervals") + # Excess travel must be added to the moment, never silently substituted + # for one unit of the already covered idle mass. + excess_moment = tuple(moment[i] + h1[i] / width for i in (0, 1)) + after_one = (margin[0] - h1[1], margin[1] - h1[0]) + require((excess_moment[1] < 1) if with_credit else (excess_moment[0] > 1), + "one true excess H1 must fit only with optional gather credit") + require(int(counts[0]) == int(with_credit), "unexpected excess-H1 headroom") + complex_cap = root[1] / (1 + root[1]) + cap = min(complex_cap, bit_cap) + return { + "name": name, "status": "CEILING_NOT_SUPPLIER", + "optional_gather_credit_assumed": with_credit, + "local_profile": B.profile_json(profile), + "model": {key: str(value) for key, value in model.items()}, + "complex_saving_root_interval": B.interval(root), + "complex_kappa_upper_bound": str(complex_cap), + "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_one_percent_target": B.interval(moment), + "per_call_margin_at_one_percent_target": B.interval(margin), + "true_excess_H1_upper_count": int(counts[0]), + "one_true_excess_H1_moment": B.interval(excess_moment), + "per_call_margin_after_one_true_excess_H1": B.interval(after_one), + } + + return { + "status": "CEILING_NOT_SUPPLIER", + "scope": "Conditional pricing of one actual-source term; seven deliveries and final completion remain unproved. No kappa improvement is certified.", + "sources": [{"path": path, "sha256": digest} for path, digest in B.INPUTS.values()], + "selected_kappa": str(B.SELECTED_KAPPA), + "target_kappa": str(target_kappa), + "necessary_complex_saving_for_target": str(target_a), + "retained_16_local_profile": B.profile_json(retained), + "actual_public_profile_delta": B.profile_json(public_delta), + "actual_private_COPY_profile": B.profile_json(private), + "actual_residual_width_delta": B.profile_json(residual_delta), + "missing_deliveries": 7, + "assumptions": [ + "Retain m=73, nine stages, four pairs, 104 ports, and COPY rank56.", + "Retain all sixteen deleted X/Y roles as dirty helpers with the pinned public baseline.", + "Use the actual source-formed one-term invoice; no external public Q bank is added.", + "Each of the other seven terms costs only one H7 child; all its delivery overhead, dirty correction, and interactions are free.", + "Completion of the comparison baseline's punctured-Y restoration costs no additional paid transport; no complete eight-term endpoint proof is supplied.", + "All residual mass is fractionally packed at rank51; actual owners, chronology, backward admission, and primitive bounds remain unproved.", + "Only the second scenario assumes the old four-unused-gather saving remains valid jointly with the changed delivery and its rederived cleanup.", + "The fixed-bit and complex caps use the retained necessary balanced-transfer inequalities.", + ], + "optional_old_gather_credit": { + "profile_delta": B.profile_json(credit), "A_event_indices": omissions, + "full_old_paths_recounted": True, "joint_changed_cleanup_verified": False, + }, + "true_excess_H1_cost_at_target": B.interval(h1), + "scenarios": [describe("one_actual_term_seven_free_H7_deliveries", local, False), + describe("same_with_optional_four_unused_gather_credit", + B.changed(local, credit), True)], + "selected_private_centre_stock": stock, + "controls": {"full_mass_and_zero_moment_identities": True, + "actual_public_plus_residual_mass_is_zero": True, + "actual_private_mass_is_seven": True, + "one_excess_H1_fits_only_with_conditional_credit": True}, + } + + +def verify(): + delivery = N.verify() + try: + price(delivery) + except ValueError as error: + rejected = str(error) + else: + raise ValueError("incomplete fragment silently priced without its optimistic assumption") + report = price(delivery, assume_seven_free_deliveries=True) + report["controls"]["missing_optimistic_assumption_rejected"] = rejected + report["delivery_negative_controls"] = delivery["negative_controls"] + return report + + +if __name__ == "__main__": + print(json.dumps(verify(), indent=2, sort_keys=True)) diff --git a/research/p104-interleaved-search/natural_delivery.py b/research/p104-interleaved-search/natural_delivery.py new file mode 100644 index 0000000000..ee3894ddbb --- /dev/null +++ b/research/p104-interleaved-search/natural_delivery.py @@ -0,0 +1,384 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""One natural-source P104 rank-one increment, not a complete supplier. + +The original selected centre cut is omitted in both comparison programs. +The candidate constructs its query in a punctured Y role, delivers it through +one owned descending copy, and compensates all query dirt. Exact replay proves +only the stated rank-one difference on live Y; the omitted other seven terms +and restoration of the comparison baseline's punctured Y roles remain open. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +import heapq +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def module(name): + spec = importlib.util.spec_from_file_location(name, HERE / (name + '.py')) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +D = module('delivery') +S = module('scalar_surgery') +require = D.require +FULL = D.FULL +ZERO = frozenset({0}) + + +def basis(frame): + values, generated = [], ZERO + for x in sorted(frame): + if x not in generated: + values.append(x) + generated = D.join(generated, frozenset({0, x})) + require(generated == frame, 'frame is not a binary subspace') + return values + + +def schedule(data, word, live, labels): + """Derive every public gate order and private contact frame from contracts.""" + v, n, bword = word['v'], 2 * word['v'] + word['R'], word['B'] + m, contacts = len(bword), data['contacts'] + frames = [D.span(f) for f in word['frames']] + ai, bi = data['pair_hamming_root_indices'] + qa, qb = labels[ai], labels[bi] + hb = frozenset(x for x in range(512) if not D.pairing(x, qb)) + uses = [[] for _ in range(n)] + last, dependencies = {}, [] + for k, e in enumerate(bword): + rr = e[1:3] if e[0] == 'add' else e[1:2] + dependencies.append({last[r] for r in rr if r in last}) + for r in rr: + last[r] = k + uses[r].append(k) + def ancestors(k): + found, todo = {k}, [k] + while todo: + for j in dependencies[todo.pop()]: + if j not in found: + found.add(j) + todo.append(j) + return found + # These independent dependency slices only choose deterministic tie breaks. + hoisted, seen = [], set() + for root in data['query_hoist_root_order']: + role = v + word['ports'].index(labels[root]) + block = ancestors(last[role]) + hoisted.extend(sorted(block - seen)) + seen |= block + hoisted.extend(k for k in range(m) if k not in seen) + priority = {k: i for i, k in enumerate(hoisted)} + current = [frames[i] for i in word['start']] + for t in range(v): + if t not in live: + current[t] = ZERO + for e in word['A']: + for r in e[1:3] if e[0] == 'add' else e[1:2]: + require(current[r] <= frames[e[-1]], 'nonmonotone source A') + current[r] = frames[e[-1]] + before = {} + for k, e in enumerate(bword): + for r in e[1:3] if e[0] == 'add' else e[1:2]: + before[k, r] = current[r] + current[r] = frames[e[-1]] + # Undirected frame propagation is stronger than scalar response support: + # even a source operand must share the promoted chart of its destination. + future = [{r-v} if v <= r < 2*v and r-v in live else set() for r in range(n)] + upper = {} + for k in range(m-1, -1, -1): + e = bword[k] + rr = e[1:3] if e[0] == 'add' else e[1:2] + reached = set().union(*(future[r] for r in rr)) + for r in rr: + future[r] = reached.copy() + cap = hb + for t in sorted(reached): + cap &= frames[word['final'][v+t]] + upper[k, r] = cap + succ = [set() for _ in range(m + len(contacts))] + for k, deps in enumerate(dependencies): + for j in deps: + succ[j].add(k) + lower, caps = [], [] + source_ready = last[data['query_register']] + for i, contact in enumerate(contacts): + k, r = contact['before_B_event'], contact['register'] + require(type(k) is int and type(r) is int and (k, r) in before, 'invalid contact anchor') + require(Q(contact['coefficient']) != 0, 'zero contact coefficient') + index = uses[r].index(k) + if index: + succ[uses[r][index-1]].add(m+i) + succ[m+i].add(k) + succ[source_ready].add(m+i) + lo = D.join(before[k, r], frozenset({0, qa})) + cap = upper[k, r] + require(lo <= cap, 'contact has no legal common frame') + lower.append(lo) + caps.append(cap) + for i in range(len(contacts)): + for j in range(len(contacts)): + if i != j and not lower[j] <= caps[i]: + succ[m+j].add(m+i) + degrees = [0] * len(succ) + for out in succ: + for j in out: + degrees[j] += 1 + def key(node): + return priority[node] if node < m else node + queue = [(key(i), i) for i, d in enumerate(degrees) if d == 0] + heapq.heapify(queue) + order = [] + while queue: + _, node = heapq.heappop(queue) + order.append(node) + for j in sorted(succ[node]): + degrees[j] -= 1 + if not degrees[j]: + heapq.heappush(queue, (key(j), j)) + require(len(order) == len(succ), 'query/contact dependency cycle') + cframes, remaining = {}, ZERO + for node in reversed(order): + if node >= m: + i = node - m + remaining = D.join(remaining, lower[i]) + require(remaining <= caps[i], 'private chain interval failure') + cframes[i] = remaining + return order, cframes, hb, frozenset({0, qa}), source_ready + + +def construct(data=None, fault=None): + """Return exact report and literal native transport/event witnesses.""" + data = deepcopy(data if data is not None else json.loads((HERE/'NATIVE-CHAIN.json').read_text())) + word, prototype, live, roots, labels = D.load_sources(data) + v, n = word['v'], 2*word['v'] + word['R'] + require((v, n) == (112, 704), 'selected dimensions') + ai, bi = data['pair_hamming_root_indices'] + require((ai, bi, data['query_register']) == (3, 113, 146), 'this certificate binds one exact term') + frames = [D.span(f) for f in word['frames']] + start, terminal = [frames[i] for i in word['start']], [frames[i] for i in word['final']] + live_y = {v+t for t in live} + for t in range(v): + if t not in live: + start[t], terminal[v+t] = ZERO, FULL + order, cframes, hb, cend, ready = schedule(data, word, live, labels) + m = len(word['B']) + query_baselines = {} + query_last = {} + probe = S.run(S.identity(n), word['precondition'], word['compensation'], word['A']) + a_end_rows = deepcopy(probe) + for root in data['query_hoist_root_order']: + role = v + word['ports'].index(labels[root]) + query_last[root] = max(k for k,e in enumerate(word['B']) if role in (e[1:3] if e[0]=='add' else e[1:2])) + for k,e in enumerate(word['B']): + S.apply(e,probe) + for root,last in query_last.items(): + if k == last: + query_baselines[root] = probe[v+word['ports'].index(labels[root])].copy() + baseline = S.run(S.identity(n), word['precondition'], word['compensation'], word['A'], word['B'], word['tail'], word['cleanup']) + source_copy = Q(data['query_copy_coefficient']) + if fault == 'source_coefficient': + source_copy += 1 + raw_query = None + response = [Q(0)]*n + raw = S.run(S.identity(n), word['precondition'], word['compensation'], word['A']) + for node in order: + if node < m: + e = word['B'][node] + S.apply(e, raw) + if e[0] == 'add': + response[e[1]] += Q(e[3], e[4])*response[e[2]] + else: + response[e[1]] *= Q(e[2], e[3]) + else: + if raw_query is None: + raw_query = {j: source_copy*x for j, x in raw[data['query_register']].items()} + c = data['contacts'][node-m] + S.add_row(raw[c['register']], raw_query, Q(c['coefficient'])) + response[c['register']] += Q(c['coefficient']) + expected_query = {t: Q(S.dot(roots[t], prototype['root_lines'][bi]), 8) for t in live if S.dot(roots[t], prototype['root_lines'][bi])} + require({t:x for t,x in raw_query.items() if t in live} == expected_query, 'natural source coefficient or availability') + dirt = {j:x for j,x in raw_query.items() if j not in live} + require(not (set(dirt) & live_y), 'query depends on initial live Y') + require(all(start[j] == ZERO for j in dirt), 'query dirt lacks initial zero frame') + for phase in ('tail', 'cleanup'): + for e in word[phase]: + S.apply(e, raw) + if e[0] == 'add': + response[e[1]] += Q(e[3],e[4])*response[e[2]] + else: + response[e[1]] *= Q(e[2],e[3]) + require(response[data['query_register']] == 0, 'cleanup query was perturbed') + entry = [] + for t in live: + coefficient = Q(S.dot(roots[t], prototype['root_lines'][ai])) + require(response[v+t] == coefficient, 'wrong final query response') + require({j:x for j,x in baseline[v+t].items() if v <= j < 2*v} == {v+t:Q(1)}, 'nonidentity initial-Y transfer') + for j,x in sorted(dirt.items()): + if coefficient: + value = -coefficient*x + entry.append(['add',v+t,j,value.numerator,value.denominator,0]) + cleanup = [] + for r,c in enumerate(response): + if c and r not in live_y: + value = -c*source_copy + cleanup.append(['add',r,data['query_register'],value.numerator,value.denominator,1]) + if fault == 'removed_cleanup': + cleanup = cleanup[:-1] + + def replay(candidate): + rows, current = S.identity(n), start.copy() + paid, copy_paid, edges, events = Counter(), Counter(), [], [] + phases, copy_frame, copy_row = {}, None, None + query_observations = {} + copies_created = 0 + copy_active = False + last_contact_node = next(node for node in reversed(order) if node >= m) + def transport(register, target, phase, private=False): + nonlocal copy_frame + old = copy_frame if private else current[register] + require((target <= old) if private else (old <= target), 'nonmonotone literal transport') + rank = abs(D.dimension(target)-D.dimension(old)) + if rank: + (copy_paid if private else paid)[rank] += 1 + edge = dict(occurrence=len(edges),register=register,phase=phase,source_frame=basis(old),target_frame=basis(target),rank=rank,private=private) + edges.append(edge) + events.append(dict(kind='transport', **edge)) + if private: + copy_frame = target + else: + if register in live_y: + require(target <= terminal[register], 'live output terminal exceeded') + current[register] = target + def event(e, phase, promote=False): + rr = e[1:3] if e[0] == 'add' else e[1:2] + target = frames[e[-1]] + if promote: + for r in rr: + target = D.join(target,current[r]) + for r in rr: + transport(r,target,phase) + require(all(current[r] == target for r in rr), 'non-common-frame scalar gate') + S.apply(e,rows) + events.append(dict(kind=e[0],registers=list(rr),coefficient=str(Q(e[3],e[4]) if e[0]=='add' else Q(e[2],e[3])),frame=basis(target),phase=phase)) + if candidate: + for e in entry: + event(e,'new entry compensation') + for phase in ('precondition','compensation','A'): + for e in word[phase]: + event(e,phase) + phases[phase] = paid.copy() + for root in range(8): + expected = {t:Q(S.dot(roots[t],prototype['root_lines'][root]),2) for t in live if S.dot(roots[t],prototype['root_lines'][root])} + banks = [r for r in word['centers'] if {t:x for t,x in rows[r].items() if t in live} == expected] + require(len(banks) == 1, 'coordinate query bank mismatch') + bank = banks[0] + wanted_h = frozenset(x for x in range(512) if not D.pairing(x,labels[root])) + query_observations['coordinate_'+str(root)] = dict(register=bank,at_phase='A end',frame_rank=D.dimension(current[bank]),original_query_frame_preserved=current[bank]==wanted_h,all_704_source_columns_preserved=rows[bank]==a_end_rows[bank]) + bnodes = order if candidate else list(range(m)) + for node in bnodes: + if node < m: + event(word['B'][node],f'B:{node}',candidate) + for root in data['query_hoist_root_order']: + role = v+word['ports'].index(labels[root]) + if node == query_last[root]: + wanted_h = frozenset(x for x in range(512) if not D.pairing(x,labels[root])) + clean = {t:rows[role].get(t,Q(0)) for t in live if rows[role].get(t,Q(0))} + expected = {t:-Q(S.dot(roots[t],prototype['root_lines'][root]),4) for t in live if S.dot(roots[t],prototype['root_lines'][root])} + query_observations[str(root)] = dict(register=role,at_original_B_event=node,frame_rank=D.dimension(current[role]),original_query_frame_preserved=current[role]==wanted_h,live_source_row_preserved=clean==expected,all_704_source_columns_preserved=rows[role]==query_baselines[root]) + else: + i, contact = node-m, data['contacts'][node-m] + if copy_row is None and fault != 'late_copy': + require(current[data['query_register']] == hb, 'query unavailable in H_b') + require(copies_created == 0, 'private role reused after discard') + copy_active = True + copy_row = {j:source_copy*x for j,x in rows[data['query_register']].items()} + copy_frame = hb + copies_created += 1 + events.append(dict(kind='private_init',register=n,frame=basis(hb),phase='query copy')) + events.append(dict(kind='private_copy',registers=[n,data['query_register']],coefficient='1',frame=basis(hb),phase='query copy')) + events.append(dict(kind='scale',registers=[n],coefficient=str(source_copy),frame=basis(hb),phase='query scaling')) + require(copy_active and copy_row is not None and copy_frame is not None, 'private read before query copy initialization') + transport(n,cframes[i],f'contact:{i}',True) + transport(contact['register'],cframes[i],f'contact:{i}') + coefficient=Q(contact['coefficient']) + S.add_row(rows[contact['register']],copy_row,coefficient) + events.append(dict(kind='add',registers=[contact['register'],n],coefficient=str(coefficient),frame=basis(cframes[i]),phase=f'contact:{i}')) + if node == last_contact_node: + transport(n,cend,'private endpoint',True) + events.append(dict(kind='private_discard',register=n,frame=basis(cend),phase='private endpoint')) + copy_active = False + require(not copy_active, 'private role left live at B end') + for phase in ('tail','cleanup'): + for e in word[phase]: + event(e,phase,candidate) + if candidate: + for e in cleanup: + event(e,'new query cleanup',True) + final = [D.join(terminal[r],current[r]) if candidate else terminal[r] for r in range(n)] + for r in range(n): + transport(r,final[r],'terminal') + return dict(rows=rows,paid=paid,copy_paid=copy_paid,final=final,edges=edges,events=events,query_observations=query_observations,copies_created=copies_created) + base = replay(False) + new = replay(True) + require(base['rows'] == baseline, 'baseline replay disagreement') + for r,row in enumerate(new['rows']): + expected = baseline[r].copy() + if r in live_y: + a = S.dot(roots[r-v],prototype['root_lines'][ai]) + for t,coefficient in expected_query.items(): + S.add_row(expected,{t:Q(1)},a*coefficient) + require(row == expected, f'full-column rank-one increment mismatch at register {r}') + require(sum(k*v for k,v in new['copy_paid'].items()) == 7, 'private COPY mass is not seven') + old_residual, new_residual = Counter(), Counter() + for r in range(n): + if not (r