diff --git a/research/hyperplane-retiming/.gitattributes b/research/hyperplane-retiming/.gitattributes new file mode 100644 index 0000000000..8cf65e53e7 --- /dev/null +++ b/research/hyperplane-retiming/.gitattributes @@ -0,0 +1,2 @@ +inputs/** -text +vendor/** -text diff --git a/research/hyperplane-retiming/.gitignore b/research/hyperplane-retiming/.gitignore new file mode 100644 index 0000000000..cc4e5ea548 --- /dev/null +++ b/research/hyperplane-retiming/.gitignore @@ -0,0 +1,4 @@ +search/*-best.json +search/*-screen.json +__pycache__/ +search/__pycache__/ diff --git a/research/hyperplane-retiming/ARITHMETIC-ORIGINS.json b/research/hyperplane-retiming/ARITHMETIC-ORIGINS.json new file mode 100644 index 0000000000..d426d4cc66 --- /dev/null +++ b/research/hyperplane-retiming/ARITHMETIC-ORIGINS.json @@ -0,0 +1,92 @@ +[ + { + "path": "vendor/research/missing-join-frame/PATCH.json", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/missing-join-frame/PATCH.json", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e" + }, + { + "path": "vendor/research/joint-helper-lattice/native_joint.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/joint-helper-lattice/native_joint.py", + "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46" + }, + { + "path": "vendor/research/joint-helper-lattice/PATCH.json", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/joint-helper-lattice/PATCH.json", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727" + }, + { + "path": "vendor/research/fresh-helper-boundary/native.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/fresh-helper-boundary/native.py", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29" + }, + { + "path": "vendor/research/fresh-helper-boundary/CHANGES.json", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/fresh-helper-boundary/CHANGES.json", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624" + }, + { + "path": "vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "vendor/research/kappa-rebuild/complex/rebuild_native.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/rebuild_native.py", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "path": "vendor/research/kappa-rebuild/complex/power_two_balance.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/power_two_balance.py", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "path": "vendor/research/kappa-rebuild/complex/native_extensions.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/native_extensions.py", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "vendor/research/kappa-function-composition/complex/prune_native.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-function-composition/complex/prune_native.py", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "path": "vendor/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "inputs/pr4610-word.json.gz", + "original_source": "head:1eb8da6cfb35512c0cc2533413e5ca42f48e13c6:research/warp-interface-20261022/ACTUAL-WORD.json.gz", + "sha256": "d578875344095047c383ef513e69b9deb9d99d2b75abe14f7359d06365a924ac" + }, + { + "path": "second_intervals.py", + "original_source": "head:b58ad9ef4d4e861b0eaa5dba41742bdc072dca51:research/kappa-rebuild/architecture/mixed_target_probe.py", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "outer_ledger.py", + "original_source": "head:b58ad9ef4d4e861b0eaa5dba41742bdc072dca51:research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "inputs/bit-stock.json", + "original_source": "head:b58ad9ef4d4e861b0eaa5dba41742bdc072dca51:research/query-thinned-controllers/RESULT.json", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f" + }, + { + "path": "inputs/p16-controller.json", + "original_source": "head:b58ad9ef4d4e861b0eaa5dba41742bdc072dca51:research/joint-helper-lattice/CONTROLLER.json", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f" + } +] diff --git a/research/hyperplane-retiming/ARITHMETIC.json b/research/hyperplane-retiming/ARITHMETIC.json new file mode 100644 index 0000000000..270a31e186 --- /dev/null +++ b/research/hyperplane-retiming/ARITHMETIC.json @@ -0,0 +1,235 @@ +{ + "compiler": { + "H": 31385200000000, + "N": "2^31385200000000", + "eta": { + "lower": "0.000000204645541328144521906682", + "upper": "0.000000204645541328144521906683" + }, + "gap": "1/700000000", + "integer_test_exponent": 44836, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "66099/21875000", + "word_materialized": false + }, + "gain_over_PR4535": "299/200000000", + "kappa": "151083/50000000", + "local_helpers": { + "4": 28, + "7": 5, + "8": 38, + "9": 337 + }, + "local_paid": { + "1": 2183, + "2": 416, + "3": 507, + "4": 135, + "5": 40, + "8": 8 + }, + "margin_at_old_root_upper": [ + "585788693166423330992560151307721906184131152992093961997/1569275433846670190958947355801916604025588861116008628224", + "585788693166423330992560151307721906184131152992150411545/1569275433846670190958947355801916604025588861116008628224" + ], + "native_receipt_sha256": "e45b32249245a827882e2888be45d41732a4e6cfb3ce5240af1b5992743e8e2c", + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "local_routes": 4793000, + "local_scalar": 158168, + "raw_scalar_upper": 181098496 + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999253/175000000000", + "fixed_halo_explicit_metadata_branch": "13475000001/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899997009/700000000000", + "new_semantic_group_guard": "3/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "296123239576967/98000000000000000", + "fused_gaussian": "296123238730901/98000000000000000", + "global_coordinate_router": "1057583/350000000", + "group_bit_router": "740308446827251/245000000000000000", + "group_scans": "349999999/350000000", + "main_transform": "296123099576967/98000000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "40108623239576967/98000000000000000" + }, + "parameters": { + "a": "1057583/350000000", + "b": "2115167/700000000", + "beta": "699999997/700000000", + "bit_saving": "17/5000", + "cap_xi": "89108623099576967/98000000000000000", + "complex_uniform_saving": "66099/21875000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "151083/50000000", + "lambda_": "199395667/200000000", + "lambda_prime": "139576967/140000000", + "layout": "1/700000000", + "q": "423033/140000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "302167/100000000" + }, + "strict_checks": { + "actual_bit_above_effective": "132417/350000000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "8891377110423033/49000000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "559576967/98000000000000000", + "cap_above_band": "40108623099576967/98000000000000000", + "cap_below_cell": "8891376760423033/98000000000000000", + "cap_below_phase_cell_power": "106891376900423033/98000000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "19759833/700000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "558730901/98000000000000000", + "gaussian_above_main": "69576967/49000000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "1746827251/245000000000000000", + "group_gauge_power_slack": "8891377103423033/49000000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "174471209/175000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645344790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000", + "lambda_above_sigma": "3/1400000000", + "lambda_above_tau": "1/1400000000", + "lambda_prime_above_lambda": "1/1400000000", + "lambda_prime_above_leaf": "1397884833/490000000000000000", + "leaf_saving_above_effective": "697884833/490000000000000000", + "main_transform_above_kappa": "419576967/98000000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "26948942421/350000000", + "microbox_halo_volume": "55300000003/700000000", + "new_complex_uniform_saving_above_b": "1/700000000", + "new_semantic_guard_with_C1_one": "1/700000000", + "polynomial_products_above_kappa": "697884837/700000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "1397884833/490000000000000000", + "q_positive": "423033/140000000", + "short_record_fallback": "697884833/700000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "39812500559576967/98000000000000000", + "stop_below_one": "699999999/700000000", + "stop_positive": "1/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000", + "union_tag_work_per_visit_fits_record": "3/700000000" + } + }, + "paid": { + "1": 40974, + "16": 448, + "2": 7488, + "24": 448, + "3": 9126, + "32": 448, + "4": 2430, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "paid_calls": 64242, + "productive_fields": 10928, + "rank_mass_surplus": 752, + "raw_root_interval": [ + "15108379/5000000000", + "30216759/10000000000" + ], + "scope": "Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.", + "source_sha256": { + "research/hyperplane-retiming/inputs/bit-stock.json": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "research/hyperplane-retiming/inputs/p16-controller.json": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "research/hyperplane-retiming/intervals.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/hyperplane-retiming/outer_ledger.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "research/hyperplane-retiming/price_profile.py": "9d5ed044b73ceb66cdfe9274a6ea967992801d1968bf480972d7d65a80eda1b8", + "research/hyperplane-retiming/second_intervals.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "research/hyperplane-retiming/verify.py": "05fcec9a922b8e59f20659fd236da02931a8c8253dbf77f06833665c15fa2e47" + }, + "status": "PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE", + "strictification": { + "alpha": { + "lower": "0.999999993909848710245136954049", + "upper": "0.999999993909848710245136954050" + }, + "cutoff": 20, + "delta": { + "lower": "0.957350155702134106401205267080", + "upper": "0.957350155702134106401205267081" + }, + "floor": 21, + "gamma": { + "lower": "0.956201848116584865358940150683", + "upper": "0.956201848116584865358940150684" + }, + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "tail_offset": "1/5", + "tested": "302167/100000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 90, + "73": 224, + "8": 684, + "9": 6066 + } +} diff --git a/research/hyperplane-retiming/ORIGINS.json b/research/hyperplane-retiming/ORIGINS.json new file mode 100644 index 0000000000..718508db98 --- /dev/null +++ b/research/hyperplane-retiming/ORIGINS.json @@ -0,0 +1,72 @@ +[ + { + "path": "vendor/research/missing-join-frame/PATCH.json", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/missing-join-frame/PATCH.json", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e" + }, + { + "path": "vendor/research/joint-helper-lattice/native_joint.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/joint-helper-lattice/native_joint.py", + "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46" + }, + { + "path": "vendor/research/joint-helper-lattice/PATCH.json", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/joint-helper-lattice/PATCH.json", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727" + }, + { + "path": "vendor/research/fresh-helper-boundary/native.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/fresh-helper-boundary/native.py", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29" + }, + { + "path": "vendor/research/fresh-helper-boundary/CHANGES.json", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/fresh-helper-boundary/CHANGES.json", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624" + }, + { + "path": "vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "vendor/research/kappa-rebuild/complex/rebuild_native.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/rebuild_native.py", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "path": "vendor/research/kappa-rebuild/complex/power_two_balance.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/power_two_balance.py", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "path": "vendor/research/kappa-rebuild/complex/native_extensions.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/native_extensions.py", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "vendor/research/kappa-function-composition/complex/prune_native.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-function-composition/complex/prune_native.py", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "path": "vendor/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "original_source": "PR4654:dca175fed8ebde8980635fd3b4508b8cba89a1b0:research/native-quotient-interface/v/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "inputs/pr4610-word.json.gz", + "original_source": "head:1eb8da6cfb35512c0cc2533413e5ca42f48e13c6:research/warp-interface-20261022/ACTUAL-WORD.json.gz", + "sha256": "d578875344095047c383ef513e69b9deb9d99d2b75abe14f7359d06365a924ac" + } +] diff --git a/research/hyperplane-retiming/PATCH.json b/research/hyperplane-retiming/PATCH.json new file mode 100644 index 0000000000..bdd92a91da --- /dev/null +++ b/research/hyperplane-retiming/PATCH.json @@ -0,0 +1,380 @@ +{ + "helper_entrances": [ + [ + 472, + 114, + 0 + ], + [ + 538, + 114, + 0 + ], + [ + 560, + 114, + 0 + ], + [ + 561, + 114, + 0 + ], + [ + 584, + 114, + 0 + ], + [ + 602, + 114, + 0 + ], + [ + 603, + 114, + 0 + ], + [ + 604, + 114, + 0 + ], + [ + 605, + 114, + 0 + ], + [ + 628, + 114, + 0 + ], + [ + 629, + 114, + 0 + ], + [ + 630, + 114, + 0 + ], + [ + 631, + 114, + 0 + ] + ], + "contacts": [ + [ + "B", + 11, + 114, + 0 + ], + [ + "B", + 12, + 114, + 0 + ], + [ + "B", + 13, + 114, + 0 + ], + [ + "B", + 14, + 114, + 0 + ], + [ + "B", + 31, + 114, + 0 + ], + [ + "B", + 58, + 114, + 0 + ], + [ + "B", + 59, + 114, + 0 + ], + [ + "B", + 115, + 114, + 0 + ], + [ + "B", + 116, + 114, + 0 + ], + [ + "B", + 117, + 114, + 0 + ], + [ + "B", + 118, + 114, + 0 + ], + [ + "B", + 119, + 114, + 0 + ], + [ + "B", + 120, + 114, + 0 + ], + [ + "B", + 121, + 114, + 0 + ], + [ + "B", + 122, + 114, + 0 + ], + [ + "B", + 123, + 114, + 0 + ], + [ + "B", + 124, + 114, + 0 + ], + [ + "B", + 125, + 114, + 0 + ], + [ + "B", + 126, + 114, + 0 + ], + [ + "B", + 127, + 114, + 0 + ], + [ + "B", + 128, + 114, + 0 + ], + [ + "B", + 129, + 114, + 0 + ], + [ + "B", + 130, + 114, + 0 + ], + [ + "B", + 131, + 114, + 0 + ], + [ + "B", + 132, + 114, + 0 + ], + [ + "B", + 133, + 114, + 0 + ], + [ + "B", + 134, + 114, + 0 + ], + [ + "B", + 215, + 114, + 0 + ], + [ + "B", + 216, + 114, + 0 + ], + [ + "B", + 217, + 114, + 0 + ], + [ + "B", + 218, + 114, + 0 + ], + [ + "B", + 219, + 114, + 0 + ], + [ + "B", + 220, + 114, + 0 + ], + [ + "B", + 221, + 114, + 0 + ], + [ + "B", + 222, + 114, + 0 + ], + [ + "B", + 223, + 114, + 0 + ], + [ + "B", + 224, + 114, + 0 + ], + [ + "B", + 225, + 114, + 0 + ], + [ + "B", + 226, + 114, + 0 + ], + [ + "B", + 227, + 114, + 0 + ], + [ + "B", + 228, + 114, + 0 + ], + [ + "B", + 229, + 114, + 0 + ], + [ + "B", + 230, + 114, + 0 + ], + [ + "B", + 231, + 114, + 0 + ], + [ + "B", + 232, + 114, + 0 + ], + [ + "B", + 233, + 114, + 0 + ], + [ + "B", + 683, + 114, + 0 + ], + [ + "B", + 684, + 114, + 0 + ], + [ + "B", + 685, + 114, + 0 + ] + ], + "hyperplane_functional": 1, + "paid": { + "1": 2183, + "2": 416, + "3": 507, + "4": 135, + "5": 40, + "8": 8 + }, + "helpers": { + "4": 28, + "7": 5, + "8": 38, + "9": 337 + } +} diff --git a/research/hyperplane-retiming/PROOF.md b/research/hyperplane-retiming/PROOF.md new file mode 100644 index 0000000000..5a75801743 --- /dev/null +++ b/research/hyperplane-retiming/PROOF.md @@ -0,0 +1,64 @@ +# Coordinated contact frames and the complete invoice + +Prepared by Cinna Davis with substantial OpenAI Codex assistance. Apache-2.0. + +## Exact changed supplier + +The predecessor is the round-two word `research/warp-interface-20261022/ACTUAL-WORD.json.gz` in Cao Yifan's PR4610, head `1eb8da6cfb35512c0cc2533413e5ca42f48e13c6`. The same head also contains a stronger round-three word, used by #4635; this package does not supersede it. The pinned round-two actual word, including unchanged native maps and main endpoint adapters, is frozen byte for byte. PR4470 and its credited predecessor chain supply the independent-helper/controller contract. PR4654's chart grammar motivates coordinated changes; its changed seven-axis main interface is not substituted here. + +Let C_U be the retained canonical gauge for binary subspace U. At a shared scalar contact, every operand has the same C_U. A physical transport is exactly C_V C_U^-1. Replace 49 contacts whose original frame is the line with registry ID 114 by the zero frame, and change the 13 helper entrances listed in PATCH.json from the same line to zero. These changes are one coherent connected component of the contact graph. All main endpoints, all helper exits, scalar opcodes/order/coefficients, shared logical native warps, main adapters and owned center instructions stay fixed. + +Gauge telescoping preserves the logical word. The retained exact free-group-algebra replay checks all arbitrary persistent input columns: the logical helper block is identity, its cross blocks to/from the main fields vanish, and the main block is the retained shear. Thus a changed helper entrance does not inject its arbitrary input into a main output. A helper input is interpreted through its actual entrance gauge; it is never assumed prepared or zero. Its productive job is the complete relative operator C_final C_start^-1, with fresh whole-job monomial normalizers, including absolute phase. + +This argument holds at every fiber width: evaluate the unchanged free-group identity in the actual native operators at that width, and tensor each explicitly lowered gauge identity independently over the digit columns. It does not assume tensor powers preserve sums. No missing main chart is quotiented away. The physical centers still cost eight rank-eight calls, using the same owned clear/copy protocol. + +Both retained interpreters reconstruct all 632 arbitrary persistent columns in both orientations. The backward physical operations are checked with their actual conjugate lowerings, rather than inferred from forward rank counts. Every new paid frame pair and all 13 changed helper boundary operators are independently lowered with exact tableaux and zero-state absolute phase. + +## Why coordinated changes are searchable by a minimum cut + +Fix any ambient subspace H and allow each chronological contact or endpoint U to use either U or U intersect H. Write a_U=dim U-dim(U intersect H), and s_U in {0,1} for that choice. Freeze the main and owned-instruction boundary gauges. Keep the original logical native maps, and require each actual warp to remain monomial. + +For an original nested paid edge U contained in V of rank r, the new rank is + + r + a_U s_U - a_V s_V. + +If a_U>0, nesting forces s_V<=s_U. On the three allowed assignments (0,0), (1,0), (1,1), its incremental paid moment is exactly the linear expression + + [f(r+a_U)-f(r)] s_U + + [f(r+a_U-a_V)-f(r+a_U)] s_V, + +where f(r)=r^t and f(0)=0. If a_U=0, only the second switch matters, with incremental cost f(r-a_V)-f(r). A productive helper edge has the negative of this expression, retaining strictly positive productive rank. + +For a fixed logical native warp G:U->V, either both reduced subspaces satisfy G(U intersect H)=V intersect H and the two switches agree, or the nontrivial switches are forbidden. If one endpoint is unchanged by intersection, only the other nontrivial switch is forbidden. These are equality or fixed-zero constraints. + +The total energy is therefore a sum of unary weights with hard binary implications, equalities and fixed values. It is a minimum-weight closure problem and has an s-t cut realization. Algebraic powers need exact enclosures for certified signs; floating min-cut discovery is not an exact optimality certificate. The admitted result is the explicit patch, independently replayed with outward rational arithmetic. + +Zero-length chronological edges must be represented when the search permits them to become paid. Contracting them is a smaller legitimate search family, not the complete contact search. The first successful search used that smaller family. Subsequent exploration permits new paid transitions. No global ceiling or completeness claim is made for these bounded searches. + +The dual construction U -> U+W has the same reduction: interchange the direction of the implications and use the corresponding dimension increments. Higher-dimensional H or W remains a fixed common choice in each minimum-cut instance; this is not optimization over arbitrary unrelated subspaces at every node. + +## Exact complete moment + +The predecessor has + + P_old={1:2201,2:412,3:506,4:135,5:36,8:8} + H_old={4:28,7:7,8:47,9:326}. + +The new supplier has + + P_new={1:2183,2:416,3:507,4:135,5:40,8:8} + H_new={4:28,7:5,8:38,9:337}. + +Both rank masses increase by 13. All 408 helper inputs remain independent and productive, once each. The exact improvement in productive minus paid moment is + + 18 - 4*2^t - 3^t - 4*5^t - 2*7^t - 9*8^t + 11*9^t. + +The verifier proves this positive at t=1-.0030216 and t=1-.004 using rational outward enclosures. It does not infer positivity at every exponent from these two points. + +Insert the supplier into the unchanged p16 controller: 18 full local calls, 15 query-only calls, all retained prefix/suffix idles, and exactly the original main Gaussian targets. The entire rank surplus remains 752. The changed raw characteristic crossing is strictly between .0030216758 and .0030216759. Both signs are outward-rational, and all changed paid/helper terms appear in the invoice. + +## Finite/compiler and outer arithmetic + +price_profile.py is a scoped adaptation of Cao Yifan's PR4610 arithmetic, retaining zxv's moment/completion bounds and Jacob Alan Sussman's integer mixed-job flow. It reads the immutable literal p16 controller, derives the entire invoice, checks a second independently implemented rational power engine, both paid and productive-completion tails, fixed routing/scalar allowances, finite logarithm absorption, ordinary BIT stock, and all 54 strict plus four functional outer predicates. Four unsupported parameter changes are rejected. + +At claimed saving .00302166 the tested moment uses .00302167. The finite integer height and program are represented by explicit bounds; an enormous uniform word is not materialized. These arithmetic checks support a conditional construction under the retained physical/native, finite compiler, precision/tape, analytic and recovery assumptions. They are not independent acceptance of those hypotheses, an unconditional theorem, or a selected-frontier update. No human proof review is claimed. diff --git a/research/hyperplane-retiming/README.md b/research/hyperplane-retiming/README.md new file mode 100644 index 0000000000..8d3e819b76 --- /dev/null +++ b/research/hyperplane-retiming/README.md @@ -0,0 +1,32 @@ +# Coordinated hyperplane retiming improves the native supplier + +Prepared by Cinna Davis with substantial OpenAI Codex assistance. Apache-2.0. + +A coordinated change to 49 scalar-contact frames and 13 arbitrary helper entrances improves the **round-two word** in Cao Yifan's PR4610. The exact p16 raw crossing increases from about **0.00302155515** to **(0.0030216758, 0.0030216759)**. Fresh native/phase checks and a finite/compiler/outer arithmetic replay support **conditional κ = 0.00302166**, versus that round's .00302152 under the retained assumptions. This is a small improvement, not the requested large bottleneck breakthrough. **This is not the pending frontier:** #4610 also contains a newer round-three word, priced at conditional κ=.0030217754 in #4635. The frozen source used here is `research/warp-interface-20261022/ACTUAL-WORD.json.gz`, not `research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz`. SEARCH.md records the completed rebound: 511 one-direction cuts and 3,449 sampled higher-codimension cuts, including shared-map and owned-center changes, found no profitable candidate in that restricted family. Optional discovery code and the exact newer input are preserved. + +The new local paid census is `{1:2183,2:416,3:507,4:135,5:40,8:8}`. Independent helper jobs are `{4:28,7:5,8:38,9:337}`. Both local rank masses increase by 13; the whole p16 rank surplus stays 752. The gain comes from a better distribution under the concave moment, not additional rank surplus. + +The construction preserves the actual full eight-axis main endpoint, every scalar opcode/order/coefficient, shared native map, eight paid rank-eight centers and owned clear/copy lifetime. Every helper input remains arbitrary. It does not insert the changed seven-axis quotient interface into the old controller. + +## Reproduce + +```sh +python3.12 -B scripts/research_package.py --package research/hyperplane-retiming +python3.12 -I -O -B research/hyperplane-retiming/verify.py +``` + +The package uses only Python's standard library for admission. The optimized caller respawns with inherited assertions enabled. The replay reconstructs both words, checks all 632 arbitrary columns with both retained interpreters, verifies 11 changed paid frame pairs and 13 helper normalizers in both orientations with absolute phase, and proves exact moment/root signs. Wrong paid rank and wrong global phase are rejected. The arithmetic command reruns both rational moment engines, finite tail/completion/compiler bounds, and all 58 outer predicates with four rejecting controls. Frozen native inputs and the minimal source closure are vendored unchanged and authenticated before loading. + +PROOF.md gives the all-fiber gauge-telescoping argument and a new minimum-cut reduction for a fixed common subspace deletion or extension. The original successful cut kept formerly zero paid edges at zero; later searches permit them to become paid. Bounded floating discovery is not trusted for acceptance or claimed as a universal optimum. + +## Evidence boundary + +The selected repository record remains κ=.00302015. The result retains the source physical/native, compiler, precision/tape, analytic and recovery hypotheses. The huge finite uniform word is bounded, not materialized. This is neither an unconditional multiplication theorem nor independent human proof review. The exact receipts are RESULT.json and ARITHMETIC.json; source provenance is in SOURCES.json, ORIGINS.json and ARITHMETIC-ORIGINS.json. + +## Open next questions + +1. Compound coordinated cuts while allowing new paid transitions, then replay the entire supplier. +2. Change native maps together with the common subspace; fixed-map searches can miss profitable invariant planes. +3. Find a center or controller change that materially improves the rank surplus rather than only redistributing it. + +Credit Cao Yifan's #4610 changed-map supplier, Cinna Davis's #4470 lineage, Dugongue's #4654 chart grammar, zxv, Jacob Alan Sussman and all retained scalar/native/Clifford/compiler sources. No novelty priority is claimed for classical minimum-cut or binary subspace facts. diff --git a/research/hyperplane-retiming/RESULT.json b/research/hyperplane-retiming/RESULT.json new file mode 100644 index 0000000000..8e37c4e5d3 --- /dev/null +++ b/research/hyperplane-retiming/RESULT.json @@ -0,0 +1,3966 @@ +{ + "changed_contacts": 49, + "changed_helper_entrances": 13, + "changed_helper_phase_normalizers": [ + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 472 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 538 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 560 + }, + { + "input": 0, + "output": 285, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + } + }, + "role": 561 + }, + { + "input": 0, + "output": 285, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + } + }, + "role": 584 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 602 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 603 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 604 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 605 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 628 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 629 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 630 + }, + { + "input": 0, + "output": 1, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "role": 631 + } + ], + "controls": [ + "false_paid_rank_rejected", + "wrong_absolute_phase_rejected" + ], + "helpers": { + "4": 28, + "7": 5, + "8": 38, + "9": 337 + }, + "local_strict_gain": [ + { + "C": "3777/1250000", + "gain_lower": "10409885808734532496791766386292259977292572344482695793/6277101735386680763835789423207666416102355444464034512896" + }, + { + "C": "1/250", + "gain_lower": "14442036510168726553934318812703115069929597232603202131/6277101735386680763835789423207666416102355444464034512896" + } + ], + "native": { + "backward": { + "arbitrary_persistent_columns": 632, + "max_formal_prefix_l1": "169", + "real_scalar_allowance": 158168 + }, + "forward": { + "arbitrary_persistent_columns": 632, + "max_formal_prefix_l1": "457", + "real_scalar_allowance": 158120 + } + }, + "new_kappa": null, + "new_paid_phase_pairs": [ + { + "input": 0, + "output": 311, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 3, + 45, + 73, + 133, + 8, + 4, + 269, + 13 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 15, + 6, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 2, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 257, + 503, + 495, + 259, + 260, + 328, + 304, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 27, + 231, + 230, + 337, + 297, + 246, + 238, + 230, + 24 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 3, + 45, + 73, + 133, + 8, + 4, + 269, + 13 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 15, + 6, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 2, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 257, + 503, + 495, + 259, + 260, + 328, + 304, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 27, + 231, + 230, + 337, + 297, + 246, + 238, + 230, + 24 + ] + } + } + } + }, + { + "input": 0, + "output": 419, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 258, + 19, + 289, + 34, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 307, + 305, + 0, + 0, + 307, + 19, + 0, + 0, + 19 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 258, + 19, + 289, + 34, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 307, + 305, + 0, + 0, + 307, + 19, + 0, + 0, + 19 + ] + } + } + } + }, + { + "input": 0, + "output": 421, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 0, + 2 + ], + "matrix_rows": [ + 19, + 324, + 33, + 34, + 260, + 8, + 48, + 320, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 0, + 2 + ], + "matrix_rows": [ + 19, + 324, + 33, + 34, + 260, + 8, + 48, + 320, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + } + } + }, + { + "input": 0, + "output": 540, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 19, + 200, + 33, + 34, + 4, + 136, + 48, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 0, + 72, + 51, + 19, + 72, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 19, + 200, + 33, + 34, + 4, + 136, + 48, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 72, + 51, + 19, + 72, + 0, + 0 + ] + } + } + } + }, + { + "input": 0, + "output": 541, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 32, + 67, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 144, + 19, + 161, + 162, + 4, + 8, + 48, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 179, + 179, + 0, + 0, + 163, + 19, + 0, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 32, + 67, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 2, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 144, + 19, + 161, + 162, + 4, + 8, + 48, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 179, + 179, + 0, + 0, + 163, + 19, + 0, + 19, + 0 + ] + } + } + } + }, + { + "input": 0, + "output": 617, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 2, + 0, + 2, + 0 + ], + "matrix_rows": [ + 19, + 257, + 140, + 33, + 290, + 132, + 136, + 304, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 306, + 307, + 12, + 12, + 307, + 19, + 0, + 0, + 19 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 1, + 2, + 0, + 2, + 0 + ], + "matrix_rows": [ + 19, + 257, + 140, + 33, + 290, + 132, + 136, + 304, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 306, + 307, + 12, + 12, + 307, + 19, + 0, + 0, + 19 + ] + } + } + } + }, + { + "input": 0, + "output": 632, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 258, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 0, + 2, + 1, + 0, + 2 + ], + "matrix_rows": [ + 144, + 328, + 19, + 161, + 162, + 4, + 264, + 48, + 320 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 179, + 179, + 0, + 72, + 163, + 19, + 72, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 258, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 2, + 2, + 3, + 0, + 2 + ], + "matrix_rows": [ + 144, + 328, + 19, + 161, + 162, + 4, + 264, + 48, + 320 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 179, + 179, + 0, + 72, + 163, + 19, + 72, + 19, + 0 + ] + } + } + } + }, + { + "input": 0, + "output": 633, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 258, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 0, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 272, + 200, + 19, + 289, + 290, + 4, + 136, + 48, + 192 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 307, + 307, + 0, + 72, + 291, + 19, + 72, + 0, + 19 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 258, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 2, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 272, + 200, + 19, + 289, + 290, + 4, + 136, + 48, + 192 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 307, + 307, + 0, + 72, + 291, + 19, + 72, + 0, + 19 + ] + } + } + } + }, + { + "input": 0, + "output": 759, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 70, + 132, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 1, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 322, + 205, + 222, + 97, + 290, + 260, + 264, + 368, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 173, + 188, + 275, + 275, + 446, + 19, + 0, + 275, + 412 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 70, + 132, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 322, + 205, + 222, + 97, + 290, + 260, + 264, + 368, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 173, + 188, + 275, + 275, + 446, + 19, + 0, + 275, + 412 + ] + } + } + } + }, + { + "input": 0, + "output": 821, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 1, + 3, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 53, + 54, + 392, + 33, + 18, + 52, + 264, + 64, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 21, + 38, + 51, + 136, + 53, + 54, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 1, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 53, + 54, + 392, + 33, + 18, + 52, + 264, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 21, + 38, + 51, + 136, + 53, + 54, + 0, + 136, + 0 + ] + } + } + } + }, + { + "input": 0, + "output": 1551, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 54, + 69, + 131, + 8, + 17, + 2, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 22, + 21, + 19, + 0, + 23, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 1, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 246, + 245, + 243, + 8, + 257, + 273, + 290, + 324, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 23, + 293, + 323, + 0, + 497, + 498, + 500, + 496, + 246 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 54, + 69, + 131, + 8, + 17, + 2, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 22, + 21, + 19, + 0, + 23, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 3, + 3, + 3, + 1, + 0 + ], + "matrix_rows": [ + 246, + 245, + 243, + 8, + 257, + 273, + 290, + 324, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 23, + 293, + 323, + 0, + 497, + 498, + 500, + 496, + 246 + ] + } + } + } + } + ], + "paid": { + "1": 2183, + "2": 416, + "3": 507, + "4": 135, + "5": 40, + "8": 8 + }, + "rank_surplus": 752, + "raw_crossing": [ + "15108379/5000000000", + "30216759/10000000000" + ], + "raw_lower_margin": "40162449197868194034946214437677965030608301414941493/3138550867693340381917894711603833208051177722232017256448", + "raw_upper_margin": "-37431642074523192881100155504251646824397794805723391/3138550867693340381917894711603833208051177722232017256448", + "scope": "Exact local supplier, all-fiber gauge proof, complete p16 raw moment. Finite/compiler, precision and outer admission remain separate.", + "status": "PASS_COORDINATED_HYPERPLANE_NATIVE_PHASE_MOMENT", + "whole_paid": { + "1": 40974, + "2": 7488, + "3": 9126, + "4": 2430, + "5": 720, + "8": 144, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "whole_targets": { + "4": 504, + "7": 90, + "8": 684, + "9": 6066, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + } +} diff --git a/research/hyperplane-retiming/SEARCH-ORIGINS.json b/research/hyperplane-retiming/SEARCH-ORIGINS.json new file mode 100644 index 0000000000..5f4ab6a16d --- /dev/null +++ b/research/hyperplane-retiming/SEARCH-ORIGINS.json @@ -0,0 +1,8 @@ +{ + "latest_word": { + "path": "inputs/pr4610-round3-word.json.gz", + "source": "head:1eb8da6cfb35512c0cc2533413e5ca42f48e13c6:research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + "discovery": "Own minimum-cut code; classical maximum closure and two-subspace simultaneous transport. SciPy is used only for discovery, never admission." +} diff --git a/research/hyperplane-retiming/SEARCH.json b/research/hyperplane-retiming/SEARCH.json new file mode 100644 index 0000000000..d29e215e37 --- /dev/null +++ b/research/hyperplane-retiming/SEARCH.json @@ -0,0 +1,30 @@ +{ + "arithmetic": "Floating power discovery and integer-capacity cuts; rank-one capacities use adaptive precision with hard constraints funded above the all-zero cut. The higher-codimension run used a fixed 100000 scale. No exact optimality or impossibility claim.", + "code_sha256": { + "search/center_model.py": "14a8877a3733ca6029d554eb72b3b5a4ff9a2931207f83282075d4f5a54929e2", + "search/graph.py": "0759cccb4b0122abd656f15dd9e6f7db662a7d8634c6e2f7465c35140df7b66d", + "search/joint_cut.py": "9d67ab08e3bc9ca5edc31e8ccc8f7b9052d01b845bf0bcee948ebcefcd33d013", + "search/multi_cut.py": "cb520049923a4909ce3fc561c8663bc56b16994acc2fd703de2305c62e1c08a3", + "search/multi_joint.py": "70ccf725d7eca33defc013b9489398856f6788c13ac64745333822d5003787b5", + "search/quotient_cut.py": "5fe59394a17bfdd15ee65c19e30fb3ad441edce875fbd4e41e7a2e73f31f338e" + }, + "constraints": "One common kernel per instance; all scalar opcodes/order fixed; actual main endpoints fixed; old full-dimension warp gauges fixed; all shared line/late native subspace pairs satisfy the two-subspace incidence condition; owned center gauges may move coherently.", + "discovery_environment": { + "python": "3.14", + "scipy": "1.18.1" + }, + "higher_codimension_cases": { + "2": 2937, + "3": 512 + }, + "observed_profitable_cuts": 0, + "rank_one_joint_map_center_cuts": 511, + "scope": "No improved round-three candidate found in these bounded families. The admitted positive PATCH/RESULT/ARITHMETIC remain the explicitly identified older round-two construction.", + "source": { + "path": "inputs/pr4610-round3-word.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "source": "head:1eb8da6cfb35512c0cc2533413e5ca42f48e13c6:research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz" + }, + "status": "BOUNDED_FLOATING_DISCOVERY_NO_NEW_FRONTIER", + "t": ".9969782" +} diff --git a/research/hyperplane-retiming/SEARCH.md b/research/hyperplane-retiming/SEARCH.md new file mode 100644 index 0000000000..785f2780c4 --- /dev/null +++ b/research/hyperplane-retiming/SEARCH.md @@ -0,0 +1,22 @@ +# Newest-word discovery checkpoint + +The admitted positive construction in this package uses the explicitly pinned **round-two** word. The source head also contains Cao Yifan's stronger round-three word. Confusing those two artifacts would overstate the contribution. SEARCH-ORIGINS.json pins the latter independently; #4635 proposes conditional κ=.0030217754 from it. This package does not claim a frontier increase. + +The optional discovery code uses the newest word and explores fixed common kernels while retaining the actual main ABI. It includes every chronological zero-length bridge, allowing it to become paid. Owned center source/scatter gauges can move coherently; their complete new rank is included. Full-dimension warp gauges are kept fixed. + +The shared native maps may change jointly. A pair of subspace contracts A->B and U->V can be realized by one invertible map exactly when their two dimensions and intersection dimension agree. Extend an intersection basis first to A and U, then to the ambient space; match the corresponding target basis. This constructs the map. The retained two-contract operators have one line contract and one late subspace contract. Under a common kernel deletion, a line is either unchanged or zero. Matching deletion dimensions gives switch equalities or fixed-zero constraints. If the retained line is inside the late subspace and only one of its two representatives lies in the kernel, a late deletion is forbidden. The other cases preserve incidence automatically. Repeated occurrences of the same line contract are consistent because deleting it adds only the zero-subspace contract. + +Thus this restricted shared-map family still reduces to minimum-weight closure, rather than pricing each occurrence with a different incompatible G. An observed positive cut would require emission of the actual common maps, fresh all-column/phase replay, and the entire compiler/outer bill before admission. + +The fresh bounded screen observed no profitable cut among 511 rank-one common kernels, 2,937 rank-two kernels and 512 rank-three kernels. Rank-two cases combine actual two-dimensional source frames with a seeded sample; they are not all 43,435 planes. The powers and capacities are discovery approximations. Rank-one capacities are adaptively scaled and every hard implication is funded above the feasible all-zero cut; SciPy's int32 edge-capacity limit is checked. Higher-codimension discovery used scale 100,000. These searches are neither exact ceilings nor an impossibility proof, and can miss very small gains. + +With SciPy installed, the separate optional searches are: + +```sh +python3 -B research/hyperplane-retiming/search/joint_cut.py +python3 -B research/hyperplane-retiming/search/multi_joint.py +``` + +They write ignored discovery outputs beside their scripts. Admission in VERIFY.json requires only the standard library and does not execute these searches. SEARCH.json binds the code, input, case counts and precise evidence boundary. No new native candidate is admitted from this screen. + +Next useful variations are arbitrary changed prelude line directions rather than only common-kernel deletions, moving formerly full-dimension warp gauges with their additional simultaneous-subspace constraints, a different scalar chronology, or a changed owned-center recipe. The current result does not exclude them. diff --git a/research/hyperplane-retiming/SOURCES.json b/research/hyperplane-retiming/SOURCES.json new file mode 100644 index 0000000000..d61cd2152b --- /dev/null +++ b/research/hyperplane-retiming/SOURCES.json @@ -0,0 +1,186 @@ +{ + "schema_version": 1, + "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/hyperplane-retiming/inputs/pr4610-word.json.gz", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/inputs/pr4610-word.json.gz", + "git_blob": "79dad65b9c9bd05956183492090d5439a269fc08", + "sha256": "d578875344095047c383ef513e69b9deb9d99d2b75abe14f7359d06365a924ac" + }, + { + "path": "research/hyperplane-retiming/PATCH.json", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/PATCH.json", + "git_blob": "bdd92a91da79023f019510b85463a06aa2586bf4", + "sha256": "096c50328169dc865c08878fe6d67cc1b8c0415c71bfa1f936079e069a21c147" + }, + { + "path": "research/hyperplane-retiming/intervals.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/intervals.py", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/hyperplane-retiming/ORIGINS.json", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/ORIGINS.json", + "git_blob": "718508db9827c3fa848b9a576dabc66cd4a66395", + "sha256": "e98baa48430d79ed7e7713ace35d79f0e9a975df2e98e1dd11fcb7005404943b" + }, + { + "path": "research/hyperplane-retiming/vendor/research/fresh-helper-boundary/CHANGES.json", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/fresh-helper-boundary/CHANGES.json", + "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624" + }, + { + "path": "research/hyperplane-retiming/vendor/research/fresh-helper-boundary/native.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/fresh-helper-boundary/native.py", + "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29" + }, + { + "path": "research/hyperplane-retiming/vendor/research/joint-helper-lattice/PATCH.json", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/joint-helper-lattice/PATCH.json", + "git_blob": "51304a6601061ed4e698f910b09135ef109555e3", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727" + }, + { + "path": "research/hyperplane-retiming/vendor/research/joint-helper-lattice/native_joint.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/joint-helper-lattice/native_joint.py", + "git_blob": "0315f80e2fdef5e0eef13e3e9b8f72066238164d", + "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-function-composition/complex/prune_native.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-function-composition/complex/prune_native.py", + "git_blob": "8c3e11b2408fa96eefa3ebe7952d1b11b90b772b", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/native_extensions.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/native_extensions.py", + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/power_two_balance.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/power_two_balance.py", + "git_blob": "a55ae0ce78a1861965f899a82604b276260f636c", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "path": "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/rebuild_native.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/rebuild_native.py", + "git_blob": "78a7b1b0e6e43a1347fb361f45c6e0eaff8dd27b", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "path": "research/hyperplane-retiming/vendor/research/missing-join-frame/PATCH.json", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/missing-join-frame/PATCH.json", + "git_blob": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e" + }, + { + "path": "research/hyperplane-retiming/vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "pin": "head:b77d279a72fe195a2dc945201a9723f805a451b8:research/hyperplane-retiming/vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/hyperplane-retiming/inputs/bit-stock.json", + "usage": "input", + "pin": "head:f26c1166e12dd45dff2cfed9b00eec1e42507389:research/hyperplane-retiming/inputs/bit-stock.json", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f" + }, + { + "path": "research/hyperplane-retiming/inputs/p16-controller.json", + "usage": "input", + "pin": "head:f26c1166e12dd45dff2cfed9b00eec1e42507389:research/hyperplane-retiming/inputs/p16-controller.json", + "git_blob": "49a2f0675819f9deeea27ed77be2c2b6ff2e87e5", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f" + }, + { + "path": "research/hyperplane-retiming/second_intervals.py", + "usage": "input", + "pin": "head:f26c1166e12dd45dff2cfed9b00eec1e42507389:research/hyperplane-retiming/second_intervals.py", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/hyperplane-retiming/outer_ledger.py", + "usage": "input", + "pin": "head:f26c1166e12dd45dff2cfed9b00eec1e42507389:research/hyperplane-retiming/outer_ledger.py", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/hyperplane-retiming/ARITHMETIC-ORIGINS.json", + "usage": "input", + "pin": "head:f26c1166e12dd45dff2cfed9b00eec1e42507389:research/hyperplane-retiming/ARITHMETIC-ORIGINS.json", + "git_blob": "d426d4cc662e72fe6b5aacf4700fb8a1953ebe18", + "sha256": "25e26669a25161c749aaf62525b5c96bf0aa3b82bd58f31ef44cec4618b6e901" + }, + { + "path": "research/hyperplane-retiming/inputs/pr4610-round3-word.json.gz", + "usage": "input", + "pin": "head:1cff01f5b7673c537afa55733729377f8afeb427:research/hyperplane-retiming/inputs/pr4610-round3-word.json.gz", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/hyperplane-retiming/SEARCH-ORIGINS.json", + "usage": "input", + "pin": "head:1cff01f5b7673c537afa55733729377f8afeb427:research/hyperplane-retiming/SEARCH-ORIGINS.json", + "git_blob": "5f4ab6a16d9593cb77da9e583f843572fa75ae2c", + "sha256": "5e71dba985a2d15145c7219b8863ce226267c4f2e52627b9721dc34f7aa0275a" + } + ] +} diff --git a/research/hyperplane-retiming/TASK.json b/research/hyperplane-retiming/TASK.json new file mode 100644 index 0000000000..d8ea0b458f --- /dev/null +++ b/research/hyperplane-retiming/TASK.json @@ -0,0 +1,92 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "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": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "scope_change_reason": "Explicit owner task asks for a much higher kappa. This changes supplier contact and helper gauges using a globally coordinated hyperplane cut, rather than repeating a fixed controller invoice search.", + "bottleneck_link": "A changed complete native paid/helper invoice is the binding input to the retained p16 mixed-target compiler. Coordinating scalar gauges and arbitrary helper entrances produces a strict moment gain while keeping the actual main interface.", + "budget_minutes": 60, + "stop_rule": "Do not promote a discovery objective or raw crossing into a selected or unconditional theorem.", + "outcome": "partial", + "evidence": "RESULT.json and ARITHMETIC.json: native/phase/all-fiber gauge proof, complete p16 moment, finite/compiler and 58 outer arithmetic conditions.", + "author": "Cinna Davis with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for derivation, search, code and verification. No independent human review.", + "open_questions": [ + { + "question": "Can further coordinated moves yield a much larger gain?", + "why_it_matters": "The current improvement changes the distribution but leaves rank surplus 752.", + "first_step": "Allow previously zero bridges to become paid and include joint native-map changes.", + "blocked_by": "No larger admitted candidate yet." + } + ], + "question": "Can coordinated common-subspace changes improve the full native supplier while preserving its real main endpoint?", + "success_criterion": "Reconstruct a changed supplier; check all arbitrary columns, physical phases and its complete moment." +} diff --git a/research/hyperplane-retiming/VERIFY.json b/research/hyperplane-retiming/VERIFY.json new file mode 100644 index 0000000000..0a331429b1 --- /dev/null +++ b/research/hyperplane-retiming/VERIFY.json @@ -0,0 +1,58 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/hyperplane-retiming/inputs/pr4610-word.json.gz", + "research/hyperplane-retiming/PATCH.json", + "research/hyperplane-retiming/intervals.py", + "research/hyperplane-retiming/ORIGINS.json", + "research/hyperplane-retiming/vendor/research/fresh-helper-boundary/CHANGES.json", + "research/hyperplane-retiming/vendor/research/fresh-helper-boundary/native.py", + "research/hyperplane-retiming/vendor/research/joint-helper-lattice/PATCH.json", + "research/hyperplane-retiming/vendor/research/joint-helper-lattice/native_joint.py", + "research/hyperplane-retiming/vendor/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "research/hyperplane-retiming/vendor/research/kappa-function-composition/complex/prune_native.py", + "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/native_extensions.py", + "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/power_two_balance.py", + "research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/rebuild_native.py", + "research/hyperplane-retiming/vendor/research/missing-join-frame/PATCH.json", + "research/hyperplane-retiming/vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/hyperplane-retiming/inputs/bit-stock.json", + "research/hyperplane-retiming/inputs/p16-controller.json", + "research/hyperplane-retiming/second_intervals.py", + "research/hyperplane-retiming/outer_ledger.py", + "research/hyperplane-retiming/ARITHMETIC-ORIGINS.json", + "research/hyperplane-retiming/inputs/pr4610-round3-word.json.gz", + "research/hyperplane-retiming/SEARCH-ORIGINS.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "All 632 arbitrary columns in both orientations, all changed paid/helper Clifford absolute phases, exact complete moment and rank/phase rejection controls" + }, + { + "argv": [ + "{python}", + "-B", + "{package}/price_profile.py", + "--native", + "{package}/RESULT.json", + "--kappa", + ".00302166", + "--out", + "{package}/ARITHMETIC.json" + ], + "timeout_seconds": 180, + "checks": "Two rational moment engines, complete p16 invoice, funded finite compiler and 54 strict plus four functional outer predicates, with four rejection controls" + } + ] +} diff --git a/research/hyperplane-retiming/inputs/bit-stock.json b/research/hyperplane-retiming/inputs/bit-stock.json new file mode 100644 index 0000000000..e0695152c9 --- /dev/null +++ b/research/hyperplane-retiming/inputs/bit-stock.json @@ -0,0 +1,356 @@ +{ + "bit_invoice": { + "main": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 25479, + "14": 444, + "2": 24156, + "21": 444, + "28": 444, + "3": 1422, + "35": 444, + "4": 792, + "42": 444, + "49": 444, + "5": 1836, + "56": 444, + "6": 198, + "63": 222, + "7": 342 + }, + "paid_calls": 57555, + "productive_fields": 11454, + "rank_surplus": 753, + "raw_scalar_record_bound": 1000000000, + "targets": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "8": 7902 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1665, + "whole_idle": { + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + } + }, + "bit_strictification": { + "alpha": { + "lower": "0.999995735238059506641600561767", + "upper": "0.999995735238059506641600561768" + }, + "compiler_H0": 3755884544, + "cutoff_base": 17, + "delta": { + "lower": "0.949707924144871179442776557218", + "upper": "0.949707924144871179442776557219" + }, + "gamma": { + "lower": "0.957429821066420278606254392110", + "upper": "0.957429821066420278606254392111" + }, + "normalized_surplus_lower": "68719461047/16845935476736", + "tail_exponent": "1/5", + "target_floor_base": 18, + "tensor_power": 1024, + "tested_saving": "173/50000", + "uniform_H1": 25986965159937, + "uniform_N": "2^25986965159937", + "uniform_saving": "3459/1000000", + "winning_word_materialized": false + }, + "complex_invoice": { + "main": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 49045, + "16": 448, + "2": 13547, + "24": 448, + "3": 4256, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 380, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 72902, + "productive_fields": 11560, + "rank_surplus": 800, + "raw_scalar_record_bound": 1000000000, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "5": 532, + "57": 448, + "6": 342, + "65": 448, + "7": 1064, + "73": 448, + "8": 1767, + "9": 4047 + }, + "thick_calls": 19, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "thin_queries": 1792, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + } + }, + "complex_strictification": { + "alpha": { + "lower": "0.999999952117240859760145478345", + "upper": "0.999999952117240859760145478346" + }, + "compiler_H0": 75415467350, + "cutoff_base": 20, + "delta": { + "lower": "0.941649713484853845388929204840", + "upper": "0.941649713484853845388929204841" + }, + "gamma": { + "lower": "0.967466409565147920980822933859", + "upper": "0.967466409565147920980822933860" + }, + "normalized_surplus_lower": "8589700209/251666829934592", + "tail_exponent": "1/5", + "target_floor_base": 21, + "tensor_power": 1024, + "tested_saving": "29603/10000000", + "uniform_H1": 10418370291022217, + "uniform_N": "2^10418370291022217", + "uniform_saving": "103609/35000000", + "winning_word_materialized": false + }, + "kappa": "37/12500", + "minimum_outer_margin_minus_kappa": "629378373/4900000000000000", + "native": { + "binary_charts": 111, + "complex_contacts_and_inverses": 896, + "owned_stream_restored_zero": true, + "thin_paid_rank_per_port": 1, + "thin_productive_credit": 0 + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform_gap": [ + "new_complex_uniform_saving_above_b" + ], + "missing_layout": [ + "positive_layout_slack" + ], + "old_BIT_cap": [ + "actual_bit_above_effective" + ], + "unfunded_kappa": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "old_atom_rejected": true, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "17429997759/17500000000", + "fixed_halo_explicit_metadata_branch": "1347500003/17500000", + "new_BIT_row_stock_sublinear_in_active_group": "69789991027/70000000000", + "new_semantic_group_guard": "9/70000000" + }, + "margins": { + "boundary_algebraic_matrix": "14504839378373/4900000000000000", + "fused_gaussian": "14504838135119/4900000000000000", + "global_coordinate_router": "51803/17500000", + "group_bit_router": "3626262033773/1225000000000000", + "group_scans": "34999997/35000000", + "main_transform": "14504629378373/4900000000000000", + "microbox_face_corrections": "1347500003/17500000", + "polynomial_products": "69999997/70000000", + "sparse_union_movement": "2005129839378373/4900000000000000" + }, + "parameters": { + "a": "51803/17500000", + "b": "41443/14000000", + "beta": "69999991/70000000", + "bit_saving": "17/5000", + "cap_xi": "4455129629378373/4900000000000000", + "complex_uniform_saving": "103609/35000000", + "d": "3/70000000", + "epsilon": "69999997/70000000", + "kappa": "37/12500", + "lambda_": "19940797/20000000", + "lambda_prime": "69792791/70000000", + "layout": "3/70000000", + "q": "207209/70000000", + "r0": "3/700000000", + "stop": "3/70000000", + "tested_saving": "29603/10000000" + }, + "strict_checks": { + "actual_bit_above_effective": "7697/17500000", + "actual_logarithmic_gamma_guard": "3/70000000", + "actual_logarithmic_group_guard": "444870685621627/2450000000000000", + "alpha_logarithm_absorption": "3/700000000", + "boundary_algebraic_matrix_above_kappa": "839378373/4900000000000000", + "cap_above_band": "2005129629378373/4900000000000000", + "cap_below_cell": "444870160621627/4900000000000000", + "cap_below_phase_cell_power": "5344870370621627/4900000000000000", + "complex_above_effective": "3/70000000", + "complex_below_one_over_32": "396057/14000000", + "complex_endpoint": "3/35000000", + "epsilon_below_one": "3/70000000", + "epsilon_positive": "69999997/70000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "838135119/4900000000000000", + "gaussian_above_main": "104378373/2450000000000000", + "global_coordinate_router_above_kappa": "3/17500000", + "global_gamma_power_slack": "27/700000000", + "group_below_dimension": "3/35000000", + "group_bit_router_above_kappa": "262033773/1225000000000000", + "group_gauge_power_slack": "444870675121627/2450000000000000", + "group_key_fits_record": "3/35000000", + "group_positive": "69999991/70000000", + "group_scans_above_kappa": "34896397/35000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "614514790400418148631/500000000000000000000000", + "lambda_above_internal": "3/140000000", + "lambda_above_sigma": "9/140000000", + "lambda_above_tau": "3/140000000", + "lambda_prime_above_lambda": "3/140000000", + "lambda_prime_above_leaf": "83875671/980000000000000", + "leaf_saving_above_effective": "41875671/980000000000000", + "main_transform_above_kappa": "629378373/4900000000000000", + "membership_arithmetic_fits_record": "3/70000000", + "microbox_face_corrections_above_kappa": "1347448203/17500000", + "microbox_halo_volume": "5530000009/70000000", + "new_complex_uniform_saving_above_b": "3/70000000", + "new_semantic_guard_with_C1_one": "3/70000000", + "polynomial_products_above_kappa": "69792797/70000000", + "positive_layout_slack": "3/70000000", + "q_below_effective": "3/70000000", + "q_below_internal": "3/70000000", + "q_below_leaf": "83875671/980000000000000", + "q_positive": "207209/70000000", + "short_record_fallback": "13958557/14000000", + "source_axis_superpolynomial": "3/70000000", + "sparse_union_movement_above_kappa": "1990625839378373/4900000000000000", + "stop_below_one": "69999997/70000000", + "stop_positive": "3/70000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "9/70000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "9/70000000", + "union_tag_work_per_visit_fits_record": "9/70000000" + } + }, + "relative_gain_over_p7": "27353/268647", + "schema": "query-thinned-productive-controllers/1", + "scope": "Conditional native construction; all-column, erasure, whole-job matching, fixed-tape, precision, analytic, prime and exact-recovery premises retained. No unconditional theorem or selected promotion.", + "source_inputs_authenticated": 17, + "status": "PASS_CONDITIONAL_QUERY_THINNED_KAPPA_00296" +} diff --git a/research/hyperplane-retiming/inputs/p16-controller.json b/research/hyperplane-retiming/inputs/p16-controller.json new file mode 100644 index 0000000000..49a2f06758 --- /dev/null +++ b/research/hyperplane-retiming/inputs/p16-controller.json @@ -0,0 +1,5224 @@ +{ + "ambient_rank": 145, + "boundaries": { + "left": [ + [ + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "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", + "1", + "0", + "1", + "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", + "1", + "0", + "1", + "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", + "1", + "0", + "1", + "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", + "1", + "0", + "1", + "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", + "1", + "0", + "1", + "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", + "1", + "0", + "1", + "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", + "1", + "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", + "1" + ], + [ + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "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", + "1", + "0", + "-1", + "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", + "1", + "0", + "-1", + "0", + "1", + "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", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "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", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 29, + 30 + ], + [ + "SWAP", + 28, + 30 + ], + [ + "SWAP", + 27, + 29 + ], + [ + "SWAP", + 26, + 28 + ], + [ + "SWAP", + 25, + 30 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "SWAP", + 23, + 26 + ], + [ + "SWAP", + 22, + 30 + ], + [ + "SWAP", + 20, + 26 + ], + [ + "SWAP", + 19, + 22 + ], + [ + "SWAP", + 18, + 29 + ], + [ + "SWAP", + 17, + 23 + ], + [ + "SWAP", + 16, + 27 + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 31 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 31, + 13, + "1" + ], + [ + "SWAP", + 13, + 30 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "ADD", + 30, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 29 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "ADD", + 29, + 9, + "1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "ADD", + 28, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 27 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "ADD", + 27, + 5, + "1" + ], + [ + "SWAP", + 5, + 26 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "ADD", + 26, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 25 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "ADD", + 25, + 1, + "1" + ], + [ + "SWAP", + 1, + 24 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "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", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "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", + "-1", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "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", + "1", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "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", + "-1", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "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", + "1", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "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", + "-1", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "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", + "1", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "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", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right_program": [ + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "ADD", + 27, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "ADD", + 27, + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "ADD", + 27, + 29, + "-1" + ], + [ + "SCALE", + 29, + "-1" + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "ADD", + 27, + 28, + "-1" + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 31, + 27, + "-1" + ], + [ + "SCALE", + 27, + "-1" + ], + [ + "SWAP", + 27, + 29 + ], + [ + "ADD", + 31, + 26, + "1" + ], + [ + "SWAP", + 26, + 29 + ], + [ + "ADD", + 29, + 25, + "-1" + ], + [ + "ADD", + 24, + 25, + "-1" + ], + [ + "SWAP", + 25, + 28 + ], + [ + "ADD", + 28, + 24, + "1" + ], + [ + "SWAP", + 23, + 29 + ], + [ + "SWAP", + 22, + 25 + ], + [ + "SWAP", + 20, + 23 + ], + [ + "SWAP", + 19, + 25 + ], + [ + "SWAP", + 18, + 27 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 31 + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 30 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 30 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 22 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 30 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 18 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 22 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 26 + ], + [ + "SWAP", + 8, + 30 + ], + [ + "SWAP", + 7, + 16 + ], + [ + "SWAP", + 6, + 18 + ], + [ + "SWAP", + 5, + 20 + ], + [ + "SWAP", + 4, + 22 + ], + [ + "SWAP", + 3, + 24 + ], + [ + "SWAP", + 2, + 26 + ], + [ + "SWAP", + 1, + 28 + ], + [ + "SWAP", + 0, + 30 + ] + ] + }, + "diagonal": [ + [ + -1, + 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, + 1, + 1 + ], + [ + -1, + 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, + 1, + 0, + 1, + 1 + ], + [ + -1, + 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, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 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, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 1, + 1, + 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 + ], + [ + -1, + 1, + 1, + 0, + 1, + 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 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 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 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 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 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 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, + 1, + 1 + ], + [ + 1, + 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, + 1, + 0, + 1, + 1 + ], + [ + 1, + 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, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 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, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 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 + ], + [ + 1, + 1, + 1, + 0, + 1, + 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 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 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 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 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 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ] + ], + "invoice": { + "main": { + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 46446, + "2": 12834, + "3": 4032, + "4": 1836, + "5": 360, + "8": 144, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "paid_calls": 69012, + "productive_fields": 10928, + "rank_surplus": 752, + "raw_scalar_record_bound": 1000000000, + "targets": { + "5": 504, + "6": 324, + "7": 1008, + "8": 1674, + "9": 3834, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1680, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + } + }, + "keep_mask": 35047648968703, + "kind": "complex", + "pairs": 16, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2, + 1 + ], + [ + "ADD", + 3, + 1, + -1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2, + -1 + ], + [ + "ADD", + 3, + 1, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4, + 1 + ], + [ + "ADD", + 5, + 3, + -1 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4, + -1 + ], + [ + "ADD", + 5, + 3, + 1 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6, + 1 + ], + [ + "ADD", + 7, + 5, + -1 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6, + -1 + ], + [ + "ADD", + 7, + 5, + 1 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8, + 1 + ], + [ + "ADD", + 9, + 7, + -1 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8, + -1 + ], + [ + "ADD", + 9, + 7, + 1 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10, + 1 + ], + [ + "ADD", + 11, + 9, + -1 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10, + -1 + ], + [ + "ADD", + 11, + 9, + 1 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12, + 1 + ], + [ + "ADD", + 13, + 11, + -1 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12, + -1 + ], + [ + "ADD", + 13, + 11, + 1 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14, + 1 + ], + [ + "ADD", + 15, + 13, + -1 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14, + -1 + ], + [ + "ADD", + 15, + 13, + 1 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "ADD", + 14, + 16, + 1 + ], + [ + "ADD", + 17, + 15, + -1 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16, + -1 + ], + [ + "ADD", + 17, + 15, + 1 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18, + 1 + ], + [ + "ADD", + 19, + 17, + -1 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18, + -1 + ], + [ + "ADD", + 19, + 17, + 1 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20, + 1 + ], + [ + "ADD", + 21, + 19, + -1 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20, + -1 + ], + [ + "ADD", + 21, + 19, + 1 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22, + 1 + ], + [ + "ADD", + 23, + 21, + -1 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22, + -1 + ], + [ + "ADD", + 23, + 21, + 1 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24, + 1 + ], + [ + "ADD", + 25, + 23, + -1 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24, + -1 + ], + [ + "ADD", + 25, + 23, + 1 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26, + 1 + ], + [ + "ADD", + 27, + 25, + -1 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26, + -1 + ], + [ + "ADD", + 27, + 25, + 1 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28, + 1 + ], + [ + "ADD", + 29, + 27, + -1 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28, + -1 + ], + [ + "ADD", + 29, + 27, + 1 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30, + 1 + ], + [ + "ADD", + 31, + 29, + -1 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30, + -1 + ], + [ + "ADD", + 31, + 29, + 1 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "LOCAL", + 32, + 15, + false + ], + [ + "IDLE", + 7, + [ + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 32 + ] + ], + [ + "ADD", + 30, + 28, + 1 + ], + [ + "ADD", + 29, + 31, + -1 + ], + [ + "ADD", + 28, + 26, + 1 + ], + [ + "ADD", + 27, + 29, + -1 + ], + [ + "ADD", + 26, + 24, + 1 + ], + [ + "ADD", + 25, + 27, + -1 + ], + [ + "ADD", + 24, + 22, + 1 + ], + [ + "ADD", + 23, + 25, + -1 + ], + [ + "ADD", + 22, + 20, + 1 + ], + [ + "ADD", + 21, + 23, + -1 + ], + [ + "ADD", + 20, + 18, + 1 + ], + [ + "ADD", + 19, + 21, + -1 + ], + [ + "ADD", + 18, + 16, + 1 + ], + [ + "ADD", + 17, + 19, + -1 + ], + [ + "ADD", + 16, + 14, + 1 + ], + [ + "ADD", + 15, + 17, + -1 + ], + [ + "ADD", + 14, + 12, + 1 + ], + [ + "ADD", + 13, + 15, + -1 + ], + [ + "ADD", + 12, + 10, + 1 + ], + [ + "ADD", + 11, + 13, + -1 + ], + [ + "ADD", + 10, + 8, + 1 + ], + [ + "ADD", + 9, + 11, + -1 + ], + [ + "ADD", + 8, + 6, + 1 + ], + [ + "ADD", + 7, + 9, + -1 + ], + [ + "ADD", + 6, + 4, + 1 + ], + [ + "ADD", + 5, + 7, + -1 + ], + [ + "ADD", + 4, + 2, + 1 + ], + [ + "ADD", + 3, + 5, + -1 + ], + [ + "ADD", + 2, + 0, + 1 + ], + [ + "ADD", + 1, + 3, + -1 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ] + ], + "prefix_pairs": 7 +} diff --git a/research/hyperplane-retiming/inputs/pr4610-round3-word.json.gz b/research/hyperplane-retiming/inputs/pr4610-round3-word.json.gz new file mode 100644 index 0000000000..46d929df83 Binary files /dev/null and b/research/hyperplane-retiming/inputs/pr4610-round3-word.json.gz differ diff --git a/research/hyperplane-retiming/inputs/pr4610-word.json.gz b/research/hyperplane-retiming/inputs/pr4610-word.json.gz new file mode 100644 index 0000000000..79dad65b9c Binary files /dev/null and b/research/hyperplane-retiming/inputs/pr4610-word.json.gz differ diff --git a/research/hyperplane-retiming/intervals.py b/research/hyperplane-retiming/intervals.py new file mode 100644 index 0000000000..4b24a50961 --- /dev/null +++ b/research/hyperplane-retiming/intervals.py @@ -0,0 +1,421 @@ +#!/usr/bin/env python3 +"""Higher-moment strictification and a polynomial-logarithm compiler bound. + +New arithmetic is independent of predecessor interval code. The unchanged +invoice replay and two outer ledgers are credited, byte-pinned oracles. +zxv with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import ast +from collections import Counter +from contextlib import redirect_stdout +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256, sha1 +import io +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +GRID = 2**192 +C = Q('0.00268648') +KAPPA = Q('0.00268647') +T = {5:420, 6:270, 7:840, 8:1395, 9:3195, + 25:448, 41:448, 57:448, 121:224} +P = {1:37305, 2:10695, 3:3360, 4:1530, 5:300, + 8:1464, 16:448, 32:448, 48:448} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def down(x): + return Q((x*GRID).__floor__(), GRID) + + +def up(x): + return Q(-((-x*GRID).__floor__()), GRID) + + +def rounded(lo, hi): + return down(lo), up(hi) + + +def mul(a, b): + products = [x*y for x in a for y in b] + return rounded(min(products), max(products)) + + +def scale(a, x): + return mul(a, (x, x)) + + +def divide(a, b): + need(b[0] > 0, 'positive interval denominator') + return mul(a, rounded(1/b[1], 1/b[0])) + + +@lru_cache(None) +def log_bounds(n): + """Exact atanh series, binary reduction; round only the final interval.""" + need(isinstance(n, int) and n >= 1, 'positive integer logarithm') + + def series(x): + u = (x-1)/(x+1) + term, total = u, Q(0) + for j in range(80): + total += 2*term/(2*j+1) + term *= u*u + tail = 2*term/(161*(1-u*u)) + return total, total+tail + + k = n.bit_length()-1 + a, b = series(Q(2)) + c, d = series(Q(n, 2**k)) + return rounded(k*a+c, k*b+d) + + +def exp_point(x): + """Outward fixed-point Taylor enclosure, with binary scaling/squaring.""" + need(abs(x) < 16, 'bounded exponential argument') + if x < 0: + a, b = exp_point(-x) + return rounded(1/b, 1/a) + divisions = 0 + while x > Q(1, 2): + x /= 2 + divisions += 1 + term = total = (Q(1), Q(1)) + for j in range(1, 65): + term = scale(term, x/j) + total = rounded(total[0]+term[0], total[1]+term[1]) + following = scale(term, x/65) + # Every remaining ratio is <= 1/132. Twice the next term is safe. + result = rounded(total[0], total[1]+2*following[1]) + for _ in range(divisions): + result = mul(result, result) + return result + + +def exp_interval(a): + return exp_point(a[0])[0], exp_point(a[1])[1] + + +@lru_cache(None) +def power(n, exponent): + return exp_interval(scale(log_bounds(n), exponent)) + + +def moment(histogram, exponent): + low = high = Q(0) + for n, count in histogram.items(): + a, b = power(n, exponent) + low += count*a + high += count*b + return rounded(low, high) + + +def display(a): + unit = 10**30 + + def fixed(n): + sign = '-' if n < 0 else '' + s = str(abs(n)).rjust(31, '0') + return sign+s[:-30]+'.'+s[-30:] + + return {'lower': fixed((a[0]*unit).__floor__()), + 'upper': fixed(-((-a[1]*unit).__floor__()))} + + +def encoded(x): + if isinstance(x, Q): + return str(x) + if isinstance(x, dict): + return {str(k): encoded(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): + return [encoded(v) for v in x] + return x + + +def source_environment(path): + env = {'__file__': str(path), '__name__': 'pinned_source_oracle'} + exec(compile(path.read_bytes(), str(path), 'exec'), env) + return env + + +def authenticate(): + result = {} + for row in json.loads((HERE/'VENDOR.json').read_text())['files']: + path = HERE/'vendor'/Path(row['path']).relative_to( + 'research/higher-moment-strictification/vendor') + digest = sha256(path.read_bytes()).hexdigest() + need(digest == row['sha256'], 'changed source: '+row['path']) + raw = path.read_bytes() + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() + == row['git_blob'], 'changed Git source blob') + result[row['path']] = digest + return result + + +def invoice_oracle(): + """Run #4426 unchanged, rebinding only its two file-location globals.""" + path = HERE/'vendor/invoice-review/verify.py' + env = source_environment(path) + env.update(ROOT=path.parent, PHASES='DATA-PHASES.json') + output = io.StringIO() + with redirect_stdout(output): + env['main']() + result = json.loads(output.getvalue()) + need(result['status'] == 'PASS_PR4416_INVOICE_REBUILD', 'source invoice oracle') + need({int(k): v for k, v in result['targets'].items()} == T + and {int(k): v for k, v in result['paid'].items()} == P, + 'exact literal-word invoice') + return result + + +def tail_certificate(v=150, cutoff=10, floor=15, u=Q(3, 10)): + t = 1-C + need(v >= 1 and 1 < cutoff < floor < 121, 'strict finite ranks') + need(t+u >= 1, 'tail moment exponent at least one') + target, paid = moment(T, t), moment(P, t) + alpha = divide(paid, target) + gamma = divide(moment(P, t+u), mul(power(cutoff, u), target)) + delta = divide((Q(sum(T.values())*floor),)*2, + mul(power(cutoff, C), target)) + limits = (1-Q(1, 10**8), Q(181, 200), Q(439, 500)) + for name, bounds, limit in zip(('alpha', 'gamma', 'delta'), + (alpha, gamma, delta), limits): + need(0 < bounds[0] <= bounds[1] < limit < 1, name+' certified limit') + a, g, d = limits + bound = 1/(1+v*(1-a))+2*g**v+2*d**v + need(bound < 1, 'complete charged normalized moment') + old_gamma = divide((Q(sum(k*n for k, n in P.items())),)*2, + mul(power(cutoff, C), target)) + old_lower = alpha[0]**v+2*old_gamma[0]**v + need(old_lower > 1, 'rank-one-tail estimate fails at this tensor power') + return {'tensor_power': v, 'cutoff_base': cutoff, 'floor_base': floor, + 'paid_moment_exponent': t+u, 'tail_offset_u': u, + 'tested_saving': C, 'alpha': display(alpha), 'gamma': display(gamma), + 'delta': display(delta), 'rational_upper_limits': limits, + 'normalized_paid_upper': bound, 'strict_moment_gap': display((1-bound,)*2), + 'old_rank_one_gamma': display(old_gamma), + 'old_rank_one_bound_lower': display((old_lower, old_lower)), + 'ambient': '121^'+str(v), 'minimum_target': str(floor)+'^'+str(v), + 'maximum_paid': str(cutoff)+'^'+str(v), + 'productive_fields_before_uniform_compiler': '7688^'+str(v), + 'rank_one_surplus': '131723^'+str(v)+'-131115^'+str(v), + 'materialized_product_or_uniform_word': False} + + +def uniform_rank(v): + t, p, theta = 1-C, 13, Q(6, 7) + gap = (C-KAPPA)/7 + uniform_saving = C-gap + need(10**7 < 15**6, 'theta upper bound') + need(2*(10**v)**7 <= (121**v)**6, 'shifted logarithm inequality') + eta = scale(exp_interval(scale(log_bounds(121), -v*C)), t) + need(eta[0] > theta**p, 'exit contraction below complement capacity') + base = exp_interval(scale(log_bounds(121), v*C)) + need(base[1] < 2**p, 'entire ordinary base range fits') + # Integer grid: gap*H is integral, avoiding enormous rational powers. + step = gap.denominator + need(gap.numerator == 1, 'chosen rational gap grid') + + def passes(j): + H = step*j + return (H+1)**p < 2**j + + lo, hi = 1, 2 + while not passes(hi): + lo, hi = hi, 2*hi + while hi-lo > 1: + mid = (lo+hi)//2 + if passes(mid): + hi = mid + else: + lo = mid + H = step*hi + need(H > 7*v and passes(hi) and not passes(hi-1), 'final integer comparison') + need(eta[1] < theta**(p-1), 'one smaller logarithmic power fails') + return {'t': t, 'uniform_saving': uniform_saving, 'gap': gap, + 'logarithm_power': p, 'theta_upper': theta, 'eta': display(eta), + 'eta_minus_theta_to_p': display((eta[0]-theta**p, eta[1]-theta**p)), + 'm_to_saving': display(base), 'H': H, 'N': '2^'+str(H), + 'integer_test': {'left_base': H+1, 'left_exponent': p, + 'right_base': 2, 'right_exponent': hi}, + 'grid_step': step, 'previous_grid_point_rejected': True, + 'smaller_logarithmic_power_rejected': True} + + +def power_majorant_comparison(v, uniform_saving): + """Retain #4416's older power proof, changing only the new unit's ranks.""" + t, z, h = 1-C, 1-uniform_saving, Q(1, 7) + z0 = (t+z)/2 + delta = z0-t + B, debt = (4+7*h)*v, 1+7*v*(1-z0) + ratio = (delta*B+debt)/(h*delta) + H0 = -((-ratio.numerator)//ratio.denominator) + ratio = H0*(1-z0)/(z-z0) + H1 = ratio.numerator//ratio.denominator+1 + need(H0 >= 7*v and H0*h*delta >= delta*B+debt, 'power majorant threshold') + need((H0-1)*h*delta < delta*B+debt, 'previous power threshold rejected') + need(H1*(z-z0) > H0*(1-z0) >= (H1-1)*(z-z0), + 'strict power-majorant comparison and previous-rank control') + return {'H0': H0, 'H1': H1, 'N': '2^'+str(H1), 'theta_upper': 1-h, + 'scope': 'Tail transformation alone, retaining the older power majorant.'} + + +def outer_ledger(uniform_saving): + d = (C-KAPPA)/7 + params = {'kappa': KAPPA, 'tested_saving': C, + 'complex_uniform_saving': uniform_saving, 'b': KAPPA+5*d, + 'a': KAPPA+4*d, 'q': KAPPA+3*d, 'bit_saving': Q('0.0027'), + 'epsilon': 1-d, 'beta': 1-3*d, 'r0': d/10, + 'stop': d, 'layout': d, 'd': d} + env = source_environment(HERE/'vendor/outer_endpoint.py') + row = env['ledger'](params) + need(len(row['strict_checks']) == 54 and len(row['functional_checks']) == 3, + 'complete first outer ledger') + need(all(v > 0 for group in ('strict_checks', 'functional_checks') + for v in row[group].values()), 'all outer predicates') + frozen = json.loads((HERE/'vendor/p7-RESULT.json').read_text())['endpoint']['outer'] + need(encoded(row) == frozen, 'unchanged full p7 endpoint ledger') + parsed = ast.parse((HERE/'vendor/check_ledger.py').read_bytes()) + function = next(n for n in parsed.body + if isinstance(n, ast.FunctionDef) and n.name == 'ledger') + constants = [n for n in parsed.body if isinstance(n, ast.Assign) + and any(isinstance(t, ast.Name) and t.id.startswith('KAPPA_') + for t in n.targets)] + eps, beta, q, a = (params[k] for k in ('epsilon', 'beta', 'q', 'a')) + grid = 10**10 + backoff = Q((eps*q*grid).__floor__(), grid)-KAPPA + need(backoff > 0, 'strict derived oracle grid backoff') + oracle = {'Q': Q, 'R0': params['r0'], 'ZETA': Q(1, 10**8), + 'SLACK': d, 'STOP': d, 'FLOOR': grid, 'BACKOFF': backoff, + 'EPS': eps, 'BETA': beta, 'THETA_POWER': Q(2), + 'HALO_POWER': 48, 'CORE_POWER': 128, 'STRASSEN_TAU': Q(45, 16), + 'b': params['b'], 'q': q, 'a': a, 'bit': params['bit_saving'], + 'online': Q('0.001730970419199163702738'), + 'old': Q('0.001730970419199163702738')} + code = ast.fix_missing_locations(ast.Module(body=constants+[function], type_ignores=[])) + exec(compile(code, 'pinned 63-predicate ledger', 'exec'), oracle) + second = oracle['ledger']('higher_moment_smaller_ranks') + need(second['kappa'] == KAPPA and second['margins'] == row['margins'], + 'all nine rows match both ledgers') + need(len(second['strict_checks']) == 63 and + all(v > 0 for v in second['strict_checks'].values()), 'all 63 legacy predicates') + controls = {} + for name, updates in [('closed_epsilon', {'epsilon': Q(1)}), + ('missing_layout', {'layout': Q(0)}), + ('unfunded_kappa', {'kappa': C}), + ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('insufficient_BIT', {'bit_saving': Q('0.0023')})]: + bad = env['ledger'](dict(params, **updates)) + failed = sorted(k for k, v in bad['strict_checks'].items() if v <= 0) + need(failed, 'outer control rejected: '+name) + controls[name] = failed + for name, options in [('old_per_axis_scan', {'old_scan': True}), + ('group_equals_dimension', {'beta_': eps})]: + bad = oracle['ledger']('reject_'+name, **options) + failed = sorted(k for k, v in bad['strict_checks'].items() if v <= 0) + need(failed, 'legacy control rejected: '+name) + controls[name] = failed + return {'ledger': row, 'legacy_63_checks': second['strict_checks'], + 'legacy_grid': grid, 'legacy_backoff': backoff, + 'minimum_margin_minus_kappa': min(row['margins'].values())-KAPPA, + 'rejected_controls': controls} + + +def finite_controls(): + def tensor(histogram): + out = Counter() + for k, n in histogram.items(): + for h, b in histogram.items(): + out[k*h] += n*b + return out + + def split(histogram, cutoff): + out = Counter() + for k, n in histogram.items(): + q, r = divmod(k, cutoff) + out[cutoff] += q*n + if r: + out[r] += n + return +out + + target, paid = tensor({2:1, 5:1}), tensor({1:2, 4:1}) + padded, completion = Counter(), Counter() + for k, n in target.items(): + padded[max(k, 9)] += n + if k < 9: + completion[9-k] += n + final = split(paid+completion, 4) + mass = lambda x: sum(k*n for k, n in x.items()) + need(mass(padded)-mass(final) == 7**2-6**2 == 13, 'exact paid padding mass') + need(min(padded) > max(final), 'exact toy separation') + need(final == Counter({1:5, 4:9}), 'literal toy expanded inventory') + # t=1/2, sigma=3/4, R=100, J=1 refutes a sublinear tail extension. + invalid = power(100, Q(1, 2))[1]+2*power(100, Q(3, 4))[1] + need(invalid < 100, 'sublinear upper-tail moment cannot bound splitting') + return {'toy_targets': padded, 'toy_paid': final, 'rank_one_surplus': 13, + 'sublinear_tail_counterexample': {'R': 100, 'J': 1, 't': '1/2', + 'sigma': '3/4', 'actual_charge': 100, + 'invalid_upper': display((invalid, invalid))}} + + +def verify(): + sources = authenticate() + invoice = invoice_oracle() + tail = tail_certificate() + rank = uniform_rank(tail['tensor_power']) + endpoint = outer_ledger(rank['uniform_saving']) + controls = finite_controls() + rejected = [] + for name, updates, expected in [ + ('too_short_product', {'v': 100}, 'complete charged normalized moment'), + ('sublinear_tail', {'u': C/2}, 'tail moment exponent at least one'), + ('lost_separation', {'floor': 10}, 'strict finite ranks'), + ]: + try: + tail_certificate(**updates) + except ValueError as error: + need(str(error) == expected, 'wrong rejection: '+name) + rejected.append({'mutation': name, 'failed_at': str(error)}) + else: + raise ValueError('accepted mutation: '+name) + old = json.loads((HERE/'vendor/p7-RESULT.json').read_text())['endpoint']['compiler'] + return encoded({'schema': 'higher-moment-native-strictification/1', + 'status': 'PASS_HIGHER_MOMENT_STRICTIFICATION', 'kappa': KAPPA, + 'invoice_oracle': invoice, 'strictification': tail, + 'uniform_rank': rank, 'outer': endpoint, + 'tail_only_power_majorant': power_majorant_comparison( + tail['tensor_power'], rank['uniform_saving']), + 'finite_controls': controls, 'rejected_mutations': rejected, + 'predecessor_H': old['H1'], + 'rank_exponent_reduction_factor': Q(old['H1'], rank['H']), + 'tensor_power_reduction_factor': Q(6240, tail['tensor_power']), + 'source_sha256': sources, + 'verifier_sha256': sha256(Path(__file__).read_bytes()).hexdigest(), + 'scope': 'Conditional charged transformation and finite compiler rank. Native all-column, physical, analytic, precision, storage, fixed-tape and recovery premises remain inherited. No new kappa, selected frontier or practical word.'}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = verify() + if args.out: + need(not args.out.exists(), 'new output path required') + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: + need(json.loads((HERE/'RESULT.json').read_text()) == result, 'changed saved receipt') + print(json.dumps({'status': result['status'], 'tensor_power': result['strictification']['tensor_power'], + 'uniform_rank': result['uniform_rank']['N'], + 'strict_moment_gap': result['strictification']['strict_moment_gap'], + 'kappa': result['kappa']})) + + +if __name__ == '__main__': + main() diff --git a/research/hyperplane-retiming/outer_ledger.py b/research/hyperplane-retiming/outer_ledger.py new file mode 100644 index 0000000000..340e1f0ffb --- /dev/null +++ b/research/hyperplane-retiming/outer_ledger.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 +"""Exact endpoint refill conditional on the source PR4359 construction. + +Apache-2.0. Substantial OpenAI assistance. The mixed inventory and elementary +function enclosure are zxv's PR4359; mixed-target flow is Jacob Alan Sussman's +Theorem 1G. Outer formulas retain the attribution in PR4359 outer_parameters.py. +This file checks arithmetic, not the native or all-size proof hypotheses. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +PREFIX = Path('research/kappa-rebuild') +OLD_BASELINE = Q('0.001730970419199163702738') +KAPPA = Q('0.00230509') +TESTED = Q('0.00230509019') +ROOT_UPPER = Q('0.002306') + + +def need(value, message): + if not value: + raise AssertionError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def ceil(value): + value = Q(value) + return -((-value.numerator) // value.denominator) + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): encode(v) for k, v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def family(kappa, tested): + """One explicit slack family approaching the same source mixed root.""" + need(Q(0) < kappa < tested < ROOT_UPPER, 'Positive strictly ordered savings') + d = (tested-kappa)/7 + return {'kappa': kappa, 'tested_saving': tested, + 'complex_uniform_saving': kappa+6*d, + 'b': kappa+5*d, 'a': kappa+4*d, 'q': kappa+3*d, + 'bit_saving': Q('0.0027'), 'epsilon': 1-d, 'beta': 1-3*d, + 'r0': d/10, 'stop': d, 'layout': d, 'd': d} + + +def ledger(p): + """Recompute all 54 named PR4359 checks with freely supplied parameters.""" + kappa, b, a, q = (p[key] for key in ('kappa', 'b', 'a', 'q')) + epsilon, beta, r0, stop, layout = (p[key] for key in + ('epsilon', 'beta', 'r0', 'stop', 'layout')) + sigma, tau = 1-b, 1-a + internal = tau+(1-stop)*max(sigma-tau, Q(0)) + leaf = sigma+stop*(1-sigma) + lam, c = 1-(q+a)/2, Q(3, 32) + xi, key = epsilon*(1+q)-c+layout, beta+1-epsilon + margins = { + 'main_transform': epsilon*q, + 'global_coordinate_router': a, + 'fused_gaussian': 1-epsilon+q*beta, + 'group_bit_router': 1-epsilon+a*beta, + 'group_scans': 1-epsilon+beta, + 'boundary_algebraic_matrix': c+xi-epsilon, + 'sparse_union_movement': xi+Q(1, 2)-epsilon, + 'polynomial_products': epsilon, + 'microbox_face_corrections': 1-(epsilon+beta+48-128+2), + } + checks = { + 'actual_bit_above_effective': p['bit_saving']-a, + 'complex_above_effective': b-a, + 'q_positive': q, 'complex_endpoint': b-q, 'q_below_effective': a-q, + 'stop_positive': stop, 'stop_below_one': 1-stop, + 'leaf_saving_above_effective': (1-stop)*b-a, + 'q_below_internal': 1-internal-q, 'q_below_leaf': 1-leaf-q, + 'lambda_above_tau': lam-tau, 'lambda_above_sigma': lam-sigma, + 'lambda_above_internal': lam-internal, + 'lambda_prime_above_lambda': 1-q-lam, + 'lambda_prime_above_leaf': 1-q-leaf, + 'epsilon_positive': epsilon, 'epsilon_below_one': 1-epsilon, + 'cap_above_band': xi-Q(1, 2), 'cap_below_cell': epsilon-xi, + 'group_positive': beta, 'group_below_dimension': epsilon-beta, + 'support_router_span': 1-beta, + 'group_gauge_power_slack': 1-(2*xi-2)-r0-beta, + 'actual_logarithmic_group_guard': 1-(2*xi-2)-beta, + 'global_gamma_power_slack': 1-epsilon-r0, + 'actual_logarithmic_gamma_guard': 1-epsilon, + 'alpha_logarithm_absorption': r0, + 'group_key_fits_record': 1-key, + 'membership_arithmetic_fits_record': 1-beta-2*(1-epsilon), + 'microbox_halo_volume': 128-48-beta, + 'positive_layout_slack': layout, + 'short_record_fallback': epsilon-a, + 'complex_below_one_over_32': Q(1, 32)-b, + 'strassen_integer_power_gap': Q(2**45-7**16), + 'theta_positive_polynomial_power': Q(2), + 'cap_below_phase_cell_power': 2-xi, + 'halo_covers_generic_inverse_radius': Q(48-43), + 'union_tag_work_per_visit_fits_record': 1-beta, + 'union_header_fits_record': 1-beta, + 'source_axis_superpolynomial': 1-epsilon, + 'gaussian_above_main': margins['fused_gaussian']-margins['main_transform'], + 'new_complex_uniform_saving_above_b': p['complex_uniform_saving']-b, + 'improvement_over_user_baseline': kappa-OLD_BASELINE, + 'new_semantic_guard_with_C1_one': 1-epsilon, + 'fine_prime_halo_umbrella': 10-(2*2+2+Q(1, 2)), + } + checks.update({name+'_above_kappa': value-kappa for name, value in margins.items()}) + # These are the additional functional conditions in the independent + # PR4359 outer_transfer_audit.py, beyond the 54-row parameter ledger. + functional = { + 'new_semantic_group_guard': 1-beta, + 'new_BIT_row_stock_sublinear_in_active_group': beta*(1-Q(3, 1000)), + 'fixed_halo_explicit_metadata_branch': 128-48-epsilon-beta-1, + } + return {'parameters': dict(p, cap_xi=xi, lambda_=lam, lambda_prime=1-q), + 'margins': margins, 'strict_checks': checks, 'functional_checks': functional} + + +def compiler_rank(E, targets, paid, tested, uniform): + """The original sufficient bound, re-instantiated for the new exponent.""" + m, kmin, rmax = max(targets), min(targets), max(paid) + need((m, kmin, rmax) == (57, 6, 5), 'Pinned complex separation') + t, z = 1-tested, 1-uniform + z0, h = (t+z)/2, Q(1, 10) + delta = z0-t + need(0 < t < z0 < z < 1, 'Compiler exponent order') + need(5**10 < 6**9 and 57 < 2**10, 'Exact source rank bounds') + need(z0 > Q(1, 2) and (1-z0)*E.log_interval(m)[1] < E.log_interval(2)[0], + 'Original eta strictly exceeds 1/4') + H0 = ceil((3+4*delta)/(h*delta)) + ratio = H0*(1-z0)/(z-z0) + H1 = ratio.numerator//ratio.denominator+1 + need(H0 >= m.bit_length() and H0*h*delta >= 3+4*delta, 'Induction starts') + need(H1*(z-z0) > H0*(1-z0), 'Strict winning uniform rank') + need((H0-1)*h*delta < 3+4*delta, 'Reject one lower threshold exponent') + need((H1-1)*(z-z0) <= H0*(1-z0), 'Reject one lower final exponent') + return {'t': t, 'z0': z0, 'z': z, 'theta_upper': Q(9, 10), + 'H0': H0, 'H1': H1, 'N_encoding': '2^H1', + 'strict_final_gap': H1*(z-z0)-H0*(1-z0), + 'winning_word_materialized': False, + 'bound': 'Original sufficient inequality; a sharper bound is separate.'} + + +def run(source_root): + base = source_root/PREFIX + interval_path = base/'architecture/mixed_target_probe.py' + spec = importlib.util.spec_from_file_location('pr4359_moment', interval_path) + E = importlib.util.module_from_spec(spec) + spec.loader.exec_module(E) + cover = read(base/'controller/P3-NATIVE-COVER.json.gz')['cover'] + targets = {int(k): int(v) for k, v in cover['targets'].items()} + paid = {int(k): int(v) for k, v in cover['paid'].items()} + need(targets == {6: 192, 7: 56, 8: 93, 9: 1229, 25: 448, 57: 224}, + 'Exact source productive inventory') + need(paid == {1: 17623, 2: 5065, 3: 1738, 4: 714, 5: 254}, + 'Exact source paid inventory') + signed = Counter(targets) + signed.subtract(paid) + need(sum(k*v for k, v in signed.items()) == 224, 'Rank-one surplus') + bracket = {'lower': E.moment(signed, TESTED), 'upper': E.moment(signed, ROOT_UPPER)} + need(bracket['lower'][0] > 0 and bracket['upper'][1] < 0, + 'Strict mixed test and upper root bound') + + original = read(base/'controller/OUTER-PARAMETERS.json')['outer'] + old = ledger({'kappa': Q('0.0023'), 'complex_uniform_saving': Q('0.002304'), + 'b': Q('0.002303'), 'a': Q('0.0023025'), 'q': Q('0.002302'), + 'bit_saving': Q('0.0027'), 'epsilon': Q('0.99999'), + 'beta': Q('0.99997'), 'r0': Q(1, 10**6), + 'stop': Q(1, 10**8), 'layout': Q(1, 10**6)}) + for group in ('margins', 'strict_checks'): + frozen = {key: Q(value['rational']) for key, value in original[group].items()} + need(old[group] == frozen, 'Exact reproduction of every old '+group) + p = family(KAPPA, TESTED) + result = ledger(p) + need(all(v > 0 for v in result['strict_checks'].values()), 'All 54 new outer predicates') + need(all(v > 0 for v in result['functional_checks'].values()), 'Additional functional predicates') + need(min(result['margins'].values()) == result['margins']['main_transform'], + 'Main transform remains limiting') + need(result['parameters']['cap_xi'] == Q(29, 32)+(1-p['d'])*p['q'], + 'Cofinal cap simplification') + controls = {} + for label, updates in [('closed_epsilon_gap', {'epsilon': Q(1)}), + ('missing_layout', {'layout': Q(0)}), + ('unfunded_kappa', {'kappa': Q('0.002306')}), + ('BIT_below_effective', {'bit_saving': OLD_BASELINE}), + ('no_complex_slack', {'complex_uniform_saving': p['b']})]: + tested = ledger(dict(p, **updates)) + failures = {k: v for k, v in tested['strict_checks'].items() if v <= 0} + need(failures, 'Mutation rejected: '+label) + controls[label] = failures + need(E.moment(signed, Q('0.004'))[1] < 0, 'Unsupported mixed target is rejected') + inputs = [interval_path, base/'controller/P3-NATIVE-COVER.json.gz', + base/'controller/OUTER-PARAMETERS.json'] + return encode({'schema': 'pr4359-cofinal-outer-refill/1', + 'status': 'PASS_EXACT_CONDITIONAL_ENDPOINT_REFILL', + 'kappa': KAPPA, 'gain_over_PR4359': KAPPA-Q('0.0023'), + 'unchanged_paid': paid, 'unchanged_targets': targets, + 'mixed_test_saving': TESTED, 'mixed_test_margin': E.show(bracket['lower']), + 'root_upper_test': ROOT_UPPER, 'root_upper_margin': E.show(bracket['upper']), + 'old_ledger_crosscheck': {'matched_savings': len(old['margins']), + 'matched_checks': len(old['strict_checks'])}, + 'outer': result, 'limiting_margin': min(result['margins'].values())-KAPPA, + 'compiler': compiler_rank(E, targets, paid, TESTED, p['complex_uniform_saving']), + 'negative_controls': controls, + 'source_sha256': {str(p.relative_to(source_root)): sha256(p.read_bytes()).hexdigest() + for p in inputs}, + 'scope': 'Conditional arithmetic and specified finite rank. The PR4359 native, compiler, cover, precision, fixed-tape and outer hypotheses remain premises; no full theorem or practical word is certified.'}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, default=HERE/'source') + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = run(args.source_root) + if args.out: + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(json.dumps({key: result[key] for key in + ('status', 'kappa', 'gain_over_PR4359', 'limiting_margin', 'compiler')}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/hyperplane-retiming/price_profile.py b/research/hyperplane-retiming/price_profile.py new file mode 100644 index 0000000000..eac423510d --- /dev/null +++ b/research/hyperplane-retiming/price_profile.py @@ -0,0 +1,144 @@ +"""Complete p16 price and finite compiler for a changed native profile. + +Adapted from Cinna Davis's PR4470 arithmetic, retaining zxv's paid tensor +completion/logarithmic majorant and Jacob Alan Sussman's mixed-job flow. +Apache-2.0. Substantial OpenAI Codex assistance. Native admission is separate. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import math +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + +def need(ok,why): + if not ok:raise ValueError(why) + +def load(path,name): + spec=importlib.util.spec_from_file_location(name,path) + m=importlib.util.module_from_spec(spec);sys.modules[name]=m;spec.loader.exec_module(m) + return m + +def encode(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +def read(path): + import gzip + b=path.read_bytes();return json.loads(gzip.decompress(b) if path.suffix=='.gz' else b) + +def assemble(local): + H={int(k):v for k,v in local['helpers'].items()};N={int(k):v for k,v in local['paid'].items()} + word=read(HERE/'inputs/p16-controller.json') + T,P=Counter(),Counter();full=thin=0 + for e in word['physical_events']: + if e[0]=='LOCAL':full+=1;T.update(H);P.update(N) + elif e[0]=='QUERY_SHEAR':thin+=1;P[1]+=112 + elif e[0]=='IDLE':P[8*len(e[2])]+=224 + for term in word['diagonal']:T[1+8*sum(term[1:])]+=112 + need(full==18 and thin==15 and sum(H.values())==408,'Complete retained p16 call and input inventory') + return H,N,T,P,word + +def run(local,kappa=None): + H,N,T,P,word=assemble(local) + E=load(HERE/'intervals.py','round2_exact_intervals') + other=load(HERE/'second_intervals.py','round2_second_intervals') + def margin(c): + t,p=E.moment(T,1-c),E.moment(P,1-c) + return t[0]-p[1],t[1]-p[0] + old_upper=Q('.0030201659771') + need(margin(old_upper)[0]>0,'Changed complete invoice strictly beats old raw root upper endpoint') + # Binary search on a fixed rational grid; all final signs use exact intervals. + lo,hi=0,100000000 + grid=10**10 + while hi-lo>1: + mid=(lo+hi)//2 + if margin(Q(mid,grid))[0]>0:lo=mid + else:hi=mid + root_low,root_high=Q(lo,grid),Q(hi,grid) + need(margin(root_low)[0]>0 and margin(root_high)[1]<0,'Strict changed-profile rational root enclosure') + if kappa is None:kappa=Q((root_low*10**8).__floor__()-3,10**8) + tested=kappa+Q(1,10**8) + need(Q('.003020165')ph and max(tl,target[0])<=min(th,target[1]) and max(pl,paid[0])<=min(ph,paid[1]),'Two independently implemented rational moment engines agree') + alpha=E.divide(paid,target) + gamma=E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta=E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,tested),target)) + alpha_gap=Q(1,10**9);g=d=Q(97,100) + need(alpha[1]<1-alpha_gap and gamma[1]theta**power,'Shifted exits and complement capacity') + need(E.power(145,v*tested)[1]<2**power,'Compiler initial range') + gap=(tested-kappa)/7;need(gap.numerator==1,'Explicit finite integer grid') + step=gap.denominator + def wins(j):return (step*j+1)**power<2**j + left,right=1,2 + while not wins(right):left,right=right,2*right + while right-left>1: + mid=(left+right)//2 + if wins(mid):right=mid + else:left=mid + height=step*right + need(height>8*v and wins(right) and not wins(right-1),'Strict finite uniform-rank integer bound') + local_scalar=max(x['real_scalar_allowance'] for x in local['native'].values()) + routes=(sum(N.values())+2*408+688)*1000 + need(local_scalar+routes<10**7,'Complete scalar and fixed monomial routing bound') + scalar_upper=18*10**7+15*1792+32*112*(len(word['physical_events'])+sum(len(word['boundaries'][k+'_program']) for k in ('left','right'))) + need(scalar_upper<10**9,'Raw controller scalar bound') + bit=read(HERE/'inputs/bit-stock.json')['ordinary_BIT'] + atom=Q(bit['atom']);ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599');admitted=Q(bit['admitted']) + need(atom==Q('.004') and atom>ordinary>admitted>tested and atom<1-ordinary,'Source ordinary BIT admission and stock') + L=load(HERE/'outer_ledger.py','round2_outer_ledger') + params={'kappa':kappa,'tested_saving':tested,'complex_uniform_saving':kappa+6*gap, + 'b':kappa+5*gap,'a':kappa+4*gap,'q':kappa+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=L.ledger(params);outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'Whole outer predicate inventory') + need(all(x>0 for key in ('strict_checks','functional_checks') for x in outer[key].values()),'All outer inequalities strictly positive') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}),('unfunded_endpoint',{'kappa':tested}),('closed_epsilon',{'epsilon':Q(1)})]: + bad=L.ledger(dict(params,**patch));failed=[k for k,x in bad['strict_checks'].items() if x<=0] + need(failed,'Reject unsupported outer patch '+name);controls[name]=failed + return encode({'status':'PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE','kappa':kappa, + 'gain_over_PR4535':kappa-Q('.003020165'),'raw_root_interval':[root_low,root_high], + 'margin_at_old_root_upper':margin(old_upper),'local_helpers':H,'local_paid':N,'targets':T,'paid':P, + 'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),'rank_mass_surplus':sum(r*n for r,n in T.items())-sum(r*n for r,n in P.items()), + 'strictification':{'tested':tested,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'uniform_saving':params['complex_uniform_saving'],'H':height,'N':'2^'+str(height),'integer_test_exponent':right,'word_materialized':False}, + 'nonrecursive':{'local_scalar':local_scalar,'local_routes':routes,'raw_scalar_upper':scalar_upper}, + 'ordinary_BIT':bit,'outer':outer,'negative_controls':controls, + 'scope':'Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.'}) + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--native',type=Path,required=True);ap.add_argument('--kappa');ap.add_argument('--out',type=Path,default=HERE/'ARITHMETIC.json');args=ap.parse_args() + V=load(HERE/'verify.py','hyper_auth');V.authenticate() + result=run(read(args.native),Q(args.kappa) if args.kappa else None) + result['native_receipt_sha256']=sha256(args.native.read_bytes()).hexdigest() + # Pin all loaded project source modules and the non-module controller/stock + # records read by the inherited engines. Standard-library files are outside + # the repository and are recorded instead by the replay's Python version. + paths={Path(__file__).resolve(),HERE/'inputs/p16-controller.json', + HERE/'inputs/bit-stock.json'} + for module in tuple(sys.modules.values()): + name=getattr(module,'__file__',None) + if name: + path=Path(name).resolve() + if path.is_relative_to(ROOT) and path.is_file():paths.add(path) + result['source_sha256']={p.relative_to(ROOT).as_posix():sha256(p.read_bytes()).hexdigest() for p in sorted(paths)} + args.out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({k:result[k] for k in ('status','kappa','gain_over_PR4535','raw_root_interval','paid_calls','compiler')},indent=2)) diff --git a/research/hyperplane-retiming/search/center_model.py b/research/hyperplane-retiming/search/center_model.py new file mode 100644 index 0000000000..a4c6586da0 --- /dev/null +++ b/research/hyperplane-retiming/search/center_model.py @@ -0,0 +1,29 @@ +"""Explore center gauges jointly with persistent scalar contacts.""" +import quotient_cut as Q +import graph as S +from pathlib import Path +import inspect,json,time,sys +owned=set();groups=[];pending=[];current=list(range(632));cursor=632 +for e in S.p: + if e[0]=='climb':continue + if e[0]=='scalar': + g=e[1];roles=g[1:3] if g[0] in ('add','copy') else g[1:2];v=cursor;cursor+=1 + if any(r[0]=='C' for r in roles): + owned.add(v) + if e[2]!=0:pending.append(v) + else:groups[-1]['low'].append(v) + for r in roles: + if r[0]=='L':current[r[1]]=v + elif e[0]=='warp': + r=e[1][1];u=current[r] + if S.NF[u]!=e[3]:u=cursor;cursor+=1 + current[r]=cursor;cursor+=1 + elif e[0]=='center': + assert len(pending)==2 + groups.append({'high':pending,'low':[]});pending=[] +assert len(groups)==8 and all(len(g['low'])>=2 for g in groups) +EXTRA=[] +for g in groups: + for side in ('high','low'): + for v in g[side][1:]:EXTRA.extend([(g[side][0],v),(v,g[side][0])]) +centeredges=[(g['low'][0],g['high'][-1],8) for g in groups] diff --git a/research/hyperplane-retiming/search/graph.py b/research/hyperplane-retiming/search/graph.py new file mode 100644 index 0000000000..764342e711 --- /dev/null +++ b/research/hyperplane-retiming/search/graph.py @@ -0,0 +1,63 @@ +"""Exploratory exact-graph phase-flow discovery. No admission claimed.""" +import gzip,json,math,time,sys +from collections import Counter,defaultdict +from pathlib import Path +D=Path(__file__).resolve().parent.parent +w=json.loads(gzip.decompress((D/'inputs/pr4610-round3-word.json.gz').read_bytes())); c=w['canonical'];p=w['programs']['forward'];n=c['h'];frames=c['frames'] +def span(B): + s={0} + for b in B:s|={x^b for x in tuple(s)} + return s +spaces=list(map(span,frames));basis_cache={} +def basis(S): + key=frozenset(S) + if key not in basis_cache: + B=[];s={0} + for x in sorted(S): + if x not in s:B.append(x);s|={y^x for y in tuple(s)} + basis_cache[key]=tuple(B) + return basis_cache[key] +def image(G,x): + out=0 + for i,g in enumerate(G): + if x>>i&1:out^=g + return out +def inverse(G): + im={image(G,x):x for x in range(1<0 else (v,u) + key=(frozenset(S.spaces[Q.NF[a]]),frozenset(S.spaces[Q.NF[b]])) + contracts[abs(op)].setdefault(key,[]).append((a,b)) +assert set(contracts)==set(range(1,73)) +for op,ps in contracts.items(): + assert len(ps)<=2,(op,len(ps)) + if len(ps)==2:assert min(len(A) for A,B in ps)==2 + +def native_constraints(l,active,pins,imp): + for u,v,op,B in Q.warps: + if active[u] and active[v]:imp.extend([(u,v),(v,u)]) + elif active[u]:pins.add(u) + elif active[v]:pins.add(v) + for op,ps in contracts.items(): + if len(ps)<2:continue + pairs=sorted(ps,key=lambda ab:len(ab[0]));(A,B),(U,V)=pairs + a=next(iter(A-{0}));b=next(iter(B-{0}));inside=a in U;assert inside==(b in V) + if inside and bool((a&l).bit_count()%2)!=bool((b&l).bit_count()%2): + for u,v in ps[(U,V)]: + if active[u]:pins.add(u) + if active[v]:pins.add(v) + +def engine(): + ns=Q.__dict__.copy();ns.update(fixed=(Q.fixed-C.owned)|fullpins,paid=[*Q.paid,*C.centeredges],EXTRA=C.EXTRA,native_constraints=native_constraints) + src=inspect.getsource(Q.solve).replace('imp=[];unary=','imp=list(EXTRA);unary=').replace('P=Counter({8:8});H=Counter()','P=Counter();H=Counter()') + a=src.index(' for u,v,g,B in warps:');b=src.index(' for r,u,v,g in helpers:',a);src=src[:a]+' native_constraints(l,active,pins,imp)\n'+src[b:] + exec(src,ns);return ns['solve'] +if __name__=='__main__': + f=engine();best=0;start=time.monotonic();records=[] + for l in range(1,512): + r=f(l,.9969782);chosen=set(r['chosen']);r['centers']=[8-int(g['high'][-1] in chosen) for g in C.groups];records.append({k:v for k,v in r.items() if k not in ('chosen','original_nodes')}) + if r['energy']>p&1:x^=y + if x: + p=x.bit_length()-1 + for k,y in list(b.items()): + if y>>p&1:b[k]=y^x + b[p]=x + return tuple(b[k] for k in sorted(b,reverse=True)) +def solve(W,t=.996): + rs={f:rb(restrict[l,f] for l in W) for f in FIDS};a=[len(rs[f]) for f in Q.NF];pins=set(Q.fixed);imp=[];unary=[0.]*(len(a));power=[0.]+[i**t for i in range(1,14)] + for u,v,r in Q.paid: + x,y=a[u],a[v];assert x<=y + if x: + imp.append((v,u));d=power[r+x]-power[r];unary[u]+=d;unary[v]+=power[r+x-y]-power[r+x] + elif y:unary[v]+=power[r-y]-power[r] + for j,(u,v,g,B) in enumerate(Q.warps): + if a[u] and a[v]: + if rs[Q.NF[u]]==rb(wr[l,j] for l in W):imp.extend([(u,v),(v,u)]) + else:pins.update((u,v)) + elif a[u]:pins.add(u) + elif a[v]:pins.add(v) + for r,u,v,g in Q.helpers: + x,y=a[u],a[v];assert x<=y + if x: + imp.append((v,u));d=power[g+x]-power[g];unary[u]-=d;unary[v]-=power[g+x-y]-power[g+x] + elif y: + if g==y:pins.add(v) + else:unary[v]+=power[g]-power[g-y] + ren={i:j+2 for j,i in enumerate(i for i,x in enumerate(a) if x and i not in pins)};n=len(ren)+2;rows=[];cols=[];caps=[] + def arc(u,v,c): + if c:rows.append(u);cols.append(v);caps.append(c) + for u,v in imp: + u=ren.get(u,0);v=ren.get(v,0) + if u and v:arc(v,u,Q.INF) + elif u:arc(0,u,Q.INF) + for i,j in ren.items(): + c=round(unary[i]*Q.SCALE) + if c>=0:arc(0,j,c) + else:arc(j,1,-c) + graph=coo_matrix((np.array(caps,dtype=np.int64),(rows,cols)),shape=(n,n)).tocsr();flow=maximum_flow(graph,0,1);residual=graph-flow.flow;residual.data=(residual.data>0).astype(np.int8);residual.eliminate_zeros();reach=set(breadth_first_order(residual,0,directed=True,return_predecessors=False));chosen={i for i,j in ren.items() if j not in reach} + assert not(chosen & pins);assert all(u not in chosen or v in chosen for u,v in imp) + P=Counter({8:8});H=Counter() + for u,v,r in Q.paid: + rank=r+a[u]*int(u in chosen)-a[v]*int(v in chosen);assert rank>=0 + if rank:P[rank]+=1 + for r,u,v,g in Q.helpers: + rank=g+a[u]*int(u in chosen)-a[v]*int(v in chosen);assert rank>0;H[rank]+=1 + energy=sum((P[r]-Q.P0[r])*power[r] for r in set(P)|set(Q.P0))-sum((H[g]-Q.H0[g])*power[g] for g in set(H)|set(Q.H0)) + return {'W':W,'energy':energy,'paid':dict(sorted(P.items())),'helpers':dict(sorted(H.items())),'chosen':sorted(chosen),'original_nodes':sorted(i for i in range(Q.N) if Q.ids[i] in chosen)} diff --git a/research/hyperplane-retiming/search/multi_joint.py b/research/hyperplane-retiming/search/multi_joint.py new file mode 100644 index 0000000000..0ee0bb4e69 --- /dev/null +++ b/research/hyperplane-retiming/search/multi_joint.py @@ -0,0 +1,44 @@ +"""Two/three-dimensional coordinated deletions with shared-map reconstruction constraints.""" +import multi_cut as M +import joint_cut as J +import quotient_cut as Q +import center_model as C +import graph as S +from pathlib import Path +from types import SimpleNamespace +import inspect,json,time,random + +def constraints(W,a,pins,imp): + for u,v,op,B in Q.warps: + x,y=a[u],a[v] + if x and y and x==y:imp.extend([(u,v),(v,u)]) + else: + if x:pins.add(u) + if y:pins.add(v) + for op,ps in J.contracts.items(): + if len(ps)<2:continue + (A,B),(U,V)=sorted(ps,key=lambda ab:len(ab[0]));x=next(iter(A-{0}));y=next(iter(B-{0}));inside=x in U;assert inside==(y in V) + ax=any((x&l).bit_count()%2 for l in W);ay=any((y&l).bit_count()%2 for l in W) + if inside and ax!=ay: + for u,v in ps[U,V]: + if a[u]:pins.add(u) + if a[v]:pins.add(v) + +def engine(): + ns=M.__dict__.copy();ns['Q']=SimpleNamespace(**dict(Q.__dict__,fixed=(Q.fixed-C.owned)|J.fullpins,paid=[*Q.paid,*C.centeredges]));ns['EXTRA']=C.EXTRA;ns['native_constraints']=constraints + src=inspect.getsource(M.solve).replace('imp=[];unary=','imp=list(EXTRA);unary=').replace('P=Counter({8:8});H=Counter()','P=Counter();H=Counter()') + a=src.index(' for j,(u,v,g,B) in enumerate(Q.warps):');b=src.index(' for r,u,v,g in Q.helpers:',a);src=src[:a]+' native_constraints(W,a,pins,imp)\n'+src[b:];exec(src,ns);return ns['solve'] +if __name__=='__main__': + rng=random.Random(20261023);cases={M.rb(B) for B in S.frames if len(B)==2} + planes=[(a,b) for a in range(1,512) for b in range(a+1,512) if b<(a^b)];rng.shuffle(planes);cases.update(M.rb(W) for W in planes[:2048]);cases=list(sorted(cases)) + extra=set() + while len(extra)<512: + W=M.rb(rng.sample(range(1,512),3)) + if len(W)==3:extra.add(W) + cases+=sorted(extra);f=engine();best=0;start=time.monotonic();records=[] + for i,W in enumerate(cases): + r=f(W,.9969782);chosen=set(r['chosen']);r['centers']=[8-len(M.rb(S.restrict(l,S.frames[Q.NF[g['high'][-1]]]) for l in W))*int(g['high'][-1] in chosen) for g in C.groups];records.append({k:v for k,v in r.items() if k not in ('chosen','original_nodes')}) + if r['energy']=0:arc(0,j,c) + else:arc(j,1,-c) + graph=coo_matrix((np.array(caps,dtype=np.int64),(rows,cols)),shape=(n,n)).tocsr();assert not len(graph.data) or max(graph.data)<2**31;flow=maximum_flow(graph,0,1) + residual=graph-flow.flow;residual.data=(residual.data>0).astype(np.int8);residual.eliminate_zeros() + reachable=set(breadth_first_order(residual,0,directed=True,return_predecessors=False));chosen={i for i,j in ren.items() if j not in reachable} + assert not(chosen & pins) + assert all(u not in chosen or v in chosen for u,v in imp) + P=Counter({8:8});H=Counter() + for u,v,r in paid: + rank=r+int(u in chosen)-int(v in chosen) + assert rank>=0 + if rank:P[rank]+=1 + for r,u,v,g in helpers: + rank=g+int(u in chosen)-int(v in chosen) + assert rank>0 + H[rank]+=1 + energy=sum((P[r]-P0[r])*power[r] for r in set(P)|set(P0))-sum((H[g]-H0[g])*power[g] for g in set(H)|set(H0)) + return {'l':l,'t':t,'energy':energy,'paid':dict(sorted(P.items())),'helpers':dict(sorted(H.items())),'chosen':sorted(chosen),'original_nodes':sorted(i for i in range(N) if ids[i] in chosen)} +if __name__=='__main__': + t=float(sys.argv[1]) if len(sys.argv)>1 else .996;best=0;start=time.monotonic();allr=[] + print('compressed_nodes',len(NF),'paid',len(paid),flush=True) + for l in range(1,1<= 0 else b) + high += n*(b if n >= 0 else a) + return low,high + +def show(bounds): + scale=10**35 + low,high=bounds + a=low.numerator*scale//low.denominator + b=-((-high.numerator*scale)//high.denominator) + def fixed(n): + sign='-' if n<0 else '' + s=str(abs(n)).rjust(36,'0') + return sign+s[:-35]+'.'+s[-35:] + return {'lower':fixed(a),'upper':fixed(b)} + +def split_rank(r,maximum): + """Least concave tariff partition with positive integers <= maximum.""" + need(maximum>=1 and r>=0, 'Legal split') + q,remainder=divmod(r,maximum) + result=Counter() + if q: + result[maximum]+=q + if remainder: + result[remainder]+=1 + return result + +def split_profile(profile,maximum): + result=Counter() + for r,n in profile.items(): + for child,count in split_rank(r,maximum).items(): + result[child]+=n*count + return result + +def add_scaled(target,source,multiple=1): + for key,value in source.items(): + target[key]+=multiple*value + +def base_case(p,minimum,pairs=None,middle=None): + """Expand all role inventories; one fresh global field per unhosted role.""" + need(p in (1,2), 'Only reconstructed p1 and p2 schedules are in scope') + need(2<=minimum<=41, 'Finite minimum-target menu') + calls=2*p+1 + main_fields=224*p + main_rank=16*p+9 + inventories=[Counter(HELPERS) for _ in range(calls)] + paid=split_profile(NATIVE,minimum-1) + paid=Counter({r:calls*n for r,n in paid.items()}) + paid[1]+=8*calls # same-width H completion, never waived + targets=Counter({main_rank:main_fields}) + if p==1: + need(pairs is None and middle is None, 'p1 has no original idle bins') + else: + pairs=pairs if pairs is not None else [(224,0,0)] + middle=middle if middle is not None else [(224,0)] + need(sum(n for n,a,b in pairs)==224, 'Each pair window has 224 bins') + need(sum(n for n,a in middle)==224, 'Middle window has 224 bins') + for stages in [(0,1),(3,4)]: + for n,a,b in pairs: + need(a+b<=16 and a in (0,5,6,7,8,9) and b in (0,5,6,7,8,9), 'Pair capacities') + for stage,r in zip(stages,(a,b)): + if r: + inventories[stage][r]-=n + add_scaled(paid,split_rank(16-a-b,minimum-1),n) + for n,r in middle: + need(r in (0,5,6,7,8), 'Middle capacity') + if r: + inventories[2][r]-=n + add_scaled(paid,split_rank(8-r,minimum-1),n) + global_roles=Counter() + for inventory in inventories: + need(all(n>=0 for n in inventory.values()), 'No helper role used twice') + global_roles.update(inventory) + for r,n in global_roles.items(): + if not n: + continue + target=max(r,minimum) + targets[target]+=n + add_scaled(paid,split_rank(target-r,minimum-1),n) + paid=+paid + targets=+targets + need(max(paid)0] + # Middle bins are independent single slots; choose positive-gain roles first. + candidates=sorted(((sp(8)-sp(8-r)-value(r),r) for r in (5,6,7,8)),reverse=True) + middle=[] + left=224 + for gain,r in candidates: + if gain>1e-12: + n=min(HELPERS[r],left) + if n: + middle.append((n,r)) + left-=n + if left: + middle.append((left,0)) + return pairs,middle,{'status':int(out.status),'message':out.message,'not_an_exact_optimality_claim':True} + +def run(discover=False): + candidates=[] + for p in (1,2): + for minimum in range(2,26): + candidates.append(base_case(p,minimum)) + candidates.append(base_case(2,9,OLD_PAIRS,OLD_MIDDLE)) + discovery=[] + if discover: + for c in (.001745,.004): + for minimum in range(5,18): + pairs,middle,meta=discover_pair_patterns(minimum,c) + case=base_case(2,minimum,pairs,middle) + case['discovery_target']=str(c) + case['solver']=meta + discovery.append(case) + candidates.extend(discovery) + best={} + for p in (1,2): + for text in ('0.001745','0.004'): + c=Q(text) + rows=[case for case in candidates if case['p']==p] + ranked=sorted(rows,key=lambda case:-numerical_value(case['signed'],float(c))) + winner=ranked[0] + # Certify that this displayed winner beats all numerically distinct + # profiles in the finite scanned menu, not all possible schedules. + win=moment(winner['signed'],c) + for case in ranked[1:]: + if dict(case['signed'])!=dict(winner['signed']): + need(win[0]>moment(case['signed'],c)[1], 'Exact finite-menu ordering') + best[f'p{p}_{text}']=serialize_case(winner) + controls={} + wrong=base_case(1,6) + wrong['targets'][6]+=1 + controls['unearned_output_credit_rejected']=(sum(r*n for r,n in wrong['targets'].items())-wrong['rank_bill']!=wrong['rank_margin']) + controls['rank5_child_with_job5_rejected']=not(5<5) + need(all(controls.values()), 'Corruption controls') + return {'schema':'productive-helper-mixed-target-tariff/1', + 'status':'PASS_CONDITIONAL_EXACT_ACCOUNTING', + 'source_sha256':sha256(Path(__file__).read_bytes()).hexdigest(), + 'native_profile':dict(NATIVE),'helper_inventory':dict(HELPERS), + 'assumed_recursive_rule':'sum_paid n_r r^(1-C) < sum_targets W_k k^(1-C); max_paid_rank < min_target_rank', + 'best_in_finite_menu':best, + 'fixed_p2_minimum9':serialize_case(base_case(2,9,OLD_PAIRS,OLD_MIDDLE)), + 'discovery_candidates':[serialize_case(c) for c in discovery], + 'controls':controls, + 'not_proved':['native whole-helper adapters and arbitrary-input block diagonal contract', + 'correct main controller and all its heads/caches/cleanup', + 'literal eligibility of any displayed head-cut grant', + 'mixed-target all-size recursion in this native model', + 'finite-precision integer-multiplication transfer and scalar/stock costs'], + 'new_kappa':False} + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--discover',action='store_true') + parser.add_argument('--output',type=Path,default=HERE/'MIXED-TARGET-PROBE.json') + args=parser.parse_args() + result=run(args.discover) + args.output.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({'status':result['status'],'best':{k:v['targets_at_C'][k.split('_',1)[1]]['after_native_completion_before_main_closure'] for k,v in result['best_in_finite_menu'].items()}},sort_keys=True)) + +if __name__=='__main__': + main() diff --git a/research/hyperplane-retiming/vendor/research/fresh-helper-boundary/CHANGES.json b/research/hyperplane-retiming/vendor/research/fresh-helper-boundary/CHANGES.json new file mode 100644 index 0000000000..45744fedd0 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/fresh-helper-boundary/CHANGES.json @@ -0,0 +1,562 @@ +{ + "entrances": [ + [448, 114, 0], + [449, 114, 0], + [450, 115, 0], + [451, 115, 0], + [452, 115, 0], + [453, 115, 0], + [454, 114, 0], + [455, 114, 0], + [457, 116, 0], + [458, 116, 0], + [460, 117, 0], + [462, 117, 0], + [473, 114, 0], + [474, 118, 0], + [475, 118, 0], + [476, 119, 0], + [477, 119, 0], + [478, 120, 0], + [480, 120, 0], + [482, 114, 0], + [483, 114, 0], + [484, 121, 0], + [485, 121, 0], + [486, 122, 0], + [487, 122, 0], + [492, 115, 0], + [493, 115, 0], + [502, 115, 0], + [503, 115, 0], + [504, 115, 0], + [513, 115, 0], + [514, 115, 0], + [515, 115, 0], + [516, 123, 0], + [517, 123, 0], + [518, 124, 0], + [519, 124, 0], + [520, 125, 0], + [521, 125, 0], + [522, 126, 0], + [523, 126, 0], + [524, 115, 0], + [525, 115, 0], + [526, 115, 0], + [527, 115, 0], + [528, 127, 0], + [529, 127, 0], + [530, 128, 0], + [531, 128, 0], + [532, 129, 0], + [533, 129, 0], + [534, 130, 0], + [535, 130, 0], + [536, 115, 0], + [537, 115, 0], + [538, 131, 114], + [539, 114, 0], + [544, 132, 0], + [545, 132, 0], + [546, 133, 0], + [547, 133, 0], + [548, 114, 0], + [549, 114, 0], + [550, 114, 0], + [551, 114, 0], + [553, 134, 0], + [555, 134, 0], + [556, 135, 0], + [557, 135, 0], + [558, 136, 0], + [559, 136, 0], + [563, 134, 0], + [565, 134, 0], + [570, 134, 0], + [571, 134, 0], + [572, 134, 0], + [573, 134, 0], + [578, 114, 0], + [579, 114, 0], + [580, 115, 0], + [581, 115, 0], + [582, 115, 0], + [583, 115, 0], + [585, 114, 0], + [586, 137, 0], + [587, 137, 0], + [588, 137, 0], + [589, 137, 0], + [590, 138, 0], + [591, 137, 0], + [592, 137, 0], + [593, 137, 0], + [596, 137, 0], + [597, 137, 0], + [598, 114, 0], + [599, 114, 0], + [600, 114, 0], + [601, 114, 0], + [606, 115, 0], + [607, 115, 0], + [608, 115, 0], + [609, 115, 0], + [610, 115, 0], + [611, 115, 0], + [612, 115, 0], + [614, 115, 0], + [615, 115, 0], + [616, 115, 0], + [617, 115, 0], + [618, 115, 0], + [619, 115, 0], + [620, 115, 0], + [621, 140, 0], + [622, 114, 0], + [623, 114, 0], + [624, 114, 0], + [625, 114, 0] + ], + "exits": [ + [277, 256, 299], + [282, 257, 299], + [293, 258, 301], + [298, 258, 301], + [307, 261, 303], + [309, 261, 303], + [311, 262, 1], + [314, 263, 303], + [323, 265, 304], + [325, 266, 304], + [327, 267, 1], + [330, 268, 304], + [337, 270, 305], + [339, 270, 305], + [341, 271, 305], + [346, 271, 305], + [353, 272, 307], + [355, 272, 307], + [357, 273, 307], + [362, 273, 307], + [369, 275, 308], + [371, 275, 308], + [373, 275, 308], + [378, 276, 308], + [385, 277, 309], + [387, 277, 309], + [389, 278, 309], + [394, 278, 309], + [494, 262, 1], + [495, 262, 1], + [505, 267, 1], + [506, 267, 1], + [548, 285, 1], + [560, 285, 1], + [566, 286, 279], + [567, 286, 279], + [568, 287, 280], + [569, 287, 280], + [574, 288, 279], + [575, 288, 279], + [576, 289, 281], + [577, 289, 281] + ], + "gates": [ + ["A", 626, 115, 0], + ["A", 627, 115, 0], + ["A", 628, 115, 0], + ["A", 629, 114, 0], + ["A", 630, 114, 0], + ["A", 631, 114, 0], + ["A", 632, 114, 0], + ["A", 633, 114, 0], + ["A", 1762, 134, 0], + ["A", 1763, 134, 0], + ["A", 1764, 134, 0], + ["A", 1765, 134, 0], + ["A", 1766, 134, 0], + ["A", 1767, 134, 0], + ["A", 1768, 134, 0], + ["A", 1769, 134, 0], + ["A", 1770, 134, 0], + ["A", 1771, 134, 0], + ["A", 1772, 134, 0], + ["A", 1773, 134, 0], + ["A", 1774, 134, 0], + ["A", 1775, 134, 0], + ["A", 1776, 134, 0], + ["A", 1777, 134, 0], + ["A", 1778, 134, 0], + ["A", 1779, 134, 0], + ["A", 1780, 134, 0], + ["A", 1781, 134, 0], + ["A", 1782, 134, 0], + ["A", 1783, 134, 0], + ["A", 1784, 134, 0], + ["A", 1785, 134, 0], + ["A", 1786, 134, 0], + ["A", 1787, 116, 0], + ["A", 1788, 119, 0], + ["A", 1789, 119, 0], + ["A", 1790, 119, 0], + ["A", 1791, 119, 0], + ["A", 1792, 117, 0], + ["A", 1793, 124, 0], + ["A", 1794, 124, 0], + ["A", 1795, 120, 0], + ["A", 1796, 124, 0], + ["A", 1797, 124, 0], + ["A", 1798, 125, 0], + ["A", 1799, 125, 0], + ["A", 1800, 125, 0], + ["A", 1801, 125, 0], + ["A", 1802, 135, 0], + ["A", 1803, 135, 0], + ["A", 1804, 117, 0], + ["A", 1805, 128, 0], + ["A", 1806, 128, 0], + ["A", 1807, 128, 0], + ["A", 1808, 128, 0], + ["A", 1809, 120, 0], + ["A", 1810, 130, 0], + ["A", 1811, 130, 0], + ["A", 1812, 130, 0], + ["A", 1813, 130, 0], + ["A", 1814, 133, 0], + ["A", 1815, 133, 0], + ["A", 1816, 116, 0], + ["A", 1817, 122, 0], + ["A", 1818, 122, 0], + ["A", 1819, 122, 0], + ["A", 1820, 122, 0], + ["A", 1821, 129, 0], + ["A", 1822, 129, 0], + ["A", 1823, 129, 0], + ["A", 1824, 129, 0], + ["A", 1825, 132, 0], + ["A", 1826, 132, 0], + ["A", 1827, 126, 0], + ["A", 1828, 126, 0], + ["A", 1829, 126, 0], + ["A", 1830, 126, 0], + ["A", 1831, 136, 0], + ["A", 1832, 136, 0], + ["A", 1833, 118, 0], + ["A", 1834, 118, 0], + ["A", 1835, 118, 0], + ["A", 1836, 118, 0], + ["A", 1837, 127, 0], + ["A", 1838, 127, 0], + ["A", 1839, 127, 0], + ["A", 1840, 127, 0], + ["A", 1841, 123, 0], + ["A", 1842, 123, 0], + ["A", 1843, 123, 0], + ["A", 1844, 123, 0], + ["A", 1845, 121, 0], + ["A", 1846, 121, 0], + ["A", 1847, 121, 0], + ["A", 1848, 121, 0], + ["A", 4031, 620, 621], + ["A", 4037, 622, 280], + ["B", 0, 115, 0], + ["B", 1, 115, 0], + ["B", 2, 115, 0], + ["B", 3, 115, 0], + ["B", 4, 115, 0], + ["B", 5, 115, 0], + ["B", 6, 115, 0], + ["B", 7, 115, 0], + ["B", 8, 114, 0], + ["B", 9, 114, 0], + ["B", 10, 114, 0], + ["B", 15, 114, 0], + ["B", 16, 114, 0], + ["B", 17, 114, 0], + ["B", 18, 114, 0], + ["B", 19, 115, 0], + ["B", 20, 115, 0], + ["B", 21, 115, 0], + ["B", 22, 115, 0], + ["B", 23, 115, 0], + ["B", 24, 115, 0], + ["B", 25, 115, 0], + ["B", 26, 115, 0], + ["B", 27, 114, 0], + ["B", 28, 114, 0], + ["B", 29, 114, 0], + ["B", 30, 114, 0], + ["B", 32, 114, 0], + ["B", 33, 114, 0], + ["B", 34, 114, 0], + ["B", 35, 115, 0], + ["B", 36, 115, 0], + ["B", 37, 115, 0], + ["B", 38, 115, 0], + ["B", 39, 115, 0], + ["B", 40, 115, 0], + ["B", 41, 115, 0], + ["B", 42, 115, 0], + ["B", 43, 114, 0], + ["B", 44, 114, 0], + ["B", 45, 114, 0], + ["B", 46, 114, 0], + ["B", 47, 114, 0], + ["B", 48, 114, 0], + ["B", 49, 115, 0], + ["B", 50, 115, 0], + ["B", 51, 115, 0], + ["B", 52, 115, 0], + ["B", 53, 115, 0], + ["B", 54, 115, 0], + ["B", 55, 115, 0], + ["B", 56, 115, 0], + ["B", 57, 114, 0], + ["B", 60, 114, 0], + ["B", 61, 137, 0], + ["B", 62, 137, 0], + ["B", 63, 137, 0], + ["B", 64, 137, 0], + ["B", 65, 137, 0], + ["B", 66, 137, 0], + ["B", 67, 137, 0], + ["B", 68, 137, 0], + ["B", 69, 137, 0], + ["B", 70, 137, 0], + ["B", 71, 137, 0], + ["B", 72, 137, 0], + ["B", 73, 137, 0], + ["B", 74, 137, 0], + ["B", 75, 137, 0], + ["B", 76, 137, 0], + ["B", 77, 137, 0], + ["B", 78, 137, 0], + ["B", 79, 137, 0], + ["B", 80, 137, 0], + ["B", 81, 137, 0], + ["B", 82, 137, 0], + ["B", 83, 137, 0], + ["B", 84, 137, 0], + ["B", 85, 137, 0], + ["B", 86, 137, 0], + ["B", 87, 137, 0], + ["B", 88, 137, 0], + ["B", 89, 137, 0], + ["B", 90, 137, 0], + ["B", 91, 137, 0], + ["B", 92, 137, 0], + ["B", 93, 137, 0], + ["B", 94, 137, 0], + ["B", 95, 137, 0], + ["B", 96, 137, 0], + ["B", 97, 114, 0], + ["B", 98, 114, 0], + ["B", 99, 114, 0], + ["B", 100, 114, 0], + ["B", 101, 114, 0], + ["B", 102, 114, 0], + ["B", 103, 114, 0], + ["B", 104, 114, 0], + ["B", 105, 114, 0], + ["B", 106, 114, 0], + ["B", 107, 114, 0], + ["B", 108, 114, 0], + ["B", 109, 114, 0], + ["B", 110, 114, 0], + ["B", 111, 114, 0], + ["B", 112, 114, 0], + ["B", 113, 114, 0], + ["B", 114, 114, 0], + ["B", 135, 115, 0], + ["B", 136, 115, 0], + ["B", 137, 115, 0], + ["B", 138, 115, 0], + ["B", 139, 115, 0], + ["B", 140, 115, 0], + ["B", 141, 115, 0], + ["B", 142, 115, 0], + ["B", 143, 115, 0], + ["B", 144, 115, 0], + ["B", 145, 115, 0], + ["B", 146, 115, 0], + ["B", 147, 115, 0], + ["B", 148, 115, 0], + ["B", 149, 115, 0], + ["B", 150, 115, 0], + ["B", 151, 115, 0], + ["B", 152, 115, 0], + ["B", 153, 115, 0], + ["B", 154, 115, 0], + ["B", 155, 115, 0], + ["B", 156, 115, 0], + ["B", 157, 115, 0], + ["B", 158, 115, 0], + ["B", 159, 115, 0], + ["B", 160, 115, 0], + ["B", 161, 115, 0], + ["B", 162, 115, 0], + ["B", 163, 115, 0], + ["B", 164, 115, 0], + ["B", 165, 115, 0], + ["B", 166, 115, 0], + ["B", 167, 115, 0], + ["B", 168, 115, 0], + ["B", 169, 115, 0], + ["B", 170, 115, 0], + ["B", 171, 115, 0], + ["B", 172, 115, 0], + ["B", 173, 115, 0], + ["B", 174, 115, 0], + ["B", 175, 115, 0], + ["B", 176, 115, 0], + ["B", 177, 115, 0], + ["B", 178, 115, 0], + ["B", 179, 115, 0], + ["B", 180, 115, 0], + ["B", 181, 115, 0], + ["B", 182, 115, 0], + ["B", 183, 115, 0], + ["B", 184, 115, 0], + ["B", 185, 115, 0], + ["B", 186, 115, 0], + ["B", 187, 115, 0], + ["B", 188, 115, 0], + ["B", 189, 115, 0], + ["B", 190, 115, 0], + ["B", 191, 115, 0], + ["B", 192, 115, 0], + ["B", 193, 115, 0], + ["B", 194, 115, 0], + ["B", 195, 115, 0], + ["B", 196, 115, 0], + ["B", 197, 115, 0], + ["B", 198, 115, 0], + ["B", 199, 114, 0], + ["B", 200, 114, 0], + ["B", 201, 114, 0], + ["B", 202, 114, 0], + ["B", 203, 114, 0], + ["B", 204, 114, 0], + ["B", 205, 114, 0], + ["B", 206, 114, 0], + ["B", 207, 114, 0], + ["B", 208, 114, 0], + ["B", 209, 114, 0], + ["B", 210, 114, 0], + ["B", 211, 114, 0], + ["B", 212, 114, 0], + ["B", 213, 114, 0], + ["B", 214, 114, 0], + ["B", 234, 114, 0], + ["B", 235, 114, 0], + ["B", 236, 114, 0], + ["B", 237, 114, 0], + ["B", 474, 138, 0], + ["B", 475, 731, 360], + ["B", 503, 743, 371], + ["B", 504, 744, 372], + ["B", 505, 745, 373], + ["B", 506, 746, 374], + ["B", 507, 747, 375], + ["B", 508, 748, 376], + ["B", 509, 749, 377], + ["B", 510, 750, 378], + ["B", 511, 751, 391], + ["B", 512, 752, 392], + ["B", 513, 753, 393], + ["B", 514, 754, 394], + ["B", 515, 755, 395], + ["B", 516, 756, 396], + ["B", 517, 757, 397], + ["B", 518, 758, 398], + ["B", 521, 256, 299], + ["B", 526, 257, 299], + ["B", 533, 765, 411], + ["B", 534, 766, 412], + ["B", 535, 767, 413], + ["B", 536, 768, 414], + ["B", 537, 769, 415], + ["B", 538, 770, 416], + ["B", 539, 771, 417], + ["B", 540, 772, 418], + ["B", 559, 779, 431], + ["B", 560, 780, 432], + ["B", 561, 781, 433], + ["B", 562, 782, 434], + ["B", 563, 783, 435], + ["B", 564, 784, 436], + ["B", 565, 785, 437], + ["B", 566, 786, 438], + ["B", 571, 261, 303], + ["B", 575, 263, 303], + ["B", 576, 263, 303], + ["B", 601, 268, 304], + ["B", 602, 268, 304], + ["B", 622, 271, 305], + ["B", 624, 270, 305], + ["B", 627, 271, 305], + ["B", 629, 270, 305], + ["B", 630, 140, 0], + ["B", 635, 801, 491], + ["B", 636, 802, 492], + ["B", 637, 803, 493], + ["B", 638, 804, 494], + ["B", 639, 805, 495], + ["B", 640, 806, 496], + ["B", 641, 807, 497], + ["B", 642, 808, 498], + ["B", 661, 813, 511], + ["B", 662, 814, 512], + ["B", 663, 815, 513], + ["B", 664, 816, 514], + ["B", 665, 817, 515], + ["B", 666, 818, 516], + ["B", 667, 819, 517], + ["B", 668, 820, 518], + ["B", 673, 275, 308], + ["B", 678, 276, 308], + ["B", 684, 131, 114], + ["cleanup_tail", 0, 286, 279], + ["cleanup_tail", 1, 286, 279], + ["cleanup_tail", 2, 286, 279], + ["cleanup_tail", 3, 287, 280], + ["cleanup_tail", 4, 287, 280], + ["cleanup_tail", 5, 287, 280], + ["cleanup_tail", 6, 288, 279], + ["cleanup_tail", 7, 288, 279], + ["cleanup_tail", 8, 288, 279], + ["cleanup_tail", 9, 289, 281], + ["cleanup_tail", 10, 289, 281], + ["cleanup_tail", 11, 289, 281], + ["cleanup_tail", 12, 262, 1], + ["cleanup_tail", 13, 262, 1], + ["cleanup_tail", 14, 262, 1], + ["cleanup_tail", 15, 267, 1], + ["cleanup_tail", 16, 267, 1], + ["cleanup_tail", 17, 267, 1], + ["cleanup_tail", 18, 267, 1], + ["cleanup_tail", 19, 267, 1], + ["cleanup_tail", 40, 262, 1], + ["cleanup_tail", 41, 262, 1], + ["cleanup_tail", 42, 262, 1], + ["cleanup_tail", 43, 262, 1], + ["cleanup_tail", 44, 262, 1], + ["cleanup_tail", 45, 262, 1], + ["cleanup_tail", 46, 262, 1], + ["cleanup_tail", 53, 267, 1], + ["cleanup_tail", 54, 267, 1], + ["cleanup_tail", 67, 285, 1], + ["cleanup_tail", 68, 285, 1], + ["cleanup_tail", 69, 285, 1], + ["cleanup_tail", 77, 285, 1], + ["cleanup_tail", 78, 285, 1], + ["cleanup_tail", 112, 267, 1], + ["cleanup_tail", 113, 267, 1], + ["cleanup_tail", 114, 267, 1], + ["cleanup_tail", 115, 267, 1], + ["cleanup_tail", 118, 262, 1], + ["cleanup_tail", 119, 262, 1], + ["cleanup_tail", 120, 262, 1] + ] +} diff --git a/research/hyperplane-retiming/vendor/research/fresh-helper-boundary/native.py b/research/hyperplane-retiming/vendor/research/fresh-helper-boundary/native.py new file mode 100644 index 0000000000..1b36f6cb5f --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/fresh-helper-boundary/native.py @@ -0,0 +1,183 @@ +"""Retiming of the pinned full-identity word; Apache-2.0, OpenAI Codex assistance. + +The scalar order and free-operator words stay fixed. Every changed transport +is independently lowered as an exact Clifford, including its absolute phase. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +import gzip +import importlib.util +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = ROOT/'research/kappa-rebuild/complex/full-identity-certificates' + +def need(ok, why): + if not ok: + raise ValueError(why) + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + m = importlib.util.module_from_spec(spec) + sys.modules[name] = m + spec.loader.exec_module(m) + return m + +def read(path): + data = Path(path).read_bytes() + return json.loads(gzip.decompress(data) if str(path).endswith('.gz') else data) + +def span(basis): + out = {0} + for x in basis: + out |= {v ^ x for v in tuple(out)} + return frozenset(out) + +def gates(program): + phase = None + counters = Counter() + result = {} + for i, e in enumerate(program): + if e[0] == 'phase': + phase = e[1] + if e[0] == 'scalar': + g = e[1] + roles = g[1:3] if g[0] in ('add', 'copy') else g[1:2] + if all(r[0] == 'L' for r in roles): + key = (phase, counters[phase]) + result[key] = i + counters[phase] += 1 + return result + +def dual(g): + g = deepcopy(g) + if g[0] == 'add': + g[1], g[2] = g[2], g[1] + g[3] *= -1 + else: + need(g[0] == 'scale', 'Reversible persistent scalar') + g[2], g[3] = g[3], g[2] + return g + +def synthesize(c, program): + current = c['start'][:] + out = [] + def climb(r, f): + old = current[r] + if old == f: + return + need(span(c['frames'][old]) < span(c['frames'][f]), 'Nested positive retimed transport') + out.append(['climb', 'retimed', r, old, f, len(c['frames'][f])-len(c['frames'][old])]) + current[r] = f + i = 0 + while i < len(program): + e = deepcopy(program[i]); i += 1 + if e[0] == 'climb': + continue + if e[0] == 'center': + second = program[i] + need(second[0] == 'center' and e[1] == second[1] == 0 and e[3] == second[2], 'Original center split') + need(sorted((e[4], second[4])) == [3, 5], 'Original 3+5 center') + e = ['center', 0, e[2], second[3], 8]; i += 1 + if e[0] == 'scalar': + g = e[1] + roles = g[1:3] if g[0] in ('add', 'copy') else g[1:2] + for r in roles: + if r[0] == 'L': + climb(r[1], e[2]) + elif e[0] == 'warp': + need(e[1][0] == 'L', 'Persistent source warp') + climb(e[1][1], e[3]); current[e[1][1]] = e[4] + elif e[0] in ('adapter', 'residual_adapter'): + # Helper wrappers are recomputed on the new whole-job boundaries. + role = e[2] if e[0] == 'adapter' else e[2] + if role >= 224: + continue + out.append(e) + for r, f in enumerate(c['final']): + climb(r, f) + return out + +def run(changes=None, phase_check=True): + c = read(BASE/'THREE-base-FULL-IDENTITY-CANONICAL.json.gz') + original = read(BASE/'THREE-base-FULL-IDENTITY-NATIVE.json.gz') + changes = read(HERE/'CHANGES.json') if changes is None else changes + for key, frame_key in (('entrances', 'start'), ('exits', 'final')): + seen = set() + for role, old, new in changes[key]: + need(role not in seen and 224 <= role < 632 and c[frame_key][role] == old, 'Bound unique helper boundary') + seen.add(role); c[frame_key][role] = new + maps = {d: gates(p) for d, p in original.items()} + need(set(maps['forward']) == set(maps['backward']), 'Both scalar orientations have the same contact inventory') + for key in maps['forward']: + f = original['forward'][maps['forward'][key]] + b = original['backward'][maps['backward'][key]] + need(b[1] == dual(f[1]) and b[2] == f[2], 'Actual inverse-transpose scalar correspondence') + changed = deepcopy(original) + seen = set() + for phase, ordinal, old, new in changes['gates']: + key = (phase, ordinal) + need(key not in seen and key in maps['forward'], 'Bound unique retimed scalar contact') + seen.add(key) + for d in changed: + e = changed[d][maps[d][key]] + need(e[2] == old, 'Original scalar frame pin') + e[2] = new + programs = {d: synthesize(c, p) for d, p in changed.items()} + V = load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py', 'fresh_boundary_rows') + X = load(ROOT/'research/kappa-rebuild/complex/native_extensions.py', 'fresh_boundary_literal') + checks = {} + profiles = {} + for d, p in programs.items(): + rows, receipt = X.literal_replay(V, c, p, d == 'backward') + for r in range(632): + need(rows['L', r] == V.expected(('L', r), [], d == 'backward', False), 'Every actual arbitrary-input endpoint, role '+str(r)) + profiles[d] = Counter({int(k): v for k, v in receipt['paid_profile'].items()}) + rebound = deepcopy(c) + rebound['local_profile'] = dict(profiles[d]) + receipt['second_literal'] = V.replay(p, rebound, [], d == 'backward', False) + checks[d] = receipt + need(profiles['forward'] == profiles['backward'], 'Same complete native tariff in both orientations') + H = Counter() + for r in range(224, 632): + a, b = c['start'][r], c['final'][r] + need(span(c['frames'][a]) <= span(c['frames'][b]), 'Nested productive helper boundary') + width = len(c['frames'][b])-len(c['frames'][a]) + need(width > 0, 'Every declared helper is independently productive') + H[width] += 1 + physical = [] + if phase_check: + ce = load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py', 'fresh_boundary_clifford') + P = load(ROOT/'research/kappa-function-composition/complex/prune_native.py', 'fresh_boundary_lowering') + N = X.N + old_edges = {(e[3], e[4]) for e in original['forward'] if e[0] == 'climb'} + new_edges = {(e[3], e[4]) for e in programs['forward'] if e[0] == 'climb'} + helper_edges = {(c['start'][r], c['final'][r]) for r in range(224, 632)} + for a, b in sorted((new_edges-old_edges) | helper_edges): + op = ce.canonical_frame(9, c['frames'][a]).adjoint().then(ce.canonical_frame(9, c['frames'][b])) + want = len(c['frames'][b])-len(c['frames'][a]) + directions = {} + for d in ('forward', 'backward'): + actual = P.conjugate(ce, op) if d == 'backward' else op + rec = N.lower_exact(P, ce, actual) + need(rec['rank'] == want, 'New physical Fourier rank including phase') + directions[d] = rec + physical.append({'old': a, 'new': b, 'rank': want, 'recipes': directions}) + return {'status': 'PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS', + 'helpers': dict(sorted(H.items())), 'paid': dict(sorted(profiles['forward'].items())), + 'changed_entrances': len(changes['entrances']), 'changed_exits': len(changes['exits']), + 'changed_scalar_frames': len(changes['gates']), 'native': checks, + 'new_physical_edges_and_boundaries': physical}, c, programs + +if __name__ == '__main__': + import argparse + p = argparse.ArgumentParser(); p.add_argument('--skip-phase', action='store_true'); p.add_argument('--write-result', action='store_true'); args = p.parse_args() + result, _, _ = run(phase_check=not args.skip_phase) + if args.write_result: + need(not args.skip_phase, 'Do not replace a complete phase receipt with a diagnostic') + (HERE/'NATIVE-RESULT.json.gz').write_bytes(gzip.compress((json.dumps(result, indent=2, sort_keys=True)+'\n').encode(),mtime=0)) + print(json.dumps({k: v for k, v in result.items() if k not in ('native', 'new_physical_edges_and_boundaries')}, sort_keys=True)) diff --git a/research/hyperplane-retiming/vendor/research/joint-helper-lattice/PATCH.json b/research/hyperplane-retiming/vendor/research/joint-helper-lattice/PATCH.json new file mode 100644 index 0000000000..51304a6601 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/joint-helper-lattice/PATCH.json @@ -0,0 +1,8991 @@ +{ + "changes": [ + { + "new": [ + 51 + ], + "old": [], + "ordinal": 449, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 451, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 453, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 455, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 482, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 483, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 502, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 503, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 504, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 525, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 526, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 527, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 548, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 549, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 550, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 551, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 578, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 580, + "phase": "entrance" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 594, + "phase": "entrance" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 595, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 598, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 599, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 600, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 601, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 606, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 607, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 608, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 609, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 614, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 615, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 616, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 617, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 622, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 623, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 624, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 625, + "phase": "entrance" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 626, + "phase": "entrance" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 627, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 627, + "phase": "A" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 628, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 629, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 630, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 631, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 632, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 633, + "phase": "A" + }, + { + "new": [ + 11, + 21, + 38, + 448 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 1997, + "phase": "A" + }, + { + "new": [ + 11, + 21, + 38, + 448 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2002, + "phase": "A" + }, + { + "new": [ + 45, + 85, + 133, + 261 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2151, + "phase": "A" + }, + { + "new": [ + 45, + 85, + 133, + 261 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2156, + "phase": "A" + }, + { + "new": [ + 14, + 35, + 69, + 400 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2305, + "phase": "A" + }, + { + "new": [ + 14, + 35, + 69, + 400 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2310, + "phase": "A" + }, + { + "new": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4007, + "phase": "A" + }, + { + "new": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4008, + "phase": "A" + }, + { + "new": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4013, + "phase": "A" + }, + { + "new": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4014, + "phase": "A" + }, + { + "new": [ + 2, + 4, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 4019, + "phase": "A" + }, + { + "new": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 4025, + "phase": "A" + }, + { + "new": [ + 2, + 4, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "old": [ + 4, + 10, + 16, + 35, + 65, + 128, + 256 + ], + "ordinal": 4043, + "phase": "A" + }, + { + "new": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "old": [ + 1, + 14, + 16, + 34, + 68, + 128, + 256 + ], + "ordinal": 4049, + "phase": "A" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 5, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 6, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 7, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 8, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 9, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 10, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 17, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 18, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 21, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 22, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 25, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 26, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 29, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 30, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 33, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 34, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 37, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 38, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 41, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 42, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 44, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 45, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 47, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 49, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 50, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 97, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 98, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 99, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 100, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 101, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 102, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 103, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 104, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 105, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 106, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 107, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 108, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 109, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 110, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 111, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 112, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 113, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 114, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 135, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 136, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 137, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 138, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 139, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 140, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 141, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 142, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 143, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 144, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 145, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 146, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 147, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 148, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 149, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 150, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 151, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 152, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 153, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 154, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 171, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 172, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 173, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 174, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 175, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 176, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 177, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 178, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 179, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 180, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 181, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 182, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 183, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 184, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 185, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 186, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 199, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 200, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 201, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 202, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 203, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 204, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 205, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 206, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 207, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 208, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 209, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 210, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 211, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 212, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 213, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 214, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 234, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 235, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 236, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 237, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 238, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 239, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 240, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 241, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 242, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 243, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 244, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 245, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 246, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 247, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 248, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 249, + "phase": "B" + }, + { + "new": [ + 7, + 42, + 80, + 144, + 256 + ], + "old": [ + 45, + 80, + 144, + 256 + ], + "ordinal": 332, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 208, + 336 + ], + "old": [ + 5, + 11, + 35, + 208, + 336 + ], + "ordinal": 335, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 80, + 400 + ], + "old": [ + 5, + 11, + 35, + 80, + 400 + ], + "ordinal": 336, + "phase": "B" + }, + { + "new": [ + 7, + 16, + 42, + 64, + 128, + 256 + ], + "old": [ + 16, + 45, + 64, + 128, + 256 + ], + "ordinal": 337, + "phase": "B" + }, + { + "new": [ + 7, + 9, + 16, + 35, + 64, + 128, + 256 + ], + "old": [ + 14, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 338, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 16, + 33, + 192, + 320 + ], + "old": [ + 5, + 11, + 16, + 35, + 192, + 320 + ], + "ordinal": 339, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 80, + 128, + 272 + ], + "old": [ + 5, + 11, + 35, + 80, + 128, + 272 + ], + "ordinal": 340, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 80, + 144, + 256 + ], + "old": [ + 5, + 11, + 35, + 80, + 144, + 256 + ], + "ordinal": 341, + "phase": "B" + }, + { + "new": [ + 45, + 73, + 137, + 286 + ], + "old": [ + 25, + 45, + 73, + 137, + 263 + ], + "ordinal": 353, + "phase": "B" + }, + { + "new": [ + 45, + 87, + 137, + 265 + ], + "old": [ + 25, + 45, + 78, + 137, + 265 + ], + "ordinal": 355, + "phase": "B" + }, + { + "new": [ + 45, + 80, + 146, + 261 + ], + "old": [ + 2, + 45, + 80, + 144, + 261 + ], + "ordinal": 374, + "phase": "B" + }, + { + "new": [ + 5, + 40, + 194, + 265 + ], + "old": [ + 5, + 40, + 82, + 144, + 265 + ], + "ordinal": 376, + "phase": "B" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 388, + "phase": "B" + }, + { + "new": [ + 45, + 400 + ], + "old": [ + 45, + 76, + 400 + ], + "ordinal": 389, + "phase": "B" + }, + { + "new": [ + 45, + 69, + 400 + ], + "old": [ + 9, + 36, + 69, + 400 + ], + "ordinal": 394, + "phase": "B" + }, + { + "new": [ + 45, + 69, + 146, + 272 + ], + "old": [ + 9, + 36, + 69, + 146, + 272 + ], + "ordinal": 397, + "phase": "B" + }, + { + "new": [ + 45, + 69, + 130, + 274 + ], + "old": [ + 9, + 36, + 69, + 130, + 274 + ], + "ordinal": 398, + "phase": "B" + }, + { + "new": [ + 45, + 73, + 144, + 274 + ], + "old": [ + 5, + 40, + 73, + 144, + 274 + ], + "ordinal": 399, + "phase": "B" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 410, + "phase": "B" + }, + { + "new": [ + 45, + 475 + ], + "old": [ + 45, + 76, + 407 + ], + "ordinal": 411, + "phase": "B" + }, + { + "new": [ + 14, + 35, + 469 + ], + "old": [ + 14, + 35, + 66, + 407 + ], + "ordinal": 416, + "phase": "B" + }, + { + "new": [ + 14, + 35, + 130, + 341 + ], + "old": [ + 14, + 35, + 66, + 130, + 279 + ], + "ordinal": 419, + "phase": "B" + }, + { + "new": [ + 14, + 35, + 215, + 258 + ], + "old": [ + 14, + 35, + 66, + 149, + 258 + ], + "ordinal": 420, + "phase": "B" + }, + { + "new": [ + 28, + 45, + 199, + 268 + ], + "old": [ + 28, + 45, + 76, + 139, + 268 + ], + "ordinal": 421, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 40, + 217, + 256 + ], + "old": [ + 5, + 40, + 219, + 256 + ], + "ordinal": 440, + "phase": "B" + }, + { + "new": [ + 7, + 18, + 42, + 66, + 393 + ], + "old": [ + 21, + 45, + 69, + 398 + ], + "ordinal": 441, + "phase": "B" + }, + { + "new": [ + 7, + 42, + 66, + 130, + 258 + ], + "old": [ + 45, + 69, + 133, + 261 + ], + "ordinal": 442, + "phase": "B" + }, + { + "new": [ + 7, + 18, + 42, + 66, + 130, + 258 + ], + "old": [ + 21, + 45, + 69, + 133, + 261 + ], + "ordinal": 443, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 16, + 40, + 64, + 393 + ], + "old": [ + 5, + 16, + 40, + 64, + 395 + ], + "ordinal": 444, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 40, + 89, + 128, + 256 + ], + "old": [ + 5, + 40, + 91, + 128, + 256 + ], + "ordinal": 445, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 25, + 40, + 64, + 128, + 256 + ], + "old": [ + 5, + 27, + 40, + 64, + 128, + 256 + ], + "ordinal": 446, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 18, + 33, + 66, + 130, + 258 + ], + "old": [ + 11, + 21, + 38, + 69, + 133, + 261 + ], + "ordinal": 447, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 16, + 40, + 64, + 128, + 265 + ], + "old": [ + 5, + 16, + 40, + 64, + 128, + 267 + ], + "ordinal": 448, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 16, + 40, + 64, + 137, + 256 + ], + "old": [ + 5, + 16, + 40, + 64, + 139, + 256 + ], + "ordinal": 449, + "phase": "B" + }, + { + "new": [ + 28, + 45, + 194, + 258 + ], + "old": [ + 5, + 25, + 40, + 194, + 258 + ], + "ordinal": 461, + "phase": "B" + }, + { + "new": [ + 21, + 45, + 66, + 386 + ], + "old": [ + 12, + 21, + 33, + 66, + 386 + ], + "ordinal": 462, + "phase": "B" + }, + { + "new": [ + 5, + 40, + 137, + 336 + ], + "old": [ + 5, + 40, + 82, + 137, + 258 + ], + "ordinal": 483, + "phase": "B" + }, + { + "new": [ + 45, + 80, + 137, + 274 + ], + "old": [ + 2, + 45, + 80, + 137, + 272 + ], + "ordinal": 485, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 17, + 34, + 64, + 387 + ], + "old": [ + 4, + 17, + 34, + 64, + 395 + ], + "ordinal": 530, + "phase": "B" + }, + { + "new": [ + 3, + 8, + 17, + 33, + 68, + 388 + ], + "old": [ + 11, + 17, + 34, + 68, + 388 + ], + "ordinal": 532, + "phase": "B" + }, + { + "new": [ + 12, + 21, + 38, + 71, + 132, + 260 + ], + "old": [ + 21, + 38, + 75, + 132, + 260 + ], + "ordinal": 556, + "phase": "B" + }, + { + "new": [ + 11, + 18, + 33, + 64, + 132, + 260 + ], + "old": [ + 11, + 51, + 64, + 132, + 260 + ], + "ordinal": 558, + "phase": "B" + }, + { + "new": [ + 6, + 10, + 18, + 32, + 65, + 385 + ], + "old": [ + 10, + 20, + 38, + 65, + 385 + ], + "ordinal": 583, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 64, + 390 + ], + "old": [ + 1, + 10, + 20, + 64, + 422 + ], + "ordinal": 585, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 38, + 64, + 129, + 257 + ], + "old": [ + 30, + 38, + 64, + 129, + 257 + ], + "ordinal": 608, + "phase": "B" + }, + { + "new": [ + 11, + 21, + 33, + 71, + 129, + 257 + ], + "old": [ + 11, + 21, + 102, + 129, + 257 + ], + "ordinal": 610, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 24, + 32, + 64, + 394 + ], + "old": [ + 6, + 24, + 32, + 64, + 395 + ], + "ordinal": 632, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 96, + 416 + ], + "old": [ + 6, + 11, + 19, + 96, + 416 + ], + "ordinal": 634, + "phase": "B" + }, + { + "new": [ + 7, + 25, + 33, + 75, + 129, + 257 + ], + "old": [ + 30, + 38, + 75, + 134, + 262 + ], + "ordinal": 658, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 18, + 64, + 160, + 288 + ], + "old": [ + 11, + 21, + 64, + 160, + 288 + ], + "ordinal": 660, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [ + 3, + 48, + 72, + 413 + ], + "ordinal": 685, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 17, + 33, + 72, + 392 + ], + "old": [ + 3, + 21, + 37, + 72, + 392 + ], + "ordinal": 687, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 8, + 48, + 64, + 401 + ], + "old": [ + 3, + 8, + 48, + 64, + 405 + ], + "ordinal": 689, + "phase": "B" + }, + { + "new": [ + 7, + 18, + 33, + 64, + 136, + 264 + ], + "old": [ + 21, + 38, + 64, + 136, + 264 + ], + "ordinal": 711, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 51, + 82, + 131, + 259 + ], + "old": [ + 11, + 51, + 85, + 131, + 259 + ], + "ordinal": 713, + "phase": "B" + }, + { + "new": [ + 4, + 51, + 82, + 136, + 264 + ], + "old": [ + 4, + 51, + 136, + 264 + ], + "ordinal": 759, + "phase": "B" + }, + { + "new": [ + 30, + 32, + 76, + 129, + 257 + ], + "old": [ + 30, + 32, + 129, + 257 + ], + "ordinal": 769, + "phase": "B" + }, + { + "new": [ + 13, + 19, + 33, + 455 + ], + "old": [ + 13, + 19, + 33, + 65, + 390 + ], + "ordinal": 770, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 70, + 129, + 257 + ], + "old": [ + 30, + 32, + 70, + 129, + 257 + ], + "ordinal": 779, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 129, + 262 + ], + "old": [ + 10, + 20, + 65, + 161, + 262 + ], + "ordinal": 784, + "phase": "B" + }, + { + "new": [ + 15, + 17, + 37, + 67, + 129, + 257 + ], + "old": [ + 30, + 37, + 67, + 129, + 257 + ], + "ordinal": 840, + "phase": "B" + }, + { + "new": [ + 8, + 22, + 34, + 68, + 129, + 257 + ], + "old": [ + 8, + 22, + 102, + 129, + 257 + ], + "ordinal": 841, + "phase": "B" + }, + { + "new": [ + 2, + 28, + 40, + 76, + 129, + 257 + ], + "old": [ + 2, + 28, + 100, + 129, + 257 + ], + "ordinal": 842, + "phase": "B" + }, + { + "new": [ + 5, + 27, + 42, + 73, + 129, + 257 + ], + "old": [ + 30, + 47, + 73, + 129, + 257 + ], + "ordinal": 843, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 131, + 260 + ], + "old": [ + 10, + 20, + 65, + 131, + 292 + ], + "ordinal": 848, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 132, + 259 + ], + "old": [ + 10, + 20, + 65, + 164, + 259 + ], + "ordinal": 849, + "phase": "B" + }, + { + "new": [ + 5, + 10, + 17, + 32, + 65, + 386 + ], + "old": [ + 10, + 20, + 37, + 65, + 386 + ], + "ordinal": 850, + "phase": "B" + }, + { + "new": [ + 2, + 8, + 20, + 32, + 65, + 389 + ], + "old": [ + 2, + 8, + 20, + 65, + 421 + ], + "ordinal": 851, + "phase": "B" + }, + { + "new": [ + 7, + 24, + 43, + 74, + 136, + 264 + ], + "old": [ + 31, + 44, + 74, + 136, + 264 + ], + "ordinal": 872, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 50, + 82, + 136, + 264 + ], + "old": [ + 1, + 50, + 84, + 136, + 264 + ], + "ordinal": 873, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 49, + 80, + 136, + 264 + ], + "old": [ + 2, + 49, + 85, + 136, + 264 + ], + "ordinal": 874, + "phase": "B" + }, + { + "new": [ + 7, + 27, + 40, + 73, + 136, + 264 + ], + "old": [ + 28, + 47, + 73, + 136, + 264 + ], + "ordinal": 875, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 137, + 272 + ], + "old": [ + 3, + 48, + 72, + 137, + 276 + ], + "ordinal": 880, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 144, + 265 + ], + "old": [ + 3, + 48, + 72, + 148, + 265 + ], + "ordinal": 881, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 24, + 40, + 72, + 385 + ], + "old": [ + 3, + 28, + 44, + 72, + 385 + ], + "ordinal": 882, + "phase": "B" + }, + { + "new": [ + 1, + 2, + 4, + 48, + 72, + 408 + ], + "old": [ + 1, + 2, + 48, + 72, + 412 + ], + "ordinal": 883, + "phase": "B" + }, + { + "new": [], + "old": [ + 2, + 5, + 40, + 80, + 409 + ], + "ordinal": 928, + "phase": "B" + }, + { + "new": [], + "old": [ + 7, + 42, + 75, + 144 + ], + "ordinal": 949, + "phase": "B" + }, + { + "new": [], + "old": [ + 7, + 42, + 75, + 144 + ], + "ordinal": 951, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 131, + 260 + ], + "old": [ + 10, + 20, + 65, + 131, + 292 + ], + "ordinal": 1052, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 132, + 259 + ], + "old": [ + 10, + 20, + 65, + 164, + 259 + ], + "ordinal": 1053, + "phase": "B" + }, + { + "new": [ + 5, + 10, + 17, + 32, + 65, + 386 + ], + "old": [ + 10, + 20, + 37, + 65, + 386 + ], + "ordinal": 1054, + "phase": "B" + }, + { + "new": [ + 2, + 8, + 20, + 32, + 65, + 389 + ], + "old": [ + 2, + 8, + 20, + 65, + 421 + ], + "ordinal": 1055, + "phase": "B" + }, + { + "new": [ + 7, + 24, + 43, + 74, + 136, + 264 + ], + "old": [ + 31, + 44, + 74, + 136, + 264 + ], + "ordinal": 1101, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 50, + 82, + 136, + 264 + ], + "old": [ + 1, + 50, + 84, + 136, + 264 + ], + "ordinal": 1102, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 49, + 80, + 136, + 264 + ], + "old": [ + 2, + 49, + 85, + 136, + 264 + ], + "ordinal": 1103, + "phase": "B" + }, + { + "new": [ + 7, + 27, + 40, + 73, + 136, + 264 + ], + "old": [ + 28, + 47, + 73, + 136, + 264 + ], + "ordinal": 1104, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 137, + 272 + ], + "old": [ + 3, + 48, + 72, + 137, + 276 + ], + "ordinal": 1121, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 144, + 265 + ], + "old": [ + 3, + 48, + 72, + 148, + 265 + ], + "ordinal": 1122, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 24, + 40, + 72, + 385 + ], + "old": [ + 3, + 28, + 44, + 72, + 385 + ], + "ordinal": 1123, + "phase": "B" + }, + { + "new": [ + 1, + 2, + 4, + 48, + 72, + 408 + ], + "old": [ + 1, + 2, + 48, + 72, + 412 + ], + "ordinal": 1124, + "phase": "B" + }, + { + "new": [ + 3, + 12, + 21, + 37, + 68, + 132, + 260 + ], + "old": [ + 15, + 21, + 38, + 68, + 132, + 260 + ], + "ordinal": 1185, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 17, + 34, + 67, + 128, + 256 + ], + "old": [ + 4, + 17, + 34, + 75, + 128, + 256 + ], + "ordinal": 1186, + "phase": "B" + }, + { + "new": [ + 4, + 11, + 18, + 33, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 51, + 64, + 128, + 256 + ], + "ordinal": 1187, + "phase": "B" + }, + { + "new": [ + 3, + 8, + 17, + 33, + 64, + 132, + 260 + ], + "old": [ + 11, + 17, + 34, + 64, + 132, + 260 + ], + "ordinal": 1188, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 17, + 34, + 64, + 128, + 259 + ], + "old": [ + 4, + 17, + 34, + 64, + 128, + 267 + ], + "ordinal": 1194, + "phase": "B" + }, + { + "new": [ + 3, + 8, + 17, + 33, + 68, + 132, + 256 + ], + "old": [ + 11, + 17, + 34, + 68, + 132, + 256 + ], + "ordinal": 1196, + "phase": "B" + }, + { + "new": [ + 1, + 12, + 18, + 38, + 64, + 128, + 256 + ], + "old": [ + 1, + 30, + 38, + 64, + 128, + 256 + ], + "ordinal": 1201, + "phase": "B" + }, + { + "new": [ + 6, + 10, + 18, + 32, + 64, + 129, + 257 + ], + "old": [ + 10, + 20, + 38, + 64, + 129, + 257 + ], + "ordinal": 1202, + "phase": "B" + }, + { + "new": [ + 6, + 11, + 19, + 33, + 65, + 129, + 257 + ], + "old": [ + 11, + 21, + 39, + 65, + 129, + 257 + ], + "ordinal": 1203, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 70, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 102, + 128, + 256 + ], + "ordinal": 1204, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 70, + 128, + 256 + ], + "old": [ + 1, + 30, + 32, + 70, + 128, + 256 + ], + "ordinal": 1205, + "phase": "B" + }, + { + "new": [ + 6, + 10, + 18, + 32, + 65, + 129, + 256 + ], + "old": [ + 10, + 20, + 38, + 65, + 129, + 256 + ], + "ordinal": 1210, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 64, + 128, + 262 + ], + "old": [ + 1, + 10, + 20, + 64, + 128, + 294 + ], + "ordinal": 1212, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 64, + 128, + 262 + ], + "old": [ + 10, + 20, + 33, + 65, + 128, + 262 + ], + "ordinal": 1213, + "phase": "B" + }, + { + "new": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "old": [ + 13, + 19, + 38, + 70, + 134, + 262 + ], + "ordinal": 1217, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 24, + 32, + 74, + 128, + 256 + ], + "old": [ + 6, + 24, + 32, + 75, + 128, + 256 + ], + "ordinal": 1218, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 11, + 21, + 32, + 64, + 128, + 256 + ], + "ordinal": 1219, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 64, + 160, + 288 + ], + "old": [ + 6, + 11, + 19, + 64, + 160, + 288 + ], + "ordinal": 1220, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 64, + 160, + 288 + ], + "old": [ + 1, + 12, + 18, + 70, + 160, + 288 + ], + "ordinal": 1221, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 24, + 32, + 64, + 128, + 266 + ], + "old": [ + 6, + 24, + 32, + 64, + 128, + 267 + ], + "ordinal": 1226, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 96, + 160, + 256 + ], + "old": [ + 6, + 11, + 19, + 96, + 160, + 256 + ], + "ordinal": 1228, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 96, + 160, + 256 + ], + "old": [ + 6, + 10, + 18, + 96, + 161, + 256 + ], + "ordinal": 1229, + "phase": "B" + }, + { + "new": [ + 7, + 8, + 18, + 33, + 64, + 128, + 256 + ], + "old": [ + 8, + 21, + 38, + 64, + 128, + 256 + ], + "ordinal": 1233, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 17, + 33, + 64, + 136, + 264 + ], + "old": [ + 3, + 21, + 37, + 64, + 136, + 264 + ], + "ordinal": 1234, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 17, + 34, + 67, + 131, + 259 + ], + "old": [ + 11, + 22, + 37, + 67, + 131, + 259 + ], + "ordinal": 1235, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 8, + 48, + 81, + 128, + 256 + ], + "old": [ + 3, + 8, + 48, + 85, + 128, + 256 + ], + "ordinal": 1236, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 17, + 33, + 72, + 136, + 256 + ], + "old": [ + 3, + 21, + 37, + 72, + 136, + 256 + ], + "ordinal": 1242, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 8, + 48, + 64, + 128, + 273 + ], + "old": [ + 3, + 8, + 48, + 64, + 128, + 277 + ], + "ordinal": 1244, + "phase": "B" + }, + { + "new": [ + 8, + 22, + 37, + 71, + 135, + 263 + ], + "old": [ + 7, + 8, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 1417, + "phase": "B" + }, + { + "new": [ + 8, + 22, + 37, + 71, + 135, + 263 + ], + "old": [ + 7, + 8, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 1418, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 67, + 131, + 259 + ], + "old": [ + 7, + 11, + 18, + 33, + 67, + 131, + 259 + ], + "ordinal": 1433, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 67, + 131, + 259 + ], + "old": [ + 7, + 11, + 18, + 33, + 67, + 131, + 259 + ], + "ordinal": 1434, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 18, + 33, + 192, + 320 + ], + "old": [ + 3, + 4, + 8, + 17, + 33, + 192, + 320 + ], + "ordinal": 1437, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 18, + 33, + 192, + 320 + ], + "old": [ + 3, + 4, + 8, + 17, + 33, + 192, + 320 + ], + "ordinal": 1438, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 70, + 134, + 262 + ], + "old": [ + 7, + 11, + 18, + 33, + 65, + 129, + 257 + ], + "ordinal": 1445, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 70, + 134, + 262 + ], + "old": [ + 7, + 11, + 18, + 33, + 65, + 129, + 257 + ], + "ordinal": 1446, + "phase": "B" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 0, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 1, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 2, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 3, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 4, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 5, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 6, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 7, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 8, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 9, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 10, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 11, + "phase": "cleanup_tail" + }, + { + "new": [ + 2, + 5, + 24, + 40, + 72, + 385 + ], + "old": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 12, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 20, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 21, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 22, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 23, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 24, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 25, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 26, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 27, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 28, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 29, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 30, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 31, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 32, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 33, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 34, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 35, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 36, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 37, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 38, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 39, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 47, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 48, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 49, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 50, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 51, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 52, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 55, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 56, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 60, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 61, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 62, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 63, + "phase": "cleanup_tail" + }, + { + "new": [ + 3, + 12, + 17, + 33, + 64, + 388 + ], + "old": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 67, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 73, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 74, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 75, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 76, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 12, + 18, + 32, + 70, + 128, + 256 + ], + "ordinal": 85, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 10, + 18, + 33, + 65, + 128, + 256 + ], + "ordinal": 88, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 94, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 95, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 96, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 97, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 98, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 99, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 100, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 101, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 102, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 103, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 104, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 105, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 106, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 107, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 108, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 109, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 110, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 111, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 116, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 117, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 121, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 122, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 123, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 124, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 125, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 126, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 127, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 128, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 129, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 130, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 131, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 132, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 133, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 134, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 135, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 136, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 137, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 138, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 139, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 140, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 141, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 142, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 143, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 144, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 145, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 146, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 147, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 148, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 149, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 150, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 151, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 152, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 153, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 154, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 155, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 156, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 157, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 158, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 159, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 160, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 161, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 162, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 163, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 164, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 165, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 166, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 167, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 168, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 169, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 170, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 171, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 172, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 173, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 174, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 175, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 176, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 177, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 178, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 179, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 180, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 181, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 182, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 183, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 188, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 189, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 191, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 192, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 193, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 194, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 195, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 196, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 197, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 198, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 199, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 200, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 201, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 202, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 204, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 205, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 206, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 207, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 208, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 209, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 226, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 228, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 230, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 249, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 251, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 265, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 267, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 299, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 304, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 320, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 331, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 363, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 395, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 408, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 412, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 424, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 428, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 448, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 449, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 450, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 451, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 452, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 453, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 454, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 455, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 482, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 483, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 496, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 497, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 503, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 504, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 507, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 508, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 526, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 527, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 550, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 551, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 566, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 567, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 568, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 569, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 574, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 575, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 576, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 577, + "phase": "exit" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 12, + 18, + 32, + 70, + 128, + 256 + ], + "ordinal": 580, + "phase": "exit" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 10, + 18, + 33, + 65, + 128, + 256 + ], + "ordinal": 582, + "phase": "exit" + } + ], + "source_head": "322e0ec764aa7ef7801383feb1f656e460dd8bed" +} diff --git a/research/hyperplane-retiming/vendor/research/joint-helper-lattice/native_joint.py b/research/hyperplane-retiming/vendor/research/joint-helper-lattice/native_joint.py new file mode 100644 index 0000000000..0315f80e2f --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/joint-helper-lattice/native_joint.py @@ -0,0 +1,118 @@ +"""Joint entrance/exit/contact retiming, with literal and phase replay. + +Apache-2.0. Substantial OpenAI assistance. Uses the credited native retiming +implementation of PR4441 and preserves PR4447's missing-span predecessor. +""" +from collections import Counter +from copy import deepcopy +from pathlib import Path +import json,gzip,sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +sys.path.insert(0,str(ROOT/'research/fresh-helper-boundary')) +import native as F +need=F.need + +def construct(patch=None): + c=F.read(F.BASE/'THREE-base-FULL-IDENTITY-CANONICAL.json.gz') + original=F.read(F.BASE/'THREE-base-FULL-IDENTITY-NATIVE.json.gz') + parent=F.read(F.HERE/'CHANGES.json') + maps={d:F.gates(p) for d,p in original.items()} + need(set(maps['forward'])==set(maps['backward']),'Same scalar contact inventory') + for key in maps['forward']: + f=original['forward'][maps['forward'][key]];b=original['backward'][maps['backward'][key]] + need(b[1]==F.dual(f[1]) and b[2]==f[2],'Retained exact dual scalar words') + for key,field in [('entrances','start'),('exits','final')]: + for r,old,new in parent[key]: + need(c[field][r]==old,'Parent boundary pin');c[field][r]=new + for phase,ordinal,old,new in parent['gates']: + for d,p in original.items(): + i=maps[d][phase,ordinal];need(p[i][2]==old,'Parent scalar pin');p[i][2]=new + prior=F.read(ROOT/'research/missing-join-frame/PATCH.json') + need(prior['phase']=='B' and prior['ordinal']==480,'Exact prior contact') + prior_frame=len(c['frames']);c['frames'].append(prior['new_basis']) + for d,p in original.items(): + i=maps[d]['B',480];need(p[i][2]==prior['old_frame'],'Missing-span parent pin');p[i][2]=prior_frame + baseline=deepcopy(c) + before={d:F.synthesize(c,p) for d,p in original.items()} + patch=F.read(HERE/'PATCH.json') if patch is None else patch + need(patch['source_head']=='322e0ec764aa7ef7801383feb1f656e460dd8bed','Pinned candidate head') + labels={frozenset(F.span(b)):i for i,b in enumerate(c['frames'])} + def label(b): + s=frozenset(F.span(b));need(len(s)==2**len(b),'Independent binary basis') + if s not in labels:labels[s]=len(c['frames']);c['frames'].append(b) + return labels[s] + seen=set();counts=Counter() + for move in patch['changes']: + phase,r=move['phase'],move['ordinal'];key=(phase,r) + need(key not in seen,'No duplicate changed boundary/contact');seen.add(key) + a,b=F.span(move['old']),F.span(move['new']);need(a!=b,'No unchanged patch entry') + f=label(move['new']);counts[phase]+=1 + if phase in ('entrance','exit'): + need(224<=r<632,'Only independent helper boundaries may change') + field='start' if phase=='entrance' else 'final' + need(F.span(c['frames'][c[field][r]])==a,'Current helper source pin') + c[field][r]=f + else: + for d,p in original.items(): + i=maps[d][key];need(F.span(c['frames'][p[i][2]])==a,'Current scalar source pin');p[i][2]=f + programs={d:F.synthesize(c,p) for d,p in original.items()} + return c,programs,baseline,before,counts + +def run(phase_check=True): + c,programs,baseline,before,counts=construct() + V=F.load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py','joint_rows') + X=F.load(ROOT/'research/kappa-rebuild/complex/native_extensions.py','joint_literal') + checks={};profiles={} + for d,p in programs.items(): + rows,rec=X.literal_replay(V,c,p,d=='backward') + for r in range(632):need(rows['L',r]==V.expected(('L',r),[],d=='backward',False),'All 632 arbitrary-input endpoints') + profiles[d]=Counter({int(k):v for k,v in rec['paid_profile'].items()}) + rebound=deepcopy(c);rebound['local_profile']=dict(profiles[d]) + rec['second_literal']=V.replay(p,rebound,[],d=='backward',False);checks[d]=rec + need(profiles['forward']==profiles['backward'],'Both complete native rank tariffs') + H=Counter() + for r in range(224,632): + a,b=c['start'][r],c['final'][r] + need(F.span(c['frames'][a]) 0 else -1) * (abs(operator) + (10**6 if backward else 0)) + out = {} + for (variable, word), coefficient in row.items(): + moved = word[1:] if word and word[0] == -symbol else (symbol,) + word + key = variable, moved + out[key] = out.get(key, Q(0)) + coefficient + return {k: v for k, v in out.items() if v} + + +def expected(role, R, backward, clean): + out = identity(role) + name, i = role + if name != "L": + return out + target = i < 112 if backward else 112 <= i < 224 + if not target: + return out + port = i if backward else i - 112 + source_offset = 112 if backward else 0 + sign = -1 if backward else 1 + add(out, identity(("L", source_offset + port)), Q(sign)) + if clean: + for query in R: + if port in query: + for j, value in query.items(): + add(out, identity(("L", source_offset + j)), -sign * query[port] * value / 4) + return out + + +def replay(program, canonical, R, backward, clean, omit_cleanup_last=False): + """All L inputs and all Z inputs are independent, including dirty outputs.""" + n = 2 * canonical["v"] + canonical["R"] + need(n == 632, "Retained compact width") + rows = {("L", i): identity(("L", i)) for i in range(n)} + current = {("L", i): frame for i, frame in enumerate(canonical["start"])} + center_indices = set() + for event in program: + if event[0] == "scalar": + op = event[1] + for register in op[1:3] if op[0] in ("add", "copy") else op[1:2]: + if register[0] == "C": + center_indices.add(register[1]) + elif event[0] == "center": + center_indices.add(event[1]) + need(center_indices <= set(range(8)), "Known center workspace indices") + for i in center_indices: + rows["C", i] = identity(("C", i)) + current["C", i] = None + spaces = [span(vectors) for vectors in canonical["frames"]] + dimensions = [len(s).bit_length() - 1 for s in spaces] + need(dimensions[1] == 9, "Cleanup uses the full native frame") + live = set() + profile = Counter() + counts = Counter() + scalar_primitives = 0 + cleanup_start = next(i for i, event in enumerate(program) if event == ["phase", "full_frame_cleanup"]) + last_scalar = max(i for i, event in enumerate(program) if event[0] == "scalar" and i > cleanup_start) + for position, event in enumerate(program): + kind = event[0] + counts[kind] += 1 + if kind in ("climb", "center"): + if kind == "climb": + _, part, index, old, new, rank = event + role = "L", index + need(spaces[old] < spaces[new], "Non-nested or empty paid climb") + else: + _, index, old, new, rank = event + role = "C", index + need(spaces[old] < spaces[new] or spaces[new] < spaces[old], "Center residual is not nested") + need(current[role] == old and rank == abs(dimensions[new] - dimensions[old]), "Paid edge source/rank") + current[role] = new + profile[rank] += 1 + elif kind == "zero_buffer": + _, action, index = event + role = "Z", index + if action == "alloc": + need(role not in rows and role not in live, "Cleanup buffer duplicate") + rows[role] = identity(role) + current[role] = 1 + live.add(role) + else: + need(action == "free" and role in live and current[role] == 1, "Cleanup buffer retirement") + live.remove(role) + elif kind == "warp": + _, role, operator, old, new = event + role = tuple(role) + need(current[role] == old, "Warp entrance frame") + rows[role] = warp(rows[role], operator, backward) + current[role] = new + elif kind == "scalar": + op, frame = event[1:] + target = tuple(op[1]) + if op[0] == "clear": + need(target[0] == "C", "A borrowed input was cleared") + rows[target] = {} + current[target] = frame + scalar_primitives += 1 + continue + need(current[target] == frame, "Scalar target frame") + if op[0] in ("add", "copy"): + source = tuple(op[2]) + need(current[source] == frame, "Scalar source frame") + if op[0] == "copy": + need(target[0] == "C", "Copy overwrites borrowed state") + rows[target] = dict(rows[source]) + scalar_primitives += 1 + continue + coefficient = Q(op[3], op[4]) + need(target != source, "Self-ADD is not a reversible shear") + numerator, denominator = abs(coefficient.numerator), coefficient.denominator + need(numerator and denominator & (denominator - 1) == 0, "Non-dyadic ADD") + scalar_primitives += 3 + numerator.bit_length() - 1 + numerator.bit_count() + denominator.bit_length() - 1 + if not (omit_cleanup_last and position == last_scalar): + add(rows[target], rows[source], coefficient) + else: + need(op[0] == "scale", "Unknown scalar event") + coefficient = Q(op[2], op[3]) + numerator, denominator = abs(coefficient.numerator), coefficient.denominator + need(numerator and numerator & (numerator - 1) == 0 and denominator & (denominator - 1) == 0, + "Nonunit dyadic SCALE") + scalar_primitives += abs(numerator.bit_length() - denominator.bit_length()) + int(coefficient < 0) + if not (omit_cleanup_last and position == last_scalar): + rows[target] = {k: coefficient * v for k, v in rows[target].items()} + else: + need(kind in ("phase", "adapter", "residual_adapter"), "Unknown native event") + need(not live and [current["L", i] for i in range(n)] == canonical["final"], "Retired fields/final frames") + need(dict(profile) == {int(k): v for k, v in canonical["local_profile"].items()}, "Complete paid profile") + mismatches = [] + for role, actual in rows.items(): + wanted = {} if role[0] == "C" else expected(role, R, backward, clean) + if actual != wanted: + mismatches.append({"role": list(role), "unequal_coefficients": sum(actual.get(k, 0) != wanted.get(k, 0) for k in set(actual) | set(wanted))}) + if not omit_cleanup_last: + need(not mismatches, "Native dirty-buffer operator mismatch: " + repr(mismatches[:3])) + else: + need(mismatches, "Missing-cleanup negative control unexpectedly accepted") + buffer_count = sum(role[0] == "Z" for role in rows) + return dict(direction="backward" if backward else "forward", clean_J=clean, + independent_borrowed_input_fields=632+buffer_count, original_data_fields=224, + expected_restored_helpers=408, expected_restored_arbitrary_cleanup_buffers=buffer_count, + explicitly_owned_C_fields_cleared=len(center_indices), event_counts=dict(counts), + paid_profile=dict(sorted(profile.items())), paid_rank_mass=sum(k*v for k,v in profile.items()), + conservative_real_scalar_primitive_allowance=2*scalar_primitives, + all_scalar_frames_checked=True, dyadic_coefficients_and_unit_scales_checked=True, + free_warp_operator_endpoint_matches=not mismatches, + negative_control_omitted_last_cleanup_scalar=omit_cleanup_last, + mismatch_examples=mismatches[:3]) + + +def liveness(canonical): + times = defaultdict(list) + for i, event in enumerate(canonical["cleanup"]): + for role in event[1:3] if event[0] == "add" else event[1:2]: + role = tuple(role) if isinstance(role, list) else ("L", role) + times[role].append(i) + full = [i for i, f in enumerate(canonical["final"]) if f == 1] + candidates = [] + for z in canonical["zero_buffers"]: + begin, end = min(times["Z", z]), max(times["Z", z]) + possible = [i for i in range(112) if all(t < begin or t > end for t in times["L", i])] + candidates.append(dict(buffer=z, first_use=begin, last_use=end, + noninterfering_same_call_X_candidates=possible, + noninterfering_full_frame_L_candidates=[i for i in full if all(t < begin or t > end for t in times["L", i])])) + return dict(full_frame_live_roles=len(full), full_frame_roles_unused_in_cleanup=[i for i in full if not times["L", i]], + same_call_X_outputs_touched=sum(bool(times["L", i]) for i in range(112)), + buffers_with_no_noninterfering_same_call_X=sum(not row["noninterfering_same_call_X_candidates"] for row in candidates), + buffers_with_no_noninterfering_full_frame_L=sum(not row["noninterfering_full_frame_L_candidates"] for row in candidates), + intervals=candidates, + conclusion="Arbitrary-buffer restoration does not establish a legal same-call completed-output alias.", + external_same_frame_bank_requirement=91, + external_bank_hosting_constructed=False) + + +def find_aliases(canonical): + """Injective lifetime-safe matching; no native L access during its Z span.""" + options = {row["buffer"]: row["noninterfering_full_frame_L_candidates"] + for row in liveness(canonical)["intervals"]} + owner = {} + + def augment(z, seen): + for role in options[z]: + if role in seen: + continue + seen.add(role) + if role not in owner or augment(owner[role], seen): + owner[role] = z + return True + return False + + for z in sorted(options, key=lambda z: (len(options[z]), z)): + augment(z, set()) + bindings = {z: role for role, z in owner.items()} + need(len(set(bindings.values())) == len(bindings), "Alias must be injective") + need(all(role in options[z] for z, role in bindings.items()), "Interfering alias") + return bindings + + +def alias_program(program, bindings): + """Replace only Z register operands, retaining every native/scalar event.""" + out = [] + + def mapped(role): + return ["L", bindings[role[1]]] if role[0] == "Z" and role[1] in bindings else list(role) + + for event in program: + if event[0] == "zero_buffer" and event[2] in bindings: + continue + if event[0] == "scalar": + op = event[1].copy() + op[1] = mapped(op[1]) + if op[0] in ("add", "copy"): + op[2] = mapped(op[2]) + out.append(["scalar", op, event[2]]) + elif event[0] == "warp": + out.append([event[0], mapped(event[1]), *event[2:]]) + else: + out.append(event) + return out + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, default=HERE / "RESULT.json") + args = parser.parse_args() + pins = authenticate() + R = [{int(k): Q(v) for k, v in row.items()} for row in read(PACKET)["R_rows"]] + providers = {} + for tag in TAGS: + providers[tag] = {} + for clean in (False, True): + folder = "converted" if clean else "sources" + canonical = read(CORE / folder / (tag + "-CANONICAL.json.gz")) + programs = read(CORE / folder / (tag + "-NATIVE-WORD.json.gz")) if clean else emit_original(canonical) + checks = [replay(programs[direction], canonical, R, direction == "backward", clean) + for direction in ("forward", "backward")] + bindings = find_aliases(canonical) + aliases = {direction: alias_program(program, bindings) for direction, program in programs.items()} + aliased_checks = [replay(aliases[direction], canonical, R, direction == "backward", clean) + for direction in ("forward", "backward")] + need(len(bindings) == 53, "Expected source-bound 53-field lifetime match") + for original, aliased in zip(checks, aliased_checks): + need(original["paid_profile"] == aliased["paid_profile"] and + original["conservative_real_scalar_primitive_allowance"] == aliased["conservative_real_scalar_primitive_allowance"], + "Aliasing changes the charged operation list") + providers[tag]["clean_J" if clean else "ordinary"] = dict(checks=checks, liveness=liveness(canonical), + lifetime_alias_bindings={str(z): role for z, role in sorted(bindings.items())}, + aliased_checks=aliased_checks, + eliminated_cleanup_fields=len(bindings), remaining_cleanup_fields=91-len(bindings), + aliased_word_sha256={direction: sha256(json.dumps(program, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + for direction, program in aliases.items()}) + print("PASS all arbitrary cleanup inputs", tag, flush=True) + canonical = read(CORE / "converted/THREE-base-CANONICAL.json.gz") + programs = read(CORE / "converted/THREE-base-NATIVE-WORD.json.gz") + controls = [replay(programs[direction], canonical, R, direction == "backward", True, True) + for direction in ("forward", "backward")] + result = dict(schema="literal-native-dirty-buffers/1", status="PASS_NATIVE_ARBITRARY_DIRTY_BUFFER_REPLAY", + new_multiplication_kappa=False, physical_phase_generation_rerun=False, + phase_evidence="Pinned inherited exact native phase receipts; unchanged native edges.", + source_hashes=pins, verifier_sha256=digest(Path(__file__)), providers=providers, + negative_controls=controls, + lifetime_safe_local_full_frame_aliases_per_word=53, + remaining_external_bank_fields_per_word=38, + all_91_local_output_alias_claim=False, external_bank_placement_and_cost_closed=False) + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(result, indent=2) + "\n") + print(result["status"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/hyperplane-retiming/vendor/research/kappa-function-composition/complex/prune_native.py b/research/hyperplane-retiming/vendor/research/kappa-function-composition/complex/prune_native.py new file mode 100644 index 0000000000..8c3e11b240 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/kappa-function-composition/complex/prune_native.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python3 +"""Delete exact unconsumed centre-assembly/inverse pairs, including dirty state. + +Apache-2.0; substantial OpenAI assistance. The native writer and final verifier +are reused with attribution from the frozen causal-continuation package. The +new search checks literal rational perturbations, never numerical similarity. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import sys +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +RESEARCH = HERE.parents[1] +BASE = RESEARCH / 'kappa-global-routing/integrated-complex' +CHECKER = RESEARCH / 'kappa-causal-continuation/buffer-borrowing/verify_buffers.py' +CHECKER_SHA = '106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7' +CLIFFORD = RESEARCH / 't74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py' +TAGS = ('THREE-base', 'THREE-extra', 'FOUR-base', 'FOUR-extra') + + +def need(ok, why): + if not ok: raise ValueError(why) + + +def digest(path): return sha256(path.read_bytes()).hexdigest() + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def save(path, value): + data = json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + path.write_bytes(gzip.compress(data, mtime=0)) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + obj = importlib.util.module_from_spec(spec) + sys.modules[name] = obj + spec.loader.exec_module(obj) + return obj + + +def apply(v, rows, event, backward=False): + if event[0] == 'warp': + r = tuple(event[1]); rows[r] = v.warp(rows[r], event[2], backward) + elif event[0] == 'scalar': + g = event[1]; r = tuple(g[1]) + if g[0] == 'add': v.add(rows[r], rows[tuple(g[2])], Q(g[3], g[4])) + else: + need(g[0] == 'scale', 'No owned field in the clean-J baseline') + rows[r] = {k: Q(g[2], g[3])*x for k, x in rows[r].items()} + + +def index_sections(program): + phase = None; result = {'A': [], 'full_frame_cleanup': []} + for i, e in enumerate(program): + if e[0] == 'phase': phase = e[1] + if phase in result and e[0] in ('scalar', 'warp'): result[phase].append(i) + return result + + +def exact_candidate_screen(v, canonical, program, R): + """Test the final 48 assembly gates, with their actual scheduled inverses.""" + indices = index_sections(program) + need(len(indices['A']) == len(canonical['A']), 'Native A gate correspondence') + need(len(indices['full_frame_cleanup']) == len(canonical['cleanup']), 'Cleanup gate correspondence') + options = []; unmatched = [] + for j in range(len(canonical['A']) - 48, len(canonical['A'])): + g = canonical['A'][j] + need(g[0] == 'add' and len(canonical['frames'][g[-1]]) in (7, 8), 'Final centre-assembly grammar') + inverse = g[:]; inverse[3] *= -1; inverse[-1] = 1 + hits = [i for i, h in enumerate(canonical['cleanup']) if h == inverse] + if len(hits) == 1: + cj = hits[0] + options.append((j, cj, indices['A'][j], indices['full_frame_cleanup'][cj])) + else: unmatched.append({'A_index': j, 'gate': g, 'matching_inverse_occurrences': hits}) + sites = {k for option in options for k in option[2:]} + effects = {}; rows = {('L', i): v.identity(('L', i)) for i in range(632)} + for i, e in enumerate(program): + if i in sites: + g = e[1] + effects[i] = (tuple(g[1]), {k: -Q(g[3], g[4])*x for k, x in rows[tuple(g[2])].items()}) + apply(v, rows, e) + need(all(row == v.expected(r, R, False, True) for r, row in rows.items()), 'Pinned baseline endpoint') + accepted = []; rejected = [] + for aj, cj, ai, ci in options: + delta = {('L', i): {} for i in range(632)} + live_data_effect = False + for i in range(ai, len(program)): + if i in (ai, ci): + target, effect = effects[i]; v.add(delta[target], effect, Q(1)) + else: apply(v, delta, program[i]) + if i < indices['full_frame_cleanup'][0]: + e = program[i] + if e[0] == 'scalar' and e[1][0] in ('add', 'scale'): + r = tuple(e[1][1]) + if r[0] == 'L' and 112 <= r[1] < 224 and delta[r]: live_data_effect = True + bad = [(r, row) for r, row in delta.items() if row] + item = {'A_index': aj, 'cleanup_index': cj, 'A_gate': canonical['A'][aj], + 'cleanup_gate': canonical['cleanup'][cj], + 'native_scalar_sites': [ai, ci], 'Y_difference_before_cleanup': live_data_effect} + if not bad: + item['all_632_arbitrary_input_columns_exactly_preserved'] = True + accepted.append(item) + else: + r, row = bad[0]; key, value = next(iter(sorted(row.items()))) + item['first_exact_nonzero_residual'] = {'output': list(r), 'input': list(key[0]), + 'operator_word': list(key[1]), 'coefficient': str(value)} + item['changed_output_fields'] = len(bad) + rejected.append(item) + need(all(not a['Y_difference_before_cleanup'] for a in accepted), 'No changed data consumer before cleanup') + return accepted, rejected, unmatched + + +def prefix_growth(v, program, backward): + rows = {('L', i): v.identity(('L', i)) for i in range(632)} + maximum_l1 = Q(1); max_coefficient = Q(1); max_numerator = 1; max_denominator = 1 + witness = {'event': -1, 'register': ['L', 0]} + for i, event in enumerate(program): + apply(v, rows, event, backward) + if event[0] not in ('scalar', 'warp'): continue + role = tuple(event[1] if event[0] == 'warp' else event[1][1]) + values = [abs(x) for x in rows[role].values()] + norm = sum(values, Q(0)) + if norm > maximum_l1: + maximum_l1 = norm; witness = {'event': i, 'register': list(role)} + if values: + max_coefficient = max(max_coefficient, max(values)) + max_numerator = max(max_numerator, max(x.numerator for x in values)) + max_denominator = max(max_denominator, max(x.denominator for x in values)) + return {'max_formal_row_l1': str(maximum_l1), 'max_abs_coefficient': str(max_coefficient), + 'max_abs_numerator': max_numerator, 'max_denominator': max_denominator, + 'l1_witness': witness, 'independent_input_columns': 632, + 'scope': 'Exact logical scalar/monomial prefixes over arbitrary inputs; no rounded child error bound.'} + + +def monomial(ce, recipe, n): + result = ce.diag(n, tuple(recipe['quadratic_rows']), tuple(recipe['linear_Z4'])) + result = result.then(ce.perm(n, tuple(recipe['matrix_rows']))).then(ce.xgate(n, recipe['offset'])) + return result.then(ce.Op(n, ce.identity(n), [('phase', recipe['phase'])])) + + +def conjugate(ce, op): + n = op.n; result = ce.ident(n) + for g in op.circuit: + if g[0] == 'P': part = ce.perm(n, g[1]) + elif g[0] == 'X': part = ce.xgate(n, g[1]) + elif g[0] == 'C': part = ce.cgate(n, g[1], -g[2]) + elif g[0] == 'D': part = ce.diag(n, g[1], tuple(-x % 4 for x in g[2])) + else: + need(g[0] == 'phase', 'Known Clifford primitive') + part = ce.Op(n, ce.identity(n), [('phase', -g[1] % 4)]) + result = result.then(part) + return result + + +def check_new_edges(canonical, old_program, new_program, cache): + ce = load(CLIFFORD, 'function_composition_clifford') + old = {(e[3], e[4]) for e in old_program if e[0] == 'climb'} + new = {(e[3], e[4]) for e in new_program if e[0] == 'climb'} + reports = [] + for a, b in sorted(new - old): + A, B = canonical['frames'][a], canonical['frames'][b] + key = tuple(A), tuple(B) + if key not in cache: + source = ce.canonical_frame(9, A).adjoint().then(ce.canonical_frame(9, B)) + records = {} + for name, op in (('forward', source), ('inverse_transpose', conjugate(ce, source))): + recipe, _ = ce.lower_child(op) + need(recipe['rank'] == len(B)-len(A), 'Exact new physical child rank') + decoded = monomial(ce, recipe['right'], 9).then(ce.fourier(9, range(recipe['rank']))).then(monomial(ce, recipe['left'], 9)) + need(decoded.tab == op.tab and decoded.zero_state() == op.zero_state(), 'Decoded Clifford equality including global phase') + records[name] = recipe + cache[key] = records + reports.append({'old_frame': a, 'new_frame': b, 'old_basis': A, 'new_basis': B, + 'rank': len(B)-len(A), 'exact_physical_recipes': cache[key]}) + return reports + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path, default=HERE/'pruned-native') + args = parser.parse_args(); args.out.mkdir(parents=True, exist_ok=True) + need(digest(CHECKER) == CHECKER_SHA, 'Frozen independent checker') + v = load(CHECKER, 'function_composition_independent'); v.authenticate() + base_receipt = read(BASE/'RESULT.json') + R = [{int(k): Q(x) for k, x in row.items()} for row in v.read(v.PACKET)['R_rows']] + providers = {}; phase_cache = {} + for tag in TAGS: + path = BASE/(tag+'-CANONICAL.json.gz') + need(digest(path) == base_receipt['providers'][tag]['artifacts'][path.name], 'Pinned baseline canonical') + old = read(path); old_native = v.emit_original(old) + yes, no, unmatched = exact_candidate_screen(v, old, old_native['forward'], R) + candidate = deepcopy(old) + a_drop = {r['A_index'] for r in yes}; c_drop = {r['cleanup_index'] for r in yes} + candidate['A'] = [g for i, g in enumerate(old['A']) if i not in a_drop] + candidate['cleanup'] = [g for i, g in enumerate(old['cleanup']) if i not in c_drop] + native = v.emit_original(candidate) + histogram = Counter(e[5] for e in native['forward'] if e[0] == 'climb') + candidate['local_profile'] = {str(r): n for r, n in sorted(histogram.items())} + candidate['edges'] = [list(e) for e in sorted({(e[3], e[4]) for e in native['forward'] if e[0] == 'climb'})] + checks = {} + for name in ('forward', 'backward'): + checks[name] = {'independent_literal_replay': v.replay(native[name], candidate, R, name == 'backward', True), + 'baseline_prefix_growth': prefix_growth(v, old_native[name], name == 'backward'), + 'new_prefix_growth': prefix_growth(v, native[name], name == 'backward')} + phases = check_new_edges(candidate, old_native['forward'], native['forward'], phase_cache) + # Removing the computation while retaining its inverse must be rejected. + negative = deepcopy(candidate) + first = yes[0] + negative['cleanup'].insert(0, first['cleanup_gate']) + bad_program = v.emit_original(negative) + rejected_control = False + try: v.replay(bad_program['forward'], negative, R, False, True) + except ValueError as error: + rejected_control = 'operator mismatch' in str(error) + need(rejected_control, 'Unpaired deletion negative control') + cp = args.out/(tag+'-CANONICAL.json.gz'); np = args.out/(tag+'-NATIVE-WORD.json.gz') + save(cp, candidate); save(np, native) + providers[tag] = {'baseline_canonical_sha256': digest(path), 'candidate_pairs_tested': len(yes)+len(no), + 'accepted_pairs': yes, 'rejected_pairs': no, 'unmatched_pairs': unmatched, + 'old_paid_profile': old['local_profile'], 'new_paid_profile': candidate['local_profile'], + 'old_paid_rank_mass': sum(int(r)*n for r, n in old['local_profile'].items()), + 'new_paid_rank_mass': sum(int(r)*n for r, n in candidate['local_profile'].items()), + 'recursive_calls_removed': sum(old['local_profile'].values())-sum(histogram.values()), + 'scalar_ADDs_removed': 2*len(yes), 'checks': checks, + 'new_physical_edges': phases, 'unpaired_deletion_negative_control_rejected': True, + 'artifacts': {cp.name: digest(cp), np.name: digest(np)}} + print('PASS pruned native', tag, len(yes), 'pairs;', dict(sorted(histogram.items())), flush=True) + result = {'schema': 'consumer-driven-clean-J-native-pruning/1', + 'status': 'PASS_ALL_FOUR_BOTH_DIRECTIONS_632_ARBITRARY_FIELDS', + 'generator_sha256': digest(Path(__file__)), 'baseline_receipt_sha256': digest(BASE/'RESULT.json'), + 'independent_interpreter_sha256': CHECKER_SHA, 'phase_compiler_path': str(CLIFFORD.relative_to(RESEARCH.parent)), + 'phase_compiler_sha256': digest(CLIFFORD), 'providers': providers, + 'native_word_new_children_phase_lowered': True, 'local_data_and_helper_endpoints_unchanged': True, + 'same_632_field_inventory': True, 'zero_owned_fields': True, 'zero_external_cleanup_fields': True, + 'no_new_kappa_claimed': True, 'query_producer_contract_preserved': False, + 'scope': 'Exact ideal clean-J local endpoints only. Final historical query assemblies are partially removed because this local word has no centre consumers. A caller that reads those historical queries cannot substitute this word without reconstructing and pricing its producer interface. The full caller and rounded induction remain open.'} + (args.out/'RESULT.json').write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(result['status'], flush=True) + + +if __name__ == '__main__': main() diff --git a/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz new file mode 100644 index 0000000000..4a8c4ed26e Binary files /dev/null and b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz differ diff --git a/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz new file mode 100644 index 0000000000..b46d44c6ee Binary files /dev/null and b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz differ diff --git a/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/native_extensions.py b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/native_extensions.py new file mode 100644 index 0000000000..7f84894efc --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/native_extensions.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python3 +"""Native embedded query logger and common-frame H conjugation contacts. + +Apache-2.0. Substantial OpenAI assistance. These are fresh constructions with +explicit arbitrary-input endpoints. An embedded cache output is not claimed +as an independent clean helper output until a whole caller erases its defect. +""" +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path +import argparse +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import rebuild_native as N +import power_two_balance as B + +B_SHA = '76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424' + + +def common_frame_h(geo, offset, frame): + """H = diag(I,-I) S_L S_-K S_L, with all shear ADDs having coefficient ±1. + + Balancing only the eight selected coordinates avoids scaling104 ordinary + coordinates. No private field and no recursive transport are introduced. + Precondition: ALL112 physical fields share the stated actual frame gauge. + """ + A = geo['selected'] + out = [['phase', 'fresh_common_frame_H']] + def scale(n, d): + out.extend(N.scalar(['scale', ['L', offset+a], n, d], frame) for a in A) + def left(): + for k, a in enumerate(A): + for u, value in sorted(geo['L'][k].items()): + coefficient = 2*value + N.need(abs(coefficient) == 1, 'Balanced unit L coefficients') + out.append(N.scalar(['add', ['L', offset+a], ['L', offset+u], int(coefficient), 1], frame)) + scale(2, 1); left(); scale(1, 4) + for k, a in enumerate(A): + for u, value in sorted(geo['L'][k].items()): + coefficient = -2*value + out.append(N.scalar(['add', ['L', offset+u], ['L', offset+a], int(coefficient), 1], frame)) + scale(4, 1); left(); scale(-1, 2) + N.need(B.scalar_sum(out) == 10096, 'Exact common-frame H scalar allowance') + return out + + +def embedded_cache_roles(canonical): + roles = [i for i in range(224, 632) if canonical['start'][i] == 0 and canonical['final'][i] == 1] + N.need(len(roles) == 213, '213 genuinely cold, full-ended native helper roles') + return roles[:8] + + +def embedded_logger_suffix(canonical, geo, roles=None): + roles = embedded_cache_roles(canonical) if roles is None else list(roles) + N.need(len(roles) == len(set(roles)) == 8, 'Eight distinct embedded caches') + N.need(all(224 <= i < 632 and canonical['start'][i] == 0 and canonical['final'][i] == 1 for i in roles), + 'Embedded logger only uses cold full-ended physical helper references') + out = [['phase', 'fresh_embedded_dirty_logger']] + for k, a in enumerate(geo['selected']): + r = roles[k] + out += [N.scalar(['scale', ['L', r], 2, 1], 1), + N.scalar(['add', ['L', r], ['L', a], 2, 1], 1)] + out += [N.scalar(['add', ['L', r], ['L', u], int(2*q), 1], 1) + for u, q in sorted(geo['L'][k].items())] + out.append(N.scalar(['scale', ['L', r], 1, 2], 1)) + N.need(B.scalar_sum(out) == 3440, 'Embedded logger exact scalar bill') + return out + + +def make_embedded_logger(canonical, base_word, geo): + word = B.make_balanced_h(canonical, base_word, geo)['forward'] + return word+embedded_logger_suffix(canonical, geo) + + +def make_wrapped_h(canonical, base_word, geo): + words = B.make_balanced_h(canonical, base_word, geo) + return {direction: common_frame_h(geo, 112, 0)+word+common_frame_h(geo, 0, 1) + for direction, word in words.items()} + + +def literal_replay(v, c, program, backward=False): + """Second literal evaluator for new endpoints; all632 inputs arbitrary. + + This checker has no endpoint-specific shortcut. It applies every scalar + and free-warp event and checks each contact's frame before comparing rows. + """ + rows = {('L', i): v.identity(('L', i)) for i in range(632)} + rows['C', 0] = v.identity(('C', 0)) + current = {('L', i): f for i, f in enumerate(c['start'])}; current['C', 0] = None + spaces = [v.span(frame) for frame in c['frames']] + profile = Counter(); cost = 0; max_l1 = Q(1); witness = None; max_denominator = 1 + for j, event in enumerate(program): + kind = event[0]; touched = None + if kind == 'scalar': + g, frame = event[1:]; target = tuple(g[1]); touched = target + cost += N.primitive_allowance(g) + if g[0] == 'clear': + N.need(target == ('C', 0), 'Only owned C0 can be cleared') + rows[target] = {}; current[target] = frame + else: + N.need(current[target] == frame, 'Exact scalar target frame') + if g[0] in ('add', 'copy'): + source = tuple(g[2]); N.need(current[source] == frame, 'Exact scalar source frame') + if g[0] == 'copy': + N.need(target == ('C', 0), 'Only owned field overwritten by copy') + rows[target] = dict(rows[source]) + else: + N.need(target != source, 'Distinct reversible ADD arguments') + v.add(rows[target], rows[source], Q(g[3], g[4])) + else: + N.need(g[0] == 'scale', 'Known scalar action') + q = Q(g[2], g[3]); rows[target] = {i: q*x for i, x in rows[target].items()} + elif kind == 'warp': + _, r, op, old, new = event; target = tuple(r); touched = target + N.need(current[target] == old, 'Warp input frame') + rows[target] = v.warp(rows[target], op, backward); current[target] = new + elif kind in ('climb', 'center'): + if kind == 'climb': + _, part, i, old, new, rank = event; target = ('L', i) + N.need(spaces[old] < spaces[new], 'Ascending borrowed climb') + else: + _, i, old, new, rank = event; target = ('C', i) + N.need(spaces[old] < spaces[new] or spaces[new] < spaces[old], 'Nested center transport') + N.need(current[target] == old and rank == abs(len(c['frames'][new])-len(c['frames'][old])), 'Paid rank and source frame') + current[target] = new; profile[rank] += 1 + else: + N.need(kind in ('phase', 'adapter', 'residual_adapter'), 'Known inert native marker') + if touched is not None: + norm = sum(map(abs, rows[touched].values()), Q(0)) + if norm > max_l1: + max_l1 = norm; witness = dict(event=j, role=list(touched)) + max_denominator = max(max_denominator, max((x.denominator for x in rows[touched].values()), default=1)) + N.need([current['L', i] for i in range(632)] == c['final'], 'Final native frames') + N.need(not rows['C', 0], 'Owned C0 cleared at return') + return rows, dict(independent_persistent_columns=632, independent_owned_entry_columns=1, + scalar_frames_checked=True, arbitrary_owned_C0_cleared=True, + paid_profile=dict(sorted(profile.items())), paid_rank_mass=sum(k*x for k, x in profile.items()), + real_scalar_allowance=cost, max_formal_prefix_l1=str(max_l1), max_denominator=max_denominator, + l1_witness=witness) + + +def check_rows(v, rows, geo, kind, backward=False, cache_roles=()): + mismatch = [] + for r in range(632): + actual = rows['L', r] + if kind == 'wrapped' and r < 224: + port = r % 112; wanted = {} + for j, q in geo['H'][port].items(): + v.add(wanted, v.identity(('L', (112 if r >= 112 else 0)+j)), q) + if backward and r < 112: + v.add(wanted, v.identity(('L', 112+j)), -q) + if not backward and r >= 112: + v.add(wanted, v.identity(('L', j)), q) + else: + wanted = v.identity(('L', r)) + if 112 <= r < 224: + for j, q in geo['H'][r-112].items(): + v.add(wanted, v.identity(('L', j)), q) + if r in cache_roles: + k = list(cache_roles).index(r) + for j, q in {geo['selected'][k]: Q(1), **geo['L'][k]}.items(): + v.add(wanted, v.identity(('L', j)), q) + if actual != wanted: + mismatch.append(r) + N.need(not mismatch, 'Fresh exact endpoint mismatch '+repr(mismatch[:5])) + + +def check_scalar_h(v, geo): + """Independent112-column execution without native body or Clifford data.""" + rows = {i: {i: Q(1)} for i in range(112)} + program = common_frame_h(geo, 0, 0) + for event in program: + if event[0] != 'scalar': + continue + g = event[1]; target = g[1][1] + if g[0] == 'scale': + q = Q(g[2], g[3]); rows[target] = {i: q*x for i, x in rows[target].items()} + else: + v.add(rows[target], rows[g[2][1]], Q(g[3], g[4])) + N.need(all(rows[i] == geo['H'][i] for i in range(112)), 'Three balanced shears exactly equal H') + return dict(all_columns=112, real_scalar_allowance=B.scalar_sum(program), + additions=sum(e[0] == 'scalar' and e[1][0] == 'add' for e in program), + unit_add_coefficients=True, owned_fields=0, new_recursive_children=0, + required_physical_precondition='All112 fields occupy one actual common frame reference.') + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--out', type=Path, default=HERE/'extension-certificates') + args = ap.parse_args(); args.out.mkdir(parents=True, exist_ok=True) + N.need(N.digest(HERE/'rebuild_native.py') == B.N_SHA and N.digest(HERE/'power_two_balance.py') == B_SHA, + 'Authenticated fresh prerequisite sources') + p, v, ce, receipt, inherited = N.authenticated(); geo = N.geometry(v.PACKET) + result = dict(schema='fresh-native-helper-log-and-common-frame-conjugation/1', + source_sha256=N.digest(Path(__file__)), reconstruction_source_sha256=B.N_SHA, + balance_source_sha256=B_SHA, scalar_H=check_scalar_h(v, geo), providers={}, no_new_kappa_claimed=True) + for tag in N.TAGS: + c = N.read(N.BASE/(tag+'-CANONICAL.json.gz')); word = N.read(N.BASE/(tag+'-NATIVE-WORD.json.gz')) + base_scalar = B.scalar_sum(word['forward']) + roles = embedded_cache_roles(c); embedded = make_embedded_logger(c, word, geo) + rows, embedded_check = literal_replay(v, c, embedded) + check_rows(v, rows, geo, 'embedded', cache_roles=roles) + N.need(embedded_check['real_scalar_allowance'] == base_scalar+3504+3440, 'Embedded complete scalar invoice') + wrapped = make_wrapped_h(c, word, geo); wrapped_checks = {} + for direction, program in wrapped.items(): + back = direction == 'backward' + rows, checked = literal_replay(v, c, program, back) + check_rows(v, rows, geo, 'wrapped', back) + N.need(checked['real_scalar_allowance'] == base_scalar+3504+2*10096, 'Wrapped H complete scalar invoice') + wrapped_checks[direction] = checked + ep = args.out/(tag+'-EMBEDDED-LOGGER.json.gz'); wp = args.out/(tag+'-SCALAR-WRAPPED-H.json.gz') + result['providers'][tag] = dict( + embedded_logger=dict(artifact=ep.name, sha256=N.save(ep, embedded), check=embedded_check, + cache_roles=roles, exactly_400_other_helpers_restored=True, + cache_output='d_k + X_A[k] + L[k] X_U', extra_children=0, + extra_persistent_fields=0, extra_owned_fields=0, extra_scalar_allowance=3440, + independent_clean_output_credit_for_eight_caches=False), + scalar_wrapped_H=dict(artifact=wp.name, sha256=N.save(wp, wrapped), checks=wrapped_checks, + endpoint='diag(H,H) times the corresponding identity shear in local logical coordinates', + new_recursive_children_beyond_H=0, extra_scalar_allowance=20192, + all_408_helpers_restored=True, + outer_intercall_frame_identification_certified=False)) + N.save(args.out/'RESULT.json', result) + print('PASS extensions', tag, 'embedded0 extra children; wrapped H20192 extra scalars', flush=True) + result['status'] = 'PASS_LOCAL_NATIVE_ENDPOINTS_WITH_EXPLICIT_OUTER_FRAME_OBLIGATION' + N.save(args.out/'RESULT.json', result) + + +if __name__ == '__main__': + main() diff --git a/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/power_two_balance.py b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/power_two_balance.py new file mode 100644 index 0000000000..a55ae0ce78 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/power_two_balance.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Exact power-of-two balancing of the reconstructed H112 and dirty logger. + +Apache-2.0. Substantial OpenAI assistance. This changes only explicit local +coefficient streams and dyadic unit scales; every recursive child is retained. +The exact arbitrary-input verifier and endpoint-gauge phase receipts are reused +from the separately source-bound reconstruction in rebuild_native.py. +""" +from collections import Counter +from copy import deepcopy +from pathlib import Path +import argparse +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import rebuild_native as N + +N_SHA = 'f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5' + + +def make_balanced_h(c, word, geo, exponent=1): + """Assemble 2^e v, transport it, deliver 12/2^e times that field.""" + N.need(isinstance(exponent, int) and -8 <= exponent <= 8, 'Bounded integral balancing exponent') + q = N.Q(2)**exponent + result = N.make_h_word(c, word, geo) + for direction, program in result.items(): + out = []; completion = False + for event in program: + if event[0] == 'phase': + completion = event[1] == 'fresh_H112_completion' + if not completion or event[0] != 'scalar': + out.append(event); continue + op, frame = event[1:] + if op[0] == 'copy' and op[1] == ['C', 0]: + out.append(event) + if q != 1: + out.append(N.scalar(['scale', ['C', 0], q.numerator, q.denominator], frame)) + elif op[0] == 'add': + factor = q if op[1] == ['C', 0] else 1/q + amount = N.Q(op[3], op[4])*factor + out.append(N.scalar(op[:3]+[amount.numerator, amount.denominator], frame)) + else: + out.append(event) + result[direction] = out + return result + + +def make_balanced_logger(c, word, geo, exponent=1): + """Scale arbitrary P by 2^e, add 2^e v, scale back; dirty P is preserved.""" + N.need(isinstance(exponent, int) and -8 <= exponent <= 8, 'Bounded integral balancing exponent') + q = N.Q(2)**exponent + suffix = [['phase', 'fresh_balanced_forward_dirty_logger']] + for k, a in enumerate(geo['selected']): + suffix.append(['cache_child', k, 0, 1, 9]) + if q != 1: + suffix.append(N.scalar(['scale', ['P', k], q.numerator, q.denominator], 1)) + suffix.append(N.scalar(['add', ['P', k], ['L', a], q.numerator, q.denominator], 1)) + for p, coefficient in sorted(geo['L'][k].items()): + x = q*coefficient + suffix.append(N.scalar(['add', ['P', k], ['L', p], x.numerator, x.denominator], 1)) + if q != 1: + suffix.append(N.scalar(['scale', ['P', k], q.denominator, q.numerator], 1)) + return word['forward']+suffix + + +def scalar_sum(program): + return sum(N.primitive_allowance(e[1]) for e in program if e[0] == 'scalar') + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--out', type=Path, default=HERE/'balanced-certificates') + args = ap.parse_args(); args.out.mkdir(parents=True, exist_ok=True) + N.need(N.digest(HERE/'rebuild_native.py') == N_SHA, 'Pinned fresh reconstruction source') + p, v, ce, receipt, inherited = N.authenticated(); geo = N.geometry(v.PACKET) + result = dict(schema='fresh-native-power-two-balancing/1', source_sha256=N.digest(Path(__file__)), + reconstruction_source_sha256=N_SHA, no_new_kappa_claimed=True, providers={}, + scope='Finite native all-column and phase certificates; full outer recurrence and rounded induction remain separate.') + for tag in N.TAGS: + c = N.read(N.BASE/(tag+'-CANONICAL.json.gz')); word = N.read(N.BASE/(tag+'-NATIVE-WORD.json.gz')) + base_scalar = scalar_sum(word['forward']) + scan = [] + for exponent in range(-4, 5): + hw = make_balanced_h(c, word, geo, exponent) + lw = make_balanced_logger(c, word, geo, exponent) + scan.append(dict(exponent=exponent, H_increment=scalar_sum(hw['forward'])-base_scalar, + logger_increment=scalar_sum(lw)-base_scalar)) + N.need(min(scan, key=lambda r: r['H_increment'])['exponent'] == 1, 'H minimum in scanned power-two family') + N.need(min(scan, key=lambda r: r['logger_increment'])['exponent'] == 1, 'Logger minimum in scanned power-two family') + hw = make_balanced_h(c, word, geo) + hp = Counter({int(k): n for k, n in c['local_profile'].items()}); hp[1] += 8 + checks = {d: N.replay_extended(v, hw[d], c, geo, d == 'backward', expected_profile=hp) + for d in ('forward', 'backward')} + N.need(all(check['real_scalar_allowance']-base_scalar == 3504 for check in checks.values()), 'H increment3504') + phases = N.h_child_recipes(p, ce, c, hw) + lw = make_balanced_logger(c, word, geo) + lp = Counter({int(k): n for k, n in c['local_profile'].items()}); lp[9] += 8 + logger_check = N.replay_extended(v, lw, c, geo, endpoint='logger', cache_count=8, expected_profile=lp) + N.need(logger_check['real_scalar_allowance']-base_scalar == 3440, 'Logger increment3440') + wrong = deepcopy(lw) + omitted = next(i for i, e in enumerate(wrong) if e[0] == 'scalar' and e[1] == ['scale', ['P', 0], 1, 2]) + wrong.pop(omitted) + control = N.replay_extended(v, wrong, c, geo, endpoint='logger', cache_count=8, allow_mismatch=True) + dirty_gain = N.Q(1) + for event in wrong: + if event[0] == 'scalar' and event[1][:2] == ['scale', ['P', 0]]: + dirty_gain *= N.Q(event[1][2], event[1][3]) + N.need(not control['exact_endpoint'] and dirty_gain == 2 and + any(x['role'] == ['P', 0] for x in control['mismatch_examples']), + 'Missing final dirty-cache rescale exposes arbitrary P coefficient error') + hpfile = args.out/(tag+'-BALANCED-H112-NATIVE.json.gz') + lpfile = args.out/(tag+'-BALANCED-FORWARD-LOGGER.json.gz') + result['providers'][tag] = dict(power_two_scan=scan, + H=dict(artifact=hpfile.name, sha256=N.save(hpfile, hw), checks=checks, new_child_recipes=phases, + increment=dict(profile={'1': 8}, real_scalar_allowance=3504, owned_C_fields=1), saved_scalar_allowance=832), + logger=dict(artifact=lpfile.name, sha256=N.save(lpfile, lw), check=logger_check, + increment=dict(profile={'9': 8}, real_scalar_allowance=3440, arbitrary_P_fields=8), saved_scalar_allowance=784, + missing_final_rescale_negative_control=dict(dirty_P0_coefficient=str(dirty_gain), + mismatches=control['mismatch_examples']))) + N.save(args.out/'RESULT.json', result) + print('PASS balanced', tag, 'H8H1+3504; logger8H9+3440', flush=True) + result['status'] = 'PASS_BALANCED_H_BOTH_DIRECTIONS_AND_FORWARD_LOGGER_ALL_FOUR_PROVIDERS' + N.save(args.out/'RESULT.json', result) + + +if __name__ == '__main__': + main() diff --git a/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/rebuild_native.py b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/rebuild_native.py new file mode 100644 index 0000000000..78a7b1b0e6 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/kappa-rebuild/complex/rebuild_native.py @@ -0,0 +1,453 @@ +#!/usr/bin/env python3 +"""Fresh reconstruction of H112, its dirty logger and helper boundary factors. + +Apache-2.0. Substantial OpenAI assistance. This is newly generated evidence; +it does not recreate or assert the identity of files lost in an earlier session. +The immutable predecessor is the attributed function-composition clean-J word. +Logical sparse replay extends the independently pinned verify_buffers grammar. +Physical lowering uses the attributed exact Clifford compiler and independently +decodes each new recipe, comparing tableau AND the exact zero-state phase. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import platform +import sys +import time + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[2] +P_PATH = ROOT/'research/kappa-function-composition/complex/prune_native.py' +BASE = P_PATH.parent/'pruned-native' +P_SHA = 'f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257' +RECEIPT_SHA = 'b62c6c123f43a697802a336ee7178942040c0249c64ebc19cd6aad7ba2728ae7' +CE_SHA = '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' +TAGS = ('THREE-base', 'THREE-extra', 'FOUR-base', 'FOUR-extra') +SELECTED = (0, 7, 20, 27, 36, 46, 57, 111) + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def digest(path): + return sha256(Path(path).read_bytes()).hexdigest() + + +def read(path): + path = Path(path) + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def save(path, value): + path = Path(path) + data = json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + path.write_bytes(gzip.compress(data, mtime=0) if path.suffix == '.gz' else data+b'\n') + return digest(path) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + obj = importlib.util.module_from_spec(spec) + sys.modules[name] = obj + spec.loader.exec_module(obj) + return obj + + +def authenticated(): + need(digest(P_PATH) == P_SHA, 'Pinned clean-J reconstruction utility') + need(digest(BASE/'RESULT.json') == RECEIPT_SHA, 'Pinned clean-J receipt') + p = load(P_PATH, 'fresh_h112_prune') + need(digest(p.CHECKER) == p.CHECKER_SHA, 'Pinned independent native interpreter') + need(digest(p.CLIFFORD) == CE_SHA, 'Pinned phase compiler') + v = load(p.CHECKER, 'fresh_h112_independent') + inherited = v.authenticate() + ce = load(p.CLIFFORD, 'fresh_h112_clifford') + receipt = read(BASE/'RESULT.json') + for tag in TAGS: + for filename, expected in receipt['providers'][tag]['artifacts'].items(): + need(digest(BASE/filename) == expected, 'Pinned predecessor artifact '+filename) + return p, v, ce, receipt, inherited + + +def geometry(packet): + """Return exact sparse R, L and the freshly checked 112 by 112 H.""" + packet = read(packet) if isinstance(packet, (str, Path)) else packet + R = [{int(k): Q(x) for k, x in row.items()} for row in packet['R_rows']] + ordinary = tuple(i for i in range(112) if i not in SELECTED) + need(len(R) == 8, 'Eight query rows') + dot = lambda a, b: sum((x*b.get(j, Q(0)) for j, x in a.items()), Q(0)) + need(all(dot(a, b) == 56*int(i == j) for i, a in enumerate(R) for j, b in enumerate(R)), 'R R^t = 56 I') + need(all(sum((r.get(a, 0)*r.get(b, 0) for r in R), Q(0)) == 4*int(a == b) + for a in SELECTED for b in SELECTED), 'Selected Gram matrix 4 I') + L = [{p: q for p in ordinary if (q := sum((r.get(a, 0)*r.get(p, 0) for r in R), Q(0))/4)} + for a in SELECTED] + need(all(len(row) == 52 and set(map(abs, row.values())) == {Q(1, 2)} for row in L), '416 half-integral L entries') + need(all(dot(a, b) == 13*int(i == j) for i, a in enumerate(L) for j, b in enumerate(L)), 'L L^t = 13 I') + J = [] + H = [] + for i in range(112): + row = {j: q for j in range(112) + if (q := Q(i == j)-sum((r.get(i, 0)*r.get(j, 0) for r in R), Q(0))/4)} + J.append(row) + changed = dict(row) + if i in SELECTED: + k = SELECTED.index(i) + for j, x in {i: Q(1), **L[k]}.items(): + changed[j] = changed.get(j, Q(0))+12*x + if not changed[j]: + del changed[j] + H.append(changed) + need(all(sum((x*H[k].get(j, 0) for k, x in H[i].items()), Q(0)) == int(i == j) + for i in range(112) for j in range(112)), 'Exact H squared equals identity') + need(any(H[i].get(j, 0) != H[j].get(i, 0) for i in range(112) for j in range(112)), 'H is not symmetric') + return dict(selected=SELECTED, ordinary=ordinary, R=R, L=L, J=J, H=H) + + +def kernel_h(packet): + return geometry(packet)['H'] + + +def scalar(op, frame): + return ['scalar', op, frame] + + +def make_h_word(canonical, base_word, geo): + """Forward suffix and separate backward prefix; H is NOT self-transpose.""" + out = deepcopy(base_word) + for backward in (False, True): + correction = [['phase', 'fresh_H112_completion']] + common = 0 if backward else 1 + source_offset = 112 if backward else 0 + target_offset = 0 if backward else 112 + for k, a in enumerate(geo['selected']): + target_frame = canonical['start'][a] if backward else canonical['final'][112+a] + correction += [scalar(['clear', ['C', 0]], common), + scalar(['copy', ['C', 0], ['L', source_offset+a]], common)] + correction += [scalar(['add', ['C', 0], ['L', source_offset+p], q.numerator, q.denominator], common) + for p, q in sorted(geo['L'][k].items())] + correction += [['center', 0, common, target_frame, 1], + scalar(['add', ['L', target_offset+a], ['C', 0], -12 if backward else 12, 1], target_frame), + scalar(['clear', ['C', 0]], target_frame)] + name = 'backward' if backward else 'forward' + out[name] = correction+out[name] if backward else out[name]+correction + return out + + +def make_logger_word(canonical, base_word, geo): + """Eight arbitrary cache fields; the caller owns their dirty baselines.""" + suffix = [['phase', 'fresh_forward_dirty_query_logger']] + for k, a in enumerate(geo['selected']): + suffix += [['cache_child', k, 0, 1, 9], scalar(['add', ['P', k], ['L', a], 1, 1], 1)] + suffix += [scalar(['add', ['P', k], ['L', p], q.numerator, q.denominator], 1) + for p, q in sorted(geo['L'][k].items())] + return base_word['forward']+suffix + + +def primitive_allowance(op): + if op[0] in ('clear', 'copy'): + return 2 + q = Q(op[3], op[4]) if op[0] == 'add' else Q(op[2], op[3]) + n, d = abs(q.numerator), q.denominator + need(n and not d & (d-1), 'Nonzero dyadic scalar') + if op[0] == 'scale': + need(not n & (n-1), 'Dyadic unit SCALE') + return 2*(abs(n.bit_length()-d.bit_length())+int(q < 0)) + need(op[0] == 'add', 'Known scalar macro') + return 2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1) + + +def replay_extended(v, program, canonical, geo, backward=False, endpoint='H', cache_count=0, + expected_profile=None, allow_mismatch=False): + """Literal exact all-column native replay, including arbitrary C at entry. + + Transports change canonical coordinate tags and retain logical row values; + separate phase receipts implement the exact physical coordinate change. + Warp words remain free noncommuting symbols, including dual orientation. + """ + need(endpoint in ('H', 'J', 'logger'), 'Known endpoint') + n = len(canonical['start']) + need(n == 632, '632 persistent predecessor roles') + rows = {('L', i): v.identity(('L', i)) for i in range(n)} + current = {('L', i): f for i, f in enumerate(canonical['start'])} + centers = {e[1] for e in program if e[0] == 'center'} + centers |= {r[1] for e in program if e[0] == 'scalar' + for r in (e[1][1:3] if e[1][0] in ('add', 'copy') else e[1][1:2]) + if r[0] == 'C'} + need(centers <= {0}, 'Only one owned completion field') + for i in centers: + rows['C', i] = v.identity(('C', i)); current['C', i] = None + for i in range(cache_count): + rows['P', i] = v.identity(('P', i)); current['P', i] = 0 + spaces = [v.span(vectors) for vectors in canonical['frames']] + dimensions = [len(s).bit_length()-1 for s in spaces] + profile = Counter(); counts = Counter(); scalar_cost = 0 + max_l1 = Q(1); max_coefficient = Q(1); max_numerator = 1; max_denominator = 1 + witness = {'event': -1, 'role': ['L', 0]} + for i, e in enumerate(program): + kind = e[0]; counts[kind] += 1; touched = None + if kind in ('climb', 'center', 'cache_child'): + if kind == 'climb': + _, part, j, old, new, rank = e; role = ('L', j) + need(spaces[old] < spaces[new], 'Strict ascending borrowed climb') + else: + _, j, old, new, rank = e + role = ('C' if kind == 'center' else 'P', j) + need(spaces[old] < spaces[new] or spaces[new] < spaces[old], 'Nested transport') + need(current[role] == old and rank == abs(dimensions[new]-dimensions[old]), 'Transport frame and exact rank') + current[role] = new; profile[rank] += 1 + elif kind == 'warp': + _, r, op, old, new = e; role = tuple(r) + need(current[role] == old, 'Warp source frame') + rows[role] = v.warp(rows[role], op, backward); current[role] = new; touched = role + elif kind == 'scalar': + op, frame = e[1:]; role = tuple(op[1]); touched = role + scalar_cost += primitive_allowance(op) + if op[0] == 'clear': + need(role[0] == 'C', 'No clearing arbitrary persistent inputs') + rows[role] = {}; current[role] = frame + else: + need(current[role] == frame, 'Scalar target frame at event '+str(i)) + if op[0] in ('add', 'copy'): + source = tuple(op[2]); need(current[source] == frame, 'Scalar source frame at event '+str(i)) + if op[0] == 'copy': + need(role[0] == 'C', 'Copy targets owned field') + rows[role] = dict(rows[source]) + else: + need(role != source, 'Reversible ADD distinct registers') + v.add(rows[role], rows[source], Q(op[3], op[4])) + else: + q = Q(op[2], op[3]); rows[role] = {k: q*x for k, x in rows[role].items()} + else: + need(kind in ('phase', 'adapter', 'residual_adapter'), 'Unsupported event '+kind) + if touched is not None: + values = [abs(x) for x in rows[touched].values()] + norm = sum(values, Q(0)) + if norm > max_l1: + max_l1 = norm; witness = {'event': i, 'role': list(touched)} + if values: + max_coefficient = max(max_coefficient, max(values)) + max_numerator = max(max_numerator, max(x.numerator for x in values)) + max_denominator = max(max_denominator, max(x.denominator for x in values)) + need([current['L', i] for i in range(n)] == canonical['final'], 'Exact final native frames') + need(all(current['P', i] == 1 for i in range(cache_count)), 'Logger cache terminal frame') + if expected_profile is not None: + need(dict(profile) == {int(k): x for k, x in expected_profile.items()}, 'Complete profile binding') + mismatch = [] + matrix = geo['H'] if endpoint == 'H' else geo['J'] + for role, actual in rows.items(): + wanted = {} if role[0] == 'C' else v.identity(role) + if role[0] == 'L': + port = role[1] if backward else role[1]-112 + if 0 <= port < 112: + offset, sign = (112, -1) if backward else (0, 1) + for j, q in matrix[port].items(): + v.add(wanted, v.identity(('L', offset+j)), sign*q) + elif role[0] == 'P': + need(endpoint == 'logger' and not backward, 'Only forward logger cache contract') + k = role[1] + for j, q in {geo['selected'][k]: Q(1), **geo['L'][k]}.items(): + v.add(wanted, v.identity(('L', j)), q) + if actual != wanted: + differences = {k: actual.get(k, Q(0))-wanted.get(k, Q(0)) for k in actual.keys() | wanted.keys()} + differences = {k: x for k, x in differences.items() if x} + first = min(differences) + mismatch.append({'role': list(role), 'unequal_coefficients': len(differences), + 'first_input': list(first[0]), 'first_word': list(first[1]), + 'first_coefficient': str(differences[first])}) + if not allow_mismatch: + need(not mismatch, 'Endpoint mismatch: '+repr(mismatch[:3])) + return dict(direction='backward' if backward else 'forward', endpoint=endpoint, + independent_persistent_input_fields=n+cache_count, + independently_initialized_owned_C_fields=len(centers), owned_C_fields_zero_at_exit=all(not rows['C', i] for i in centers), + all_408_helpers_exactly_restored_in_logical_coordinates=all(rows['L', i] == v.identity(('L', i)) for i in range(224, 632)), + all_scalar_frames_checked=True, all_new_coefficients_dyadic=True, + event_counts=dict(counts), paid_profile=dict(sorted(profile.items())), + paid_rank_mass=sum(k*x for k, x in profile.items()), real_scalar_allowance=scalar_cost, + prefix=dict(max_formal_row_l1=str(max_l1), max_abs_coefficient=str(max_coefficient), + max_abs_numerator=max_numerator, max_denominator=max_denominator, l1_witness=witness, + scope='Exact logical ideal prefixes; no rounded recursive error bound.'), + exact_endpoint=not mismatch, mismatch_examples=mismatch[:3]) + + +def lower_exact(p, ce, op): + recipe, _ = ce.lower_child(op) + left = p.monomial(ce, recipe['left'], op.n) + if recipe['rank']: + right = p.monomial(ce, recipe['right'], op.n) + decoded = right.then(ce.fourier(op.n, range(recipe['rank']))).then(left) + else: + decoded = left + need(decoded.tab == op.tab and decoded.zero_state() == op.zero_state(), 'Independent recipe decode including absolute phase') + return recipe + + +def normal_form(p, ce, op, rank): + recipe = lower_exact(p, ce, op) + need(recipe['rank'] == rank, 'Physical rank equals promised helper width') + left = p.monomial(ce, recipe['left'], 9) + right = p.monomial(ce, recipe['right'], 9) + pre = right.adjoint(); post = left.adjoint() + pre_recipe = lower_exact(p, ce, pre); post_recipe = lower_exact(p, ce, post) + need(pre_recipe['rank'] == post_recipe['rank'] == 0, 'Free boundary wrappers') + wrapped = pre.then(op).then(post); target = ce.fourier(9, range(rank)) + need(wrapped.tab == target.tab and wrapped.zero_state() == target.zero_state(), 'Helper boundary is exact standard Fourier including phase') + return dict(rank=rank, factorization=recipe, outer_pre_monomial=pre_recipe['left'], + outer_post_monomial=post_recipe['left'], exact_tableau_and_global_phase=True) + + +def helper_normal_forms(p, ce, canonical, cache=None): + """Certify every helper, with explicit inherited and fresh outer wrappers. + + Bare residual is F_end F_start^-1. The retained residual_adapter convention + already maps it to C_width in forward, and conjugate(C_width) in backward. + New outer normalizers below act at the WHOLE invocation boundaries. They + require no change to internal frames, helper reads, or scalar event order. + """ + cache = {} if cache is None else cache + rows = []; widths = Counter() + for role in range(224, 632): + start, end = canonical['start'][role], canonical['final'][role] + A, B = canonical['frames'][start], canonical['frames'][end] + rank = len(B)-len(A) + need(0 < rank <= 9, 'Positive productive helper width') + key = (tuple(A), tuple(B)) + if key not in cache: + physical = ce.canonical_frame(9, A).adjoint().then(ce.canonical_frame(9, B)) + inherited = lower_exact(p, ce, physical) + need(inherited['rank'] == rank, 'Native helper residual rank') + lm = p.monomial(ce, inherited['left'], 9) + rm = p.monomial(ce, inherited['right'], 9) + directions = {} + for backward in (False, True): + name = 'backward' if backward else 'forward' + op = p.conjugate(ce, physical) if backward else physical + l = p.conjugate(ce, lm) if backward else lm + r = p.conjugate(ce, rm) if backward else rm + native = r.adjoint().then(op).then(l.adjoint()) + target = ce.fourier(9, range(rank)) + if backward: + target = p.conjugate(ce, target) + need(native.tab == target.tab and native.zero_state() == target.zero_state(), 'Inherited oriented native helper boundary') + directions[name] = dict(bare_residual_normal_form=normal_form(p, ce, op, rank), + inherited_native_target='conjugate(C_width)' if backward else 'C_width', + existing_native_boundary_normal_form=normal_form(p, ce, native, rank)) + cache[key] = dict(start_basis=A, end_basis=B, inherited_forward_factorization=inherited, directions=directions) + rows.append(dict(role=role, start_frame=start, end_frame=end, width=rank, certificate=cache[key])) + widths[rank] += 1 + expected = {5: 28, 6: 18, 7: 56, 8: 93, 9: 213} if widths[7] == 56 else {5: 28, 6: 18, 7: 57, 8: 92, 9: 213} + need(dict(widths) == expected, 'Exact all-helper productive width profile') + return dict(status='PASS_ALL_408_HELPERS_BOTH_ORIENTATIONS_WITH_ABSOLUTE_PHASE', + count=len(rows), widths=dict(sorted(widths.items())), total_width=sum(k*x for k, x in widths.items()), + recipes=rows, unique_frame_pairs=len({(r['start_frame'], r['end_frame']) for r in rows}), + scope='Native ideal helper block and free boundary adapters only; productive outer ownership and full recursive bill are separate obligations.') + + +def h_child_recipes(p, ce, canonical, words): + result = {} + for direction, program in words.items(): + rows = [] + for i, e in enumerate(program): + if e[0] != 'center': + continue + _, role, old, new, rank = e + # These corrections occur OUTSIDE the inherited data adapters. + # The physical endpoint references are the original port gates, + # not the monomial-equivalent canonical representatives. Using a + # bare canonical_frame here would leave an uncharged/missing phase + # adapter on the scalar contact despite a correct logical replay. + k = len(rows); port_index = SELECTED[k]; q = canonical['ports'][port_index] + if direction == 'forward': + source = ce.fourier(9) + target = ce.cgate(9, q).adjoint().then(ce.fourier(9)) + else: + source = ce.ident(9) + target = p.conjugate(ce, ce.cgate(9, q)) + op = source.adjoint().then(target) + recipe = lower_exact(p, ce, op) + need(recipe['rank'] == rank == 1, 'Completion child rank one') + direct = ce.cgate(9, q).adjoint() + need(op.tab == direct.tab and op.zero_state() == direct.zero_state(), 'External completion is exact inverse port gate') + rows.append(dict(event=i, selected_port=port_index, port_vector=q, + source_frame=old, target_frame=new, recipe=recipe, + physical_reference='original external endpoint gauge; inherited adapters already outside the contact', + exact_inverse_port_gate_including_phase=True)) + need(len(rows) == 8, 'Exactly eight completion children') + result[direction] = rows + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--out', type=Path, default=HERE/'fresh-certificates') + ap.add_argument('--stage', choices=('helpers', 'H', 'logger', 'all'), default='all') + ap.add_argument('--tags', nargs='+', choices=TAGS, default=list(TAGS)) + args = ap.parse_args(); args.out.mkdir(parents=True, exist_ok=True) + p, v, ce, receipt, inherited = authenticated() + geo = geometry(v.PACKET) + run = dict(schema='fresh-native-H112-reconstruction/1', reconstructed_after_loss=True, + source_sha256=digest(Path(__file__)), predecessor_receipt_sha256=RECEIPT_SHA, + predecessor_generator_sha256=P_SHA, independent_interpreter_sha256=p.CHECKER_SHA, + clifford_compiler_sha256=CE_SHA, packet_sha256=digest(v.PACKET), + geometry=dict(selected=list(SELECTED), ordinary_count=104, L_nonzeros=416, H_squared_identity=True, + H_not_symmetric=True, divisions_by_odd_numbers=0), + environment=dict(python=sys.version, platform=platform.platform()), + no_new_kappa_claimed=True, providers={}) + phase_cache = {} + for tag in args.tags: + started = time.monotonic() + c = read(BASE/(tag+'-CANONICAL.json.gz')); word = read(BASE/(tag+'-NATIVE-WORD.json.gz')) + row = dict(predecessor_artifacts=receipt['providers'][tag]['artifacts']) + if args.stage in ('helpers', 'all'): + helpers = helper_normal_forms(p, ce, c, phase_cache) + path = args.out/(tag+'-HELPER-BOUNDARIES.json.gz') + row['helper_boundaries'] = dict(artifact=path.name, sha256=save(path, helpers), widths=helpers['widths'], + total_width=helpers['total_width'], count=408) + print('PASS helpers', tag, helpers['widths'], flush=True) + if args.stage in ('H', 'all'): + hw = make_h_word(c, word, geo); expected_profile = Counter({int(k): x for k, x in c['local_profile'].items()}); expected_profile[1] += 8 + checks = {d: replay_extended(v, hw[d], c, geo, d == 'backward', expected_profile=expected_profile) for d in ('forward', 'backward')} + phases = h_child_recipes(p, ce, c, hw) + baseline_scalar = receipt['providers'][tag]['checks']['forward']['independent_literal_replay']['conservative_real_scalar_primitive_allowance'] + need(all(check['real_scalar_allowance']-baseline_scalar == 4336 for check in checks.values()), 'Exact 4336 scalar increment') + broken = deepcopy(hw['forward']) + omitted = next(i for i, e in enumerate(broken) if e[0] == 'scalar' and e[1][:2] == ['add', ['L', 112+SELECTED[0]]] and e[1][2] == ['C', 0]) + broken.pop(omitted) + negative = replay_extended(v, broken, c, geo, allow_mismatch=True) + need(not negative['exact_endpoint'], 'Missing completion negative control rejected') + path = args.out/(tag+'-H112-NATIVE.json.gz') + row['H112'] = dict(artifact=path.name, sha256=save(path, hw), checks=checks, new_child_recipes=phases, + increment=dict(profile={'1': 8}, real_scalar_allowance=4336, owned_C_fields=1, persistent_fields=0), + omitted_completion_negative_control=negative['mismatch_examples']) + print('PASS H112', tag, '8 H1 + 4336; both directions', flush=True) + if args.stage in ('logger', 'all'): + lw = make_logger_word(c, word, geo) + profile = Counter({int(k): x for k, x in c['local_profile'].items()}); profile[9] += 8 + check = replay_extended(v, lw, c, geo, endpoint='logger', cache_count=8, expected_profile=profile) + baseline_scalar = receipt['providers'][tag]['checks']['forward']['independent_literal_replay']['conservative_real_scalar_primitive_allowance'] + need(check['real_scalar_allowance']-baseline_scalar == 4224, 'Exact 4224 scalar logger increment') + op = ce.canonical_frame(9, c['frames'][0]).adjoint().then(ce.canonical_frame(9, c['frames'][1])) + recipe = lower_exact(p, ce, op); need(recipe['rank'] == 9, 'Logger paid rank nine') + path = args.out/(tag+'-FORWARD-LOGGER.json.gz') + row['logger'] = dict(artifact=path.name, sha256=save(path, lw), check=check, cache_child_recipe=recipe, + increment=dict(profile={'9': 8}, real_scalar_allowance=4224, owned_C_fields=0, arbitrary_cache_fields=8), + cache_restored=False, productive_cache_credit_claimed=False) + print('PASS logger', tag, '8 H9 + 4224', flush=True) + row['seconds'] = time.monotonic()-started + run['providers'][tag] = row + save(args.out/('RESULT-'+args.stage+'.json'), run) + run['status'] = 'PASS_FRESH_RECONSTRUCTION_REQUESTED_STAGES' + save(args.out/('RESULT-'+args.stage+'.json'), run) + + +if __name__ == '__main__': + main() diff --git a/research/hyperplane-retiming/vendor/research/missing-join-frame/PATCH.json b/research/hyperplane-retiming/vendor/research/missing-join-frame/PATCH.json new file mode 100644 index 0000000000..f96d295d40 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/missing-join-frame/PATCH.json @@ -0,0 +1,24 @@ +{ + "phase": "B", + "ordinal": 480, + "old_frame": 732, + "new_basis": [ + 168, + 336, + 45 + ], + "old_basis": [ + 258, + 133, + 82, + 45 + ], + "incoming_frames": [ + 364, + 360 + ], + "outgoing_frames": [ + 736, + 692 + ] +} diff --git a/research/hyperplane-retiming/vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py b/research/hyperplane-retiming/vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/hyperplane-retiming/vendor/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<0 and margin(hi)[1]<0,'Strict p16 raw crossing enclosure') + oldP={int(k):v for k,v in source['canonical']['local_profile'].items()};oldH=Counter(len(c['frames'][source['canonical']['final'][r]])-len(c['frames'][source['canonical']['start'][r]]) for r in range(224,632)) + local=[] + for C in (Q('.0030216'),Q('.004')): + nt,np=E.moment(H,1-C),E.moment(P,1-C);ot,op=E.moment(oldH,1-C),E.moment(oldP,1-C);gain=nt[0]-np[1]-ot[1]+op[0];need(gain>0,'Strict entire local moment improvement');local.append({'C':str(C),'gain_lower':str(gain)}) + return {'status':'PASS_COORDINATED_HYPERPLANE_NATIVE_PHASE_MOMENT','native':checks,'changed_helper_entrances':len(patch['helper_entrances']),'changed_contacts':len(patch['contacts']),'helpers':dict(H),'paid':P,'new_paid_phase_pairs':phase_paid,'changed_helper_phase_normalizers':phase_helpers,'whole_targets':dict(T),'whole_paid':dict(paid),'rank_surplus':752,'raw_crossing':[str(lo),str(hi)],'raw_lower_margin':str(margin(lo)[0]),'raw_upper_margin':str(margin(hi)[1]),'local_strict_gain':local,'controls':['false_paid_rank_rejected','wrong_absolute_phase_rejected'],'new_kappa':None,'scope':'Exact local supplier, all-fiber gauge proof, complete p16 raw moment. Finite/compiler, precision and outer admission remain separate.'} +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args() + if sys.flags.optimize: + # Inherited source assertions remain enabled even under an optimized caller. + raise SystemExit(subprocess.run([sys.executable,'-I','-B',str(Path(__file__).resolve()),*(['--write'] if a.write else [])],check=False).returncode) + result=run();target=HERE/'RESULT.json' + if a.write:target.write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + else:need(read(target)==json.loads(json.dumps(result)),'Deterministic complete receipt') + print(result['status'],flush=True)