From 6deda901721316fcb61c6e2a6dd6b537de183452 Mon Sep 17 00:00:00 2001 From: Hanson Sun <182361798+bbMisk@users.noreply.github.com> Date: Tue, 13 Oct 2026 16:21:25 -0400 Subject: [PATCH] Independently realize the 20-ADD R439 frame-509 block under H1-H5 --- .../r439-b509-boolean-seed05/CANDIDATE.json | 165 ++ research/r439-b509-boolean-seed05/CLAIM.json | 57 + .../r439-b509-boolean-seed05/EXPECTED.json | 311 +++ .../r439-b509-boolean-seed05/EXPLORATION.json | 330 +++ research/r439-b509-boolean-seed05/NATIVE.json | 2173 +++++++++++++++++ research/r439-b509-boolean-seed05/NOTICE.md | 35 + .../r439-b509-boolean-seed05/OVERLAP1127.json | 166 ++ .../r439-b509-boolean-seed05/OVERLAP1208.json | 152 ++ research/r439-b509-boolean-seed05/README.md | 158 ++ .../r439-b509-boolean-seed05/SOURCES.json | 94 + .../r439-b509-boolean-seed05/VALIDATION.json | 29 + .../candidate.json.gz | Bin 0 -> 42302 bytes research/r439-b509-boolean-seed05/native.py | 132 + .../r439-b509-boolean-seed05/test_package.py | 135 + research/r439-b509-boolean-seed05/verify.py | 415 ++++ 15 files changed, 4352 insertions(+) create mode 100644 research/r439-b509-boolean-seed05/CANDIDATE.json create mode 100644 research/r439-b509-boolean-seed05/CLAIM.json create mode 100644 research/r439-b509-boolean-seed05/EXPECTED.json create mode 100644 research/r439-b509-boolean-seed05/EXPLORATION.json create mode 100644 research/r439-b509-boolean-seed05/NATIVE.json create mode 100644 research/r439-b509-boolean-seed05/NOTICE.md create mode 100644 research/r439-b509-boolean-seed05/OVERLAP1127.json create mode 100644 research/r439-b509-boolean-seed05/OVERLAP1208.json create mode 100644 research/r439-b509-boolean-seed05/README.md create mode 100644 research/r439-b509-boolean-seed05/SOURCES.json create mode 100644 research/r439-b509-boolean-seed05/VALIDATION.json create mode 100644 research/r439-b509-boolean-seed05/candidate.json.gz create mode 100644 research/r439-b509-boolean-seed05/native.py create mode 100644 research/r439-b509-boolean-seed05/test_package.py create mode 100644 research/r439-b509-boolean-seed05/verify.py 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 0000000000000000000000000000000000000000..6d25b8be2aeab9b8dc7b6d3b17f7ae999b2a090f GIT binary patch literal 42302 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 z zt@fw$_1g*RCoB4yt>}=uEOW`XG*41He<+w1=PTR7?3<@&4v_t%)qk;Dvc2+0+vGfH zoqv%Dc2MN*TMeQa{l>9EY(4K=Cc(Pp`Vl%uf2)!9QY$0b9w{H@YfYl^p3(Ky=J;lB z+;?e~d2d<0?|dp!R&UhIU|V9_?1}d;JM;L9oq5^}uWU2?d8cNdOT>lq38(u`+^NEW zyksVE85Jj(m6P)G1VgLn)pE_2m$ua&>tABK+vde-dWC3&ypvg>evla;#v5MA-#%}ia~cYMA#yZ?R;Uy^%u?Hr|Jj&FTbw-QuD2C zIfiFuhUt;Ke)yXH-D|$}=?nVD{vAHUPruHdul;(-(|&JS#hwNAt@e1!{LBxZ&hS+> zKBFQy8e&>}_B`o7Ww!zwgU`yVmeEIstN&IlwxRx;spBQ9%gm}Wb7=G}|2Xq&*e~=U7edhfCD)g1%Wt;9e^Tvg&%XRcU;J9V>^d8ptTHvw6P4A(2%;LVgjhEf6ec9dQ zWp}GzcDJ(aZlnBzujj*V_)}c_FZtMhWa`R`Rh;dF*AM#Po1f;lYFFnL%lIWj%(qCc zkC+?T?1$G&=I8!P4sy;>xmn16^x6EA`1A2YUZbDBguS*z+x+NzZHd15(vOt|n)N-_ z^FHcHyk*t@Cw}z0`O=eyQNLvU!dLLEV#-gkKzq%%@nR+4S-^ZcTKmM(P~I{%yk%)9 zFPR$7jc>^|&x5L_?3H2PPCs>VD`O96|I3*e_BwC>Z+qXiE6J@~`7izIDmX7pk|_-4 zZGK>01>-;?>x|_&Ix<>)JT?sfyOU%Dxgr?M%-XxRMj8l>R%usPas~xt!9ujMGYQ$aFN1g zG2*WV^42K?26n>M5&EbYXQZuruHV)H>%AY?wIfgMs_INfZj64ztlJdZebaAm)NQ}H zsEzl4j1vqpH!}mGUJ?-;i=E%@_&UAfj+1fDV#6*c98B8loBJDGFu{faJAsGWeIE07 zcG4e#F&lE@f_n*VTefKzuw{4Y;bET#VZ&nX`%KEU*QRaMSi7%E+mvd9gqMci*Ls`(XaUfqF+w=_g7J{?VXV@#oTf$5_W>wyd4Si7u?3bVpJ?) z>uZ(TRfNn9tceealItFnZ6dIFYut(Sw2}a^g8nfS~;jHwe18s z=M{R+8J2^ESXOzbT9fV#Jb~mIZ8<5O(XjfRY5g5l*Mc)lzLnh|-QA(*qOvAdgQcNn zHc2|dbf@?3Ht07NTgTDMYK-M1-)`~5b9IK+wO(-!okfz|pcB(Fz_$n6PZxEKMwdL1 z2V;GTanr_E)O4t}GY8chr@8T0^`+7G$3&oD74Kwl!^c5yUhREpTXj>++*S+~Ym)qF zZ(iGGeQQj$B9Os$4fB9Cchr?y)U;cy-WE>O4fsG-!$VsxJDc8)H&kn6WCNdBBVkFeRS~&v@rZ2Hla}^+Ojx{yRN_uJr8*6 zHzW4yzC!GEQPH%p;9a5F5wEO?F!16KlclrMQL&71?={3I&IIGo%G?!jGnb=Y;`tlNT9`rNe1cBy-qgv)#OdOgMIxy;a*qCv)p-XC!Sj6Q<`m$?RSfL4Y&F=jaYN8vbf=-_J2RA zOxZ7brtf18eqocZs{TpGKrml6D_oj`8mMK!nls-(hI=E%VP$zoST)V8GoM%;v*HUl zW7&Bn>+6inh_=rq!%mkO>2M9d$E--;Tpruq)#?azA8bbNbw*WM-1!UCUCl;cUn>p~ z6mPy)ScGsdV^O6zHV$R8cU=JVwU$udSJc!DuU9>sM!C7wW&#&%WqyE<)hyqf;aw=Z zYoI7=f8WjMzj+ryDWsz2%3_fW?5Xr}6l;Dhl9lx%$0t-LSb>P9YUa#)4AQ{;kW@F< z)&XJtfQXWleLIFx|Dd`ZaKs;ceePC~xBUsu$$z}>Z87GY*^IxQA0EG^&U;1Qg`4`0 zbsg)u9XbS9dTujnLeKQvg^ufPv&Ekt)f z4pChwLq@z_dx>|)nHq**v>iqY1(o1tOGMAg` zR;9C-nms0}ZdIGgd+Rn0%IZ+1^d4c}o37gi_8(Sv%&NLW zqvrzXyQxFZeI?W!OZ8&(4X%1^fgbL!u z&5CCB=QT<~4{mVV>)YKcEIeZ1N42Kp&6r(U!b!G}^r6VR7%{tw`CJEnHuT06w=~qH zR@^7%)xG4It6f|$y5iwBj;cQOE`A>K-*H9enrNVr=iexnJ_2u&GjR2@jjPYP6SiPrsZ*jiV7Yo_oLfcaNcuPO;01e9E8}R9FR8rqNI@$C8*#}~?x$e0ADSM|Ht=>d z^K7_ao<(V14aQjq98v7`P{)DXX<)=S8(v_XjoYXi6Ua>z}dPTy~W^`7HM7L09{eP6K}2o3iUNu-uStuQ)%k(*Q75WT{4O z5?vv(*wUSt5j&9IKiv8al#9wB5n{ z$|whlAYm7ks@tp%DjRf9b&#_OQc{HeGCHV=t|_{MDs)ZJI_k8G>IzJaFcT=rH5?6d0~Pek!>=u-+f4QRv2Qc3=Z5;k4!K~|bPKkAyx}&;F*}Gv&t#=f1`2`D2UcG& z(IZ^<1qhb2m%w!+y0kG2KA0V{Tn zd?+jYw)K4#^*FP>_vIB%V56!Pt#Jzp*5yMs(qW?-lgZ{;&-!dO*af`eTenaUngRPP zAF`>Oa8N8(+evT54fG+|XP4|%&gh4Wz0XFdE_c$&MmRGSE-ULTE))S9GN0rw>UG=0GsDok|^aBPf?Q@R$@63a0 zDeymm!K#x^(UoL9k8ofQv(77svThpv&@Pe@RRn{jZG&Dp=mG4cBNr7r^I-9BbYpYZ zfZ6C8u!3dpp?AcNd}kFM7LAC*S%+khny#Oi)s+M}&YeQYuPS$ew>ZSlY7RIkwiM<) zTL!$sy22^iQQVHPPuqQqQLo_*E^=q^Q_LsaXzrp@yf;u<7AHl3$|m$hgRHybE+!)9 z>&oq%yWq`~mxwa|Tl-fy(rtJ8jB&^KS_h4ixQ*<_eUN*&s?~dyGs4n$aiH%m82SWC zYs4d=BfP3Ft>{w9T$52@Y63{G=8>4GQgoCr*7|R|usN@?Y-hT0={*^3V?uOy?Ac&+ z*BSQZO17m_`f@wbmnU6TdVT3Fd|(9JOzc^vI$f#}VOTZrBKNP*sS9)*y{l6Pd5P); z`9Ut&shkAcl)KRZYLpWm@dd3HdU)w|aqU*Bdv{wkbl4-}4tw@`p_kWzUN-QGRX5P3JsT#cF-+CG{Q>A{*wO(RzrYJ;Qff-q8)8Uof#O z&~aYrVXGtbsK;a15nA_pJnIPkhF*`2oeDjrsCgyU0TZC+xAX(Zt zwVxvORAl5Ub;(ox6M6S`)H8^}-xTjSR;v^4I@^WNCsEjavcsl~A_s;2v-%`%vPWXx z%}sSOR=I{@j$u`JKMM^t!uxG%M|Cem54*?_71S5O$fxSMxUG2=gz4*hB2Ep%C)k&~ z#Ozg6)2!I*5vPZ>96QDIg7PFhVDsR-FO#U@7{&GcO{O}$vF1Uq2EMt_!@wJBB?;pj zDvV=!0==|e+*Tu|P>h%m#@Vd%;3&xjpNw@gb$DjFp+;3m0@uv9R8StmI=H1)pvta{UY3gpJf_V<|W;*t=-b}~uEH{%^U5JCt0k%vt=r_Sv z>x^1G&Yxhvtwq)6=}3%bTV71Y<(>tPYev>{#%0ZV)OiTI%8!hqGOH28(;fiU)CI+M z7f5;+BZs1D={nx7V4whW^ci)fl}`yb81K;fALUf$K~BXrme3rHo^4bUvV!J_v{O+V zf6+N)1O3Z();_48Tea?82D(@Dr1h%4WPgF@aqTmKW=Htd?yE3lXx5RN8PEf>p=XgB ze8k&$!Q&;^K3C{Kw?PFw>e>nFlR5e_s`y+D{kolWtTQloIey4-LvM5dH8OlFVC%LG zZhqFWNv|#nX~6n)?X!ASpK>h;<(u6mD>s)3dBAE8#J{malQS6ajqdJM*E+)+SWY^8 zTD*z_)+62BGshkke$T`_d$1Ug6D%11Z2-NDJ#DPK%6og+tbMI>wO>cknOWJhsIR$$ zr)E3is;QtDopqhxATpyO=gl8xUa%Q#-`S{N3FS11C{4IgzcLN#R|4qgKvoCa#}nDe zUPW($UB9wSIq!q|d4`D1PA6bL$q?=eW5_t@T{0b68N$=vHX6OfeQuocj~9r_xE383 zm_i*9pNwoEW1M5l)l_>HBiv*aWZmkUZWRdoU|<2Ap+hl>JsH?P4=61!@qW2FbS3Wz zbm)vab1vRe_M=_#l%%fQ5cv@4X7&RnxK;VqPDM#TALbi+6dCcC^>?y+o#ltG1}}u} z-^Eh14syy?6lF5_xv{Hc*ct>WoXTt*)n5r*F9jb#Y+#s>5nM@!1MdWt_zj`)w zkHWoZE}EKM!^$4aszqQ}Q}t^Y)zzr2jCsLmt}__d7GPXs-Q>n>Ys-YaT&hGEoy#xfVt3Jq7>}5TEQ@@z`3i=)QfJgp zSeTW&EWJ9atS~F0Z%XK+%%W0UV^(x^IOA5F!6L-5ysyO~Bw~8I#j>H|dM1C2<&Prj zYBf0gy^`+rW{+(v?iUP}U5kf{Z&RyluvZak)T4knt@;yqs70R?%@^Y@r2TGB?O^zu zPIeM9QCb|~o&oP-`J8w=V~o(^mO-C0s>~V20r{3*2XVkaHr#H+|5oUmJsF%b+yQ7O ztLkcult8So#t6NNYTwAgnAPJL&2~m-AV03t zop+;(e3o&<5hG^KBrd%#Tu}qy6Ib1B#SiD4hp{Bu8C3xDNyZRs-gL&$stWK%*WeA9 zk^s$BS>bdQ`EJ*}35oW~mW?O;U6X-vnHtMxmR7bdtopY_A!CDqzCu=E72B)1YAb7~ zC05k{pRo>i-G+7pV>peypd8bS4P)4OLF*uU7?oF~quh*T@hW3zbRAyiu5Kmt%t>9e zJ1BI7wwbM7DI=WAq7W1olhSgHs1OwbLG>#{r0k~r@jLxmR|9|O2Hu!PUtnbC40VBw z9Zp59wL}9WxRE z&>6#RfYzATt12w_LR`|Hc!WAm=`OeywGE9D9#142?By=gi2VK=aQn|jr?@*6TdU$* z)UiwCr+qbUsk=~UkI+JljgYfp;2F;2ez8Md?tRd|WucR>DCJF2}=6 zWKh}23kknup&v!moKXR>4D@$+0UK_iL=YD~83^29^vycMhhO!RUGDXi&3Zq8O&uHN zl68NU_*JnoEriNlPWvJjW&lI_Yt+v`i&z!7%e-l+Kg-)&lCL9y(cmHT2H!3+FV80x zYFFKftf~sdU0!W<52pf8gVk4dPy^ZZK19prPWNT2lEU@ho0HIn#>YdqfQsLWVYFFng#Q|TbHIvd<%uJMzB^h=#@==v@y=vm7B6&}?q>qd7S znNP4$o0RHmp9f%4De)3nTOOrO@1lAf#Z&!ib59x2#X1h%)k+#@5ae|1V$B=qT*Nt{ z6``?B$VzH3ri3Uv3w8D}MbES?oV___Byi2{Wt?AUx%N!@SRfGG-JQkV-Gjs8ZowB=oW=ckukO2h>;61d(^E6kQuC|3pB{9y$7T>C zEXKj2wvbwMPX5F8F}Ni1gEf|g>*GYc5(RNae5X#W;17isJcaO}#WY3+rr3p;6hb3p7^=9u$ z&o+SV;|_hb1*{JFCx?U)49!cXE>oMNc5@N{MCC67L`K)~ZLNGTTKgJ1hk#06`x*jO zQ-MhcL43e=AvdWifajE##@guy@3XXu)DAPNk?XoM})1rkpvAD7nK}E1JA_Yk0OXCqd@bp(Yx5 z44;ZabQOlv)hs>O2}xcgk9IkgH_lc}-ccJUPx@_;L{M|}{HrFKQLbt8#W6}sMF&|~ z7a6=HuqkjvMq~EU@Riv(ja&R9^J2rU)IeA*qwSonq>n8-NOmo(m=dN!;>92OV96r3 z_@113L2Ev#uUEBm_NYV=*2d1gl8RH4sw|fc@v8_%hI=kk#5!pp4!`9zWPvR@3CS$r!wn-ukZ88Q<2eF@F!dW6pI%;xw$9l877 zUyV0k?!4}c&hMJ^jv;Eyp#O~|OTZ;&Msg0|im@iIG{X2G=BvT^3C%sIXZ0MBjS|n@;^?*tn zEfj!DlsW$o;i`V>&&L4B@>8asmxNM52PNwOLYTUJK#TC6=*!c^evD}MM9xm$-Q{GC zuRvAE>kS~r_w~%T+nWjCeGBn8@_oL8`1W__yq*?!|CR&zzMK|+ijLS_1)#_E?X(X!=1xJbScP5(YZ4F&l3Uf5kS^i56ObL2nb*OJ#5_g% zjcP+kw(#6B$PA0l>tIP@fP&;kwI;+zcNWWIC2r>LOYfT1rESbMo zEx!b5?MqZngy>~qH41#Pb`_aB^e&kPX3uz1_{NOix$(bL4H>yV{fq8?xg(A4zPM{I zp4`PMQkj6}J3ky}iU<{}OhR{@AD%KPQfKiLJWWP^6*DAX^~Y!H%=~95r@{gaqZ6(z zVpzE9PcKf$)|th#@icjxlK~Cm{*U;FXK&$u00M~3c7UR${11e&3fC4gG+p&4XD`80 zlvQk@|04-hQMtSNztEu!Ma{`R{|}%*!(#s%fL613RKhqjcpSnwZ}SBH8!qh&7)(4( zR8)?kVZy?-#SAxB{n^<|vv^*fCX=K(ZeIXfiMI};8GI0fOc;+c@KbR|oW}adX8Jl0m?C0uvY_# zXF(&?(7mF?j$IpImd0>N$DXTPweIi&%-M4s%$c%?kDCUzSx?#FW`A+qyqvUW6a6Gp z-;u+@@A>ade&BL<3)Ax{x=lDlg>auOU8KA3stVul?{L48L7$JA5*Jxm>{+Y%6UC}^ zmzrSdi6otSQAV)1NtuZC^Q*zr17A)Cd*C>3is5Co6J-A?z0jVidU=?oI@@Q$BrA^$ zGM1Qwb)9UqpBTYZt;>W}*q)N`#AtDIClBfvbc%)U>-dOV8Tlw#Hij8qPUkHa9B6ye zmHv*csd}0iJu_`gkx_Xu0gfXxckX>~zp7^zWiZItP*GchrB7OWj+1sJ=FHlN>~(ce zM8v-;gzT$fD(B|(1z^P&zbd3m85+8KvKGTyqDM&uJ8Lgr3lx}>7qbk(jv{QeFzEtb zx0jrqiP2Zq5TVY!Gci%Yht?n1_pi~qN)Xrm#fp;R|G2O$$Z(c`6l_zlSP>Yl(ELOO zo{Tg4biXY-yE*|bgp-`7^^^URQ{w&!LZ!)(KE?twR?+dVNtlx>*bj+X?z9XOHdB55jlZJGuuV;CmSp@LGT!2`kyiBl+k z_A1{(6H95Hp@?V>Nd(ljIx?*7E;_ zF1vukOAZpKPTDg&vvJbAAep!UxoK6+Im_nb;TN?Zez7Dl%>>-WqM_wZgn!P9Z1&A^Bk$ zW3%Zo>V%12$xr!l3mrwa)5*U_;!`Sjg_g!vhc?*beX~Wff6{x`pAR%>f?3gxanelh zcF(#9tnBSf@RqRV@3;z~1tfPnb>)EvRBI0T?9TYWw`g~Dj7AeWV;itbqttBMYg88cYhZJrT&`_@6Ub=h1L5g)>o zp<7j-#6Bn_^^0*RBdxmE+qhQ*|AO*wC@=uLP?u(cE;o$)lj$QvmLtVP{ZcZD{_>J_ zc`Egf(}%pgWT&NzpHc$q<3*?e0d&pF0iS2=Z0ZdUrF@$z7d#$Tdz-Wb_l{R@1S9m{ z3$7}rPirj+M)>;+k|HHY=+^RnEF|LP#h?%M_pWWVMdD`OxAnc|V8+ZMC+hmxLN~gu#CU%|+~&;=@#xKrv!EkI$jb7=3E$dXFLCMqR%kIg-+3tj7-8~j z;K1Oivz6=Q>hL`@W4~I-h@iWG`*AOF{$!GLBXhg$YxYx86V@9IdV)@8#BtfVeF~0a z3iu`Zw&C9b5zM+}$>?3nw>( zFXIJ%sk0Ec>jErqT|0>yu5296X3LG)2nu1*Jv2T`Z4l(W+n$QUk(*$8EFS@7jG$BH z*zbAK7$sORaR@fmpWDqcJtWuC07mPL)brTz_=6zfg112yB!W<_$>pA5bk)d>`dD?P6yWLfH5&K*0# zvmief6KPlc=ysw<&7Bko$b`|fQQGjc7SZ(of zYTGh&Q;E`CRUe|A3PJo+^MS?_0S`h4@eJ)f_njYc^%rWAsvBNELRj?7ozfN1HO3wmo{Xrq!2P@+y#;m(g%A3q@Pkzy37E8ws>?-J z$KSYFv~)L-LtX5gve+xW3>QiL7ULCnwkEA8w&XJw?wWmNuq zx;qXhk^9K9<B!l${eNF}g1_N$fF#05`2$eZgJLw$I}=f9elb%~NVzp9j_J38aj8 z1?8pAsD9U8bg^`Bqh}6;%6r5;cK)5trn=;B+%29uQJ77vqWlVEM?m4c=+KGAJQ1lwyY7{gWly#KK{rvM0)SdCX~O=Zh_AjjxO{&YQ+$8yHHY~pHp)SUub9{u~=?M!nKw{m}y}a z{DE%Mz73~Lsm&4NL-SrHqH{Nnw`*td_-|67&hWWHpS}3xV!dx4@v!5!x<|L{+d&z( z`~ofcRSq)duoN0#Nm$(tOSqra>m)4(hVN$!-~D<~)W`1MXVfSxh?cL5Ut`U_0pF3L z`|b3N0wv?&msm*J)-U2rE70DjzUp?(vVRG~{|3&?5UGTrK-J}AZ-1-O z96Bj`pg2?ux}+u}iHLjE$+4$9hUb%!gnn)Ba_8I|cHGl>!mE^i;@X4D6(Bm3 z%$(`J4w&8Cuv$bFUOt7J+#rp5>Cx|MVyz|=1-3L?%>4K<@h;JO}W_sp#A9GQhCFSQ-;ep;AW5otb&CR%EVC<#EkzdVikca0yQU@1j*Lk zScRu$L5sblk?s|yV;9dC7>}k)Io~fH4sU(Pj}CagsZCR1_0;Qr9+c}*Dx0^il!*q9 z8aJcSRSAHiTkB}Y@@fA7swg#!LHHi$RVnsWtju#>ABhUocaXY_Xj)R8d2N7pb_6J2 zEjAG;tjY_N$pD|xAwTib19q7~t~x4=pp`1LeOdjb?HY-vBD7`kZPm_-WK-QYwjXky zM!4TF>F5l(Z+z4Zd;B}ob`+~iEOC`tvO^04cBP#G}t)VX`B6H;+SE}Du6+#ek;e}Dn^FVr4A%M{A>V?{9gVk_dom*L zk%kX}Y<6iFpW9Q<24S&SGKkm>d`{P;y&iQexE`@eaeof#h**fWV~^vKdQ9_2Uz-=l zCUq00L*vfO7h>}>;I0c^Dh&@d>|IokpI!a*3}V_%;>Lfe?S%hnaWxLLyn`lQPf>Tx z7!b2&d2$$C4)#zIKFQA`n{g_xc=$mx>pvB4}sK?o%E)Y7E{DmNi zImcS8DbugTL@YIlVg5$fL6ZKm;Jx4?;OUf*R5AZu7vU)&CAIaW@S8w7Ylf=#|h z56%sjit>n-(cRh2L~RvA3`S+1VMMGB*WRG%-IN0VT$t16^zV!{INJ&fmvqq!U7+tQ z*nNiY*9a$vu9F)yfhcg)Qdi|nL-eHbl}<$UJ;lLN zgm+u$pX3@qZBKqzkJcaf1UuceO1@=SsuOS#m+$ew?w4mUmNv>Aet#( zPI<4anC&Gf;k57jml~Yccw;7l=03miw@uanH$JFw37WlDM_r%_&7lmx>g048J+X51 zRB@?mfwdjF7zPe41}k-ks$ywn51Y6qe*RynbChdNb#xR1%|0&_UBsnUVje&;bmXT+ z|Gx5qcljaf^{vUE4YE%nUx@)yWtr@|rKZA_`2zPgwUrjK%Cfqe=wDhMV`_{G^q3SK zh|#*Gpz=tF6&8(l=c#I)ACT%t2uZbH3&DVmP>j+1fC;*^RO{KlB?9}VZ?SS&){DO| z>1Fi=OaD0OC?ZtDfu$0yEgPrCgvFGj*WP_4>&#=!R{xkWoQr^BKuqF`-vnz)7ON%t zDA`!oR^?Dd-~~uTv{{xLO~xflzKA7o95^4*igZCcAM;P?3CzUqcoke+H>XTFlfI>l(6_QH@-m{fpAPm(`GV30} z!=@`@w_UKfb#*r?+*o6)ak;RmP~F9sk|Y>^dvqH|Hv&*$SF9!U?LC2VdG>b*jZ5&= zbT9Ai1PEE%b%>=N=o;qwnMsld0dXtT?Yyqnaat;x$B$C7tDt)Zna8yC<2V7g^t(*< z?7yyx(UwUe(-5u*{aE~x6t%V~#j61!V65kidPi-cGYy^8!hAov!M{v29YcZkDemv( zbENf-s2y~7pXU(6>yd4y-q#?R3{{4QL`AjrpiR=?{_ABocVQFfAT^K4&1g);0^ij% zg+P)1erF4gU2OWknTjlJisX|MEpsyx(&^MP#t9&@nZZd|J`#)=5={haK)QQXy`|m4 zE2UTro@ZRn)}p>DK59}gJkC;7z6cJheX@vz>;6!t+d|4tc=u9WYcH+AxZd6{pzHZM zC zurt2u{;S>kt~>j?MAoAwgXYB9g&Nc81WHZ@MKb>xIEmuVtqcA$YyGRh97FLud^4({ zq5c)rWm;zY#B5XJo3Rp*ph{UAPpqIbp`npqX&CZ%ay5qj?Yy^El+0nX8E#h6 z6U3Y`u#S3MUI^q@)w52f4Fy(1R?H`62zo6Cm0TNao#ddzZ`~e@=l@v~DIZ={~VHW0x$9cC{+e!@L zXMt`;@{|x&xgn(VDkF0s%E|oieX5Q*r$cOkP07QLEwfI8hh3W8x?k;T5OFq!RMj92 z;(L0iz=~A&{2f)*_Pn;(vaFW>oUkq~y&H1)6DJehg!2Xtq@$5Ky91K?$8`xIV&>jctw z@ON84+NoHft4=lrjp@680fR}4xaUarj@Y7HCyg43ICSr|1OJY}vr<`KM4FnJ{plwW z)>PeZx0FxGC7ZtpD}C5=i!1_KSPANA5v&qsU1zoX`nnPj{tB^1Qy`hp*4oDBKxPrI zlP59MGs&!u55DB5sW7H&*J-qz&~4940ed^|xg#L#i^iIp8Xh4^BC|{^KFNzs#H?G^ zCjDU?qy)6S@c~?HzFVKR%fHq{R(*e~IMUMH!qBEP**awZmSA^^3JvPrUAO6BH5;vV z@EWTWljrm!X{od+SpM16(BHgDu_Rmn*Opz74P)_*=^vea!mXi$VX9@i;C(a1?5`RF zrst^I<%l8tZlcNx{DVEpz3SohdzVs4=LzaQEnTZB~ypmO2G@=;gG*=6l z(Kam{c`1k<(CrBXmj!Dk&dc?urWt>?l%;J%ny~fj>J4S~M@M{TBU0MlWAiKFXZaKe zXX1!$?A|l1ZN=|8zbHWx&8khGF>kw4Ij;{p{>_kC5pk2=njVu0Uc$RyX!_rcm^*uT z_a2$i95QT=wQiyre<)ucjZ~!`Uco+-j$i!>)I$AcmvJL*m5^OiAw@7KAaKoV{axR+ z20lyhGICn~2KO-_l+NU=Syf(Vry-0>F;;fak}^NU47D}@E!w=(Z~C-RbqTwWkG33d zR%fNyNdr>quMF zjvejXCShHlw?s=`GpiMM2Srm27_X>>0Z1 zFag5R==MqiC|sat3WwwPzNUk{^uvvG^q2Y78;auA+N&>wVphN?E>Q^=&5a5Im?$Fb zas?Yp6F>Q^HvXtL3p-AgDuM>x^x01k@&_`pVsZ6~rx^X1^o$5;9cm z`*5Y??fn3b@qOM(QQ7c*Jb|U2WBnt0AitpKgg={iKlD1s>||IUIV*LKz8x0G`K0mU z_0;UO9|jPf_nLeeDZV(s%Vr%HD@K0OJQITGPrhiVT-RENF3l31SYg~A4`m!ZjB)9E z@0V_P-sE^L#0WqB%^tK=`PEX)y*?%}joIv;{ZMJ~T3UR!RR8JND)NRa*h_CmQ%<#g z?2&T)KWD=K>kLJ;&j_q+9eCKBeOGGny6OB>%YdQXoOMgQk!Pm`D2;(^{Op+bJ+|`3 zEJP}(@4B1=2)Ey6KPRZ{sHOk8$bO(4)?XF>0eNA)(|INz)QA02*>To$_eXu6-mmU| zdb!ZqQP|8N2YLBIoS2f|754`w_ z9+~8m^KpX?S0|<08JIlOd)8EPHaIzaHaR)Uy}H?c@EgU1oOwNMkH!??=6B(%5wzal zjn~(31a3@o6!n#j(ys8LBleR_j{diomHm{5Gg^)wY*ybK@GB3;dy*M)nuQ=@w1eAC zfy70aQl3fPUe4;1x3EOVo*IY54iV1#bl`8Rfy1?q%&$+RqB$>75QZL$>oZ6dpWWDv z$OLoG%7xy}?aU>*wGSimlNX$~#gowKJkmqRtufdc-PLYof3@quCFmIjX`hs{$&L$r z<+;lh4Mo4#l-?%gUC9JALSsaIpYC@iKl!e|79T*_yS*RwL`9y@0Y)Oex5Z~~>BIY> zPa>br$Vm2QMc*R!y07wjJ2d(E1^9G#|LFTXoAV0W>E88yo_za`!iM|zqOa%+ewRO; Iu;AbQFD#D4YybcN literal 0 HcmV?d00001 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()