From b512fd71e9eb5711d24abaa35978660eeb87f363 Mon Sep 17 00:00:00 2001 From: ross Date: Tue, 20 Oct 2026 23:37:50 +1100 Subject: [PATCH] Prove sharp fixed BIT repairs and a two-code hybrid controller --- .../ADAPTATIONS.md | 42 + .../CONTROLS.json | 605 +++++ .../CORE-SNAPSHOT.json | 313 +++ .../CROSS-REVIEW-HYBRID.md | 91 + .../CROSS-REVIEW-RECIPE.md | 56 + .../EVIDENCE-INDEX.md | 32 + .../FROZEN-SHA256.json | 24 + research/bit-fixed-controller-repairs/LICENSE | 201 ++ .../bit-fixed-controller-repairs/ORIGINS.json | 94 + .../PROOF-HYBRID.md | 286 +++ .../PROOF-RECIPE.md | 231 ++ .../bit-fixed-controller-repairs/README.md | 184 ++ .../RELATED-WORK.json | 69 + .../REVIEW-HYBRID.md | 76 + .../REVIEW-RECIPE.md | 116 + .../REVIEW-VERIFICATION.md | 142 ++ .../SOURCE-AUDIT.md | 112 + .../SOURCE-CLOSURE.json | 159 ++ .../bit-fixed-controller-repairs/SOURCES.json | 60 + .../bit-fixed-controller-repairs/TASK.json | 96 + .../bit-fixed-controller-repairs/VERIFY.json | 60 + .../bit-fixed-controller-repairs/controls.py | 458 ++++ .../frozen/geometry/E8.json.gz | Bin 0 -> 33865 bytes .../frozen/geometry/MATRICES.json | 1118 +++++++++ .../frozen/geometry/R438.json.gz | Bin 0 -> 42305 bytes .../frozen/hybrid/CLOSED-HYBRID.json | 670 ++++++ .../frozen/hybrid/EARLY-PROMOTION.json | 93 + .../frozen/hybrid/README.md | 180 ++ .../frozen/hybrid/closed_hybrid.py | 325 +++ .../frozen/hybrid/early_promotion.py | 97 + .../frozen/provenance/bit_cap_copy_local.py | 162 ++ .../frozen/recipe/BIT-NILPOTENT-RECIPE.json | 2020 +++++++++++++++++ .../frozen/recipe/bit_nilpotent_recipe.py | 48 + .../frozen/recipe/bit_seeded_star.py | 84 + .../frozen/reviews/hybrid/CHECKS.json.gz | Bin 0 -> 13719 bytes .../reviews/hybrid/SOURCE-DEPENDENCIES.json | 36 + .../frozen/reviews/hybrid/VALIDATION.json | 90 + .../frozen/reviews/hybrid/check.py | 594 +++++ .../frozen/reviews/recipe/CHECKS.json.gz | Bin 0 -> 10228 bytes .../reviews/recipe/SOURCE-DEPENDENCIES.json | 31 + .../frozen/reviews/recipe/VALIDATION.json | 63 + .../frozen/reviews/recipe/check.py | 410 ++++ .../frozen/routes/expanded_sections.py | 139 ++ .../frozen/upstream/global_k.py | 264 +++ .../bit-fixed-controller-repairs/verify.py | 234 ++ 45 files changed, 10165 insertions(+) create mode 100644 research/bit-fixed-controller-repairs/ADAPTATIONS.md create mode 100644 research/bit-fixed-controller-repairs/CONTROLS.json create mode 100644 research/bit-fixed-controller-repairs/CORE-SNAPSHOT.json create mode 100644 research/bit-fixed-controller-repairs/CROSS-REVIEW-HYBRID.md create mode 100644 research/bit-fixed-controller-repairs/CROSS-REVIEW-RECIPE.md create mode 100644 research/bit-fixed-controller-repairs/EVIDENCE-INDEX.md create mode 100644 research/bit-fixed-controller-repairs/FROZEN-SHA256.json create mode 100644 research/bit-fixed-controller-repairs/LICENSE create mode 100644 research/bit-fixed-controller-repairs/ORIGINS.json create mode 100644 research/bit-fixed-controller-repairs/PROOF-HYBRID.md create mode 100644 research/bit-fixed-controller-repairs/PROOF-RECIPE.md create mode 100644 research/bit-fixed-controller-repairs/README.md create mode 100644 research/bit-fixed-controller-repairs/RELATED-WORK.json create mode 100644 research/bit-fixed-controller-repairs/REVIEW-HYBRID.md create mode 100644 research/bit-fixed-controller-repairs/REVIEW-RECIPE.md create mode 100644 research/bit-fixed-controller-repairs/REVIEW-VERIFICATION.md create mode 100644 research/bit-fixed-controller-repairs/SOURCE-AUDIT.md create mode 100644 research/bit-fixed-controller-repairs/SOURCE-CLOSURE.json create mode 100644 research/bit-fixed-controller-repairs/SOURCES.json create mode 100644 research/bit-fixed-controller-repairs/TASK.json create mode 100644 research/bit-fixed-controller-repairs/VERIFY.json create mode 100644 research/bit-fixed-controller-repairs/controls.py create mode 100644 research/bit-fixed-controller-repairs/frozen/geometry/E8.json.gz create mode 100644 research/bit-fixed-controller-repairs/frozen/geometry/MATRICES.json create mode 100644 research/bit-fixed-controller-repairs/frozen/geometry/R438.json.gz create mode 100644 research/bit-fixed-controller-repairs/frozen/hybrid/CLOSED-HYBRID.json create mode 100644 research/bit-fixed-controller-repairs/frozen/hybrid/EARLY-PROMOTION.json create mode 100644 research/bit-fixed-controller-repairs/frozen/hybrid/README.md create mode 100644 research/bit-fixed-controller-repairs/frozen/hybrid/closed_hybrid.py create mode 100644 research/bit-fixed-controller-repairs/frozen/hybrid/early_promotion.py create mode 100644 research/bit-fixed-controller-repairs/frozen/provenance/bit_cap_copy_local.py create mode 100644 research/bit-fixed-controller-repairs/frozen/recipe/BIT-NILPOTENT-RECIPE.json create mode 100644 research/bit-fixed-controller-repairs/frozen/recipe/bit_nilpotent_recipe.py create mode 100644 research/bit-fixed-controller-repairs/frozen/recipe/bit_seeded_star.py create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/hybrid/CHECKS.json.gz create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/hybrid/VALIDATION.json create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/hybrid/check.py create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/recipe/CHECKS.json.gz create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/recipe/SOURCE-DEPENDENCIES.json create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/recipe/VALIDATION.json create mode 100644 research/bit-fixed-controller-repairs/frozen/reviews/recipe/check.py create mode 100644 research/bit-fixed-controller-repairs/frozen/routes/expanded_sections.py create mode 100644 research/bit-fixed-controller-repairs/frozen/upstream/global_k.py create mode 100644 research/bit-fixed-controller-repairs/verify.py diff --git a/research/bit-fixed-controller-repairs/ADAPTATIONS.md b/research/bit-fixed-controller-repairs/ADAPTATIONS.md new file mode 100644 index 0000000000..1cf08cc76b --- /dev/null +++ b/research/bit-fixed-controller-repairs/ADAPTATIONS.md @@ -0,0 +1,42 @@ +# Replay adaptations + +The frozen historical code and data are unchanged. Original imports, absolute +path constants and command-line entrypoints are not imported wholesale. +`verify.py` authenticates each selected file against `FROZEN-SHA256.json`, +selects unique named top-level definitions and compiles those definitions +with `dont_inherit=True, optimize=0`. + +The inherited nested recipe loaders still select the original `recipe` +definition. Their supplied AST parser requires that definition to be unique, +and their supplied compiler also forces assertions on under optimized Python. +Only the recipe executes from the original `global_k.py`; its imports and +other top-level code do not execute. + +Every retained historical source read uses an explicit `SourcePath` mapping. +Its only I/O authenticates the declared frozen bytes anew. This covers the +recipe, matrix input, R438 word, full E8 root word and route-generator hash. +The original unique literal `RAW_SHA` is parsed from the retained +`bit_cap_copy_local.py` and must agree with the frozen R438 input. No function +from that cap-copy file runs. + +The original closed-hybrid `receipt()` is evaluated directly. The original +nilpotent and early-promotion generators run their selected `main()` with +`--write` and a temporary output directory outside the package. Those complete +fresh JSON values are compared against the three frozen receipts with a typed +canonical serialization, preserving every field and list position. +The old Python dictionary-equality acceptance paths are therefore not the +publication acceptance check. + +Only `need`, `mul`, `plus`, `scale` and `ident` are selected from the seeded-star +file. Its main program and unused `inverse_event` stub do not execute. That +stub's broad involution comment does not describe the new-F primitive and is +not used as a premise. + +The independent checkers receive only explicit input paths and external output +paths. Their complete modules are compiled from authenticated bytes with +assertions enabled. Every full generated receipt is compared, and the frozen +inventory is checked again after each stage. + +These are loading and acceptance adaptations. They do not alter the old +mathematical functions, discard receipt fields or turn an imported native +premise into a proof. diff --git a/research/bit-fixed-controller-repairs/CONTROLS.json b/research/bit-fixed-controller-repairs/CONTROLS.json new file mode 100644 index 0000000000..8bfab44796 --- /dev/null +++ b/research/bit-fixed-controller-repairs/CONTROLS.json @@ -0,0 +1,605 @@ +{ + "no_new_kappa": true, + "route_census_or_general_B_replayed": false, + "runs": [ + { + "complete_real_receipts": [ + { + "mutated_nested_path": [ + "controls", + 0, + "defect", + 0, + 2, + 0, + 0 + ], + "receipt": "frozen/hybrid/CLOSED-HYBRID.json", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/hybrid/CLOSED-HYBRID.json" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/hybrid/CLOSED-HYBRID.json" + } + ], + "sha256": "f12bf6aabe9ea0cb058eab5d68f10886cddff6200f7e00b40c048f4cf01689b7" + }, + { + "mutated_nested_path": [ + "code_offdiagonal", + "coefficient" + ], + "receipt": "frozen/hybrid/EARLY-PROMOTION.json", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/hybrid/EARLY-PROMOTION.json" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/hybrid/EARLY-PROMOTION.json" + } + ], + "sha256": "c278d5bd9cca084cbeae5212b73afa5f03461ecb4af9e18608bda0c54c89a2d6" + }, + { + "mutated_nested_path": [ + "cases", + 0, + "epsilon_matrix_A", + 0, + 0 + ], + "receipt": "frozen/recipe/BIT-NILPOTENT-RECIPE.json", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/recipe/BIT-NILPOTENT-RECIPE.json" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/recipe/BIT-NILPOTENT-RECIPE.json" + } + ], + "sha256": "ef97f43313ccffb7a8ea5965d37b37452b70cf4ccfbafe81e9e92e46d0f1a14a" + }, + { + "mutated_nested_path": [ + "cases", + 0, + "instantiations", + 0, + "N_rows", + 0 + ], + "receipt": "frozen/reviews/recipe/CHECKS.json.gz", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/reviews/recipe/CHECKS.json.gz" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/reviews/recipe/CHECKS.json.gz" + } + ], + "sha256": "cff40bd8d82e7919b9a1a76c03389bc0a82c9156d162198faf6132eac4691359" + }, + { + "mutated_nested_path": [ + "cases", + 0, + "preterminal", + 0, + 0, + 1, + 0 + ], + "receipt": "frozen/reviews/hybrid/CHECKS.json.gz", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/reviews/hybrid/CHECKS.json.gz" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/reviews/hybrid/CHECKS.json.gz" + } + ], + "sha256": "8a76a7141b4851084923e87c8f17bc8c02db6543d7614bc2c911e45e43a0ef8f" + } + ], + "compressed_original_binding": { + "equivalent_storage_with_same_original_accepted": true, + "rejections": [ + { + "name": "changed_compressed_bytes", + "reason": "frozen input changed: frozen/original.json.gz" + }, + { + "name": "origin_container_hash_mismatch", + "reason": "origin container binding differs" + }, + { + "name": "changed_decompressed_original", + "reason": "compressed original bytes changed: frozen/original.json.gz" + }, + { + "name": "origin_inventory_omission", + "reason": "origin and frozen inventories differ" + } + ] + }, + "literal_source_pin": { + "actual_original_pin_matches": true, + "rejections": [ + { + "name": "missing_literal_pin", + "reason": "original RAW_SHA binding must be unique" + }, + { + "name": "duplicate_literal_pin", + "reason": "original RAW_SHA binding must be unique" + }, + { + "name": "wrong_literal_pin_type", + "reason": "original RAW_SHA is not a digest" + }, + { + "name": "executable_pin_expression", + "reason": "malformed node or string on line 1: " + } + ] + }, + "mathematical_controls": { + "actual_authenticated_function": "closed_hybrid.receipt", + "coefficient_ring": "Z[free group(a0,...,a8)]", + "deleted_named_check_detected": true, + "formal_input_rows": 8, + "one_literal_inverse_code_direction_changed_after_authentication": true, + "rejections": [ + { + "name": "one_actual_inverse_code_runs_forward", + "reason": "literal reverse-inverse cleanup" + }, + { + "name": "independent_control_rejects_unrelated_error", + "reason": "wrong rejection for unrelated_fixture" + } + ] + }, + "nested_sources": { + "only_authenticated_mapped_reads": true, + "original_imports_and_top_level_excluded": true, + "rejections": [ + { + "name": "undeclared_logical_read", + "reason": "undeclared historical source read: missing" + }, + { + "name": "absolute_path_escape", + "reason": "undeclared historical source read: /etc/passwd" + }, + { + "name": "relative_path_escape", + "reason": "undeclared historical source read: ../outside" + }, + { + "name": "mapped_unregistered_input", + "reason": "unregistered frozen input: frozen/unregistered.py" + }, + { + "name": "nested_recipe_assert_under_parent_flags", + "reason": "NESTED_RECIPE_ASSERT" + }, + { + "name": "duplicate_nested_recipe", + "reason": "recipe definition must be unique" + }, + { + "name": "missing_nested_recipe", + "reason": "recipe definition must be unique" + }, + { + "name": "mapped_changed_bytes", + "reason": "frozen input changed: frozen/recipe.py" + }, + { + "name": "mapped_missing_file", + "reason": "[Errno 2] No such file or directory: '/private/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/b07-controls-07cy0gl3/nested/frozen/recipe.py'" + } + ] + }, + "parent_optimization": 0, + "receipt_contract": { + "deleted_named_check_detected": true, + "rejections": [ + { + "name": "boolean_for_integer", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "float_for_integer", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "integer_for_boolean", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "nested_omission", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "list_reordering", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "list_truncation", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "missing_fixed_receipt", + "reason": "[Errno 2] No such file or directory: '/private/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/b07-controls-07cy0gl3/receipt/frozen/receipt.json'" + } + ] + }, + "source_selection": { + "imports_top_level_and_main_excluded": true, + "rejections": [ + { + "name": "direct_runtime_gate_under_parent_flags", + "reason": "DIRECT_RUNTIME_GATE" + }, + { + "name": "extracted_assert_under_parent_flags", + "reason": "EXTRACTED_ASSERT" + }, + { + "name": "nested_assert_under_parent_flags", + "reason": "NESTED_ASSERT" + }, + { + "name": "authenticated_module_assert_under_parent_flags", + "reason": "MODULE_ASSERT" + }, + { + "name": "changed_authenticated_module", + "reason": "frozen input changed: frozen/module.py" + }, + { + "name": "missing_named_definition", + "reason": "function selection changed" + }, + { + "name": "duplicate_source_definition", + "reason": "function selection changed" + }, + { + "name": "duplicate_requested_name", + "reason": "function selection changed" + }, + { + "name": "unregistered_source", + "reason": "unregistered frozen input: frozen/unknown.py" + }, + { + "name": "changed_authenticated_source", + "reason": "frozen input changed: frozen/source.py" + }, + { + "name": "missing_registered_source", + "reason": "[Errno 2] No such file or directory: '/private/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/b07-controls-07cy0gl3/source/frozen/source.py'" + } + ] + }, + "verifier_sha256": "f8954d6b6c8b5ad0a9b228adac60cbd6f798a1f8958a669877e149f8a48dff9b" + }, + { + "complete_real_receipts": [ + { + "mutated_nested_path": [ + "controls", + 0, + "defect", + 0, + 2, + 0, + 0 + ], + "receipt": "frozen/hybrid/CLOSED-HYBRID.json", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/hybrid/CLOSED-HYBRID.json" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/hybrid/CLOSED-HYBRID.json" + } + ], + "sha256": "f12bf6aabe9ea0cb058eab5d68f10886cddff6200f7e00b40c048f4cf01689b7" + }, + { + "mutated_nested_path": [ + "code_offdiagonal", + "coefficient" + ], + "receipt": "frozen/hybrid/EARLY-PROMOTION.json", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/hybrid/EARLY-PROMOTION.json" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/hybrid/EARLY-PROMOTION.json" + } + ], + "sha256": "c278d5bd9cca084cbeae5212b73afa5f03461ecb4af9e18608bda0c54c89a2d6" + }, + { + "mutated_nested_path": [ + "cases", + 0, + "epsilon_matrix_A", + 0, + 0 + ], + "receipt": "frozen/recipe/BIT-NILPOTENT-RECIPE.json", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/recipe/BIT-NILPOTENT-RECIPE.json" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/recipe/BIT-NILPOTENT-RECIPE.json" + } + ], + "sha256": "ef97f43313ccffb7a8ea5965d37b37452b70cf4ccfbafe81e9e92e46d0f1a14a" + }, + { + "mutated_nested_path": [ + "cases", + 0, + "instantiations", + 0, + "N_rows", + 0 + ], + "receipt": "frozen/reviews/recipe/CHECKS.json.gz", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/reviews/recipe/CHECKS.json.gz" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/reviews/recipe/CHECKS.json.gz" + } + ], + "sha256": "cff40bd8d82e7919b9a1a76c03389bc0a82c9156d162198faf6132eac4691359" + }, + { + "mutated_nested_path": [ + "cases", + 0, + "preterminal", + 0, + 0, + 1, + 0 + ], + "receipt": "frozen/reviews/hybrid/CHECKS.json.gz", + "rejections": [ + { + "name": "real_nested_field_mutation", + "reason": "complete receipt mismatch: frozen/reviews/hybrid/CHECKS.json.gz" + }, + { + "name": "real_nested_field_omission", + "reason": "complete receipt mismatch: frozen/reviews/hybrid/CHECKS.json.gz" + } + ], + "sha256": "8a76a7141b4851084923e87c8f17bc8c02db6543d7614bc2c911e45e43a0ef8f" + } + ], + "compressed_original_binding": { + "equivalent_storage_with_same_original_accepted": true, + "rejections": [ + { + "name": "changed_compressed_bytes", + "reason": "frozen input changed: frozen/original.json.gz" + }, + { + "name": "origin_container_hash_mismatch", + "reason": "origin container binding differs" + }, + { + "name": "changed_decompressed_original", + "reason": "compressed original bytes changed: frozen/original.json.gz" + }, + { + "name": "origin_inventory_omission", + "reason": "origin and frozen inventories differ" + } + ] + }, + "literal_source_pin": { + "actual_original_pin_matches": true, + "rejections": [ + { + "name": "missing_literal_pin", + "reason": "original RAW_SHA binding must be unique" + }, + { + "name": "duplicate_literal_pin", + "reason": "original RAW_SHA binding must be unique" + }, + { + "name": "wrong_literal_pin_type", + "reason": "original RAW_SHA is not a digest" + }, + { + "name": "executable_pin_expression", + "reason": "malformed node or string on line 1: " + } + ] + }, + "mathematical_controls": { + "actual_authenticated_function": "closed_hybrid.receipt", + "coefficient_ring": "Z[free group(a0,...,a8)]", + "deleted_named_check_detected": true, + "formal_input_rows": 8, + "one_literal_inverse_code_direction_changed_after_authentication": true, + "rejections": [ + { + "name": "one_actual_inverse_code_runs_forward", + "reason": "literal reverse-inverse cleanup" + }, + { + "name": "independent_control_rejects_unrelated_error", + "reason": "wrong rejection for unrelated_fixture" + } + ] + }, + "nested_sources": { + "only_authenticated_mapped_reads": true, + "original_imports_and_top_level_excluded": true, + "rejections": [ + { + "name": "undeclared_logical_read", + "reason": "undeclared historical source read: missing" + }, + { + "name": "absolute_path_escape", + "reason": "undeclared historical source read: /etc/passwd" + }, + { + "name": "relative_path_escape", + "reason": "undeclared historical source read: ../outside" + }, + { + "name": "mapped_unregistered_input", + "reason": "unregistered frozen input: frozen/unregistered.py" + }, + { + "name": "nested_recipe_assert_under_parent_flags", + "reason": "NESTED_RECIPE_ASSERT" + }, + { + "name": "duplicate_nested_recipe", + "reason": "recipe definition must be unique" + }, + { + "name": "missing_nested_recipe", + "reason": "recipe definition must be unique" + }, + { + "name": "mapped_changed_bytes", + "reason": "frozen input changed: frozen/recipe.py" + }, + { + "name": "mapped_missing_file", + "reason": "[Errno 2] No such file or directory: '/private/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/b07-controls-dpr7hs5w/nested/frozen/recipe.py'" + } + ] + }, + "parent_optimization": 1, + "receipt_contract": { + "deleted_named_check_detected": true, + "rejections": [ + { + "name": "boolean_for_integer", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "float_for_integer", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "integer_for_boolean", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "nested_omission", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "list_reordering", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "list_truncation", + "reason": "complete receipt mismatch: frozen/receipt.json" + }, + { + "name": "missing_fixed_receipt", + "reason": "[Errno 2] No such file or directory: '/private/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/b07-controls-dpr7hs5w/receipt/frozen/receipt.json'" + } + ] + }, + "source_selection": { + "imports_top_level_and_main_excluded": true, + "rejections": [ + { + "name": "direct_runtime_gate_under_parent_flags", + "reason": "DIRECT_RUNTIME_GATE" + }, + { + "name": "extracted_assert_under_parent_flags", + "reason": "EXTRACTED_ASSERT" + }, + { + "name": "nested_assert_under_parent_flags", + "reason": "NESTED_ASSERT" + }, + { + "name": "authenticated_module_assert_under_parent_flags", + "reason": "MODULE_ASSERT" + }, + { + "name": "changed_authenticated_module", + "reason": "frozen input changed: frozen/module.py" + }, + { + "name": "missing_named_definition", + "reason": "function selection changed" + }, + { + "name": "duplicate_source_definition", + "reason": "function selection changed" + }, + { + "name": "duplicate_requested_name", + "reason": "function selection changed" + }, + { + "name": "unregistered_source", + "reason": "unregistered frozen input: frozen/unknown.py" + }, + { + "name": "changed_authenticated_source", + "reason": "frozen input changed: frozen/source.py" + }, + { + "name": "missing_registered_source", + "reason": "[Errno 2] No such file or directory: '/private/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/b07-controls-dpr7hs5w/source/frozen/source.py'" + } + ] + }, + "verifier_sha256": "f8954d6b6c8b5ad0a9b228adac60cbd6f798a1f8958a669877e149f8a48dff9b" + } + ], + "small_fixed_hybrid_word_replayed": true, + "source_hashes": { + "FROZEN-SHA256.json": "fcd33e728f973cca005a80d385952fc823340d2144a3dfc1e565d2af299937ce", + "ORIGINS.json": "f8097548bee9a85d78344cfabc495f0e3e1d0b4f5093ae3e54bc34dafe560d10", + "verify.py": "f8954d6b6c8b5ad0a9b228adac60cbd6f798a1f8958a669877e149f8a48dff9b" + }, + "status": "PASS_B07_COMPACT_SOURCE_AND_MATHEMATICAL_GATES" +} diff --git a/research/bit-fixed-controller-repairs/CORE-SNAPSHOT.json b/research/bit-fixed-controller-repairs/CORE-SNAPSHOT.json new file mode 100644 index 0000000000..54f190ad51 --- /dev/null +++ b/research/bit-fixed-controller-repairs/CORE-SNAPSHOT.json @@ -0,0 +1,313 @@ +{ + "controls": { + "complete_scientific_receipts": [ + "frozen/hybrid/CLOSED-HYBRID.json", + "frozen/hybrid/EARLY-PROMOTION.json", + "frozen/recipe/BIT-NILPOTENT-RECIPE.json", + "frozen/reviews/recipe/CHECKS.json.gz", + "frozen/reviews/hybrid/CHECKS.json.gz" + ], + "mode_results": [ + { + "complete_real_receipts": 5, + "deliberate_named_check_deletions_detected": 2, + "intended_rejections": 47, + "optimization": 0 + }, + { + "complete_real_receipts": 5, + "deliberate_named_check_deletions_detected": 2, + "intended_rejections": 47, + "optimization": 1 + } + ], + "path": "CONTROLS.json", + "sha256": "536efef62a0e72a3872923aa50b63bafe694b9dd5f76b0f259458c1e71a6491a", + "source_hashes": { + "FROZEN-SHA256.json": "fcd33e728f973cca005a80d385952fc823340d2144a3dfc1e565d2af299937ce", + "ORIGINS.json": "f8097548bee9a85d78344cfabc495f0e3e1d0b4f5093ae3e54bc34dafe560d10", + "verify.py": "f8954d6b6c8b5ad0a9b228adac60cbd6f798a1f8958a669877e149f8a48dff9b" + } + }, + "core_digest_definition": "SHA256 of UTF-8 JSON for files, sorted keys, compact separators, ensure_ascii=False.", + "core_file_count": 43, + "core_sha256": "24737c4b7c55fcf5449784673c86df0a0797798de895ecfd4cab1c87c1922ae3", + "excluded_from_core_inventory": [ + "CONTROLS.json", + "CORE-SNAPSHOT.json" + ], + "execution_scope": { + "compact_normal_and_optimized_controls_replayed": true, + "full_registered_mathematical_stages_replayed_by_this_reviewer": false, + "full_route_census_or_general_B_checker_replayed_by_this_reviewer": false, + "parent_owns_registered_committed_and_git_free_replays": true, + "small_authenticated_historical_hybrid_word_replayed": true + }, + "files": { + "ADAPTATIONS.md": { + "bytes": 2283, + "sha256": "0837fc5e0eea52bfde77010d3ea10ad9ceba9ed282b423be5a2071f6ddf43c69" + }, + "CROSS-REVIEW-HYBRID.md": { + "bytes": 4903, + "sha256": "5453581d5da37b6cee6795c09b97e249975efce0e01adc8cbb8e4c52b0a16ce3" + }, + "CROSS-REVIEW-RECIPE.md": { + "bytes": 3164, + "sha256": "a94059f471e7f429aeb44f490145213a84ee9e2538f9784fbb3900578e5355c5" + }, + "EVIDENCE-INDEX.md": { + "bytes": 2834, + "sha256": "4e44ec544aa1e63f4a6425ed4a1f6f7c85e8a8f57046882065a6c3de7639dc5c" + }, + "FROZEN-SHA256.json": { + "bytes": 2371, + "sha256": "fcd33e728f973cca005a80d385952fc823340d2144a3dfc1e565d2af299937ce" + }, + "LICENSE": { + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "ORIGINS.json": { + "bytes": 6190, + "sha256": "f8097548bee9a85d78344cfabc495f0e3e1d0b4f5093ae3e54bc34dafe560d10" + }, + "PROOF-HYBRID.md": { + "bytes": 12773, + "sha256": "3f90c6c169d48b567ba1d406db058662cf18d1ca823acb5bdc18e16d180db732" + }, + "PROOF-RECIPE.md": { + "bytes": 9626, + "sha256": "6cd7ce069671ee2f15f6a39aca7b12dc537d1c726e9c3a2ff807ff0fa7a24abb" + }, + "README.md": { + "bytes": 8331, + "sha256": "5b97d9f6261ec3c6a6bc4b5da69bc8fba503a36fb71b31f54b3e227480aac623" + }, + "RELATED-WORK.json": { + "bytes": 2601, + "sha256": "449734127e0500bed692c3f74386d0af83812dcb257d5e09641eb3af25e154a8" + }, + "REVIEW-HYBRID.md": { + "bytes": 4366, + "sha256": "367f780480a09cfe25f34fa28b44132cfa91d61d51d1fdb43b496110ffd318d1" + }, + "REVIEW-RECIPE.md": { + "bytes": 6383, + "sha256": "276d9bd94e6cab720ba268766c33d07564c4c26ed6d1480787d1dbb8fe635065" + }, + "REVIEW-VERIFICATION.md": { + "bytes": 8058, + "sha256": "f552f52177951e444c69aa986cf3831459ff6e2b023d238f82b20a7e08b1d0b4" + }, + "SOURCE-AUDIT.md": { + "bytes": 6359, + "sha256": "34edf54a73c1dec50192d1e45fe293a653b3d42c57678fe8303178c7a1ded77b" + }, + "SOURCE-CLOSURE.json": { + "bytes": 6690, + "sha256": "616a5fe1eed5865f344cc710b73fd2c5f04538d8f7c150d42bae37b323e6ecb3" + }, + "SOURCES.json": { + "bytes": 2420, + "sha256": "d41f2f4b5cae44707841b2e7f8b543ba0dd67fbc7a397e26111a10ece8134eb0" + }, + "TASK.json": { + "bytes": 6910, + "sha256": "46b4409bc2c11b2c461b25909fd15c375d4a68468d55342e542ca1ce3d4bbbec" + }, + "VERIFY.json": { + "bytes": 1572, + "sha256": "4085de4462380724d2667e4c4ff1fab8edbdabe0ff34503a1035df30e9807e38" + }, + "controls.py": { + "bytes": 21199, + "sha256": "006ee774848108ffea2c71898e792e109f0ce242e0a1979ab7e6684d6560e83d" + }, + "frozen/geometry/E8.json.gz": { + "bytes": 33865, + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "frozen/geometry/MATRICES.json": { + "bytes": 28228, + "sha256": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979" + }, + "frozen/geometry/R438.json.gz": { + "bytes": 42305, + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "frozen/hybrid/CLOSED-HYBRID.json": { + "bytes": 10950, + "sha256": "f12bf6aabe9ea0cb058eab5d68f10886cddff6200f7e00b40c048f4cf01689b7" + }, + "frozen/hybrid/EARLY-PROMOTION.json": { + "bytes": 2226, + "sha256": "c278d5bd9cca084cbeae5212b73afa5f03461ecb4af9e18608bda0c54c89a2d6" + }, + "frozen/hybrid/README.md": { + "bytes": 8657, + "sha256": "0206fc9c9950e04baf4b9395af0a1e0b9a99907900b328eb06eb48477703ea24" + }, + "frozen/hybrid/closed_hybrid.py": { + "bytes": 13193, + "sha256": "78f92b8b8fdb6528bd87f974f3022e73c9b60877f0022200fe0b4422da2b7738" + }, + "frozen/hybrid/early_promotion.py": { + "bytes": 4771, + "sha256": "d59e5487251929416fa657f45e617d78a3392310203f1df08389d3746acd6732" + }, + "frozen/provenance/bit_cap_copy_local.py": { + "bytes": 7588, + "sha256": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb" + }, + "frozen/recipe/BIT-NILPOTENT-RECIPE.json": { + "bytes": 30914, + "sha256": "ef97f43313ccffb7a8ea5965d37b37452b70cf4ccfbafe81e9e92e46d0f1a14a" + }, + "frozen/recipe/bit_nilpotent_recipe.py": { + "bytes": 3727, + "sha256": "d2649a223c4fd221e64dc059422bcf796fbe1becc524911c7e84c0cf475b2b7e" + }, + "frozen/recipe/bit_seeded_star.py": { + "bytes": 6317, + "sha256": "91d3bbebfad36836b48949a2d231afd3eb8dd46f0443d45f7e19ff9779468347" + }, + "frozen/reviews/hybrid/CHECKS.json.gz": { + "bytes": 13719, + "sha256": "8a76a7141b4851084923e87c8f17bc8c02db6543d7614bc2c911e45e43a0ef8f" + }, + "frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json": { + "bytes": 1889, + "sha256": "a2c1fd731281a3f1360e95a70d426f59332e6482155c6190dc3ac49d37b42ec2" + }, + "frozen/reviews/hybrid/VALIDATION.json": { + "bytes": 5160, + "sha256": "ebd5d303781781850cac8e4b76d31f24b63fcd90cf0f2132128b222ba093c221" + }, + "frozen/reviews/hybrid/check.py": { + "bytes": 27225, + "sha256": "148b456444486d4fde75c83d20717aef7dcd2c6aef31adb009035f834c530138" + }, + "frozen/reviews/recipe/CHECKS.json.gz": { + "bytes": 10228, + "sha256": "cff40bd8d82e7919b9a1a76c03389bc0a82c9156d162198faf6132eac4691359" + }, + "frozen/reviews/recipe/SOURCE-DEPENDENCIES.json": { + "bytes": 1720, + "sha256": "4eb24d806c09d957c7dca375393634100f6cfacf999bff49845314e131acad20" + }, + "frozen/reviews/recipe/VALIDATION.json": { + "bytes": 1973, + "sha256": "db3d1cba36f98efc8330b19e0df8e5ad086145aeaa487703cac539a10d9f6062" + }, + "frozen/reviews/recipe/check.py": { + "bytes": 17005, + "sha256": "50ef2041dc27c11189e0f4293cd30aed2ee372b1a6e928dbe6197e21ceab75de" + }, + "frozen/routes/expanded_sections.py": { + "bytes": 8284, + "sha256": "b5b0f01da04d95ccaae56cfb503bbf12bdd47442a924802c280089acc564795b" + }, + "frozen/upstream/global_k.py": { + "bytes": 16791, + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "verify.py": { + "bytes": 10294, + "sha256": "f8954d6b6c8b5ad0a9b228adac60cbd6f798a1f8958a669877e149f8a48dff9b" + } + }, + "frozen_file_count": 22, + "limits": [ + "Written all-B proofs are distinct from finite exact checker domains.", + "Fixed common-involution repair and signed independent-label hybrid use separate alphabets.", + "Deleted normalization controls check a declared invoice; they do not prove native cleanup.", + "Native admission, arbitrary-helper/COPY lifetime implementation, precision, a general caller bound and new kappa remain unclaimed." + ], + "review_kind": "Independent AI source, acceptance-control and scope review; not a formal-kernel or human review.", + "schema_version": 1, + "status": "PASS_B07_REVIEWED_CORE", + "validation": { + "all_storage_and_declared_original_hashes_match": true, + "compressed_original_bindings": [ + "frozen/reviews/hybrid/CHECKS.json.gz", + "frozen/reviews/recipe/CHECKS.json.gz" + ], + "exact_frozen_origin_and_tree_inventory": true, + "independent_imports": { + "frozen/reviews/hybrid/check.py": [ + "argparse", + "ast", + "copy", + "fractions", + "gzip", + "hashlib", + "json", + "pathlib" + ], + "frozen/reviews/recipe/check.py": [ + "argparse", + "ast", + "hashlib", + "json", + "pathlib" + ] + }, + "mandatory_readme_heading_present": true, + "no_symlinks_or_bytecode_artifacts": true, + "owned_review_controls_and_source_audit_copies_match": true, + "registered_commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "historical" + ], + "checks": "All three complete original receipts, unchanged mathematical functions and explicit authenticated source-read closure.", + "timeout_seconds": 90 + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "recipe" + ], + "checks": "Independent dual-number recipe, all-B rank/trace and attaining-projector formula fixtures, arbitrary-input N/spectator instantiations and intended controls.", + "timeout_seconds": 120 + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "hybrid" + ], + "checks": "Independent ordered free-group-ring all-input words, two-code correction, both inverses/dual, restricted determinant count, selected actual ADDRESS witness and invoice controls.", + "timeout_seconds": 120 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py", + "--package", + "{package}" + ], + "checks": "Normal and optimized source/AST/path bindings, complete typed receipt comparisons, actual semantic defects and deliberate check deletion.", + "timeout_seconds": 60 + } + ] + } +} diff --git a/research/bit-fixed-controller-repairs/CROSS-REVIEW-HYBRID.md b/research/bit-fixed-controller-repairs/CROSS-REVIEW-HYBRID.md new file mode 100644 index 0000000000..59956dafe0 --- /dev/null +++ b/research/bit-fixed-controller-repairs/CROSS-REVIEW-HYBRID.md @@ -0,0 +1,91 @@ +# Read-only mathematical cross-review of the hybrid controller + +**Verdict: PASS within the stated abstract and conditional scope.** +No actionable mathematical error was found in the all-B tail proof, the +two-code construction, the restricted determinant lower bound, the direct +forward VALUE witness, or their presentation in the staging README. +This is a separate AI mathematical reading, not human acceptance or a +formal-kernel proof. No full replay was run during this cross-review. + +The reviewed source hashes are: + +| File | SHA-256 | +| --- | --- | +| `b07-hybrid-review/PROOF.md` | `3f90c6c169d48b567ba1d406db058662cf18d1ca823acb5bdc18e16d180db732` | +| `b07-hybrid-review/check_hybrid.py` | `148b456444486d4fde75c83d20717aef7dcd2c6aef31adb009035f834c530138` | +| `b07-hybrid-review/REVIEW.md` | `367f780480a09cfe25f34fa28b44132cfa91d61d51d1fdb43b496110ffd318d1` | +| `b07-staging/README.md` | `5b97d9f6261ec3c6a6bc4b5da69bc8fba503a36fb71b31f54b3e227480aac623` | + +## Clean-tail induction + +I independently expanded the ladder operations with their signed dual +bridges. On pair zero, the positive bridge, clean forward local and negative +bridge leave `(U,U+V+x1)` and present pair one as +`(x1,y1+U+x1)`. For later pairs the incoming second bank is +`yj+s(j-1)+xj`; the reverse local sets its first bank to +`sj=-yj-s(j-1)`. The next forward local and opposite bridge pair leave +`(sj,xj+x(j+1))` and propagate the same incoming formula to the next pair. + +In the descending return ladder the source `sj` has not yet been changed, +while the next pair's second bank already equals `x(j+1)`. Consequently the +new first bank is `s(j+1)+sj=-y(j+1)` and the second-bank telescoping removes +exactly `x(j+1)`. Pair zero ends `(U,U+V)` and all other pairs end `(-yj,xj)`. +The B=1 case is a single clean forward local. The induction therefore covers +every B>=1 without using a finite list as an extrapolation. + +## Two-code correction and lower bound + +The fixed coded prefix gives `U=-y0` and +`V=a1^-1(y0+a0*x0)`. The tail gives `X0=U, Y0=U+V`. +The four displayed terminal steps send Y0 through V, `y0+a0*x0`, +`a0*x0`, and x0, while X0 remains `-y0`. No code labels were commuted in +this calculation. The unchanged exchange closes every input bank. + +The determinant argument is taken only after the valid commutative +specialization to Q(t,u); no determinant over the noncommutative group +algebra is presumed. The fixed prefix has factor t/u and the fixed target +requires added factor u/t. Under the declared single-bank primitive alphabet, +each extra occurrence changes at most one independent exponent by one. +Thus at least two occurrences are required, and the construction attains it. + +The argument is an optimum for universal words in that independent-generator +alphabet. It is not an optimum for one specialized pair of physical codes +that could satisfy additional relations, and not a scalar-ADD or physical +frame-normalization lower bound. The proof and README keep those boundaries. + +## Direct VALUE orientation + +The relevant convention is ADDRESS push T and VALUE push +`g(w)=f(T^-1*w)`. The source function `f(w)=1[w10=0]` on F101 addresses +is constant under translation by every source P0 root-line vector, since +those vectors have zero fresh-coordinate component. The recorded inverse +route sends the target P3 vector `2e3` to `2e10`; hence +`g(0)=1` and `g(2e3)=0`. This directly violates target P3-line invariance +in the required source-to-target direction. + +The separate forward route and pullback separator are useful dual checks; +they are not substituted for the direct VALUE push argument. A point delta +is not assumed to be an admitted source quotient function. Reading the +selected route code confirms that it constructs both route orders and +checks the inverse relation and the exact inverse image. The reported +native obstruction remains one selected ordered off-diagonal pair. + +## Conditional cost and native boundary + +The scalar arithmetic `9216-3220=5996` is correct at the same declared +1499-ADD code tariff and 111-ADD bank-shear tariff. The two words have the +same two declared normalization sweeps. The comparison +`2*60-222=-102` remains negative and independent of B under the stated +equal-price owner-return premises. + +The proof does not infer native legality from abstract endpoint equality. +Its normalization controls explicitly distinguish the unchanged algebraic +endpoint after deleting a logical identity from the failed native inventory. +The common terminal FULL cut, legal current frames, mixed owners, helpers, +physical source access, actual integer target leakage and precision remain +separate premises. The README also preserves the B=1 algebraic versus native +driver distinction and does not turn the scalar saving into a supplier or +kappa claim. + +Only this cross-review file was written. No frozen contribution files, +staging content or other worker-owned material was changed. diff --git a/research/bit-fixed-controller-repairs/CROSS-REVIEW-RECIPE.md b/research/bit-fixed-controller-repairs/CROSS-REVIEW-RECIPE.md new file mode 100644 index 0000000000..4018ead479 --- /dev/null +++ b/research/bit-fixed-controller-repairs/CROSS-REVIEW-RECIPE.md @@ -0,0 +1,56 @@ +# Cross-review of the fixed-involution repair proof + +Read-only mathematical review of `b07-recipe-review/PROOF.md`, SHA-256 +`9601bf1cfdd196e30c885f2d880f6322c3e1d11c898a1689ad8087259b573988`. +This is an independent proof reading, not another execution of its checker. +Prepared with substantial OpenAI Codex assistance. + +The all-B endpoint derivation is correct. Starting with +`t0=X0+NY0`, direct substitution through the positive bridge, local forward +call and negative bridge gives +`t_(j+1)=X_(j+1)+Y_(j+1)+N(Xj+tj)`. +Writing `tj=Xj+Sj+epsilon*bj` yields the stated recurrence +`b_(j+1)=bj+Sj`. The descending X bridges add neighboring `p` rows while +the Y bridges telescope through suffix sums of `q` rows. This gives the +displayed endpoint on every arbitrary bank input, including B=1. + +The block formula `C=L^T L` is exact: its `(j,k)` entry counts indices +`ell>=max(j,k)`. Both C and D are invertible. For the repair coefficient +`M=A+I`, row j of `DC` for j>=1 is the row with ones exactly at `k=1 and first row +`C[0,*]`; its first pivot is `B mod2`. This proves rank `2B` for odd B +and `2B-1` for even B. Trace M is one, since the dimension is even and +the only diagonal coefficient of A is its y0 entry. + +Both attaining projector decompositions are valid. In the odd case, +the y0 column splits into two rank-one projectors whose added coordinate +projectors cancel. All other diagonal pairings are one. In the even +case, the kernel relation +`m_y0=sum_(j odd) m_xj` reconstructs the omitted y0 column. The x-column +readout `e_xj^T+[j odd]e_y0^T` still pairs to one: the y0 row of D is +supported only at x0, and j=0 is even. All retained y-column diagonal +pairings are one. A basis beginning with u and completing with `ker(v^T)` +implements each claimed scalar conjugation exactly. + +The restored-spectator quantifier is justified. The required coefficient +is `M direct-sum 0`, with every spectator row and column included, so +rank and trace give the same lower bounds in any larger finite ambient +bank space. No spectator is specialized to zero. The attaining words +extend by identity and therefore restore every spectator literally. + +The insertion extension is also sound for complete repair gates with +constant term I. Moving a repair to the terminal cut conjugates its +epsilon coefficient by the constant part of an invertible fixed suffix +(equivalently the corresponding fixed prefix in the opposite product +convention). The result remains a rank-one projector with trace one; +epsilon terms in the conjugating product do not contribute because +`epsilon^2=0`. Multiple repairs commute at that coefficient level. +This does not license extra unpaired scalar mixing or changes to the +original recipe, as the proof correctly states. + +No mathematical defect was found in the stated theorem or construction. +The proof does not extend to changing the local alphabet, altering the +original scalar topology, or treating the formal free mixing as native +physical work. Its conversion of seven B4 calls into 777 rank-one +children remains explicitly conditional on a separately admitted +111-child implementation. diff --git a/research/bit-fixed-controller-repairs/EVIDENCE-INDEX.md b/research/bit-fixed-controller-repairs/EVIDENCE-INDEX.md new file mode 100644 index 0000000000..1510bea2ce --- /dev/null +++ b/research/bit-fixed-controller-repairs/EVIDENCE-INDEX.md @@ -0,0 +1,32 @@ +# Evidence boundaries + +| Evidence | Coverage | Limit | +| --- | --- | --- | +| Original `CLOSED-HYBRID.json` | Fixed B4 six-code word, eight independent rows, inverse/dual and four controls | Historical conditional invoice; not native supplier admission | +| Original `BIT-NILPOTENT-RECIPE.json` | Fixed recipe for B1 through B6 | Finite evidence, superseded in scope by the written all-B proof | +| Original `EARLY-PROMOTION.json` | Actual code entry, exact ADDRESS witness and original route checks | Rejects one proposed free code admission | +| [PROOF-RECIPE.md](PROOF-RECIPE.md) and independent recipe checker | Closed all-B defect formula, rank/trace floor and attaining repairs | Fixed original recipe and rank-one idempotent repair alphabet | +| [PROOF-HYBRID.md](PROOF-HYBRID.md) and independent hybrid checker | All-B tail identity, two-code correction, restricted determinant floor and exact selected route witness | Abstract coded boundary; declared native normalization remains conditional | +| [REVIEW-RECIPE.md](REVIEW-RECIPE.md), [REVIEW-HYBRID.md](REVIEW-HYBRID.md) | Separate mathematical checking contexts and resolved findings | AI review, not human acceptance | +| [CROSS-REVIEW-RECIPE.md](CROSS-REVIEW-RECIPE.md), [CROSS-REVIEW-HYBRID.md](CROSS-REVIEW-HYBRID.md) | Reciprocal written-proof review, including quantifiers and native limits | Read-only mathematical review; no additional replay claimed | +| [REVIEW-VERIFICATION.md](REVIEW-VERIFICATION.md), controls and core snapshot | Exact source selection, complete typed receipts, intended defects and check-deletion sensitivity | Acceptance integrity, not a formal proof kernel | + +The all-parameter results are written algebraic proofs. Finite checker fixtures +independently verify the formulas and constructions on their recorded domains; +they do not establish the universal quantifier by enumeration. +The recipe proof incorporates the cross-review's product-order clarification: +moving an inserted repair to the final cut conjugates it by the fixed suffix. +The cross-review preserves the original pre-clarification source hash. + +The three historical receipts are regenerated by their unchanged mathematical +functions and compared in full. The new checkers use separate implementations. +The originals are retained for provenance and discrepancy detection, not as +independent evidence for the new all-B theorems. + +Source and container hashes are in [FROZEN-SHA256.json](FROZEN-SHA256.json). +Original locations and any storage encoding are in [ORIGINS.json](ORIGINS.json). +Repository pins are in [SOURCES.json](SOURCES.json). Attribution and comparison +scope are recorded in [RELATED-WORK.json](RELATED-WORK.json). + +The registered checks make no selected-frontier change, native precision claim, +unrestricted caller lower bound, physical-tape claim or new kappa claim. diff --git a/research/bit-fixed-controller-repairs/FROZEN-SHA256.json b/research/bit-fixed-controller-repairs/FROZEN-SHA256.json new file mode 100644 index 0000000000..1da0709c8b --- /dev/null +++ b/research/bit-fixed-controller-repairs/FROZEN-SHA256.json @@ -0,0 +1,24 @@ +{ + "frozen/hybrid/closed_hybrid.py": "78f92b8b8fdb6528bd87f974f3022e73c9b60877f0022200fe0b4422da2b7738", + "frozen/hybrid/early_promotion.py": "d59e5487251929416fa657f45e617d78a3392310203f1df08389d3746acd6732", + "frozen/hybrid/CLOSED-HYBRID.json": "f12bf6aabe9ea0cb058eab5d68f10886cddff6200f7e00b40c048f4cf01689b7", + "frozen/hybrid/EARLY-PROMOTION.json": "c278d5bd9cca084cbeae5212b73afa5f03461ecb4af9e18608bda0c54c89a2d6", + "frozen/hybrid/README.md": "0206fc9c9950e04baf4b9395af0a1e0b9a99907900b328eb06eb48477703ea24", + "frozen/recipe/bit_nilpotent_recipe.py": "d2649a223c4fd221e64dc059422bcf796fbe1becc524911c7e84c0cf475b2b7e", + "frozen/recipe/bit_seeded_star.py": "91d3bbebfad36836b48949a2d231afd3eb8dd46f0443d45f7e19ff9779468347", + "frozen/recipe/BIT-NILPOTENT-RECIPE.json": "ef97f43313ccffb7a8ea5965d37b37452b70cf4ccfbafe81e9e92e46d0f1a14a", + "frozen/routes/expanded_sections.py": "b5b0f01da04d95ccaae56cfb503bbf12bdd47442a924802c280089acc564795b", + "frozen/geometry/MATRICES.json": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979", + "frozen/geometry/R438.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "frozen/geometry/E8.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "frozen/upstream/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "frozen/provenance/bit_cap_copy_local.py": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb", + "frozen/reviews/recipe/check.py": "50ef2041dc27c11189e0f4293cd30aed2ee372b1a6e928dbe6197e21ceab75de", + "frozen/reviews/recipe/SOURCE-DEPENDENCIES.json": "4eb24d806c09d957c7dca375393634100f6cfacf999bff49845314e131acad20", + "frozen/reviews/recipe/VALIDATION.json": "db3d1cba36f98efc8330b19e0df8e5ad086145aeaa487703cac539a10d9f6062", + "frozen/reviews/recipe/CHECKS.json.gz": "cff40bd8d82e7919b9a1a76c03389bc0a82c9156d162198faf6132eac4691359", + "frozen/reviews/hybrid/check.py": "148b456444486d4fde75c83d20717aef7dcd2c6aef31adb009035f834c530138", + "frozen/reviews/hybrid/CHECKS.json.gz": "8a76a7141b4851084923e87c8f17bc8c02db6543d7614bc2c911e45e43a0ef8f", + "frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json": "a2c1fd731281a3f1360e95a70d426f59332e6482155c6190dc3ac49d37b42ec2", + "frozen/reviews/hybrid/VALIDATION.json": "ebd5d303781781850cac8e4b76d31f24b63fcd90cf0f2132128b222ba093c221" +} diff --git a/research/bit-fixed-controller-repairs/LICENSE b/research/bit-fixed-controller-repairs/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/bit-fixed-controller-repairs/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/bit-fixed-controller-repairs/ORIGINS.json b/research/bit-fixed-controller-repairs/ORIGINS.json new file mode 100644 index 0000000000..5950318292 --- /dev/null +++ b/research/bit-fixed-controller-repairs/ORIGINS.json @@ -0,0 +1,94 @@ +{ + "frozen/hybrid/closed_hybrid.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/closed_hybrid.py", + "sha256": "78f92b8b8fdb6528bd87f974f3022e73c9b60877f0022200fe0b4422da2b7738" + }, + "frozen/hybrid/early_promotion.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/early_promotion.py", + "sha256": "d59e5487251929416fa657f45e617d78a3392310203f1df08389d3746acd6732" + }, + "frozen/hybrid/CLOSED-HYBRID.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/CLOSED-HYBRID.json", + "sha256": "f12bf6aabe9ea0cb058eab5d68f10886cddff6200f7e00b40c048f4cf01689b7" + }, + "frozen/hybrid/EARLY-PROMOTION.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/EARLY-PROMOTION.json", + "sha256": "c278d5bd9cca084cbeae5212b73afa5f03461ecb4af9e18608bda0c54c89a2d6" + }, + "frozen/hybrid/README.md": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/README.md", + "sha256": "0206fc9c9950e04baf4b9395af0a1e0b9a99907900b328eb06eb48477703ea24" + }, + "frozen/recipe/bit_nilpotent_recipe.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/bit_nilpotent_recipe.py", + "sha256": "d2649a223c4fd221e64dc059422bcf796fbe1becc524911c7e84c0cf475b2b7e" + }, + "frozen/recipe/bit_seeded_star.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/bit_seeded_star.py", + "sha256": "91d3bbebfad36836b48949a2d231afd3eb8dd46f0443d45f7e19ff9779468347" + }, + "frozen/recipe/BIT-NILPOTENT-RECIPE.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/BIT-NILPOTENT-RECIPE.json", + "sha256": "ef97f43313ccffb7a8ea5965d37b37452b70cf4ccfbafe81e9e92e46d0f1a14a" + }, + "frozen/routes/expanded_sections.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/expanded_sections.py", + "sha256": "b5b0f01da04d95ccaae56cfb503bbf12bdd47442a924802c280089acc564795b" + }, + "frozen/geometry/MATRICES.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-ROW-INPUT.json", + "sha256": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979" + }, + "frozen/geometry/R438.json.gz": { + "original_path": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "frozen/geometry/E8.json.gz": { + "original_path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "frozen/upstream/global_k.py": { + "original_path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "frozen/provenance/bit_cap_copy_local.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_cap_copy_local.py", + "sha256": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb" + }, + "frozen/reviews/recipe/check.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-recipe-review/check.py", + "sha256": "50ef2041dc27c11189e0f4293cd30aed2ee372b1a6e928dbe6197e21ceab75de" + }, + "frozen/reviews/recipe/SOURCE-DEPENDENCIES.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-recipe-review/SOURCE-DEPENDENCIES.json", + "sha256": "4eb24d806c09d957c7dca375393634100f6cfacf999bff49845314e131acad20" + }, + "frozen/reviews/recipe/VALIDATION.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-recipe-review/VALIDATION.json", + "sha256": "db3d1cba36f98efc8330b19e0df8e5ad086145aeaa487703cac539a10d9f6062" + }, + "frozen/reviews/recipe/CHECKS.json.gz": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-recipe-review/CHECKS.json", + "sha256": "cff40bd8d82e7919b9a1a76c03389bc0a82c9156d162198faf6132eac4691359", + "encoding": "gzip of unchanged complete JSON bytes", + "original_sha256": "e829f99da71b9a6b1a533d7743cc249e15ab7f65a936c7b89800c24e4b9dc687" + }, + "frozen/reviews/hybrid/check.py": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/check_hybrid.py", + "sha256": "148b456444486d4fde75c83d20717aef7dcd2c6aef31adb009035f834c530138" + }, + "frozen/reviews/hybrid/CHECKS.json.gz": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/CHECKS.json", + "sha256": "8a76a7141b4851084923e87c8f17bc8c02db6543d7614bc2c911e45e43a0ef8f", + "encoding": "gzip of unchanged complete JSON bytes", + "original_sha256": "c1c1444d09bda057e6fa12c97fe8e7c4674ad0076d83e1d7ad7f5975ca946442" + }, + "frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/SOURCE-DEPENDENCIES.json", + "sha256": "a2c1fd731281a3f1360e95a70d426f59332e6482155c6190dc3ac49d37b42ec2" + }, + "frozen/reviews/hybrid/VALIDATION.json": { + "original_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/VALIDATION.json", + "sha256": "ebd5d303781781850cac8e4b76d31f24b63fcd90cf0f2132128b222ba093c221" + } +} diff --git a/research/bit-fixed-controller-repairs/PROOF-HYBRID.md b/research/bit-fixed-controller-repairs/PROOF-HYBRID.md new file mode 100644 index 0000000000..564172a718 --- /dev/null +++ b/research/bit-fixed-controller-repairs/PROOF-HYBRID.md @@ -0,0 +1,286 @@ +# An all-bank hybrid controller with two terminal code applications + +This is an exact abstract controller construction and a conditional scalar +cost improvement. It does not admit a physical BIT supplier or improve its +rank mass. The historical scientific source is +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`. + +## Contract and coefficient ring + +There are \(B\ge1\) pairs \((X_j,Y_j)\), with all \(2B\) entering banks +\((x_j,y_j)\) arbitrary and independent. Work over the integral free group +algebra on independent invertible operators \(a_0,a_1,\ldots,a_{2B}\). +Only adjacent inverse cancellation is permitted; operators do not commute. +The result specializes to arbitrary invertible linear operators on a module. +Transpose symbols are separate operators, with multiplication order reversed +under transpose; no equation \(a_s^T=a_s^{-1}\) is used. + +The abstract coded local maps are + +\[ + F_s(X,Y)=(a_sX,\;Y+a_sX),\qquad + B_s(X,Y)=(X-Y,\;a_s^{-1}Y). +\] + +Clean locals replace \(a_s\) by \(I\). A bridge of coefficient \(c\) from pair +\(s\) to pair \(d\) is + +\[ + X_d\mathrel{+}=cX_s,\qquad Y_s\mathrel{-}=cY_d. +\] + +The `recipe(B)` function in the pinned `global_k.py` has \(2B+1\) locals, +\(3B-3\) bridges, and one final exchange, hence \(5B-1\) events. It begins +with \(F_0,B_1\) on pair 0, advances through the adjacent pairs using the +two opposite bridge signs, then returns through the descending bridges. + +Each local's dirty helpers must restore for **every** entering helper value, +and its copied field must obey its own zero-entry/cleanup lifetimes. +Those are imported local contracts. No public bank is assumed clean or used +as zero scratch. The added controller operations act only on the public +banks; the formal boundary is direct summed with the identity on the +arbitrary restored helpers. + +The actual R429 local identity supplies this map on binary VALUE functions. +Its signed integer lift can have even target helper leakage. Consequently, +the signed free-group theorem is an abstract result and cannot be applied to +that actual integer lift merely because its reduction modulo 2 agrees. +Native ADDRESS frames, global phase, mixed helper owners, source access, +COPY legality and rounded precision remain separate obligations. + +## Clean-tail identity for every \(B\) + +Cut immediately after the first reverse local \(B_1\). Let its current pair +be \((U,V)\); all other pairs still enter as \((x_j,y_j)\). Use only clean +locals after that cut and keep every original bridge and its sign. +The tail before the final exchange sends + +\[ + (U,V),(x_1,y_1),\ldots,(x_{B-1},y_{B-1}) + \longmapsto + (U,U+V),(-y_1,x_1),\ldots,(-y_{B-1},x_{B-1}). + \tag{1} +\] + +Here is an induction on the literal ladder, not an extrapolation from a +finite list of bank counts. Put \(s_0=U\) and +\(s_j=-y_j-s_{j-1}\) for \(j\ge1\), and put +\(z_0=U+V,\ z_j=x_j\) for \(j\ge1\). + +For \(B>1\), the first positive bridge, clean forward local, and negative +bridge leave \(X_0=s_0,\ Y_0=z_0+x_1\) and present the next pair as +\((x_1,y_1+s_0+x_1)\). In general, pair \(j\ge1\) enters its clean reverse +local as \((x_j,y_j+s_{j-1}+x_j)\); the reverse local sets +\(X_j=s_j\). If \(j 64 -> 3`. Each selected route is the symmetric involution +\[ + \rho_p=\begin{pmatrix}P_p&A_p\\A_p^T&0\end{pmatrix},\qquad + A_p^TA_p=I_7,\quad A_pA_p^T=I_8-P_p. +\] +Here \(P_p=q_pq_p^T/4\) and the vectors are exactly those in the pinned word. + +For the source root-line vector \(v=2e_0\in P_0\), +\[ + \rho_0v=v,\qquad + T v=(\rho_3^{-1}\rho_0)v=2e_{10}, +\] +where coordinate 10 is the third fresh coordinate. This vector lies +outside the target \(P_3\), over the rationals and over \(\mathbb F_{101}\). +Thus the relative route does not carry the source promoted-frame fiber +into the target promoted-frame fiber. + +The ADDRESS convention is a forward point push \(v\mapsto Tv\), so the +corresponding VALUE push is \(g(w)=f(T^{-1}w)\). Directly, the target +root-line vector is \(v_3=2e_3\in P_3\), and the independently computed +inverse route gives \(T^{-1}v_3=2e_{10}\). +Take the binary source VALUE function \(f(w)=1\) exactly when +\(w_{10}=0\) over \(\mathbb F_{101}\). It is constant along source +\(P_0\), which has no fresh component. But its forward VALUE image has +\(g(0)=1\) and \(g(v_3)=0\), so it is not constant along the target +\(P_3\). This is the actual source-to-target admission failure, without +switching the push/pull orientation. + +As a dual check, the same coordinate indicator is constant along target +\(P_3\), but \(f(T0)=1\) and \(f(Tv)=0\), so its pullback is not constant +along source \(P_0\). These separators avoid presuming that a point delta +is admissible on an entire quotient fiber. + +This is one selected off-diagonal native admission failure. The checker +reconstructs only two routes and one ordered off-diagonal pair; it does +not claim to replay the predecessor's 12,210-pair theorem. It excludes the +free future-code admission used in that early-promotion proposal. It does +not exclude a changed promoted-input factory, a proved current-word +normalization cancellation, or a different controller. The historical +undo/code/redo workaround still has its stated 111+111 child bill, before +source access and precision. + +## Evidence and remaining boundary + +The standalone checker uses its own elementary matrix algebra over the +free group ring. It authenticates and extracts only `recipe` from its +source, independently reconstructs the event list, and replays both +controllers for \(B=1,\ldots,12,16,32\), on all \(2B\) symbolic inputs. +It checks both inverse products and chronological gatewise +inverse-transpose propagation, with independent transpose symbols. +These finite fixtures verify the implementation; the ladder induction +above is the all-\(B\) proof. Neither is a formal-kernel proof. + +Controls remove actual terminal operations, alter a code direction or +bank, change a compensation sign, restore a stale coded \(F_2\), and change +one actual inverse-code direction. The signed endpoint is involutive, so +repeating the complete forward word would be a vacuous inverse control. +Deleting a normalization deliberately leaves the abstract logical endpoint +unchanged and is rejected only by the declared native inventory check. +That distinction is recorded, not hidden. + +No actual integer R429 map without target helper leakage, native global +phase, mixed-owner hosting, full supplier histogram, physical source-access +cost, whole-word rounding/COPY certificate, or outer multiplication theorem +is established here. No new conditional kappa is claimed. + +The controller and geometry lineage is retained from the old +DreamingOfClouds/eumemic/PR555,543,545,510 work, Ali Romman's R438 deletion +and source builder, Sagar Thakrar's transported R438 hosting, and the prior +source-code preparation interface in Ali Romman's PR1862. The six-code +hybrid and original selected route witness are preserved predecessor work. +This contribution adds the all-bank clean-tail proof, the two-code +construction, its restricted occurrence lower bound, and an independent +exact audit. Substantial OpenAI Codex assistance was used; new material is +Apache-2.0. diff --git a/research/bit-fixed-controller-repairs/PROOF-RECIPE.md b/research/bit-fixed-controller-repairs/PROOF-RECIPE.md new file mode 100644 index 0000000000..ad5593ca91 --- /dev/null +++ b/research/bit-fixed-controller-repairs/PROOF-RECIPE.md @@ -0,0 +1,231 @@ +# Exact repair count for the fixed routed involution recipe + +This is a written all-parameter proof, with finite executable certificates. +It is not a formal-kernel proof or an admission theorem for a physical supplier. +Prepared with substantial OpenAI Codex assistance. Apache-2.0. + +## Model and theorem + +Let \(B\geq1\), \(n=2B\), and work over \(\mathbb F_2\). Every bank contains an +arbitrary, independently chosen vector in a common vector space. Fix a +nonidentity linear involution \(N\), and put \(\epsilon=N+I\). Thus +\(\epsilon^2=0\), and \(I,\epsilon\) are linearly independent over +\(\mathbb F_2\): a nonzero scalar multiple of \(I\) cannot be nonzero and square +to zero. Consequently the dual-number algebra embeds in this representation. +The argument therefore covers every nonidentity involution, not just a +particular small matrix representation. + +Use exactly the event word returned by the pinned `global_k.py:recipe(B)`, +with its bridge order, bank pairing and terminal pair exchange unchanged. +Replace its two local interfaces by + +\[ + F(x,y)=(x,x+Ny),\qquad H(x,y)=(Nx+y,y). +\] + +A bridge from pair \(s\) into pair \(d\) sends +\(x_d\leftarrow x_d+x_s\) and \(y_s\leftarrow y_s+y_d\). +Its source coefficient \(+1\) or \(-1\) has the same value in this field. + +An allowed additional paid repair is a scalar-GL-conjugated application of +\(N\) to one bank: +\[ + Q_P=I+\epsilon P,\qquad + P=uv^T,\quad v^Tu=1. +\] +Scalar mixing means matrices over \(\mathbb F_2\) on the bank index, tensored +with the identity on the bank contents. These scalar changes of basis and +their inverses are free only in the formal call-count model. + +The target is \(N I_n\) on the original banks. For any finite number \(d\) +of extra independently dirty banks, their target is literal identity. +The fixed recipe acts as identity on these spectators. + +**Theorem.** The minimum number of such additional repair calls is +\[ + k(B)= + \begin{cases} + 2B+1,&B\text{ odd},\\ + 2B-1,&B\text{ even}. + \end{cases} +\] +The same minimum holds with any finite number of restored dirty spectators, +even if each additional repair mixes original and spectator banks. +Repairs can be placed after the fixed word. The lower bound also permits +inserting these complete constant-identity repair gates between its events. + +This theorem does not allow changing the existing scalar topology, pairing, +local alphabet, or observation boundary. In particular it does not obstruct +the changed seeded-star topology or the separate closed hybrid controller. + +## Endpoint derivation for every B + +Write the original bank inputs as \(X_j,Y_j\), \(0\leq j0,\ k=j-1],\qquad + E_{00}=1,\quad E_{jk}=[k=1`. The unchanged native +bank tiling is not asserted at those parameters. + +The useful new construction omits both historical immediate code +pullbacks. At the final common FULL cut, after the old idle returns, apply + +``` +Y0 -= X0; Y0 := a1 Y0; Y0 += X0; Y0 := a0^-1 Y0. +``` + +This restores the all-clean endpoint using two additional code occurrences, +two scalar bank shears, the same two conditional normalization sweeps, and +no new helper. Its added scalar invoice is 3220 instead of 9216 ADDs at the +same 1499/111 tariffs, an exact saving of 5996. Its net rank-mass comparison +against the all-clean word remains `-102`, independent of B. + +The two-code occurrence lower bound is valid only for the stated alphabet: +same coded F0/B1, no additional coded local, remaining locals clean, +single-bank generator applications, determinant-neutral scalar mixing, +logical normalization, and fixed target. Scalar specialization gives the +required determinant factor `a1/a0`; both independent exponents require an +occurrence. This is not physical-code optimality. + +The native counterexample is independently reproduced for actual +`A[3,0]=1`: the pinned port-relative route sends source root-line vector +`2e0` to `2e10`, outside target P3, over Q and F101. The review replays only +the two selected routes, not the predecessor's all-ordered-pairs result. +An explicit binary VALUE fiber separator replaces any implicit assumption +that a point delta is legal on an entire quotient fiber. With ADDRESS push +`T`, VALUE pushes by `f(T^-1 w)`. The inverse route sends target root +`2e3` to `2e10`; the source-P0-invariant function `1[w_10=0]` therefore +pushes to a function that is not target-P3-invariant. The forward +admission failure is checked directly, with its orientation stated. + +The implementation is independent of the historical hybrid evaluator: +it composes elementary sparse matrices over the free group ring, with a +different coefficient representation, and separately composes each +gate's inverse transpose. Only the pinned `recipe` definition is extracted +from predecessor Python; no original imports, main function, or source-path +globals execute. The independently generated event list is compared in full. +All 2B rows are retained, including dirty public inputs. + +The final replay includes actual omissions, coefficient changes, wrong-bank +and inverse-direction controls with exact intended exceptions. The +normalization controls make the important distinction explicit: deleting a +logical identity leaves the algebraic endpoint unchanged, but fails the +222-child declared inventory. Neither outcome is a native phase proof. + +The main limitations are actual R429 integer target helper leakage, unproved +mixed-owner hosting and native phase admission, the absence of a full +rank/width recurrence, and unpriced physical source access and precision. +There is no new kappa or formal-kernel proof. The published claim should be +the all-B two-code abstract construction and exact conditional scalar +saving, accompanied by the native admission counterexample and these +limits. + +Final validation used CPython 3.12.14 with `-I -B -W error`, then with +`-O`, and then optimized Python with compressed recipe/matrix inputs in +a directory containing spaces. All three complete JSON receipts were +byte-identical. They cover 28 full word fixtures, 12 word/inventory +mutation controls and three selected-route controls. Recorded durations +were 0.295, 0.358 and 0.362 seconds. The final source and receipt hashes +are in `VALIDATION.json`; `CHECKS.json.gz` is the deterministic compressed +full receipt. `SOURCE-DEPENDENCIES.json` distinguishes actual authenticated +inputs from read-only predecessor provenance. diff --git a/research/bit-fixed-controller-repairs/REVIEW-RECIPE.md b/research/bit-fixed-controller-repairs/REVIEW-RECIPE.md new file mode 100644 index 0000000000..c52ff9ae97 --- /dev/null +++ b/research/bit-fixed-controller-repairs/REVIEW-RECIPE.md @@ -0,0 +1,116 @@ +# Independent mathematical review of the fixed recipe + +Verdict: the fixed-recipe repair theorem and its stated finite certificates +pass this review. No mathematical acceptance by a maintainer or independent +human reviewer is claimed. This review and its extension were prepared by a +separate OpenAI Codex mathematical worker. + +## What was inherited, and what is new + +The historical `bit_nilpotent_recipe.py` evaluated B=1,...,6 in +\(\mathbb F_2[N]/(N^2-1)\). Its rank sequence 2,3,6,7,10,11, trace-one +observation and B4 lower bound of seven were conditional claims about that +fixed word. This review does not use their recorded PASS status as proof. +It independently replays all six complete case records and derives the +endpoint from the actual source recipe. + +The new mathematical content is a closed form valid for every B, a rank and +trace proof, explicit attaining decompositions for both parities, and the +extension to every finite number of independently dirty restored spectator +banks. Thus the historical lower screen becomes an exact formal minimum: +\(2B+1\) added calls for odd B and \(2B-1\) for even B. + +The unchanged source `recipe` function is extracted from an authenticated +full source file. Its imports, module state and main routine are not executed. +The independent checker uses separate constant and epsilon bit matrices; +it does not import the historical coefficient-ring arithmetic. + +## Assumptions checked + +- The coefficient field is F2. The theorem is not an integer-lift result. +- The same nonidentity involution N acts on every original bank. +- N+I is nonzero and squares to zero, so the dual-number model is injective. + An identity N is explicitly excluded from the obstruction. +- The original local interfaces, bridge order, bank pairing and final + exchange are fixed. Changing scalar topology can change the endpoint. +- A paid additional event is a rank-one idempotent coupling + \(I+(N+I)uv^T\), with \(v^Tu=1\), equivalently a scalar-conjugated + single-bank application of N. +- All input banks and all added spectator banks are independently dirty. + The spectator endpoint is literal identity. +- Scalar GL changes of basis are free only in this formal event-count model. + Their physical access and implementation costs remain unpaid here. + +## Derivation audit + +The t-recurrence is obtained by expanding the four literal operations on a +nonterminal pair. The x input of the next pair is still its original input; +only its y input is changed. Descending terminal bridges update each x bank +from its as-yet unchanged preceding p bank, while they telescope the q banks. +This confirms the event order used in the written endpoint derivation. + +The block formula gives C=L^T L and invertible lower bidiagonal D, so A is +invertible. For M=A+I the Schur reduction is an invertible block row operation. +Every row after its first becomes a coordinate row; the first row has leading +entry B mod2. This proves the rank formula without extrapolating a finite table. +Only A's y0 diagonal is one, yielding trace(M)=1. + +For even B, the displayed kernel relation removes exactly the y0 column. +Its contribution is folded into the duals of odd x columns. The resulting +dual/image pairings remain one because the y0 row of D only touches x0, +whose index is even. For odd B, the only trace-zero column is split into two +rank-one idempotents. Every asserted projector is nonzero and their sum is +exactly M. The corresponding scalar basis and inverse make the word explicit. + +Rank and trace bounds apply to M direct-sum zero on any number of spectators. +They therefore permit repair projectors that mix data and dirty spectators; +the attainment uses no spectator. Conjugating an inserted repair through an +unchanged fixed-word suffix uses only the scalar part of that suffix, because +epsilon squared is zero. This preserves the same projector rank and trace. +This argument covers complete constant-identity repair gates, not arbitrary +new scalar wiring around existing query calls. + +## Executed finite coverage + +`CHECKS.json` is a full deterministic receipt. Normal and optimized CPython +3.12 executions produce identical bytes. + +- B=1,...,12: literal recipe endpoint, closed-form coefficient, Schur rows, + rank, trace, kernel for even B, exact attaining count, all projectors and + explicit scalar conjugators. +- B=1,...,6: every field of each historical case, including its event list + and full endpoint matrices, is regenerated and compared. +- B=1,...,8: 72 full arbitrary-input binary matrix instantiations from three + nonidentity involutions and spectator counts zero, one and three. +- Twelve intended controls: changed local orientation, omitted bridge, + omitted exchange, omitted repair, a trace-zero coupling, wrong even kernel, + a non-involution, identity N, duplicate or missing source function, changed + coefficient formula, and an incorrect nonidentity spectator endpoint. + Every control requires a specific ValueError message. + The spectator control runs the actual B4 complete repair word on a passing + two-port involution and one dirty spectator, changes that spectator's target + block from identity to N, and fails the same exact spectator-restoration + gate used by all positive instantiations. + +These are finite checks of the identities used in the proof. They are not +an exhaustive search over all B, all N, all scalar words, or all spectators. +The all-parameter statement is the written proof. No formal-kernel check +was run. + +## Cost and publication limits + +For B4, exactly seven formal repairs are necessary and sufficient in this +alphabet. Seven separately admitted 111-port N implementations would have +777 rank-one child calls if each costs 111 such children. The proof does not +admit that implementation or compare the result with a distinct controller's +planning allowance. It does not certify a full supplier, owner schedule, +fresh-frame controller, recursive moment improvement, or new kappa. + +The seeded-star contribution changes the topology and is outside this +fixed-recipe theorem. Published three-bit idempotent counts and trace-zero +commutator floors have different target contracts; they were read for +context only and are not imported as proof dependencies. + +The reviewer owns only this review directory. No staging files, Git branches, +PRs, external comments, shared configuration or other workers' files were +modified. diff --git a/research/bit-fixed-controller-repairs/REVIEW-VERIFICATION.md b/research/bit-fixed-controller-repairs/REVIEW-VERIFICATION.md new file mode 100644 index 0000000000..f068d34503 --- /dev/null +++ b/research/bit-fixed-controller-repairs/REVIEW-VERIFICATION.md @@ -0,0 +1,142 @@ +# Source and exact-control review + +**Verdict: PASS within the declared fixed-controller scope.** +This is an independent AI review of source binding, complete receipts, +mathematical acceptance controls and scope. It is not a formal-kernel proof, +human acceptance, hosted CI result or a new supplier-admission result. +Prepared with substantial OpenAI Codex assistance. + +The reviewed verifier has SHA-256 +`f8954d6b6c8b5ad0a9b228adac60cbd6f798a1f8958a669877e149f8a48dff9b`. +The complete final package inventory is delimited separately by +`CORE-SNAPSHOT.json`; the compact run is recorded in `CONTROLS.json`. +The parent owns the full registered-stage and Git-free replays. + +## Authenticated execution and historical closure + +The minimal historical closure contains fourteen files: six mathematical +source files, three data inputs, three fixed receipts and two provenance +files. The new independent checkers and their fixed receipts add separate +evidence; they are not substituted for the historical sources. + +`Frozen.raw` reads once, checks the registered SHA-256 and returns those +same bytes for parsing or execution. Selected historical definitions are +matched by a full name multiset, so missing and duplicate definitions or +requested names fail. Only declared definitions are compiled. Historical +imports, module initialization and unselected entry points do not run. +The two explicitly selected historical `main` functions generate their +bounded records into a fresh external temporary directory. + +Every literal historical read passes through `SourcePath` and its explicit +logical map. Unmapped, missing or changed inputs fail; there is no fallback +to the original absolute checkout or sibling imports. The nested +`global_k.recipe` read requires one top-level definition and is recorded as +executed. The original cap-copy `RAW_SHA` is read as an authenticated literal +and compared to the frozen R438 input. The route generator is executed +through its declared functions; its old driver and unused functions are +excluded. + +Compilation at both AST layers and for each complete independent checker +sets `dont_inherit=True, optimize=0`. The independent checker module receives +an explicit non-main name. Frozen code is compiled from authenticated bytes, +with no importlib or frozen-module bytecode-cache loading path. The compact +fixtures confirm that direct gates, extracted assertions, nested assertions +and complete-module assertions survive an outer `-O` process. + +Both container and original-byte bindings are checked for compressed +receipts. The origin and frozen inventories must agree exactly. A control +that updates both disposable container digests still fails on a changed +decompressed original. Recompressing the same original with a different gzip +timestamp passes when the disposable storage bindings are updated. + +The historical `bit_seeded_star.inverse_event` is intentionally excluded: +its generic involutivity statement is not valid for its `new_F` primitive. +The five ring primitives used by this package do not call it. No assertion +about that unused function is needed for the replay. + +## Complete receipts and controls + +The acceptance gate compares canonical JSON for every field of all five +fixed scientific receipts: + +| Record | Stage | +| --- | --- | +| `frozen/hybrid/CLOSED-HYBRID.json` | historical | +| `frozen/hybrid/EARLY-PROMOTION.json` | historical | +| `frozen/recipe/BIT-NILPOTENT-RECIPE.json` | historical | +| `frozen/reviews/recipe/CHECKS.json.gz` | recipe | +| `frozen/reviews/hybrid/CHECKS.json.gz` | hybrid | + +Each stage also requires its exact set of compared receipts. There is no +selected-field acceptance or regeneration of a missing expected receipt. +The canonical comparison distinguishes integer, float and boolean scalars, +preserves list order, and detects nested omission. Every actual receipt was +positively compared in full, then rejected after a deep field mutation and +after omission of that same field. + +The compact suite passed under Python 3.12 in both normal and optimized +children. Each mode reached **47 intended rejecting controls**, plus two +deliberate check-deletion tests. Fixtures use external temporary directories. +The verifier, frozen manifest and origins remained unchanged during the run. + +The mathematical inverse control authenticates and executes the actual old +eight-bank hybrid word. It changes exactly one backward code application to +a forward application in memory, after authentication. The resulting word +fails the `literal reverse-inverse cleanup` gate. Disabling only that gate +makes this rejection test detect unexpected acceptance. Thus the control +depends on the mathematical check, rather than on a changed input hash or +an unrelated exception. Repeating the entire forward endpoint would have +been vacuous here because the signed target endpoint is itself involutive. + +The receipt-gate deletion test likewise confirms that the scalar-type +mutation requires the complete-comparison gate. The independent recipe +control helper also rejects a fixture that raises the wrong semantic error; +unexpected acceptance is outside its exception handler. + +## Mathematical coverage and boundaries + +The recipe checker independently implements the constant/epsilon arithmetic, +checks the literal fixed recipe for B=1 through 12, recovers all historical +B=1 through 6 case fields, and exercises arbitrary-input involutions with +dirty spectators. Its written all-B rank/trace proof is separate from those +finite checks. The attaining projector decompositions and the spectator +extension use every input column. The fixed-suffix conjugation clarification +is consistent with the chronological product convention. This establishes +the stated optimum only for complete scalar-conjugated single-bank +involution repairs of the fixed recipe, including arbitrary restored dirty +spectators. It does not permit changing the scalar topology or introducing +unpaired scalar mixing. + +The hybrid checker independently implements ordered free-group words, +literal inverses and distinct transpose labels. Its finite audits cover both +controller variants at B=1 through 12, 16 and 32, with all bank columns, +both inverse products, the dual and complete event inventories. The written +ladder proof establishes the all-B extension. The determinant specialization +proves the two-added-code minimum only in the declared universal independent +generator alphabet. It does not prove an optimum for a specialized physical +code pair, scalar ADD count or normalization cost. + +The selected native witness uses actual authenticated code coefficient +`A[3,0]=1` and exact rational relative routes. For ADDRESS push T, the VALUE +push is `g(w)=f(T^-1 w)`. The admitted source function `f(w)=1[w10=0]` is +constant on the source P0 line; the computed inverse route sends the target +P3 vector `2e3` to `2e10`, so `g(0)=1` and `g(2e3)=0`. This is the required +forward VALUE failure. The separate forward-route/pullback witness is a +dual check. The independent checker covers this selected ordered pair; the +historical route generator retains its own full ordered-pair census. + +The independent semantic controls alter authenticated mathematical events +and require their intended errors. In particular, deleting a declared +normalization does not change the abstract endpoint: its control checks the +normalization inventory explicitly. It is not represented as a proof of +native normalization or arbitrary-helper cleanup. + +The two alphabets remain distinct: the fixed involution recipe is over +characteristic two with a nilpotent coefficient, whereas the hybrid proof +uses signed noncommuting invertible labels. No conclusion is transferred +between them without its stated premises. The conditional 111-child tariff, +the 1499/111 scalar invoice and the historical 60/492/309 owner terms remain +declared source premises. Native frame legality, physical source access, +private helper restoration, COPY lifetimes, integer helper leakage, +precision, a general caller recurrence and any new kappa bound remain +outside this package's conclusion. diff --git a/research/bit-fixed-controller-repairs/SOURCE-AUDIT.md b/research/bit-fixed-controller-repairs/SOURCE-AUDIT.md new file mode 100644 index 0000000000..f755df132c --- /dev/null +++ b/research/bit-fixed-controller-repairs/SOURCE-AUDIT.md @@ -0,0 +1,112 @@ +# B07 source audit before integration + +Scope: the fixed routed recipe, the explicit closed hybrid and the explicit +early-promotion witness. This audit does not admit a general caller, native +precision, helper ownership, or a new exponent. Substantial OpenAI Codex +assistance was used. + +## Minimal historical replay closure + +The unchanged historical execution needs six Python sources, three data +artifacts and three fixed scientific receipts: + +| Source | Selected definitions or purpose | +| --- | --- | +| `closed_hybrid.py` | All mathematical functions through `receipt`; exclude its filesystem `main`. Its nested `recipe` loader must use authenticated source bytes. | +| `bit_nilpotent_recipe.py` | `rank`, `main`; execute its bounded B=1,...,6 computation with fresh external output. | +| `bit_seeded_star.py` | Only `need`, `mul`, `plus`, `scale`, `ident`, supplying the four-element ring arithmetic. | +| `early_promotion.py` | `need`, `main`; execute against authenticated explicit inputs and fresh external output. | +| `expanded_sections.py` | `need`, `bits`, `xor`, `eye`, `product`, `mm`, `tr`, `eyeq`, `roots_and_routes`. | +| `global_k.py` | Only the unique top-level `recipe` definition. No configuration, placement or bank-route imports are needed. | + +The data are the exact `BIT-THREE-ROW-INPUT.json`, R438 +`r438-t154.json.gz`, and full-root `bitE8-r865.json.gz`. The fixed receipts are +`BIT-NILPOTENT-RECIPE.json`, `CLOSED-HYBRID.json`, and +`EARLY-PROMOTION.json`. `bit_cap_copy_local.py` additionally preserves the +source of the literal `RAW_SHA` binding; no cap-copy function is required. +The original hybrid README supplies contract and attribution context. +These two provenance documents bring the current frozen inventory to 14 files. + +The seeded-star receipt and its `main`, the expanded-sections receipt and its +`main`, and the `geometry.py` hash read used only by that excluded main are +outside this replay. The new independent mathematical reviewers own their +separate construction and theorem obligations. + +## Required adapters + +The original programs use absolute paths and ordinary sibling imports. These +are replaced by explicit authenticated namespaces and a read-only logical-path +map. Every historical `read_bytes` must delegate to `Frozen.raw`, including: + +- `RECIPE` or `SOURCE` for `global_k.py`; +- `OLD/recursive/BIT-THREE-ROW-INPUT.json`; +- `ENDPOINT/expanded_sections.py`, whose original byte hash enters the receipt; +- `source.cap.RAW`; +- `REPO/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz`. + +No fallback to an ambient checkout or normal source importer is needed. +The full-root file is a real dependency of `roots_and_routes`; freezing only +the punctured R438 word is insufficient. + +Two original loaders compile nested recipe ASTs without an explicit +optimization setting and select the first definition with `next`. Supply a +compiler that forces `dont_inherit=True, optimize=0`, and require exactly one +top-level recipe definition before either old loader runs. All selected +definitions were inspected for imports, decorators and default-expression +side effects. The current mathematical definitions contain no `assert`; +synthetic direct, nested and nested-recipe assertion controls still establish +the loader's behavior under optimized Python. + +The literal `RAW_SHA` must be extracted from the authenticated cap-copy source +and checked against the retained R438 digest. Merely assigning that field from +the current manifest would authenticate the R438 bytes without binding the +retained cap source's named constant. + +Report `global_k.py::recipe` as executed through the nested loader, as well +as the selected route generator. A list of compiled historical function +definitions should not imply that unrelated original entrypoints ran. + +The two selected `main` functions may retain their original `--write` branches +only with `HERE` set to a fresh external temporary directory. Compare the +entire resulting JSON with each separately frozen receipt. Do not regenerate +a missing fixed receipt. Python structural equality accepts `True == 1`; +canonical JSON comparison must preserve scalar types, list order and every +nested field. + +## Mathematical control boundaries + +The historical closed target is `diag(1,-1,1,-1,...)` over the integral free +group algebra. It becomes identity only in characteristic two. It is +involutive, so repeating the entire forward endpoint is a vacuous inverse +control. Change the direction of one actual inverse code operation instead. +The original compensation, B1-pullback and stale-coded-stage mutations alter +actual words and compare their complete eight-input endpoint coefficients. + +`normalize` is the identity on the logical rows in the historical interpreter. +Its omission cannot be detected by endpoint algebra. The two native +normalization sweeps and their tariffs remain separate explicit premises or +invoice checks. Ordinary dirty-helper restoration is likewise a premise of +these abstract local interfaces, not an extra bank silently initialized to zero. + +The unused `bit_seeded_star.inverse_event` returns every event unchanged and +comments that all primitives are involutive. That statement does not hold +for `new_F`: its square has target `(1+N)x+y`. Its actual `main` correctly +switches `new_F` to `new_F_inverse`. The misleading unused helper is excluded +from this package's required extraction and must not be reported as verified. + +The small ring primitives assume equal row lengths and entries in `0..3`; +`plus` uses `zip` and does not itself validate dimensions. The fixed generated +recipes meet those premises. The new general-B proof and checker must state +and enforce their own dimension and ring-domain contracts. + +The early-promotion witness is an actual off-diagonal code entry and a +15-coordinate rational route, also nonzero over the specified odd field. +It does not obstruct every new promoted-input factory or changed controller. +The route function's all-pairs census is a finite geometric calculation; +the fresh independent reviewer must distinguish it from the general written +claim. + +Numerical comparison constants such as the old 60-unit local tariff and the +492-unit allowance are literal source premises in the historical receipt. +Reproducing those literals does not independently derive their owner, budget +or native implementation hypotheses. diff --git a/research/bit-fixed-controller-repairs/SOURCE-CLOSURE.json b/research/bit-fixed-controller-repairs/SOURCE-CLOSURE.json new file mode 100644 index 0000000000..2ca33a69df --- /dev/null +++ b/research/bit-fixed-controller-repairs/SOURCE-CLOSURE.json @@ -0,0 +1,159 @@ +{ + "additional_provenance_files": 2, + "ambient_imports_required": false, + "core_audit_note": "SOURCE-AUDIT.md", + "fixed_receipts": 3, + "frozen_files": { + "frozen/geometry/E8.json.gz": { + "bytes": 33865, + "original_path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "role": "complete fixed data artifact", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "frozen/geometry/MATRICES.json": { + "bytes": 28228, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-ROW-INPUT.json", + "role": "complete fixed data artifact", + "sha256": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979" + }, + "frozen/geometry/R438.json.gz": { + "bytes": 42305, + "original_path": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "role": "complete fixed data artifact", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "frozen/hybrid/CLOSED-HYBRID.json": { + "bytes": 10950, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/CLOSED-HYBRID.json", + "role": "complete fixed scientific receipt", + "sha256": "f12bf6aabe9ea0cb058eab5d68f10886cddff6200f7e00b40c048f4cf01689b7" + }, + "frozen/hybrid/EARLY-PROMOTION.json": { + "bytes": 2226, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/EARLY-PROMOTION.json", + "role": "complete fixed scientific receipt", + "sha256": "c278d5bd9cca084cbeae5212b73afa5f03461ecb4af9e18608bda0c54c89a2d6" + }, + "frozen/hybrid/README.md": { + "bytes": 8657, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/README.md", + "role": "contract and attribution provenance only", + "sha256": "0206fc9c9950e04baf4b9395af0a1e0b9a99907900b328eb06eb48477703ea24" + }, + "frozen/hybrid/closed_hybrid.py": { + "bytes": 13193, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/closed_hybrid.py", + "role": "selected unchanged source definitions", + "selected_assert_count": 0, + "selected_decorators": 0, + "selected_definitions": [ + "need", + "reduce_word", + "inverse_word", + "add", + "left", + "identity", + "serial", + "recipe", + "old_word", + "hybrid_word", + "apply", + "evaluate", + "transpose_operator_word", + "transpose_operators", + "product", + "receipt" + ], + "sha256": "78f92b8b8fdb6528bd87f974f3022e73c9b60877f0022200fe0b4422da2b7738" + }, + "frozen/hybrid/early_promotion.py": { + "bytes": 4771, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/early_promotion.py", + "role": "selected unchanged source definitions", + "selected_assert_count": 0, + "selected_decorators": 0, + "selected_definitions": [ + "need", + "main" + ], + "sha256": "d59e5487251929416fa657f45e617d78a3392310203f1df08389d3746acd6732" + }, + "frozen/provenance/bit_cap_copy_local.py": { + "bytes": 7588, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_cap_copy_local.py", + "role": "literal RAW_SHA provenance only; no function execution", + "sha256": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb" + }, + "frozen/recipe/BIT-NILPOTENT-RECIPE.json": { + "bytes": 30914, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/BIT-NILPOTENT-RECIPE.json", + "role": "complete fixed scientific receipt", + "sha256": "ef97f43313ccffb7a8ea5965d37b37452b70cf4ccfbafe81e9e92e46d0f1a14a" + }, + "frozen/recipe/bit_nilpotent_recipe.py": { + "bytes": 3727, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/bit_nilpotent_recipe.py", + "role": "selected unchanged source definitions", + "selected_assert_count": 0, + "selected_decorators": 0, + "selected_definitions": [ + "rank", + "main" + ], + "sha256": "d2649a223c4fd221e64dc059422bcf796fbe1becc524911c7e84c0cf475b2b7e" + }, + "frozen/recipe/bit_seeded_star.py": { + "bytes": 6317, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/bit_seeded_star.py", + "role": "selected unchanged source definitions", + "selected_assert_count": 0, + "selected_decorators": 0, + "selected_definitions": [ + "need", + "mul", + "plus", + "scale", + "ident" + ], + "sha256": "91d3bbebfad36836b48949a2d231afd3eb8dd46f0443d45f7e19ff9779468347" + }, + "frozen/routes/expanded_sections.py": { + "bytes": 8284, + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/expanded_sections.py", + "role": "selected unchanged source definitions", + "selected_assert_count": 0, + "selected_decorators": 0, + "selected_definitions": [ + "need", + "bits", + "xor", + "eye", + "product", + "mm", + "tr", + "eyeq", + "roots_and_routes" + ], + "sha256": "b5b0f01da04d95ccaae56cfb503bbf12bdd47442a924802c280089acc564795b" + }, + "frozen/upstream/global_k.py": { + "bytes": 16791, + "original_path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "role": "selected unchanged source definitions", + "selected_assert_count": 0, + "selected_decorators": 0, + "selected_definitions": [ + "recipe" + ], + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + } + }, + "no_route_census_or_general_B_replay": true, + "original_expanded_sections_main_required": false, + "original_global_generator_main_required": false, + "original_seeded_star_main_required": false, + "runtime_data_files": 3, + "runtime_source_files": 6, + "schema": "b07-historical-source-closure-v1", + "status": "PASS_STATIC_EXACT_SOURCE_CLOSURE" +} diff --git a/research/bit-fixed-controller-repairs/SOURCES.json b/research/bit-fixed-controller-repairs/SOURCES.json new file mode 100644 index 0000000000..9b44773308 --- /dev/null +++ b/research/bit-fixed-controller-repairs/SOURCES.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "usage": "provenance" + }, + { + "path": "docs/research/agent-task-catalog.json", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96", + "usage": "provenance" + }, + { + "path": "docs/research/research-family-status.md", + "git_blob": "abdd2792e6a5596b3fa6be3dc9db882bd8e3ef89", + "sha256": "0e61c47dfbc6f16e5f64594fcc7d907d4187568e38dddf10d473f0992419c44f", + "usage": "provenance" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "git_blob": "3df12bd632f1fdba825ced57110a1fee82eb2857", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "usage": "provenance" + }, + { + "path": "research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "usage": "provenance" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "usage": "provenance" + }, + { + "path": "research/bit-r438-source-code/README.md", + "git_blob": "e501165027be66b75c60b13ed93377c4a58c1d0c", + "sha256": "f1033297e1156f9fb154a4319bee394a82476195cd2a53d01d93ef7332536d27", + "usage": "provenance" + }, + { + "path": "research/r429-full-target-interface/README.md", + "git_blob": "d54eea80e4aefce50b28ae48b3e5e15162cb636d", + "sha256": "79d3cec7177676aeb501488cc2415ffbcda6515ef75f005731a91d48c62a67f9", + "usage": "provenance" + }, + { + "path": "research/r429-full-target-interface/PROOF-CALLER.md", + "git_blob": "f23f8772371cd1196fc7fe1578c36e47acaa3634", + "sha256": "a8c05af3bf3a973d7f2c44e356fa635bcf1146ca22286be2454b3b91581eae60", + "usage": "provenance" + } + ] +} diff --git a/research/bit-fixed-controller-repairs/TASK.json b/research/bit-fixed-controller-repairs/TASK.json new file mode 100644 index 0000000000..27d2e3a35f --- /dev/null +++ b/research/bit-fixed-controller-repairs/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the sharp all-bank-count repair tariff for the fixed inherited BIT recipe and a two-code closed hybrid in its separate local alphabet, with exact inverse/dual, actual early-promotion witness and explicit conditional costs.", + "scope_change_reason": "Explicit donor assignment to finish unpublished B06 remainder/B07 and extend promising results. These are two scoped comparisons of the same inherited bank recipe, not a new QQ16 supplier target.", + "bottleneck_link": "Local endpoint identities need paid terminal correction and legal native admission; a formal repair optimum cannot be charged as a complete physical supplier.", + "budget_minutes": 240, + "stop_rule": "Keep the inherited recipe and the two declared local alphabets. Prove the closed all-B identities and attaining repairs; stop before broader controller search or new supplier admission.", + "outcome": "partial", + "evidence": "Three fully regenerated original receipts, two independent exact checkers, written all-B proofs, explicit attaining repairs and typed source/control checks.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance in original construction, independent mathematical checking contexts and publication. AI review is not human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Can a changed native hybrid reduce or amortize the two normalization sweeps while preserving arbitrary inputs?", + "why_it_matters": "The scalar code count improves but the stated native comparison still loses 102 rank units.", + "first_step": "Specify the exact current frames, all mixed helper owners and a complete terminal/source-access invoice.", + "blocked_by": "No native mixed-owner or rounded implementation is supplied." + }, + { + "question": "Can changing the original paid recipe improve on the fixed-repair tariff?", + "why_it_matters": "The sharp theorem fixes all original operations and allows only complete conjugated single-bank N repairs.", + "first_step": "State which original local or scalar-control operation changes and derive its full arbitrary-input endpoint.", + "blocked_by": "Any new topology requires its own native and full-cost admission." + } + ] +} diff --git a/research/bit-fixed-controller-repairs/VERIFY.json b/research/bit-fixed-controller-repairs/VERIFY.json new file mode 100644 index 0000000000..bfa9cf437a --- /dev/null +++ b/research/bit-fixed-controller-repairs/VERIFY.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "historical" + ], + "timeout_seconds": 90, + "checks": "All three complete original receipts, unchanged mathematical functions and explicit authenticated source-read closure." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "recipe" + ], + "timeout_seconds": 120, + "checks": "Independent dual-number recipe, all-B rank/trace and attaining-projector formula fixtures, arbitrary-input N/spectator instantiations and intended controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "hybrid" + ], + "timeout_seconds": 120, + "checks": "Independent ordered free-group-ring all-input words, two-code correction, both inverses/dual, restricted determinant count, selected actual ADDRESS witness and invoice controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py", + "--package", + "{package}" + ], + "timeout_seconds": 60, + "checks": "Normal and optimized source/AST/path bindings, complete typed receipt comparisons, actual semantic defects and deliberate check deletion." + } + ] +} diff --git a/research/bit-fixed-controller-repairs/controls.py b/research/bit-fixed-controller-repairs/controls.py new file mode 100644 index 0000000000..989bab31e4 --- /dev/null +++ b/research/bit-fixed-controller-repairs/controls.py @@ -0,0 +1,458 @@ +#!/usr/bin/env python3 +"""Compact B07 source-selection and acceptance controls. + +No route census or independent general-B replay is run here. +The fixed small hybrid word supplies one semantic inverse control. +Prepared for Ross with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import copy +import gzip +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import types + + +HERE = Path(__file__).resolve().parent + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def load_verifier(package): + path = package / "verify.py" + raw = path.read_bytes() + module = types.ModuleType("b07_control_verifier") + module.__file__ = str(path) + exec(compile(raw, str(path), "exec", dont_inherit=True, optimize=0), module.__dict__) + return module, sha(raw) + + +def reject(name, action, expected, records): + try: + action() + except (ValueError, AssertionError, FileNotFoundError) as error: + need(expected in str(error), f"wrong rejection for {name}: {error}") + records.append({"name": name, "reason": str(error)}) + else: + raise ValueError("control accepted: " + name) + + +def fixture(directory, entries, original=None): + root = Path(directory).resolve() + root.mkdir(parents=True) + hashes, origins = {}, {} + for name, raw in entries.items(): + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(raw) + hashes[name] = sha(raw) + origins[name] = {"sha256": sha(raw)} + if original and name in original: + origins[name]["original_sha256"] = sha(original[name]) + (root / "FROZEN-SHA256.json").write_text(json.dumps(hashes)) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + return root + + +def source_checks(v, temporary): + source = ( + b'import a_module_that_does_not_exist\n' + b'raise RuntimeError("ORIGINAL_TOP_LEVEL_RAN")\n' + b'def chosen(x=3):\n return x + 4\n' + b'def assertion():\n assert False, "EXTRACTED_ASSERT"\n' + b'def nested():\n def inner():\n assert False, "NESTED_ASSERT"\n' + b' return inner()\n' + b'def main():\n raise RuntimeError("ORIGINAL_MAIN_RAN")\n' + b'if __name__ == "__main__":\n main()\n' + ) + root = fixture(temporary / "source", { + "frozen/source.py": source, + "frozen/duplicate.py": b"def duplicate():\n return 1\n" + b"def duplicate():\n return 2\n", + "frozen/module.py": b'assert False, "MODULE_ASSERT"\n', + "frozen/module_main.py": b'VALUE = 7\n' + b'if __name__ == "__main__":\n' + b' raise RuntimeError("ORIGINAL_MAIN_RAN")\n', + }) + f = v.Frozen(root) + f.check_all() + chosen = f.functions("frozen/source.py", ["chosen"], {}) + need(chosen.chosen() == 7 and set(vars(chosen)) == {"chosen"}, + "only declared functions should be exported") + need(f.executed == {"frozen/source.py": ["chosen"]}, "selected-source receipt") + rejected = [] + reject("direct_runtime_gate_under_parent_flags", + lambda: v.need(False, "DIRECT_RUNTIME_GATE"), "DIRECT_RUNTIME_GATE", rejected) + reject("extracted_assert_under_parent_flags", + lambda: f.functions("frozen/source.py", ["assertion"], {}).assertion(), + "EXTRACTED_ASSERT", rejected) + reject("nested_assert_under_parent_flags", + lambda: f.functions("frozen/source.py", ["nested"], {}).nested(), + "NESTED_ASSERT", rejected) + reject("authenticated_module_assert_under_parent_flags", + lambda: f.module("frozen/module.py"), "MODULE_ASSERT", rejected) + module = f.module("frozen/module_main.py") + need(module["VALUE"] == 7 and module["__name__"] == "authenticated_review", + "independent module main exclusion") + (root / "frozen/module.py").write_bytes(b"VALUE = 99\n") + reject("changed_authenticated_module", + lambda: f.module("frozen/module.py"), "frozen input changed", rejected) + reject("missing_named_definition", + lambda: f.functions("frozen/source.py", ["absent"], {}), + "function selection changed", rejected) + reject("duplicate_source_definition", + lambda: f.functions("frozen/duplicate.py", ["duplicate"], {}), + "function selection changed", rejected) + reject("duplicate_requested_name", + lambda: f.functions("frozen/source.py", ["chosen", "chosen"], {}), + "function selection changed", rejected) + reject("unregistered_source", + lambda: f.functions("frozen/unknown.py", ["chosen"], {}), + "unregistered frozen input", rejected) + (root / "frozen/source.py").write_bytes(b"def chosen():\n return 99\n") + reject("changed_authenticated_source", + lambda: f.functions("frozen/source.py", ["chosen"], {}), + "frozen input changed", rejected) + (root / "frozen/source.py").unlink() + reject("missing_registered_source", + lambda: f.functions("frozen/source.py", ["chosen"], {}), + "source.py", rejected) + return {"imports_top_level_and_main_excluded": True, "rejections": rejected} + + +def nested_source_checks(v, temporary): + import ast + entries = { + "frozen/recipe.py": b'import unavailable_original_dependency\n' + b'raise RuntimeError("ORIGINAL_TOP_LEVEL_RAN")\n' + b'def recipe(K):\n return K + 19\n', + "frozen/assert_recipe.py": b'def recipe(K):\n' + b' def inner():\n' + b' assert False, "NESTED_RECIPE_ASSERT"\n' + b' return inner()\n', + "frozen/duplicate.py": b'def recipe(K):\n return 1\n' + b'def recipe(K):\n return 2\n', + "frozen/absent.py": b'def other(K):\n return 0\n', + } + root = fixture(temporary / "nested", entries) + f = v.Frozen(root) + mapping = {"source/" + name.split("/")[-1]: name for name in entries} + mapping["source/unregistered.py"] = "frozen/unregistered.py" + source = v.SourcePath(f, mapping) + path = source / "source" / "recipe.py" + need(path.read_bytes() == entries["frozen/recipe.py"], "exact mapped source bytes") + need(not hasattr(path, "write_bytes") and not hasattr(path, "write_text"), + "source path should expose no write interface") + def nested(name): + raw = (source / "source" / name).read_bytes() + tree = v.recipe_tree(raw) + definition = next(n for n in tree.body + if isinstance(n, ast.FunctionDef) and n.name == "recipe") + namespace = {} + exec(v.compile_checked(ast.Module(body=[definition], type_ignores=[]), + str(source / "source" / name), "exec"), namespace) + return namespace["recipe"](4) + need(nested("recipe.py") == 23, "nested recipe positive control") + rejected = [] + reject("undeclared_logical_read", lambda: (source / "missing").read_bytes(), + "undeclared historical source read", rejected) + reject("absolute_path_escape", lambda: (source / "/etc/passwd").read_bytes(), + "undeclared historical source read", rejected) + reject("relative_path_escape", lambda: (source / "../outside").read_bytes(), + "undeclared historical source read", rejected) + reject("mapped_unregistered_input", lambda: (source / "source/unregistered.py").read_bytes(), + "unregistered frozen input", rejected) + reject("nested_recipe_assert_under_parent_flags", lambda: nested("assert_recipe.py"), + "NESTED_RECIPE_ASSERT", rejected) + reject("duplicate_nested_recipe", lambda: nested("duplicate.py"), + "recipe definition must be unique", rejected) + reject("missing_nested_recipe", lambda: nested("absent.py"), + "recipe definition must be unique", rejected) + (root / "frozen/recipe.py").write_bytes(b'def recipe(K):\n return 99\n') + reject("mapped_changed_bytes", path.read_bytes, "frozen input changed", rejected) + (root / "frozen/recipe.py").unlink() + reject("mapped_missing_file", path.read_bytes, "recipe.py", rejected) + return {"only_authenticated_mapped_reads": True, + "original_imports_and_top_level_excluded": True, "rejections": rejected} + + +def literal_pin_checks(v, package): + frozen = v.Frozen(package) + value = v.literal_raw_sha(frozen.raw("frozen/provenance/bit_cap_copy_local.py")) + need(value == frozen.hashes["frozen/geometry/R438.json.gz"], + "actual cap-copy constant and R438 digest") + valid = b"RAW_SHA = '" + b"a" * 64 + b"'\n" + need(v.literal_raw_sha(valid) == "a" * 64, "literal pin positive fixture") + rejected = [] + reject("missing_literal_pin", lambda: v.literal_raw_sha(b"OTHER = 1\n"), + "original RAW_SHA binding must be unique", rejected) + reject("duplicate_literal_pin", lambda: v.literal_raw_sha(valid + valid), + "original RAW_SHA binding must be unique", rejected) + reject("wrong_literal_pin_type", lambda: v.literal_raw_sha(b"RAW_SHA = 123\n"), + "original RAW_SHA is not a digest", rejected) + reject("executable_pin_expression", lambda: v.literal_raw_sha(b"RAW_SHA = side_effect()\n"), + "malformed node or string", rejected) + return {"actual_original_pin_matches": True, "rejections": rejected} + + +def receipt_checks(v, temporary): + value = {"integer": 1, "boolean": True, "nested": {"ordered": [1, 2, 3]}} + root = fixture(temporary / "receipt", { + "frozen/receipt.json": json.dumps(value).encode(), + }) + f = v.Frozen(root) + f.check_all() + f.compare("frozen/receipt.json", copy.deepcopy(value)) + rejected = [] + mutations = { + "boolean_for_integer": dict(value, integer=True), + "float_for_integer": dict(value, integer=1.0), + "integer_for_boolean": dict(value, boolean=1), + "nested_omission": dict(value, nested={}), + "list_reordering": dict(value, nested={"ordered": [1, 3, 2]}), + "list_truncation": dict(value, nested={"ordered": [1, 2]}), + } + for name, altered in mutations.items(): + reject(name, lambda altered=altered: f.compare("frozen/receipt.json", altered), + "complete receipt mismatch", rejected) + (root / "frozen/receipt.json").unlink() + reject("missing_fixed_receipt", lambda: f.compare("frozen/receipt.json", value), + "receipt.json", rejected) + need(not (root / "frozen/receipt.json").exists(), "missing receipt was regenerated") + (root / "frozen/receipt.json").write_bytes(json.dumps(value).encode()) + saved = v.need + try: + v.need = lambda ok, message: ( + None if message.startswith("complete receipt mismatch") else saved(ok, message)) + try: + reject("disabled_receipt_gate", + lambda: f.compare("frozen/receipt.json", mutations["boolean_for_integer"]), + "complete receipt mismatch", []) + except ValueError as error: + need(str(error) == "control accepted: disabled_receipt_gate", + "receipt check deletion sensitivity") + else: + raise ValueError("receipt mutation survived deletion of its target check") + finally: + v.need = saved + return {"rejections": rejected, "deleted_named_check_detected": True} + + +def compression_checks(v, temporary): + plain = b'{"all":"original bytes","ordered":[1,2,3]}\n' + name = "frozen/original.json.gz" + root = fixture(temporary / "compression", + {name: gzip.compress(plain, mtime=0)}, {name: plain}) + f = v.Frozen(root) + f.check_all() + need(f.decoded(name) == plain, "complete decompression") + rejected = [] + changed = gzip.compress(b'{"all":"different bytes","ordered":[1,2,3]}\n', mtime=0) + (root / name).write_bytes(changed) + reject("changed_compressed_bytes", f.check_all, "frozen input changed", rejected) + # Both manifests must agree about storage bytes before the separate + # original-byte binding can be reached. + f.hashes[name] = sha(changed) + reject("origin_container_hash_mismatch", f.check_all, + "origin container binding differs", rejected) + origins = json.loads((root / "ORIGINS.json").read_bytes()) + origins[name]["sha256"] = sha(changed) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + reject("changed_decompressed_original", f.check_all, + "compressed original bytes changed", rejected) + equivalent = gzip.compress(plain, mtime=17) + (root / name).write_bytes(equivalent) + f.hashes[name] = sha(equivalent) + origins[name]["sha256"] = sha(equivalent) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + f.check_all() + need(f.decoded(name) == plain, "equivalent compression rejected") + (root / "ORIGINS.json").write_text("{}") + reject("origin_inventory_omission", f.check_all, + "origin and frozen inventories differ", rejected) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + f.check_all() + return {"rejections": rejected, "equivalent_storage_with_same_original_accepted": True} + + +def mathematical_checks(v, package): + import ast + import hashlib + from types import SimpleNamespace + frozen = v.Frozen(package) + frozen.check_all() + source = v.SourcePath(frozen, {"recipe.py": "frozen/upstream/global_k.py"}) + api = SimpleNamespace(parse=v.recipe_tree, FunctionDef=ast.FunctionDef, Module=ast.Module) + names = ["need", "reduce_word", "inverse_word", "add", "left", "identity", "serial", + "recipe", "old_word", "hybrid_word", "apply", "evaluate", "transpose_operator_word", + "transpose_operators", "product", "receipt"] + hybrid = frozen.functions("frozen/hybrid/closed_hybrid.py", names, + {"ast": api, "compile": v.compile_checked, + "sha256": hashlib.sha256, "RECIPE": source / "recipe.py", + "PIN": "20ecf2891d80b5acf18d980b2164fb44ea7faa90"}) + good = hybrid.receipt() + frozen.compare("frozen/hybrid/CLOSED-HYBRID.json", good) + namespace = hybrid.receipt.__globals__ + original_apply, original_need = namespace["apply"], namespace["need"] + fault = {"used": False} + def changed_inverse(rows, event, backwards=False): + if backwards and event["kind"] == "code" and not fault["used"]: + fault["used"] = True + return original_apply(rows, event, backwards=False) + return original_apply(rows, event, backwards) + rejected = [] + try: + namespace["apply"] = changed_inverse + reject("one_actual_inverse_code_runs_forward", hybrid.receipt, + "literal reverse-inverse cleanup", rejected) + need(fault["used"], "actual inverse-code fault was not reached") + namespace["need"] = lambda ok, message: ( + None if message == "literal reverse-inverse cleanup" else original_need(ok, message)) + fault["used"] = False + try: + reject("disabled_literal_inverse_gate", hybrid.receipt, + "literal reverse-inverse cleanup", []) + except ValueError as error: + need(str(error) == "control accepted: disabled_literal_inverse_gate", + "mathematical check deletion sensitivity") + else: + raise ValueError("inverse mutation survived deletion of its target check") + need(fault["used"], "deleted-gate fault was not reached") + finally: + namespace["apply"], namespace["need"] = original_apply, original_need + independent = frozen.module("frozen/reviews/recipe/check.py") + def fail(message): + raise ValueError(message) + accepted = independent["reject"]("intended_fixture", lambda: fail("INTENDED"), "INTENDED") + need(accepted["rejection"] == "INTENDED", "independent intended-gate fixture") + reject("independent_control_rejects_unrelated_error", + lambda: independent["reject"]( + "unrelated_fixture", lambda: fail("UNRELATED"), "INTENDED"), + "wrong rejection for unrelated_fixture", rejected) + return {"actual_authenticated_function": "closed_hybrid.receipt", + "formal_input_rows": 8, "coefficient_ring": good["coefficient_ring"], + "one_literal_inverse_code_direction_changed_after_authentication": True, + "rejections": rejected, "deleted_named_check_detected": True} + + +def real_receipts(v, package): + frozen = v.Frozen(package) + names = [ + "frozen/hybrid/CLOSED-HYBRID.json", + "frozen/hybrid/EARLY-PROMOTION.json", + "frozen/recipe/BIT-NILPOTENT-RECIPE.json", + "frozen/reviews/recipe/CHECKS.json.gz", + "frozen/reviews/hybrid/CHECKS.json.gz", + ] + result = [] + + def leaves(value, path=()): + if isinstance(value, dict): + for key in sorted(value): + yield from leaves(value[key], path + (key,)) + elif isinstance(value, list): + for key, item in enumerate(value): + yield from leaves(item, path + (key,)) + else: + yield path, value + + for name in names: + value = frozen.data(name) + frozen.compare(name, copy.deepcopy(value)) + need(type(value) is dict and len(value) > 1, "real receipt structure") + changed = copy.deepcopy(value) + path, old = max(leaves(value), key=lambda item: len(item[0])) + need(len(path) > 1, "real receipt nested coverage") + parent = changed + for key in path[:-1]: + parent = parent[key] + if type(old) is bool: + parent[path[-1]] = not old + elif type(old) is int: + parent[path[-1]] = old + 1 + elif type(old) is str: + parent[path[-1]] = old + "-MUTATED" + else: + parent[path[-1]] = {"mutated": True} + rejected = [] + reject("real_nested_field_mutation", + lambda: frozen.compare(name, changed), "complete receipt mismatch", rejected) + omitted = copy.deepcopy(value) + parent = omitted + for key in path[:-1]: + parent = parent[key] + del parent[path[-1]] + reject("real_nested_field_omission", + lambda: frozen.compare(name, omitted), "complete receipt mismatch", rejected) + result.append({"receipt": name, "sha256": sha(frozen.raw(name)), + "mutated_nested_path": list(path), "rejections": rejected}) + return result + + +def child(package): + v, verifier_hash = load_verifier(package) + with tempfile.TemporaryDirectory(prefix="b07-controls-") as temp: + temporary = Path(temp).resolve() + result = { + "source_selection": source_checks(v, temporary), + "nested_sources": nested_source_checks(v, temporary), + "literal_source_pin": literal_pin_checks(v, package), + "receipt_contract": receipt_checks(v, temporary), + "compressed_original_binding": compression_checks(v, temporary), + "mathematical_controls": mathematical_checks(v, package), + "complete_real_receipts": real_receipts(v, package), + } + return {"parent_optimization": sys.flags.optimize, "verifier_sha256": verifier_hash, **result} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--package", type=Path, required=True) + parser.add_argument("--output", type=Path) + parser.add_argument("--child", action="store_true") + args = parser.parse_args() + package = args.package.resolve() + if args.child: + print(canonical(child(package))) + return + before = {name: sha((package / name).read_bytes()) + for name in ("verify.py", "FROZEN-SHA256.json", "ORIGINS.json")} + results = [] + for optimized in (False, True): + command = [sys.executable, "-I", "-B"] + if optimized: + command.append("-O") + command += [str(Path(__file__).resolve()), "--package", str(package), "--child"] + proc = subprocess.run(command, capture_output=True, text=True) + need(proc.returncode == 0, proc.stderr + proc.stdout) + results.append(json.loads(proc.stdout)) + need(all(sha((package / name).read_bytes()) == expected for name, expected in before.items()), + "verification core changed during compact controls") + need(all(x["verifier_sha256"] == before["verify.py"] for x in results), + "mixed verifier versions") + report = {"status": "PASS_B07_COMPACT_SOURCE_AND_MATHEMATICAL_GATES", + "source_hashes": before, "runs": results, + "route_census_or_general_B_replayed": False, + "small_fixed_hybrid_word_replayed": True, "no_new_kappa": True} + if args.output: + args.output.write_text(json.dumps(report, sort_keys=True, indent=2) + "\n") + print(canonical(report)) + + +if __name__ == "__main__": + main() diff --git a/research/bit-fixed-controller-repairs/frozen/geometry/E8.json.gz b/research/bit-fixed-controller-repairs/frozen/geometry/E8.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..8bec1751f7e33c3a1e4673ef5dbc34d6f205321e GIT binary patch literal 33865 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 F0sxs54@Cd~ literal 0 HcmV?d00001 diff --git a/research/bit-fixed-controller-repairs/frozen/geometry/MATRICES.json b/research/bit-fixed-controller-repairs/frozen/geometry/MATRICES.json new file mode 100644 index 0000000000..b73bf60626 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/geometry/MATRICES.json @@ -0,0 +1,1118 @@ +{ + "matrices": { + "B0": [ + 39, + 272, + 193 + ], + "C": [ + 1525985549154159990308229050892137, + 868815842344965628299048346020156, + 921600628995998434986948263566170 + ], + "C0": [ + 39, + 193, + 272 + ], + "F9": [ + 38, + 37, + 35, + 47, + 486, + 32, + 401, + 439, + 486 + ], + "H": [ + 2435152141571036339947241132521486, + 1676235005588950225218933581500878, + 1985881855729225176177634927700398, + 576460752303423479, + 2596069508172130947062333349822703, + 309485009244884317495099359, + 10140895326260170442259558318015, + 2586086145551572543258365643440255, + 2589398147263233519358262897489001, + 2592804859121274158248396097259625, + 2592757506467882867942327749505385, + 2589350696924854570449116603662953, + 2592757607046729626097202769225065, + 2589398046688157573239251990943081, + 1734130175483521454113919338159274, + 872127581635430275692856302967978, + 1734082824753018225619070127219626, + 872080229941564978246942081967018, + 1734082638102400486742802049377194, + 872080416603461748079412450059178, + 1734129989784902589838982619225258, + 872127767322601782224528012057770, + 1727411440318023397244010205189692, + 1730818316584958295536456233036092, + 865409096642019473566534911481404, + 868815842344965628299048312465724, + 1730818250503269321255597434906940, + 1727411504793977486514998242612796, + 868815908432870002457488389400892, + 865409032159589424156957136475708, + 2074858996396035948243032183350476, + 521289741389326929135848345773260, + 2074874778680810587002010371677132, + 521273956203100808511232534174668, + 2072878290888070053094984619596748, + 523270444007074256637602259213260, + 2072894076062932979370040723563724, + 523254661710936423529209318401228, + 2076939870114869318455535043620442, + 2070839202466181082725842274750810, + 519208660696083532087046669348442, + 525309130074591671054823598068058, + 2076913464757075216842810317853018, + 2070812995372221397883440020581978, + 519234867789959053610134593065306, + 525335535432301609385342510820954, + 1040477090824847938641120621672601, + 1557678348740587315422543376644249, + 1555671525429274415289046754834585, + 1040450598424477833956020544161689, + 1555697645480573934758181972035481, + 1038496385959229956686199488153497, + 1036415348463713915987060390989071, + 1559717362350266569457138779189775, + 1553616728556518518103859291114767, + 1553632511808493436610737168036367, + 1559733145605930584577179433667855, + 1036431132679051268236573095129615, + 1042531635912499996902255866825999, + 2442837275459972787867604775352560, + 153311153807439872482697688135920, + 153381061151871645922135271262192, + 2435152141571032296831911913588720, + 160996287696368250945970177312752, + 2435082234226561323937622632167664, + 161066195040797725438535476181232, + 2436839364805697551520070573952358, + 2441080144874030676477440684772710, + 2436881146555144115750106525659750, + 155110066145707204895318291460710, + 159309064460461694903411553799526, + 155068284390874191395430580669798, + 159267282707252382191578237432422, + 921600628986554049220172345615525, + 1682191151535119421842017996924069, + 921642409864502096000228197292965, + 1682232931534707996362662452239269, + 1674547800120299651826471254205605, + 913957277411173124529028742931621, + 1674506018760669530239658887633829, + 913915496448222481057609187695525, + 919913369774626757624573998837299, + 1680503778976952268902256777719347, + 1676304630755838562290390870348083, + 1676235037732122190192959896858163, + 1680434060224950656924623320813875, + 915644568083505924911912553377331, + 919843634097663672590244470411571, + 613258455012551051935980706536643, + 1982889317737070288973385274694851, + 613271454662945717308722385052611, + 1982873535281552587068141812638659, + 1982884713009696305588313795796163, + 613248589040009093434313723026627, + 1982855929623799733803660893807555, + 613232804024526035955953525908419, + 616739979317472700226294587053653, + 610084907965218710579626836486485, + 1979012216963470485452010633025109, + 1985271336101041249538680574437717, + 1978061571187198456537696014685781, + 1983369763776710285739684119177557, + 611748697252973517619043237877333, + 1059466916186105936643779914809238, + 1505680090170857789839556165861270, + 1485975326376127769826014943428502, + 989056453791076342151881663283094, + 1364281031450268375981883671625622, + 745667375834477930338916844797846, + 420571176367129553061060905975702, + 227888122428023580164624009756566 + ], + "Hinv": [ + 1036431066917147235800910130679281, + 155110066146297500705676997112420, + 159267282711974748674447882646114, + 2596069508172130947062333349822711, + 2592804859121274348434640409261446, + 915644696935251980586125816851987, + 872080229941564630634031984516117, + 2435152141571036908517930340976496, + 1036431066917147340706634380243727, + 1734082638102400139253257160253013, + 1070186092205683326968000072549481, + 10062283715840703413139600820479, + 2070839299192822143208225543290533, + 1982889664769853447109413392301251, + 10140895326260170442259558334463, + 1073192063923781737161094643124736, + 1982876011161631157828691610952643, + 1730739332625394452960466601203260, + 1036415348463713920490660018621711, + 153311153807441025404202294458608, + 1676304640427245119207424269046067, + 2072894076062932979370109445137612, + 2592757607046729823220815696431766, + 521289741389326929135850501645516, + 1526516934907711552607934707580777, + 915714280287592924605916055507251, + 1529546280007629316466569637415424, + 913915659233118696859702544196698, + 2596148119782403992920180245135359, + 519208559152544495809438779953573, + 1724020661944812032040721224196949, + 2074858687878086373295512064566476, + 1069631494359702562103442484674409, + 161066195040834618926674305349872, + 1982335066357199084675559718855619, + 1682232770034295463901145688597594, + 309485009244884386214576127, + 1040450783786839878381303724685414, + 921642409902281374218549567530074, + 1522956365343631975573826916682240, + 613272418105783168125849809511363, + 2441038363121116313561770190753177, + 610243364290247069726968685532842, + 2442837275459973364319560985753840, + 919843788840168583280371018846515, + 1525985710433553159048016831020905, + 1559717362350266578393969289753103, + 2442767368115540430806845405513712, + 2589350794613531380503080241935766, + 2586086145551572542695415690019071, + 1557678348740587010692700823783270, + 2441080237893630186555866680079001, + 3343570146139651513252439979414, + 1680503732332161711328218476801587, + 1069608120987932092906184992178281, + 1724068199325848799989509063547989, + 1042515917458920518617178903785999, + 1979329129613527234925030038055338, + 160996287696377186087630880376816, + 2441038458694039975247170088258969, + 523254661710935270607842150507724, + 865409032159587118313948459652668, + 1559733145605926044948755044207887, + 921642571468395098107766871008346, + 2586007224475014265204571375681535, + 610243267866221556537671819466410, + 1066602199611267145957523985156608, + 1040450598424330560229834852055142, + 1727411440317728249338830856558140, + 1042531700711485471725527578856719, + 1724020847630802946951674450305877, + 1680434098908215701351322088804659, + 1069631333068407784622856786853737, + 1042515851702917970256945386992143, + 160996558778007789427806529390576, + 1680503783774876615497816314834483, + 2074874472988755648007628401728460, + 1682190989289015706944831957343066, + 2076913561779686215541178679176869, + 1040477091429311152337862183700326, + 159309063252716656154253577745049, + 1522970289324512316543001337427200, + 2586086445383918843719784033403135, + 525309217129826174621822736395941, + 862065585171582474812111242026069, + 1559717257902736069339629582971407, + 610266650909441257157848505248170, + 2442767484456855233445308305491952, + 1982890246192099753008591449038019, + 1674547181301395389389199079005018, + 10063216987831545060963121086719, + 1038472369438856867742494982834022, + 6802684102716385337231157441942, + 1036441036199365695393960363979279, + 1985862048688596610093236541712810, + 1676274619670207470772119047417395, + 616739979317472863988461902768554, + 2434993414145487461660084877920240, + 915327732804701322897805558771251, + 1527173970883544922338623569084521, + 2594801552922449744736548978426111, + 521770168990415348554375416786597, + 1560741940843478793159745611581286, + 924056702458973789388645014594650, + 498926251092431692274353096085925, + 573248269215565368432219967660995, + 949866627363996986502486023640636, + 1391357451727305172726679790308623, + 2110563955902126796107423785679088, + 1943720399151029217252402151754390, + 228442881570021188546502354190185 + ], + "J": [ + 10141204792381678636617894477822, + 2586086450219622122178300732227837, + 2596069203522677974138045681631483, + 576460752303423479, + 2596069508172130947062333349822703, + 309485009244884317495099359, + 10140895326260170442259558318015, + 2586086145551572543258365643440255, + 2589398147263233519358262897489001, + 2592804859121274158248396097259625, + 2592757506467882867942327749505385, + 2589350696924854570449116603662953, + 2592757607046729626097202769225065, + 2589398046688157573239251990943081, + 1734130175483521454113919338159274, + 872127581635430275692856302967978, + 1734082824753018225619070127219626, + 872080229941564978246942081967018, + 1734082638102400486742802049377194, + 872080416603461748079412450059178, + 1734129989784902589838982619225258, + 872127767322601782224528012057770, + 1727411440318023397244010205189692, + 1730818316584958295536456233036092, + 865409096642019473566534911481404, + 868815842344965628299048312465724, + 1730818250503269321255597434906940, + 1727411504793977486514998242612796, + 868815908432870002457488389400892, + 865409032159589424156957136475708, + 2074858996396035948243032183350476, + 521289741389326929135848345773260, + 2074874778680810587002010371677132, + 521273956203100808511232534174668, + 2072878290888070053094984619596748, + 523270444007074256637602259213260, + 2072894076062932979370040723563724, + 523254661710936423529209318401228, + 2076939870114869318455535043620442, + 2070839202466181082725842274750810, + 519208660696083532087046669348442, + 525309130074591671054823598068058, + 2076913464757075216842810317853018, + 2070812995372221397883440020581978, + 519234867789959053610134593065306, + 525335535432301609385342510820954, + 1040477090824847938641120621672601, + 1557678348740587315422543376644249, + 1555671525429274415289046754834585, + 1040450598424477833956020544161689, + 1555697645480573934758181972035481, + 1038496385959229956686199488153497, + 1036415348463713915987060390989071, + 1559717362350266569457138779189775, + 1553616728556518518103859291114767, + 1553632511808493436610737168036367, + 1559733145605930584577179433667855, + 1036431132679051268236573095129615, + 1042531635912499996902255866825999, + 2442837275459972787867604775352560, + 153311153807439872482697688135920, + 153381061151871645922135271262192, + 2435152141571032296831911913588720, + 160996287696368250945970177312752, + 2435082234226561323937622632167664, + 161066195040797725438535476181232, + 2436839364805697551520070573952358, + 2441080144874030676477440684772710, + 2436881146555144115750106525659750, + 155110066145707204895318291460710, + 159309064460461694903411553799526, + 155068284390874191395430580669798, + 159267282707252382191578237432422, + 921600628986554049220172345615525, + 1682191151535119421842017996924069, + 921642409864502096000228197292965, + 1682232931534707996362662452239269, + 1674547800120299651826471254205605, + 913957277411173124529028742931621, + 1674506018760669530239658887633829, + 913915496448222481057609187695525, + 919913369774626757624573998837299, + 1680503778976952268902256777719347, + 1676304630755838562290390870348083, + 1676235037732122190192959896858163, + 1680434060224950656924623320813875, + 915644568083505924911912553377331, + 919843634097663672590244470411571, + 613258455012551051935980706536643, + 1982889317737070288973385274694851, + 613271454662945717308722385052611, + 1982873535281552587068141812638659, + 1982884713009696305588313795796163, + 613248589040009093434313723026627, + 1982855929623799733803660893807555, + 613232804024526035955953525908419, + 616739979317472700226294587053653, + 610084907965218710579626836486485, + 1979012216963470485452010633025109, + 1985271336101041249538680574437717, + 1978061571187198456537696014685781, + 1983369763776710285739684119177557, + 611748697252973517619043237877333, + 1059466916186105936643779914809238, + 1505680090170857789839556165861270, + 1485975326376127769826014943428502, + 989056453791076342151881663283094, + 1364281031450268375981883671625622, + 745667375834477930338916844797846, + 420571176367129553061060905975702, + 227888122428023580164624009756566 + ], + "K": [ + 496, + 22, + 511, + 25, + 21, + 499, + 26, + 508, + 118, + 488, + 415, + 491, + 117, + 412, + 217, + 161, + 174, + 214, + 324, + 316, + 307, + 331, + 295, + 185, + 351, + 193, + 339, + 205, + 299, + 181, + 179, + 290, + 196, + 341, + 199, + 342, + 176, + 289, + 164, + 314, + 309, + 171, + 313, + 167, + 168, + 310, + 493, + 405, + 124, + 112, + 481, + 409, + 398, + 104, + 502, + 385, + 31, + 505, + 103, + 445, + 454, + 91, + 457, + 434, + 84, + 47, + 478, + 55, + 425, + 59, + 421, + 76, + 466, + 265, + 369, + 382, + 262, + 370, + 266, + 261, + 381, + 286, + 358, + 248, + 357, + 251, + 285, + 131, + 138, + 283, + 253, + 364, + 241, + 352, + 134, + 279, + 372, + 234, + 229, + 379, + 271, + 145, + 158, + 475, + 419, + 74, + 50, + 416, + 472, + 49, + 73 + ], + "M": [ + 507, + 135, + 238, + 349, + 185, + 437, + 205, + 503, + 425 + ], + "N": [ + 506, + 133, + 234, + 341, + 169, + 405, + 141, + 375, + 169 + ], + "Q": [ + 1525985549154159990308229050892137, + 921600628995998434986948263566170, + 868815842344965628299048346020156, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "R": [ + 2589350794613531190557368506174057, + 2592804956806343667382164200032873, + 1038469893558777993237266185156761, + 1557652228689369648595160641472409, + 1042515851693473237291206096564751, + 2442767368115540430947582893869040, + 2441038363121116511671115291243110, + 915714330356837041509315611365683, + 610243267866258280493576590715221 + ], + "S": [ + 1, + 1, + 1, + 1, + 7, + 0, + 6, + 3, + 5 + ], + "T": [ + 3, + 1, + 1, + 0, + 4, + 1, + 2, + 2, + 4 + ], + "W": [ + 10, + 59, + 466, + 21, + 497, + 247, + 207, + 457, + 19, + 349, + 43, + 391, + 201, + 241, + 26, + 82, + 364, + 292, + 398, + 454, + 248, + 176, + 108, + 290, + 36, + 362, + 448, + 142, + 392, + 198, + 297, + 345, + 95, + 47, + 133, + 245, + 499, + 387, + 359, + 41, + 279, + 89, + 243, + 445, + 131, + 461, + 104, + 32, + 24, + 508, + 396, + 452, + 394, + 140, + 450, + 180, + 506, + 252, + 434, + 435, + 289, + 181, + 31, + 141, + 395, + 281, + 81, + 105, + 295, + 397, + 195, + 251, + 437, + 16, + 88, + 358, + 302, + 130, + 202, + 500, + 444, + 94, + 22, + 344, + 204, + 386, + 132, + 458, + 283, + 363, + 109, + 29, + 393, + 505, + 255, + 143, + 365, + 35, + 285, + 83, + 511, + 177, + 399, + 356, + 300, + 276, + 348, + 502, + 446, + 390, + 462 + ], + "X": [ + 357, + 447, + 80, + 436, + 196, + 39, + 287, + 272, + 193 + ], + "X0": [ + 82, + 408, + 119, + 436, + 5, + 0, + 15, + 0, + 0 + ], + "selected": [ + 0, + 1, + 2 + ] + }, + "producer": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/helper-boundary/BIT-THREE-ROW.json", + "producer_contract": { + "copied_snapshots": "Two unchanged arbitrary-helper snapshots per each of three target rows", + "final_frames": "source FULL; target Pp-perp; helper FULL", + "forward": "(x,y,h)->(Ax,y+Ax,h)", + "initial_frames": "source Pp; target0; helper0", + "literal_inverse": "(x,y,h)->(A^-1 x,y+x,h)", + "matrix_names": "H=A, Hinv=A^-1; J Hinv=I+Q" + }, + "producer_forward": { + "copies": 6, + "dirty_helpers_restored": 438, + "endpoint_sha256": "687b53099896320c0351e6ae9fae326b19c092904845bbd1d68a05871d497b16", + "max_live_copies": 1, + "nonzero_output_rows": 660, + "paths_sha256": "ffaf7043f1b2b615dc2b11ca0adf7925b3c6b662f745243018b7bddfeb39ae80", + "profile": { + "1": 1328, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "public_columns": 660, + "rank_mass": 5064 + }, + "producer_positive": { + "applicability": "Numerical screen only; changed source-code interface not admitted", + "forward": 3320097058, + "historical_local_guard_pass": false, + "historical_nine_guard_pass": false, + "local_bits": 173, + "nine_bits": 320, + "reverse": 60206953888 + }, + "producer_receipt_sha256_at_snapshot": "3e7af7fb5809844c97dd2f637f51463c2387d8a5da5a0ce98a371ae58f668b80", + "producer_reverse": { + "copies": 6, + "dirty_helpers_restored": 438, + "endpoint_sha256": "5bfc936d72331eecef8967246fbb242dc06fa6b7945c70ed0d24553496018783", + "max_live_copies": 1, + "nonzero_output_rows": 660, + "paths_sha256": "06c4cac22b8ef3107c1068db48bc18d58247d95c75c88ecc9695c0d3d0cbc996", + "profile": { + "1": 1328, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "public_columns": 660, + "rank_mass": 5064 + }, + "schema": "bit-three-row-audit-input-v1", + "source_code": { + "B": [ + 1070186092205683326968000072548457, + 872127581635430275692856303000746, + 521289741389326929135850493256908, + 8, + 153311153807441025404202294982896, + 32, + 64, + 128, + 1529532302407315035771526049019136, + 1522956415691818522681327695006208, + 1024, + 2048, + 4096, + 8192, + 2586007533941153643822988606291968, + 32768, + 65536, + 131072, + 262144, + 524288, + 1048576, + 2097152, + 4194304, + 8388608, + 16777216, + 33554432, + 67108864, + 134217728, + 268435456, + 536870912, + 2596148119782404569380930669510656, + 2147483648, + 4294967296, + 8589934592, + 17179869184, + 34359738368, + 68719476736, + 137438953472, + 274877906944, + 549755813888, + 1099511627776, + 2199023255552, + 4398046511104, + 8796093022208, + 17592186044416, + 35184372088832, + 70368744177664, + 140737488355328, + 281474976710656, + 562949953421312, + 1125899906842624, + 2251799813685248, + 4503599627370496, + 9007199254740992, + 18014398509481984, + 36028797018963968, + 72057594037927936, + 144115188075855872, + 288230376151711744, + 2596148429267413237804495861186560, + 1152921504606846976, + 2305843009213693952, + 4611686018427387904, + 9223372036854775808, + 18446744073709551616, + 36893488147419103232, + 73786976294838206464, + 147573952589676412928, + 295147905179352825856, + 590295810358705651712, + 1180591620717411303424, + 2361183241434822606848, + 4722366482869645213696, + 9444732965739290427392, + 18889465931478580854784, + 37778931862957161709568, + 75557863725914323419136, + 151115727451828646838272, + 302231454903657293676544, + 604462909807314587353088, + 1208925819614629174706176, + 2417851639229258349412352, + 4835703278458516698824704, + 9671406556917033397649408, + 19342813113834066795298816, + 38685626227668133590597632, + 77371252455336267181195264, + 154742504910672534362390528, + 309485009821345068724781056, + 618970019642690137449562112, + 1237940039285380274899124224, + 2475880078570760549798248448, + 4951760157141521099596496896, + 9903520314283042199192993792, + 19807040628566084398385987584, + 39614081257132168796771975168, + 79228162514264337593543950336, + 158456325028528675187087900672, + 316912650057057350374175801344, + 633825300114114700748351602688, + 1267650600228229401496703205376, + 2535301200456458802993406410752, + 5070602400912917605986812821504, + 10141204801825835211973625643008, + 20282409603651670423947251286016, + 40564819207303340847894502572032, + 81129638414606681695789005144064, + 162259276829213363391578010288128, + 324518553658426726783156020576256, + 649037107316853453566312041152512, + 1298074214633706907132624082305024 + ], + "D": [ + 209, + 344, + 28, + 370, + 191, + 392, + 12, + 394, + 24 + ], + "fanout_adds": 504, + "middle": [ + 1073758465, + 576460752303440144, + 276, + 1073759007, + 576460752303440642, + 576460752303440695, + 576460753377166167, + 576460753377181847, + 1073742615, + 576460753377165328, + 1073759489, + 576460752303442433, + 576460752303444225, + 576460753377173761, + 20, + 32770, + 1073808130, + 1073890050, + 576460752303686402, + 576460752303964930, + 576460753378230274, + 576460753379262466, + 4194836, + 8388884, + 16794132, + 33571092, + 576460753444274452, + 576460753511383572, + 576460753645617428, + 576460753914053140, + 576460753377165330, + 2147483652, + 4294984452, + 9663693572, + 576460769483293444, + 576460787736904452, + 576460822096658436, + 576460889742393348, + 274877907474, + 549755814162, + 1100585370130, + 2200096997650, + 576465150349951250, + 576469548396462610, + 576478345563226386, + 576495937749271058, + 70368744177681, + 140737488371729, + 281476050452497, + 577023702256861969, + 577586653284025105, + 578712553190851345, + 580964351930794247, + 585467951558181383, + 594475150812922119, + 612489550396129799, + 648518347415093511, + 720575941453038087, + 864691129528893703, + 272, + 1152921504606846992, + 2882303761517134608, + 4611686019501130512, + 9799832790231941904, + 19023204827086733328, + 36893488148492861456, + 73786976294838206726, + 147573952590750171398, + 295147905180426584582, + 590872271111009075718, + 1181168081469714727174, + 2361759702188199788806, + 4722942943623022395910, + 9444732965739290427397, + 18889465931478580871173, + 37778931862958235468549, + 75557863725915397161733, + 151116303912580950261765, + 302232031364409597116421, + 604463486268067964535557, + 1208926396075382551872261, + 2417851639229259423154707, + 4835703278458517772583443, + 9671406556917034471407891, + 19342813690294820172464659, + 38685626804128886967763219, + 77371253031797020558377491, + 154742505487133287739572499, + 309485009821345068724781059, + 618970019642690138523303939, + 1237940039285380275972883203, + 2475880078570760549798265603, + 4951760157717981851899920387, + 9903520314859502952570159107, + 19807040629142545151763170051, + 39614081257708629549075415811, + 79228162514264337593543967253, + 158456325028528675187087917333, + 316912650057057350375249560085, + 633825300114114700749425361173, + 1267650600228805862249006645781, + 2535301200457035263745709850901, + 5070602400913494066740190003733, + 10141204801825835211973625643798, + 20282409603651670423947251303190, + 40564819207303340847895576314646, + 81129638414606681695790078903062, + 162259276829213939852330313712406, + 324518553658427303243908324016918, + 649037107316854030027065418318614, + 1298074214633707483593377459487510 + ], + "pivots": [ + 0, + 1, + 2, + 4, + 8, + 9, + 14, + 30, + 59 + ], + "prepare_adds": 474, + "query": [ + 1070186092205683326968000072548457, + 872127581635430275692856303000746, + 521289741389326929135850493256908, + 153311153807441025404202294982896, + 1529532302407315035771526049019136, + 1522956415691818522681327695006208, + 2586007533941153643822988606291968, + 2596148119782404569380930669510656, + 2596148429267413237804495861186560 + ], + "quotient_adds": 35, + "unprepare_adds": 474 + }, + "source_gzip_sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "source_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_word": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "word_canonical_sha256": "b756b837a9bcfc3808fe85c5729f6c36269e65e68dacc95bb18ac91b50aa56fd", + "word_gzip_sha256": "b00f9492743418b40eb32d543ef0dcbe120ea121796b006dc9f88d2eacdd965e" +} diff --git a/research/bit-fixed-controller-repairs/frozen/geometry/R438.json.gz b/research/bit-fixed-controller-repairs/frozen/geometry/R438.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8 GIT binary patch literal 42305 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%0D#o{m4v0S^lXMc!B^5s|rQj}G= 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 literal 0 HcmV?d00001 diff --git a/research/bit-fixed-controller-repairs/frozen/hybrid/CLOSED-HYBRID.json b/research/bit-fixed-controller-repairs/frozen/hybrid/CLOSED-HYBRID.json new file mode 100644 index 0000000000..747541fb64 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/hybrid/CLOSED-HYBRID.json @@ -0,0 +1,670 @@ +{ + "coefficient_ring": "Z[free group(a0,...,a8)]", + "controls": [ + { + "defect": [ + [ + [ + [], + 0, + -1 + ], + [ + [], + 1, + 1 + ], + [ + [ + 1 + ], + 0, + 1 + ], + [ + [ + 2 + ], + 0, + 1 + ], + [ + [ + 2 + ], + 1, + -1 + ], + [ + [ + 2, + 1 + ], + 0, + -1 + ] + ], + [ + [ + [ + 1 + ], + 0, + -1 + ], + [ + [ + 1 + ], + 1, + 1 + ], + [ + [ + 1, + 1 + ], + 0, + 1 + ], + [ + [ + 1, + 2 + ], + 0, + 1 + ], + [ + [ + 1, + 2 + ], + 1, + -1 + ], + [ + [ + 1, + 2, + 1 + ], + 0, + -1 + ] + ], + [], + [], + [], + [], + [], + [] + ], + "first_bad_output": 0, + "mutation": "omit_current_B_pullback", + "rejected": true + }, + { + "defect": [ + [], + [ + [ + [ + 1 + ], + 0, + -2 + ] + ], + [], + [], + [], + [], + [], + [] + ], + "first_bad_output": 1, + "mutation": "wrong_compensation_sign", + "rejected": true + }, + { + "defect": [ + [ + [ + [], + 0, + -1 + ], + [ + [], + 1, + 1 + ], + [ + [ + 1 + ], + 0, + 1 + ], + [ + [ + 2 + ], + 2, + -1 + ], + [ + [ + 2, + 3 + ], + 2, + 1 + ], + [ + [ + 2, + 3, + -2 + ], + 0, + 1 + ], + [ + [ + 2, + 3, + -2 + ], + 1, + -1 + ], + [ + [ + 2, + 3, + -2, + 1 + ], + 0, + -1 + ] + ], + [ + [ + [ + 1 + ], + 0, + -1 + ], + [ + [ + 1 + ], + 1, + 1 + ], + [ + [ + 1, + 1 + ], + 0, + 1 + ], + [ + [ + 1, + 2 + ], + 2, + -1 + ], + [ + [ + 1, + 2, + 3 + ], + 2, + 1 + ], + [ + [ + 1, + 2, + 3, + -2 + ], + 0, + 1 + ], + [ + [ + 1, + 2, + 3, + -2 + ], + 1, + -1 + ], + [ + [ + 1, + 2, + 3, + -2, + 1 + ], + 0, + -1 + ] + ], + [], + [], + [], + [], + [], + [] + ], + "first_bad_output": 0, + "mutation": "stale_coded_F2", + "rejected": true + }, + { + "control_note": "Repeating the whole forward endpoint is a vacuous control here because the signed target is involutive; one actual inverse gate is changed instead.", + "mutation": "one_code_uses_forward_instead_of_inverse", + "rejected": true + } + ], + "dual_relations": "a_s^T are independent transpose symbols, not inverse symbols; chronological gatewise inverse-transpose matches transpose of full inverse", + "endpoint": [ + [ + [ + [], + 0, + 1 + ] + ], + [ + [ + [], + 1, + -1 + ] + ], + [ + [ + [], + 2, + 1 + ] + ], + [ + [ + [], + 3, + -1 + ] + ], + [ + [ + [], + 4, + 1 + ] + ], + [ + [ + [], + 5, + -1 + ] + ], + [ + [ + [], + 6, + 1 + ] + ], + [ + [ + [], + 7, + -1 + ] + ] + ], + "formal_input_rows": 8, + "invoice_per_replica": { + "R429_1499_ADD_code_scalar_invoice": 9216, + "additional_private_rank_one_equivalent": 420, + "clean_replacements_from_fullycoded": 7, + "excess_over_beta_002_allowance": 150, + "necessary_allowance_at_beta_002": 492, + "necessary_allowance_at_beta_003": 309, + "net_rank_mass_saved_vs_all_old_clean": -102, + "new_private_or_arbitrary_helper_fields_for_controller": 0, + "original_terminal_idle_split": false, + "source_code_applications": 6, + "terminal_normalization_rank_one_children": 222, + "total_extra_rank_one_equivalent": 642 + }, + "local_clean_stages": [ + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "local_coded_stages": [ + 0, + 1 + ], + "operator_relations": "only a_s^-1 a_s=a_s a_s^-1=1; no commutation", + "recipe_source_sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": [ + "all eight independent public logical input banks, arbitrary values", + "old local ordinary dirty helper restoration used as explicit premise", + "actual complete 19-event B4 order including both bridge signs", + "exact group-ring coefficient and reverse-inverse proof; characteristic2 specialization valid", + "terminal two-N physical realization and local old/code tariffs are conditional source mechanisms" + ], + "status": "PASS_CLOSED_NONCOMMUTATIVE_HYBRID_NO_GAIN", + "terminal_before_decoder": [ + [ + [ + [ + -2 + ], + 0, + 1 + ], + [ + [ + -2 + ], + 1, + -1 + ], + [ + [ + -2, + 1 + ], + 0, + -1 + ] + ], + [ + [ + [ + -2 + ], + 0, + 1 + ] + ], + [ + [ + [], + 3, + -1 + ] + ], + [ + [ + [], + 2, + 1 + ] + ], + [ + [ + [], + 5, + -1 + ] + ], + [ + [ + [], + 4, + 1 + ] + ], + [ + [ + [], + 7, + -1 + ] + ], + [ + [ + [], + 6, + 1 + ] + ] + ], + "unresolved": [ + "no native global phase admission", + "no mixed 438/429 helper owner allocation or full width/stock moment", + "no source-access, precision, tape or outer all-size theorem", + "fails the necessary beta002 budget, so not a positive kappa candidate" + ], + "word": [ + { + "coded": true, + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "cut": "immediately after local0", + "kind": "code", + "native_level": 0, + "register": 0, + "side": "X", + "word": [ + -1 + ] + }, + { + "coded": true, + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "cut": "immediately after local1", + "kind": "code", + "native_level": 1, + "register": 0, + "side": "X", + "word": [ + -2 + ] + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "coded": false, + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "coded": false, + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "coded": false, + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "coded": false, + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "coded": false, + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "coded": false, + "kind": "local", + "pair": 3, + "reverse": true, + "stage": 7 + }, + { + "coded": false, + "kind": "local", + "pair": 3, + "reverse": false, + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "direction": "cap_to_FULL", + "kind": "normalize", + "rank_one_children": 111, + "register": 1 + }, + { + "cut": "terminal after all idle owners return", + "kind": "code", + "native_level": 8, + "register": 1, + "side": "FULL", + "word": [ + 2 + ] + }, + { + "cut": "terminal after all idle owners return", + "kind": "code", + "native_level": 8, + "register": 0, + "side": "FULL", + "word": [ + 2 + ] + }, + { + "coefficient": -1, + "dst": 0, + "kind": "shear", + "src": 1 + }, + { + "cut": "terminal source preparation", + "kind": "code", + "native_level": 8, + "register": 1, + "side": "FULL", + "word": [ + 1 + ] + }, + { + "coefficient": 1, + "dst": 0, + "kind": "shear", + "src": 1 + }, + { + "cut": "terminal exact source unprepare", + "kind": "code", + "native_level": 8, + "register": 1, + "side": "FULL", + "word": [ + -1 + ] + }, + { + "direction": "FULL_to_cap", + "kind": "normalize", + "rank_one_children": 111, + "register": 1 + }, + { + "kind": "exchange" + } + ] +} diff --git a/research/bit-fixed-controller-repairs/frozen/hybrid/EARLY-PROMOTION.json b/research/bit-fixed-controller-repairs/frozen/hybrid/EARLY-PROMOTION.json new file mode 100644 index 0000000000..4da6f72e64 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/hybrid/EARLY-PROMOTION.json @@ -0,0 +1,93 @@ +{ + "R438_word_sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "code_offdiagonal": { + "coefficient": 1, + "input_port": 0, + "output_port": 3 + }, + "controls": [ + "diagonal relative route fixes its physical root line", + "unpromoted zero flag is preserved by every relative route" + ], + "covered_domain": "exact rational address geometry and odd ADDRESS field F101; arbitrary binary VALUE delta at the listed input port/address", + "defect_outside_target_Pp": [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "0", + "0", + "0", + "0" + ], + "extra_undo_code_redo_charge": { + "rank_one_children_per_bank": 222, + "scalar_access_and_precision": "additional; not waived" + }, + "geometry_receipt": { + "address_prime": 101, + "full_root_word_sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "ordered_distinct_pairs_checked": 12210 + }, + "limits": [ + "does not exclude a new native factory accepting promoted Y", + "does not exclude a changed current-word N cancellation", + "no general lower bound or positive kappa claim" + ], + "logical_boundary": "initial Y ZERO -> P_p costs one111-port rank-one sweep; after promotion same-port X/Y scalar ADD is admitted but generic cross-port future A code is not", + "matrix_input_sha256": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979", + "native_address_input": [ + "2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "native_address_output": [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "0", + "0", + "0", + "0" + ], + "output_fresh_coordinates_mod101": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "reason": "rho_s,q fixes P_q, but rho_s,p^-1 rho_s,q sends P_q into fresh E_s outside target P_p for p!=q", + "route_reconstruction_sha256": "b5b0f01da04d95ccaae56cfb503bbf12bdd47442a924802c280089acc564795b", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "status": "PASS_ACTUAL_EARLY_PROMOTION_LOSES_FUTURE_CODE_ADMISSION" +} diff --git a/research/bit-fixed-controller-repairs/frozen/hybrid/README.md b/research/bit-fixed-controller-repairs/frozen/hybrid/README.md new file mode 100644 index 0000000000..2dc0f74022 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/hybrid/README.md @@ -0,0 +1,180 @@ +# Closed hybrid comparison and early-promotion witness + +Local-only mathematical work, scientific source pin +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`. No primary checkout edit, +commit, push, Discussion post or PR was made. This lane does not establish +the requested positive beta .002/.003 construction. + +`closed_hybrid.py` reconstructs the actual 19-event B4 recipe from its pinned +primary source. It retains one exact changed word, all eight independent +input rows, its literal inverse, a separately composed inverse transpose, +and four defect-sensitive controls in `CLOSED-HYBRID.json`. + +## Assumptions and exact combined word + +The abstract coefficient ring is the integral free-group algebra on +independent invertible operators a0,...,a8. No two operators commute. +Transpose operators are independent symbols; they are not identified with +inverse operators. A coded forward/reverse pair is, respectively, + +``` +F_s(x,y) = (a_s x, y+a_s x), +B_s(x,y) = (x-y, a_s^-1 y). +``` + +Each local circuit's ordinary dirty helpers must restore for every entering +helper value; the private copied field must be zero outside its own +immutable lifetimes. Those are imported local-source premises. For actual +BIT suppliers, the target/source shear formula above is only asserted over +binary VALUE functions. The old signed integer lift can have even target +helper leakage, although its ordinary integer helpers restore. This abstract +group-ring proof is not an assertion that the signed native integer block +has an exact target coefficient a_s. + +Use the exact original 19-event order and both original bridge signs. The +bridge with coefficient c is + +``` +X_dst += c X_src; +Y_src -= c Y_dst. +``` + +Change only the following sections: + +1. Keep F0 and B1 coded. After F0 apply a0^-1 to X0. After B1 apply a1^-1 + to X0. These are legal past-code preparations immediately after the + respective local helper restoration cuts. +2. Use the original clean local suppliers at stages2,...,8. +3. After every old terminal idle and bridge, promote Y0 from its hole frame + to the common FULL frame by its 111 portwise rank-one D_P calls. All + owners have returned at this cut. +4. Apply Y0 := a1 Y0 and X0 := a1 X0. Then X0 -= Y0; prepare Y0 by a0; + X0 += Y0; unprepare Y0 by a0^-1. These operations are at the terminal + FULL cut and accept every past stage code. +5. Demote Y0 by the second 111-call D_P sweep and perform the original + final bank exchange. + +Every public source/target input is arbitrary. In particular Y0 is never +treated as clean workspace. At the cut before the new terminal normalization, +the actual current-word pullbacks are + +``` +X0 = a1^-1 ((I-a0)x0-y0), Y0 = a1^-1 x0, +Xi = -yi, Yi = xi, i=1,2,3. +``` + +Thus after the two a1 operations, X0=(I-a0)x0-y0 and Y0=x0. The paid +target compensation is exactly `X0 -= Y0; X0 += a0 Y0`, yielding -y0. +Preparing/unpreparing the source gives that second summand while restoring +the entire arbitrary source word. The final exchange matches the original +clean controller: `(Xout,Yout)=(x,-y)` over the abstract signed ring and +the corresponding identity over characteristic2. All eight rows, including +the six unchanged endpoint rows, are checked. + +The literal inverse reverses the entire changed invertible word and inverts +every code, ADD, local block and exchange. Inverse-transpose propagation is +also composed chronologically from each actual gate inverse and compared to +the transpose of the complete inverse. No orthogonality of a_s is assumed. + +## Paid comparison and stop result + +The assigned fully coded R429 comparator saves 60 complete rank-mass units +per local call relative to the old R438 clean supplier, including returned +idle owner work. Using that common comparator, this closed word adds + +``` +7 clean replacements *60 =420 rank-one-equivalent units/replica; +2 complete D_P sweeps =222 rank-one native children/replica; +total =642. +``` + +The parent supplied necessary extra-rank allowances 492 at beta .002 and +309 at beta .003. This word exceeds the former by150. Relative to the +entirely old clean word it saves only `2*60-222=-102` rank units. It fails +before new source-access, precision or physical-storage charges. + +The six added source-code applications cost `6*1499=8994` scalar ADDs for +the assigned R429 literal code/inverse. The two full-bank compensation ADDs +cost another222 scalar ADDs, for9216 added scalar ADDs per replica. The +normalizations add222 native rank-one children. No new private or ordinary +dirty helper field is introduced. No old terminal idle is split. These are +the complete added controller operations; the mixed seven-clean/two-coded +helper allocation and full rank histogram remain a separate source-bound +obligation. No speculative allocation improvement is credited against this +screening invoice. + +Controls remove the actual B1 pullback, flip an actual compensation sign, +restore a stale coded F2, or use the wrong direction for one actual inverse +code. Each changes the literal word and is rejected. Repeating the whole +forward word would be a vacuous inverse control because the signed clean +endpoint is involutive; that control was caught and replaced before retaining +the receipt. + +## Early promotion is a changed native premise + +`early_promotion.py` checks the root's alternative entrance cut. Promoting +Y0 from ZERO to P_p before F0 permits same-port scalar X/Y ADDs, but removes +the old future-code admission. The actual P012 code has offdiagonal +`A[3,0]=1`. On this entry the actual routed relative operator is +rho_(s,3)^-1 rho_(s,0). The source root-line vector at port0 is fixed by +rho_(s,0), but the other route sends it outside the target P_3 line into +the fresh E_s block. The exact rational witness has fresh coordinates + +``` +(0,0,2,0,0,0,0), also modulo101. +``` + +`EARLY-PROMOTION.json` records the full input/output ADDRESS vectors, +source hashes and the diagonal/zero-frame controls. The witness is for a +binary VALUE delta on the stated rational/odd-field ADDRESS domain. A +future code applied before promotion acts only on original Y dirt; an X +term added afterwards has not received that code. The unchanged F0 local +word also expects original Y entrance ZERO, so it cannot simply be reused +after promotion. Undo/code/redo at the old ZERO cut adds222 rank-one calls +per111-port bank, besides scalar access and precision. + +This excludes the particular free future-code admission after promotion. It +does not exclude a new promoted-input local factory, a proved current-word +N cancellation, or another changed controller. + +## Attribution and remaining implications + +The old B4 topology and native BIT factory belong to the retained +DreamingOfClouds/eumemic/PR555,543,545,510 lineage. Credit Ali Romman for the +R438 deletion/source builder and Sagar Thakrar for the transported R438 word +and hosting. The source-code preparation interface also has prior work in +Ali Romman's PR1862. The prior local run supplies the three-row P012 code, +its R429 support deletion, local arbitrary-helper checks and the 60-unit +complete owner-return comparison. The parent/native lane supplies the +conservative two-normalization completion and its111+111 tariff. The actual +E8 route reconstruction and fresh-fiber argument are retained predecessor +mechanisms in `../bit-endpoint/expanded_sections.py` and `FRESH-FIBER.md`. + +This lane adds the explicit two-coded/seven-clean closed controller, its +current-word terminal compensation, its independent formal inverse/dual +checks and its concrete failed budget; it also binds the early-promotion +failure to actual code entry[3,0]. Substantial OpenAI Codex assistance was +used. New material is Apache-2.0. + +The all-eight-input algebraic theorem is proved by finite symbolic exact +coefficient propagation, which gives an all-value identity for this fixed +word. The native global phase, mixed helper owners/stock, whole-word +rounding/COPY precision, source access, physical tape realization and outer +all-size multiplication theorem are not established. No formal-kernel proof +or new conditional kappa is claimed. + +## Reproduction and open next question + +From this directory, standard Python3 only: + +``` +python3 -B closed_hybrid.py +python3 -B early_promotion.py +``` + +The remaining positive obligation is a completely explicit changed word +with at most492 extra rank-one-equivalent units against the same comparator, +including its actual terminal correction and mixed owner/precision bills. +A dirty FULL reservoir must be tracked on all eight independent inputs; +neither a clean redundant snapshot nor a generic future code on a promoted +P_p bank is currently admitted. diff --git a/research/bit-fixed-controller-repairs/frozen/hybrid/closed_hybrid.py b/research/bit-fixed-controller-repairs/frozen/hybrid/closed_hybrid.py new file mode 100644 index 0000000000..35883919cf --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/hybrid/closed_hybrid.py @@ -0,0 +1,325 @@ +#!/usr/bin/env python3 +"""A closed, non-winning hybrid BIT B4 controller over a free group ring. + +No stored source or primary checkout is edited. This is a mathematical +comparison word, not a physical supplier admission or new kappa result. +Apache-2.0; prepared with substantial OpenAI Codex assistance. +""" +import argparse +import ast +from hashlib import sha256 +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +REPO = Path('/Users/ross/git/math/integer-mult-bounds') +PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +RECIPE = REPO / ('research/e8-bit-p111-tuned/vendor/pr510/' + 'e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py') + + +def need(p, message): + if not p: + raise ValueError(message) + + +def reduce_word(word): + out = [] + for generator in word: + if out and out[-1] == -generator: + out.pop() + else: + out.append(generator) + return tuple(out) + + +def inverse_word(word): + return tuple(-x for x in reversed(word)) + + +def add(a, b, coefficient=1): + out = dict(a) + for key, value in b.items(): + out[key] = out.get(key, 0) + coefficient * value + if not out[key]: + del out[key] + return out + + +def left(row, word): + out = {} + for (suffix, column), value in row.items(): + key = (reduce_word(tuple(word) + suffix), column) + out[key] = out.get(key, 0) + value + if not out[key]: + del out[key] + return out + + +def identity(n=8): + return [{((), i): 1} for i in range(n)] + + +def serial(rows): + return [[[list(word), column, value] + for (word, column), value in sorted(row.items())] for row in rows] + + +def recipe(): + raw = RECIPE.read_bytes() + tree = ast.parse(raw) + function = next(x for x in tree.body + if isinstance(x, ast.FunctionDef) and x.name == 'recipe') + env = {} + exec(compile(ast.Module(body=[function], type_ignores=[]), + str(RECIPE), 'exec'), env) + events = env['recipe'](4) + need(len(events) == 19, 'actual B4 event count') + return events, sha256(raw).hexdigest() + + +def old_word(events): + return [dict(e, coded=False) if e['kind'] == 'local' else dict(e) + for e in events] + + +def hybrid_word(events, mutation=None): + out = [] + for event in events: + if event['kind'] == 'local': + stage = event['stage'] + coded = stage in (0, 1) + if mutation == 'stale_coded_F2' and stage == 2: + coded = True + out.append(dict(event, coded=coded)) + if stage in (0, 1): + if mutation == 'omit_current_B_pullback' and stage == 1: + continue + out.append({'kind': 'code', 'register': 0, + 'word': [-(stage + 1)], + 'cut': 'immediately after local' + str(stage), + 'side': 'X', 'native_level': stage}) + elif event['kind'] == 'exchange': + out.append({'kind': 'normalize', 'register': 1, + 'direction': 'cap_to_FULL', 'rank_one_children': 111}) + out.append({'kind': 'code', 'register': 1, 'word': [2], + 'cut': 'terminal after all idle owners return', + 'side': 'FULL', 'native_level': 8}) + out.append({'kind': 'code', 'register': 0, 'word': [2], + 'cut': 'terminal after all idle owners return', + 'side': 'FULL', 'native_level': 8}) + out.append({'kind': 'shear', 'dst': 0, 'src': 1, + 'coefficient': -1}) + out.append({'kind': 'code', 'register': 1, 'word': [1], + 'cut': 'terminal source preparation', + 'side': 'FULL', 'native_level': 8}) + out.append({'kind': 'shear', 'dst': 0, 'src': 1, + 'coefficient': -1 if mutation == 'wrong_compensation_sign' else 1}) + out.append({'kind': 'code', 'register': 1, 'word': [-1], + 'cut': 'terminal exact source unprepare', + 'side': 'FULL', 'native_level': 8}) + out.append({'kind': 'normalize', 'register': 1, + 'direction': 'FULL_to_cap', 'rank_one_children': 111}) + out.append(dict(event)) + else: + out.append(dict(event)) + return out + + +def apply(rows, event, backwards=False): + rows = [dict(row) for row in rows] + k = event['kind'] + if k == 'local': + p, s, rev = event['pair'], event['stage'], event['reverse'] + i, j = 2 * p, 2 * p + 1 + x, y = rows[i], rows[j] + a = (s + 1,) if event.get('coded') else () + if not rev: + if not backwards: + rows[i] = left(x, a) + rows[j] = add(y, rows[i]) + else: + rows[j] = add(y, x, -1) + rows[i] = left(x, inverse_word(a)) + elif not backwards: + rows[i] = add(x, y, -1) + rows[j] = left(y, inverse_word(a)) + else: + rows[j] = left(y, a) + rows[i] = add(x, rows[j]) + elif k == 'bridge': + d, s = event['dst'], event['src'] + coefficient = event['coefficient'] * (-1 if backwards else 1) + rows[2*d] = add(rows[2*d], rows[2*s], coefficient) + rows[2*s+1] = add(rows[2*s+1], rows[2*d+1], -coefficient) + elif k == 'code': + word = tuple(event['word']) + if backwards: + word = inverse_word(word) + rows[event['register']] = left(rows[event['register']], word) + elif k == 'shear': + coefficient = event['coefficient'] * (-1 if backwards else 1) + rows[event['dst']] = add(rows[event['dst']], + rows[event['src']], coefficient) + elif k == 'exchange': + rows = [row for p in range(4) for row in + (rows[2*p+1], rows[2*p])] + elif k == 'normalize': + # Logical-value coordinate is unchanged; native D_P changes frame. + # Native physical validity and its rank-one tariff are conditional. + pass + else: + raise ValueError(k) + return rows + + +def evaluate(word, start=None, backwards=False): + rows = identity() if start is None else start + for event in reversed(word) if backwards else word: + rows = apply(rows, event, backwards) + return rows + + +def transpose_operator_word(word): + # a_s^T is an independent noncommuting generator, not a_s^-1. + # The operation reverses multiplication order and preserves exponents. + return tuple((1 if x > 0 else -1) * (abs(x)+9) + for x in reversed(word)) + + +def transpose_operators(rows): + out = [{} for _ in range(len(rows))] + for i, row in enumerate(rows): + for (word, j), value in row.items(): + out[j][(transpose_operator_word(word), i)] = value + return out + + +def product(a, b): + out = [] + for row in a: + value = {} + for (word, j), coefficient in row.items(): + value = add(value, left(b[j], word), coefficient) + out.append(value) + return out + + +def receipt(): + events, recipe_pin = recipe() + old = old_word(events) + word = hybrid_word(events) + target = evaluate(old) + out = evaluate(word) + need(out == target, 'exact all-input old-clean endpoint equality') + need(evaluate(word, out, backwards=True) == identity(), + 'literal reverse-inverse cleanup') + need(evaluate(word, identity(), backwards=True) == target, + 'inverse target endpoint') + # The old clean signed word ends (Xout,Yout)=(x,-y), not literal Z identity. + expected = identity() + for i in range(1, 8, 2): + expected[i] = {key: -value for key, value in expected[i].items()} + need(target == expected, 'all clean signed controller target') + need(product(out, evaluate(word, identity(), True)) == identity(), + 'independent matrix multiplication inverse') + # Compare chronological gatewise inverse-transpose propagation to the + # transpose of the complete inverse. Transpose generators are independent. + inverse = evaluate(word, identity(), True) + inverse_transpose = transpose_operators(inverse) + need(product(transpose_operators(out), inverse_transpose) == identity(), + 'free-ring independent transpose inverse') + gatewise_dual = identity() + for event in word: + gatewise_dual = product(transpose_operators(apply(identity(), event, True)), + gatewise_dual) + need(gatewise_dual == inverse_transpose, + 'chronological gatewise inverse-transpose propagation') + controls = [] + for mutation in ('omit_current_B_pullback', 'wrong_compensation_sign', + 'stale_coded_F2'): + bad_word = hybrid_word(events, mutation) + need(bad_word != word, 'mutation changed actual word') + bad = evaluate(bad_word) + need(bad != target, 'affected endpoint mutant rejected') + delta = [add(a, b, -1) for a, b in zip(bad, target)] + controls.append({'mutation': mutation, 'rejected': True, + 'first_bad_output': next(i for i, row in enumerate(delta) if row), + 'defect': serial(delta)}) + wrong_inverse, changed = out, False + for event in reversed(word): + if event['kind'] == 'code' and not changed: + wrong_inverse = apply(wrong_inverse, event, backwards=False) + changed = True + else: + wrong_inverse = apply(wrong_inverse, event, backwards=True) + need(changed and wrong_inverse != identity(), 'wrong inverse code direction') + controls.append({'mutation': 'one_code_uses_forward_instead_of_inverse', + 'rejected': True, + 'control_note': 'Repeating the whole forward endpoint is a vacuous control here because the signed target is involutive; one actual inverse gate is changed instead.'}) + # State just before the terminal normalization is an informative witness. + before = [] + for event in word: + if event['kind'] == 'normalize': + break + before.append(event) + partial = evaluate(before) + x0 = add(left(identity()[0], (-2,)), + left(identity()[0], (-2, 1)), -1) + x0 = add(x0, left(identity()[1], (-2,)), -1) + need(partial[0] == x0 and partial[1] == left(identity()[0], (-2,)), + 'current-word terminal pullbacks') + for p in range(1, 4): + need(partial[2*p] == {key: -value for key, value in identity()[2*p+1].items()} + and partial[2*p+1] == identity()[2*p], 'other identity slots') + source_applications = sum(len(e['word']) for e in word if e['kind'] == 'code') + n = 111 + return { + 'status': 'PASS_CLOSED_NONCOMMUTATIVE_HYBRID_NO_GAIN', + 'scientific_pin': PIN, 'recipe_source_sha256': recipe_pin, + 'formal_input_rows': 8, 'coefficient_ring': 'Z[free group(a0,...,a8)]', + 'operator_relations': 'only a_s^-1 a_s=a_s a_s^-1=1; no commutation', + 'dual_relations': 'a_s^T are independent transpose symbols, not inverse symbols; chronological gatewise inverse-transpose matches transpose of full inverse', + 'local_coded_stages': [0, 1], 'local_clean_stages': list(range(2, 9)), + 'terminal_before_decoder': serial(partial), 'endpoint': serial(out), + 'word': word, 'controls': controls, + 'invoice_per_replica': { + 'clean_replacements_from_fullycoded': 7, + 'additional_private_rank_one_equivalent': 7*60, + 'terminal_normalization_rank_one_children': 2*n, + 'total_extra_rank_one_equivalent': 7*60+2*n, + 'necessary_allowance_at_beta_002': 492, + 'necessary_allowance_at_beta_003': 309, + 'excess_over_beta_002_allowance': 7*60+2*n-492, + 'net_rank_mass_saved_vs_all_old_clean': 2*60-2*n, + 'source_code_applications': source_applications, + 'R429_1499_ADD_code_scalar_invoice': source_applications*1499+2*n, + 'new_private_or_arbitrary_helper_fields_for_controller': 0, + 'original_terminal_idle_split': False}, + 'scope': ['all eight independent public logical input banks, arbitrary values', + 'old local ordinary dirty helper restoration used as explicit premise', + 'actual complete 19-event B4 order including both bridge signs', + 'exact group-ring coefficient and reverse-inverse proof; characteristic2 specialization valid', + 'terminal two-N physical realization and local old/code tariffs are conditional source mechanisms'], + 'unresolved': ['no native global phase admission', + 'no mixed 438/429 helper owner allocation or full width/stock moment', + 'no source-access, precision, tape or outer all-size theorem', + 'fails the necessary beta002 budget, so not a positive kappa candidate']} + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + data = receipt() + path = HERE / 'CLOSED-HYBRID.json' + if args.write: + path.write_text(json.dumps(data, sort_keys=True, indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == data, 'stored receipt differs') + print(data['status']) + print('extra642 > allowance492; rank-saving vs old = -102; all8 inputs restored') + + +if __name__ == '__main__': + main() diff --git a/research/bit-fixed-controller-repairs/frozen/hybrid/early_promotion.py b/research/bit-fixed-controller-repairs/frozen/hybrid/early_promotion.py new file mode 100644 index 0000000000..66529000b4 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/hybrid/early_promotion.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +"""Actual port-route witness against free future codes after early promotion. + +Read-only reuse of the pinned exact E8 route reconstruction. This establishes +one missing native admission, not an obstruction to all changed controllers. +Apache-2.0; prepared with substantial OpenAI Codex assistance. +""" +import argparse +import gzip +from hashlib import sha256 +import json +from pathlib import Path +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +OLD = Path('/Users/ross/git/math/.research-automation/runs/' + 'kappa-3605-successor-20261018T0940Z/major-frontier') +ENDPOINT = HERE.parent / 'bit-endpoint' +sys.path.insert(0, str(ENDPOINT)) +import expanded_sections as source + + +def need(p, message): + if not p: + raise ValueError(message) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + inp = OLD/'recursive/BIT-THREE-ROW-INPUT.json' + mat = json.loads(inp.read_bytes())['matrices'] + R, K = mat['R'], mat['K'] + W = K[:] + for p in (0, 1, 2): + W[p] = 0 + A = [i ^ row for i, row in zip(source.eye(111), source.product(W, R))] + p, q = next((p, q) for p, row in enumerate(A) + for q in source.bits(row) if p != q) + raw = source.cap.RAW.read_bytes() + need(sha256(raw).hexdigest() == source.cap.RAW_SHA, 'R438 source pin') + word = json.loads(gzip.decompress(raw)) + rho, cap, P, geometry = source.roots_and_routes(word) + # rho_q fixes the source physical root line P_q, whereas rho_p need not. + delta = list(map(source.F, word['lines'][q])) + [source.F(0)]*7 + target = [row + [source.F(0)]*7 for row in P[p]] + target += [[source.F(0)]*15 for _ in range(7)] + relative = source.mm(rho[p], rho[q]) + image = [sum(x*y for x,y in zip(row, delta)) for row in relative] + target_component = [sum(x*y for x,y in zip(row, image)) for row in target] + defect = [x-y for x,y in zip(image, target_component)] + need(any(image[8:]) and any(defect), 'promoted P flag not preserved') + mod101 = lambda x: x.numerator*pow(x.denominator, -1, 101) % 101 + need(any(map(mod101, image[8:])), 'actual odd field witness') + # The actual diagonal relative route fixes its own promoted flag. + diagonal = source.mm(rho[q], rho[q]) + diagonal_image = [sum(x*y for x,y in zip(row, delta)) for row in diagonal] + need(diagonal_image == delta, 'diagonal preserved-line control') + zero_flag = [[source.F(0)]*15 for _ in range(15)] + need(source.mm(relative, zero_flag) == source.mm(zero_flag, relative), + 'unpromoted zero-frame native preparation control') + data = { + 'status': 'PASS_ACTUAL_EARLY_PROMOTION_LOSES_FUTURE_CODE_ADMISSION', + 'scientific_pin': '20ecf2891d80b5acf18d980b2164fb44ea7faa90', + 'matrix_input_sha256': sha256(inp.read_bytes()).hexdigest(), + 'route_reconstruction_sha256': sha256((ENDPOINT/'expanded_sections.py').read_bytes()).hexdigest(), + 'R438_word_sha256': sha256(raw).hexdigest(), + 'code_offdiagonal': {'output_port': p, 'input_port': q, + 'coefficient': 1}, + 'native_address_input': list(map(str, delta)), + 'native_address_output': list(map(str, image)), + 'output_fresh_coordinates_mod101': list(map(mod101, image[8:])), + 'defect_outside_target_Pp': list(map(str, defect)), + 'covered_domain': 'exact rational address geometry and odd ADDRESS field F101; arbitrary binary VALUE delta at the listed input port/address', + 'logical_boundary': 'initial Y ZERO -> P_p costs one111-port rank-one sweep; after promotion same-port X/Y scalar ADD is admitted but generic cross-port future A code is not', + 'reason': 'rho_s,q fixes P_q, but rho_s,p^-1 rho_s,q sends P_q into fresh E_s outside target P_p for p!=q', + 'controls': ['diagonal relative route fixes its physical root line', + 'unpromoted zero flag is preserved by every relative route'], + 'extra_undo_code_redo_charge': {'rank_one_children_per_bank': 222, + 'scalar_access_and_precision': 'additional; not waived'}, + 'limits': ['does not exclude a new native factory accepting promoted Y', + 'does not exclude a changed current-word N cancellation', + 'no general lower bound or positive kappa claim'], + 'geometry_receipt': geometry} + path = HERE/'EARLY-PROMOTION.json' + if args.write: + path.write_text(json.dumps(data, sort_keys=True, indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == data, 'stored receipt differs') + print(data['status']) + print('offdiagonal', p, q, 'fresh mod101', data['output_fresh_coordinates_mod101']) + + +if __name__ == '__main__': + main() diff --git a/research/bit-fixed-controller-repairs/frozen/provenance/bit_cap_copy_local.py b/research/bit-fixed-controller-repairs/frozen/provenance/bit_cap_copy_local.py new file mode 100644 index 0000000000..679be90ff9 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/provenance/bit_cap_copy_local.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python3 +"""Local-only exact native cap-copy audit, independent of any controller. + +Inputs are the pinned R438 word and frozen signed six-copy local word. The +16-column ADDRESS identities hold over every odd field where dyadic entries +are interpreted. Scalar integer cleanup and rounded child errors are separate. +Apache-2.0; substantial OpenAI Codex assistance. +""" + +import argparse +from collections import Counter +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +RAW = Path('/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz') +RAW_SHA = 'a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def rank(rows): + basis = {} + for row in rows: + row = list(map(Q, row)) + for j, old in sorted(basis.items()): + c = row[j] + row = [x-c*y for x,y in zip(row,old)] + j = next((j for j,x in enumerate(row) if x), None) + if j is not None: + c = row[j] + basis[j] = [x/c for x in row] + return len(basis) + + +def identity(n): + return [[Q(i == j) for j in range(n)] for i in range(n)] + + +def multiply(a, b): + return [[sum(x*y for x,y in zip(row,col)) for col in zip(*b)] for row in a] + + +def exchange(u): + c = [[Q(i == j)-u[i][j] for j in range(8)] for i in range(8)] + return [c[i]+u[i] for i in range(8)]+[u[i]+c[i] for i in range(8)] + + +def address_identities(word): + ident = identity(8) + out = [] + for p, q in enumerate(word['lines']): + need(sum(x*x for x in q) == 4, 'actual E8 root norm') + start = [word['lines'][j] for j in word['frames'][word['start'][p]]] + cap = [word['lines'][j] for j in word['frames'][word['final'][111+p]]] + need(rank(start) == 1 and all(all(4*x == sum(a*b for a,b in zip(row,q))*y + for x,y in zip(row,q)) for row in start), 'actual entrance is not P_p') + need(rank(cap) == 7 and all(sum(x*y for x,y in zip(row,q)) == 0 for row in cap), + 'actual target cap is not K_p') + proj = [[Q(x*y,4) for y in q] for x in q] + complement = [[ident[i][j]-proj[i][j] for j in range(8)] for i in range(8)] + need(multiply(proj,proj) == proj and rank(proj) == 1, 'actual P_p projector') + need(multiply(exchange(ident),exchange(proj)) == exchange(complement), + 'D_I D_P differs from D_K') + need(multiply(exchange(proj),exchange(proj)) == identity(16), 'D_P squared differs from I') + encoded = [[[v.numerator,v.denominator] for v in row] for row in proj] + out.append(sha256(canonical(encoded)).hexdigest()) + need(len(out) == 111, 'actual punctured root count') + return out + + +def frame_replay(word, program, backward=False, fault=None): + dims = [rank(word['lines'][j] for j in f) for f in word['frames']] + masks = [sum(1 << j for j in f) for f in word['frames']] + need(dims[1] == 8, 'named FULL is not full') + frames = (word['final'] if backward else word['start'])[:]+[None] + open_source, copies, erases = None, [], 0 + paid = Counter() + rows = list(reversed(program['records'])) if backward else program['records'] + for raw in rows: + op,x,y,c,f,phase = raw + if op == 0: + old,new = (c,y) if backward else (y,c) + lo,hi = (new,old) if backward else (old,new) + need(frames[x] == old, 'MOVE source frame') + need(not masks[lo] & ~masks[hi] and dims[hi]-dims[lo] == f > 0, 'MOVE rank or containment') + frames[x] = new + paid[f] += 1 + elif op == 1: + need(x < 660 and x != y and frames[x] == frames[y] == f, 'ADD common frame') + need(open_source != x, 'immutable copied source changed') + elif op == (3 if backward else 2): + need(open_source is None and y == 660 and frames[660] is None, 'COPY fresh private field') + if fault == 'copy_to_full': + f = 1 + need(frames[x] == c == 1 and not masks[f] & ~masks[c], 'COPY source FULL and target nested') + need(dims[c]-dims[f] == 1, 'COPY does not use rank-one cap descent') + frames[660],open_source = f,x + copies.append({'source':x,'source_frame':c,'private_frame':f,'rank':1}) + paid[1] += 1 + else: + need(op == (2 if backward else 3), 'unknown native opcode') + need(open_source == x and y == 660 and frames[x] == c and frames[660] == f, + 'ERASE original snapshot source/frame') + frames[660],open_source = None,None + erases += 1 + need(open_source is None and frames[:660] == (word['start'] if backward else word['final']), 'native endpoint') + need(len(copies) == erases == 6, 'six closed immutable snapshots') + return {'copies':copies,'literal_erases':erases,'paid_profile':dict(sorted(paid.items())), + 'maximum_simultaneous_private_snapshots':1} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + raw = RAW.read_bytes() + need(sha256(raw).hexdigest() == RAW_SHA, 'R438 source pin') + word = json.loads(gzip.decompress(raw)) + meta = json.loads((HERE/'BIT-SIGNED-INPUT.json').read_bytes()) + packed = (HERE/'BIT-SIGNED-INPUT-WORD.json.gz').read_bytes() + decoded = gzip.decompress(packed) + need(sha256(packed).hexdigest() == meta['word_gzip_sha256'] and + sha256(decoded).hexdigest() == meta['word_canonical_sha256'], 'frozen signed word pin') + program = json.loads(decoded) + need(program['start'] == word['start'] and program['final'] == word['final'], 'retained native boundaries') + projectors = address_identities(word) + forward,backward = frame_replay(word,program),frame_replay(word,program,True) + try: + frame_replay(word,program,fault='copy_to_full') + except ValueError as error: + negative = str(error) + else: + raise ValueError('rank-zero FULL copy mutation escaped') + receipt = {'status':'PASS_LOCAL_SIX_CAP_COPY_NATIVE_CONTRACT', + 'raw_R438_gzip_sha256':RAW_SHA,'signed_word_canonical_sha256':meta['word_canonical_sha256'], + 'actual_port_count':111,'actual_entrance_and_target_frames':222, + 'projector_sha256':projectors,'address_identity_columns':3552, + 'forward':forward,'literal_inverse':backward,'negative_control':negative, + 'domain':'Exact dyadic projectors and ADDRESS matrices; every odd modulus where their dyadic coefficients are interpreted. VALUE scalar identity and native recursive child errors are separate.', + 'source_role_rule':'COPY may read an actual source field or an arbitrary helper, provided the physical source stays unchanged until ERASE. No helper-only restriction is used.', + 'limits':['local native/frame contract only','no global controller, endpoint decoder, owner allocation, precision theorem, tape bound or kappa claim']} + path = HERE/'BIT-CAP-COPY-LOCAL.json' + if args.write: + path.write_text(json.dumps(receipt,sort_keys=True,indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == json.loads(canonical(receipt)), 'complete cap-copy receipt differs') + print(receipt['status']) + + +if __name__ == '__main__': + main() diff --git a/research/bit-fixed-controller-repairs/frozen/recipe/BIT-NILPOTENT-RECIPE.json b/research/bit-fixed-controller-repairs/frozen/recipe/BIT-NILPOTENT-RECIPE.json new file mode 100644 index 0000000000..dde77a8967 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/recipe/BIT-NILPOTENT-RECIPE.json @@ -0,0 +1,2020 @@ +{ + "all_size_scope": "Polynomial identity for every nonidentity involution N over characteristic2. No finite Fourier kernel expansion is used.", + "cases": [ + { + "B": 1, + "epsilon_matrix_A": [ + [ + 0, + 1 + ], + [ + 1, + 1 + ] + ], + "events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "kind": "exchange" + } + ], + "rank_A": 2, + "rank_defect_M": 2, + "raw_endpoint_ring_entries": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ] + ], + "relative_to_common_N_defect_M": [ + [ + 1, + 1 + ], + [ + 1, + 0 + ] + ], + "trace_defect": 1 + }, + { + "B": 2, + "epsilon_matrix_A": [ + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1 + ], + [ + 1, + 1, + 1, + 0 + ] + ], + "events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "exchange" + } + ], + "rank_A": 4, + "rank_defect_M": 3, + "raw_endpoint_ring_entries": [ + [ + 1, + 0, + 0, + 3 + ], + [ + 3, + 2, + 0, + 0 + ], + [ + 0, + 3, + 1, + 3 + ], + [ + 3, + 3, + 3, + 1 + ] + ], + "relative_to_common_N_defect_M": [ + [ + 1, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 1 + ], + [ + 1, + 1, + 1, + 1 + ] + ], + "trace_defect": 1 + }, + { + "B": 3, + "epsilon_matrix_A": [ + [ + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 0 + ] + ], + "events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "exchange" + } + ], + "rank_A": 6, + "rank_defect_M": 6, + "raw_endpoint_ring_entries": [ + [ + 1, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 3 + ], + [ + 3, + 3, + 3, + 1, + 0, + 0 + ], + [ + 0, + 3, + 0, + 3, + 1, + 3 + ], + [ + 0, + 3, + 3, + 3, + 3, + 1 + ] + ], + "relative_to_common_N_defect_M": [ + [ + 1, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 1 + ] + ], + "trace_defect": 1 + }, + { + "B": 4, + "epsilon_matrix_A": [ + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + ], + "events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 3, + "reverse": true, + "stage": 7 + }, + { + "kind": "local", + "pair": 3, + "reverse": false, + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "exchange" + } + ], + "rank_A": 8, + "rank_defect_M": 7, + "raw_endpoint_ring_entries": [ + [ + 1, + 0, + 0, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 1, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 3, + 3, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 3 + ], + [ + 0, + 3, + 3, + 3, + 3, + 1, + 0, + 0 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 1, + 3 + ], + [ + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 1 + ] + ], + "relative_to_common_N_defect_M": [ + [ + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ] + ], + "trace_defect": 1 + }, + { + "B": 5, + "epsilon_matrix_A": [ + [ + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + ], + "events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 3, + "reverse": true, + "stage": 7 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 4 + }, + { + "kind": "local", + "pair": 3, + "reverse": false, + "stage": 8 + }, + { + "coefficient": -1, + "dst": 3, + "kind": "bridge", + "src": 4 + }, + { + "kind": "local", + "pair": 4, + "reverse": true, + "stage": 9 + }, + { + "kind": "local", + "pair": 4, + "reverse": false, + "stage": 10 + }, + { + "coefficient": 1, + "dst": 4, + "kind": "bridge", + "src": 3 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "exchange" + } + ], + "rank_A": 10, + "rank_defect_M": 10, + "raw_endpoint_ring_entries": [ + [ + 1, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 3, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 0, + 3, + 1, + 3, + 0, + 0, + 0, + 3 + ], + [ + 0, + 3, + 3, + 3, + 3, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 3 + ], + [ + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 1, + 0, + 0 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 0, + 3, + 1, + 3 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 1 + ] + ], + "relative_to_common_N_defect_M": [ + [ + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ] + ], + "trace_defect": 1 + }, + { + "B": 6, + "epsilon_matrix_A": [ + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + ], + "events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 3, + "reverse": true, + "stage": 7 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 4 + }, + { + "kind": "local", + "pair": 3, + "reverse": false, + "stage": 8 + }, + { + "coefficient": -1, + "dst": 3, + "kind": "bridge", + "src": 4 + }, + { + "kind": "local", + "pair": 4, + "reverse": true, + "stage": 9 + }, + { + "coefficient": 1, + "dst": 4, + "kind": "bridge", + "src": 5 + }, + { + "kind": "local", + "pair": 4, + "reverse": false, + "stage": 10 + }, + { + "coefficient": -1, + "dst": 4, + "kind": "bridge", + "src": 5 + }, + { + "kind": "local", + "pair": 5, + "reverse": true, + "stage": 11 + }, + { + "kind": "local", + "pair": 5, + "reverse": false, + "stage": 12 + }, + { + "coefficient": 1, + "dst": 5, + "kind": "bridge", + "src": 4 + }, + { + "coefficient": 1, + "dst": 4, + "kind": "bridge", + "src": 3 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "exchange" + } + ], + "rank_A": 12, + "rank_defect_M": 11, + "raw_endpoint_ring_entries": [ + [ + 1, + 0, + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 1, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 3 + ], + [ + 3, + 3, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 3, + 0, + 0, + 0, + 3 + ], + [ + 0, + 3, + 3, + 3, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 1, + 3, + 0, + 0, + 0, + 3 + ], + [ + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 3 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 1, + 0, + 0 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 0, + 3, + 0, + 3, + 1, + 3 + ], + [ + 0, + 3, + 0, + 3, + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 1 + ] + ], + "relative_to_common_N_defect_M": [ + [ + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ] + ], + "trace_defect": 1 + } + ], + "limits": [ + "Changed bank pairing, shared native stages, source normalization and altered scalar controls can change A and are outside this fixedrecipe bound.", + "No all-caller lower bound or negative kappa claim follows.", + "The seeded-star construction is an explicit changed topology and is deliberately outside this screen." + ], + "parity": "Each such repair projector has trace1. The fixed defect trace is1, so the number of repair N events is odd. At B1 rank2 plus trace1 gives minimum at least3.", + "rank_repair_bound": "For this fixed evaluated word R=I+epsilon A, its defect relative common parent N I is I+epsilon(A+I). Repair gates consisting of a scalar-GL-conjugated single-bank N have first-order rank1; k such added gates sum at most rankk. Thus repairing the fixed B4 word needs at least7 such extra N events (777 rank1 for111ports). This statement is not about a redesigned scalar controller that changes existing query pullbacks.", + "ring": "F2[N]/(N^2-1), epsilon=N+1, epsilon^2=0. F=[[1,0],[1,N]], B=[[N,1],[0,1]]. All old bridges and terminal bank exchange are literally retained.", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_recipe_sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "status": "PASS_FIXED_RECIPE_NILPOTENT_DEFECT_MATRICES" +} diff --git a/research/bit-fixed-controller-repairs/frozen/recipe/bit_nilpotent_recipe.py b/research/bit-fixed-controller-repairs/frozen/recipe/bit_nilpotent_recipe.py new file mode 100644 index 0000000000..401610bdea --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/recipe/bit_nilpotent_recipe.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +"""Fixed routed recipe over F2[N]/(N^2-1); not a changed-caller obstruction. +Apache-2.0. Substantial OpenAI Codex assistance. +""" +import argparse,ast,json +from hashlib import sha256 +from pathlib import Path +from bit_seeded_star import mul,plus,scale,ident,need +HERE=Path(__file__).resolve().parent +SOURCE=Path('/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py') +def rank(rows): + d={} + for x in rows: + while x: + k=x.bit_length()-1 + if k in d:x^=d[k] + else:d[k]=x;break + return len(d) +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');a=ap.parse_args() + raw=SOURCE.read_bytes();t=ast.parse(raw);f=next(x for x in t.body if isinstance(x,ast.FunctionDef)and x.name=='recipe');env={};exec(compile(ast.Module(body=[f],type_ignores=[]),str(SOURCE),'exec'),env) + cases=[] + for B in range(1,7): + n=2*B;z=ident(n);events=env['recipe'](B) + for e in events: + if e['kind']=='local': + i=2*e['pair'];x,y=z[i],z[i+1] + if e['reverse']:z[i]=plus(scale(x,2),y) + else:z[i+1]=plus(x,scale(y,2)) + elif e['kind']=='bridge': + d,s=e['dst'],e['src'];z[2*d]=plus(z[2*d],z[2*s]);z[2*s+1]=plus(z[2*s+1],z[2*d+1]) + elif e['kind']=='exchange':z=[r for j in range(B)for r in(z[2*j+1],z[2*j])] + need(all(((x&1)^(x>>1))==int(i==j)for i,r in enumerate(z)for j,x in enumerate(r)),'constant epsilon0 endpoint I') + A=[[x>>1 for x in r]for r in z];M=[[x^int(i==j)for j,x in enumerate(r)]for i,r in enumerate(A)] + rA=rank([sum(x<>1;b0,b1=b&1,b>>1 + return ((a0*b0)^(a1*b1))|(((a0*b1)^(a1*b0))<<1) +def plus(a,b):return [x^y for x,y in zip(a,b)] +def scale(a,q):return[mul(x,q)for x in a] +def ident(n):return[[int(i==j)for j in range(n)]for i in range(n)] +def inverse_event(e):return e # Every declared GF2 primitive here is involutive. +def apply(z,e): + z=[r[:]for r in z];i,j=e['source'],e['target'];k=e['kind'] + if k=='old_F':z[j]=plus(z[j],scale(z[i],2)) + elif k=='old_B':z[i]=plus(z[i],scale(z[j],2)) + elif k=='exchange':z[i],z[j]=z[j],z[i] + elif k=='new_F':z[j]=plus(z[i],scale(z[j],2)) + elif k=='new_F_inverse':z[j]=scale(plus(z[j],z[i]),2) + elif k=='CNOT':z[j]=plus(z[j],z[i]) + else:raise ValueError(k) + return z + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');a=ap.parse_args() + word=[{'kind':'old_F','source':0,'target':1,'stage':0},{'kind':'old_B','source':0,'target':1,'stage':1},{'kind':'old_F','source':0,'target':1,'stage':2},{'kind':'exchange','source':0,'target':1,'cut':'afterstage2'}] + for j in range(2,8):word.append({'kind':'new_F','source':0,'target':j,'stage':j+1}) + # The source is unchanged by every fanout; terminal CNOTs cancel those + # entering-source columns, once all eight fronts equal the common parent. + for j in reversed(range(2,8)):word.append({'kind':'CNOT','source':0,'target':j,'cut':'terminal common NGamma'}) + z=ident(8);prefix=[] + for e in word: + z=apply(z,e);prefix.append(z) + target=scale_identity=[[2*int(i==j)for j in range(8)]for i in range(8)] + need(z==target,'all eight independent raw input columns reach common N') + back=z + for e in reversed(word): + inv=dict(e) + if inv['kind']=='new_F':inv['kind']='new_F_inverse' + back=apply(back,inv) + need(back==ident(8),'literal reverse-inverse all raw input columns') + # Defect-sensitive negative controls alter actual words. + bad=ident(8) + for e in word: + if e.get('stage')==1:continue + bad=apply(bad,e) + need(bad!=target,'omitted seed B rejected') + bad=ident(8) + for k,e in enumerate(word): + if k==len(word)-1:continue + bad=apply(bad,e) + need(bad!=target,'omitted terminal CNOT rejected') + # Pure new-F diagonalization cannot create source common-axis progress. + single=apply(apply(ident(2),{'kind':'new_F','source':0,'target':1}),{'kind':'CNOT','source':0,'target':1}) + need(single==[[1,0],[0,2]],'source remains I under postCNOT diagonalization') + windows=[{'bank':0,'active_stages':list(range(9)),'fresh_idle_query_ranks':[]},{'bank':1,'active_stages':[0,1,2],'fresh_idle_query_ranks':[42]}] + for j in range(2,8): + s=j+1;windows.append({'bank':j,'active_stages':[s],'fresh_idle_query_ranks':[x for x in(7*s,7*(8-s))if x]}) + out={'status':'PASS_SEEDED_STAR_EIGHT_RAW_INPUT_COLUMNS','scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90', + 'coefficient_ring':'F2[N]/(N^2-1), entry encoded a+2*b for a+bN. Fresh Gs commute mutually and with N; cumulative Gamma is stripped only at matched fresh-prefix cuts.', + 'assumed_local_interfaces':['old_F_N=(x,y+Nx), old_B_N=(x+Ny,y), three clean rank7 stages, ordinary helper restoration as supplied by the old R438 factory.','new_F=(x,x+Ny), six stages, each from the changed R429 full-target factory. Its helpers and target preencoding must be admitted at the actual common-past prefix; this record does not establish that native binding.'], + 'word':word,'prefix_rows':prefix,'endpoint_rows':z,'inverse_endpoint_rows':back, + 'identity':'Three old F_N/B_N/F_N plus SWAP give diag(N,N). Six new F calls from bank0 to banks2..7 yield N(x0,x1,x2+x0,...,x7+x0). Six terminal CNOTs then yield N times I8.', + 'fresh_path':'Every active call advances its two banks by its stage G_s; complete every inactive fresh interval by the listed native idle query. All eight banks must reach Gamma9 before the terminal CNOTs.', + 'public_fresh_idle_windows':windows, + 'conditional_local_invoice':'3 old factories at private63 plus6 changed factories at private3; nominal raw rank deficit2*111-3*63-6*3=15 before padding, changed owner allocation, moments and precision. No unchanged nineteen-event owner witness applies.', + 'pure_newF_control':'PostCNOT * newF = diag(I,N). It leaves arbitrary raw source a unchanged, so it does not alone give common N on both raw inputs. An entrance normalization a=Nx must be paid or supplied by an explicit encoded-input caller contract.', + 'negative_controls':['Omit old seed B: wrong all-input endpoint.','Omit one terminal CNOT: one original x0 term remains.'], + 'all_size_scope':'The written word is a polynomial identity for every involution N over characteristic2 and every commuting fresh Gs. No finite Fourier expansion, one-bit support shortcut or clean data assumption is used.', + 'remaining':['Native source/target pre/post A admission at these changed cuts, all429 helper dirt and return identities require recursive lane producer binding.','New chronological whole-helper owner allocation and full moments, arity, rounding/precision and tape costs are not supplied.','No positive kappa follows from nominal D15.'], + 'attribution':'Recursive lane proposed three-old-call seed and six-new-call fanout; root proposed testing pure newF diagonalization. This lane independently verifies the changed word on all raw columns, inverse and defect controls, and separates the missing source input normalization.'} + out=json.loads(json.dumps(out));target_path=HERE/'BIT-SEEDED-STAR.json' + if a.write:target_path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(target_path.read_bytes())==out,'stored seeded star differs') + print(out['status']);print('8 raw inputs; reverse-inverse;2 controls; changed idle windows PASS') +if __name__=='__main__':main() diff --git a/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/CHECKS.json.gz b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/CHECKS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..417af54cfc96ffe13b8cdc1eb5832320b139e450 GIT binary patch literal 13719 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 literal 0 HcmV?d00001 diff --git a/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json new file mode 100644 index 0000000000..98dfb2409f --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/SOURCE-DEPENDENCIES.json @@ -0,0 +1,36 @@ +{ + "checker_sha256": "148b456444486d4fde75c83d20717aef7dcd2c6aef31adb009035f834c530138", + "matrices": { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-ROW-INPUT.json", + "sha256": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979" + }, + "r438": { + "path": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "read_only_predecessors": { + "old_hybrid": { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/closed_hybrid.py", + "runtime_dependency": false, + "sha256": "78f92b8b8fdb6528bd87f974f3022e73c9b60877f0022200fe0b4422da2b7738" + }, + "old_promotion": { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/hybrid-independent/early_promotion.py", + "runtime_dependency": false, + "sha256": "d59e5487251929416fa657f45e617d78a3392310203f1df08389d3746acd6732" + }, + "old_routes": { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/expanded_sections.py", + "runtime_dependency": false, + "sha256": "b5b0f01da04d95ccaae56cfb503bbf12bdd47442a924802c280089acc564795b" + } + }, + "recipe": { + "path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "roots": { + "path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + } +} diff --git a/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/VALIDATION.json b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/VALIDATION.json new file mode 100644 index 0000000000..5b712d68cb --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/VALIDATION.json @@ -0,0 +1,90 @@ +{ + "checker_sha256": "148b456444486d4fde75c83d20717aef7dcd2c6aef31adb009035f834c530138", + "full_receipt_byte_identical": true, + "python": "Python 3.12.14", + "receipt_canonical_sha256": "f8344bb945fdf069140991ad6c293ed1a85eed8b17258a10c41aeda0e03907c8", + "receipt_gzip_sha256": "8a76a7141b4851084923e87c8f17bc8c02db6543d7614bc2c911e45e43a0ef8f", + "receipt_sha256": "c1c1444d09bda057e6fa12c97fe8e7c4674ad0076d83e1d7ad7f5975ca946442", + "results": [ + { + "command": [ + "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "-I", + "-B", + "-W", + "error", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/check_hybrid.py", + "--recipe", + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "--matrices", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-ROW-INPUT.json", + "--r438", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "--roots", + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "--output", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/CHECKS.json" + ], + "exit_code": 0, + "mode": "normal", + "output_sha256": "c1c1444d09bda057e6fa12c97fe8e7c4674ad0076d83e1d7ad7f5975ca946442", + "seconds": 0.2952352080028504, + "stdout": "{\"cases\": 28, \"receipt_canonical_sha256\": \"f8344bb945fdf069140991ad6c293ed1a85eed8b17258a10c41aeda0e03907c8\", \"status\": \"PASS_ALL_B_PROOF_FIXTURES_TWO_CODE_HYBRID_AND_SELECTED_NATIVE_WITNESS\", \"word_controls\": 12}" + }, + { + "command": [ + "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "-I", + "-B", + "-W", + "error", + "-O", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/check_hybrid.py", + "--recipe", + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "--matrices", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-ROW-INPUT.json", + "--r438", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "--roots", + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "--output", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/CHECKS-O.json" + ], + "exit_code": 0, + "mode": "optimized", + "output_sha256": "c1c1444d09bda057e6fa12c97fe8e7c4674ad0076d83e1d7ad7f5975ca946442", + "seconds": 0.3577241659804713, + "stdout": "{\"cases\": 28, \"receipt_canonical_sha256\": \"f8344bb945fdf069140991ad6c293ed1a85eed8b17258a10c41aeda0e03907c8\", \"status\": \"PASS_ALL_B_PROOF_FIXTURES_TWO_CODE_HYBRID_AND_SELECTED_NATIVE_WITNESS\", \"word_controls\": 12}" + }, + { + "command": [ + "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "-I", + "-O", + "-B", + "-W", + "error", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/check_hybrid.py", + "--recipe", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/transport with spaces/recipe.py.gz", + "--matrices", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/transport with spaces/matrices.json.gz", + "--r438", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/transport with spaces/r438.json.gz", + "--roots", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/transport with spaces/roots.json.gz", + "--output", + "/Users/ross/git/math/.research-automation/runs/unpublished-round2-20261020T1106Z/b07-hybrid-review/CHECKS-TRANSPORT.json" + ], + "exit_code": 0, + "mode": "compressed_inputs_path_spaces", + "output_sha256": "c1c1444d09bda057e6fa12c97fe8e7c4674ad0076d83e1d7ad7f5975ca946442", + "seconds": 0.36249387499992736, + "stdout": "{\"cases\": 28, \"receipt_canonical_sha256\": \"f8344bb945fdf069140991ad6c293ed1a85eed8b17258a10c41aeda0e03907c8\", \"status\": \"PASS_ALL_B_PROOF_FIXTURES_TWO_CODE_HYBRID_AND_SELECTED_NATIVE_WITNESS\", \"word_controls\": 12}" + } + ], + "route_controls": 3, + "status": "PASS_NORMAL_OPTIMIZED_COMPRESSED_INPUTS", + "word_controls": 12 +} diff --git a/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/check.py b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/check.py new file mode 100644 index 0000000000..5d81e9ce4c --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/reviews/hybrid/check.py @@ -0,0 +1,594 @@ +#!/usr/bin/env python3 +"""Independent signed hybrid-controller and selected native-route audit. + +Standard library only. All scientific inputs are explicit and authenticated. +The arbitrary-input algebra is abstract; native realization stays conditional. +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +import argparse +import ast +import copy +from fractions import Fraction as F +import gzip +import hashlib +import json +from pathlib import Path + + +PINS = { + "recipe": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "matrices": "e5edb9e4e738192f98bd520ae6c1e8f1ddb19a0074ee9a1044e309b81e39c979", + "r438": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "roots": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(data): + return json.dumps(data, sort_keys=True, separators=(",", ":")).encode() + + +def digest(data): + return hashlib.sha256(data).hexdigest() + + +def read_source(path, name): + raw = path.read_bytes() + # Matrices and recipe may be losslessly compressed for portable packaging. + if name in ("matrices", "recipe") and raw[:2] == b"\x1f\x8b": + raw = gzip.decompress(raw) + need(digest(raw) == PINS[name], "source pin: " + name) + return raw + + +def reduce_word(word): + stack = [] + for g in word: + if stack and stack[-1] == -g: + stack.pop() + else: + stack.append(g) + return tuple(stack) + + +def ident(n): + return [{(i, ()): 1} for i in range(n)] + + +def matrix_product(left, right): + result = [] + for row in left: + out = {} + for (middle, first), coefficient in row.items(): + for (column, second), value in right[middle].items(): + key = (column, reduce_word(first + second)) + out[key] = out.get(key, 0) + coefficient * value + result.append({key: value for key, value in out.items() if value}) + return result + + +def transpose(matrix): + # Separate starred generators; preserve exponent and reverse factor order. + result = [{} for _ in matrix] + for row, entries in enumerate(matrix): + for (column, word), value in entries.items(): + starred = tuple((1 if g > 0 else -1) * (10000 + abs(g)) + for g in reversed(word)) + result[column][(row, starred)] = value + return result + + +def serialize(matrix): + return [[[column, list(word), value] + for (column, word), value in sorted(row.items())] + for row in matrix] + + +def endpoint(n): + return [{(i, ()): 1 if i % 2 == 0 else -1} for i in range(n)] + + +def primitive_matrix(event, n, inverse=False): + kind = event["kind"] + out = ident(n) + if kind == "add": + need(event["dst"] != event["src"], "ADD roles must be distinct") + out[event["dst"]][(event["src"], ())] = ( + event["coefficient"] * (-1 if inverse else 1)) + elif kind == "code": + g = event["generator"] * (-1 if inverse else 1) + out[event["register"]] = {(event["register"], (g,)): 1} + elif kind == "exchange": + out = [{(i ^ 1, ()): 1} for i in range(n)] + elif kind == "normalize": + pass + else: + raise ValueError("unknown primitive: " + kind) + return out + + +def flatten(events): + primitives = [] + for event in events: + kind = event["kind"] + if kind == "local": + x, y = 2 * event["pair"], 2 * event["pair"] + 1 + g = event["stage"] + 1 + if event["reverse"]: + primitives.append(dict(kind="add", dst=x, src=y, coefficient=-1)) + if event.get("coded", False): + primitives.append(dict(kind="code", register=y, generator=-g, + origin="local")) + else: + if event.get("coded", False): + primitives.append(dict(kind="code", register=x, generator=g, + origin="local")) + primitives.append(dict(kind="add", dst=y, src=x, coefficient=1)) + elif kind == "bridge": + d, s, c = event["dst"], event["src"], event["coefficient"] + primitives.extend([ + dict(kind="add", dst=2*d, src=2*s, coefficient=c), + dict(kind="add", dst=2*s+1, src=2*d+1, coefficient=-c)]) + else: + primitives.append(dict(event)) + return primitives + + +def evaluate(events, n, inverse=False): + out = ident(n) + primitives = flatten(events) + for event in reversed(primitives) if inverse else primitives: + out = matrix_product(primitive_matrix(event, n, inverse), out) + return out + + +def independent_recipe(b): + need(type(b) is int and b >= 1, "positive bank count") + events = [dict(kind="local", stage=0, pair=0, reverse=False)] + for j in range(b): + events.append(dict(kind="local", stage=2*j+1, pair=j, reverse=True)) + if j + 1 < b: + events.append(dict(kind="bridge", dst=j, src=j+1, coefficient=1)) + events.append(dict(kind="local", stage=2*j+2, pair=j, reverse=False)) + if j + 1 < b: + events.append(dict(kind="bridge", dst=j, src=j+1, coefficient=-1)) + events.extend(dict(kind="bridge", dst=j+1, src=j, coefficient=1) + for j in range(b-2, -1, -1)) + events.append(dict(kind="exchange")) + return events + + +def source_recipe(raw): + nodes = [node for node in ast.parse(raw).body + if isinstance(node, ast.FunctionDef) and node.name == "recipe"] + need(len(nodes) == 1, "exactly one pinned recipe") + env = {} + exec(compile(ast.Module(body=nodes, type_ignores=[]), "", + "exec", dont_inherit=True, optimize=0), env) + return env["recipe"] + + +def make_hybrid(events, variant): + need(variant in ("historical", "two_code"), "known hybrid variant") + result = [] + for event in events: + if event["kind"] == "local": + result.append(dict(event, coded=event["stage"] in (0, 1))) + if variant == "historical" and event["stage"] in (0, 1): + result.append(dict(kind="code", register=0, + generator=-event["stage"]-1)) + elif event["kind"] == "exchange": + result.append(dict(kind="normalize", register=1, + direction="cap_to_FULL", rank_one_children=111)) + if variant == "historical": + result.extend([ + dict(kind="code", register=1, generator=2), + dict(kind="code", register=0, generator=2), + dict(kind="add", dst=0, src=1, coefficient=-1), + dict(kind="code", register=1, generator=1), + dict(kind="add", dst=0, src=1, coefficient=1), + dict(kind="code", register=1, generator=-1)]) + else: + result.extend([ + dict(kind="add", dst=1, src=0, coefficient=-1), + dict(kind="code", register=1, generator=2), + dict(kind="add", dst=1, src=0, coefficient=1), + dict(kind="code", register=1, generator=-1)]) + result.extend([ + dict(kind="normalize", register=1, direction="FULL_to_cap", + rank_one_children=111), + dict(event)]) + else: + result.append(dict(event)) + return result + + +def expected_preterminal(b, variant): + rows = [] + if variant == "historical": + rows.extend([ + {(0, (-2,)): 1, (0, (-2, 1)): -1, (1, (-2,)): -1}, + {(0, (-2,)): 1}]) + else: + rows.extend([ + {(1, ()): -1}, + {(1, ()): -1, (1, (-2,)): 1, (0, (-2, 1)): 1}]) + for j in range(1, b): + rows.extend([{(2*j+1, ()): -1}, {(2*j, ()): 1}]) + return rows + + +def check_normalizations(word): + actual = [e for e in word if e["kind"] == "normalize"] + expected = [ + dict(kind="normalize", register=1, direction="cap_to_FULL", rank_one_children=111), + dict(kind="normalize", register=1, direction="FULL_to_cap", rank_one_children=111)] + need(actual == expected, "declared native normalization inventory") + first = next(i for i,e in enumerate(word) if e["kind"] == "normalize") + need(not any(e["kind"] in ("local","bridge") for e in word[first:]), + "normalizations at terminal cut") + need(word[-2] == expected[1] and word[-1]["kind"] == "exchange", + "demotion immediately before terminal exchange") + + +def audit_word(word, b, variant): + n = 2*b + out = evaluate(word, n) + need(out == endpoint(n), variant + ": all-input endpoint") + inverse = evaluate(word, n, inverse=True) + need(inverse == endpoint(n), variant + ": inverse endpoint") + need(matrix_product(out, inverse) == ident(n), variant + ": right inverse") + need(matrix_product(inverse, out) == ident(n), variant + ": left inverse") + dual = ident(n) + for event in flatten(word): + dual = matrix_product(transpose(primitive_matrix(event, n, True)), dual) + need(dual == transpose(inverse), variant + ": chronological dual") + need(matrix_product(transpose(out), dual) == ident(n), + variant + ": transpose-inverse identity") + cut = next(i for i, event in enumerate(word) if event["kind"] == "normalize") + before = evaluate(word[:cut], n) + need(before == expected_preterminal(b, variant), variant + ": terminal pullback") + codes = [e for e in word if e["kind"] == "code"] + additions = [e for e in word if e["kind"] == "add"] + need(len(codes) == (6 if variant == "historical" else 2), "code inventory") + need(len(additions) == 2, "added scalar sweep inventory") + check_normalizations(word) + need(sum(e["kind"] == "local" and not e["coded"] for e in word) == 2*b-1, + "clean local inventory") + bridges = sum(e["kind"] == "bridge" for e in word) + need(bridges == 3*b-3, "full inherited bridge inventory") + locals_count = sum(e["kind"] == "local" for e in word) + need(locals_count == 2*b+1, "full local inventory") + need(sum(e["kind"] == "exchange" for e in word) == 1, + "full terminal exchange inventory") + macro_inventory = dict( + coded_local_calls=2, clean_local_calls=2*b-1, + inherited_bridges=bridges, inherited_scalar_bank_ADD_sweeps=2*bridges, + additional_scalar_bank_ADD_sweeps=2, + additional_prefix_code_applications=2 if variant=="historical" else 0, + additional_terminal_code_applications=4 if variant=="historical" else 2, + terminal_normalization_sweeps=2, children_per_normalization_sweep=111, + terminal_pair_exchanges=b, + known_nonlocal_scalar_ADDs=2*bridges*111+len(codes)*1499+222, + local_internal_ADDs="same local words in both comparators; not repriced here", + original_idle_owners="retained as a separate native caller premise") + return dict(bank_pairs=b, formal_inputs=n, variant=variant, + controller_events=len(word), word=word, + complete_macro_inventory=macro_inventory, + preterminal=serialize(before), endpoint=serialize(out), + literal_inverse_endpoint=serialize(inverse), + inverse_transpose_endpoint=serialize(dual), + added_code_occurrences=len(codes), + added_bank_ADD_sweeps=len(additions), + added_scalar_ADDs=len(codes)*1499+222, + normalization_rank_one_children=222, + clean_replacements=2*b-1, + extra_rank_mass_vs_fullycoded=(2*b-1)*60+222, + net_rank_mass_saved_vs_allclean=-102) + + +def expect_failure(name, operation, message): + try: + operation() + except ValueError as error: + need(str(error) == message, name + ": wrong rejection: " + str(error)) + return dict(mutation=name, rejected=True, intended_message=message) + raise ValueError(name + ": control did not reject") + + +def mutation_controls(events): + controls = [] + original = make_hybrid(events, "two_code") + n = 8 + def endpoint_gate(word): + need(evaluate(word, n) == endpoint(n), "mutated all-input endpoint") + code_indices = [i for i,e in enumerate(original) if e["kind"] == "code"] + add_indices = [i for i,e in enumerate(original) if e["kind"] == "add"] + for i in code_indices + add_indices: + bad = copy.deepcopy(original) + del bad[i] + controls.append(expect_failure("omit_event_"+str(i), + lambda bad=bad: endpoint_gate(bad), + "mutated all-input endpoint")) + for name, index, field, value in [ + ("wrong_code_direction", code_indices[0], "generator", -2), + ("wrong_code_bank", code_indices[1], "register", 0), + ("wrong_compensation_sign", add_indices[0], "coefficient", 1)]: + bad = copy.deepcopy(original) + bad[index][field] = value + controls.append(expect_failure(name, lambda bad=bad: endpoint_gate(bad), + "mutated all-input endpoint")) + bad = copy.deepcopy(original) + next(e for e in bad if e.get("stage") == 2)["coded"] = True + controls.append(expect_failure("stale_coded_F2", lambda: endpoint_gate(bad), + "mutated all-input endpoint")) + # The overall signed endpoint is involutive; repeating it is not a control. + state = evaluate(original, n) + changed = False + for event in reversed(flatten(original)): + wrong = event["kind"] == "code" and not changed + state = matrix_product(primitive_matrix(event, n, not wrong), state) + changed = changed or wrong + controls.append(expect_failure( + "literal_inverse_one_code_direction", + lambda: need(state == ident(n), "mutated literal inverse"), + "mutated literal inverse")) + # Frame normalization is abstractly the identity. Its absence cannot be + # detected by this logical endpoint, so test the declared native inventory. + normalizations = [i for i,e in enumerate(original) if e["kind"] == "normalize"] + for omitted in normalizations: + bad = copy.deepcopy(original) + del bad[omitted] + need(evaluate(bad,n) == endpoint(n), + "omitted normalization has unchanged abstract endpoint") + control = expect_failure( + "omit_normalization_"+str(omitted), + lambda bad=bad: check_normalizations(bad), + "declared native normalization inventory") + control["logical_endpoint_still_passes"] = True + control["rejection_scope"] = "declared inventory, not native realization proof" + controls.append(control) + bad = copy.deepcopy(original) + bad[normalizations[0]]["register"] = 0 + controls.append(expect_failure( + "wrong_normalization_bank",lambda: check_normalizations(bad), + "declared native normalization inventory")) + # Independent generators really do not commute or equal their transposes. + need(reduce_word((1,2,-1,-2)) != (), "noncommutative representation") + need(transpose([{(0,(1,)):1}]) != [{(0,(-1,)):1}], + "transpose must not be inverse") + return controls + + +def mm(a, b): + return [[sum(x*y for x,y in zip(row,column)) for column in zip(*b)] + for row in a] + + +def tr(a): + return [list(row) for row in zip(*a)] + + +def eye(n): + return [[F(i == j) for j in range(n)] for i in range(n)] + + +def mv(a, vector): + return [sum(x*y for x,y in zip(row,vector)) for row in a] + + +def serialq(a): + return [[str(x) for x in row] for row in a] + + +def route_witness(matrices, raw_word, root_word): + mat = matrices["matrices"] + k, r = mat["K"], mat["R"] + need(len(k) == 111 and len(r) == 9, "actual code dimensions") + a = [] + for p, mask in enumerate(k): + row = 1 << p + if p not in (0,1,2): + for j, data in enumerate(r): + if mask >> j & 1: + row ^= data + a.append(row) + need((a[3] & 1) == 1, "actual A[3,0]") + full_lines = root_word["lines"] + need(len(full_lines) == 120, "full E8 line inventory") + p, q = 3, 0 + selected = {raw_word["ports_geom"][p], raw_word["ports_geom"][q]} + # Reconstruct the same deterministic discovery tree, only composing routes + # on the paths needed for the selected witness. No all-pairs claim. + parent = {0: None} + edge = {} + frontier = [0] + while not selected <= parent.keys(): + later = [] + for source in frontier: + for target in range(120): + dot = sum(x*y for x,y in zip(full_lines[source],full_lines[target])) + if target in parent or abs(dot) != 2: + continue + sign = 1 if dot == 2 else -1 + d = [F(x-sign*y) for x,y in zip(full_lines[source],full_lines[target])] + norm = sum(x*x for x in d) + reflection = [[F(i==j)-2*d[i]*d[j]/norm for j in range(8)] + for i in range(8)] + parent[target] = source + edge[target] = reflection + later.append(target) + need(later, "selected route labels reachable") + frontier = later + routes, projections, paths = {}, {}, {} + for port in (p,q): + label = raw_word["ports_geom"][port] + need(raw_word["lines"][port] == full_lines[label], "selected actual root") + path, current = [], label + while parent[current] is not None: + path.append(current) + current = parent[current] + g = eye(8) + for target in reversed(path): + g = mm(edge[target],g) + root = [F(x) for x in raw_word["lines"][port]] + cap = [row[1:] for row in g] + projection = [[x*y/4 for y in root] for x in root] + need(mm(tr(cap),cap) == eye(7), "selected cap orthonormal") + need(mm(cap,tr(cap)) == [[F(i==j)-projection[i][j] for j in range(8)] + for i in range(8)], "selected cap projector") + rho = [projection[i]+cap[i] for i in range(8)] + rho += [row+[F(0)]*7 for row in tr(cap)] + need(tr(rho) == rho and mm(rho,rho) == eye(15), + "selected route symmetric involution") + routes[port], projections[port], paths[port] = rho,projection,list(reversed(path)) + vector = [F(x) for x in raw_word["lines"][q]]+[F(0)]*7 + need(mv(routes[q],vector) == vector, "source route fixes source root line") + relative = mm(routes[p],routes[q]) # rho_p^-1 rho_q; both involutions. + output = mv(relative,vector) + expected = [F(0)]*15 + expected[10] = F(2) + need(output == expected, "selected exact fresh-coordinate witness") + target = [row+[F(0)]*7 for row in projections[p]]+[[F(0)]*15 for _ in range(7)] + defect = [x-y for x,y in zip(output,mv(target,output))] + need(defect == expected, "fresh output lies outside target P3") + mod101 = [x.numerator*pow(x.denominator,-1,101)%101 for x in output] + need(mod101[10] == 2, "odd-field fresh witness") + # The binary function f(w)=1[w_10=0] is constant on target P3 cosets, + # but f(T*0)=1 differs from f(T*(2e0))=0 although 2e0 is in source P0. + # This gives an explicit quotient/pullback separator, rather than assuming + # a point delta is admissible on an entire source-frame fiber. + separator_at_zero, separator_at_image = 1, int(mod101[10] == 0) + need(separator_at_zero != separator_at_image, "binary VALUE fiber separator") + target_fiber_vector = [F(x) for x in raw_word["lines"][p]]+[F(0)]*7 + inverse_relative = mm(routes[q],routes[p]) + need(mm(relative,inverse_relative) == eye(15), "relative inverse orientation") + inverse_image = mv(inverse_relative,target_fiber_vector) + need(inverse_image == expected, "direct source VALUE pushforward witness") + inverse_mod101 = [x.numerator*pow(x.denominator,-1,101)%101 for x in inverse_image] + pushed_at_zero, pushed_at_target_shift = 1, int(inverse_mod101[10] == 0) + need(pushed_at_zero != pushed_at_target_shift, "forward VALUE admission failure") + need(mv(mm(routes[q],routes[q]),vector) == vector, "diagonal route control") + zero = [[F(0)]*15 for _ in range(15)] + need(mm(relative,zero) == mm(zero,relative) == zero, "ZERO frame control") + controls = [] + controls.append(expect_failure( + "omitted_relative_route", + lambda: need(any(mv(eye(15),vector)[8:]), "fresh-coordinate witness required"), + "fresh-coordinate witness required")) + controls.append(expect_failure( + "diagonal_substituted_for_offdiagonal", + lambda: need(any(mv(mm(routes[q],routes[q]),vector)[8:]), + "fresh-coordinate witness required"), + "fresh-coordinate witness required")) + controls.append(expect_failure( + "delete_actual_A30", + lambda: need(((a[3]^1)&1) == 1, "actual A[3,0]"), + "actual A[3,0]")) + return dict(status="PASS_SELECTED_A30_EARLY_PROMOTION_COUNTEREXAMPLE", + binary_code_rows=a, output_port=p,input_port=q,coefficient=1, + selected_route_paths={str(i): paths[i] for i in (p,q)}, + selected_route_matrices={str(i): serialq(routes[i]) for i in (p,q)}, + input_address=list(map(str,vector)), + output_address=list(map(str,output)), + defect_outside_target_P3=list(map(str,defect)), + output_mod101=mod101, + binary_VALUE_separator=dict( + function="f(w)=1 if w_10=0 in F101, else 0", + constant_on_target_P3=True, + at_T_zero=separator_at_zero,at_T_source_P0_vector=separator_at_image, + implication="pullback along T is not constant on source P0"), + direct_forward_VALUE_witness=dict( + address_push="T=rho3^-1*rho0", + VALUE_push="g(w)=f(T^-1*w)", + source_function="f(w)=1 if w_10=0 in F101, else 0", + source_function_constant_on_P0=True, + target_P3_vector=list(map(str,target_fiber_vector)), + inverse_address_image=list(map(str,inverse_image)), + g_at_zero=pushed_at_zero,g_at_target_P3_shift=pushed_at_target_shift, + implication="g is not constant on target P3"), + exact_fresh_coordinates=list(map(str,output[8:])), + selected_routes_checked=2,ordered_offdiagonal_pairs_checked=1, + all_12210_ordered_pairs_replayed=False, + controls=controls, + scope="Rational ADDRESS and ADDRESS field F101; explicit binary VALUE separator", + excluded_claim="No obstruction to all changed promoted-input factories") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + for name in PINS: + parser.add_argument("--"+name, required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + args = parser.parse_args() + sources = {name: read_source(getattr(args,name),name) for name in PINS} + recipe = source_recipe(sources["recipe"]) + cases = [] + # All-B proof is written separately. These are finite implementation fixtures. + for b in list(range(1,13))+[16,32]: + events = recipe(b) + need(events == independent_recipe(b), "pinned recipe reconstruction") + need(len(events) == 5*b-1, "recipe event count") + need(evaluate(events,2*b) == endpoint(2*b), "all-clean signed endpoint") + for variant in ("historical","two_code"): + cases.append(audit_word(make_hybrid(events,variant),b,variant)) + b4 = recipe(4) + controls = mutation_controls(b4) + route = route_witness(json.loads(sources["matrices"]), + json.loads(gzip.decompress(sources["r438"])), + json.loads(gzip.decompress(sources["roots"]))) + # Determinant exponent certificate under a0=t, a1=u, all other a_s=1. + prefix_exponents = [1,-1] + terminal_exponents = [0,0] + for event in make_hybrid(b4,"two_code"): + if event["kind"] == "code": + generator = event["generator"] + terminal_exponents[abs(generator)-1] += 1 if generator>0 else -1 + need(terminal_exponents == [-1,1], "terminal determinant correction") + need([a+b for a,b in zip(prefix_exponents,terminal_exponents)] == [0,0], + "determinant exponents cancel") + receipt = dict( + status="PASS_ALL_B_PROOF_FIXTURES_TWO_CODE_HYBRID_AND_SELECTED_NATIVE_WITNESS", + scientific_pin="20ecf2891d80b5acf18d980b2164fb44ea7faa90", + sources=PINS, algebra="Integral free group algebra; transpose generators independent", + finite_bank_counts=list(range(1,13))+[16,32],cases=cases, + word_controls=controls, early_promotion=route, + two_code_lower_bound=dict( + scalar_specialization="a0=t,a1=u,other generators=1 over Q(t,u)", + prefix_determinant_exponents=prefix_exponents, + required_added_exponents=[-1,1],attained_added_exponents=terminal_exponents, + minimum_added_single_bank_generator_occurrences=2, + restrictions=["same first coded F0,B1","all remaining locals clean", + "no extra coded local","single-bank a_s or a_s^-1 primitives", + "scalar determinant-neutral mixing and logical normalization", + "fixed all-clean signed endpoint", + "no free composite-code primitive or new operator-valued gate"]), + invoice=dict(historical_code_occurrences=6,new_code_occurrences=2, + historical_scalar_ADDs=9216,new_scalar_ADDs=3220, + scalar_ADDs_saved=5996,normalization_rank_one_children=222, + conditional_net_rank_saving_vs_allclean=-102, + formula_extra_rank_vs_fullycoded="60*(2*B-1)+222", + historical_B4_allowances_only={"beta_002":492,"beta_003":309}, + historical_B4_extra_rank=642), + scope=["written proof covers every B>=1 and arbitrary 2B input banks", + "finite replay covers listed bank counts only", + "local arbitrary-helper restoration and copied-field cleanup are premises", + "signed abstract local map is not an assertion about actual R429 integer target", + "native phase, mixed owners, access, precision and full recurrence remain conditional", + "two-code optimum is for the stated generator-occurrence alphabet only", + "no new rank saving, physical optimum, kappa or formal-kernel proof"]) + # Output is external; no package-relative writes or hidden dependencies. + args.output.parent.mkdir(parents=True,exist_ok=True) + args.output.write_text(json.dumps(receipt,sort_keys=True,indent=2)+"\n") + print(json.dumps({"status":receipt["status"],"cases":len(cases), + "word_controls":len(controls), + "receipt_canonical_sha256":digest(canonical(receipt))}, + sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/bit-fixed-controller-repairs/frozen/reviews/recipe/CHECKS.json.gz b/research/bit-fixed-controller-repairs/frozen/reviews/recipe/CHECKS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..11f14c0d8f38611638947c7f6dbee48847b92231 GIT binary patch literal 10228 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 hCh+;--t)0p)AMom> j) & 1) << i for i, r in enumerate(rows)) + + +def outer(u, v, n): + return [v if (u >> i) & 1 else 0 for i in range(n)] + + +def add(a, b): + need(len(a) == len(b), "matrix dimensions") + return [x ^ y for x, y in zip(a, b)] + + +def multiply(a, b): + answer = [] + for row in a: + value = 0 + while row: + bit = row & -row + value ^= b[bit.bit_length() - 1] + row ^= bit + answer.append(value) + return answer + + +def inverse(a): + n = len(a) + z = [r | (1 << (n + i)) for i, r in enumerate(a)] + for j in range(n): + positions = [i for i in range(j, n) if (z[i] >> j) & 1] + need(bool(positions), "scalar conjugator singular") + p = positions[0] + z[j], z[p] = z[p], z[j] + for i in range(n): + if i != j and (z[i] >> j) & 1: + z[i] ^= z[j] + return [r >> n for r in z] + + +def transpose(rows, n): + return [column(rows, j) for j in range(n)] + + +def trace(rows): + return sum((row >> i) & 1 for i, row in enumerate(rows)) & 1 + + +def extract_recipe(raw): + tree = ast.parse(raw) + matches = [ + node for node in tree.body + if isinstance(node, ast.FunctionDef) and node.name == "recipe" + ] + need(len(matches) == 1, "recipe definition multiplicity") + function = matches[0] + need(not function.decorator_list, "decorated recipe excluded") + environment = {"__builtins__": {"dict": dict, "range": range, "reversed": reversed}} + exec(compile(ast.Module(body=[function], type_ignores=[]), + "", "exec", + dont_inherit=True, optimize=0), environment) + return environment["recipe"] + + +def bound_bytes(path, expected, message): + raw = path.read_bytes() + need(hashlib.sha256(raw).hexdigest() == expected, message) + return raw + + +def evaluate(events, banks): + """Dual-number matrices as separate constant and epsilon bit rows.""" + n = 2 * banks + constant, epsilon = identity(n), [0] * n + for event in events: + kind = event["kind"] + if kind == "local": + i = 2 * event["pair"] + need(0 <= i < n - 1, "local bank range") + if event["reverse"]: + # x <- (1+epsilon)x+y, with y unchanged. + epsilon[i] ^= constant[i] ^ epsilon[i + 1] + constant[i] ^= constant[i + 1] + else: + # y <- x+(1+epsilon)y, with x unchanged. + epsilon[i + 1] ^= epsilon[i] ^ constant[i + 1] + constant[i + 1] ^= constant[i] + elif kind == "bridge": + d, s = 2 * event["dst"], 2 * event["src"] + need(d != s and 0 <= d < n and 0 <= s < n, "bridge bank range") + need(event["coefficient"] in (-1, 1), "bridge coefficient") + constant[d] ^= constant[s] + epsilon[d] ^= epsilon[s] + constant[s + 1] ^= constant[d + 1] + epsilon[s + 1] ^= epsilon[d + 1] + elif kind == "exchange": + for i in range(0, n, 2): + constant[i], constant[i + 1] = constant[i + 1], constant[i] + epsilon[i], epsilon[i + 1] = epsilon[i + 1], epsilon[i] + else: + raise ValueError("unknown recipe event") + return constant, epsilon + + +def grouped(rows, banks): + permutation = list(range(0, 2 * banks, 2)) + list(range(1, 2 * banks, 2)) + return [ + sum(((rows[i] >> j) & 1) << k for k, j in enumerate(permutation)) + for i in permutation + ] + + +def ungrouped(rows, banks): + permutation = list(range(0, 2 * banks, 2)) + list(range(1, 2 * banks, 2)) + answer = [0] * (2 * banks) + for i, original_i in enumerate(permutation): + answer[original_i] = sum( + ((rows[i] >> j) & 1) << original_j + for j, original_j in enumerate(permutation) + ) + return answer + + +def closed_form(banks): + b = banks + c = [sum(((b - max(i, j)) & 1) << j for j in range(b)) for i in range(b)] + d = [(1 << i) | ((1 << (i - 1)) if i else 0) for i in range(b)] + e = [1] + [(1 << i) - 1 for i in range(1, b)] + a = [row << b for row in c] + [d[i] | (e[i] << b) for i in range(b)] + m = add(a, identity(2 * b)) + return a, m, c, d, e + + +def projector_conjugator(u, v, n): + need(u != 0 and v != 0 and dot(v, u) == 1, "repair is not a rank-one idempotent") + pivot = (v & -v).bit_length() - 1 + columns = [u] + for j in range(n): + if j != pivot: + columns.append((1 << j) ^ ((1 << pivot) if (v >> j) & 1 else 0)) + scalar = transpose(columns, n) + scalar_inverse = inverse(scalar) + need(scalar_inverse[0] == v, "conjugator first dual") + paid = [1] + [0] * (n - 1) + p = outer(u, v, n) + need(multiply(multiply(scalar, paid), scalar_inverse) == p, + "scalar conjugation projector") + need(multiply(p, p) == p and rank(p) == 1 and trace(p) == 1, + "projector identities") + return scalar, scalar_inverse + + +def repair_projectors(m, banks): + n, y0 = 2 * banks, banks + result = [] + if banks & 1: + for j in range(n): + if j != y0: + result.append((column(m, j), 1 << j)) + result += [(column(m, y0) ^ (1 << y0), 1 << y0), + (1 << y0, 1 << y0)] + else: + for j in range(banks): + result.append((column(m, j), (1 << j) ^ ((1 << y0) if j & 1 else 0))) + for j in range(banks + 1, n): + result.append((column(m, j), 1 << j)) + return result + + +def validate_repair(m, projectors): + n = len(m) + total = [0] * n + records = [] + for u, v in projectors: + scalar, scalar_inverse = projector_conjugator(u, v, n) + total = add(total, outer(u, v, n)) + records.append({"u_bits": u, "v_bits": v, + "scalar_rows": scalar, "scalar_inverse_rows": scalar_inverse}) + need(total == m, "repair coefficient endpoint") + return records + + +def tensor(rows, n_block): + """Kronecker product in bank-major order, bit-packed binary matrices.""" + width = len(n_block) + answer = [] + for row in rows: + for block_row in n_block: + answer.append(sum(block_row << (j * width) + for j in range(len(rows)) if (row >> j) & 1)) + return answer + + +def instantiated_endpoint(a, m, projectors, base_n, spectators, + wrong_first_spectator_target=False): + """Exact arbitrary-input matrix replay, including dirty identity spectators.""" + n, w = len(a), len(base_n) + need(multiply(base_n, base_n) == identity(w), "N is not an involution") + epsilon = add(base_n, identity(w)) + need(any(epsilon), "N identity representation excluded from obstruction") + r = n + spectators + enlarged_a = a[:] + [0] * spectators + enlarged_m = m[:] + [0] * spectators + endpoint = add(identity(r * w), tensor(enlarged_a, epsilon)) + for u, v in projectors: + event = add(identity(r * w), tensor(outer(u, v, r), epsilon)) + endpoint = multiply(event, endpoint) + target = tensor(identity(n) + [0] * spectators, base_n) + for i in range(n * w, r * w): + target[i] = 1 << i + if wrong_first_spectator_target: + need(spectators > 0, "spectator mutation needs a spectator") + for i in range(w): + target[n * w + i] = base_n[i] << (n * w) + need(endpoint[n * w:] == target[n * w:], + "literal dirty spectator restoration") + need(endpoint == target, "instantiated full dirty-input endpoint") + need(rank(tensor(enlarged_m, epsilon)) == rank(enlarged_m) * rank(epsilon), + "instantiated tensor rank") + return {"ports_per_bank": w, "spectators": spectators, "N_rows": base_n, + "all_input_columns": r * w, "epsilon_rank": rank(epsilon), + "defect_rank": rank(enlarged_m) * rank(epsilon)} + + +def reject(name, operation, expected): + try: + operation() + except ValueError as error: + need(str(error) == expected, "wrong rejection for " + name) + return {"name": name, "rejection": str(error)} + raise ValueError("negative control accepted: " + name) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--recipe-source", type=Path, required=True) + parser.add_argument("--historical-receipt", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + recipe_raw = bound_bytes(args.recipe_source, RECIPE_SHA, "recipe source hash") + historical_raw = bound_bytes(args.historical_receipt, HISTORICAL_SHA, "historical receipt hash") + recipe = extract_recipe(recipe_raw) + historical = json.loads(historical_raw) + need(historical["scientific_pin"] == PIN and historical["source_recipe_sha256"] == RECIPE_SHA, + "historical source binding") + cases = [] + for b in range(1, 13): + n = 2 * b + events = recipe(b) + constant, epsilon = evaluate(events, b) + a, m, c, d, e = closed_form(b) + need(constant == identity(n), "recipe constant endpoint") + need(grouped(epsilon, b) == a, "recipe closed-form coefficient") + schur = add(add(e, identity(b)), multiply(d, c)) + need(schur == [c[0]] + identity(b)[1:], "Schur row formula") + expected_rank = n if b & 1 else n - 1 + expected_count = n + 1 if b & 1 else n - 1 + need(rank(a) == n and rank(m) == expected_rank and trace(m) == 1, + "rank and trace theorem") + if not b & 1: + kernel = (1 << b) | sum(1 << j for j in range(1, b, 2)) + need(all(dot(row, kernel) == 0 for row in m), "even kernel formula") + else: + kernel = None + projectors = repair_projectors(m, b) + repairs = validate_repair(m, projectors) + need(len(projectors) == expected_count, "attaining repair count") + need(len(projectors) >= rank(m) and len(projectors) & 1 == trace(m), + "lower bound match") + instantiations = [] + if b <= 8: + for base_n in ([2, 1], [3, 2], [3, 2, 12, 8]): + for spectators in (0, 1, 3): + instantiations.append(instantiated_endpoint(a, m, projectors, base_n, spectators)) + if b <= 6: + old = historical["cases"][b - 1] + raw_n_entries = [ + [(((constant[i] >> j) & 1) ^ ((epsilon[i] >> j) & 1)) + | (((epsilon[i] >> j) & 1) << 1) for j in range(n)] + for i in range(n) + ] + old_a = [[(epsilon[i] >> j) & 1 for j in range(n)] for i in range(n)] + old_m = [[old_a[i][j] ^ int(i == j) for j in range(n)] for i in range(n)] + recovered = {"B": b, "events": events, "raw_endpoint_ring_entries": raw_n_entries, + "epsilon_matrix_A": old_a, "relative_to_common_N_defect_M": old_m, + "rank_A": n, "rank_defect_M": expected_rank, "trace_defect": 1} + need(recovered == old, "complete historical case replay") + cases.append({"B": b, "events": events, "constant_rows": constant, + "epsilon_A_grouped_rows": a, "defect_M_grouped_rows": m, + "C_rows": c, "D_rows": d, "E_rows": e, "schur_rows": schur, + "rank_A": n, "rank_M": expected_rank, "trace_M": 1, + "even_kernel_bits": kernel, "minimum_repair_calls": expected_count, + "repair_projectors": repairs, "instantiations": instantiations}) + + b = 4 + a, m, _, _, _ = closed_form(b) + events = recipe(b) + projectors = repair_projectors(m, b) + controls = [] + bad = [dict(event) for event in events] + bad[0]["reverse"] = True + controls.append(reject("reverse initial local call", + lambda: need(evaluate(bad, b) == (identity(8), ungrouped(a, b)), + "changed word endpoint"), + "changed word endpoint")) + bridge_index = next(i for i, event in enumerate(events) if event["kind"] == "bridge") + bad_bridge = events[:bridge_index] + events[bridge_index + 1:] + controls.append(reject("omit first bridge", + lambda: need(evaluate(bad_bridge, b) == (identity(8), ungrouped(a, b)), + "changed word endpoint"), + "changed word endpoint")) + controls.append(reject("omit terminal exchange", + lambda: need(evaluate(events[:-1], b) == (identity(8), ungrouped(a, b)), + "changed word endpoint"), + "changed word endpoint")) + controls.append(reject("omit one attaining repair", + lambda: validate_repair(m, projectors[:-1]), + "repair coefficient endpoint")) + controls.append(reject("trace-zero rank-one coupling", + lambda: projector_conjugator(1, 2, 8), + "repair is not a rank-one idempotent")) + controls.append(reject("wrong even kernel parity", + lambda: need(all(dot(row, 1 << b) == 0 for row in m), + "even kernel formula"), + "even kernel formula")) + controls.append(reject("non-involutive N", + lambda: instantiated_endpoint(a, m, projectors, [2, 3], 1), + "N is not an involution")) + controls.append(reject("identity N obstruction hypothesis", + lambda: instantiated_endpoint(a, m, projectors, [1, 2], 1), + "N identity representation excluded from obstruction")) + controls.append(reject("duplicate recipe definition", + lambda: extract_recipe(b"def recipe(K): return []\ndef recipe(K): return []\n"), + "recipe definition multiplicity")) + controls.append(reject("missing recipe definition", + lambda: extract_recipe(b"def another(K): return []\n"), + "recipe definition multiplicity")) + controls.append(reject("changed epsilon formula", + lambda: need(add(a, [1] + [0] * 7) == grouped(evaluate(events, b)[1], b), + "recipe closed-form coefficient"), + "recipe closed-form coefficient")) + controls.append(reject("dirty spectator incorrectly receives N", + lambda: instantiated_endpoint( + a, m, projectors, [2, 1], 1, + wrong_first_spectator_target=True), + "literal dirty spectator restoration")) + output = { + "status": "PASS_FIXED_RECIPE_ALL_B_PROOF_CERTIFICATES", + "scientific_pin": PIN, + "source_hashes": {"recipe": RECIPE_SHA, "historical_receipt": HISTORICAL_SHA}, + "finite_coverage": {"B": [1, 12], "full_binary_instantiation_B": [1, 8], + "binary_N_matrices": 3, "spectator_counts": [0, 1, 3], + "historical_full_cases": 6}, + "all_parameter_written_theorem": "k(B)=2B+1 for odd B; k(B)=2B-1 for even B", + "coordinate_order": "x0,...,x(B-1),y0,...,y(B-1)", + "cases": cases, "negative_controls": controls, + "formal_kernel_proof": False, + "limits": ["Fixed recipe and scalar-GL-conjugated single-bank N repairs only.", + "Every finite number of independently dirty restored spectator banks is covered by the written bound.", + "Native scalar access, each N implementation and its price, fresh frames, helper restoration and precision remain separate."] + } + args.output.write_text(json.dumps(output, indent=2, sort_keys=True) + "\n") + print(output["status"]) + print("B=1..12; all historical B=1..6 cases; 72 arbitrary-input instantiations; 12 intended rejections") + + +if __name__ == "__main__": + main() diff --git a/research/bit-fixed-controller-repairs/frozen/routes/expanded_sections.py b/research/bit-fixed-controller-repairs/frozen/routes/expanded_sections.py new file mode 100644 index 0000000000..5ba1e11ac5 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/routes/expanded_sections.py @@ -0,0 +1,139 @@ +#!/usr/bin/env python3 +"""Exact135-repair scalar closure and actual fresh-coordinate route witness. + +Scalar closure is not a native endpoint. The fresh-coordinate test proves +that this candidate fails even on arbitrary binary VALUE functions over an +explicit odd ADDRESS field. No kappa or completed supplier is claimed. +Substantial OpenAI Codex assistance. +""" +import argparse,gzip,json,sys +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +OLD=Path('/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier') +REPO=Path('/Users/ross/git/math/integer-mult-bounds') +sys.path.insert(0,str(OLD/'recursive')) +import bit_cap_copy_local as cap + +def need(b,s): + if not b:raise ValueError(s) + +def bits(x): + while x: + b=x&-x;yield b.bit_length()-1;x^=b +def xor(xs): + x=0 + for a in xs:x^=a + return x +def eye(n):return [1<>j&1),None) + need(p is not None,'singular binary code');w[p],w[j]=w[j],w[p] + for p in range(n): + if p!=j and w[p]>>j&1:w[p]^=w[j] + need([r&((1<>n for r in w] + +def mm(a,b): + bt=list(zip(*b));return [[sum(x*y for x,y in zip(row,col)) for col in bt] for row in a] +def tr(a):return list(map(list,zip(*a))) +def eyeq(n):return [[F(i==j) for j in range(n)] for i in range(n)] +def serial(a):return [[str(x) for x in row] for row in a] + +def roots_and_routes(word): + rawpath=REPO/'research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz' + raw=rawpath.read_bytes();full=json.loads(gzip.decompress(raw));lines=full['lines'] + I=eyeq(8);gs={0:I};todo=[0] + while todo: + more=[] + for p in todo: + for q in range(120): + ip=sum(x*y for x,y in zip(lines[p],lines[q]))//2 + if q in gs or abs(ip)!=1:continue + d=[F(x-y if ip==1 else x+y) for x,y in zip(lines[p],lines[q])] + norm=sum(x*x for x in d) + r=[[F(i==j)-2*d[i]*d[j]/norm for j in range(8)] for i in range(8)] + gs[q]=mm(r,gs[p]);more.append(q) + todo=more + need(len(gs)==120,'all actual E8 routes') + rho=[];AA=[];PP=[] + for p,label in enumerate(word['ports_geom']): + q=word['lines'][p];g=gs[label];a=[row[1:] for row in g] + P=[[F(x*y,4) for y in q] for x in q] + need(mm(tr(a),a)==eyeq(7),'actual orthonormal cap basis') + need(mm(a,tr(a))==[[I[i][j]-P[i][j] for j in range(8)] for i in range(8)],'actual cap projector') + r=[P[i]+a[i] for i in range(8)]+[row+[F(0)]*7 for row in tr(a)] + need(mm(r,r)==eyeq(15) and tr(r)==r,'actual involutive route') + rho.append(r);AA.append(a);PP.append(P) + # Every ordered distinct pair moves the fresh coordinate, even mod101. + failures=[];count=0 + for p in range(111): + for q in range(111): + if p==q:continue + aq=mm(tr(AA[p]),[[F(x)] for x in word['lines'][q]]) + need(any(x[0] for x in aq),'distinct-line fresh crossblock') + need(any((x[0].numerator*pow(x[0].denominator,-1,101))%101 for x in aq), + 'fresh crossblock nonzero mod101') + count+=1 + return rho,AA,PP,{'full_root_word_sha256':sha256(raw).hexdigest(),'ordered_distinct_pairs_checked':count,'address_prime':101} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + inp=OLD/'recursive/BIT-THREE-ROW-INPUT.json';mat=json.loads(inp.read_bytes())['matrices'];R,K=mat['R'],mat['K'] + W=K[:] + for p in (0,1,2):W[p]=0 + A=[i^r for i,r in zip(eye(111),product(W,R))];AI=inverse(A) + J=[i^r for i,r in zip(eye(111),product(K,R))] + codes=[A]*8+[eye(111)];repairs=[];prefix=eye(111) + for s,a in enumerate(codes): + ai=inverse(a);Q=[i^r for i,r in zip(eye(111),product(J,ai))] + rows=[p for p,r in enumerate(Q) if r];need(rows==([0,1,2] if s<8 else list(range(111))),'actual physical repair rows') + repairs.append({'stage':s,'rows':rows,'queries':Q}) + prefix=product(a if s%2==0 else ai,prefix) + need(prefix==eye(111),'all111 scalar input columns close') + wordpath=cap.RAW;raw=wordpath.read_bytes();need(sha256(raw).hexdigest()==cap.RAW_SHA,'R438 source word pin') + word=json.loads(gzip.decompress(raw));rho,AA,PP,geo=roots_and_routes(word) + # Latest nonidentity factor is reverse stage7, whose coefficient matrixAI + # has an offdiagonal. Stage8 is the exact identity factor. + p,q=next((p,q) for p,row in enumerate(AI) for q in bits(row) if p!=q) + cross=mm(tr(AA[p]),PP[q]);i=next(i for i in range(8) if any(row[i] for row in cross)) + a=[F(j==i) for j in range(15)];b=[row[i] for row in mm(rho[p],rho[q])] + need(a[8:]==[0]*7 and any(b[8:]),'fresh-fiber delta witness') + # Literal pullback rule: row addresses use d*rho; the delta image is the + # corresponding inverse map, column rho_p*rho_q*a as recorded above. + need(b==[sum(rho[p][j][k]*rho[q][k][i] for k in range(15)) for j in range(15)],'ordered delta coordinate action') + b101=[x.numerator*pow(x.denominator,-1,101)%101 for x in b] + need(any(b101[8:]),'explicit odd-field delta witness') + # A missing offdiagonal cannot diagnose this phenomenon; diagonal routes + # fix the whole fresh coordinate. Omitting the port-relative route would + # incorrectly turn every factor into its scalar augmentation. + need(mm(rho[p],rho[p])==eyeq(15),'diagonal route control') + off_without_routes=eyeq(15);need(not any(off_without_routes[j][i] for j in range(8,15)),'omitted-route control') + sourcepath=REPO/'research/e8-bit-carrier-skeleton/code/nine/geometry.py' + out={'status':'PASS135_REPAIR_SCALAR_CLOSURE_AND_NATIVE_FRESH_FIBER_FAILURE', + 'R438_word_sha256':sha256(raw).hexdigest(),'matrix_input_sha256':sha256(inp.read_bytes()).hexdigest(), + 'actual_geometry_source_sha256':sha256(sourcepath.read_bytes()).hexdigest(), + 'codes':codes,'stage_repairs':repairs,'total_rank_one_copies':135,'previous_total':27,'extra_copies':108, + 'source_codes_binary_invertible':True,'scalar_all111_columns_endpoint_identity':True, + 'local_tariff':'eight3-row coded calls plus one111-row ordinary-source call; one private field live per snapshot, no new dirty helper', + 'fresh_coordinate_witness':{'latest_stage':7,'local_factor':'A^-1','output_port':p,'input_port':q, + 'coefficient':(AI[p]>>q)&1,'input_address_15':list(map(str,a)), + 'output_address_15':list(map(str,b)),'output_address_mod101':b101, + 'global_fresh_axes':list(range(8+7*6,8+7*7)), + 'compact_endpoint_input':'(G6...G0)^-1 delta(input_port q,input_address a)', + 'difference':'G7 delta has nonzero output at port p with freshE7!=0; (G6...G0)^-1 delta is supported wholly in freshE7=0'}, + 'geometry':geo,'controls':['diagonal relative route fixes fresh block','omitting relative route loses fresh witness'], + 'theorem_scope':'For any finite common-E controller with scalar invertible stage codes and these once-only fresh-block routes, exact endpointidentity forces every scalar stage code diagonal. OverF2 it forcesI, hence111physical repair rows perstage in this row-repair grammar.', + 'limits':['arbitrary changedcaller, operator-valued codes, revisiting fresh blocks, extra terminal stages and non-common-E controllers remain outside this theorem', + '135-copy candidate is only scalar closure and fails native endpoint; no whole supplier, signed local words or kappa admission']} + out=json.loads(json.dumps(out));path=HERE/'EXPANDED-SECTIONS.json' + if args.write:path.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n') + else:need(json.loads(path.read_bytes())==out,'complete route receipt differs') + print(out['status']);print('scalarcopies135; actualfreshwitness',p,q,'axis',i,'mod101',b101[8:]) + +if __name__=='__main__':main() diff --git a/research/bit-fixed-controller-repairs/frozen/upstream/global_k.py b/research/bit-fixed-controller-repairs/frozen/upstream/global_k.py new file mode 100644 index 0000000000..3df12bd632 --- /dev/null +++ b/research/bit-fixed-controller-repairs/frozen/upstream/global_k.py @@ -0,0 +1,264 @@ +# Generalised from PR #443's global_kernel.py to an arbitrary odd stage count S = 2K+1 (compressed window m = 1+7S) +# by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. At the defaults (S = 9, 32 replicas) the emitted +# GLOBAL-TEMPLATE.json.gz and GLOBAL.json equal PR #443's (GLOBAL.json except wall-clock seconds). +# Kernel integration of PR436/PR386 by chafreaky, with OpenAI Codex assistance. +# Original copyright and attribution retained below. This variant uses explicit +# residual isometries and mixed-width banks; the original all-zero-start +# requirement is replaced by the verified kernel entrance contract. +"""Source-bound compressed S-stage (S = 2K+1 odd, default 9) bit template with independent replicas. +PR386 global identity and PR436 generalization by Zhihao Chen and eumemic, +with their disclosed OpenAI Codex and Anthropic Claude assistance, Apache-2.0. +PR439 explicit residual routes and this replication extension by chafreaky, +with OpenAI Codex assistance. All owner assignments and emitted calls are checked. +Historical PR386 regression is performed by the unchanged parent wrapper. +""" +import argparse, gzip, hashlib, json, struct, time +from collections import Counter +from pathlib import Path +import os, sys +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../e8-r740-replica32/code')) +from bank_routes_k import placement, validate_isometries +from config import REPLICAS + +H,L,K,T,M=8,9,4,REPLICAS,64 # overwritten in main() from --stages / --replicas +NAMES={5:'FIVE',7:'SEVEN',9:'NINE',11:'ELEVEN',13:'THIRTEEN'} +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def write(p,x): p.write_text(json.dumps(x,indent=2)+'\n') + +def recipe(K): + out=[dict(kind='local',stage=0,pair=0,reverse=False)]; stage=1 + for j in range(K): + out.append(dict(kind='local',stage=stage,pair=j,reverse=True)); stage+=1 + if j=5 and a.stages%2==1; L=a.stages; K=(L-1)//2; T=a.replicas; M=1+7*L; NOBANK=a.no_banks + if L!=9: assert NOBANK, 'bank tiling is only emitted for the nine-stage layout; use --no-banks and host every residual' + DEFICIT=T*(2*K*120-9*H*L) + wp=a.word; w=json.loads(gzip.decompress(wp.read_bytes()) if wp.suffix=='.gz' else wp.read_bytes()) + V,R=w['v'],w['R']; LOCAL=2*V+R; DATA=2*K*V*T; LIVE=DATA+L*R + assert (w['h'],V,w['form'])==(8,120,'/2') + geo=json.loads((out/'GEOMETRY.json').read_text()) + assert geo['status']=='PASS_COMPRESSED_%s_BIT_GEOMETRY_AND_BANK_BLOCKS'%NAMES[L] and geo['stages']==L and geo['m']==M + # the port routes depend only on the labels: same 120 label vectors, in the same order + assert len(geo['ports'])==V and all(p['port']==t and p['q']==w['lines'][t] for t,p in enumerate(geo['ports'])) + rp=a.local_check/'records/249-records.bin'; raw=rp.read_bytes(); rec=list(struct.iter_unpack('<6i',raw)) + state=json.loads((a.local_check/'records/249-states.json').read_text()) + fs=json.loads((a.local_check/'records/frames.json').read_text())['frames'] + dims={int(f):z['dim'] for f,z in fs.items()} + lg=json.loads((a.local_check/'cout/legality.json').read_text()) + cc=json.loads((a.local_check/'cout/columns.json').read_text()) + assert lg['status'].startswith('PASS') and cc['status'].startswith('PASS') + assert (state['v'],state['n'])==(V,LOCAL) and lg['copies']==lg['erasures']==9 + ADDS=lg['common_frame_ADDs'] + assert cc['formal_columns_checked']==4*V+R and cc['local_scalar_additions']==ADDS + initial=[state['initial'][str(i)] for i in range(LOCAL)] + final=[state['final'][str(i)] for i in range(LOCAL)] + assert all(dims[final[i]]==H for i in range(2*V,LOCAL)) + widths=[H-dims[initial[i]] for i in range(2*V,LOCAL)] + ENT=sum(H-z for z in widths) + if NOBANK: place,NB=None,None; LIVE=DATA + else: + place,NB=placement(widths,T,M) + assert T%8==0 and T*(H*R-ENT)%M==0 and NB==T*(H*R-ENT)//M + LIVE=DATA+L*NB + isometries=json.loads(a.isometries.read_text()) + assert validate_isometries(isometries,w['frames'],w['lines'],dims)==set(initial[2*V:]) + streams={}; checks={}; localH=None + for reverse in (False,True): + cur=(final if reverse else initial)[:]+[-1]; val=[1<=0 + cur[x]=newf + if f: hist[f]+=1 + events.append([0,x,oldf,newf,f,int(reverse)]) + elif op==1: + assert cur[x]==cur[y]==f and x!=y and x