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()