diff --git a/research/r439-deferred-target-basis-seed06/EXPECTED.json b/research/r439-deferred-target-basis-seed06/EXPECTED.json new file mode 100644 index 0000000000..074ede527a --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/EXPECTED.json @@ -0,0 +1,7029 @@ +{ + "census": { + "PR1040": { + "ADDs": [ + 11780, + 11348 + ], + "B": [ + 10394084, + 9602408 + ], + "D_runs": [ + [ + "hh", + 221 + ], + [ + "yy", + 307 + ], + [ + "yh", + 111 + ], + [ + "yy", + 307 + ], + [ + "hh", + 221 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 72847, + 72847 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3558, + "cuts_with_target_difference": 2918, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "616732de2383dc406632a1dfce5e7cc111607f88a24e829f8d9e904c0a69134c", + "exporter": { + "base": { + "ADD": 11780, + "B": 10394084, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "b98c9307fe8e2f395cdfa63678d71fc485a61e9e1d523a85fb98badd128a1f6d", + "records": 14709 + }, + "deferred": { + "ADD": 11348, + "B": 9602408, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "d30e9d0d79bcf1f9a256c259e6d6257a93e69cbca1f409c7b59868f8880d28bd", + "records": 14277 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 606, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1110, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 587, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 95, + "prefix_split_argmin": [ + 0 + ], + "prefix_split_cost_full_deferral": 95, + "prefix_split_cost_min": 95, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 0, + "prefix_split_listing_unchanged_for_first_gates": 0, + "prefix_split_points": 308, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 16, + 8, + 4, + 8, + 10, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 92, + [ + 32, + 52, + 53 + ] + ], + "best_by_size": [ + [ + 95, + [] + ], + [ + 94, + [ + 32 + ] + ], + [ + 93, + [ + 32, + 52 + ] + ], + [ + 92, + [ + 32, + 52, + 53 + ] + ], + [ + 92, + [ + 1, + 32, + 52, + 53 + ] + ] + ], + "full_deferral_cost": 95, + "greedy": [ + 92, + [ + 32, + 52, + 53 + ] + ], + "ideals_by_size": [ + 1, + 62, + 1915, + 39313, + 603838 + ], + "minimal_gates": 62, + "size_bound": 4, + "undo_gates": 307 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-target-retune-seed14/candidate.json.gz", + "payload_sha256": "06fab704664b836fb79cc512daf39d684375b4523a1b9b827e3e91a591385dcd", + "preparation_contiguous": true, + "preparation_gates": 307, + "rank_mass": 5129, + "saving": 432, + "scatter_ADDs": [ + 527, + 95 + ], + "selected_profile": true, + "undo_gates": 307 + }, + "PR1047": { + "ADDs": [ + 11769, + 11339 + ], + "B": [ + 10394084, + 9602408 + ], + "D_runs": [ + [ + "hh", + 221 + ], + [ + "yy", + 306 + ], + [ + "hh", + 1 + ], + [ + "yh", + 111 + ], + [ + "hh", + 1 + ], + [ + "yy", + 306 + ], + [ + "hh", + 221 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 72847, + 72847 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3557, + "cuts_with_target_difference": 2916, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "0dd36801391a49f603ac0f3fa3a48b86776d22cd70f70a653dd1af60c6425ba7", + "exporter": { + "base": { + "ADD": 11769, + "B": 10394084, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "da5e33a7bde82fff5c86a42ca633e6bab2218a73a394734a098181c60e67c713", + "records": 14698 + }, + "deferred": { + "ADD": 11339, + "B": 9602408, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "17de64210ef0401ca57ec9d4588f52d247b41a87c74e6bb9210dbab7d95990ed", + "records": 14268 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-post-helper-shear-seed03/candidate.json.gz", + "payload_sha256": "784caecb6e3b5e38efcb7f9bbd3e0973f97edc0889b7c28fad5662c48388eb29", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1062": { + "ADDs": [ + 11500, + 11070 + ], + "B": [ + 5911840, + 5024524 + ], + "D_runs": [ + [ + "hh", + 236 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 236 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 25717, + 25717 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3585, + "cuts_with_target_difference": 2931, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "3a9cba324837a3f486ced7dc2b4df38c0c59b884c1763057194eb13096e9b687", + "exporter": { + "base": { + "ADD": 11500, + "B": 5911840, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 25717, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 182, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "80bb888427eb8bf158dd4279aa56340d20cf573c296f15632b22afabedf0967d", + "records": 14429 + }, + "deferred": { + "ADD": 11070, + "B": 5024524, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 25717, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 181, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "e3ed2ba50aca53620b1dde2f8b9ee68518213639fc6a187084aa5e945f1f86db", + "records": 13999 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 95, + 95 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 182, + 181 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-bsection-stars-seed01/candidate.json.gz", + "payload_sha256": "62fc64481911bec4c18643c0c6ac7d31091f09c081a9223096839a7150185be8", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1062-composition": { + "ADDs": [ + 11515, + 11085 + ], + "B": [ + 5846566, + 4971904 + ], + "D_runs": [ + [ + "hh", + 221 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 221 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 24625, + 24625 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3555, + "cuts_with_target_difference": 2916, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "6d5ea18989d817fad5d7447c1e54694cef8486a1387dc4f46bd8cb3da9c8e1a4", + "exporter": { + "base": { + "ADD": 11515, + "B": 5846566, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 24625, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 181, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "3ef472637d6d99f03bb0b92a88bd5109632b9ddc621362ff1ed49a9b502c3335", + "records": 14444 + }, + "deferred": { + "ADD": 11085, + "B": 4971904, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 24625, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 180, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "e2aa83c7ff8ad6de1ed65c1c636099b33ccf37b52582f1c8875ee50105982200", + "records": 14014 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 95, + 95 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 181, + 180 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-bsection-stars-seed01/composition.json.gz", + "payload_sha256": "42ca09ed2996737f9280f27688176ab4401b22600586df0e29f7460528568b55", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1062-pair-control": { + "ADDs": [ + 11715, + 11285 + ], + "B": [ + 5892602, + 5005286 + ], + "D_runs": [ + [ + "hh", + 188 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 188 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 24563, + 24563 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3489, + "cuts_with_target_difference": 2883, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "ac7302160e164c89c5cb2404a111cc5a11dcefd466fda3eed5f451a6f39a7964", + "exporter": { + "base": { + "ADD": 11715, + "B": 5892602, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 24563, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 181, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "da348d2ac45dd28670464c7237a89125ae7480397857b16bc1c0303a2892e9b0", + "records": 14644 + }, + "deferred": { + "ADD": 11285, + "B": 5005286, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 24563, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 180, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "45016403d1cabcfd1bb035845dc3a38e3d1377e54dca42aef0ba5fd560873517", + "records": 14214 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 95, + 95 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 181, + 180 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-bsection-stars-seed01/pair_control.json.gz", + "payload_sha256": "0bdfccdfa63cdba6b24a52dd06021af7cbf7159bb74b85c020b4a94d18da2e62", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1122": { + "ADDs": [ + 10652, + 10222 + ], + "B": [ + 3910388, + 2996128 + ], + "D_runs": [ + [ + "hh", + 236 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 236 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 15223, + 15223 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3216, + "cuts_with_target_difference": 2562, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "2c4f214a660c03fd45ec133542d86daed50b08391870d33909fba1f72a3b6040", + "exporter": { + "base": { + "ADD": 10652, + "B": 3910388, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 15223, + "MOVE": 2911, + "local_bits": 92, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 176, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "c3b2efc2282db0f5593c35c46c44b70af79e724f77b322637b26dc54e8578d7c", + "records": 13581 + }, + "deferred": { + "ADD": 10222, + "B": 2996128, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 15223, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 174, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "4ad6c661a7677605320276ca6a42d93ee7fd11c9c0463e85607d32a80122fe6a", + "records": 13151 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 92, + 91 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 176, + 174 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-abc-star-composition/candidate.json.gz", + "payload_sha256": "7bbaed96041297cd38e89ff48eb055750cfab36609b9fdbeafcec1b2758c1254", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1188": { + "ADDs": [ + 10492, + 10062 + ], + "B": [ + 3758418, + 2825146 + ], + "D_runs": [ + [ + "hh", + 236 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 236 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 13667, + 13667 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3136, + "cuts_with_target_difference": 2482, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "e7dd976535977adb327cfe03847324eef05f0d76b38bf120a17a79facac495bf", + "exporter": { + "base": { + "ADD": 10492, + "B": 3758418, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 13667, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 175, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "2df55087c71725651b7fc531323a371810f6c8c6d49d84d2c397bdc2d1862133", + "records": 13421 + }, + "deferred": { + "ADD": 10062, + "B": 2825146, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 13667, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 173, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "9732a8373b845d090615a39a693dc3c1fdb165777aa9b136f4f86aaac8f90e0c", + "records": 12991 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 91, + 91 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 175, + 173 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-gl5-shortest/candidate.json.gz", + "payload_sha256": "b381d9bc18820b89f92485826ff9f8449d0f72f7599772d52c14e07d6b89b7f2", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1208": { + "ADDs": [ + 10542, + 10112 + ], + "B": [ + 3663878, + 2774762 + ], + "D_runs": [ + [ + "hh", + 236 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 236 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 13721, + 13721 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3162, + "cuts_with_target_difference": 2508, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "8c6117493886d31bb13d055a308b60a0be3d97dee349e8c7004d87fd65cbfe09", + "exporter": { + "base": { + "ADD": 10542, + "B": 3663878, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 13721, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 174, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "aeb75254657bc6e326398abcb9696b6076755c7d975a51ed89019cb19605c895", + "records": 13471 + }, + "deferred": { + "ADD": 10112, + "B": 2774762, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 13721, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 173, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "3184b0189befdb67ea67bb1ef64d6082aec89afcfcafcfbc559243b747868d8f", + "records": 13041 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 91, + 91 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 526, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 174, + 173 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-abc-zrewrite-seed16/CANDIDATE-WORD.json", + "payload_sha256": "85df062ca4cdffc17113fe12e32588db91dc950c1ec9a089b59920a3be17e353", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1449": { + "ADDs": [ + 11781, + 11351 + ], + "B": [ + 10394084, + 9602408 + ], + "D_runs": [ + [ + "hh", + 221 + ], + [ + "yy", + 306 + ], + [ + "hh", + 1 + ], + [ + "yy", + 1 + ], + [ + "yh", + 111 + ], + [ + "yy", + 1 + ], + [ + "hh", + 1 + ], + [ + "yy", + 306 + ], + [ + "hh", + 221 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 72847, + 72847 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3560, + "cuts_with_target_difference": 2919, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "a158e2a75389d7ee5647737396f06a8b46f0eb65cc0ba05f4f27ad9e02d356f3", + "exporter": { + "base": { + "ADD": 11781, + "B": 10394084, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "e94864b8dd71f32932a6940ecf232dcb40cc931c6b612cc5330a0424fadbf3bc", + "records": 14710 + }, + "deferred": { + "ADD": 11351, + "B": 9602408, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "77ae47597f80fa9acdc5e760098551fd9a0257cf46de0cfe6d02e1104fbe2dfe", + "records": 14280 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 604, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1083, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 586, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 7, + "prefix_split_listing_unchanged_for_first_gates": 6, + "prefix_split_points": 308, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 32, + 52, + 53 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 32 + ] + ], + [ + 95, + [ + 32, + 52 + ] + ], + [ + 94, + [ + 32, + 52, + 53 + ] + ], + [ + 94, + [ + 0, + 32, + 52, + 53 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 32, + 52, + 53 + ] + ], + "ideals_by_size": [ + 1, + 62, + 1915, + 39315, + 603961 + ], + "minimal_gates": 62, + "size_bound": 4, + "undo_gates": 307 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-neutral-mixed-shears-seed13/candidate.json.gz", + "payload_sha256": "6d58ca3b5cb9f5d77615766995972202cfa75df90d02c85749d202aae86195eb", + "preparation_contiguous": false, + "preparation_gates": 307, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 307 + }, + "PR1543": { + "ADDs": [ + 11489, + 11059 + ], + "B": [ + 5977064, + 5089748 + ], + "D_runs": [ + [ + "hh", + 238 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 238 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 25885, + 25885 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3589, + "cuts_with_target_difference": 2933, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "798b59e1a587f2c77a53cfc46da6a139d209d3e5fc871f297599f626d88318b8", + "exporter": { + "base": { + "ADD": 11489, + "B": 5977064, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 25885, + "MOVE": 2911, + "local_bits": 96, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 182, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "9ea8c7068d40c57ba2fb54296bcd0ace2f12966f9f394edeaade334fb0910679", + "records": 14418 + }, + "deferred": { + "ADD": 11059, + "B": 5089748, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 25885, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 181, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "6ebef769d76ee76ec96313413971d48f0b45f793d17715265bcd29f8fe8e9b77", + "records": 13988 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 96, + 95 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 182, + 181 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-neutral-helper-chain-seed17/CANDIDATE.json.gz", + "payload_sha256": "ae112d1ee2fc6ef9f077a107a0e8ddeec8aaeaec6d88eee28e7272a7562937b7", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1709": { + "ADDs": [ + 11488, + 11058 + ], + "B": [ + 5921344, + 5034028 + ], + "D_runs": [ + [ + "hh", + 241 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 241 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 27061, + 27061 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3595, + "cuts_with_target_difference": 2936, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "5d18a3bb696dbad029fd9eeaa7cbfdcc120ea6cfdd4aba2e8cc34aaee733a277", + "exporter": { + "base": { + "ADD": 11488, + "B": 5921344, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 27061, + "MOVE": 2911, + "local_bits": 96, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 182, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "10de6f93ba0dcf14aaeb0bfeaea0e35f65ad5ba22de6284fe2828a7ee0504930", + "records": 14417 + }, + "deferred": { + "ADD": 11058, + "B": 5034028, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 27061, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 181, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "20745d9535ffab56e1fc54ed3a5e6a732daa310f84fdd478ee082ea21fbc489b", + "records": 13987 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 96, + 95 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 182, + 181 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-five-cycle-seed9f01/CANDIDATE.json.gz", + "payload_sha256": "b19f7c71997e5d402003b62c7083fc115fec931344ead2667d4e736e0008be2b", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1868-1062": { + "ADDs": [ + 11497, + 11067 + ], + "B": [ + 5858638, + 4976508 + ], + "D_runs": [ + [ + "hh", + 236 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 233 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 25717, + 25717 + ], + "T_is_identity": false, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": null, + "base_D_operator_equals_PR589_D": false + }, + "bridge": { + "cuts": 3582, + "cuts_with_target_difference": 2928, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "73a3285e2691a0e985dc0096b158df67f4275ff01fe77feaab2019b41f580d22", + "exporter": { + "base": { + "ADD": 11497, + "B": 5858638, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 25717, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 182, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "c44b7709940a9256293cbd21a29e819382426ea15c02b90b0d39ca096bc53620", + "records": 14426 + }, + "deferred": { + "ADD": 11067, + "B": 4976508, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 25717, + "MOVE": 2911, + "local_bits": 95, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 181, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "b1d5e7ae1f5c0bfc519950a32aee3ad740d6ca34e280e06100f0fef8fa75bc77", + "records": 13996 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": false, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": false, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 95, + 95 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 182, + 181 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "H4_C_literal_reverse_at_full", + "K_equals_D", + "C_is_U_inverse" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H4_C_literal_reverse_at_full", + "H5_V_identity", + "K_equals_D", + "C_is_U_inverse" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-twisted-star-absorption-seed02/absorbed-pr1062.json.gz", + "payload_sha256": "b6b2acfc7293ac1910fdf8b087ab62f002809eaec7760b7dcaae9aa754738062", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR1868-1188": { + "ADDs": [ + 10489, + 10059 + ], + "B": [ + 3748680, + 2816834 + ], + "D_runs": [ + [ + "hh", + 236 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 233 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 13667, + 13667 + ], + "T_is_identity": false, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": null, + "base_D_operator_equals_PR589_D": false + }, + "bridge": { + "cuts": 3133, + "cuts_with_target_difference": 2479, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "73c0d1713d5ceec20e0cee68f20973801ba3a50481ab0965269c6d0d46f4d18b", + "exporter": { + "base": { + "ADD": 10489, + "B": 3748680, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 13667, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 175, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "2b4da8c826c816b58ea05f1b2906df46379e20da8d1e2bbd7e84430d99f0973f", + "records": 13418 + }, + "deferred": { + "ADD": 10059, + "B": 2816834, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 13667, + "MOVE": 2911, + "local_bits": 91, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 173, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "1fad8a002101d6ec04adc8b08502973f229608733c69a13faba8cb7374672fb2", + "records": 12988 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": false, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": false, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 91, + 91 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 527, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 175, + 173 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "H4_C_literal_reverse_at_full", + "K_equals_D", + "C_is_U_inverse" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H4_C_literal_reverse_at_full", + "H5_V_identity", + "K_equals_D", + "C_is_U_inverse" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-twisted-star-absorption-seed02/absorbed-pr1188.json.gz", + "payload_sha256": "72a28b93811e7f175dd824079f776dfde41eda7482bb86db01e153d84cff3931", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR915": { + "ADDs": [ + 13208, + 12778 + ], + "B": [ + 9534616, + 8742940 + ], + "D_runs": [ + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 49347, + 49347 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3113, + "cuts_with_target_difference": 2695, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "562e69a98dfb9cea8abe3bcdf97ce7d4854ea09cf10b0b172416fd0966ed24b2", + "exporter": { + "base": { + "ADD": 13208, + "B": 9534616, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 49347, + "MOVE": 2911, + "local_bits": 100, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 189, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "c8f0b1a067b94fcf10096df2758c1e943dd4f30ace9d3629cf8e20d19bed05cf", + "records": 16137 + }, + "deferred": { + "ADD": 12778, + "B": 8742940, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 49347, + "MOVE": 2911, + "local_bits": 99, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 189, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "770185daf2047ecb40d0ef5bc1441c22acffd38a4e7ff19607b58498ca4471aa", + "records": 15707 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 100, + 99 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 189, + 189 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-target-compensation/candidate.json.gz", + "payload_sha256": "6aec2c6f91c87a7440af10cdeb90b8814501224a86de14d4033ae3ffa00899da", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR926": { + "ADDs": [ + 11980, + 11550 + ], + "B": [ + 10562318, + 9770642 + ], + "D_runs": [ + [ + "hh", + 192 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 192 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 71907, + 71907 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3497, + "cuts_with_target_difference": 2887, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "a1398b11bb59033df2c395a3dd815f6588d8e46a3bafe4b4f0c4214303c0f1c7", + "exporter": { + "base": { + "ADD": 11980, + "B": 10562318, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 71907, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "1c93cd7f1d3a0971e30289eef4a1334a059a867a4f469095952bfb9de3b9f411", + "records": 14909 + }, + "deferred": { + "ADD": 11550, + "B": 9770642, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 71907, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "3240b377ab4507a7ac9e51f6cedcf456d72d73890bf5f32759f11ebed662dcf5", + "records": 14479 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-two-sided-compensation/candidate.json.gz", + "payload_sha256": "fdb1a0dfafe5392e01fb87f5813737db0f15682c5cb98fc224d4d4cdbc806dd2", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR941": { + "ADDs": [ + 11949, + 11519 + ], + "B": [ + 10548832, + 9757156 + ], + "D_runs": [ + [ + "hh", + 199 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 199 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 70083, + 70083 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3511, + "cuts_with_target_difference": 2894, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "8d8e2dcfecfe189f7f69347adc549e7a3bf0b6bd610307911aadadb7f9277b36", + "exporter": { + "base": { + "ADD": 11949, + "B": 10548832, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 70083, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "a03df32b8d6eed87f5037c2b28f600125dd30206f57e5ba9ea8ff78d3a9a2c22", + "records": 14878 + }, + "deferred": { + "ADD": 11519, + "B": 9757156, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 70083, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "b2dddda5fcb13b8183582f4a2463c1152eb2fdc9c2653d20f31b030c88c987bc", + "records": 14448 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 101, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-helper-matching/candidate.json.gz", + "payload_sha256": "06808b6a98689bba6095fd96c0602fa585dc114bf33073f30acce34b1fdff18d", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR941-floor": { + "ADDs": [ + 11948, + 11518 + ], + "B": [ + 10518760, + 9727084 + ], + "D_runs": [ + [ + "hh", + 199 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 199 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 73603, + 73603 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3511, + "cuts_with_target_difference": 2894, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "d1753c7837e3e8e3021d363feefcea306dbe7233e78a5d2e8ad758f22f095832", + "exporter": { + "base": { + "ADD": 11948, + "B": 10518760, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 73603, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": false, + "nine_stage_bits": 193, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "c4be2f74266fdc752f87f2ca1e52b5764f6c487be486720a58c83ee3989ca82d", + "records": 14877 + }, + "deferred": { + "ADD": 11518, + "B": 9727084, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 73603, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "74be8438db4a4ff22a99f6670582c5ec03fad9cbcf52a558be76574ac97c811a", + "records": 14447 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 193, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-helper-matching/floor-word.json.gz", + "payload_sha256": "8948c509341735070c46de5ecb723f8e4294c22b14470ad7c3140875ab10971f", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR965": { + "ADDs": [ + 11840, + 11410 + ], + "B": [ + 10464656, + 9672980 + ], + "D_runs": [ + [ + "hh", + 234 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 234 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 72399, + 72399 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3581, + "cuts_with_target_difference": 2929, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "e81c9cbe701005a08a2249a08cdf417284bfa7239cc03cfdf18d1fda33c27a22", + "exporter": { + "base": { + "ADD": 11840, + "B": 10464656, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72399, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "4283f1d5d6157b5bcf23f58204e4c73488dfffe0954c7e41379f4df3c01a4386", + "records": 14769 + }, + "deferred": { + "ADD": 11410, + "B": 9672980, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72399, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "06b65800e5736adcc03874796b844857968ed1d4ab6ff2a23bee82097229364c", + "records": 14339 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-helper-triples/candidate.json.gz", + "payload_sha256": "03016658f28ad8d53eba99c6a6bf4db8f6812200e978b4dfa15e74577ef612ee", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + }, + "PR967": { + "ADDs": [ + 11783, + 11353 + ], + "B": [ + 10394084, + 9602408 + ], + "D_runs": [ + [ + "hh", + 221 + ], + [ + "yy", + 306 + ], + [ + "yh", + 111 + ], + [ + "yy", + 306 + ], + [ + "hh", + 221 + ] + ], + "ES_nonzero_rows": 55, + "F": [ + 72847, + 72847 + ], + "T_is_identity": true, + "anchor": { + "PR589_D_splice_passes_every_owner_flag": true, + "base_D_operator_equals_PR589_D": true + }, + "bridge": { + "cuts": 3555, + "cuts_with_target_difference": 2916, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_sha256": "7a1d1b93ffb24a85f1eb598e8b8ee2b84716d7840cfe3ea2b16d14052af627ef", + "exporter": { + "base": { + "ADD": 11783, + "B": 10394084, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 102, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "4970411c56f2c7f7463c70f28d17c4bc517175b12259e7b5c4063e37c2abd856", + "records": 14712 + }, + "deferred": { + "ADD": 11353, + "B": 9602408, + "COPY": 9, + "COPY_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "ERASE": 9, + "F": 72847, + "MOVE": 2911, + "local_bits": 101, + "local_ok": true, + "nine_ok": true, + "nine_stage_bits": 192, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "record_sha256": "5c2cfb93680db6a02a4a6822a8dc3e3c744d9bcc7ee1e54339c1620628220cbf", + "records": 14282 + } + }, + "h5tw": { + "base": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": true, + "R_offdiagonal_ones": 0, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": true, + "V_offdiagonal_ones": 0, + "final_targets_y_plus_x": true + }, + "deferred": { + "C_Uprime_T_identity": true, + "C_full_frame_z_only": true, + "D_frame_zero": true, + "D_source_free": true, + "D_sources_identity": true, + "D_targets_no_source_column": true, + "J_identity": true, + "R_invertible": true, + "R_is_identity": false, + "R_offdiagonal_ones": 608, + "T_helper_only": true, + "T_invertible": true, + "T_is_identity": true, + "U_block_form": true, + "VN_equals_KprimeT": true, + "VR_identity": true, + "V_is_identity": false, + "V_offdiagonal_ones": 1104, + "final_targets_y_plus_x": true + } + }, + "local_bits": [ + 102, + 101 + ], + "maximality": { + "B_target_block_identity": true, + "B_target_write_frames_shared_by_another_target_path": 0, + "B_target_writes": 213, + "B_target_writes_at_zero": 0, + "B_target_writes_reading_targets": 0, + "absorption_pairs": 585, + "absorption_pairs_frame_legal": 0, + "first_B_target_climb_index": 0, + "first_B_touch_of_every_target_climbs": true, + "per_column_choice_total": 97, + "prefix_split_argmin": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "prefix_split_cost_full_deferral": 97, + "prefix_split_cost_min": 97, + "prefix_split_cost_no_deferral": 527, + "prefix_split_cost_unchanged_for_first_gates": 6, + "prefix_split_listing_unchanged_for_first_gates": 5, + "prefix_split_points": 307, + "relaxed_paths": { + "current": { + "max_partners": 55, + "writes_with_a_partner": 102 + }, + "loose": { + "max_partners": 58, + "writes_with_a_partner": 102 + }, + "monotone": { + "max_partners": 7, + "writes_with_a_partner": 94 + } + }, + "scatter_column_ones_new": [ + 17, + 17, + 8, + 4, + 8, + 11, + 13, + 6, + 13 + ], + "scatter_column_ones_old": [ + 63, + 55, + 55, + 55, + 63, + 63, + 55, + 55, + 63 + ], + "target_nonzero_frame_sets_pairwise_disjoint": true, + "target_pairs_sharing_a_nonzero_frame": 0, + "undo_latest_B_index_max": 661, + "undo_latest_B_index_min": 0, + "undo_operands": 111 + }, + "nine_stage_bits": [ + 192, + 192 + ], + "order_ideals": { + "best": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "best_by_size": [ + [ + 97, + [] + ], + [ + 96, + [ + 31 + ] + ], + [ + 95, + [ + 31, + 51 + ] + ], + [ + 94, + [ + 31, + 51, + 52 + ] + ], + [ + 94, + [ + 0, + 31, + 51, + 52 + ] + ] + ], + "full_deferral_cost": 97, + "greedy": [ + 94, + [ + 31, + 51, + 52 + ] + ], + "ideals_by_size": [ + 1, + 61, + 1854, + 37461, + 566500 + ], + "minimal_gates": 61, + "size_bound": 4, + "undo_gates": 306 + }, + "owner_false_base": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "owner_false_deferred": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "path": "research/r439-helper-stars-seed19/candidate.json.gz", + "payload_sha256": "82521d616fb9cd3b57576678e1b9de67c8587c7d0b8ed8d87a1405c5a684c3ae", + "preparation_contiguous": true, + "preparation_gates": 306, + "rank_mass": 5129, + "saving": 430, + "scatter_ADDs": [ + 527, + 97 + ], + "selected_profile": true, + "undo_gates": 306 + } + }, + "check_controls": [ + [ + "precision guard on the PR941 floor-calibration base word (193 nine-stage bits)", + "PR941-floor base: precision guard (exporter F/B)" + ] + ], + "columns": 661, + "controls": { + "PR1062": [ + [ + "deferral with the old scatter listing S", + "dirty endpoint wrong on 111 registers {'target': 111}; failed equations ['J_identity', 'VN_equals_KprimeT']" + ], + [ + "undo moved after B[0], the first B climb of an undo operand (frames)", + "illegal frame move: register 111 frame 127 -> 0" + ], + [ + "undo moved after B[0] (values, frames ignored)", + "dirty endpoint wrong on 28 registers {'target': 28}" + ], + [ + "first undo gate dropped", + "dirty endpoint wrong on 6 registers {'target': 6}; failed equations ['VR_identity', 'VN_equals_KprimeT']" + ], + [ + "undo gates in preparation order", + "dirty endpoint wrong on 111 registers {'target': 111}; failed equations ['VR_identity', 'J_identity', 'VN_equals_KprimeT']" + ], + [ + "E S row 1 with bit 0 flipped", + "dirty endpoint wrong on 6 registers {'target': 6}; failed equations ['J_identity', 'VN_equals_KprimeT']" + ], + [ + "corrupted source pin", + "source pin mismatch (sha256): research/r439-bsection-stars-seed01/candidate.json.gz" + ], + [ + "adjacent non-commuting undo gates 7,8 swapped", + "dirty endpoint wrong on 24 registers {'target': 24}; failed equations ['VR_identity', 'VN_equals_KprimeT']" + ], + [ + "bridge on the deferred word with its last D gate dropped", + "bridge: the deferred word D/A differ from the replayed steps" + ], + [ + "bridge on the old-S word", + "bridge: target 1 is not the tracked twist of the original" + ], + [ + "bridge on the swapped-undo word", + "bridge: the twist is not undone" + ], + [ + "owner delta on (base, base)", + "PR1062: owner flags newly false [], newly true []" + ], + [ + "frame paths: legal frame raise of B[500] 508 -> 422", + "PR1062: ordered per-register frame paths changed" + ], + [ + "paid profile: legal frame raise of B[500] 508 -> 422", + "PR1062: paid profile changed" + ], + [ + "exporter profile against the frame-raised profile", + "PR1062: exporter profile differs from the frame-path profile" + ], + [ + "maximality census with the deferred word as its own base", + "PR1062: maximality census" + ] + ], + "PR1188": [ + [ + "deferral with the old scatter listing S", + "dirty endpoint wrong on 111 registers {'target': 111}; failed equations ['J_identity', 'VN_equals_KprimeT']" + ], + [ + "undo moved after B[0], the first B climb of an undo operand (frames)", + "illegal frame move: register 111 frame 127 -> 0" + ], + [ + "undo moved after B[0] (values, frames ignored)", + "dirty endpoint wrong on 28 registers {'target': 28}" + ], + [ + "first undo gate dropped", + "dirty endpoint wrong on 6 registers {'target': 6}; failed equations ['VR_identity', 'VN_equals_KprimeT']" + ], + [ + "undo gates in preparation order", + "dirty endpoint wrong on 111 registers {'target': 111}; failed equations ['VR_identity', 'J_identity', 'VN_equals_KprimeT']" + ], + [ + "E S row 1 with bit 0 flipped", + "dirty endpoint wrong on 6 registers {'target': 6}; failed equations ['J_identity', 'VN_equals_KprimeT']" + ], + [ + "corrupted source pin", + "source pin mismatch (sha256): research/r439-gl5-shortest/candidate.json.gz" + ], + [ + "adjacent non-commuting undo gates 7,8 swapped", + "dirty endpoint wrong on 24 registers {'target': 24}; failed equations ['VR_identity', 'VN_equals_KprimeT']" + ], + [ + "bridge on the deferred word with its last D gate dropped", + "bridge: the deferred word D/A differ from the replayed steps" + ], + [ + "bridge on the old-S word", + "bridge: target 1 is not the tracked twist of the original" + ], + [ + "bridge on the swapped-undo word", + "bridge: the twist is not undone" + ], + [ + "owner delta on (base, base)", + "PR1188: owner flags newly false [], newly true []" + ], + [ + "frame paths: legal frame raise of B[500] 508 -> 422", + "PR1188: ordered per-register frame paths changed" + ], + [ + "paid profile: legal frame raise of B[500] 508 -> 422", + "PR1188: paid profile changed" + ], + [ + "exporter profile against the frame-raised profile", + "PR1188: exporter profile differs from the frame-path profile" + ], + [ + "maximality census with the deferred word as its own base", + "PR1188: maximality census" + ] + ] + }, + "ideal_split": { + "PR1040": { + "ADDs": [ + 11780, + 11348, + 11345 + ], + "B": 9602408, + "F": 72847, + "bridge": { + "cuts": 3558, + "cuts_with_target_difference": 2918, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_to_B": 304, + "kept_before_scatter": 3, + "kept_undo_gates": [ + 32, + 52, + 53 + ], + "label": "found by search (exhaustive over ideals of size <= 4 plus greedy descent), not optimal", + "local_bits": 101, + "nine_stage_bits": 192, + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "scatter_ADDs": [ + 527, + 95, + 92 + ], + "word_sha256": "b95bec07e83a67a861b0e05c81aaf07e9dc56239db77983f484ce16866f8a48f" + }, + "PR1062": { + "ADDs": [ + 11500, + 11070, + 11067 + ], + "B": 5024524, + "F": 25717, + "bridge": { + "cuts": 3585, + "cuts_with_target_difference": 2931, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_to_B": 303, + "kept_before_scatter": 3, + "kept_undo_gates": [ + 31, + 51, + 52 + ], + "label": "found by search (exhaustive over ideals of size <= 4 plus greedy descent), not optimal", + "local_bits": 95, + "nine_stage_bits": 181, + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "scatter_ADDs": [ + 527, + 97, + 94 + ], + "word_sha256": "5b7ce519bb3a93987bdbfeddcc15699dae436652d9da837dadbbcec2d834df6f" + }, + "PR1188": { + "ADDs": [ + 10492, + 10062, + 10059 + ], + "B": 2825146, + "F": 13667, + "bridge": { + "cuts": 3136, + "cuts_with_target_difference": 2482, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_to_B": 303, + "kept_before_scatter": 3, + "kept_undo_gates": [ + 31, + 51, + 52 + ], + "label": "found by search (exhaustive over ideals of size <= 4 plus greedy descent), not optimal", + "local_bits": 91, + "nine_stage_bits": 173, + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "scatter_ADDs": [ + 527, + 97, + 94 + ], + "word_sha256": "3cadbce5c79d65f18183bb97f64d972099e73a1635f897215085f0a32e781187" + }, + "PR1868-1188": { + "ADDs": [ + 10489, + 10059, + 10056 + ], + "B": 2816834, + "F": 13667, + "bridge": { + "cuts": 3133, + "cuts_with_target_difference": 2479, + "max_targets_differing": 111, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "deferred_to_B": 303, + "kept_before_scatter": 3, + "kept_undo_gates": [ + 31, + 51, + 52 + ], + "label": "found by search (exhaustive over ideals of size <= 4 plus greedy descent), not optimal", + "local_bits": 91, + "nine_stage_bits": 173, + "owner_newly_false": [ + "H5_V_identity" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "scatter_ADDs": [ + 527, + 97, + 94 + ], + "word_sha256": "23f1912469a34f27372761ee40c439cea19fff39925bd70c505bec723c0dbf07" + } + }, + "inputs": { + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/e8-bit-p111/data/bitE8mut-p111.json.gz": "1bc3c53d4baf4927c6a00c339ea3975516471a48074d4d97c6addaded2a4d858", + "research/r439-abc-star-composition/candidate.json.gz": "2b09a7a3851cdf2a7f19350d1555cf75788d001c9507a37e459cd931881ee066", + "research/r439-abc-zrewrite-seed16/CANDIDATE-WORD.json": "66b34404f39f5f612c2aaadd53ae33eb9f5993ec2065c82e23d7467cce03a226", + "research/r439-b509-boolean-seed05/candidate.json.gz": "14b8bde5e0b3171795574e3f52046b0e53b5c994a5af5aa77ce0485d69a82687", + "research/r439-bsection-stars-seed01/candidate.json.gz": "b452d2c2b0b2a546d1105b1da9769aa78e5c54d6f00e97b30c77e3f54ce445ee", + "research/r439-bsection-stars-seed01/composition.json.gz": "0203fea9fa442ca206fe683aa5b6860adac680d63b9fb8be6bd42b39aa7b5cce", + "research/r439-bsection-stars-seed01/pair_control.json.gz": "628ebfebe215e153338e88e2e324040d139a111eebfb090929697c7a0b6f3f59", + "research/r439-five-cycle-seed9f01/CANDIDATE.json.gz": "286fb2e8b397909bd74257ef911b4a76a633e169493d481a9ca40379ae9072b9", + "research/r439-five-wire-prefix/candidate.json.gz": "3a11fc4675cd708316f9b0d398e0c3b73d626de0f824c5ed9b9c96279cfef091", + "research/r439-four-wire-prefix/candidate.json.gz": "9946eaacc69f05a91ad18ca16e57cd4f78db3e0d5b23939f691c96b4a4098a2f", + "research/r439-gl5-shortest/candidate.json.gz": "4e7904d01ebdbfc60a26472b4e0d2e813c19c2fe1a4bb8ab390c12746a1da359", + "research/r439-global-prefix-admission/candidate.json.gz": "fffc0484a3572c76bf3bb5284d4a40eeb723c4b3acf3da5e2d9e113ac1747ec6", + "research/r439-helper-matching/candidate.json.gz": "60531408445a1d7c793dff6821e767739012db1d2646f49aec7fdf7fe0b979f3", + "research/r439-helper-matching/floor-word.json.gz": "4be50c06f91bc605660d4f9fba865c330f82dc4c364041870b725c220d16244e", + "research/r439-helper-stars-seed19/candidate.json.gz": "d8b08885e8ce9868200b2645189d15ed18a27fc2742e54990b3257a0ca4df6b8", + "research/r439-helper-triples/candidate.json.gz": "11f5c75711090892827d536b6bf82b4001e02ebd13d10e87a1aa915a4e78704b", + "research/r439-neutral-helper-chain-seed17/CANDIDATE.json.gz": "559f948dc9f7474e314b27d70286025b21922e3f7a6fbd93b7786cc0f6a871b5", + "research/r439-neutral-mixed-shears-seed13/candidate.json.gz": "845ee7205390e8b5252187051839304c1eae197006cf80fdc9ec156d50916834", + "research/r439-post-helper-shear-seed03/candidate.json.gz": "e6a7a50662ba2c32c7fb42d7051d1300bef52f8e442f593c0081999bc0c27934", + "research/r439-six-wire-boolean/candidate.json.gz": "5c67c7949c07a89ea8394a936a155585d22e6b258997df73e36e7be47fc84cb0", + "research/r439-target-compensation/candidate.json.gz": "ac30266144f8772ec8cd629153993aa9eb692fe745a9f95015a1b7fa88977a2e", + "research/r439-target-retune-seed14/candidate.json.gz": "908f285b69b70cc998718575706b48091e856d96f23e3267060dca7a7546ac50", + "research/r439-twisted-star-absorption-seed02/absorbed-pr1062.json.gz": "38af2e18956a3f6111ddde59da59fd9ca14c7fdbe589f718056ff66a51ecd963", + "research/r439-twisted-star-absorption-seed02/absorbed-pr1188.json.gz": "0d24063702f353cf30466077ac7bc88ed19baabfade80002fafa7edcc14302e7", + "research/r439-two-sided-compensation/candidate.json.gz": "6ac771545e823c054e005429c405dbb2c01ff80fce181b714e1af5e28b6b7cb2", + "research/r439-z3to2-seed13/CANDIDATE-WORD.json": "8aedb3be192baae884c80a2ff3d15d9f32ae8c8055dff170bebca2f87e75539a" + }, + "instances": { + "PR1062": { + "file": "candidate-1062.json.gz", + "payload_sha256": "3a9cba324837a3f486ced7dc2b4df38c0c59b884c1763057194eb13096e9b687" + }, + "PR1188": { + "file": "candidate-1188.json.gz", + "payload_sha256": "e7dd976535977adb327cfe03847324eef05f0d76b38bf120a17a79facac495bf" + } + }, + "new_kappa_claim": false, + "outside": { + "PR1127": { + "ADDs": 23495, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/r439-z3to2-seed13/CANDIDATE-WORD.json", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR1221": { + "ADDs": 24283, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/r439-b509-boolean-seed05/candidate.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR555": { + "ADDs": 24305, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/e8-bit-p111/data/bitE8mut-p111.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR589": { + "ADDs": 24305, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR904": { + "ADDs": 24051, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/r439-four-wire-prefix/candidate.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR936": { + "ADDs": 23711, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/r439-five-wire-prefix/candidate.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR952": { + "ADDs": 23673, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/r439-six-wire-boolean/candidate.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + }, + "PR980": { + "ADDs": 23433, + "D_runs": [ + [ + "yh", + 111 + ] + ], + "deferral": "vacuous (R = I)", + "path": "research/r439-global-prefix-admission/candidate.json.gz", + "scatter_ADDs": 527, + "target_basis_gates": 0 + } + }, + "reorder": { + "PR1062": { + "adjacent_transpositions": 305, + "commuting": 270, + "commuting_swap_boundary_exact": true, + "commuting_swap_checked": [ + 0, + 1 + ], + "non_commuting": 35, + "operator_changes_iff_non_commuting": true + }, + "PR1188": { + "adjacent_transpositions": 305, + "commuting": 270, + "commuting_swap_boundary_exact": true, + "commuting_swap_checked": [ + 0, + 1 + ], + "non_commuting": 35, + "operator_changes_iff_non_commuting": true + } + }, + "selected_heuristic": { + "ADDs": [ + 24305, + 24190 + ], + "B": [ + 1113070, + 1117988 + ], + "F": [ + 49347, + 49347 + ], + "basis_gates_each_way": 79, + "bridge": { + "cuts": 2353, + "cuts_with_target_difference": 2241, + "max_targets_differing": 79, + "states_equal_after_undo": true, + "z_reads_of_targets_in_window": 0 + }, + "local_bits": [ + 93, + 93 + ], + "method": "Prim minimum spanning tree over the 111 scatter rows plus a zero root, edge cost 2 + Hamming distance; scatter basis G (R = G, V = G^-1); heuristic, not optimal", + "nine_stage_bits": [ + 177, + 177 + ], + "owner_false": [ + "H2_D_frame0_targets_from_helpers", + "H5_V_identity", + "K_equals_D" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "roots": 32, + "scatter_ADDs": [ + 527, + 254 + ], + "scatter_related_cost": 412, + "tree_edges": 79, + "word_sha256": "85c9c49b558a9aae2c02966d674009e0d910e67ba52690c84bc89791ae843f21" + }, + "status": "PASS_R439_DEFERRED_TARGET_BASIS" +} diff --git a/research/r439-deferred-target-basis-seed06/PROOF.md b/research/r439-deferred-target-basis-seed06/PROOF.md new file mode 100644 index 0000000000..a4e52fd2ba --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/PROOF.md @@ -0,0 +1,462 @@ +# Deferred target basis (H5-tw): proofs + +This note proves four statements and records one refinement: + +1. the replacement lemma H5-tw, with its converse; +2. that deferring the target-basis undo turns every lineage word into a word meeting H5-tw, with a + unique scatter listing; +3. the cut-by-cut bridge, with an argued physical reading that needs no premise beyond those the base + words already use; +4. maximality of the deferral under fixed ordered frame paths, among prefix splits of the literal undo + order; +5. the order-ideal refinement: splitting the undo at a commutation-closed down-set. On every word the + search finds a split three scatter ADDs below full deferral, and the split is fully checked on + four words. It is found by search and is not claimed optimal. + +`verify.py` checks every finite fact used here, on every committed lineage word (as of base +c6765481). + +## Notation + +A word has `n = 2v + r` registers: sources `x` (v of them), targets `y` (v) and helpers `h` (r). +Write `z = (x, h)`. Here `v = 111`, `r = 439` and `n = 661`. The word runs D, then A, then the +scatter, then B, then C. The scatter is realised literally: COPY one retained helper into a clean +temporary at the zero frame, ADD that temporary into the listed targets, then ERASE it. Each ADD +`d ^= s` is an elementary transvection over F2. + +As in PR1868, a finite product of transvections acts on `M^n` for any F2-module M through its F2 +coefficient matrix. "Boundary" means the complete coefficient matrix on all 661 columns, with +arbitrary ("dirty") helper inputs. + +The kept clauses come from the inherited interleaved lemma. eumemic's PR543 states it (restated in +`research/e8-bit-r420/README.md`), and eumemic's PR555 adaptation `xcheck_p.py` checks it: + +- **H1**: no gate whose destination is a z register reads a target. +- **H3**: A writes only z registers. The scatter reads only retained helpers and writes only targets. + Each B gate either writes a z register from z registers, or writes a target (from any sources). +- **C clause**: every C gate has a z destination, reads only z registers and runs at the full frame. +- **D-shape** (the structural part of H2, as in PR1194 and PR1868): every D gate is at the zero frame + and reads and writes only targets and helpers. D contains no COPY, ERASE or climb. + +By H1 no helper gate in D reads a target, so D's operator has the form + + (x, y, h) -> (x, R y + N h, T h) + +for a v-by-v matrix R, a v-by-r matrix N and an r-by-r matrix T. By H1 and H3 the raw word +`W0' = (A, scatter, B)` has the block form + + z' = U' z, y' = V y + J x + K' h. + +The inherited H2 target clause is `R = I`: D adds to the targets without changing their basis. This +is also PR1194's "complete restoration of every target basis at D's boundary". The inherited H5 is +`V = I`. + +## 1. The replacement lemma H5-tw + +**Contract H5-tw.** Keep H1, H3, the C clause and the D-shape. Replace the pair (H2 target clause +`R = I`, H5 `V = I`) and the K check by: + + (i) V R = I, + (ii) J = I, + (iii) V N = K' T, + (iv) C U' (I_x ⊕ T) = I on z. + +**Lemma.** Under the kept clauses, the complete word maps `(x, y, h) -> (x, y + x, h)` on every +F2-module if and only if (i)–(iv) hold. + +*Proof.* D sends `(x, y, h)` to `(x, R y + N h, T h)`. Applying `W0'` gives + + z' = U' (x, T h) = U' (I ⊕ T) z, + y' = V (R y + N h) + J x + K' T h = V R y + J x + (V N + K' T) h. + +C reads and writes only z registers, so it leaves y unchanged and sends z' to `C U' (I ⊕ T) z`. +The final state is therefore + + (z, y) -> (C U' (I ⊕ T) z, V R y + J x + (V N + K' T) h). + +If (i)–(iv) hold, this is `(z, y + x)`, since `V N + K'T = 0` over F2. Every coefficient lies in F2, +so the identity holds on every M. + +Conversely, suppose the boundary `(x, y, h) -> (x, y + x, h)` holds. Evaluate on the F2 unit columns: + +- the target rows on the target columns give `V R = I`; +- the target rows on the source columns give `J = I`; +- the target rows on the helper columns give `V N + K'T = 0`; +- the z rows give `C U' (I ⊕ T) = I`. ∎ + +**Remarks.** + +- **Invertibility.** `V R = I` forces R and V to be invertible, with `V = R^-1`. +- **The inherited case.** With `R = I`, (i) is H5, so the inherited contract is the case `R = V = I`. + - (iii) with `V = T = I` is PR1194's `N = K`. + - (iii) with `V = I` and general T is PR1868's K-tw. +- **The cleanup (iv).** + - Under the literal H4 (C is the reversed list of z-gates of A and B), `C = U'^-1`, so (iv) holds if + and only if `T = I`. + - PR1868's H4-tw is (iv) itself. + - So the converse proves (iv) from the boundary; it is not assumed through the C clause, which only + fixes C's shape. +- **The listing is unique.** The scatter listing is determined by the rest of the word. Suppose a word + keeps D, A, B and C and changes only the listing, from L to L'. + - The retained totals are nine distinct registers of an invertible state, so their columns c are + linearly independent. + - The final targets change by `V_B (L' + L) c`, where `V_B` is the invertible target block of + everything between the scatter and the end. + - So L is the only listing that meets the boundary. + +## 2. The deferral meets H5-tw + +**Shape of the lineage words.** Every committed PR915-lineage word has a D section of the form + + helper-star preparations, P_E, reads, U_E, helper restorations. + +- `P_E` is the target-basis preparation: 306 target-from-target gates (307 on PR1040 and PR1449). + Its product is E. +- The reads are 111 gates, target-from-helpers. +- `U_E` is the undo: exactly `P_E` reversed, gate by gate, so its product is `E^-1`. + +All of these gates are at the zero frame. There are small layout variations: + +- the helper parts are empty on PR915's word; +- on PR1047 and PR1449 one helper gate sits on each side of the reads; +- on PR1449 the preparation is not contiguous. + +The argument only uses three facts: + +- the target gates before the first read are exactly `P_E`; +- the target gates after the last read are exactly `U_E`; +- no target-from-target gate sits among the reads. + +`verify.py` checks all three on every word. + +**The base word W.** W satisfies the inherited target clauses `R = I` and `V = I`. Let the reads add +`M h~` to the targets, where `h~ = T_s h` is the helper state at the reads and `T_s` is the +helper-star preparation. Then W's D target operator is + + y -> E^-1 (E y + M T_s h) = y + N h, N = E^-1 M T_s. + +W also satisfies (iii) and (iv): + +- the 17 words with `T = I` satisfy PR1194's `N = K`, with literal H4; +- PR1868's two absorbed words satisfy its K-tw and H4-tw. + +**The deferred word W'.** W' makes three changes: + +- it deletes `U_E` from D; +- it replaces the scatter listing S (rows over the nine retained totals) by `E S`; +- it runs the same `U_E` gates, at the zero frame, as the first gates of B. + +**The deferred word's blocks.** + +- *D.* D' is D without `U_E`. Its target operator is `y -> E y + M T_s h = E (y + N h)`, so + `R' = E`, `N' = E N` and `T' = T`. +- *Up to the undo.* A does not touch targets (H1, H3). The scatter adds `E S c`, where c holds the + nine COPY values (functions of z only). The undo then maps the targets by `E^-1`. So after the undo + the targets hold `E^-1 y + S c`, exactly what W's targets hold after its own scatter on input + `E^-1 y`. B is unchanged. +- *The raw word.* Hence `W0''(y) = W0(E^-1 y)`, which gives `V'' = V E^-1 = E^-1`, `J'' = J = I`, + `K'' = K'` and `U'' = U'`. + +Therefore: + + V'' R' = E^-1 E = I, + V'' N' = E^-1 E N = N = K' T, + J'' = I, + +and C, U' and T are unchanged, so (iv) is inherited. W' meets H5-tw with `R = E` and `V = E^-1`. +It fails H5 (`V ≠ I`) and the H2 target clause (`R ≠ I`). By the uniqueness remark, `E S` is the +only listing for this placement. + +`verify.py` computes R, N, T, V, J and K' directly from the words, not from this derivation. It +checks: + +- `R = E` and `V = E^-1`, the latter as the matrix of the literal undo gates; +- (i)–(iv), and the D-shape; +- that the base word is the `R = V = I` case; +- that T is unchanged. + +The controls exhibit the converse: each failing control violates at least one equation, and its +dirty endpoint fails. + +| control | failed equations | dirty endpoint | +|---|---|---| +| old listing S | J, K | wrong on all 111 targets | +| dropped undo gate | V R, K | wrong on 6 targets | +| undo in preparation order | V R, J, K | wrong on 111 targets | +| one wrong E S row | J, K | wrong on 6 targets | +| swapped non-commuting undo pair | V R, K | wrong on 24 targets | + +Here "K" abbreviates `V N = K'T`. Every control fails the dirty endpoint. + +## 3. The bridge, cut by cut + +Align W and W' as follows: + +- the common D gates; +- W's undo, which W' skips; +- the common helper restorations and A; +- the nine COPY blocks (W adds column j of S, W' adds column j of E S); +- W''s deferred undo, which W skips; +- the common B and C. + +**Invariant.** At every cut in this alignment: + +1. every non-target register has the same value and the same frame in W and W'; +2. every target is at the zero frame in both words; +3. W''s target vector equals `M_c` times W's target vector. + +Here `M_c` is I before W's undo. During W's undo it is the running product, and it equals E from the +end of W's undo through the last COPY block. During W''s undo it is again a running product, and it +returns to I. + +*Proof.* Induction over the cuts: + +- *Common z gates.* By H1 they read no target, so they see identical operands in both words. +- *Undo gates.* These are the only target-from-target gates in the window. A W-only gate G updates + `M <- M G`, and a W'-only gate updates `M <- G M`. Both run at the zero frame on registers that + are at the zero frame. +- *COPY blocks.* A block copies the same retained total (a z register, equal in both words) and adds + `S_j c_j` in W and `E S_j c_j = M (S_j c_j)` in W'. +- *Frames.* Targets never move before B: A and the scatter do not climb them, and the exporter places + every scatter ADD at the zero frame. + +After W''s undo, `M = I`, so the complete states agree in value and frame. The remaining +instructions (B and C) are identical. + +**What `verify.py` replays.** It replays both words in lockstep with frames. The deferred side is the +deferred word itself: its D and A must equal the replayed steps, and its B must start with the replayed +undo. It checks the invariant at every cut. A listing other than `M S` breaks the invariant at the +first COPY block it affects; the old-S control is rejected exactly there. + +For example, there are 3,585 cuts on PR1062, of which 2,931 have twisted targets, and 3,136 on PR1188, +with 2,482 twisted. The verifier also checks that no z gate reads a target in the window and that +`M = E` when the scatter starts. + +**Physical reading (argued, not proved).** The physical realization of W is inherited: + +- For the 17 words with `T = I`, `verify.py` re-checks two facts. W's D has the same complete + operator as PR589's D. The PR1194-style proof-only splice, W's A/scatter/B/C with PR589's + target-only D, passes every inherited owner flag. +- For PR1868's two absorbed words, PR1868's own per-cut bridge applies. + +We argue that W' needs no new physical premise. W' differs from W, at every cut, only on targets. They +differ by a linear map of the targets, and the twisted targets are: + +- held at the zero frame; +- read by no z gate. + +The gates that realize this map in W' are of kinds the inherited interface already admits after A: + +- **Undo gates.** The deferred undo consists of B target writes from target sources, which the + inherited H3 permits ("writes a target", any sources). They run under the inherited common-label + realization at the zero frame, where every operand already sits. +- **Scatter ADDs.** W's own scatter ADDs are zero-frame target writes made after A's climbs and the + COPYs, which is the same situation as the deferred undo and the `E S` listing. + +Nothing at a nonzero frame differs, and no register climbs carrying a different value. + +This differs from PR1194's substitution, which was restricted to frame-zero D prefixes. Here the +twisted window extends through A and the scatter, though the targets stay at frame zero and unread +throughout. + +**Contrast with PR1868.** There, three helpers climbed out of the zero frame while holding +`centre + leaf`. That needed the common-frame / climb-additivity premise, applied newly to helpers. +Here no twisted register ever climbs. + +## 4. Maximality under fixed frame paths + +In this section **B means W's B**, which is W''s B after the deferred undo. `verify.py` computes these +facts on W's B, and establishes them on all 19 words: + +- **(F1) Target-frame disjointness.** For each target, take the set of nonzero frames on its ordered + frame path. These sets are pairwise disjoint: none of the 6,105 target pairs share a nonzero frame. +- **(F2) Every first B touch climbs.** Every target's first B touch runs at a nonzero frame. The very + first B gate, B[0], is such a climb. +- **(F3) Target-column confinement.** No B target write reads a target, and none runs at the zero + frame. B's own target block (B alone, from the identity) is I. +- **(F4) The undo covers every target.** All 111 targets are undo operands. + +**Proposition 1 (the undo cannot run later).** Keep the gates and the ordered per-register frame +paths. Then every target-from-target gate runs at the zero frame, before the first B climb of either +of its operands. + +*Proof.* A gate at frame f needs both operands at f at that moment. With fixed paths, f lies on both +operands' paths, and by F1 the only common frame is the zero frame. Frames never descend, and by F2 +each target leaves the zero frame at its first B touch. ∎ + +Consequences: + +- The undo block cannot follow B[0]. Its target, register 111, is an undo operand (F4). +- Each undo gate can pass only B gates that touch neither of its operands. Such a move is a + commutation, and changes no value, frame or count. + +The control that moves the undo after B[0] is rejected by the frame replay (register 111 would +descend from frame 127 to 0). Ignoring frames, its endpoint is also wrong, on 28 targets. + +**Proposition 2 (no B-side absorption).** No undo gate can be absorbed into B. + +*Proof.* In the single-edge sense of PR1868, absorption would delete an undo gate `t ^= s` and +compensate in a later gate writing t. In B, such gates are B target writes at nonzero frames f (F3). +Compensating there needs s at f, so f would have to lie on s's path, which F1 excludes. ∎ + +The census covers every pair (undo gate, B gate writing its destination): 585 pairs per word (587 on +PR1040, 586 on PR1449). None of them is frame-legal. + +More generally, B's target block is I (F3), so B supplies no target-from-target mixing. All of +`E^-1` must therefore be realized by zero-frame target gates that run before the first climbs. The +deferred undo is one such placement. The remaining freedom is: + +- the choice of circuit for `E^-1` (an open question); +- reorderings that leave its product unchanged. On PR1062 and PR1188, 270 of the 305 adjacent + transpositions commute, and those keep the boundary. The other 35 change the operator, and the + checked one breaks the endpoint; +- **where to split the undo between D and B** (below). + +**Prefix-split census.** Suppose the first k undo gates, in the literal undo order, stay in D and the +rest are deferred. The scatter then costs `nnz(E_k S)`, where `E_k` is the basis after those k gates. +Among these prefix splits of the literal undo order only, full deferral (k = 0) attains the minimum +over all split points (307, or 308 where E has 307 gates) on every word: + +- **Ties.** The first five undo gates leave `E S` itself unchanged, and the first six keep + `nnz(E_k S) = 97`, so k ≤ 6 tie. On PR1449 the counts are six and seven, so k ≤ 7 tie. On PR1040 the + minimum is unique. +- **Per-column choice.** Restricted to the two bases I and E for each COPY column, it would not help. + The old column weights are `[63, 55, 55, 55, 63, 63, 55, 55, 63]`. The E-basis weights are + `[17, 17, 8, 4, 8, 11, 13, 6, 13]`, or `[17, 16, 8, 4, 8, 10, 13, 6, 13]` on PR1040, so E is + better on every column. Such a choice would also need the undo inside the scatter, which the word + format cannot express. + +**Scope.** These statements assume fixed ordered frame paths. If paths may change, `verify.py` counts, +for each of the 213 B target writes at frame f, the other targets that could be co-located at f +under three criteria: + +| criterion | writes with a partner | max partners | +|---|---:|---:| +| loose upper bound: the target's final frame contains f | 102 | 58 | +| also: its frame at that moment lies inside f | 102 | 55 | +| also: f fits monotonically between its own earlier and later fixed touches | 94 | 7 | + +Any such visit inserts a climb into that target's path, which changes the paid profile. That class is +outside this census. + +## 5. The order-ideal refinement + +Full deferral is not optimal once commuting reorders of the undo are allowed (pre-PR proof review). + +**Construction.** Let I be an **order ideal** of the undo's dependency poset: a set of undo gates +closed under "every earlier undo gate it does not commute with". Then: + +- the undo sequence is commutation-equivalent to (the gates of I, in order) followed by (the rest, in + order); +- with `G_I` the product of the gates in I, the rest compose to `E^-1 G_I^-1`. + +The ideal-split word keeps the gates of I at the end of D, at the zero frame, lists the scatter as +`G_I E S`, and runs the rest first in B. + +**It meets the same lemma.** Its D target operator is `G_I E (y + N h)`, so: + +- `R = G_I E`; +- `V = E^-1 G_I^-1`, hence `V R = I`; +- `V N' = N = K'T`; +- J, K', U', T and C are unchanged. + +The bridge is the same with `M = G_I E` during A and the scatter. + +**Search, pinned in EXPECTED.json.** `verify.py` enumerates every order ideal of size at most 4, and +then runs a greedy strict descent from the empty ideal: + +| | 306-gate words | PR1040 | +|---|---|---| +| minimal gates | 61 | 62 | +| ideals of size 0–4 | 1, 61, 1,854, 37,461, 566,500 | 1, 62, 1,915, 39,313, 603,838 | +| best ideal | {31, 51, 52} | {32, 52, 53} | +| scatter nnz | 97 → 94 | 95 → 92 | + +PR1449 gives 1, 62, 1,915, 39,315, 603,961 ideals, and its best ideal is {32, 52, 53} with nnz 94. +The greedy descent reaches the same ideal on every word, and no ideal of size 4 improves on size 3. + +**Fully checked words.** On PR1062, PR1188, PR1040 and PR1868's absorbed PR1188 word, `verify.py` +builds the best split found and applies the deferred word's checks: + +- boundary both ways; +- identical frame paths and MOVE records; +- paid profile from frames and from the exporter; +- guards; +- owner checker, with exactly `H5_V_identity` newly false; +- H5-tw identities with `R = G_I E` and `V` the matrix of the remaining gates; +- the per-cut bridge. + +| word | base | full deferral | ideal split | +|---|---:|---:|---:| +| PR1062 | 11,500 | 11,070 | **11,067** | +| PR1188 | 10,492 | 10,062 | **10,059** | +| PR1040 | 11,780 | 11,348 | **11,345** | +| PR1868 absorbed PR1188 | 10,489 | 10,059 | **10,056** | + +They match the counts an independent pre-PR reviewer found. F, B and the guard bits equal the full-deferral values. + +This is a refinement **found by search, not an optimum.** The only pinned search evidence is the exhaustive +search over ideals of size at most 4 and the greedy descent above; whether larger ideals go lower is open. +Full deferral stays the headline construction because its contract is the cleanest (`R = E`, `V = E^-1`). + +## 6. Accounting + +The scatter falls from 527 to 97 ADDs. The undo's 306 ADDs (307 on PR1040 and PR1449) move from D to +B; none is deleted. So the complete local count falls by 430. On PR1040 it falls by 432: its E differs +(PR1040's extra target step), and its E S listing has 95 ones. + +| quantity | change | +|---|---| +| F | unchanged on every word | +| B | falls on every word | +| guard bits | never rise | +| frames, climbs, COPY ranks | unchanged | +| exporter MOVE records (2,911) | identical | +| paid profile `{1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}`, rank mass 5,129 | unchanged | + +On PR941's floor-calibration word the nine-stage guard moves from 193 to 192 bits. That word is the +only base word that misses the guard, and the guard check must reject it (a pinned control). Its +deferred word meets the guard. + +## 7. The selected-word heuristic (PR589) + +PR589 has no target-basis block: its D is the 111 reads, so the deferral itself is vacuous there. A +scatter basis G still fits H5-tw, with `R = G` and `V = G^-1`. + +**Construction.** Run Prim's algorithm over the 111 scatter rows plus a zero root: + +- edge cost is `2 + Hamming distance` (one gate in G and one in `G^-1`, plus the changed row); +- root cost is the row weight. + +The tree has 79 edges and 32 roots. G is the 79 transvections `a ^= parent(a)`, children before +parents, placed after the D reads at the zero frame. `G^-1` is G reversed, as the first gates of B. +The listing is `G S`, with 254 ones. + +**Cost and checks.** The scatter-related cost falls from 527 to `158 + 254 = 412`, and the word from +24,305 to 24,190 ADDs. `verify.py` applies the same checks: + +- boundary; +- frames and MOVE records; +- exporter paid profile and rank mass; +- guards (93/177 bits, unchanged; the reverse bound B rises from 1,113,070 to 1,117,988); +- H5-tw identities; +- the bridge to PR589 itself. + +**Owner flags.** PR589 passes every owner flag. The heuristic word makes three newly false: + +- `H2_D_frame0_targets_from_helpers` and `K_equals_D`: the same syntactic departure every lineage word + already has, caused by target-from-target gates in D. +- `H5_V_identity`. + +This is a heuristic (an MST over one fixed cost model), not an optimum. + +## 8. What is not proved here + +- **Native and hosted replay.** Native 5/9/11-stage C++ replay was not run on the deferred words. + Hosted emission and invoice were not run either; for the deferred PR1122 word, PR1806's PR1122 + nine-stage hosted invoice is the obvious route. The undo now appears in B's exporter phase (4) + rather than D's (1), and any phase-specific expectation of those tools is unchecked. +- **Inherited obligations.** The all-size compiler, the common-label/mutable-source realization, + rounding/tape and the analytic obligations remain inherited. +- **Adoption.** Whether H5-tw is accepted as the interface is a maintainer decision. The lemma and + the argued bridge are offered as the case for it. diff --git a/research/r439-deferred-target-basis-seed06/README.md b/research/r439-deferred-target-basis-seed06/README.md new file mode 100644 index 0000000000..65f1c7c1ba --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/README.md @@ -0,0 +1,469 @@ +# Deferred target basis: `V R = I` replaces H5 together with the H2 target clause + +**Replacement-interface result with finite R439 instances. No new κ, and the bit side does not +bind.** The selected result, the selected bit supplier (PR589) and `upstream/` are unchanged. + +## The interface result + +Three statements of the interface keep two clauses fixed: the inherited interleaved lemma (eumemic's +PR543, `research/e8-bit-r420/README.md`) and the two later R439 replacements of H2/K. The clauses are: + +- the target clause of H2: D adds to the targets without changing their basis, `R = I`; +- H5: the raw word `W0' = (A, scatter, B)` has target-to-target block `V = I`. + +The two replacements are woklerx's PR1194 semantic D (H2-sem) and PR1868's twisted helper contract. +PR1194 states the first clause as "complete restoration of every helper and target basis at D's +boundary". + +This package replaces that pair by their product. D may leave the targets in any basis R, provided +`W0'` applies `R^-1` before the targets climb: + +| | inherited / PR1194 / PR1868 | H5-tw (this package) | +|---|---|---| +| D operator | `(x, y + N h, T h)` (`T = I` except PR1868) | `(x, R y + N h, T h)` | +| D shape | zero frame, source-free, no COPY/ERASE/climb | same | +| target basis | `R = I` and `V = I` | **`V R = I`** | +| source response | `J = I` | `J = I` | +| helper response | `N = K` (PR1194), `N = K'T` (PR1868) | **`V N = K'T`** | +| cleanup | z-only at the full frame; literal H4 (`T = I`) or PR1868's H4-tw | z-only at the full frame; `C U'(I ⊕ T) = I` | +| H1, H3 | kept | kept | + +**Lemma (H5-tw, with its converse).** Assume: + +- H1, H3 and the D shape; +- C is z-only at the full frame; +- D acts as `(x, y, h) -> (x, R y + N h, T h)`, and `W0'` has block form + `z' = U'z`, `y' = V y + J x + K' h`. + +Then the complete word acts as `(z, y) -> (C U'(I ⊕ T) z, V R y + J x + (V N + K'T) h)`. So it maps +`(x, y, h) -> (x, y + x, h)` on every F2-module **if and only if** all four of these hold: + + V R = I, J = I, V N = K'T, C U'(I ⊕ T) = I. + +Each equation is read off the unit columns, so all four are necessary. The inherited contract is the +case `R = V = I`. Under the literal H4, the last equation holds exactly when `T = I`; PR1868's H4-tw +is that equation itself. [PROOF.md](PROOF.md) section 1 gives the proof. + +**The bridge, cut by cut.** A deferred word W' differs from its base word W only on the targets, +and only by the target basis. From W's undo to W''s deferred undo, every target of W': + +- sits at the zero frame; +- is read by no z gate (H1): the only gates touching it are scatter ADDs into it and the undo gates; +- holds `M` times W's target values, where `M = E` during A and the scatter. + +The undo runs at the zero frame, after which the complete states (values and frames) are equal and +the remaining instructions are identical. `verify.py` replays the deferred word's own D, A and B +prefix against W in lockstep. It checks this invariant at every cut on every word, for example +3,585 cuts on PR1062 and 3,136 on PR1188. + +W itself is anchored as before. For the 17 words with `T = I`, its D has PR589's D operator, and the +PR1194-style splice passes every inherited owner flag. PR1868's two words use its own bridge. + +**We argue that no new physical premise is needed** (PROOF.md section 3). The deferred undo consists +of zero-frame B target writes from target sources, which the inherited H3 admits. W's own scatter +ADDs are already zero-frame target writes made after A's climbs. + +This differs from PR1194's substitution, which was restricted to frame-zero D prefixes. Here the +twisted window extends through A and the scatter, with the targets held at frame zero and unread. + +It also differs from PR1868. There, three helpers climbed out of the zero frame holding a twisted +value, which needed the helper common-frame / climb-additivity premise. Here no twisted register +ever climbs. + +**Maximality (fixed ordered frame paths).** Here B means W's B, which is W''s B after the deferred +undo. On every word: + +- the nonzero frame sets of the 111 targets are pairwise disjoint (0 of 6,105 pairs share one); +- every target's first B touch climbs out of the zero frame, the first at B[0]; +- no B target write reads a target, and B's own target block is I. + +Hence every target-from-target gate must run at the zero frame before its operands' first climbs. +The deferred undo is one such placement. + +- **Timing.** The undo cannot follow B[0], whose target is an undo operand. +- **Absorption.** No undo gate can be absorbed into a B target write. Of the 585 (undo gate, B write) + pairs per word (587 on PR1040, 586 on PR1449), none is frame-legal. +- **Prefix splits.** Among prefix splits of the literal undo order only, full deferral is a best + split: keeping a prefix of the undo in D never makes the scatter cheaper. + +**Full deferral is not optimal once commuting reorders are allowed.** The pre-PR proof review found +a better split, which the same lemma covers. Keep an order ideal (a commutation-closed down-set) of +the undo's dependency poset at the end of D, list the scatter in the resulting basis, and run the rest +of the undo first in B. See "Order-ideal refinement" below and [PROOF.md](PROOF.md) sections 4–5, +which also give the scope limit when paths may change. + +## The construction + +Every committed PR915-lineage R439 word has a D section of this shape: + + helper-star preparations, P_E (306 gates), helper reads (111), U_E = P_E reversed, helper restorations + +All of it runs at the zero frame. `P_E` has 307 gates on PR1040 and PR1449, and PR915's word has no +helper stars. The deferred word makes three changes: + +1. it deletes `U_E` from D; +2. it runs the same gates, at the zero frame, as the first gates of B; +3. it replaces the scatter listing S (111 rows over the nine retained totals) by the rows of `E S`. + +`E S` is the unique listing for this placement (PROOF.md section 1). Its consequences: + +- **Twisted window.** During A and the scatter the targets hold E times their original values. +- **Contract.** `R = E` and `V = E^-1`. +- **Unchanged.** T, J, K', U' and C are all unchanged. +- **Scatter.** `E S` has 55 nonzero rows and 97 ones, against 527 ones in S. +- **Count.** The complete local ADD count falls by 430 (432 on PR1040; see below). The undo's ADDs + move from D to B; none is deleted. +- **Frames and bounds.** Frame paths, COPY ranks, MOVE records and the paid profile are unchanged. + F is unchanged, and B falls. + +## Census of every committed lineage word (as of base c6765481) + +All 19 distinct committed lineage words were found by scanning `research/` for R439 word files and +deduplicating vendor copies by canonical hash. To repeat the scan (it needs git), run: + +```sh +python3 research/r439-deferred-target-basis-seed06/verify.py --census-scan +``` + +It lists every committed R439 word and reports any word missing from the verifier's lists. At c6765481 +it reports 27 distinct words (19 lineage and 8 outside), all listed. + +Every number below is recomputed live by `verify.py` and pinned in [EXPECTED.json](EXPECTED.json). + +| word (PR, author) | ADDs base → deferred | saving | F | B base → deferred | local/nine-stage bits | +|---|---:|---:|---:|---:|---| +| PR915 (Gareth Davidson), `r439-target-compensation` | 13,208 → **12,778** | 430 | 49,347 | 9,534,616 → 8,742,940 | 100/189 → 99/189 | +| PR926 (Gareth Davidson) | 11,980 → 11,550 | 430 | 71,907 | 10,562,318 → 9,770,642 | 102/192 → 101/192 | +| PR941 (Gareth Davidson) | 11,949 → 11,519 | 430 | 70,083 | 10,548,832 → 9,757,156 | 101/192 → 101/192 | +| PR941 floor-calibration word | 11,948 → 11,518 | 430 | 73,603 | 10,518,760 → 9,727,084 | 102/**193** → 101/192 | +| PR965 (Ross Richardson) | 11,840 → 11,410 | 430 | 72,399 | 10,464,656 → 9,672,980 | 102/192 → 101/192 | +| PR967 (Sricharan Vagvala) | 11,783 → **11,353** | 430 | 72,847 | 10,394,084 → 9,602,408 | 102/192 → 101/192 | +| PR1040 (woklerx) | 11,780 → 11,348 | **432** | 72,847 | 10,394,084 → 9,602,408 | 102/192 → 101/192 | +| PR1047 (woklerx) | 11,769 → 11,339 | 430 | 72,847 | 10,394,084 → 9,602,408 | 102/192 → 101/192 | +| PR1449 (Hanson Sun, @bbMisk) | 11,781 → 11,351 | 430 | 72,847 | 10,394,084 → 9,602,408 | 102/192 → 101/192 | +| PR1062 (Sagar Thakrar) | 11,500 → **11,070** | 430 | 25,717 | 5,911,840 → 5,024,524 | 95/182 → 95/181 | +| PR1062 composition word | 11,515 → 11,085 | 430 | 24,625 | 5,846,566 → 4,971,904 | 95/181 → 95/180 | +| PR1062 pair-control word | 11,715 → 11,285 | 430 | 24,563 | 5,892,602 → 5,005,286 | 95/181 → 95/180 | +| PR1543 (ToikY) | 11,489 → **11,059** | 430 | 25,885 | 5,977,064 → 5,089,748 | 96/182 → 95/181 | +| PR1709 (Cinna Davis) | 11,488 → 11,058 | 430 | 27,061 | 5,921,344 → 5,034,028 | 96/182 → 95/181 | +| PR1868 absorbed PR1062 (Sagar Thakrar), `T ≠ I` | 11,497 → 11,067 | 430 | 25,717 | 5,858,638 → 4,976,508 | 95/182 → 95/181 | +| PR1122 (Gareth Davidson) | 10,652 → **10,222** | 430 | 15,223 | 3,910,388 → 2,996,128 | 92/176 → 91/174 | +| PR1208 (ToikY), `r439-abc-zrewrite-seed16` | 10,542 → **10,112** | 430 | 13,721 | 3,663,878 → 2,774,762 | 91/174 → 91/173 | +| PR1188 (Gareth Davidson) | 10,492 → **10,062** | 430 | 13,667 | 3,758,418 → 2,825,146 | 91/175 → 91/173 | +| PR1868 absorbed PR1188 (Sagar Thakrar), `T ≠ I` | 10,489 → **10,059** | 430 | 13,667 | 3,748,680 → 2,816,834 | 91/175 → 91/173 | + +Bold ADD counts are the eight pinned in `verify.py`'s probe table (from the unpublished exploratory +probe); all eight reproduce exactly. On every word `verify.py` checks all of the following: + +- **Boundary.** `(x, y, h) -> (x, y + x, h)` on all 661 dirty columns, forward and reverse, through + the literal COPY/ERASE stream, for both the base and the deferred word. +- **Frames.** The ordered per-register frame paths and the exporter's 2,911 MOVE records are + identical. +- **Paid profile.** Every lineage word has the PR589 profile `{1:1323, 2:1342, 3:79, 4:44, 5:102, + 6:11, 7:19}`, rank mass 5,129. It is computed from the frame paths and, separately, by the pinned + exporter (`research/e8-bit-carrier-skeleton/code/bit/export_records.py`), which runs with exit code 0. +- **Guards.** The exporter's ADD count and F/B match the literal replay. Both strict guards + (`64 F^3 B^2 < 2^104`, `2^18 F^5 B^4 < 2^192`) hold on every deferred word, and the guard bits + never rise. +- **Owner checker.** The unchanged `research/e8-bit-p111-tuned/code/xcheck_p.py` accepts geometry + and endpoint. Exactly one flag becomes newly false, `H5_V_identity`, beside the inherited + `H2_D_frame0_targets_from_helpers` and `K_equals_D`. PR1868's words also keep their inherited + `H4_C_literal_reverse_at_full` and `C_is_U_inverse`. +- **Identities.** `V R = I`, `V N = K'T`, `J = I` and `C U'(I ⊕ T) = I` hold, with `R = E` and `V` + equal to the matrix of the literal undo gates. The base word is the `R = V = I` case. + +**Not reproduced as stated.** An exploratory estimate of 430 on every word does not hold for +PR1040: its E differs (PR1040's extra target step), its `E S` listing has 95 ones, and the saving is +432. PR1449 also has 307 preparation gates, split by a helper gate, but its listing has 97 ones and it +saves 430. Every other probe number reproduces. + +**Composition with PR1868.** PR1868's absorbed PR1188 word is merged. Deferral on it gives +**10,489 → 10,059**, the lowest full-deferral count in this census. + +**Words outside the lineage.** Eight committed R439 words have no target-basis block: PR555, PR589, +PR904, PR936, PR952, PR980, PR1127 and PR1221. Their D is the 111 helper reads, so `R = I` and the +deferral is vacuous; `verify.py` checks the shape. + +Some packages carry moves or certificates rather than a committed word. They are not censused here: + +- PR1045 and PR1400 (helper fusion and descent moves); +- PR1704 (two-copy scatter). + +## Order-ideal refinement (found by search, not optimal) + +Call a set I of undo gates an **order ideal** when it contains, with each gate, every earlier undo gate +that the gate does not commute with. Keeping such an I in D is then commutation-equivalent to splitting +the undo there. The ideal-split word keeps I at the end of D (at the zero frame), lists the scatter as +`G_I E S`, where `G_I` is the product of the gates in I, and runs the rest of the undo first in B. It +meets the same lemma, with `R = G_I E` and `V = E^-1 G_I^-1`. + +`verify.py` runs two searches on every lineage word: + +- an exhaustive search over all ideals of size at most 4 (566,500 of size 4 on the 306-gate words); +- a greedy strict descent. + +Both find the size-3 ideal {31, 51, 52} with scatter nnz 94 against 97 ({32, 52, 53} on PR1040 and +PR1449, with 92 and 94). No size-4 ideal does better. + +On four words it builds the split and applies every check of the deferred word: boundary both ways, +paths and MOVE records, exporter profile, guards, owner checker (exactly `H5_V_identity` newly false), +H5-tw identities and the per-cut bridge. + +| word | base | full deferral | ideal split | +|---|---:|---:|---:| +| PR1062 | 11,500 | 11,070 | **11,067** | +| PR1188 | 10,492 | 10,062 | **10,059** | +| PR1040 | 11,780 | 11,348 | **11,345** | +| PR1868 absorbed PR1188 | 10,489 | 10,059 | **10,056** | + +F, B and the guard bits equal the full-deferral values. They match the counts an independent pre-PR reviewer found. + +Full deferral remains the headline construction, because its contract is the cleanest (`R = E`, +`V = E^-1`). The ideal split is a refinement under the same lemma. It was found by search, and no +optimality is claimed. + +## Committed instances + +[candidate-1062.json.gz](candidate-1062.json.gz) and [candidate-1188.json.gz](candidate-1188.json.gz) +are the fully deferred PR1062 and PR1188 words. They are canonical JSON, gzip mtime 0, rebuilt +deterministically by `verify.py --write`. The verifier requires the decompressed payload to equal +the rebuilt word byte for byte. The gzip containers are also byte-identical under CPython 3.12.15. +They differ under 3.14.8, as CONTRIBUTING.md anticipates, while the payloads still match. The +ideal-split words are rebuilt in memory and pinned by SHA-256 in EXPECTED.json. + +## Selected-word heuristic (PR589) + +PR589 has no target basis, but a scatter basis G fits the same contract, with `R = G` and +`V = G^-1`. G comes from a minimum spanning tree over the scatter rows plus a zero root, with edge +cost `2 + Hamming distance`. It has 79 transvections, placed after the D reads at the zero frame, and +`G^-1` runs first in B. + +The scatter-related cost falls from 527 to 412 (158 basis gates plus 254 listing ones), and the word +from 24,305 to 24,190 ADDs. The same checks pass: + +- boundary, frames and exporter profile; +- guards: 93/177 bits, unchanged, while the reverse bound B rises from 1,113,070 to 1,117,988; +- H5-tw identities and the bridge to PR589. + +PR589 itself passes every owner flag, so here three flags become newly false: + +- `H2_D_frame0_targets_from_helpers` and `K_equals_D`: the lineage's syntactic departure, caused by + target gates in D; +- `H5_V_identity`. + +**This is a heuristic, not an optimum, and no supplier change is proposed.** + +## Controls + +The PR1062 and PR1188 instances carry these controls. All must fail or be rejected. + +1. **Deferral with the old listing S.** The dirty endpoint is wrong on all 111 targets, and + `J = I` and `V N = K'T` fail. +2. **Undo moved after B[0]**, the first B climb of an undo operand. The frame replay rejects it: + register 111 would descend from frame 127 to 0. With frames ignored, the endpoint is wrong on 28 + targets. +3. **First undo gate dropped.** The endpoint is wrong on 6 targets; `V R = I` and `V N = K'T` fail. +4. **Reordered undo.** + - *Preparation order instead of its reverse:* the endpoint is wrong on all 111 targets, and all + three target equations fail. + - *Adjacent swaps (honest census):* 305 per instance. 270 swap commuting gates and keep the + operator; a checked one keeps the boundary exact. The other 35 change the operator; the first + (gates 7 and 8) breaks the endpoint on 24 targets. So the order matters only through the product + `E^-1`. +5. **One wrong `E S` row** (row 1, bit 0 flipped). The endpoint is wrong on 6 targets. +6. **Corrupted source pin.** The SHA-256 check rejects it. + +**Check-level controls.** Each must be rejected by the intended check, which is matched by its error +message. + +| check | control (per instance unless noted) | +|---|---| +| bridge structure | the deferred word with its last D gate dropped | +| bridge invariant | the old-S word | +| bridge, undo complete | the swapped-undo word | +| owner delta | `(base, base)`, which has no newly false flag | +| frame paths | a legal frame raise of B[500], frame 508 → 422 | +| paid profile | the same raise, which also changes the profile | +| exporter profile | the base word's exporter profile against the raised profile | +| maximality | the census run with the deferred word as its own base | +| precision guard (once) | the PR941 floor-calibration base word, 193 nine-stage bits | + +**Mutation run.** We ran 26 mutants of copies of the verifier (not shipped). Disabling the body of +any check (guards, paths, profile, exporter profile, owner delta, bridge invariant, bridge structure, +undo completion or maximality) now makes the verifier fail. + +Six mutants still pass: + +- **Call-site removals (2).** One drops the base-word guard call; the other forces the owner delta. + Their outputs stay pinned in EXPECTED.json. +- **Equivalent mutant (1).** Changing `<` to `<=` at the guard caps makes no difference, because no + word sits exactly at a cap. +- **Redundant pins (2).** Removing the review-number pin, or the F/B-equality check, for the ideal + splits is covered: those values are also pinned in EXPECTED.json. +- **gzip mtime (1).** A changed gzip mtime passes, as CONTRIBUTING.md requires. + +## Reproduce + +From the repository root (standard library only; about 40–95 s per run on an Apple-silicon Mac, +depending on the interpreter): + +```sh +python3 -I -B research/r439-deferred-target-basis-seed06/verify.py +python3 -I -O -B research/r439-deferred-target-basis-seed06/verify.py +python3 scripts/research_package.py --package research/r439-deferred-target-basis-seed06 --check-only +python3.12 scripts/research_package.py --package research/r439-deferred-target-basis-seed06 +``` + +The expected final line is: + +```text +PASS_R439_DEFERRED_TARGET_BASIS words=19 outside=8 instances=2 ideal_splits=4 columns=661 controls=33 no_new_kappa (… s) +``` + +All 29 inputs are pinned by SHA-256 and git blob in [SOURCES.json](SOURCES.json): 27 words, the owner +checker and the exporter. The verifier refuses drifted bytes. + +- **Owner checker.** It runs from its verified bytes in-process. It raises its own `Reject`, not + `assert`. +- **Exporter.** It runs from its verified bytes in a child interpreter without `-O`. +- **Checks.** They raise `ValueError`, so `-O` cannot weaken them. The report must equal + EXPECTED.json exactly. +- **Portability.** The report is identical under CPython 3.12.15 and 3.14.8. + +`--write` regenerates EXPECTED.json and the two payloads. `--census-scan` repeats the word census. + +## Task and scope + +The card is `bit-helper-contract` (scope key 3475f46c8358c6a9211b), and the scope status is +**changed**. The card asks for an H2/K replacement for a helper operation. This package also relaxes +H5 (`V = I`), which the card keeps, and its object is the target-basis block, not a helper operation. +It also broadens to every committed lineage word, instead of narrowing to one helper-star instance as +the card's allowed variation suggests. TASK.json records the full reason. + +## Scope and limits + +- **The new result.** It is the interface lemma H5-tw with its converse, the argued cut-by-cut + bridge, the maximality census among prefix splits, the order-ideal refinement and the finite + instances. The ADD savings are finite consequences. They do not change the paid profile, the + selected moment or κ. +- **Scope of maximality.** It is proved for fixed ordered frame paths and prefix splits of the literal + undo order. If paths may change, `verify.py` counts the other targets that could be co-located at a + B target write's frame, under three criteria: + - *loose upper bound* (the target's final frame contains the write frame): 102 of 213 writes, up to + 58 targets; + - *with the target's current frame inside the write frame:* 102 writes, up to 55; + - *monotone through the target's own fixed touches:* 94 writes, up to 7. + + Any such move changes that target's path and the paid profile, so it is not covered. +- **Not run.** + - Native 5/9/11-stage C++ replay and hosted emission/invoice were not run on the deferred words. + For the deferred PR1122 word, PR1806's PR1122 nine-stage hosted-invoice replay is the obvious + route. + - The undo now sits in B's exporter phase rather than D's, and any phase-specific expectation of + those tools is unchecked. + - The all-size compiler, common-label/mutable-source realization, rounding/tape and analytic + obligations remain inherited. +- **Adoption.** Whether H5-tw becomes the interface is a maintainer decision. The owner checker's H5 + is literal, and it flags every deferred word. + +## Related and concurrent work + +- **PR1704** (Ross Richardson, merged, `research/bit-two-copy-scatter`) is the nearest construction. + It rewrites the same 527-ADD scatter of PR1062's word, using two simultaneously live COPY + temporaries under a replacement copied-workspace contract, and reaches 527 → 407. + - It is a different mechanism, under a different interface: this package keeps one temporary and + the inherited COPY/ERASE contract. PR1704's README explicitly excludes target-basis changes. + - **The two savings are not additive.** Both rewrite the same block. After deferral the scatter has + 97 ADDs, and PR1704's −120 was computed on S, not on `E S`. +- **PR1194** (woklerx) and **PR1868** keep `R = V = I`. This package keeps their D-shape and cleanup + clauses, replaces the target-basis pair by `V R = I` and generalizes K to `V N = K'T`. +- **PR794** (commdata2338, open) is R420 target-basis compensation. Its preparation, reads and undo + all stay inside D, as in PR915, and it does not defer the undo. +- **PR2037** (commdata2338, open) routes R439 H2/K work through the retained semantic-D evidence. +- **PR1806** (mtpsl, merged) is the complete PR1122 nine-stage hosted invoice. It is the hosted route + for the deferred PR1122 word. +- **PR1580 and PR1592** (Arham Tahir, merged) exclude terminal helper-star restoration and arbitrary + terminal star compensation under fixed frames. They are the contrasting deferral results: those + move helper restorations to the end, while this package moves a target-basis undo past A and the + scatter. +- **Same-card and nearby work.** + - Discussion #1166, cycle 18 (Cinna Davis, @1337isnot1337): a post-read one-gate star compensation + run on PR1062's word, which was not pushed. + - PR2033 (ToikY, open): a helper-sharing pair on PR1062's star word. + - PR1913 (Adam Gall, merged) and PR1937 (Aaron Wang, open): helper-star absorption corrections. + + All of these are helper side. +- **PR1435** (woklerx) bounds late mixing of the retained totals before the COPY by its paid COPY + frames. That is helper side, not target basis. +- **Overlap search.** `gh pr list --state all --search` was run for: scatter, "target basis", H5, + V_identity, "deferred undo", 10,062, 11,070 and "twisted target". It found no PR that defers the + undo or lists the scatter in the target basis. The last five terms returned nothing relevant. + `scripts/find_overlap.py` with "deferred undo", "H5_V_identity", "twisted target" and "deferred + target" returned no matches. This is not a novelty certificate. + +## Open next questions + +The structured versions are in [TASK.json](TASK.json). + +1. **A joint basis for the reads and the scatter.** + - *Why it matters:* E was chosen by PR915's application of PR794's greedy search, for the D reads + alone. Once the undo is deferred, the same basis also prices the scatter (`nnz(E S)`). + - *First step:* add `nnz(E S)` to that search's objective, under the same prefix guards. +2. **A shorter circuit for `E^-1`, and better order-ideal splits.** + - *Why it matters:* maximality fixes where target-from-target gates may run, not the circuit for + `E^-1` or the best split. The ideal search is exhaustive only up to size 4. + - *First step:* resynthesize `E^-1` at the zero frame with a bounded linear-circuit search, and + extend the ideal search (larger sizes, or a joint split and resynthesis). +3. **Composition with other rewrites.** + - An exploratory probe suggests the deferral also composes with a shear-descent D rewrite, but no + number is claimed until it is verified. + - Whether a two-copy pairing in the style of PR1704 still pays on the 97-ADD `E S` listing is + open. +4. **Native and hosted replay.** + - *First step:* run PR1188's native checkers (or PR1902's audit harness) on + `candidate-1188.json.gz`, or PR1806's hosted-invoice replay on the deferred PR1122 word. + - *Blocker:* a host with Boost or PR1509's checked stand-in. +5. **An optimal scatter basis on PR589.** The MST basis is a heuristic, and an exact or better bound + for this cost model is open. + +## Credit + +- **Target-basis lineage.** + - Gareth Davidson (@bitplane): PR915 guarded target-basis compensation on R439, the E block this + package defers; also PR926, PR941, PR1122 and PR1188, and the outside words PR904, PR952 and + PR980. + - commdata2338: PR794 (open), the guarded target-basis method and the greedy prefix-guarded search + that PR915 transfers to R439. + - Scott Woolsey Biggart (@swbiggart): PR713, the first restored target basis, on R420. + - Sagar Thakrar: PR716, optimal disjoint R420 target pairs. + - Dugongue: #476 and #478, the reversible donor-receiver target identity. The deferral stretches + that identity across the scatter. +- **Lineage words.** + - Sricharan Vagvala (@theon199): PR967 helper stars. + - Ross Richardson: the PR923 frame-520 circuit inside the words; PR965 helper triples; PR936. + - Aaron Wang (@navinor): the PR1015 B circuits inside the words; PR1127. + - Sagar Thakrar: PR1062 and PR1868. + - woklerx: PR1040 and PR1047. + - Hanson Sun (@bbMisk): PR1449 and PR1221. + - ToikY: PR1543 and PR1208. + - Cinna Davis (@1337isnot1337): PR1709. + - DreamingOfClouds: PR589 tuning, on eumemic's PR555 word, built on DreamingOfClouds' PR545 + punctured unit. +- **Interface and checkers.** + - eumemic: PR543, the R420 word and the H1–H5 interleaved lemma in `research/e8-bit-r420`; PR555 + and its checker adaptation `xcheck_p.py`. + - Zhihao Chen: PR425 (open), the scalar-interface lemma. + - Mikhail R. Gadelha: PR686 (open), the first semantic D-boundary substitution. + - woklerx: PR1194 semantic D. + - Arham Tahir (@Arham-Tahir64): PR1311 bridge. + - Dylan Crow: the exporter `export_records.py` (per its header, carried in eumemic's PR493 + package). + - Hanson Sun (@bbMisk): PR1902 native audit of PR1868's words. +- **Nearest construction.** Ross Richardson's PR1704 two-copy scatter: a different mechanism, not + additive with this one. +- **Review.** The pre-PR review found the order-ideal refinement, the bridge's reliance on the base + word, and the missing check-level controls, all fixed here. + +Prepared by Sagar Thakrar with substantial Anthropic Claude assistance (Claude Code, including +subagents for the exploratory probe, its independent checks, the pre-PR review and package assembly). +No independent human review. New work is Apache-2.0. diff --git a/research/r439-deferred-target-basis-seed06/SOURCES.json b/research/r439-deferred-target-basis-seed06/SOURCES.json new file mode 100644 index 0000000000..74937803e0 --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/SOURCES.json @@ -0,0 +1,192 @@ +{ + "schema_version": 1, + "base_commit": "c676548106012571fefa1dce0ec16f1bcfe11dce", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/bit/export_records.py", + "usage": "input", + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + { + "path": "research/e8-bit-p111-tuned/code/xcheck_p.py", + "usage": "input", + "git_blob": "184f5dcf94a486cc7db91ca4db5865916bf26009", + "sha256": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/e8-bit-p111/data/bitE8mut-p111.json.gz", + "usage": "input", + "git_blob": "bdbb95aa970647bd52895c120b494f0f591f3f87", + "sha256": "1bc3c53d4baf4927c6a00c339ea3975516471a48074d4d97c6addaded2a4d858" + }, + { + "path": "research/r439-abc-star-composition/candidate.json.gz", + "usage": "input", + "git_blob": "0ab597fefd68bfefecc85d631b172d174bdaeb70", + "sha256": "2b09a7a3851cdf2a7f19350d1555cf75788d001c9507a37e459cd931881ee066" + }, + { + "path": "research/r439-abc-zrewrite-seed16/CANDIDATE-WORD.json", + "usage": "input", + "git_blob": "83fb8ef2286a9aafaff7b5db4386ea65a07126a9", + "sha256": "66b34404f39f5f612c2aaadd53ae33eb9f5993ec2065c82e23d7467cce03a226" + }, + { + "path": "research/r439-b509-boolean-seed05/candidate.json.gz", + "usage": "input", + "git_blob": "6d25b8be2aeab9b8dc7b6d3b17f7ae999b2a090f", + "sha256": "14b8bde5e0b3171795574e3f52046b0e53b5c994a5af5aa77ce0485d69a82687" + }, + { + "path": "research/r439-bsection-stars-seed01/candidate.json.gz", + "usage": "input", + "git_blob": "9a17b4920334878d6c949191f6931bd97126fe3c", + "sha256": "b452d2c2b0b2a546d1105b1da9769aa78e5c54d6f00e97b30c77e3f54ce445ee" + }, + { + "path": "research/r439-bsection-stars-seed01/composition.json.gz", + "usage": "input", + "git_blob": "d95fc2bf795fd9ef8d8bae9d70693c5e64948cec", + "sha256": "0203fea9fa442ca206fe683aa5b6860adac680d63b9fb8be6bd42b39aa7b5cce" + }, + { + "path": "research/r439-bsection-stars-seed01/pair_control.json.gz", + "usage": "input", + "git_blob": "16972bc96de0c81321eb2feef70766c403017016", + "sha256": "628ebfebe215e153338e88e2e324040d139a111eebfb090929697c7a0b6f3f59" + }, + { + "path": "research/r439-five-cycle-seed9f01/CANDIDATE.json.gz", + "usage": "input", + "git_blob": "9e4ca90ee968cbb9b7d0b66ca0d94dd3c7e9301a", + "sha256": "286fb2e8b397909bd74257ef911b4a76a633e169493d481a9ca40379ae9072b9" + }, + { + "path": "research/r439-five-wire-prefix/candidate.json.gz", + "usage": "input", + "git_blob": "513cc674f2962973db5bfa41deafccc541b2aa6c", + "sha256": "3a11fc4675cd708316f9b0d398e0c3b73d626de0f824c5ed9b9c96279cfef091" + }, + { + "path": "research/r439-four-wire-prefix/candidate.json.gz", + "usage": "input", + "git_blob": "6d8c457604f8ed41e41f3fe6d57155c2286f701d", + "sha256": "9946eaacc69f05a91ad18ca16e57cd4f78db3e0d5b23939f691c96b4a4098a2f" + }, + { + "path": "research/r439-gl5-shortest/candidate.json.gz", + "usage": "input", + "git_blob": "0d4dd2fb241a00cab1b57b17991db82bc06edd91", + "sha256": "4e7904d01ebdbfc60a26472b4e0d2e813c19c2fe1a4bb8ab390c12746a1da359" + }, + { + "path": "research/r439-global-prefix-admission/candidate.json.gz", + "usage": "input", + "git_blob": "d409686d75c095126cf719c40df7ef2af48a7c45", + "sha256": "fffc0484a3572c76bf3bb5284d4a40eeb723c4b3acf3da5e2d9e113ac1747ec6" + }, + { + "path": "research/r439-helper-matching/candidate.json.gz", + "usage": "input", + "git_blob": "b3befb831854157e14512ac40fa48dbea289d105", + "sha256": "60531408445a1d7c793dff6821e767739012db1d2646f49aec7fdf7fe0b979f3" + }, + { + "path": "research/r439-helper-matching/floor-word.json.gz", + "usage": "input", + "git_blob": "906e935541d6a5d2ca40d2885e21e46b4675b0ee", + "sha256": "4be50c06f91bc605660d4f9fba865c330f82dc4c364041870b725c220d16244e" + }, + { + "path": "research/r439-helper-stars-seed19/candidate.json.gz", + "usage": "input", + "git_blob": "8b0210d8b8e9524182e5f54f9bf93c28f4719735", + "sha256": "d8b08885e8ce9868200b2645189d15ed18a27fc2742e54990b3257a0ca4df6b8" + }, + { + "path": "research/r439-helper-triples/candidate.json.gz", + "usage": "input", + "git_blob": "e74d3a8edecac5ca9262b774a965702c19207bea", + "sha256": "11f5c75711090892827d536b6bf82b4001e02ebd13d10e87a1aa915a4e78704b" + }, + { + "path": "research/r439-neutral-helper-chain-seed17/CANDIDATE.json.gz", + "usage": "input", + "git_blob": "10faaa18268bd75981556fdd3f4d5569110f2eec", + "sha256": "559f948dc9f7474e314b27d70286025b21922e3f7a6fbd93b7786cc0f6a871b5" + }, + { + "path": "research/r439-neutral-mixed-shears-seed13/candidate.json.gz", + "usage": "input", + "git_blob": "aded007562c199f00b13fec7df904b5cf514b108", + "sha256": "845ee7205390e8b5252187051839304c1eae197006cf80fdc9ec156d50916834" + }, + { + "path": "research/r439-post-helper-shear-seed03/candidate.json.gz", + "usage": "input", + "git_blob": "c97bf4c26939f4c6d9fc07dcbe6215bab632ceeb", + "sha256": "e6a7a50662ba2c32c7fb42d7051d1300bef52f8e442f593c0081999bc0c27934" + }, + { + "path": "research/r439-six-wire-boolean/candidate.json.gz", + "usage": "input", + "git_blob": "028620b46ed820c0ec3125c112be5522d58f8114", + "sha256": "5c67c7949c07a89ea8394a936a155585d22e6b258997df73e36e7be47fc84cb0" + }, + { + "path": "research/r439-target-compensation/candidate.json.gz", + "usage": "input", + "git_blob": "7f1f188f516ca4661f419dc72114751abf3cc920", + "sha256": "ac30266144f8772ec8cd629153993aa9eb692fe745a9f95015a1b7fa88977a2e" + }, + { + "path": "research/r439-target-retune-seed14/candidate.json.gz", + "usage": "input", + "git_blob": "d7e1416295bc6bd2f048a20d766ac4bac82f41a6", + "sha256": "908f285b69b70cc998718575706b48091e856d96f23e3267060dca7a7546ac50" + }, + { + "path": "research/r439-twisted-star-absorption-seed02/absorbed-pr1062.json.gz", + "usage": "input", + "git_blob": "7656a7996e8fefdd0a40d9a4439deea8f121f015", + "sha256": "38af2e18956a3f6111ddde59da59fd9ca14c7fdbe589f718056ff66a51ecd963" + }, + { + "path": "research/r439-twisted-star-absorption-seed02/absorbed-pr1188.json.gz", + "usage": "input", + "git_blob": "ff8d2cfd045303a2a5426cb8b7d2cfdd9a7b9994", + "sha256": "0d24063702f353cf30466077ac7bc88ed19baabfade80002fafa7edcc14302e7" + }, + { + "path": "research/r439-two-sided-compensation/candidate.json.gz", + "usage": "input", + "git_blob": "0a192829589d6cbcec0f32695a928d24e6c33549", + "sha256": "6ac771545e823c054e005429c405dbb2c01ff80fce181b714e1af5e28b6b7cb2" + }, + { + "path": "research/r439-z3to2-seed13/CANDIDATE-WORD.json", + "usage": "input", + "git_blob": "0dcb80c50baa842e1a5dc72c94b7c2d4497d2652", + "sha256": "8aedb3be192baae884c80a2ff3d15d9f32ae8c8055dff170bebca2f87e75539a" + } + ] +} diff --git a/research/r439-deferred-target-basis-seed06/TASK.json b/research/r439-deferred-target-basis-seed06/TASK.json new file mode 100644 index 0000000000..794895f62f --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/TASK.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 3, + "base_commit": "c676548106012571fefa1dce0ec16f1bcfe11dce", + "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": [ + "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.", + "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": "Replace H5 (V = I) together with the H2 target clause (R = I) by the deferred-target-basis contract H5-tw: frame-zero, source-free D with operator (x, y, h) -> (x, R y + N h, T h) and raw word W0' = (A, scatter, B) with V R = I, J = I, V N = K'T and C U'(I + T) = I (kept H1, H3, D-shape and z-only full-frame C clauses). Prove it with its converse, instantiate it on every committed PR915-lineage word (as of base c6765481) by deferring the D-tail target-basis undo E^-1 to the start of B and listing the scatter as E S, and check the full dirty boundary, frame paths, paid profile, owner flags, guards, a cut-by-cut bridge and fixed-frame-path maximality among prefix splits of the literal undo order. Add the order-ideal refinement (a commutation-closed split of the undo, found by bounded exhaustive and greedy search, not optimal), fully checked on four words.", + "scope_change_reason": "Changed: the card asks for an H2/K replacement for a helper operation; this package also relaxes H5 (V = I), which the card keeps, and its object is the target-basis block, not a helper operation. PR1194 (H2-sem) and PR1868 (twisted helpers) already replace H2/K, but both keep H5 and the H2 target clause (R = I: D restores the target basis at its boundary). This package replaces that pair by V R = I and generalizes K to V N = K'T. It also broadens rather than narrows: the census covers every committed lineage word, not one helper-star instance. It does not attempt hosted adoption, native replay or a global optimum.", + "bottleneck_link": "Side result on the bit supplier. A replacement interface admits cheaper bit words (430 complete local ADDs fewer on 18 of 19 lineage words, 432 on PR1040; a further 3 with the order-ideal split found by search) with unchanged frame paths, paid profile and rank mass; the selected moment and kappa are unchanged and the bit side does not bind.", + "budget_minutes": 60, + "stop_rule": "Stop after the H5-tw lemma and its converse, the per-cut bridge, the fixed-frame-path maximality and prefix-split census, the bounded order-ideal search with four fully checked ideal splits, the live census on every committed lineage word, two committed instances with controls and check-level controls, the PR1868 composition and one heuristic PR589 instance; no basis search, native replay or hosted emission.", + "outcome": "completed", + "evidence": "EXPECTED.json, PROOF.md, candidate-1062.json.gz and candidate-1188.json.gz; python3 -I -B research/r439-deferred-target-basis-seed06/verify.py prints PASS_R439_DEFERRED_TARGET_BASIS (also under -O and CPython 3.14); --census-scan repeats the word census.", + "author": "Sagar Thakrar", + "ai_assistance": "Prepared by Sagar Thakrar with substantial Anthropic Claude assistance (Claude Code, including subagents for the exploratory probe, its independent checks, the pre-PR review and package assembly). No independent human review.", + "open_questions": [ + { + "question": "Can a target basis chosen jointly for the D reads and the deferred scatter beat PR915's E plus deferral?", + "why_it_matters": "E comes from PR915's application of PR794's greedy search, optimized for the reads alone; after deferral the same basis also prices the scatter (nnz(E S)), so the joint objective differs.", + "first_step": "Add nnz(E S) to the objective of PR915's application of PR794's greedy search and rerun it under the same 104/192-bit prefix guards.", + "blocked_by": "Search budget and a fresh prefix recount; no interface blocker beyond H5-tw adoption." + }, + { + "question": "Is there a shorter zero-frame circuit for E^-1 than the literal 306-gate reverse, or a better split of the undo between D and B than the order ideal found here?", + "why_it_matters": "Maximality fixes where target-from-target gates may run (zero frame, before the first B climbs), not the circuit for E^-1 or the split. Full deferral is best only among prefix splits of the literal order; the order-ideal search (exhaustive up to size 4, plus greedy) found 3 more ADDs and is not an optimum.", + "first_step": "Resynthesize E^-1 at the zero frame with a bounded linear-circuit search, and extend the order-ideal search to larger ideals or to a joint split and resynthesis; recheck the guards.", + "blocked_by": "Search budget only." + }, + { + "question": "Does the deferral compose with other rewrites of the same words, such as a shear-descent D rewrite or a PR1704-style two-copy pairing on the E S listing?", + "why_it_matters": "An exploratory probe suggests composition with a shear descent; PR1704's two-copy saving was computed on S and is not additive with deferral, but pairing may still pay on the 97-ADD E S listing.", + "first_step": "Rebuild the shear-descent word, apply the deferral and run this package's checks; separately run PR1704's pair/singleton partition search on E S.", + "blocked_by": "A verified composition; PR1704 also needs its two-live-temporary interface." + }, + { + "question": "Do the deferred words pass native 5/9/11-stage replay and hosted emission?", + "why_it_matters": "This package checks local scalar, frame and precision facts only; the undo now sits in B's exporter phase, which native tools may treat differently.", + "first_step": "Run PR1188's native checkers (or PR1902's audit harness) on candidate-1188.json.gz, or PR1806's PR1122 nine-stage hosted-invoice replay on the deferred PR1122 word.", + "blocked_by": "A host with Boost headers or PR1509's checked cpp_int stand-in." + }, + { + "question": "What is the best scatter basis G for the selected PR589 word under the 2|G| + nnz(G S) cost model?", + "why_it_matters": "The minimum-spanning-tree basis here is a heuristic (527 -> 412); an exact optimum or a lower bound would settle how much the selected word's scatter can gain under H5-tw.", + "first_step": "Enumerate small Steiner-type extensions of the MST (shared intermediate rows) and compare with a linear-programming lower bound.", + "blocked_by": "Search budget; adoption of H5-tw for the selected supplier is a separate maintainer decision." + } + ] +} diff --git a/research/r439-deferred-target-basis-seed06/VERIFY.json b/research/r439-deferred-target-basis-seed06/VERIFY.json new file mode 100644 index 0000000000..678a108bd2 --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/VERIFY.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/e8-bit-carrier-skeleton/code/bit/export_records.py", + "research/e8-bit-p111-tuned/code/xcheck_p.py", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/e8-bit-p111/data/bitE8mut-p111.json.gz", + "research/r439-abc-star-composition/candidate.json.gz", + "research/r439-abc-zrewrite-seed16/CANDIDATE-WORD.json", + "research/r439-b509-boolean-seed05/candidate.json.gz", + "research/r439-bsection-stars-seed01/candidate.json.gz", + "research/r439-bsection-stars-seed01/composition.json.gz", + "research/r439-bsection-stars-seed01/pair_control.json.gz", + "research/r439-five-cycle-seed9f01/CANDIDATE.json.gz", + "research/r439-five-wire-prefix/candidate.json.gz", + "research/r439-four-wire-prefix/candidate.json.gz", + "research/r439-gl5-shortest/candidate.json.gz", + "research/r439-global-prefix-admission/candidate.json.gz", + "research/r439-helper-matching/candidate.json.gz", + "research/r439-helper-matching/floor-word.json.gz", + "research/r439-helper-stars-seed19/candidate.json.gz", + "research/r439-helper-triples/candidate.json.gz", + "research/r439-neutral-helper-chain-seed17/CANDIDATE.json.gz", + "research/r439-neutral-mixed-shears-seed13/candidate.json.gz", + "research/r439-post-helper-shear-seed03/candidate.json.gz", + "research/r439-six-wire-boolean/candidate.json.gz", + "research/r439-target-compensation/candidate.json.gz", + "research/r439-target-retune-seed14/candidate.json.gz", + "research/r439-twisted-star-absorption-seed02/absorbed-pr1062.json.gz", + "research/r439-twisted-star-absorption-seed02/absorbed-pr1188.json.gz", + "research/r439-two-sided-compensation/candidate.json.gz", + "research/r439-z3to2-seed13/CANDIDATE-WORD.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 400, + "checks": "SHA-256 and git-blob input pins; census of all 19 committed PR915-lineage words (literal COPY/ERASE boundary on all 661 dirty columns in both directions for base and deferred word, identical ordered frame paths and exporter MOVE records, paid profile from frames and from the pinned exporter, exporter bill, 104/192-bit guards from exporter F/B, unchanged owner checker with exactly H5_V_identity newly false, H5-tw identities V R = I, V N = K'T, J = I with R = E and V = E^-1, per-cut bridge over the deferred word's own D/A/B prefix, maximality and prefix-split census, bounded order-ideal search); four fully checked order-ideal splits; eight outside words; the PR589 heuristic instance; endpoint controls, check-level controls (each rejected by its intended check) and the reorder census on the PR1062 and PR1188 instances; committed payloads and EXPECTED.json equality." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 400, + "checks": "The same verification under -O: every check raises ValueError, and the pinned exporter child runs without -O." + } + ] +} diff --git a/research/r439-deferred-target-basis-seed06/candidate-1062.json.gz b/research/r439-deferred-target-basis-seed06/candidate-1062.json.gz new file mode 100644 index 0000000000..0a3b17530e Binary files /dev/null and b/research/r439-deferred-target-basis-seed06/candidate-1062.json.gz differ diff --git a/research/r439-deferred-target-basis-seed06/candidate-1188.json.gz b/research/r439-deferred-target-basis-seed06/candidate-1188.json.gz new file mode 100644 index 0000000000..e72404c457 Binary files /dev/null and b/research/r439-deferred-target-basis-seed06/candidate-1188.json.gz differ diff --git a/research/r439-deferred-target-basis-seed06/verify.py b/research/r439-deferred-target-basis-seed06/verify.py new file mode 100644 index 0000000000..9b64c5ff4e --- /dev/null +++ b/research/r439-deferred-target-basis-seed06/verify.py @@ -0,0 +1,1367 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Prepared by Sagar Thakrar with substantial Anthropic Claude assistance. +"""Deferred target basis on fixed R439 bit words (H5-tw): exact finite verification. + +Every PR915-lineage word runs, in D, a 306-gate target-basis preparation E, the helper reads, and the +literal undo E^-1. The deferred word deletes the undo from D, lists the scatter in the target basis +(rows of E S) and runs the same undo gates, at the zero frame, as the first gates of B. This replaces +H5 (V = I) together with the H2 target clause (R = I) by V R = I, with V N = K' T and J = I. + +Checks, from SHA-256 and git-blob pinned repository inputs only: +* census on every committed lineage word (as of base c6765481): D layout, literal undo = reversed + preparation at the zero frame, ADD saving, literal COPY/ERASE boundary (x,y,h) -> (x,y+x,h) on all 661 + dirty columns forward and reverse, identical ordered per-register frame paths, paid profile from frames + and from the pinned exporter, exporter bill and MOVE records, both precision guards from the exporter's + F/B, the unchanged owner checker (exactly H5_V_identity newly false), the H5-tw identities (V R = I, + V N = K' T, J = I, R = E, V = E^-1), the per-cut bridge (the deferred word's own D, A and B prefix are + replayed; its targets differ only by the tracked twist, at the zero frame, unread, until the undo) and + the maximality census (fixed frame paths; B means the base word's B, which is the deferred word's B + after the deferred undo); +* the order-ideal refinement: an exhaustive search over order ideals (commutation-closed down-sets) of the + undo's dependency poset up to a fixed size, a greedy descent, and the best split found, fully checked on + four words (found by search, not optimal); +* the PR1062 and PR1188 instances rebuilt and compared with the committed payloads; +* the PR589 selected-word heuristic (minimum-spanning-tree scatter basis G), with the same checks; +* controls that must fail or be rejected (each check-level control must fail for its intended reason), + and an honest reorder census. +Standard library only. Every check raises ValueError (never assert), so -O cannot weaken it. The +pinned exporter uses assert, so it runs from its verified bytes in a child interpreter without -O. +`--census-scan` (optional, needs git) lists every committed R439 word under research/ and reports any word +missing from LINEAGE/OUTSIDE. +""" +import argparse +import gzip +import hashlib +import json +import os +import struct +import subprocess +import sys +import tempfile +import time +import types +from collections import Counter +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + +# Every distinct committed PR915-lineage R439 word at base c6765481 (duplicate vendor copies omitted). +LINEAGE = [ + ('PR915', 'research/r439-target-compensation/candidate.json.gz'), + ('PR926', 'research/r439-two-sided-compensation/candidate.json.gz'), + ('PR941', 'research/r439-helper-matching/candidate.json.gz'), + ('PR941-floor', 'research/r439-helper-matching/floor-word.json.gz'), + ('PR965', 'research/r439-helper-triples/candidate.json.gz'), + ('PR967', 'research/r439-helper-stars-seed19/candidate.json.gz'), + ('PR1040', 'research/r439-target-retune-seed14/candidate.json.gz'), + ('PR1047', 'research/r439-post-helper-shear-seed03/candidate.json.gz'), + ('PR1062', 'research/r439-bsection-stars-seed01/candidate.json.gz'), + ('PR1062-composition', 'research/r439-bsection-stars-seed01/composition.json.gz'), + ('PR1062-pair-control', 'research/r439-bsection-stars-seed01/pair_control.json.gz'), + ('PR1122', 'research/r439-abc-star-composition/candidate.json.gz'), + ('PR1188', 'research/r439-gl5-shortest/candidate.json.gz'), + ('PR1208', 'research/r439-abc-zrewrite-seed16/CANDIDATE-WORD.json'), + ('PR1449', 'research/r439-neutral-mixed-shears-seed13/candidate.json.gz'), + ('PR1543', 'research/r439-neutral-helper-chain-seed17/CANDIDATE.json.gz'), + ('PR1709', 'research/r439-five-cycle-seed9f01/CANDIDATE.json.gz'), + ('PR1868-1062', 'research/r439-twisted-star-absorption-seed02/absorbed-pr1062.json.gz'), + ('PR1868-1188', 'research/r439-twisted-star-absorption-seed02/absorbed-pr1188.json.gz'), +] +PR589 = 'research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz' +# Committed R439 words outside the lineage: D is the 111 helper reads only (no target basis, R = I). +OUTSIDE = [ + ('PR555', 'research/e8-bit-p111/data/bitE8mut-p111.json.gz'), + ('PR589', PR589), + ('PR904', 'research/r439-four-wire-prefix/candidate.json.gz'), + ('PR936', 'research/r439-five-wire-prefix/candidate.json.gz'), + ('PR952', 'research/r439-six-wire-boolean/candidate.json.gz'), + ('PR980', 'research/r439-global-prefix-admission/candidate.json.gz'), + ('PR1127', 'research/r439-z3to2-seed13/CANDIDATE-WORD.json'), + ('PR1221', 'research/r439-b509-boolean-seed05/candidate.json.gz'), +] +CHECKER = 'research/e8-bit-p111-tuned/code/xcheck_p.py' +EXPORTER = 'research/e8-bit-carrier-skeleton/code/bit/export_records.py' +INPUTS = sorted({p for _, p in LINEAGE + OUTSIDE} | {CHECKER, EXPORTER}) + +INSTANCES = {'PR1062': 'candidate-1062.json.gz', 'PR1188': 'candidate-1188.json.gz'} +# Probe table: complete local ADDs (base, deferred) and B/guard bits from the unpublished exploratory probe, +# required to reproduce; every other number is pinned in EXPECTED.json. +PROBE = {'PR915': (13208, 12778), 'PR967': (11783, 11353), 'PR1062': (11500, 11070), 'PR1122': (10652, 10222), + 'PR1188': (10492, 10062), 'PR1208': (10542, 10112), 'PR1543': (11489, 11059), + 'PR1868-1188': (10489, 10059)} +PROBE_B = {'PR1062': (5911840, 5024524, (95, 182), (95, 181)), 'PR1188': (3758418, 2825146, (91, 175), (91, 173))} +# Order-ideal refinement: exhaustive search bound, and the words on which the best split found is fully checked, +# with the complete local ADDs reported by the pre-PR proof review (required to reproduce). +IDEAL_MAX = 4 +IDEAL_REVIEW = {'PR1062': 11067, 'PR1188': 10059, 'PR1040': 11345, 'PR1868-1188': 10056} +PROFILE = {1: 1323, 2: 1342, 3: 79, 4: 44, 5: 102, 6: 11, 7: 19} +RANK_MASS = 5129 +LOCAL_CAP, NINE_CAP = 104, 192 +OWNER_KEYS = ['H1_no_target_feeds_z', 'H2_D_frame0_targets_from_helpers', 'H3_A_z_only_scatter_targets_B_split', + 'H4_C_literal_reverse_at_full', 'H5_V_identity', 'U_block_form', 'J_identity', 'K_equals_D', + 'C_is_U_inverse'] + + +def need(cond, msg): + if not cond: + raise ValueError(msg) + + +def canonical(w): + return json.dumps(w, sort_keys=True, separators=(',', ':')).encode() + + +def sha(b): + return hashlib.sha256(b).hexdigest() + + +def git_blob(b): + return hashlib.sha1(b'blob %d\0' % len(b) + b).hexdigest() + + +# ------------------------------------------------------------------ pinned inputs + +def check_pin(path, data, pin): + need(sha(data) == pin['sha256'], 'source pin mismatch (sha256): ' + path) + need(git_blob(data) == pin['git_blob'], 'source pin mismatch (git blob): ' + path) + + +def load_inputs(): + src = json.loads((HERE / 'SOURCES.json').read_text(encoding='utf-8')) + pins = {r['path']: r for r in src['files'] if r['usage'] == 'input'} + need(sorted(pins) == INPUTS, 'SOURCES.json input set differs from the verifier inputs') + man = json.loads((HERE / 'VERIFY.json').read_text(encoding='utf-8')) + need(sorted(man['inputs']) == INPUTS, 'VERIFY.json input set differs from the verifier inputs') + data = {} + for p in INPUTS: + b = (ROOT / p).read_bytes() + check_pin(p, b, pins[p]) + data[p] = b + return data, pins + + +def parse_word(path, b): + return json.loads(gzip.decompress(b) if path.endswith('.gz') else b) + + +def owner_module(code): + mod = types.ModuleType('r439_owner_xcheck_p') + mod.__file__ = CHECKER + exec(compile(code, CHECKER, 'exec'), mod.__dict__) + return mod + + +# ------------------------------------------------------------------ geometry (adapted from PR1868's verify.py) + +def rank_q(rows): + m = [[Fraction(x) for x in r] for r in rows] + rk = 0 + for col in range(len(m[0]) if m else 0): + p = next((i for i in range(rk, len(m)) if m[i][col] != 0), None) + if p is None: + continue + m[rk], m[p] = m[p], m[rk] + for i in range(len(m)): + if i != rk and m[i][col] != 0: + f = m[i][col] / m[rk][col] + m[i] = [a - f * b for a, b in zip(m[i], m[rk])] + rk += 1 + return rk + + +class Geo: + def __init__(self, w): + self.v, self.R = w['v'], w['R'] + self.n = 2 * self.v + self.R + self.fs = [frozenset(f) for f in w['frames']] + self.fdim = [rank_q([w['lines'][i] for i in f]) if f else 0 for f in w['frames']] + zero = [k for k, d in enumerate(self.fdim) if d == 0] + full = [k for k, d in enumerate(self.fdim) if d == 8] + need(len(zero) == 1 and len(full) == 1, 'one zero and one full frame') + self.ZERO, self.FULL = zero[0], full[0] + self.X = (1 << self.v) - 1 + self.Y = self.X << self.v + self.H = ((1 << self.R) - 1) << (2 * self.v) + self.I = [1 << a for a in range(self.v)] + + def is_y(self, r): + return self.v <= r < 2 * self.v + + +def same_geometry(a, b): + return all(a[k] == b[k] for k in ('v', 'R', 'h', 'lines', 'frames', 'start', 'final', 'ret')) + + +def frame_paths(w, geo): + fs = geo.fs + ps = [[f] for f in w['start']] + for sec in 'DABC': + for f, d, ss in w[sec]: + for r in (d, *ss): + if ps[r][-1] != f: + need(fs[ps[r][-1]] < fs[f], 'illegal frame move: register %d frame %d -> %d' % (r, ps[r][-1], f)) + ps[r].append(f) + for r, f in enumerate(w['final']): + if ps[r][-1] != f: + need(fs[ps[r][-1]] < fs[f], 'illegal final move: register %d' % r) + ps[r].append(f) + return ps + + +def copy_ranks(w, geo): + cur = list(w['start']) + for sec in 'DA': + for f, d, ss in w[sec]: + for r in (d, *ss): + cur[r] = f + return [geo.fdim[cur[q]] for q in w['ret']] + + +def paid_profile(w, geo, ps=None): + ps = frame_paths(w, geo) if ps is None else ps + prof = Counter(geo.fdim[b] - geo.fdim[a] for p in ps for a, b in zip(p, p[1:])) + prof.update(copy_ranks(w, geo)) + return {k: prof[k] for k in sorted(prof)} + + +# ------------------------------------------------------------------ literal F2 stream (adapted from PR1868) + +def stream(w): + v, tmp = w['v'], 2 * w['v'] + w['R'] + out = [(0, d, s) for sec in 'DA' for _, d, ss in w[sec] for s in ss] + for j, centre in enumerate(w['ret']): + out.append((1, tmp, centre)) + out += [(0, v + i, tmp) for i, row in enumerate(w['scatter']) if j in row] + out.append((2, tmp, centre)) + out += [(0, d, s) for sec in 'BC' for _, d, ss in w[sec] for s in ss] + return out + + +def literal(w, reverse=False): + """Set-valued (bitmask) replay of the literal ADD/COPY/ERASE stream on all formal columns.""" + n = 2 * w['v'] + w['R'] + rows = [1 << r for r in range(n)] + [0] + ins = stream(w) + for kind, d, s in (reversed(ins) if reverse else ins): + if reverse and kind: + kind = 3 - kind + if kind == 0: + rows[d] ^= rows[s] + elif kind == 1: + need(not rows[d], 'COPY into a live temporary') + rows[d] = rows[s] + else: + need(rows[d] == rows[s], 'ERASE of a changed copy') + rows[d] = 0 + need(not rows[-1], 'temporary not erased') + return rows[:-1] + + +def wanted(w): + v, n = w['v'], 2 * w['v'] + w['R'] + return [(1 << r) | (1 << (r - v)) if v <= r < 2 * v else 1 << r for r in range(n)] + + +def boundary_bad(w, reverse=False): + """Registers whose literal endpoint differs from (x, y + x, h); None if the stream itself is rejected.""" + try: + rows = literal(w, reverse) + except ValueError: + return None + return [r for r, (a, b) in enumerate(zip(rows, wanted(w))) if a != b] + + +def boundary_ok(w): + return all(boundary_bad(w, rev) == [] for rev in (False, True)) + + +def bounds(w): + peaks = [] + ins = stream(w) + for reverse in (False, True): + val = [1] * (2 * w['v'] + w['R'] + 1) + peak = 1 + for kind, d, s in (reversed(ins) if reverse else ins): + if reverse and kind: + kind = 3 - kind + val[d] = val[d] + val[s] if kind == 0 else (val[s] if kind == 1 else 0) + peak = max(peak, val[d]) + peaks.append(peak) + F, B = peaks + return dict(ADDs=sum(k == 0 for k, _, _ in ins), D_ADDs=sum(len(g[2]) for g in w['D']), + A_ADDs=sum(len(g[2]) for g in w['A']), scatter_ADDs=sum(len(r) for r in w['scatter']), + B_ADDs=sum(len(g[2]) for g in w['B']), C_ADDs=sum(len(g[2]) for g in w['C']), F=F, B=B) + + +def guard_bits(F, B): + local, nine = 64 * F**3 * B**2, (1 << 18) * F**5 * B**4 + return dict(local_bits=local.bit_length(), nine_stage_bits=nine.bit_length(), + local_ok=local < 1 << LOCAL_CAP, nine_ok=nine < 1 << NINE_CAP) + + +def run_values(w, secs, start=None): + v, n = w['v'], 2 * w['v'] + w['R'] + val = list(start) if start is not None else [1 << r for r in range(n)] + for sec in secs: + if sec == 'scatter': + cp = [val[q] for q in w['ret']] + for t, row in enumerate(w['scatter']): + for j in row: + val[v + t] ^= cp[j] + else: + for f, d, ss in w[sec]: + acc = 0 + for s in ss: + acc ^= val[s] + val[d] ^= acc + return val + + +def bits(x): + out = [] + while x: + low = x & -x + out.append(low.bit_length() - 1) + x ^= low + return out + + +def f2_rank(rows): + rows = [r for r in rows if r] + rk = 0 + while rows: + p = rows.pop() + rk += 1 + low = p & -p + rows = [r ^ p if r & low else r for r in rows] + rows = [r for r in rows if r] + return rk + + +# ------------------------------------------------------------------ target-basis algebra + +def tmat(gates, v, start=None): + """Rows over target indices: after the target-only gates, target a holds the sum of targets in row a.""" + M = list(start) if start is not None else [1 << a for a in range(v)] + for _, d, ss in gates: + acc = 0 + for s in ss: + acc ^= M[s - v] + M[d - v] ^= acc + return M + + +def mul(A, B): + out = [] + for row in A: + acc = 0 + for b in bits(row): + acc ^= B[b] + out.append(acc) + return out + + +def scatter_rows(w): + return [sum(1 << j for j in row) for row in w['scatter']] + + +def listing(rows, nret): + return [[j for j in range(nret) if r >> j & 1] for r in rows] + + +def gate_kind(geo, g): + _, d, ss = g + H0 = 2 * geo.v + if geo.is_y(d): + if all(geo.is_y(s) for s in ss): + return 'yy' + if all(s >= H0 for s in ss): + return 'yh' + return 'y-mixed' + if d >= H0 and all(s >= H0 for s in ss): + return 'hh' + return 'z-other' + + +def d_runs(geo, D): + out = [] + for g in D: + k = gate_kind(geo, g) + if out and out[-1][0] == k: + out[-1][1] += 1 + else: + out.append([k, 1]) + return out + + +def split_d(w, geo): + """Partition D into target-basis preparation, helper reads and literal undo (target gates only).""" + D = w['D'] + ks = [gate_kind(geo, g) for g in D] + need(all(k in ('yy', 'yh', 'hh') for k in ks), 'D has a gate outside target<-target, target<-helper, helper<-helper') + need(all(g[0] == geo.ZERO for g in D), 'D gate off the zero frame') + reads = [i for i, k in enumerate(ks) if k == 'yh'] + need(reads, 'D has no helper reads') + lo, hi = reads[0], reads[-1] + need(all(ks[i] != 'yy' for i in range(lo, hi + 1)), 'a target<-target gate sits among the reads') + prep = [i for i in range(lo) if ks[i] == 'yy'] + undo = [i for i in range(hi + 1, len(D)) if ks[i] == 'yy'] + return dict(prep=prep, reads=reads, undo=undo, + helper_gates=sum(1 for k in ks if k == 'hh'), runs=d_runs(geo, D)) + + +def defer(w, geo, sp): + """Delete the undo from D, list the scatter as rows of E S, and run the undo first in B.""" + v, D = geo.v, w['D'] + E = tmat([D[i] for i in sp['prep']], v) + ES = mul(E, scatter_rows(w)) + und = set(sp['undo']) + w2 = dict(w) + w2['D'] = [list(g) for i, g in enumerate(D) if i not in und] + w2['scatter'] = listing(ES, len(w['ret'])) + w2['B'] = [list(D[i]) for i in sp['undo']] + [list(g) for g in w['B']] + return w2, E, ES + + +# ------------------------------------------------------------------ H5-tw identities + +def h5tw(w, geo): + """Block form of D and of the raw word W0' = (A, scatter, B), and the H5-tw equations.""" + v, n, H0 = geo.v, geo.n, 2 * geo.v + z = [r for r in range(n) if not geo.is_y(r)] + Dm = run_values(w, ['D']) + R = [(Dm[v + a] & geo.Y) >> v for a in range(v)] + N = [Dm[v + a] & geo.H for a in range(v)] + T = [Dm[h] & geo.H for h in range(H0, n)] + raw = run_values(w, ['A', 'scatter', 'B']) + V = [(raw[v + a] & geo.Y) >> v for a in range(v)] + Kp = [raw[v + a] & geo.H for a in range(v)] + VN = mul(V, N) + KpT = [] + for a in range(v): + acc = 0 + for j in bits(Kp[a]): + acc ^= Dm[j] & geo.H + KpT.append(acc) + full = run_values(w, ['D', 'A', 'scatter', 'B', 'C']) + out = dict( + D_frame_zero=all(g[0] == geo.ZERO for g in w['D']), + D_source_free=all(g[1] >= v and all(s >= v for s in g[2]) for g in w['D']), + D_sources_identity=all(Dm[s] == 1 << s for s in range(v)), + D_targets_no_source_column=all(Dm[v + a] & geo.X == 0 for a in range(v)), + T_helper_only=all(Dm[h] & ~geo.H == 0 for h in range(H0, n)), + T_invertible=f2_rank(T) == geo.R, + T_is_identity=all(Dm[h] == 1 << h for h in range(H0, n)), + R_invertible=f2_rank(R) == v, + R_is_identity=R == geo.I, + U_block_form=all(raw[r] & geo.Y == 0 for r in z), + V_is_identity=V == geo.I, + VR_identity=mul(V, R) == geo.I, + J_identity=all(raw[v + a] & geo.X == 1 << a for a in range(v)), + VN_equals_KprimeT=VN == KpT, + C_full_frame_z_only=all(g[0] == geo.FULL and not geo.is_y(g[1]) and not any(geo.is_y(s) for s in g[2]) + for g in w['C']), + C_Uprime_T_identity=all(full[r] == 1 << r for r in z), + final_targets_y_plus_x=all(full[v + a] == (1 << (v + a)) | (1 << a) for a in range(v)), + R_offdiagonal_ones=sum(len(bits(R[a] & ~(1 << a))) for a in range(v)), + V_offdiagonal_ones=sum(len(bits(V[a] & ~(1 << a))) for a in range(v)), + ) + return out, R, V + + +H5TW_REQUIRED = ['D_frame_zero', 'D_source_free', 'D_sources_identity', 'D_targets_no_source_column', 'T_helper_only', + 'T_invertible', 'R_invertible', 'U_block_form', 'VR_identity', 'J_identity', 'VN_equals_KprimeT', + 'C_full_frame_z_only', 'C_Uprime_T_identity', 'final_targets_y_plus_x'] +EQUATIONS = ['VR_identity', 'J_identity', 'VN_equals_KprimeT', 'C_Uprime_T_identity'] + + +def failed_equations(w, geo): + t, _, _ = h5tw(w, geo) + return [k for k in EQUATIONS if not t[k]] + + +# ------------------------------------------------------------------ per-cut bridge + +def bridge(w, w2, geo, steps_d, twist_b, twist): + """Lockstep replay, with frames, of the original word w and the deferred word w2 up to the undo. + + steps_d: D steps ('both' | 'W' | 'W2', gate); twist_b: the gates w2 runs first in B. Invariant at every + cut: all non-target registers agree in value and frame, every target sits at the zero frame in both + words, and w2's targets equal M times w's targets for the tracked basis M. The deferred side is the + deferred word itself: its D and A must equal the replayed steps and its B prefix the replayed twist_b.""" + v, n = geo.v, geo.n + need(w2['D'] == [list(g) for who, g in steps_d if who in ('both', 'W2')] and w2['A'] == w['A'], + 'bridge: the deferred word D/A differ from the replayed steps') + need(w['D'] == [list(g) for who, g in steps_d if who in ('both', 'W')], + 'bridge: the original word D differs from the replayed steps') + need(w2['B'][:len(twist_b)] == [list(g) for g in twist_b], 'bridge: the deferred B prefix differs from the replayed undo') + vals = [[1 << r for r in range(n)], [1 << r for r in range(n)]] + curs = [list(w['start']), list(w['start'])] + M = list(geo.I) + st = dict(cuts=0, cuts_with_target_difference=0, max_targets_differing=0, z_reads_of_targets_in_window=0) + now = [0] # targets differing at the current cut (only target steps change it) + + def cut(): + st['cuts'] += 1 + st['cuts_with_target_difference'] += now[0] > 0 + + def gate(side, f, d, ss): + for r in (d, *ss): + if curs[side][r] != f: + need(geo.fs[curs[side][r]] < geo.fs[f], 'bridge: frame descent') + curs[side][r] = f + acc = 0 + for s in ss: + acc ^= vals[side][s] + vals[side][d] ^= acc + + def check_targets(): + diff = 0 + for a in range(v): + acc = 0 + for b in bits(M[a]): + acc ^= vals[0][v + b] + need(acc == vals[1][v + a], 'bridge: target %d is not the tracked twist of the original' % a) + diff += vals[0][v + a] != vals[1][v + a] + need(all(curs[i][v + a] == geo.ZERO for i in (0, 1) for a in range(v)), 'bridge: a target left the zero frame') + now[0] = diff + st['max_targets_differing'] = max(st['max_targets_differing'], diff) + + def check_z(regs): + for r in regs: + need(curs[0][r] == curs[1][r], 'bridge: register %d frames differ' % r) + if not geo.is_y(r): + need(vals[0][r] == vals[1][r], 'bridge: z register %d differs' % r) + + def twist_col(g): # w alone runs g: M <- M G + _, d, ss = g + for a in range(v): + if M[a] >> (d - v) & 1: + for s in ss: + M[a] ^= 1 << (s - v) + + def twist_row(g): # w2 alone runs g: M <- G M + _, d, ss = g + for s in ss: + M[d - v] ^= M[s - v] + + for who, g in steps_d: + if who in ('both', 'W'): + gate(0, *g) + if who in ('both', 'W2'): + gate(1, *g) + if who == 'W': + twist_col(g) + elif who == 'W2': + twist_row(g) + if who != 'both' or geo.is_y(g[1]): + check_targets() + else: + check_z((g[1], *g[2])) + cut() + need(M == twist, 'bridge: after D the twist is not the expected target basis') + for g in w['A']: + need(not geo.is_y(g[1]), 'bridge: A writes a target') + st['z_reads_of_targets_in_window'] += sum(1 for s in g[2] if geo.is_y(s)) + gate(0, *g) + gate(1, *g) + check_z((g[1], *g[2])) + cut() + need(st['z_reads_of_targets_in_window'] == 0, 'bridge: a z gate reads a twisted target') + need(all(vals[0][r] == vals[1][r] and curs[0][r] == curs[1][r] for r in range(n) if not geo.is_y(r)), + 'bridge: z state differs after A') + # No separate listing check here: a listing other than M S breaks the per-cut invariant at a COPY block. + S0, S1 = scatter_rows(w), scatter_rows(w2) + for j, q in enumerate(w['ret']): + need(vals[0][q] == vals[1][q] and curs[0][q] == curs[1][q], 'bridge: COPY source differs') + for side, rows in ((0, S0), (1, S1)): + for a in range(v): + if rows[a] >> j & 1: + vals[side][v + a] ^= vals[side][q] + check_targets() + cut() + for g in twist_b: + gate(1, *g) + twist_row(g) + check_targets() + cut() + need(M == geo.I, 'bridge: the twist is not undone') + need(vals[0] == vals[1] and curs[0] == curs[1], 'bridge: states differ at the start of the common B') + need(w['B'] == w2['B'][len(twist_b):] and w['C'] == w2['C'], 'bridge: B/C suffix differs') + st['states_equal_after_undo'] = True + return st + + +# ------------------------------------------------------------------ maximality census + +def maximality(w, w2, geo, undo, E): + """Fixed-frame-path census: where the undo may sit and whether B can absorb it. Here B is w's B, which is + w2's B after the deferred undo.""" + v, fs = geo.v, geo.fs + ps = frame_paths(w2, geo) + tpath = [set(ps[v + a]) - {geo.ZERO} for a in range(v)] + sharing = sum(1 for a in range(v) for b in range(a + 1, v) if tpath[a] & tpath[b]) + Bt = [(k, g) for k, g in enumerate(w['B']) if geo.is_y(g[1])] + target_reading = sum(1 for _, g in Bt if any(geo.is_y(s) for s in g[2])) + zero_writes = sum(1 for _, g in Bt if g[0] == geo.ZERO) + vb = run_values(w, ['B']) + confined = all(vb[v + a] & geo.Y == 1 << (v + a) for a in range(v)) + first = {} + for k, (f, d, ss) in enumerate(w['B']): + for r in (d, *ss): + if geo.is_y(r) and r not in first: + first[r] = (k, f) + need(len(first) == v, 'every target is touched in B') + first_climbs = all(f != geo.ZERO for _, f in first.values()) + operands = sorted({r - v for g in undo for r in (g[1], *g[2])}) + latest = [min(first[r][0] for r in (g[1], *g[2])) for g in undo] + # single-edge absorption into a B target write: undo gate t ^= s against a B gate writing t at frame f; + # compensating it there needs s at frame f, i.e. f on s's fixed path. + pairs = legal = 0 + for g in undo: + t = g[1] + for _, (f, d, ss) in Bt: + if d == t: + pairs += 1 + legal += all(f in ps[s] for s in g[2]) + # any target sharing the frame of a B target write on its fixed path + shared_write_frames = sum(1 for _, (f, d, _) in Bt if any(f in tpath[b] for b in range(v) if v + b != d)) + # Relaxed paths (scope limit, not a maximality claim): for each B target write at frame f, count the other + # targets that could be co-located at f if paths may change, under three criteria of decreasing looseness: + # loose = the target's final frame contains f (an upper bound); current = also its frame at that moment lies + # inside f; monotone = f fits monotonically between its own earlier and later fixed touches (and its final). + cur = list(w['start']) + for sec in 'DA': + for f, d, ss in w[sec]: + for r in (d, *ss): + cur[r] = f + touches = {v + b: [] for b in range(v)} + for k, (f, d, ss) in enumerate(w['B']): + for r in (d, *ss): + if geo.is_y(r): + touches[r].append((k, f)) + relaxed = {'loose': Counter(), 'current': Counter(), 'monotone': Counter()} + for k, (f, d, ss) in enumerate(w['B']): + if geo.is_y(d): + cnt = Counter() + for b in range(v): + r = v + b + if r == d or not fs[f] <= fs[w['final'][r]]: + continue + cnt['loose'] += 1 + cnt['current'] += fs[cur[r]] <= fs[f] + cnt['monotone'] += (all(fs[x] <= fs[f] for kk, x in touches[r] if kk < k) + and all(fs[f] <= fs[x] for kk, x in touches[r] if kk > k)) + for key in relaxed: + relaxed[key][cnt[key]] += 1 + for r in (d, *ss): + cur[r] = f + relaxed_report = {key: dict(writes_with_a_partner=sum(c for x, c in cnt.items() if x), max_partners=max(cnt)) + for key, cnt in relaxed.items()} + # prefix-split census: keep the first k undo gates (literal order) in D, defer the rest; scatter cost nnz(E_k S) + S = scatter_rows(w) + ES = mul(E, S) + Ek = list(E) + costs = [sum(len(bits(r)) for r in ES)] + same_listing = [True] + for g in undo: + Ek = tmat([g], v, Ek) + P = mul(Ek, S) + costs.append(sum(len(bits(r)) for r in P)) + same_listing.append(P == ES) + need(Ek == geo.I, 'the undo inverts E') + best = min(costs) + nret = len(w['ret']) + listing_kept = next((k for k, x in enumerate(same_listing) if not x), len(costs)) - 1 + cost_kept = next((k for k, c in enumerate(costs) if c != costs[0]), len(costs)) - 1 + col_old = [sum(1 for a in range(v) if S[a] >> j & 1) for j in range(nret)] + col_new = [sum(1 for a in range(v) if ES[a] >> j & 1) for j in range(nret)] + return dict( + target_nonzero_frame_sets_pairwise_disjoint=sharing == 0, target_pairs_sharing_a_nonzero_frame=sharing, + B_target_writes=len(Bt), B_target_writes_reading_targets=target_reading, B_target_writes_at_zero=zero_writes, + B_target_block_identity=confined, first_B_touch_of_every_target_climbs=first_climbs, + first_B_target_climb_index=min(k for k, _ in first.values()), + undo_operands=len(operands), undo_latest_B_index_min=min(latest), undo_latest_B_index_max=max(latest), + absorption_pairs=pairs, absorption_pairs_frame_legal=legal, + B_target_write_frames_shared_by_another_target_path=shared_write_frames, + relaxed_paths=relaxed_report, + prefix_split_cost_full_deferral=costs[0], prefix_split_cost_no_deferral=costs[-1], prefix_split_cost_min=best, + prefix_split_argmin=[k for k, c in enumerate(costs) if c == best], prefix_split_points=len(costs), + prefix_split_listing_unchanged_for_first_gates=listing_kept, prefix_split_cost_unchanged_for_first_gates=cost_kept, + scatter_column_ones_old=col_old, scatter_column_ones_new=col_new, + per_column_choice_total=sum(min(a, b) for a, b in zip(col_old, col_new))) + + +def require_maximality(mx, name): + need(mx['target_nonzero_frame_sets_pairwise_disjoint'] and mx['B_target_writes_reading_targets'] == 0 + and mx['B_target_writes_at_zero'] == 0 and mx['B_target_block_identity'] + and mx['first_B_touch_of_every_target_climbs'] and mx['absorption_pairs_frame_legal'] == 0 + and mx['B_target_write_frames_shared_by_another_target_path'] == 0, name + ': maximality census') + need(mx['prefix_split_argmin'][0] == 0, name + ': full deferral is not a best prefix split') + + +# ------------------------------------------------------------------ owner checker and exporter + +def owner_flags(own, w): + try: + _, _, _, hyp, con, _ = own.check(w) + except own.Reject as e: + raise ValueError('owner checker rejects: %s' % e) + flags = {**hyp, **con} + need(list(flags) == OWNER_KEYS, 'owner checker flag set changed') + return flags + + +def exporter(code, w, work, name): + d = work / name + d.mkdir() + (d / 'export_records.py').write_bytes(code) + (d / 'word.json.gz').write_bytes(gzip.compress(canonical(w), mtime=0)) + env = {k: x for k, x in os.environ.items() if k != 'PYTHONOPTIMIZE'} + subprocess.run([sys.executable, '-I', '-B', str(d / 'export_records.py'), str(d / 'word.json.gz'), str(d / 'rec')], + check=True, capture_output=True, text=True, env=env) + raw = (d / 'rec/249-records.bin').read_bytes() + need(len(raw) % 24 == 0, 'record alignment') + rec = list(struct.iter_unpack('<6i', raw)) + peaks = [] + for reverse in (False, True): + norm, peak, open_ = [1] * (2 * w['v'] + w['R'] + 1), 1, False + for op, a, b, c, _, _ in (reversed(rec) if reverse else rec): + if op == 0: + continue + if reverse and op in (2, 3): + op = 5 - op + if op == 1: + norm[a] += abs(c) * norm[b] + peak = max(peak, norm[a]) + elif op == 2: + need(not open_, 'nested copy') + norm[b], open_ = norm[a], True + elif op == 3: + need(open_, 'erase without copy') + norm[b], open_ = 0, False + else: + raise ValueError('record opcode') + need(not open_, 'unclosed copy') + peaks.append(peak) + moves = {} + for r in rec: + if r[0] == 0: + moves.setdefault(r[1], []).append((r[2], r[3], r[4])) + prof = Counter(r[4] for r in rec if r[0] == 0) + prof.update(r[5] for r in rec if r[0] == 2) + out = dict(records=len(rec), ADD=sum(r[0] == 1 for r in rec), COPY=sum(r[0] == 2 for r in rec), + ERASE=sum(r[0] == 3 for r in rec), MOVE=sum(r[0] == 0 for r in rec), + COPY_ranks=[r[5] for r in rec if r[0] == 2], F=peaks[0], B=peaks[1], + profile={k: prof[k] for k in sorted(prof)}, rank_mass=sum(k * x for k, x in prof.items()), + record_sha256=sha(raw)) + out.update(guard_bits(out['F'], out['B'])) + return out, moves + + +def rejected(label, fn, out, why=None): + """A control must be rejected; with `why`, it must be rejected by the intended check (message substring).""" + try: + detail = fn() + except ValueError as e: + msg = str(e) + need(why is None or why in msg, 'control rejected for the wrong reason: %s (%s)' % (label, msg[:160])) + out.append([label, msg[:160]]) + return + raise ValueError('control accepted: %s (%s)' % (label, detail)) + + +# ------------------------------------------------------------------ checks (each has a control that it must reject) + +def require_boundary(w, tag): + for rev in (False, True): + need(boundary_bad(w, rev) == [], '%s boundary (%s)' % (tag, 'reverse' if rev else 'forward')) + + +def require_same_paths(w, w2, geo, name): + ps0, ps1 = frame_paths(w, geo), frame_paths(w2, geo) + need(ps0 == ps1, name + ': ordered per-register frame paths changed') + return ps0, ps1 + + +def require_same_profile(w, w2, geo, name): + prof0, prof1 = paid_profile(w, geo), paid_profile(w2, geo) + need(prof0 == prof1, name + ': paid profile changed') + return prof0, prof1 + + +def require_exporter(e, b, prof, nret, name): + need(e['ADD'] == b['ADDs'] and e['COPY'] == e['ERASE'] == nret and e['F'] == b['F'] and e['B'] == b['B'], + name + ': exporter bill') + need(e['profile'] == prof, name + ': exporter profile differs from the frame-path profile') + + +def require_guards(e, name): + need(e['local_ok'] and e['nine_ok'], name + ': precision guard (exporter F/B)') + + +def require_owner_delta(own, w, w2, name, expect=('H5_V_identity',)): + f0, f1 = owner_flags(own, w), owner_flags(own, w2) + newly_false = [k for k in OWNER_KEYS if f0[k] and not f1[k]] + newly_true = [k for k in OWNER_KEYS if f1[k] and not f0[k]] + need(newly_false == list(expect) and not newly_true, name + ': owner flags newly false %s, newly true %s' + % (newly_false, newly_true)) + return f0, f1, newly_false + + +def legal_frame_raise(w2, geo, skip, changes_profile=False): + """First B z-gate (from index skip) whose frame can be raised to a larger non-full frame while every operand + still climbs monotonically; optionally the first such raise that also changes the paid profile.""" + fs, B = geo.fs, w2['B'] + seq = [g for sec in 'DA' for g in w2[sec]] + [g for g in B] + [g for g in w2['C']] + off = len(w2['D']) + len(w2['A']) + base_prof = paid_profile(w2, geo) if changes_profile else None + for k in range(skip, len(B)): + f, d, ss = B[k] + if geo.is_y(d): + continue + nxt = [] + for r in (d, *ss): + g2 = next((g for g in seq[off + k + 1:] if r == g[1] or r in g[2]), None) + nxt.append(fs[g2[0]] if g2 is not None else fs[w2['final'][r]]) + for f2 in range(len(fs)): + if f2 == geo.FULL or not fs[f] < fs[f2] or not all(fs[f2] <= x for x in nxt): + continue + trial = dict(w2, B=B[:k] + [[f2, d, list(ss)]] + B[k + 1:]) + frame_paths(trial, geo) # confirms legality with the full replay + if changes_profile and paid_profile(trial, geo) == base_prof: + continue + return trial, k, f, f2 + raise ValueError('no legal frame raise found') + + +# ------------------------------------------------------------------ order-ideal refinement + +def commute(g, h): + return g[1] not in h[2] and h[1] not in g[2] + + +def ideal_search(undo, E, S, v, kmax): + """Order ideals of the undo's dependency poset (gate i depends on every earlier gate it does not commute + with). Keeping an ideal I before the scatter (in D) and the rest first in B lists the scatter as G_I E S. + Exhaustive over |I| <= kmax (each ideal generated once, elements in increasing index), then a greedy strict + descent from the empty ideal (smallest cost, then smallest index).""" + n = len(undo) + pred = [frozenset(j for j in range(i) if not commute(undo[i], undo[j])) for i in range(n)] + P0 = mul(E, S) + c0 = sum(r.bit_count() for r in P0) + count = [0] * (kmax + 1) + best = [None] * (kmax + 1) + + def step(P, g): + _, t, ss = g + new = P[t - v] + for s in ss: + new ^= P[s - v] + return t - v, new + + def rec(I, last, P, cost): + k = len(I) + count[k] += 1 + if best[k] is None or cost < best[k][0]: + best[k] = (cost, list(I)) + if k == kmax: + return + Iset = set(I) + for i in range(last + 1, n): + if pred[i] <= Iset: + a, new = step(P, undo[i]) + old = P[a] + P[a] = new + I.append(i) + rec(I, i, P, cost + new.bit_count() - old.bit_count()) + I.pop() + P[a] = old + rec([], -1, list(P0), c0) + I, P, cost = [], list(P0), c0 + while True: + Iset = set(I) + cands = [] + for i in range(n): + if i not in Iset and pred[i] <= Iset: + a, new = step(P, undo[i]) + cands.append((cost + new.bit_count() - P[a].bit_count(), i, a, new)) + if not cands or min(cands)[0] >= cost: + break + c, i, a, new = min(cands) + P[a] = new + I.append(i) + cost = c + overall = min([b for b in best] + [(cost, sorted(I))], key=lambda x: (x[0], len(x[1]), x[1])) + return dict(undo_gates=n, minimal_gates=sum(1 for p in pred if not p), size_bound=kmax, ideals_by_size=count, + best_by_size=[[c, I] for c, I in best], greedy=[cost, sorted(I)], best=[overall[0], overall[1]], + full_deferral_cost=c0) + + +def ideal_word(w, geo, sp, I): + """Keep the undo gates of the order ideal I (original order) at the end of D, list the scatter as G E S with + G their product, and run the remaining undo gates (original order) first in B.""" + v, D = geo.v, w['D'] + undo = [D[i] for i in sp['undo']] + keep = set(I) + kept = [undo[i] for i in sorted(I)] + rest = [undo[i] for i in range(len(undo)) if i not in keep] + E = tmat([D[i] for i in sp['prep']], v) + G = tmat(kept, v, E) + und = set(sp['undo']) + w3 = dict(w) + w3['D'] = [list(g) for i, g in enumerate(D) if i not in und] + [list(g) for g in kept] + w3['scatter'] = listing(mul(G, scatter_rows(w)), len(w['ret'])) + w3['B'] = [list(g) for g in rest] + [list(g) for g in w['B']] + return w3, G, kept, rest + + +def ideal_instance(name, w, w2, geo, sp, I, own, code, work): + """The best order-ideal split found, with the same checks as the deferred word.""" + v = geo.v + w3, G, kept, rest = ideal_word(w, geo, sp, I) + require_boundary(w3, name + ' ideal split') + require_same_paths(w, w3, geo, name + ' ideal split') + _, prof3 = require_same_profile(w, w3, geo, name + ' ideal split') + b0, b2, b3 = bounds(w), bounds(w2), bounds(w3) + need(b3['ADDs'] == b2['ADDs'] - (b2['scatter_ADDs'] - b3['scatter_ADDs']), name + ': ideal split ADD accounting') + need(b3['F'] == b2['F'] and b3['B'] == b2['B'], name + ': ideal split F/B differ from full deferral') + need(b3['ADDs'] == IDEAL_REVIEW[name], name + ': ideal split ADDs %d, review reported %d' % (b3['ADDs'], IDEAL_REVIEW[name])) + e0, mv0 = exporter(code, w, work, name + '-ideal-base') + e3, mv3 = exporter(code, w3, work, name + '-ideal') + require_exporter(e3, b3, prof3, len(w['ret']), name + ' ideal split') + require_guards(e3, name + ' ideal split') + need(mv0 == mv3, name + ': ideal split MOVE records differ') + _, _, newly = require_owner_delta(own, w, w3, name + ' ideal split') + t3, R3, V3 = h5tw(w3, geo) + need(all(t3[k] for k in H5TW_REQUIRED) and R3 == G and V3 == tmat(rest, v) and tmat(rest, v, G) == geo.I + and not t3['R_is_identity'] and not t3['V_is_identity'], name + ': ideal split H5-tw identities') + und = set(sp['undo']) + steps = [('W' if i in und else 'both', g) for i, g in enumerate(w['D'])] + [('W2', g) for g in kept] + br = bridge(w, w3, geo, steps, w3['B'][:len(rest)], G) + return dict(kept_undo_gates=sorted(I), kept_before_scatter=len(kept), deferred_to_B=len(rest), + scatter_ADDs=[b0['scatter_ADDs'], b2['scatter_ADDs'], b3['scatter_ADDs']], + ADDs=[b0['ADDs'], b2['ADDs'], b3['ADDs']], F=e3['F'], B=e3['B'], + local_bits=e3['local_bits'], nine_stage_bits=e3['nine_stage_bits'], paid_profile=prof3, + owner_newly_false=newly, word_sha256=sha(canonical(w3)), bridge=br, + label='found by search (exhaustive over ideals of size <= %d plus greedy descent), not optimal' % IDEAL_MAX) + + +# ------------------------------------------------------------------ one lineage word + +def census_word(name, w, geo, p589, own, code, work, check_controls): + v = geo.v + need(same_geometry(w, p589), name + ': geometry differs from PR589') + sp = split_d(w, geo) + D = w['D'] + prep, undo = [D[i] for i in sp['prep']], [D[i] for i in sp['undo']] + need(prep and len(prep) == len(undo), name + ': preparation/undo shape') + need(undo == prep[::-1], name + ': the undo is not the literal reverse of the preparation') + need(all(g[0] == geo.ZERO for g in prep + undo), name + ': preparation/undo off the zero frame') + w2, E, ES = defer(w, geo, sp) + need(tmat(undo, v, E) == geo.I, name + ': the undo is not E^-1') + need(scatter_rows(w2) == mul(E, scatter_rows(w)), name + ': the deferred listing is not E S') + # literal boundary, both words, both directions + require_boundary(w, name + ' base') + require_boundary(w2, name + ' deferred') + # frames and paid profile + ps0, ps1 = require_same_paths(w, w2, geo, name) + prof0, prof1 = require_same_profile(w, w2, geo, name) + # Census fact (reported per word): every committed lineage word carries PR589's profile. + need(prof1 == PROFILE and sum(k * x for k, x in prof1.items()) == RANK_MASS, name + ': profile is not PR589\'s') + # scalar bill + b0, b1 = bounds(w), bounds(w2) + saving = b0['scatter_ADDs'] - b1['scatter_ADDs'] + undo_adds = sum(len(g[2]) for g in undo) + need(b0['ADDs'] - b1['ADDs'] == saving and b1['B_ADDs'] - b0['B_ADDs'] == b0['D_ADDs'] - b1['D_ADDs'] == undo_adds, + name + ': ADD accounting') + need(b1['F'] == b0['F'] and b1['B'] < b0['B'], name + ': F unchanged and B falls') + if name in PROBE: + need((b0['ADDs'], b1['ADDs']) == PROBE[name], name + ': probe ADDs %s, found %s' % (PROBE[name], (b0['ADDs'], b1['ADDs']))) + # exporter: bill, profile, guards, MOVE records + e0, mv0 = exporter(code, w, work, name + '-base') + e1, mv1 = exporter(code, w2, work, name + '-deferred') + require_exporter(e0, b0, prof0, len(w['ret']), name + ' base') + require_exporter(e1, b1, prof1, len(w['ret']), name + ' deferred') + # The guards are required of every deferred word. PR941's floor-calibration word is the only base word that + # already misses the nine-stage guard (193 bits); the guard check must reject it. + require_guards(e1, name + ' deferred') + if name == 'PR941-floor': + rejected('precision guard on the PR941 floor-calibration base word (%d nine-stage bits)' % e0['nine_stage_bits'], + lambda: require_guards(e0, name + ' base'), check_controls, why='precision guard') + else: + require_guards(e0, name + ' base') + need(e1['local_bits'] <= e0['local_bits'] and e1['nine_stage_bits'] <= e0['nine_stage_bits'], name + ': guard bits rise') + need(mv0 == mv1, name + ': exporter MOVE records differ') + if name in PROBE_B: + B0, B1, bits0, bits1 = PROBE_B[name] + need((e0['B'], e1['B']) == (B0, B1) and (e0['local_bits'], e0['nine_stage_bits']) == bits0 + and (e1['local_bits'], e1['nine_stage_bits']) == bits1, name + ': probe B and guard bits') + # owner checker + f0, f1, newly_false = require_owner_delta(own, w, w2, name) + # H5-tw identities + t0, R0, V0 = h5tw(w, geo) + t1, R1, V1 = h5tw(w2, geo) + for t in (t0, t1): + need(all(t[k] for k in H5TW_REQUIRED), name + ': H5-tw contract') + need(t0['R_is_identity'] and t0['V_is_identity'], name + ': base is the R = V = I case') + need(not t1['R_is_identity'] and not t1['V_is_identity'] and R1 == E and V1 == tmat(undo, v), name + ': R = E, V = E^-1') + need(t0['T_is_identity'] == t1['T_is_identity'], name + ': helper twist T unchanged') + # Anchor of the bridge chain for T = I words: the base D has PR589's D operator, and the PR1194-style + # proof-only splice (base A/scatter/B/C with PR589's target-only D) passes every inherited owner flag. + # The T != I words of PR1868 are anchored by PR1868's own per-cut bridge instead. + d_equal = run_values(w, ['D']) == run_values(p589, ['D']) + splice_ok = all(owner_flags(own, dict(w, D=p589['D'])).values()) if t0['T_is_identity'] else None + need(d_equal == t0['T_is_identity'] and splice_ok in (True, None), name + ': PR1194-style anchor') + # per-cut bridge (the deferred word's own D, A and B prefix) + und = set(sp['undo']) + steps = [('W' if i in und else 'both', g) for i, g in enumerate(D)] + br = bridge(w, w2, geo, steps, w2['B'][:len(undo)], E) + # maximality (prefix splits of the literal undo order) and the order-ideal search + mx = maximality(w, w2, geo, undo, E) + require_maximality(mx, name) + ideals = ideal_search(undo, E, scatter_rows(w), v, IDEAL_MAX) + need(ideals['full_deferral_cost'] == b1['scatter_ADDs'] and ideals['best'][0] <= mx['prefix_split_cost_min'], + name + ': order-ideal search') + row = dict(path=dict(LINEAGE)[name], payload_sha256=sha(canonical(w)), deferred_sha256=sha(canonical(w2)), + D_runs=sp['runs'], preparation_gates=len(prep), undo_gates=len(undo), + preparation_contiguous=sp['prep'] == list(range(sp['prep'][0], sp['prep'][-1] + 1)), + ES_nonzero_rows=sum(1 for r in ES if r), scatter_ADDs=[b0['scatter_ADDs'], b1['scatter_ADDs']], + ADDs=[b0['ADDs'], b1['ADDs']], saving=saving, F=[e0['F'], e1['F']], B=[e0['B'], e1['B']], + local_bits=[e0['local_bits'], e1['local_bits']], nine_stage_bits=[e0['nine_stage_bits'], e1['nine_stage_bits']], + paid_profile=prof1, rank_mass=sum(k * x for k, x in prof1.items()), selected_profile=prof1 == PROFILE, + exporter=dict(base=e0, deferred=e1), owner_false_base=[k for k in OWNER_KEYS if not f0[k]], + owner_false_deferred=[k for k in OWNER_KEYS if not f1[k]], owner_newly_false=newly_false, + h5tw=dict(base=t0, deferred=t1), T_is_identity=t1['T_is_identity'], + anchor=dict(base_D_operator_equals_PR589_D=d_equal, PR589_D_splice_passes_every_owner_flag=splice_ok), + bridge=br, maximality=mx, order_ideals=ideals) + return w2, row + + +# ------------------------------------------------------------------ controls (instances) + +def controls(name, w, w2, geo, data, pins, own, row): + out = [] + v = geo.v + sp = split_d(w, geo) + undo = [w['D'][i] for i in sp['undo']] + nu = len(undo) + kinds = lambda rs: dict(sorted(Counter('source' if r < v else 'target' if r < 2 * v else 'helper' for r in rs).items())) + + def endpoint(ww, label): + bad = boundary_bad(ww) + need(bad == [], 'dirty endpoint wrong on %d registers %s; failed equations %s' + % (len(bad), kinds(bad), failed_equations(ww, geo))) + return label + # 1. deferral with the old S listing + old = dict(w2, scatter=w['scatter']) + rejected('deferral with the old scatter listing S', lambda: endpoint(old, 'old S'), out) + # 2. undo moved after an operand's first B climb + ops = {r for g in undo for r in (g[1], *g[2])} + k0 = next(k for k, g in enumerate(w['B']) if ops & {g[1], *g[2]}) + moved = dict(w2, B=[list(g) for g in w['B'][:k0 + 1]] + [list(g) for g in undo] + [list(g) for g in w['B'][k0 + 1:]]) + rejected('undo moved after B[%d], the first B climb of an undo operand (frames)' % k0, lambda: frame_paths(moved, geo), out) + moved_bad = boundary_bad(moved) + need(moved_bad != [], 'moved undo: F2 endpoint unexpectedly exact') + out.append(['undo moved after B[%d] (values, frames ignored)' % k0, + 'dirty endpoint wrong on %d registers %s' % (len(moved_bad), kinds(moved_bad))]) + # 3. one dropped undo gate + drop = dict(w2, B=[list(g) for g in undo[1:]] + [list(g) for g in w['B']]) + rejected('first undo gate dropped', lambda: endpoint(drop, 'dropped'), out) + # 4. reordered undo gates: preparation order instead of its reverse + fwd = dict(w2, B=[list(g) for g in undo[::-1]] + [list(g) for g in w['B']]) + rejected('undo gates in preparation order', lambda: endpoint(fwd, 'prep order'), out) + # 5. one wrong E S row + a = next(i for i, row in enumerate(w2['scatter']) if row) + rows = [list(r) for r in w2['scatter']] + rows[a] = sorted(set(rows[a]) ^ {0}) + wrong = dict(w2, scatter=rows) + rejected('E S row %d with bit 0 flipped' % a, lambda: endpoint(wrong, 'wrong row'), out) + # 6. corrupted pin + p = dict(LINEAGE)[name] + b = bytearray(data[p]) + b[len(b) // 2] ^= 1 + rejected('corrupted source pin', lambda: check_pin(p, bytes(b), pins[p]), out) + # reorder census: an adjacent transposition preserves the undo operator iff the two gates commute + U = tmat(undo, v) + comm = noncomm = agree = 0 + first_c = first_n = None + for i in range(nu - 1): + sw = undo[:i] + [undo[i + 1], undo[i]] + undo[i + 2:] + same = tmat(sw, v) == U + g, h = undo[i], undo[i + 1] + commute = g[1] not in h[2] and h[1] not in g[2] + agree += same == commute + if commute: + comm += 1 + first_c = i if first_c is None else first_c + else: + noncomm += 1 + first_n = i if first_n is None else first_n + need(agree == nu - 1, 'reorder census: operator change does not match non-commutation') + + def swapped(i): + sw = undo[:i] + [undo[i + 1], undo[i]] + undo[i + 2:] + return dict(w2, B=[list(g) for g in sw] + [list(g) for g in w['B']]) + rejected('adjacent non-commuting undo gates %d,%d swapped' % (first_n, first_n + 1), + lambda: endpoint(swapped(first_n), 'swap'), out) + need(first_c is not None and boundary_ok(swapped(first_c)), 'a commuting swap keeps the boundary') + # Check-level controls: each check must reject a word built to violate it, for the intended reason. + E = tmat([w['D'][i] for i in sp['prep']], v) + und = set(sp['undo']) + steps = [('W' if i in und else 'both', g) for i, g in enumerate(w['D'])] + short = dict(w2, D=w2['D'][:-1]) + rejected('bridge on the deferred word with its last D gate dropped', + lambda: bridge(w, short, geo, steps, short['B'][:nu], E), out, why='differ from the replayed steps') + rejected('bridge on the old-S word', lambda: bridge(w, old, geo, steps, old['B'][:nu], E), out, why='tracked twist') + sw = swapped(first_n) + rejected('bridge on the swapped-undo word', lambda: bridge(w, sw, geo, steps, sw['B'][:nu], E), out, why='not undone') + rejected('owner delta on (base, base)', lambda: require_owner_delta(own, w, w, name), out, why='owner flags') + fp, k, f, f2 = legal_frame_raise(w2, geo, nu) + rejected('frame paths: legal frame raise of B[%d] %d -> %d' % (k, f, f2), lambda: require_same_paths(w, fp, geo, name), + out, why='frame paths changed') + fq, k2, g, g2 = legal_frame_raise(w2, geo, nu, changes_profile=True) + rejected('paid profile: legal frame raise of B[%d] %d -> %d' % (k2, g, g2), lambda: require_same_profile(w, fq, geo, name), + out, why='paid profile changed') + e0, b0 = row['exporter']['base'], bounds(w) + rejected('exporter profile against the frame-raised profile', + lambda: require_exporter(e0, b0, paid_profile(fq, geo), len(w['ret']), name), out, why='exporter profile differs') + rejected('maximality census with the deferred word as its own base', + lambda: require_maximality(maximality(w2, w2, geo, undo, E), name), out, why='maximality census') + reorder = dict(adjacent_transpositions=nu - 1, commuting=comm, non_commuting=noncomm, + operator_changes_iff_non_commuting=True, + commuting_swap_checked=[first_c, first_c + 1], commuting_swap_boundary_exact=True) + return out, reorder + + +# ------------------------------------------------------------------ PR589 selected-word heuristic + +def mst_basis(S, v, ZERO): + """Prim's minimum spanning tree over the scatter rows plus a zero root; edge cost 2 + Hamming distance, + root cost = row weight. Returns target gates a ^= parent(a), children before parents.""" + pc = lambda x: len(bits(x)) + best = {a: (pc(S[a]), -1) for a in range(v)} + order, parent = [], {} + while best: + a = min(best, key=lambda k: (best[k][0], k)) + _, p = best.pop(a) + parent[a] = p + order.append(a) + for b in best: + c = 2 + pc(S[a] ^ S[b]) + if c < best[b][0]: + best[b] = (c, a) + cost = sum(pc(S[a]) if parent[a] < 0 else 2 + pc(S[a] ^ S[parent[a]]) for a in range(v)) + gates = [[ZERO, v + a, [v + parent[a]]] for a in reversed(order) if parent[a] >= 0] + return gates, cost + + +def selected_heuristic(p589, geo, own, code, work): + """PR589 has no target basis; a scatter basis G (MST heuristic) after the D reads, G^-1 first in B.""" + v = geo.v + sp = split_d(p589, geo) + need(not sp['prep'] and not sp['undo'], 'PR589 D has no target basis') + S = scatter_rows(p589) + Gg, cost = mst_basis(S, v, geo.ZERO) + Gm = tmat(Gg, v) + GS = mul(Gm, S) + w2 = dict(p589) + w2['D'] = [list(g) for g in p589['D']] + [list(g) for g in Gg] + w2['scatter'] = listing(GS, len(p589['ret'])) + w2['B'] = [list(g) for g in Gg[::-1]] + [list(g) for g in p589['B']] + need(cost == 2 * len(Gg) + sum(len(bits(r)) for r in GS), 'MST cost accounting') + require_boundary(w2, 'PR589 heuristic') + require_same_paths(p589, w2, geo, 'PR589 heuristic') + prof0, prof = require_same_profile(p589, w2, geo, 'PR589 heuristic') + need(prof == PROFILE, 'PR589 heuristic paid profile') + b0, b1 = bounds(p589), bounds(w2) + e0, mv0 = exporter(code, p589, work, 'PR589-base') + e1, mv1 = exporter(code, w2, work, 'PR589-heuristic') + require_exporter(e0, b0, PROFILE, len(p589['ret']), 'PR589 base') + require_exporter(e1, b1, PROFILE, len(p589['ret']), 'PR589 heuristic') + need(e0['rank_mass'] == e1['rank_mass'] == RANK_MASS, 'PR589 heuristic rank mass') + require_guards(e0, 'PR589 base') + require_guards(e1, 'PR589 heuristic') + need(mv0 == mv1, 'PR589 heuristic MOVE records') + expect = ['H2_D_frame0_targets_from_helpers', 'H5_V_identity', 'K_equals_D'] + f0, f1, newly = require_owner_delta(own, p589, w2, 'PR589 heuristic', expect=expect) + need(all(f0.values()), 'PR589 passes every owner flag') + t1, R1, V1 = h5tw(w2, geo) + need(all(t1[k] for k in H5TW_REQUIRED) and R1 == Gm and V1 == tmat(Gg[::-1], v) and not t1['V_is_identity'], + 'PR589 heuristic H5-tw identities') + steps = [('both', g) for g in p589['D']] + [('W2', g) for g in Gg] + br = bridge(p589, w2, geo, steps, w2['B'][:len(Gg)], Gm) + return dict(method='Prim minimum spanning tree over the 111 scatter rows plus a zero root, edge cost 2 + Hamming ' + 'distance; scatter basis G (R = G, V = G^-1); heuristic, not optimal', + tree_edges=len(Gg), roots=v - len(Gg), basis_gates_each_way=len(Gg), + scatter_ADDs=[b0['scatter_ADDs'], b1['scatter_ADDs']], scatter_related_cost=cost, + ADDs=[b0['ADDs'], b1['ADDs']], F=[e0['F'], e1['F']], B=[e0['B'], e1['B']], + local_bits=[e0['local_bits'], e1['local_bits']], nine_stage_bits=[e0['nine_stage_bits'], e1['nine_stage_bits']], + paid_profile=prof, rank_mass=e1['rank_mass'], owner_false=[k for k in OWNER_KEYS if not f1[k]], + word_sha256=sha(canonical(w2)), bridge=br) + + +# ------------------------------------------------------------------ census scan (optional) + +def census_scan(): + """Every committed R439 word under research/ (git ls-files), deduplicated by canonical hash, against the lists.""" + files = subprocess.run(['git', '-C', str(ROOT), 'ls-files', 'research'], capture_output=True, text=True, + check=True).stdout.split('\n') + own_dir = 'research/' + HERE.name + '/' + listed = {p for _, p in LINEAGE + OUTSIDE} + seen = {} + for f in files: + if not f.endswith(('.json', '.json.gz')) or f.startswith(own_dir): + continue + try: + b = (ROOT / f).read_bytes() + if len(b) > 50_000_000: + continue + raw = gzip.decompress(b) if f.endswith('.gz') else b + if b'"scatter"' not in raw: + continue + w = json.loads(raw) + except (OSError, ValueError, EOFError): + continue + if not isinstance(w, dict) or not all(k in w for k in ('v', 'R', 'D', 'A', 'B', 'C', 'scatter', 'ret')): + continue + if (w['v'], w['R']) != (111, 439): + continue + seen.setdefault(sha(canonical(w)), []).append(f) + listed_hashes = {} + for h, fs in seen.items(): + for f in fs: + if f in listed: + listed_hashes[h] = f + missing = {h: fs for h, fs in seen.items() if h not in listed_hashes} + print('census scan: %d distinct committed R439 words (%d files); %d listed, %d unlisted' + % (len(seen), sum(len(x) for x in seen.values()), len(listed_hashes), len(missing))) + for h, fs in sorted(missing.items()): + print(' UNLISTED %s %s' % (h[:12], ', '.join(fs))) + need(len(listed_hashes) == len(listed), 'a listed word was not found by the scan') + return not missing + + +# ------------------------------------------------------------------ driver + +def run(write=False): + data, pins = load_inputs() + p589 = parse_word(PR589, data[PR589]) + own = owner_module(data[CHECKER]) + geo = Geo(p589) + rep = dict(status='PASS_R439_DEFERRED_TARGET_BASIS', inputs={p: pins[p]['sha256'] for p in INPUTS}, + columns=geo.n, census={}, outside={}, instances={}, controls={}, check_controls=[], reorder={}, + ideal_split={}) + built = {} + words = {} + with tempfile.TemporaryDirectory(prefix='r439-deferred-') as tmp: + work = Path(tmp) + for name, path in LINEAGE: + w = parse_word(path, data[path]) + words[name] = w + built[name], rep['census'][name] = census_word(name, w, geo, p589, own, data[EXPORTER], work, + rep['check_controls']) + if name in INSTANCES: + ctl, reo = controls(name, w, built[name], geo, data, pins, own, rep['census'][name]) + rep['controls'][name] = ctl + rep['reorder'][name] = reo + need(len(rep['check_controls']) == 1, 'the PR941 floor guard control ran exactly once') + for name in IDEAL_REVIEW: + w = words[name] + sp = split_d(w, geo) + I = rep['census'][name]['order_ideals']['best'][1] + rep['ideal_split'][name] = ideal_instance(name, w, built[name], geo, sp, I, own, data[EXPORTER], work) + for name, path in OUTSIDE: + w = parse_word(path, data[path]) + need(same_geometry(w, p589), name + ': geometry') + sp = split_d(w, geo) + need(not sp['prep'] and not sp['undo'] and sp['helper_gates'] == 0, name + ': not a target-basis word') + b = bounds(w) + rep['outside'][name] = dict(path=path, D_runs=sp['runs'], ADDs=b['ADDs'], scatter_ADDs=b['scatter_ADDs'], + target_basis_gates=0, deferral='vacuous (R = I)') + rep['selected_heuristic'] = selected_heuristic(p589, geo, own, data[EXPORTER], work) + for name, fname in INSTANCES.items(): + rep['instances'][name] = dict(file=fname, payload_sha256=sha(canonical(built[name]))) + rep['new_kappa_claim'] = False + rep = json.loads(json.dumps(rep)) + if write: + for name, fname in INSTANCES.items(): + (HERE / fname).write_bytes(gzip.compress(canonical(built[name]), mtime=0)) + (HERE / 'EXPECTED.json').write_text(json.dumps(rep, indent=1, sort_keys=True) + '\n', encoding='utf-8') + containers = {} + for name, fname in INSTANCES.items(): + raw = (HERE / fname).read_bytes() + need(gzip.decompress(raw) == canonical(built[name]), 'committed payload differs from the rebuilt word: ' + name) + containers[name] = raw == gzip.compress(canonical(built[name]), mtime=0) + need(json.loads((HERE / 'EXPECTED.json').read_text(encoding='utf-8')) == rep, 'EXPECTED.json mismatch') + return rep, containers + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.split('\n')[0]) + ap.add_argument('--write', action='store_true', help='regenerate EXPECTED.json and the committed payloads') + ap.add_argument('--census-scan', action='store_true', + help='only list committed R439 words under research/ (needs git) and report any unlisted word') + a = ap.parse_args() + if a.census_scan: + sys.exit(0 if census_scan() else 1) + t0 = time.perf_counter() + rep, containers = run(write=a.write) + print('%-20s %6s %6s %5s %4s %4s %9s %7s %17s %10s %s' % ('word', 'base', 'defer', 'save', 'E', 'ES', 'scatter', + 'F', 'B', 'bits', 'owner newly false')) + for name, c in rep['census'].items(): + print('%-20s %6d %6d %5d %4d %4d %4d->%-4d %7d %8d->%-8d %d/%d->%d/%d %s%s' % ( + name, c['ADDs'][0], c['ADDs'][1], c['saving'], c['preparation_gates'], c['ES_nonzero_rows'], + c['scatter_ADDs'][0], c['scatter_ADDs'][1], c['F'][1], c['B'][0], c['B'][1], c['local_bits'][0], + c['nine_stage_bits'][0], c['local_bits'][1], c['nine_stage_bits'][1], ','.join(c['owner_newly_false']), + '' if c['T_is_identity'] else ' (T != I)')) + first = next(iter(rep['census'].values())) + print('every lineage word: boundary %d columns both directions, frame paths and MOVE records identical, ' + 'paid profile %s mass %d, bridge, maximality census' % (rep['columns'], json.dumps(first['paid_profile'], + separators=(',', ':')), first['rank_mass'])) + for name, c in rep['census'].items(): + b, m, o = c['bridge'], c['maximality'], c['order_ideals'] + rl = m['relaxed_paths'] + print(' %-20s cuts=%d twisted=%d prefix-split min %d at %s; absorption legal %d/%d; relaxed partners ' + 'loose %d/%d current %d/%d monotone %d/%d; ideals<=%d best %d %s greedy %d' % ( + name, b['cuts'], b['cuts_with_target_difference'], m['prefix_split_cost_min'], m['prefix_split_argmin'], + m['absorption_pairs_frame_legal'], m['absorption_pairs'], + rl['loose']['writes_with_a_partner'], rl['loose']['max_partners'], + rl['current']['writes_with_a_partner'], rl['current']['max_partners'], + rl['monotone']['writes_with_a_partner'], rl['monotone']['max_partners'], + o['size_bound'], o['best'][0], o['best'][1], o['greedy'][0])) + for name, x in rep['ideal_split'].items(): + print('order-ideal split %-12s keep undo gates %s before the scatter: scatter %d -> %d, ADDs %d -> %d -> %d; ' + 'B %d; bits %d/%d; owner newly false %s; bridge cuts %d (%s)' % ( + name, x['kept_undo_gates'], x['scatter_ADDs'][1], x['scatter_ADDs'][2], x['ADDs'][0], x['ADDs'][1], + x['ADDs'][2], x['B'], x['local_bits'], x['nine_stage_bits'], ','.join(x['owner_newly_false']), + x['bridge']['cuts'], x['label'])) + for name, o in rep['outside'].items(): + print('outside %-8s ADDs %d scatter %d: %s' % (name, o['ADDs'], o['scatter_ADDs'], o['deferral'])) + s = rep['selected_heuristic'] + print('PR589 heuristic (MST scatter basis G, not optimal): scatter %d -> %d with %d basis gates each way; ADDs %d -> %d; ' + 'B %d -> %d; bits %d/%d -> %d/%d; owner false %s' % ( + s['scatter_ADDs'][0], s['scatter_related_cost'], s['basis_gates_each_way'], s['ADDs'][0], s['ADDs'][1], + s['B'][0], s['B'][1], s['local_bits'][0], s['nine_stage_bits'][0], s['local_bits'][1], + s['nine_stage_bits'][1], ','.join(s['owner_false']))) + for label, why in rep['check_controls']: + print(' check control rejected: %s -- %s' % (label, why)) + for name, ctl in rep['controls'].items(): + for label, why in ctl: + print(' %s control rejected: %s -- %s' % (name, label, why)) + r = rep['reorder'][name] + print(' %s reorder census: %d adjacent swaps, %d commuting (operator kept, boundary exact), %d not (operator ' + 'changes)' % (name, r['adjacent_transpositions'], r['commuting'], r['non_commuting'])) + print('committed payloads equal the rebuilt words; gzip containers byte-identical here: %s' % containers) + print('PASS_R439_DEFERRED_TARGET_BASIS words=%d outside=%d instances=%d ideal_splits=%d columns=%d controls=%d ' + 'no_new_kappa (%.1f s)' % (len(rep['census']), len(rep['outside']), len(rep['instances']), + len(rep['ideal_split']), rep['columns'], + sum(len(x) for x in rep['controls'].values()) + len(rep['check_controls']), + time.perf_counter() - t0)) + + +if __name__ == '__main__': + main()