diff --git a/.github/workflows/dirty-stride-precision.yml b/.github/workflows/dirty-stride-precision.yml new file mode 100644 index 0000000000..3c1003e07e --- /dev/null +++ b/.github/workflows/dirty-stride-precision.yml @@ -0,0 +1,26 @@ +name: Dirty stride precision +on: + pull_request: + paths: + - 'research/dirty-stride-precision/**' + - '.github/workflows/dirty-stride-precision.yml' + push: + paths: + - 'research/dirty-stride-precision/**' + - '.github/workflows/dirty-stride-precision.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + verify: + runs-on: ubuntu-latest + timeout-minutes: 45 + strategy: + matrix: + python: ['3.11', '3.14'] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + - run: python -I -O -B research/dirty-stride-precision/test_package.py diff --git a/research/dirty-stride-precision/CHECKS.md b/research/dirty-stride-precision/CHECKS.md new file mode 100644 index 0000000000..4178f08ec1 --- /dev/null +++ b/research/dirty-stride-precision/CHECKS.md @@ -0,0 +1,29 @@ +# Check ownership and scope + +The test authoring gate was read before the new checks were added. Each +group below protects a mathematical or package contract. No production +hook, changed dispatcher, or runtime monkey patch was added for a check. + +| Owner | Contract and credible defect | Separate evidence | +| --- | --- | --- | +| `pins` | The proof applies to the retained word and source dependencies. A transport or word edit can invalidate that proof. | SHA256 and Git blob pins; AST comparison permits only the new admission, helper, and two read-once validation edits. Numerical faults are also tested without this binding check. | +| `budget_checks` | Fractional, integer, preparation, and feedback inequalities must hold. A missing factor, wrong beta exponent, or omitted inverse-preimage term can understate a width. | Separate count recurrence, Euler-phi formula, and exponent inequalities. Package faults reduce the local exponent and inverse guard and must fail at these checks. | +| `admission_checks` | Every induced exponent is between `2^k` and the original cycle length. Prepared powers must be exactly zero at the claimed cutoff. | Exact geometry enumeration, real and complex powers, rational non-dyadic margins, and all-length threshold inequalities. A false cutoff is rejected by actual nonzero coefficient output. | +| `zero_subtrees` | The dirty tail must have the exact addition endpoint and a depth-independent magnitude bound. Endpoint equality alone is insufficient. | Actual `solve` calls with five further structural levels, both signs, two root phases, arbitrary dirty data, and peak-value observation. | +| `leaf_checks` | Signed source-only accuracy, exact restoration, target dependence, and the unchanged tape bill must hold. A wrong restoration or expansion can break them. | A separate geometric inverse, unmodified PR985 output comparison, actual tape meters, and two target-dependent increments. | +| `deep_admission` | A finite case beyond the old length gate must execute correctly. The new formula alone is insufficient evidence. | Full `L=5741` word, a residual bound from the Neumann inverse, exact cancellation, and complete movement count. The old public API rejects the same dimensions and width. | +| `kernel_cases` | Tighter budgets must support the actual dirty word. A missing inner shift or wrong inverse order can corrupt output or restoration. | All ten original factor fixtures, a dense expanded-polynomial oracle, both signs from fresh states, both inverse orders, odd lowest bits, integer guards, and two physical tape heads. | +| `uniform_kernel_cases` | The stated uniform widths must admit actual coefficient preparation and execution, not only an integer formula. | Roots are rounded to the prescribed factor width. Exact interval coefficient bounds, stable margins, norm hypotheses, dense output, and restoration are checked. | +| `run_counted` | Literal array accesses must equal the charged reads and writes. Duplicate validation reads were present in the predecessor. | An array observer counts actual indexed accesses independently. It rejects the retained original and a duplicate-read mutation. | +| `test_package` | The result must run without a checkout or writable source. It must detect source drift and preserve an existing output file. | Twelve faults, a full read-only relocated replay in a path with spaces, and exact receipt regeneration. | + +PR985's full original package remains byte-exact. Its power cases are +reused because the powering implementation is unchanged and extinction +depends on its norm bound. The new leaf cases own the changed admission +and signed-error transfer. The new suite does not replay unrelated +frontier or compiler packages. The selected-record checks protect the +unchanged current frontier separately. + +The written proofs supply the all-size arguments. Finite cases cannot +replace the return-time induction, zero-subtree induction, common-operator +theorem, or inherited analytic and preparation hypotheses. diff --git a/research/dirty-stride-precision/CLAIM.json b/research/dirty-stride-precision/CLAIM.json new file mode 100644 index 0000000000..895d364096 --- /dev/null +++ b/research/dirty-stride-precision/CLAIM.json @@ -0,0 +1,47 @@ +{ + "active_depth": "min(K, ceil(log2(1/beta)) + ceil(log2(W+1)))", + "actual_structural_recursion_unchanged": true, + "additional_word_size_inputs": "Immutable coefficient, margin, multiplier and unit-gauge descriptor lengths; long stride input descriptions are also paid.", + "base_commit": "8bddbee377e2f3ce1f1247196c4b290d55767d20", + "branch": "codex/s8-dirty-precision", + "concurrent_contributions": [ + { + "contribution": "Phase lane array observer", + "relation": "It found two PR985 validation expressions that read twice but charge once. The derived solver caches each value once and the retained original is unchanged." + }, + { + "contribution": "PR1025", + "head": "6ef2168ac90d42926bceb7ac9b2e029463800c76", + "relation": "It improves an analytic input and gives a clean-scratch corollary. Its proof was read for overlap. It is not a dependency. A combined dirty budget is a follow-up; see OVERLAP.md." + } + ], + "consumed_pr985_head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "fractional_bound": "W <= max(p,w_input) + m + 18*r^3", + "kind": "conditional accuracy theorem and exact-rational verification", + "length_independent_leaf_threshold": "W >= 4*ceil(log2(1/beta)) + 16", + "nonclaims": [ + "new kappa", + "minimum working width", + "measured runtime gain", + "nonconstant site phases", + "new transport", + "all-size root factorizer", + "fast bit compiler", + "Lean proof", + "complete transform or multiplication reduction" + ], + "pr985_successor": { + "checked_utc": "2026-10-13T17:11:38.940368+00:00", + "head": "da1cdf8ed4ac9b1b8378dfec73f77ff4e81a4f70", + "relation": "Accounting-only successor reported by the coordinator. The exact consumed 9df42a predecessor remains unchanged; see OVERLAP.md." + }, + "prepared_for": "Ali Romman (@aliromman)", + "primary_claim": "The actual constant-coefficient PR985 dirty arbitrary-stride word has an all-length sufficient admission and a cubic sufficient kernel precision bound, with exact restoration and its full two-tape bill.", + "review_boundary": "The coordinator reviews this local candidate before publication. No independent human review is claimed.", + "schema": 1, + "seed": null, + "selected_kappa_unchanged": "1661960547713947/1000000000000000000", + "signed_integer_reserve_bound": "I <= m + 15*r^3", + "source_and_dirty_restoration": "exact grid-word restoration in both signs", + "substantial_ai_assistance": "OpenAI Codex, assigned Astra Max lane in the eight-contribution sprint" +} diff --git a/research/dirty-stride-precision/EXPECTED.json b/research/dirty-stride-precision/EXPECTED.json new file mode 100644 index 0000000000..039ea4eff6 --- /dev/null +++ b/research/dirty-stride-precision/EXPECTED.json @@ -0,0 +1,2224 @@ +{ + "admission": { + "extinction_cases": 180, + "extinction_sha256": "0a2484189c5d847b796da085769f5952905799e8d8822e69fcf3d931404716de", + "geometries": 8256, + "thresholds": 1088 + }, + "budgets": { + "cases": 5220, + "radix64": { + "circle_exponent": 129037, + "coefficient_mass": 1458, + "depth": 6, + "factor_bits": 516499, + "factors": 63, + "incoming_bits": 0, + "integer_bits": 1291719, + "inverse_exponent": 258140, + "leaf_calls": 4000, + "local_error_exponent": 645878, + "magnitude_bits": 20, + "margin_exponent": 129173, + "phi": 32, + "prefix_exponent": 258287, + "preparation_error_exponent": 516432, + "radix": 64, + "target_bits": 128, + "working_bits": 1420902 + }, + "radix64_old_fractional_bits": 517236859, + "sha256": "741f370d788ba1f68bfb557c94dad10fe3fc8ef34e7ed41ba5c301cd0c1a8b4a" + }, + "controls": [ + { + "name": "reduced_precision_certificate", + "reason": "certificate fields" + }, + { + "name": "boolean_certificate", + "reason": "integer certificate" + }, + { + "name": "feedback_violation", + "reason": "feedback smallness" + }, + { + "name": "underprecision", + "reason": "precision admission" + }, + { + "name": "old_length_gate", + "reason": "precision admission" + }, + { + "name": "off_grid", + "reason": "fixed grid data" + }, + { + "name": "borrowed_target", + "reason": "all arrays distinct" + }, + { + "name": "nonunit_gauge", + "reason": "immutable unit gauge" + }, + { + "name": "mixed_unstable_factor", + "reason": "stable factor descriptor" + } + ], + "deep": { + "bits": 12, + "effective_depth": 5, + "length": 5741, + "old_admitted": false, + "residual_squared": "17/67108864", + "stride": 2378, + "structural_depth": 10, + "tape_moves": 3952237 + }, + "inherited_powers": { + "cases": 2322, + "maximum_exponent": 129, + "nonzero_errors": 2178 + }, + "kernels": [ + { + "embedding": 1, + "error_squared_log2_upper": -447, + "gauge": [ + "1", + "0" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 1, + "negative_error_squared_log2_upper": -447, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 2, + "radix": 3, + "sha256": "0131657b755d06bdf504babf50e8f78a69a5ccfa6d7d84b4dee65a98619c8861", + "stride": 0, + "tape_bound": 122880, + "tape_moves": 29, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -450, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 1, + "negative_error_squared_log2_upper": -450, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 3, + "radix": 3, + "sha256": "7fb7b5662cc31041bd77d3697bfc8a9c9bf1847c688dc5ce54acbe9d2025f2ae", + "stride": 0, + "tape_bound": 122880, + "tape_moves": 29, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -442, + "gauge": [ + "1", + "0" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 3, + "negative_error_squared_log2_upper": -442, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "e8f9c0c21c749630954ee6ec56eb4c66016201d71be57b0393090fdbf535a6b9", + "stride": 1, + "tape_bound": 368640, + "tape_moves": 1311, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -448, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 3, + "negative_error_squared_log2_upper": -448, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "9028f35b04c274398a6dd08b4e6d17235537e4e2edc378fc2ffb11703e69a824", + "stride": 1, + "tape_bound": 368640, + "tape_moves": 1311, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -445, + "gauge": [ + "1", + "0" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 5, + "negative_error_squared_log2_upper": -445, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "ca6981ee5635976c0e12b445b71ed40decdb2a64633a4af4f2e041904ff5e9ad", + "stride": 2, + "tape_bound": 614400, + "tape_moves": 4049, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -445, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 5, + "negative_error_squared_log2_upper": -445, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 5, + "radix": 3, + "sha256": "b72ce90e849c702d33705f4110d2d8fdca7b18c729a17ba79c0483fd70c43a00", + "stride": 2, + "tape_bound": 614400, + "tape_moves": 4049, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -445, + "gauge": [ + "1", + "0" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 5, + "negative_error_squared_log2_upper": -445, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "671f5f13109679cfa1f800d98e013b5165b3079bfa2775ca8041c0f1d1a1ef8b", + "stride": -2, + "tape_bound": 614400, + "tape_moves": 4033, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -443, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 78, + "leaf_calls": 4, + "length": 5, + "negative_error_squared_log2_upper": -443, + "nonzero_error": true, + "old_working_bits": 188, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "88979699a188520d28fc2cc2c8cfce8d9618c4eb897627c330d7ce5972be6437", + "stride": -2, + "tape_bound": 614400, + "tape_moves": 4033, + "working_bits": 224 + }, + { + "embedding": 1, + "error_squared_log2_upper": -505, + "gauge": [ + "1", + "0" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 1, + "negative_error_squared_log2_upper": -505, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 3, + "radix": 4, + "sha256": "10639197ae7b1f00ccf64e9d5dd05f5d4e6e3881a01b6efaff0b5178b5359dda", + "stride": 0, + "tape_bound": 360448, + "tape_moves": 104, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -507, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 1, + "negative_error_squared_log2_upper": -507, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "a76cc1efc65eabc49fe911f93161c795ce85bb82fd1757b9a25871fe5b5b4286", + "stride": 0, + "tape_bound": 360448, + "tape_moves": 104, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -501, + "gauge": [ + "1", + "0" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 3, + "negative_error_squared_log2_upper": -501, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "c86d68e4fd5e13686fad24b29002455e5fa8e9dcd9d2b0f83ec2eda6b7cd9ad8", + "stride": 1, + "tape_bound": 1081344, + "tape_moves": 3392, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -502, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 3, + "negative_error_squared_log2_upper": -502, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "c96a03aa69e95b58d5f20dcc6f29f74dcb076d7ab9b3edf14593949d53bb8ef6", + "stride": 1, + "tape_bound": 1081344, + "tape_moves": 3392, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -498, + "gauge": [ + "1", + "0" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 5, + "negative_error_squared_log2_upper": -498, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 6, + "radix": 4, + "sha256": "19e9afffa972e7bda1eb1d0e7db1670c3e29860b5da9d2f6791069c9fb514657", + "stride": 2, + "tape_bound": 1802240, + "tape_moves": 10320, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -500, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 5, + "negative_error_squared_log2_upper": -500, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "ec6889bf9870f127c14c99c9955e27615e4d5f2232084a84fc71e84c783165ac", + "stride": 2, + "tape_bound": 1802240, + "tape_moves": 10320, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -499, + "gauge": [ + "1", + "0" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 5, + "negative_error_squared_log2_upper": -499, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 5, + "radix": 4, + "sha256": "54a8ab197f3953dac3556cde67739fb1bdfca0a6bdb5d855a116ee0a7d3a31cd", + "stride": -2, + "tape_bound": 1802240, + "tape_moves": 10280, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -500, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 87, + "leaf_calls": 10, + "length": 5, + "negative_error_squared_log2_upper": -500, + "nonzero_error": true, + "old_working_bits": 241, + "peak_l1_log2_upper": 5, + "radix": 4, + "sha256": "f15ec8c12cf65461b6561d0a38f8f3f4397f6e1f5cfbb9048813a43f161bae37", + "stride": -2, + "tape_bound": 1802240, + "tape_moves": 10280, + "working_bits": 252 + }, + { + "embedding": 1, + "error_squared_log2_upper": -583, + "gauge": [ + "1", + "0" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 1, + "negative_error_squared_log2_upper": -583, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 3, + "radix": 5, + "sha256": "ab1ec1f1de256b3da1bfc13a394378d8e7203447ddd4921c1891631632ef5ad6", + "stride": 0, + "tape_bound": 557056, + "tape_moves": 128, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -583, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 1, + "negative_error_squared_log2_upper": -583, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 5, + "radix": 5, + "sha256": "e3a9d0dadacf40597923ed26335e010e1236d374ee81fbe28ef659d0aaab5b4d", + "stride": 0, + "tape_bound": 557056, + "tape_moves": 128, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -578, + "gauge": [ + "1", + "0" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 3, + "negative_error_squared_log2_upper": -578, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 5, + "radix": 5, + "sha256": "fa6c1a7173cfcf3bcb882482291b1401522cd0083e2db3476729083416d6b890", + "stride": 1, + "tape_bound": 1671168, + "tape_moves": 5256, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -580, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 3, + "negative_error_squared_log2_upper": -580, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 4, + "radix": 5, + "sha256": "c2a2d4b2c6c6ab5c3772aecfb8878e8fb72579b45c16f721485728a037a37f9d", + "stride": 1, + "tape_bound": 1671168, + "tape_moves": 5256, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -572, + "gauge": [ + "1", + "0" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 5, + "negative_error_squared_log2_upper": -572, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 7, + "radix": 5, + "sha256": "045785caf1f710e6e084aa5449a34cbed240ad5dc47f6145d9c5e4c7d6f35c1f", + "stride": 2, + "tape_bound": 2785280, + "tape_moves": 16208, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -577, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 5, + "negative_error_squared_log2_upper": -577, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 5, + "radix": 5, + "sha256": "efa7e864166fdb2fcf0f550d59928f0cae19b978a89f47f0c72c0d5e20dc26b4", + "stride": 2, + "tape_bound": 2785280, + "tape_moves": 16208, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -572, + "gauge": [ + "1", + "0" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 5, + "negative_error_squared_log2_upper": -572, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 7, + "radix": 5, + "sha256": "33c621778f66b54c10e9ab304b1f166aff1a893a5e8a50cd343b529b74e12695", + "stride": -2, + "tape_bound": 2785280, + "tape_moves": 16144, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -577, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 106, + "leaf_calls": 16, + "length": 5, + "negative_error_squared_log2_upper": -577, + "nonzero_error": true, + "old_working_bits": 309, + "peak_l1_log2_upper": 6, + "radix": 5, + "sha256": "74414e4b289ab10b3bcfd8bca8866743b638cadcb0ce357591de961dbb69ccc3", + "stride": -2, + "tape_bound": 2785280, + "tape_moves": 16144, + "working_bits": 291 + }, + { + "embedding": 1, + "error_squared_log2_upper": -829, + "gauge": [ + "1", + "0" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 1, + "negative_error_squared_log2_upper": -829, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 4, + "radix": 7, + "sha256": "d883d6f393b65cdc0988c59f18617c4636eab53dc951e3df6b97aab4b5a6d4b0", + "stride": 0, + "tape_bound": 1679360, + "tape_moves": 479, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -822, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 1, + "negative_error_squared_log2_upper": -822, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 8, + "radix": 7, + "sha256": "667e642c22d4252e1c8c161983c00decb8ea6e5faa9c2e4b834823dc71b29d2b", + "stride": 0, + "tape_bound": 1679360, + "tape_moves": 479, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -820, + "gauge": [ + "1", + "0" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 3, + "negative_error_squared_log2_upper": -820, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 6, + "radix": 7, + "sha256": "75ca66c65628c55f4383fe31575de729ae362548cdbdfc72cb6cbbb52a98523b", + "stride": 1, + "tape_bound": 5038080, + "tape_moves": 13733, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -816, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 3, + "negative_error_squared_log2_upper": -816, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 7, + "radix": 7, + "sha256": "a05c29eb10fb3ff8d5ee414d6fa00303b6461cb86c84cb802fce900a6ef1837a", + "stride": 1, + "tape_bound": 5038080, + "tape_moves": 13733, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -819, + "gauge": [ + "1", + "0" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 5, + "negative_error_squared_log2_upper": -819, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 7, + "radix": 7, + "sha256": "71d0c26ef36c48760ef1f3c7a06e759daf453163d379334ea240d3776be5aa9a", + "stride": 2, + "tape_bound": 8396800, + "tape_moves": 41547, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -815, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 5, + "negative_error_squared_log2_upper": -815, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 8, + "radix": 7, + "sha256": "a9a31d394f9aeeeba4a555d4f12e5a250066dcf4cc05823a14aae75b26f51ff1", + "stride": 2, + "tape_bound": 8396800, + "tape_moves": 41547, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -820, + "gauge": [ + "1", + "0" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 5, + "negative_error_squared_log2_upper": -820, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 7, + "radix": 7, + "sha256": "29299c63fe847a9b2e4d556cb26a84b31fdd521532343c87c66c68d9b983791e", + "stride": -2, + "tape_bound": 8396800, + "tape_moves": 41387, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -814, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 166, + "leaf_calls": 40, + "length": 5, + "negative_error_squared_log2_upper": -814, + "nonzero_error": true, + "old_working_bits": 659, + "peak_l1_log2_upper": 8, + "radix": 7, + "sha256": "e2affeaba08e431c57f9bfbb32c20e79a51477555109f710ec5acc86d672c50e", + "stride": -2, + "tape_bound": 8396800, + "tape_moves": 41387, + "working_bits": 412 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1098, + "gauge": [ + "1", + "0" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 1, + "negative_error_squared_log2_upper": -1098, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 4, + "radix": 8, + "sha256": "3a0779009f09efa0c35ca189e60ed5448c842ddddf44551f5ed0fdf018f312f4", + "stride": 0, + "tape_bound": 2170880, + "tape_moves": 549, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1101, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 1, + "negative_error_squared_log2_upper": -1101, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 7, + "radix": 8, + "sha256": "eb4d8b35c4cd1f0a2d4366622a9c4b092c423e78f309afc4ac166955b49489f7", + "stride": 0, + "tape_bound": 2170880, + "tape_moves": 549, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1090, + "gauge": [ + "1", + "0" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 3, + "negative_error_squared_log2_upper": -1090, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 7, + "radix": 8, + "sha256": "85cbd92c0e6a8040f87632a9c725bdbf4eb4ffd0c7c247e9d5406590500357d4", + "stride": 1, + "tape_bound": 6512640, + "tape_moves": 17527, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1091, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 3, + "negative_error_squared_log2_upper": -1091, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 6, + "radix": 8, + "sha256": "38d5a36963c3da7ea087d27a4c15ac3f2d220809dd6bbe3156a81382a09dafb4", + "stride": 1, + "tape_bound": 6512640, + "tape_moves": 17527, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1090, + "gauge": [ + "1", + "0" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 5, + "negative_error_squared_log2_upper": -1090, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 8, + "radix": 8, + "sha256": "6df06f833036dad90629d28767b5e2c9068aae2b709fb2743272eb4a00349f69", + "stride": 2, + "tape_bound": 10854400, + "tape_moves": 53433, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1089, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 5, + "negative_error_squared_log2_upper": -1089, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 8, + "radix": 8, + "sha256": "a699823784e3d4f03e79cda4c1cc998fa7dacaef3d8d23b8cc892c0816ca50e4", + "stride": 2, + "tape_bound": 10854400, + "tape_moves": 53433, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1091, + "gauge": [ + "1", + "0" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 5, + "negative_error_squared_log2_upper": -1091, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 8, + "radix": 8, + "sha256": "28204e5ee39aaad2ae9b43a11eb567c53d22cc0a3d6a0115c8ca1fb09f25d9ba", + "stride": -2, + "tape_bound": 10854400, + "tape_moves": 53225, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1088, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 237, + "leaf_calls": 52, + "length": 5, + "negative_error_squared_log2_upper": -1088, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 8, + "radix": 8, + "sha256": "fd77e5158ab359d93971914a293e6587ac6c506d5da114271fea0865252c95ad", + "stride": -2, + "tape_bound": 10854400, + "tape_moves": 53225, + "working_bits": 549 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1009, + "gauge": [ + "1", + "0" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 1, + "negative_error_squared_log2_upper": -1009, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 4, + "radix": 9, + "sha256": "b76fd8d2d9d4d81529b2b1d09ffed4569354c44aca371615bd5b013c4bae3ceb", + "stride": 0, + "tape_bound": 2662400, + "tape_moves": 603, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1007, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 1, + "negative_error_squared_log2_upper": -1007, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 5, + "radix": 9, + "sha256": "91927a6de7057f7c89c258d709677425ed3e2f20f039439dac4ca5a800bd4cc7", + "stride": 0, + "tape_bound": 2662400, + "tape_moves": 603, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1004, + "gauge": [ + "1", + "0" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 3, + "negative_error_squared_log2_upper": -1004, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 6, + "radix": 9, + "sha256": "12906282e7156852c8d1ed07e6880a9615f18dea914d6aba282a20559cc26d4c", + "stride": 1, + "tape_bound": 7987200, + "tape_moves": 21321, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1007, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 3, + "negative_error_squared_log2_upper": -1007, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 5, + "radix": 9, + "sha256": "3f383c8f3200f3a1e4f59289c7541eef41c1d424f404bbaffbe3b919c170fd68", + "stride": 1, + "tape_bound": 7987200, + "tape_moves": 21321, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -999, + "gauge": [ + "1", + "0" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -999, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 8, + "radix": 9, + "sha256": "aa29a6c36107bac517e9b360608f394eb912b471ac3926a27eef7f79f102c649", + "stride": 2, + "tape_bound": 13312000, + "tape_moves": 65559, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1005, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -1005, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 7, + "radix": 9, + "sha256": "328c6de29d4c7747899740775d91a7ea5c66d86adda762a800663293d32736e2", + "stride": 2, + "tape_bound": 13312000, + "tape_moves": 65559, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -999, + "gauge": [ + "1", + "0" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -999, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 8, + "radix": 9, + "sha256": "58c88cdaba962fc1e99e255e406a8c91afd37a10c5f952a58b31d15c146208ce", + "stride": -2, + "tape_bound": 13312000, + "tape_moves": 65367, + "working_bits": 506 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1004, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 204, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -1004, + "nonzero_error": true, + "old_working_bits": 1079, + "peak_l1_log2_upper": 7, + "radix": 9, + "sha256": "ff98d3e90e8915ecb7598a3a0f08dc25d7a1605209da76926b10b44e682f92c3", + "stride": -2, + "tape_bound": 13312000, + "tape_moves": 65367, + "working_bits": 506 + }, + { + "embedding": 2, + "error_squared_log2_upper": -835, + "gauge": [ + "1", + "0" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 1, + "negative_error_squared_log2_upper": -835, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 5, + "radix": 9, + "sha256": "fb62486bfe2dedac3382dc105b2575bd0259e12adc76d2b77e95985e59962bb9", + "stride": 0, + "tape_bound": 2662400, + "tape_moves": 603, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -839, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 1, + "negative_error_squared_log2_upper": -839, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 7, + "radix": 9, + "sha256": "b9e48838a5683271c6bdb3fa34d5bb56b2911f4a0a28d86775990ad15703483d", + "stride": 0, + "tape_bound": 2662400, + "tape_moves": 603, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -829, + "gauge": [ + "1", + "0" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 3, + "negative_error_squared_log2_upper": -828, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 6, + "radix": 9, + "sha256": "0aecf120cd6eaec67baf1242f65af6feb0c5c37468a419bec89eb9ea11a61ebf", + "stride": 1, + "tape_bound": 7987200, + "tape_moves": 21273, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -828, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 3, + "negative_error_squared_log2_upper": -828, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 6, + "radix": 9, + "sha256": "ffce064a16f034663a8fe63332ec2a37cff3588d30d49d36635f1fd6d72df0b7", + "stride": 1, + "tape_bound": 7987200, + "tape_moves": 21273, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -825, + "gauge": [ + "1", + "0" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -825, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 8, + "radix": 9, + "sha256": "f11b68fd1354526bc83a9d032be4a308c8f83a44f3077d74dbfcbd400a461de5", + "stride": 2, + "tape_bound": 13312000, + "tape_moves": 65239, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -826, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -826, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 7, + "radix": 9, + "sha256": "d3ca9120a13312e2c6b6140d72bc00dec3b8490bba046c8dab7f4ce00adb17ac", + "stride": 2, + "tape_bound": 13312000, + "tape_moves": 65239, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -825, + "gauge": [ + "1", + "0" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -825, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 9, + "radix": 9, + "sha256": "be7e58054c804891e15c21c7f7032019134ded971976729aa4e1aa35626f9e6f", + "stride": -2, + "tape_bound": 13312000, + "tape_moves": 64983, + "working_bits": 418 + }, + { + "embedding": 2, + "error_squared_log2_upper": -827, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 156, + "leaf_calls": 64, + "length": 5, + "negative_error_squared_log2_upper": -827, + "nonzero_error": true, + "old_working_bits": 875, + "peak_l1_log2_upper": 7, + "radix": 9, + "sha256": "f01c7b1c57b32221f3427db56ffcbfc6a141d0361b2ee2789e64ee809c09b446", + "stride": -2, + "tape_bound": 13312000, + "tape_moves": 64983, + "working_bits": 418 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1163, + "gauge": [ + "1", + "0" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 1, + "negative_error_squared_log2_upper": -1163, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 6, + "radix": 11, + "sha256": "65aa681053e4194efab0251ff8e71a6ef481cbb4f8407da9d14fc86168e64c41", + "stride": 0, + "tape_bound": 5554176, + "tape_moves": 1762, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1160, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 1, + "negative_error_squared_log2_upper": -1160, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 6, + "radix": 11, + "sha256": "f184a3628af57186882ede310500ac190a8ffe362d82b60ea38336315ce418ae", + "stride": 0, + "tape_bound": 5554176, + "tape_moves": 1762, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1153, + "gauge": [ + "1", + "0" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 3, + "negative_error_squared_log2_upper": -1153, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 7, + "radix": 11, + "sha256": "2e7f58b9e46bf0b4d8574a26fa64a7b28001332872257f22bda8fd1815585e47", + "stride": 1, + "tape_bound": 16662528, + "tape_moves": 40126, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1154, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 3, + "negative_error_squared_log2_upper": -1154, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 5, + "radix": 11, + "sha256": "557f570d675f39db06fc5b13cfd547af66ed062f911d04d2922ab22a9eedadd3", + "stride": 1, + "tape_bound": 16662528, + "tape_moves": 40126, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1153, + "gauge": [ + "1", + "0" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 5, + "negative_error_squared_log2_upper": -1153, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 7, + "radix": 11, + "sha256": "5b9c489a4c07f17af3797740354f1b2150c6d668741f5c9ecaaaff6b60f43af4", + "stride": 2, + "tape_bound": 27770880, + "tape_moves": 119930, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1151, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 5, + "negative_error_squared_log2_upper": -1151, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 8, + "radix": 11, + "sha256": "d99175e5ca0da23a9a7c664dcc28b9e995be497030b0087dc5496a5da4a4ff8f", + "stride": 2, + "tape_bound": 27770880, + "tape_moves": 119930, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1153, + "gauge": [ + "1", + "0" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 5, + "negative_error_squared_log2_upper": -1153, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 7, + "radix": 11, + "sha256": "9141043ca34f5d5409e6c004a95b984b4ea776de2ccd9741402cac6e3a958578", + "stride": -2, + "tape_bound": 27770880, + "tape_moves": 119674, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1151, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 229, + "leaf_calls": 112, + "length": 5, + "negative_error_squared_log2_upper": -1151, + "nonzero_error": true, + "old_working_bits": 1752, + "peak_l1_log2_upper": 8, + "radix": 11, + "sha256": "4b36e641ed90787ae6bf5cd0ef1d314e27b93783324659985b49b72375139e2f", + "stride": -2, + "tape_bound": 27770880, + "tape_moves": 119674, + "working_bits": 581 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1463, + "gauge": [ + "1", + "0" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 1, + "negative_error_squared_log2_upper": -1463, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 6, + "radix": 13, + "sha256": "f4bce97e802449d8cec4b8199c7569a82311fb10f9df10e1bb89296b125006b9", + "stride": 0, + "tape_bound": 7913472, + "tape_moves": 2182, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1454, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 1, + "negative_error_squared_log2_upper": -1454, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 7, + "radix": 13, + "sha256": "e874def68178eb6572c42baeadad5384150a5d507f430041ad5558d1248fdcb0", + "stride": 0, + "tape_bound": 7913472, + "tape_moves": 2182, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1458, + "gauge": [ + "1", + "0" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 3, + "negative_error_squared_log2_upper": -1458, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 8, + "radix": 13, + "sha256": "7da0000c922edf7321d17eb80ff15b428e791790950b7c10030db68cc3bed13e", + "stride": 1, + "tape_bound": 23740416, + "tape_moves": 55994, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1452, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 3, + "negative_error_squared_log2_upper": -1452, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 6, + "radix": 13, + "sha256": "70442a6b1a83e82ebe61c8603c8fd495528b4f94e132a601c0e29dde03ace7bd", + "stride": 1, + "tape_bound": 23740416, + "tape_moves": 55994, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1452, + "gauge": [ + "1", + "0" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 5, + "negative_error_squared_log2_upper": -1452, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 9, + "radix": 13, + "sha256": "c622181de97473387c03c6e6d58750d82e57174443a295caed0df56135ba7e54", + "stride": 2, + "tape_bound": 39567360, + "tape_moves": 169390, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1449, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 5, + "negative_error_squared_log2_upper": -1449, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 9, + "radix": 13, + "sha256": "cc23f34302b3b7723703731b9d4fb0fdb2a9820aabac3515229e83d2d918e11a", + "stride": 2, + "tape_bound": 39567360, + "tape_moves": 169390, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1452, + "gauge": [ + "1", + "0" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 5, + "negative_error_squared_log2_upper": -1452, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 9, + "radix": 13, + "sha256": "12b321dea02146d2ca15cc948834753af3015f6ece3029d087b8de3aa2f6786d", + "stride": -2, + "tape_bound": 39567360, + "tape_moves": 169134, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1449, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 292, + "leaf_calls": 160, + "length": 5, + "negative_error_squared_log2_upper": -1449, + "nonzero_error": true, + "old_working_bits": 2753, + "peak_l1_log2_upper": 9, + "radix": 13, + "sha256": "c6ab4899e785955e2133d5b510d96dd343b71f844c6372db6ef40bebee12a63b", + "stride": -2, + "tape_bound": 39567360, + "tape_moves": 169134, + "working_bits": 733 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1408, + "gauge": [ + "1", + "0" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 1, + "negative_error_squared_log2_upper": -1408, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 8, + "radix": 16, + "sha256": "f5423770fbb81ede654cbfde96e4e3db8761a6dc02384c90995d46bf208bcc31", + "stride": 0, + "tape_bound": 11452416, + "tape_moves": 2744, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1406, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 1, + "negative_error_squared_log2_upper": -1406, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 10, + "radix": 16, + "sha256": "798c90680d5a83d1bd85b5e28526c4238aa1ae4892a9dfc384150402238aa6ec", + "stride": 0, + "tape_bound": 11452416, + "tape_moves": 2744, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1397, + "gauge": [ + "1", + "0" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 3, + "negative_error_squared_log2_upper": -1397, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 10, + "radix": 16, + "sha256": "d970c3f1da3225495fb63eec7f7b9b45e4c89e6ec9f2eb1c62c43efb38a45995", + "stride": 1, + "tape_bound": 34357248, + "tape_moves": 79280, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1397, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 3, + "negative_error_squared_log2_upper": -1397, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 9, + "radix": 16, + "sha256": "b34f0b2f751fb0690968fa38e468d2e58bcd2f2189af06d4b2066e143cf5ac8d", + "stride": 1, + "tape_bound": 34357248, + "tape_moves": 79280, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1393, + "gauge": [ + "1", + "0" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 5, + "negative_error_squared_log2_upper": -1393, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 10, + "radix": 16, + "sha256": "dcec4ddc528be3a03e720ef53e00934b0acb0f7f8f58348124f6c4e3f4fabc66", + "stride": 2, + "tape_bound": 57262080, + "tape_moves": 242056, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1392, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 5, + "negative_error_squared_log2_upper": -1392, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 11, + "radix": 16, + "sha256": "941621e06be40597e4bd581a2f09ed25ca05634f46f1db352f7621fb95f000e3", + "stride": 2, + "tape_bound": 57262080, + "tape_moves": 242056, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1395, + "gauge": [ + "1", + "0" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 5, + "negative_error_squared_log2_upper": -1395, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 10, + "radix": 16, + "sha256": "e480a96d9072c698a66931125de33488aef70ada55233f36f6e15a658c1d4257", + "stride": -2, + "tape_bound": 57262080, + "tape_moves": 241640, + "working_bits": 704 + }, + { + "embedding": 1, + "error_squared_log2_upper": -1391, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 264, + "leaf_calls": 232, + "length": 5, + "negative_error_squared_log2_upper": -1391, + "nonzero_error": true, + "old_working_bits": 3429, + "peak_l1_log2_upper": 11, + "radix": 16, + "sha256": "7523dfddcd000810baa1b3a3b9b870db21e34cc6169408dea700ae83e6ae043e", + "stride": -2, + "tape_bound": 57262080, + "tape_moves": 241640, + "working_bits": 704 + } + ], + "leaves": { + "cases": 468, + "nonzero_errors": 468, + "sha256": "1df5d602fc90664f849b0318831eebfcc52428dee5f1f8e915105e47ee852b3c", + "target_dependence": true + }, + "source_pins": 31, + "status": "passed", + "uniform_kernels": [ + { + "coefficient_error_log2_upper": -219, + "embedding": 1, + "error_squared_log2_upper": -858, + "factor_bits": 218, + "gauge": [ + "1", + "0" + ], + "integer_bits": 288, + "leaf_calls": 4, + "length": 1, + "negative_error_squared_log2_upper": -858, + "nonzero_error": true, + "peak_l1_log2_upper": 2, + "radix": 3, + "sha256": "70eb76da98b2e190fdf1f0756e8caf5ec1e8cde82f69f25c6a287185422a6d09", + "stride": 0, + "tape_bound": 122880, + "tape_moves": 29, + "working_bits": 429 + }, + { + "coefficient_error_log2_upper": -219, + "embedding": 1, + "error_squared_log2_upper": -860, + "factor_bits": 218, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 288, + "leaf_calls": 4, + "length": 1, + "negative_error_squared_log2_upper": -860, + "nonzero_error": true, + "peak_l1_log2_upper": 3, + "radix": 3, + "sha256": "c3ebb4c679a6482183a04160588cdf3c397557ac1172a8d0b110e361de8f6156", + "stride": 0, + "tape_bound": 122880, + "tape_moves": 29, + "working_bits": 429 + }, + { + "coefficient_error_log2_upper": -219, + "embedding": 1, + "error_squared_log2_upper": -856, + "factor_bits": 218, + "gauge": [ + "1", + "0" + ], + "integer_bits": 288, + "leaf_calls": 4, + "length": 5, + "negative_error_squared_log2_upper": -856, + "nonzero_error": true, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "592662171a78d1c48b92646eccfc40b5169699630260c788117d89a369cd84d1", + "stride": 2, + "tape_bound": 614400, + "tape_moves": 4049, + "working_bits": 429 + }, + { + "coefficient_error_log2_upper": -219, + "embedding": 1, + "error_squared_log2_upper": -854, + "factor_bits": 218, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 288, + "leaf_calls": 4, + "length": 5, + "negative_error_squared_log2_upper": -854, + "nonzero_error": true, + "peak_l1_log2_upper": 5, + "radix": 3, + "sha256": "9b31ba083dcf6c2dc094f5a260993e1db8e769486f6ba75c04e7efb6d19cc131", + "stride": 2, + "tape_bound": 614400, + "tape_moves": 4049, + "working_bits": 429 + }, + { + "coefficient_error_log2_upper": -219, + "embedding": 1, + "error_squared_log2_upper": -855, + "factor_bits": 218, + "gauge": [ + "1", + "0" + ], + "integer_bits": 288, + "leaf_calls": 4, + "length": 12, + "negative_error_squared_log2_upper": -855, + "nonzero_error": true, + "peak_l1_log2_upper": 3, + "radix": 3, + "sha256": "4f67b7a7ea59abe14cea14990a55c7bb3630ea8b5346e9ef4c47c1b370431594", + "stride": 5, + "tape_bound": 1474560, + "tape_moves": 14552, + "working_bits": 429 + }, + { + "coefficient_error_log2_upper": -219, + "embedding": 1, + "error_squared_log2_upper": -854, + "factor_bits": 218, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 288, + "leaf_calls": 4, + "length": 12, + "negative_error_squared_log2_upper": -854, + "nonzero_error": true, + "peak_l1_log2_upper": 4, + "radix": 3, + "sha256": "e1199e6c6b6c90ed4804bc88d1bd9904fef5deacb51d81e82d8eab3daead12f6", + "stride": 5, + "tape_bound": 1474560, + "tape_moves": 14552, + "working_bits": 429 + }, + { + "coefficient_error_log2_upper": -268, + "embedding": 1, + "error_squared_log2_upper": -1178, + "factor_bits": 269, + "gauge": [ + "1", + "0" + ], + "integer_bits": 429, + "leaf_calls": 10, + "length": 1, + "negative_error_squared_log2_upper": -1178, + "nonzero_error": true, + "peak_l1_log2_upper": 3, + "radix": 4, + "sha256": "931203a70c402960603d2df57a7d0f47e4163f0504dab61b031a958db9ca8929", + "stride": 0, + "tape_bound": 360448, + "tape_moves": 104, + "working_bits": 588 + }, + { + "coefficient_error_log2_upper": -268, + "embedding": 1, + "error_squared_log2_upper": -1176, + "factor_bits": 269, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 429, + "leaf_calls": 10, + "length": 1, + "negative_error_squared_log2_upper": -1176, + "nonzero_error": true, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "98de62a21415fa584c410a364640afe652a8d2b4df75f368179ae03e6ba35ddb", + "stride": 0, + "tape_bound": 360448, + "tape_moves": 104, + "working_bits": 588 + }, + { + "coefficient_error_log2_upper": -268, + "embedding": 1, + "error_squared_log2_upper": -1170, + "factor_bits": 269, + "gauge": [ + "1", + "0" + ], + "integer_bits": 429, + "leaf_calls": 10, + "length": 5, + "negative_error_squared_log2_upper": -1170, + "nonzero_error": true, + "peak_l1_log2_upper": 6, + "radix": 4, + "sha256": "4aa64ddd7d76ba5e81264c9b94876be53ee076e5709177cfd2094ea042f04af7", + "stride": 2, + "tape_bound": 1802240, + "tape_moves": 10320, + "working_bits": 588 + }, + { + "coefficient_error_log2_upper": -268, + "embedding": 1, + "error_squared_log2_upper": -1172, + "factor_bits": 269, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 429, + "leaf_calls": 10, + "length": 5, + "negative_error_squared_log2_upper": -1172, + "nonzero_error": true, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "c9bb715b599a3d0a4ecc691ec6b5a50dd23c1b18551dd7ae4f05fd1500e98e52", + "stride": 2, + "tape_bound": 1802240, + "tape_moves": 10320, + "working_bits": 588 + }, + { + "coefficient_error_log2_upper": -268, + "embedding": 1, + "error_squared_log2_upper": -1171, + "factor_bits": 269, + "gauge": [ + "1", + "0" + ], + "integer_bits": 429, + "leaf_calls": 10, + "length": 12, + "negative_error_squared_log2_upper": -1171, + "nonzero_error": true, + "peak_l1_log2_upper": 4, + "radix": 4, + "sha256": "ea821703abdfd4fa41e197ff0f20c9b8998e23e376669d332c06da2a77413bd8", + "stride": 5, + "tape_bound": 4325376, + "tape_moves": 36868, + "working_bits": 588 + }, + { + "coefficient_error_log2_upper": -268, + "embedding": 1, + "error_squared_log2_upper": -1168, + "factor_bits": 269, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 429, + "leaf_calls": 10, + "length": 12, + "negative_error_squared_log2_upper": -1168, + "nonzero_error": true, + "peak_l1_log2_upper": 6, + "radix": 4, + "sha256": "f7d4afa6ebfe9d859ceccdb558835129a90c5487ce5b19ee77c32ca81fded80e", + "stride": 5, + "tape_bound": 4325376, + "tape_moves": 36868, + "working_bits": 588 + }, + { + "coefficient_error_log2_upper": -503, + "embedding": 1, + "error_squared_log2_upper": -2506, + "factor_bits": 504, + "gauge": [ + "1", + "0" + ], + "integer_bits": 1039, + "leaf_calls": 16, + "length": 1, + "negative_error_squared_log2_upper": -2506, + "nonzero_error": true, + "peak_l1_log2_upper": 3, + "radix": 5, + "sha256": "3664fbf3b752e8cbfd77fcbbaf90f9405ca28f063b33c841b0f667d3c15d6dc4", + "stride": 0, + "tape_bound": 557056, + "tape_moves": 128, + "working_bits": 1253 + }, + { + "coefficient_error_log2_upper": -503, + "embedding": 1, + "error_squared_log2_upper": -2509, + "factor_bits": 504, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 1039, + "leaf_calls": 16, + "length": 1, + "negative_error_squared_log2_upper": -2509, + "nonzero_error": true, + "peak_l1_log2_upper": 5, + "radix": 5, + "sha256": "86b7c96265bc5ec0b75e1e9ddedaa2f9c05a79e48870bf7154cdb61b837db72b", + "stride": 0, + "tape_bound": 557056, + "tape_moves": 128, + "working_bits": 1253 + }, + { + "coefficient_error_log2_upper": -503, + "embedding": 1, + "error_squared_log2_upper": -2495, + "factor_bits": 504, + "gauge": [ + "1", + "0" + ], + "integer_bits": 1039, + "leaf_calls": 16, + "length": 5, + "negative_error_squared_log2_upper": -2495, + "nonzero_error": true, + "peak_l1_log2_upper": 7, + "radix": 5, + "sha256": "9e24d9c2e16bb409b315fd69df05f414ff01e03ac0b8a50f1124b12c898e4364", + "stride": 2, + "tape_bound": 2785280, + "tape_moves": 16208, + "working_bits": 1253 + }, + { + "coefficient_error_log2_upper": -503, + "embedding": 1, + "error_squared_log2_upper": -2502, + "factor_bits": 504, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 1039, + "leaf_calls": 16, + "length": 5, + "negative_error_squared_log2_upper": -2502, + "nonzero_error": true, + "peak_l1_log2_upper": 5, + "radix": 5, + "sha256": "a1eea03d968ae166bbc176ad2d34e9527e85ce05b3bea38cd55ddd6457c83696", + "stride": 2, + "tape_bound": 2785280, + "tape_moves": 16208, + "working_bits": 1253 + }, + { + "coefficient_error_log2_upper": -503, + "embedding": 1, + "error_squared_log2_upper": -2500, + "factor_bits": 504, + "gauge": [ + "1", + "0" + ], + "integer_bits": 1039, + "leaf_calls": 16, + "length": 12, + "negative_error_squared_log2_upper": -2500, + "nonzero_error": true, + "peak_l1_log2_upper": 6, + "radix": 5, + "sha256": "12bc6b3a7702f7d9c370555bec890c032b3d5d7198e9bb73d02de5ce61192b07", + "stride": 5, + "tape_bound": 6684672, + "tape_moves": 58220, + "working_bits": 1253 + }, + { + "coefficient_error_log2_upper": -503, + "embedding": 1, + "error_squared_log2_upper": -2498, + "factor_bits": 504, + "gauge": [ + "3/5", + "4/5" + ], + "integer_bits": 1039, + "leaf_calls": 16, + "length": 12, + "negative_error_squared_log2_upper": -2498, + "nonzero_error": true, + "peak_l1_log2_upper": 6, + "radix": 5, + "sha256": "0781ea2e236b8a4b1cf63e98bb51085a6eca1654c5d35a0f378824c7bdb1d02c", + "stride": 5, + "tape_bound": 6684672, + "tape_moves": 58220, + "working_bits": 1253 + } + ], + "zero_subtrees": [ + { + "effective_depth": 5, + "length": 70, + "peak_l1": "27/8", + "remaining_depth": 5, + "root": [ + "1/2", + "0" + ], + "sign": -1, + "stride": 29 + }, + { + "effective_depth": 5, + "length": 70, + "peak_l1": "3457/1024", + "remaining_depth": 5, + "root": [ + "1/2", + "0" + ], + "sign": 1, + "stride": 29 + }, + { + "effective_depth": 5, + "length": 70, + "peak_l1": "27/8", + "remaining_depth": 5, + "root": [ + "3/10", + "2/5" + ], + "sign": -1, + "stride": 29 + }, + { + "effective_depth": 5, + "length": 70, + "peak_l1": "3457/1024", + "remaining_depth": 5, + "root": [ + "3/10", + "2/5" + ], + "sign": 1, + "stride": 29 + } + ] +} diff --git a/research/dirty-stride-precision/NOTICE.md b/research/dirty-stride-precision/NOTICE.md new file mode 100644 index 0000000000..10dd84845b --- /dev/null +++ b/research/dirty-stride-precision/NOTICE.md @@ -0,0 +1,46 @@ +# Source credit and scope + +Prepared for Ali Romman (@aliromman) with substantial OpenAI Codex +assistance. One assigned research agent prepared this package in the +eight-contribution sprint. The coordinator reviews it separately. No +independent human review or formal verification is claimed. + +The new work proves the effective-depth and zero-subtree transfer for +PR985's actual constant-coefficient dirty word. It also transfers the +common-operator prefix estimate to that target-dependent rounded word, +with explicit inverse-preimage magnitude guards, exact budgets, and +supporting checks. The code changes precision admission in the leaf and +caches two validation reads. The simultaneous phase lane found the +duplicate-read accounting mismatch with an independent array observer. +That finding is credited here; the rounded data word does not change. +The source and test files are under the repository's Apache-2.0 license. + +Credit the following predecessor contributions: + +- Ali Romman, PR985, for source-prefix closure reuse, reversible block + transport on two tapes, the target-dependent rounded leaf, and its + local accuracy and complete cost proof. Its complete package is + retained unchanged in `vendor/pr985/`. +- Chafik Boukhalfa (@chafreaky), PR905, for the free-algebra prefix lemma + and its use with the common-operator subset bound in a dirty word. +- Chafik Boukhalfa, PR862, for the complementary-factor/common-isometry + estimate and cubic analytic preparation budgets. +- Chafik Boukhalfa, PR977, for effective-depth analysis of PR846's + clean-scratch solver. Its source is retained for comparison. Its + clean-scratch identity is not used as a dirty-word theorem. +- Rohan Guliani, PR846, for the Euclidean chain and closure decomposition. +- Chafik Boukhalfa, PR628, for certified kernel factors and the balanced + dirty commutator. Gareth Davidson (@bitplane), PR877, for the nonlinear + prefix perturbation method. 0xkilgore, PR663, for the exact leaf count + and restoration audit. Charles Bethin, PR764, for the shared-suffix + estimate. Ali Romman, PR621, for the retained kernel proof lineage. + +All retained notices remain in place. `SOURCES.json` gives the exact +heads, source paths, Git blobs, and SHA256 values. The proof identifies +which claims are inherited and which implications this package adds. +No priority claim is made for the classical Mahler-measure, Neumann, +variation-of-constants, or approximate-factorization methods. + +The result does not change the selected bound. It does not implement +variable site phases, a new transport scheme, a Lean proof, a fast +arithmetic compiler, a complete transform, or a multiplication reduction. diff --git a/research/dirty-stride-precision/OVERLAP.md b/research/dirty-stride-precision/OVERLAP.md new file mode 100644 index 0000000000..97e040a1a0 --- /dev/null +++ b/research/dirty-stride-precision/OVERLAP.md @@ -0,0 +1,43 @@ +# Concurrent analytic improvement + +The final overlap check read PR1025 at commit +`6ef2168ac90d42926bceb7ac9b2e029463800c76` on 2026-10-13. +Chafik Boukhalfa's [pinned proof](https://github.com/CrocSwap/integer-mult-bounds/blob/6ef2168ac90d42926bceb7ac9b2e029463800c76/research/averaged-cyclotomic-height/PROOF.md) +uses averaged cyclotomic coefficient heights to replace the inherited +circle exponent by + + d = 1 + 2ell + (r-1) phi(r) min(r,8ell^2). + +Its precision corollary applies this bound to the retained PR862 and +PR977 clean-scratch estimates. It retains that solver's 40L record +interface. It does not supply a dirty-array circuit or a new inverse +execution. These are statements of that contribution's scope, not an +independent verification of its analytic theorem. + +This package instead proves the effective-depth identity, nonlinear +error transfer, and inverse-preimage integer guard for the actual +PR985 target-dependent dirty word. It retains all structural recursion +and two-tape costs. Its explicit cubic budgets use the older pinned +analytic input. They remain sufficient; they are not a claim of the +best available analytic exponent or a minimum working width. + +The theorem in Sections 4 and 5 of `PROOF.md` takes the margin and +common-operator subset bound as inputs. A later contribution can check +PR1025's analytic proof, substitute its exponents into this dirty +contract, derive new explicit integer and fractional inequalities, +and execute representative prepared kernels at those widths. This +package does not claim that combined result. No new dependency or +changed budget was added after the source freeze. + +## PR985 accounting successor + +PR985 advanced to `da1cdf8ed4ac9b1b8378dfec73f77ff4e81a4f70` during +verification. The coordinator reports that this successor applies the same +two read-once validation corrections and retains the mathematical receipt. +Its public head was checked on 2026-10-13 at 17:11 UTC. + +This package intentionally retains the exact consumed predecessor, +`9df42a99dd8497b6e7d46cd2507bb89071372640`, in `vendor/pr985/`. The +derived solver contains the two read-once corrections and its separate +effective-depth admission. The independent array observer rejects the old +double-read behavior. No moving dependency was imported after verification. diff --git a/research/dirty-stride-precision/PROOF.md b/research/dirty-stride-precision/PROOF.md new file mode 100644 index 0000000000..89cde92419 --- /dev/null +++ b/research/dirty-stride-precision/PROOF.md @@ -0,0 +1,338 @@ +# Cubic precision for the constant-coefficient dirty stride word + +## Result and fixed interface + +This result applies to PR985 at +`9df42a99dd8497b6e7d46cd2507bb89071372640`. The unchanged source is in +`vendor/pr985/`. The new `dirty_stride.py` changes the precision admission, +adds its effective-depth formula, and caches two validation reads. It retains every rounded +operation, recursive child, block swap, coefficient computation, and head +return. In particular, it does not add an early exit or a clean data array. + +The two validation loops now read each datum once, check that cached value, +and discard it. PR985's Python expression read the same entry twice while +charging one access. The simultaneous phase lane found that mismatch with +an independent array observer. The derived source corrects it without a +new data operation or a changed validation result. An observer separate +from the meter checks every literal indexed read and write in the new +leaf and kernel executions. The original source remains unchanged. + +Let `u=2^-W`, `0=4g+16` implies (1) at every length and stride. The +unscaled leaf error remains `64 (X+1) u / beta^5` for source norm at most +`X`. For a multiplier with modulus at most `R>=1`, it is at most + + [64 R (X+1)/beta^5 + 3] u. (2) + +For the inherited certified prime-power kernels, the complete balanced +dirty word has sufficient fractional precision + + W <= max(p,w_input) + m + 18r^3, + +where every initial array has norm at most `2^m`. A sufficient signed +integer reserve per component is at most `m+15r^3`. The bound applies to +both signs of the word. Exact source and scratch restoration, two data +tapes, the logarithmic borrowed-array count, and the full PR985 movement +bill remain. No new multiplication exponent follows. + +## 1. Extinction for the coefficients that PR985 computes + +At a normalized non-base level, `0M`, that level cannot +occur. Reversal changes orientation but does not change these counts. + +PR985 computes each coefficient afresh as `power(b,e,W)`. It does not +multiply a stored array of child coefficients. Its binary powering +truncates both components toward zero after each product. Truncation +cannot increase complex modulus. Induction over the multiplication tree +therefore gives + + |power(b,e,W)| <= |b|^e. + +For `e>=2`, the returned number is on the grid of spacing `u`; the final +operation includes truncation. At level `k>=D_eff`, + + beta e >= 2^-g 2^k >= W+1, + |b|^e <= (1-beta)^e <= exp(-beta e) + <= exp(-(W+1)) < 2^-W. + +The last inequality is strict, also when `W=0`. Since `g>=1`, these +levels have `e>=2`. Each component of the returned grid number thus has +absolute value below one grid unit and must be zero. This proof uses +complex modulus and the actual truncation rule. It does not assume a +positive real coefficient, a dyadic root descriptor, or monotonicity of +individual rounded powers. Every descendant meets the same bound. The +terminal cycle exponent is also at most `M` and meets the lower bound. + +## 2. The full dirty zero subtree + +Consider a subtree in which the two prepared coefficients at every level, +including every diagonal coefficient, are zero. A causal map with zero +coefficient is the identity on both arrays. Its physical implementation +still makes all the prescribed swaps, but only permutes values temporarily. +An expansion is a causal inverse, a zero injection, and a causal map. +It is the identity, including when its target contains arbitrary data. + +At a non-base node, the closure calls are consequently adjacent inverse +maps after the identity expansions are removed. The first call adds its +result to the source prefix; the inverse sees the exact state that the +first call left. Both calls restore their tail input. The pair cancels +exactly. The baseline addition is the only remaining operation. At a +diagonal node, division by one and grid rounding leave the source value +unchanged. Thus, with the internal multiplier one, the whole subtree is +exactly `y += sign*x`. Both signs satisfy the identity. This is an +induction on the actual dirty word, not a use of PR977's clean-scratch +identity and not an assumption of target-independent rounding elsewhere. + +The identity also has an internal magnitude bound. Let the incoming source +and target norms be at most `S` and `T`. Each recursive source is an +unchanged tail of its caller's source. Its target is a disjoint prefix of +that source. No recursive source includes an already changed connector. +Each temporary connector therefore contains at most the sum of two +source values, with norm at most `2S`. The outer target has norm at most +`T+S`. The inverse sign has the same bound. All other data movement is +swaps. The peak in the entire zero subtree is at most + + max(T+S, 2S), + +independently of its structural depth. Endpoint equality alone would not +have proved this internal bound. + +For the accuracy proof only, replace each subtree at depth `D_eff` by +its exact addition. This preserves the complete rounded output. There +are now at most `min(K,D_eff)` active non-base levels. PR985's power +error, shared-suffix, coefficient mismatch, and weighted source estimates +apply to those levels without any change. The new terminal has zero +error, which satisfies the former terminal allowance `u`. Beyond the +cutoff, the actual source causal maps are identities; their weighted +source bound does not accumulate more error. The preceding magnitude +lemma also controls all data in the untruncated zero tail. This proves +(1), (2), and the use of PR985's internal forward-leaf bound below. + +No runtime subtree is removed. The structural depth, recursive call +count, two-tape movement, metadata stack, and coefficient preparation +still have their original costs. + +## 3. A length-independent sufficient threshold + +For fixed `g`, `(D_eff+1)2^-W` decreases as integer `W` increases: the +ceiling logarithm increases by at most one at a step, while the power of +two doubles. It is enough to check `W0=4g+16`. For `g>=1`, + + 4g+17 <= 2^(g+5), + D_eff(W0)+1 <= 2g+6 <= 8*2^(g-1), + 48(D_eff(W0)+1) <= 192*2^g <= 2^(g+16). + +As `beta>=2^-g`, this proves `48(D_eff+1)2^-W<=beta^3`. The first two +elementary inequalities hold at `g=1` and persist after incrementing +`g`: each right side doubles and each left side grows by at most four. + +The executable admission uses (1), which can be weaker than this simple +threshold. For example, `beta=1/2`, `W=12`, `L=5741`, `w=2378` has +`K=10` and `D_eff=5`. The original admission fails and (1) holds. The +checker executes the full rounded word on this case, checks its residual +and exact inverse, and charges every data movement. A residual check is +numerical evidence for this one input; the preceding proof covers all +lengths. + +## 4. Transfer to the actual target-dependent kernel leaves + +Let `U=tau Z_L^w`, with one immutable unit scalar `tau` shared by all +factors. Let `Q(z)=r^-1 product_j(z-rho_j)`, of degree `n=r-1`. +The outer leaf has coefficient `tau/rho_j` and multiplier `-1/rho_j`. +The inner leaf has coefficient `rho_j conjugate(tau)`, stride `-w`, +multiplier `conjugate(tau)`, and output shift `-w`. Both ideal maps are +`(U-rho_j I)^-1`. Exactly one factor also has scale `r`. These are the +maps in PR985's unchanged dispatcher, and all use the same `U`. + +Let `||Q||_1<=M_Q` and `||Q(U)^-1||<=H_Q`. PR862's complementary-factor +argument gives a norm bound for every subset of the scaled factors: + + G = max(1, r 2^n M_Q H_Q). (3) + +Indeed `product max(1,|rho_j|)<=||rQ||_1<=r M_Q` by the elementary +Mahler-measure inequality. A complementary polynomial has coefficient +norm at most `2^n r M_Q`. Multiplication by `Q(U)^-1/r` bounds the +unscaled subset inverse, and the one factor `r` is then paid. The same +unit isometry must occur in all factors; this is not a bound for +arbitrary unrelated operators. + +Use PR905's free-algebra prefix lemma for the balanced four-call word. +With `h=ceil(log2 n)`, every ideal prefix and inverse prefix has +coefficient row sum at most `C=2*3^h`, and each monomial uses a strictly +decreasing subset of factor occurrences. Its proof includes both signs +of every child word. It depends on the ideal shear word, not on the +implementation of a rounded leaf. PR985's ideal dispatcher is exactly +that word. Equation (3) therefore gives + + B = C G + +for every ideal prefix and inverse prefix, and `B^2` for every interval +propagator. The retained PR905 proof gives the universal induction. The +new contribution here is the transfer to the PR985 leaf contract and its +physical word, not a new prefix lemma. + +For a positive PR985 leaf, (2) implies error at most + + a u (||source||+1), a=68(r+1) beta^-5. (4) + +For a negative leaf, write its input target as `y` and its output as +`z`. Exact inversion of the positive word gives + + y = z + A x + delta(x,z), + z = y - A x - delta(x,z). + +The source is unchanged. The positive bound (4) holds for every target +`z`, without a target magnitude hypothesis. Thus the negative leaf has +the same error bound with the same source norm. No bound on the unknown +preimage target is used for this accuracy step. Its magnitude is paid +separately in Section 5. + +Let all initial arrays have norm at most `D0`. The exact leaf count is +`N=3qn-2q^2<=2n^2`, with `q=2^floor(log2 n)`. Let `T` be the largest +actual joint norm at complete leaf boundaries. Every computed prefix is +finite because all closure denominators have modulus at least `beta`. +Insert the actual nonlinear errors into the ideal word by variation of +constants. For either sign, the prefix bounds and (4) give + + T <= B D0 + t(T+1), t=N B^2 a u. + +If `t<=1/2`, then `T<=2 B D0+1`, and the final execution error is at most + + 2 N B^2 a u (B D0+1). (5) + +This argument uses neither linearity nor target independence of a rounded +call. Each closure and each whole-word inverse is still the exact inverse +grid word. Distinct ancestor operands and the original scratch-depth +condition remain required by the implementation. + +## 5. Integer guards, including inverse preimages + +At a leaf boundary put `D*=2 B D0+1`. PR985's forward-leaf bound is + + 512 (r+1)(D*+1)/beta^7. + +Section 2 justifies the same bound in the full zero tails. To apply it +inside an inverse leaf, first bound that leaf's positive preimage. Its +source has norm at most `D*`, and its ideal operator has norm at most +`r/beta`. Since `a u<=1` follows from `t<=1/2`, the preimage target has +norm at most + + D_pre <= (2+r/beta)D*+1. + +The inverse traverses the positive word at this preimage in reverse. +Use `D_pre+1<=(r+2)(D*+1)/beta` in the forward bound. A bound for every +data value, in either sign of every leaf, is consequently + + V = 1024 (r+1)(r+2)(B D0+1)/beta^8. (6) + +Two extra bits above `ceil(log2 V)` suffice for a signed component +reserve. This extra preimage factor is necessary in this proof; the +incoming negative target was not assumed to obey the forward preimage +bound. Block transport only moves these values and adds no new magnitude. + +## 6. Explicit prime-power budgets + +Retain the PR621/628/862 analytic and supplied factor-preparation +hypotheses. Let `r>=3` be a prime power, `n=r-1`, `ell=ceil(log2 r)`, +`h=ceil(log2 n)`, `phi=EulerPhi(r)`, and `D0<=2^m`, `m>=0`. Define + + d0 = 1+2ell+r n phi, + a0 = 2d0+r+2, + g = d0+ell+2r+2, beta=2^-g, + e = max(d0+1,a0+1,p+2a0+m+4), + b_factor = max(n ell,e+r+3). + +The original inverse has norm at most `2^a0`. The supplied dyadic-root +polynomial `Q` has coefficient error at most `2^-e`, norm at most `2^r`, +and stable factor margin `beta`. The common-isometry Neumann argument +gives `||Q(U)^-1||<=2^(a0+1)`. On a source of norm at most `2^m`, the +original-versus-prepared inverse error is at most `2^(-p-3)`. These are +inherited hypotheses and algorithms; this package does not implement +an all-size root factorizer. + +Equations (3)--(6) are paid by the integer exponents + + J = a0+2r+ell+1+2h, + A = 5g+ceil(log2(68(r+1))), + W = max(w_input,4g+16,p+3+ceil(log2 N)+A+m+3J), + I = J+m+8g+2ell+16. + +Here `B<=2^J`, `a<=2^A`, and `B D0+1<=2^(J+m+1)`. Thus (5) is at +most `2^(-p-1)`, with `t<=1/2`. Admission follows from Section 3. The +bound (6), plus a sign reserve, is below `2^I`. No incoming grid is +coarsened. Preparation plus execution error is below `2^-p`. + +For completeness, use `phi,ell,h<=r`, +`ceil(log2 N)<=1+2h`, and `ceil(log2(68(r+1)))<=ell+8`. The fractional +overhead is at most + + 11r^3-11r^2+58r+42 <= 18r^3. + +The difference is `(r-3)(7r^2+32r+38)+72`. The term `4g+16` is smaller +than this same majorant. Likewise + + I-m <= 10r^3-10r^2+52r+45 <= 15r^3, + +with difference `(r-3)(5r^2+25r+23)+24`. The inherited factor width obeys +`b_factor<=p+m+7r^3`. These polynomial identities prove the all-size +bounds; the finite budget rows check their implementation. + +At `r=64`, `p=128`, `m=20`, and `w_input=0`, the fractional budget is +`1,420,902` bits. PR985's full-word bound with the same margin and initial +norm needs `517,236,859` bits before any larger structural-depth admission. +Both words have `4,000` leaf calls and six borrowed arrays. These are +sufficient bounds, not optimal widths or measured execution times. + +## 7. Complete cost and scope + +Every leaf still uses two data arrays, a constant number of clean complex +arithmetic registers, and `O(log^2 L)` integer metadata bits. PR985 proves +at most `1280L` scalar products and divisions and `4096L` record moves +per leaf, including the complete structural recursion and returns. The +kernel retains `h` arbitrary dirty arrays and routes all of them over +two physical tapes. Its unchanged bound is + + 8192 (N+1)(h+2)L + +data-record moves. The effective depth is only for error analysis. It +must not replace structural depth in these resource counts. + +Let `A_word=W+I` and let `B_desc` include the actual immutable root, +margin, multiplier, and unit-gauge descriptor lengths. Let `M(s)` pay +for rounded multiplication and division of words of width `s`. The bill +remains + + preparation + O(N L M(A_word+B_desc)) + + O(N(h+2)L(A_word+B_desc)) + O(NL). + +The last term pays the inherited integer-control bound. Reading a stride +descriptor longer than `O(log L)` is additional input work. The supplied +preparation bill is `soft-O(r^3(p+m+r^3))` under the retained algorithms. +An arbitrarily long exact gauge description remains an extra charge. +There is no new coefficient array, tape, or borrowed data allocation. + +This is a written accuracy proof with exact-rational supporting checks. +It is not a Lean proof, a fast arithmetic compiler, a measured runtime +gain, a variable-site-phase construction, a complete transform, or a +multiplication reduction. The selected certificate and `upstream/` do +not change. Source credit and substantial AI assistance are in `NOTICE.md`. diff --git a/research/dirty-stride-precision/README.md b/research/dirty-stride-precision/README.md new file mode 100644 index 0000000000..4dec7d4bbe --- /dev/null +++ b/research/dirty-stride-precision/README.md @@ -0,0 +1,72 @@ +# Constant-coefficient dirty stride precision + +This package removes the length-dependent precision admission from +PR985's dirty arbitrary-stride solver and replaces its conservative +kernel precision by a cubic sufficient bound. The rounded word and all +two-tape movement remain unchanged. No new kappa is claimed. + +For a certified prime-power kernel of radix `r`, initial array norm at +most `2^m`, target error `2^-p`, and incoming grid precision `w_input`, +the sufficient fractional precision is + + W <= max(p,w_input) + m + 18r^3. + +A signed integer reserve of at most `m+15r^3` bits per component covers +both forward and inverse intermediate values. Immutable coefficient and +gauge descriptor lengths are additional word-size inputs. The kernel +keeps `ceil(log2(r-1))` arbitrary dirty arrays. Every source and borrowed +array restores exactly. Negative calls execute the full inverse word. + +At radix 64, target 128 bits, and magnitude bound `2^20`, the explicit +fractional budget is `1,420,902` bits. PR985's full-word bound with the +same margin needs `517,236,859` bits before a larger depth admission. +Both have `4,000` leaf calls and six borrowed arrays. These are sufficient +precision bounds, not runtime measurements or minimum widths. + +## Reproduce + +Use standard-library Python 3.11 or later: + +```sh +python3 -I -O -B research/dirty-stride-precision/verify.py +python3 -I -O -B research/dirty-stride-precision/test_package.py +``` + +The main check covers exact exponent budgets, coefficient extinction, +return-time bounds, the dirty zero-subtree identity and its internal +magnitudes, signed leaf errors, and actual kernel executions with odd +lowest working bits. The kernel checks use a dense polynomial oracle, +exact prepared-coefficient bounds, complete tape counters, integer +guards, and both orders of inverse cancellation. `EXPECTED.json` is +the exact mathematical receipt. `VALIDATION.json` records the local +checks and omitted checks; hosted CI is separate. + +The `L=5741`, `w=2378`, `beta=1/2`, `W=12` case executes the full word +beyond the old admission. Its structural depth is 10 and its effective +error depth is 5. No runtime recursion is skipped. + +## Files and mathematical boundary + +- `PROOF.md` gives the all-length proof, the common-operator transfer, + inverse-preimage guards, explicit cubic inequalities, and complete cost. +- `dirty_stride.py` derives from PR985. It changes admission and caches + the two validation reads so each literal access has its meter charge. +- `budget.py` supplies exact finite and uniform precision budgets. +- `verify.py` checks the mathematical and execution contracts. +- `vendor/pr985/` retains the original complete package unchanged. + The other vendor folders retain the relevant credited proofs. +- `SOURCES.json` pins every retained dependency. `NOTICE.md` gives credit + and discloses substantial OpenAI Codex assistance. + +The actual increment can depend on its target and scratch data. The proof +bounds each negative leaf at its positive preimage and does not assume +target-independent rounded increments. It proves the zero-subtree +identity for the dirty word itself; PR977's clean-scratch theorem is not +imported by assertion. + +The supplied prime-power preparation, analytic inverse, and fast scalar +arithmetic hypotheses remain. The rational reference does not implement +an all-size factorizer or a fast bit compiler. Variable site phases, +common-label/Clifford realization, full transform composition, physical +supplier hosting, and the multiplication reduction remain open. The +selected certificate and `upstream/` are unchanged. diff --git a/research/dirty-stride-precision/SOURCES.json b/research/dirty-stride-precision/SOURCES.json new file mode 100644 index 0000000000..e0d34f9564 --- /dev/null +++ b/research/dirty-stride-precision/SOURCES.json @@ -0,0 +1,253 @@ +{ + "base": "8bddbee377e2f3ce1f1247196c4b290d55767d20", + "sources": [ + { + "pr": 862, + "head": "57e0659150d323b784580110b36aa64a2dca2a33", + "path": "research/cubic-cyclic-inverse/NOTICE.md", + "local": "vendor/pr862/NOTICE.md", + "sha256": "08c25cd6248e8c4dc7008e14e9ea7690f9084e94f927bb602363773637a89921", + "blob": "737060bd4d9666a925dfd1e17fc6eaa53c289b8d" + }, + { + "pr": 862, + "head": "57e0659150d323b784580110b36aa64a2dca2a33", + "path": "research/cubic-cyclic-inverse/PROOF.md", + "local": "vendor/pr862/PROOF.md", + "sha256": "bdb0518892c631f8b6ac149535ac5a92270def19fe7778ca737641cd56b7da0b", + "blob": "0196499f010857b58ea297611f44721a4b7a0ec6" + }, + { + "pr": 905, + "head": "aab6c0b8f4574cb36285ab5dab3fcfad0cd2b69e", + "path": "research/dirty-cubic-precision/NOTICE.md", + "local": "vendor/pr905/NOTICE.md", + "sha256": "062efe3baa26ba98bb879c7d954cc557aedfd1b7fce6209e6bf8e6677e7257c5", + "blob": "03c791502edad7286faed9d5bacb7c21587caffe" + }, + { + "pr": 905, + "head": "aab6c0b8f4574cb36285ab5dab3fcfad0cd2b69e", + "path": "research/dirty-cubic-precision/PROOF.md", + "local": "vendor/pr905/PROOF.md", + "sha256": "fc6b863d940a6b7341e65f0627d88e409d11222f871b422dd784198db9ebf381", + "blob": "c3bd9e0a3dbede80984fd78fda98e4c67bbdf651" + }, + { + "pr": 977, + "head": "2846af720af190cb75b45ebddbb0357dec1121ec", + "path": "research/cyclic-stride-effective-depth/NOTICE.md", + "local": "vendor/pr977/NOTICE.md", + "sha256": "b6e1bab630faf7eb4ad0952173dd789a7f5d6333bf938b275bcf087474f4f189", + "blob": "57939c758daebf9b7c952ce849ccb169d10c35c6" + }, + { + "pr": 977, + "head": "2846af720af190cb75b45ebddbb0357dec1121ec", + "path": "research/cyclic-stride-effective-depth/PROOF.md", + "local": "vendor/pr977/PROOF.md", + "sha256": "30c296d4f1947cbcaaeb0fe575c36e3c2308f1583dde6029efb4a162fb7a4b27", + "blob": "6019f4d03f2a429c07aae18deba0525d9af36d71" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/CLAIM.json", + "local": "vendor/pr985/CLAIM.json", + "sha256": "04a779b6490a00fb393a3c0cb48deb095a8a741313d968105e9c01eeb2d2e026", + "blob": "aa3c3fdbfa886de78673bf3eed3ba761da49b4c9" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/EXPECTED.json", + "local": "vendor/pr985/EXPECTED.json", + "sha256": "4545a0f63837efa8be0715be509fb0a2ac6a8c4835a118b871653235b9c907d2", + "blob": "c429da6f81ea13c4bd952adb736f9713d5b675f8" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/LICENSE", + "local": "vendor/pr985/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/NOTICE.md", + "local": "vendor/pr985/NOTICE.md", + "sha256": "759fd9ada0c70e657a0b903089b32c84239b05b1f214cb01e81e9ca61b0d87f4", + "blob": "a96d0c7fea342d1e6990b4d16d731038ba983511" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/PROOF.md", + "local": "vendor/pr985/PROOF.md", + "sha256": "af6560b048b20649aebd31d68815948a104d2c87efcdf556c85a10f48bbc0489", + "blob": "01a3da73470dc773a33948ee5f8cfc8848798411" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/README.md", + "local": "vendor/pr985/README.md", + "sha256": "96527e5f166ab8223e5c652975f32b4ba1b6b1d7fd41667a46bf515571fdaf13", + "blob": "451ac2bac0cc263d03f3a489fc5dabd653e9a4c5" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/SOURCE.json", + "local": "vendor/pr985/SOURCE.json", + "sha256": "a0ce06a3d3fd083145b099b378afac9a33fbc499837c25250befb9236a2a9ec6", + "blob": "ab6dd87dca22b4810a562be0ca98d79e353a284b" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/VALIDATION.json", + "local": "vendor/pr985/VALIDATION.json", + "sha256": "a3cb5788a6494d916896bfd772964a88ed769d47caa2991e0b0fb3fde05dea2b", + "blob": "5a4ba499fbe9d95fca458132d99987a3da7fc4dd" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/dirty_stride.py", + "local": "vendor/pr985/dirty_stride.py", + "sha256": "129b2bc8cf89159aae0a810fad4703caefefccf1c5f4805dd3c9b5e8d967354b", + "blob": "f469930b8b7d79cbc05a884dc2e224e32db7fc4a" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/test_package.py", + "local": "vendor/pr985/test_package.py", + "sha256": "d767e8c37bc8300f417f84c9d5602f0af4bb63f8794bb044479547fc2d92b57c", + "blob": "20e58c1ce5bddc37dddcdec12db99babdfa79004" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/DIRTY-PROOF.md", + "local": "vendor/pr985/vendor/pr628/DIRTY-PROOF.md", + "sha256": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61", + "blob": "caf4aafc784a630d61ca7874a0bd19cbcb34e585" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/FACTORS.json", + "local": "vendor/pr985/vendor/pr628/FACTORS.json", + "sha256": "643d60ac24d5e67f6c9305175bd1c99bf5e42edfef6d1995c051e0b98ba446a7", + "blob": "d3894bd2a1660229f1a7ed16c9d982689effc96f" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/NOTICE.md", + "local": "vendor/pr985/vendor/pr628/NOTICE.md", + "sha256": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68", + "blob": "22fbeb8ef0a28dd6b3feea718492091319ceb96e" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/README.md", + "local": "vendor/pr985/vendor/pr628/README.md", + "sha256": "3ffc38b79ef21f506f35b8e4613510a9a5ceacefddf4a56515fbc6ec6138584d", + "blob": "89182e5b96f603b4d826b729270bffeec2bd9316" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/SOURCE.json", + "local": "vendor/pr985/vendor/pr628/SOURCE.json", + "sha256": "38a425e2d3a72a5e39b18b54c728e40407e121d481a1c6423edd5c18e9b68a04", + "blob": "59bddaea4d66725bf675a67b6d2cf85a061b1fae" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/check.py", + "local": "vendor/pr985/vendor/pr628/check.py", + "sha256": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d", + "blob": "5ef6dd67b6c6cf949fedf16c0cd7b34ca4ccafc2" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/dirty.py", + "local": "vendor/pr985/vendor/pr628/dirty.py", + "sha256": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21", + "blob": "2b9471083706a37519a1af7598e012f5fecf2636" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/interval_kernel.py", + "local": "vendor/pr985/vendor/pr628/interval_kernel.py", + "sha256": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe", + "blob": "1182175a55cb871481de0f56ea9ae56e474705fe" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr628/scan.py", + "local": "vendor/pr985/vendor/pr628/scan.py", + "sha256": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e", + "blob": "d620e493596f12578c1ce47f216c44c79b65de08" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr846/NOTICE.md", + "local": "vendor/pr985/vendor/pr846/NOTICE.md", + "sha256": "9403006a0d8193298ac9c5dd4036619190aea29bfe37b03d2d716d8be264fc75", + "blob": "4dcef892b50028a3c9bce2d84954bca2fce44879" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr846/PROOF.md", + "local": "vendor/pr985/vendor/pr846/PROOF.md", + "sha256": "3937696d2156e000519fb185a8a55fa7fd55dc12266fe0fe806dba42b2acf4e1", + "blob": "8987bfdfc4ba6635cc3e0e984ca24d91da429084" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr846/README.md", + "local": "vendor/pr985/vendor/pr846/README.md", + "sha256": "0ecef1ba0da4f7d033db59084944baa9cf79140cd04f91d39db9e899c8ee03cc", + "blob": "f33410800c79792670d909077bcf856a2fa135be" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr846/SOURCE.json", + "local": "vendor/pr985/vendor/pr846/SOURCE.json", + "sha256": "07bc9fe307f254b68810f664bcef0f30eabd130226d39804bb38517777e3a92b", + "blob": "e1624e72ddffcd9fc2271691f79edcedeffc3c91" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/vendor/pr846/stride.py", + "local": "vendor/pr985/vendor/pr846/stride.py", + "sha256": "da56e45f414a633453e06e8d058bcec6c815c73950816fcf049d92c570f8928e", + "blob": "9229a4193b004d0dd939a502cfae75c27791dc76" + }, + { + "pr": 985, + "head": "9df42a99dd8497b6e7d46cd2507bb89071372640", + "path": "research/dirty-stride-source-reuse/verify.py", + "local": "vendor/pr985/verify.py", + "sha256": "676f9476ae71c370365a42d8d84cc36cbac419ef29d878bc60f53f74363b7fe7", + "blob": "56648ad5702a20c649ab9acb61aa0b580dcc2af0" + } + ] +} diff --git a/research/dirty-stride-precision/VALIDATION.json b/research/dirty-stride-precision/VALIDATION.json new file mode 100644 index 0000000000..4dff1a5c34 --- /dev/null +++ b/research/dirty-stride-precision/VALIDATION.json @@ -0,0 +1,171 @@ +{ + "base_commit": "8bddbee377e2f3ce1f1247196c4b290d55767d20", + "checks_not_run": [ + { + "check": "make verify", + "reason": "This isolated package changes no selected construction, generator, or global artifact. The relevant standalone and selected-record checks passed." + }, + { + "check": "make frontier741-verify", + "reason": "The selected construction is unchanged. No new selected frontier is claimed." + }, + { + "check": "Hosted Linux/Python 3.11 and 3.14 workflow", + "reason": "The scoped workflow is supplied. It has not run in this local candidate." + }, + { + "check": "Lean or full multiplication theorem verification", + "reason": "This contribution is a written conditional accuracy proof with finite exact checks." + } + ], + "earlier_wrapper_failure": { + "command": "/usr/bin/time -l python3 -I -O -B research/dirty-stride-precision/test_package.py", + "exact_receipt_regenerated": true, + "package_reported_pass": true, + "reason": "The package finished. The macOS timing wrapper then failed because the sandbox denied sysctl kern.clockrate. The unchanged package was repeated with Python timing and returned zero.", + "returncode": 1, + "source_freeze_unchanged": true, + "wall_seconds": 624.9138164157048 + }, + "fragile_workarounds": false, + "metadata_added_after_frozen_replay": [ + "research/dirty-stride-precision/CLAIM.json", + "research/dirty-stride-precision/OVERLAP.md", + "research/dirty-stride-precision/VALIDATION.json", + "research/dirty-stride-precision/VALIDATION.log.txt" + ], + "package_replay": { + "command": "python3 -I -O -B research/dirty-stride-precision/test_package.py", + "log_sha256": "ad204b0012f140332119335526e13318b69184a35c8bd97b5b6e63bef38ca632", + "peak_child_rss_bytes": 41304064, + "platform": "macOS-26.6.1-arm64-arm-64bit-Mach-O", + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "receipt_sha256": "49737d3948b88d852f498f762913e5b6a8da2da6e99ff8f5737b16f18381fc5d", + "returncode": 0, + "source_freeze_unchanged": true, + "started_utc": "2026-10-13T16:55:51.382601+00:00", + "thread_limits": { + "MKL_NUM_THREADS": "1", + "OMP_NUM_THREADS": "1", + "OPENBLAS_NUM_THREADS": "1" + }, + "wall_seconds": 740.8109312499873 + }, + "receipt_summary": { + "admission_thresholds": 1088, + "budget_cases": 5220, + "certified_kernel_cases": 80, + "coefficient_extinction_cases": 180, + "complete_kernel_leaf_executions": 24848, + "complete_kernel_word_executions": 392, + "core_rejection_controls": 9, + "deep_new_admission": { + "bits": 12, + "effective_depth": 5, + "length": 5741, + "old_admitted": false, + "residual_squared": "17/67108864", + "stride": 2378, + "structural_depth": 10, + "tape_moves": 3952237 + }, + "dirty_zero_subtrees": 4, + "exact_receipt_regeneration": true, + "exponent_geometries": 8256, + "package_fault_controls": 12, + "read_only_relocation": true, + "retained_power_cases": 2322, + "signed_leaf_cases": 468, + "source_pins": 31, + "uniform_preparation_kernel_cases": 18 + }, + "recorded_utc": "2026-10-13T17:11:02.597301+00:00", + "repository_checks": { + "checked_utc": "2026-10-13T17:09:16.043953+00:00", + "checks": [ + { + "args": [ + "make", + "selected-record-check" + ], + "log_sha256": "c7c0f3574cb3964657db98f1c2596b2330f2d3e98890f9cf4750bd4e3016a93c", + "name": "selected-record", + "returncode": 0, + "wall_seconds": 0.3712814589962363 + }, + { + "args": [ + "python3", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_selected*.py" + ], + "log_sha256": "af6bd68a46702580b3c47408d9ef148739e56ca37c676fb59b650262f6292b79", + "name": "selected-tests", + "returncode": 0, + "wall_seconds": 0.6136498753912747 + } + ] + }, + "resource_limits": { + "experiment_cpus": 1, + "memory_cap_bytes": 2147483648, + "minimum_free_disk_bytes": 3221225472, + "new_package_below_bytes": 1048576, + "observed_peak_child_rss_bytes": 41304064 + }, + "schema": 1, + "status": "passed", + "tested_source_sha256": { + ".github/workflows/dirty-stride-precision.yml": "751044842af363cd3ba3f95abcc676cf3604bed01cb4d42fd7e73db51b731f29", + "research/dirty-stride-precision/CHECKS.md": "2fd250af1b47797564d9f64e81ef9440ea583f9238064e11f2d8aeb88cf5cab6", + "research/dirty-stride-precision/EXPECTED.json": "49737d3948b88d852f498f762913e5b6a8da2da6e99ff8f5737b16f18381fc5d", + "research/dirty-stride-precision/NOTICE.md": "d8059542dc8b2cebe6747a1334f2e03b97311dc4210d32b8f177c2ceb6b5c485", + "research/dirty-stride-precision/PROOF.md": "11c23a39b91fe6acbda1d7f0e3aa640a983b106ac4733ae03530d79c952d6919", + "research/dirty-stride-precision/README.md": "ea532a90ffa5be5e0121edd60d6ac3e54859d2c24954614d31fa875262176659", + "research/dirty-stride-precision/SOURCES.json": "686ace177e18123ad1f22d5aa4f97d26caf75092556d86b5173c1928485737a8", + "research/dirty-stride-precision/budget.py": "49538c697067525e5d4dc061c84f1e5cb5af459afd811b41663ee4607ba1fbc7", + "research/dirty-stride-precision/dirty_stride.py": "e2ebf6a2233901e116b8de6bcc8762aee0e0832098b194a112b51736f4ea9f21", + "research/dirty-stride-precision/test_package.py": "9e9d5c4848914d3a0d9fe8e1620eed581f58c3ccdb941665f1267d076610ecf5", + "research/dirty-stride-precision/vendor/pr862/NOTICE.md": "08c25cd6248e8c4dc7008e14e9ea7690f9084e94f927bb602363773637a89921", + "research/dirty-stride-precision/vendor/pr862/PROOF.md": "bdb0518892c631f8b6ac149535ac5a92270def19fe7778ca737641cd56b7da0b", + "research/dirty-stride-precision/vendor/pr905/NOTICE.md": "062efe3baa26ba98bb879c7d954cc557aedfd1b7fce6209e6bf8e6677e7257c5", + "research/dirty-stride-precision/vendor/pr905/PROOF.md": "fc6b863d940a6b7341e65f0627d88e409d11222f871b422dd784198db9ebf381", + "research/dirty-stride-precision/vendor/pr977/NOTICE.md": "b6e1bab630faf7eb4ad0952173dd789a7f5d6333bf938b275bcf087474f4f189", + "research/dirty-stride-precision/vendor/pr977/PROOF.md": "30c296d4f1947cbcaaeb0fe575c36e3c2308f1583dde6029efb4a162fb7a4b27", + "research/dirty-stride-precision/vendor/pr985/CLAIM.json": "04a779b6490a00fb393a3c0cb48deb095a8a741313d968105e9c01eeb2d2e026", + "research/dirty-stride-precision/vendor/pr985/EXPECTED.json": "4545a0f63837efa8be0715be509fb0a2ac6a8c4835a118b871653235b9c907d2", + "research/dirty-stride-precision/vendor/pr985/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/dirty-stride-precision/vendor/pr985/NOTICE.md": "759fd9ada0c70e657a0b903089b32c84239b05b1f214cb01e81e9ca61b0d87f4", + "research/dirty-stride-precision/vendor/pr985/PROOF.md": "af6560b048b20649aebd31d68815948a104d2c87efcdf556c85a10f48bbc0489", + "research/dirty-stride-precision/vendor/pr985/README.md": "96527e5f166ab8223e5c652975f32b4ba1b6b1d7fd41667a46bf515571fdaf13", + "research/dirty-stride-precision/vendor/pr985/SOURCE.json": "a0ce06a3d3fd083145b099b378afac9a33fbc499837c25250befb9236a2a9ec6", + "research/dirty-stride-precision/vendor/pr985/VALIDATION.json": "a3cb5788a6494d916896bfd772964a88ed769d47caa2991e0b0fb3fde05dea2b", + "research/dirty-stride-precision/vendor/pr985/dirty_stride.py": "129b2bc8cf89159aae0a810fad4703caefefccf1c5f4805dd3c9b5e8d967354b", + "research/dirty-stride-precision/vendor/pr985/test_package.py": "d767e8c37bc8300f417f84c9d5602f0af4bb63f8794bb044479547fc2d92b57c", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/DIRTY-PROOF.md": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/FACTORS.json": "643d60ac24d5e67f6c9305175bd1c99bf5e42edfef6d1995c051e0b98ba446a7", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/NOTICE.md": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/README.md": "3ffc38b79ef21f506f35b8e4613510a9a5ceacefddf4a56515fbc6ec6138584d", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/SOURCE.json": "38a425e2d3a72a5e39b18b54c728e40407e121d481a1c6423edd5c18e9b68a04", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/check.py": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/dirty.py": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/interval_kernel.py": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe", + "research/dirty-stride-precision/vendor/pr985/vendor/pr628/scan.py": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e", + "research/dirty-stride-precision/vendor/pr985/vendor/pr846/NOTICE.md": "9403006a0d8193298ac9c5dd4036619190aea29bfe37b03d2d716d8be264fc75", + "research/dirty-stride-precision/vendor/pr985/vendor/pr846/PROOF.md": "3937696d2156e000519fb185a8a55fa7fd55dc12266fe0fe806dba42b2acf4e1", + "research/dirty-stride-precision/vendor/pr985/vendor/pr846/README.md": "0ecef1ba0da4f7d033db59084944baa9cf79140cd04f91d39db9e899c8ee03cc", + "research/dirty-stride-precision/vendor/pr985/vendor/pr846/SOURCE.json": "07bc9fe307f254b68810f664bcef0f30eabd130226d39804bb38517777e3a92b", + "research/dirty-stride-precision/vendor/pr985/vendor/pr846/stride.py": "da56e45f414a633453e06e8d058bcec6c815c73950816fcf049d92c570f8928e", + "research/dirty-stride-precision/vendor/pr985/verify.py": "676f9476ae71c370365a42d8d84cc36cbac419ef29d878bc60f53f74363b7fe7", + "research/dirty-stride-precision/verify.py": "b0cfbdb490cbf1ca1e08d0993efd7e66ad03f9262ad46c95a5688f939678f3aa" + }, + "validation_log": "VALIDATION.log.txt", + "validation_log_sha256": "e5e066c7bd2f7afa825cedc9537d863513d6e6b48f89c27485f66255eeda8fbb" +} diff --git a/research/dirty-stride-precision/VALIDATION.log.txt b/research/dirty-stride-precision/VALIDATION.log.txt new file mode 100644 index 0000000000..a415fa74a4 --- /dev/null +++ b/research/dirty-stride-precision/VALIDATION.log.txt @@ -0,0 +1,48 @@ +Frozen standalone package replay +checked kernel 3 1 +checked kernel 4 1 +checked kernel 5 1 +checked kernel 7 1 +checked kernel 8 1 +checked kernel 9 1 +checked kernel 9 2 +checked kernel 11 1 +checked kernel 13 1 +checked kernel 16 1 +checked uniform kernel 3 1 +checked uniform kernel 4 1 +checked uniform kernel 5 1 +PASS_DIRTY_STRIDE_PRECISION budgets=5220 leaves=468 kernels=80 uniform=18 controls=9 +{"controls": ["legacy_validation_rereads", "source_undo", "closure_inverse", "nearest_power", "false_extinction", "inverse_order", "inner_shift", "validation_reread", "local_error_power", "inverse_guard", "dependency_drift", "output_overwrite"], "read_only_relocation": true, "receipt_sha256": "49737d3948b88d852f498f762913e5b6a8da2da6e99ff8f5737b16f18381fc5d"} +PASS_DIRTY_STRIDE_PRECISION_PACKAGE controls=12 relocation=1 + +Selected record +python3 -B scripts/verify_selected_result.py +PASS selected record, exact kappa, original source inventory and proof supplement: 1661960547713947/1000000000000000000 + +Selected tests +......................... +---------------------------------------------------------------------- +Ran 25 tests in 0.553s + +OK + +Earlier measurement wrapper +checked kernel 3 1 +checked kernel 4 1 +checked kernel 5 1 +checked kernel 7 1 +checked kernel 8 1 +checked kernel 9 1 +checked kernel 9 2 +checked kernel 11 1 +checked kernel 13 1 +checked kernel 16 1 +checked uniform kernel 3 1 +checked uniform kernel 4 1 +checked uniform kernel 5 1 +PASS_DIRTY_STRIDE_PRECISION budgets=5220 leaves=468 kernels=80 uniform=18 controls=9 +{"controls": ["legacy_validation_rereads", "source_undo", "closure_inverse", "nearest_power", "false_extinction", "inverse_order", "inner_shift", "validation_reread", "local_error_power", "inverse_guard", "dependency_drift", "output_overwrite"], "read_only_relocation": true, "receipt_sha256": "49737d3948b88d852f498f762913e5b6a8da2da6e99ff8f5737b16f18381fc5d"} +PASS_DIRTY_STRIDE_PRECISION_PACKAGE controls=12 relocation=1 + 624.85 real 543.62 user 6.41 sys +time: sysctl kern.clockrate: Operation not permitted diff --git a/research/dirty-stride-precision/budget.py b/research/dirty-stride-precision/budget.py new file mode 100644 index 0000000000..f90742b4d1 --- /dev/null +++ b/research/dirty-stride-precision/budget.py @@ -0,0 +1,120 @@ +"""Precision bounds for the constant-coefficient PR985 word. + +The common-operator hypotheses are mathematical inputs. See PROOF.md. +""" +from fractions import Fraction as F +from math import gcd, isqrt + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def ceil_log2(value): + value = F(value) + need(value > 0, 'positive logarithm') + k = value.numerator.bit_length() - value.denominator.bit_length() + return k + (value > F(2)**k) + + +def prime_power(r): + if type(r) is not int or r < 3: + return False + p = next((d for d in range(2, isqrt(r)+1) if r % d == 0), r) + while r % p == 0: + r //= p + return r == 1 + + +def resources(count): + need(type(count) is int and count >= 1, 'positive factor count') + h = (count-1).bit_length() + q = 1 << (count.bit_length()-1) + return h, 3*q*count-2*q*q, 2*3**h + + +def execution(count, scale, beta, subset_bound, initial_bound, bits): + """Bound both signs of the complete rounded dirty word.""" + need(type(bits) is int and bits >= 0 and scale >= 1 + and 0 < beta <= F(1, 2) and subset_bound >= 1 + and initial_bound >= 0, 'execution domain') + h, calls, mass = resources(count) + prefix = mass*subset_bound + local = 68*(scale+1)/beta**5 + unit = F(1, 1 << bits) + g = ceil_log2(1/beta) + active = g+bits.bit_length() + need(48*(active+1)*unit <= beta**3, 'all-length admission') + feedback = calls*prefix**2*local*unit + need(feedback <= F(1, 2), 'feedback smallness') + boundary = 2*prefix*initial_bound+1 + peak = 1024*(scale+1)*(scale+2)*(prefix*initial_bound+1)/beta**8 + return dict(leaf_calls=calls, dirty_arrays=h, prefix_bound=prefix, + effective_depth=active, local_error_coefficient=local, + feedback=feedback, boundary_magnitude=boundary, + internal_magnitude=peak, + error=2*feedback*(prefix*initial_bound+1)) + + +def choose(count, scale, beta, subset_bound, initial_bound, target_bits, incoming_bits): + """Choose sufficient precision without a length or stride input.""" + need(all(type(v) is int and v >= 0 for v in (target_bits, incoming_bits)), + 'integer precision') + need(scale >= 1 and 0 < beta <= F(1, 2) and subset_bound >= 1 + and initial_bound >= 0, 'budget domain') + _, calls, mass = resources(count) + prefix = mass*subset_bound + local = 68*(scale+1)/beta**5 + bits = max(incoming_bits, 4*ceil_log2(1/beta)+16, + target_bits+2+ceil_log2(calls*prefix**2*local*(prefix*initial_bound+1))) + result = execution(count, scale, beta, subset_bound, initial_bound, bits) + need(result['error'] <= F(1, 1 << (target_bits+1)), 'execution target') + result['working_bits'] = bits + result['integer_bits'] = ceil_log2(result['internal_magnitude'])+2 + return result + + +def uniform(r, target_bits, magnitude_bits, incoming_bits): + """Use the inherited prime-power preparation bounds as exponents.""" + need(prime_power(r), 'prime-power radix >=3') + need(all(type(v) is int and v >= 0 for v in + (target_bits, magnitude_bits, incoming_bits)), 'integer precision') + n = r-1 + h, calls, mass = resources(n) + ell = (r-1).bit_length() + phi = sum(gcd(j, r) == 1 for j in range(1, r)) + d0 = 1+2*ell+r*n*phi + a0 = 2*d0+r+2 + g = d0+ell+2*r+2 + e = max(d0+1, a0+1, target_bits+2*a0+magnitude_bits+4) + factor_bits = max(n*ell, e+r+3) + prefix = a0+2*r+ell+1+2*h + local = 5*g+ceil_log2(68*(r+1)) + bits = max(incoming_bits, 4*g+16, + target_bits+3+ceil_log2(calls)+local+magnitude_bits+3*prefix) + integer = prefix+magnitude_bits+8*g+2*ell+16 + return dict(radix=r, target_bits=target_bits, magnitude_bits=magnitude_bits, + incoming_bits=incoming_bits, factors=n, depth=h, leaf_calls=calls, + coefficient_mass=mass, phi=phi, circle_exponent=d0, + inverse_exponent=a0, margin_exponent=g, + preparation_error_exponent=e, factor_bits=factor_bits, + prefix_exponent=prefix, local_error_exponent=local, + working_bits=bits, integer_bits=integer) + + +def check_uniform(row): + """Check a supplied exponent certificate with exact integer bounds.""" + need(all(type(v) is int for v in row.values()), 'integer certificate') + r, p, m, incoming = (row[k] for k in + ('radix', 'target_bits', 'magnitude_bits', 'incoming_bits')) + need(row == uniform(r, p, m, incoming), 'certificate fields') + w, g, j, a, calls = (row[k] for k in + ('working_bits', 'margin_exponent', 'prefix_exponent', + 'local_error_exponent', 'leaf_calls')) + need(w >= incoming and w >= 4*g+16, 'input grid and all-length admission') + exponent = w-p-m-3*j-a-3 + need(exponent >= 0 and calls <= 1 << exponent, 'execution exponent') + need(w <= max(p, incoming)+m+18*r**3, 'fractional cubic bound') + need(row['integer_bits'] <= m+15*r**3, 'integer cubic bound') + need(row['factor_bits'] <= p+m+7*r**3, 'preparation cubic bound') diff --git a/research/dirty-stride-precision/dirty_stride.py b/research/dirty-stride-precision/dirty_stride.py new file mode 100644 index 0000000000..7c8cdd77a4 --- /dev/null +++ b/research/dirty-stride-precision/dirty_stride.py @@ -0,0 +1,422 @@ +"""Add a cyclic inverse to a target and restore the source exactly. + +This extends PR985 at 9df42a99dd8497b6e7d46cd2507bb89071372640. +The precision admission and two validation reads change. The rounded word +and its two-tape movement are unchanged. See PROOF.md for the bounds. +""" +from dataclasses import dataclass, field +from fractions import Fraction as F +from math import gcd + +ZERO = (F(0), F(0)) +ONE = (F(1), F(0)) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def add(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def sub(a, b): + return (a[0] - b[0], a[1] - b[1]) + + +def mul(a, b): + return (a[0]*b[0] - a[1]*b[1], a[0]*b[1] + a[1]*b[0]) + + +def norm2(a): + return a[0]*a[0] + a[1]*a[1] + + +def div(a, b): + d = norm2(b) + need(d != 0, 'zero divisor') + v = mul(a, (b[0], -b[1])) + return (v[0]/d, v[1]/d) + + +def rnd(a, bits): + """Use nearest dyadic rounding, with ties toward positive infinity.""" + scale = 1 << bits + def component(v): + t = v*scale + F(1, 2) + return F(t.numerator // t.denominator, scale) + return (component(a[0]), component(a[1])) + + +def trunc(a, bits): + """Truncate each component toward zero. This cannot increase the norm.""" + scale = 1 << bits + return tuple(F(int(v*scale), scale) for v in a) + + +@dataclass +class Meter: + reads: int = 0 + writes: int = 0 + tape_moves: int = 0 + products: int = 0 + power_products: int = 0 + divisions: int = 0 + nodes: int = 0 + leaves: int = 0 + validation_reads: int = 0 + max_depth: int = 0 + heads: dict = field(default_factory=dict) + layout: dict = field(default_factory=dict) + + def access(self, data, index, write=False): + tape, start = self.layout[id(data)] + position = start+index + self.tape_moves += abs(position - self.heads.get(tape, 0)) + 1 + self.heads[tape] = position + if write: + self.writes += 1 + else: + self.reads += 1 + + def rewind(self): + for tape, position in self.heads.items(): + self.tape_moves += position + self.heads[tape] = 0 + + +@dataclass(frozen=True) +class View: + data: list + start: int + step: int + length: int + meter: Meter + + def index(self, i): + need(0 <= i < self.length, 'view index') + return (self.start + self.step*i) % len(self.data) + + def get(self, i): + j = self.index(i) + self.meter.access(self.data, j) + return self.data[j] + + def put(self, i, value): + j = self.index(i) + self.meter.access(self.data, j, True) + self.data[j] = value + + def part(self, first, length): + need(0 <= first and first + length <= self.length, 'view interval') + return View(self.data, self.start + self.step*first, self.step, length, self.meter) + + def reverse(self): + return View(self.data, self.start + self.step*(self.length-1), + -self.step, self.length, self.meter) + + +def depth(length, stride): + count = 0 + while True: + stride %= length + stride = min(stride, length-stride) + if stride == 0: + return count + length, stride = stride, (-length) % stride + count += 1 + + +def effective_depth(beta, bits): + """Bound the nonzero levels of the unchanged rounded word.""" + need(0 < beta <= F(1, 2) and type(bits) is int and bits >= 0, + 'effective depth domain') + return ceil_log2(1/beta) + bits.bit_length() + + +def admitted(beta, bits, levels): + if not (type(bits) is int and bits >= 0 and type(levels) is int + and levels >= 0 and 0 < beta <= F(1, 2)): + return False + active = min(levels, effective_depth(beta, bits)) + return 48*(active+1)*F(1, 1 << bits) <= beta**3 + + +def power(b, exponent, bits, meter): + """Use a left-to-right binary product and scalar working storage.""" + need(exponent >= 1, 'positive exponent') + result = b + for k in range(exponent.bit_length()-2, -1, -1): + result = trunc(mul(result, result), bits) + meter.power_products += 1 + if (exponent >> k) & 1: + result = trunc(mul(result, b), bits) + meter.power_products += 1 + return result + + +@dataclass(frozen=True) +class Geometry: + root: tuple + divisor: int + cycle: int + inverse: int + bits: int + meter: Meter + + def exponents(self, length, stride, orientation): + if stride == 0: + return (self.cycle, self.cycle) + def exponent(displacement): + need(displacement % self.divisor == 0, 'cycle lattice') + return ((displacement // self.divisor)*self.inverse) % self.cycle or self.cycle + return (exponent(orientation*stride), exponent(orientation*(stride-length))) + + def coefficients(self, length, stride, orientation): + a, b = self.exponents(length, stride, orientation) + left = power(self.root, a, self.bits, self.meter) + right = left if a == b else power(self.root, b, self.bits, self.meter) + return (left, right) + + +def emit(target, i, value, multiplier, sign, bits): + if multiplier != ONE: + target.meter.products += 1 + value = rnd(mul(multiplier, value), bits) + old = target.get(i) + target.put(i, add(old, value) if sign == 1 else sub(old, value)) + + +def swap(source, target): + for i in range(source.length): + left, right = source.get(i), target.get(i) + source.put(i, right) + target.put(i, left) + + +def causal(source, carrier, stride, geometry, undo=False): + """Apply the causal lifts with block swaps; restore the dirty carrier.""" + a, _ = geometry.coefficients(source.length, stride, source.step) + n = source.length + if undo: + swap(source, carrier) + for first in range(((n-1)//stride)*stride, -1, -stride): + size = min(stride, n-first) + swap(source.part(first, size), carrier.part(first, size)) + if first: + for i in range(first+size-1, first-1, -1): + value = rnd(mul(a, carrier.get(i-stride)), geometry.bits) + geometry.meter.products += 1 + source.put(i, sub(source.get(i), value)) + else: + for first in range(0, n, stride): + size = min(stride, n-first) + if first: + for i in range(first, first+size): + value = rnd(mul(a, carrier.get(i-stride)), geometry.bits) + geometry.meter.products += 1 + source.put(i, add(source.get(i), value)) + swap(source.part(first, size), carrier.part(first, size)) + swap(source, carrier) + + +def expand(source, target, stride, geometry, multiplier, sign): + """Conjugate the seed injection by exact inverse causal grid maps.""" + causal(target, source, stride, geometry, undo=True) + _, b = geometry.coefficients(source.length, stride, source.step) + coefficient = mul(multiplier, b) + geometry.meter.products += 1 + for i in range(stride): + value = rnd(mul(coefficient, source.get(i)), geometry.bits) + geometry.meter.products += 1 + emit(target, i, value, ONE, sign, geometry.bits) + causal(target, source, stride, geometry) + + +def closure(source, target, stride, geometry, sign, level): + """Move the child target to the other tape and restore the carrier.""" + borrowed = source.part(0, stride) + carrier = target.part(0, stride) + ends = source.part(source.length-stride, stride) + swap(borrowed, carrier) + solve(ends, carrier, (-source.length) % stride, geometry, sign=sign, level=level+1) + swap(borrowed, carrier) + + +def diagonal(source, target, geometry, multiplier, sign): + coefficient = power(geometry.root, geometry.cycle, geometry.bits, geometry.meter) + denominator = sub(ONE, coefficient) + for i in range(source.length): + value = rnd(div(source.get(i), denominator), geometry.bits) + geometry.meter.divisions += 1 + emit(target, i, value, multiplier, sign, geometry.bits) + + +def solve(source, target, stride, geometry, multiplier=ONE, sign=1, level=0): + """Use integer metadata at each level; scalar temporaries stay in helpers.""" + length = source.length + stride %= length + if 2*stride > length: + source, target, stride = source.reverse(), target.reverse(), length-stride + geometry.meter.nodes += 1 + geometry.meter.max_depth = max(geometry.meter.max_depth, level) + if stride == 0: + diagonal(source, target, geometry, multiplier, sign) + return + causal(source, target, stride, geometry) + if sign == 1: + for i in range(length): + emit(target, i, source.get(i), multiplier, 1, geometry.bits) + closure(source, target, stride, geometry, 1, level) + expand(source, target, stride, geometry, multiplier, 1) + closure(source, target, stride, geometry, -1, level) + expand(source, target, stride, geometry, multiplier, -1) + else: + expand(source, target, stride, geometry, multiplier, 1) + closure(source, target, stride, geometry, 1, level) + expand(source, target, stride, geometry, multiplier, -1) + closure(source, target, stride, geometry, -1, level) + for i in range(length): + emit(target, i, source.get(i), multiplier, -1, geometry.bits) + causal(source, target, stride, geometry, undo=True) + + +def lift(x, y, b, beta, bits, stride, sign=1, multiplier=ONE, shift=0, meter=None): + """Add multiplier*(I-b Z^stride)^-1 x at output indices i+shift.""" + need(type(stride) is int and type(shift) is int and type(sign) is int + and sign in (-1, 1), 'integer stride and sign') + need(x is not y and len(x) == len(y) and len(x) > 0, 'distinct equal arrays') + need(shift % len(x) in (0, stride % len(x)), 'output shift must be zero or the leaf stride') + need(isinstance(b, tuple) and len(b) == 2 and norm2(b) <= (1-beta)**2, 'stable constant coefficient') + need(isinstance(multiplier, tuple) and len(multiplier) == 2, 'constant multiplier') + need(admitted(beta, bits, depth(len(x), stride)), 'precision admission') + meter = meter if meter is not None else Meter() + if not meter.layout: + meter.layout = {id(x): (0, 0), id(y): (1, 0)} + need(id(x) in meter.layout and id(y) in meter.layout + and {meter.layout[id(x)][0], meter.layout[id(y)][0]} == {0, 1}, 'two distinct data tapes') + for data in (x, y): + for i in range(len(data)): + meter.access(data, i) + meter.validation_reads += 1 + datum = data[i] + need(rnd(datum, bits) == datum, 'fixed grid data') + del datum + divisor = gcd(len(x), stride) + cycle = len(x)//divisor + inverse = pow((stride//divisor) % cycle, -1, cycle) if cycle > 1 else 0 + geometry = Geometry(b, divisor, cycle, inverse, bits, meter) + solve(View(x, 0, 1, len(x), meter), View(y, shift, 1, len(y), meter), + stride, geometry, multiplier, sign) + meter.leaves += 1 + meter.rewind() + return meter + + +def leaf_bound(bound, beta, bits, multiplier_bound=1): + return (64*multiplier_bound*(bound+1)/beta**5 + 3)*F(1, 1 << bits) + + +def leaf_calls(count): + need(type(count) is int and count >= 1, 'positive factor count') + if count == 1: + return 1 + return 2*leaf_calls(count//2) + 2*leaf_calls(count-count//2) + + +def compose(x, y, factors, scratch, tau, beta, bits, stride, sign=1, meter=None): + """Use PR628's balanced dirty commutator with the new arbitrary-stride leaf.""" + need(factors and len(scratch) >= (len(factors)-1).bit_length(), 'dirty depth') + arrays = [x, y] + scratch + need(len({id(a) for a in arrays}) == len(arrays), 'all arrays distinct') + need(len(x) > 0 and all(len(a) == len(x) for a in arrays), 'array lengths') + need(isinstance(tau, tuple) and norm2(tau) == 1, 'immutable unit gauge') + need(type(sign) is int and sign in (-1, 1) and type(stride) is int, 'integer stride and sign') + need(admitted(beta, bits, depth(len(x), stride)), 'precision admission') + for factor in factors: + need(isinstance(factor, tuple) and len(factor) == 3, 'factor descriptor') + inside, b, scale = factor + need(type(inside) is bool and isinstance(b, tuple) and len(b) == 2 + and norm2(b) <= (1-beta)**2 and isinstance(scale, (int, F)), 'stable factor descriptor') + meter = meter if meter is not None else Meter() + if scratch: + layout = {id(a): (0, i*len(x)) for i, a in enumerate(arrays[:-1])} + layout[id(scratch[-1])] = (1, 0) + else: + layout = {id(x): (0, 0), id(y): (1, 0)} + need(not meter.layout or meter.layout == layout, 'kernel tape layout') + meter.layout = layout + for data in arrays: + for i in range(len(data)): + meter.access(data, i) + meter.validation_reads += 1 + datum = data[i] + need(rnd(datum, bits) == datum, 'fixed grid data') + del datum + def run(src, dst, lo, hi, level, direction): + if hi-lo == 1: + inside, b, scale = factors[lo] + phase = (tau[0], -tau[1]) if inside else tau + coefficient = mul(b, phase) + m = phase if inside else (-b[0], -b[1]) + m = (m[0]*scale, m[1]*scale) + if meter.layout[id(src)][0] == meter.layout[id(dst)][0]: + spare = scratch[-1] + destination = View(dst, 0, 1, len(dst), meter) + carrier = View(spare, 0, 1, len(spare), meter) + swap(destination, carrier) + lift(src, spare, coefficient, beta, bits, -stride if inside else stride, + direction, m, -stride if inside else 0, meter) + swap(destination, carrier) + else: + lift(src, dst, coefficient, beta, bits, -stride if inside else stride, + direction, m, -stride if inside else 0, meter) + return + mid = (lo+hi)//2 + z = scratch[level] + if direction == 1: + run(src, z, lo, mid, level+1, 1) + run(z, dst, mid, hi, level+1, 1) + run(src, z, lo, mid, level+1, -1) + run(z, dst, mid, hi, level+1, -1) + else: + run(z, dst, mid, hi, level+1, 1) + run(src, z, lo, mid, level+1, 1) + run(z, dst, mid, hi, level+1, -1) + run(src, z, lo, mid, level+1, -1) + run(x, y, 0, len(factors), 0, sign) + meter.rewind() + return meter + + +def ceil_log2(value): + value = F(value) + need(value > 0, 'positive logarithm') + k = value.numerator.bit_length() - value.denominator.bit_length() + power_of_two = F(2)**k + return k if value <= power_of_two else k+1 + + +def execution_bound(count, r, beta, initial_bound, bits): + need(r >= 1 and initial_bound >= 0 and 0 < beta <= F(1, 2) + and type(bits) is int and bits >= 0, 'execution budget domain') + calls = leaf_calls(count) + a = 68*(r+1)/beta**5 + growth = 2+F(r)/beta + need(a*F(1, 1 << bits) <= 1, 'execution precision') + return calls*a*(initial_bound+1)*F(1, 1 << bits)*growth**(calls-1) + + +def working_bits(count, r, beta, initial_bound, target_bits, incoming_bits, length, stride): + need(r >= 1 and initial_bound >= 0 and 0 < beta <= F(1, 2) + and type(target_bits) is int and target_bits >= 0 + and type(incoming_bits) is int and incoming_bits >= 0 + and type(length) is int and length > 0 and type(stride) is int, 'working budget domain') + calls = leaf_calls(count) + a = 68*(r+1)/beta**5 + growth = 2+F(r)/beta + levels = depth(length, stride) + return max(incoming_bits, target_bits+1+ceil_log2(calls*a*(initial_bound+1)) + +(calls-1)*ceil_log2(growth), ceil_log2(a), + ceil_log2(48*(levels+1)/beta**3)) diff --git a/research/dirty-stride-precision/test_package.py b/research/dirty-stride-precision/test_package.py new file mode 100644 index 0000000000..f9a4ee65c7 --- /dev/null +++ b/research/dirty-stride-precision/test_package.py @@ -0,0 +1,173 @@ +"""Check faults, source binding, and a read-only standalone replay.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + +LOAD = r''' +import importlib.util, pathlib, sys +p = pathlib.Path(sys.argv[1]) +s = importlib.util.spec_from_file_location('probe', p/'verify.py') +v = importlib.util.module_from_spec(s) +s.loader.exec_module(v) +d, b, F = v.d, v.b, v.F +''' + +SOURCE = LOAD+r''' +x0, y0 = v.v.values(12, 64, 36), v.v.values(12, 64, 71) +x, y = v.v.Bank(x0), v.v.Bank(y0) +d.lift(x, y, (F(3,10), F(2,5)), F(1,2), 64, 5) +d.need(x.values == x0, 'source restoration') +''' + +KERNEL = LOAD+r''' +fs = [(True, (F(1,4), F(1,8)), F(3)), + (False, (F(1,3), F(1,9)), F(1))] +q = [d.ONE] +for inside, coefficient, scale in fs: + root = coefficient if inside else d.div(d.ONE, coefficient) + new = [d.ZERO]*(len(q)+1) + for j, value in enumerate(q): + new[j] = d.sub(new[j], d.mul(root, value)) + new[j+1] = d.add(new[j+1], value) + q = new +q = [tuple(z/3 for z in pair) for pair in q] +state = dict(radix=3, embedding=0, q=q, + certificate=dict(factorization_inverse_error_bound='0')) +budget = b.choose(2, 3, F(1,2), 1000, 4, 128, 16) +v.execute_kernel(state, fs, F(1,2), budget, 5, 2, (F(3,5), F(4,5))) +''' + +POWER = LOAD+r''' +root = (F(3,10), F(2,5)) +exact = d.mul(root, root) +d.need(d.norm2(d.power(root, 2, 4, d.Meter())) <= d.norm2(exact), 'power norm guard') +''' + +EXTINCTION = LOAD+r''' +beta, bits = F(1,4096), 64 +depth = d.effective_depth(beta, bits) +d.need(d.power((1-beta,F(0)), 1 << depth, bits, d.Meter()) == d.ZERO, + 'exact coefficient extinction') +''' + +LEGACY_READS = LOAD+r''' +arrays = [v.Bank(v.v.values(12, 64, salt)) for salt in (36,71)] +v.run_counted(lambda: v.v.d.lift(*arrays, (F(3,10),F(2,5)), F(1,2), 64, 5), arrays) +''' + + +def need(ok, reason): + if not ok: + raise ValueError(reason) + + +def run(args, reason=None, cwd=None): + env = dict(os.environ, OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', MKL_NUM_THREADS='1') + result = subprocess.run([sys.executable, '-I', '-O', '-B']+args, cwd=cwd, + env=env, text=True, capture_output=True) + if reason is None: + need(result.returncode == 0, result.stdout+'\n'+result.stderr) + else: + need(result.returncode != 0 and reason in result.stderr, + 'wrong failure: '+reason+'\n'+result.stdout+'\n'+result.stderr) + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--mutations-only', action='store_true') + args = parser.parse_args() + controls = [] + with tempfile.TemporaryDirectory(prefix='dirty precision checks ') as tmp: + root = Path(tmp) + package = root/'standalone package' + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns('__pycache__')) + for probe in (SOURCE, KERNEL, POWER, EXTINCTION): + run(['-c', probe, str(package)]) + run(['-c', LEGACY_READS, str(package)], 'literal indexed access charge') + controls.append('legacy_validation_rereads') + source = package/'dirty_stride.py' + original = source.read_text() + inverse_word = (' run(z, dst, mid, hi, level+1, 1)\n' + ' run(src, z, lo, mid, level+1, 1)\n' + ' run(z, dst, mid, hi, level+1, -1)\n' + ' run(src, z, lo, mid, level+1, -1)') + wrong_word = (' run(src, z, lo, mid, level+1, -1)\n' + ' run(z, dst, mid, hi, level+1, -1)\n' + ' run(src, z, lo, mid, level+1, 1)\n' + ' run(z, dst, mid, hi, level+1, 1)') + mutations = [ + ('source_undo', ' causal(source, target, stride, geometry, undo=True)\n', + '', SOURCE, 'source restoration'), + ('closure_inverse', 'closure(source, target, stride, geometry, -1, level)', + 'closure(source, target, stride, geometry, 1, level)', SOURCE, 'source restoration'), + ('nearest_power', 'result = trunc(mul(', 'result = rnd(mul(', POWER, 'power norm guard'), + ('false_extinction', 'return ceil_log2(1/beta) + bits.bit_length()', + 'return 0', EXTINCTION, 'exact coefficient extinction'), + ('inverse_order', inverse_word, wrong_word, KERNEL, 'complete word inverse'), + ('inner_shift', 'm, -stride if inside else 0, meter)', + 'm, 0, meter)', KERNEL, 'new kernel execution error'), + ('validation_reread', "need(rnd(datum, bits) == datum, 'fixed grid data')", + "need(rnd(data[i], bits) == data[i], 'fixed grid data')", + KERNEL, 'literal indexed access charge'), + ] + for name, old, new, probe, reason in mutations: + need(old in original, 'missing fault site: '+name) + source.write_text(original.replace(old, new)) + run(['-c', probe, str(package)], reason) + controls.append(name) + source.write_text(original) + budget = package/'budget.py' + original_budget = budget.read_text() + for name, old, new, reason in ( + ('local_error_power', 'local = 5*g+', 'local = 3*g+', 'independent local bound'), + ('inverse_guard', 'prefix+magnitude_bits+8*g+2*ell+16', + 'prefix+magnitude_bits+7*g+2*ell+16', 'inverse preimage integer guard'), + ): + need(old in original_budget, 'missing budget fault site') + budget.write_text(original_budget.replace(old, new)) + run(['-c', LOAD+'v.budget_checks()\n', str(package)], reason) + controls.append(name) + budget.write_text(original_budget) + dependency = package/'vendor/pr985/dirty_stride.py' + dependency.write_bytes(dependency.read_bytes()+b'\n') + run(['-c', LOAD+'v.pins()\n', str(package)], 'source SHA256') + controls.append('dependency_drift') + shutil.copyfile(HERE/'vendor/pr985/dirty_stride.py', dependency) + occupied = root/'occupied.json' + occupied.write_text('keep\n') + run([str(package/'verify.py'), '--write', str(occupied)], 'output already exists') + need(occupied.read_text() == 'keep\n', 'existing output preserved') + controls.append('output_overwrite') + receipt = None + if not args.mutations_only: + output = root/'regenerated.json' + try: + for item in package.rglob('*'): + item.chmod(0o555 if item.is_dir() else 0o444) + package.chmod(0o555) + result = run([str(package/'verify.py'), '--write', str(output)], cwd=root) + need(output.read_bytes() == (HERE/'EXPECTED.json').read_bytes(), + 'standalone exact receipt') + receipt = hashlib.sha256(output.read_bytes()).hexdigest() + print(result.stdout, end='') + finally: + package.chmod(0o755) + for item in package.rglob('*'): + item.chmod(0o755 if item.is_dir() else 0o644) + print(json.dumps(dict(controls=controls, read_only_relocation=receipt is not None, + receipt_sha256=receipt), sort_keys=True)) + print('PASS_DIRTY_STRIDE_PRECISION_PACKAGE controls=%d relocation=%d' % + (len(controls), not args.mutations_only)) + + +if __name__ == '__main__': + main() diff --git a/research/dirty-stride-precision/vendor/pr862/NOTICE.md b/research/dirty-stride-precision/vendor/pr862/NOTICE.md new file mode 100644 index 0000000000..737060bd4d --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr862/NOTICE.md @@ -0,0 +1,31 @@ +# Attribution and scope + +New contribution by Chafik Boukhalfa (@chafreaky), prepared with substantial +OpenAI Codex assistance, under the repository's Apache-2.0 license. + +- Ali Romman (@aliromman), PR621 at + `520774462b19b29af41554b74def31f9d01e997e`: prime-power kernel, circle + lower bound and length-uniform inverse bound. Its notice is retained. +- Chafik Boukhalfa (@chafreaky), PR628 at + `0768f97d06c623b8211e651543c66135796b62bf`: stable cyclic scan, rounded + execution, preparation and phase arguments, exact kernel fixtures and + earlier dirty-shear construction. Its notice is retained. +- The classical Mahler-measure bound, periodic filtering and approximate + factorization methods are not claimed as new. The source-recovery and + complementary-factor accounting are the contribution of this package. +- Pan's factorization bound is cited through Mehlhorn, Sagraloff and Wang, + *From Approximate Factorization to Root Isolation with Application to + Cylindrical Algebraic Decomposition*, Theorem 2 and Corollary 1, + https://arxiv.org/pdf/1301.4870, PDF page 8. The inherited fast elementary + function reference and original kernel attribution remain in PR628's note. + +PR846 by Rohan Guliani and PR764 by Charles Bethin are discussed only as +related stride and rounding work. No source from either is consumed here; +their arbitrary-stride or sharper local bounds are not prerequisites of +this package's claims. + +The dense oracle is a separate implementation in the same package. No +independent human or delegated-agent review, formal verification, practical +speedup, literature priority, complete multiplication theorem or new kappa +is claimed. The reserved low bits are part of the source contract; arbitrary +dirty storage and common-label/Clifford realization are not supplied. diff --git a/research/dirty-stride-precision/vendor/pr862/PROOF.md b/research/dirty-stride-precision/vendor/pr862/PROOF.md new file mode 100644 index 0000000000..0196499f01 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr862/PROOF.md @@ -0,0 +1,259 @@ +# A cubic precision guard for the prime-power cyclic inverse + +## Result and boundary + +For the PR621 prime-power kernel of order r>=3, the PR628 neighboring +cyclic scan needs working precision + + max(p,w) + O(r^3 + log(D+1)), + +including integer magnitude bits, to approximate the inverse to absolute +error 2^-p on a source of norm <=D initially on the 2^-w grid. The same +precision suffices for coarse-grid in-place source recovery. The previous +uniform scan composition charged O(r^4) because it propagated every local +error through a product of individual reciprocal margins. Here every +partial inverse is bounded by the full inverse and complementary factors. + +Array execution still costs O(rL) rounded scalar operations. With the same +charged approximate-factorization and coefficient-verification algorithms, +the bit cost for a neighboring cyclic layout is + + soft-O((Lr+r^3)(max(p,w)+r^3+log(D+1))). + +This is a standard-arithmetic, supplied-layout theorem. The worst-case +factorization and fast arithmetic are inherited algorithms, not implemented +by the Fraction reference. The restored-source version needs owned widened +source words whose low working bits are initially zero; those bits are +charged. No arbitrary dirty-bit, Clifford, common-label, complete-transform +or multiplication-exponent claim follows. +Phase-oracle costs and the cost of reading a longer phase description are +additional to the displayed bit bound. + +## Full inverse controls every partial inverse + +Let U be an invertible isometry in the maximum norm: ||U^k||=1 for every +integer k. A unit-weighted permutation, including a weighted cyclic shift, +has this property. Let + + f(z)=product_(j=1)^n (z-rho_j) = s Q(z), + M >= sum_j |Q_j|, ||Q(U)^-1|| <= A. + +Assume Q(U) is invertible. All factors are polynomials in the **same U**. +The assertion below does not apply to different noncommuting shifts. + +For a monic polynomial f define its Mahler measure + + M(f)=product_j max(1,|rho_j|). + +For completeness, the elementary circle identity +mean_t log|exp(it)-rho| = log max(1,|rho|) follows by integrating the +power series of log(1-z) when |z|<1 and factoring out rho when |rho|>1. +There are no unit-circle roots in this application. Summing the identities, +then applying concavity of log and Parseval, gives + + log M(f) = mean log|f(exp(it))| + <= (1/2) log(mean |f(exp(it))|^2) + = (1/2) log(sum_j |f_j|^2). + +Thus M(f)<=||f||_2<=||f||_1<=sM. For any subset J of the root occurrences +(multiplicities included), the complementary factor has coefficient norm + + ||product_(j notin J)(z-rho_j)||_1 + <= product_(j notin J)(1+|rho_j|) + <= 2^n M(f) <= 2^n sM. + +As the factors commute, + + product_(j in J)(U-rho_j I)^-1 + = product_(j notin J)(U-rho_j I) Q(U)^-1 / s. + +Every such inverse, including every prefix and every contiguous suffix, +therefore has norm <= B=max(1,2^n M A). Importantly, log B depends on the +full inverse bound, not n times the worst individual reciprocal margin. + +For later source restoration, let K_j=1+|Re rho_j|+|Im rho_j|. Then +K_j<=3 max(1,|rho_j|), so every forward subproduct has norm bounded by +its product of K_j, which is <=F=3^n sM. This also bounds amplification of +the rounding errors introduced during forward restoration. + +## Rounded execution without repeated reciprocal-margin multiplication + +Suppose every factor is implemented by PR628's stable scan with margin +beta, and u=2^-W<=beta^2/2. Including the final outer scalar or inner unit +shift, its local error for an input of norm <=X is at most + + a (X+1)u, a=7 beta^-3. + +Begin with s x and apply all n inverse factors. The exact prefix norm is +<=sBD. Let E_j be the computed prefix error, E=max_(0<=j<=n) E_j, and +delta_j the local error at stage j. Then + + |delta_j| <= a(sBD+E+1)u. + +The error at any prefix is the sum of earlier delta_j propagated through +contiguous inverse subproducts. Each propagation has norm <=B, hence + + E <= nBa(sBD+E+1)u. + +For t=nBa u<1 this implies + + E <= t(sBD+1)/(1-t). (1) + +This rearrangement is not an inductive assumption that the error is small: +all finite computed prefixes exist by the stable closure condition, and +their maximum obeys the displayed inequality. The strict contraction +condition then bounds it. The verifier compares every prefix with an +independent exact dense oracle in its small-cycle cases. + +## Recovering a coarse-grid source + +The cyclic inverse's first pass computes the boundary seed read-only. Its +second pass reads each original source entry before overwriting that slot. +An inner factor's unit shift is performed in place with one saved boundary +entry; an outer factor needs a scalar pass. Thus no full-length intermediate +array is required for evaluation on a neighboring cyclic layout. + +After adding the computed inverse to a distinct working-grid target, +apply the forward factors in reverse order. Each forward pass saves the +original cyclic predecessor before overwriting the current entry. It has +error at most u per output entry. Divide by s and round at W bits. Relative +to the original source, the resulting error is at most + + R <= F E/s + nF u/s + u. (2) + +Alternatively, the finite checker uses the sharper exact recurrence +R=E, then R=K_j R+u for j=n,...,1, then R=R/s+u. If R<2^(-w-1), rounding +each component to the original grid recovers the source exactly. The target +increment is independent of its initial value. The low W-w source bits +are explicit reserved zeros; their capacity is 2L(W-w) bits. Integer guards, +target widening and arithmetic workspace are also charged. + +For a fixed coarse-grid external shear, round the computed increment to +the original grid before its exact addition to the target. The resulting +function f(x) approximates Q(U)^-1 x, depends only on x, and gives the exact +grid bijection (x,y)->(x,y+f(x)). Subtracting the identical f(x) is its inverse. +All arrays then stay on the same coarse grid between calls. The separate +composition proof gives a fixed (w,W) budget for an entire prescribed word; +it does not require new low bits at every stage. + +## Explicit prime-power budgets + +Let r>=3 be a prime power, n=r-1, Dfield=phi(r), H=2^r-1 and +ell=ceil(log2 r), c=ceil(log2 n). To avoid overloading D, write the source +bound as D<=2^m with m>=0. PR621 supplies + + delta = 1/(2rn H^(n Dfield-1)), + |P(z)|>=delta on |z|=1, + ||P(U)^-1|| <= delta^-1 + 2nH/(r delta^2). + +Its absolutely summable Laurent-series argument applies to the isometry U +above, including varying unit phases. No phase table is constructed for +this norm argument. Put + + d=1+2ell+r n Dfield, delta>=2^-d, + a0=2d+r+2, ||P(U)^-1||<=2^a0, + g=d+ell+2r+2, beta=2^-g, + h=a0+2r, + e=max(d+1,a0+1,p+2a0+m+3), epsilon=2^-e, + b=max(n ell,e+r+3). + +As in PR628, approximate-factorization and exact coefficient verification +produce dyadic roots for Q=(1/r)product(z-rho_j) with ||P-Q||_1<=epsilon. +The first two e constraints imply |Q|>=delta/2 on the circle and +||Q(U)^-1||<=2^(a0+1). The last one gives + + D ||P(U)^-1-Q(U)^-1|| <= 2^(-p-2). + +Also ||Q||_1<=H/r+epsilon<=2^r. PR628's radial derivative argument applied +to Q supplies the stated stable margin beta for its inner or reciprocal +outer roots. Consequently the complementary-factor bound gives B<=2^h. +The forward product bound gives F<=2^v for v=3r+ell. + +Define + + J=c+2h+3g+ell+m+5, + W=J+max(p+2,w+v+3). (3) + +This W satisfies u<=beta^2/2 and t<=1/2. Since rBD+1<=2^(ell+h+m+1), +equation (1) yields E<=2^(J-W)<=2^(-p-2). Combining with coefficient +perturbation gives total inverse error <=2^(-p-1), leaving extra slack. +Since 2^J>=n+1, equation (2) gives + + R <= 2^(v+J+1-W) <= 2^(-w-2) < 2^(-w-1), + +which proves exact source recovery after coarse rounding. + +These are explicit integer exponent inequalities, not numerical fits. +Using Dfield<=r, ell<=r, c<=r and r>=3 gives the convenient bounds + + W <= max(p,w)+12r^3+m, + b <= p+6r^3+m. + +For example, J+v+3 <= 7r^3+35r+25+m <=12r^3+m. Likewise +e+r+3<=p+4r^3+11r+14+m<=p+6r^3+m, and n ell<=r^2. +Intermediate magnitude bits also have order O(r^3+m): exact prefixes are +bounded by rBD, scan closure state adds at most O(g) magnitude bits, and +forward subproducts add O(r) bits. A target additionally needs the bits +for its own initial magnitude. Bounds (3) concern fractional precision; +the complete word width includes these integer bits. + +## Preparation, phases, and scope + +The monic exact polynomial rP has coefficient norm <=H and logarithmic +root bound O(r). Pan's approximate-factorization bound, as stated in +Mehlhorn–Sagraloff–Wang, Theorem 2 and Corollary 1, applies at b>=n log n +with cost soft-O(nb+n^2 Gamma) and O(b+n Gamma) coefficient precision. +Here Gamma=O(r) and b=O(p+r^3+m). The same coefficient oracle and +conservative exact product verification from PR628 cost +soft-O(r^3(p+r^3+m)); the latter forms exact O(rb)-bit coefficients. +Repeated roots need not be individually isolated. This inherits the cited +algorithms; the finite fixture checker does not implement their worst-case +runtime. [Approximate-factorization source](https://arxiv.org/pdf/1301.4870), +PDF page 8. + +A supplied exact rational unit phase uses its actual numerator/denominator +length in scalar costs. For an approximate phase oracle, bound the induced +polynomial coefficient perturbation separately and allocate additional +slack by replacing p with p+O(1). Its required precision is O(p+r^3+m) +under the same bounded description assumptions as PR628. An arbitrarily +long phase description remains an extra input cost. + +The proof applies to any implementation of each factor with the stated +local error bound. The concrete in-place and restored-source schedule here +covers neighboring cyclic layouts only. PR846's clean-tape arbitrary-stride +solver has a compatible local bound and an additional depth admission +condition; extending the present tape claim would require retaining that +condition and its clean-scratch model. That solver is not part of this +package or its certified source-restoration claim. + +The cubic improvement comes from bounding intermediate inverse products, +not from improving PR621's circle lower bound. The full multiplication +assembly, common-label and Clifford interfaces, arbitrary dirty storage, +transform-level phase and normalization accounting remain separate. +No new kappa, practical timing improvement, or literature-priority claim +is made. + +## Executable evidence and attribution + +The exact verifier checks 5,220 integer budgets over all 116 prime-power +radices from 3 through 512, five target precisions, three source precisions +and three magnitude bounds. These support implementation of (3); the +inequalities above are the all-size proof. + +There are 120 kernel executions on ten pinned PR628 fixtures, with both +directions, varying exact rational unit phases and lengths 1,2,3,8,17,64. +Sixty executions compare every prefix to independent dense solves. All +120 check the expanded polynomial residual, pre-round recovery error, +exact coarse-grid restoration and total true-kernel error <=2^-128. +The finite tests use PR628's existing, conservative supplied inverse-norm +certificates; they do not claim that those finite certificates are tighter +than every previous finite execution budget. Six controls reject omitted +complement growth, insufficient target/recovery/coefficient precision, +nonshared shifts and lost prefix contraction. + +Credit Ali Romman for PR621, Chafik Boukhalfa for PR628, and the standard +Mahler-measure, cyclic-filtering and approximate-factorization methods. +This extension was prepared by Chafik Boukhalfa with substantial OpenAI +Codex assistance. The independent dense checker is a separate implementation, +not an independent human or delegated-agent review. Source pins are in +`SOURCE.json`. diff --git a/research/dirty-stride-precision/vendor/pr905/NOTICE.md b/research/dirty-stride-precision/vendor/pr905/NOTICE.md new file mode 100644 index 0000000000..03c791502e --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr905/NOTICE.md @@ -0,0 +1,36 @@ +# Attribution and scope + +New contribution by Chafik Boukhalfa (@chafreaky), prepared with substantial +OpenAI Codex assistance, under the repository's Apache-2.0 license. + +- Chafik Boukhalfa, PR628 at + `0768f97d06c623b8211e651543c66135796b62bf`: balanced dirty dispatcher, + exact grid restoration, rounded cyclic leaves, fixtures and preparation. + Original proof, source record and notice are retained under `vendor/628/`. +- Gareth Davidson (@bitplane), PR877 at + `80a60c0da2b916798167deb0ce3a5ef22fda147a`: the restored-child prefix audit, + inverse-prefix and nonlinear perturbation argument, quartic comparison, + independent word generator and dense prefix/inverse/interval checks. + Original source/proof/README/source pins are retained under `vendor/877/`. +- Chafik Boukhalfa, PR862 at + `57e0659150d323b784580110b36aa64a2dca2a33`: complementary-factor subset + bound, cubic coefficient preparation and precision analysis. Its + reserved-zero-bit recovery method is not used here. Its proof, budget, + source record and notice are retained under `vendor/862/`. +- Ali Romman (@aliromman), PR621: prime-power kernel, circle lower bound and + length-uniform Fourier inverse estimate. Its original proof and notice + are retained through PR862's pinned vendor bytes. +- 0xkilgore, PR663: exact balanced leaf count and nonlinear dirty restoration + audit. Androolloyd, PR673: related restoration/phase-alias audit. No source + from these two packages is imported directly. + +The free-algebra no-repeated-factor prefix induction and its application to +arbitrary-dirty cubic precision are the new contribution. Mahler measure, +variation of constants and the inherited approximate-factorization methods +are not claimed as new. The numerical checker follows the predecessor +boundary-monitor/oracle pattern while using the new bound and full-grid +arbitrary input words. Separate code paths are not independent human or +multi-agent review. No literature-priority, optimal-precision, full-theorem, +practical performance or new-kappa claim is made. + +All consumed files and original locations are pinned in `SOURCES.json`. diff --git a/research/dirty-stride-precision/vendor/pr905/PROOF.md b/research/dirty-stride-precision/vendor/pr905/PROOF.md new file mode 100644 index 0000000000..c3bd9e0a3d --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr905/PROOF.md @@ -0,0 +1,191 @@ +# Cubic precision for balanced cyclic inverses with arbitrary dirty arrays + +This is a local arithmetic result, not a new multiplication +exponent or a common-label/Clifford implementation. + +## 1. A free-algebra prefix lemma + +Let A_0,...,A_(n-1) be composable linear operators. Use exactly PR628's +balanced binary commutator word with distinct source, target and one dirty +connector at each recursion depth. At this point the A_j need not commute. +At complete leaf boundaries regard each instruction as the ideal shear +`target += sign A_j source`. Source rows and target columns of every +primitive prefix matrix are the corresponding identity row and column. +The same holds for its inverse. Other coordinates outside the current +subproblem are untouched. This follows directly because no leaf writes the +subproblem's source or reads its target. + +Every matrix entry of every prefix and inverse prefix is a noncommutative +polynomial in the A_j whose monomials have strictly decreasing indices. +In particular no factor occurrence is repeated. The sum of absolute integer +coefficients in any block row is at most + + C_n = 2 * 3^h, h = ceil(log2 n). + +Proof by induction on the balanced tree: the leaf assertion is immediate, +with coefficient row sum at most two. At an internal node let B be the full +left product and A the full right product. All indices of A exceed every +index of B. Write U for `z += B x`, V for `y += A z`. A prefix has the form +`R C`, where C consists of zero to three completed children and R is a +prefix inside the next child. Complete children restore all deeper scratch. +Their exact outer-coordinate states, with unchanged x, are: + +| Word | completed children k | z after C | y after C | active child | +|---|---:|---|---|---| +| positive U,V,U^-1,V^-1 | 0 | z | y | left | +| positive | 1 | z+Bx | y | right | +| positive | 2 | z+Bx | y+Az+ABx | left | +| positive | 3 | z | y+Az+ABx | right | +| negative V,U,V^-1,U^-1 | 0 | z | y | right | +| negative | 1 | z | y+Az | left | +| negative | 2 | z+Bx | y+Az | right | +| negative | 3 | z+Bx | y-ABx | left | + +Each C and C^-1 has coefficient block-row sum at most three. The last +boundary is the completed product shear and has row sum at most two. + +For an active left child, R's target column z is the identity column and +its source row x is the identity row. In R C, any Bx term already in z is +therefore added without another left factor; the y row is untouched by R. +In C^-1 R^-1, a nontrivial product can only prepend A to an expression from +the left child. For an active right child, R's target column y and source +row z are identities. In R C a nontrivial product can only append B to an +expression from the right child; in C^-1 R^-1 all A terms multiply the +identity source row. Inspection of the eight displayed cases includes the +AB terms, signs, and both inverse formulas. Thus all new products are +ordered concatenations of disjoint index sets. Addition and cancellation +cannot create another monomial. Coefficient row sums are submultiplicative, +so both R C and C^-1 R^-1 have row sum at most three times the child bound. +The balanced depth is h, proving the assertion for all n. + +Consequently, if EVERY ordered subset product of the A_j has operator +norm at most G>=1 (including the empty product), then every ideal prefix +P and its inverse have norm at most B=C_n G in the maximum joint-array +norm. Every interval propagator P_j P_i^-1 has norm at most B^2. This last +step need not have squarefree monomials; the two prefix bounds suffice. + +## 2. Common cyclic factors give a small subset bound + +Now let U be a unit-weighted permutation, hence an isometry in every integer +power, and let `product_j(z-rho_j) = r Q(z)` for n=r-1. All inverse factors +use this same U, direction, and immutable phases. PR628 puts scale r on +exactly one factor; all other factors have scale one. + +Suppose `||Q||_1<=M`, `||Q(U)^-1||<=H`. For any subset J, commutativity gives + + product_(j in J)(U-rho_j I)^-1 + = product_(j notin J)(U-rho_j I) Q(U)^-1 / r. + +The elementary Mahler-measure inequality +`product_j max(1,|rho_j|) <= ||r Q||_1 <= r M` implies that the complementary +polynomial has coefficient norm at most `2^n r M`. Thus every unscaled +subset inverse has norm at most `2^n M H`; a subset of the actual scaled +factors has norm at most + + G = max(1, r 2^n M H). + +This is PR862's complementary-factor argument, now applied to the free +prefix lemma, rather than to an in-place scan. There is no low-zero-bit +requirement. The factor r is paid even for subsets containing the scaled +leaf. The assertion is false in general for different noncommuting shifts; +the free-algebra lemma alone does not supply a small G. + +## 3. Rounded execution and exact dirty restoration + +At complete leaf boundaries the unchanged PR628 leaf has local error at +most `a u (||source||+1)`, where `a=13(r+1) beta^-3`, `u=2^-w`, and the +closure condition is `u<=beta^2/2`. All initial arrays, including borrowed +ones and target, have norm at most D. Leaves are deterministic target- +independent signed increments and restore their sources exactly. Immutable +phase and factor data must be disjoint from every mutable array. + +Let N be the actual paid leaf count, including all inverses and restoration: +`N=3 q n-2 q^2`, q=2^floor(log2 n), hence N<=2n^2. Let M_actual be the +largest computed joint norm at leaf boundaries. Variation of constants +inserts the actual, possibly nonlinear, errors into the ideal shear word. +With B=C_n G and t=N B^2 a u it gives + + M_actual <= B D + t(M_actual+1). + +If t<=1/2 then M_actual<=2 B D+1 and the complete execution error is at most + + 2 N B^2 a u (B D+1). + +This is the perturbation argument in PR877, with a different, smaller +prefix bound. It does not assume rounded children are linear or independent +of dirt. Their exact inverse identities still restore source and borrowed +arrays, and the negative whole word exactly cancels the positive whole +word on the same grid. Intermediate state inside a leaf retains PR628's +separate causal/closure bounds. + +## 4. Explicit cubic budgets + +For prime power r>=3, put n=r-1, ell=ceil(log2 r), h=ceil(log2 n), +phi=EulerPhi(r), and suppose D<=2^m, m>=0. Reuse the PR621/PR862 bounds + + d0 = 1+2ell+r n phi, + a0 = 2d0+r+2, + g = d0+ell+2r+2, + beta = 2^-g. + +The original kernel has inverse norm <=2^a0. Prepare the same dyadic-root +polynomial Q using coefficient error epsilon=2^-e, where + + e = max(d0+1, a0+1, p+2a0+m+4), + b = max(n ell, e+r+3). + +The common-isometry Neumann argument gives ||Q(U)^-1||<=2^(a0+1), +||Q||_1<=2^r and original-versus-prepared inverse error on the source at +most 2^(-p-3), in particular <=2^(-p-1). The inherited radial derivative +bound gives the leaf margin beta. As in PR862, these are supplied +approximate-factorization/coefficient-verification algorithms, not a claim +that the rational fixture executable implements their asymptotic runtime. + +Then the scaled subset bound is <=2^(a0+2r+ell). Put + + J = a0+2r+ell+1+2h, + Aerr = 3g+ceil(log2(13(r+1))), + w = max(w_input, Aerr, 2g+1, + p+3+ceil(log2 N)+Aerr+m+3J). + +Here 2^J>=B because 3^h<=2^(2h). The execution error is at most 2^(-p-1), +and closure and feedback smallness both hold. Combined preparation and +execution error is <=2^-p. No incoming grid is silently coarsened. + +Since phi<=r, ell,h<=r, and ceil(log2 N)<=1+2h, the precision overhead is +at most `9r^3-9r^2+48r+33 <=16r^3` for r>=3: the difference is +`(r-3)(7r^2+30r+42)+93`, which is positive. Thus + + w <= max(w_input,p) + m + 16r^3. + +Also b=O(p+m+r^3). Integer magnitude bits are O(m+r^3): the leaf-boundary +bound is 2BD+1 and the inherited internal leaf adds O(g+ell) bits. The +complete word size is therefore `max(w_input,p)+O(m+r^3)`. + +The neighboring-layout execution and preparation bill is + + soft-O((L r^2+r^3)(max(w_input,p)+m+r^3)). + +All N leaf calls, their three passes and validation/source access, inverse +work, scalar arithmetic, descriptors and routing remain paid. Borrowed +storage is ceil(log2 n) arbitrary dirty length-L arrays; no clean length-L +array and no reserved zero bits have been added. Phase-oracle or long exact +phase-description access is an additional charge. Arbitrary-stride routing +and the inherited arithmetic/preparation hypotheses remain as in PR628. + +## Scope and credit + +This proves a sufficient local precision bound for the existing balanced +classical arithmetic dispatcher. It does not prove minimum precision, +practical speed, bit-reversible arithmetic, a common-label or Clifford word, +physical owner layout, a full transform recurrence, a multiplication +reduction, or any change to kappa. A finite symbolic trace supports but does +not replace the all-size induction above. The general statement depends on +the inherited leaf and preparation lemmas. + +Credit Chafik Boukhalfa / chafreaky for PR628 and PR862, Gareth Davidson / +bitplane for PR877's restored-child prefix and nonlinear perturbation audit, +0xkilgore for PR663's exact leaf count and restoration audit, and the +original PR621 kernel lineage. This draft was prepared by Chafik Boukhalfa +with substantial OpenAI Codex assistance. No independent human review, +formal verification of the full theorem, or literature priority is claimed. diff --git a/research/dirty-stride-precision/vendor/pr977/NOTICE.md b/research/dirty-stride-precision/vendor/pr977/NOTICE.md new file mode 100644 index 0000000000..57939c758d --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr977/NOTICE.md @@ -0,0 +1,40 @@ +# Attribution and scope + +New effective-depth argument, cubic-stride integration and checks by Chafik +Boukhalfa (@chafreaky), with substantial OpenAI Codex assistance, under the +repository's Apache-2.0 license. No independent human/delegated-agent review +or literature-priority claim is made. + +- Rohan Guliani (@Rohansguliani), PR846, head + `4bdb3e755ea7118170a7a34764df955880dec282`: arbitrary-stride Euclidean + chain/closure solver, fixed-tape FIFO accounting, uniform error argument + and kernel integration. Its solver, checker, proof, source record and + notice are retained unchanged. `early.py` is an explicitly attributed + adaptation of its `solve` function, adding a charged exact-zero base case. +- Charles Bethin (@cbethin), PR764, head + `983d66f0f2e48ee500ec7eee2da9244c001c5064`: shared-suffix scan identity and + inverse-square error analysis, used through the retained PR846 proof. +- Chafik Boukhalfa, PR628, head + `0768f97d06c623b8211e651543c66135796b62bf`: root-factor certificates, + preparation/phase budgets and exact arithmetic. The five files retained + by PR846 remain byte-identical and independently hash-bound here. +- Chafik Boukhalfa, PR862, head + `57e0659150d323b784580110b36aa64a2dca2a33`: common-operator complement + bound and cubic preparation/execution precision. Its proof and notice + are retained unchanged. +- Ali Romman (@aliromman), PR621, head + `520774462b19b29af41554b74def31f9d01e997e`: prime-power kernel and its + uniform inverse bound, retained through the cited preparation lineage. + +Original notices retain the OpenAI exact-DFT manuscript, classical +Mahler/Wiener arguments, Pan factorization, fast elementary arithmetic, +and the standard queue-from-two-stacks attribution. Their credits and +licenses remain unchanged. Nearest-grid extinction and pointwise-zero +substitution are elementary; no priority claim is made for those ideas. + +The new result removes the stride solver's length-dependent precision +admission and combines its unchanged local error with PR862's cubic bound. +It does not replace the inherited preparation theorem with the finite root +fixtures or claim that the Python reference implements its asymptotic cost. +Clean scratch, phase access and all remaining transform/physical obligations +stay explicit. No new multiplication exponent is claimed. diff --git a/research/dirty-stride-precision/vendor/pr977/PROOF.md b/research/dirty-stride-precision/vendor/pr977/PROOF.md new file mode 100644 index 0000000000..6019f4d03f --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr977/PROOF.md @@ -0,0 +1,238 @@ +# An effective depth bound for the rounded stride solver + +This research argument extends PR846 at head +4bdb3e755ea7118170a7a34764df955880dec282. The original source is retained +unchanged in vendor/pr846/stride.py. Its clean scratch and sequential-tape model +remain unchanged. No borrowed-array, bit-reversible or kappa claim. + +Let beta=2^-g, g>=1, and let u=2^-W with W>=2g+8. Assume every input +coefficient has modulus at most 1-beta. Add one exact zero test at each +recursion level: when every coefficient is zero, return the data rounded +once. This solves that level exactly up to one rounding. Count the test as +one full coefficient scan and head return; traffic is at most 44L records instead of +the original conservative 40L. + +For the early-terminated solver, the number K of non-base levels is bounded independently of L by + + D(g,W)=2g+ceil(log2 W)+4. + +Consequently 4(K+1)u<=beta follows from W>=2g+8. This removes the original +p>=log2(log2 L+2) admission condition, after imposing this sufficient local +working-precision condition instead. + +## Decay of the rounded closure coefficients + +Write rho for the maximum coefficient modulus at a level. Every chain has +at least two coefficients. Its product is initialized with the first exact +coefficient and then rounded after each multiplication. For chain length +ell>=2, its magnitude is bounded by + + rho^ell+u*(1+rho+...+rho^(ell-2)) <= rho^2+u/(1-rho). + +Thus a scalar majorant for the next maximum is rho^2+u/(1-rho). + +First suppose beta<=m=1-rho<=1/2. Since u<=beta^2/16<=m^2/16, + + 1-rho_next >= m(2-m)-u/m >= (23/16)m > sqrt(2)m. + +Within at most 2g levels, the margin therefore reaches 1/2, unless recursion +has already terminated. While rho<=1/2, the majorant is rho^2+2u. +This stays below 1/2, and two further levels give rho<=1/4 (W>=10 is more +than sufficient for these elementary inequalities). + +While rho>2sqrt(u), the same majorant satisfies rho_next<=3rho^2/2. +For t=2rho, this implies t_next<=t^2, starting from t<=1/2. After at most +ceil(log2 W) additional levels, rho<=2sqrt(u): otherwise repeated squaring +would give rho<=2^(-2^j-1)<=u/2, a contradiction. + +One more level gives rho<=6u. At the following level the first multiplication +in every chain has modulus at most 36u^2=2g+8, ceil(log2 W)<=W-1 and 2g<=W-8, hence + + 4(D+1)<=8W-16. + +Also W-g>=ceil(W/2)+4 and 2^ceil(W/2)>=W for W>=4, so + + 2^(W-g)>=16W>4(D+1). + +This proves 4(K+1)u<=beta, and u<=beta/3 is automatic. PR846's margin, +weighted-data and shared-suffix error arguments now apply through at most +D levels. The new terminal system has exact solution x; rounding it once +has error at most u, matching the old terminal bound. Therefore the stated all-length error bound holds for both implementations, +with K equal to the truncated depth, or conservatively min(D,1/beta) in its +geometric error factor. The original structural depth is not used for admission. + +The algebraic source/input restoration properties are unchanged: this is +still a clean-tape solver with the input unmodified. The optional early-exit check adds at most 2 sum L_k<=4L coefficient records +to the original 40L traffic bound. Executing the unchanged implementation +needs no extra scan and retains 40L. +Any full-kernel composition must use a working precision satisfying both +its existing error target and W>=2g+8. That added local condition is O(g) +and preserves the previous polynomial-in-r precision order. + +## Cubic precision for the full kernel at arbitrary strides + +This section combines the local result above with PR862's retained +common-operator argument. The target is the same prime-power kernel +P(U), with U=tau Z_L^w and |tau|=1, as in PR846. All inverse factors use +this one operator. Different noncommuting shifts are outside the argument. + +A stride solve on input norm at most X has error at most + + (u/beta^2)(5+4X/beta)+u. + +After the outer scalar or inner unit rotation and its rounding, its error +is at most 7(X+1)u/beta^3 for beta<=1/2. This is exactly the local bound +required by PR862. Its proof only needs stable factors and that bound; +it does not require the neighboring-stride implementation. + +Let n=r-1, let Q=(1/r) product(z-rho_j), and suppose + + ||Q||_1<=M, ||Q(U)^-1||<=H, + B=max(1,2^n M H). + +The complementary-factor/Mahler argument in the retained PR862 proof +bounds every inverse prefix and contiguous inverse subproduct by B. +Starting with r x, ||x||<=D, the maximum prefix execution error E obeys + + E <= t(r B D+E+1), t=7nB beta^-3 u. + +For t<1 this yields E<=t(rBD+1)/(1-t). This does not repeatedly multiply +the worst reciprocal root margin at every factor. + +For prime-power r>=3 and p,m>=0, retain the source preparation hypotheses +and put + + ell=ceil(log2 r), c=ceil(log2(r-1)), phi=EulerPhi(r), + d=1+2ell+r(r-1)phi, a0=2d+r+2, + g=d+ell+2r+2, beta=2^-g, h=a0+2r, + e=max(d+1,a0+1,p+2a0+m+3), + b=max((r-1)ell,e+r+3). + +PR628/862's charged approximate factorization and coefficient verification +supply prepared roots with stable margin beta, ||Q||_1<=2^r, +||Q(U)^-1||<=2^(a0+1), and source-scaled kernel perturbation at most +2^(-p-2) for D<=2^m. Thus B<=2^h. These are certified premises, not +conclusions drawn merely from a numerical root list. + +Choose + + J=c+2h+3g+ell+m+5, W=p+J+2. + +This W exceeds 2g+8, so the stride admission holds for every L and every +stride. Moreover n<=2^c and 7<=2^3 imply + + t <= 2^(c+h+3+3g-W) <= 1/2, + rBD+1 <= 2^(ell+h+m+1), + E <= 2t(rBD+1) <= 2^(J-W)=2^(-p-2). + +Adding the independently charged kernel preparation perturbation gives +error at most 2^(-p-1), within the target 2^-p. Approximate phase oracles +still need their separately charged perturbation and access budget. + +A sufficient integer guard for data/state magnitudes is + + G=m+ell+h+g+8. + +Indeed each factor input is bounded by rBD+E. PR846's weighted-data +invariant bounds recursive data and closure values by O(rBD/beta); +its corresponding recursive rounding error is at most one under the +chosen W (h>=g). Chain values, products, scalar application and division +fit this guard. Exact arithmetic accumulators and numerator/denominator +products may use a constant-factor wider representation, as usual. + +Using phi<=r, ell<=r and c<=r gives the explicit cubic bounds + + W <= p+m+9r^3, G <= m+6r^3, b <= p+m+6r^3. + +The exact nonnegative remainders in t=r-3 are + +| Bound | Remainder after removing p and m as appropriate | +| --- | --- | +| 9r^3 minus the working overhead | 65t+25t^2+2t^3 | +| 6r^3 minus the integer guard overhead | 51+85t+30t^2+3t^3 | +| 6r^3 minus the factor-precision overhead | 43+67t+22t^2+2t^3 | + +For the final row, the alternative (r-1)ell<=r^2 also fits the cap. +`cubic.py` checks these coefficient identities and exact exponent +inequalities; it does not infer an all-size bound from sampled radices. + +If the incoming data have fractional width w, define the word scale +A=max(p,w)+2m+16r^3. With a supplied exact rational phase of representation +size B_tau, the one-kernel bill is + + soft-O(r^3(p+m+r^3)) + + O(rL) M(A+B_tau) + + O(rL(A+B_tau)). + +The terms are factor preparation/coefficient verification, rounded +execution, and sequential tape traffic. Here M is the cost of the charged +integer arithmetic; the Python reference is not a measured implementation +of asymptotically fast multiplication or factorization. Longer initial +coefficient/phase descriptions retain their actual input-reading cost. +Execution uses the inherited clean scratch tapes and O(L) data records; +there is no borrowed-array or bit-reversible realization claim. + +The original solver retains its 40L traffic bound per stable factor. +Exact inner rotations and scalar applications add their inherited O(L) +work. The optional zero-truncated solver has at most 44L per factor. +Neither bound has a sorting factor or a precision admission depending +on L. Transform-level layout, phase collection, normalization, common +labels and the multiplication reduction remain separate. + +## Evidence and attribution + +The checks compare 423 array cases exactly between the unchanged and +truncated solver, with independent geometric oracles for the short cases. +They include non-dyadic margins and four deeper arrays through L=5741. +Ninety scalar coefficient paths test exact extinction for gaps through +2^-256; they are not huge-array executions. + +All 300 original PR846 kernel cases pass using the uniform effective-depth +admission, with exact output equivalence and their original residual/dense +checks. An additional 64 executions at the actual cubic W cover radices +3/4/5/7, every stride at lengths 1/2/5, two unit phases, and arbitrary odd +lowest working bits. Roots are rounded to no more than the stated +preparation budget. Every common-operator hypothesis and the independent +kernel perturbation are checked before using the cubic budget. + +The source lineage is PR846 (Rohan Guliani), PR764 (Charles Bethin), PR628 +and PR862 (Chafik Boukhalfa), and PR621 (Ali Romman), together with their +retained classical references. This argument and its exact integration +checks do not claim independent human peer review or formal verification. +No new kappa is claimed. diff --git a/research/dirty-stride-precision/vendor/pr985/CLAIM.json b/research/dirty-stride-precision/vendor/pr985/CLAIM.json new file mode 100644 index 0000000000..aa3c3fdbfa --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/CLAIM.json @@ -0,0 +1,80 @@ +{ + "seed": 36, + "scope_override": "User explicitly selected the dirty-array solver remaining in PR846", + "base": "47481c89fd30a43f8f882eb4b391e89c29273fd0", + "head846": "4bdb3e755ea7118170a7a34764df955880dec282", + "track": "Complex supplier / explicit user-selected dirty recursive interface", + "candidates": [ + { + "object": "Direct cycle walk of PR628 dirty leaf", + "decision": "Not selected: known arbitrary-stride route does not remove sorting." + }, + { + "object": "Dirty two-stack FIFO for PR846", + "decision": "Not selected: requires a new storage and movement proof." + }, + { + "object": "Reuse the source prefix for the recursive closure target", + "decision": "Selected: two closure calls, no additional dirty array per leaf, exact restoration." + } + ], + "method": "Exact two-tape trace, independent geometric and dense rational oracles, complete restoration and precision checks, malformed-package controls.", + "deliverable": "One isolated research construction with executable solver, full recurrence, exact receipts, controls and scope limits.", + "finish": "2026-10-13 15:55 UTC", + "coordination": "No pinned sprint issue returned by GitHub GraphQL; claim is local.", + "overlap": [ + 628, + 744, + 764, + 805, + 846, + 862, + 877, + 905, + 929, + 951, + 977, + 982 + ], + "hypothesis": "Source-prefix reuse gives a dirty arbitrary-stride additive solver with O(L) rounded arithmetic, O(1) clean arithmetic registers and no extra dirty array; fixed-tape linearity is not assumed.", + "inspected_heads": { + "628": "0768f97d06c623b8211e651543c66135796b62bf", + "663": "e0e546fd01b396478c68b6b6c5a16d87515983ba", + "673": "0b4f514c60d9bc7786415d7cbc24754f24d6dc3b", + "744": "302383e0c1ec71c50860362d3f394f85664c2445", + "764": "983d66f0f2e48ee500ec7eee2da9244c001c5064", + "805": "ef34bd5b32fcf2d5640dae90b5b8f28488738d5a", + "846": "4bdb3e755ea7118170a7a34764df955880dec282", + "862": "57e0659150d323b784580110b36aa64a2dca2a33", + "877": "80a60c0da2b916798167deb0ce3a5ef22fda147a", + "905": "aab6c0b8f4574cb36285ab5dab3fcfad0cd2b69e", + "929": "85a1d11adbbd7610d269cfeb3e477cf7d457f2eb", + "951": "de0c8641dcf1a4cd0abde9b897fa946de2bede49", + "977": "2846af720af190cb75b45ebddbb0357dec1121ec", + "982": "5eca5b435d2ce172edf6ffb85694c7efa31bf114" + }, + "orientation_minutes": 14, + "coverage_rule": "Construct and prove the specified leaf. Exhaust the declared finite domains. No parameter search or optimality claim.", + "scope_limit": "Constant coefficients and supplied unit gauges only. No variable site phases, complete transform, physical supplier, or multiplication reduction.", + "evidence_driven_pivot": { + "initial": "The indexed source-prefix word restores correctly, but its direct movement is quadratic. The length-2378 stride-856 fixture needed 21388833 record moves before final head returns.", + "new_mechanism": "Use reversible block swaps with the dirty target as carrier, a causal conjugation for the seed expansion, and physical staging of child targets. Route all kernel arrays over two tapes.", + "preserved": "The first indexed implementation, proof, and receipts remain in the local research archive.", + "hypothesis": "The complete data movement obeys a two-child Euclidean recurrence and is linear in L." + }, + "overlap_refresh_max_pr": 983, + "status": "verified research construction; ready for submission", + "overlap_refresh_utc": "2026-10-13T15:50:23.096008+00:00", + "overlap_result": "PR977 improves the precision of PR846 and keeps its clean scratch tape model. PR982 borrows outputs for a fanout interface. Neither supplies the dirty arbitrary-stride leaf constructed here. PR951 remains a different clean-scalar and arithmetic contract.", + "submission_context": { + "kappa": "1661960547713947/1000000000000000000", + "certificate": "research/community-frontier942-audit/ASSEMBLY.json", + "certificate_sha256": "4b2894956e594e408e111d806c842f2ed2c32aefcadff93fad69ff0b46f1991a", + "review": "docs/research/community-batch952-review.md", + "reproduce": "make frontier942-verify", + "main": "407d52ff15b2217b6e22bce44728b4c3907b6515", + "note": "Context refresh only. The experimental base and source pins remain unchanged." + }, + "completed_at_utc": "2026-10-13T15:57:06.516658+00:00", + "result": "Dirty constant-coefficient inverse with source-prefix reuse and reversible transport on two tapes. Complete finite replay, exact restoration, ten package controls, and read-only receipt regeneration pass. No new kappa." +} diff --git a/research/dirty-stride-precision/vendor/pr985/EXPECTED.json b/research/dirty-stride-precision/vendor/pr985/EXPECTED.json new file mode 100644 index 0000000000..c429da6f81 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/EXPECTED.json @@ -0,0 +1,2386 @@ +{ + "controls": [ + { + "name": "source_target_alias", + "reason": "distinct equal arrays" + }, + { + "name": "insufficient_precision", + "reason": "precision admission" + }, + { + "name": "unit_coefficient", + "reason": "stable constant coefficient" + }, + { + "name": "off_grid_source", + "reason": "fixed grid data" + }, + { + "name": "ancestor_target_as_scratch", + "reason": "all arrays distinct" + }, + { + "name": "missing_dirty_level", + "reason": "dirty depth" + }, + { + "name": "nonunit_gauge", + "reason": "immutable unit gauge" + }, + { + "name": "late_unstable_factor", + "reason": "stable factor descriptor" + }, + { + "name": "fractional_stride", + "reason": "integer stride and sign" + }, + { + "name": "same_tape_operands", + "reason": "two distinct data tapes" + }, + { + "name": "unsupported_shift", + "reason": "output shift must be zero or the leaf stride" + }, + { + "changed_entries": 2, + "name": "target_dependence", + "reason": "L=3, stride=1, W=48" + } + ], + "costs": [ + { + "arithmetic_bound": 44, + "divisions": 1, + "length": 1, + "nodes": 1, + "power_products": 0, + "reads": 4, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 5, + "weighted_length": 1, + "writes": 1 + }, + { + "arithmetic_bound": 56, + "divisions": 2, + "length": 2, + "nodes": 1, + "power_products": 0, + "reads": 8, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 18, + "weighted_length": 2, + "writes": 2 + }, + { + "arithmetic_bound": 234, + "divisions": 2, + "length": 2, + "nodes": 3, + "power_products": 2, + "reads": 84, + "scalar_products": 10, + "stride": 1, + "two_tape_record_moves": 200, + "weighted_length": 4, + "writes": 68 + }, + { + "arithmetic_bound": 92, + "divisions": 5, + "length": 5, + "nodes": 1, + "power_products": 0, + "reads": 20, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 57, + "weighted_length": 5, + "writes": 5 + }, + { + "arithmetic_bound": 366, + "divisions": 2, + "length": 5, + "nodes": 3, + "power_products": 6, + "reads": 204, + "scalar_products": 28, + "stride": 1, + "two_tape_record_moves": 557, + "weighted_length": 7, + "writes": 161 + }, + { + "arithmetic_bound": 804, + "divisions": 4, + "length": 5, + "nodes": 7, + "power_products": 60, + "reads": 360, + "scalar_products": 44, + "stride": 2, + "two_tape_record_moves": 997, + "weighted_length": 13, + "writes": 299 + }, + { + "arithmetic_bound": 804, + "divisions": 4, + "length": 5, + "nodes": 7, + "power_products": 60, + "reads": 360, + "scalar_products": 44, + "stride": 3, + "two_tape_record_moves": 993, + "weighted_length": 13, + "writes": 299 + }, + { + "arithmetic_bound": 176, + "divisions": 12, + "length": 12, + "nodes": 1, + "power_products": 0, + "reads": 48, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 148, + "weighted_length": 12, + "writes": 12 + }, + { + "arithmetic_bound": 546, + "divisions": 2, + "length": 12, + "nodes": 3, + "power_products": 8, + "reads": 484, + "scalar_products": 70, + "stride": 1, + "two_tape_record_moves": 1390, + "weighted_length": 14, + "writes": 378 + }, + { + "arithmetic_bound": 408, + "divisions": 8, + "length": 12, + "nodes": 3, + "power_products": 4, + "reads": 496, + "scalar_products": 58, + "stride": 4, + "two_tape_record_moves": 1672, + "weighted_length": 20, + "writes": 396 + }, + { + "arithmetic_bound": 2298, + "divisions": 8, + "length": 12, + "nodes": 15, + "power_products": 304, + "reads": 1180, + "scalar_products": 142, + "stride": 5, + "two_tape_record_moves": 3600, + "weighted_length": 38, + "writes": 990 + }, + { + "arithmetic_bound": 444, + "divisions": 12, + "length": 12, + "nodes": 3, + "power_products": 2, + "reads": 504, + "scalar_products": 50, + "stride": 6, + "two_tape_record_moves": 1740, + "weighted_length": 24, + "writes": 408 + }, + { + "arithmetic_bound": 380, + "divisions": 29, + "length": 29, + "nodes": 1, + "power_products": 0, + "reads": 116, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 369, + "weighted_length": 29, + "writes": 29 + }, + { + "arithmetic_bound": 846, + "divisions": 2, + "length": 29, + "nodes": 3, + "power_products": 14, + "reads": 1164, + "scalar_products": 172, + "stride": 1, + "two_tape_record_moves": 3413, + "weighted_length": 31, + "writes": 905 + }, + { + "arithmetic_bound": 3054, + "divisions": 8, + "length": 29, + "nodes": 15, + "power_products": 408, + "reads": 2164, + "scalar_products": 276, + "stride": 9, + "two_tape_record_moves": 7079, + "weighted_length": 63, + "writes": 1781 + }, + { + "arithmetic_bound": 1684, + "divisions": 4, + "length": 29, + "nodes": 7, + "power_products": 76, + "reads": 1928, + "scalar_products": 252, + "stride": 10, + "two_tape_record_moves": 6301, + "weighted_length": 53, + "writes": 1571 + }, + { + "arithmetic_bound": 5992, + "divisions": 16, + "length": 29, + "nodes": 31, + "power_products": 960, + "reads": 3472, + "scalar_products": 412, + "stride": 12, + "two_tape_record_moves": 11237, + "weighted_length": 105, + "writes": 2927 + }, + { + "arithmetic_bound": 3162, + "divisions": 8, + "length": 29, + "nodes": 15, + "power_products": 392, + "reads": 2620, + "scalar_products": 324, + "stride": 13, + "two_tape_record_moves": 8753, + "weighted_length": 75, + "writes": 2177 + }, + { + "arithmetic_bound": 1756, + "divisions": 4, + "length": 29, + "nodes": 7, + "power_products": 76, + "reads": 2232, + "scalar_products": 284, + "stride": 14, + "two_tape_record_moves": 7361, + "weighted_length": 61, + "writes": 1835 + }, + { + "arithmetic_bound": 872, + "divisions": 70, + "length": 70, + "nodes": 1, + "power_products": 0, + "reads": 280, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 902, + "weighted_length": 70, + "writes": 70 + }, + { + "arithmetic_bound": 1530, + "divisions": 2, + "length": 70, + "nodes": 3, + "power_products": 16, + "reads": 2804, + "scalar_products": 418, + "stride": 1, + "two_tape_record_moves": 8292, + "weighted_length": 72, + "writes": 2176 + }, + { + "arithmetic_bound": 2858, + "divisions": 4, + "length": 70, + "nodes": 7, + "power_products": 96, + "reads": 4556, + "scalar_products": 602, + "stride": 23, + "two_tape_record_moves": 15396, + "weighted_length": 120, + "writes": 3700 + }, + { + "arithmetic_bound": 2366, + "divisions": 20, + "length": 70, + "nodes": 7, + "power_products": 68, + "reads": 4740, + "scalar_products": 586, + "stride": 25, + "two_tape_record_moves": 16834, + "weighted_length": 140, + "writes": 3880 + }, + { + "arithmetic_bound": 2520, + "divisions": 56, + "length": 70, + "nodes": 7, + "power_products": 60, + "reads": 5040, + "scalar_products": 538, + "stride": 28, + "two_tape_record_moves": 18274, + "weighted_length": 182, + "writes": 4186 + }, + { + "arithmetic_bound": 16842, + "divisions": 32, + "length": 70, + "nodes": 63, + "power_products": 2896, + "reads": 9628, + "scalar_products": 1130, + "stride": 29, + "two_tape_record_moves": 32378, + "weighted_length": 280, + "writes": 8140 + }, + { + "arithmetic_bound": 1662, + "divisions": 70, + "length": 70, + "nodes": 3, + "power_products": 2, + "reads": 2940, + "scalar_products": 282, + "stride": 35, + "two_tape_record_moves": 10672, + "weighted_length": 140, + "writes": 2380 + }, + { + "arithmetic_bound": 2060, + "divisions": 169, + "length": 169, + "nodes": 1, + "power_products": 0, + "reads": 676, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 2189, + "weighted_length": 169, + "writes": 169 + }, + { + "arithmetic_bound": 2814, + "divisions": 2, + "length": 169, + "nodes": 3, + "power_products": 20, + "reads": 6764, + "scalar_products": 1012, + "stride": 1, + "two_tape_record_moves": 20073, + "weighted_length": 171, + "writes": 5245 + }, + { + "arithmetic_bound": 4864, + "divisions": 4, + "length": 169, + "nodes": 7, + "power_products": 104, + "reads": 11024, + "scalar_products": 1460, + "stride": 56, + "two_tape_record_moves": 37605, + "weighted_length": 285, + "writes": 8947 + }, + { + "arithmetic_bound": 11944, + "divisions": 16, + "length": 169, + "nodes": 31, + "power_products": 1552, + "reads": 14544, + "scalar_products": 1828, + "stride": 60, + "two_tape_record_moves": 51025, + "weighted_length": 389, + "writes": 12019 + }, + { + "arithmetic_bound": 39580, + "divisions": 64, + "length": 169, + "nodes": 127, + "power_products": 7632, + "reads": 25736, + "scalar_products": 2996, + "stride": 70, + "two_tape_record_moves": 88825, + "weighted_length": 729, + "writes": 21799 + }, + { + "arithmetic_bound": 21846, + "divisions": 32, + "length": 169, + "nodes": 63, + "power_products": 3152, + "reads": 21188, + "scalar_products": 2524, + "stride": 71, + "two_tape_record_moves": 74461, + "weighted_length": 579, + "writes": 17809 + }, + { + "arithmetic_bound": 5368, + "divisions": 4, + "length": 169, + "nodes": 7, + "power_products": 88, + "reads": 13152, + "scalar_products": 1684, + "stride": 84, + "two_tape_record_moves": 44461, + "weighted_length": 341, + "writes": 10795 + }, + { + "arithmetic_bound": 4928, + "divisions": 408, + "length": 408, + "nodes": 1, + "power_products": 0, + "reads": 1632, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 5296, + "weighted_length": 408, + "writes": 408 + }, + { + "arithmetic_bound": 5778, + "divisions": 2, + "length": 408, + "nodes": 3, + "power_products": 22, + "reads": 16324, + "scalar_products": 2446, + "stride": 1, + "two_tape_record_moves": 48514, + "weighted_length": 410, + "writes": 12654 + }, + { + "arithmetic_bound": 7536, + "divisions": 272, + "length": 408, + "nodes": 3, + "power_products": 4, + "reads": 16864, + "scalar_products": 1906, + "stride": 136, + "two_tape_record_moves": 61204, + "weighted_length": 680, + "writes": 13464 + }, + { + "arithmetic_bound": 17116, + "divisions": 32, + "length": 408, + "nodes": 31, + "power_products": 1872, + "reads": 33256, + "scalar_products": 4190, + "stride": 146, + "two_tape_record_moves": 119324, + "weighted_length": 884, + "writes": 27396 + }, + { + "arithmetic_bound": 14640, + "divisions": 192, + "length": 408, + "nodes": 15, + "power_products": 312, + "reads": 40416, + "scalar_products": 4574, + "stride": 168, + "two_tape_record_moves": 149016, + "weighted_length": 1224, + "writes": 33816 + }, + { + "arithmetic_bound": 91458, + "divisions": 128, + "length": 408, + "nodes": 255, + "power_products": 20176, + "reads": 67116, + "scalar_products": 7766, + "stride": 169, + "two_tape_record_moves": 235916, + "weighted_length": 1866, + "writes": 56922 + }, + { + "arithmetic_bound": 8760, + "divisions": 408, + "length": 408, + "nodes": 3, + "power_products": 2, + "reads": 17136, + "scalar_products": 1634, + "stride": 204, + "two_tape_record_moves": 62724, + "weighted_length": 816, + "writes": 13872 + }, + { + "arithmetic_bound": 11852, + "divisions": 985, + "length": 985, + "nodes": 1, + "power_products": 0, + "reads": 3940, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 12797, + "weighted_length": 985, + "writes": 985 + }, + { + "arithmetic_bound": 12798, + "divisions": 2, + "length": 985, + "nodes": 3, + "power_products": 30, + "reads": 39404, + "scalar_products": 5908, + "stride": 1, + "two_tape_record_moves": 117177, + "weighted_length": 987, + "writes": 30541 + }, + { + "arithmetic_bound": 20000, + "divisions": 4, + "length": 985, + "nodes": 7, + "power_products": 124, + "reads": 64336, + "scalar_products": 8532, + "stride": 328, + "two_tape_record_moves": 220661, + "weighted_length": 1645, + "writes": 52195 + }, + { + "arithmetic_bound": 45804, + "divisions": 32, + "length": 985, + "nodes": 63, + "power_products": 3664, + "reads": 96616, + "scalar_products": 11924, + "stride": 354, + "two_tape_record_moves": 347085, + "weighted_length": 2521, + "writes": 80263 + }, + { + "arithmetic_bound": 208928, + "divisions": 256, + "length": 985, + "nodes": 511, + "power_products": 45136, + "reads": 172000, + "scalar_products": 19812, + "stride": 408, + "two_tape_record_moves": 612657, + "weighted_length": 4717, + "writes": 146011 + }, + { + "arithmetic_bound": 119538, + "divisions": 128, + "length": 985, + "nodes": 255, + "power_products": 21840, + "reads": 145068, + "scalar_products": 17004, + "stride": 409, + "two_tape_record_moves": 524085, + "weighted_length": 3887, + "writes": 122461 + }, + { + "arithmetic_bound": 22952, + "divisions": 4, + "length": 985, + "nodes": 7, + "power_products": 108, + "reads": 76800, + "scalar_products": 9844, + "stride": 492, + "two_tape_record_moves": 260701, + "weighted_length": 1973, + "writes": 63019 + }, + { + "arithmetic_bound": 28568, + "divisions": 2378, + "length": 2378, + "nodes": 1, + "power_products": 0, + "reads": 9512, + "scalar_products": 0, + "stride": 0, + "two_tape_record_moves": 30906, + "weighted_length": 2378, + "writes": 2378 + }, + { + "arithmetic_bound": 29706, + "divisions": 2, + "length": 2378, + "nodes": 3, + "power_products": 30, + "reads": 95124, + "scalar_products": 14266, + "stride": 1, + "two_tape_record_moves": 282944, + "weighted_length": 2380, + "writes": 73724 + }, + { + "arithmetic_bound": 45328, + "divisions": 8, + "length": 2378, + "nodes": 7, + "power_products": 120, + "reads": 155328, + "scalar_products": 20594, + "stride": 792, + "two_tape_record_moves": 552114, + "weighted_length": 3970, + "writes": 126014 + }, + { + "arithmetic_bound": 68752, + "divisions": 32, + "length": 2378, + "nodes": 31, + "power_products": 1488, + "reads": 217696, + "scalar_products": 27130, + "stride": 856, + "two_tape_record_moves": 790510, + "weighted_length": 5634, + "writes": 180206 + }, + { + "arithmetic_bound": 89584, + "divisions": 1312, + "length": 2378, + "nodes": 31, + "power_products": 960, + "reads": 284704, + "scalar_products": 31354, + "stride": 984, + "two_tape_record_moves": 1056218, + "weighted_length": 8610, + "writes": 240014 + }, + { + "arithmetic_bound": 506274, + "divisions": 512, + "length": 2378, + "nodes": 1023, + "power_products": 110416, + "reads": 435180, + "scalar_products": 49954, + "stride": 985, + "two_tape_record_moves": 1565454, + "weighted_length": 11812, + "writes": 369680 + }, + { + "arithmetic_bound": 50130, + "divisions": 2378, + "length": 2378, + "nodes": 3, + "power_products": 2, + "reads": 99876, + "scalar_products": 9514, + "stride": 1189, + "two_tape_record_moves": 366104, + "weighted_length": 4756, + "writes": 80852 + } + ], + "generic": { + "cases": 3456, + "lengths": [ + 1, + 24 + ], + "max_squared_error_ratio_log2_upper": -22, + "nonzero_errors": 3456, + "output_digest": "834a0a2523f97d36c75cc7e264445b228b4d2928d10219824442d3c234aceea4", + "output_shifts": "zero and stride modulo L; duplicates removed", + "strides": "every integer in [-L,L)" + }, + "geometry": { + "cases": 8256, + "lengths": [ + 1, + 128 + ], + "levels": 29642 + }, + "kernels": [ + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -381, + "execution_bound": "1005333662539757423464078520558824699400496353384701542767953057/4479489484355608421114884561136888556243290994469299069799978201927583742360321890761754986543214231552", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 4, + "length": 1, + "nonzero_error": true, + "output_digest": "a65f5dbb7f8d8d382ca18e7abda784c31503d3098a0cd4975831f3b57ed36e65", + "peak_l1_log2_upper": 2, + "radix": 3, + "stride": 0, + "tape_bound": 122880, + "two_tape_record_moves": 29 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -377, + "execution_bound": "1005333662539757423464078520558824699400496353384701542767953057/4479489484355608421114884561136888556243290994469299069799978201927583742360321890761754986543214231552", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 4, + "length": 1, + "nonzero_error": true, + "output_digest": "9069b495b347a19a9023d438f8aa1b1cc40bb8938c5efd4566aabab550723416", + "peak_l1_log2_upper": 3, + "radix": 3, + "stride": 0, + "tape_bound": 122880, + "two_tape_record_moves": 29 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -373, + "execution_bound": "1005333662539757423464078520558824699400496353384701542767953057/4479489484355608421114884561136888556243290994469299069799978201927583742360321890761754986543214231552", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 4, + "length": 3, + "nonzero_error": true, + "output_digest": "3d72258176db96c8756382031b1b93b019df53f53dc52c35d3725d2fa99775c6", + "peak_l1_log2_upper": 4, + "radix": 3, + "stride": 1, + "tape_bound": 368640, + "two_tape_record_moves": 1311 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -377, + "execution_bound": "1005333662539757423464078520558824699400496353384701542767953057/4479489484355608421114884561136888556243290994469299069799978201927583742360321890761754986543214231552", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 4, + "length": 3, + "nonzero_error": true, + "output_digest": "476dbc3919c1f09fc9cdbddcb966fe6c75ceeef8a62b79f9fff206cad45eb6e0", + "peak_l1_log2_upper": 4, + "radix": 3, + "stride": 1, + "tape_bound": 368640, + "two_tape_record_moves": 1311 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -373, + "execution_bound": "94001551/365375409332725729550921208179070754913983135744", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 4, + "length": 5, + "nonzero_error": true, + "output_digest": "4bc53e184b6dc2e6c3f8cbe31be5d9d834ced6778b6e6b56c7259843b6c7049b", + "peak_l1_log2_upper": 4, + "radix": 3, + "stride": 2, + "tape_bound": 614400, + "two_tape_record_moves": 4049 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -372, + "execution_bound": "94001551/365375409332725729550921208179070754913983135744", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 4, + "length": 5, + "nonzero_error": true, + "output_digest": "b11bcf475ad412b1dc295eee62dff1b54e01c9e7f033f6d2bcab836f829a04c2", + "peak_l1_log2_upper": 5, + "radix": 3, + "stride": 2, + "tape_bound": 614400, + "two_tape_record_moves": 4049 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -374, + "execution_bound": "94001551/365375409332725729550921208179070754913983135744", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 4, + "length": 5, + "nonzero_error": true, + "output_digest": "a143eb38e43f27283ea9ee6367fea6ecfe9439d2e4fda9926f1c9316451d90e2", + "peak_l1_log2_upper": 4, + "radix": 3, + "stride": -2, + "tape_bound": 614400, + "two_tape_record_moves": 4033 + }, + { + "bits": 188, + "borrowed_arrays": 1, + "embedding": 1, + "error_squared_log2_upper": -373, + "execution_bound": "94001551/365375409332725729550921208179070754913983135744", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 4, + "length": 5, + "nonzero_error": true, + "output_digest": "b6142217726335649e8c4881d6d05f9d272e9ba02e31db12488e8d089803365f", + "peak_l1_log2_upper": 4, + "radix": 3, + "stride": -2, + "tape_bound": 614400, + "two_tape_record_moves": 4033 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -482, + "execution_bound": "39854005211390988476233872306630921220068367192772867543243645919477133945177142156103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 10, + "length": 1, + "nonzero_error": true, + "output_digest": "977f33cbd0ca0a3f0dce1db3d1d5e240aae09e869b4b788c551e2deec60326c6", + "peak_l1_log2_upper": 3, + "radix": 4, + "stride": 0, + "tape_bound": 360448, + "two_tape_record_moves": 104 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -483, + "execution_bound": "39854005211390988476233872306630921220068367192772867543243645919477133945177142156103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 10, + "length": 1, + "nonzero_error": true, + "output_digest": "02ada6cd834d32dc075051ae7ca4850b378660d910b0d40c263d3c9dd031aa89", + "peak_l1_log2_upper": 4, + "radix": 4, + "stride": 0, + "tape_bound": 360448, + "two_tape_record_moves": 104 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -482, + "execution_bound": "41798103026580792792147719736222673474705848519249592789255531086280896576219804556103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 10, + "length": 3, + "nonzero_error": true, + "output_digest": "db8bdbcfe39b4f689c402cfa3d9e5bc562b05ee1d25ac94a0d2304d6effbae46", + "peak_l1_log2_upper": 4, + "radix": 4, + "stride": 1, + "tape_bound": 1081344, + "two_tape_record_moves": 3392 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -480, + "execution_bound": "41798103026580792792147719736222673474705848519249592789255531086280896576219804556103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 10, + "length": 3, + "nonzero_error": true, + "output_digest": "d1d3a6bc2362eddc47d454fa7cf108b6912b03647a1477ca3308c3a71b8042b6", + "peak_l1_log2_upper": 4, + "radix": 4, + "stride": 1, + "tape_bound": 1081344, + "two_tape_record_moves": 3392 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -478, + "execution_bound": "47630396472150205739889262024997930238618292498679768527291186586692184469347791756103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 10, + "length": 5, + "nonzero_error": true, + "output_digest": "81a40472cf09f80fc24566a19dadefdf4b4585e3a4d59cadb66f724f66ed6291", + "peak_l1_log2_upper": 6, + "radix": 4, + "stride": 2, + "tape_bound": 1802240, + "two_tape_record_moves": 10320 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -478, + "execution_bound": "47630396472150205739889262024997930238618292498679768527291186586692184469347791756103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 10, + "length": 5, + "nonzero_error": true, + "output_digest": "69ca0c9972ac137cc966046b7934d70be45e3e98b3ce16a4e76df595d7aba6df", + "peak_l1_log2_upper": 4, + "radix": 4, + "stride": 2, + "tape_bound": 1802240, + "two_tape_record_moves": 10320 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -478, + "execution_bound": "47630396472150205739889262024997930238618292498679768527291186586692184469347791756103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 10, + "length": 5, + "nonzero_error": true, + "output_digest": "a0176c55d6b3062b8cfd52d99e5e83a4f9330cd96ef252c1a9800e2fd9b59450", + "peak_l1_log2_upper": 5, + "radix": 4, + "stride": -2, + "tape_bound": 1802240, + "two_tape_record_moves": 10280 + }, + { + "bits": 241, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -477, + "execution_bound": "47630396472150205739889262024997930238618292498679768527291186586692184469347791756103515625/45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788416", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 10, + "length": 5, + "nonzero_error": true, + "output_digest": "f71af497d2b771ea7ac86c5ae1ce195e23c2e439902953c62d094c09e41172c9", + "peak_l1_log2_upper": 5, + "radix": 4, + "stride": -2, + "tape_bound": 1802240, + "two_tape_record_moves": 10280 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -621, + "execution_bound": "86270209988398327916270568269429561091683790200437570076148852268545721703121489554279330030455691146814000551842462091241204307/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 16, + "length": 1, + "nonzero_error": true, + "output_digest": "c97aba772e790ca9c09fe2a90c44ebef2a50daeba5f841ef0edacd584f29d9e1", + "peak_l1_log2_upper": 3, + "radix": 5, + "stride": 0, + "tape_bound": 557056, + "two_tape_record_moves": 128 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -621, + "execution_bound": "86270209988398327916270568269429561091683790200437570076148852268545721703121489554279330030455691146814000551842462091241204307/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 16, + "length": 1, + "nonzero_error": true, + "output_digest": "162ede919b6817add8c72c5264762ad77961a32a5cf2760d88d89e2ff0aaeca0", + "peak_l1_log2_upper": 5, + "radix": 5, + "stride": 0, + "tape_bound": 557056, + "two_tape_record_moves": 128 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -612, + "execution_bound": "90478512914661660985356937453304173827863487283385744226204893842621122761810342703268565641694282947817837068279413058923014739/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 16, + "length": 3, + "nonzero_error": true, + "output_digest": "f4d3de3a857d5b2d94638c027bd91673172ee26b1abaaa116af42b7f6764a294", + "peak_l1_log2_upper": 5, + "radix": 5, + "stride": 1, + "tape_bound": 1671168, + "two_tape_record_moves": 5256 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -615, + "execution_bound": "90478512914661660985356937453304173827863487283385744226204893842621122761810342703268565641694282947817837068279413058923014739/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 16, + "length": 3, + "nonzero_error": true, + "output_digest": "9a93c16cf7a8d0f8f84430ebeb7e36fb760d5ee95bb004c5f2d7189487358d39", + "peak_l1_log2_upper": 4, + "radix": 5, + "stride": 1, + "tape_bound": 1671168, + "two_tape_record_moves": 5256 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -607, + "execution_bound": "103103421693451660192616045004928012036402578532230266676373018564847325937876902150236272475410058350829346617590265961968446035/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 16, + "length": 5, + "nonzero_error": true, + "output_digest": "0a56ebb6aa3d92e5c04c5db3ffba630c9d27a49062cb992bf53736af3e9ae0bb", + "peak_l1_log2_upper": 7, + "radix": 5, + "stride": 2, + "tape_bound": 2785280, + "two_tape_record_moves": 16208 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -612, + "execution_bound": "103103421693451660192616045004928012036402578532230266676373018564847325937876902150236272475410058350829346617590265961968446035/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 16, + "length": 5, + "nonzero_error": true, + "output_digest": "6a1c64f50d8735b0069552ea5b58c9cff9c434f1dfe556917beb82d95745e7aa", + "peak_l1_log2_upper": 5, + "radix": 5, + "stride": 2, + "tape_bound": 2785280, + "two_tape_record_moves": 16208 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -607, + "execution_bound": "103103421693451660192616045004928012036402578532230266676373018564847325937876902150236272475410058350829346617590265961968446035/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 16, + "length": 5, + "nonzero_error": true, + "output_digest": "e0042da1fbdd47e511cc9113f57f2fad5539c2f46b8bc6733b0adf9fd7daff3f", + "peak_l1_log2_upper": 7, + "radix": 5, + "stride": -2, + "tape_bound": 2785280, + "two_tape_record_moves": 16144 + }, + { + "bits": 309, + "borrowed_arrays": 2, + "embedding": 1, + "error_squared_log2_upper": -613, + "execution_bound": "103103421693451660192616045004928012036402578532230266676373018564847325937876902150236272475410058350829346617590265961968446035/120766797594289323271729746591624604509341479053326093708038601607859973196548763266756055205685080561326988000984443036792658708157593364241965896045846273396780650463232", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 16, + "length": 5, + "nonzero_error": true, + "output_digest": "fa5d9d110967ac62538761acb7093fab5305db5e0ba38698573081cb0db60221", + "peak_l1_log2_upper": 6, + "radix": 5, + "stride": -2, + "tape_bound": 2785280, + "two_tape_record_moves": 16144 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1317, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 40, + "length": 1, + "nonzero_error": true, + "output_digest": "c2f2ad5947cd21dedaaab8a3f76b10a3adf1ccfb186e2f0b74b11fb1dd595405", + "peak_l1_log2_upper": 4, + "radix": 7, + "stride": 0, + "tape_bound": 1679360, + "two_tape_record_moves": 479 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1317, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 40, + "length": 1, + "nonzero_error": true, + "output_digest": "a4590f0e9d8209538c57e0ef5fc450252041144190fb55eec52df812ddab7a74", + "peak_l1_log2_upper": 8, + "radix": 7, + "stride": 0, + "tape_bound": 1679360, + "two_tape_record_moves": 479 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1313, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 40, + "length": 3, + "nonzero_error": true, + "output_digest": "e1de792d7db58c670932feffa7f49091204ad88eb77e4fe91d5246689b4868ff", + "peak_l1_log2_upper": 6, + "radix": 7, + "stride": 1, + "tape_bound": 5038080, + "two_tape_record_moves": 13733 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1309, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 40, + "length": 3, + "nonzero_error": true, + "output_digest": "01a4780f17bae5dfa8696bf83e187fafbeff2c77077b5bf7f3aad869574063c6", + "peak_l1_log2_upper": 7, + "radix": 7, + "stride": 1, + "tape_bound": 5038080, + "two_tape_record_moves": 13733 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1312, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 40, + "length": 5, + "nonzero_error": true, + "output_digest": "11b706c8c1942a6cf918d58cb6186201db208052dfed42373781066a62692732", + "peak_l1_log2_upper": 7, + "radix": 7, + "stride": 2, + "tape_bound": 8396800, + "two_tape_record_moves": 41547 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1308, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 40, + "length": 5, + "nonzero_error": true, + "output_digest": "608eb517700b475b5c1f1c3e5ab35efbcc2e8f936c7151500c4c7b3e1d840cea", + "peak_l1_log2_upper": 8, + "radix": 7, + "stride": 2, + "tape_bound": 8396800, + "two_tape_record_moves": 41547 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1312, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 40, + "length": 5, + "nonzero_error": true, + "output_digest": "c8f2647b4976adc5847a3bf6e88f1350581118688dee8124a73a7805cede70fa", + "peak_l1_log2_upper": 7, + "radix": 7, + "stride": -2, + "tape_bound": 8396800, + "two_tape_record_moves": 41387 + }, + { + "bits": 659, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -1308, + "execution_bound": "2513260808663837653083422361027386210737049031074014979019007173243825171829940093167111957947796772734788514024560998802479968561536252705330314968763859583005876407345281371298349898140155352869068600176952615149343363500435738285673838506339801443977105824128143363671954696080831118021658923584924039212746676373261246506325/577756298062692634882899796320514825754569701436275375467883216895815138273904148947370775875738379270397749529435460924064103319004651876830131274380548720588597872393444873405265091429549226291371123473288851713585905064826579939194634093737504859185768962010552087157267774632410684258267121287728707126733386345748295699714571521040271552753678267463143641875218432", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 40, + "length": 5, + "nonzero_error": true, + "output_digest": "333dd6bc9f56558b44b28935350a8c970dab0efa0e1add4b46f531364ae103ab", + "peak_l1_log2_upper": 8, + "radix": 7, + "stride": -2, + "tape_bound": 8396800, + "two_tape_record_moves": 41387 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2157, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 52, + "length": 1, + "nonzero_error": true, + "output_digest": "5746f3f9cf3736aae1f085e91470ef5b2a303dfd99ff2bace64312556d1aae64", + "peak_l1_log2_upper": 4, + "radix": 8, + "stride": 0, + "tape_bound": 2170880, + "two_tape_record_moves": 549 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2158, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 52, + "length": 1, + "nonzero_error": true, + "output_digest": "e72d8675c5aac5a13a7ada3ac0cc2a5e6dc0a6ddaa3d47cb16b6bfb742fa67f3", + "peak_l1_log2_upper": 7, + "radix": 8, + "stride": 0, + "tape_bound": 2170880, + "two_tape_record_moves": 549 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2150, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 52, + "length": 3, + "nonzero_error": true, + "output_digest": "d92c4a2559de9aaa12ea28198f8295f56d30d6cde977e56817f95a5dad6803b7", + "peak_l1_log2_upper": 7, + "radix": 8, + "stride": 1, + "tape_bound": 6512640, + "two_tape_record_moves": 17527 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2151, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 52, + "length": 3, + "nonzero_error": true, + "output_digest": "87ff9498658a87d403746ae86fa74407e7b78692880abdf31fdbcbf4f948c88d", + "peak_l1_log2_upper": 6, + "radix": 8, + "stride": 1, + "tape_bound": 6512640, + "two_tape_record_moves": 17527 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2148, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 52, + "length": 5, + "nonzero_error": true, + "output_digest": "eb6fce9c389811c5d3cc92ffd573ad423a23b7cd83fd6c8b5bcc829787cf7e9f", + "peak_l1_log2_upper": 8, + "radix": 8, + "stride": 2, + "tape_bound": 10854400, + "two_tape_record_moves": 53433 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2150, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 52, + "length": 5, + "nonzero_error": true, + "output_digest": "a3d8510dc374c924ec22511c37e137e9220843e618844309124d4a70210f0ade", + "peak_l1_log2_upper": 8, + "radix": 8, + "stride": 2, + "tape_bound": 10854400, + "two_tape_record_moves": 53433 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2148, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 52, + "length": 5, + "nonzero_error": true, + "output_digest": "4f5678d008f3d3eb178b316baf6b4949da1592dbd040357ac2e7670875812b20", + "peak_l1_log2_upper": 8, + "radix": 8, + "stride": -2, + "tape_bound": 10854400, + "two_tape_record_moves": 53225 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2148, + "execution_bound": "3990643289625379951801622460698542058651064531131187958953115782508523082790045139663808776613317025057708253773628673454200736652066794096515352730644522893220957310763498420396049039386147368309280817191047612958869967318832421483399716396731951346918773504801632190085395008320378676963296387791275654461151957603139552806035622439699384355514479016149130211443519537003947731995022155477454418653689684263593241135456773238462447163272480799422829094118839896435318605988591776955151602769780517162995653359120506250689217650810221480157290561550799570885/15779788120757327783552185883139624980685597006697013687563645228283523017025337350193946001720172589691756816856395517331113065991450645065961011907445450742495545589502439497924901245307447317771512518742220492322652450509091677813397507001209067612588694263689602071722449165791536039359156444884731633555622233100423995322600085345002231198660242204749180692420803544595227633158427887768680953546961482776339650253155203787889819898584788039259617975211566030872619963237705180529861866077603185287928975869461278288596678353687987616316174397651092448995899480192006642893221913381324291110134694146025193472", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 52, + "length": 5, + "nonzero_error": true, + "output_digest": "0412934eddf4836552b7076744075cfc9af13160171fb9d969a6b025ca6998a7", + "peak_l1_log2_upper": 8, + "radix": 8, + "stride": -2, + "tape_bound": 10854400, + "two_tape_record_moves": 53225 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2159, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 1, + "nonzero_error": true, + "output_digest": "a2bf300eb35789cbd5743d5db4178b68ea31d73836f65582cf7f48f1e6a761d9", + "peak_l1_log2_upper": 4, + "radix": 9, + "stride": 0, + "tape_bound": 2662400, + "two_tape_record_moves": 603 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2156, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 1, + "nonzero_error": true, + "output_digest": "d65dd3d3e2b7fdddbde462a010c3e477d41747784a27abc380184e53204f1334", + "peak_l1_log2_upper": 5, + "radix": 9, + "stride": 0, + "tape_bound": 2662400, + "two_tape_record_moves": 603 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2149, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 3, + "nonzero_error": true, + "output_digest": "29313e59aa79229ed7f8bd0bb5bd6e9e804f3a0f5c4b20510688dafa52cdaf65", + "peak_l1_log2_upper": 6, + "radix": 9, + "stride": 1, + "tape_bound": 7987200, + "two_tape_record_moves": 21321 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2152, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 3, + "nonzero_error": true, + "output_digest": "df6d9d83d28d2009f7c3e1d997fdb4f1c5829bcb1fafa501e0b0ee11afb572b1", + "peak_l1_log2_upper": 5, + "radix": 9, + "stride": 1, + "tape_bound": 7987200, + "two_tape_record_moves": 21321 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2145, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "1dc66e76ab068ce434c068b7704d46d003f6ba9b4a69f2ae51259350784ee2c2", + "peak_l1_log2_upper": 8, + "radix": 9, + "stride": 2, + "tape_bound": 13312000, + "two_tape_record_moves": 65559 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2150, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "77110c0ed5b473bbf5e9ed00f2186bb4fec5cb45477f6f92de31ba3897be32e7", + "peak_l1_log2_upper": 7, + "radix": 9, + "stride": 2, + "tape_bound": 13312000, + "two_tape_record_moves": 65559 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2145, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "3ac865db8cd814d43f4f6f5579e16edd32f8d9a65735bde8cc52e4dafb703d01", + "peak_l1_log2_upper": 8, + "radix": 9, + "stride": -2, + "tape_bound": 13312000, + "two_tape_record_moves": 65367 + }, + { + "bits": 1079, + "borrowed_arrays": 3, + "embedding": 1, + "error_squared_log2_upper": -2154, + "execution_bound": "562894566815557176236291890289055304928573987307303262130899845909434045777698958109583880003369567519880466065757176730812752336454684674580143608603080662464799777794745037305292665977117703292985467898609956311029349447289935011200977471114447425433088599950168436089755686740522327739179817430290739972010212355202143483485399251656778622367054787803158156759754281270019519823427071186263455972837176591464147564096046392896594525137456086908154550040950651934348536035182468167392886106080274201689360244370658649403844691283970979426875270247643645525/3944947030189331945888046470784906245171399251674253421890911307070880754256334337548486500430043147422939204214098879332778266497862661266490252976861362685623886397375609874481225311326861829442878129685555123080663112627272919453349376750302266903147173565922400517930612291447884009839789111221182908388905558275105998830650021336250557799665060551187295173105200886148806908289606971942170238386740370694084912563288800946972454974646197009814904493802891507718154990809426295132465466519400796321982243967365319572149169588421996904079043599412773112248974870048001660723305478345331072777533673536506298368", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "35f46e422ed6483e4e832bca6edc10b91c26748e8cde5f488bcd684190937405", + "peak_l1_log2_upper": 7, + "radix": 9, + "stride": -2, + "tape_bound": 13312000, + "two_tape_record_moves": 65367 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1749, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 1, + "nonzero_error": true, + "output_digest": "e81c698c89f2b3025fbbea8cf04e74ec15234eac6ae8c0c5d1c56c6ba7582c8d", + "peak_l1_log2_upper": 5, + "radix": 9, + "stride": 0, + "tape_bound": 2662400, + "two_tape_record_moves": 603 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1751, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 1, + "nonzero_error": true, + "output_digest": "086c1a4037511d47b357e82ba55d6b404caa737ecb9632c438bcc0cd08c5eac3", + "peak_l1_log2_upper": 7, + "radix": 9, + "stride": 0, + "tape_bound": 2662400, + "two_tape_record_moves": 603 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1743, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 3, + "nonzero_error": true, + "output_digest": "80ea9681a0b912daa456de66f43752113fab9a93a97b78882a2a4e8f7d467509", + "peak_l1_log2_upper": 6, + "radix": 9, + "stride": 1, + "tape_bound": 7987200, + "two_tape_record_moves": 21273 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1742, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 3, + "nonzero_error": true, + "output_digest": "f580ec18b82a8774b98650b306ea411c147f96b9a7b3c1cf1c25d0c828171614", + "peak_l1_log2_upper": 6, + "radix": 9, + "stride": 1, + "tape_bound": 7987200, + "two_tape_record_moves": 21273 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1739, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "203795747581c8782d8bb7a7659ec586886cf002a30b85ef0be2cfa2f1a373ed", + "peak_l1_log2_upper": 8, + "radix": 9, + "stride": 2, + "tape_bound": 13312000, + "two_tape_record_moves": 65239 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1741, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "eb3143c87246fe095743201ffc6a5e19ad1ae333a1a3588aab5d578bc0aafa01", + "peak_l1_log2_upper": 7, + "radix": 9, + "stride": 2, + "tape_bound": 13312000, + "two_tape_record_moves": 65239 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1739, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "b3521d2bffe52645070e7835fdbdc1ec0a181f3176be2af182a3a2665a75e625", + "peak_l1_log2_upper": 9, + "radix": 9, + "stride": -2, + "tape_bound": 13312000, + "two_tape_record_moves": 64983 + }, + { + "bits": 875, + "borrowed_arrays": 3, + "embedding": 2, + "error_squared_log2_upper": -1741, + "execution_bound": "30701638821779788103514129246107908208269999828841722290741408898379785477971648165748335414871434513169169690936943940234660101479206924113983579970327606981276347884795701753475254717899061744422573069889313674390673739768450679003673636478488391047891010296227563092796464739274518192998696448898807473932668597553031785438981614103335702080500187639288967272939295661448323739019348593691587793510148740400522949293580972885803717583125/195547775662336465673561050502666118201918492341643811759108265916522506920148372619350853024089935313516893094581096147257537338874132866617972821686108989356215452403601690028005660644754421918651185140323193136909752470810989908379987037493152726497401000584522635683600028033091471085759227126208725663108375841888546479802707314930017492979087571033711158619825344637684181080987786542971490893184721514938212120802172063286820466572632483836745146378654102629458762216037403914811006255104", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 64, + "length": 5, + "nonzero_error": true, + "output_digest": "46117d868f38fe7238c7ac9803191fc3999923249a660ee2b18165c2dc4ce68c", + "peak_l1_log2_upper": 7, + "radix": 9, + "stride": -2, + "tape_bound": 13312000, + "two_tape_record_moves": 64983 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3506, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 112, + "length": 1, + "nonzero_error": true, + "output_digest": "72153ee4fa25205e9238685943d2d387aa852da373a8960d61136cf77e0b57c4", + "peak_l1_log2_upper": 6, + "radix": 11, + "stride": 0, + "tape_bound": 5554176, + "two_tape_record_moves": 1762 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3500, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 112, + "length": 1, + "nonzero_error": true, + "output_digest": "0c1c8324c0c45fb22fc3ce98244a014362347ae9b334f0c4ad8e8584a79c7273", + "peak_l1_log2_upper": 6, + "radix": 11, + "stride": 0, + "tape_bound": 5554176, + "two_tape_record_moves": 1762 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3498, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 112, + "length": 3, + "nonzero_error": true, + "output_digest": "11c283604bce003a7f9e9f3a57d3a42643679e0f72090ce257760524737b5d2d", + "peak_l1_log2_upper": 7, + "radix": 11, + "stride": 1, + "tape_bound": 16662528, + "two_tape_record_moves": 40126 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3498, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 112, + "length": 3, + "nonzero_error": true, + "output_digest": "7a4ef304252176181afca0a2f6486d51115407299513c6c29006ee47391b8d7b", + "peak_l1_log2_upper": 5, + "radix": 11, + "stride": 1, + "tape_bound": 16662528, + "two_tape_record_moves": 40126 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3495, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 112, + "length": 5, + "nonzero_error": true, + "output_digest": "474e214a99949e1bac7abbeed1a46e9e766696a9340aea09c6ae78ce75f10f55", + "peak_l1_log2_upper": 7, + "radix": 11, + "stride": 2, + "tape_bound": 27770880, + "two_tape_record_moves": 119930 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3492, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 112, + "length": 5, + "nonzero_error": true, + "output_digest": "16f8e6281073bd6f91dea9477298b440c80f904dcb411995f1cb30755e2051b8", + "peak_l1_log2_upper": 8, + "radix": 11, + "stride": 2, + "tape_bound": 27770880, + "two_tape_record_moves": 119930 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3494, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 112, + "length": 5, + "nonzero_error": true, + "output_digest": "fbe36b1dc835bb15a1e67cd1a8f9ed7af9eb2f8bfaebd4176e33cf83ec4ad5d6", + "peak_l1_log2_upper": 7, + "radix": 11, + "stride": -2, + "tape_bound": 27770880, + "two_tape_record_moves": 119674 + }, + { + "bits": 1752, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -3492, + "execution_bound": "31027958671968742193581197523385972700044006076848357663488573386336577830451502887451562292797164031540245747346335295415722072030278197438835493097331581999688806787245221230041123158752393663308707619521637753193519993965855403346518346890336050112701284882359913475939087011503909235238096208190608445521689858008610142349365868303371850960969474355370457114686052185562557816860339552148728788821968939849649405630395747109064650901097339548930005703415767167694322152089943047506107617625601176193537958652785890871681889307626049737943461394787824936059664294921351787698234576500869548204574536654144752674044597256233489184796755086002148095234015024707839572221207216186883551022451141981366399356467874268562474167557028701076060027374575971768407520946537245263502909819267547019083314272007567211884166975576458107914279107887266287693057607688537298325620005644739024414472257602712606681193849739658963057058685140283466906362540901/43053210614369623275011949477807910277124994302510754029452983178868116489346653820746702518119364294848283371670167817028214634937669711526669783126238401159311296499551662981256428285231131625645562249553311314258619862956666226798064508891850284650496107260046214699819879975019400221498411842635219207966271546984719521435693184551634762089397523353948494431735486019825539032963579841404397041667216993971630915514330762089831417332472645319179347240312531835719491495336795193909699784036316896687700109330633539092664557442395980058508973341497730064036598991400546385711450277850089810409768091023195513943137496873153117764901655523375000801870847263529723987268925016323374652438763952374795534114869261477938392421121471291003604934631888226286354739345651170015766130353046188462662407271012395986175921735302155980465385121793936944471726304768129353574399446657208154000197568487029643548820802643552427485201634415348289926339392940824667523653880369997660279736459231426126952297538781184", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 112, + "length": 5, + "nonzero_error": true, + "output_digest": "23abe20267d9ab34773509e61042c84714caac2e0a9d1bb09fba59c44f702eab", + "peak_l1_log2_upper": 8, + "radix": 11, + "stride": -2, + "tape_bound": 27770880, + "two_tape_record_moves": 119674 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5507, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 160, + "length": 1, + "nonzero_error": true, + "output_digest": "339bceac4303cd356306afb2808c3ae1fb9f21dd9b34a6af2ce7249bbcf06d7b", + "peak_l1_log2_upper": 6, + "radix": 13, + "stride": 0, + "tape_bound": 7913472, + "two_tape_record_moves": 2182 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5498, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 160, + "length": 1, + "nonzero_error": true, + "output_digest": "904fcd9626a34402e4b5cc80b331f7eea4b547b463d5e9311da6e729066ecdcb", + "peak_l1_log2_upper": 7, + "radix": 13, + "stride": 0, + "tape_bound": 7913472, + "two_tape_record_moves": 2182 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5495, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 160, + "length": 3, + "nonzero_error": true, + "output_digest": "acc61dd1760e9f8ec35bee1c8e184a3277cfb8b0951f43d59549056faa81c68a", + "peak_l1_log2_upper": 8, + "radix": 13, + "stride": 1, + "tape_bound": 23740416, + "two_tape_record_moves": 55994 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5491, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 160, + "length": 3, + "nonzero_error": true, + "output_digest": "43df84aa181fdc8e2a1de2b43b00ab31b4883d5a88d7af06b8d95d30333007ac", + "peak_l1_log2_upper": 6, + "radix": 13, + "stride": 1, + "tape_bound": 23740416, + "two_tape_record_moves": 55994 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5492, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 160, + "length": 5, + "nonzero_error": true, + "output_digest": "eb8aff01aa37565f05245315a1223bb9dbd905bda2d22ff982b14367c08412f9", + "peak_l1_log2_upper": 9, + "radix": 13, + "stride": 2, + "tape_bound": 39567360, + "two_tape_record_moves": 169390 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5490, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 160, + "length": 5, + "nonzero_error": true, + "output_digest": "74bbddae2c99091846f8cec4ee87feae494ec01baa6f18227a16a20adf636226", + "peak_l1_log2_upper": 9, + "radix": 13, + "stride": 2, + "tape_bound": 39567360, + "two_tape_record_moves": 169390 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5493, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 160, + "length": 5, + "nonzero_error": true, + "output_digest": "4df73eac0ac22f28ab7335a0675f04a29209835ee49d42cde0a9a0500f2fda1d", + "peak_l1_log2_upper": 9, + "radix": 13, + "stride": -2, + "tape_bound": 39567360, + "two_tape_record_moves": 169134 + }, + { + "bits": 2753, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -5490, + "execution_bound": "215558047666143933789539249903345713184583955432568710717170178636289339089175684451254430945540698567992728156561989411176897370011343284546900355516424474819039254481838005401028249595185110192869478280759659552165735767081101174305093540351088169844173330618709459211291583209369561716429510415273276518448575756961333958352096989442139750365388653775776102885341490894977151805661885818658792139029735036969804593639046049587451881601716523286319293961826730552512502987209764899603933578168820193971364045712452718475011503222754907743279083529412237995892560206324997501922322542882763674425628969359862392277705499831839029780719864326917497593094554720408600118202634367867556985586732532791041921441668539903274160190427747303003715178721994543437350083112551856679340928112710744628438518752407147515518320313892866596880096180463854607968552809071307101146911646068194603417509991727242015258709929085054173373908559861019607376470591259281653033305978297899538593044014986398798452508524678096011969373598000796329271576885021578599377136775841370136913771607252217847645382479534987619326094347770393344426073018032990888496436130174538012232432206414335612947716487883036839790763158093740818282232608251850143467146339703461837542900052007391083868314624757483473887404057039664078212114587775543199395489037385034807775247835222597154251824582915226535373195835106602337622400394846233677395345595154515769502905728176422690219311376009670748743034381814461422446397355878373067010478347782509445096366107463836669921875/68598894115791550984095258268370468393707674479240879459273983686881685428836370512062151523044414734386228725209386919197767568783907045257967454825169947464878616707745781924902801556859991819729908338298444715343547472874157902085207650253566979123127955888005381625834842537713906585221259669566008396460215069964242893177522478696148669953874565738841937261250964255005654107736285497778370245396972604211302422115620974750903234953213032663566645648945090700060647965105614028587580905316793024024902513418524367078710593313642901709490588376205799185469787420507047628077902060313470199548986658402268871230753944834900111754005830462060501175219408721568012802389771305263605792693347726014158183840289384017823279144985329554817081869554347464025319863135194273786277644224133083548141912245503015958407318595416300754128903336698821158076337761390711781600110542961396809337388403769081656978368514559860277256426055872174613654777336058856389726805453537750925787898342008212490007100268574335829578940509425924907809191897590633623475402843772390913356170704940796619612340007309540930679014940515668091437542536183914091130076814120999026890510702169109879424293710825997770603678661057775141647198102407194696924828089466397717151416686267195501626815672901431246771912310994848135722995244455533406862806344321770659256607149226470191903951417312777094693097391279771826633293299282748681567138402528524911892291942819124510419421194814452508357457564065295085684606568776242070355153652398120900077796262706540273036301712507723934174819182615234082120223557565556713324544", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 160, + "length": 5, + "nonzero_error": true, + "output_digest": "b0ee71efeec0a9b9fb644feada433138617f63163a599489bf00cac793e2ccc9", + "peak_l1_log2_upper": 9, + "radix": 13, + "stride": -2, + "tape_bound": 39567360, + "two_tape_record_moves": 169134 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6858, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 232, + "length": 1, + "nonzero_error": true, + "output_digest": "1afe4be55236640b64944ec0928f3c045673a8085e01c7de417ee4a0660ea0c9", + "peak_l1_log2_upper": 8, + "radix": 16, + "stride": 0, + "tape_bound": 11452416, + "two_tape_record_moves": 2744 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6856, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 232, + "length": 1, + "nonzero_error": true, + "output_digest": "30f6af21f7f87ef662f9b5af8487ca3497d471d837c27581b9151076444623e7", + "peak_l1_log2_upper": 10, + "radix": 16, + "stride": 0, + "tape_bound": 11452416, + "two_tape_record_moves": 2744 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6843, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 232, + "length": 3, + "nonzero_error": true, + "output_digest": "3fb618ddb55b6213d0c26fd23393ea6af56142a668281464a41e800eec85844c", + "peak_l1_log2_upper": 10, + "radix": 16, + "stride": 1, + "tape_bound": 34357248, + "two_tape_record_moves": 79280 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6846, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 232, + "length": 3, + "nonzero_error": true, + "output_digest": "61e3466933b3f0cb3f31542bdea9f3b39ea8db879909be08477dbcfd65a5d82f", + "peak_l1_log2_upper": 9, + "radix": 16, + "stride": 1, + "tape_bound": 34357248, + "two_tape_record_moves": 79280 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6842, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 232, + "length": 5, + "nonzero_error": true, + "output_digest": "a881701d6ce20389ab00d66232e21725c15ce0422a3eed93ec391f8b8a876867", + "peak_l1_log2_upper": 10, + "radix": 16, + "stride": 2, + "tape_bound": 57262080, + "two_tape_record_moves": 242056 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6842, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 232, + "length": 5, + "nonzero_error": true, + "output_digest": "8980bd526f33f94af0a1e9f5093647c7abf7d4b690a22e39da4cd419b808a6d0", + "peak_l1_log2_upper": 11, + "radix": 16, + "stride": 2, + "tape_bound": 57262080, + "two_tape_record_moves": 242056 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6842, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "1", + "0" + ], + "leaf_calls": 232, + "length": 5, + "nonzero_error": true, + "output_digest": "55e67fd44973cf3bee17fb8bd35c6739812c71cb5ae0878d5da0ce1a86fd635b", + "peak_l1_log2_upper": 10, + "radix": 16, + "stride": -2, + "tape_bound": 57262080, + "two_tape_record_moves": 241640 + }, + { + "bits": 3429, + "borrowed_arrays": 4, + "embedding": 1, + "error_squared_log2_upper": -6842, + "execution_bound": "68739891673414910684014503021321580706193794602764588741516437183811032623526509465035575182596336485078538310731723152918903466222528124380184781484561754166307265460424286204761010815867118304766640169242326442292114731016775418440390054147478430761881168642707590068427551767206650650000760631364830385214808324110933295925911332076366004784523254069734743759588054186140767009457471687817725172878904556601043943451548352920483995501041604200232037868844429541789375398901262371039071610382228221312993385035781527953907442789545399241501432577660856256789352495227896290346521274994609253494145196336804233228147798101017082444128723890189955753656038821987253402886622829842959318358382828397759931421985213953459632044700229017039764790756072489590152183721227044915706134104073021525661971606154673372726662436400390367935699120279508041292269088582253600313695882143187718994635279071121419889080415010948485382086835034690577172994619581239864481866908007070863813634813511462040173572136160735204507862328896677423762852375757645321199417401324772472697674012552317036433010468453242678566106432145384491302732959035990045732639236225017758628253575888803411993636116815945185060928928408791884380217998517546729046622926955380832073523452085798582653127444080241469234628503089655145383868156435993932087481285657485472454039313096511737895176309023102679991585864428128129000473337973985731331310182232029208537861220685392535211590155162948777934847132594529520424192232732585302193693251240743283447044194842581732702585771372689033344130379711276272711628978893536941476277246416127101287403936798647651150344835254536284289263646785404582734002033828428841966070691560362007704801260487585218968000659649825555237454545797908872405063159412617968436506625578962790495060737390347140075841249170250706478467022382927156934816285504164377382450065473851581/374327286739040253799131301965476366087677983984006043605495846872914156216620044130478186065328641172527665162511935061376820372555008294102898493323949175149008666878484668260969194967699204128910174429634243031312808823169599258499733726359374145606396035541539747598262323493742800478403931988717385880070266241422367186265085842480214405195835107834300178219895924619480514435344868112889793894064710158632436807987714375131306650433305404462994952964527889619261963887571943176702382246211052819985155163638147559996986939605520682927972670708990443798095406265191381795707026046664779262749129995191027752307712568594607120122500094435684807213922841246702934654585140684226850762905434408660825698938063109780003291466253654695142858255207471876967553732187327205215359707975586278055218728143519396416432977798024938915551143514816525535470245874453102170521681449869237109700753365276622953813696743603048294981017011518303725448042390799916256625661387623226366854530544669803674325031683858736663927536752864531395782514323564330310763897234065561140427220781885679702968882523621640995232830633496996010714617853256533149752037451137489259575722432810963226296125798345108453919369796507981781354466849738901621138721556694946412994055366819522920187562630342046826403885872734143391684152156566902621056159929637451111116278551752795903877983650243890029284293966435788625186557381493132119091554293159677947133581362446972014998959741154885182955179517583540313749295169565691926679680216165279509421446595377517041252885095128248177558984433634000389322937617722666539030253547975071228542676433682398332603119972345811322317616889626927037883113411008756123232496434802699455127799018487311637721120709182485122059006090579793613622491352354621283441174134765895334464966279100091177201338275421406687063123170872998021633672399510623850676858452345450593697256320258971696764262767495232871779765708234536607971573309593436805523551989018244429098389149252059136", + "gauge": [ + "3/5", + "4/5" + ], + "leaf_calls": 232, + "length": 5, + "nonzero_error": true, + "output_digest": "7aafd3bf9640f18b1e9aa43727f820b01d364072887a20ff3036d62c93a761fb", + "peak_l1_log2_upper": 11, + "radix": 16, + "stride": -2, + "tape_bound": 57262080, + "two_tape_record_moves": 241640 + } + ], + "pins": 14, + "power": { + "cases": 2322, + "maximum_exponent": 129, + "nonzero_errors": 2178 + }, + "status": "passed" +} diff --git a/research/dirty-stride-precision/vendor/pr985/LICENSE b/research/dirty-stride-precision/vendor/pr985/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/dirty-stride-precision/vendor/pr985/NOTICE.md b/research/dirty-stride-precision/vendor/pr985/NOTICE.md new file mode 100644 index 0000000000..a96d0c7fea --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/NOTICE.md @@ -0,0 +1,39 @@ +# Attribution and license + +New material is prepared for Ali Romman (@aliromman), with substantial +OpenAI Codex assistance in the derivation, implementation, tests, and text. +One AI agent performed this work. The separate exact arithmetic paths are +not independent human review or a formal proof of the full theorem. + +The new files use Apache-2.0. The retained predecessor files keep their +original notices and source pins in `SOURCE.json`. + +- Rohan Guliani (@Rohansguliani), PR846, supplies the Euclidean chain and + closure decomposition and its linear-tape clean-storage solver. This + submission uses that decomposition and supplies a separate dirty transport + proof. It does not reuse the clean queue or its traffic constant. +- Chafik Boukhalfa (@chafreaky), PR628, supplies certified factor data, + paid coefficient and phase preparation, rounded integer lifts, and the + balanced dirty commutator. Its unchanged checker and dense solver check + the original kernels here. Its original dirty proof supplies the + conservative full-word perturbation argument. +- Charles Bethin (@cbethin), PR764, supplies the shared-suffix estimate used + in the weighted error argument, also used by PR846. No PR764 code is used. +- Ali Romman, PR621, supplies the uniform cyclic inverse bound and retained + kernel lineage. PR628's notice credits the pinned OpenAI exact-DFT + preprint, classical Newton and q-Pochhammer factorization, Alexey + Kuznetsov, and the cited preparation and filtering methods. Those credits + remain applicable. No priority claim is made for those methods. +- 0xkilgore's PR663 independently audits exact restoration and the binary + leaf count. PR673, PR689, PR730, PR744, and later echo work study other + tree and scratch contracts. The present source reuse acts inside a leaf. + +The overlap check also read Chafik Boukhalfa's PR862, PR905, PR929, and PR951, +Gareth Davidson's PR877, Wentao Li's PR805, and Chafik Boukhalfa's new +PR977. PR977 improves the precision of the clean solver. Ross Richardson's +PR982 borrows outputs for a different fanout interface. These results supply different +precision or storage results. They are not implemented, benchmarked, or +combined by this package. Their inspected heads are recorded in CLAIM.json. + +No literature-priority, new kappa, selected-supplier, production-speed, +bit-reversible compiler, or complete multiplication theorem claim is made. diff --git a/research/dirty-stride-precision/vendor/pr985/PROOF.md b/research/dirty-stride-precision/vendor/pr985/PROOF.md new file mode 100644 index 0000000000..01a3da7347 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/PROOF.md @@ -0,0 +1,428 @@ +# A dirty source for the arbitrary-stride closure + +## Contract and limits + +Let `Z_L^w x` have entry `x_((i-w) mod L)`. Let `0 < beta <= 1/2`, +`|b| <= 1-beta`, and `u=2^-W`. The source `x` and target `y` are distinct +length-`L` arrays on the complex dyadic grid of spacing `u`. They can contain +arbitrary data. The coefficient `b` is one immutable rational complex number. Reduce the +stride modulo `L`. The bounds below use a residue with `O(log L)` bits; +reading an oversized stride descriptor is additional input work. + +The function `lift` adds an approximation to + + m (I-b Z_L^w)^-1 x + +to a cyclic shift of `y`. It restores `x` exactly. It needs no other data +array, no reserved zero bits, and only a constant number of clean complex +arithmetic registers. The recursion keeps integer indices and array views. +It does not keep a clean array of coefficients or closure values. + +Reversible block swaps implement the data operations on two sequential +tapes. No blank data array or coefficient table is used. The source and +target occupy one tape each during a leaf. The complete kernel routes its +borrowed arrays over the same two tapes, with all movement charged below. +The optional output shift is zero or the leaf stride; these are the two +cases required by the kernel factors. The construction does not implement +the variable-coefficient case of PR846's Theorem 1. + +Let `K` be the number of non-base Euclidean levels. Assume + + 48 (K+1) u <= beta^3. + +If `|x_i| <= B`, the unscaled target increment differs from the inverse by +at most + + 64 (B+1) u / beta^5. + +A multiplier of modulus at most `M`, with `M>=1`, changes this bound to + + (64 M (B+1) / beta^5 + 3) u. + +The rounded increment can depend on the target's initial value within this +error bound. A negative call executes the exact inverse word. It restores +the completed positive call, including all source and target data. + +## Source reuse + +As in Rohan Guliani's PR846, normalize the stride and reverse the index views +when necessary. Then `0 < w <= L/2`. Split the source into chains with +indices `c, c+w, c+2w, ...`. Apply the causal integer lifts + + x_i += rnd(a_i x_(i-w)), i=w,...,L-1. + +Call the resulting source `z`. Each lift has an exact inverse on the grid: +subtract the same rounded product in reverse order. Add `z` to the target +before using any source entries as temporary storage. + +The last `w` source entries contain the closure right-hand side. The first +`w` source entries are disjoint from that tail. Use this prefix as a dirty +target for the recursive closure. It contains arbitrary values; it is not +cleared. Let `F` be the completed rounded closure call. Let `H` be the +linear chain expansion. A reversible rounded conjugation implements the +additive `H` call, as specified below. +Execute + + F(tail, prefix) + H_add(prefix, y) + F_inverse(tail, prefix) + H_add_inverse(prefix, y) + +Then undo the original causal lifts. There are two recursive calls. + +The recursive call restores its input tail. The expansion preserves the +whole source, including the changed prefix and the tail. Thus `F_inverse` +sees precisely the state left by `F` and restores the prefix exactly. +Target independence and rounded linearity are not required. The two +expansion errors are charged separately. At every depth the prefix and +tail are disjoint because `2w <= L`. This proves restoration by induction. + +The negative leaf reverses the complete middle word: first the positive +expansion, then `F`, then the inverse expansion, then `F_inverse`, then the +negative baseline addition. It is not the positive word with all signs +changed in place. + +In exact arithmetic the source lifts give the chain decomposition +`S x = z + H S_child z_tail`. The four instructions above add precisely the +second term. This is the usual dirty commutator, with its connector taken +from the source prefix. PR628 supplies the dirty commutator and exact grid +lift methods; PR846 supplies the chain/closure decomposition. + +## Reversible transport on two dirty tapes + +Write `C` for the causal map whose non-start coefficient is `a`. Split the +source and carrier views into consecutive blocks of at most `w` records. +The carrier has arbitrary contents. For each block in forward order: + +1. For each position after the first block, add the rounded product of `a` + and the preceding block's value on the carrier tape to the source. +2. Swap this whole source block with its corresponding carrier block. + +At this point the source tape holds the original carrier, and the carrier +tape holds `C_round(source)`. Swap the two complete views. The causal map +has been applied, and the carrier has been restored exactly. Each block +scan and each rewind costs its block length. There is no length-`w` clean +queue. The old carrier data remains in the other tape throughout. + +For the inverse, first swap the complete views. Visit the blocks in reverse +order. Swap the current block back, then subtract its rounded predecessor +products. The predecessor block is still on the carrier tape. Reverse the +order within each block as well. This is the exact inverse grid word. +Each map costs at most `64n` data-record moves on views of length `n`, +including read/write charges, block rewinds and full-view swaps. This loose +bound also covers a cyclic view that crosses the root tape boundary once. + +An expansion uses this causal map on the **target**, with the source as +its dirty carrier. Apply `C_round_inverse` to the target, add +`rnd(m*b_start*prefix_i)` to its first `w` entries, then apply `C_round`. +The source is restored by each transport pass and is unchanged at the +injection. The negative expansion changes only the injection sign. It is +the exact inverse of the positive expansion. + +The closure source and its dirty prefix initially lie on the same tape. +Swap the source prefix with the first `w` records of the other tape. Run +the child on the source tail and this moved prefix, then swap back. The +outer target's displaced data is never read by the child and is restored +exactly. Both child views are now on distinct tapes. Their physical spans +are contiguous. At the root an output shift of zero or the leaf stride +ensures that the moved prefix does not cross the tape boundary. All later +views are reversals or subintervals of these contiguous views. + +## Two coefficients per level + +No length-dependent clean coefficient table is required. Put + + g = gcd(L0,w0), M = L0/g, v = (w0/g)^-1 modulo M. + +For `M=1`, all cycles have length one and no modular inverse is required. +At a recursive level the remaining original indices form an interval, +with orientation `s` equal to `+1` or `-1`. Its length and stride are `n,d`. +The displacement to a predecessor is `s*d` when `i>=d`, and `s*(d-n)` +otherwise. The number of original edges is the unique integer in `[1,M]` +congruent to + + (displacement/g) v modulo M. + +The induced edge stops at the first remaining vertex. It cannot complete +an extra original cycle first. Thus these residues are the actual return +times, not only congruence classes. At a base level each vertex has returned +to itself, so its exponent is `M`. There are only two possible coefficients +per level, both powers of the original `b`. + +The checker independently forms each new exponent by summing the old chain +exponents. It compares all resulting entries with this modular formula. +That finite comparison supports the all-length argument above. + +The implementation recomputes these two powers before each pass. Scalar +temporaries are held only inside `causal`, `expand`, and `diagonal`; they +are discarded before a recursive call. The recursion retains only views, +integer metadata, and references to the immutable root descriptor. + +## Rounded coefficient preparation + +`power` uses binary powering from the most significant bit. After each +product it truncates both components toward zero. A truncation has complex +error at most `2u` and cannot increase the norm. Hence the value prepared +for exponent `e` has norm at most `q^e`, where `q=|b|`. + +Expand the repeated squaring into a binary multiplication tree with `e` +leaves. A local error propagates through sibling products whose combined +norm is at most `q^(e-t)`, where that node contains `t` leaves. At most two +nodes have more than `floor(e/2)` leaves. All other internal nodes have at +least `ceil(e/2)` leaves outside them. Therefore the error is at most + + 2u [2 + e q^ceil(e/2)] <= 2u [2 + 2/beta] <= 8u/beta. + +Here `k q^k <= sum_(j=0)^(k-1) q^j <= 1/beta`. Exponents one and two +satisfy the same bound directly. The tree counts repeated operands with +their multiplicity; reuse of a scalar result does not remove its error. + +Let a chain contain `t` prepared coefficients. Each coefficient and its +exact counterpart has norm at most `q`. A telescoping product comparison +gives error at most + + (8u/beta) t q^(t-1) <= 8u/beta^2. + +Compare this chain product `pi` with the freshly prepared child coefficient. +They approximate the same original power. Their difference is at most + + eta = 12u/beta^2, + +since `8u/beta^2 + 8u/beta <= 12u/beta^2`. Every prepared coefficient has +margin at least `beta`. These statements include complex coefficients. + +## Error recurrence + +Consider the exact solution of the system with the prepared coefficients +at each level. Suppose its right-hand side satisfies + + |x_i| <= A (1-|a_i|). + +The shared-suffix identity used by Charles Bethin in PR764 bounds the exact +zero-seed chain value by `A(1-|pi|)`. The rounded causal pass adds at most +`u/beta`. Because the child coefficient differs from `pi` by at most `eta`, +the next weighted bound is + + A_next <= (1 + 12u/beta^3) A + u/beta^2. + +Start with `A0=B/beta`. The admission condition gives +`K*12u/beta^3 <= 1/4`. Thus `(1+12u/beta^3)^K < 2`, and at every level + + A <= Astar = 2(B/beta+1). + +The inverse of a system with coefficients of modulus at most `1-beta` +has infinity norm at most `1/beta`. Its stronger weighted estimate is: +if `|v_i| <= C(1-|a_i|)`, its solution has norm at most `C`. Both follow +from the absolutely convergent Neumann series and telescoping weights. + +Compare the exact child solution with the exact Schur solution. Their +right-hand sides differ by at most `u/beta`, and their coefficients differ +by at most `eta`. The Schur solution is a restriction of the parent solution +and has norm at most `Astar`. Their solution difference is at most + + Dstar = u/beta^2 + 12 Astar u/beta^3. + +The rounded inverse causal map differs from `C^-1` by at most `u` per +entry: each non-start entry subtracts one rounded product. The forward map +differs from `C` by at most `u/beta`. The seed injection adds at most `u` +error. Since `||C||<=1/beta`, the conjugated expansion differs from its +linear additive map by at most `3u/beta`, independently of both dirty +arrays. There are two expansions. The source pass contributes another +`u/beta`. Each chain prefix contains at +least one coefficient, so it contracts a child error by at most `1-beta`. +For the unscaled leaf error, + + e_k <= (1-beta) e_(k+1) + Dstar + 7u/beta, + e_K <= u. + +Summing the geometric series gives + + e_0 <= u + u/beta^3 + 12 Astar u/beta^4 + 7u/beta^2 + <= 64(B+1)u/beta^5. + +The root multiplier scales the baseline and each seed injection. The +injection rounding was already charged above. The baseline adds at most +one further `u`; a diagonal root adds at most one. Taking `M>=1` gives the +stated conservative bound with an additional `3u` allowance. + +## Complete arithmetic and storage recurrence + +Let `n_k` be the level lengths after orientation changes. Then + + n_k >= 2 n_(k+1) + n_(k+2). + +Indeed the next length is the normalized remainder, which is at most the +ordinary Euclidean remainder. Let `S(n,d)` be the sum of lengths over the +full binary recursion tree. It satisfies + + S(n,0)=n, + S(n,d)=n+2 S(d,(-n) mod d) <= 5n+2d <= 6n. + +The potential `5n+2d` proves the inequality directly using +`n>=2d+d_next`. Each non-base visit pays for six complete causal maps, +two seed injections, the baseline output, four closure transport swaps, +and both complete children. Each base visit pays for all divisions and +target additions. Validation scans and final head returns are also paid. +Reversal and slicing create index views; their physical accesses still pay +for every movement. + +Each visit prepares at most sixteen powers, each with `O(log M)` products. +This cost is also `O(L)`, although the constant is not optimized. From +`n_k>=5n_(k+2)`, a tree of depth `K` has `O(2^K)` nodes and +`2^K=O(L^log_5(4))`. Since `log_5(4)<1`, +`2^K log L=O(L)`. The Euclidean and modular-inverse setup uses integer +arithmetic on `O(log L)` bits. The implementation retains `O(log L)` +integer metadata words, or `O(log^2 L)` bits, with no data-sized values +on the recursion stack. Index arithmetic can be charged conservatively +with sequential counter updates. A block counter costs `O(w)` bit changes +over a block, including its `O(log(w+1))` reset. Integer setup costs +`O(log^3 L)` per visit, using a conservative schoolbook division bound. +The bound on `2^K` also gives `2^K log^3 L=O(L)`, so the total control cost +is `O(L)` bit operations in +the stated tape implementation. The rational reference uses Python +indices; it is not a timing implementation of this control bound. + +An explicit loose count is at most `1280L` scalar products and divisions, +including power preparation and a root multiplier. To see this, let `J` +be the number of tree visits. The direct count is at most +`9S + 32J bit_length(M) + 3L`. Since `4^8 <= 5^7`, the depth bound gives +`J <= 4 L^(7/8)`. Also `log2 L <= 8 L^(1/8)` for `L>=1`. It follows that +`J bit_length(M) <= 36L`, which proves the stated count. Mutable data +accesses are at most `71S+2L < 512L`, including both validation scans. +These constants are arithmetic bounds, not measured runtime claims. + +Thus one leaf uses `O(L)` rounded scalar operations, two data arrays, and +`O(1)` clean arithmetic registers, apart from scalar arithmetic workspace. +If both incoming arrays have norm at most `D`, internal values have +magnitude bounded by a polynomial in `(D+1)/beta`, independent of `L`. +The weighted bound gives `H=3(D+1)/beta` for causal source values at every +level. Under `a*u<=1` below, a completed child changes a prefix of this +size by at most `H/beta+(H+1)/2`. Thus the changed seed has norm at most +`10(D+1)/beta^2`. Each expansion target adds at most `M` times that seed +norm plus `3u/beta`. Inside its causal conjugation, the inverse pass has +norm at most twice its input plus `u`; the injection adds its seed term; +the forward pass divides this combined bound by at most `beta` and adds +`u/beta`. Apply these inequalities to both expansion calls and the baseline. +The loose bound `512(M+1)(D+1)/beta^7` covers every intermediate value, +including the displaced carrier data. At each recursive call its initial +target is a source prefix or the completed change to that prefix; no +unbounded sequence of target magnifications is assumed. The implementation +is an exact-rational reference with explicit +rounding; it is not a fast fixed-precision arithmetic compiler. + +## Products and paid precision + +For a certified kernel `Q(U)=r^-1 product_j(U-rho_j)`, use the same factor +maps as PR628 and PR846, with `U=tau Z_L^w` and constant `|tau|=1`. +For an outer root use coefficient `tau/rho` and multiplier `-1/rho`. +For an inner root use coefficient `rho*conj(tau)`, stride `-w`, multiplier +`conj(tau)`, and output shift `-w`. Include `r` in one multiplier. + +The implementation uses PR628's balanced four-call dirty commutator. +It requires `h=ceil(log2(r-1))` distinct arbitrary dirty arrays. The new +leaf needs no additional array. For `n` factors, the complete leaf count is + + N(1)=1, N(n)=2N(floor(n/2))+2N(ceil(n/2)) <= 4n^2. + +A negative composition reverses the order and signs of the four child +calls. Ancestor inputs and targets cannot be used as deeper scratch. +All source and borrowed data restore exactly. The final rounded increment +of a composition can depend on the initial borrowed values, as in PR628. + +For a simple sufficient bound retain PR628's full-word perturbation proof. +Put `a=68(r+1)/beta^5`, `G=2+r/beta`, and let every initial array have norm +at most `D`. If `a*u<=1`, then the execution error is at most + + N a (D+1) u G^(N-1). + +Choose `W` at least the incoming grid precision, the admission budget, and + + p+1 + ceil(log2(N a (D+1))) + (N-1) ceil(log2 G). + +This pays the execution error to `2^(-p-1)`. The pinned factor certificate +pays the remaining error to `2^(-p-1)` after scaling by the source norm. +For general input norm `X`, coefficient preparation must use target +`p+ceil(log2(max(1,X)))`. The supplied fixtures have ample certified margin; +their scaled perturbation is checked exactly, not assumed. + +With PR628's inherited `log2(1/beta)=O(r^3)`, this conservative choice is +`O(p+incoming_bits+log(D+1)+r^5+log(log L+2))` fractional bits. Integer +magnitude bits have the same order. An explicit safe integer reserve is + + ceil(log2(D+1)) + N ceil(log2 G) + + ceil(log2(512(r+1)/beta^7)) + 3. + +This note does not claim a precision improvement. Gareth Davidson's PR877 +and Chafik Boukhalfa's PR905 give stronger prefix bounds for the predecessor +dispatcher. Their cubic or quartic conclusions are not imported without a +separate check of the new leaf contract. + +## Complete tape and preparation bill + +The meter maps every mutable array to one of **two** physical tapes and +an absolute tape offset. It charges the distance from the previous head +position plus one unit for each read or write. It counts transport swaps, +validation, source restoration, and explicit final head returns. It does +not give each borrowed array a free tape head. + +One non-base visit costs at most `640n` record moves, apart from its two +children. Six causal maps cost at most `384n`. Baseline and seed scans cost +at most `24n`. The closure swaps and travel into and out of the child spans +cost at most `32n`. These total less than `640n`. The loose allowance also +covers the root cyclic view and entry positioning. A base visit costs at +most `8n`. Since `S<=6L`, validation and head returns leave the complete +leaf below **`4096L` data-record moves**. This is a proof bound, not a claim +that its constant is sharp. + +For a full kernel with `h>=1`, place the last borrowed array on tape B. +Place the source, target, and other borrowed arrays consecutively on tape +A. If a leaf's two arrays are both on A, swap its target with the array on +B, execute the leaf, and swap back. The B array is distinct from both +operands in this case. Its contents never enter the leaf calculation and +are restored exactly. If a leaf already uses both tapes, no such routing +is needed. For `h=0`, put the two arrays on separate tapes directly. + +This routing adds `O((h+2)L)` moves per leaf, including the distance between +array slots and returns to the tape origins. The full bound used by the +checker is `8192(N+1)(h+2)L` moves. It includes the initial validation scan. +No extra data array is allocated for transport. + +Let `W_total` include the fractional bits, integer reserve, and the bit +lengths of the immutable coefficient, gauge, and margin descriptors. The generic +rational API does not bound descriptor length from coefficient magnitude. +Let `M(W_total)` include the chosen rounded scalar multiplication and +division cost. With this complete scalar word size, the resulting bill is + + preparation + O(N L) M(W_total) + O(N(h+2)L W_total). + +Locating a factor on a sequential read-only descriptor tape costs at most +`O(r W_total)` per leaf, hence `O(r^3 W_total)` over the word. The original +factor and phase preparation charges remain inherited from PR628; this +descriptor access is included, not treated as free. Temporary powers, +source reads, multipliers, divisions, copies, inverse calls, and children +are all charged. The two data tapes, scalar arithmetic tapes, and metadata +stack use a fixed number of tapes. Borrowed data storage remains `hL` +complex words. Scalar arithmetic workspace has the declared word size; +the leaf index stack has `O(log^2 L)` bits. The balanced composition and +array routing retain another `O(log r (log r + log L))` metadata bits. +Their control cost is absorbed by the routing and descriptor terms, since +`log L=O(L)` and `log^2 r=O(r)`. These are metadata bits, not arithmetic +registers or data arrays. + +This is a constant-coefficient kernel construction. Variable site phases, +complete-transform composition and normalization, common-label/Clifford +compilation, physical supplier hosting, and the multiplication reduction +remain open. There is no new kappa, complex b, or BIT c claim. Finite replay +is not a formal proof of the full theorem or independent human review. + +Chafik Boukhalfa's concurrent PR951 gives two grouped additive calls with +no dirty connector in a neighboring-cycle layout. It uses a larger clean +scalar workspace. This note instead uses constant clean arithmetic storage +per first-order leaf, the original logarithmic dirty array budget, and +arbitrary-stride transport. It makes no claim to improve PR951's arithmetic +count or cubic precision. + +Chafik Boukhalfa's PR977 removes the length admission and proves cubic +precision for PR846 in its original clean scratch model. This construction +retains its stated admission and conservative precision. Combining those +precision arguments with the new dirty leaf requires a separate proof. diff --git a/research/dirty-stride-precision/vendor/pr985/README.md b/research/dirty-stride-precision/vendor/pr985/README.md new file mode 100644 index 0000000000..451ac2bac0 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/README.md @@ -0,0 +1,130 @@ +# Dirty cyclic inverse with source reuse + +**Status: research construction. No new kappa.** + +This is a follow-up to [PR846](https://github.com/CrocSwap/integer-mult-bounds/pull/846). +It implements an arbitrary-stride inverse for a **constant** stable complex +coefficient. It adds the inverse to a dirty target and restores the source +exactly, with no extra data array inside the leaf. The implementation also +composes the leaves into the certified kernels from PR628, with the same +`ceil(log2(r-1))` borrowed arrays as its original dirty dispatcher. + +The source prefix holds the recursive closure result temporarily. Two +opposite closure calls restore that prefix. Each closure input is the +disjoint source tail. The resulting recurrence has two children and total +weighted length at most `6L`. Coefficients at each level have only two +possible exponents, so they can be prepared in scalar storage. + +Reversible block swaps use the existing dirty target as a carrier. A +causal conjugation expands the closure values without a clean queue. +The construction uses `O(L)` rounded scalar operations, `O(L)` data-record +movement on **two tapes**, and `O(1)` clean arithmetic registers per leaf. +The leaf index stack uses `O(log^2 L)` bits. The full kernel retains the original +logarithmic number of borrowed arrays and routes all of them over the same +two tapes. Every swap, child, inverse call, and head return is charged. + +## Reproduce + +Use standard-library Python 3.11 or later from any working directory: + +```sh +python3 -I -O -B research/dirty-stride-source-reuse/verify.py +python3 -I -O -B research/dirty-stride-source-reuse/test_package.py +``` + +The first command compares every field with `EXPECTED.json`. It checks +8,256 stride geometries, 3,456 rounded generic leaves, and 80 original +kernel executions. All 3,456 leaf and 80 kernel executions have nonzero +rounding error. +The inputs, targets, and borrowed arrays all include an odd lowest working +bit. No clean low-bit storage is reserved. The second command checks +standalone use, exact regeneration, source and certificate corruption, and +faults in the arithmetic word. It runs two complete replays; the scoped CI +job uses this command on Python 3.11 and 3.14. + +Expected primary marker: + +```text +PASS_DIRTY_STRIDE_SOURCE_REUSE geometry=8256 generic=3456 kernels=80 controls=12 +``` + +To write a new receipt, use an output path that does not exist: + +```sh +python3 -I -O -B research/dirty-stride-source-reuse/verify.py --write /tmp/dirty-stride-replay.json +``` + +`PROOF.md` gives the all-length restoration, rounding, preparation, memory, +arithmetic, and tape arguments. `EXPECTED.json` is finite supporting evidence. +`VALIDATION.json` records the checks actually run. The exact-rational Python +implementation does not establish a measured fast-arithmetic runtime. + +## Evidence and scope + +- All lengths `1..128` and all residues `0..L-1` compare the return-time + formula with explicit chain elimination: 8,256 cases and 29,642 levels. +- 2,322 rounded powers check the norm and the uniform error bound through + exponent 129. This includes 2,178 cases with nonzero preparation error. +- Generic leaves cover lengths `1..24`, every integer stride in `[-L,L)`, + both allowed output shifts, and margins `1/2`, `1/16`, and `1/4096`. + A separate finite geometric sum + supplies the exact result. All source restoration and inverse checks pass. +- All ten pinned PR628 fixtures through radix 16 run at both unit gauges, + with zero, positive, and negative strides. A dense rational solve of the + expanded polynomial is the numerical oracle. Scaled factor perturbation, + 128-bit target accuracy, the full leaf count, dirty restoration, and exact + inverse cancellation are checked. +- An indexed bank rejects iteration and slicing inside the solver. The + arithmetic and data-access counters check the written complete recurrence. + The tape counter uses two physical heads, including when the kernel has + several borrowed arrays. It includes validation, transport, reads, writes, + restoration, and returns to the tape origins. + +For one leaf the sufficient error is `64(B+1) 2^-W / beta^5`, with admission +`48(K+1) 2^-W <= beta^3`. The complete kernel uses the conservative PR628 +perturbation argument with the new leaf constant. It does not claim the +stronger precision results of PR877 or PR905. + +The proof gives loose bounds of `1280L` counted products/divisions and +`4096L` data-record moves per leaf. The complete kernel pays +`O(NL) M(W_total) + O(N(h+2)L W_total)`, plus coefficient/phase preparation +and descriptor access, where `N<=4(r-1)^2` and `h=ceil(log2(r-1))`. +These are proved operation bounds, not measured runtime speedups. + +The rounded increment can depend on the initial target. The package has +a concrete length-three example. Inverse calls therefore reverse the +complete word; changing signs in the original order is not sufficient. +Variable site phases, complete-transform accounting, physical supplier +realization, and the multiplication reduction remain open. + +## Pins, selection, and credit + +Base: `47481c89fd30a43f8f882eb4b391e89c29273fd0`. +The selected conditional result at that base is PR890, +`kappa=1661957774647029/1000000000000000000`. At submission refresh, main +`407d52ff15b2217b6e22bce44728b4c3907b6515` selects PR942 at +`kappa=1661960547713947/1000000000000000000`. This package changes neither +certificate. `CLAIM.json` records both contexts. + +The exact source heads, paths, Git blobs, and SHA256 values are in +`SOURCE.json`. Retained files are unchanged; some are context documents, +not standalone copies of their original packages. The baseline PR846 +replay passed separately at head `4bdb3e755ea7118170a7a34764df955880dec282`. +No selected frontier or file under `upstream/` is changed. + +OS assignment seed **36** selected the complex supplier track. The user +then selected the remaining dirty-array solver in PR846 explicitly. +`CLAIM.json` records the three scoped candidates, the chosen mechanism, +the local claim, and the overlap check. This is a construction, not a search +for a better kappa or an optimal algorithm. + +Credit Rohan Guliani for PR846, Chafik Boukhalfa for PR628, Charles Bethin +for PR764, and the original PR621 and kernel lineage. The later PR862, +PR877, PR905, PR929, and concurrent PR951 results have different precision, +scalar storage, or neighboring-stride contracts. PR951 has two grouped +calls and no dirty connector, with larger clean scalar workspace. This +contribution makes no claim to improve that arithmetic count or its cubic +precision. PR977 improves PR846 to cubic precision and removes its length +admission, with the original clean scratch model. Its precision result is +not imported here. See `NOTICE.md` for attribution and the AI assistance +disclosure. diff --git a/research/dirty-stride-precision/vendor/pr985/SOURCE.json b/research/dirty-stride-precision/vendor/pr985/SOURCE.json new file mode 100644 index 0000000000..ab6dd87dca --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/SOURCE.json @@ -0,0 +1,118 @@ +{ + "base": "47481c89fd30a43f8f882eb4b391e89c29273fd0", + "selected_kappa": "1661957774647029/1000000000000000000", + "sources": [ + { + "pr": 846, + "head": "4bdb3e755ea7118170a7a34764df955880dec282", + "path": "research/cyclic-inverse-stride-bridge/README.md", + "local": "vendor/pr846/README.md", + "sha256": "0ecef1ba0da4f7d033db59084944baa9cf79140cd04f91d39db9e899c8ee03cc", + "blob": "f33410800c79792670d909077bcf856a2fa135be" + }, + { + "pr": 846, + "head": "4bdb3e755ea7118170a7a34764df955880dec282", + "path": "research/cyclic-inverse-stride-bridge/PROOF.md", + "local": "vendor/pr846/PROOF.md", + "sha256": "3937696d2156e000519fb185a8a55fa7fd55dc12266fe0fe806dba42b2acf4e1", + "blob": "8987bfdfc4ba6635cc3e0e984ca24d91da429084" + }, + { + "pr": 846, + "head": "4bdb3e755ea7118170a7a34764df955880dec282", + "path": "research/cyclic-inverse-stride-bridge/NOTICE.md", + "local": "vendor/pr846/NOTICE.md", + "sha256": "9403006a0d8193298ac9c5dd4036619190aea29bfe37b03d2d716d8be264fc75", + "blob": "4dcef892b50028a3c9bce2d84954bca2fce44879" + }, + { + "pr": 846, + "head": "4bdb3e755ea7118170a7a34764df955880dec282", + "path": "research/cyclic-inverse-stride-bridge/SOURCE.json", + "local": "vendor/pr846/SOURCE.json", + "sha256": "07bc9fe307f254b68810f664bcef0f30eabd130226d39804bb38517777e3a92b", + "blob": "e1624e72ddffcd9fc2271691f79edcedeffc3c91" + }, + { + "pr": 846, + "head": "4bdb3e755ea7118170a7a34764df955880dec282", + "path": "research/cyclic-inverse-stride-bridge/stride.py", + "local": "vendor/pr846/stride.py", + "sha256": "da56e45f414a633453e06e8d058bcec6c815c73950816fcf049d92c570f8928e", + "blob": "9229a4193b004d0dd939a502cfae75c27791dc76" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/README.md", + "local": "vendor/pr628/README.md", + "sha256": "3ffc38b79ef21f506f35b8e4613510a9a5ceacefddf4a56515fbc6ec6138584d", + "blob": "89182e5b96f603b4d826b729270bffeec2bd9316" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/NOTICE.md", + "local": "vendor/pr628/NOTICE.md", + "sha256": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68", + "blob": "22fbeb8ef0a28dd6b3feea718492091319ceb96e" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/SOURCE.json", + "local": "vendor/pr628/SOURCE.json", + "sha256": "38a425e2d3a72a5e39b18b54c728e40407e121d481a1c6423edd5c18e9b68a04", + "blob": "59bddaea4d66725bf675a67b6d2cf85a061b1fae" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/DIRTY-PROOF.md", + "local": "vendor/pr628/DIRTY-PROOF.md", + "sha256": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61", + "blob": "caf4aafc784a630d61ca7874a0bd19cbcb34e585" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/dirty.py", + "local": "vendor/pr628/dirty.py", + "sha256": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21", + "blob": "2b9471083706a37519a1af7598e012f5fecf2636" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/check.py", + "local": "vendor/pr628/check.py", + "sha256": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d", + "blob": "5ef6dd67b6c6cf949fedf16c0cd7b34ca4ccafc2" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/scan.py", + "local": "vendor/pr628/scan.py", + "sha256": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e", + "blob": "d620e493596f12578c1ce47f216c44c79b65de08" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/interval_kernel.py", + "local": "vendor/pr628/interval_kernel.py", + "sha256": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe", + "blob": "1182175a55cb871481de0f56ea9ae56e474705fe" + }, + { + "pr": 628, + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "path": "research/prime-power-cyclic-scan/FACTORS.json", + "local": "vendor/pr628/FACTORS.json", + "sha256": "643d60ac24d5e67f6c9305175bd1c99bf5e42edfef6d1995c051e0b98ba446a7", + "blob": "d3894bd2a1660229f1a7ed16c9d982689effc96f" + } + ] +} diff --git a/research/dirty-stride-precision/vendor/pr985/VALIDATION.json b/research/dirty-stride-precision/vendor/pr985/VALIDATION.json new file mode 100644 index 0000000000..5a4ba499fb --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/VALIDATION.json @@ -0,0 +1,159 @@ +{ + "status": "passed", + "result_type": "research construction; no new kappa", + "base": "47481c89fd30a43f8f882eb4b391e89c29273fd0", + "environment": { + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "platform": "macOS-26.6.1-arm64-arm-64bit-Mach-O" + }, + "source_sha256": { + "dirty_stride.py": "129b2bc8cf89159aae0a810fad4703caefefccf1c5f4805dd3c9b5e8d967354b", + "verify.py": "676f9476ae71c370365a42d8d84cc36cbac419ef29d878bc60f53f74363b7fe7", + "test_package.py": "d767e8c37bc8300f417f84c9d5602f0af4bb63f8794bb044479547fc2d92b57c", + "SOURCE.json": "a0ce06a3d3fd083145b099b378afac9a33fbc499837c25250befb9236a2a9ec6" + }, + "receipt_sha256": "4545a0f63837efa8be0715be509fb0a2ac6a8c4835a118b871653235b9c907d2", + "main_replay": { + "command": [ + "python3", + "-I", + "-O", + "-B", + "research/dirty-stride-source-reuse/verify.py", + "--write", + "ABSENT_OUTPUT_PATH" + ], + "exit_code": 0, + "seconds": 567.721838791389 + }, + "coverage": { + "source_files": 14, + "geometry": { + "cases": 8256, + "lengths": [ + 1, + 128 + ], + "levels": 29642 + }, + "rounded_powers": { + "cases": 2322, + "maximum_exponent": 129, + "nonzero_errors": 2178 + }, + "generic": { + "cases": 3456, + "lengths": [ + 1, + 24 + ], + "max_squared_error_ratio_log2_upper": -22, + "nonzero_errors": 3456, + "output_digest": "834a0a2523f97d36c75cc7e264445b228b4d2928d10219824442d3c234aceea4", + "output_shifts": "zero and stride modulo L; duplicates removed", + "strides": "every integer in [-L,L)" + }, + "cost_fixtures": 54, + "kernel_cases": 80, + "kernel_nonzero_errors": 80, + "kernel_target_bits": 128, + "controls": [ + "source_target_alias", + "insufficient_precision", + "unit_coefficient", + "off_grid_source", + "ancestor_target_as_scratch", + "missing_dirty_level", + "nonunit_gauge", + "late_unstable_factor", + "fractional_stride", + "same_tape_operands", + "unsupported_shift", + "target_dependence" + ] + }, + "selected_checks": { + "checks": [ + { + "command": [ + "make", + "selected-record-check" + ], + "returncode": 0 + }, + { + "command": [ + "python3", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_selected*.py", + "-v" + ], + "returncode": 0 + } + ], + "seconds": 1.4073673752136528, + "base": "47481c89fd30a43f8f882eb4b391e89c29273fd0" + }, + "selected_tests": 17, + "predecessor_replay": { + "head": "4bdb3e755ea7118170a7a34764df955880dec282", + "result": "PASS_CYCLIC_INVERSE_STRIDE_BRIDGE generic=2052 kernel_cases=300 controls=4 max_records_per_entry=29.671875" + }, + "failed_experiments": [ + "The first indexed implementation passed numerical and restoration checks. Its direct tape movement was quadratic, so it was replaced by reversible block transport. The initial length-2378 stride-856 trace used 21388833 moves before final head returns.", + "The first inverse-order mutation fixture failed at its forward error check before the expected inverse check. The control now uses two factors and is rejected at the exact inverse obligation. The solver was not changed for this fixture correction." + ], + "evidence_scope": "Finite exact arithmetic replays support the written all-length proof. The oracles use different algorithms, but one AI-assisted contributor performed the work. No independent human review or formal proof is claimed.", + "not_run": [ + "Repository-wide make verify, since only the isolated research package and its scoped workflow change.", + "Selected frontier cold replay; the selected construction is unchanged.", + "Python 3.11 locally; the scoped GitHub workflow schedules Python 3.11 and 3.14.", + "Fast fixed-precision compiler, complete transform, physical supplier integration, and multiplication reduction." + ], + "completed_at_utc": "2026-10-13T15:57:06.516658+00:00", + "standalone_package": { + "run": { + "command": [ + "python3", + "-I", + "-O", + "-B", + "research/dirty-stride-source-reuse/test_package.py" + ], + "returncode": 0, + "seconds": 1329.845718540717, + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "platform": "macOS-26.6.1-arm64-arm-64bit-Mach-O" + }, + "result": "PASS_DIRTY_STRIDE_PACKAGE relocation=1 regeneration=1 controls=10", + "controls": [ + "missing_source_undo", + "unpaired_closure", + "wrong_closure_stride", + "missing_inner_shift", + "missing_closure_transport", + "expansive_power_rounding", + "wrong_inverse_order", + "source_drift", + "existing_output", + "certificate_integer_to_boolean" + ], + "receipt_sha256": "4545a0f63837efa8be0715be509fb0a2ac6a8c4835a118b871653235b9c907d2" + }, + "final_source_note": "All executable and retained source files match the source freeze used for the main replay and both standalone replays. Later edits only clarify proof, metadata, credit, and scope.", + "submission_context": { + "kappa": "1661960547713947/1000000000000000000", + "certificate": "research/community-frontier942-audit/ASSEMBLY.json", + "certificate_sha256": "4b2894956e594e408e111d806c842f2ed2c32aefcadff93fad69ff0b46f1991a", + "review": "docs/research/community-batch952-review.md", + "reproduce": "make frontier942-verify", + "main": "407d52ff15b2217b6e22bce44728b4c3907b6515", + "note": "Context refresh only. The experimental base and source pins remain unchanged." + } +} diff --git a/research/dirty-stride-precision/vendor/pr985/dirty_stride.py b/research/dirty-stride-precision/vendor/pr985/dirty_stride.py new file mode 100644 index 0000000000..f469930b8b --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/dirty_stride.py @@ -0,0 +1,407 @@ +"""Add a cyclic inverse to a target and restore the source exactly. + +This is a fixed-grid arithmetic model with two data tapes. Every data access +pays its head movement. See PROOF.md for the complete bill. +""" +from dataclasses import dataclass, field +from fractions import Fraction as F +from math import gcd + +ZERO = (F(0), F(0)) +ONE = (F(1), F(0)) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def add(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def sub(a, b): + return (a[0] - b[0], a[1] - b[1]) + + +def mul(a, b): + return (a[0]*b[0] - a[1]*b[1], a[0]*b[1] + a[1]*b[0]) + + +def norm2(a): + return a[0]*a[0] + a[1]*a[1] + + +def div(a, b): + d = norm2(b) + need(d != 0, 'zero divisor') + v = mul(a, (b[0], -b[1])) + return (v[0]/d, v[1]/d) + + +def rnd(a, bits): + """Use nearest dyadic rounding, with ties toward positive infinity.""" + scale = 1 << bits + def component(v): + t = v*scale + F(1, 2) + return F(t.numerator // t.denominator, scale) + return (component(a[0]), component(a[1])) + + +def trunc(a, bits): + """Truncate each component toward zero. This cannot increase the norm.""" + scale = 1 << bits + return tuple(F(int(v*scale), scale) for v in a) + + +@dataclass +class Meter: + reads: int = 0 + writes: int = 0 + tape_moves: int = 0 + products: int = 0 + power_products: int = 0 + divisions: int = 0 + nodes: int = 0 + leaves: int = 0 + validation_reads: int = 0 + max_depth: int = 0 + heads: dict = field(default_factory=dict) + layout: dict = field(default_factory=dict) + + def access(self, data, index, write=False): + tape, start = self.layout[id(data)] + position = start+index + self.tape_moves += abs(position - self.heads.get(tape, 0)) + 1 + self.heads[tape] = position + if write: + self.writes += 1 + else: + self.reads += 1 + + def rewind(self): + for tape, position in self.heads.items(): + self.tape_moves += position + self.heads[tape] = 0 + + +@dataclass(frozen=True) +class View: + data: list + start: int + step: int + length: int + meter: Meter + + def index(self, i): + need(0 <= i < self.length, 'view index') + return (self.start + self.step*i) % len(self.data) + + def get(self, i): + j = self.index(i) + self.meter.access(self.data, j) + return self.data[j] + + def put(self, i, value): + j = self.index(i) + self.meter.access(self.data, j, True) + self.data[j] = value + + def part(self, first, length): + need(0 <= first and first + length <= self.length, 'view interval') + return View(self.data, self.start + self.step*first, self.step, length, self.meter) + + def reverse(self): + return View(self.data, self.start + self.step*(self.length-1), + -self.step, self.length, self.meter) + + +def depth(length, stride): + count = 0 + while True: + stride %= length + stride = min(stride, length-stride) + if stride == 0: + return count + length, stride = stride, (-length) % stride + count += 1 + + +def admitted(beta, bits, levels): + return (type(bits) is int and bits >= 0 and 0 < beta <= F(1, 2) + and 48*(levels+1)*F(1, 1 << bits) <= beta**3) + + +def power(b, exponent, bits, meter): + """Use a left-to-right binary product and scalar working storage.""" + need(exponent >= 1, 'positive exponent') + result = b + for k in range(exponent.bit_length()-2, -1, -1): + result = trunc(mul(result, result), bits) + meter.power_products += 1 + if (exponent >> k) & 1: + result = trunc(mul(result, b), bits) + meter.power_products += 1 + return result + + +@dataclass(frozen=True) +class Geometry: + root: tuple + divisor: int + cycle: int + inverse: int + bits: int + meter: Meter + + def exponents(self, length, stride, orientation): + if stride == 0: + return (self.cycle, self.cycle) + def exponent(displacement): + need(displacement % self.divisor == 0, 'cycle lattice') + return ((displacement // self.divisor)*self.inverse) % self.cycle or self.cycle + return (exponent(orientation*stride), exponent(orientation*(stride-length))) + + def coefficients(self, length, stride, orientation): + a, b = self.exponents(length, stride, orientation) + left = power(self.root, a, self.bits, self.meter) + right = left if a == b else power(self.root, b, self.bits, self.meter) + return (left, right) + + +def emit(target, i, value, multiplier, sign, bits): + if multiplier != ONE: + target.meter.products += 1 + value = rnd(mul(multiplier, value), bits) + old = target.get(i) + target.put(i, add(old, value) if sign == 1 else sub(old, value)) + + +def swap(source, target): + for i in range(source.length): + left, right = source.get(i), target.get(i) + source.put(i, right) + target.put(i, left) + + +def causal(source, carrier, stride, geometry, undo=False): + """Apply the causal lifts with block swaps; restore the dirty carrier.""" + a, _ = geometry.coefficients(source.length, stride, source.step) + n = source.length + if undo: + swap(source, carrier) + for first in range(((n-1)//stride)*stride, -1, -stride): + size = min(stride, n-first) + swap(source.part(first, size), carrier.part(first, size)) + if first: + for i in range(first+size-1, first-1, -1): + value = rnd(mul(a, carrier.get(i-stride)), geometry.bits) + geometry.meter.products += 1 + source.put(i, sub(source.get(i), value)) + else: + for first in range(0, n, stride): + size = min(stride, n-first) + if first: + for i in range(first, first+size): + value = rnd(mul(a, carrier.get(i-stride)), geometry.bits) + geometry.meter.products += 1 + source.put(i, add(source.get(i), value)) + swap(source.part(first, size), carrier.part(first, size)) + swap(source, carrier) + + +def expand(source, target, stride, geometry, multiplier, sign): + """Conjugate the seed injection by exact inverse causal grid maps.""" + causal(target, source, stride, geometry, undo=True) + _, b = geometry.coefficients(source.length, stride, source.step) + coefficient = mul(multiplier, b) + geometry.meter.products += 1 + for i in range(stride): + value = rnd(mul(coefficient, source.get(i)), geometry.bits) + geometry.meter.products += 1 + emit(target, i, value, ONE, sign, geometry.bits) + causal(target, source, stride, geometry) + + +def closure(source, target, stride, geometry, sign, level): + """Move the child target to the other tape and restore the carrier.""" + borrowed = source.part(0, stride) + carrier = target.part(0, stride) + ends = source.part(source.length-stride, stride) + swap(borrowed, carrier) + solve(ends, carrier, (-source.length) % stride, geometry, sign=sign, level=level+1) + swap(borrowed, carrier) + + +def diagonal(source, target, geometry, multiplier, sign): + coefficient = power(geometry.root, geometry.cycle, geometry.bits, geometry.meter) + denominator = sub(ONE, coefficient) + for i in range(source.length): + value = rnd(div(source.get(i), denominator), geometry.bits) + geometry.meter.divisions += 1 + emit(target, i, value, multiplier, sign, geometry.bits) + + +def solve(source, target, stride, geometry, multiplier=ONE, sign=1, level=0): + """Use integer metadata at each level; scalar temporaries stay in helpers.""" + length = source.length + stride %= length + if 2*stride > length: + source, target, stride = source.reverse(), target.reverse(), length-stride + geometry.meter.nodes += 1 + geometry.meter.max_depth = max(geometry.meter.max_depth, level) + if stride == 0: + diagonal(source, target, geometry, multiplier, sign) + return + causal(source, target, stride, geometry) + if sign == 1: + for i in range(length): + emit(target, i, source.get(i), multiplier, 1, geometry.bits) + closure(source, target, stride, geometry, 1, level) + expand(source, target, stride, geometry, multiplier, 1) + closure(source, target, stride, geometry, -1, level) + expand(source, target, stride, geometry, multiplier, -1) + else: + expand(source, target, stride, geometry, multiplier, 1) + closure(source, target, stride, geometry, 1, level) + expand(source, target, stride, geometry, multiplier, -1) + closure(source, target, stride, geometry, -1, level) + for i in range(length): + emit(target, i, source.get(i), multiplier, -1, geometry.bits) + causal(source, target, stride, geometry, undo=True) + + +def lift(x, y, b, beta, bits, stride, sign=1, multiplier=ONE, shift=0, meter=None): + """Add multiplier*(I-b Z^stride)^-1 x at output indices i+shift.""" + need(type(stride) is int and type(shift) is int and type(sign) is int + and sign in (-1, 1), 'integer stride and sign') + need(x is not y and len(x) == len(y) and len(x) > 0, 'distinct equal arrays') + need(shift % len(x) in (0, stride % len(x)), 'output shift must be zero or the leaf stride') + need(isinstance(b, tuple) and len(b) == 2 and norm2(b) <= (1-beta)**2, 'stable constant coefficient') + need(isinstance(multiplier, tuple) and len(multiplier) == 2, 'constant multiplier') + need(admitted(beta, bits, depth(len(x), stride)), 'precision admission') + meter = meter if meter is not None else Meter() + if not meter.layout: + meter.layout = {id(x): (0, 0), id(y): (1, 0)} + need(id(x) in meter.layout and id(y) in meter.layout + and {meter.layout[id(x)][0], meter.layout[id(y)][0]} == {0, 1}, 'two distinct data tapes') + for data in (x, y): + for i in range(len(data)): + meter.access(data, i) + meter.validation_reads += 1 + need(rnd(data[i], bits) == data[i], 'fixed grid data') + divisor = gcd(len(x), stride) + cycle = len(x)//divisor + inverse = pow((stride//divisor) % cycle, -1, cycle) if cycle > 1 else 0 + geometry = Geometry(b, divisor, cycle, inverse, bits, meter) + solve(View(x, 0, 1, len(x), meter), View(y, shift, 1, len(y), meter), + stride, geometry, multiplier, sign) + meter.leaves += 1 + meter.rewind() + return meter + + +def leaf_bound(bound, beta, bits, multiplier_bound=1): + return (64*multiplier_bound*(bound+1)/beta**5 + 3)*F(1, 1 << bits) + + +def leaf_calls(count): + need(type(count) is int and count >= 1, 'positive factor count') + if count == 1: + return 1 + return 2*leaf_calls(count//2) + 2*leaf_calls(count-count//2) + + +def compose(x, y, factors, scratch, tau, beta, bits, stride, sign=1, meter=None): + """Use PR628's balanced dirty commutator with the new arbitrary-stride leaf.""" + need(factors and len(scratch) >= (len(factors)-1).bit_length(), 'dirty depth') + arrays = [x, y] + scratch + need(len({id(a) for a in arrays}) == len(arrays), 'all arrays distinct') + need(len(x) > 0 and all(len(a) == len(x) for a in arrays), 'array lengths') + need(isinstance(tau, tuple) and norm2(tau) == 1, 'immutable unit gauge') + need(type(sign) is int and sign in (-1, 1) and type(stride) is int, 'integer stride and sign') + need(admitted(beta, bits, depth(len(x), stride)), 'precision admission') + for factor in factors: + need(isinstance(factor, tuple) and len(factor) == 3, 'factor descriptor') + inside, b, scale = factor + need(type(inside) is bool and isinstance(b, tuple) and len(b) == 2 + and norm2(b) <= (1-beta)**2 and isinstance(scale, (int, F)), 'stable factor descriptor') + meter = meter if meter is not None else Meter() + if scratch: + layout = {id(a): (0, i*len(x)) for i, a in enumerate(arrays[:-1])} + layout[id(scratch[-1])] = (1, 0) + else: + layout = {id(x): (0, 0), id(y): (1, 0)} + need(not meter.layout or meter.layout == layout, 'kernel tape layout') + meter.layout = layout + for data in arrays: + for i in range(len(data)): + meter.access(data, i) + meter.validation_reads += 1 + need(rnd(data[i], bits) == data[i], 'fixed grid data') + def run(src, dst, lo, hi, level, direction): + if hi-lo == 1: + inside, b, scale = factors[lo] + phase = (tau[0], -tau[1]) if inside else tau + coefficient = mul(b, phase) + m = phase if inside else (-b[0], -b[1]) + m = (m[0]*scale, m[1]*scale) + if meter.layout[id(src)][0] == meter.layout[id(dst)][0]: + spare = scratch[-1] + destination = View(dst, 0, 1, len(dst), meter) + carrier = View(spare, 0, 1, len(spare), meter) + swap(destination, carrier) + lift(src, spare, coefficient, beta, bits, -stride if inside else stride, + direction, m, -stride if inside else 0, meter) + swap(destination, carrier) + else: + lift(src, dst, coefficient, beta, bits, -stride if inside else stride, + direction, m, -stride if inside else 0, meter) + return + mid = (lo+hi)//2 + z = scratch[level] + if direction == 1: + run(src, z, lo, mid, level+1, 1) + run(z, dst, mid, hi, level+1, 1) + run(src, z, lo, mid, level+1, -1) + run(z, dst, mid, hi, level+1, -1) + else: + run(z, dst, mid, hi, level+1, 1) + run(src, z, lo, mid, level+1, 1) + run(z, dst, mid, hi, level+1, -1) + run(src, z, lo, mid, level+1, -1) + run(x, y, 0, len(factors), 0, sign) + meter.rewind() + return meter + + +def ceil_log2(value): + value = F(value) + need(value > 0, 'positive logarithm') + k = value.numerator.bit_length() - value.denominator.bit_length() + power_of_two = F(2)**k + return k if value <= power_of_two else k+1 + + +def execution_bound(count, r, beta, initial_bound, bits): + need(r >= 1 and initial_bound >= 0 and 0 < beta <= F(1, 2) + and type(bits) is int and bits >= 0, 'execution budget domain') + calls = leaf_calls(count) + a = 68*(r+1)/beta**5 + growth = 2+F(r)/beta + need(a*F(1, 1 << bits) <= 1, 'execution precision') + return calls*a*(initial_bound+1)*F(1, 1 << bits)*growth**(calls-1) + + +def working_bits(count, r, beta, initial_bound, target_bits, incoming_bits, length, stride): + need(r >= 1 and initial_bound >= 0 and 0 < beta <= F(1, 2) + and type(target_bits) is int and target_bits >= 0 + and type(incoming_bits) is int and incoming_bits >= 0 + and type(length) is int and length > 0 and type(stride) is int, 'working budget domain') + calls = leaf_calls(count) + a = 68*(r+1)/beta**5 + growth = 2+F(r)/beta + levels = depth(length, stride) + return max(incoming_bits, target_bits+1+ceil_log2(calls*a*(initial_bound+1)) + +(calls-1)*ceil_log2(growth), ceil_log2(a), + ceil_log2(48*(levels+1)/beta**3)) diff --git a/research/dirty-stride-precision/vendor/pr985/test_package.py b/research/dirty-stride-precision/vendor/pr985/test_package.py new file mode 100644 index 0000000000..20e58c1ce5 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/test_package.py @@ -0,0 +1,145 @@ +"""Check relocation, exact receipts, and faults at the solver boundary.""" +import argparse +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + +LOAD = r''' +import importlib.util, pathlib, sys +p = pathlib.Path(sys.argv[1]) +s = importlib.util.spec_from_file_location('replay', p/'verify.py') +v = importlib.util.module_from_spec(s) +s.loader.exec_module(v) +''' + +PROBE = LOAD+r''' +v.generic_check(8) +d, F = v.d, v.F +fs = [(False, (F(1, 4), F(1, 8)), F(1)), + (True, (F(1, 3), F(1, 9)), F(1)), + (False, (F(-1, 5), F(1, 7)), F(1))] +originals = [v.values(7, 96, 36+7*j) for j in range(4)] +banks = [v.Bank(a) for a in originals] +tau = (F(3, 5), F(4, 5)) +d.compose(banks[0], banks[1], fs, banks[2:], tau, F(1, 2), 96, 3) +d.need(banks[0].values == originals[0] and [a.values for a in banks[2:]] == originals[2:], 'product restoration') +c = v.load(p/'vendor/pr628/check.py', 'probe628') +q = [d.ONE] +for inside, b, scale in fs: + rho = b if inside else d.div(d.ONE, b) + new = [d.ZERO]*(len(q)+1) + for j, value in enumerate(q): + new[j] = d.sub(new[j], d.mul(rho, value)) + new[j+1] = d.add(new[j+1], value) + q = new +exact = c.matrix_solve(originals[0], c.phased_polynomial(q, tau), 3) +net = [d.sub(a, b) for a, b in zip(banks[1].values, originals[1])] +bound = d.execution_bound(len(fs), 1, F(1, 2), 4, 96) +d.need(all(d.norm2(d.sub(a, b)) <= bound**2 for a, b in zip(net, exact)), 'mixed factor output') +d.compose(banks[0], banks[1], fs, banks[2:], tau, F(1, 2), 96, 3, -1) +d.need([a.values for a in banks] == originals, 'product inverse') +print('PASS_BOUNDARY_PROBE') +''' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def run(args, reason=None): + result = subprocess.run([sys.executable, '-I', '-O', '-B']+args, + text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + if reason is None: + need(result.returncode == 0, result.stdout+'\n'+result.stderr) + else: + need(result.returncode != 0 and reason in result.stderr, + 'wrong rejection: '+str(args)+'\n'+result.stdout+'\n'+result.stderr) + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--mutations-only', action='store_true', help='Run the short fault checks only.') + args = parser.parse_args() + controls = [] + with tempfile.TemporaryDirectory(prefix='dirty stride checks ') as tmp: + root = Path(tmp) + package = root/'standalone package' + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns('__pycache__')) + run(['-c', PROBE, str(package)]) + source = package/'dirty_stride.py' + original = source.read_text() + inverse_probe = PROBE.replace('originals =', 'fs = fs[:2]\noriginals =', 1) + mutations = [ + ('missing_source_undo', ' causal(source, target, stride, geometry, undo=True)\n', + '', 'source restoration', PROBE), + ('unpaired_closure', 'closure(source, target, stride, geometry, -1, level)', + 'closure(source, target, stride, geometry, 1, level)', 'source restoration', PROBE), + ('wrong_closure_stride', '(-source.length) % stride, geometry', + 'source.length % stride, geometry', 'leaf error', PROBE), + ('missing_inner_shift', 'm, -stride if inside else 0, meter)', + 'm, 0, meter)', 'mixed factor output', PROBE), + ('missing_closure_transport', ' swap(borrowed, carrier)\n', + '', 'leaf error', PROBE), + ('expansive_power_rounding', 'result = trunc(mul(', + 'result = rnd(mul(', 'power does not increase the norm', LOAD+'v.power_check()\n'), + ('wrong_inverse_order', + ' run(z, dst, mid, hi, level+1, 1)\n run(src, z, lo, mid, level+1, 1)\n run(z, dst, mid, hi, level+1, -1)\n run(src, z, lo, mid, level+1, -1)', + ' run(src, z, lo, mid, level+1, -1)\n run(z, dst, mid, hi, level+1, -1)\n run(src, z, lo, mid, level+1, 1)\n run(z, dst, mid, hi, level+1, 1)', + 'product inverse', inverse_probe), + ] + for name, old, new, reason, probe in mutations: + need(old in original, 'missing mutation site: '+name) + source.write_text(original.replace(old, new)) + run(['-c', probe, str(package)], reason) + source.write_text(original) + controls.append(name) + + vendor = package/'vendor/pr846/stride.py' + raw = vendor.read_bytes() + vendor.write_bytes(raw+b'\n') + run(['-c', LOAD+'v.pins()\n', str(package)], 'source SHA256') + vendor.write_bytes(raw) + controls.append('source_drift') + + occupied = root/'occupied.json' + occupied.write_bytes(b'keep these bytes\n') + run([str(package/'verify.py'), '--write', str(occupied)], 'output already exists') + need(occupied.read_bytes() == b'keep these bytes\n', 'existing output changed') + controls.append('existing_output') + + if args.mutations_only: + print('PASS_DIRTY_STRIDE_MUTATIONS controls='+str(len(controls))) + return + + expected_file = package/'EXPECTED.json' + expected = expected_file.read_bytes() + changed = json.loads(expected) + need(type(changed['costs'][0]['length']) is int and changed['costs'][0]['length'] == 1, + 'integer-to-Boolean control fixture') + changed['costs'][0]['length'] = True + expected_file.write_text(json.dumps(changed)) + run([str(package/'verify.py')], 'exact receipt mismatch') + expected_file.write_bytes(expected) + controls.append('certificate_integer_to_boolean') + + for path in package.rglob('*'): + if path.is_file(): + path.chmod(0o444) + regenerated = root/'regenerated.json' + run([str(package/'verify.py'), '--write', str(regenerated)]) + need(regenerated.read_bytes() == expected, 'standalone receipt differs') + need(source.read_text() == original, 'mutated source was not restored') + print('PASS_DIRTY_STRIDE_PACKAGE relocation=1 regeneration=1 controls='+str(len(controls))) + print(json.dumps(dict(controls=controls, receipt_sha256=hashlib.sha256(expected).hexdigest()), sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/DIRTY-PROOF.md b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/DIRTY-PROOF.md new file mode 100644 index 0000000000..caf4aafc78 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/DIRTY-PROOF.md @@ -0,0 +1,128 @@ +# Cyclic inverse shears with dirty array restoration + +This extends the classical rounded cyclic-inverse primitive of PR628. It removes +its need for a clean length-L intermediate array. It does not supply a common-label +Clifford realization, reversible bit arithmetic, transform layout, or the complete +integer-multiplication reduction. No new kappa follows from this lemma. + +## Contract + +Input x, target y and h borrowed arrays are complex dyadic grids of spacing u=2^-w. +Every array has length L>=1 and may initially contain arbitrary data. The arrays +are distinct. Their initial infinity norms are at most D. Read-only phases tau_i +have modulus one. Phase generation/storage and coefficient preparation are paid; +there is no free phase table. The primitive adds an approximation to Q(W)^-1 x +to y, restores x and every borrowed array exactly, and needs only a constant number +of clean scalar arithmetic registers besides loop counters and factor descriptors. +Here (Wx)_i=tau_i*x_(i-d), initially for d=+/-1 in a cyclic layout, and +Q(z)=r^-1 product_(j=1)^n(z-rho_j), n=r-1, with stable reciprocal/inner factors +of norm at most 1-beta. The final increment can depend on the initial dirt within +the stated approximation error. Exact independence of the increment from dirt is +not claimed for rounded arithmetic. + +## One factor + +First consider T x = y defined by y_i=x_i+b_i*y_(i-d), |b_i|<=1-beta. +Choose the cyclic order in direction d. Let z be the zero-boundary causal solution +and p_i the product of b from the first position through i. Let c be the complete +product. Then y_i=z_i+p_i*s, s=z_last/(1-c). The stable cyclic equation itself +implies ||y||<=B/beta when ||x||<=B, so |s|<=B/beta. + +On the dyadic grid, perform the causal pass directly in x, skipping the first +position: x_i += round(b_i*x_previous). These are integer lifts. Reversing their +order and subtracting the same rounded source products restores x exactly, +including arbitrary nonzero initial values. During the first pass also accumulate +the rounded scalar product c_hat. Compute s_hat=round(z_hat_last/(1-c_hat)). +In a second pass accumulate rounded prefix products p_hat_i and add +round(m_i*(z_hat_i+round(p_hat_i*s_hat))) to the appropriate target position. +Finally undo the causal lifts. Each target position is written exactly once; +its existing value never enters the computed increment. Scalar arithmetic and +coefficient scratch can be cleared classically; no reversible arithmetic gate +claim is made. Three passes suffice, excluding validation scans and paid +coefficient access. O(1) clean scalar words and O(log L) indexing bits suffice. + +Nearest complex rounding has norm error at most u. Assuming u<=beta^2/2, +|z_hat-z|<=u/beta, |p_hat-p|<=u/beta, |c_hat-c|<=u/beta, and +|1-c_hat|>=beta/2. Using s=z_last/(1-c), rather than separately bounding the +numerator and denominator, gives + + |s_hat-s| <= u + (2/beta)*(u/beta + (B/beta)*(u/beta)) + <= 5*(B+1)*u/beta^3. + +Also |p_hat|<=1+u/beta<=3/2. Hence the corrected output before m multiplication +has error at most 12*(B+1)*u/beta^3. If |m_i|<=r, the final rounded multiplication +has error at most a*(B+1)*u, a=13*(r+1)/beta^3. None of these constants depends +on L. + +For an outer root, b_i=rho^-1*tau_i, m_i=-rho^-1. For an inner root, scan in +direction -d with b_i=rho*conjugate(tau_(i+d)); the value at position i is +multiplied by conjugate(tau_i) and added at i-d. This is +(W-rho I)^-1=(I-rho W^-1)^-1 W^-1. The scalar r is included in one leaf's +multiplier. Each exact factor has operator norm at most K=r/beta. No permutation +of the mutable source array is required for the inner factor. + +## Product of factors + +For exact linear maps A,B and a dirty scratch array z, the sequence + + z += B*x; y += A*z; z -= B*x; y -= A*z + +adds AB*x to y and restores z. Split the factor list in halves recursively; +use one distinct borrowed array per recursion depth. A negative call executes +the exact inverse instruction word (reverse operation order and invert signs). +It is not obtained by negating signs in the original order. + +The rounded construction still restores every borrowed array and x exactly. +Inductively each call preserves its input and all deeper scratch, and its increment +is independent of its target. The paired calls computing B therefore see the same +input and deeper initial dirt. Never use an ancestor input or target as deeper +scratch: the ancestor target may have changed between the paired calls. This is +an explicit alias exclusion in the executable contract. + +There are h=ceil(log2 n) borrowed arrays and at most N=4*n^2 leaf calls. Pad to the +next power of two for this count if desired (identity leaves require no rounded +inverse). The implementation splits without padding and checks the actual count. + +For the ideal elementary shears, the joint max norm grows by at most C=1+K per +leaf. With a*u<=1 the computed trajectory satisfies + + M_j+1 <= G^j*(D+1), G=C+1. + +Comparing the complete rounded word with the ideal word on the same initial +arrays, and summing the propagated leaf errors, gives + + E_N <= N*a*(D+1)*u*G^(N-1). + +The ideal word cancels all borrowed initial data exactly. This proves the target +error bound for every length and every initial dirt bounded by D, while actual +restoration is exact without an error allowance. Choosing + + w >= p+1+ceil(log2(N*a*(D+1)))+(N-1)*ceil(log2 G) + +and enforcing a*u<=1 and u<=beta^2/2 gives execution error <=2^(-p-1). +PR628's coefficient/phase perturbation bound, budgeted to <=2^(-p-1) for the +original x, then gives total <=2^-p. That perturbation bound scales with ||x||; +for general input bound X use p+ceil(log2(max(1,X))) in its preparation budget. +The initial borrowed dirt does not enter the ideal operator perturbation bound. + +PR628 has log2(beta^-1)=O(r^3). Therefore these deliberately loose budgets need +w=O(p+log(D+1)+r^5) bits, and O(r^2) passes. Inside a leaf, the causal state and closure scalars add at most another +O(log(beta^-1)+log r) magnitude bits. Maximum transient magnitudes thus add +O(log(D+1)+r^5) integer bits, already covered by this word-size bound. Standard +fast fixed-precision arithmetic yields soft-O((L*r^2+r^3)*(p+log(D+1)+r^5)) +bit work plus charged phase-oracle and routing costs. Factor preparation and +coefficient enclosures are inherited from PR628. Borrowed storage is +O(L log r) words; clean arithmetic storage is O(w+log L) bits up to the chosen +multiplication implementation's workspace, plus O(r) read-only factor descriptors. +A machine with only a fixed number of dirty data arrays is not covered by this +contract. Arbitrary stride still incurs PR628's explicitly charged routing. + +## Executable evidence + +`dirty.py` uses exact rational arithmetic and explicit nearest dyadic rounding. +It checks generic variable-coefficient leaves, dense independently assembled +factor inverses, both orientations, nonzero targets, several initial dirty arrays, +exact source/scratch restoration, exact whole-word inversion, and the leaf count. +Finite checks support the implementation; the inequalities above are the all-L +argument. The exact-rational prototype does not itself implement the claimed +fast fixed-precision arithmetic cost. diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/FACTORS.json b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/FACTORS.json new file mode 100644 index 0000000000..d3894bd2a1 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/FACTORS.json @@ -0,0 +1,402 @@ +[ + { + "radix": 3, + "embedding": 1, + "roots": [ + [ + "-49530798732358771146118901080958076273052470912342260266258914227109710325121387637640669783171544976658235453737966492290535102314016775076196131137253281608605845416954368911072190053165368500463077348683479820730223655747230034954087192637416985282711781569366341015472238222901103154593890125768068166111/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "13475305001181955152635744113343228941870362999235845156852762789867665164197346764233250937361286208084929252607275859697194884125876348244811537318304219573113812813781235059890295167053180994008138010725194287959555680271101985158640265590661977057048524039192974778963502923615772560082862029626247356915/11235582092889474423308157442431404585112356118389416079589380072358292237843810195794279832650471001320007117491962084853674360550901038905802964414967132773610493339054092829768888725077880882465817684505312860552384417646403930092119569408801702322709406917786643639996702871154982269052209770601514008576" + ], + [ + "-170592372764629843867157976456437557496591605016661465377627293282379593058008669423781376417268214078363699912331157051907114448593591383586878883684704623349440149303389490092308949295538404178253469730760549011796778712019234252302695280536406885179602202888146765328976392461917368148065254242900199873601/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-46411209039859540974176647362240554857493432165837745376222291831822369430116719300153189465225800706342648078500395279868781491155333745970178758722507111433403998868313736485156740909917748907461424289090884948593897673112150836753179290605396652366677201787911857343898640266500768045571317618646184981515/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152" + ] + ], + "beta": "1/32", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 4, + "embedding": 1, + "roots": [ + [ + "18839227606306460928750436776825014273496077882053237212856774153163841259423959845929808348046828320902424357370784726029073309579224150022196016795678227966011136545266483378669974662335269472502528125472018535885295396863622929964034462260120294171947340433492325221872688727385544533583048885326400903597/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "12796926340379968523293584046788682991068081520875261248350397459182248423294625032260126325308015563095435234200881380927938236702421262255195096551267084999719624023209458696352316971284756123109784206671973205284974765619111294724890379061690528176512207203087118838657451331182211930074180553022205037717/11235582092889474423308157442431404585112356118389416079589380072358292237843810195794279832650471001320007117491962084853674360550901038905802964414967132773610493339054092829768888725077880882465817684505312860552384417646403930092119569408801702322709406917786643639996702871154982269052209770601514008576" + ], + [ + "-67937135992698413485848028692002309503217002121030373236286063853851112002834956545147982981350737462809662177353146777437281023159349478379475061510263643694108201092716816673971478633600166383954345966000686009575573734331558302198133439150275018280298091260360209316562436177361876091474717502741308380027/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304", + "5835616822424528393018276731807351617575339522981934688817604363901147520344005371600541622764811103253229296878826668528234697818556822582094397306602957922127281544555831623274134108430066605792876461395490781682749981003075479237572505884700169238753265724966398880489058963937223602091905317904711941499/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ], + [ + "73140002878255602241711158912281750377574232707837598458857400104507930946414903201953646254948585509216110472170409026061261014243757141002856798605902222432653774400735298040913720270819301943861772786445719733578848858120147397354586183800152541785894513923362213804429810043582243527480464796014608479295/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-101965650555502300179425242688687701922297090080040644000576714490063310164897746283818166254598757360914998703650200531654685086831846027226086641171539829015447750993610037727758956893880614628095284026104635045032186714065136378505612299766669091235639722208461448795105675773286000398597466612399588126671/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ] + ], + "beta": "1/32", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 5, + "embedding": 1, + "roots": [ + [ + "18410399432434593285169076294769602275894540638275295419244544381879773242101229303192661033873560946309710294140171891893900372823577853227464636318197065166893737578492060390055766605671671799743745029504200984650324085253453636489088551766233790345264477955593735634726155875498225455897152145422527110857/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304", + "88926944313291886897540182389959275756316664511795052113045934836868436387626350644157761509746590523735127289561482706452011713192888368531757723983026280383546034048812998372260884484021077768824721106874944498264700931287184901932524740060871613024772296891180592599727648764929046216006068462246504374811/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-167545453603640477774873977068820521490816283320967799058419418306745166535530698475752796883467944874062781699503482002031721106189111733803133269028126037337336557647540282023493990675410251006273872459992624200925878916492155324954465535073616098706096481035319289799489810569175272312690818408702357774707/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "154556349957963769064367096421348364953192572923709918873780464142362058554060160862470338328380796109257170485631887393041866922712420579126848130118663444268007905141768967672162702816973919207497792878550271826416467017062585388767141690359055369161984340591026398951036705551282299373389928249065466957777/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-246025941110189748337782398645962696281966535596390989644134716992878047915802819087254020031137007742552596547220618828803263741659091725736455982888598484589330876923271022291321628747736395867996706991862080909718783945688678933156172363230796038024619721716767295126085355526352538295019215908632644428645/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-80017827675325207808535539612151904575968566998857213977754346138586638701168117409273474539675100516306047838318004762335480802433891996015633286597935493715465198565408881501720917279311214162172063959383782684101469915657487668687514739767345963311117394934914437584673901163128059865890829000565376585079/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "215712256432223249791838888842272962081449782057642246390000600800148072180501294511436300947360881829332748816482640829932179778301978229874156851415522923858548828681148808544326153700577210577826268148302190110772732181100719565734873230271520263077404047413202169567004576671193383551882477838906429979943/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-343345360254883912964398674422494284929201599795775129858953529504351638375339699421889616865554200011416676596545392950323715795619267003477668104686330984199520110843844773329958643601792506764296355657817381043552933491542452533905205092594361844214785757345776857492089057313413558295951124845050277505639/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ] + ], + "beta": "1/64", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 7, + "embedding": 1, + "roots": [ + [ + "120836177722361423700961200616746340939117621826067821546283999942075497210076949759460370715678904626969473270870038244427213482017330996532718477962097048482765518680096123147561488619800104812093083654163138766755667970537231472653449243809561047362543545086368385980168510507433365046715788937161703716085/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "68125532188584294286663341974472312621216872199921619246009406654878430278942492383247031997235044995684216361049673718348715972217344544049530857813500428243332162775155119877092074201530144921889140264057120091137424453307505120185335081880162914431352955991832950471916200413514695655590549673800742347681/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-23352251484866588814984102757151938020295470378892869474143458720257279649755690100107547794252764950418419952156812046731260229125257633674879904341802608588717478148648944135150233501962993159400202815681865439334171539946279604850805926161998688918951893236128852170350420117380648887992523528703050194783/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "12132115037519896013585104434007386698287966150528447173769745653094849377705471451533571302407701987585405260939215552836593163546110098278844478687559077536413118639791236269008047600329470759689721901333721666143586701098282693338033702985076136987291514686849805451278368411427725280317893977203863584583/11235582092889474423308157442431404585112356118389416079589380072358292237843810195794279832650471001320007117491962084853674360550901038905802964414967132773610493339054092829768888725077880882465817684505312860552384417646403930092119569408801702322709406917786643639996702871154982269052209770601514008576" + ], + [ + "-92291382711014775221380021171202817794657125260699000287682436525116249639100986456003288102293593362503506340776371812568234629218022304094954295338321708547490187028615230917002633870289187269289797994714342072570440381702763361962356356505306507682202967183538465154964375441642931008189553934230981931559/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "119712689918657651145189233762925546457090337327810229148877839636675818166345698397220337691661044465436596246450977563970023691296540621113539611731979073364553791157261962787179002477238112224575127636003783615332436194461854998451162028079761177278027679849503098212639903585808693056859631675024978403655/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-241550214101542094297167535638151897507830585201411331736006717246868123702109366984690181768784545848116906421886000314994526788327659530751761942604584557795696877540130891932133377552105984741145270626005788962709578395270874088233819746015884483414705471639012552028950063730900626438412769308246134412423/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-44636521770478560155358654717184927568066750073373513015128082461673476496822166780757639936727928123676721979818426533919863914831246651250724819329685161786373417321779253128206274251444083819402120012005681947845516990805594334226921578412078056649090375828519802643691118444466847932595531100425230751867/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-30203061381136258809439665112684149466527548721381460346906377733218206927673101886508360525270680857362678859262610296498976901610754244593890353821856268232116927740493603349537265139809747876075016798077935946460243881062966294672661437770702005876180419387161259974619074523496342984580783717368906963491/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-305110068800135848497848181573777483300901124284310624770759696080464881064477659631992063113691884421747360163819890589058455217115247182223505704124808283746309249249359889226760626023333388774388559141421503453637601946482828567415910388069454422041311561341290600832629150554612317238895704865818852456303/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "321370196207928824720915204711075455015246912340098126751032311594524033112453537345445629309422537818066392684089031234715114932786141935425039670921672922753033036803089443416637226862726853593951312786044577899391357952048006221305816041423551248138900234992740786667031784280806046850529260976098348049203/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-24530473927531504467392407392323938052443883461832126187972943992643983667419063708657378422819680820353364287646948211385092126125885316040368239976682069981937416789728921378575979136146542456286295719081463657034678512460199743093437741946258402070242087927157968777687527815825283515074190769218475070497/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152" + ] + ], + "beta": "1/512", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 8, + "embedding": 1, + "roots": [ + [ + "8676521756510435418408946804461767324891306204862417174847745121263025946650658922911780062841899310292089809846830833767424385518217195893825119278967539421517248349379935548836275419185719990536047729374806106190931483190985689626709113976582272252929209174868395094303365494483709135736692733466731317795/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "46927175506395187795687931561127127492542914401987186784106756230323458946080644106593751363160127877209084537223858819579870206674713563202937305209536930043680869885123270522345465099010053820092378973496193748874813123926250211050432217802376301722910925291572156201602782436939032617502745379314433603689/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ], + [ + "66202580992830939447277596770820976547224187818360015042315917699790056190563629777404288554237323292216596605503553003282188641500233854198283302909676455062335042428271478810798541736972692302397024682764300702362971680590029381246736867638520196791172922404288387541122616211813091943463685403402194819637/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "121765996413538109244722158430733772946581021648295379494316178425975201830123378250127037871022862140665047768946333869871635524590445958253367982270652171353818448747755198251644533171986927552011666923832137891571028711514868831622149886611924577771659219065857057020727239216653669500246218019089692681775/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-63004972185514719302016938882476801018029290150894658797428428794872008178224844068489106570343956469890320581237050176572657244106576400241496924996645905145525690133237596136064437406720491787085549650786601720713499367232077045311041089715211178346785441054922158278590254819899949862505839484404422514173/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "162089912107789904580698670024539381013319877304490279642065801647607770297007606234339566380838505368774389327096714260667996331814249381137709093996072587356720324791880511287815302447216666542808264118488552050522502999610415668210833042811542567219354932850746955158614010677677778588862432609198364889609/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-114541150781975074659493858700499576773418741657487570824179357865241951223155018561684267907712799100922762526706741412523928902105409038951683693424204620570355075936652546398681787931145609090635335092259268023627437543404884939870413071359280803563668076790897925194743799223677433801998275248938099138653/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "28536383328959703993730430075303364190020911254551649423945663982045094704274492977093462377686393175454598424578736919668575596341930388955047068633656361481992620692814813327812876623975978375572536423322145652113828759035405388077251778997084312380853597717028602612494470837499099867849196700594746333193/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-201517388249894989478411032097072751718656423446768498708508564928448662660651229648295542554051448907899318156973678948290345776073447986354173204606393763408869392055271224486081374851034619526102418795206963640221560398265963426462213308991975932816594775660953319668579841424702426262528857537080463794965/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-174513042277315163849266924439208792551210027773319873062117112212107791949617487997311514602133978721591638988373550045126013490861600577744660221983293741489328994487990284644844821816190752936317045684025385986252691736431523152528005392504331486525860129092504396317973074372934850065698391093382548690683/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "20853952201633312877387277508463847055126394746254519899742972932555894208910866792849243688527659586695779456772099102381103863965624564255350878448532450809472846089800434934408081189773222964612807975923115727341248896300480297539550915338524351483735093086771402116129065052573895987568833471894650866121/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-312641081391502269606656250395689464714521237121044730843195101985540858918629890694914712449559446202158312842962672451031785756934401273144496289056535368585556084621907933962326641902682587075123817870096547428328478755021925309233810847720403976729205559662801376490464233034499544774061638742784145893525/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "166672131806845776192896885973661042124973372869940345006468266318743480528703466414015865739675637832291806442497067063319157094307655919219743641987468037062277740025664176448810213542701871758655081692776525610517996057224630655703118199190067622390022656134231632552577778502578893106037108271941930607565/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-4376967838200489497250994948825473623872235696381225795629850903139948925947408138790254476399212615558494266176816561458243901205759824715627651584088611054101239737165343081922176424447484738906847833188948761892037696110205922052863065492314158621446222809067390965832669530284377833079714832042153910245/5617791046444737211654078721215702292556178059194708039794690036179146118921905097897139916325235500660003558745981042426837180275450519452901482207483566386805246669527046414884444362538940441232908842252656430276192208823201965046059784704400851161354703458893321819998351435577491134526104885300757004288" + ] + ], + "beta": "1/8192", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 9, + "embedding": 1, + "roots": [ + [ + "333910482659483459438655528550746003905249000982454975806894848438737707753764976869561366054330641369183833856032301628669487010009234742939505872476695122089942073608783197493524773122513229557328670182714416409970596568787760524274687406159411184511162472265702547672362929076759614595740589264277517789373/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-47752137171466876261593994891268639759720371836251849522631883826242730835462895269072450253303956251409642499713362915697132486294075863280378249136595798406260146271799670133428231669418934780402000503782168565275986637683350570973550359499708480182227099344116449794282936783930506661431843381346792007145/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "180857061429154340683796569249229633634282740219290917942321763794161703285567755908320831766805092839199995120635992701965884419377793868614453316178802274842846369150241658175248894374357637462187419868434067659967756992677108864166432671147587357826434832424046949718532074646758771501650950393504125313/702223880805592151456759840151962786569522257399338504974336254522393264865238137237142489540654437582500444843247630303354647534431314931612685275935445798350655833690880801860555545317367555154113605281582053784524026102900245630757473088050106395169337932361665227499793929447186391815763110662594625536", + "89031252177887495190665762976190738719635134333314194291508015840329805457255816648024444476560108063934040996807695532427466053700897943316995019084184510458211965571902286576252834532496294909472140013944090159918770767649059087712467909540838463240479671623720707864757601071992191516521915069518033316617/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-77570549831923552874388989142731030044682007042905840083400846000380141528891579777851595702752702328774473303959132662315889278783543232097424451580806347987068043391866782113060657867967927073555566291117612044119958405987268589066112630178066419315079209294063775976558795584459682150886660045413954013769/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "179897435173147029214413437523250288359207247872041518170502120727641382930349650875642891171666569302908673314657961466832174273548337212606432197485311335192890539535613453859826823968059826198019685012450454506061510186429992789952527736462387221084655053453668251388987921959301870000019796834301705370287/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-190010959094347690462269137172070133553459071158786598796602362999138607180514755593009011514443911574926856975116553278070950196565545016104446202259984121956425990468540175254088981798543541253103375431235218242689895049528330746625788021572824829150972581783014458284949616718799691063891716331606263765491/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "99030770506346274571412767249597026710488468973300656614141769044065104917082032751052659130642873032747152401206156730746432904390655127956658220469005080826426402974997601139897941906522466353259384287497934337081931282143875656631456401729850661272991846764776573277336890519241664182121666563815825108741/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-233081207055107292068614793986538528139321828237103534257403268711362307316433680696116996201453280211587720811602707281081949546040375748910078559633641468576989928431965548210945788819468022114946692214502141994372721141673746177085180557226353646152761400166555794272666489885938550232614191513505184437909/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-55943527093538648994131853774327760706423292404958516460832453352530715831038895988364294084379075527404154738093222713072803156085772412806543739693673201174982311509658713101771928709767111169834072902328747368130517026338521314072319621096339894710376582330134409800137590938355592424671582274968784888015/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-73674816051867153651072739874884099639564752966078427342019842615755828513593612394516445502429253037266855084255963456491511864584968452239949356574902784890872662314770973795626380106098390700582613148829779523841278267045301960823172752044249996830463280555136131109752238430106594324223891786255349386507/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-229807430732849177117110644126555193643659835289545136715286801956254443227030503648670842696618870987609340139528277927495657195520865722750609252335913869508408276603724155327353030563572875987772902902949206596449124196495306939290344827467222870442728695524546121120411264232478377181674795998646854090937/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "21321939274995178538221961206791871382984274797017580984543305003879576871583449027897925288200755917559935688963418115740792809342472296149539253956569356996997885510566587640382490543578910073936695660519193238722044786613345993169911490333550849222184308269478701581148338439803843307487853418615205531513/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304", + "-150737439183938417466026541943664853780573301677390200716773762546802420416786746939455291356847900573293657693272612561521417054798588970409780434875913176859075028648525952666660665297532915477471545641607412073362848129142966744244476665807658602486321803579387819475245914693110974696229125922432406831735/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "35114167688248708489705226725520322239757602458420567049561448419515293002391419875052402245031950661384666638645168035176238701372703027255979313802828205032500024750897988872631333460681293263507451895457087663973744113306278768660451880594853026913028478026418649968409550880245338037923086078312777680791/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304", + "27546478297781289342951459913655862154150871859653605939980547557514582388613385010841997426553751173842745619847075795184069081850799605852120546322776304239444231584968459156764651674979961647993059971657017151034383284332304041936961882154160895082836934427447719866692376787959364467530446014008721598863/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ] + ], + "beta": "1/1024", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 9, + "embedding": 2, + "roots": [ + [ + "36627579605007658966659778461203634251371697379108157264801251842963340495317878340007270952160418991100126967216105106719737629728806468143838917422932843178173126209184087556635317452073232467886327807084905993395510516160589404741476340166934455525421308327705599519861799297110888754524674156034983913189/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "91213904696706307172757488630720409637634441273504301106383789102894171902182804905443189017899008504696948838212829861096814223539148482614848676923111790231266756795679293509188920363735763072749479237417340538439822705330283204140328446148978965322292213168306231351893475906153300657761895447665575697199/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "84035680545684351602473661021561463081168863906638834415994052385965625479101474846868259017791131826318727391437910192088726625481437554020823348149067175314300228396308280676735847981399985641700401470915484644497581666130585473688371033657369860576189725447930344844832440162634723948823836250202417994515/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "8148013099263468190653788738472861941241579884501632117571698363380494060372231299699288233780855988276576215383902261263316045847213105572379987687627519561818982137927974561918890474195006623065707914273566644830852081228319342987631236139162161704438123829472498354324469835175859687317768243701014103519/11235582092889474423308157442431404585112356118389416079589380072358292237843810195794279832650471001320007117491962084853674360550901038905802964414967132773610493339054092829768888725077880882465817684505312860552384417646403930092119569408801702322709406917786643639996702871154982269052209770601514008576" + ], + [ + "-100078953961497513827019582958503948692313436745489773412119737617020533859319405373115780371895107700252180090915260674831636736234959936041881253145088199481284819872914984423224863245178613426667354296068721645475017118632587754300463918861969486842414948740548757053004934043822785610986714760398365599679/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "3398809930139403861148899090261015484845408816967426658162601582201664636905280230206674173374829015640972007851858863447180055375534479268107072312487849563160091306886763149122921123989532906823269948436995082554330272656634564774170850622113683532802699002449190529818559937755553698477368426140195610501/2808895523222368605827039360607851146278089029597354019897345018089573059460952548948569958162617750330001779372990521213418590137725259726450741103741783193402623334763523207442222181269470220616454421126328215138096104411600982523029892352200425580677351729446660909999175717788745567263052442650378502144" + ], + [ + "-183338193122679443380740560128812455004059475231783258422114826847995734608876245819348478430541727370982727757486771145154226239259518782402684145929956021883455556122678489997638290182053381073341880321623966722662080562479192139016173619844654784754986657599090969957280567175733144107276191731039944767793/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "69544043884892615520046310400849713710736128335193355114162837516266036707296210585162307101033581669414559740283356404136662487557992456157952373635087040782218145130401822170858673477542223017483990259128019803079762888726928377309670948765232529247230492706760919274284002471550667971352710783976141811759/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-286271387236816925280241522879228420963755468856311152978521691079419985629370744590058055558139090150368540678259547716089060942385350516235204508672078069739575899105386310373908278914441421362759756269445058265422389064137253935790453915270461746334070802354549224387950778330302172659661620800950476186749/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-82918958338806825753830833680976263062074588869905593699233198939242160296448906481827055827641905389023514571488788279137339639543608846689251136263565750412573086750041060060195606898601160434500732786154396471493243930049913562346718453598705146259982726005531537274756750753151714066487137785910761431947/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-49807632985904636056327801309165668569949679703177249904015612774568110724009981257491882061879367530463687202275856313301341867893146717453038446249068471976860842053788497157502426856271448101222353866671376525212460060433231010076669364400926876741344107657680474212816727791674300296404422336397687738749/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-177362022940644076757392587993194089526114195004881930778497281946886928035272836044916000656700084837927346549061559295412976727004631522383668857538236746314783697433474028860696915143971089197553031019918950340000537004506529613569767212474004309695951498140271896557248889203205304701749822638973665710421/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "151726435005196152503621229407512430240201194430624150994328999718615893705101127231153874291153282523199899481986566943279721987880106907314573029521495326835809641098557389722103622116104726637641894632029695112812573695921454951502415653852282073265566820064948245713045069992446951560447509654860385758977/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-384822354883360534431812042911405387725218348666290124845083009057711843252196160570381320302098793490714437674025650657316209395944001060980319931861297115592823638687839794408498221389027544281560445374349368840423996714188312856799321242909238654232390908052313482832343212428064897303568712693638467285975/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "41081431198079572611558466625440658048255168639522243169055624589826066923314664776521434977008446938486253681718692790654307094043265416041383699295454020975360572161215700150415363540172271447445087225207715238810462166560904016969936740545340760747113041037652787910341644753600676564529962945902837220001/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304", + "-4118711747111065465143117971635801376758138406433752164082253287354658505291179385338879623132445718177109921503638931942611426340975801223027948444391682221345950298080184044770827371312364405460096337648485815254515555637274146065727250436766509743948076237782619108756462233723207660043495600271274827343/5617791046444737211654078721215702292556178059194708039794690036179146118921905097897139916325235500660003558745981042426837180275450519452901482207483566386805246669527046414884444362538940441232908842252656430276192208823201965046059784704400851161354703458893321819998351435577491134526104885300757004288" + ] + ], + "beta": "1/128", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 11, + "embedding": 1, + "roots": [ + [ + "19987067627228188344629069299179400482723624880399215433823291767545287429199097189201872739530866475858846834340571882225835111913315556842511345498467666815253246841468908666504463346483028254245326381190693095283853100267355904488055841487849491381199845949444150700195520393828374821557134768600767466237/11235582092889474423308157442431404585112356118389416079589380072358292237843810195794279832650471001320007117491962084853674360550901038905802964414967132773610493339054092829768888725077880882465817684505312860552384417646403930092119569408801702322709406917786643639996702871154982269052209770601514008576", + "-16371177452751777825563018362473384628992592467063145384041920070193938502884230358731455517486303546488422975735506625293320144959392098974784869852824091878513232785682339953450977565251051966045793101131935501779170807314388776610230256291440229867741336996952861254445223349520745729923222550176564288491/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "18856846747548568697588208088342677025973301317628666942362894682533954455666322781604686688583386331954228030929273184779113235417601784513933283718249884792714800236464676089878514996628927413059992636963593921322785923317037817194703770654332326501994334024022987493666601426630817081203976984338145763405/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152", + "92987134558769461110036206867296860043881621638534166853641725913226172224366088756826381486275497978147294133585381794639930001435905110892538226145300666954747499650465654558096450639522609112222032585019033582960779504653453557208357386268301504380446208517791958035784800586179182112037390042935466531117/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-8755627176049049991226664047137245698863739906064153437347452970558147035098726451283760392997679178295614102787623006912674241102405755920868082634752574119386112664741472162925566921061850884242496676415467646079844403140934545444691802820099406918031463518136566579394224020189874248767924449767942783925/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "184869178819451977603611176386928738242876901648101569688171783567941034492292441694469196166591126057251772941746470171157037212752090292935695497021766339398687078438294125034073412980357691297887600434603353395394298477189459158524716423700412207205879422399971470449045719677938588065634394716581191836817/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-54478583300645253822831870111416997505140953588934025523583341251965664154365796078024298205741864555549713807076133144301802106929744713687687990384993502959532496048549753489310281500438525352868503316582822328826656480517864695496618221362284012857411443021555596782792697074220181225526863918268300639411/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "20286205262628437605254043475721537150966571526564811549532640552204714056754728803364947802459551692869353686447919641018139868478560640763273306515452613049046891837083267506195031814938252858003236870013002284111289860505997396859958206617069856782707127987927582577818632717973254483287992421656734652759/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152" + ], + [ + "-95898183509014184241500254592800463383859036505354131097291586846162888704186664657955359052988941231121132518651068021267889402827792190056019212109768207300155797496969688201128119018149578616452527735438289364195597833846776297049494445152908588057194749724385825905412784224692093180207921450384112242461/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "42778814428655042090098870059327487099864258445354926673871694836725119840952203199861360259612720795076463940032853087688047118369165810858094712277252996243488507752097503657331562950399220905133886815882248888535031166708361760343306732503522179656046809130881476963896662304795263022774723587080694995587/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-225921504279610020642388278131970798218208536978767361355204927337288732255627291982651523854880824990070444198973400989148467743303745890374317986738214990201636073279077380395278347044974050305694703888747355737926977743906487115905900433985192373300492134362778507994126188996113276482333293522946874166163/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-18512006630388580492498585919316792146843256940712140321718354870283077911759945301636725256521424427374811915420777847665766697831971631267719642616122994338671795328699256187096082707061323572720759145517912510241431847044219321767359552211168619158510793131072148281713269420146872738380344999839805482673/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-180384503040408332969274788910647993002194348933408627006352614755504198801432827860872973900664892565262188160970148757056307523990146812970216425530483920281444046886004414828488834832305952363622670602928505922661923912562146105294903808098488454307366830380059864074416998974794846587590490652864169574297/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-176646969751708359448147936704547232946199217170499539675033536510376224673878639512761397186205834591084970427821916955369563206972314869103885725048066220048023304706002429705664922747797907812155061260294680552052160516977538525542207321666484952876348281560646346378263539923187144743564731897674171100239/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-38861837212388384976420529976991509417115833041275628837436068047549600060280382176786322036369939502791851622004559175908329336385610877310085063200757697917251570206071466998822689139170709736990644246151849501271239337143095479406182219416332143451639476774213058321348321744184322700650862375330310963823/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-277565260286031004677878130054188583191705289863934684844268782639173497999273973903587616669187872134632967542328894598608374892255412381085758974558621898023147837402060395658900058771526410416451986547731710938161234642213649079303903522523174051553608817790842230009020182395206171132818408527279761433361/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "21488211622826500960553162925976956012202845211007392491489641798267308432671711630040098232679466316650764179735598419427366676486749904192558644332299235921421144714023516384651586190355271133895433014816047193327744219762731373547159612179053454955452144677625900088969121688703953521421817439565637653255/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152", + "-128511894661549286531404877158872813325425204854650114042374504318410629316789283103583139449251533177702910299315398368686906037165442415057629373076402635077289348627984153358667785498500978795932314288919594386024513282286275663286707605543358820950021120445081138909212973329449308021598533550888061275955/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "83585712907819930372525737678387002726043373066088394654745598301106562580077687197093984735045193590830082209556833412016347775904780083057550263000319559749883171904511683435215084292917686994094634613938974636571702338378693688527807890580242888639214849494751714712417179164070115873698326690655414974855/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "39527043648482950010229499119972439999724135181397298119791477377378696955872414923351111484626654042810194997537223158576386497412597956774521165982556008744194574609655834444282255397016231889321227196472166056329130778270908426382465705876154201534793629442915901015100724328325125021229484333621969864103/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ] + ], + "beta": "1/1024", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 13, + "embedding": 1, + "roots": [ + [ + "18692326237161478268382893815511145026088685648190526628486457135249558896952920917514467617130261745382206732573150104474804362843637309165023312885970700945843085407379411136466208630482730176116475442280579227987505293153616103902239142645063037996256214288997875546400775697052054140996875722199535144377/11235582092889474423308157442431404585112356118389416079589380072358292237843810195794279832650471001320007117491962084853674360550901038905802964414967132773610493339054092829768888725077880882465817684505312860552384417646403930092119569408801702322709406917786643639996702871154982269052209770601514008576", + "6486859248533430000780273205701654512173970909417755732036832012643583151844496919483104176207017793400666110165169957902541959012070998111285223760348081928328199544477282093388192150307015875863662558373792923793254558604148460967249276341192795957495960108311024542088237938103987924150576546911604521261/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "157323348664187956666822829330189664661635426810358914253796127992247865612061106690649235990527526045899298682970108967127473022845446753514004123946631683036181536536551113663594714055940804627834938973774495105472785669307840365432825878956659739101252967010629991460289857031165177301889783427611928177035/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "40452681226070075570072472344401074944712003983589808887925600577667159697646220867905051803615621855045591166578947446549771630680539405755136473452812017494827925564012739248547906421181216869880258586492201563801160785331284811700400735399327336162196251093715630564873576011674857714278044254516933544179/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "34899392812722428966123339680611544816703491872217428378010116691058846226498126253227436478273425414652638211700583485046158136663268894227982165278243907434398134769506468269248093633129553630375056939180388351514797408409815225914896580843925098996214002147635347069013543757886234918338529369491958625833/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "88011579740709610420551536777095471880520733731329804909182057295159138856658844441946791253952523971367978325361906101288855444899057938251340285018035035161867960959529967697490808156919827046584265520088861647898766523277648589169329276572810161414081405603460615665641982272371797657744614418548585824559/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-23632344362636047103245294315793142313888805211632242345277872394180256512662942947584023084035033218243173110811282908595282258284332226870800162079433188907613058231842037992245668397834548268318570993706111537983389312729510092584842380438077530588177371098312347383358971591168761951695032633273140864129/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "179549417839364571074172991064461500088264697781045040638237379539937742850790852186678832881823049512825498163936194969819369072795634141188946475578546985346143228307209114122988494462198458310511930360221307110264021454197646686772971727200632632260525068224424641531327341793787119527322865955849707710265/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-64171504828073803152954152937711567711542666684035601356646712378688470076580612870475769092135067000533842853688036144897397023533079657883641351971704778429165978068814538057468601770310658772323207554597087096804145799486637998411913965567996425496787598923735682562388421874636442133233905377559485353157/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "73251115769149306473345828646266294966486765451643471177403942814435204983959223865491318323457407052192740413543012493039306909122000661827522200300183854470520931139463523567192277441532807875169028627798601616463280909274217382738236473252288608372738895951142823317852525506369814133883275719630758807137/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-96104599738951769633676493389601285253005282559510584694569816846333257502863917660923538247139087495252208921646849092614916922614604316843162321832456288793741483649147875280476706456286703917113215728033231503625203893643516836727765185675495923663427569333306934484123850806643288701454825729811953604323/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "9516631030430603547304258413179041787814767345466107116984577378638068226215235344637777767447480019230821635109605408066669055840851972438579815757178810228708736258218847736218387748283693992362423328654952423382366630325601232318115927373324378897688359132242894713899973429384583590542101150580140274839/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152" + ], + [ + "-55062228354540215497376005863565840475664320925484203015301893653352734911931366500499734179862501376983233255651835114951841126300871292416409994938947913247339808265695383764522624850188675657931604747407328681915351414694957246542297547449812418192888195444651234827845753423977115916824720713929628153581/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304", + "-12496569895905601754496446211252110954226257293968968523070001442676531897713204634587293165700868423273240811744498014947415054071256992206134858336956107724864774886993506222731936628197452918495709094251331874681454069575341628004137867852588704373449128871488326320348282721855230926986775081427488534319/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-97236621922926488171753094952475321839966850867104708437058094218576032195216305246450562921641655245078955900922369570464505990156267416121818652856643194067118861143473065056879134133679172250527578434553971705148706518072819842042031704168804575722945478691295867602666460085505768296696878111825723393123/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-139974366379725222238941562299015165007954582856054307766040303104694071987798318784342412584103837521837750166553176969910384907399840762917340723142586181202439284159762153726030716323608885065258852362112003980666178559063919724073261539914546317386542228981943211320210328234291676368809663605528890583427/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-12916153817227395308964320333307521693172637922378933961237847141531974139138197199274579477201858620610500507563920459598428400153777012639967564196276145126945301605944903521853118392469464413956941118844472993633600262566258024731392397410303362620852019080248276163503519613363724636522615542062596291175/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152", + "-238994272365838385358698151204558291126185120423482408759980968611149377358699437412307564621248256757262516810026759206258728546995344843798934973819120821031754741483239472065190876326354096946934497360840975069467809446930323282385605750700824263085431792466905140472727845592124191127039452483105619360915/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "6013043937133886929785992231257511969627667249481246735439580322562221982328578577554836403334984733439034934735034117774148354364364987263562214790340175882986670622045334794157783337444852881404655139096629253059946504379613666594193738691315078072319789952637941430021364779329441507323583528933381210005/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152", + "-278679923529189704360039255534940158059487346553817563199472560610069982490137529352759281333079523373930862003820159709004193000121849875645389874369158065539387537232566451095140876980715405549825629533527920059018461562814145916859044343901996440993708624557401126980979858868823094800991662382134844602877/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "109989007535808651476018626898092526943022773744744817418914845584436965704556653332778848051969834606627072091810750458326495050646220897112757542708660487042684367750689381549049479775617896373974012758542109149431726669145658671611746929890662655791701705849605871346529807065359253700271713756945440448383/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-51882011778821188484364240793453110774348786484062001914177257798483135937985388930919631365603190565770832669699636056548063889192925119116887789197614808884804148831874399739412809224443826013793004508047851389354227654919416055982643722487389332768423157423587133671627261738239235292352438537394793285609/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ], + [ + "105894466188666824637797522379481298816044382741836996193011641682857452110816736028928950018833122381771371198703803457128745525851017334778410249826879397875759195534689495859965994904874626346162905042038177007336006951294064455526202243127641508935278616124494878183999313811884724475030368145374684989523/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "70513352389598145213663477133635023707890899921823566159207226270576916995395924683079445594271942693838367850660040457845959093720558038483352469338574636265642119180155548293660979873985809604194360555360145016038237726142654627699688283243073137486408739406691752226458425337231524766414622661143826464579/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ] + ], + "beta": "1/4096", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + }, + { + "radix": 16, + "embedding": 1, + "roots": [ + [ + "134039650432496433101295605159145494804947147618859989214825957778126813783946265379824234530653079795983300535220081531974499830210731306488624875267801121995052729438299927149721093666927526785655754801147235486784301827065913383198135946696241002975265831017168785200446019385215181318777012203053206775435/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "10043776175087489111857420427705466089122018604250422834704851221257606484042652956267827527042103582138401817998484317090147751084140645935922861891946502301969712627060390112286498548692413675638854082746767615556998261778873625372575511704320589333963130560858950109780981665146820923938000446283595843981/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ], + [ + "163698198267763187271175317732354162942142798991132287897605537834861074139898973926663170112137318749861087075458509497866923709014367775583409379820255381037822285641799332965596998682187512678394888610812074850883841645394925104103931217581714852536893012837648469034763538149987146660169793180318525683963/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "34154907814115855601778002615718880203068084565931904547779687937911408288344869439590995495717368706638636414617448243280929199776252293685154663952500722290615662112290390816093868694604275838431637064859423302174318393837094657848778434379080583038727143019868879816065247203874832557642095346180510541817/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "125972697409629971610668644095806954773026269483836139794069300342348858033512225247311677027781101220433900638850299785029618718841248714192496025858197851778421685409754264599923508300047622246726630559684778235132368096407527643305232066166954976575730325609055979040383084148029612053926198944646591312277/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "15167790659874947924589060300057100404989113576637779018845337397852208471948163165837442910874732484685189549202575299032263922362242746686661085009319025178790114153139930066286476936454793858408781296809315075998603335912470151363640101092646280120351957483245267415973808462131927199015047640649421685169/22471164185778948846616314884862809170224712236778832159178760144716584475687620391588559665300942002640014234983924169707348721101802077811605928829934265547220986678108185659537777450155761764931635369010625721104768835292807860184239138817603404645418813835573287279993405742309964538104419541203028017152" + ], + [ + "13853536865015261579911150032049872304272006558508656999350196565098776518334784731805531655741656799427586114638867558728051351302042284720128353136488689847220369858233808059733505486343038607449224336533854935610047845464572670709769013819513710914519750342782309697087053886069773135656466958608061541769/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "177545851147179895490196191648273709559870852473948635168982933050035672511543664292889660396400875012049726711091359491491643948309945736293014186853449971590825791166882789030071391843162221062181697202769315484013800917514554939433749527198631298084673567294376435632058165815416832640235572073617726120941/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-52210378056113995222526794456200026551550434350267615704607002484161409961625123864247636241912256583356359184500954597575895892110205892926433892520877857803012652172002684435938465544783335544671181399418477865628149454975798200306362483024809010252305140774988065045567446320437361416053738363358747644443/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "87648308710707093471187039917458706451472578491021738770540393300719242093206053400276097328660396266053722682800563211432811793974391639650142917556304518681178604701687327846402527191048522814812999729648713916842250073122954579935163661634587626288322854319550536493507991774193503157659239580292987842157/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608" + ], + [ + "-116664073824034912718051835779935450320038013857443941308097484208019490686854521720422334021093095268154662714097019061138743852755115144088228123078315232346900394049166264273018455963049040513237001187564736700035245183063339192035351382225907798789582613795974065118752512750692942562782534375193614661861/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "149449269678260753521945326074791968079519019469792743136375292271466248404832296872514640066703937306939051683043529915596390678603913779661604066173180108039752595884583226240160259044735240089986116711339120429442816430176353855415258845446067522565220002881930958366647672375789662340506634532555558066251/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-85610957404387028634243322426648242688663257839375635069698465559559419377521551982033761821736612609921595358004172251326835155119996617686944093557730406618580170261786725657706867217353963671009491290423195732204000640025294244393939752267572032643929785491689258684316664163295188812404572449637311320451/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "99615833663101054301816080147826293655285718447019552564330413357835145945778960092597289825973787281964918942430276502793281215764935713502351704443126657759517272838966727793208748184206115834330960302736430555573552466912693730743584134891685941797179902285300308856534717258649051539716231977831990434935/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-206470925126790414958903095327931072696188278347167769164325237872418927430185815104414777620540205015448274164195641352218542457975169039791010753378777708716944076446597350330115681723054142766603880278838717720575430103778172708862328494065918713903827091679242299103863352097855468435963485647011288487845/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "28326730094049526360308020645864856724598891128838513609367588904514833835204347361667185978800994436970191543152173345365891935121884286237303162650500563575271973969509154285033455092089962932786873166080400502570268738193931444116625301385853996639117280974700258567439169279262226550039720244993440086577/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-212793201622109962448330100692808593439645159644577548679667883054110536914612983822159045347472254754395342771708966598767283083523909873556284381276124835470115664134649247694090104295004718385271153849431718533152316853933967919972046963990390480364949318130626453951329110678301062337081449200475601735875/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-57964249005932469131896837719919287256295100537523457777437606447238450243954529094264672294496860934864424519386491456408615251057823684209861120741434670159618673936343232127524840096572869938406481577342691505214852241781904532730223280532007263456890157126325151281429988053858853115810915974956182248013/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-181906514405143036384357434995971625275836390798303598349017616251000415282024441569357952686816616444878672327665448828051994214624348737805868406889846662816154885625310561267277397135353478192043756460106331313083421328902239020972755544322708347048855909898995764083966273823919667161396109476550719848725/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-147945663340461763698212430143771286414026284146309945071685010721085537380641268203814890803383015075422455405339014135542776026293391412163500686456905034790428849048670266153134094858649998069511486106390629359568273414843847740088984032890568291491121209596476991217967574780912075401622245788540973317237/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "-109295650712632922954470152700014140962344687784228817505917409852933900860213282982253187319663670767937851495649957296830456277490544817826798947725684889752695688092754004821393186285277520453649669774004548684876352062161227459330029625465970767406457202300678613241928430071212855440266575276167464763807/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "-56200741848002868079111868432724886507129621548125121648642474266599250489673841691778046881437449293933434722648357280706913445930283045991236908716738562916199191451345481529063774448710946467551285759609323141571550416355308596877200595274065373565280076263027603986562578831336689401091825392816459762247/44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + ], + [ + "15968822176892792285891476438139425317687583108455281192008770761103687215213981897594608046751009662616135817210933151016991807601573680585709456982599855455736137633949541869722566316681492518193528500018722529515726386747292338115274696063766393314538517893691137581991598848479112650484943606294759671/1404447761611184302913519680303925573139044514798677009948672509044786529730476274474284979081308875165000889686495260606709295068862629863225370551870891596701311667381761603721111090634735110308227210563164107569048052205800491261514946176100212790338675864723330454999587858894372783631526221325189251072", + "-266324790638046954468748086815326096854011998014910958879637384810491281671701735342579622902906841022217262017537242815542832447116697353634706329017518582629343845840130883918382746688279956080610789278337184153491906948023245930590272626869013417164765399270940382908317755754807962553226947387458433481969/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "1060865642031292630770255648031651464303955219241748845301061404301449150107131123877033982501236564870546734157170738071205142825981730629211934466958373310795930234883644313113012070731987912222503770737372313560840648279391481374684780737322726034313967342539259478356716096981485614792922808816297076935/1404447761611184302913519680303925573139044514798677009948672509044786529730476274474284979081308875165000889686495260606709295068862629863225370551870891596701311667381761603721111090634735110308227210563164107569048052205800491261514946176100212790338675864723330454999587858894372783631526221325189251072", + "-246799233700152837800565619104070457222176842192478672102595825359550055541867252492449227477274629665694532828700249246838030620913792598556947021011742874894999694125075108903854687975235844168506798118891370394456073402356817011957930168970746212902758217822556747842079095849448037149783703853881509351465/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "74864797941206513281047175374406371423373655545874336711328481273747977974984455616940936075339467433634151221026156653070150698647294564580345247390350645817572015177013890581338145235391049860293804890641833349803840457797326162410138640935908664989180260619163393823243511563841284652103776498758852275761/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216", + "158507016237416030279508951176317259509379692049347194102510424353036380843727700204504205980624447511489013333078714007658126019484831026660454241743943509290714726174111157436372813963025263036212831092360360315950519574485871493725846468575071813444421951074798721371147434849601216160281721594412331444679/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ], + [ + "126287595802823388378145790573347116516250877023657551588569070335106577368621778092749228800089231992059072999369812292461321688715048725080489109408634374024142218044000898630952519239661477382516567361587110636505950019813691734756152201601098996057298499115007197346303456331071237494888612444968034206643/89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608", + "-143526397691224128056251209454968080411106577138808675995376721394908697117978740021220231248704896684803444156609685788793425078524968774144075750535259582404256698559171991950020896681595928832179228331976729295065837037698098662420392076528307364731612360503267270299597486337931330781272500922478650324859/179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216" + ] + ], + "beta": "1/512", + "factor_bits": 1024, + "working_bits": 768, + "target_bits": 128 + } +] diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/NOTICE.md b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/NOTICE.md new file mode 100644 index 0000000000..22fbeb8ef0 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/NOTICE.md @@ -0,0 +1,24 @@ +# Attribution and scope + +Ali Romman's PR621, exact head 520774462b19b29af41554b74def31f9d01e997e, +supplies the prime-power kernel circle bound. Its kernel attribution is +OpenAI's exact-DFT preprint at adc7f1241b42e322a6451854ab7e4b4c146bf78a +(`loc:newton`, `loc:fourier-factorization`) and classical q-Pochhammer/Newton +factorization, including Alexey Kuznetsov's cited q-calculus work. This +package does not claim to originate those constructions. + +Pan's approximate-factorization theorem is used in the form stated by +Mehlhorn, Sagraloff and Wang; Brent's work supplies fast elementary-function +evaluation. Causal/anticausal recursive filtering is standard, as illustrated +by the Briand-Davy source listed in SOURCE.json. Sources are cited for these +specific tools, not as proofs of this package's complete claim. + +The scan rounding analysis, explicit budget composition, interval and +factor certificates, routed reference execution, and packaging were +prepared with substantial OpenAI Codex assistance for chafreaky. The dense +matrix solver and algebraic coefficient crosschecks provide independent +computational paths, not human peer review or formal Lean verification. + +No new multiplication exponent, literature priority, maintainer acceptance, +physical tape execution, or production performance result is claimed. +The code and documents use the repository's Apache-2.0 license. diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/README.md b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/README.md new file mode 100644 index 0000000000..89182e5b96 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/README.md @@ -0,0 +1,70 @@ +# Uniform rounded cyclic inversion, with charged preparation and layout + +This package advances the inversion step following PR621's circle bound. +It gives a uniform algorithm in the standard bit model for a prime-power +kernel applied to neighboring cyclic shifts. It makes **no new integer +kappa, complex b, BIT c, full multiplication, or practical-speedup claim**. + +The main result in [PROOF.md](PROOF.md) uses precision `p+O(r^4)`, independent +of cyclic length `L`, and `O(r)` sequential array passes. With conservative +exact factor-product verification, its bit bound is +`soft-O((Lr+r^3)(p+r^4))`. Approximate factor preparation uses Pan's published +theorem, and elementary-function preparation uses standard fast algorithms. +Those worst-case algorithms are not implemented by the exploratory root +nomination script. Exact rational phases and certified approximations of +unit phases have explicit error and preparation budgets. + +The package separates six claims and their evidence: + +- [SCAN-PROOF.md](SCAN-PROOF.md): two rounded scans solve a stable first-order + periodic factor, with error independent of cycle length. +- [CERTIFICATE-PROOF.md](CERTIFICATE-PROOF.md): ten exact factor certificates + through radix 16, including inner roots and an irrational unit phase, each + achieving error at most `2^-128` for every cycle length. +- [PROOF.md](PROOF.md): the general preparation, stability and precision + argument, using the explicitly cited standard factorization theorem. +- [WEIGHTED-PROOF.md](WEIGHTED-PROOF.md): independently varying unit phases + at every position, with the same length-independent precision bound. + Each phase oracle and its input cost is charged. +- [DIRTY-PROOF.md](DIRTY-PROOF.md): inverse shears restore their input and + `ceil(log2(r-1))` borrowed dirty arrays exactly. The all-length error budget + uses `O(p+log(D+1)+r^5)` precision and `O(r^2)` factor calls. Clean scalar + arithmetic remains allowed; bit-level reversible compilation is not supplied. +- [LAYOUT.md](LAYOUT.md): arbitrary strides via two charged merge sorts. + Their `O(L(B+log L)log L)` cost can become `O(Lp^2)` when `B` and `log L` + scale with `p`; this is not a free tape permutation. + +The reference verifier uses exact rational and outward interval arithmetic. +It does not trust floating roots, use a hidden numerical library, or reuse +historical workspace artifacts. `nominate.py` only generates candidates; +verification imports neither that script nor its numerical root finder. + +## Replay + +Python 3.11 or newer, standard library only: + +```sh +bash research/prime-power-cyclic-scan/verify.sh /tmp/cyclic-scan-fresh +``` + +The output directory must be empty. The wrapper checks complete source +hash coverage, replays all certificates under isolated optimized Python, +requires byte-identical deterministic outputs, rechecks source pins, and +writes every stage log plus `RECEIPT.json`. + +Coverage includes 108 generic scan cases, 480 mixed-factor cases with 240 +independent dense comparisons, 345 budget instances, 8384 stride mappings, +43 routed executions, 116 varying-coefficient/phase cases with 72 dense +comparisons, 36 dirty-leaf cases, 120 dirty compositions, 24 actual-kernel dirty +cases, 1035 dirty precision budgets, and 48 malformed or corrupted controls +in total. +Small samples support the reference implementation; the written arguments +and exact certificates establish the stated all-length bounds. + +The remaining application work includes the transform's complete layout +and phase collection, composition through its recursion and precision +guard, normalization, and scheduling enough distinct borrowed arrays for +the new dirty-shear contract. Common-label realization and reversible bit +arithmetic remain open. The sorting route +does not by itself meet a faster application's I/O target. Source and +assistance attribution are in [NOTICE.md](NOTICE.md) and [SOURCE.json](SOURCE.json). diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/SOURCE.json b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/SOURCE.json new file mode 100644 index 0000000000..59bddaea4d --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/SOURCE.json @@ -0,0 +1,18 @@ +{ + "upstream_kernel_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/621", + "upstream_kernel_head": "520774462b19b29af41554b74def31f9d01e997e", + "upstream_proof_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/520774462b19b29af41554b74def31f9d01e997e/research/prime-power-cyclic-inverse/PROOF.md", + "upstream_proof_sha256": "2b8056c88e66f692f407450fff0414d41bcd09db8597be22e274a6c3dc20eb9e", + "factorization_primary": "https://arxiv.org/pdf/1301.4870", + "factorization_result": "Theorem 2 and Corollary 1, PDF page 8, crediting Pan", + "elementary_functions_primary": "https://maths-people.anu.edu.au/~brent/pub/pub034.html", + "recursive_filter_primary": "https://www.ipol.im/pub/art/2019/257/article_lr.pdf", + "local_provenance": { + "stable-cyclic-scan": "bc36a9d44893f9cd25225b64b08f1f3e938a248f39c16fa50d71e84eb0a1b0ef", + "stable-cyclic-mixed": "df063d9ec36d95a65119af4518137f78935ac6fac0e88de11e6a7212492afe4a", + "uniform-neighbor-cyclic-inverse": "1f8fc021a466d03d62ccf708ef6cc83d2b38b340b50893fbcceb39c704922a71" + }, + "base_commit": "ed49217ad6244f1d3bfe4588f122fa861849739c", + "reference_runtime": "Python standard library; no external packages or historical workspace files required.", + "unimplemented": "Pan worst-case factorizer, fast elementary-function implementation, literal tape simulator, dirty-scratch restoration, complete multiplication reduction." +} diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/check.py b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/check.py new file mode 100644 index 0000000000..5ef6dd67b6 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/check.py @@ -0,0 +1,178 @@ +"""Rational proof of mixed inside/outside cyclic factor inversion.""" +from pathlib import Path +from fractions import Fraction as F +import argparse,importlib.util,json,math,sys +sys.set_int_max_str_digits(100000) +P=Path(__file__).resolve().parent +def module(name): + s=importlib.util.spec_from_file_location(name,P/(name+'.py'));m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m +c=module('scan');ik=module('interval_kernel') + +def prime_power(r): + if type(r)!=int or r<3:return False + p=next((d for d in range(2,math.isqrt(r)+1) if r%d==0),r) + while r%p==0:r//=p + return r==1 + +def certify(data): + r,k=data['radix'],data['embedding'] + c.need(prime_power(r) and type(k)==int and 00 and type(target)==int and target>0,'precision budget') + c.need(type(fb)==int and 0=F(1,2),'gauge chart') + parameters=[im/(1+re) for im in v[1] for re in v[0]] + mid=(min(parameters)+max(parameters))/2 + t=c.rounded((mid,F(0)),1024)[0] + sigma=c.mul(center,((1-t*t)/(1+t*t),2*t/(1+t*t))) + c.need(c.norm2(sigma)==1,'exact rational unit phase') + error=sum(max(abs(endpoint-coordinate) for endpoint in iv) for iv,coordinate in zip(box,sigma)) + c.need(error0) + for name in ('unit_root','missing_root','wrong_embedding','low_precision','bad_margin'): + row=json.loads(json.dumps(mixed)) + if name=='unit_root':row['roots'][0]=['1','0'] + if name=='missing_root':row['roots'].pop() + if name=='wrong_embedding':row['embedding']=row['radix'] + if name=='low_precision':row['working_bits']=8 + if name=='bad_margin':row['beta']='1' + try:certify(row) + except ValueError as error:controls.append(dict(name=name,rejected=str(error))) + else:raise ValueError('bad control accepted '+name) + state=certify(mixed);x=[c.ONE,c.ZERO,(F(1,2),F(1,4))] + bad=apply(x,state,1,omit_inner_shift=True) + try:residual_check(x,bad,state,1) + except ValueError as error:controls.append(dict(name='omitted_inner_shift',rejected=str(error))) + else:raise ValueError('inner-shift mutation accepted') + try:apply(x,state,1,(F(1),F(1))) + except ValueError as error:controls.append(dict(name='nonunit_gauge',rejected=str(error))) + else:raise ValueError('nonunit gauge accepted') + args.out.write_text(json.dumps(dict(status='passed',kernel_crosschecks=crosschecks,irrational_gauge=gauge_record,certificates=certificates,cases=cases,controls=controls),indent=2)+'\n') + print(json.dumps(dict(status='passed',certificates=len(certificates),cases=len(cases),dense_cases=sum(row['dense_comparison'] for row in cases),controls=len(controls)))) + +if __name__=='__main__':main() diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr628/dirty.py b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/dirty.py new file mode 100644 index 0000000000..2b94710837 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr628/dirty.py @@ -0,0 +1,133 @@ +"""Integer lifting for cyclic inverse shears using borrowed dirty arrays. +Exact rational prototype. Arithmetic workspace and phase access are charged in the proof; +this is not a common-label Clifford word or a bit-reversible arithmetic compiler. +""" +from pathlib import Path +from fractions import Fraction as F +import importlib.util,json,argparse,itertools +P=Path(__file__).resolve().parent +s=importlib.util.spec_from_file_location('weighted',P/'weighted.py');w=importlib.util.module_from_spec(s);s.loader.exec_module(w);c=w.c + +def scaled(z,q):return(z[0]*q,z[1]*q) +def conj(z):return(z[0],-z[1]) +def ordered(n,d):return range(n)if d==1 else range(n-1,-1,-1) + +def lift(x,y,coefficient,beta,bits,d,sign=1,destination=None,multiplier=None,stats=None): + """y += sign*F(x), restoring x exactly; no length-dependent clean data array.""" + n=len(x);c.need(x is not y and n==len(y)>0,'distinct equally sized arrays') + c.need(d in(-1,1)and sign in(-1,1),'orientation and sign') + c.need(0=(beta/2)**2,'closure denominator') + seed=c.rounded(c.div(x[previous],denominator),bits) + power=c.ONE + for i in ordered(n,d): + power=c.rounded(c.mul(coefficient(i),power),bits) + value=c.add(x[i],c.rounded(c.mul(power,seed),bits)) + value=c.rounded(c.mul(multiplier(i),value),bits) + j=destination(i);y[j]=c.add(y[j],scaled(value,sign)) + # The scalar seed and coefficient scratch may be cleared by ordinary classical + # arithmetic. The dirty data itself is restored by exact inverse integer lifts. + first=0 if d==1 else n-1 + for i in ordered(n,-d): + if i!=first:x[i]=c.sub(x[i],c.rounded(c.mul(coefficient(i),x[i-d]),bits)) + if stats is not None:stats['leaves']+=1;stats['scalar_steps']+=3*n + +def leaf(x,y,factor,phases,beta,bits,d,sign,stats): + inside,b,scale=factor;n=len(x) + if inside: + lift(x,y,lambda i:c.mul(b,conj(phases[(i+d)%n])),beta,bits,-d,sign, + lambda i:(i-d)%n,lambda i:scaled(conj(phases[i]),scale),stats) + else: + lift(x,y,lambda i:c.mul(b,phases[i]),beta,bits,d,sign, + multiplier=lambda i:scaled(c.neg(b),scale),stats=stats) + +def compose(x,y,factors,scratch,phases,beta,bits,d,sign=1,stats=None): + """Balanced commutator; negative call is the exact inverse instruction word.""" + c.need(sign in(-1,1)and d in(-1,1),'orientation and sign') + c.need(factors and len(scratch)>=(len(factors)-1).bit_length(),'dirty depth') + arrays=[x,y]+scratch;c.need(len({id(v)for v in arrays})==len(arrays),'all ancestor arrays distinct') + c.need(len(x)>0 and all(len(v)==len(x)for v in arrays)and len(phases)==len(x),'array lengths') + c.need(all(c.norm2(t)==1 for t in phases),'unit phases') + if len(factors)==1:return leaf(x,y,factors[0],phases,beta,bits,d,sign,stats) + mid=len(factors)//2;B,A=factors[:mid],factors[mid:];z=scratch[0];rest=scratch[1:] + operations=[(x,z,B,1),(z,y,A,1),(x,z,B,-1),(z,y,A,-1)] + if sign==-1:operations=[(src,dst,fs,-sgn)for src,dst,fs,sgn in reversed(operations)] + for src,dst,fs,sgn in operations:compose(src,dst,fs,rest,phases,beta,bits,d,sgn,stats) + +def exact_operator(x,factors,phases,d): + # Dense rational oracle constructed independently from the lifting recurrence. + n=len(x);out=x[:] + for inside,b,scale in factors: + a=[[c.ZERO for _ in range(n)]for _ in range(n)] + if inside: + for i in range(n):a[i][i]=c.neg(b);a[i][(i-d)%n]=c.add(a[i][(i-d)%n],phases[i]) + else: + rho=c.div(c.ONE,b) + for i in range(n):a[i][i]=c.neg(rho);a[i][(i-d)%n]=c.add(a[i][(i-d)%n],phases[i]) + out=[scaled(z,scale)for z in w.solve(a,out)] + return out + +def certificate(n,beta,r,D,bits): + N=4*n*n;a=13*(r+1)/beta**3;G=2+F(r)/beta;u=F(1,1<4:raise ValueError('angle bound') + itheta=(point(0),theta) + total=term=ONE + # Taylor remainder for complex exp: <=exp(4)*4^(N+1)/(N+1)! <128*... + n=0 + while True: + n+=1;term=cmul(term,itheta);term=(scale(term[0],F(1,n)),scale(term[1],F(1,n)));total=cadd(total,term) + remainder=F(128*4**(n+1),math.factorial(n+1)) + if remainder 0, 'empty cycle') + need(direction in (-1, 1), 'invalid direction') + need(0 < beta <= 1, 'invalid margin') + need(norm2(b) <= (1-beta)**2, 'uncertified stable factor') + u = F(1, 1 << bits) + need(u <= beta*beta/2, 'precision too low for closure') + order = list(range(len(x))) if direction == 1 else list(reversed(range(len(x)))) + z, power = ZERO, ONE + for i in order: + z = rounded(add(x[i], mul(b, z)), bits) + power = rounded(mul(b, power), bits) + den = sub(ONE, power) + need(norm2(den) >= (beta/2)**2, 'closure lower bound failed') + seed = rounded(div(z, den), bits) + y, previous = [ZERO]*len(x), seed + for i in order: + previous = rounded(add(x[i], mul(b, previous)), bits) + y[i] = previous + return y + +def dense_solve(x, b, direction): + """Independent exact Gaussian elimination on the cyclic matrix.""" + n = len(x) + a = [[ZERO for _ in range(n)] + [x[i]] for i in range(n)] + for i in range(n): + a[i][i] = add(a[i][i], ONE) + j = (i-direction) % n + a[i][j] = sub(a[i][j], b) + for k in range(n): + pivot = next(i for i in range(k, n) if a[i][k] != ZERO) + a[k], a[pivot] = a[pivot], a[k] + p = a[k][k] + a[k] = [div(v, p) for v in a[k]] + for i in range(n): + if i == k: continue + p = a[i][k] + a[i] = [sub(v, mul(p, w)) for v, w in zip(a[i], a[k])] + return [row[-1] for row in a] + +def residual_bound(x, y, b, beta, direction, bound): + # Neumann inverse norm <= 1/beta converts residual to forward error. + for i in range(len(x)): + residual = sub(sub(y[i], mul(b, y[(i-direction) % len(x)])), x[i]) + need(norm2(residual) <= (beta*bound)**2, 'residual error bound failed') + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--out', type=Path, required=True) + args = parser.parse_args() + cases = [] + for beta in (F(1, 2), F(1, 16), F(1, 4096)): + for unit in (ONE, (F(-1), F(0)), (F(3, 5), F(4, 5))): + b = mul((1-beta, F(0)), unit) + for n in (1, 2, 3, 8, 17, 64): + x = [(F((i*7)%13-6, 8), F((i*11)%17-8, 16)) for i in range(n)] + B = max(abs(v[0])+abs(v[1]) for v in x) + for direction in (-1, 1): + bits = 64 + bound = 6*(B+1)*F(1, 1 << bits)/beta**3 + y = scan(x, b, beta, bits, direction) + residual_bound(x, y, b, beta, direction, bound) + if n <= 8: + exact = dense_solve(x, b, direction) + need(all(norm2(sub(v,w)) <= bound**2 for v,w in zip(y,exact)), 'dense comparison failed') + cases.append(dict(beta=str(beta), b=[str(v) for v in b], length=n, + direction=direction, bits=bits, forward_error_bound=str(bound), + dense_crosscheck=n<=8, residual_check=True)) + controls = [] + for name, x, b, beta, bits, direction in ( + ('unstable', [ONE], ONE, F(1,2), 64, 1), + ('underprecision', [ONE], (F(15,16),F(0)), F(1,16), 3, 1), + ('empty', [], ZERO, F(1,2), 64, 1), + ('bad_direction', [ONE], ZERO, F(1,2), 64, 0), + ): + try: scan(x,b,beta,bits,direction) + except ValueError as error: controls.append(dict(name=name,rejected=str(error))) + else: raise ValueError('negative control accepted: '+name) + x = [ONE, ZERO, ONE] + b, beta = (F(1,2),F(0)), F(1,2) + y = scan(x,b,beta,64,1) + y[0] = add(y[0],ONE) + try: residual_bound(x,y,b,beta,1,F(1,1<<40)) + except ValueError as error: controls.append(dict(name='corrupt_output',rejected=str(error))) + else: raise ValueError('corrupt output accepted') + args.out.write_text(json.dumps(dict(status='passed',cases=cases,controls=controls),indent=2)+'\n') + print(json.dumps(dict(status='passed',cases=len(cases),dense_cases=sum(c['dense_crosscheck'] for c in cases),controls=len(controls)))) + +if __name__ == '__main__': main() diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr846/NOTICE.md b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/NOTICE.md new file mode 100644 index 0000000000..4dcef892b5 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/NOTICE.md @@ -0,0 +1,22 @@ +# Notice and attribution + +New material in this directory is by Rohan Guliani (@Rohansguliani) and is +released under Apache-2.0. Substantial AI assistance was used in the +derivation, implementation and writing. No human peer review or +proof-assistant verification is claimed. + +Predecessor work: + +* **#621, Ali Romman (aliromman).** Kernel and the `L`-uniform circle and + inverse bounds (`research/prime-power-cyclic-inverse`). +* **#628, Chafik Boukhalfa (chafreaky).** Certified approximate + factorization, preparation and phase budgets, the two-scan primitive, the + dirty-shear composition and the sort-route layout charge. The files in + `vendor/` are byte-identical to #628 head `0768f97d`. Its notice is + retained in `vendor/PR628-NOTICE.md`. +* **#764, Charles Bethin (cbethin).** The shared-suffix identity + `1-Q >= beta G` and the inverse-square scan bound, used in Lemma 1. No + #764 code is consumed. + +The two-stack queue and Euclidean stride reduction are standard techniques. +No literature-priority claim is made. diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr846/PROOF.md b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/PROOF.md new file mode 100644 index 0000000000..8987bfdfc4 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/PROOF.md @@ -0,0 +1,211 @@ +# Linear-traffic rounded inversion for every cyclic stride + +## Result and scope + +PR628 inverts PR621's kernel `P(tau Z_L^w)` for neighbouring strides with +precision `p+O(r^4)` that does not depend on `L`. For other strides it routes +the cycles into contiguous order with two merge sorts, at a cost of +`O(L(B+log L)log L)`. That sort cost brings back a `log L` traffic factor. +This note removes the sort. The solver below handles every stride `w` with +`O(L)` sequential record moves and `O(L)` rounded operations per factor. Its +error bound does not depend on `L`. + +**Theorem 1 (one stable factor, any stride).** Let `L>=1`, let `w` be any +integer, and let `0= g+2+log2(K+1)`, where `beta=2^-g`. Any execution +budget for target precision `p >= log2(log2 L + 2)` already meets it. + +## Algorithm + +Normalize `w` modulo `L`. If `2w>L`, reverse the arrays. Reversal turns the +stride into `L-w`, which is at most `L/2`. A tape reads one array backwards +while it writes another forwards, which costs `2L` record moves each way. +If `w=0`, return `x_i/(1-b_i)` rounded. + +Otherwise the residue classes modulo `w` form chains. Chain `c` contains +`c, c+w, c+2w, ...`. Each chain has at least two members because `w<=L/2`. + +1. **Pass A.** Scan `i=0..L-1`. Read the lag-`w` predecessor from a FIFO + that starts with `w` start markers. Compute the zero-seed value + `zhat_i = rnd(x_i + b_i zhat_(i-w))` and the chain product + `pihat_i = rnd(b_i pihat_(i-w))`. At a chain start, `zhat=x` and + `pihat=b` exactly. +2. **Closure.** The last `w` positions `e=L-w+k` are the chain ends. The + start of chain `c` has predecessor `c-w+L`, which is end `k=c`. Hence the + end values satisfy + + Y_k = zhat_(L-w+k) + pihat_(L-w+k) Y_((k+L) mod w). + + This is the same problem on `w` entries with stride `(-L) mod w`. + Solve it recursively. +3. **Pass C.** Scan `i=0..L-1` again. This time the FIFO starts with + `Y_0..Y_(w-1)`. Compute `yhat_i = rnd(x_i + b_i * pop())` and push it. + +Each level at least halves the length, so `sum_k L_k <= 2L` and +`K <= floor(log2 L)+1`. A FIFO built from two stacks moves each record at +most four times: a push, a transfer pop, a transfer push and a pop. A stack +on a tape keeps its head at the top. Pass A, the closure handoff, pass C and +the two reversals therefore cost at most a fixed multiple of `L_k` record +moves at level `k`. In the finite replay through `L=131072` the maximum is +29.68 per entry. For comparison, PR628's two sorts make +`4L ceil(log2 L)` record moves. A record holds the `O(B)` bits of one or +two numbers. Moving it costs `O(B)` tape cells. Loop counters need only +amortized `O(1)` bit changes per step, plus `O(log L)` per level for the +values `L_k` and `w_k`. Stride arithmetic over all levels costs +`O(log^2 L)` bit operations. + +## Proof of Theorem 1 + +**Notation.** `Shat_k` is the computed system at level `k`, with data +`xhat^k` and coefficients `bhat^k`. `Ytilde^k` is its exact solution, and +`m_k = min_i (1-|bhat^k_i|)` is its margin. `S*` is the exact Schur +complement of `Shat_k` on the chain ends. The solution of `S*` is the +restriction of `Ytilde^k` to those ends. + +**Lemma 1 (PR764's shared-suffix identity).** Let `q_1..q_l` lie in +`[0,1-m]`. Put `P_j = q_(j+1)...q_l` and `G = sum_j P_j`. Then + + sum_j (1-q_j) P_j = 1 - q_1...q_l, hence G <= (1-|pi|)/m. + +The quantity `pi` is the chain product. A rounded recursion multiplies its +previous error by `b` and adds at most `u`, so after a chain its error is at +most `uG`. Therefore + + |zhat_e - z_e| <= u(1-|pi_e|)/m_k, |pihat_e - pi_e| <= u(1-|pi_e|)/m_k. + +**Lemma 2 (margins never shrink below beta).** From Lemma 1, +`1-|pihat| >= (1-|pi|)(1-u/m_k)`. A chain has at least two members, so +`1-|pi| >= 1-(1-m_k)^2 = m_k(2-m_k)`. Hence `m_(k+1) >= f(m_k)` with +`f(m)=(2-m)(m-u)`. The function `f` is concave on `[beta,1]`. At the +endpoints, + + f(beta) = (2-beta)(beta-u) >= (3/2)(2beta/3) = beta when beta<=1/2 and u<=beta/3, + f(1) = 1-u >= beta. + +Therefore `m_k >= beta` at every level. The bound does not depend on depth. +The replay checks `|bhat|<=1-beta` exactly at every level of all 2052 +generic cases. + +**Lemma 3 (weighted data).** Suppose `|xhat^k_i| <= A_k(1-|bhat^k_i|)`. +Then the telescoping identity gives `|z_e| <= A_k(1-|pi_e|)`. Lemma 1 adds +at most `u(1-|pi_e|)/m_k`, and Lemma 2 compares `1-|pi|` with `1-|pihat|`. +Together they give the same invariant at level `k+1` with + + A_(k+1) = (A_k + u/beta)/(1-u/beta), A_0 = B/beta. + +The admission condition `4(K+1)u <= beta` gives `A_k <= 2A_0+1` at every +level. + +**Lemma 4 (weighted inverse).** Suppose `|v_i| <= C(1-|b_i|)`. Then the +solution of `Y = v + b W Y` satisfies `|Y_i| <= C`. The Neumann series has +weights `P_j(1-q_j)`, and these telescope to at most one. In particular, +`|Ytilde^k| <= A_k`. + +**Error recursion.** `Shat_(k+1)` differs from `S*` only by the pass-A +rounding. The two solutions satisfy + + (I - Bhat W)(Ytilde^(k+1) - Y*) = Delta x + Delta B * W Y*. + +By Lemma 1, each entry of the right side is at most +`(u/beta)(1+A_k)(1-|pi_e|)`, and `1-|pi_e| <= (1-|pihat_e|)/(1-u/beta)`. +Lemma 4 then bounds the solution difference by +`(u/beta)(1+A_k)/(1-u/beta) <= 2(u/beta)(1+A_k)`. Pass C seeds every chain +with the closure value. The seed error is multiplied by the chain prefix +product. That product contains at least one coefficient, so its modulus is +at most `1-beta`. Pass C's own rounding adds at most `u/beta`. Let +`e_k = |Yhat^k - Ytilde^k|`. Then + + e_k <= (1-beta)(e_(k+1) + 2(u/beta)(1+A_k)) + u/beta, + e_K <= u (base case: one exactly rounded division, |1-b|>=beta). + +Sum this recursion. At level 0 the data are exact, so `Ytilde^0 = y`. With +`A_k <= 2B/beta+1` and `sum_(k= log2(log2 L+2)`. + +## Not closed here + +* PR628's dirty-array contract allows `ceil(log2(r-1))` borrowed arrays and + only `O(1)` clean scalars. That contract arises in the exact-width word + model. The stride solver here uses blank scratch tape, which is free in + the sequential-tape model and is erased at linear cost. It has not been + recast for borrowed arrays. That case still uses PR628's + `O(p+log(D+1)+r^5)` precision and neighbouring-stride leaves. +* The guard `O(r^4)` is a proof bound. Numerical probes for `r<=32` put + `min_|z|=1 |P(z)|` near `2^-10`, while PR621's bound gives up to + `2^-27880`. A sharper lower bound would shrink every budget above. + This package does not certify those probe values. +* Composition across the complete transform, the transform's phase + collection, normalization and the integer-multiplication reduction remain + open. No integer kappa, complex b, or BIT c changes. diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr846/README.md b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/README.md new file mode 100644 index 0000000000..f33410800c --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/README.md @@ -0,0 +1,81 @@ +# Cyclic inverse stride bridge + +This package continues the open obligation recorded for #621 in +[the K492 review](../../docs/research/community-k492-review.md). That +obligation is to pay for efficient preparation, rounded execution, +restoration and tape before using #621's length-independent inverse bound. + +#628 pays for preparation and neighbouring-stride execution. #764 sharpens +the scan rounding. Both PRs are still open and are pinned in +[SOURCE.json](SOURCE.json). For any stride other than ±1, #628's route +depends on two merge sorts costing `O(L(B+log L)log L)`. Those sorts bring +back a `log L` factor that the inverse bound was supposed to remove. + +[PROOF.md](PROOF.md) replaces the sorts with a Euclidean chain/closure +recursion. A FIFO built from two stacks gives every pass a lag-`w` +predecessor in natural order. Theorem 1 gives one stable factor at any +stride with: + +* at most `40L` sequential record moves; +* `O(L)` rounded operations; +* an error bound `min(K,1/beta)(u/beta)(5+4B/beta)+u` that holds for every + `L`. + +The proof reuses #764's shared-suffix identity. It also shows that margins +do not shrink across recursion levels. Theorem 2 composes the solver with +#628's certified factorization. The kernel precision is +`p+(n+2)g+O(log r)=p+O(r^4)`, with no `L` term. One admission condition, +`p >= log2(log2 L+2)`, depends on `L`. The table in PROOF.md charges every +listed cost. + +**Verdict:** consider one inverse of `P(tau Z_L^w)` on fixed sequential +tapes, with all four listed costs paid. Its cost per entry still does not +depend on `L`, so #621's gain survives. Three things are not claimed: + +* a borrowed-array (dirty) form of the stride solver; +* composition across the complete transform; +* any change to integer kappa, complex b, or BIT c. + +## Replay + +Python 3.11 or later with the standard library only. The replay takes +about 100 seconds: + +```sh +python3 -B -I -O research/cyclic-inverse-stride-bridge/verify.py --check +``` + +Expected: `PASS_CYCLIC_INVERSE_STRIDE_BRIDGE generic=2052 kernel_cases=300 +controls=4 max_records_per_entry=29.671875`. + +The replay covers the following checks: + +* **Generic cases (2052).** `L=1..18`, every stride in `[-L,L)`, + `beta in {1/4,1/8,1/32}` and two grids. Each case is compared exactly + with an independent per-cycle geometric-closure oracle against Theorem 1. + The margin `|bhat|<=1-beta` is checked at every recursion level. +* **Traffic.** Count-only runs reach `L=131072`. Strides include `0`, `±1`, + `L/2`, `L/2+1`, golden-ratio strides and the prime `L=99991`. Every run is + checked against `40L` record moves. The maximum observed is + 29.68 moves per entry, compared with #628's + sort route of `4L ceil(log2 L)`. +* **Kernel cases (300).** These use all ten #628 certified kernels, radix 3 + through 16. Gauges are `1` and `3/5+4i/5`. Lengths are 1, 2, 3, 5 and 8, + with all strides for `L<=5`. Each case evaluates Theorem 2's exact budget + against the target together with #628's perturbation bound. Each also + checks the expanded polynomial residual. 81 cases are compared with an + independent dense Gauss–Jordan solve. +* **Controls (4).** + * a rotated closure reseed; + * a precision below the admission condition; + * a unit coefficient; + * a wrong inner-shift direction. + + The replay rejects all four. + +The vendored #628 files must match the hashes in SOURCE.json byte for byte. +The verifier refuses drift. `--write` regenerates `EXPECTED.json`. + +Finite cases support the reference implementation. The written proof +carries the all-`L` claims. The Python lists model sequential tapes and +count record moves; they are not a literal Turing machine. diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr846/SOURCE.json b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/SOURCE.json new file mode 100644 index 0000000000..e1624e72dd --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/SOURCE.json @@ -0,0 +1,15 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "pr621": {"url": "https://github.com/CrocSwap/integer-mult-bounds/pull/621", "head": "520774462b19b29af41554b74def31f9d01e997e", "author": "Ali Romman (aliromman)", "use": "circle lower bound and L-uniform inverse bound; on main at research/prime-power-cyclic-inverse"}, + "pr628": {"url": "https://github.com/CrocSwap/integer-mult-bounds/pull/628", "head": "0768f97d06c623b8211e651543c66135796b62bf", "author": "Chafik Boukhalfa (chafreaky)", "use": "certified factors, preparation and perturbation budget, dirty-shear composition, sort-route layout charge; vendored files below are byte-identical to that head"}, + "pr764": {"url": "https://github.com/CrocSwap/integer-mult-bounds/pull/764", "head": "983d66f0f2e48ee500ec7eee2da9244c001c5064", "author": "Charles Bethin (cbethin)", "use": "shared-suffix identity 1-Q >= beta*G, reused in Lemma 1; no code consumed"}, + "vendored_sha256": { + "check.py": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d", + "FACTORS.json": "643d60ac24d5e67f6c9305175bd1c99bf5e42edfef6d1995c051e0b98ba446a7", + "interval_kernel.py": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe", + "scan.py": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e", + "PR628-NOTICE.md": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68" + }, + "two_stack_queue": "standard amortized queue from two stacks (folklore; e.g. Okasaki, Purely Functional Data Structures, 1998)", + "unimplemented": "Pan worst-case factorizer, fast elementary functions, a literal Turing-machine tape, borrowed-array (dirty) form of the stride solver, transform-level composition and the multiplication reduction." +} diff --git a/research/dirty-stride-precision/vendor/pr985/vendor/pr846/stride.py b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/stride.py new file mode 100644 index 0000000000..9229a4193b --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/vendor/pr846/stride.py @@ -0,0 +1,168 @@ +"""Rounded stride-w cyclic first-order solver with linear sequential traffic. + +Solves y_i = x_i + b_i * y_((i-w) mod L) for |b_i| <= 1-beta by a +Euclidean chain/closure recursion. Every array pass is in natural order +(or its reverse) and reads the lag-w predecessor from a FIFO built from two +stacks, which a fixed number of sequential tapes implement with amortized +O(1) record moves. See PROOF.md. Exact rational arithmetic is used; the only +inexactness is the explicit nearest-dyadic rounding on a grid of spacing u. +""" +from fractions import Fraction as F + +ZERO = (F(0), F(0)) +ONE = (F(1), F(0)) + + +def add(a, b): return (a[0] + b[0], a[1] + b[1]) +def sub(a, b): return (a[0] - b[0], a[1] - b[1]) +def mul(a, b): return (a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]) +def norm2(a): return a[0] * a[0] + a[1] * a[1] + + +def div(a, b): + d = norm2(b) + if not d: + raise ValueError('zero divisor') + c = mul(a, (b[0], -b[1])) + return (c[0] / d, c[1] / d) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def rounded(a, bits): + """Nearest point of the grid 2^-bits in each component, ties upward.""" + if bits is None: + return a + scale = 1 << bits + + def component(v): + w = v * scale + F(1, 2) + return F(w.numerator // w.denominator, scale) + return (component(a[0]), component(a[1])) + + +class Tape: + """Counts sequential record traffic. One unit is one B-bit record moved + past a tape head (read or write). Stacks are tapes whose head sits at + the top; a FIFO is two stacks; reversal copies one record per unit.""" + + def __init__(self): + self.records = 0 + self.levels = [] + + +class Fifo: + def __init__(self, tape, initial): + self.tape = tape + self.inbox = [] + self.outbox = [] + for v in initial: + self.push(v) + + def push(self, v): + self.tape.records += 1 + self.inbox.append(v) + + def pop(self): + if not self.outbox: + while self.inbox: # one transfer per record, amortized O(1) + self.tape.records += 2 + self.outbox.append(self.inbox.pop()) + self.tape.records += 1 + return self.outbox.pop() + + +def solve(x, b, w, bits, tape, trace=None, level=0): + """Return the rounded solution. trace collects per-level (L, w, data, + coefficients) for invariant checks. Values may be None in count-only + mode (structure and traffic only).""" + L = len(x) + need(L >= 1 and len(b) == L, 'shape') + w %= L + if 2 * w > L: # reverse orientation: stride L-w <= L/2 + tape.records += 2 * L # read backwards, write forwards + y = solve(x[::-1], b[::-1], L - w, bits, tape, trace, level) + tape.records += 2 * L + return y[::-1] + tape.levels.append((L, w)) + if trace is not None: + trace.append(dict(level=level, length=L, stride=w, x=x, b=b)) + count_only = x[0] is None + if w == 0: # every point is its own cycle + tape.records += 2 * L + if count_only: + return [None] * L + return [rounded(div(xi, sub(ONE, bi)), bits) for xi, bi in zip(x, b)] + # Pass A: zero-seed chains along +w, with rounded chain products. + fifo = Fifo(tape, [None] * w) + z = [None] * L + p = [None] * L + for i in range(L): + tape.records += 2 # read x_i, b_i + prev = fifo.pop() + if count_only: + fifo.push(None) + continue + if prev is None: + z[i], p[i] = x[i], b[i] + else: + z[i] = rounded(add(x[i], mul(b[i], prev[0])), bits) + p[i] = rounded(mul(b[i], prev[1]), bits) + fifo.push((z[i], p[i])) + # Closure system on the w chain ends: Y_k = c_k + a_k Y_((k+L) mod w). + c, a = z[L - w:], p[L - w:] + tape.records += 2 * w # the ends are the tail of the pass-A output + Y = solve(c, a, (-L) % w, bits, tape, trace, level + 1) + # Pass C: reseed chain starts from the closure values (Y_k feeds start k). + fifo = Fifo(tape, Y) + y = [None] * L + for i in range(L): + tape.records += 3 # read x_i, b_i; write y_i + prev = fifo.pop() + if not count_only: + y[i] = rounded(add(x[i], mul(b[i], prev)), bits) + fifo.push(y[i]) + return y + + +def levels(L, w): + """Number of non-base recursion levels K (stride halves every level).""" + K = 0 + while True: + w %= L + if 2 * w > L: + w = L - w + if w == 0: + return K + L, w, K = w, (-L) % w, K + 1 + + +def exact_cycle_solve(x, b, w): + """Independent oracle: per-cycle finite geometric closure.""" + L = len(x) + y = [None] * L + for i in range(L): + total, weight, j = ZERO, ONE, i + while True: + total = add(total, mul(weight, x[j])) + weight = mul(weight, b[j]) + j = (j - w) % L + if j == i: + break + y[i] = div(total, sub(ONE, weight)) + return y + + +def solve_error_bound(B, beta, bits, K): + """PROOF.md, Theorem 1: kappa*(u/beta)*(5+4B/beta)+u, kappa=min(K,1/beta).""" + u = F(1, 1 << bits) + kappa = min(F(max(K, 1)), 1 / beta) + return kappa * (u / beta) * (5 + 4 * B / beta) + u + + +def admitted(beta, bits, K): + u = F(1, 1 << bits) + return beta <= F(1, 2) and u <= beta / 3 and u * 4 * (K + 1) <= beta diff --git a/research/dirty-stride-precision/vendor/pr985/verify.py b/research/dirty-stride-precision/vendor/pr985/verify.py new file mode 100644 index 0000000000..56648ad570 --- /dev/null +++ b/research/dirty-stride-precision/vendor/pr985/verify.py @@ -0,0 +1,323 @@ +"""Check the dirty stride construction with exact arithmetic.""" +import argparse +import hashlib +import importlib.util +import json +import math +from pathlib import Path +import sys +from fractions import Fraction as F + +HERE = Path(__file__).resolve().parent +if hasattr(sys, 'set_int_max_str_digits'): + sys.set_int_max_str_digits(0) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +d = load(HERE/'dirty_stride.py', 'dirty_stride') + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')) + + +def pins(): + source = json.loads((HERE/'SOURCE.json').read_text()) + for row in source['sources']: + data = (HERE/row['local']).read_bytes() + d.need(hashlib.sha256(data).hexdigest() == row['sha256'], 'source SHA256: '+row['local']) + blob = b'blob '+str(len(data)).encode()+b'\0'+data + d.need(hashlib.sha1(blob).hexdigest() == row['blob'], 'source Git blob: '+row['local']) + return len(source['sources']) + + +class Bank: + """Allow indexed reads and writes. Refuse iteration and array copies.""" + def __init__(self, values): + self.values = list(values) + self.peak_l1 = max(abs(a)+abs(b) for a, b in self.values) + + def __len__(self): + return len(self.values) + + def __getitem__(self, index): + if type(index) is not int: + raise ValueError('data slice is not allowed') + return self.values[index] + + def __setitem__(self, index, value): + if type(index) is not int: + raise ValueError('data slice is not allowed') + self.values[index] = value + self.peak_l1 = max(self.peak_l1, abs(value[0])+abs(value[1])) + + def __iter__(self): + raise ValueError('data iteration is not allowed') + + +def values(length, bits, salt): + scale = 1 << bits + return [(F(2*((5*i+salt) % 13)-11, 8)+F(1, scale), + F(2*((7*i+salt) % 11)-9, 16)+F(1, scale)) for i in range(length)] + + +def magnitude(arrays): + return max(abs(a)+abs(b) for array in arrays for a, b in array) + + +def digest_arrays(arrays): + data = [[[str(a), str(b)] for a, b in array] for array in arrays] + return hashlib.sha256(canonical(data).encode()).hexdigest() + + +def cycle_oracle(source, coefficient, stride): + """Sum the finite geometric inverse. Do not use the recursive solver.""" + n = len(source) + count = n//math.gcd(n, stride) + ar, ai = coefficient + result = [] + for i in range(n): + sr = si = F(0) + wr, wi = F(1), F(0) + for k in range(count): + xr, xi = source[(i-k*stride) % n] + sr, si = sr+wr*xr-wi*xi, si+wr*xi+wi*xr + wr, wi = wr*ar-wi*ai, wr*ai+wi*ar + rr, ri = 1-wr, -wi + den = rr*rr+ri*ri + result.append(((sr*rr+si*ri)/den, (si*rr-sr*ri)/den)) + return result + + +def geometry_check(limit=128): + cases = levels = 0 + for length in range(1, limit+1): + for stride in range(length): + divisor = math.gcd(length, stride) + cycle = length//divisor + inv = pow(stride//divisor, -1, cycle) if cycle > 1 else 0 + geo = d.Geometry(d.ZERO, divisor, cycle, inv, 64, d.Meter()) + weights = [1]*length + w, orientation = stride, 1 + while True: + n = len(weights) + w %= n + if 2*w > n: + weights.reverse() + w, orientation = n-w, -orientation + a, b = geo.exponents(n, w, orientation) + d.need(weights == [b if i < w else a for i in range(n)], 'return-time geometry') + levels += 1 + if w == 0: + break + weights = [sum(weights[j] for j in range(i % w, i+1, w)) + for i in range(n-w, n)] + w = (-n) % w + cases += 1 + return dict(lengths=[1, limit], cases=cases, levels=levels) + + +def power_check(): + cases = nonzero = 0 + for beta in (F(1, 2), F(1, 16), F(1, 4096)): + for phase in (d.ONE, (F(3, 5), F(4, 5)), (F(-5, 13), F(12, 13))): + root = tuple((1-beta)*v for v in phase) + for bits in (16, 64): + exact = d.ONE + for exponent in range(1, 130): + exact = d.mul(exact, root) + result = d.power(root, exponent, bits, d.Meter()) + d.need(d.norm2(result) <= d.norm2(exact), 'power does not increase the norm') + error = d.norm2(d.sub(result, exact)) + d.need(error <= (8*F(1, 1 << bits)/beta)**2, 'uniform power error') + nonzero += error != 0 + cases += 1 + return dict(cases=cases, nonzero_errors=nonzero, maximum_exponent=129) + + +def generic_check(limit=24): + cases = nonzero = 0 + receipt = hashlib.sha256() + worst = F(0) + for beta in (F(1, 2), F(1, 16), F(1, 4096)): + bits = 32+6*d.ceil_log2(1/beta) + b = ((1-beta)*F(3, 5), (1-beta)*F(4, 5)) + for length in range(1, limit+1): + for stride in range(-length, length): + x0, y0 = values(length, bits, 36), values(length, bits, 71) + exact = cycle_oracle(x0, b, stride) + for shift in sorted({0, stride % length}): + x, y = Bank(x0), Bank(y0) + meter = d.lift(x, y, b, beta, bits, stride, shift=shift) + d.need(x.values == x0, 'source restoration') + error = max(d.norm2(d.sub(d.sub(y.values[i], y0[i]), exact[(i-shift) % length])) + for i in range(length)) + bound = d.leaf_bound(magnitude([x0]), beta, bits) + d.need(error <= bound*bound, 'leaf error') + worst = max(worst, error/(bound*bound)) + nonzero += error != 0 + receipt.update(digest_arrays([y.values]).encode()) + d.lift(x, y, b, beta, bits, stride, -1, shift=shift) + d.need(x.values == x0 and y.values == y0, 'leaf inverse') + d.need(meter.max_depth == d.depth(length, stride), 'observed recursion depth') + d.need(meter.tape_moves <= 4096*length, 'shifted leaf tape bound') + cases += 1 + return dict(lengths=[1, limit], strides='every integer in [-L,L)', cases=cases, + output_shifts='zero and stride modulo L; duplicates removed', + nonzero_errors=nonzero, max_squared_error_ratio_log2_upper=d.ceil_log2(worst), + output_digest=receipt.hexdigest()) + + +def cost_check(): + rows = [] + for length in (1, 2, 5, 12, 29, 70, 169, 408, 985, 2378): + for stride in sorted({0, 1 % length, length//3, length//2, (length*36)//100, + math.isqrt(2*length*length)-length, + min(length-1, math.isqrt(2*length*length)-length+1)}): + n, w, weight, mass, nodes = length, stride, 1, 0, 0 + while True: + w %= n + w = min(w, n-w) + mass += weight*n + nodes += weight + if w == 0: + break + n, w, weight = w, (-n) % w, weight*2 + d.need(mass <= 6*length, 'Euclidean recurrence mass') + x, y = Bank([d.ZERO]*length), Bank([d.ONE]*length) + meter = d.lift(x, y, d.ZERO, F(1, 2), 64, stride) + calls = meter.products+meter.power_products+meter.divisions + bound = 9*mass+32*nodes*(length//math.gcd(length, stride)).bit_length()+3*length + d.need(meter.nodes == nodes and calls <= bound, 'complete arithmetic bill') + d.need(calls <= 1280*length and meter.reads+meter.writes <= 512*length, + 'linear arithmetic and indexed access bound') + d.need(meter.tape_moves <= 4096*length and set(meter.heads) == {0, 1} + and all(v == 0 for v in meter.heads.values()), 'linear two-tape bound and head returns') + d.need(x.values == [d.ZERO]*length and y.values == [d.ONE]*length, 'count fixture restoration') + rows.append(dict(length=length, stride=stride, nodes=nodes, weighted_length=mass, + scalar_products=meter.products, power_products=meter.power_products, + divisions=meter.divisions, reads=meter.reads, writes=meter.writes, + two_tape_record_moves=meter.tape_moves, arithmetic_bound=bound)) + return rows + + +def kernel_check(): + c = load(HERE/'vendor/pr628/check.py', 'source628_check') + fixtures = json.loads((HERE/'vendor/pr628/FACTORS.json').read_text()) + rows = [] + for fixture in fixtures: + state = c.certify(fixture) + factors = [(inside, b, F(state['radix']) if i == 0 else F(1)) + for i, (inside, b) in enumerate(state['factors'])] + beta, r = state['beta'], state['radix'] + perturbation = F(state['certificate']['factorization_inverse_error_bound']) + for length, stride in ((1, 0), (3, 1), (5, 2), (5, -2)): + for tau in (d.ONE, (F(3, 5), F(4, 5))): + bits = d.working_bits(len(factors), r, beta, 4, 128, 16, length, stride) + originals = [values(length, bits, 36+7*j) + for j in range(2+(len(factors)-1).bit_length())] + bound0 = magnitude(originals) + d.need(bound0 <= 4, 'initial magnitude') + d.need(all((a*(1 << bits)).numerator % 2 and (b*(1 << bits)).numerator % 2 + for array in originals for a, b in array), 'odd lowest input bits') + banks = [Bank(v) for v in originals] + meter = d.compose(banks[0], banks[1], factors, banks[2:], tau, beta, bits, stride) + d.need(banks[0].values == originals[0] and + [a.values for a in banks[2:]] == originals[2:], 'kernel dirty restoration') + net = [d.sub(a, old) for a, old in zip(banks[1].values, originals[1])] + exact = c.matrix_solve(originals[0], c.phased_polynomial(state['q'], tau), stride) + error = max(d.norm2(d.sub(a, b)) for a, b in zip(net, exact)) + execution = d.execution_bound(len(factors), r, beta, bound0, bits) + d.need(error <= execution**2, 'independent dense kernel error') + d.need(execution+perturbation*magnitude([originals[0]]) <= F(1, 1 << 128), 'true kernel target') + d.need(meter.leaves == d.leaf_calls(len(factors)), 'paid leaf count') + tape_bound = 8192*(meter.leaves+1)*len(banks)*length + d.need(meter.tape_moves <= tape_bound and set(meter.heads) == {0, 1} + and all(v == 0 for v in meter.heads.values()), 'kernel two-tape routing') + space_bound = 512*(r+1)*(bound0+1)*(2+F(r)/beta)**meter.leaves/beta**7 + peak = max(bank.peak_l1 for bank in banks) + d.need(peak <= space_bound, 'complete integer magnitude allowance') + output_digest = digest_arrays([b.values for b in banks]) + d.compose(banks[0], banks[1], factors, banks[2:], tau, beta, bits, stride, -1) + d.need([b.values for b in banks] == originals, 'full word inverse') + rows.append(dict(radix=r, embedding=state['embedding'], length=length, + stride=stride, gauge=[str(v) for v in tau], bits=bits, + leaf_calls=meter.leaves, borrowed_arrays=len(banks)-2, + two_tape_record_moves=meter.tape_moves, tape_bound=tape_bound, + peak_l1_log2_upper=d.ceil_log2(peak), + nonzero_error=error != 0, error_squared_log2_upper=d.ceil_log2(error) if error else None, + execution_bound=str(execution), output_digest=output_digest)) + print('checked kernel', r, fixture['embedding'], flush=True) + return rows + + +def controls(): + rows = [] + def reject(name, fn): + try: + fn() + except ValueError as exc: + rows.append(dict(name=name, reason=str(exc))) + else: + raise ValueError('control accepted: '+name) + x, y = Bank([d.ONE, d.ZERO]), Bank([d.ZERO, d.ONE]) + reject('source_target_alias', lambda: d.lift(x, x, d.ZERO, F(1, 2), 64, 1)) + reject('insufficient_precision', lambda: d.lift(x, y, d.ZERO, F(1, 16), 8, 1)) + reject('unit_coefficient', lambda: d.lift(x, y, d.ONE, F(1, 2), 64, 1)) + reject('off_grid_source', lambda: d.lift(Bank([(F(1, 3), F(0)), d.ZERO]), y, + d.ZERO, F(1, 2), 64, 1)) + factors = [(True, (F(1, 4), F(0)), F(1))]*2 + reject('ancestor_target_as_scratch', lambda: d.compose(x, y, factors, [y], d.ONE, F(1, 2), 64, 1)) + reject('missing_dirty_level', lambda: d.compose(x, y, factors, [], d.ONE, F(1, 2), 64, 1)) + reject('nonunit_gauge', lambda: d.compose(x, y, factors, [Bank([d.ONE]*2)], + (F(2), F(0)), F(1, 2), 64, 1)) + scratch = Bank([d.ONE]*2) + before = [x.values[:], y.values[:], scratch.values[:]] + reject('late_unstable_factor', lambda: d.compose(x, y, [factors[0], (True, d.ONE, F(1))], + [scratch], d.ONE, F(1, 2), 64, 1)) + d.need([x.values, y.values, scratch.values] == before, 'preflight must precede mutation') + reject('fractional_stride', lambda: d.lift(x, y, d.ZERO, F(1, 2), 64, F(1, 2))) + bad_meter = d.Meter(layout={id(x): (0, 0), id(y): (0, 2)}) + reject('same_tape_operands', lambda: d.lift(x, y, d.ZERO, F(1, 2), 64, 1, meter=bad_meter)) + reject('unsupported_shift', lambda: d.lift(Bank([d.ZERO]*3), Bank([d.ONE]*3), + d.ZERO, F(1, 2), 64, 1, shift=2)) + increments = [] + for salt in (1, 2): + x0, y0 = values(3, 48, 36), values(3, 48, salt) + src, dst = Bank(x0), Bank(y0) + d.lift(src, dst, (F(3, 10), F(2, 5)), F(1, 2), 48, 1) + increments.append([d.sub(a, b) for a, b in zip(dst.values, y0)]) + d.need(increments[0] != increments[1], 'target dependence witness') + rows.append(dict(name='target_dependence', reason='L=3, stride=1, W=48', + changed_entries=sum(a != b for a, b in zip(*increments)))) + return rows + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--write', type=Path, help='Write a new exact receipt to this absent path.') + args = parser.parse_args() + if args.write: + d.need(not args.write.exists(), 'output already exists') + result = dict(status='passed', pins=pins(), geometry=geometry_check(), power=power_check(), + generic=generic_check(), costs=cost_check(), kernels=kernel_check(), controls=controls()) + text = json.dumps(result, indent=2, sort_keys=True)+'\n' + if args.write: + with args.write.open('x') as out: + out.write(text) + else: + expected = json.loads((HERE/'EXPECTED.json').read_text()) + d.need(canonical(result) == canonical(expected), 'exact receipt mismatch') + print('PASS_DIRTY_STRIDE_SOURCE_REUSE geometry=%d generic=%d kernels=%d controls=%d' % + (result['geometry']['cases'], result['generic']['cases'], len(result['kernels']), len(result['controls']))) + + +if __name__ == '__main__': + main() diff --git a/research/dirty-stride-precision/verify.py b/research/dirty-stride-precision/verify.py new file mode 100644 index 0000000000..dd8afc0290 --- /dev/null +++ b/research/dirty-stride-precision/verify.py @@ -0,0 +1,438 @@ +"""Check the new precision contract with exact arithmetic.""" +import argparse +import ast +from fractions import Fraction as F +import hashlib +import importlib.util +import json +from math import gcd +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +sys.set_int_max_str_digits(0) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +d = load(HERE/'dirty_stride.py', 'stride_precision_solver') +b = load(HERE/'budget.py', 'stride_precision_budget') +v = load(HERE/'vendor/pr985/verify.py', 'stride_precision_reference') +c = load(HERE/'vendor/pr985/vendor/pr628/check.py', 'stride_precision_kernel') + + +class Bank(v.Bank): + """Count each actual indexed access, apart from the solver's meter.""" + def __init__(self, values): + super().__init__(values) + self.reads = self.writes = 0 + + def __getitem__(self, index): + self.reads += 1 + return super().__getitem__(index) + + def __setitem__(self, index, value): + self.writes += 1 + super().__setitem__(index, value) + + +def run_counted(fn, arrays): + before = (sum(a.reads for a in arrays), sum(a.writes for a in arrays)) + meter = fn() + after = (sum(a.reads for a in arrays), sum(a.writes for a in arrays)) + d.need(after[0]-before[0] == meter.reads and after[1]-before[1] == meter.writes, + 'literal indexed access charge') + return meter + + +def digest(value): + return hashlib.sha256(json.dumps(value, default=str, sort_keys=True, + separators=(',', ':')).encode()).hexdigest() + + +def pins(): + records = json.loads((HERE/'SOURCES.json').read_text())['sources'] + for row in records: + data = (HERE/row['local']).read_bytes() + d.need(hashlib.sha256(data).hexdigest() == row['sha256'], 'source SHA256') + header = b'blob '+str(len(data)).encode()+b'\0' + d.need(hashlib.sha1(header+data).hexdigest() == row['blob'], 'source Git blob') + def word(text): + nodes = ast.parse(text).body + return [ast.dump(node) for node in nodes + if not isinstance(node, ast.Expr) + and getattr(node, 'name', '') not in ('admitted', 'effective_depth')] + reference = (HERE/'vendor/pr985/dirty_stride.py').read_text() + old = " need(rnd(data[i], bits) == data[i], 'fixed grid data')" + new = (" datum = data[i]\n" + " need(rnd(datum, bits) == datum, 'fixed grid data')\n" + " del datum") + d.need(reference.count(old) == 2, 'two retained validation sites') + d.need(word((HERE/'dirty_stride.py').read_text()) == word(reference.replace(old, new)), + 'unchanged rounded word and tape operations') + return len(records) + + +def budget_checks(): + def calls(n): + return 1 if n == 1 else 2*(calls(n//2)+calls(n-n//2)) + rows = [] + for r in range(3, 513): + if not b.prime_power(r): + continue + ell, h = (r-1).bit_length(), (r-2).bit_length() + prime = next((j for j in range(2, r+1) if r % j == 0)) + phi = r-r//prime + delta = 1+2*ell+r*(r-1)*phi + inverse, gap = 2*delta+r+2, delta+ell+2*r+2 + prefix = inverse+2*r+ell+1+2*h + count = calls(r-1) + for p in (0, 1, 16, 128, 1024): + for m in (0, 20, 128): + for incoming in (0, 64, 4096): + row = b.uniform(r, p, m, incoming) + b.check_uniform(row) + d.need((row['phi'], row['leaf_calls'], row['prefix_exponent']) + == (phi, count, prefix), 'independent prefix budget') + local = row['local_error_exponent'] + d.need(local >= 5*gap and 68*(r+1) <= 1 << (local-5*gap), + 'independent local bound') + w = row['working_bits'] + e = w-p-m-3*prefix-local-3 + d.need(e >= 0 and count <= 1 << e, 'independent execution budget') + d.need(w >= max(incoming, 4*gap+16), 'independent admission budget') + d.need(row['integer_bits'] >= prefix+m+8*gap+2*ell+15, + 'inverse preimage integer guard') + d.need(row['preparation_error_exponent'] >= p+2*inverse+m+4, + 'independent coefficient error') + d.need(w <= max(p, incoming)+m+18*r**3 + and row['integer_bits'] <= m+15*r**3, + 'independent cubic bounds') + rows.append(row) + comparison = b.uniform(64, 128, 20, 0) + g, calls64 = comparison['margin_exponent'], comparison['leaf_calls'] + old = (129+(calls64*68*65*((1 << 20)+1)-1).bit_length()+5*g + +(calls64-1)*(g+7)) + return dict(cases=len(rows), sha256=digest(rows), radix64=comparison, + radix64_old_fractional_bits=old) + + +def admission_checks(): + checked = 0 + for g in range(1, 65): + beta = F(1, 1 << g) + for bits in range(4*g+16, 4*g+33): + depth = d.effective_depth(beta, bits) + d.need(depth == g+bits.bit_length(), 'effective depth formula') + d.need(48*(depth+1) <= 1 << (bits-3*g), 'all-length admission inequality') + d.need(d.admitted(beta, bits, 1 << 100), 'large structural depth admission') + checked += 1 + decay = [] + for beta in (F(1, 2), F(1, 3), F(1, 16), F(2, 129), F(1, 4096)): + for bits in (12, 24, 64, 128): + depth = d.effective_depth(beta, bits) + for phase in (d.ONE, (F(3, 5), F(4, 5)), (F(-5, 13), F(12, 13))): + coefficient = tuple((1-beta)*z for z in phase) + for exponent in (1 << depth, (1 << depth)+1, 3 << depth): + d.need(d.power(coefficient, exponent, bits, d.Meter()) == d.ZERO, + 'exact coefficient extinction') + decay.append((str(beta), bits, depth, exponent, phase)) + geometries = 0 + for length in range(1, 129): + for stride in range(length): + divisor = gcd(length, stride) + cycle = length//divisor + inverse = pow(stride//divisor, -1, cycle) if cycle > 1 else 0 + geo = d.Geometry(d.ONE, divisor, cycle, inverse, 64, d.Meter()) + n, w, orientation, level = length, stride, 1, 0 + while True: + w %= n + if 2*w > n: + w, orientation = n-w, -orientation + exponents = geo.exponents(n, w, orientation) + d.need(min(exponents) >= 1 << level and max(exponents) <= cycle, + 'return exponent growth and cycle maximum') + if w == 0: + break + n, w, level = w, (-n) % w, level+1 + geometries += 1 + return dict(thresholds=checked, extinction_cases=len(decay), + extinction_sha256=digest(decay), geometries=geometries) + + +def zero_subtrees(): + rows = [] + for root in ((F(1, 2), F(0)), (F(3, 10), F(2, 5))): + length, stride, bits, beta = 5741, 2378, 12, F(1, 2) + cutoff = d.effective_depth(beta, bits) + n, w, orientation = length, stride, 1 + for _ in range(cutoff): + w %= n + if 2*w > n: + w, orientation = n-w, -orientation + n, w = w, (-n) % w + if 2*w > n: + w, orientation = n-w, -orientation + for sign in (-1, 1): + originals = [v.values(n, bits, 36), v.values(n, bits, 71)] + arrays = [v.Bank(z) for z in originals] + meter = d.Meter(layout={id(arrays[0]): (0, 0), id(arrays[1]): (1, 0)}) + geo = d.Geometry(root, 1, length, pow(stride, -1, length), bits, meter) + d.need(geo.coefficients(n, w, orientation) == (d.ZERO, d.ZERO), + 'zero subtree coefficients') + start = 0 if orientation == 1 else n-1 + views = [d.View(a, start, orientation, n, meter) for a in arrays] + d.solve(*views, w, geo, sign=sign, level=cutoff) + expected = [d.add(y, tuple(sign*z for z in x)) + for x, y in zip(*originals)] + d.need(arrays[0].values == originals[0] and arrays[1].values == expected, + 'zero subtree exact addition') + bound = 2*v.magnitude(originals) + d.need(max(a.peak_l1 for a in arrays) <= bound, + 'zero subtree depth-independent magnitude') + rows.append(dict(root=list(map(str, root)), length=n, stride=w, sign=sign, + effective_depth=cutoff, remaining_depth=d.depth(n, w), + peak_l1=str(max(a.peak_l1 for a in arrays)))) + return rows + + +def leaf_checks(limit=12): + rows, target_increments = [], [] + for beta in (F(1, 2), F(1, 16), F(1, 4096)): + bits = 32+6*b.ceil_log2(1/beta) + coefficient = ((1-beta)*F(3, 5), (1-beta)*F(4, 5)) + for length in range(1, limit+1): + for stride in range(-length, length): + originals = [v.values(length, bits, 36), v.values(length, bits, 71)] + exact = v.cycle_oracle(originals[0], coefficient, stride) + sign = -1 if stride < 0 else 1 + shift = stride % length + multiplier = (F(6, 5), F(8, 5)) + arrays = [Bank(a) for a in originals] + reference = [v.Bank(a) for a in originals] + meter = run_counted(lambda: d.lift(*arrays, coefficient, beta, bits, stride, + sign, multiplier, shift), arrays) + old_meter = v.d.lift(*reference, coefficient, beta, bits, stride, sign, multiplier, shift) + d.need([a.values for a in arrays] == [a.values for a in reference], + 'same rounded output as PR985') + d.need(meter.tape_moves == old_meter.tape_moves, 'same complete tape movement') + d.need(arrays[0].values == originals[0], 'source restoration') + bound = d.leaf_bound(v.magnitude([originals[0]]), beta, bits, 2) + error = max(d.norm2(d.sub(d.sub(arrays[1].values[i], originals[1][i]), + tuple(sign*z for z in d.mul(multiplier, exact[(i-shift) % length])))) + for i in range(length)) + d.need(error <= bound**2, 'signed source-only leaf error') + run_counted(lambda: d.lift(*arrays, coefficient, beta, bits, stride, + -sign, multiplier, shift), arrays) + d.need([a.values for a in arrays] == originals, 'signed leaf inverse') + rows.append((str(beta), length, stride, sign, error != 0)) + for salt in (1, 2): + x, y = v.values(3, 48, 36), v.values(3, 48, salt) + source, target = v.Bank(x), v.Bank(y) + d.lift(source, target, (F(3, 10), F(2, 5)), F(1, 2), 48, 1) + target_increments.append([d.sub(a, z) for a, z in zip(target.values, y)]) + d.need(target_increments[0] != target_increments[1], 'actual target dependence') + return dict(cases=len(rows), nonzero_errors=sum(row[-1] for row in rows), + sha256=digest(rows), target_dependence=True) + + +def deep_admission(): + length, stride, bits, beta = 5741, 2378, 12, F(1, 2) + originals = [v.values(length, bits, 36), v.values(length, bits, 71)] + d.need(not v.d.admitted(beta, bits, d.depth(length, stride)), 'old length gate fixture') + d.need(d.admitted(beta, bits, d.depth(length, stride)), 'new length gate fixture') + arrays = [Bank(z) for z in originals] + coefficient = (F(3, 10), F(2, 5)) + meter = run_counted(lambda: d.lift(*arrays, coefficient, beta, bits, stride), arrays) + net = [d.sub(a, z) for a, z in zip(arrays[1].values, originals[1])] + residual = max(d.norm2(d.sub(d.sub(net[i], d.mul(coefficient, net[(i-stride) % length])), + originals[0][i])) for i in range(length)) + bound = d.leaf_bound(v.magnitude([originals[0]]), beta, bits) + d.need(0 < residual <= (beta*bound)**2, 'newly admitted inverse residual') + d.need(arrays[0].values == originals[0], 'deep source restoration') + d.need(meter.tape_moves <= 4096*length and all(x == 0 for x in meter.heads.values()), + 'full deep tape bill') + run_counted(lambda: d.lift(*arrays, coefficient, beta, bits, stride, -1), arrays) + d.need([a.values for a in arrays] == originals, 'deep inverse cancellation') + return dict(length=length, stride=stride, bits=bits, structural_depth=d.depth(length, stride), + effective_depth=d.effective_depth(beta, bits), old_admitted=False, + tape_moves=meter.tape_moves, residual_squared=str(residual)) + + +def kernel_cases(): + rows = [] + fixtures = json.loads((HERE/'vendor/pr985/vendor/pr628/FACTORS.json').read_text()) + for fixture in fixtures: + state = c.certify(fixture) + r, beta = state['radix'], state['beta'] + factors = [(inside, z, F(r if j == 0 else 1)) + for j, (inside, z) in enumerate(state['factors'])] + qnorm = sum(abs(re)+abs(im) for re, im in state['q']) + inverse = F(state['certificate']['inverse_norm_bound']) + subset = max(F(1), r*(1 << (r-1))*qnorm*inverse) + budget = b.choose(r-1, r, beta, subset, 4, 128, 16) + for length, stride in ((1, 0), (3, 1), (5, 2), (5, -2)): + for tau in (d.ONE, (F(3, 5), F(4, 5))): + row = execute_kernel(state, factors, beta, budget, length, stride, tau) + row['old_working_bits'] = v.d.working_bits(r-1, r, beta, 4, 128, 16, length, stride) + rows.append(row) + print('checked kernel', r, fixture['embedding'], flush=True) + return rows + + +def uniform_kernel_cases(): + rows = [] + fixtures = json.loads((HERE/'vendor/pr985/vendor/pr628/FACTORS.json').read_text()) + for fixture in fixtures[:3]: + r, embedding = fixture['radix'], fixture['embedding'] + row = b.uniform(r, 128, 2, 16) + beta = F(1, 1 << row['margin_exponent']) + roots = [d.rnd(tuple(map(F, z)), row['factor_bits']) for z in fixture['roots']] + q, factors = [d.ONE], [] + for j, root in enumerate(roots): + inside = d.norm2(root) < 1 + coefficient = root if inside else d.div(d.ONE, root) + d.need(d.norm2(coefficient) <= (1-beta)**2, 'uniform prepared margin') + factors.append((inside, coefficient, F(r if j == 0 else 1))) + new = [d.ZERO]*(len(q)+1) + for i, value in enumerate(q): + new[i] = d.sub(new[i], d.mul(root, value)) + new[i+1] = d.add(new[i+1], value) + q = new + q = [tuple(z/r for z in value) for value in q] + boxes = c.ik.kernel(r, embedding) + epsilon = sum(max(abs(endpoint-value) for endpoint in interval) + for box, coefficient in zip(boxes, q) + for interval, value in zip(box, coefficient)) + d.need(epsilon <= F(1, 1 << row['preparation_error_exponent']), + 'uniform prepared coefficient error') + d.need(sum(abs(re)+abs(im) for re, im in q) <= 1 << r, 'uniform coefficient norm') + inverse = 1 << row['inverse_exponent'] + d.need(inverse*epsilon <= F(1, 2), 'uniform Neumann admission') + perturbation = 2*inverse**2*epsilon + subset = 1 << (row['inverse_exponent']+2*r+(r-1).bit_length()) + budget = b.execution(r-1, r, beta, subset, 4, row['working_bits']) + budget.update(working_bits=row['working_bits'], integer_bits=row['integer_bits']) + state = dict(radix=r, embedding=embedding, q=q, + certificate=dict(factorization_inverse_error_bound=str(perturbation))) + for length, stride in ((1, 0), (5, 2), (12, 5)): + for tau in (d.ONE, (F(3, 5), F(4, 5))): + result = execute_kernel(state, factors, beta, budget, length, stride, tau) + result['factor_bits'] = row['factor_bits'] + result['coefficient_error_log2_upper'] = b.ceil_log2(epsilon) + rows.append(result) + print('checked uniform kernel', r, embedding, flush=True) + return rows + + +def execute_kernel(state, factors, beta, budget, length, stride, tau): + r, bits = state['radix'], budget['working_bits'] + originals = [v.values(length, bits, 36+7*j) for j in range(2+budget['dirty_arrays'])] + d.need(v.magnitude(originals) <= 4, 'initial magnitude') + d.need(all((component*(1 << bits)).numerator % 2 + for a in originals for pair in a for component in pair), 'odd lowest input bits') + arrays = [Bank(z) for z in originals] + def execute(sign): + return run_counted(lambda: d.compose(*arrays[:2], factors, arrays[2:], tau, + beta, bits, stride, sign), arrays) + meter = execute(1) + d.need(arrays[0].values == originals[0] and [a.values for a in arrays[2:]] == originals[2:], + 'kernel source and scratch restoration') + net = [d.sub(a, z) for a, z in zip(arrays[1].values, originals[1])] + exact = c.matrix_solve(originals[0], c.phased_polynomial(state['q'], tau), stride) + error = max(d.norm2(d.sub(a, z)) for a, z in zip(net, exact)) + d.need(0 < error <= budget['error']**2, 'new kernel execution error') + perturbation = F(state['certificate']['factorization_inverse_error_bound'])*4 + d.need(budget['error']+perturbation <= F(1, 1 << 128), 'true kernel target') + d.need(meter.leaves == budget['leaf_calls'], 'complete paid leaf count') + tape = 8192*(meter.leaves+1)*len(arrays)*length + d.need(meter.tape_moves <= tape and set(meter.heads) == {0, 1} + and all(x == 0 for x in meter.heads.values()), 'complete two-tape bill') + peak = max(a.peak_l1 for a in arrays) + d.need(peak <= budget['internal_magnitude'], 'forward integer guard') + execute(-1) + d.need([a.values for a in arrays] == originals, 'complete word inverse') + execute(-1) + negative = [d.sub(a, z) for a, z in zip(arrays[1].values, originals[1])] + negative_error = max(d.norm2(d.add(a, z)) for a, z in zip(negative, exact)) + d.need(0 < negative_error <= budget['error']**2, 'standalone inverse error at preimage') + d.need(arrays[0].values == originals[0] and [a.values for a in arrays[2:]] == originals[2:], + 'standalone inverse restoration') + d.need(max(a.peak_l1 for a in arrays) <= budget['internal_magnitude'], 'inverse integer guard') + execute(1) + d.need([a.values for a in arrays] == originals, 'positive word cancels inverse') + return dict(radix=r, embedding=state['embedding'], length=length, stride=stride, + gauge=list(map(str, tau)), working_bits=bits, integer_bits=budget['integer_bits'], + leaf_calls=meter.leaves, tape_moves=meter.tape_moves, tape_bound=tape, + nonzero_error=True, error_squared_log2_upper=b.ceil_log2(error), + negative_error_squared_log2_upper=b.ceil_log2(negative_error), + peak_l1_log2_upper=b.ceil_log2(peak), sha256=digest(net)) + + +def controls(): + rows = [] + def reject(name, fn, reason): + try: + fn() + except ValueError as exc: + d.need(str(exc) == reason, 'wrong rejection for '+name) + rows.append(dict(name=name, reason=reason)) + else: + raise ValueError('control accepted: '+name) + row = b.uniform(5, 128, 2, 16) + changed = dict(row, working_bits=row['working_bits']-1) + reject('reduced_precision_certificate', lambda: b.check_uniform(changed), 'certificate fields') + changed = dict(row, magnitude_bits=True) + reject('boolean_certificate', lambda: b.check_uniform(changed), 'integer certificate') + reject('feedback_violation', lambda: b.execution(63, 64, F(1, 2), 1 << 100, 4, 32), + 'feedback smallness') + reject('underprecision', lambda: d.lift([d.ONE]*3, [d.ZERO]*3, d.ZERO, F(1, 2), 8, 1), + 'precision admission') + reject('old_length_gate', lambda: v.d.lift([d.ONE]*5741, [d.ZERO]*5741, + d.ZERO, F(1, 2), 12, 2378), 'precision admission') + reject('off_grid', lambda: d.lift([(F(1, 3), F(0))], [d.ZERO], d.ZERO, F(1, 2), 64, 0), + 'fixed grid data') + x, y = [d.ONE]*3, [d.ZERO]*3 + fs = [(True, (F(1, 4), F(0)), F(1))]*2 + reject('borrowed_target', lambda: d.compose(x, y, fs, [y], d.ONE, F(1, 2), 64, 1), + 'all arrays distinct') + reject('nonunit_gauge', lambda: d.compose(x, y, fs, [[d.ZERO]*3], + (F(2), F(0)), F(1, 2), 64, 1), 'immutable unit gauge') + reject('mixed_unstable_factor', lambda: d.compose(x, y, [fs[0], (True, d.ONE, F(1))], + [[d.ZERO]*3], d.ONE, F(1, 2), 64, 1), + 'stable factor descriptor') + d.need(x == [d.ONE]*3 and y == [d.ZERO]*3, 'preflight before mutation') + return rows + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--write', type=Path, help='Write a receipt to a new path.') + args = parser.parse_args() + if args.write: + d.need(not args.write.exists(), 'output already exists') + result = dict(status='passed', source_pins=pins(), budgets=budget_checks(), + admission=admission_checks(), zero_subtrees=zero_subtrees(), + inherited_powers=v.power_check(), leaves=leaf_checks(), + deep=deep_admission(), kernels=kernel_cases(), + uniform_kernels=uniform_kernel_cases(), controls=controls()) + text = json.dumps(result, indent=2, sort_keys=True)+'\n' + if args.write: + with args.write.open('x') as out: + out.write(text) + else: + d.need(digest(result) == digest(json.loads((HERE/'EXPECTED.json').read_text())), + 'exact receipt mismatch') + print('PASS_DIRTY_STRIDE_PRECISION budgets=%d leaves=%d kernels=%d uniform=%d controls=%d' % + (result['budgets']['cases'], result['leaves']['cases'], + len(result['kernels']), len(result['uniform_kernels']), len(result['controls']))) + + +if __name__ == '__main__': + main()