diff --git a/research/r439-b509-boolean-seed05/CANDIDATE.json b/research/r439-b509-boolean-seed05/CANDIDATE.json new file mode 100644 index 0000000000..86f33af179 --- /dev/null +++ b/research/r439-b509-boolean-seed05/CANDIDATE.json @@ -0,0 +1,165 @@ +{ + "assignment_seed": 5, + "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe", + "format": "r439-b509-boolean/1", + "frame": 509, + "gates": [ + [ + 509, + 50, + [ + 67 + ] + ], + [ + 509, + 87, + [ + 77 + ] + ], + [ + 509, + 87, + [ + 22 + ] + ], + [ + 509, + 87, + [ + 92 + ] + ], + [ + 509, + 87, + [ + 38 + ] + ], + [ + 509, + 87, + [ + 50 + ] + ], + [ + 509, + 87, + [ + 60 + ] + ], + [ + 509, + 468, + [ + 38 + ] + ], + [ + 509, + 38, + [ + 33 + ] + ], + [ + 509, + 77, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 87 + ] + ], + [ + 509, + 17, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 22 + ] + ], + [ + 509, + 67, + [ + 17 + ] + ], + [ + 509, + 50, + [ + 17 + ] + ], + [ + 509, + 92, + [ + 33 + ] + ], + [ + 509, + 60, + [ + 17 + ] + ], + [ + 509, + 468, + [ + 92 + ] + ], + [ + 509, + 77, + [ + 17 + ] + ], + [ + 509, + 38, + [ + 17 + ] + ] + ], + "registers": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92, + 468 + ], + "slice": [ + 283, + 314 + ] +} diff --git a/research/r439-b509-boolean-seed05/CLAIM.json b/research/r439-b509-boolean-seed05/CLAIM.json new file mode 100644 index 0000000000..7fd85e491f --- /dev/null +++ b/research/r439-b509-boolean-seed05/CLAIM.json @@ -0,0 +1,57 @@ +{ + "track": "Bit supplier", + "assignment_seed": 5, + "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe", + "object": "PR589 tuned R439 phase-B frame 509", + "candidates_considered": [ + "Whole-frame Boolean CNOT synthesis at B frame 509, allowing cancellation outside nonnegative-integer factorization", + "Restored helper shear in D; overlapping PR967, PR1062 and post-helper work", + "Changed helper entrance; overlapping PR1179 sparse kernel and PR1128 boundary work" + ], + "chosen_method": "Bounded XOR row/column elimination and local exact identities, seed 5; fixed 11-wire block, no auxiliary, same frame; rebuild literal cleanup", + "changed_hypothesis": "Require same F2 block operator instead of same positive integer transfer; verify complete positive envelopes separately", + "budget": "Same paid frame path, COPY and recursive profile; no claim to improve nonbinding bit endpoint or kappa. A block saving s pays 2s including inverse cleanup. No added helpers/source access/adapters.", + "stopping_rule": "At most 10000 seeded elimination trajectories; stop earlier at declared time cap; report completed coverage and never claim optimum. One evidence-driven pivot permitted.", + "expected_deliverable": "Pinned candidate or scoped negative evidence, independent finite checker and failure controls", + "finish_utc": "2026-10-13T20:55:43Z", + "orientation_completed_utc": "2026-10-13T19:59:04.703467+00:00", + "coordination": "No pinned sprint issue at entry; local claim under user instructions. Read discussions 1163/1166/1167 and open PRs through 1196.", + "outcome": { + "status": "independent finite bit-circuit construction", + "selected_baseline_ADDs": 24305, + "prior973_ADDs": 24285, + "candidate_ADDs": 24283, + "new_kappa": false, + "method": "One exact four-gate to three-gate Boolean identity on the PR973 frame-509 program; all four registers may enter dirty.", + "selected_record_unchanged": true + }, + "exploration": { + "greedy_elimination": { + "seed": 5, + "completed_trajectories": 10000, + "distinct_programs": 9472, + "best_ADDs": 23 + }, + "pivot_elimination": { + "seed": 5, + "completed_trajectories": 10000, + "best_ADDs": 23 + }, + "budget_adjustment": "The initial 10000-trajectory cap was extended once by 10000 pivot-elimination trials after the greedy method failed. Both stopped at the fixed count. One accidental duplicate replay repeated the first domain and added no coverage.", + "development_correction": "An initial greedy prototype allowed an already processed pivot as donor; its exact product self-check rejected the first trial. Restricting donors to remaining pivots fixed it before the reported complete runs.", + "final_identity": "No search optimum claimed; literal PR973 window [7:11] reduced algebraically." + }, + "coordination_result": "DONE locally: independently verified finite construction; result_link identifies the review packet. No pinned sprint issue existed. The user handoff will include the submitted PR URL.", + "overlap_refresh": { + "through_pr": 1213, + "open_pr_count": 822, + "main_unchanged": true, + "PR1208_head": "24c45725f7b9ffca4529b46661acf343ce93cee3", + "same_local_mechanism": true, + "additional_scope": "Original PR589/PR973 words with all H1-H5 and K_equals_D true; isolated 20-ADD witness with independently executed columns, truth tables, source pins and native admission. No novel identity, priority, or ADD-count record claimed." + }, + "assignment_randomness": "secrets.randbelow(100), operating-system CSPRNG", + "seed_drawn_at_utc": "2026-10-13T19:55:42.904624+00:00", + "result_link": "https://github.com/bbMisk/integer-mult-bounds/blob/research/r439-b509-boolean-seed05/research/r439-b509-boolean-seed05/README.md", + "result_checked_at_utc": "2026-10-13T20:19:53.465739+00:00" +} diff --git a/research/r439-b509-boolean-seed05/EXPECTED.json b/research/r439-b509-boolean-seed05/EXPECTED.json new file mode 100644 index 0000000000..2f6273c2f6 --- /dev/null +++ b/research/r439-b509-boolean-seed05/EXPECTED.json @@ -0,0 +1,311 @@ +{ + "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe", + "block_additions": { + "candidate": 20, + "prior973": 21, + "selected": 31 + }, + "boolean_inputs": 2048, + "controls_rejected": [ + "omit_block_ADD_00", + "omit_block_ADD_01", + "omit_block_ADD_02", + "omit_block_ADD_03", + "omit_block_ADD_04", + "omit_block_ADD_05", + "omit_block_ADD_06", + "omit_block_ADD_07", + "omit_block_ADD_08", + "omit_block_ADD_09", + "omit_block_ADD_10", + "omit_block_ADD_11", + "omit_block_ADD_12", + "omit_block_ADD_13", + "omit_block_ADD_14", + "omit_block_ADD_15", + "omit_block_ADD_16", + "omit_block_ADD_17", + "omit_block_ADD_18", + "omit_block_ADD_19", + "restore_old_order_after_deletion", + "stale_cleanup", + "unpaid_frame_descent", + "missing_helper_restoration", + "omitted_ERASE", + "mutate_copied_source", + "F2_identity_precision_overflow" + ], + "four_wire_identity_inputs": 16, + "frame_paths_checked": 661, + "integer_difference_columns": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "new_kappa_claimed": false, + "prefix_binding": { + "K": 4, + "bridges": 18, + "charged_bits": 192, + "envelope": "2^18 * F^5 * B^4", + "source": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "stages": 9 + }, + "status": "PASS_R439_B509_BOOLEAN", + "words": { + "baseline": { + "additions": 24305, + "canonical_word_sha256": "5642fd0e35a1acc11acff8d0c08350c1617e95f310d4d35ad63a651f9eeeba0b", + "columns": 661, + "conclusions": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copies": 9, + "erases": 9, + "forward_positive_bound": 49347, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "moves": 2911, + "nine_stage_bits": 177, + "nine_stage_upper": "117742596540718658156527847560864213734191286190080000", + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "payload_bits": 93, + "payload_upper": "9528119495320518471870892800", + "rank_mass": 5129, + "records": 27234, + "reverse_positive_bound": 1113070 + }, + "candidate": { + "additions": 24283, + "canonical_word_sha256": "8ec11f9c47a82e1a4f512605b0756da1b5ddfbeaf2fc31b45b7984ac4f337a5b", + "columns": 661, + "conclusions": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copies": 9, + "erases": 9, + "forward_positive_bound": 49347, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "moves": 2911, + "nine_stage_bits": 177, + "nine_stage_upper": "115161018575400328364002545203913984951930947169681408", + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "payload_bits": 93, + "payload_upper": "9423085667358616084409488128", + "rank_mass": 5129, + "records": 27212, + "reverse_positive_bound": 1106918 + }, + "prior973": { + "additions": 24285, + "canonical_word_sha256": "5246ef6f5a6f5a284529512635bda8833452161ad78fb6bb8b91977952e24bba", + "columns": 661, + "conclusions": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copies": 9, + "erases": 9, + "forward_positive_bound": 49347, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "moves": 2911, + "nine_stage_bits": 177, + "nine_stage_upper": "115161018575400328364002545203913984951930947169681408", + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "payload_bits": 93, + "payload_upper": "9423085667358616084409488128", + "rank_mass": 5129, + "records": 27214, + "reverse_positive_bound": 1106918 + } + } +} diff --git a/research/r439-b509-boolean-seed05/EXPLORATION.json b/research/r439-b509-boolean-seed05/EXPLORATION.json new file mode 100644 index 0000000000..3fa89c7e66 --- /dev/null +++ b/research/r439-b509-boolean-seed05/EXPLORATION.json @@ -0,0 +1,330 @@ +{ + "claim": "These finite samples found no program shorter than 23; they do not bound the class. The delivered 20-ADD witness is an algebraic rewrite of PR973.", + "greedy": { + "distinct": 9472, + "hist": { + "23": 9, + "24": 9, + "25": 12, + "26": 30, + "27": 40, + "28": 61, + "29": 101, + "30": 155, + "31": 179, + "32": 210, + "33": 274, + "34": 357, + "35": 398, + "36": 432, + "37": 462, + "38": 550, + "39": 492, + "40": 442, + "41": 471, + "42": 402, + "43": 460, + "44": 534, + "45": 692, + "46": 731, + "47": 618, + "48": 474, + "49": 417, + "50": 285, + "51": 181, + "52": 146, + "53": 110, + "54": 72, + "55": 51, + "56": 38, + "57": 29, + "58": 20, + "59": 16, + "60": 10, + "61": 5, + "62": 7, + "63": 4, + "64": 4, + "65": 2, + "66": 4, + "68": 1, + "69": 1, + "71": 1, + "75": 1 + }, + "ops": [ + [ + 8, + 5 + ], + [ + 8, + 7 + ], + [ + 4, + 6 + ], + [ + 8, + 4 + ], + [ + 8, + 3 + ], + [ + 1, + 9 + ], + [ + 0, + 8 + ], + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 5, + 0 + ], + [ + 6, + 0 + ], + [ + 10, + 3 + ], + [ + 7, + 2 + ], + [ + 3, + 2 + ], + [ + 2, + 8 + ], + [ + 8, + 1 + ], + [ + 1, + 9 + ], + [ + 4, + 0 + ], + [ + 2, + 9 + ], + [ + 9, + 2 + ], + [ + 3, + 0 + ], + [ + 7, + 0 + ], + [ + 10, + 9 + ] + ], + "wires": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92, + 468 + ] + }, + "random_pivots": { + "hist": { + "23": 4, + "24": 5, + "25": 24, + "26": 23, + "27": 47, + "28": 65, + "29": 81, + "30": 147, + "31": 220, + "32": 327, + "33": 358, + "34": 390, + "35": 339, + "36": 326, + "37": 333, + "38": 372, + "39": 397, + "40": 368, + "41": 382, + "42": 366, + "43": 305, + "44": 328, + "45": 341, + "46": 292, + "47": 332, + "48": 347, + "49": 362, + "50": 346, + "51": 332, + "52": 293, + "53": 318, + "54": 312, + "55": 285, + "56": 248, + "57": 206, + "58": 154, + "59": 150, + "60": 121, + "61": 80, + "62": 71, + "63": 61, + "64": 33, + "65": 27, + "66": 25, + "67": 18, + "68": 17, + "69": 9, + "70": 8, + "71": 1, + "72": 1, + "73": 1, + "75": 1, + "80": 1 + }, + "ops": [ + [ + 8, + 3 + ], + [ + 10, + 3 + ], + [ + 7, + 2 + ], + [ + 9, + 2 + ], + [ + 0, + 2 + ], + [ + 3, + 2 + ], + [ + 8, + 9 + ], + [ + 10, + 9 + ], + [ + 4, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 2, + 8 + ], + [ + 9, + 8 + ], + [ + 0, + 8 + ], + [ + 10, + 8 + ], + [ + 8, + 1 + ], + [ + 0, + 1 + ], + [ + 7, + 0 + ], + [ + 5, + 0 + ], + [ + 4, + 0 + ], + [ + 6, + 0 + ], + [ + 3, + 0 + ] + ], + "regs": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92, + 468 + ], + "trial": 1978 + }, + "runs_per_method": 10000, + "seed": 5 +} diff --git a/research/r439-b509-boolean-seed05/NATIVE.json b/research/r439-b509-boolean-seed05/NATIVE.json new file mode 100644 index 0000000000..dc2cbc12e7 --- /dev/null +++ b/research/r439-b509-boolean-seed05/NATIVE.json @@ -0,0 +1,2173 @@ +{ + "distinct_omitted_bridge_controls": 144, + "expected_python_receipt_sha256": "1c1db9ab4e08ab76c4fafb984fbebe851225a8228df04fd91edf0e820c4da948", + "status": "PASS_R439_B509_BOOLEAN_NATIVE", + "words": { + "baseline": { + "columns": { + "columns_h": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121525, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k2": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121525, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k4": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "global_live_registers": 1327, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218745, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k5": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "global_live_registers": 1549, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 267355, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24305, + "containment_pairs_checked": 2386, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2911, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 27234, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + }, + "candidate": { + "columns": { + "columns_h": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121415, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24283, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24283, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k2": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121415, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24283, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24283, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k4": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "global_live_registers": 1327, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24283, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24283, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218547, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k5": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "global_live_registers": 1549, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24283, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24283, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 267113, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24283, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24283, + "containment_pairs_checked": 2386, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2911, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 27212, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + }, + "prior973": { + "columns": { + "columns_h": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121425, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24285, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24285, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k2": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121425, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24285, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24285, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k4": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "global_live_registers": 1327, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24285, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24285, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218565, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns_k5": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "global_live_registers": 1549, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24285, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24285, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9423085667358616084409488128", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1106918", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 267135, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24285, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24285, + "containment_pairs_checked": 2386, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2911, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 27214, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + } + } +} diff --git a/research/r439-b509-boolean-seed05/NOTICE.md b/research/r439-b509-boolean-seed05/NOTICE.md new file mode 100644 index 0000000000..8f857b7ee0 --- /dev/null +++ b/research/r439-b509-boolean-seed05/NOTICE.md @@ -0,0 +1,35 @@ +# Attribution and license + +Hanson Sun (@bbMisk), with substantial OpenAI Codex assistance in research, +implementation, verification and writing. No independent human review is +claimed. New material is Apache-2.0, under the repository's `../../LICENSE`. + +This construction changes one four-gate window of Cinna Davis +(@1337isnot1337)'s PR973 frame-509 program. Aaron Wang (@navinor)'s PR1015 +independently reaches the same prior block length, and his PR1127 uses the +related Boolean triangle identity on the original word. Dugongue's +PR541/PR548 and DreamingOfClouds' PR589 tuner are earlier sources for these +move families. The identity itself is not claimed as new. + +ToikY's concurrent PR1208 independently applies the same cancellation to +PR1015's block in the composed PR1122 word, also reaching 20 block ADDs. +It appeared during this package's verification and is credited without a +priority claim. This package's additional scope is the original H1–H5 +interface on the selected/PR973 lineage. + +DreamingOfClouds' PR589 tuning of eumemic's PR555 supplies the frozen R439 +word and interface checker, with the retained PR543/PR545/PR510 ancestry. +The preceding frame-509 source-sharing result is Anudeep Adiraju's PR843. +Their original notices remain unchanged. + +The native harness adapts Cinna Davis's PR973 harness, itself adapted from +Jerry Chen (@CubeJerry)'s PR906 package. The independent scalar receipt +conventions also follow Gareth Davidson (@bitplane)'s six-wire Boolean +package. Dylan Crow authored the retained exporter/native interfaces with +Anthropic Claude assistance; DaysSky supplied the generalized bridged-stage +schedule. Zhihao Chen, eumemic, DreamingOfClouds and Chafik Boukhalfa are +credited in the unchanged global compiler source. All source-local notices +and licenses are retained. + +Only the new scoped research directory is changed. No predecessor artifact, +`upstream/` file, selected record, or review disposition is edited. diff --git a/research/r439-b509-boolean-seed05/OVERLAP1127.json b/research/r439-b509-boolean-seed05/OVERLAP1127.json new file mode 100644 index 0000000000..9d64332f5f --- /dev/null +++ b/research/r439-b509-boolean-seed05/OVERLAP1127.json @@ -0,0 +1,166 @@ +{ + "pr": 1127, + "author": "Aaron Wang (@navinor)", + "head": "2e9dc9d3356a6b7258ed869ddcee46352907f746", + "source_path": "research/r439-z3to2-seed13/CANDIDATE-WORD.json", + "source_sha256": "8aedb3be192baae884c80a2ff3d15d9f32ae8c8055dff170bebca2f87e75539a", + "source_git_blob": "0dcb80c50baa842e1a5dc72c94b7c2d4497d2652", + "gates": [ + [ + 509, + 92, + [ + 22 + ] + ], + [ + 509, + 87, + [ + 92 + ] + ], + [ + 509, + 87, + [ + 67 + ] + ], + [ + 509, + 87, + [ + 38 + ] + ], + [ + 509, + 87, + [ + 60 + ] + ], + [ + 509, + 87, + [ + 50 + ] + ], + [ + 509, + 87, + [ + 77 + ] + ], + [ + 509, + 92, + [ + 33 + ] + ], + [ + 509, + 77, + [ + 87 + ] + ], + [ + 509, + 77, + [ + 17 + ] + ], + [ + 509, + 17, + [ + 33 + ] + ], + [ + 509, + 92, + [ + 87 + ] + ], + [ + 509, + 468, + [ + 92 + ] + ], + [ + 509, + 468, + [ + 38 + ] + ], + [ + 509, + 38, + [ + 33 + ] + ], + [ + 509, + 17, + [ + 87 + ] + ], + [ + 509, + 67, + [ + 17 + ] + ], + [ + 509, + 50, + [ + 67 + ] + ], + [ + 509, + 60, + [ + 17 + ] + ], + [ + 509, + 33, + [ + 87 + ] + ], + [ + 509, + 33, + [ + 22 + ] + ], + [ + 509, + 38, + [ + 17 + ] + ] + ], + "block_ADDs": 22, + "scope": "Same frame-509 F2 block only. No full-word composition, paid-profile transfer or additive global saving claimed." +} diff --git a/research/r439-b509-boolean-seed05/OVERLAP1208.json b/research/r439-b509-boolean-seed05/OVERLAP1208.json new file mode 100644 index 0000000000..d36e90becc --- /dev/null +++ b/research/r439-b509-boolean-seed05/OVERLAP1208.json @@ -0,0 +1,152 @@ +{ + "pr": 1208, + "author": "ToikY, with substantial OpenAI Codex assistance", + "head": "24c45725f7b9ffca4529b46661acf343ce93cee3", + "source_path": "research/r439-abc-zrewrite-seed16/CANDIDATE-WORD.json", + "source_sha256": "66b34404f39f5f612c2aaadd53ae33eb9f5993ec2065c82e23d7467cce03a226", + "source_git_blob": "83fb8ef2286a9aafaff7b5db4386ea65a07126a9", + "gates": [ + [ + 509, + 87, + [ + 77 + ] + ], + [ + 509, + 87, + [ + 38 + ] + ], + [ + 509, + 77, + [ + 33 + ] + ], + [ + 509, + 87, + [ + 22 + ] + ], + [ + 509, + 87, + [ + 50 + ] + ], + [ + 509, + 87, + [ + 92 + ] + ], + [ + 509, + 87, + [ + 60 + ] + ], + [ + 509, + 87, + [ + 67 + ] + ], + [ + 509, + 468, + [ + 38 + ] + ], + [ + 509, + 38, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 87 + ] + ], + [ + 509, + 17, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 22 + ] + ], + [ + 509, + 92, + [ + 33 + ] + ], + [ + 509, + 38, + [ + 17 + ] + ], + [ + 509, + 67, + [ + 17 + ] + ], + [ + 509, + 77, + [ + 17 + ] + ], + [ + 509, + 60, + [ + 17 + ] + ], + [ + 509, + 468, + [ + 92 + ] + ], + [ + 509, + 50, + [ + 67 + ] + ] + ], + "block_ADDs": 20, + "scope": "Same local mechanism and 20-ADD block bound, independently corroborated on a different full word. This package retains the original H1-H5 and tests the selected/PR973 lineage. No priority or smaller block claim." +} diff --git a/research/r439-b509-boolean-seed05/README.md b/research/r439-b509-boolean-seed05/README.md new file mode 100644 index 0000000000..18030e62bc --- /dev/null +++ b/research/r439-b509-boolean-seed05/README.md @@ -0,0 +1,158 @@ +# R439 frame 509: 21 ADDs become 20 + +**Independent finite bit-circuit construction; no new κ.** One Boolean cancellation +shortens Cinna Davis's reviewed PR973 block from 21 to 20 ADDs. Paying the +literal reverse cleanup saves two complete local ADDs beyond PR973, or 22 +against the selected PR589 word. No helper, source access, frame adapter, +COPY or recursive child is added. All eleven block inputs, including helper +468, are arbitrary. + +Concurrent **PR1208 uses the same local cancellation and also reaches 20** +on the composed PR1122 word. This package independently realizes it on the +reviewed PR973/selected PR589 lineage, preserving the original H1–H5 and +`K_equals_D` without a changed D interface. No priority or ADD-count record +is claimed. + +| Complete local quantity | Selected PR589 | Reviewed PR973 | This candidate | +|---|---:|---:|---:| +| Frame-509 B ADDs | 31 | 21 | **20** | +| All ADDs, including D, scatter and C | 24,305 | 24,285 | **24,283** | +| Exported records | 27,234 | 27,214 | **27,212** | +| MOVEs / COPYs / ERASEs | 2,911 / 9 / 9 | same | same | +| Paid rank mass | 5,129 | 5,129 | 5,129 | +| Positive forward envelope F | 49,347 | 49,347 | 49,347 | +| Positive reverse envelope B | 1,113,070 | 1,106,918 | 1,106,918 | +| Sufficient local / nine-stage bits | 93 / 177 | 93 / 177 | 93 / 177 | +| Charged local / nine-stage bits | 104 / 192 | 104 / 192 | 104 / 192 | + +The unchanged paid profile is +`{1:1323,2:1342,3:79,4:44,5:102,6:11,7:19}`. This is a scalar circuit +saving, with no improvement to the recursive moment. At base +`1b59b624d21924f8e3537cdc1ac52d3be6eda2fe`, the selected conditional κ is +`836330098538459/500000000000000000`; the complex supplier binds. + +## Reproduce + +From the repository root, Python 3.11+ and the standard library: + +```sh +python3 -I -B research/r439-b509-boolean-seed05/verify.py +python3 -I -B research/r439-b509-boolean-seed05/test_package.py -v +``` + +Expected verifier marker: + +```text +PASS_R439_B509_BOOLEAN gates=31/21->20 ADDs=24305/24285->24283 columns=661 truth_table=2048 H1-H5 controls=27 no_new_kappa +``` + +For the unchanged C++17/Boost legality and 5/9/11-stage column checkers: + +```sh +BOOST_INCLUDE=/path/to/boost-headers python3 -I -B research/r439-b509-boolean-seed05/native.py +``` + +Expected: `PASS_R439_B509_BOOLEAN_NATIVE words=3 columns=883/1327/1549 +bridge_controls=144 five_stage_regression=PASS`. `CXX` selects the compiler. +On systems with Boost under `/usr/include`, `BOOST_INCLUDE` can be omitted. +`--output /absolute/new/directory` retains generated words and logs; existing +destinations are refused. `--write-expected` is an explicit development option, +not the reproduction command. Decoded candidate fields and deterministic +receipts are compared, not regenerated gzip container bytes. + +## Exact identity and splice + +Use the original eleven physical registers +`[17,22,33,38,50,60,67,77,87,92,468]`, all at frame 509 for this block. +In PR973 gates `[7:11]`, set `a=x33`, `b=x38`, `h=x468`, `c=x77`. +Replace the left program by the right: + +```text +old (4 ADDs) new (3 ADDs) +b ^= a h ^= b +h ^= a b ^= a +c ^= a c ^= a +h ^= b +``` + +Over F₂, both endpoints are exactly + +```text +(a, b, h, c) -> (a, b + a, h + b, c + a). +``` + +This holds for arbitrary incoming values; the old helper update is +`h + a + (b + a) = h + b`. Over the integers, the old block map minus the +new block map is **`2 e_468 e_33^T`**. Integer equality is explicitly false; +the test over F₃ rejects it. The replacement is therefore outside PR973's +integer-map-preserving search class. + +Before and after this four-gate window the block is unchanged. The selected +word's `B[283:314]` is replaced by the resulting 20-gate block. C is rebuilt +as the literal reverse of all z-destination A/B gates, at the full frame. +Equality of the F₂ block operators preserves every subsequent observation, +including arbitrary helper dirt. No frame path changes. This argument proves +the local identity; the complete finite checks below bind it to this word. + +## Evidence and boundaries + +The checker independently executes all eleven block columns and all 2,048 +Boolean inputs, checks the exact integer-map difference, and compares all 661 +ordered register frame paths. A set-valued interpreter replays all 661 dirty +columns in both directions for the three words. It checks each COPY/ERASE +lifetime and recomputes both positive envelopes. A separate packed-column +replay checks the original exporter's literal stream and complete invoice. +The unchanged E8 checker verifies H1–H5 and all four interface conclusions. +The nine-stage bound `2^18 F^5 B^4` is bound to the pinned compiler expression. + +All three words pass fresh native 5/9/11-stage checks, with 883/1,327/1,549 +formal columns per stage count and 144 distinct omitted-bridge controls. +The 27 local controls include every single block-ADD omission, a missing +helper restoration, stale cleanup, unpaid frame descent, COPY corruption and +an F₂-identity insertion that exceeds the precision charge. Ten package tests +cover relocated optimized replay, corrupted source, an underbilled receipt, +existing-output preservation and the characteristic-two restriction. +The 14 existing selected-record and finite-bit-contract tests also pass. + +This does not establish a minimum circuit, a practical speedup, a new κ, +hosted-supplier admission, or the full multiplication theorem. No selected +cold replay or hosted emission/owner/invoice/assembly is claimed. The +all-size compiler, mutable-source/common-label realization, whole-call +hosting, precision/tape, recovery and analytic assumptions remain inherited. +Remote CI and human independent review are separate from these local checks. + +## Provenance and overlap + +`SOURCES.json` pins every consumed source by SHA-256 and Git blob, including +PR973 at `c05dc72734c25dd069077157224d4dd30c6e8c19`. The selected bit source +is DreamingOfClouds' PR589 on eumemic's PR555. `CLAIM.json` records OS seed +**5**, the alternatives, bounded experiments and stopping rules. + +The broad greedy and pivot-elimination samples each completed 10,000 trials; +both found at best 23 ADDs. They are failed finite searches, not exclusions. +The delivered witness comes from the displayed algebraic identity applied to +PR973. `EXPLORATION.json` records both samples and `CLAIM.json` records the +one count extension and the rejected development prototype. + +Aaron Wang's pending PR1127 at `2e9dc9d3356a6b7258ed869ddcee46352907f746` +uses the related triangle identity on the original selected word. Its +frame-509 block has 22 ADDs and the same F₂ map; the extracted comparison is +in `OVERLAP1127.json`. This contribution applies that identity family to the +already factored PR973 block and reaches 20. No full-word composition or +addition of independent PR savings is claimed. PR1015 independently reached +21 for this block; PR1062/1122/1188 change other complete words and remain +separate. The identity family predates this contribution. + +The final overlap refresh found ToikY's PR1208 at +`24c45725f7b9ffca4529b46661acf343ce93cee3`. Its sole B rewrite uses the +same three operands `33,38,468`. `OVERLAP1208.json` preserves its 20-gate +block and exact provenance. The two block programs have the same integer +and Boolean endpoints but different literal orders. This independently +corroborates the local mechanism; the additional evidence here covers the +original H1–H5 interface and all three selected/PR973/candidate words. +The composed semantic-D construction's inherited H2/K flags are outside +this package's claims. No PR1208 full-word replay is claimed. + +Prepared by **Hanson Sun (@bbMisk)** with substantial **OpenAI Codex +assistance**. New material is Apache-2.0. See `NOTICE.md` for predecessor and +implementation credit. diff --git a/research/r439-b509-boolean-seed05/SOURCES.json b/research/r439-b509-boolean-seed05/SOURCES.json new file mode 100644 index 0000000000..e54ccb4fd5 --- /dev/null +++ b/research/r439-b509-boolean-seed05/SOURCES.json @@ -0,0 +1,94 @@ +{ + "AI_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing; no human independent review claimed", + "author": "Hanson Sun (@bbMisk)", + "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe", + "files": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": { + "git_blob": "00c5a3a5d81d083582f60f33dd2e7bea5049c37f", + "sha256": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce" + }, + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": { + "git_blob": "42bb232fbec4de703e70cc13dc2f39a3b43a3a01", + "sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2" + }, + "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp": { + "git_blob": "82d69f7c5d044c9887c96b90c97f5639083ecd14", + "sha256": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63" + }, + "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp": { + "git_blob": "cb1233c7e96b1aa8bbf4d2e4165d75ab0dca64b9", + "sha256": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3" + }, + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": { + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + "research/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py": { + "git_blob": "f6d7afe3e623208c4207b6a683a1e3e49249e31c", + "sha256": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a" + }, + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h": { + "git_blob": "fc5664e929d9a81d9b4926bee049a93330be86ec", + "sha256": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99" + }, + "research/e8-bit-p111-tuned/NOTICE.md": { + "git_blob": "b589500c8ae02a0a4c476e61dfdd1b79dcbf7cad", + "sha256": "5b88eb2b7de76aa2a3288ee3c7a08d18a5eadfa82f5e7a99e207d232aed71221" + }, + "research/e8-bit-p111-tuned/code/xcheck_p.py": { + "git_blob": "184f5dcf94a486cc7db91ca4db5865916bf26009", + "sha256": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e" + }, + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": { + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": { + "git_blob": "3df12bd632f1fdba825ced57110a1fee82eb2857", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "research/r439-frame509-seed08/CANDIDATE.json": { + "git_blob": "40a28f124a8561b437f0cc0aefbfb49224dcf3a0", + "sha256": "4c340610fb641a3699224016b4a322005fa9c578d9761b23220b01bc67ab4068" + }, + "research/r439-frame509-seed08/NOTICE.md": { + "git_blob": "a1d170a418cc6684608b2cbc959f7def10b72748", + "sha256": "9c532dd6d908abfe21ed0ea812e0d64d4f85e9a2dc2af6c8d0c048de324dd114" + } + }, + "implementation_lineage": { + "research/r439-frame509-seed08/native.py": { + "git_blob": "248d00e0a8809a2710f2925a5ee787707382ca23", + "sha256": "6419b0c4fb3c965877b26efbbdf5e42d507fe337ddb61b3ae8fc5249db249401" + }, + "research/r439-frame509-seed08/verify.py": { + "git_blob": "d8bb174728adb4b2123d3fa580d302682c9e0ebf", + "sha256": "60583517f44338e8ec228bfa035f56aaba5d17110f9f9ee8d68111d9eb3c279f" + }, + "research/r439-six-wire-boolean/verify.py": { + "git_blob": "3131c9c08ef1f2398267a18b6b5a3ca0da166df1", + "sha256": "85afc79d0a0d6e64f632ecb2f69d1107ddd7a717ecf17665647d5e4caf907148" + } + }, + "license": "Apache-2.0", + "predecessor973": { + "author": "Cinna Davis (@1337isnot1337)", + "head": "c05dc72734c25dd069077157224d4dd30c6e8c19", + "path": "research/r439-frame509-seed08/CANDIDATE.json" + }, + "selected_bit": { + "PR": 589, + "ancestry": [ + 555, + 543, + 545, + 510 + ], + "head": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46" + }, + "selected_context": { + "binding": "complex", + "kappa": "836330098538459/500000000000000000", + "selected_json_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + } +} diff --git a/research/r439-b509-boolean-seed05/VALIDATION.json b/research/r439-b509-boolean-seed05/VALIDATION.json new file mode 100644 index 0000000000..3718151678 --- /dev/null +++ b/research/r439-b509-boolean-seed05/VALIDATION.json @@ -0,0 +1,29 @@ +{ + "boost_cpp_int_sha256": "4099045e8ac3e3507779c08980272b261a86498a23a4d0bb0786849f5424595a", + "byte_order": "little", + "compiler": "Apple clang version 21.0.0 (clang-2100.1.1.101)", + "counts": { + "distinct_bridge_controls": 144, + "existing_tests": 14, + "local_controls": 27, + "native_words": 3, + "package_tests": 10 + }, + "executed_commands": [ + "python3 -I -B research/r439-b509-boolean-seed05/verify.py", + "python3 -I -B research/r439-b509-boolean-seed05/test_package.py -v", + "BOOST_INCLUDE= python3 -I -B research/r439-b509-boolean-seed05/native.py", + "python3 -B -m unittest discover -s tests -p test_finite_bit_contract.py", + "python3 -B -m unittest discover -s tests -p test_selected_result.py" + ], + "not_run": [ + "full hosted supplier emission/admission", + "selected complex cold replay", + "repository-wide suite", + "remote CI", + "formal proof assistant" + ], + "overlap_check": "PR1208 identical local mechanism, same integer/F2 map but different gate order; original H1-H5 lineage independently verified here.", + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]" +} diff --git a/research/r439-b509-boolean-seed05/candidate.json.gz b/research/r439-b509-boolean-seed05/candidate.json.gz new file mode 100644 index 0000000000..6d25b8be2a Binary files /dev/null and b/research/r439-b509-boolean-seed05/candidate.json.gz differ diff --git a/research/r439-b509-boolean-seed05/native.py b/research/r439-b509-boolean-seed05/native.py new file mode 100644 index 0000000000..86956ed776 --- /dev/null +++ b/research/r439-b509-boolean-seed05/native.py @@ -0,0 +1,132 @@ +#!/usr/bin/env python3 +"""Fresh unchanged C++ legality and 5/9/11-stage replays for all three words. + +Adapted from Cinna Davis (@1337isnot1337)'s PR973 harness, which adapts +Jerry Chen (@CubeJerry)'s PR906 native harness. Hanson Sun (@bbMisk). +Substantial OpenAI Codex assistance; Apache-2.0. +""" +import argparse +from concurrent.futures import ThreadPoolExecutor +import hashlib +import json +import os +from pathlib import Path +import platform +import shlex +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BIT = ROOT / 'research/e8-bit-carrier-skeleton/code/bit' + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def run(command, logfile): + result = subprocess.run([str(x) for x in command], capture_output=True, text=True) + logfile.write_text(result.stdout + result.stderr) + need(result.returncode == 0, 'command failed; see ' + str(logfile)) + return result.stdout + + +def native(output, compiler, boost): + output.mkdir(parents=True, exist_ok=False) + command = [sys.executable, '-I', '-B', HERE / 'verify.py', '--output', output / 'python'] + run(command, output / 'python.log') + reference = json.loads((output / 'python/RESULT.json').read_text()) + includes = ['-I' + str(BIT / 'checkers'), '-I' + str(boost), + '-I' + str(ROOT / 'research/e8-bit-carrier-skeleton/portable-include')] + common = compiler + ['-O2', '-std=c++17', '-DHDIM=8', '-DNCOPY=9', + '-DVPORTS=111', '-DRHELP=439'] + includes + configurations = [('legality', 'legality_h.cpp', []), + ('columns_h', 'columns_h.cpp', [])] + [ + ('columns_k' + str(k), 'columns_k.cpp', ['-DKPAIRS=' + str(k)]) for k in (2, 4, 5)] + + def compile_one(config): + name, source, flags = config + run(common + flags + [BIT / 'checkers' / source, '-o', output / name], + output / ('compile-' + name + '.log')) + + with ThreadPoolExecutor(max_workers=2) as pool: + list(pool.map(compile_one, configurations)) + summary = {} + for name in ('baseline', 'prior973', 'candidate'): + record_dir = output / 'python' / (name + '-records') + cin, cout = output / (name + '-in'), output / (name + '-out') + run([sys.executable, '-I', '-B', BIT / 'regression/stage_cohort.py', + record_dir, record_dir, cin, cout], output / (name + '-stage.log')) + run([output / 'legality', cin, cout, cout / 'legality.json'], + output / (name + '-legality.log')) + legality = json.loads((cout / 'legality.json').read_text()) + py = reference['words'][name] + for field, local in [('common_frame_ADDs', 'additions'), ('rank_mass', 'rank_mass'), + ('nested_MOVEs', 'moves'), ('copies', 'copies'), ('records', 'records')]: + need(legality[field] == py[local], 'native legality mismatch: ' + field) + need({str(k): v for k, v in legality['paid_histogram']} == py['paid_profile'], + 'native paid profile mismatch') + columns = {} + for binary, _, _ in configurations[1:]: + receipt = cout / (binary + '.json') + run([output / binary, cout / 'COHORT249-RECORDS.bin', receipt], + output / (name + '-' + binary + '.log')) + data = json.loads(receipt.read_text()) + need(data['local_scalar_additions'] == py['additions'], 'native ADD mismatch') + need(data['payload_prefix_upper'] == py['payload_upper'], 'native payload mismatch') + need(data['payload_prefix_bits'] == py['payload_bits'], 'native payload bits mismatch') + bounds = [int(x['cancellation_free_signed_row_l1_upper']) + for x in data['signed_lift_prefix']] + need(bounds == [py['forward_positive_bound'], py['reverse_positive_bound']], + 'native positive prefix mismatch') + need({str(k): v for k, v in data['local_raw_H']} == py['paid_profile'], + 'native column profile mismatch') + expected_columns = {'columns_h': 883, 'columns_k2': 883, + 'columns_k4': 1327, 'columns_k5': 1549}[binary] + need(data['formal_columns_checked'] == expected_columns, 'native coverage mismatch') + expected_controls = {'columns_h': 6, 'columns_k2': 6, + 'columns_k4': 18, 'columns_k5': 24}[binary] + need(len(data['negative_controls']) == expected_controls and + all(x['rejected'] for x in data['negative_controls']), 'bridge control failure') + data.pop('seconds') + data.pop('local_scalar_stream') + columns[binary] = data + need(columns['columns_h'] == columns['columns_k2'], 'five-stage regression mismatch') + summary[name] = {'legality': legality, 'columns': columns} + result = {'status': 'PASS_R439_B509_BOOLEAN_NATIVE', 'words': summary, + 'distinct_omitted_bridge_controls': 144, + 'expected_python_receipt_sha256': hashlib.sha256((HERE / 'EXPECTED.json').read_bytes()).hexdigest()} + (output / 'NATIVE.json').write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + environment = {'python': sys.version, 'platform': platform.platform(), + 'compiler': run(compiler + ['--version'], output / 'compiler.log').splitlines()[0], + 'boost_cpp_int_sha256': hashlib.sha256( + (boost / 'boost/multiprecision/cpp_int.hpp').read_bytes()).hexdigest()} + (output / 'ENVIRONMENT.json').write_text(json.dumps(environment, sort_keys=True, indent=2) + '\n') + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', type=Path, help='fresh directory; default temporary') + parser.add_argument('--cxx', default=os.environ.get('CXX', 'c++')) + parser.add_argument('--boost-include', type=Path, + default=Path(os.environ.get('BOOST_INCLUDE', '/usr/include'))) + parser.add_argument('--write-expected', action='store_true', help='explicit receipt regeneration') + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix='r439-frame509-native-') as temporary: + result = native(args.output or Path(temporary) / 'replay', shlex.split(args.cxx), + args.boost_include) + expected = HERE / 'NATIVE.json' + if args.write_expected: + expected.write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + else: + need(result == json.loads(expected.read_text()), 'committed native receipt mismatch') + print('PASS_R439_B509_BOOLEAN_NATIVE words=3 columns=883/1327/1549 ' + 'bridge_controls=144 five_stage_regression=PASS') + + +if __name__ == '__main__': + main() diff --git a/research/r439-b509-boolean-seed05/test_package.py b/research/r439-b509-boolean-seed05/test_package.py new file mode 100644 index 0000000000..782c0c67e1 --- /dev/null +++ b/research/r439-b509-boolean-seed05/test_package.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 +"""Source/certificate controls and relocated optimized replay. Apache-2.0. + +Hanson Sun (@bbMisk), with substantial OpenAI Codex assistance. +""" +import copy +import importlib.util +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("b509_verifier", HERE / "verify.py") +V = importlib.util.module_from_spec(spec) +spec.loader.exec_module(V) + + +class PackageTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temporary = tempfile.TemporaryDirectory(prefix="b509 package space ") + cls.root = Path(cls.temporary.name) / "source root" + cls.package = cls.root / "research/r439-b509-boolean-seed05" + shutil.copytree(HERE, cls.package, ignore=shutil.ignore_patterns("__pycache__")) + for name in V.SOURCE_PATHS: + target = cls.root / name + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(V.ROOT / name, target) + cls.receipt = V.load(HERE / "EXPECTED.json") + cls.base = V.load(V.ROOT / V.WORD) + cls.prior = V.load(V.ROOT / V.PRIOR)["gates"] + cls.gates = V.load(HERE / "CANDIDATE.json")["gates"] + cls.candidate = V.replace(cls.base, cls.gates) + + @classmethod + def tearDownClass(cls): + cls.temporary.cleanup() + + def command(self, *args): + return subprocess.run([sys.executable, "-I", "-O", "-B", self.package / "verify.py", *args], + cwd=self.temporary.name, capture_output=True, text=True) + + def test_01_relocated_optimized_receipt(self): + out = Path(self.temporary.name) / "relocated output" + result = self.command("--output", str(out)) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertEqual(V.load(out / "RESULT.json"), self.receipt) + + def test_02_corrupted_source_rejected(self): + path = self.root / V.WORD + raw = path.read_bytes() + try: + path.write_bytes(raw + b"corrupted") + result = self.command() + self.assertNotEqual(result.returncode, 0) + self.assertIn("source SHA256", result.stderr) + finally: + path.write_bytes(raw) + + def test_03_candidate_receipt_cannot_underbill(self): + path = self.package / "EXPECTED.json" + raw = path.read_bytes() + bad = copy.deepcopy(self.receipt) + bad["words"]["candidate"]["additions"] -= 1 + try: + V.write(path, bad) + result = self.command() + self.assertNotEqual(result.returncode, 0) + self.assertIn("receipt mismatch", result.stderr) + finally: + path.write_bytes(raw) + + def test_04_preserve_existing_output(self): + output = Path(self.temporary.name) / "existing output" + output.mkdir() + sentinel = output / "sentinel" + sentinel.write_text("preserve me") + result = self.command("--output", str(output)) + self.assertNotEqual(result.returncode, 0) + self.assertIn("output already exists", result.stderr) + self.assertEqual(sentinel.read_text(), "preserve me") + self.assertEqual(list(output.iterdir()), [sentinel]) + + def test_05_dirty_helper_is_arbitrary(self): + # All incoming helper values are preserved with the same increment. + for dirty in (0, 1): + for source in (0, 1): + values = {w: dirty if w == 468 else source if w == 33 else 0 for w in V.WIRES} + result = [] + for gates in (self.base["B"][283:314], self.gates): + state = dict(values) + for d, s in V.operations(gates): + state[d] ^= state[s] + result.append(state) + self.assertEqual(*result) + self.assertEqual(result[0][468], dirty ^ source) + + def test_06_integer_equality_is_false(self): + self.assertNotEqual(V.column_map(self.prior), V.column_map(self.gates)) + self.assertEqual(V.column_map(self.prior, 2), V.column_map(self.gates, 2)) + self.assertNotEqual(V.column_map(self.prior, 3), V.column_map(self.gates, 3)) + + def test_07_typed_and_foreign_operands(self): + for invalid in ([True, 38, [33]], [509, True, [33]], + [509, 38, [True]], [509, 38, [660]], [509, 38, [38]]): + with self.assertRaises(ValueError): + V.operations([invalid]) + + def test_08_duplicate_json_key(self): + with self.assertRaises(ValueError): + json.loads('{"frame":509,"frame":0}', object_pairs_hook=V.strict_pairs) + + def test_09_positive_growth_guard_is_not_f2_equality(self): + # A two-gate square is identity mod 2 but changes the positive matrix. + extra = [[509, 38, [33]], [509, 38, [33]]] + self.assertEqual(V.column_map(self.gates, 2), V.column_map(self.gates + extra, 2)) + self.assertNotEqual(V.column_map(self.gates), V.column_map(self.gates + extra)) + + def test_10_concurrent_block_comparisons(self): + earlier = V.load(HERE / "OVERLAP1127.json") + same_mechanism = V.load(HERE / "OVERLAP1208.json") + self.assertEqual(len(earlier["gates"]), 22) + self.assertEqual(len(same_mechanism["gates"]), 20) + for item in (earlier, same_mechanism): + self.assertEqual(V.column_map(item["gates"], 2), V.column_map(self.gates, 2)) + self.assertEqual(V.column_map(same_mechanism["gates"]), V.column_map(self.gates)) + self.assertNotEqual(same_mechanism["gates"], self.gates) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/r439-b509-boolean-seed05/verify.py b/research/r439-b509-boolean-seed05/verify.py new file mode 100644 index 0000000000..ad30da6161 --- /dev/null +++ b/research/r439-b509-boolean-seed05/verify.py @@ -0,0 +1,415 @@ +#!/usr/bin/env python3 +"""Finite frame-509 Boolean splice; no supplier adoption or kappa claim. + +Hanson Sun (@bbMisk), substantial OpenAI Codex assistance. Apache-2.0. +Scalar receipt conventions follow Cinna Davis PR973 / Jerry Chen PR906 and +Gareth Davidson's six-wire Boolean package. Their implementations are not +imported. The original E8 checker and exporter are run unchanged and pinned. +""" +import argparse +import ast +from collections import Counter +import copy +import gzip +import hashlib +import json +from pathlib import Path +import struct +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe" +WORD = "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz" +PRIOR = "research/r439-frame509-seed08/CANDIDATE.json" +CHECKER = "research/e8-bit-p111-tuned/code/xcheck_p.py" +BIT = "research/e8-bit-carrier-skeleton/code/bit" +EXPORTER = BIT + "/export_records.py" +START, STOP, FRAME = 283, 314, 509 +WIRES = [17, 22, 33, 38, 50, 60, 67, 77, 87, 92, 468] +SOURCE_PATHS = { + WORD, PRIOR, CHECKER, EXPORTER, BIT + "/regression/stage_cohort.py", + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h", + *(BIT + "/checkers/" + name for name in + ("legality_h.cpp", "columns_h.cpp", "columns_k.cpp", "json.hpp")), + "research/r439-frame509-seed08/NOTICE.md", + "research/e8-bit-p111-tuned/NOTICE.md", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/" + "e8-r715-eleven-stage-whole/code/global_k.py", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def strict_pairs(items): + result = {} + for key, value in items: + need(key not in result, "duplicate JSON key: " + key) + result[key] = value + return result + + +def load(path): + raw = Path(path).read_bytes() + if str(path).endswith(".gz"): + raw = gzip.decompress(raw) + return json.loads(raw, object_pairs_hook=strict_pairs, + parse_constant=lambda x: (_ for _ in ()).throw(ValueError(x))) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode() + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def write(path, value): + Path(path).write_text(json.dumps(value, sort_keys=True, indent=2, allow_nan=False) + "\n") + + +def pins(root): + manifest = load(HERE / "SOURCES.json") + need(manifest["base_commit"] == BASE, "base pin") + need(set(manifest["files"]) == SOURCE_PATHS, "source inventory") + for name, item in manifest["files"].items(): + raw = (root / name).read_bytes() + need(hashlib.sha256(raw).hexdigest() == item["sha256"], "source SHA256: " + name) + header = ("blob " + str(len(raw)) + "\0").encode() + need(hashlib.sha1(header + raw).hexdigest() == item["git_blob"], "source Git blob: " + name) + return manifest + + +def operations(gates): + out = [] + for gate in gates: + need(type(gate) is list and len(gate) == 3, "gate shape") + frame, dst, srcs = gate + need(type(frame) is int and frame == FRAME, "block frame") + need(type(dst) is int and dst in WIRES, "block destination") + need(type(srcs) is list and len(srcs) == 1 and type(srcs[0]) is int + and srcs[0] in WIRES and dst != srcs[0], "block source") + out.append((dst, srcs[0])) + return out + + +def column_map(gates, modulus=None): + # Scalar unit inputs, independent of the discovery's packed-row matrices. + ops = operations(gates) + columns = [] + for initial in WIRES: + values = {w: int(w == initial) for w in WIRES} + for dst, src in ops: + values[dst] += values[src] + if modulus: + values[dst] %= modulus + columns.append([values[w] for w in WIRES]) + return columns + + +def cleanup(word): + v = word["v"] + return [[1, d, list(ss)] for _, d, ss in reversed(word["A"] + word["B"]) + if not v <= d < 2 * v] + + +def replace(base, gates): + word = copy.deepcopy(base) + word["B"][START:STOP] = copy.deepcopy(gates) + word["C"] = cleanup(word) + return word + + +def paths(word): + result = [[f] for f in word["start"]] + for phase in "DABC": + for f, d, ss in word[phase]: + for r in [d, *ss]: + if result[r][-1] != f: + result[r].append(f) + for r, f in enumerate(word["final"]): + if result[r][-1] != f: + result[r].append(f) + return result + + +def splice_check(base, prior_gates, candidate_gates, candidate): + need(len(prior_gates) == 21 and len(candidate_gates) == 20, "gate invoice") + original = base["B"][START:STOP] + need(column_map(original, 2) == column_map(candidate_gates, 2), "Boolean block map") + need(column_map(original) == column_map(prior_gates), "predecessor integer map") + delta = [[x - y for x, y in zip(a, b)] for a, b in + zip(column_map(prior_gates), column_map(candidate_gates))] + expected = [[2 * int(source == 33 and dst == 468) for dst in WIRES] for source in WIRES] + need(delta == expected, "integer-map difference") + need(candidate["C"] == cleanup(candidate), "literal cleanup") + need(paths(candidate) == paths(base), "ordered frame paths") + for key in base: + if key not in ("B", "C"): + need(candidate[key] == base[key], "unrelated word field: " + key) + need(candidate["B"][:START] == base["B"][:START] + and candidate["B"][START + 20:] == base["B"][STOP:], "unrelated B gates") + return delta + + +def scalar_stream(word): + n, v = 2 * word["v"] + word["R"], word["v"] + out = [] + for phase in ("D", "A", "scatter", "B", "C"): + if phase == "scatter": + for j, center in enumerate(word["ret"]): + out.append(("copy", n, center)) + out.extend(("add", v + i, n) for i, ss in enumerate(word["scatter"]) if j in ss) + out.append(("erase", n, center)) + else: + out.extend(("add", d, s) for _, d, ss in word[phase] for s in ss) + return out + + +def scalar_audit(word): + n, v = 2 * word["v"] + word["R"], word["v"] + program = scalar_stream(word) + peaks = [] + for reverse in (False, True): + stream = [("erase" if op == "copy" else "copy" if op == "erase" else op, d, s) + for op, d, s in reversed(program)] if reverse else program + values = [{i} for i in range(n)] + [set()] + positive = [1] * n + [0] + peak = 1 + for op, d, s in stream: + if op == "add": + values[d].symmetric_difference_update(values[s]) + positive[d] += positive[s] + elif op == "copy": + need(not values[d], "COPY temporary live") + values[d] = set(values[s]) + positive[d] = positive[s] + else: + need(values[d] == values[s], "ERASE copy changed") + values[d] = set() + positive[d] = 0 + peak = max(peak, positive[d]) + expected = [{i, i - v} if v <= i < 2 * v else {i} for i in range(n)] + [set()] + need(values == expected, "dirty endpoint") + peaks.append(peak) + f, b = peaks + local, nine = 64 * f**3 * b**2, (1 << 18) * f**5 * b**4 + need(local < 1 << 104 and nine < 1 << 192, "precision ceilings") + return {"additions": sum(op == "add" for op, _, _ in program), "columns": n, + "forward_positive_bound": f, "reverse_positive_bound": b, + "payload_upper": str(local), "payload_bits": local.bit_length(), + "nine_stage_upper": str(nine), "nine_stage_bits": nine.bit_length()} + + +def prefix_binding(root): + # Bind the inherited scalar envelope to its pinned source expression. + source = next(path for path in SOURCE_PATHS if path.endswith("/global_k.py")) + tree = ast.parse((root / source).read_text()) + expression = ast.dump(ast.parse("(1 << nb) * cf**(K+1) * cb**K", mode="eval").body) + need(any(isinstance(node, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "prefix" for t in node.targets) + and ast.dump(node.value) == expression for node in ast.walk(tree)), "prefix source expression") + bridge = ast.dump(ast.parse("nb == 6*(K-1)", mode="eval").body) + need(any(ast.dump(term) == bridge for node in ast.walk(tree) if isinstance(node, ast.Assert) + for term in ast.walk(node.test)), "prefix bridge source") + return {"source": source, "stages": 9, "K": 4, "bridges": 18, + "envelope": "2^18 * F^5 * B^4", "charged_bits": 192} + + +def run(command, path): + result = subprocess.run([str(x) for x in command], capture_output=True, text=True) + path.write_text(result.stdout + result.stderr) + need(result.returncode == 0, "command failed: " + str(path)) + return result.stdout + + +def exported_audit(records, word): + n, v = 661, 111 + values = [1 << i for i in range(n)] + [0] + profile = Counter() + moved = [[f] for f in word["start"]] + opened = None + counts = Counter() + literal = [] + for op, a, b, c, f, rank in records: + need(type(op) is int and 0 <= op <= 3, "export opcode") + counts[op] += 1 + if op == 0: + need(0 <= a < n and 0 <= f <= 8, "MOVE range") + if f: + profile[f] += 1 + # exporter a,b,c encode register/from/to; f is rank difference + need(moved[a][-1] == b, "MOVE origin") + moved[a].append(c) + elif op == 1: + need(0 <= a < n and 0 <= b <= n and a != b and c == 1, "ADD operands") + need(a != opened and (b < n or opened is not None), "COPY source/temporary use") + values[a] ^= values[b] + literal.append(("add", a, b)) + elif op == 2: + need(opened is None and 0 <= a < n and b == n and rank == 7, "COPY lifecycle/rank") + opened = a + values[n] = values[a] + profile[rank] += 1 + literal.append(("copy", n, a)) + else: + need(opened == a and b == n and values[n] == values[a], "ERASE lifecycle") + opened = None + values[n] = 0 + literal.append(("erase", n, a)) + need(opened is None and counts[2] == counts[3] == 9, "COPY count/closure") + need(literal == scalar_stream(word), "literal exported stream") + need(values == [(1 << i) ^ ((1 << (i-v)) if v <= i < 2*v else 0) + for i in range(n)] + [0], "exported endpoint") + need(moved == paths(word), "exported MOVE paths") + return {"records": len(records), "moves": counts[0], "copies": counts[2], + "erases": counts[3], "paid_profile": {str(k): v for k, v in sorted(profile.items())}, + "rank_mass": sum(k * v for k, v in profile.items())} + + +def negative_controls(base, prior, gates, candidate, records): + rejected = [] + + def reject(name, action, reason): + try: + action() + except ValueError as exc: + need(reason in str(exc), "wrong rejection for " + name + ": " + str(exc)) + rejected.append(name) + else: + raise ValueError("control accepted: " + name) + + target = column_map(base["B"][START:STOP], 2) + for i in range(20): + bad = gates[:i] + gates[i+1:] + reject("omit_block_ADD_%02d" % i, + lambda bad=bad: need(column_map(bad, 2) == target, "Boolean block map"), "Boolean block map") + bad = copy.deepcopy(gates) + bad[7], bad[8] = bad[8], bad[7] + reject("restore_old_order_after_deletion", + lambda: need(column_map(bad, 2) == target, "Boolean block map"), "Boolean block map") + bad_word = copy.deepcopy(candidate) + bad_word["C"] = base["C"] + reject("stale_cleanup", lambda: splice_check(base, prior, gates, bad_word), "literal cleanup") + bad_word2 = copy.deepcopy(candidate) + bad_word2["B"][START][0] = 0 + reject("unpaid_frame_descent", lambda: splice_check(base, prior, gates, bad_word2), "ordered frame paths") + bad_word3 = copy.deepcopy(candidate) + helper_gate = next(i for i, (_, d, _) in enumerate(bad_word3["C"]) if d == 468) + del bad_word3["C"][helper_gate] + reject("missing_helper_restoration", lambda: scalar_audit(bad_word3), "dirty endpoint") + bad_records = [r for r in records if r[0] != 3] + reject("omitted_ERASE", lambda: exported_audit(bad_records, candidate), "COPY lifecycle") + copy_at = next(i for i, r in enumerate(records) if r[0] == 2) + center = records[copy_at][1] + bad_records2 = records[:copy_at+1] + [(1, center, 661, 1, 0, 0)] + records[copy_at+1:] + reject("mutate_copied_source", lambda: exported_audit(bad_records2, candidate), "COPY source") + # An even number of ADDs is F2-invisible but must still be billed and priced. + padded = copy.deepcopy(candidate) + huge = [[509, 33, [38]], [509, 38, [33]]] * 180 + padded["B"][START:START] = huge + list(reversed(huge)) + padded["C"] = cleanup(padded) + reject("F2_identity_precision_overflow", lambda: scalar_audit(padded), "precision ceilings") + return rejected + + +def verify(root, output): + pins(root) + prefix = prefix_binding(root) + base = load(root / WORD) + prior_gates = load(root / PRIOR)["gates"] + # The four-gate identity includes the commuting update of source 77. + need(prior_gates[7:11] == [[509, 38, [33]], [509, 468, [33]], + [509, 77, [33]], [509, 468, [38]]], "predecessor window") + derived = prior_gates[:7] + [prior_gates[10], prior_gates[7], prior_gates[9]] + prior_gates[11:] + recipe = load(HERE / "CANDIDATE.json") + need(recipe == {"format": "r439-b509-boolean/1", "base_commit": BASE, + "assignment_seed": 5, "slice": [START, STOP], "frame": FRAME, + "registers": WIRES, "gates": derived}, "candidate recipe") + candidate = replace(base, recipe["gates"]) + prior_word = replace(base, prior_gates) + delta = splice_check(base, prior_gates, derived, candidate) + need(load(HERE / "candidate.json.gz") == candidate, "candidate decoded word") + # Full Boolean truth tables with arbitrary helper 468, no clean input. + old_ops, new_ops = operations(base["B"][START:STOP]), operations(derived) + for assignment in range(1 << len(WIRES)): + results = [] + for ops in (old_ops, new_ops): + state = {w: (assignment >> i) & 1 for i, w in enumerate(WIRES)} + for d, s in ops: + state[d] ^= state[s] + results.append(state) + need(results[0] == results[1], "Boolean truth table") + # Complete four-variable identity (a,b,h,c), including dirty h. + for bits in range(16): + a, b, h, c = [(bits >> i) & 1 for i in range(4)] + old = [a, b ^ a, h ^ a ^ (b ^ a), c ^ a] + new = [a, b ^ a, h ^ b, c ^ a] + need(old == new, "four-wire identity") + output.mkdir(parents=True, exist_ok=False) + reports, record_sets = {}, {} + for name, word in (("baseline", base), ("prior973", prior_word), ("candidate", candidate)): + path = output / (name + ".json.gz") + path.write_bytes(gzip.compress(canonical(word), mtime=0)) + report = scalar_audit(word) + interface_path = output / (name + "-interface.json") + run([sys.executable, "-I", "-B", root / CHECKER, path, "--json", interface_path], + output / (name + "-interface.log")) + interface = load(interface_path) + need(all(interface["hypotheses"].values()) and all(interface["conclusion"].values()), "H1-H5 interface") + need(interface["columns"] == 661 and interface["copy_ranks"] == [7] * 9, + "interface columns/copies") + record_dir = output / (name + "-records") + run([sys.executable, "-I", "-B", root / EXPORTER, path, record_dir], output / (name + "-export.log")) + raw = (record_dir / "249-records.bin").read_bytes() + need(len(raw) % 24 == 0, "record alignment") + records = list(struct.iter_unpack("<6i", raw)) + report.update(exported_audit(records, word)) + report.update({"hypotheses": interface["hypotheses"], "conclusions": interface["conclusion"], + "canonical_word_sha256": hashlib.sha256(canonical(word)).hexdigest()}) + reports[name], record_sets[name] = report, records + for name in ("prior973", "candidate"): + for key in ("moves", "copies", "erases", "paid_profile", "rank_mass", "columns"): + need(reports[name][key] == reports["baseline"][key], "changed paid field: " + key) + # Order within a frame may move identical charged events past ADDs. + need(Counter(r for r in record_sets[name] if r[0] != 1) == + Counter(r for r in record_sets["baseline"] if r[0] != 1), "non-ADD invoice") + need([reports[n]["additions"] for n in reports] == [24305, 24285, 24283], "complete ADD invoice") + need(reports["candidate"]["rank_mass"] == 5129, "paid rank mass") + controls = negative_controls(base, prior_gates, derived, candidate, record_sets["candidate"]) + result = {"status": "PASS_R439_B509_BOOLEAN", "base_commit": BASE, + "block_additions": {"selected": 31, "prior973": 21, "candidate": 20}, + "integer_difference_columns": delta, "boolean_inputs": 2048, + "four_wire_identity_inputs": 16, "frame_paths_checked": 661, + "words": reports, "prefix_binding": prefix, + "controls_rejected": controls, "new_kappa_claimed": False} + write(output / "RESULT.json", result) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + parser.add_argument("--source-root", type=Path, default=ROOT) + parser.add_argument("--write-expected", action="store_true") + args = parser.parse_args() + if args.output: + need(not args.output.exists(), "output already exists") + with tempfile.TemporaryDirectory(prefix="r439-b509-") as temp: + result = verify(args.source_root.resolve(), args.output or Path(temp) / "run") + if args.write_expected: + write(HERE / "EXPECTED.json", result) + else: + need(result == load(HERE / "EXPECTED.json"), "receipt mismatch") + print("PASS_R439_B509_BOOLEAN gates=31/21->20 ADDs=24305/24285->24283 " + "columns=661 truth_table=2048 H1-H5 controls=%d no_new_kappa" % len(result["controls_rejected"])) + + +if __name__ == "__main__": + main()