From 121b7f1c8b664ae41820e35ba2201423ab21db8b Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 19:24:52 -0500 Subject: [PATCH 1/2] Record P104 private descent fanout reuse construction --- .../COST-RESULT.json | 92 ++ .../FANOUT-RESULT.json | 1026 +++++++++++++++++ .../NATIVE-RESULT.json | 22 + .../README.md | 152 +++ .../TASK.json | 132 +++ .../fanout-helper-reuse.patch | 213 ++++ .../price_reuse.py | 102 ++ .../verify_native.py | 44 + 8 files changed, 1783 insertions(+) create mode 100644 research/p104-private-descent-reuse-seed915fa969/COST-RESULT.json create mode 100644 research/p104-private-descent-reuse-seed915fa969/FANOUT-RESULT.json create mode 100644 research/p104-private-descent-reuse-seed915fa969/NATIVE-RESULT.json create mode 100644 research/p104-private-descent-reuse-seed915fa969/README.md create mode 100644 research/p104-private-descent-reuse-seed915fa969/TASK.json create mode 100644 research/p104-private-descent-reuse-seed915fa969/fanout-helper-reuse.patch create mode 100644 research/p104-private-descent-reuse-seed915fa969/price_reuse.py create mode 100644 research/p104-private-descent-reuse-seed915fa969/verify_native.py diff --git a/research/p104-private-descent-reuse-seed915fa969/COST-RESULT.json b/research/p104-private-descent-reuse-seed915fa969/COST-RESULT.json new file mode 100644 index 0000000000..46aa9b41f4 --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/COST-RESULT.json @@ -0,0 +1,92 @@ +{ + "combined_profile": { + "1": 2611, + "2": 513, + "3": 378, + "4": 132, + "5": 81, + "6": 15, + "7": 13 + }, + "combined_rank_mass": 5885, + "combined_rank_mass_before": 5894, + "complex_kappa_cap": "830751799397/500830751799397", + "fanout_variant_sha256": "853b067a399d0bd893b69468890cd6338c68d4c5b63c32d3c9c7cff28ce50567", + "fixed_bit_kappa_cap": "1733427039589844234749/1001733427039589844234749", + "fractional_rank_51_residual_relaxation": true, + "inputs": { + "assembly": { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + "engine": { + "path": "research/complex-local-word-ceiling/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + "selection": { + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + "source_manifest": { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + "stock": { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + "word": { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + } + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "827", + "local_mass": "5885", + "total_mass": "6712", + "w": "832/9" + }, + "new_kappa_gain_certified": false, + "predecessor_commit": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "private_COPY_profile": { + "1": 2, + "2": 1, + "3": 1, + "7": 7 + }, + "public_profile": { + "1": 2609, + "2": 512, + "3": 377, + "4": 132, + "5": 81, + "6": 15, + "7": 6 + }, + "rank_mass_saved": 9, + "saving_root_interval": { + "lower": "1661503598793/1000000000000000", + "lower_decimal": "0.001661503598793", + "upper": "830751799397/500000000000000", + "upper_decimal": "0.001661503598794" + }, + "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 + }, + "selected_threshold_excluded": true, + "selected_threshold_moment": { + "lower": "115797359306122468329603805425583230183217804648449829200764880802103324328373/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00004551320250791818750", + "upper": "57898679653061234164801902712791615091608902324224914600382440401051662164207/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00004551320250791818750" + }, + "status": "SCOPED_LOCAL_COST_REDUCTION_SELECTED_KAPPA_STILL_EXCLUDED" +} diff --git a/research/p104-private-descent-reuse-seed915fa969/FANOUT-RESULT.json b/research/p104-private-descent-reuse-seed915fa969/FANOUT-RESULT.json new file mode 100644 index 0000000000..4c48abe226 --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/FANOUT-RESULT.json @@ -0,0 +1,1026 @@ +{ + "actual_query_Hb_frames_verified": true, + "all_new_helpers_restored": true, + "all_public_scalar_adds_common_chart": true, + "candidate_public_profile": { + "1": 2609, + "2": 512, + "3": 377, + "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, + 0, + 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": 86, + "contact_schedule_sha256": "f9eb9e1258ae76d09199a76c428af511963dc66ad62a1fffef4d2a3d3cb21f0a", + "deterministic_clones": [ + [ + 3, + 113 + ], + [ + 2, + 47 + ], + [ + 4, + 57 + ] + ], + "entry_compensation_additions": 825, + "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", + "missing_reused_contact": "full 735-column endpoint identity failed", + "query_coefficient": "dirty helper not restored" + }, + "ordinary_fanout_helpers": 31, + "peak_private_copies": 1, + "plans_sha256": "0c2ae264694bbe7c15b9261ba8adf68c9552849effd423894713c68ad23d28ca", + "private_COPY_profile": { + "1": 2, + "2": 1, + "3": 1, + "7": 7 + }, + "private_copies_created": 8, + "private_reused_contact_additions": 3, + "public_rank_mass": 5829, + "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, + "reused_fanout_helper": 7, + "scalar_add_count": 20947, + "scalar_adds_by_phase": { + "A": 2980, + "B query prefix": 506, + "B suffix": 1284, + "entry compensation": 825, + "fanout contact": 86, + "fanout helper seed": 30, + "ghost restoration": 911, + "helper restoration": 30, + "old cleanup": 6574, + "old compensation": 7208, + "precondition": 136, + "private query copy replaces fanout helper": 3, + "response cleanup": 276, + "tail": 98 + }, + "scalar_operation_word_sha256": "c18b1ca618b7c3277c9fe2ecf992c4f9115142a1d7c131a34400d91ce4ecdd7c", + "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": "0fcefff6747add290356285be795a24b8b13c93c0df096a5821b89a633b6c420" +} diff --git a/research/p104-private-descent-reuse-seed915fa969/NATIVE-RESULT.json b/research/p104-private-descent-reuse-seed915fa969/NATIVE-RESULT.json new file mode 100644 index 0000000000..e2d1280dfa --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/NATIVE-RESULT.json @@ -0,0 +1,22 @@ +{ + "distinct_transport_recipes": 3050, + "every_recipe_signed_pauli_action_and_global_phase_checked": true, + "intrinsic_monomial_endpoint_adapters": 208, + "literal_transport_occurrences": 3743, + "native_rank_mass": 5885, + "paid_profile": { + "1": 2611, + "2": 513, + "3": 378, + "4": 132, + "5": 81, + "6": 15, + "7": 13 + }, + "private_path_gaussian_columns": 4096, + "private_paths": 8, + "recipe_payload_sha256": "714b8a48c6415e14925ebb9b83fec5c2f60bf13fca99c2c7dec1fb95dd141f89", + "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 +} diff --git a/research/p104-private-descent-reuse-seed915fa969/README.md b/research/p104-private-descent-reuse-seed915fa969/README.md new file mode 100644 index 0000000000..079051c5eb --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/README.md @@ -0,0 +1,152 @@ +# P104 private descent reuses one public fanout helper + +## Result + +This package records a finite construction improvement to the forward P104 +word in PR #2152. One rank-seven owned query copy serves the three contacts +previously routed through public helper 7, by descending through their nested +contact frames before continuing to its original rank-one endpoint. The helper +slot stays allocated and untouched. The replay verifies every endpoint row +over all 735 input columns, including the specified live-Y plus X transfer, +and the native lowering verifies the revised private descent. + +The combined paid local profile drops from rank mass 5,894 to 5,885, a saving +of 9. This does **not** improve the selected conditional bound. Under the +retained m=73, P104, COPY56, nine-stage balanced-transfer screen, the exact +selected-threshold moment is still above one and the optimistic complex-side +cap remains below the selected κ. This is a local cost reduction, not a new +supplier or κ result. + +## Pins and coordination + +- Cycle seed: `915fa969cacecdfec5dcd7a95a4bf0a0` +- Track/task: `complex-mechanisms` / `p104-side-correction` +- Catalogue priority revision: `4` +- Main base commit: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` +- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` +- Predecessor: PR #2152 at `05f7aad0f08992ee48ec2dd93e896d9a4567847d` +- Claim: Discussion #1167 comment #18936581, expiring 2026-10-15 01:59:31 UTC +- The predecessor's README asks whether existing helper lifetimes can replace + new fanout helpers. The scope here is the concrete global helper 7, pair + `(4,57)`, and its three contacts at B-prefix cut 507. +- Relevant predecessor PRs/claims included #2089, #2082, #2090, #2113, #2127, + #2139, #2173, #2190, and completed claims #2131/#2190. The live overlap + check found no active helper-7 private-descent implementation. PR #2152's + helper-lifetime question is the direct predecessor, not a competing claim. + Before submission, new claim #2218 appeared for a different `(97,5)` delayed + recipient echo and register/cut scope; its method and term differ from this + nested descent. The live PR search also returned #2113's rank-eight cut + obstruction, not a helper-reuse construction. + +The experiment uses the pinned PR #2152 source unchanged as its base and +patches its `fanout.py` word before the separate `coalesced.py` rechart. The +initial Discussion claim named the coalesced word; this package narrows the +verified scope to the predecessor's original forward word. The coalesced +variant remains untested. The single-file patch in `fanout-helper-reuse.patch` +adds the exact matrix replay controls. `price_reuse.py` and `verify_native.py` +run against the patched predecessor checkout. + +## Mechanism + +The `(4,57)` query source is register 133 in an 8-dimensional frame `Hb`. Its +owned private copy is scaled by `lambda=-1/2`. In the predecessor word, helper +7 enters at the line `La`, receives contacts at the following nested frames, +then returns to `FULL`: + +| Target register | Contact coefficient | Contact frame basis | Dimension | +| --- | ---: | --- | ---: | +| 159 | -1 | `[2,12,16,33,64,128,261]` | 7 | +| 203 | 2 | `[2,12,33,80,144,261]` | 6 | +| 148 | 2 | `[45,82,144]` | 3 | + +These spaces satisfy `La ⊆ F1 ⊆ F2 ⊆ F3 ⊆ Hb`, where F1 is the frame for +register 148, F2 for 203, and F3 for 159. The private copy descends +`Hb → F3 → F2 → F1 → La`, charging rank jumps `1+1+3+2=7`. At each contact, +the target register moves to the same frame used by the predecessor helper +and receives the same scalar multiple of the scaled query row. The private +copy then reaches `La` and seeds the other helpers for `(4,57)` as before. + +The public helper's entry, contact, and endpoint transports disappear. The +other two helpers for `(4,57)`, all other contacts, and the source query are +retained. No additional private copy is created and peak private occupancy +stays one. The freed helper register remains part of the 735-column identity +and is left untouched. + +## Exact evidence + +| Quantity | Before | After | +| --- | ---: | ---: | +| Public transport profile | `1:2611, 2:514, 3:378, 4:132, 5:81, 6:15, 7:6` | `1:2609, 2:512, 3:377, 4:132, 5:81, 6:15, 7:6` | +| Private `COPY` profile | `7:8` | `1:2, 2:1, 3:1, 7:7` | +| Combined rank mass | 5,894 | 5,885 | +| Private `COPY` rank mass | 56 | 56 | +| Exact scalar ADD count | 20,956 | 20,947 | + +The verifier checks all 735 endpoint columns, exact rational scalar +operations, the public and private occurrence invoices, and five negative +controls. Entry compensation drops from 832 to 825 ADDs; helper seed and +helper restoration each drop from 31 to 30. The three removed public contact +ADDs are replaced by three direct private-copy contact ADDs. Response cleanup +remains 276 ADDs and punctured-Y restoration remains 911. Omitting one reused +contact fails the endpoint map. Native lowering checks every literal +transport recipe, signed Pauli action and phase, the eight private paths, and +all 4,096 Gaussian basis columns in the composed private paths. + +The priced combined profile is +`1:2611, 2:513, 3:378, 4:132, 5:81, 6:15, 7:13`, with exact local mass 5,885. +The certified saving-root bracket is +`[1661503598793/1000000000000000, 830751799397/500000000000000]`, or +`[0.001661503598793, 0.001661503598794]`. Its complex-side κ cap is +`830751799397/500830751799397` +(`0.00165874758371416805798661`), below selected +`0.001672660197076918`. At the selected saving threshold, the exact moment +interval is + +```text +[115797359306122468329603805425583230183217804648449829200764880802103324328373 + /115792089237316195423570985008687907853269984665640564039457584007913129639936, + 57898679653061234164801902712791615091608902324224914600382440401051662164207 + /57896044618658097711785492504343953926634992332820282019728792003956564819968] +``` + +Both endpoints are greater than one. The model prices the full observed public +and owned transport profiles, recursive children, frame changes, and +restoration under the pinned balanced-transfer screen. Exact scalar ADDs are +recorded above; the selected-result ceiling is a transport-profile moment +model. As in that necessary screen, all residual mass is optimistically +permitted to form fractional rank-51 idle children. +This experiment does not supply the full multiplication wrapper, global +hosting, or bit-side admission, and it does not establish a new κ. + +## Reproduction + +From a clone of `CrocSwap/integer-mult-bounds`, fetch and check out the exact +predecessor commit in a temporary worktree, then apply the recorded patch. Run +the artifact scripts from the repository checkout that contains this package: + +```sh +git fetch origin refs/pull/2152/head:refs/remotes/origin/pr2152 +test "$(git rev-parse refs/remotes/origin/pr2152)" = 05f7aad0f08992ee48ec2dd93e896d9a4567847d +git worktree add --detach /tmp/p104-private-reuse 05f7aad0f08992ee48ec2dd93e896d9a4567847d +git -C /tmp/p104-private-reuse apply /path/to/fanout-helper-reuse.patch +cd /path/to/the/package-containing-checkout +python3 -I -B /tmp/p104-private-reuse/research/p104-interleaved-search/fanout.py +P104_REPLAY_ROOT=/tmp/p104-private-reuse python3 -I -B research/p104-private-descent-reuse-seed915fa969/price_reuse.py +P104_REPLAY_ROOT=/tmp/p104-private-reuse python3 -I -B research/p104-private-descent-reuse-seed915fa969/verify_native.py +``` + +Expected checks are `full_735_column_identity_verified: true` (the predecessor +field name for the exact endpoint-map check), +`all_new_helpers_restored: true`, the five rejected negative controls, combined +rank mass 5,885, selected moment greater than one, and native status +`PASS_FINITE_NATIVE_LOWERING`. The native replay is substantially slower than +the scalar replay because it checks the full Gaussian-column basis. + +## Attribution and limits + +The seed and scoped hypothesis were selected by this cycle. The mathematical +idea and implementation were developed with substantial OpenAI Codex +assistance. The predecessor P104 word, query construction, frame data, +balanced-transfer model, and native checker remain attributed to their +respective source packages and authors. The patch is an experiment based on +PR #2152, not a modification of that PR. diff --git a/research/p104-private-descent-reuse-seed915fa969/TASK.json b/research/p104-private-descent-reuse-seed915fa969/TASK.json new file mode 100644 index 0000000000..aeffd5a40f --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/TASK.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "cycle_seed": "915fa969cacecdfec5dcd7a95a4bf0a0", + "track": "complex-mechanisms", + "task_id": "p104-side-correction", + "priority_revision": 4, + "main_base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected_result": { + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + "certificate": { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + "reproduction": "make frontier1094-verify" + }, + "selector_draws": [ + {"seed": "70ef5c9c369417ac91cd4e9d3056b3d9", "track": "verifier-engineering", "excluded": true}, + {"seed": "2dcbbffcaa33cd698a882f4412f7eecc", "track": "verifier-engineering", "excluded": true}, + {"seed": "464afd7b8518080539e19f5a5004dde3", "track": "independent-verification", "excluded": true}, + {"seed": "a05c4fb7c9e2077b46987741b689c3c2", "track": "adversarial-audit", "excluded": true}, + {"seed": "915fa969cacecdfec5dcd7a95a4bf0a0", "track": "complex-mechanisms", "excluded": false} + ], + "predecessor": { + "pull_request": 2152, + "commit": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "source": "research/p104-interleaved-search/fanout.py", + "patch_sha256": "6eb26b8cb17c5b58d8a69f4c782fd3a822faf945ced2f1ceb7ba33884b562d8a", + "patched_source_sha256": "853b067a399d0bd893b69468890cd6338c68d4c5b63c32d3c9c7cff28ce50567" + }, + "scope": { + "object": "P104 eight-query forward word at B-prefix cut 507", + "question": "Can the existing private query copy for pair (4,57) directly serve the three nested-frame contacts of public helper 7, then continue to La, eliminating that helper lifetime?", + "changed_expense": "Replace helper 7's public entry/contact/endpoint lifetime and one private H7 descent with a nested private descent; keep the register allocated and untouched.", + "bounded_domain": "Only global helper ordinal 7, its three fixed contacts, and the original fanout.py word at the pinned predecessor commit; the separate coalesced.py rechart is not tested.", + "expected_deliverable": "Exact rational replay, native lowering, revised complete transport and scalar-ADD invoices, and the same selected-result cost screen." + }, + "claim": { + "discussion": 1167, + "comment": 18936581, + "expires_utc": "2026-10-15T01:59:31Z" + }, + "overlap_at_claim": { + "live_scope_check": "No open PR match for P104 fanout-helper reuse; PR #2152 head pinned above; no competing helper-7 private-descent claim found on the hub.", + "related_predecessors": [2089, 2082, 2090, 2113, 2127, 2139, 2173, 2190], + "completed_related_claims": [2131, 2190] + }, + "submission_overlap": { + "checked_at_utc": "2026-10-15T00:24:38Z", + "pr_2152_state": "open", + "pr_2152_head": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "open_pr_searches": { + "P104 helper lifetime": [], + "P104 fanout reuse": [], + "P104 private descent": [2113] + }, + "new_active_discussion": { + "number": 2218, + "scope": "Term (97,5) delayed recipient echo, registers 14/412 and cuts 507/962; different term and mechanism from helper 7 nested private descent." + }, + "decision": "Continue with the exact (4,57) helper-7 construction; preserve #2218 attribution and distinguish its recipient-echo mechanism." + }, + "result": { + "status": "finite_forward_construction_with_local_cost_reduction", + "full_735_input_endpoint_map_verified": true, + "negative_controls_rejected": [ + "query_coefficient", + "missing_private_initialization", + "missing_response_cleanup", + "missing_entry_compensation", + "missing_reused_contact" + ], + "native_lowering": { + "status": "PASS_FINITE_NATIVE_LOWERING", + "private_paths": 8, + "gaussian_basis_columns": 4096, + "wrong_global_phase_rejected": true + }, + "public_transport_profile": {"1": 2609, "2": 512, "3": 377, "4": 132, "5": 81, "6": 15, "7": 6}, + "private_COPY_profile": {"1": 2, "2": 1, "3": 1, "7": 7}, + "combined_transport_profile": {"1": 2611, "2": 513, "3": 378, "4": 132, "5": 81, "6": 15, "7": 13}, + "combined_rank_mass_before": 5894, + "combined_rank_mass_after": 5885, + "scalar_add_count_before": 20956, + "scalar_add_count_after": 20947, + "entry_compensation_additions_before": 832, + "entry_compensation_additions_after": 825, + "helper_seed_additions_before": 31, + "helper_seed_additions_after": 30, + "helper_restoration_additions_before": 31, + "helper_restoration_additions_after": 30, + "direct_private_contact_additions": 3 + }, + "cost_screen": { + "scope": "Necessary m=73, P104, COPY56, 832-family, nine-stage balanced-transfer profile model with fractional rank-51 residual packing.", + "combined_rank_mass": 5885, + "saving_root_interval": [ + "1661503598793/1000000000000000", + "830751799397/500000000000000" + ], + "complex_kappa_cap": "830751799397/500830751799397", + "selected_kappa": "836330098538459/500000000000000000", + "selected_threshold_moment_lower_decimal": "1.00004551320250791818750", + "selected_kappa_still_excluded": true, + "new_kappa_gain_certified": false + }, + "artifacts": { + "fanout_patch": "fanout-helper-reuse.patch", + "fanout_receipt": "FANOUT-RESULT.json", + "cost_receipt": "COST-RESULT.json", + "native_receipt": "NATIVE-RESULT.json", + "source_inputs_pinned_in": "COST-RESULT.json", + "sha256": { + "fanout-helper-reuse.patch": "6eb26b8cb17c5b58d8a69f4c782fd3a822faf945ced2f1ceb7ba33884b562d8a", + "FANOUT-RESULT.json": "018885346d5bbd5693d3718b8651dee97ca8cffee3b2fda69eb71b12820b8244", + "COST-RESULT.json": "0ba38e6549418f9930eb61e0d66a2b4e41225f5b1b6a697141550173c7b56f3f", + "NATIVE-RESULT.json": "688e694aac5412d5c9c0b0ed9ed63c956a8407ddfaa9c0322a233a89d8046049" + } + }, + "ai_assistance": "Substantial OpenAI Codex assistance. Predecessor P104 construction, source data, selected result, cost engine, and native checker remain attributed to their source authors.", + "remaining_obligations": [ + "The local ceiling rejects the selected kappa under the stated model.", + "No global multiplication wrapper or supplier is supplied.", + "No owner-window hosting, bit-side admission, or recursive precision/reserve account is established.", + "No new kappa is claimed." + ] +} diff --git a/research/p104-private-descent-reuse-seed915fa969/fanout-helper-reuse.patch b/research/p104-private-descent-reuse-seed915fa969/fanout-helper-reuse.patch new file mode 100644 index 0000000000..fbc0f26366 --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/fanout-helper-reuse.patch @@ -0,0 +1,213 @@ +diff --git a/research/p104-interleaved-search/fanout.py b/research/p104-interleaved-search/fanout.py +index 66472a83..57e09798 100644 +--- a/research/p104-interleaved-search/fanout.py ++++ b/research/p104-interleaved-search/fanout.py +@@ -54,7 +54,7 @@ class NeedHelper(Exception): + """The deterministic cumulative-frame allocator needs another dirty role.""" + + +-def construct(fault=None, fixed=None): ++def construct(fault=None, fixed=None, reuse_helper=None): + """Derive the forward word. Mutations consume the baseline's fixed repairs.""" + inputs = QC.load_inputs() + word, prototype = inputs['word'], inputs['coordinates'] +@@ -100,7 +100,8 @@ def construct(fault=None, fixed=None): + caps.append(cap.copy()) + caps.reverse() + +- def run(compensation=(), repairs=None, mutation=None): ++ def run(compensation=(), repairs=None, mutation=None, reuse_frames=None): ++ active_reuse = reuse_helper if reuse_frames is not None else None + n = oldn + len(helpers) + rows = QC.identity(n) + current = [frames[i] for i in word['start']] + [ZERO] * len(helpers) +@@ -184,16 +185,43 @@ def construct(fault=None, fixed=None): + 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]]) ++ path = [] ++ direct = [c for c in contacts[cut] if c['helper'] == active_reuse] if active_reuse is not None else [] ++ if active_reuse in js: ++ require(direct and all(helpers[c['helper']]['source'] == source for c in direct), ++ 'reused helper contacts do not share the owned query') ++ for c in sorted(direct, key=lambda item: D.dimension(reuse_frames[item['register']]), reverse=True): ++ frame = reuse_frames[c['register']] ++ transport(c['register'], frame, 'reused fanout target chart') ++ before = len(edges) ++ transport(owned, frame, 'owned query to reused fanout contact', True) ++ if len(edges) > before: ++ path.append(edges[-1]) ++ require(current[c['register']] == frame, 'reused contact target is not in the private chart') ++ if mutation != 'missing_reused_contact' or c is not direct[0]: ++ scalar_add(c['register'], owned, Q(c['coefficient']), ++ 'private query copy replaces fanout helper', True) ++ before = len(edges) ++ transport(owned, line, 'owned query to La after reused contacts', True) ++ if len(edges) > before: ++ path.append(edges[-1]) ++ else: ++ before = len(edges) ++ transport(owned, line, 'owned Hb to La', True) ++ if len(edges) > before: ++ path.append(edges[-1]) ++ private_paths.append(path) + for j in js: ++ if j == active_reuse: ++ continue + 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'])): ++ for c in sorted((c for c in contacts[k] if c['helper'] != active_reuse), ++ 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') +@@ -215,6 +243,8 @@ def construct(fault=None, fixed=None): + for r, q in qrows.items(): + require(rows[r] == q, 'actual query bank changed before helper restoration') + for j in range(len(helpers)): ++ if j == active_reuse: ++ continue + transport(oldn+j, FULL, 'fanout helper endpoint') + if repairs is None: + for r, rr in enumerate(response): +@@ -227,6 +257,8 @@ def construct(fault=None, fixed=None): + transport(r, FULL, 'response cleanup') + scalar_add(r,h,Q(c),'response cleanup') + for j,h in enumerate(helpers): ++ if j == active_reuse: ++ continue + 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') +@@ -259,16 +291,42 @@ def construct(fault=None, fixed=None): + cleanup=cleanup, ghost_restoration=ghost_restores, contacts=routed_contacts) + + clones = [] ++ reference = None + if fixed is None: + while True: + try: +- preliminary = run() ++ reference = 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') ++ else: ++ helpers = deepcopy(fixed['helpers']) ++ compensation, repairs, clones = deepcopy(fixed['compensation']), deepcopy(fixed['repairs']), fixed['clones'] ++ reference = run() ++ reuse_frames = None ++ if reuse_helper is not None: ++ reuse_frames = {item['target']: QC.span(item['frame']) for item in reference['contacts'] ++ if item['helper'] == reuse_helper} ++ requested = {c['register'] for cs in contacts.values() for c in cs if c['helper'] == reuse_helper} ++ require(set(reuse_frames) == requested and len(requested) == 3, ++ 'baseline helper does not have exactly three realized contacts') ++ require(set(reuse_frames) == {148, 203, 159}, 'reused helper contact targets changed') ++ f1, f2, f3 = (reuse_frames[target] for target in (148, 203, 159)) ++ la = helpers[reuse_helper]['line'] ++ query = next(q for q in reference['query_records'] ++ if q['pair'] == [helpers[reuse_helper]['a'], helpers[reuse_helper]['b']]) ++ hb = QC.span(query['frame']) ++ require((D.dimension(f1), D.dimension(f2), D.dimension(f3)) == (3, 6, 7) and ++ la <= f1 <= f2 <= f3 <= hb, ++ 'reused contact frames are not the claimed nested descent') ++ target_contacts = [c for c in contacts[cut] if c['register'] in reuse_frames] ++ require(len(target_contacts) == 3 and all(c['helper'] == reuse_helper for c in target_contacts), ++ 'reused target has another same-cut contact writer') ++ preliminary = run(reuse_frames=reuse_frames) if reuse_helper is not None else reference ++ if fixed is None: + compensation = [] + for t in live: + row = preliminary['rows'][v+t] +@@ -280,21 +338,29 @@ def construct(fault=None, fixed=None): + '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) ++ built = run(applied_compensation, repairs, fault, reuse_frames) + 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} ++ if reuse_helper is not None: ++ expected = dict(expected) ++ for rank, count in ((1, -2), (2, -2), (3, -1)): ++ expected[str(rank)] += count ++ expected = {rank: count for rank, count in expected.items() if count} ++ require(built['copy_paid'] == Counter({1: 2, 2: 1, 3: 1, 7: 7}), ++ 'one nested-frame reuse replaces exactly one rank-seven private descent') ++ else: ++ require(built['copy_paid'] == Counter({7:8}), 'eight complete rank-seven owned copies') + 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)] ++ scalar_adds = Counter(e['phase'] for e in built['scalar_operations'] if e['kind'] == 'add') ++ require(scalar_adds['private query copy replaces fanout helper'] == (3 if reuse_helper is not None else 0), ++ 'direct private contact ADD count') + # 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.', +@@ -304,6 +370,9 @@ def construct(fault=None, fixed=None): + 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']), ++ scalar_add_count=sum(scalar_adds.values()), ++ scalar_adds_by_phase=dict(sorted(scalar_adds.items())), ++ private_reused_contact_additions=scalar_adds['private query copy replaces fanout helper'], + 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, +@@ -312,7 +381,8 @@ def construct(fault=None, fixed=None): + 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) ++ completed_full_multiplication_supplier=False, kappa_improvement_claimed=False, ++ reused_fanout_helper=reuse_helper) + built.update(report=report, fixed=dict(helpers=helpers, compensation=compensation, repairs=repairs, clones=clones), + ports=[word['ports'][t] for t in live]) + return built +@@ -331,12 +401,15 @@ def native_witness(built=None): + public_profile=built['report']['candidate_public_profile'], private_profile=built['report']['private_COPY_profile']) + + +-def verify(): +- built = construct() ++def verify(reuse_helper=None): ++ built = construct(reuse_helper=reuse_helper) + controls = {} +- for fault in ('query_coefficient','missing_private_initialization','missing_response_cleanup','missing_entry_compensation'): ++ faults = ['query_coefficient','missing_private_initialization','missing_response_cleanup','missing_entry_compensation'] ++ if reuse_helper is not None: ++ faults.append('missing_reused_contact') ++ for fault in faults: + try: +- construct(fault=fault,fixed=built['fixed']) ++ construct(fault=fault,fixed=built['fixed'],reuse_helper=reuse_helper) + except (ValueError,NeedHelper) as error: + controls[fault] = str(error) + else: +@@ -346,4 +419,4 @@ def verify(): + + + if __name__ == '__main__': +- print(json.dumps(verify(),indent=2,sort_keys=True)) ++ print(json.dumps(verify(reuse_helper=7),indent=2,sort_keys=True)) diff --git a/research/p104-private-descent-reuse-seed915fa969/price_reuse.py b/research/p104-private-descent-reuse-seed915fa969/price_reuse.py new file mode 100644 index 0000000000..cd894fe2a4 --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/price_reuse.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Price the reused-helper word under the pinned selected-result screen.""" + +from __future__ import annotations + +import importlib.util +import hashlib +import json +import os +from pathlib import Path + + +ROOT = Path(os.environ.get("P104_REPLAY_ROOT", Path(__file__).resolve().parents[2])).resolve() + + +def load(name: str, path: Path): + spec = importlib.util.spec_from_file_location("p104_private_reuse_" + name, path) + if spec is None or spec.loader is None: + raise ValueError("cannot load " + str(path)) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def main() -> None: + fanout = load("fanout", ROOT / "research/p104-interleaved-search/fanout.py") + budget = load("budget", ROOT / "research/p104-interleaved-search/budget.py") + natural = load("natural_budget", ROOT / "research/p104-interleaved-search/natural_budget.py") + report = fanout.construct(reuse_helper=7)["report"] + engine, _, _, stock = budget.load_inputs() + public = natural.integers(report["candidate_public_profile"]) + private = natural.integers(report["private_COPY_profile"]) + require(private == {1: 2, 2: 1, 3: 1, 7: 7}, "reused private path invoice") + profile = budget.changed(public, private) + expected = {1: 2611, 2: 513, 3: 378, 4: 132, 5: 81, 6: 15, 7: 13} + require(profile == expected, "combined profile differs from scalar replay") + require(budget.mass(profile) == 5885, "combined local rank mass") + width = budget.Q(budget.FAMILIES, budget.STAGES) + coverage_mass = (budget.M - 1) * width + budget.CENTRE + model = engine.model(profile, budget.M, budget.FAMILIES, budget.STAGES, budget.CENTRE) + require(model["local_mass"] + model["idle_mass"] == coverage_mass, + "complete local and idle coverage mass") + zero = engine.relax(profile, budget.M, budget.FAMILIES, budget.STAGES, + budget.CENTRE, budget.Q(0)) + require(zero[0] <= coverage_mass / (budget.M * width) <= zero[1], + "zero-saving coverage moment") + root = engine.ceiling(profile, budget.M, budget.FAMILIES, + budget.STAGES, budget.CENTRE) + require(engine.relax(profile, budget.M, budget.FAMILIES, budget.STAGES, + budget.CENTRE, root[0])[1] < 1, + "lower saving-root bracket") + require(engine.relax(profile, budget.M, budget.FAMILIES, budget.STAGES, + budget.CENTRE, root[1])[0] > 1, + "upper saving-root bracket") + selected_a = budget.SELECTED_KAPPA / (1 - budget.SELECTED_KAPPA) + selected_moment = engine.relax(profile, budget.M, budget.FAMILIES, + budget.STAGES, budget.CENTRE, selected_a) + require(selected_moment[0] > 1, "selected threshold remains excluded") + complex_cap = root[1] / (1 + root[1]) + bit_cap = budget.BIT_LOWER / (1 + budget.BIT_LOWER) + cap = min(complex_cap, bit_cap) + require(cap < budget.SELECTED_KAPPA, "screen no longer rejects selected kappa") + + inputs = { + name: {"path": path, "sha256": digest} + for name, (path, digest) in budget.INPUTS.items() + } + result = { + "status": "SCOPED_LOCAL_COST_REDUCTION_SELECTED_KAPPA_STILL_EXCLUDED", + "predecessor_commit": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "fanout_variant_sha256": hashlib.sha256( + (ROOT / "research/p104-interleaved-search/fanout.py").read_bytes() + ).hexdigest(), + "selected_kappa": str(budget.SELECTED_KAPPA), + "selected_complex_saving_threshold": str(selected_a), + "public_profile": budget.profile_json(public), + "private_COPY_profile": budget.profile_json(private), + "combined_profile": budget.profile_json(profile), + "combined_rank_mass": budget.mass(profile), + "combined_rank_mass_before": 5894, + "rank_mass_saved": 9, + "model": {key: str(value) for key, value in model.items()}, + "saving_root_interval": budget.interval(root), + "complex_kappa_cap": str(complex_cap), + "fixed_bit_kappa_cap": str(bit_cap), + "selected_threshold_moment": budget.interval(selected_moment), + "selected_threshold_excluded": True, + "fractional_rank_51_residual_relaxation": True, + "selected_private_centre_stock": stock, + "inputs": inputs, + "new_kappa_gain_certified": False, + } + print(json.dumps(result, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-private-descent-reuse-seed915fa969/verify_native.py b/research/p104-private-descent-reuse-seed915fa969/verify_native.py new file mode 100644 index 0000000000..dfd259e9ee --- /dev/null +++ b/research/p104-private-descent-reuse-seed915fa969/verify_native.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +"""Run the exact native finite-word checker on the reused-helper variant.""" + +from __future__ import annotations + +import importlib.util +import json +import os +from pathlib import Path + + +ROOT = Path(os.environ.get("P104_REPLAY_ROOT", Path(__file__).resolve().parents[2])).resolve() + + +def load(name: str, path: Path): + spec = importlib.util.spec_from_file_location("p104_private_reuse_" + name, path) + if spec is None or spec.loader is None: + raise ValueError("cannot load " + str(path)) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def main() -> None: + fanout = load("fanout", ROOT / "research/p104-interleaved-search/fanout.py") + native = load("native", ROOT / "research/p104-interleaved-search/native_checks.py") + built = fanout.construct(reuse_helper=7) + witness = fanout.native_witness(built) + result = native.verify(witness) + expected = {"1": 2611, "2": 513, "3": 378, "4": 132, + "5": 81, "6": 15, "7": 13} + if result["status"] != "PASS_FINITE_NATIVE_LOWERING": + raise ValueError("native finite-word replay did not pass") + if result["paid_profile"] != expected: + raise ValueError("native transport invoice differs from the priced profile") + if result["private_paths"] != 8 or result["private_path_gaussian_columns"] != 4096: + raise ValueError("native private descent coverage is incomplete") + if not result["wrong_global_phase_control_rejected"]: + raise ValueError("native global-phase negative control did not reject") + print(json.dumps(result, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() From 3f913bc17276b68f0c9008a1202b6ce588e77ff6 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 19:26:02 -0500 Subject: [PATCH 2/2] Link P104 reuse result handoff --- .../README.md | 2 ++ .../TASK.json | 12 +++++++++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/research/p104-private-descent-reuse-seed915fa969/README.md b/research/p104-private-descent-reuse-seed915fa969/README.md index 079051c5eb..0c584025a3 100644 --- a/research/p104-private-descent-reuse-seed915fa969/README.md +++ b/research/p104-private-descent-reuse-seed915fa969/README.md @@ -17,6 +17,8 @@ selected-threshold moment is still above one and the optimistic complex-side cap remains below the selected κ. This is a local cost reduction, not a new supplier or κ result. +The contribution is packaged in [PR #2219](https://github.com/CrocSwap/integer-mult-bounds/pull/2219). + ## Pins and coordination - Cycle seed: `915fa969cacecdfec5dcd7a95a4bf0a0` diff --git a/research/p104-private-descent-reuse-seed915fa969/TASK.json b/research/p104-private-descent-reuse-seed915fa969/TASK.json index aeffd5a40f..54d2ced1e3 100644 --- a/research/p104-private-descent-reuse-seed915fa969/TASK.json +++ b/research/p104-private-descent-reuse-seed915fa969/TASK.json @@ -43,7 +43,9 @@ "claim": { "discussion": 1167, "comment": 18936581, - "expires_utc": "2026-10-15T01:59:31Z" + "expires_utc": "2026-10-15T01:59:31Z", + "handoff_comment": 18936901, + "released": true }, "overlap_at_claim": { "live_scope_check": "No open PR match for P104 fanout-helper reuse; PR #2152 head pinned above; no competing helper-7 private-descent claim found on the hub.", @@ -96,6 +98,14 @@ "helper_restoration_additions_after": 30, "direct_private_contact_additions": 3 }, + "submission": { + "pull_request": 2219, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2219", + "status_at_submission": "open", + "base": "main", + "discussion_handoff": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18936901", + "scope_correction": "The checked source is PR #2152 fanout.py before the separate coalesced.py rechart; the initial claim said coalesced." + }, "cost_screen": { "scope": "Necessary m=73, P104, COPY56, 832-family, nine-stage balanced-transfer profile model with fractional rank-51 residual packing.", "combined_rank_mass": 5885,