From d278bdae48180553d8331107a3c977797bd72cd0 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 22:16:45 -0500 Subject: [PATCH] research: bound two-center R439 defect relay --- .../CERTIFICATE.json | 1850 +++++++++++++++++ .../README.md | 127 ++ .../SOURCES.json | 81 + .../TASK.json | 66 + .../VERIFY.json | 23 + .../verify.py | 607 ++++++ 6 files changed, 2754 insertions(+) create mode 100644 research/r439-two-center-defect-relay-seed63e9/CERTIFICATE.json create mode 100644 research/r439-two-center-defect-relay-seed63e9/README.md create mode 100644 research/r439-two-center-defect-relay-seed63e9/SOURCES.json create mode 100644 research/r439-two-center-defect-relay-seed63e9/TASK.json create mode 100644 research/r439-two-center-defect-relay-seed63e9/VERIFY.json create mode 100644 research/r439-two-center-defect-relay-seed63e9/verify.py diff --git a/research/r439-two-center-defect-relay-seed63e9/CERTIFICATE.json b/research/r439-two-center-defect-relay-seed63e9/CERTIFICATE.json new file mode 100644 index 0000000000..50fbac53a7 --- /dev/null +++ b/research/r439-two-center-defect-relay-seed63e9/CERTIFICATE.json @@ -0,0 +1,1850 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "candidate_path": "research/r439-bsection-stars-seed01/candidate.json.gz", + "candidate_sha256": "b452d2c2b0b2a546d1105b1da9769aa78e5c54d6f00e97b30c77e3f54ce445ee", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "claim_status": "No advance claim posted; report as FINDING/DONE per autoresearch.md.", + "controls": { + "known_absorption_positive": { + "A_writer": 304, + "B": 5874310, + "D_adds": 5547, + "F": 25717, + "edge": [ + 514, + 367 + ], + "forward_and_reverse_equal_parent": true, + "frame_paths_equal_parent": true, + "local_bits": 95, + "native_ADDs": 11499, + "new_sources": [ + 360 + ], + "nine_stage_bits": 182, + "paid_mass": 5129, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + } + }, + "wrong_source_negative": { + "A_writer": 304, + "changed_forward_output_rows": 57, + "edge": [ + 514, + 367 + ], + "rejected": true, + "wrong_sources": [ + 361 + ] + } + }, + "kind": "scoped two-center in-flight defect relay obstruction", + "no_new_kappa": true, + "paired_omission_cases": [ + { + "affected_output_rows": 61, + "candidate_A_gates": [ + 325, + 556, + 1514, + 1515, + 1516, + 1517 + ], + "candidate_gate_supports": [ + { + "gate": 325, + "output_registers": [ + 111, + 113, + 116, + 118, + 120, + 122, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 144, + 145, + 146, + 147, + 149, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 186, + 194, + 196, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 216, + 218, + 219, + 221, + 525 + ] + }, + { + "gate": 556, + "output_registers": [ + 111, + 113, + 116, + 118, + 120, + 121, + 122, + 124, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 144, + 145, + 146, + 147, + 149, + 154, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 186, + 191, + 194, + 196, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 218, + 219, + 643 + ] + }, + { + "gate": 1514, + "output_registers": [ + 111, + 113, + 116, + 118, + 120, + 122, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 144, + 145, + 146, + 147, + 149, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 186, + 194, + 196, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 216, + 218, + 219, + 221, + 525 + ] + }, + { + "gate": 1515, + "output_registers": [ + 111, + 113, + 116, + 118, + 120, + 122, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 144, + 145, + 146, + 147, + 149, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 186, + 194, + 196, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 216, + 218, + 219, + 221, + 525 + ] + }, + { + "gate": 1516, + "output_registers": [ + 111, + 113, + 116, + 118, + 120, + 122, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 144, + 145, + 146, + 147, + 149, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 186, + 194, + 196, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 216, + 218, + 219, + 221, + 525 + ] + }, + { + "gate": 1517, + "output_registers": [ + 111, + 113, + 116, + 118, + 120, + 122, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 144, + 145, + 146, + 147, + 149, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 186, + 194, + 196, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 216, + 218, + 219, + 221, + 525 + ] + } + ], + "centers": [ + 643, + 525 + ], + "columnspace_basis_hex": [ + "20000000000000000000000000000000000000000000000000000000000000000000000000002df32a9404aa6d6e6c2fb541e5528000000000000000000000000000", + "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000cf32a9484aa6d6e642fb541f7528000000000000000000000000000" + ], + "cost_admissible_source_action_pairs": 0, + "distinct_candidate_supports": 2, + "distinct_nonzero_row_syndromes": 3, + "factorizations": [ + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 325, + "interaction_parity": 0, + "required_first_input_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 556 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 325, + "interaction_parity": 1, + "required_first_input_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 556 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 0, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1514 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 1, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1514 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 0, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1515 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 1, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1515 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 0, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1516 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 1, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1516 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 0, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1517 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 556, + "interaction_parity": 1, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1517 + } + ], + "first_singleton_reads": [ + 1517, + 1525 + ], + "interaction_factorizations": 10, + "nonzero_residual_rows": [ + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 111 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 113 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 116 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 118 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 120 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 121 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 122 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 124 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 125 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 126 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 127 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 128 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 134 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 136 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 138 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 140 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 141 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 143 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 144 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 145 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 146 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 147 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 149 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 154 + }, + { + "input_mask_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 155 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 157 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 158 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 161 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 162 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 163 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 165 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 166 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 168 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 170 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 171 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 173 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 174 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 177 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 179 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 181 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 183 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 186 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 191 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 194 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 196 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 199 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 201 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 203 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 205 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 208 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 209 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 212 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 213 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 214 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 215 + }, + { + "input_mask_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 216 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 218 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 219 + }, + { + "input_mask_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 221 + }, + { + "input_mask_hex": "800000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 525 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 643 + } + ], + "omitted_D_indices": [ + 979, + 1096 + ], + "omitted_edges": [ + [ + 643, + 594 + ], + [ + 525, + 287 + ] + ], + "ordered_distinct_support_gate_pairs": 5, + "residual_rank": 2, + "residual_row_weights": { + "1": 8, + "2": 53 + }, + "scalar_budget": { + "A_actions_tested": [ + "remove", + "add", + "replace" + ], + "frame_availability": "relaxed: every register label considered", + "maximum_A_tap_delta_for_strict_saving": 1, + "two_D_restorations_removed": -2 + } + }, + { + "affected_output_rows": 14, + "candidate_A_gates": [ + 327, + 566, + 1493, + 1494, + 1495, + 1496 + ], + "candidate_gate_supports": [ + { + "gate": 327, + "output_registers": [ + 119, + 123, + 149, + 154, + 185, + 188, + 215, + 218, + 526 + ] + }, + { + "gate": 566, + "output_registers": [ + 141, + 147, + 149, + 154, + 185, + 188, + 193, + 195, + 648 + ] + }, + { + "gate": 1493, + "output_registers": [ + 119, + 123, + 149, + 154, + 185, + 188, + 215, + 218, + 526 + ] + }, + { + "gate": 1494, + "output_registers": [ + 119, + 123, + 149, + 154, + 185, + 188, + 215, + 218, + 526 + ] + }, + { + "gate": 1495, + "output_registers": [ + 119, + 123, + 149, + 154, + 185, + 188, + 215, + 218, + 526 + ] + }, + { + "gate": 1496, + "output_registers": [ + 119, + 123, + 149, + 154, + 185, + 188, + 215, + 218, + 526 + ] + } + ], + "centers": [ + 648, + 526 + ], + "columnspace_basis_hex": [ + "400000000000000000000000000000000000000000000000000000000000000000000000000004800000120000000420000008800000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a120000000428200000000000000000000000000000000000" + ], + "cost_admissible_source_action_pairs": 0, + "distinct_candidate_supports": 2, + "distinct_nonzero_row_syndromes": 3, + "factorizations": [ + { + "charged_action_pairs": 0, + "first_actions": 1, + "first_gate": 327, + "interaction_parity": 0, + "required_first_input_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 566 + }, + { + "charged_action_pairs": 0, + "first_actions": 1, + "first_gate": 327, + "interaction_parity": 1, + "required_first_input_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 566 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 0, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1493 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 1, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1493 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 0, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1494 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 1, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1494 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 0, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1495 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 1, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1495 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 0, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1496 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 566, + "interaction_parity": 1, + "required_first_input_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1496 + } + ], + "first_singleton_reads": [ + 1496, + 1502 + ], + "interaction_factorizations": 10, + "nonzero_residual_rows": [ + { + "input_mask_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 119 + }, + { + "input_mask_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 123 + }, + { + "input_mask_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 141 + }, + { + "input_mask_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 147 + }, + { + "input_mask_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 149 + }, + { + "input_mask_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 154 + }, + { + "input_mask_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 185 + }, + { + "input_mask_hex": "2000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 188 + }, + { + "input_mask_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 193 + }, + { + "input_mask_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 195 + }, + { + "input_mask_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 215 + }, + { + "input_mask_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 218 + }, + { + "input_mask_hex": "8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 526 + }, + { + "input_mask_hex": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 648 + } + ], + "omitted_D_indices": [ + 1023, + 1097 + ], + "omitted_edges": [ + [ + 648, + 589 + ], + [ + 526, + 543 + ] + ], + "ordered_distinct_support_gate_pairs": 5, + "residual_rank": 2, + "residual_row_weights": { + "1": 10, + "2": 4 + }, + "scalar_budget": { + "A_actions_tested": [ + "remove", + "add", + "replace" + ], + "frame_availability": "relaxed: every register label considered", + "maximum_A_tap_delta_for_strict_saving": 1, + "two_D_restorations_removed": -2 + } + }, + { + "affected_output_rows": 14, + "candidate_A_gates": [ + 343, + 570, + 1573, + 1574, + 1575, + 1576 + ], + "candidate_gate_supports": [ + { + "gate": 343, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 570, + "output_registers": [ + 131, + 139, + 160, + 164, + 175, + 182, + 206, + 211, + 650 + ] + }, + { + "gate": 1573, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 1574, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 1575, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 1576, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + } + ], + "centers": [ + 650, + 534 + ], + "columnspace_basis_hex": [ + "40000000000000000000000000000000000000000000000000000000000000000000000000000000084020400000110210080800000000000000000000000000000000", + "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000084000004080110000080800000000000000000000000000000000" + ], + "cost_admissible_source_action_pairs": 0, + "distinct_candidate_supports": 2, + "distinct_nonzero_row_syndromes": 3, + "factorizations": [ + { + "charged_action_pairs": 0, + "first_actions": 1, + "first_gate": 343, + "interaction_parity": 0, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 570 + }, + { + "charged_action_pairs": 0, + "first_actions": 1, + "first_gate": 343, + "interaction_parity": 1, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 570 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1573 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1573 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1574 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1574 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1575 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1575 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1576 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1576 + } + ], + "first_singleton_reads": [ + 1576, + 1583 + ], + "interaction_factorizations": 10, + "nonzero_residual_rows": [ + { + "input_mask_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 131 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 139 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 148 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 153 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 160 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 164 + }, + { + "input_mask_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 175 + }, + { + "input_mask_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 182 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 190 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 197 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 206 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 211 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 534 + }, + { + "input_mask_hex": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 650 + } + ], + "omitted_D_indices": [ + 966, + 981 + ], + "omitted_edges": [ + [ + 650, + 372 + ], + [ + 534, + 570 + ] + ], + "ordered_distinct_support_gate_pairs": 5, + "residual_rank": 2, + "residual_row_weights": { + "1": 8, + "2": 6 + }, + "scalar_budget": { + "A_actions_tested": [ + "remove", + "add", + "replace" + ], + "frame_availability": "relaxed: every register label considered", + "maximum_A_tap_delta_for_strict_saving": 1, + "two_D_restorations_removed": -2 + } + }, + { + "affected_output_rows": 14, + "candidate_A_gates": [ + 343, + 570, + 1573, + 1574, + 1575, + 1576 + ], + "candidate_gate_supports": [ + { + "gate": 343, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 570, + "output_registers": [ + 131, + 139, + 160, + 164, + 175, + 182, + 206, + 211, + 650 + ] + }, + { + "gate": 1573, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 1574, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 1575, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + }, + { + "gate": 1576, + "output_registers": [ + 131, + 139, + 148, + 153, + 160, + 164, + 190, + 197, + 206, + 211, + 534 + ] + } + ], + "centers": [ + 650, + 534 + ], + "columnspace_basis_hex": [ + "40000000000000000000000000000000000000000000000000000000000000000000000000000000084020400000110210080800000000000000000000000000000000", + "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000084000004080110000080800000000000000000000000000000000" + ], + "cost_admissible_source_action_pairs": 0, + "distinct_candidate_supports": 2, + "distinct_nonzero_row_syndromes": 3, + "factorizations": [ + { + "charged_action_pairs": 0, + "first_actions": 1, + "first_gate": 343, + "interaction_parity": 0, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 570 + }, + { + "charged_action_pairs": 0, + "first_actions": 1, + "first_gate": 343, + "interaction_parity": 1, + "required_first_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 570 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1573 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1573 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1574 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1574 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1575 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1575 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 0, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1576 + }, + { + "charged_action_pairs": 0, + "first_actions": 0, + "first_gate": 570, + "interaction_parity": 1, + "required_first_input_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_second_input_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "second_actions": 0, + "second_gate": 1576 + } + ], + "first_singleton_reads": [ + 1576, + 1583 + ], + "interaction_factorizations": 10, + "nonzero_residual_rows": [ + { + "input_mask_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 131 + }, + { + "input_mask_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 139 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 148 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 153 + }, + { + "input_mask_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 160 + }, + { + "input_mask_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 164 + }, + { + "input_mask_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 175 + }, + { + "input_mask_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 182 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 190 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 197 + }, + { + "input_mask_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 206 + }, + { + "input_mask_hex": "4000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 211 + }, + { + "input_mask_hex": "40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 534 + }, + { + "input_mask_hex": "4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output_register": 650 + } + ], + "omitted_D_indices": [ + 961, + 966 + ], + "omitted_edges": [ + [ + 650, + 602 + ], + [ + 534, + 570 + ] + ], + "ordered_distinct_support_gate_pairs": 5, + "residual_rank": 2, + "residual_row_weights": { + "1": 8, + "2": 6 + }, + "scalar_budget": { + "A_actions_tested": [ + "remove", + "add", + "replace" + ], + "frame_availability": "relaxed: every register label considered", + "maximum_A_tap_delta_for_strict_saving": 1, + "two_D_restorations_removed": -2 + } + } + ], + "reciprocal_singleton_pairs": [ + { + "centers": [ + 643, + 525 + ], + "first_reads": [ + 1517, + 1525 + ], + "terminal_leafs": [ + [ + 594 + ], + [ + 287 + ] + ] + }, + { + "centers": [ + 648, + 526 + ], + "first_reads": [ + 1496, + 1502 + ], + "terminal_leafs": [ + [ + 589 + ], + [ + 543 + ] + ] + }, + { + "centers": [ + 650, + 534 + ], + "first_reads": [ + 1576, + 1583 + ], + "terminal_leafs": [ + [ + 372, + 602 + ], + [ + 570 + ] + ] + } + ], + "schema_version": 1, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "source_word": { + "A_adds": 2130, + "B": 5911840, + "D_adds": 5548, + "F": 25717, + "formal_columns": 661, + "label": "PR1062 / r439-bsection-stars-seed01", + "local_bits": 95, + "native_ADDs": 11500, + "nine_stage_bits": 182, + "paid_mass": 5129, + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + } + }, + "totals": { + "accepted_new_constructions": 0, + "cost_admissible_action_pairs": 0, + "gate_pairs": 20, + "interaction_factorizations": 40, + "omission_cases": 4, + "rank_two_cases": 4, + "scope_limit": "two restorations at one reciprocal pair; at most two A tap edits on distinct gates; total A tap delta <= +1" + } +} diff --git a/research/r439-two-center-defect-relay-seed63e9/README.md b/research/r439-two-center-defect-relay-seed63e9/README.md new file mode 100644 index 0000000000..199ddb8b72 --- /dev/null +++ b/research/r439-two-center-defect-relay-seed63e9/README.md @@ -0,0 +1,127 @@ +# Two-center in-flight defect relay: scoped obstruction + +This package tests one concrete way to reduce the scalar cost of the pinned +R439 helper-star word: remove one terminal `D` restoration at each of a +reciprocal pair of helper centers, then repair the resulting coupled defect by +editing one `A` source tap at each of two distinct gates. It finds no repair +with a strict scalar `ADD` saving in this finite domain. This is a scoped +negative result; it does not bound larger edits or other words. + +## Exact scope and result + +The source is the PR #1062 11,500-`ADD` word +`research/r439-bsection-stars-seed01/candidate.json.gz`, pinned by SHA-256 +`b452d2c2b0b2a546d1105b1da9769aa78e5c54d6f00e97b30c77e3f54ce445ee`. The +experiment covers all three reciprocal singleton first-read center pairs in +that word: + +| Centers | First `A` reads | Terminal `D` leaves | Omission cases | +| --- | --- | --- | ---: | +| `(643, 525)` | `(1517, 1525)` | `(594, 287)` | 1 | +| `(648, 526)` | `(1496, 1502)` | `(589, 543)` | 1 | +| `(650, 534)` | `(1576, 1583)` | `(602, 570)` or `(372, 570)` | 2 | + +For each of the four two-restoration omissions, the verifier computes the +complete `F_2` state map and its reverse over all 661 formal columns. The +forward omission residual has rank 2. Its output-column support is contained +in the span of the perturbation supports of six `A` gates, with two distinct +supports. Consequently there are five distinct-support gate pairs per case. +For every gate pair, both possible interaction orientations are solved +exactly, giving 20 gate pairs and 40 factorizations total. + +The factorization solves for the two source-state masks that the tap edits +must introduce. It also accounts for the first edit changing a donor read at +the later gate. For each factorization, the verifier inventories tap removal, +addition, and replacement actions across every register label. This relaxes +the frame rule by allowing even labels unavailable at the gate. No action pair +meets the map equations and scalar budget. + +The scalar charge is explicit: two omitted `D` taps save 2 `ADD`s, so a strict +net saving requires the two `A` edits together to cost at most +1 `ADD`: + +```text +delta_ADD = -2 + delta_A_taps <= -1 +``` + +Because no pair restores the complete boundary even under the relaxed +all-register donor inventory, frame legality, frame-path equality, paid +profile, and the remaining recursive assembly costs cannot admit a candidate +within this domain. No value of `kappa` or supplier improvement is claimed. + +The pinned parent word costs 11,500 native `ADD`s, has paid profile +`{1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}` with mass 5,129, and has +integer bounds `F=25,717`, `B=5,911,840`. Its local and nine-stage precision +guards use 95 and 182 bits, respectively. These are source-word values, not a +cost claim for an accepted two-center construction. + +## Controls + +The positive control replays the known one-edge absorption from PR #1937: +omit `514 ^= 367` and change the source of `A[304]` to `[360]`. The exact +forward and reverse maps, frame paths, and paid profile match the parent; +native `ADD`s fall from 11,500 to 11,499 and `D` `ADD`s from 5,548 to 5,547. +Its `F/B` bounds are `25,717 / 5,874,310`, with the same 95/182-bit guards and +paid mass 5,129. The negative control changes that source to `[361]` and checks +that the forward map changes. + +These controls show that the replay accepts a known valid absorption and +rejects a wrong donor. They are finite checks of this word, not a theorem about +all helper circuits. + +## Provenance and overlap + +- Track: `bit-mechanisms`; task: `bit-helper-contract`; priority revision 4. +- Seed: `63e9ed039147038f4e817746114c150d`. +- Base commit: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. +- Task catalogue SHA-256: `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. +- Selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Selected review, source manifest, and assembly are pinned in `SOURCES.json`; + their SHA-256 values are `7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb`, + `79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b`, and + `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`. +- Parent word: [PR #1062](https://github.com/CrocSwap/integer-mult-bounds/pull/1062), + head `cd016e5dcd5ba28dafa3f3b4eeef003a38e6a11b`, by Sagar Thakrar. +- Nearest overlapping work: [PR #1937](https://github.com/CrocSwap/integer-mult-bounds/pull/1937), + head `8b4a4d59eb5df9971d44587d9980c3dd0b18fc96`, by Aaron Wang. That package + includes the positive control and explicitly leaves in-flight intermediate + defect-vector injection unmodeled; this result covers only the four pinned + reciprocal-pair omission cases and the stated two-tap budget. +- A completed one-restoration post-read study was found in [Discussion #1166, + comment 18930632](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18930632). + That single-restoration scope was retired before this experiment. +- No advance claim was posted for the changed scope. Report this package as a + `FINDING`/`DONE` result, not a maintainer-reviewed conclusion. + +## Reproduce + +Run the registered replay with Python 3.12: + +```sh +python3.12 scripts/research_package.py --package research/r439-two-center-defect-relay-seed63e9 --check-only +python3.12 scripts/research_package.py --package research/r439-two-center-defect-relay-seed63e9 +``` + +The registered metadata check pins the full provenance chain and live inputs; +the verifier rechecks the candidate and checker hashes, the selected record and +catalogue at the pinned base commit, parent maps in both directions, all four +omission residuals, rank/support factorizations, all-register tap action +inventory, scalar budget, integer precision guards, profile, controls, and +deterministic certificate equality. The initial package replay was run locally +with Python 3.14.7; the repository's generic replay uses Python 3.12. + +## Open next questions + +Can three or more `A` tap edits, or a nonreciprocal center pair, create a fully +charged multi-center defect relay? This matters because the current obstruction +does not eliminate larger correction sets, and those could supply a further +scalar saving before recursive assembly. For a fresh investigation, derive the +rank-three residual factorization and its fully charged tap budget before +expanding the search. This package does not cover three or more edits, +nonreciprocal centers, other source words, `B/C` changes, or supplier +re-evaluation. + +## Credit + +The parent word and known absorption control are attributed to Sagar Thakrar +(PR #1062) and Aaron Wang (PR #1937). This package was prepared with substantial +OpenAI Codex assistance; no independent human review is claimed. diff --git a/research/r439-two-center-defect-relay-seed63e9/SOURCES.json b/research/r439-two-center-defect-relay-seed63e9/SOURCES.json new file mode 100644 index 0000000000..a86d8385e6 --- /dev/null +++ b/research/r439-two-center-defect-relay-seed63e9/SOURCES.json @@ -0,0 +1,81 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/r439-bsection-stars-seed01/README.md", + "usage": "provenance", + "git_blob": "188175a52bb2a3ad65c701b3bd218ae3fc0bdfde", + "sha256": "3a32ecbf886d6605eb7441c63ca934c6aab0942d0e7e570c3dd0795d1cf00336" + }, + { + "path": "research/r439-bsection-stars-seed01/SOURCES.json", + "usage": "provenance", + "git_blob": "8c02baa7fcc9e04abb8f7fc81299c708b3dfeb42", + "sha256": "779a4d0d1ca0d578026d0f4ce0f8f16466cc6e866b7d80193ef9e7eb2a2d6cfe" + }, + { + "path": "research/r439-bsection-stars-seed01/candidate.json.gz", + "usage": "input", + "git_blob": "9a17b4920334878d6c949191f6931bd97126fe3c", + "sha256": "b452d2c2b0b2a546d1105b1da9769aa78e5c54d6f00e97b30c77e3f54ce445ee" + }, + { + "path": "research/e8-bit-p111-tuned/code/xcheck_p.py", + "usage": "input", + "git_blob": "184f5dcf94a486cc7db91ca4db5865916bf26009", + "sha256": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e" + } + ], + "predecessors": [ + { + "role": "overlap boundary and known one-edge positive control", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1937", + "head_commit": "8b4a4d59eb5df9971d44587d9980c3dd0b18fc96", + "package": "research/r439-multi-donor-star-absorption", + "specific_open_scope": "cross-center injection of intermediate defect vectors from in-flight multi-write corrections is not modeled there" + }, + { + "role": "completed one-restoration post-read overlap retired before this run", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18930632", + "package": "research/r439-postread-star-absorption-seedc887", + "specific_scope": "single-restoration post-read absorption with one existing writer per helper" + }, + { + "role": "pinned parent R439 word", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1062", + "head_commit": "cd016e5dcd5ba28dafa3f3b4eeef003a38e6a11b", + "author": "Sagar Thakrar" + } + ] +} diff --git a/research/r439-two-center-defect-relay-seed63e9/TASK.json b/research/r439-two-center-defect-relay-seed63e9/TASK.json new file mode 100644 index 0000000000..b0d15b85ab --- /dev/null +++ b/research/r439-two-center-defect-relay-seed63e9/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "accepted_seed": "63e9ed039147038f4e817746114c150d", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "selector_method": "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement.", + "selected_method": "Derive the rank-two replacement-interface condition for a two-center in-flight relay, then exhaust its fully charged two-tap realizations.", + "scope_status": "changed", + "scope_change_reason": "The selector method was counterexample-oriented, so the construction-focused replacement-interface method on the same card was selected. Live overlap found a completed one-restoration post-read study (Cycle 18, Discussion #1166 comment 18930632); this run therefore changed the object to simultaneous omissions at two reciprocal helper centers and a two-tap in-flight defect relay, which PR #1937 explicitly leaves outside its cross-center leaf-vector census. The result is a bounded obstruction for that new candidate mechanism.", + "actual_scope": "On the pinned PR1062 11,500-ADD R439 word, enumerate the three reciprocal singleton first-read helper-center pairs (643,525), (648,526), (650,534) and all four cross-products of one terminal D restoration from each center. For each two-omission word, test whether at most two existing A source-tap edits at distinct gates, with total scalar ADD charge at most +1, can restore the full 661-column forward and reverse state maps. The donor inventory is deliberately relaxed to every register label, without frame restrictions. A positive candidate would still need frame legality, frame-path and paid-profile checks, the twisted helper contract, integer precision bounds, and full assembly pricing; no candidate exists even in the relaxed map-preserving domain.", + "bottleneck_link": "A positive result would save at least one scalar ADD in the finite bit word; the selected construction remains complex-bound, and no supplier adoption or kappa change follows from this local scope. The bounded negative result removes this two-center relay family from the immediate construction search.", + "budget_minutes": 60, + "stop_rule": "Exhaust all reciprocal singleton first-read pairs in this pinned word, every cross-product of one terminal restoration per center, and every one- or two-tap A edit with total tap charge at most +1. Stop after the exact residual-rank/support factorization and complete all-register action inventory; do not extend to three or more tap edits, nonreciprocal pairs, other words or supplier assembly in this cycle.", + "outcome": "negative-result", + "evidence": "CERTIFICATE.json records the four exact residuals and rank-two factorizations, 20 candidate ordered gate pairs, 40 interaction orientations and zero cost-admissible tap pairs. verify.py recomputes the full F2 maps, source action inventory, parent pins, known positive absorption control and wrong-source rejection control.", + "claim_status": "No advance claim was posted before the bounded experiment. Report as FINDING/DONE and release scope in Discussion #1166, following autoresearch.md.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human review is claimed.", + "open_questions": [ + { + "question": "Can three or more A tap edits or a nonreciprocal center pair produce a fully charged multi-center defect relay?", + "why_it_matters": "The current exact obstruction covers only two simultaneous D omissions at reciprocal singleton first-read pairs and at most two A tap edits; larger edit sets can create new intermediate defect vectors.", + "first_step": "Start from a fresh selector seed and a distinct construction scope; if continuing this line, derive the rank-three residual factorization and its fully charged A-tap budget before any wider search.", + "blocked_by": "No universal obstruction is proved for three or more tap edits, nonreciprocal centers, other pinned R439 words, or changes to B/C." + } + ] +} diff --git a/research/r439-two-center-defect-relay-seed63e9/VERIFY.json b/research/r439-two-center-defect-relay-seed63e9/VERIFY.json new file mode 100644 index 0000000000..0337d83719 --- /dev/null +++ b/research/r439-two-center-defect-relay-seed63e9/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/r439-bsection-stars-seed01/candidate.json.gz", + "research/e8-bit-p111-tuned/code/xcheck_p.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Pinned 661-column linear map in both directions; all reciprocal singleton first-read pairs and four two-restoration omission cases; exact rank-two residuals, the complete two-tap gate-pair and donor-action factorization including first-to-second interaction; strict ADD charge cap; source pins; known one-edge absorption positive control; wrong-source negative control; frame-path/profile and precision guard replay; certificate byte equality." + } + ] +} diff --git a/research/r439-two-center-defect-relay-seed63e9/verify.py b/research/r439-two-center-defect-relay-seed63e9/verify.py new file mode 100644 index 0000000000..7629442b23 --- /dev/null +++ b/research/r439-two-center-defect-relay-seed63e9/verify.py @@ -0,0 +1,607 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact bounded search for a two-center R439 restoration relay.""" +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json +import subprocess +from collections import Counter, defaultdict +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PACKAGE = HERE.relative_to(ROOT).as_posix() +BASE = "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2" +SELECTED_SHA256 = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" +CATALOGUE_SHA256 = "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" +CANDIDATE_PATH = "research/r439-bsection-stars-seed01/candidate.json.gz" +XCHECK_PATH = "research/e8-bit-p111-tuned/code/xcheck_p.py" +PROFILE_EXPECTED = {1: 1323, 2: 1342, 3: 79, 4: 44, 5: 102, 6: 11, 7: 19} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def sha256(data): + return hashlib.sha256(data).hexdigest() + + +def canonical_json(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def load_word(): + sources = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + source_pins = {row["path"]: row["sha256"] for row in sources["files"]} + raw = (ROOT / CANDIDATE_PATH).read_bytes() + need(sha256(raw) == source_pins[CANDIDATE_PATH], "pinned PR1062 word SHA-256 mismatch") + need(sha256((ROOT / XCHECK_PATH).read_bytes()) == source_pins[XCHECK_PATH], + "pinned owner-profile checker SHA-256 mismatch") + for path, expected in (("certificates/selected-result.json", SELECTED_SHA256), + ("docs/research/agent-task-catalog.json", CATALOGUE_SHA256)): + need(source_pins[path] == expected, f"{path} manifest pin mismatch") + pinned = subprocess.run( + ["git", "show", f"{BASE}:{path}"], cwd=ROOT, + check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout + need(sha256(pinned) == expected, f"{path} base-commit SHA-256 mismatch") + return json.loads(gzip.decompress(raw).decode("utf-8")) + + +def stream(word): + out = [("add", d, s) for section in ("D", "A") + for _, d, sources in word[section] for s in sources] + n = 2 * word["v"] + word["R"] + temporary = n + for j, center in enumerate(word["ret"]): + out.append(("copy", temporary, center)) + out.extend(("add", word["v"] + i, temporary) + for i, row in enumerate(word["scatter"]) if j in row) + out.append(("erase", temporary, center)) + out.extend(("add", d, s) for section in ("B", "C") + for _, d, sources in word[section] for s in sources) + return out + + +def flipped(kind): + if kind == "copy": + return "erase" + if kind == "erase": + return "copy" + return kind + + +def linear_map(word, reverse=False): + n = 2 * word["v"] + word["R"] + rows = [1 << i for i in range(n)] + [0] + instructions = stream(word) + if reverse: + instructions = [(flipped(kind), d, s) + for kind, d, s in reversed(instructions)] + for kind, d, s in instructions: + if kind == "add": + rows[d] ^= rows[s] + elif kind == "copy": + need(rows[d] == 0, "COPY into a live temporary") + rows[d] = rows[s] + else: + need(rows[d] == rows[s], "ERASE of a modified temporary") + rows[d] = 0 + need(rows[-1] == 0, "temporary not erased") + return rows[:-1] + + +def integer_bill(word): + n = 2 * word["v"] + word["R"] + ins = stream(word) + peaks = [] + for reverse in (False, True): + values = [1] * (n + 1) + peak = 1 + ordered = ins + if reverse: + ordered = [(flipped(kind), d, s) + for kind, d, s in reversed(ins)] + for kind, d, s in ordered: + if kind == "add": + values[d] += values[s] + elif kind == "copy": + values[d] = values[s] + else: + values[d] = 0 + peak = max(peak, values[d]) + peaks.append(peak) + F, B = peaks + local = 64 * (F ** 3) * (B ** 2) + nine = (1 << 18) * (F ** 5) * (B ** 4) + need(local < (1 << 104), "local precision guard failed") + need(nine < (1 << 192), "nine-stage precision guard failed") + return { + "native_ADDs": sum(1 for kind, _, _ in ins if kind == "add"), + "D_adds": sum(len(gate[2]) for gate in word["D"]), + "A_adds": sum(len(gate[2]) for gate in word["A"]), + "F": F, + "B": B, + "local_bits": local.bit_length(), + "nine_stage_bits": nine.bit_length(), + } + + +def frame_paths(word): + frame_sets = [frozenset(frame) for frame in word["frames"]] + paths = [[frame] for frame in word["start"]] + for section in ("D", "A", "B", "C"): + for frame, dest, sources in word[section]: + for reg in (dest, *sources): + if paths[reg][-1] != frame: + need(frame_sets[paths[reg][-1]] < frame_sets[frame], + "nonmonotone frame path") + paths[reg].append(frame) + for reg, frame in enumerate(word["final"]): + if paths[reg][-1] != frame: + need(frame_sets[paths[reg][-1]] < frame_sets[frame], + "nonmonotone final frame path") + paths[reg].append(frame) + return paths + + +def owner_profile(word): + checker_path = ROOT / XCHECK_PATH + spec = importlib.util.spec_from_file_location("r439_pinned_xcheck", checker_path) + need(spec is not None and spec.loader is not None, "cannot load pinned xcheck_p.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + W, _, fl, hypotheses, conclusions, _ = module.check(word) + profile = Counter() + for path in frame_paths(word): + for a, b in zip(path, path[1:]): + profile[W.fdim[b] - W.fdim[a]] += 1 + profile.update(row["rank"] for row in fl["totals"]) + result = {int(k): int(profile[k]) for k in sorted(profile)} + mass = sum(k * count for k, count in result.items()) + return result, mass, hypotheses, conclusions + + +def terminal_restorations(word): + half = len(word["D"]) // 2 + out = [] + for index, gate in enumerate(word["D"]): + frame, dest, sources = gate + if index >= half and dest >= 2 * word["v"] and len(sources) == 1: + out.append((dest, sources[0], index)) + return out + + +def reciprocal_pairs(word, by_center): + first = {} + for center in by_center: + for i, (_, dest, sources) in enumerate(word["A"]): + if center in sources: + first[center] = (i, dest, list(sources)) + break + pairs = [] + for a, (i, c, sources) in first.items(): + if sources != [a] or c not in first: + continue + j, dest, other_sources = first[c] + if i < j and dest == a and other_sources == [c]: + pairs.append((a, c, i, j)) + return sorted(set(pairs)) + + +def omit_edges(word, edges): + result = copy.deepcopy(word) + half = len(result["D"]) // 2 + indices = [] + for a, b in edges: + matches = [i for i, gate in enumerate(result["D"]) + if i >= half and gate[1] == a and gate[2] == [b]] + need(len(matches) == 1, f"expected one terminal restoration {a}^{b}") + indices.extend(matches) + need(len(set(indices)) == len(indices), "duplicate restoration edge in omission set") + for index in sorted(indices, reverse=True): + result["D"].pop(index) + return result, sorted(indices) + + +def capture_a_snapshots(word): + n = 2 * word["v"] + word["R"] + rows = [1 << i for i in range(n)] + frames = list(word["start"]) + for frame, dest, sources in word["D"]: + for source in sources: + rows[dest] ^= rows[source] + for reg in (dest, *sources): + frames[reg] = frame + snapshots = [] + for frame, dest, sources in word["A"]: + snapshots.append((rows.copy(), frames.copy())) + for source in sources: + rows[dest] ^= rows[source] + for reg in (dest, *sources): + frames[reg] = frame + return snapshots + + +def gf2_basis(vectors): + pivots = {} + for vector in vectors: + value = vector + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + value ^= pivots[pivot] + else: + pivots[pivot] = value + break + return pivots + + +def in_basis(value, pivots): + value = int(value) + while value: + pivot = value.bit_length() - 1 + if pivot not in pivots: + return False + value ^= pivots[pivot] + return True + + +def solve_two(value, first, second): + return {0: (0, 0), first: (1, 0), second: (0, 1), + first ^ second: (1, 1)}.get(value) + + +def impulse_supports(word): + instructions = stream(word) + n = 2 * word["v"] + word["R"] + supports = [] + for gate_index, (_, dest, _) in enumerate(word["A"]): + offset = sum(len(gate[2]) for gate in word["D"]) + offset += sum(len(gate[2]) for gate in word["A"][:gate_index + 1]) + coefficients = [0] * (n + 1) + coefficients[dest] = 1 + for kind, d, s in instructions[offset:]: + if kind == "add": + coefficients[d] ^= coefficients[s] + elif kind == "copy": + coefficients[d] = coefficients[s] + else: + coefficients[d] = 0 + supports.append(sum(1 << i for i, bit in enumerate(coefficients[:n]) if bit)) + return supports + + +def impulse_to_source(word, earlier_gate, later_gate, source): + n = 2 * word["v"] + word["R"] + coefficients = [0] * n + coefficients[word["A"][earlier_gate][1]] = 1 + for gate_index in range(earlier_gate + 1, later_gate): + _, dest, sources = word["A"][gate_index] + for s in sources: + coefficients[dest] ^= coefficients[s] + return coefficients[source] + + +def source_actions(word, gate_index, target, snapshots): + _, dest, existing = word["A"][gate_index] + values, _ = snapshots[gate_index] + by_value = defaultdict(list) + for reg, value in enumerate(values): + by_value[value].append(reg) + actions = [] + for old in existing: + if values[old] == target: + actions.append(("remove", old, None, -1)) + for new in by_value.get(values[old] ^ target, []): + if new != dest and new not in existing: + actions.append(("replace", old, new, 0)) + for new in by_value.get(target, []): + if new != dest and new not in existing: + actions.append(("add", None, new, 1)) + unique = {} + for action in actions: + unique[action[:3]] = action + return list(unique.values()) + + +def interaction_parity(word, action, earlier_gate, later_gate): + operation, old, new, _ = action + if operation == "remove": + return impulse_to_source(word, earlier_gate, later_gate, old) + if operation == "add": + return impulse_to_source(word, earlier_gate, later_gate, new) + return (impulse_to_source(word, earlier_gate, later_gate, old) + ^ impulse_to_source(word, earlier_gate, later_gate, new)) + + +def apply_actions(word, edges, actions): + result, _ = omit_edges(word, edges) + by_gate = defaultdict(list) + for gate_index, action in actions: + by_gate[gate_index].append(action) + for gate_index, gate_actions in by_gate.items(): + sources = set(result["A"][gate_index][2]) + for operation, old, new, _ in gate_actions: + if operation == "remove": + need(old in sources, "removing a missing source tap") + sources.remove(old) + elif operation == "add": + need(new not in sources, "adding an existing source tap") + sources.add(new) + else: + need(old in sources and new not in sources, + "invalid source replacement") + sources.remove(old) + sources.add(new) + result["A"][gate_index][2] = sorted(sources) + return result + + +def one_edge_control(word): + result = copy.deepcopy(word) + half = len(result["D"]) // 2 + matches = [i for i, gate in enumerate(result["D"]) + if i >= half and gate[1] == 514 and gate[2] == [367]] + need(len(matches) == 1, "positive-control restoration pin") + result["D"].pop(matches[0]) + need(result["A"][304][1] == 514, "positive-control A writer pin") + result["A"][304][2] = [360] + return result + + +def wrong_one_edge_control(word): + result = copy.deepcopy(word) + half = len(result["D"]) // 2 + matches = [i for i, gate in enumerate(result["D"]) + if i >= half and gate[1] == 514 and gate[2] == [367]] + need(len(matches) == 1, "negative-control restoration pin") + result["D"].pop(matches[0]) + result["A"][304][2] = [361] + return result + + +def build_report(word): + base_forward = linear_map(word) + base_reverse = linear_map(word, reverse=True) + base_paths = frame_paths(word) + base_bill = integer_bill(word) + base_profile, base_mass, _, _ = owner_profile(word) + need(base_profile == PROFILE_EXPECTED and base_mass == 5129, + "pinned PR1062 parent paid profile") + + restorations = terminal_restorations(word) + by_center = defaultdict(list) + for center, leaf, index in restorations: + by_center[center].append(leaf) + pairs = reciprocal_pairs(word, by_center) + expected_pairs = [(643, 525, 1517, 1525), + (648, 526, 1496, 1502), + (650, 534, 1576, 1583)] + need(pairs == expected_pairs, "reciprocal singleton pair census changed") + + supports = impulse_supports(word) + case_reports = [] + all_gate_pairs = 0 + all_factorizations = 0 + all_action_pairs = 0 + for a, c, first_a, first_c in pairs: + for b in sorted(set(by_center[a])): + for d in sorted(set(by_center[c])): + edges = [(a, b), (c, d)] + omitted, d_indices = omit_edges(word, edges) + changed = [x ^ y for x, y in zip(base_forward, linear_map(omitted))] + changed_reverse = [x ^ y for x, y in zip(base_reverse, + linear_map(omitted, reverse=True))] + need(changed_reverse, "omission residual unexpectedly vanishes in reverse") + nonzero_rows = [(i, value) for i, value in enumerate(changed) if value] + columns = [sum(1 << i for i, row in enumerate(changed) + if (row >> col) & 1) for col in range(len(changed))] + colspace = gf2_basis(columns) + row_rank = len(gf2_basis(value for _, value in nonzero_rows)) + need(len(colspace) == 2 and row_rank == 2, + "two-restoration residual is not rank two") + need(len({value for _, value in nonzero_rows}) == 3, + "residual nonzero row syndrome count changed") + snapshots = capture_a_snapshots(omitted) + gates = [j for j, support in enumerate(supports) + if support and in_basis(support, colspace)] + support_values = sorted(set(supports[j] for j in gates)) + need(len(gates) == 6 and len(support_values) == 2, + "residual output-support gate census changed") + gate_pairs = [(j, k) for j in gates for k in gates + if j < k and supports[j] != supports[k]] + need(len(gate_pairs) == 5, + "candidate ordered gate-pair count changed") + case_factorizations = 0 + case_action_pairs = 0 + factor_rows = [] + for j, k in gate_pairs: + uj, uk = supports[j], supports[k] + for alpha in (0, 1): + basis_one = uj ^ (uk if alpha else 0) + basis_two = uk + q1 = 0 + q2 = 0 + valid = True + for col, vector in enumerate(columns): + coeff = solve_two(vector, basis_one, basis_two) + if coeff is None: + valid = False + break + if coeff[0]: + q1 |= 1 << col + if coeff[1]: + q2 |= 1 << col + need(valid, "rank-two support factorization failed") + case_factorizations += 1 + first_actions = source_actions(word, j, q1, snapshots) + second_actions = source_actions(word, k, q2, snapshots) + admissible = [] + for first_action in first_actions: + for second_action in second_actions: + alpha_actual = interaction_parity( + word, second_action, j, k) + cost = first_action[3] + second_action[3] + if alpha_actual == alpha and cost <= 1: + admissible.append((first_action, second_action, cost)) + case_action_pairs += len(admissible) + factor_rows.append({ + "first_gate": j, + "second_gate": k, + "interaction_parity": alpha, + "required_first_input_hex": format(q1, "x"), + "required_second_input_hex": format(q2, "x"), + "first_actions": len(first_actions), + "second_actions": len(second_actions), + "charged_action_pairs": len(admissible), + }) + for first_action, second_action, _cost in admissible: + candidate = apply_actions( + word, edges, [(j, first_action), (k, second_action)]) + need(linear_map(candidate) == base_forward + and linear_map(candidate, reverse=True) == base_reverse, + "factorized source actions do not repair both boundaries") + need(case_action_pairs == 0, + "a cost-admissible two-tap action pair exists") + all_gate_pairs += len(gate_pairs) + all_factorizations += case_factorizations + all_action_pairs += case_action_pairs + case_reports.append({ + "centers": [a, c], + "omitted_edges": edges, + "omitted_D_indices": d_indices, + "first_singleton_reads": [first_a, first_c], + "residual_rank": row_rank, + "affected_output_rows": len(nonzero_rows), + "distinct_nonzero_row_syndromes": len({v for _, v in nonzero_rows}), + "residual_row_weights": dict(sorted(Counter( + value.bit_count() for _, value in nonzero_rows).items())), + "nonzero_residual_rows": [ + {"output_register": i, "input_mask_hex": format(value, "x")} + for i, value in nonzero_rows], + "columnspace_basis_hex": [format(x, "x") + for x in sorted(colspace.values())], + "candidate_A_gates": gates, + "candidate_gate_supports": [ + {"gate": j, "output_registers": [i for i in range(len(changed)) + if (supports[j] >> i) & 1]} + for j in gates], + "distinct_candidate_supports": len(support_values), + "ordered_distinct_support_gate_pairs": len(gate_pairs), + "interaction_factorizations": case_factorizations, + "cost_admissible_source_action_pairs": case_action_pairs, + "factorizations": factor_rows, + "scalar_budget": { + "two_D_restorations_removed": -2, + "maximum_A_tap_delta_for_strict_saving": 1, + "A_actions_tested": ["remove", "add", "replace"], + "frame_availability": "relaxed: every register label considered", + }, + }) + need(all_gate_pairs == 20 and all_factorizations == 40 and all_action_pairs == 0, + "aggregate relay search counts changed") + + positive = one_edge_control(word) + need(linear_map(positive) == base_forward, "known absorption positive control forward") + need(linear_map(positive, reverse=True) == base_reverse, + "known absorption positive control reverse") + need(frame_paths(positive) == base_paths, + "known absorption positive control frame paths") + positive_bill = integer_bill(positive) + need(positive_bill["native_ADDs"] == 11499 and positive_bill["D_adds"] == 5547, + "known absorption positive-control scalar bill") + positive_profile, positive_mass, _, _ = owner_profile(positive) + need(positive_profile == base_profile and positive_mass == base_mass, + "known absorption positive-control paid profile") + + wrong = wrong_one_edge_control(word) + wrong_forward = linear_map(wrong) + wrong_diffs = sum(x != y for x, y in zip(wrong_forward, base_forward)) + need(wrong_diffs > 0, "wrong-donor negative control unexpectedly preserves map") + + return { + "schema_version": 1, + "kind": "scoped two-center in-flight defect relay obstruction", + "base_commit": BASE, + "selected_record_sha256": SELECTED_SHA256, + "catalogue_sha256": CATALOGUE_SHA256, + "candidate_path": CANDIDATE_PATH, + "candidate_sha256": sha256((ROOT / CANDIDATE_PATH).read_bytes()), + "source_word": { + "label": "PR1062 / r439-bsection-stars-seed01", + "native_ADDs": base_bill["native_ADDs"], + "D_adds": base_bill["D_adds"], + "A_adds": base_bill["A_adds"], + "formal_columns": len(base_forward), + "paid_profile": base_profile, + "paid_mass": base_mass, + "F": base_bill["F"], + "B": base_bill["B"], + "local_bits": base_bill["local_bits"], + "nine_stage_bits": base_bill["nine_stage_bits"], + }, + "reciprocal_singleton_pairs": [ + {"centers": [a, c], "first_reads": [i, j], + "terminal_leafs": [sorted(set(by_center[a])), sorted(set(by_center[c]))]} + for a, c, i, j in pairs], + "paired_omission_cases": case_reports, + "totals": { + "omission_cases": len(case_reports), + "rank_two_cases": sum(c["residual_rank"] == 2 for c in case_reports), + "gate_pairs": all_gate_pairs, + "interaction_factorizations": all_factorizations, + "cost_admissible_action_pairs": all_action_pairs, + "accepted_new_constructions": 0, + "scope_limit": "two restorations at one reciprocal pair; at most two A tap edits on distinct gates; total A tap delta <= +1", + }, + "controls": { + "known_absorption_positive": { + "edge": [514, 367], + "A_writer": 304, + "new_sources": [360], + "forward_and_reverse_equal_parent": True, + "frame_paths_equal_parent": True, + "native_ADDs": positive_bill["native_ADDs"], + "D_adds": positive_bill["D_adds"], + "F": positive_bill["F"], + "B": positive_bill["B"], + "local_bits": positive_bill["local_bits"], + "nine_stage_bits": positive_bill["nine_stage_bits"], + "profile": positive_profile, + "paid_mass": positive_mass, + }, + "wrong_source_negative": { + "edge": [514, 367], "A_writer": 304, "wrong_sources": [361], + "changed_forward_output_rows": wrong_diffs, + "rejected": True, + }, + }, + "claim_status": "No advance claim posted; report as FINDING/DONE per autoresearch.md.", + "no_new_kappa": True, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-certificate", action="store_true") + args = parser.parse_args() + report = build_report(load_word()) + path = HERE / "CERTIFICATE.json" + payload = json.dumps(report, indent=2, sort_keys=True) + "\n" + if args.write_certificate: + path.write_text(payload, encoding="utf-8") + else: + need(path.is_file(), "missing CERTIFICATE.json; run --write-certificate") + need(path.read_text(encoding="utf-8") == payload, + "certificate differs from deterministic replay") + print("PASS_R439_TWO_CENTER_DEFECT_RELAY cases=4 rank2=4 gate_pairs=20 " + "factorizations=40 admissible_pairs=0 positive_control=1 no_new_kappa") + + +if __name__ == "__main__": + main()