From cc009708e5d7ca1e76a3263eb4e9efce57ac7d10 Mon Sep 17 00:00:00 2001 From: CubeJerry <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 16 Oct 2026 22:46:07 +0800 Subject: [PATCH] Complete native and hosted replay of the R438 bit improvement Complete the PR2653 handoff for PR2423's fixed transported R438 word and rehosting selection. Preserve the native and hosted acceptance predicates, bind emitted owners and remainders to the independent projector certificate, and reproduce the complete exact invoice. No new kappa. Prepared by @CubeJerry with substantial OpenAI Codex assistance; predecessor credit and limitations are retained in the package. --- research/r438-native-rehost/CERTIFICATE.json | 2122 +++++++++++++++++ research/r438-native-rehost/README.md | 167 ++ research/r438-native-rehost/SOURCES.json | 1146 +++++++++ research/r438-native-rehost/TASK.json | 164 ++ research/r438-native-rehost/VALIDATION.md | 107 + research/r438-native-rehost/VERIFY.json | 208 ++ .../requirements-native.txt | 5 + research/r438-native-rehost/verify.py | 385 +++ 8 files changed, 4304 insertions(+) create mode 100644 research/r438-native-rehost/CERTIFICATE.json create mode 100644 research/r438-native-rehost/README.md create mode 100644 research/r438-native-rehost/SOURCES.json create mode 100644 research/r438-native-rehost/TASK.json create mode 100644 research/r438-native-rehost/VALIDATION.md create mode 100644 research/r438-native-rehost/VERIFY.json create mode 100644 research/r438-native-rehost/requirements-native.txt create mode 100644 research/r438-native-rehost/verify.py diff --git a/research/r438-native-rehost/CERTIFICATE.json b/research/r438-native-rehost/CERTIFICATE.json new file mode 100644 index 0000000000..674ef36f72 --- /dev/null +++ b/research/r438-native-rehost/CERTIFICATE.json @@ -0,0 +1,2122 @@ +{ + "base_commit": "389fa10d714f5b40afe624908e487eb5e424498d", + "controls": [ + { + "name": "omitted_candidate_cleanup", + "rejection": "Wrong arbitrary-dirty endpoint" + }, + { + "name": "omitted_candidate_dirty_compensation", + "rejection": "Wrong arbitrary-dirty endpoint" + }, + { + "name": "transport_retains_old_frame", + "rejection": "Frame descent" + }, + { + "name": "emitted_owner_wrong_port", + "rejection": "emitted owner family differs" + }, + { + "name": "emitted_owner_wrong_replica", + "rejection": "emitted owner family differs" + }, + { + "name": "emitted_owner_equal_width_wrong_slice", + "rejection": "emitted owner slice differs" + }, + { + "name": "emitted_rank34_omit", + "rejection": "emitted remainder factors differ" + }, + { + "name": "emitted_rank34_undercharge", + "rejection": "emitted remainder factors differ" + }, + { + "name": "emitted_local_instruction_omitted", + "rejection": "emitted local program changed" + } + ], + "emitted_binding": { + "local_program_sha256": "4c50687a587140a04187db68719499b3536e5c77df0f8178b108033fbc77f71b", + "owner_occurrences": 126144, + "owner_projector_sha256": "5226250b03a365832485f37f0a542dd830258a462f79a9ceab576ea297bcb0ac", + "paid_children": 904320, + "physical_deadlines": 71040, + "profile": { + "1": 380736, + "2": 400352, + "3": 22752, + "4": 26880, + "5": 29376, + "6": 17376, + "7": 26496, + "34": 32, + "42": 320 + }, + "rank_mass": 1808352, + "remainder_factors_sha256": "1e0e20f68af797c3075096ae626b765797004c52eb9046b59cddb517c61a007c" + }, + "geometry": { + "full_generated_artifact": "geometry/GEOMETRY.json", + "h": 8, + "m": 64, + "missing_route_factor_controls": 111, + "ports": 111, + "route_checks": 999, + "semantic_sha256": "5b0e4cf8612a4c309a7d6ac5d305c2cacb173bd1dd3a8c18c7d5ee9e305f15a5", + "stages": 9 + }, + "local": { + "baseline": { + "adds": 24305, + "copies": 9, + "forward_bound": 49347, + "helpers": 439, + "local_bits": 93, + "nine_stage_bits": 177, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "records": 27234, + "registers": 661, + "reverse_bound": 1113070, + "word_sha256": "5642fd0e35a1acc11acff8d0c08350c1617e95f310d4d35ad63a651f9eeeba0b" + }, + "candidate": { + "adds": 24248, + "copies": 9, + "forward_bound": 49347, + "helpers": 438, + "local_bits": 93, + "nine_stage_bits": 177, + "profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "rank_mass": 5121, + "records": 27175, + "registers": 660, + "reverse_bound": 1113070, + "word_sha256": "7aad486877b8c03866b8f1e6f909d12085da347d86aaae891f86f4e2dbc550d1" + } + }, + "no_new_kappa": true, + "normalization": "Original raw geometry/template hashes checked within each run; semantic_* hashes omit only geometry.seconds and rebind that geometry digest in the templates.", + "pipeline": { + "baseline": { + "columns": { + "11": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "global_live_registers": 1549, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 267355, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "5": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121525, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "9": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "global_live_registers": 1327, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218745, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "hosted": { + "audit": { + "bank_assignments": 0, + "deficit": 10272, + "emitted_events": 7843392, + "emitted_program_sha256": "96c7ad2e744e9a503a4ef5ecd52d0f6a8899bdb5efac2e3aafa0db18adf99523", + "hosted_residuals": 126432, + "live": 28416, + "maxchild": 42, + "mutations_rejected": [ + "slot outside window", + "copy index outside family", + "negative slot offset", + "wrong residual width", + "duplicate helper", + "omitted helper", + "hosted owner in another replica or outside the data stock", + "hosted owner on a wrong data family", + "wrong call orientation", + "duplicate call", + "changed idle rank", + "understated live stock", + "missing remainder summary", + "stale stage count", + "hosted coordinate beyond the pending set", + "overlapping hosted coordinates" + ], + "physical": 28425, + "profile": { + "1": 381024, + "2": 400416, + "3": 22752, + "4": 26880, + "42": 288, + "5": 29376, + "6": 17376, + "7": 26784 + }, + "rank_mass": 1808352, + "semantic_template_sha256": "0ee55df480db549c55ad0452cf24d1789f7be0009af159b7f208dc2034f99e1c", + "status": "PASS_INDEPENDENT_REPLICATED_HOSTING_AUDIT" + }, + "invoice": { + "R": 439, + "bit": { + "bank_assignments": 0, + "charged_prefix_bits": 192, + "charged_two_level_coefficient_bits": 512, + "coefficient_bits": 177, + "halving_depth": 2, + "hosted_residuals": 126432, + "live": 28416, + "maxchild": 42, + "physical": 28425, + "prefix_bits": 177, + "rank_mass": 1808352, + "row_coefficient": 18355, + "two_level_coefficient_bits": 393 + }, + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "bit_lower_decimal": "0.001733427039589844234749", + "bit_profile": { + "1": 381024, + "2": 400416, + "3": 22752, + "4": 26880, + "42": 288, + "5": 29376, + "6": 17376, + "7": 26784 + }, + "emitted_program_sha256": "96c7ad2e744e9a503a4ef5ecd52d0f6a8899bdb5efac2e3aafa0db18adf99523", + "next_grid_point_rejected": "6933708158359376939/4000000000000000000000", + "replicas": 32, + "stages": 9, + "status": "PASS_NINE_STAGE_WHOLE_HOSTED_BIT_PRICE_AND_CITED_ASSEMBLY" + }, + "parent": { + "R": 439, + "all_scalar_columns_restored": true, + "bank_assignments": 126432, + "banks_per_stage": 1756, + "bridge_additions": 63936, + "charged_prefix_bits": 192, + "copy_erase_episodes": 2592, + "deficit": 10272, + "emitted_events": 7843392, + "emitted_program_sha256": "3663872061341889b43bd605d4e9a38072a842dab8505ed34ea5aeba3f5656d1", + "entrance_rank_total": 0, + "global_prefix_bits": 177, + "global_prefix_bound": "117742596540718658156527847560864213734191286190080000", + "h": 8, + "halving_depth": 2, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "independent_unbanked_scalar_columns": 4839, + "live": 44220, + "local_additions": 24305, + "local_checks": { + "forward": { + "adds": 24305, + "all_columns": 661, + "cancellation_free_row_l1": 49347, + "copies": 9, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "records": 27234, + "sha256": "a778a0300bbf4b07908ee24c0d271426ba6c70568e788af2f0ac8517897cb5b4" + }, + "reverse": { + "adds": 24305, + "all_columns": 661, + "cancellation_free_row_l1": 1113070, + "copies": 9, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "records": 27234, + "sha256": "98d97804744d691548b4d54868a8a0e5f500c55ab32ac4be96f3ba30e6f5bef8" + } + }, + "local_invocations": 288, + "m": 64, + "maxchild": 42, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "padding_calls": 0, + "paid_calls": 904896, + "physical": 44229, + "profile": { + "1": 381024, + "14": 14208, + "2": 386496, + "28": 14208, + "3": 22752, + "4": 12672, + "42": 14208, + "5": 29376, + "6": 3168, + "7": 26784 + }, + "rank_mass": 2819808, + "replicas": 32, + "residual_bank_slots": true, + "scalar_stages": [ + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 0 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 1 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 2 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 3 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 4 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 5 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 6 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 7 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 8 + } + ], + "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", + "semantic_geometry_sha256": "5b0e4cf8612a4c309a7d6ac5d305c2cacb173bd1dd3a8c18c7d5ee9e305f15a5", + "semantic_template_sha256": "9f3d11b6f0912eaf65eba21ea738caed142e9e11e8f616d0fb0d086214027153", + "source_records_sha256": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a", + "status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", + "v": 111, + "word_sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + "parent_audit": { + "entrance_rank_total": 0, + "exact_bank_families": 15804, + "exact_nested_frame_pairs": 2386, + "exact_reflected_pairs": 2386, + "mutations_rejected": [ + "omit an idle child", + "omit a bridge", + "omit terminal exchange", + "remove a local invocation", + "understate live stock", + "omit a local paid move", + "wrong reflected copy charge", + "alter residual orthogonal basis", + "misstate replication count", + "misstate stage count", + "alias data across stages", + "delay an idle advance past its level", + "truncate the last idle advance", + "re-use a helper bank slot", + "wrong residual frame", + "alias data across replica groups", + "omit the fourth replica group" + ], + "orthogonal_lift_argument": "Adding the same orthogonal E_s leaves P_V-P_U unchanged; each audited projector is therefore the literal child projector in every one of the nine windows.", + "profile": { + "1": 381024, + "14": 14208, + "2": 386496, + "28": 14208, + "3": 22752, + "4": 12672, + "42": 14208, + "5": 29376, + "6": 3168, + "7": 26784 + }, + "residual_isometries": 1, + "semantic_template_sha256": "9f3d11b6f0912eaf65eba21ea738caed142e9e11e8f616d0fb0d086214027153", + "source_frames": 636, + "status": "PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT" + } + }, + "interface": { + "columns": 661, + "conclusion": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copy_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "gates": { + "A": 2075, + "B": 712, + "C": 2574, + "D": 111 + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "interleaving": { + "B_target_reads_of_registers_rewritten_earlier_in_B": 111, + "B_z_operand_kinds": { + "helper<-helper": 3, + "helper<-source": 13, + "source<-helper": 108, + "source<-source": 375 + }, + "B_z_operand_kinds_by_dim": { + "dim4:helper<-source": 13, + "dim4:source<-source": 375, + "dim6:helper<-helper": 3, + "dim6:source<-helper": 108 + }, + "B_z_write_frame_dims": { + "4": 388, + "6": 111 + }, + "B_z_writes_after_a_target_read_of_the_same_register": 454, + "cleanup_gates": 2574, + "helper_writes_B": 16, + "source_writes_A": 0, + "source_writes_B": 483, + "sources_rewritten_B": 108, + "target_reads_of_targets": 0, + "z_gates_A": 2075, + "z_gates_B": 499 + }, + "punctured": 9, + "status": "PASS_EXACT_REPLAY_AND_INTERLEAVED_INTERFACE", + "totals_on_punctured_hyperplanes": true, + "v": 111 + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24305, + "containment_pairs_checked": 2386, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2911, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 27234, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + }, + "candidate": { + "columns": { + "11": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1548, + "fresh_center_copies": 99, + "global_live_registers": 1548, + "independent_dirty_registers": 438, + "local_odd_scalar_additions": 24248, + "local_raw_H": [ + [ + 1, + 1322 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "local_registers": 660, + "local_scalar_additions": 24248, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 266728, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "5": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121240, + "formal_columns_checked": 882, + "fresh_center_copies": 45, + "global_live_registers": 882, + "independent_dirty_registers": 438, + "local_odd_scalar_additions": 24248, + "local_raw_H": [ + [ + 1, + 1322 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "local_registers": 660, + "local_scalar_additions": 24248, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "9": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1326, + "fresh_center_copies": 81, + "global_live_registers": 1326, + "independent_dirty_registers": 438, + "local_odd_scalar_additions": 24248, + "local_raw_H": [ + [ + 1, + 1322 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "local_registers": 660, + "local_scalar_additions": 24248, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218232, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "hosted": { + "audit": { + "bank_assignments": 0, + "deficit": 10272, + "emitted_events": 7826400, + "emitted_program_sha256": "480f8b94801efb971aacf77bd20445a648f73f191b4f630ba193b5eae8f6aa14", + "hosted_residuals": 126144, + "live": 28416, + "maxchild": 42, + "mutations_rejected": [ + "slot outside window", + "copy index outside family", + "negative slot offset", + "wrong residual width", + "duplicate helper", + "omitted helper", + "hosted owner in another replica or outside the data stock", + "hosted owner on a wrong data family", + "wrong call orientation", + "duplicate call", + "changed idle rank", + "understated live stock", + "missing remainder summary", + "stale stage count", + "hosted coordinate beyond the pending set", + "overlapping hosted coordinates" + ], + "physical": 28425, + "profile": { + "1": 380736, + "2": 400352, + "3": 22752, + "34": 32, + "4": 26880, + "42": 320, + "5": 29376, + "6": 17376, + "7": 26496 + }, + "rank_mass": 1808352, + "semantic_template_sha256": "9f5c3c4b7ae658ee0d047b78ba93d26d731ffd4a70181c722241188197cb23bc", + "status": "PASS_INDEPENDENT_REPLICATED_HOSTING_AUDIT" + }, + "invoice": { + "R": 438, + "bit": { + "bank_assignments": 0, + "charged_prefix_bits": 192, + "charged_two_level_coefficient_bits": 512, + "coefficient_bits": 177, + "halving_depth": 2, + "hosted_residuals": 126144, + "live": 28416, + "maxchild": 42, + "physical": 28425, + "prefix_bits": 177, + "rank_mass": 1808352, + "row_coefficient": 18355, + "two_level_coefficient_bits": 393 + }, + "bit_lower": "69393850564807966059/40000000000000000000000", + "bit_lower_decimal": "0.001734846264120199151475", + "bit_profile": { + "1": 380736, + "2": 400352, + "3": 22752, + "34": 32, + "4": 26880, + "42": 320, + "5": 29376, + "6": 17376, + "7": 26496 + }, + "emitted_program_sha256": "480f8b94801efb971aacf77bd20445a648f73f191b4f630ba193b5eae8f6aa14", + "next_grid_point_rejected": "433711566030049787869/250000000000000000000000", + "replicas": 32, + "stages": 9, + "status": "PASS_NINE_STAGE_WHOLE_HOSTED_BIT_PRICE_AND_CITED_ASSEMBLY" + }, + "parent": { + "R": 438, + "all_scalar_columns_restored": true, + "bank_assignments": 126144, + "banks_per_stage": 1752, + "bridge_additions": 63936, + "charged_prefix_bits": 192, + "copy_erase_episodes": 2592, + "deficit": 10272, + "emitted_events": 7826400, + "emitted_program_sha256": "096ac9a98a6e0f941e61a04b7ac721b1006a2276eec35af13a6b45f1f68ad643", + "entrance_rank_total": 0, + "global_prefix_bits": 177, + "global_prefix_bound": "117742596540718658156527847560864213734191286190080000", + "h": 8, + "halving_depth": 2, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "independent_unbanked_scalar_columns": 4830, + "live": 44184, + "local_additions": 24248, + "local_checks": { + "forward": { + "adds": 24248, + "all_columns": 660, + "cancellation_free_row_l1": 49347, + "copies": 9, + "profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "records": 27175, + "sha256": "82853061c90de52f66ca3ea57545fe9d9f028e3a77b6437ea78d26e5b7617864" + }, + "reverse": { + "adds": 24248, + "all_columns": 660, + "cancellation_free_row_l1": 1113070, + "copies": 9, + "profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "records": 27175, + "sha256": "9563caa686bbae6c1aa153dfd589a14ac5b09d5d46c2861f68c3799b1b12b2ae" + } + }, + "local_invocations": 288, + "m": 64, + "maxchild": 42, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "padding_calls": 0, + "paid_calls": 904320, + "physical": 44193, + "profile": { + "1": 380736, + "14": 14208, + "2": 386496, + "28": 14208, + "3": 22752, + "4": 12672, + "42": 14208, + "5": 29376, + "6": 3168, + "7": 26496 + }, + "rank_mass": 2817504, + "replicas": 32, + "residual_bank_slots": true, + "scalar_stages": [ + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 0 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 1 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 2 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 3 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 4 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 5 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 6 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 7 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 8 + } + ], + "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", + "semantic_geometry_sha256": "5b0e4cf8612a4c309a7d6ac5d305c2cacb173bd1dd3a8c18c7d5ee9e305f15a5", + "semantic_template_sha256": "902fe6565d76506a77392111ae8d928018b442a6dad29fc5401ed3579651ccaf", + "source_records_sha256": "4cc2e7032cf9897f93e45ff0c3944d1dd2d6506ad25e5a1140d4cbc91f6af6f7", + "status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", + "v": 111, + "word_sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "parent_audit": { + "entrance_rank_total": 0, + "exact_bank_families": 15768, + "exact_nested_frame_pairs": 2385, + "exact_reflected_pairs": 2385, + "mutations_rejected": [ + "omit an idle child", + "omit a bridge", + "omit terminal exchange", + "remove a local invocation", + "understate live stock", + "omit a local paid move", + "wrong reflected copy charge", + "alter residual orthogonal basis", + "misstate replication count", + "misstate stage count", + "alias data across stages", + "delay an idle advance past its level", + "truncate the last idle advance", + "re-use a helper bank slot", + "wrong residual frame", + "alias data across replica groups", + "omit the fourth replica group" + ], + "orthogonal_lift_argument": "Adding the same orthogonal E_s leaves P_V-P_U unchanged; each audited projector is therefore the literal child projector in every one of the nine windows.", + "profile": { + "1": 380736, + "14": 14208, + "2": 386496, + "28": 14208, + "3": 22752, + "4": 12672, + "42": 14208, + "5": 29376, + "6": 3168, + "7": 26496 + }, + "residual_isometries": 1, + "semantic_template_sha256": "902fe6565d76506a77392111ae8d928018b442a6dad29fc5401ed3579651ccaf", + "source_frames": 636, + "status": "PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT" + } + }, + "interface": { + "columns": 660, + "conclusion": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copy_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "gates": { + "A": 2074, + "B": 712, + "C": 2573, + "D": 111 + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "interleaving": { + "B_target_reads_of_registers_rewritten_earlier_in_B": 111, + "B_z_operand_kinds": { + "helper<-helper": 3, + "helper<-source": 13, + "source<-helper": 108, + "source<-source": 375 + }, + "B_z_operand_kinds_by_dim": { + "dim4:helper<-source": 13, + "dim4:source<-source": 375, + "dim6:helper<-helper": 3, + "dim6:source<-helper": 108 + }, + "B_z_write_frame_dims": { + "4": 388, + "6": 111 + }, + "B_z_writes_after_a_target_read_of_the_same_register": 454, + "cleanup_gates": 2573, + "helper_writes_B": 16, + "source_writes_A": 0, + "source_writes_B": 483, + "sources_rewritten_B": 108, + "target_reads_of_targets": 0, + "z_gates_A": 2074, + "z_gates_B": 499 + }, + "punctured": 9, + "status": "PASS_EXACT_REPLAY_AND_INTERLEAVED_INTERFACE", + "totals_on_punctured_hyperplanes": true, + "v": 111 + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24248, + "containment_pairs_checked": 2385, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2909, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1322 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "rank_mass": 5121, + "records": 27175, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + }, + "hosting_change": { + "hosted_helpers_per_replica": 3942, + "new_remainders": { + "2": 433, + "34": 1, + "4": 444, + "42": 10, + "6": 444, + "7": 666 + }, + "old_remainders": { + "2": 435, + "4": 444, + "42": 9, + "6": 444, + "7": 666 + }, + "returned_idle_rank_per_replica": 72 + } + }, + "projector_receipt": { + "census": { + "deadline_families": 71040, + "factorization_sha256": "7983d077edcf50376dc0f85ae48b1015a1b4e8077d0ba0770973a79451305798", + "families_with_multiple_children": 14208, + "idle_per_replica_including_zero": { + "0": 222, + "2": 433, + "4": 444, + "6": 444, + "7": 666, + "34": 1, + "42": 10 + }, + "occupied_families": 28096, + "owner_projector_sha256": "5226250b03a365832485f37f0a542dd830258a462f79a9ceab576ea297bcb0ac", + "physical_helpers": 126144, + "qperp_host_occurrences": 21312, + "slots": 3942 + }, + "children": 904320, + "control_witnesses": { + "replica_basis_witness": [ + 888, + 22 + ], + "wrong_exterior_axes": [ + 30, + 8 + ], + "wrong_port_basis_column": 0 + }, + "controls": [ + "source_byte_corruption", + "missing_helper", + "duplicate_helper", + "split_qperp_slice", + "stage_outside_window", + "omitted_rank34_remainder", + "duplicate_rank34_remainder", + "equal_rank_wrong_exterior", + "equal_rank_wrong_port_operator_witness", + "wrong_replica_dirty_basis_witness" + ], + "deficit": 10272, + "distinct_factorizations": 12, + "exact_basis_columns": 170496, + "global_profile": { + "1": 380736, + "2": 400352, + "3": 22752, + "4": 26880, + "5": 29376, + "6": 17376, + "7": 26496, + "34": 32, + "42": 320 + }, + "local_profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "port_projectors": 111, + "predecessor_head": "13cd273dc13c98244b1f9bcf588b6e828cbc0347", + "rank_mass": 1808352, + "scope": "finite changed-placement projector binding; no new endpoint or supplier admission", + "selected_control_helper_occurrences": 126432, + "status": "PASS_R438_REHOST_PROJECTORS" + }, + "schema_version": 1, + "selected_context": { + "binding": "complex", + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "complex_lower": "67018507072324140917/40000000000000000000000", + "kappa": "836330098538459/500000000000000000" + }, + "status": "PASS_R438_NATIVE_REHOST" +} diff --git a/research/r438-native-rehost/README.md b/research/r438-native-rehost/README.md new file mode 100644 index 0000000000..3fda84469c --- /dev/null +++ b/research/r438-native-rehost/README.md @@ -0,0 +1,167 @@ +# Native checks and hosted emission for the R438 bit supplier + +**A complete finite native/hosted replay of the PR2423 improvement. No new κ.** +This package takes the explicit native-emission handoff in commdata2338's +[PR2653](https://github.com/CrocSwap/integer-mult-bounds/pull/2653) and +[Discussion1289](https://github.com/CrocSwap/integer-mult-bounds/discussions/1289). +It emits Sagar Thakrar's fixed transported R438 word and rehosting selection, +checks the actual emitted owners against the independent geometric certificate, +and runs the complete native, parent, hosted and exact-price pipeline. + +The circuit, selection and predicted endpoint belong to the predecessors. +The new result is their source-bound emitted realization and complete finite +replay, including the previously untested rank-34 remainder. This does not +promote a selected supplier or settle the inherited all-size interfaces. + +| Complete bill | Selected PR589 control | PR2423 emitted candidate | +| --- | ---: | ---: | +| Dirty helpers per local call | 439 | 438 | +| Local ADDs, including compensation/restoration | 24,305 | 24,248 | +| Local COPY / ERASE pairs | 9 | 9 | +| Local paid rank mass | 5,129 | 5,121 | +| Whole hosted helper occurrences | 126,432 | 126,144 | +| Paid recursive children | 904,896 | 904,320 | +| Global paid rank mass | 1,808,352 | 1,808,352 | +| Live data families | 28,416 | 28,416 | +| Nine-stage precision charge | 192 bits | 192 bits | +| Two-level precision charge | 512 bits | 512 bits | +| Exact bit endpoint | 0.001733427039589844234749 | **0.001734846264120199151475** | + +Both moment engines accept the reported endpoint and reject the next point +on the `10^-24` grid. The candidate is about 0.08187% above the selected bit +endpoint. The selected complex endpoint remains +`0.001675462676808103522925`, below both; the selected overall result remains +`κ = 836330098538459/500000000000000000`. This work does not combine pending +complex claims with the bit candidate. + +## What is implemented + +Ali Romman's PR1043 `pipeline.py` is imported from its pinned source without +editing it. Its selection callback is replaced with a small adapter that writes +PR2423's published patterns and stage demands. No emission, geometry, mutation, +precision or moment acceptance predicate is replaced. The old selection format +requires a floating heuristic field; the adapter recomputes that metadata using +the predecessor formula, but it is not used to certify a price or optimum. + +The original baseline and the candidate both run through the unchanged C++17 +legality checker and native five/nine/eleven-stage formal-column checkers. +The candidate has 882/1,326/1,548 formal columns; the baseline has +883/1,327/1,549. Local arbitrary-dirty replay covers all 660 candidate inputs, +and the original H1–H5 flags and their conclusions all pass. + +The unchanged supplier pipeline then emits and audits the parent and hosted +programs and computes the complete invoice. The new `bind_emitted` bridge +compares all 126,144 **actual emitted** helper owners to PR2653's independent +slot expansion, physical family identities and projector supports. It also +compares every emitted remainder histogram, requires the local programs to be +unchanged by hosting, and independently recounts the global profile from those +program costs and emitted remainders. The owner/projector digest must equal +PR2653's independently reconstructed digest. + +The rank-34 remainder is the actual complement `[30,64)` of the helper slice +`[22,30)` inside child 6's pending `[22,64)` space. It occurs once per replica +and is charged 32 times. Deleting a helper returns 72 idle-rank units per +replica (2,304 globally); those charges are retained. The global profile is +`{1:380736,2:400352,3:22752,4:26880,5:29376,6:17376,7:26496,34:32,42:320}`. +The maximum child remains 42, with `2*42^2 < 64^2`; the row coefficient is +18,355, below 20,161. All source access, nine copied totals, local cleanup, +whole-helper occupancy, idle remainders and bridge work are included by the +unchanged pipeline. + +## Reproduce + +Python 3.12, C++17 and Boost headers are required. Install the recorded Python +versions in a virtual environment using `requirements-native.txt`. Set `CXX` +if needed, and `BOOST_INCLUDE` to the directory containing `boost/` if it is +not `/usr/include`. From the repository root, run: + +```sh +python3 -B research/r438-native-rehost/verify.py +``` + +Expected last line: + +```text +PASS_R438_NATIVE_REHOST native=5,9,11 owners=126144 children=904320 c=0.001734846264120199151475 no_new_kappa +``` + +The default uses a temporary directory and compares the entire normalized +certificate with `CERTIFICATE.json`. `--output /absolute/new/directory` retains +the emitted templates, commands, logs and full receipts. The destination must +not exist. Only timing, toolchain metadata and the pipeline's explicitly +historical cited-PR548 outer assembly are excluded from the new certificate; +all mathematical fields of its native and hosted receipts are retained. +The inherited geometry JSON includes elapsed time. Every original geometry +and template hash is checked within its own run, then `semantic_*` digests +omit only `geometry.seconds` and rebind that stable geometry digest inside +the templates. That digest binds every other geometry field; the full generated +geometry remains in the replay output rather than adding a second large copy +to this package. +Source archives are byte-pinned; template identity uses decompressed canonical +JSON, and histogram keys are normalized before comparison. + +The registered standard-library command is deliberately a **local-only** +check: `python3 -B scripts/research_package.py --package research/r438-native-rehost`. +It rechecks source pins, both local words, the exact projector certificate and +three candidate faults. Its marker says `native_not_run`; it does not stand +in for the full command above. All modes reject `-O` because inherited engines +use assertions. `--write-certificate FILE` is an explicit fresh-output mode +for rebuilding evidence, not a comparison against the committed certificate. + +## Failure detection and scope + +The complete run retains 96 native omitted-bridge controls across the two +words, 34 parent-template mutations and 32 hosted-template mutations. +PR2653's ten geometric controls/witnesses are replayed. Nine new controls +reject omitted cleanup, omitted dirty compensation, the old transport frame, +a wrong emitted port, a wrong replica, an equal-width wrong slice, an omitted +or undercharged rank-34 remainder, and a deleted emitted local instruction. +The selected R439 program is the positive end-to-end control. + +This is finite conditional construction evidence, not a formal proof of the +full multiplication theorem or an implementation of its physical machine. +The common-label/mutable-source realization, correlated whole-call hosting, +injective cover/all-size compiler, recursive physical storage and routing, +precision/tape and analytic-transfer contracts remain inherited. Native scalar +columns alone do not prove those contracts. PR2653 supplies the geometric +argument, which is reused and bound to the emitted program here; it is not +presented as a new independent proof. The historical PR548 outer assembly +happens to execute inside the original pipeline, but is not used as the +current frontier or as evidence for a new κ. The selected cold replay, full +repository suite and Lean are outside this contribution. + +Exact sources are in `SOURCES.json`; the task, three alternatives, seed 08, +local claim, overlap coverage and stopping rule are in `TASK.json`. +Research base: `389fa10d714f5b40afe624908e487eb5e424498d`. +Dependency heads: + +- PR1043, Ali Romman: `e309e17f83f5759b1ea1fa24a76f24838784cb4d`. +- PR2423, Sagar Thakrar: `13cd273dc13c98244b1f9bcf588b6e828cbc0347`. +- PR2653, commdata2338: `ff26f4477786cf9ab188e060d6820a39dd2ed117`. +- PR589, DreamingOfClouds: `a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46`. + +PR1043 is archived but remains partially reviewed; PR2423 and PR2653 were +incorporated only within their explicitly scoped reviews. Their unresolved +native-emission handoff, not their merge status, motivates this work. + +## Open next questions + +Review this exact emitted candidate against the retained all-size physical +interfaces before any supplier admission. The concrete first step is to bind +its local program and owner digests to those compiler/hosting hypotheses; +finite native execution does not supply a complete physical routing proof. +Any future overall improvement also needs a stronger admitted complex supplier. +No further packing or transport search was performed here. + +## Credit and license + +Prepared by **@CubeJerry**, with substantial **OpenAI Codex assistance** in +scoping, implementation, mathematical checking and writing. No independent +human review or proof-kernel certification is claimed. + +Credit Ali Romman for helper470 deletion and the complete source pipeline; +Sagar Thakrar for the transport, optimal fixed-slot layout and predicted price; +commdata2338 for the pending-projector proof and independent census. Retain +DreamingOfClouds, eumemic, DaysSky, Zhihao Chen, chafreaky, the PR555/543/545/510 +and PR442 hosting lineage, PR1023 packing, and the seed72/seed14 window work. +Their sources and notices are imported unchanged. New material is Apache-2.0. diff --git a/research/r438-native-rehost/SOURCES.json b/research/r438-native-rehost/SOURCES.json new file mode 100644 index 0000000000..7159ab8a14 --- /dev/null +++ b/research/r438-native-rehost/SOURCES.json @@ -0,0 +1,1146 @@ +{ + "schema_version": 1, + "base_commit": "389fa10d714f5b40afe624908e487eb5e424498d", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "research/bit-boundary-persistence/CERTIFICATE.json", + "usage": "input", + "git_blob": "56400920050c523e6e399f2455137b36c35cf528", + "sha256": "32c6cd6103006d627909cabdaf5083238c661a6582016a8b21075bd01c892eff" + }, + { + "path": "research/bit-boundary-persistence/FRAME-PATHS.json", + "usage": "input", + "git_blob": "b1862b43e1fa1ee0fb02e29b303801265638dae4", + "sha256": "0d347b9e4d8a8336a707565deceb1d505cd138c97a56831643583b83d91c3b4f" + }, + { + "path": "research/bit-boundary-persistence/build.py", + "usage": "input", + "git_blob": "074d045cf6a5de84f67bd772ae422edc051d3c6e", + "sha256": "58f402c365eb18b9c3dd736523999676f1d1652e40c1a9b4f6967c1b7acb72df" + }, + { + "path": "research/bit-boundary-persistence/pipeline.py", + "usage": "input", + "git_blob": "a2f6eb503faf4de86143a45ec91cd5be14f32478", + "sha256": "0adb958461b67d48cd3a32c3c235afd73692d51949083899324f090a5a9b2f22" + }, + { + "path": "research/bit-boundary-persistence/verify.py", + "usage": "input", + "git_blob": "8da708efb7f74e1fa7119975a10586a65f0ba5af", + "sha256": "34a76019c5371acccfa8ccbf267a4bc0285ba44001ee8688f140085943cd2bc7" + }, + { + "path": "research/bit-r438-transport-rehost/verify_rehost.receipt.json", + "usage": "input", + "git_blob": "c2fb443f44f2c7c420cd367ab5fa12644efe318a", + "sha256": "06fa9322508aba3d8a5dc6469151cdfaa906b60559582b49c8b024428b158021" + }, + { + "path": "research/bit-r438-transport-rehost/verify_transport.receipt.json", + "usage": "input", + "git_blob": "fae72f779c1b6b992878b0e44edd9490a43d6636", + "sha256": "662ce03a62c00d79830e0d1d2948fea70a095e297342baa4931ebcf36f6a8d90" + }, + { + "path": "research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "usage": "input", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "path": "research/community-frontier942-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "9e71e9c1a1c1cbd1979f0c7bac87495322cbfad0", + "sha256": "4b2894956e594e408e111d806c842f2ed2c32aefcadff93fad69ff0b46f1991a" + }, + { + "path": "research/e8-bit-carrier-skeleton/EXPECTED.json", + "usage": "input", + "git_blob": "973aaf30f1ec6a4d58038acabb9361ee1f44787a", + "sha256": "3494ba83280cc86548fe0cc6695c50d23e6b6ffca85aeb1a33337c1196e280cb" + }, + { + "path": "research/e8-bit-carrier-skeleton/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/e8-bit-carrier-skeleton/MANIFEST.sha256", + "usage": "input", + "git_blob": "1213654fbd423d66e785bf582ba8ee76a41cdd36", + "sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297" + }, + { + "path": "research/e8-bit-carrier-skeleton/NOTICE.md", + "usage": "input", + "git_blob": "5a0ecdcd2c7fad0488740a1da0f633b73b56a809", + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a" + }, + { + "path": "research/e8-bit-carrier-skeleton/README.md", + "usage": "input", + "git_blob": "dd0d7c43611d6c527a17287bc550e763edca0294", + "sha256": "e5212e8058c92a2b02cc12b4e174a65ce1cef7b4d7977ae770e64f5ff91b7204" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr370.json", + "usage": "input", + "git_blob": "1b30f277afa20cb9db1e4495d655a32d64552317", + "sha256": "03de1d341196cfa8cf1d39f3cc8648b25bb5f39c3c602a728cfbd089e8253ac0" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr381.json", + "usage": "input", + "git_blob": "fb0b0edd1375ffcbe9b2c9065bcca236a974660f", + "sha256": "16b1977240ca9acb58fa64572fb4231a423bc10bbf3e7bb30f1c8201fe369ba5" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr386.json", + "usage": "input", + "git_blob": "3744861904f61f29b00e2dec9cb98639a0fb7dfe", + "sha256": "87c659ba932525631a40be14dca28a6a2efade8641f23bb08d6e1567fc991131" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr436.json", + "usage": "input", + "git_blob": "f190527ae1c97a51fa9030518b59affeb0befcd3", + "sha256": "4a4f99f5bdb7530a0dcf9433f7f02afbf2abf908e718f7c63ffa5503d4f49693" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr445.json", + "usage": "input", + "git_blob": "ae29de391a7aa893bec6ab8c2b6e89688191b088", + "sha256": "e6f4a272442bb71ef68aaa3545b271236f9c99297e444fa01c62b0b5fb6a170f" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr448.json", + "usage": "input", + "git_blob": "3648ab36928a28564ce89d224cfb3f16c891ecf1", + "sha256": "c771fa9be492408a78d6d970c839e68c4dfd1b66f4f4a4748e3d12726a43cf27" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr451.json", + "usage": "input", + "git_blob": "fbd9881e09d7219f264eb1ee67c40c2e43d0832e", + "sha256": "a639956eec858341987a815b7464ef472505300db754b5f9ac012dd01d18c8df" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr458.json", + "usage": "input", + "git_blob": "c36c74cbeacf690473803b59a8d25008ec5a7710", + "sha256": "cbdea984a46ab5de354b95e73fd76c1918fdc6676c658398a552772c4dc3dcaf" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr471.json", + "usage": "input", + "git_blob": "0dc019cfb1933e55d063fbd9e45bb316e4045857", + "sha256": "499d861e090c9e646d978dd67890a8e58a9ff6bf08512684e66605179132076b" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr472.json", + "usage": "input", + "git_blob": "31acb027ecd0808f18e6f59c59662f6f94f5b9ac", + "sha256": "6753bcf50c91806b75dd4dbe3963a79699a614d0dab8ce32b261cc3e76b288b1" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr473.json", + "usage": "input", + "git_blob": "821caf8f073c615680ba5610e268eee2d23d2d03", + "sha256": "2515c4f23dfa22a21913d92597669770f7f44c2a5b3ef069ef68a0c89779a656" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr478.json", + "usage": "input", + "git_blob": "608323ccbe4150d5a6522ddb3b18aa9cb5dff4fa", + "sha256": "9c7c4ea678865a955b0c89f0952927159976fdf55cadc6a488dec5757f03fe7d" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr483.json", + "usage": "input", + "git_blob": "817396d9c89965a32979b943e638163d8261a205", + "sha256": "24e3eab4a985e115adb7f8665a401423e9636e9f16cc4373ec68cc86950445a8" + }, + { + "path": "research/e8-bit-carrier-skeleton/SOURCE-pr484.json", + "usage": "input", + "git_blob": "76292df8518ac72acb3754a7b4fb23c368725b13", + "sha256": "b92f43fbcba3921a1aa37bcb9f05cf5fa612ff708785e05512438a6317bf0867" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp", + "usage": "input", + "git_blob": "00c5a3a5d81d083582f60f33dd2e7bea5049c37f", + "sha256": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp", + "usage": "input", + "git_blob": "42bb232fbec4de703e70cc13dc2f39a3b43a3a01", + "sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py", + "usage": "input", + "git_blob": "b740d47295c02692260d7cc01874a49fe48f78ab", + "sha256": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp", + "usage": "input", + "git_blob": "82d69f7c5d044c9887c96b90c97f5639083ecd14", + "sha256": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp", + "usage": "input", + "git_blob": "cb1233c7e96b1aa8bbf4d2e4165d75ab0dca64b9", + "sha256": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/export_records.py", + "usage": "input", + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/independent/checkword.py", + "usage": "input", + "git_blob": "da4e0fe05067184d4dab1e130ae1384c1fa983f5", + "sha256": "11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/independent/interface.py", + "usage": "input", + "git_blob": "8beb87c39a07e389c8f83f32ab9d17f8097ed9b1", + "sha256": "2c63a039f97e3a11ce5a6b83302d4f5beda160c1db14164a5a9b0855aeb19d3c" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/independent/mutate.py", + "usage": "input", + "git_blob": "eba592fd468e0d7e7e5100fe99da6eb548c5906b", + "sha256": "0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/independent/mutate_mut.py", + "usage": "input", + "git_blob": "f4c6191b783094c4d241f179446085331feb052b", + "sha256": "3b002c19a5dcca76a5594f2a30fac7c01d2b45fc96b3e7cfbfd8b720f5ffb4e8" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/independent/relax.py", + "usage": "input", + "git_blob": "a37e8b8176080d4a977bb48bd25f92f4a62b156b", + "sha256": "d6e9f58de3fa41f538516b6227c249d61fb30f0f6843027cc8a07a1a372fa6b6" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/mutate_records.py", + "usage": "input", + "git_blob": "6794516f665d36eac189894e350a5ad01113cb4c", + "sha256": "b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/mutate_records_mut.py", + "usage": "input", + "git_blob": "ea26fcebf99312eb5d4f5440862959fa6a74ec52", + "sha256": "a9e085ec60d5657cd5d77832e3d95004e81b9f4f249d9e0fc95e345366cb2d2e" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py", + "usage": "input", + "git_blob": "f6d7afe3e623208c4207b6a683a1e3e49249e31c", + "sha256": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/cited.py", + "usage": "input", + "git_blob": "e543cf2c9b2b1d43693bed6efbdba607ad9ac277", + "sha256": "a4c2dd4755f2a45ceda327b36d9ee400c2804893000626ca8ff3f6ee296fd842" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/eleven/adapt.py", + "usage": "input", + "git_blob": "c13c91c245146670d4b454ff07b835f480171fc1", + "sha256": "d8a8c13b484d985f0133a5d06de4a78b8477314f922b9f693ba73640b7184d6b" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/eleven/assemble.py", + "usage": "input", + "git_blob": "87cc45bc831fa7003906e8b026ac1480a69da1de", + "sha256": "c47889a606701ae592374dd82a13cee8c5a4e8449b7facfdad2d90563a30a18c" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/eleven/audit.py", + "usage": "input", + "git_blob": "10e47d32e3b4769ae5ce5bad9f76a7b3e5d797fc", + "sha256": "5ad832830c19ec6c904d1b64480f6b1e71c5673fdd38d487d17e179b1d197c09" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/eleven/emit.py", + "usage": "input", + "git_blob": "640cdb4d1220950e198f2fd9994d76d69ecbf764", + "sha256": "b0b25955875625ed63f82690f83aef976e3e9a978ae6620b23a23fc1207acd46" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/eleven/local_audit.py", + "usage": "input", + "git_blob": "2233c5f35f2fcb58809f7a1d8f91e9b36ad74080", + "sha256": "95275473d7f9811011bda760dd0f04de5169c2a6922456dc9a5725a5d671f941" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/assemble.py", + "usage": "input", + "git_blob": "cd60b4bcfae515fccd7f21fd1ff5a7114a132eb9", + "sha256": "abb60c35e448e0f94073f38a0352d11249aaf7bb8dbd7352414ae60a1d2b79c3" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/audit.py", + "usage": "input", + "git_blob": "155b61f2944116423a5be6ae666276e1c1827fe5", + "sha256": "d28062127a9b0d3866a3b79aad98a307233b20ebdb94cfb9f197d726b82ffea5" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/emit.py", + "usage": "input", + "git_blob": "df74ad698a98419e828b37d4dfd7c036fc49a890", + "sha256": "98d77cefbc3a76f9f10bd7df3a2590ab88b411f6afe77b5f8d73f1602eb2bef3" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/local_audit.py", + "usage": "input", + "git_blob": "931f884920125b334412f70cf30d9517b084dc7a", + "sha256": "23eda3fe3d774e7f2dbf4dbdd4ff90d69ae7d1762ff95c8629cdc7667aa3fe71" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/hosting.json", + "usage": "input", + "git_blob": "381fb06ccbe055f4fbdc7544dcf8c0bae8f96701", + "sha256": "765382d4fefd594e94c8c5826ec6300422ce9f79c816d7f7323ef85e99320f28" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/residual-isometries.json", + "usage": "input", + "git_blob": "5864e4d680035401d53d32adab0369046d80b171", + "sha256": "750221cc66badd0ed0a74e7aad2d59f91f89c107370af21c6d929fbdd4a08a9f" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/word.json.gz", + "usage": "input", + "git_blob": "f7d55b8bd45d385011ced25e632a3d922bb77bba", + "sha256": "b2af02f593cd161bea64e6cd793508386914136be519f80726c071697379d5a9" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/bank_routes.py", + "usage": "input", + "git_blob": "9e43a876664a26899762f3b8e9a582e684a3650a", + "sha256": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/e8core.py", + "usage": "input", + "git_blob": "78983b368715e89fe8524a6dd2c13585d2b5394e", + "sha256": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/base_two_moment.py", + "usage": "input", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/moment.py", + "usage": "input", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/outer.py", + "usage": "input", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/tile_m.py", + "usage": "input", + "git_blob": "cd5fd9b5399f5e7afe5d2a95bd3504bd543c0d60", + "sha256": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/residual-isometries.json", + "usage": "input", + "git_blob": "9b8b35cb1528a978e209e1098864cae48c57fd93", + "sha256": "e12ed7ddd13cee101ba74a083b54665fd64d0b122b0bad5b83d817dcc8bae9d8" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/word.json.gz", + "usage": "input", + "git_blob": "85390b07e4747feddbf2e16f94b5e0a8a308c191", + "sha256": "d8d6d3d3f336720302bc40b3c1504fe3c3583a7a8d707bb9bd7b21f85e5e69c6" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/idle-axis-hosting/hosting_core.py", + "usage": "input", + "git_blob": "68b536daa9e6546c0aa046934bf840aaa3c3fde3", + "sha256": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/emit.py", + "usage": "input", + "git_blob": "5ff0de0d6f088ac95e25a2a7aed8653e8cd0333e", + "sha256": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/geometry.py", + "usage": "input", + "git_blob": "b4ad5074014dc00a01143910eb1cd27fafe0e15c", + "sha256": "9554182d67e434ea84b4430f909a2c400abc755d8487b51454a8e6968e62859d" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/row_bound.py", + "usage": "input", + "git_blob": "11d3c0d48e4ea5a02ac3b6689f3c7d36f2972eb8", + "sha256": "de4a9b9cd797e1a05da56f62cfe725c8728cea3a4aa031b7d1b0a68f869760d6" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/data/selection.json", + "usage": "input", + "git_blob": "8e548e5a9204a909d539ba36b866804b256d4c2b", + "sha256": "52dbbb68e8c147690d15eaa1d952df05d074b0c121885a4159d9f6732f391872" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/code/emit.py", + "usage": "input", + "git_blob": "5ff0de0d6f088ac95e25a2a7aed8653e8cd0333e", + "sha256": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/residual-isometries.json", + "usage": "input", + "git_blob": "ec8b4131d203d7a288ca078ca559f922d38fe9d2", + "sha256": "b23fda74a7979179e8fd83ee9870c1e232442cc90c05077adaabfe31d050d1e4" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/selection.json", + "usage": "input", + "git_blob": "c57069f7385c3b6aff4fe3c73c0a21bae727c76f", + "sha256": "4d9c2cf6a3d31a6faa287731e0721cb16601b0bc5c1a186b9645bfb5760ce8db" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/word.json.gz", + "usage": "input", + "git_blob": "3c8489a29f0de2cad7dafaddc340a1ff197d5172", + "sha256": "41626789888ee070e1b435fa380b10ab9b88e3cf7d8d8e166ecef17269bbcf47" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "usage": "input", + "git_blob": "91594e0223e8fac49162b5aef834ffaa8e94a254", + "sha256": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/pricing/base_two_moment.py", + "usage": "input", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/pricing/moment.py", + "usage": "input", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/pricing/outer.py", + "usage": "input", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py", + "usage": "input", + "git_blob": "7f16d930302ae879c562dd58e085d9747fcac077", + "sha256": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/provenance.py", + "usage": "input", + "git_blob": "9bfcb106230e454d9405ce5eb42dd2218d905ea6", + "sha256": "e28fd87d0e34a6f6f6f1fddb6c4891deac220662c954de855d7aa5a7f9cceca4" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/skeleton/e8.py", + "usage": "input", + "git_blob": "92e83a2e0c1f67551f583630a728b2a880b06f51", + "sha256": "721d859a6517d665ca84d03ef89668da3aae7433ffb0ee47faf37f2aeb85450e" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/skeleton/gen.py", + "usage": "input", + "git_blob": "9811c127d41521e906462a75322a29f0e193629c", + "sha256": "7cdcf48078ed4beacd2e240aa8145e4aa6984558748d07659cb1b252786e073a" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/skeleton/geom.py", + "usage": "input", + "git_blob": "9e5fe3a781dc52e07b7c5de3a44c8be6f5024cd4", + "sha256": "bb356568fa05e7bfd5fcd9012903611cf742729a99b4dc3a13685355b2678ae3" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/skeleton/wordkit.py", + "usage": "input", + "git_blob": "7cc4e6d618d9d0166efe8be75a019b6aecee0582", + "sha256": "2b6c12d96f24a4e81f2c807827c2b74cf80037367fc8034e8c871dd5ce008351" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "usage": "input", + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/bit/bitE8mut-r489.json.gz", + "usage": "input", + "git_blob": "ef67bec220c96a1de7b87c9f1a6e7acb26cb3284", + "sha256": "835eb96e147740fc7454f8cfb3dbd34ae89524b1dbd89a61e9288eae8ab6a5b9" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex-b.json", + "usage": "input", + "git_blob": "0df48f8e590fc9ad01ca4d6eaf97b9acc10aac7d", + "sha256": "dce3f4b76aa3f6c3ba826ce556ffa61398b33e81e4d1a226dd2a36ce684fb02e" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr448/EXPECTED.json", + "usage": "input", + "git_blob": "1574e6488b6fc59191ae49fcc0c089e48b196fbd", + "sha256": "18b42250c3faf6f0df76fcab6c3a483582192ad7bb09cb1985f4b0bb91d67024" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr458/EXPECTED.json", + "usage": "input", + "git_blob": "e06a17c177eee0e0962c96ea61554239ef38ef4d", + "sha256": "a4312cb0c53c2066a28b683a971a41e7d76c5f6d828a96481c3ae7b3c01bb2f3" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr471/EXPECTED.json", + "usage": "input", + "git_blob": "ed1e72239ebebdbfad847fb817e5546f980c1d8d", + "sha256": "188f9d1a7450496dbfd8d64381febd20b0597141537eb1a003435297df2d1720" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr473/EXPECTED.json", + "usage": "input", + "git_blob": "45ee9fde7fdf6b19b6303372068977201b4ef61c", + "sha256": "70e515f0a5a2f9508cd030d35a99f90981a6eccc027c9ad5a3c77f5860310910" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr478/EXPECTED.json", + "usage": "input", + "git_blob": "77f5805cd8125602e8c50f4eaba1691440c611c2", + "sha256": "07bd05d14c71df8925b0b03510b2b337334b73ac425a94e03b2ec34ed2680164" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr483/EXPECTED.json", + "usage": "input", + "git_blob": "f7ff643cd54a334bf46c82989ba155eb6e69adde", + "sha256": "799fa4ab2f785c478c3cdcb6c1c0428a5ce6e3ddbe4a4b2fd88630d811a593f6" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/complex/pr484/EXPECTED.json", + "usage": "input", + "git_blob": "7f93fcbb9f1c2799fd86dd308ec1e6f0ad2a3264", + "sha256": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/eleven/hosting.json", + "usage": "input", + "git_blob": "72b63ff0866db6aec50ecd356d7d007b17bf6475", + "sha256": "61f790657c465d16d3455f48f90f816797b9ea08bf02dbd0c90d2cf41836257e" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/eleven/residual-isometries.json", + "usage": "input", + "git_blob": "5c645b267861fd0994d2679885f8e0bbf99640b0", + "sha256": "0fa5b353a0321af2ce4e2045db1d4c2d6418a11663894e2afcdb1eaa1984bddc" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/skeleton/d4part-pairs.json", + "usage": "input", + "git_blob": "7ea439877369b6c2e94bb47980d08944d61454fb", + "sha256": "d69ffe3326140bc541b8f1639e02db43a5835ab8ca02cc742b5bee2bf2ef1ba9" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/skeleton/plan-skB.json", + "usage": "input", + "git_blob": "52e341f4f0b441ff88897162cc9f25eb72f34405", + "sha256": "f6162bb4d8092bc233700fa7ebc6a0d79f2893135aee18e998369044abb3f44b" + }, + { + "path": "research/e8-bit-carrier-skeleton/discovery/README.md", + "usage": "input", + "git_blob": "751a9e82df9c860b496affd423b938cb008e2d88", + "sha256": "b09aa45d5651720e10326cde559c863ba3ea45fe2fb6b4aaa3bfaa66a8fcf69f" + }, + { + "path": "research/e8-bit-carrier-skeleton/discovery/d4part.py", + "usage": "input", + "git_blob": "ed7418a0800321d7629e86b4946f77e8cf60a044", + "sha256": "a64927c340a4772ce0682b349e0c90c80d1a766000ccf397fb41b36a31929179" + }, + { + "path": "research/e8-bit-carrier-skeleton/discovery/host_select.py", + "usage": "input", + "git_blob": "5b50de453ddbd90d433f9ea8ed584308e7ab2d0f", + "sha256": "2aaaac18e083d289d4341e734c32571c89c51fefba04b388d407c7372b906dc7" + }, + { + "path": "research/e8-bit-carrier-skeleton/discovery/plan.py", + "usage": "input", + "git_blob": "050a3ca42bad8b3d34d149607a7c67de39a52356", + "sha256": "40e8dea1b4b71c5afd5993625f57bcac089dd2f72dfbc4dbc23ce917e5a61010" + }, + { + "path": "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h", + "usage": "input", + "git_blob": "fc5664e929d9a81d9b4926bee049a93330be86ec", + "sha256": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99" + }, + { + "path": "research/e8-bit-carrier-skeleton/requirements.txt", + "usage": "input", + "git_blob": "05bdf190fff0fda4cf958441aa15b9d7a9239ad4", + "sha256": "6023d480f929cdfa4e2f35e361eea003451cd6695af806935a32038b0115abb5" + }, + { + "path": "research/e8-bit-carrier-skeleton/verify.sh", + "usage": "input", + "git_blob": "dd7df2a4445f5a8b0d5e336a855a930ab5d34bee", + "sha256": "0f9248aa3611dfe2b5d59dbe992c6f7d21a0cc4f1de2b5ed05a6110191191224" + }, + { + "path": "research/e8-bit-p111-tuned/DEPENDS.json", + "usage": "input", + "git_blob": "25cb6abcf9ce8d48191f3fdfae44be136537796c", + "sha256": "fa9253078c444b8f4a57e849048f727c3c8233c3dc3c7f651bef2cf7bb0178c5" + }, + { + "path": "research/e8-bit-p111-tuned/EXPECTED.json", + "usage": "input", + "git_blob": "c8ad4439e83f07bcda437598d6a4c31f4e65f2a9", + "sha256": "7c2675fd49afd7e328606399a4421fd49c43fe8a6c5b57154cc908c00588abe2" + }, + { + "path": "research/e8-bit-p111-tuned/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/e8-bit-p111-tuned/MANIFEST.sha256", + "usage": "input", + "git_blob": "98b1e7e0029d082f82d4f7b8fe5a20ebae8fadbb", + "sha256": "8d8fc2625b71b835176b666385c69fa4d1e4c5839e8e601924db2c9261761310" + }, + { + "path": "research/e8-bit-p111-tuned/NOTICE.md", + "usage": "input", + "git_blob": "b589500c8ae02a0a4c476e61dfdd1b79dcbf7cad", + "sha256": "5b88eb2b7de76aa2a3288ee3c7a08d18a5eadfa82f5e7a99e207d232aed71221" + }, + { + "path": "research/e8-bit-p111-tuned/README.md", + "usage": "input", + "git_blob": "40dff2216e65ebba0be490ad962e869876a45286", + "sha256": "a054ce8453e2936d45c4edd1c3678993903fcf6705ac241b9f1a4c4f9accda2d" + }, + { + "path": "research/e8-bit-p111-tuned/SOURCE-pr510.json", + "usage": "input", + "git_blob": "f44af5ca75faa5871c020fa3154abbb1c2b4b3d4", + "sha256": "5e84c26ba837ce029acd1b5089e5533d2ebde793deede84215322112e95e06f8" + }, + { + "path": "research/e8-bit-p111-tuned/SOURCE-pr535.json", + "usage": "input", + "git_blob": "9002227599dbcac6dd0cbc854925ad1f90238905", + "sha256": "74254fde5cff5580d5c199b139ff3ce31a3defded3f653a3ba83cf0c9204ddc4" + }, + { + "path": "research/e8-bit-p111-tuned/SOURCE-pr544.json", + "usage": "input", + "git_blob": "12fd9dd44e3add22e114f5aec9ec15f86f5658a1", + "sha256": "9ae1cfa69158f678499510e9cf24396b2bdd9b68979e906cbb8d4ee29b63e0b9" + }, + { + "path": "research/e8-bit-p111-tuned/SOURCE-pr545.json", + "usage": "input", + "git_blob": "9af8fcb1bc71bdf9254493936fbbb7d33d0763d5", + "sha256": "4b868b05c092eb821b257eab0f429f7c502fde946dd6508e8f5161a8758b4904" + }, + { + "path": "research/e8-bit-p111-tuned/SOURCE-pr548.json", + "usage": "input", + "git_blob": "efaf9fab93003c50c15c6559102c03b5b0100ff2", + "sha256": "4480cd4e1dd0dc2bf55c26a1ae4a8bbb8587a96cea3053687e5d4c874148043e" + }, + { + "path": "research/e8-bit-p111-tuned/code/adapt9p.py", + "usage": "input", + "git_blob": "96bbc2ba9bb11984736e34db8b65c1a91e8f842e", + "sha256": "14365d0eb8f4a7352edd28816196148fd28d5bbcb36044ebeeb15ca051bca9de" + }, + { + "path": "research/e8-bit-p111-tuned/code/cited.py", + "usage": "input", + "git_blob": "3a23130b8f9b4c7ed83e7b8c186921d268f6807d", + "sha256": "8f7852571a897e131cf964d4b7826dc7bb2b7a42e81892d436f8ea092b26ef7d" + }, + { + "path": "research/e8-bit-p111-tuned/code/gen_p3.py", + "usage": "input", + "git_blob": "ab21c9c19fc2386f273cd568b46282efcdd77fff", + "sha256": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd" + }, + { + "path": "research/e8-bit-p111-tuned/code/mutants.py", + "usage": "input", + "git_blob": "5b0fa1922076d2e91367b58483c96b33b7b08661", + "sha256": "e2fd3429e2db4389ae8a5ab47dda89f551b0d0952c42fad5ac8d38a85d670594" + }, + { + "path": "research/e8-bit-p111-tuned/code/mutants_p.py", + "usage": "input", + "git_blob": "f249d3250a89092a1b3e0b83f0ae8ee78eaf9504", + "sha256": "ee2a2cfb44072a214dd29eae5b96a71b258ac886a05456b84d600de94b339591" + }, + { + "path": "research/e8-bit-p111-tuned/code/mutrec_b.py", + "usage": "input", + "git_blob": "7b644a4a03423404348633680a6c503d3a2c7060", + "sha256": "231cbf26bfe5e6824347e4556959941d8b4dea1efa06d7f88d7a73cca8b03158" + }, + { + "path": "research/e8-bit-p111-tuned/code/nodeopt.py", + "usage": "input", + "git_blob": "dd30a2e4e6e33ba60669d7b421229a2f6e53d6ad", + "sha256": "6a5896f60b1fe05c41ab28ce822dff782c635e12d0c74fad20b5ce2a4010fa3f" + }, + { + "path": "research/e8-bit-p111-tuned/code/planio.py", + "usage": "input", + "git_blob": "0d5874976a18cc7db7e58fdc177568d538a59c01", + "sha256": "c0a687f61aed29455cea953d8a3e49a32136edb3cd4213c46880c146a6ca7fa3" + }, + { + "path": "research/e8-bit-p111-tuned/code/provenance.py", + "usage": "input", + "git_blob": "da0f0a91e5487b47b020b73680cf541fa085b12e", + "sha256": "aade757c1e4e2714207cbc80a9a60793d84b5f009de2cac79ee8d3239986fd2a" + }, + { + "path": "research/e8-bit-p111-tuned/code/pwordl.py", + "usage": "input", + "git_blob": "a90bed93e227c3916aca67817794f35e24123ceb", + "sha256": "6d8fccd44508e4705b6446e0a64482a5221a3efc5663c5ca7ae90d44581ac50a" + }, + { + "path": "research/e8-bit-p111-tuned/code/receipt_kappa.py", + "usage": "input", + "git_blob": "2a8823a049e3fec45ac58086193b05cb60bcc5c0", + "sha256": "6ac4cb3c6015bd46f3b0a88dfffce741d8942a703cc68738ad61953fae485e9e" + }, + { + "path": "research/e8-bit-p111-tuned/code/summary.py", + "usage": "input", + "git_blob": "4fefa8aab4e646176472366dcb3a562ea8a4c56d", + "sha256": "c7599cafe1a2330a2fc8a956dca457f802dbb8b04e4dc4ffa9d90890e5efb428" + }, + { + "path": "research/e8-bit-p111-tuned/code/xcheck_p.py", + "usage": "input", + "git_blob": "184f5dcf94a486cc7db91ca4db5865916bf26009", + "sha256": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e" + }, + { + "path": "research/e8-bit-p111-tuned/data/bitE8mut-p111.json.gz", + "usage": "input", + "git_blob": "bdbb95aa970647bd52895c120b494f0f591f3f87", + "sha256": "1bc3c53d4baf4927c6a00c339ea3975516471a48074d4d97c6addaded2a4d858" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex-b.json", + "usage": "input", + "git_blob": "78bbe7da45a8a9e39c2640bddf9ecb0848b2d114", + "sha256": "96943a080f371392381c70676638c7b3281ffc44f96b50d7ab064f59aa9897c0" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex/pr535/EXACT-ASSEMBLY-PR493.json", + "usage": "input", + "git_blob": "91873f25e16f5184f4baaaa900622fe62aeb3760", + "sha256": "3f4be566309841e00e842d5686f7937a355ae1a6a2eaa3ccb07bdf8a9ca604fb" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex/pr535/EXPECTED.json", + "usage": "input", + "git_blob": "2c5a1a32628e2e93b29a54ecfb9ccfa5d84b9b17", + "sha256": "cb734055c36681d38cf431a6926b7713351a94073cfba37d70a5384a9ef0d178" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex/pr544/EXACT-ASSEMBLY.json", + "usage": "input", + "git_blob": "a0f66a8c8f5a5634a02beac66b0055d7e2b73365", + "sha256": "eaacbe5a9b971b20f59503a5e948c1ba76c5e082f81a012c9cc7394494bc4db5" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex/pr544/EXPECTED.json", + "usage": "input", + "git_blob": "d6ca3ca276ffe69c0d6d226ed8489ec5a5adec7d", + "sha256": "8f48531cb1ccc6c1fe7c80ba5990f8aea4278dbe9394bcc4d3f471a3e8d75f1c" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex/pr548/EXACT-ASSEMBLY.json", + "usage": "input", + "git_blob": "1a99506aa28c8179248ec9646cca314c21e91187", + "sha256": "8c40d6a7907c2ba71284d4f29a2d6e6bbe4dfc5da92a6da1bbac13488b916349" + }, + { + "path": "research/e8-bit-p111-tuned/data/complex/pr548/EXPECTED.json", + "usage": "input", + "git_blob": "8bbdb3bcd4588f42b30e2ab8a2c9af04ed2b7b71", + "sha256": "2e458dd9880d001b63153e37ef7954c6bcfceae378ab4b225cfa1c94ea8e23ce" + }, + { + "path": "research/e8-bit-p111-tuned/data/hosting11-p111.json", + "usage": "input", + "git_blob": "cbdea6d055c62a37864d4be12404e2841170225f", + "sha256": "1f5a1142e0119483cabf9a4d99094d988014d1adaa29370e93f4b4a63d9bfd7f" + }, + { + "path": "research/e8-bit-p111-tuned/data/plan-l3.json", + "usage": "input", + "git_blob": "0d6e198897bd2090b96dee443543f00b6a54e065", + "sha256": "d5c2494b4baae801143049e172db303b3c8e25a002e9d9715a1d79dcb2d74c58" + }, + { + "path": "research/e8-bit-p111-tuned/data/punct.json", + "usage": "input", + "git_blob": "d61f73c78578f5159ab9a5d40c99468291e5ea7c", + "sha256": "dd371e1d6fe57602f242920b582ec4c133efc8ede4a849fd701ac90b7f6e1853" + }, + { + "path": "research/e8-bit-p111-tuned/data/selection9-p111.json", + "usage": "input", + "git_blob": "e69ea66a3add357f570fc5552ab6368b3c8f9bb2", + "sha256": "4ab1ed4529683cd184987f8bc3031fb7408b9cd22c25ab9cf541a8aaf896eaf1" + }, + { + "path": "research/e8-bit-p111-tuned/discovery/choose.py", + "usage": "input", + "git_blob": "43bec415e1f08ebb77b21bad67d8498e6a4db351", + "sha256": "18d77e8f62ffc671b3b3d3e50626c03481a2eaf6fb4abbc131e08226feebc180" + }, + { + "path": "research/e8-bit-p111-tuned/discovery/search.py", + "usage": "input", + "git_blob": "af33dc4362a61df20e9c2c92c902d013c93d4f5e", + "sha256": "edd876212edf0db3f6620534dcf50b5d2c23197c2d5f8af8c030ed5bc8447923" + }, + { + "path": "research/e8-bit-p111-tuned/requirements.txt", + "usage": "input", + "git_blob": "4f2c3cd39e58ddb520c8073c45c42e4b0c49b2a5", + "sha256": "e11a6f5c2a40b77fbf54a31a4c45bac575e9d2f765d35b657406d5f088fd0664" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/README.md", + "usage": "input", + "git_blob": "5b1554369682c8344d4f0767111d9b2b35eecbec", + "sha256": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d" + }, + { + "path": "research/e8-bit-p111-tuned/tune/apply.py", + "usage": "input", + "git_blob": "65849f369bdcb0b2ad87566d102e5c776b3994eb", + "sha256": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/e8-bit-p111-tuned/tune/fastc.py", + "usage": "input", + "git_blob": "ec050c0139109d3033933fa137aa83a0f14fe5cc", + "sha256": "ae51f1fbb22b8c8dac8aab787c798361f6aa5d4e1fefb29e43d0197899d4eab5" + }, + { + "path": "research/e8-bit-p111-tuned/tune/moves.json", + "usage": "input", + "git_blob": "6162d9fe11a90d45354bcb873b5b69a67afa1463", + "sha256": "a113933002239eb2dd32726bd572ba8ca41b5bce0d438327dd770754c8d5e0f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/summary.py", + "usage": "input", + "git_blob": "a4ae3ba9dafc637e768a84cb3dd86191cc32c67b", + "sha256": "24841f9f5b039f05cfa934295203c982faf181cf28b9b1a71e50d1a35dc723d0" + }, + { + "path": "research/e8-bit-p111-tuned/tune/tune.py", + "usage": "input", + "git_blob": "6153f8c78b105a18b6cfecf775ca2ba85a768a11", + "sha256": "bdaf632852c514b257bcb1b81004a942fc022ab876565b4e5f6ff5a038d323c2" + }, + { + "path": "research/e8-bit-p111-tuned/tune/verify.sh", + "usage": "input", + "git_blob": "92310cbc220ece46c72f2131ddcc8d802bd35c56", + "sha256": "efb1051d3e2c6119574a29a8e4efbe316307b5901d05079d029e12fae9ff1fb1" + }, + { + "path": "research/e8-bit-p111-tuned/tune/wlib.py", + "usage": "input", + "git_blob": "0e5f9a26f68cc415b793aa903cf6d105acbc8f03", + "sha256": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-dead-totals/data/bitE8mut-r480.json.gz", + "usage": "input", + "git_blob": "8e59c4b5380d522b1c1cb930029a71556b2fa65f", + "sha256": "92e399e9a486b55229b5624632ac54f800dd9e022f2aee97f1e5f264bbc0ef5c" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/EXPECTED.json", + "usage": "input", + "git_blob": "c89fe719e81ae3a4d920bf50f87b7100bbf335ae", + "sha256": "883f7a1a84f31d9e4430e348bc8d9c1ec10210b206ff602dbe126349056af13d" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/adapt.py", + "usage": "input", + "git_blob": "7c595c50bc3910577f8587ca94ce8b9c0e6f55b0", + "sha256": "27b6b77cc4ebf439f9019e63a22dedc1ef72ee65fe120aad3d17316b1df06d7b" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py", + "usage": "input", + "git_blob": "238226c568742dd5723b03eabae564a2eaa2bda9", + "sha256": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/data/selection9-r480.json", + "usage": "input", + "git_blob": "786ba4d5bedef5888ce02629d6caf9aebb290b73", + "sha256": "8176db518bed23ea8121543bfb18085ec6633064142ba40ac5db00f63b06553d" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_hosted_k.py", + "usage": "input", + "git_blob": "8864ca9b942a3507171edca0cf6cbaaf10fcf434", + "sha256": "57e558c80a2fea6e291587b04afd76dfaee3550729997798b61f33daf90b8ec9" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_parent_k.py", + "usage": "input", + "git_blob": "ee54ca566ff9d8553f845144dd4570fa1fe21495", + "sha256": "374e1d983589463bbfa06b6e9f2ffafb9d2c14acf97b1f858593a3cef90e93d2" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/bank_routes_k.py", + "usage": "input", + "git_blob": "aaab9d5ae3f280dcb82775337d88dc244984e225", + "sha256": "ea678a7befda10c6f1b9dd38a36fe1437c6468472bd649f60b9f01522047e0bf" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/emit_k.py", + "usage": "input", + "git_blob": "b84c795a045143639efe6aefb0562b3c20a2c9d7", + "sha256": "298b16c3d4f58a468ad1a64564c8500cb281414a3f3c0428fd467908eeb4a4b4" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "usage": "input", + "git_blob": "3df12bd632f1fdba825ced57110a1fee82eb2857", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/hosting_k.py", + "usage": "input", + "git_blob": "02fea8320b676e14f8ffa242c3ddfa85fa829e31", + "sha256": "081c3b95b18d900d97ce82af64fb428f085b6adc6d8ca93ea920797dad7eb81e" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/bank_routes.py", + "usage": "input", + "git_blob": "9e43a876664a26899762f3b8e9a582e684a3650a", + "sha256": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/config.py", + "usage": "input", + "git_blob": "c6824d9c4ea37d58c0d24cb7a3021c4dfcc6f3bb", + "sha256": "283d7fad45155ee91e704d63ec947cf4a60aeff5cc43510bc0e835f7da7d8767" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/e8core.py", + "usage": "input", + "git_blob": "78983b368715e89fe8524a6dd2c13585d2b5394e", + "sha256": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/base_two_moment.py", + "usage": "input", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/moment.py", + "usage": "input", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/outer.py", + "usage": "input", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/tile_m.py", + "usage": "input", + "git_blob": "cd5fd9b5399f5e7afe5d2a95bd3504bd543c0d60", + "sha256": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py", + "usage": "input", + "git_blob": "68b536daa9e6546c0aa046934bf840aaa3c3fde3", + "sha256": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr545/EXPECTED.json", + "usage": "input", + "git_blob": "ac7f102363a64ae19ba4a3edda9176f0b17ae9dc", + "sha256": "dd078d075b153ea2ed02a4bbd1fe467315930f4d7dc90f2c34cd2c33e06a5029" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr545/code/adapt.py", + "usage": "input", + "git_blob": "bd1552af18ae259c01039627aa06006b9d5e760f", + "sha256": "b9a50303147a3003ad94fc4b1a822d4fca7f9b9e917d165e3c45152575302a0e" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr545/code/punct_cfg.py", + "usage": "input", + "git_blob": "ee5ee42498bb170225ebd7842eadf93b5d6e592f", + "sha256": "7cedd3416d6a8ce2e6393cea32dc1d11032190787a593a0ad964a0b62fc407f3" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr545/data/bitE8mut-v111-r489.json.gz", + "usage": "input", + "git_blob": "f69cc130937c90fedea71f69e9fc1720f41224bf", + "sha256": "c78317ab05ea175dc380f4dce2bafdbcd7e8b46f0c9d6baf350c2f604bb3ae4e" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr545/data/hosting-v111-r489.json", + "usage": "input", + "git_blob": "131d6cbc668b4377e64d3677c301228b3b9608c5", + "sha256": "862155e5c341053668ac1a18db05591417c38b9fe5f395d64a3b0a17a1502042" + }, + { + "path": "research/e8-bit-p111-tuned/verify.sh", + "usage": "input", + "git_blob": "e3f5289c676a723c9eab7d9b527d36cc83823220", + "sha256": "3bb8abf984e98fccf77914ae56d51eb60aab284db677905c1c4aafeacc44eee0" + }, + { + "path": "research/r438-rehost-projectors/NOTICE.md", + "usage": "input", + "git_blob": "9d011941df170da86f722c8250fe499db48669ec", + "sha256": "4346fa4de9946b48594eb0edd43f58518d6d89caa4e329d53e5ea1895c30757f" + }, + { + "path": "research/r438-rehost-projectors/README.md", + "usage": "input", + "git_blob": "0ad17349f0bc5798fa49e679755999340f5a7165", + "sha256": "8579e7742e2659ea6b6be4a76049f3f453d83aecf20aac6e785fe4d25afd9ff3" + }, + { + "path": "research/r438-rehost-projectors/RESULT.json", + "usage": "input", + "git_blob": "f132b04a5d21a5849e8786216dc049a70caafd53", + "sha256": "46c496b5a83af2936380ff8522191c3f71845516ad0d479715eac9354c71b268" + }, + { + "path": "research/r438-rehost-projectors/SOURCES.json", + "usage": "input", + "git_blob": "39a5b1f2defca78055cd93615b808e5d727d989c", + "sha256": "ce3b46e4f9fe278727e06c4166f7f3bfa423c30c5a54b538a8b0c7660a07549e" + }, + { + "path": "research/r438-rehost-projectors/TASK.json", + "usage": "input", + "git_blob": "b54d7d582dba38d2549fa3326c55ac735cd32b63", + "sha256": "ed70eb7b05a2abb1dee0f5cb69cec23fcc0a9096b74b7ba1f49611285150530f" + }, + { + "path": "research/r438-rehost-projectors/VERIFY.json", + "usage": "input", + "git_blob": "08ffca8e3e84d7261e9b5701f015e0dff616e4ce", + "sha256": "5b18ca5737b1b3e19278cf342768157fa8850defc9ef4446dda6c0bba891ed61" + }, + { + "path": "research/r438-rehost-projectors/sources/pr2423-rehost.json", + "usage": "input", + "git_blob": "c2fb443f44f2c7c420cd367ab5fa12644efe318a", + "sha256": "06fa9322508aba3d8a5dc6469151cdfaa906b60559582b49c8b024428b158021" + }, + { + "path": "research/r438-rehost-projectors/sources/pr2423-word.json.gz", + "usage": "input", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "path": "research/r438-rehost-projectors/test_verify.py", + "usage": "input", + "git_blob": "97fdb3f4c81dfb1681df8d0dd5e9998e9bf88420", + "sha256": "02003f7af14a2b247fc55876dd715010af378a53e299c6809812cb088b194b08" + }, + { + "path": "research/r438-rehost-projectors/verify.py", + "usage": "input", + "git_blob": "30b18ceaf5605202ad688e4e2d45b691c8941139", + "sha256": "30c4499d63d9cf8abd228ba4d0e6533f1aea244ec2e7e6bb57c086dc3dc0a82f" + }, + { + "path": "research/selected-bit-hosting-audit/README.md", + "usage": "input", + "git_blob": "145a92501fa73ccd507d9ddd2d6752fc78354764", + "sha256": "f77ad5fcbd30d4704e8a8161fd4ac280756a4a91b9fed41f50e8099ebabd65ac" + } + ] +} diff --git a/research/r438-native-rehost/TASK.json b/research/r438-native-rehost/TASK.json new file mode 100644 index 0000000000..25b2cd9894 --- /dev/null +++ b/research/r438-native-rehost/TASK.json @@ -0,0 +1,164 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 5, + "base_commit": "389fa10d714f5b40afe624908e487eb5e424498d", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "changed", + "actual_scope": "Complete native and hosted emission of the fixed PR2423 R438 t154 word and rehosting selection; bind emitted owners and remainders to PR2653, and certify the complete bit invoice.", + "scope_change_reason": "The suggested helper-mixing H2/K card already has successors. This takes PR2653 and Discussion1289's explicit native-emission handoff for a paid bit-profile improvement, retaining H1-H5 and every existing acceptance predicate.", + "bottleneck_link": "Bit headroom: PR2423 predicts c=0.001734846264120199151475 versus selected PR589 c=0.001733427039589844234749. The selected complex c=0.001675462676808103522925 still binds; no new kappa is expected.", + "budget_minutes": 120, + "stop_rule": "Stop on an unrepaired native, owner/projector, precision or moment mismatch; one bounded implementation repair is permitted, no search extension. Reserve final 30 minutes for final verification, publication and handoff.", + "outcome": "completed", + "evidence": "CERTIFICATE.json: full C++17/Boost 5/9/11-stage replay on baseline and candidate; original H1-H5; both emitted parent/hosted audits; 126144 emitted owner/projector bindings and all remainder factors; 904320 paid children, rank mass1808352; both exact moment engines accept c=0.001734846264120199151475 and reject the next 1e-24 grid point. 96 bridge,66 parent/hosted,10 inherited projector controls/witnesses and9 new rejection controls. No new kappa.", + "author": "@CubeJerry with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in task selection, mathematical accounting, implementation, verification and writing. One agent; no independent human or proof-kernel review.", + "open_questions": [ + { + "question": "Can the finite emitted construction be admitted under the inherited all-size physical contracts?", + "why_it_matters": "A finite native and hosted certificate does not implement the full multiplication machine.", + "first_step": "Review the new source-bound emitted invoice alongside retained compiler and hosting hypotheses.", + "blocked_by": "Common-label realization, correlated whole-call hosting, precision/tape and analytic transfer remain inherited." + } + ], + "assignment": { + "seed": 8, + "seed_domain": [ + 0, + 39 + ], + "random_source": "Python secrets.randbelow(40), operating-system randomness", + "drawn_at": "2026-10-16T14:00:00Z", + "chooser_nonce": "932d8f7e9c486fb6e4d4a00681d08e41", + "track": "bit-mechanisms" + }, + "candidate_tasks": [ + { + "scope": "R438 t154 native emission and complete rehosting invoice", + "decision": "chosen: explicit unclaimed handoff, changes paid supplier profile, finite build fits budget" + }, + { + "scope": "R438 transports of three interacting gates around source77 and receiver444", + "decision": "not chosen: new joint enabling is distinct from fixed-option pairs but speculative and small" + }, + { + "scope": "A fourth-register nonabelian bit word", + "decision": "not chosen: source alphabet/native realization and complete cost unresolved; neighboring formal domains already extensively searched" + } + ], + "local_claim": { + "status": "DONE; verified contribution; scope released", + "utc": "2026-10-16T14:10:26.845310+00:00", + "base": "389fa10d714f5b40afe624908e487eb5e424498d", + "scope_key": "R438/PR2423-t154/PR2653-projectors/native-hosted-emission", + "method": "Use pinned PR1043 native pipeline with a source-authenticated selection adapter; compare all emitted owner tuples and remainder factors with PR2653 independent expansion; retain every parent/hosted mutation and exact pricing predicate.", + "deliverable": "One opt-in package, reproducible emitted construction, exact certificate, source pins and defect-sensitive controls.", + "expires": "2026-10-16T15:59:28Z", + "posting": "Local claim: no pinned coordination issue on public issue list (only issue913); coordination is on Discussions. Connected GitHub tools have no Discussion-write capability. Discussion1289 was read immediately before the claim and the native-emission handoff is released.", + "result": "The fixed t154 word and rehosted selection pass complete native/hosted emission, exact projector binding and the full bit invoice. No new kappa.", + "branch_url": "https://github.com/CubeJerry/integer-mult-bounds/tree/research/cubejerry-seed08-r438-native-20261016-932d8f7e", + "completed_utc": "2026-10-16T14:22:43.913648+00:00" + }, + "optimistic_complete_budget": { + "helpers": 438, + "local_adds": 24248, + "local_rank_mass": 5121, + "local_profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "copies_per_local": 9, + "copy_rank": 7, + "helper_occurrences": 126144, + "idle_per_replica": { + "2": 433, + "4": 444, + "6": 444, + "7": 666, + "34": 1, + "42": 10 + }, + "global_paid_children": 904320, + "global_rank_mass": 1808352, + "live_stock": 28416, + "deficit": 10272, + "local_payload_charge": 104, + "nine_stage_payload_charge": 192, + "two_level_payload_charge": 512, + "maximum_child": 42, + "expected_bit_c": "0.001734846264120199151475", + "new_kappa": false + }, + "predecessors": { + "1043": "e309e17f83f5759b1ea1fa24a76f24838784cb4d", + "2423": "13cd273dc13c98244b1f9bcf588b6e828cbc0347", + "2653": "ff26f4477786cf9ab188e060d6820a39dd2ed117", + "589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46" + }, + "overlap": { + "read_utc": "2026-10-16T14:10:26.845358+00:00", + "sources": [ + "Latest 100 upstream PRs via REST", + "Targeted all-state PR searches: R438; R438 native; transport triple", + "Local ledger and exact-head dispositions1043/2423/2653", + "Discussion1163,1166,1317,1289 public pages", + "find_overlap.py --task bit-helper-contract --offline" + ], + "finding": "PR2423 and PR2653 explicitly leave this emitted-native handoff open; Discussion1289 scope released. No same-object active claim seen.", + "limitations": "PR query and public discussion pages are not complete repository-wide or hidden/paginated-comment coverage; offline helper has no current remote cache.", + "final_check_utc": "2026-10-16T14:37:00.685876+00:00", + "final_result": "Targeted all-state R438 PR search still returns only the predecessor/adjacent work already listed; no same-object new native-emission PR found." + }, + "upstream_refresh": { + "utc": "2026-10-16T14:37:00.685859+00:00", + "publication_base": "0614abaef427f123d9b844f85a759e64ee3ab29c", + "research_base": "389fa10d714f5b40afe624908e487eb5e424498d", + "guidance_and_selected_record_changed": false, + "changed_live_inputs": [], + "scope": "Advanced the isolated branch to fresh canonical main; all 188 live dependency bytes and task guidance unchanged. Archive/ledger updates were reviewed for the three predecessors; their scopes remain as recorded.", + "native_replay_base": "318ba71b8927f81141f41a89c1af74323586f253" + }, + "declared_milestone": "Complete finite emitted bit-supplier candidate with unchanged inherited interfaces; no integrated kappa target because the accepted complex supplier binds." +} diff --git a/research/r438-native-rehost/VALIDATION.md b/research/r438-native-rehost/VALIDATION.md new file mode 100644 index 0000000000..5bb573f03d --- /dev/null +++ b/research/r438-native-rehost/VALIDATION.md @@ -0,0 +1,107 @@ +# Executed validation and scope + +The first complete native/hosted run passed on 2026-10-16 UTC. Its fresh +certificate is committed as `CERTIFICATE.json`. Two complete runs were compared, followed by a final clean-output run after +normalizing timing-dependent hash links; final status is recorded below. +No recorded predecessor PASS is substituted for fresh native execution. + +Environment used: + +- Linux x86_64, glibc 2.39; CPython 3.12.14. +- GCC C++ 13.3.0, `-O2 -std=c++17`, with the exact macro/include flags in + pinned PR1043 `pipeline.py`. +- Boost 1.83 headers; `boost/version.hpp` SHA256 + `a547ee7eddf1b96695027922345b471feba8bcba79a8572399d282247c02e4ab`. + Headers were extracted locally from Debian's + `libboost1.83-dev_1.83.0-4.2~bpo12+1_amd64.deb`; no compiler source was changed. +- NumPy 2.3.5, SciPy 1.17.0, SymPy 1.14.0, mpmath 1.3.0, in a virtual + environment. The exact requirements are recorded beside this file. + +Executed commands (paths abbreviated only for the local output directories): + +```sh +BOOST_INCLUDE=/tmp/s2-boost/usr/include /tmp/s2-venv/bin/python -B \ + research/r438-native-rehost/verify.py --output /tmp/s2-native-second \ + --write-certificate /tmp/s2-native-certificate.json +BOOST_INCLUDE=/tmp/s2-boost/usr/include /tmp/s2-venv/bin/python -B \ + research/r438-native-rehost/verify.py --output /tmp/s2-native-publish +python3 -B scripts/research_package.py --package research/r438-native-rehost --check-only +python3 -B scripts/research_package.py --package research/r438-native-rehost +python3 -O -B research/r438-native-rehost/verify.py --local-only +``` + +The optimized command must exit nonzero with `Inherited checkers require +assertions: do not use -O`. It did. The registered command passed and explicitly +reported `native_not_run`; only the complete commands execute native and hosted stages. The catalogue's first working example, +`research/r439-bsection-stars-seed01/verify.py`, was also run and passed during +orientation; it is not evidence for this different candidate. + +Fresh complete evidence includes: + +- Both source words, every dirty local column, and every original H1–H5 flag. +- Six freshly compiled scalar checkers (three stage counts for each word), + native legality and exact positive Gram checks; 96 rejected omitted bridges. +- Both parent constructions and all 34 parent mutations; both hosted + constructions and all 32 hosted mutations. +- Both exact endpoint engines, with the full inherited surcharge, precision, + child-size and row checks. The historical cited PR548 outer calculation + executes but is excluded from this package's current-frontier claims. +- PR2653's entire exact geometric receipt and its ten controls/witnesses; + all 126,144 actual emitted owner/projector matches and every remainder. +- Nine new semantic rejection controls, including equal-width owner errors and + an understated rank-34 remainder. See the certificate for exact messages. + +During adapter development, the first partial run stopped because the new +adapter compared zero-rank remainders against a predecessor table that records +only positive ranks. The comparison was corrected to use the declared +positive-rank convention. A pre-native comparison also exposed JSON integer +versus string histogram-key ordering; normalization now precedes sorting. +These were adapter implementation failures, not counterexamples to the word +or weakened inherited checks. The final emitted remainder check still retains +all per-child histograms, including zero entries where present. + +The first clean certificate comparison then caught a real reproducibility +issue: `GEOMETRY.json` contains elapsed seconds, and its raw digest is included +in both templates. The two complete runs agreed on every mathematical value +and every emitted instruction/owner digest. The final adapter authenticates +each run's original raw geometry/template links, removes only geometry +elapsed time, and records explicit `semantic_*` digests for comparisons. +Re-summarizing both complete output directories produced identical normalized +certificates. The final clean-output command exercises this corrected path +from compilation through complete certificate comparison. + +Before the clean comparison run, canonical main advanced from research base +`389fa10d714f5b40afe624908e487eb5e424498d` to publication base +`318ba71b8927f81141f41a89c1af74323586f253`. The isolated branch was updated. +All 188 live source files, the task guidance, catalogue and selected record +were unchanged. The three predecessor ledger scopes were checked again. +No `upstream/`, selected certificate, frozen input or shared checker is edited. + +This is local execution evidence. Hosted CI, a full selected-frontier cold +replay, the full repository suite, Lean and independent human review are not +claimed. Publication commit/tree identity is recorded in the PR handoff; it +is not embedded in this file, which would make the commit self-referential. + +Final stable replay: **PASS**, 2026-10-16T14:36Z. After replacing the large +generated geometry copy by its full semantic digest, the publication replay +repeats the complete command and certificate comparison; see final status below. + +Final verifier source SHA256: +`f80d03a25d3742822cc8da8435b3b0fe51dd63f53ea744a8e781294eae06cd27`. +Normalized certificate SHA256: +`6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c`. + +Publication refresh: canonical main advanced again to +`0614abaef427f123d9b844f85a759e64ee3ab29c`. All 188 live inputs and the +entry guidance/selected record remained byte-identical. The branch was +advanced to that parent after the native run; package/source-pin checks and +committed-byte preflight were repeated on the publication tree. + +The compact publication certificate binds the full generated geometry by its +semantic digest and records its dimensions/control counts. It does not +vendor the 5.8 MB regenerated geometry a second time. All original integrity +checks and complete mathematical coverage remain in the reproduction command. + +Publication replay: **PASS**, 2026-10-16T14:44Z, on the compact final +verifier/certificate. All native/hosted stages and the complete normalized +certificate comparison passed in a fresh output directory. diff --git a/research/r438-native-rehost/VERIFY.json b/research/r438-native-rehost/VERIFY.json new file mode 100644 index 0000000000..3449daed86 --- /dev/null +++ b/research/r438-native-rehost/VERIFY.json @@ -0,0 +1,208 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-boundary-persistence/CERTIFICATE.json", + "research/bit-boundary-persistence/FRAME-PATHS.json", + "research/bit-boundary-persistence/build.py", + "research/bit-boundary-persistence/pipeline.py", + "research/bit-boundary-persistence/verify.py", + "research/bit-r438-transport-rehost/verify_rehost.receipt.json", + "research/bit-r438-transport-rehost/verify_transport.receipt.json", + "research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "research/community-frontier942-audit/ASSEMBLY.json", + "research/e8-bit-carrier-skeleton/EXPECTED.json", + "research/e8-bit-carrier-skeleton/LICENSE", + "research/e8-bit-carrier-skeleton/MANIFEST.sha256", + "research/e8-bit-carrier-skeleton/NOTICE.md", + "research/e8-bit-carrier-skeleton/README.md", + "research/e8-bit-carrier-skeleton/SOURCE-pr370.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr381.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr386.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr436.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr445.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr448.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr451.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr458.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr471.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr472.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr473.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr478.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr483.json", + "research/e8-bit-carrier-skeleton/SOURCE-pr484.json", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp", + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py", + "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp", + "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py", + "research/e8-bit-carrier-skeleton/code/bit/independent/checkword.py", + "research/e8-bit-carrier-skeleton/code/bit/independent/interface.py", + "research/e8-bit-carrier-skeleton/code/bit/independent/mutate.py", + "research/e8-bit-carrier-skeleton/code/bit/independent/mutate_mut.py", + "research/e8-bit-carrier-skeleton/code/bit/independent/relax.py", + "research/e8-bit-carrier-skeleton/code/bit/mutate_records.py", + "research/e8-bit-carrier-skeleton/code/bit/mutate_records_mut.py", + "research/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py", + "research/e8-bit-carrier-skeleton/code/cited.py", + "research/e8-bit-carrier-skeleton/code/eleven/adapt.py", + "research/e8-bit-carrier-skeleton/code/eleven/assemble.py", + "research/e8-bit-carrier-skeleton/code/eleven/audit.py", + "research/e8-bit-carrier-skeleton/code/eleven/emit.py", + "research/e8-bit-carrier-skeleton/code/eleven/local_audit.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/assemble.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/audit.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/emit.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/local_audit.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/hosting.json", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/residual-isometries.json", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/word.json.gz", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/bank_routes.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/e8core.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/base_two_moment.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/moment.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/outer.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/tile_m.py", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/residual-isometries.json", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/word.json.gz", + "research/e8-bit-carrier-skeleton/code/hub/idle-axis-hosting/hosting_core.py", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/emit.py", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/geometry.py", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/row_bound.py", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/data/selection.json", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/code/emit.py", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/residual-isometries.json", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/selection.json", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/word.json.gz", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "research/e8-bit-carrier-skeleton/code/pricing/base_two_moment.py", + "research/e8-bit-carrier-skeleton/code/pricing/moment.py", + "research/e8-bit-carrier-skeleton/code/pricing/outer.py", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py", + "research/e8-bit-carrier-skeleton/code/provenance.py", + "research/e8-bit-carrier-skeleton/code/skeleton/e8.py", + "research/e8-bit-carrier-skeleton/code/skeleton/gen.py", + "research/e8-bit-carrier-skeleton/code/skeleton/geom.py", + "research/e8-bit-carrier-skeleton/code/skeleton/wordkit.py", + "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "research/e8-bit-carrier-skeleton/data/bit/bitE8mut-r489.json.gz", + "research/e8-bit-carrier-skeleton/data/complex-b.json", + "research/e8-bit-carrier-skeleton/data/complex/pr448/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/complex/pr458/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/complex/pr471/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/complex/pr473/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/complex/pr478/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/complex/pr483/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/complex/pr484/EXPECTED.json", + "research/e8-bit-carrier-skeleton/data/eleven/hosting.json", + "research/e8-bit-carrier-skeleton/data/eleven/residual-isometries.json", + "research/e8-bit-carrier-skeleton/data/skeleton/d4part-pairs.json", + "research/e8-bit-carrier-skeleton/data/skeleton/plan-skB.json", + "research/e8-bit-carrier-skeleton/discovery/README.md", + "research/e8-bit-carrier-skeleton/discovery/d4part.py", + "research/e8-bit-carrier-skeleton/discovery/host_select.py", + "research/e8-bit-carrier-skeleton/discovery/plan.py", + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h", + "research/e8-bit-carrier-skeleton/requirements.txt", + "research/e8-bit-carrier-skeleton/verify.sh", + "research/e8-bit-p111-tuned/DEPENDS.json", + "research/e8-bit-p111-tuned/EXPECTED.json", + "research/e8-bit-p111-tuned/LICENSE", + "research/e8-bit-p111-tuned/MANIFEST.sha256", + "research/e8-bit-p111-tuned/NOTICE.md", + "research/e8-bit-p111-tuned/README.md", + "research/e8-bit-p111-tuned/SOURCE-pr510.json", + "research/e8-bit-p111-tuned/SOURCE-pr535.json", + "research/e8-bit-p111-tuned/SOURCE-pr544.json", + "research/e8-bit-p111-tuned/SOURCE-pr545.json", + "research/e8-bit-p111-tuned/SOURCE-pr548.json", + "research/e8-bit-p111-tuned/code/adapt9p.py", + "research/e8-bit-p111-tuned/code/cited.py", + "research/e8-bit-p111-tuned/code/gen_p3.py", + "research/e8-bit-p111-tuned/code/mutants.py", + "research/e8-bit-p111-tuned/code/mutants_p.py", + "research/e8-bit-p111-tuned/code/mutrec_b.py", + "research/e8-bit-p111-tuned/code/nodeopt.py", + "research/e8-bit-p111-tuned/code/planio.py", + "research/e8-bit-p111-tuned/code/provenance.py", + "research/e8-bit-p111-tuned/code/pwordl.py", + "research/e8-bit-p111-tuned/code/receipt_kappa.py", + "research/e8-bit-p111-tuned/code/summary.py", + "research/e8-bit-p111-tuned/code/xcheck_p.py", + "research/e8-bit-p111-tuned/data/bitE8mut-p111.json.gz", + "research/e8-bit-p111-tuned/data/complex-b.json", + "research/e8-bit-p111-tuned/data/complex/pr535/EXACT-ASSEMBLY-PR493.json", + "research/e8-bit-p111-tuned/data/complex/pr535/EXPECTED.json", + "research/e8-bit-p111-tuned/data/complex/pr544/EXACT-ASSEMBLY.json", + "research/e8-bit-p111-tuned/data/complex/pr544/EXPECTED.json", + "research/e8-bit-p111-tuned/data/complex/pr548/EXACT-ASSEMBLY.json", + "research/e8-bit-p111-tuned/data/complex/pr548/EXPECTED.json", + "research/e8-bit-p111-tuned/data/hosting11-p111.json", + "research/e8-bit-p111-tuned/data/plan-l3.json", + "research/e8-bit-p111-tuned/data/punct.json", + "research/e8-bit-p111-tuned/data/selection9-p111.json", + "research/e8-bit-p111-tuned/discovery/choose.py", + "research/e8-bit-p111-tuned/discovery/search.py", + "research/e8-bit-p111-tuned/requirements.txt", + "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/e8-bit-p111-tuned/tune/README.md", + "research/e8-bit-p111-tuned/tune/apply.py", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/e8-bit-p111-tuned/tune/fastc.py", + "research/e8-bit-p111-tuned/tune/moves.json", + "research/e8-bit-p111-tuned/tune/summary.py", + "research/e8-bit-p111-tuned/tune/tune.py", + "research/e8-bit-p111-tuned/tune/verify.sh", + "research/e8-bit-p111-tuned/tune/wlib.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-dead-totals/data/bitE8mut-r480.json.gz", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/EXPECTED.json", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/adapt.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/data/selection9-r480.json", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_hosted_k.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_parent_k.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/bank_routes_k.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/emit_k.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/hosting_k.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/bank_routes.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/config.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/e8core.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/base_two_moment.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/moment.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/outer.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/tile_m.py", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py", + "research/e8-bit-p111-tuned/vendor/pr545/EXPECTED.json", + "research/e8-bit-p111-tuned/vendor/pr545/code/adapt.py", + "research/e8-bit-p111-tuned/vendor/pr545/code/punct_cfg.py", + "research/e8-bit-p111-tuned/vendor/pr545/data/bitE8mut-v111-r489.json.gz", + "research/e8-bit-p111-tuned/vendor/pr545/data/hosting-v111-r489.json", + "research/e8-bit-p111-tuned/verify.sh", + "research/r438-rehost-projectors/NOTICE.md", + "research/r438-rehost-projectors/README.md", + "research/r438-rehost-projectors/RESULT.json", + "research/r438-rehost-projectors/SOURCES.json", + "research/r438-rehost-projectors/TASK.json", + "research/r438-rehost-projectors/VERIFY.json", + "research/r438-rehost-projectors/sources/pr2423-rehost.json", + "research/r438-rehost-projectors/sources/pr2423-word.json.gz", + "research/r438-rehost-projectors/test_verify.py", + "research/r438-rehost-projectors/verify.py", + "research/selected-bit-hosting-audit/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--local-only" + ], + "timeout_seconds": 120, + "checks": "Authenticate every declared input; replay all dirty local columns, candidate cleanup/compensation/frame faults and independent PR2653 exact projector certificate. Native output is intentionally not claimed by this registered fast command." + } + ] +} diff --git a/research/r438-native-rehost/requirements-native.txt b/research/r438-native-rehost/requirements-native.txt new file mode 100644 index 0000000000..5e4d298dda --- /dev/null +++ b/research/r438-native-rehost/requirements-native.txt @@ -0,0 +1,5 @@ +# Reproduction versions used for the complete native/hosted run. +numpy==2.3.5 +scipy==1.17.0 +sympy==1.14.0 +mpmath==1.3.0 diff --git a/research/r438-native-rehost/verify.py b/research/r438-native-rehost/verify.py new file mode 100644 index 0000000000..5706d120de --- /dev/null +++ b/research/r438-native-rehost/verify.py @@ -0,0 +1,385 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Source-bound native/hosted emission of PR2423's R438 t154 construction. + +@CubeJerry, with substantial OpenAI Codex assistance. Apache-2.0. +Construction: Ali Romman (PR1043), Sagar Thakrar (PR2423). +Projector proof/checker: commdata2338 (PR2653). Inherited engines are unchanged. +""" +import argparse +from collections import Counter, defaultdict +import copy +from fractions import Fraction +import gzip +import hashlib +import json +import math +from pathlib import Path +import sys +import tempfile +import types + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +WORD = 'research/bit-r438-transport-rehost/words/r438-t154.json.gz' +LAYOUT = 'research/bit-r438-transport-rehost/verify_rehost.receipt.json' +EXPECTED_C = Fraction('0.001734846264120199151475') +BASE_C = Fraction('0.001733427039589844234749') +SELECTED_COMPLEX = Fraction('0.001675462676808103522925') + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + # JSON histogram keys are strings after reading; normalize fresh integer + # keys before sorting so comparisons do not depend on insertion order. + value = json.loads(json.dumps(value)) + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def load(name, path): + # Execute authenticated source bytes, avoiding preexisting bytecode caches. + path = ROOT / path + module = types.ModuleType(name) + module.__file__ = str(path) + sys.modules[name] = module + exec(compile(path.read_bytes(), str(path), 'exec'), module.__dict__) + return module + + +def check_sources(): + pins = read(HERE / 'SOURCES.json') + seen = set() + for item in pins['files']: + if item['usage'] != 'input': + continue + path = item['path'] + require(path not in seen, 'duplicate input pin') + seen.add(path) + raw = (ROOT / path).read_bytes() + require(hashlib.sha256(raw).hexdigest() == item['sha256'], 'source SHA256: ' + path) + blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + require(blob == item['git_blob'], 'source Git blob: ' + path) + require(seen == set(read(HERE / 'VERIFY.json')['inputs']), 'declared input coverage') + return pins + + +def reject(name, action, expected, controls): + try: + action() + except ValueError as error: + require(expected in str(error), name + ' rejected for another reason: ' + str(error)) + controls.append({'name': name, 'rejection': str(error)}) + return + raise ValueError('control accepted: ' + name) + + +def prepare(): + check_sources() + builder = load('r438_native_builder', 'research/bit-boundary-persistence/build.py') + pipeline = load('r438_native_pipeline', 'research/bit-boundary-persistence/pipeline.py') + projector = load('r438_native_projector', 'research/r438-rehost-projectors/verify.py') + layout = read(ROOT / LAYOUT)['placement'] + words = {'baseline': ROOT / builder.WORD, 'candidate': ROOT / WORD} + local, records, decoded = {}, {}, {} + for name, path in words.items(): + decoded[name] = json.loads(gzip.decompress(path.read_bytes())) + local[name], records[name] = builder.replay(decoded[name]) + reference = projector.run() + require(canonical(reference) == canonical(read(ROOT / 'research/r438-rehost-projectors/RESULT.json')), + 'projector predecessor receipt differs') + require(canonical(decoded['candidate']) == canonical(json.loads(gzip.decompress( + (ROOT / 'research/r438-rehost-projectors/sources/pr2423-word.json.gz').read_bytes()))), + 'projector/candidate word mismatch') + _, children, windows = projector.chronology() + slots, remaining = projector.expand(layout['selection'], children, windows, 438) + require(local['candidate']['profile'] == {int(k): v for k, v in reference['local_profile'].items()}, + 'independent local profiles disagree') + require((local['candidate']['adds'], local['candidate']['rank_mass']) == (24248, 5121), + 'local cost changed') + controls = [] + bad = copy.deepcopy(decoded['candidate']) + bad['C'].pop() + reject('omitted_candidate_cleanup', lambda: builder.replay(bad), 'Wrong arbitrary-dirty endpoint', controls) + bad = copy.deepcopy(decoded['candidate']) + bad['D'][0][2].pop() + reject('omitted_candidate_dirty_compensation', lambda: builder.replay(bad), + 'Wrong arbitrary-dirty endpoint', controls) + bad = copy.deepcopy(decoded['candidate']) + require(bad['A'][154] == [79, 444, [77]], 'transport instruction changed') + bad['A'][154][0] = 186 + reject('transport_retains_old_frame', lambda: builder.replay(bad), 'Frame descent', controls) + return dict(builder=builder, pipeline=pipeline, projector=projector, layout=layout, + words=words, local=local, records=records, reference=reference, + children=children, windows=windows, slots=slots, remaining=remaining, + local_controls=controls) + + +def install_selection(context): + p = context['pipeline'] + children = context['children'] + projector = context['projector'] + layout = context['layout'] + remaining = context['remaining'] + + def selection(root, output, template): + actual = [e for e in template['schedule'] if e['kind'] == 'idle'] + fields = ('pair', 'source_level', 'target_level', 'rank') + require([[e[k] for k in fields] for e in actual] == + [[e[k] for k in fields] for e in children], 'parent chronology differs') + baseline = read(root / 'research/e8-bit-p111-tuned/data/selection9-p111.json')['bit'] + _, old_remaining = projector.expand(baseline, children, context['windows'], 439) + # This floating heuristic is informational metadata required by the old + # selection format. Acceptance and both moment engines use exact bills. + cost = lambda r: r * math.log(64 / r) if r else 0.0 + proxy = sum(count * (cost(children[i]['rank']) - cost(children[i]['rank'] - sum(widths))) + for i, widths, count in layout['selection']['patterns']) + selection_value = dict(layout['selection'], proxy_saving=proxy) + p.write(output / 'candidate-selection.json', {'bit': selection_value}) + old_hist = Counter(r for r in old_remaining.values() if r) + new_hist = Counter(r for r in remaining.values() if r) + require(new_hist == Counter({int(k): v for k, v in layout['idle_per_replica'].items()}), + 'candidate remainders differ') + require(sum(remaining.values()) - sum(old_remaining.values()) == 72, + 'deleted helper rank not returned') + return {'old_remainders': dict(old_hist), 'new_remainders': dict(new_hist), + 'returned_idle_rank_per_replica': 72, + 'hosted_helpers_per_replica': len(context['slots'])} + + # A public data-choice callback, not a change to any acceptance predicate. + p.selection = selection + + +def bind_emitted(template, parent, context): + """Compare every actual emitted owner with the independent projector census.""" + projector = context['projector'] + children, slots = context['children'], context['slots'] + require(template['local_programs'] == parent['local_programs'], 'emitted local program changed') + require(template['hosting']['slots'] == [list(x) for x in slots], 'emitted selection differs') + require((template['stages'], template['replicas'], template['m'], template['live']) == + (9, 32, 64, 28416), 'emitted dimensions differ') + calls = {} + for call in template['calls']: + key = (call['replica'], call['stage']) + require(key not in calls, 'duplicate emitted call') + require(len(call['owners']) == 660, 'emitted owner arity') + calls[key] = call + require(set(calls) == {(r, s) for r in range(32) for s in range(9)}, 'emitted call coverage') + by_deadline = defaultdict(list) + for child, cp, off, width, stage, helper in slots: + by_deadline[child, cp].append((off, width, stage, helper)) + owner_rows = [] + for replica in range(32): + for (child, cp), pieces in sorted(by_deadline.items()): + side, port = divmod(cp, 111) + expected_family = replica * 888 + (2 * children[child]['pair'] + side) * 111 + port + axes = projector.axes(children[child]['mask']) + for off, width, stage, helper in pieces: + family, descriptor = calls[replica, stage]['owners'][222 + helper] + require(family == expected_family, 'emitted owner family differs') + require(descriptor == ['hosted', child, off, width], 'emitted owner slice differs') + support = sum(1 << i for i in axes[off:off + width]) + owner_rows.append((replica, stage, helper, family, child, support)) + require(digest(owner_rows) == context['reference']['census']['owner_projector_sha256'], + 'emitted owner/projector digest differs') + remainders = defaultdict(Counter) + for (child, _), rank in context['remaining'].items(): + if child in {int(i) for i in template['hosting']['windows']}: + remainders[str(child)][str(rank)] += 1 + require(template['hosting']['remainders'] == {i: dict(v) for i, v in remainders.items()}, + 'emitted remainder factors differ') + hist = Counter({int(r): 288 * n for r, n in context['local']['candidate']['profile'].items()}) + # Include all actual schedule remainders, including children with no hosting window. + for event in template['schedule']: + if event['kind'] != 'idle' or not event['rank']: + continue + child = str(event['idx']) + if child in template['hosting']['remainders']: + hist.update({int(r): 32 * n for r, n in template['hosting']['remainders'][child].items() if int(r)}) + else: + hist[event['rank']] += 32 * 222 + require(dict(hist) == {int(k): v for k, v in context['reference']['global_profile'].items()}, + 'emitted complete profile differs') + return {'owner_projector_sha256': digest(owner_rows), 'owner_occurrences': len(owner_rows), + 'physical_deadlines': context['reference']['census']['deadline_families'], + 'remainder_factors_sha256': digest(template['hosting']['remainders']), + 'local_program_sha256': digest(template['local_programs']), + 'profile': dict(sorted(hist.items())), 'paid_children': sum(hist.values()), + 'rank_mass': sum(r * n for r, n in hist.items())} + + +def binding_controls(template, parent, context): + controls = [] + # Mutate actual emitted structures. Preserve unrelated fields and counts. + def owner_mutation(family_delta=0, offset_delta=0): + bad = dict(template, calls=list(template['calls'])) + call = dict(bad['calls'][0], owners=list(bad['calls'][0]['owners'])) + bad['calls'][0] = call + family, descriptor = call['owners'][222] + descriptor = list(descriptor) + descriptor[2] += offset_delta + call['owners'][222] = [family + family_delta, descriptor] + return bad + reject('emitted_owner_wrong_port', lambda: bind_emitted(owner_mutation(1), parent, context), + 'owner family differs', controls) + reject('emitted_owner_wrong_replica', lambda: bind_emitted(owner_mutation(888), parent, context), + 'owner family differs', controls) + reject('emitted_owner_equal_width_wrong_slice', lambda: bind_emitted(owner_mutation(offset_delta=1), parent, context), + 'owner slice differs', controls) + for kind in ('omit', 'undercharge'): + bad = dict(template, hosting=dict(template['hosting'])) + remainders = copy.deepcopy(template['hosting']['remainders']) + child = next(i for i, counts in remainders.items() if '34' in counts) + n = remainders[child].pop('34') + if kind == 'undercharge': + remainders[child]['33'] = n + bad['hosting']['remainders'] = remainders + reject('emitted_rank34_' + kind, lambda: bind_emitted(bad, parent, context), + 'remainder factors differ', controls) + bad = dict(template, local_programs=copy.deepcopy(template['local_programs'])) + key = next(iter(bad['local_programs'])) + bad['local_programs'][key].pop() + reject('emitted_local_instruction_omitted', lambda: bind_emitted(bad, parent, context), + 'local program changed', controls) + return controls + + +def summarize(out, context): + result = read(out / 'RESULT.json') + parent = json.loads(gzip.decompress((out / 'candidate/nine/GLOBAL-TEMPLATE.json.gz').read_bytes())) + template = json.loads(gzip.decompress((out / 'candidate/hosted/GLOBAL-TEMPLATE.json.gz').read_bytes())) + binding = bind_emitted(template, parent, context) + controls = binding_controls(template, parent, context) + actual_global = read(out / 'candidate/hosted/GLOBAL.json') + require(digest(template) == actual_global['template_sha256'], 'hosted template content digest') + # The inherited geometry JSON includes wall-clock seconds, whose raw hash + # propagates into both templates. Authenticate every original link first, + # then replace only these timing-dependent links by semantic digests. + geometry_raw = (out / 'geometry/GEOMETRY.json').read_bytes() + geometry = json.loads(geometry_raw) + require(isinstance(geometry.pop('seconds'), (int, float)), 'geometry elapsed-time field') + raw_geometry_hash = hashlib.sha256(geometry_raw).hexdigest() + semantic_geometry_hash = digest(geometry) + for name in ('baseline', 'candidate'): + entry = result[name]['hosted'] + parent_template = json.loads(gzip.decompress((out / name / 'nine/GLOBAL-TEMPLATE.json.gz').read_bytes())) + hosted_template = json.loads(gzip.decompress((out / name / 'hosted/GLOBAL-TEMPLATE.json.gz').read_bytes())) + require(entry['parent']['geometry_sha256'] == parent_template['geometry_sha256'] == + hosted_template['geometry_sha256'] == raw_geometry_hash, 'raw geometry hash binding') + require(digest(parent_template) == entry['parent']['template_sha256'] == + entry['parent_audit']['template_sha256'], 'raw parent template hash binding') + require(digest(hosted_template) == entry['audit']['template_sha256'] == + read(out / name / 'hosted/GLOBAL.json')['template_sha256'], 'raw hosted template hash binding') + parent_template['geometry_sha256'] = semantic_geometry_hash + hosted_template['geometry_sha256'] = semantic_geometry_hash + for receipt, field, value in ( + (entry['parent'], 'geometry_sha256', semantic_geometry_hash), + (entry['parent'], 'template_sha256', digest(parent_template)), + (entry['parent_audit'], 'template_sha256', digest(parent_template)), + (entry['audit'], 'template_sha256', digest(hosted_template)), + ): + receipt.pop(field) + receipt['semantic_' + field] = value + for name, expected in (('baseline', BASE_C), ('candidate', EXPECTED_C)): + entry = result[name] + require(all(entry['interface']['hypotheses'].values()) and + all(entry['interface']['conclusion'].values()), 'inherited scalar interface failed') + invoice = entry['hosted']['invoice'] + require(Fraction(invoice['bit_lower']) == expected, name + ' exact endpoint differs') + require(Fraction(invoice['next_grid_point_rejected']) == expected + Fraction(1, 10**24), + name + ' root bracket differs') + require((invoice['bit']['charged_prefix_bits'], invoice['bit']['charged_two_level_coefficient_bits'], + invoice['bit']['row_coefficient']) == (192, 512, 18355), 'complete precision/row bill changed') + require(len(entry['hosted']['parent_audit']['mutations_rejected']) == 17 and + len(entry['hosted']['audit']['mutations_rejected']) == 16, 'inherited control coverage') + candidate = result['candidate']['hosted'] + require(binding['profile'] == {int(k): v for k, v in candidate['audit']['profile'].items()}, + 'emitted binding/audit profile mismatch') + require(binding['rank_mass'] == 64 * 28416 - 10272 and binding['paid_children'] == 904320, + 'emitted complete bill mismatch') + require(EXPECTED_C > BASE_C > SELECTED_COMPLEX, 'supplier binding changed') + # Retain every proof-relevant field of the complete source pipeline result. + # Runtime/toolchain fields and historical cited PR548 assembly are separate. + result.pop('environment') + for entry in (result['baseline'], result['candidate']): + entry['hosted']['invoice'].pop('kappa') + local = {name: {k: v for k, v in receipt.items() if k != 'paths'} + for name, receipt in context['local'].items()} + return {'schema_version': 1, 'status': 'PASS_R438_NATIVE_REHOST', + 'base_commit': read(HERE / 'SOURCES.json')['base_commit'], + 'normalization': 'Original raw geometry/template hashes checked within each run; semantic_* hashes omit only geometry.seconds and rebind that geometry digest in the templates.', + 'geometry': {'semantic_sha256': semantic_geometry_hash, + 'h': geometry['h'], 'm': geometry['m'], 'stages': geometry['stages'], + 'ports': len(geometry['ports']), 'route_checks': geometry['route_checks'], + 'missing_route_factor_controls': geometry['missing_route_factor_controls'], + 'full_generated_artifact': 'geometry/GEOMETRY.json'}, + 'local': local, 'pipeline': result, 'emitted_binding': binding, + 'projector_receipt': context['reference'], + 'controls': context['local_controls'] + controls, + 'selected_context': {'bit_lower': str(BASE_C), 'complex_lower': str(SELECTED_COMPLEX), + 'kappa': '836330098538459/500000000000000000', 'binding': 'complex'}, + 'no_new_kappa': True} + + +def execute(out, context): + install_selection(context) + context['pipeline'].run(ROOT, out, context['words'], context['local'], context['records']) + result = summarize(out, context) + write(out / 'CERTIFICATE.json', result) + return result + + +def main(): + require(__debug__, 'Inherited checkers require assertions: do not use -O') + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', type=Path, help='Retain a full replay in a NEW directory') + parser.add_argument('--local-only', action='store_true', help='Recheck local/interface geometry only; no native claim') + parser.add_argument('--write-certificate', type=Path, help='Write a fresh external certificate instead of comparing') + args = parser.parse_args() + require(not args.local_only or (args.output is None and args.write_certificate is None), + 'local-only is incompatible with output/certificate options') + if args.write_certificate: + require(not args.write_certificate.exists(), 'Certificate destination exists') + require(HERE not in args.write_certificate.resolve().parents, 'Certificate output must be outside the package') + context = prepare() + if args.local_only: + expected = read(HERE / 'CERTIFICATE.json') + require(canonical(expected['projector_receipt']) == canonical(context['reference']), 'stored projector receipt') + local = {name: {k: v for k, v in r.items() if k != 'paths'} for name, r in context['local'].items()} + require(canonical(local) == canonical(expected['local']), 'stored local receipt') + require(expected['controls'][:3] == context['local_controls'], 'stored local controls') + print('PASS_R438_NATIVE_REHOST_LOCAL local_columns=660 native_not_run no_new_kappa') + return + if args.output: + out = args.output.resolve() + require(not out.exists(), 'Output directory already exists') + result = execute(out, context) + else: + with tempfile.TemporaryDirectory(prefix='r438-native-rehost-') as temporary: + result = execute(Path(temporary) / 'run', context) + if args.write_certificate: + with args.write_certificate.open('x') as stream: + stream.write(json.dumps(result, sort_keys=True, indent=2) + '\n') + else: + require(canonical(result) == canonical(read(HERE / 'CERTIFICATE.json')), 'complete stored certificate differs') + print('PASS_R438_NATIVE_REHOST native=5,9,11 owners=126144 children=904320 ' + 'c=0.001734846264120199151475 no_new_kappa') + + +if __name__ == '__main__': + main()