From a164f06263e438ead570b169e5b7103aa45bf228 Mon Sep 17 00:00:00 2001 From: Koroffstrogov Date: Tue, 13 Oct 2026 07:01:53 +0200 Subject: [PATCH] Research: optimize dirty-echo trees under a scratch cap --- research/space-capped-dirty-echo/CLAIM.json | 52 + .../CONCURRENT-SOURCES.json | 16 + .../space-capped-dirty-echo/CONCURRENT.json | 54 + .../space-capped-dirty-echo/EXPECTED.json | 6392 +++++++++++++++++ research/space-capped-dirty-echo/LICENSE | 201 + research/space-capped-dirty-echo/NOTICE.md | 77 + research/space-capped-dirty-echo/PROOF.md | 242 + research/space-capped-dirty-echo/README.md | 168 + research/space-capped-dirty-echo/SOURCES.json | 116 + .../space-capped-dirty-echo/VALIDATION.md | 98 + .../compare_concurrent.py | 64 + research/space-capped-dirty-echo/planner.py | 146 + .../space-capped-dirty-echo/test_contracts.py | 132 + .../vendor/pr628/DIRTY-PROOF.md | 128 + .../vendor/pr628/FACTORS.json | 402 ++ .../vendor/pr628/NOTICE.md | 24 + .../vendor/pr628/check.py | 178 + .../vendor/pr628/check_budgets.py | 59 + .../vendor/pr628/dirty.py | 133 + .../vendor/pr628/interval_kernel.py | 61 + .../vendor/pr628/scan.py | 123 + .../vendor/pr628/weighted.py | 118 + .../vendor/pr673/ECHO-PROOF.md | 171 + .../vendor/pr673/INTEGRATION-PROOF.md | 243 + .../vendor/pr673/echo.py | 75 + .../vendor/pr689/NOTICE.md | 47 + .../vendor/pr689/README.md | 304 + .../vendor/pr689/ternary.py | 101 + .../vendor/pr730/NOTICE.md | 41 + .../vendor/pr730/optimize.py | 86 + research/space-capped-dirty-echo/verify.py | 437 ++ 31 files changed, 10489 insertions(+) create mode 100644 research/space-capped-dirty-echo/CLAIM.json create mode 100644 research/space-capped-dirty-echo/CONCURRENT-SOURCES.json create mode 100644 research/space-capped-dirty-echo/CONCURRENT.json create mode 100644 research/space-capped-dirty-echo/EXPECTED.json create mode 100644 research/space-capped-dirty-echo/LICENSE create mode 100644 research/space-capped-dirty-echo/NOTICE.md create mode 100644 research/space-capped-dirty-echo/PROOF.md create mode 100644 research/space-capped-dirty-echo/README.md create mode 100644 research/space-capped-dirty-echo/SOURCES.json create mode 100644 research/space-capped-dirty-echo/VALIDATION.md create mode 100644 research/space-capped-dirty-echo/compare_concurrent.py create mode 100644 research/space-capped-dirty-echo/planner.py create mode 100644 research/space-capped-dirty-echo/test_contracts.py create mode 100644 research/space-capped-dirty-echo/vendor/pr628/DIRTY-PROOF.md create mode 100644 research/space-capped-dirty-echo/vendor/pr628/FACTORS.json create mode 100644 research/space-capped-dirty-echo/vendor/pr628/NOTICE.md create mode 100644 research/space-capped-dirty-echo/vendor/pr628/check.py create mode 100644 research/space-capped-dirty-echo/vendor/pr628/check_budgets.py create mode 100644 research/space-capped-dirty-echo/vendor/pr628/dirty.py create mode 100644 research/space-capped-dirty-echo/vendor/pr628/interval_kernel.py create mode 100644 research/space-capped-dirty-echo/vendor/pr628/scan.py create mode 100644 research/space-capped-dirty-echo/vendor/pr628/weighted.py create mode 100644 research/space-capped-dirty-echo/vendor/pr673/ECHO-PROOF.md create mode 100644 research/space-capped-dirty-echo/vendor/pr673/INTEGRATION-PROOF.md create mode 100644 research/space-capped-dirty-echo/vendor/pr673/echo.py create mode 100644 research/space-capped-dirty-echo/vendor/pr689/NOTICE.md create mode 100644 research/space-capped-dirty-echo/vendor/pr689/README.md create mode 100644 research/space-capped-dirty-echo/vendor/pr689/ternary.py create mode 100644 research/space-capped-dirty-echo/vendor/pr730/NOTICE.md create mode 100644 research/space-capped-dirty-echo/vendor/pr730/optimize.py create mode 100644 research/space-capped-dirty-echo/verify.py diff --git a/research/space-capped-dirty-echo/CLAIM.json b/research/space-capped-dirty-echo/CLAIM.json new file mode 100644 index 0000000000..f794ad3633 --- /dev/null +++ b/research/space-capped-dirty-echo/CLAIM.json @@ -0,0 +1,52 @@ +{ + "track": "Recursive interfaces", + "assignment_seed": 58, + "randomness": "Python secrets.randbelow(100), operating-system CSPRNG, one draw", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "started_utc": "2026-10-13T04:34:32Z", + "claimed_utc": "2026-10-13T04:39:00Z", + "expected_finish_utc": "2026-10-13T05:34:32Z", + "verification_reserved_from_utc": "2026-10-13T05:19:32Z", + "coordination": "GitHub pinnedIssues is empty; issue 650 is a discussion request with no comments. Claim retained locally as instructed.", + "initial_overlap": "528 open PRs through #708; reviewed titles and relevant bodies, review ledger, selected construction/review and prior negative-search index", + "candidates": [ + "Defer owner-boundary residual restoration in the selected #626 allocation: close to #675 and existing whole-owner assumptions", + "Optimize arbitrary contiguous dirty-echo partitions and arities under a hard scratch cap: selected; #689 explicitly excludes unbalanced splits and unequal costs", + "Split width-9 residual hosting with a different boundary contract: close to #665's fully priced negative result" + ], + "object": "PR673 multiway dirty echo, with arbitrary contiguous factor partitions and arities under a fixed peak borrowed-array budget", + "method": "Exact interval dynamic programming, independent exhaustive small-tree oracle, nonlinear restoration and noncommutative operator checks; complete leaf/phase-access/precision recurrence", + "seed_use": "58 mod 8 = 2 selects radix 16 from [4,9,16,25,27,32,49,64]; use its 15 factors and #689's five-array budget as the primary comparison", + "deliverable": "One isolated research package with optimality scoped to sequential multiway echo trees, literal schedules, reproducible certificates, negative controls and no new kappa claim", + "stopping_rule": "One planner and its fixed finite verification domain; stop after exact comparison and verification. Do not pursue supplier integration or another mechanism.", + "dependency_heads": { + "628": "0768f97d06c623b8211e651543c66135796b62bf", + "673": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3", + "689": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a" + }, + "contributor": "Koroffstrogov, with substantial OpenAI Codex assistance", + "status": "completed", + "result_update_utc": "2026-10-13T05:01:20Z", + "actual_verification_and_handoff_start_utc": "2026-10-13T04:52:00Z", + "result": "Exact all-arity, unbalanced contiguous echo-tree planner: 160 -> 152 complete calls at five arbitrary dirty arrays; weighted radix-16 phase accesses 3840 -> 3656. No new kappa.", + "result_link": "https://github.com/Koroffstrogov/integer-mult-bounds/tree/research/space-capped-dirty-echo/research/space-capped-dirty-echo", + "final_overlap": { + "open_prs": 544, + "through_pr": 725, + "pinned_issue_count": 0, + "closest_concurrent": { + "714": "efad8a40094ab453c0525efef0b0eff2a5d8b850: requires one clean root array, unlike the all-dirty pool here", + "689": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a: balanced ternary only; credited baseline", + "673": "156f259b99723468cfdd2b5d47d0ba894f09bea7: new bit-role sharing screen; all three consumed files unchanged from pinned bfff94e" + } + }, + "publication_overlap_supplement": { + "through_pr": 745, + "inspected": { + "730": "d222e348179cc02a54d6d26dbd2838944f62c6e5", + "744": "576c6b20065fff3402c1eed2ad74c5c7d03029e8" + }, + "distinct_result": "Higher arities already in the original claimed scope; pinned #730 binary/ternary optimizer gives 160 while all-arity gives 152 at n=15, cap=5. Actual weighted radix-16 replay adds 3840 -> 3656 phase reads. #744 independently checks the narrower ternary class. Both credited, no priority claim for unbalanced or weighted optimization.", + "reproduce_comparison": "python3 -I -O -B research/space-capped-dirty-echo/compare_concurrent.py" + } +} diff --git a/research/space-capped-dirty-echo/CONCURRENT-SOURCES.json b/research/space-capped-dirty-echo/CONCURRENT-SOURCES.json new file mode 100644 index 0000000000..a3924557dd --- /dev/null +++ b/research/space-capped-dirty-echo/CONCURRENT-SOURCES.json @@ -0,0 +1,16 @@ +{ + "sources": [ + { + "path": "vendor/pr730/optimize.py", + "commit": "d222e348179cc02a54d6d26dbd2838944f62c6e5", + "source_path": "research/ordered-dirty-echo/optimize.py", + "sha256": "d2cff4c43cfec569454c43af28b2a4fb1fe0b8521722c6c5003ba062d89f526c" + }, + { + "path": "vendor/pr730/NOTICE.md", + "commit": "d222e348179cc02a54d6d26dbd2838944f62c6e5", + "source_path": "research/ordered-dirty-echo/NOTICE.md", + "sha256": "492220b4a4fa193615a04a475622c0bd2aca991a92ddcaccfba7f9b7750dddcc" + } + ] +} diff --git a/research/space-capped-dirty-echo/CONCURRENT.json b/research/space-capped-dirty-echo/CONCURRENT.json new file mode 100644 index 0000000000..f7e007b1e5 --- /dev/null +++ b/research/space-capped-dirty-echo/CONCURRENT.json @@ -0,0 +1,54 @@ +{ + "pr730_commit": "d222e348179cc02a54d6d26dbd2838944f62c6e5", + "status": "PASS_HIGHER_ARITY_COMPARISON", + "uniform": [ + { + "all_arity_calls": 152, + "cap": 5, + "factors": 15, + "pr730_calls": 160 + }, + { + "all_arity_calls": 128, + "cap": 6, + "factors": 15, + "pr730_calls": 144 + }, + { + "all_arity_calls": 448, + "cap": 6, + "factors": 27, + "pr730_calls": 464 + }, + { + "all_arity_calls": 1600, + "cap": 8, + "factors": 58, + "pr730_calls": 1728 + } + ], + "weighted": { + "all_arity_calls": 152, + "all_arity_phase_reads": 3656, + "cap": 5, + "pr730_calls": 160, + "pr730_phase_reads": 3840, + "weights": [ + 23, + 28, + 28, + 28, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 28, + 23 + ] + } +} diff --git a/research/space-capped-dirty-echo/EXPECTED.json b/research/space-capped-dirty-echo/EXPECTED.json new file mode 100644 index 0000000000..26fd063ae8 --- /dev/null +++ b/research/space-capped-dirty-echo/EXPECTED.json @@ -0,0 +1,6392 @@ +{ + "controls": { + "rejected": [ + "omit_0", + "sign_0", + "omit_1", + "sign_1", + "omit_2", + "sign_2", + "omit_3", + "sign_3", + "omit_4", + "sign_4", + "omit_5", + "sign_5", + "omit_6", + "sign_6", + "omit_7", + "sign_7", + "omit_8", + "sign_8", + "omit_9", + "sign_9", + "omit_10", + "sign_10", + "omit_11", + "sign_11", + "omit_12", + "sign_12", + "omit_13", + "sign_13", + "omit_14", + "sign_14", + "omit_15", + "sign_15", + "omit_16", + "sign_16", + "omit_17", + "sign_17", + "omit_18", + "sign_18", + "omit_19", + "sign_19", + "omit_20", + "sign_20", + "omit_21", + "sign_21", + "omit_22", + "sign_22", + "omit_23", + "sign_23", + "omit_24", + "sign_24", + "omit_25", + "sign_25", + "omit_26", + "sign_26", + "omit_27", + "sign_27", + "omit_28", + "sign_28", + "omit_29", + "sign_29", + "omit_30", + "sign_30", + "omit_31", + "sign_31", + "omit_32", + "sign_32", + "omit_33", + "sign_33", + "omit_34", + "sign_34", + "omit_35", + "sign_35", + "omit_36", + "sign_36", + "omit_37", + "sign_37", + "omit_38", + "sign_38", + "omit_39", + "sign_39", + "omit_40", + "sign_40", + "omit_41", + "sign_41", + "omit_42", + "sign_42", + "omit_43", + "sign_43", + "omit_44", + "sign_44", + "omit_45", + "sign_45", + "omit_46", + "sign_46", + "omit_47", + "sign_47", + "omit_48", + "sign_48", + "omit_49", + "sign_49", + "omit_50", + "sign_50", + "omit_51", + "sign_51", + "omit_52", + "sign_52", + "omit_53", + "sign_53", + "omit_54", + "sign_54", + "omit_55", + "sign_55", + "omit_56", + "sign_56", + "omit_57", + "sign_57", + "omit_58", + "sign_58", + "omit_59", + "sign_59", + "omit_60", + "sign_60", + "omit_61", + "sign_61", + "omit_62", + "sign_62", + "omit_63", + "sign_63", + "omit_64", + "sign_64", + "omit_65", + "sign_65", + "omit_66", + "sign_66", + "omit_67", + "sign_67", + "omit_68", + "sign_68", + "omit_69", + "sign_69", + "omit_70", + "sign_70", + "omit_71", + "sign_71", + "omit_72", + "sign_72", + "omit_73", + "sign_73", + "omit_74", + "sign_74", + "omit_75", + "sign_75", + "omit_76", + "sign_76", + "omit_77", + "sign_77", + "omit_78", + "sign_78", + "omit_79", + "sign_79", + "omit_80", + "sign_80", + "omit_81", + "sign_81", + "omit_82", + "sign_82", + "omit_83", + "sign_83", + "omit_84", + "sign_84", + "omit_85", + "sign_85", + "omit_86", + "sign_86", + "omit_87", + "sign_87", + "omit_88", + "sign_88", + "omit_89", + "sign_89", + "omit_90", + "sign_90", + "omit_91", + "sign_91", + "omit_92", + "sign_92", + "omit_93", + "sign_93", + "omit_94", + "sign_94", + "omit_95", + "sign_95", + "omit_96", + "sign_96", + "omit_97", + "sign_97", + "omit_98", + "sign_98", + "omit_99", + "sign_99", + "omit_100", + "sign_100", + "omit_101", + "sign_101", + "omit_102", + "sign_102", + "omit_103", + "sign_103", + "omit_104", + "sign_104", + "omit_105", + "sign_105", + "omit_106", + "sign_106", + "omit_107", + "sign_107", + "omit_108", + "sign_108", + "omit_109", + "sign_109", + "omit_110", + "sign_110", + "omit_111", + "sign_111", + "omit_112", + "sign_112", + "omit_113", + "sign_113", + "omit_114", + "sign_114", + "omit_115", + "sign_115", + "omit_116", + "sign_116", + "omit_117", + "sign_117", + "omit_118", + "sign_118", + "omit_119", + "sign_119", + "omit_120", + "sign_120", + "omit_121", + "sign_121", + "omit_122", + "sign_122", + "omit_123", + "sign_123", + "omit_124", + "sign_124", + "omit_125", + "sign_125", + "omit_126", + "sign_126", + "omit_127", + "sign_127", + "omit_128", + "sign_128", + "omit_129", + "sign_129", + "omit_130", + "sign_130", + "omit_131", + "sign_131", + "omit_132", + "sign_132", + "omit_133", + "sign_133", + "omit_134", + "sign_134", + "omit_135", + "sign_135", + "omit_136", + "sign_136", + "omit_137", + "sign_137", + "omit_138", + "sign_138", + "omit_139", + "sign_139", + "omit_140", + "sign_140", + "omit_141", + "sign_141", + "omit_142", + "sign_142", + "omit_143", + "sign_143", + "omit_144", + "sign_144", + "omit_145", + "sign_145", + "omit_146", + "sign_146", + "omit_147", + "sign_147", + "omit_148", + "sign_148", + "omit_149", + "sign_149", + "omit_150", + "sign_150", + "omit_151", + "sign_151", + "factor_order", + "inverse_order", + "scratch_alias", + "empty", + "zero", + "negative", + "bool_weight", + "bool_cap", + "negative_cap", + "infeasible", + "missing_factor", + "reordered_factor", + "unary_node", + "source_target", + "source_scratch", + "target_scratch", + "scratch_pair", + "phase_alias", + "short_scratch", + "length", + "sign", + "bool_sign" + ], + "rejected_count": 326 + }, + "enumeration": { + "comparisons": 144, + "domain": "all reduced ordered rooted trees, n=1..8; four weight vectors; cap=0..n-1", + "rows_sha256": "063983f2eebb3e409fda024bfec3c608369d46dd3ab0f4e5ffb4907473888e78", + "trees": 5440 + }, + "rounded": { + "generic": [ + { + "calls": 1, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 1, + "length": 1, + "lift_loop_visits": 3, + "output_sha256": "611fb192d9ab5919d17707bb1716b94719ec8b7bc5eac94c2e69be8ee0801aea", + "phase_reads": 4, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 1, + "length": 1, + "lift_loop_visits": 3, + "output_sha256": "611fb192d9ab5919d17707bb1716b94719ec8b7bc5eac94c2e69be8ee0801aea", + "phase_reads": 4, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 1, + "length": 1, + "lift_loop_visits": 3, + "output_sha256": "611fb192d9ab5919d17707bb1716b94719ec8b7bc5eac94c2e69be8ee0801aea", + "phase_reads": 4, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 1, + "length": 1, + "lift_loop_visits": 3, + "output_sha256": "611fb192d9ab5919d17707bb1716b94719ec8b7bc5eac94c2e69be8ee0801aea", + "phase_reads": 4, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 1, + "length": 3, + "lift_loop_visits": 9, + "output_sha256": "52c9cc4604c90c1f03a2c0c84b453015ee86b56f6dbf52fce508eafb5520b1bc", + "phase_reads": 16, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 1, + "length": 3, + "lift_loop_visits": 9, + "output_sha256": "52c9cc4604c90c1f03a2c0c84b453015ee86b56f6dbf52fce508eafb5520b1bc", + "phase_reads": 16, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 1, + "length": 3, + "lift_loop_visits": 9, + "output_sha256": "bd5ed53c1335c885cc56a6abb4cbdedede167afb94c4d5f6f7a3082872ec131b", + "phase_reads": 16, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 1, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 1, + "length": 3, + "lift_loop_visits": 9, + "output_sha256": "bd5ed53c1335c885cc56a6abb4cbdedede167afb94c4d5f6f7a3082872ec131b", + "phase_reads": 16, + "scratch": 0, + "working_bits": 78 + }, + { + "calls": 4, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 2, + "length": 1, + "lift_loop_visits": 12, + "output_sha256": "baec68f45eb021378b4dc3b87c5b4097262bb88bf06787c21cb900862ff4eb2b", + "phase_reads": 14, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 2, + "length": 1, + "lift_loop_visits": 12, + "output_sha256": "a939bab3c29cf8cecb0c4a5383052a7efa8a0e7fba505069790adf2cc13e389b", + "phase_reads": 14, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 2, + "length": 1, + "lift_loop_visits": 12, + "output_sha256": "baec68f45eb021378b4dc3b87c5b4097262bb88bf06787c21cb900862ff4eb2b", + "phase_reads": 14, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 2, + "length": 1, + "lift_loop_visits": 12, + "output_sha256": "a939bab3c29cf8cecb0c4a5383052a7efa8a0e7fba505069790adf2cc13e389b", + "phase_reads": 14, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 2, + "length": 3, + "lift_loop_visits": 36, + "output_sha256": "75ffd50f3c256994edb6c8bfbb2108ebb28e55272c8da820ba25fe7acb005812", + "phase_reads": 58, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 2, + "length": 3, + "lift_loop_visits": 36, + "output_sha256": "0668402971288a295732e8b6af9cc37a94781634dad664475f59e5b385995d9f", + "phase_reads": 58, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 2, + "length": 3, + "lift_loop_visits": 36, + "output_sha256": "71aca23c8d0b6c803e64c7d4b162b5aaca84c3bfcbfd430f785ecf67ed573c64", + "phase_reads": 58, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 4, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 2, + "length": 3, + "lift_loop_visits": 36, + "output_sha256": "8d95ca228632bf89ca92c90553f963b5e8f0efaf1fbd049c76eb0395928c5913", + "phase_reads": 58, + "scratch": 1, + "working_bits": 89 + }, + { + "calls": 8, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 3, + "length": 1, + "lift_loop_visits": 24, + "output_sha256": "f3891369c7e21f6bad8c43901e24a0b5618a8a58c3a12f408f808fd84db86c1f", + "phase_reads": 28, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 3, + "length": 1, + "lift_loop_visits": 24, + "output_sha256": "a1c717d742fa06f3509fea92f461281187c23c1f35aff264a055b5d6b3a9b48b", + "phase_reads": 28, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 3, + "length": 1, + "lift_loop_visits": 24, + "output_sha256": "f3891369c7e21f6bad8c43901e24a0b5618a8a58c3a12f408f808fd84db86c1f", + "phase_reads": 28, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 3, + "length": 1, + "lift_loop_visits": 24, + "output_sha256": "a1c717d742fa06f3509fea92f461281187c23c1f35aff264a055b5d6b3a9b48b", + "phase_reads": 28, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 3, + "length": 3, + "lift_loop_visits": 72, + "output_sha256": "fc11d25c99806a2300f0e842dae93420837c3b5aca7271448c528631ae84e10a", + "phase_reads": 116, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 3, + "length": 3, + "lift_loop_visits": 72, + "output_sha256": "d74ec0d6d8ccb43912fa7c980b25a8a665d5c90558593f269ff0fed6d3b08e06", + "phase_reads": 116, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 3, + "length": 3, + "lift_loop_visits": 72, + "output_sha256": "7d3765b7cfd746007dc54fc831d31fbe98a8f87b5b9e6ac33cac9f9680bb6de2", + "phase_reads": 116, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 8, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 3, + "length": 3, + "lift_loop_visits": 72, + "output_sha256": "ccd34d1aa7709e83f456a714f504cef4f82e429bd570e763184c7d8a9042a100", + "phase_reads": 116, + "scratch": 2, + "working_bits": 102 + }, + { + "calls": 16, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 5, + "length": 1, + "lift_loop_visits": 48, + "output_sha256": "7d1a2f7cda8a381238b3fcd20a9a9ef4887ad20e3624580a63fb457f412a37bf", + "phase_reads": 56, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 5, + "length": 1, + "lift_loop_visits": 48, + "output_sha256": "af4ddf81a55d617cdf33a861b9d83ddce05dbe0d804ecde74ce97e985c926a54", + "phase_reads": 56, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 5, + "length": 1, + "lift_loop_visits": 48, + "output_sha256": "7d1a2f7cda8a381238b3fcd20a9a9ef4887ad20e3624580a63fb457f412a37bf", + "phase_reads": 56, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 5, + "length": 1, + "lift_loop_visits": 48, + "output_sha256": "af4ddf81a55d617cdf33a861b9d83ddce05dbe0d804ecde74ce97e985c926a54", + "phase_reads": 56, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 5, + "length": 3, + "lift_loop_visits": 144, + "output_sha256": "9b4b9768e254f13d0a6abc359b27c42b3da3851faf8ae812438153a3ed485af7", + "phase_reads": 232, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 5, + "length": 3, + "lift_loop_visits": 144, + "output_sha256": "3c47e203431fe56818e00961e567eee5c2a9deb6050dc3ce09995d888c4f6e45", + "phase_reads": 232, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 5, + "length": 3, + "lift_loop_visits": 144, + "output_sha256": "6305912a57a87c1f746927219bbb598e1520e959e80d5475a7d7d4c2a0df8899", + "phase_reads": 232, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 16, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 5, + "length": 3, + "lift_loop_visits": 144, + "output_sha256": "ed2cb013623448d71253a9338ff0aff4d9019c779c0b87514491a7e3e6444058", + "phase_reads": 232, + "scratch": 4, + "working_bits": 127 + }, + { + "calls": 48, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 8, + "length": 1, + "lift_loop_visits": 144, + "output_sha256": "49e3188b205db8321d40f6a0a4293eeeae174fa39ef762b305cb3c8233522dd5", + "phase_reads": 168, + "scratch": 4, + "working_bits": 225 + }, + { + "calls": 48, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 8, + "length": 1, + "lift_loop_visits": 144, + "output_sha256": "f14e450db081f2d519321bcd7ee0ba977b383b2b4d4e53b18ae0a22a15b006ae", + "phase_reads": 168, + "scratch": 4, + "working_bits": 224 + }, + { + "calls": 48, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 8, + "length": 1, + "lift_loop_visits": 144, + "output_sha256": "49e3188b205db8321d40f6a0a4293eeeae174fa39ef762b305cb3c8233522dd5", + "phase_reads": 168, + "scratch": 4, + "working_bits": 225 + }, + { + "calls": 48, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 8, + "length": 1, + "lift_loop_visits": 144, + "output_sha256": "f14e450db081f2d519321bcd7ee0ba977b383b2b4d4e53b18ae0a22a15b006ae", + "phase_reads": 168, + "scratch": 4, + "working_bits": 224 + }, + { + "calls": 48, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 8, + "length": 3, + "lift_loop_visits": 432, + "output_sha256": "b1f25d6156c6ac51e86d57096a64075059decaa65bdf9f31cbf077bccdb0f820", + "phase_reads": 696, + "scratch": 4, + "working_bits": 225 + }, + { + "calls": 48, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 8, + "length": 3, + "lift_loop_visits": 432, + "output_sha256": "b1f25d6156c6ac51e86d57096a64075059decaa65bdf9f31cbf077bccdb0f820", + "phase_reads": 696, + "scratch": 4, + "working_bits": 224 + }, + { + "calls": 48, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 8, + "length": 3, + "lift_loop_visits": 432, + "output_sha256": "e44cdc8ddfca09c7cc31dd07ba594e3767b9754d5985fc4cd5453d8b82a76052", + "phase_reads": 696, + "scratch": 4, + "working_bits": 225 + }, + { + "calls": 48, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 8, + "length": 3, + "lift_loop_visits": 432, + "output_sha256": "e57efee6eb87622223868337580f920a11ec645890ca587e72e544624b25c67a", + "phase_reads": 696, + "scratch": 4, + "working_bits": 224 + }, + { + "calls": 152, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 1, + "lift_loop_visits": 456, + "output_sha256": "4b37df17dd282b4bd7ab62a3abf1c8ba8308e14b31408c374d622352ec1db1da", + "phase_reads": 536, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 1, + "lift_loop_visits": 456, + "output_sha256": "a3257e0e033b65565a86fc655af132f7e31758aa24113e17eda19fd7f8756c4f", + "phase_reads": 536, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 1, + "lift_loop_visits": 456, + "output_sha256": "4b37df17dd282b4bd7ab62a3abf1c8ba8308e14b31408c374d622352ec1db1da", + "phase_reads": 536, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 1, + "lift_loop_visits": 456, + "output_sha256": "a3257e0e033b65565a86fc655af132f7e31758aa24113e17eda19fd7f8756c4f", + "phase_reads": 536, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 3, + "lift_loop_visits": 1368, + "output_sha256": "b271996d0bbbb5e6e5b1a1570d552b2cef1e47fa483b80e527b0a7de3117b167", + "phase_reads": 2216, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 3, + "lift_loop_visits": 1368, + "output_sha256": "f3f9caf9d567e9063aec45ef0b00eeb5d8c2d8288962ea978ebd0df39fb233ad", + "phase_reads": 2216, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 3, + "lift_loop_visits": 1368, + "output_sha256": "08dcdb810274c481ef65a16eda3082765096a886813f3c237c4aa322bcf445bb", + "phase_reads": 2216, + "scratch": 5, + "working_bits": 538 + }, + { + "calls": 152, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 3, + "lift_loop_visits": 1368, + "output_sha256": "89bfd8015aeeb1df7e9774cc43614a588a03469aad52dd13adc454909691c40d", + "phase_reads": 2216, + "scratch": 5, + "working_bits": 538 + } + ], + "kernel": [ + { + "calls": 152, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "uniform", + "output_sha256": "d76059214404e85cb2725797310a6bb6b4e90b65c0f5923000ef5c266650cd53", + "phase_reads": 3696, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "uniform", + "output_sha256": "2ad60a994c6ce80f8b4f665a1079f31b2c5b0e6fbc2c0b19e5625d415dfc7ede", + "phase_reads": 3696, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "uniform", + "output_sha256": "0340c2c6f23b0237aaf12386d54f31f48fb0214246513f68076ee32bd019c8b7", + "phase_reads": 3696, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "uniform", + "output_sha256": "5dbe62bded7e74fa625530169129a2d4dfedd41776c8e1117fc22b1be617c683", + "phase_reads": 3696, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": -1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "phase_weighted", + "output_sha256": "27e3a760dd9062243df9bb945c0dc2dcbe13e04da75fc4c027938273f5217848", + "phase_reads": 3656, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": -1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "phase_weighted", + "output_sha256": "9eb054996b65545cd046ae2324d8e6d1352b2b7245c9e98cc2a3d2e20ba0f195", + "phase_reads": 3656, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": 1, + "dirt": -7, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "phase_weighted", + "output_sha256": "e00d1416957e6e5ebcc483d44f6ff7c58957474ed5350038a7e286057cf7568d", + "phase_reads": 3656, + "scratch": 5, + "working_bits": 2225 + }, + { + "calls": 152, + "direction": 1, + "dirt": 5, + "execution_target_bits": 64, + "factors": 15, + "length": 5, + "lift_loop_visits": 2280, + "objective": "phase_weighted", + "output_sha256": "c6f78827dce19484362edaeacfc55a495cf89e22b7c3f02e3116d3387faffcb8", + "phase_reads": 3656, + "scratch": 5, + "working_bits": 2225 + } + ], + "kernel_scope": "radix 16 embedding 1, length 5, both directions, two arbitrary-dirt fixtures; represented-factor polynomial and inherited root certificate", + "weighted": { + "calls": 152, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 8, + 8, + 8, + 16, + 16, + 8, + 8 + ], + "oracle_root_partitions": 18212, + "pr689_phase_reads": 3840, + "price": 3656, + "scratch": 5, + "symbolic": { + "calls": 152, + "factors": 15, + "nonlinear_atoms": 40, + "scratch": 5, + "word_sha256": "0be4bfc307e95d8546cb5863192d2e21cb23a4d5c7791daef15a3232094dadf6" + }, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + 5, + 6, + 7, + 8 + ], + [ + [ + 9, + 10 + ], + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ] + ], + "uniform_phase_reads": 3696, + "weights": [ + 23, + 28, + 28, + 28, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 28, + 23 + ] + } + }, + "sources": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "files": 18, + "selected_kappa": "51110230636731/31250000000000000" + }, + "status": "PASS_SPACE_CAPPED_DIRTY_ECHO", + "uniform": { + "domain": "n=1..32 at minimum feasible cap and one extra; n=15 caps 4..14; n=58 cap 8", + "n58": { + "calls": 1600, + "occurrences": [ + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 32, + 32, + 32, + 16, + 16, + 32, + 32, + 32, + 32, + 16, + 16, + 32, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 64, + 32, + 32, + 32, + 32, + 32 + ], + "price": 1600, + "scratch": 8, + "tree": [ + [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9 + ], + [ + 10, + 11, + 12, + 13 + ], + [ + [ + 14, + 15, + 16 + ], + [ + 17, + 18, + 19 + ] + ] + ], + [ + [ + 20, + 21, + 22, + 23, + 24, + 25 + ], + [ + 26, + 27, + 28, + 29, + 30, + 31 + ] + ], + [ + [ + [ + 32, + 33, + 34, + 35 + ], + [ + [ + 36, + 37 + ], + 38, + [ + 39, + 40 + ] + ] + ], + [ + [ + 41, + 42 + ], + 43, + 44, + [ + 45, + 46 + ] + ], + [ + [ + [ + 47, + 48 + ], + [ + 49, + 50 + ] + ], + [ + 51, + 52, + 53 + ], + [ + [ + 54, + 55 + ], + [ + 56, + 57 + ] + ] + ] + ] + ] + }, + "pr673_primary": { + "calls": 208, + "scratch": 5 + }, + "pr689_primary": { + "calls": 160, + "scratch": 5 + }, + "primary_pareto": [ + { + "calls": 224, + "cap": 4, + "occurrences": [ + 8, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "oracle_root_partitions": 6959, + "price": 224, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + [ + 3, + 4 + ], + [ + 5, + 6 + ] + ] + ], + [ + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ], + [ + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ] + ] + ] + }, + { + "calls": 152, + "cap": 5, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8 + ], + "oracle_root_partitions": 18212, + "price": 152, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + 5, + 6, + 7, + 8 + ], + [ + [ + 9, + 10, + 11 + ], + [ + 12, + 13, + 14 + ] + ] + ] + }, + { + "calls": 128, + "cap": 6, + "occurrences": [ + 4, + 8, + 8, + 8, + 4, + 8, + 16, + 16, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "oracle_root_partitions": 37115, + "price": 128, + "scratch": 6, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4 + ], + [ + 5, + 6, + 7, + 8 + ], + [ + [ + 9, + 10 + ], + 11, + 12, + [ + 13, + 14 + ] + ] + ] + }, + { + "calls": 112, + "cap": 7, + "occurrences": [ + 4, + 8, + 8, + 8, + 8, + 8, + 4, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "oracle_root_partitions": 61745, + "price": 112, + "scratch": 7, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + 9, + 10, + 11, + 12, + [ + 13, + 14 + ] + ] + ] + }, + { + "calls": 100, + "cap": 8, + "occurrences": [ + 4, + 8, + 8, + 8, + 8, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 8, + 8, + 4 + ], + "oracle_root_partitions": 86955, + "price": 100, + "scratch": 8, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + 7, + [ + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ] + ] + }, + { + "calls": 92, + "cap": 9, + "occurrences": [ + 4, + 8, + 8, + 8, + 8, + 4, + 4, + 4, + 4, + 4, + 8, + 8, + 8, + 8, + 4 + ], + "oracle_root_partitions": 107312, + "price": 92, + "scratch": 9, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + 6, + 7, + 8, + [ + 9, + 10, + 11, + 12, + 13, + 14 + ] + ] + }, + { + "calls": 84, + "cap": 10, + "occurrences": [ + 4, + 8, + 8, + 8, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 8, + 8, + 8, + 4 + ], + "oracle_root_partitions": 120243, + "price": 84, + "scratch": 10, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4 + ], + 5, + 6, + 7, + 8, + 9, + [ + 10, + 11, + 12, + 13, + 14 + ] + ] + }, + { + "calls": 76, + "cap": 11, + "occurrences": [ + 4, + 8, + 8, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 8, + 8, + 4 + ], + "oracle_root_partitions": 126633, + "price": 76, + "scratch": 11, + "tree": [ + [ + 0, + 1, + 2, + 3 + ], + 4, + 5, + 6, + 7, + 8, + 9, + 10, + [ + 11, + 12, + 13, + 14 + ] + ] + }, + { + "calls": 68, + "cap": 12, + "occurrences": [ + 4, + 8, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 8, + 4 + ], + "oracle_root_partitions": 129031, + "price": 68, + "scratch": 12, + "tree": [ + [ + 0, + 1, + 2 + ], + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + [ + 12, + 13, + 14 + ] + ] + }, + { + "calls": 60, + "cap": 13, + "occurrences": [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + "oracle_root_partitions": 129678, + "price": 60, + "scratch": 13, + "tree": [ + [ + 0, + 1 + ], + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + [ + 13, + 14 + ] + ] + }, + { + "calls": 56, + "cap": 14, + "occurrences": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 2 + ], + "oracle_root_partitions": 129783, + "price": 56, + "scratch": 14, + "tree": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ] + } + ], + "resource_rows": [ + { + "calls": 1, + "cap": 0, + "factors": 1, + "occurrences": [ + 1 + ], + "price": 1, + "scratch": 0, + "tree": 0 + }, + { + "calls": 4, + "cap": 1, + "factors": 2, + "occurrences": [ + 2, + 2 + ], + "price": 4, + "scratch": 1, + "tree": [ + 0, + 1 + ] + }, + { + "calls": 8, + "cap": 2, + "factors": 3, + "occurrences": [ + 2, + 4, + 2 + ], + "price": 8, + "scratch": 2, + "tree": [ + 0, + 1, + 2 + ] + }, + { + "calls": 16, + "cap": 2, + "factors": 4, + "occurrences": [ + 4, + 4, + 4, + 4 + ], + "price": 16, + "scratch": 2, + "tree": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ] + }, + { + "calls": 12, + "cap": 3, + "factors": 4, + "occurrences": [ + 2, + 4, + 4, + 2 + ], + "price": 12, + "scratch": 3, + "tree": [ + 0, + 1, + 2, + 3 + ] + }, + { + "calls": 20, + "cap": 3, + "factors": 5, + "occurrences": [ + 4, + 4, + 4, + 4, + 4 + ], + "price": 20, + "scratch": 3, + "tree": [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ] + }, + { + "calls": 16, + "cap": 4, + "factors": 5, + "occurrences": [ + 2, + 4, + 4, + 4, + 2 + ], + "price": 16, + "scratch": 4, + "tree": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "calls": 32, + "cap": 3, + "factors": 6, + "occurrences": [ + 4, + 8, + 4, + 4, + 8, + 4 + ], + "price": 32, + "scratch": 3, + "tree": [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ] + }, + { + "calls": 24, + "cap": 4, + "factors": 6, + "occurrences": [ + 4, + 4, + 4, + 4, + 4, + 4 + ], + "price": 24, + "scratch": 4, + "tree": [ + [ + 0, + 1 + ], + 2, + 3, + [ + 4, + 5 + ] + ] + }, + { + "calls": 48, + "cap": 3, + "factors": 7, + "occurrences": [ + 4, + 8, + 4, + 8, + 8, + 8, + 8 + ], + "price": 48, + "scratch": 3, + "tree": [ + [ + 0, + 1, + 2 + ], + [ + [ + 3, + 4 + ], + [ + 5, + 6 + ] + ] + ] + }, + { + "calls": 36, + "cap": 4, + "factors": 7, + "occurrences": [ + 4, + 8, + 4, + 4, + 4, + 8, + 4 + ], + "price": 36, + "scratch": 4, + "tree": [ + [ + 0, + 1, + 2 + ], + 3, + [ + 4, + 5, + 6 + ] + ] + }, + { + "calls": 64, + "cap": 3, + "factors": 8, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 64, + "scratch": 3, + "tree": [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ] + ] + }, + { + "calls": 48, + "cap": 4, + "factors": 8, + "occurrences": [ + 4, + 8, + 8, + 4, + 4, + 8, + 8, + 4 + ], + "price": 48, + "scratch": 4, + "tree": [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ] + ] + }, + { + "calls": 64, + "cap": 4, + "factors": 9, + "occurrences": [ + 4, + 8, + 8, + 4, + 8, + 8, + 8, + 8, + 8 + ], + "price": 64, + "scratch": 4, + "tree": [ + [ + 0, + 1, + 2, + 3 + ], + [ + [ + 4, + 5 + ], + 6, + [ + 7, + 8 + ] + ] + ] + }, + { + "calls": 52, + "cap": 5, + "factors": 9, + "occurrences": [ + 4, + 8, + 8, + 4, + 4, + 4, + 8, + 8, + 4 + ], + "price": 52, + "scratch": 5, + "tree": [ + [ + 0, + 1, + 2, + 3 + ], + 4, + [ + 5, + 6, + 7, + 8 + ] + ] + }, + { + "calls": 80, + "cap": 4, + "factors": 10, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 80, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + [ + 5, + 6 + ], + 7, + [ + 8, + 9 + ] + ] + ] + }, + { + "calls": 64, + "cap": 5, + "factors": 10, + "occurrences": [ + 4, + 8, + 8, + 8, + 4, + 4, + 8, + 8, + 8, + 4 + ], + "price": 64, + "scratch": 5, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4 + ], + [ + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "calls": 96, + "cap": 4, + "factors": 11, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 16, + 8, + 8, + 8, + 8, + 8 + ], + "price": 96, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ] + }, + { + "calls": 80, + "cap": 5, + "factors": 11, + "occurrences": [ + 4, + 8, + 8, + 8, + 4, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 80, + "scratch": 5, + "tree": [ + [ + 0, + 1, + 2, + 3, + 4 + ], + [ + [ + 5, + 6 + ], + 7, + 8, + [ + 9, + 10 + ] + ] + ] + }, + { + "calls": 128, + "cap": 4, + "factors": 12, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8 + ], + "price": 128, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + 6, + 7, + 8 + ], + [ + 9, + 10, + 11 + ] + ] + ] + }, + { + "calls": 96, + "cap": 5, + "factors": 12, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 96, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + 3, + [ + 4, + 5 + ] + ], + [ + [ + 6, + 7 + ], + 8, + 9, + [ + 10, + 11 + ] + ] + ] + }, + { + "calls": 160, + "cap": 4, + "factors": 13, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8, + 16, + 16, + 16, + 16 + ], + "price": 160, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + 6, + 7, + 8 + ], + [ + [ + 9, + 10 + ], + [ + 11, + 12 + ] + ] + ] + ] + }, + { + "calls": 112, + "cap": 5, + "factors": 13, + "occurrences": [ + 4, + 8, + 8, + 4, + 8, + 16, + 16, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 112, + "scratch": 5, + "tree": [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ], + [ + [ + 8, + 9 + ], + 10, + [ + 11, + 12 + ] + ] + ] + }, + { + "calls": 192, + "cap": 4, + "factors": 14, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 192, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + [ + 6, + 7 + ], + [ + 8, + 9 + ] + ], + [ + [ + 10, + 11 + ], + [ + 12, + 13 + ] + ] + ] + ] + }, + { + "calls": 128, + "cap": 5, + "factors": 14, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 128, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + 5, + 6, + 7, + 8 + ], + [ + [ + 9, + 10 + ], + 11, + [ + 12, + 13 + ] + ] + ] + }, + { + "calls": 224, + "cap": 4, + "factors": 15, + "occurrences": [ + 8, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 224, + "scratch": 4, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + [ + 3, + 4 + ], + [ + 5, + 6 + ] + ] + ], + [ + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ], + [ + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ] + ] + ] + }, + { + "calls": 152, + "cap": 5, + "factors": 15, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8 + ], + "price": 152, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + 5, + 6, + 7, + 8 + ], + [ + [ + 9, + 10, + 11 + ], + [ + 12, + 13, + 14 + ] + ] + ] + }, + { + "calls": 256, + "cap": 4, + "factors": 16, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 256, + "scratch": 4, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ] + ], + [ + [ + [ + 8, + 9 + ], + [ + 10, + 11 + ] + ], + [ + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ] + ] + ] + }, + { + "calls": 176, + "cap": 5, + "factors": 16, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8 + ], + "price": 176, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9 + ], + [ + [ + 10, + 11, + 12 + ], + [ + 13, + 14, + 15 + ] + ] + ] + }, + { + "calls": 208, + "cap": 5, + "factors": 17, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 8, + 16, + 16, + 16, + 16 + ], + "price": 208, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9 + ], + [ + [ + 10, + 11, + 12 + ], + [ + [ + 13, + 14 + ], + [ + 15, + 16 + ] + ] + ] + ] + }, + { + "calls": 160, + "cap": 6, + "factors": 17, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 16, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 160, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + 3, + [ + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9, + 10 + ], + [ + [ + 11, + 12 + ], + 13, + 14, + [ + 15, + 16 + ] + ] + ] + }, + { + "calls": 240, + "cap": 5, + "factors": 18, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 240, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9 + ], + [ + [ + [ + 10, + 11 + ], + [ + 12, + 13 + ] + ], + [ + [ + 14, + 15 + ], + [ + 16, + 17 + ] + ] + ] + ] + }, + { + "calls": 176, + "cap": 6, + "factors": 18, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "price": 176, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + 5, + 6, + 7, + 8 + ], + [ + 9, + 10, + 11, + 12 + ], + [ + [ + 13, + 14 + ], + 15, + [ + 16, + 17 + ] + ] + ] + }, + { + "calls": 272, + "cap": 5, + "factors": 19, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 272, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + 6, + 7 + ], + 8, + [ + 9, + 10 + ] + ], + [ + [ + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ], + [ + [ + 15, + 16 + ], + [ + 17, + 18 + ] + ] + ] + ] + }, + { + "calls": 200, + "cap": 6, + "factors": 19, + "occurrences": [ + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8 + ], + "price": 200, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + 5, + 6, + 7, + 8 + ], + [ + 9, + 10, + 11, + 12 + ], + [ + [ + 13, + 14, + 15 + ], + [ + 16, + 17, + 18 + ] + ] + ] + }, + { + "calls": 304, + "cap": 5, + "factors": 20, + "occurrences": [ + 8, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 304, + "scratch": 5, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + [ + 3, + 4 + ], + [ + 5, + 6 + ] + ] + ], + [ + [ + 7, + 8 + ], + 9, + [ + 10, + 11 + ] + ], + [ + [ + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ], + [ + [ + 16, + 17 + ], + [ + 18, + 19 + ] + ] + ] + ] + }, + { + "calls": 224, + "cap": 6, + "factors": 20, + "occurrences": [ + 8, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 8, + 8, + 16, + 8 + ], + "price": 224, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9 + ], + [ + 10, + 11, + 12, + 13 + ], + [ + [ + 14, + 15, + 16 + ], + [ + 17, + 18, + 19 + ] + ] + ] + }, + { + "calls": 336, + "cap": 5, + "factors": 21, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 336, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ] + ], + [ + [ + 8, + 9 + ], + 10, + [ + 11, + 12 + ] + ], + [ + [ + [ + 13, + 14 + ], + [ + 15, + 16 + ] + ], + [ + [ + 17, + 18 + ], + [ + 19, + 20 + ] + ] + ] + ] + }, + { + "calls": 256, + "cap": 6, + "factors": 21, + "occurrences": [ + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8 + ], + "price": 256, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ] + ], + [ + 8, + 9, + 10, + 11, + 12 + ], + [ + [ + 13, + 14, + 15, + 16 + ], + [ + 17, + 18, + 19, + 20 + ] + ] + ] + }, + { + "calls": 384, + "cap": 5, + "factors": 22, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 384, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ], + [ + 15, + 16, + 17 + ], + [ + [ + 18, + 19 + ], + [ + 20, + 21 + ] + ] + ] + ] + }, + { + "calls": 288, + "cap": 6, + "factors": 22, + "occurrences": [ + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 16, + 16, + 16, + 16, + 16 + ], + "price": 288, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ] + ], + [ + 8, + 9, + 10, + 11, + 12 + ], + [ + [ + 13, + 14, + 15, + 16 + ], + [ + [ + 17, + 18 + ], + 19, + [ + 20, + 21 + ] + ] + ] + ] + }, + { + "calls": 448, + "cap": 5, + "factors": 23, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16 + ], + "price": 448, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + [ + 11, + 12, + 13 + ], + [ + 14, + 15, + 16 + ] + ], + [ + [ + 17, + 18, + 19 + ], + [ + 20, + 21, + 22 + ] + ] + ] + ] + }, + { + "calls": 320, + "cap": 6, + "factors": 23, + "occurrences": [ + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16 + ], + "price": 320, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ] + ], + [ + 8, + 9, + 10, + 11, + 12 + ], + [ + [ + [ + 13, + 14 + ], + 15, + [ + 16, + 17 + ] + ], + [ + [ + 18, + 19 + ], + 20, + [ + 21, + 22 + ] + ] + ] + ] + }, + { + "calls": 512, + "cap": 5, + "factors": 24, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 32, + 32, + 32, + 32 + ], + "price": 512, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + [ + 11, + 12, + 13 + ], + [ + 14, + 15, + 16 + ] + ], + [ + [ + 17, + 18, + 19 + ], + [ + [ + 20, + 21 + ], + [ + 22, + 23 + ] + ] + ] + ] + ] + }, + { + "calls": 352, + "cap": 6, + "factors": 24, + "occurrences": [ + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 352, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ] + ], + [ + 8, + 9, + 10, + 11, + 12 + ], + [ + [ + [ + 13, + 14 + ], + [ + 15, + 16 + ] + ], + [ + 17, + 18, + 19 + ], + [ + [ + 20, + 21 + ], + [ + 22, + 23 + ] + ] + ] + ] + }, + { + "calls": 576, + "cap": 5, + "factors": 25, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 576, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + [ + 11, + 12, + 13 + ], + [ + 14, + 15, + 16 + ] + ], + [ + [ + [ + 17, + 18 + ], + [ + 19, + 20 + ] + ], + [ + [ + 21, + 22 + ], + [ + 23, + 24 + ] + ] + ] + ] + ] + }, + { + "calls": 384, + "cap": 6, + "factors": 25, + "occurrences": [ + 8, + 16, + 16, + 8, + 8, + 16, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 384, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2, + 3 + ], + [ + 4, + 5, + 6, + 7 + ] + ], + [ + [ + 8, + 9 + ], + 10, + 11, + [ + 12, + 13 + ] + ], + [ + [ + [ + 14, + 15 + ], + [ + 16, + 17 + ] + ], + [ + 18, + 19, + 20 + ], + [ + [ + 21, + 22 + ], + [ + 23, + 24 + ] + ] + ] + ] + }, + { + "calls": 640, + "cap": 5, + "factors": 26, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 640, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + [ + 11, + 12, + 13 + ], + [ + [ + 14, + 15 + ], + [ + 16, + 17 + ] + ] + ], + [ + [ + [ + 18, + 19 + ], + [ + 20, + 21 + ] + ], + [ + [ + 22, + 23 + ], + [ + 24, + 25 + ] + ] + ] + ] + ] + }, + { + "calls": 416, + "cap": 6, + "factors": 26, + "occurrences": [ + 8, + 16, + 16, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 416, + "scratch": 6, + "tree": [ + [ + [ + 0, + 1, + 2, + 3 + ], + [ + [ + 4, + 5 + ], + 6, + [ + 7, + 8 + ] + ] + ], + [ + [ + 9, + 10 + ], + 11, + 12, + [ + 13, + 14 + ] + ], + [ + [ + [ + 15, + 16 + ], + [ + 17, + 18 + ] + ], + [ + 19, + 20, + 21 + ], + [ + [ + 22, + 23 + ], + [ + 24, + 25 + ] + ] + ] + ] + }, + { + "calls": 704, + "cap": 5, + "factors": 27, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 704, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + [ + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ], + [ + [ + 15, + 16 + ], + [ + 17, + 18 + ] + ] + ], + [ + [ + [ + 19, + 20 + ], + [ + 21, + 22 + ] + ], + [ + [ + 23, + 24 + ], + [ + 25, + 26 + ] + ] + ] + ] + ] + }, + { + "calls": 448, + "cap": 6, + "factors": 27, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 448, + "scratch": 6, + "tree": [ + [ + [ + [ + 0, + 1 + ], + 2, + [ + 3, + 4 + ] + ], + [ + [ + 5, + 6 + ], + 7, + [ + 8, + 9 + ] + ] + ], + [ + [ + 10, + 11 + ], + 12, + 13, + [ + 14, + 15 + ] + ], + [ + [ + [ + 16, + 17 + ], + [ + 18, + 19 + ] + ], + [ + 20, + 21, + 22 + ], + [ + [ + 23, + 24 + ], + [ + 25, + 26 + ] + ] + ] + ] + }, + { + "calls": 768, + "cap": 5, + "factors": 28, + "occurrences": [ + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 768, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + 6, + 7, + 8 + ], + [ + 9, + 10, + 11 + ] + ] + ], + [ + [ + [ + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ], + [ + [ + 16, + 17 + ], + [ + 18, + 19 + ] + ] + ], + [ + [ + [ + 20, + 21 + ], + [ + 22, + 23 + ] + ], + [ + [ + 24, + 25 + ], + [ + 26, + 27 + ] + ] + ] + ] + ] + }, + { + "calls": 480, + "cap": 6, + "factors": 28, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 480, + "scratch": 6, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + 11, + 12 + ], + 13, + 14, + [ + 15, + 16 + ] + ], + [ + [ + [ + 17, + 18 + ], + [ + 19, + 20 + ] + ], + [ + 21, + 22, + 23 + ], + [ + [ + 24, + 25 + ], + [ + 26, + 27 + ] + ] + ] + ] + }, + { + "calls": 832, + "cap": 5, + "factors": 29, + "occurrences": [ + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 832, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + 6, + 7, + 8 + ], + [ + [ + 9, + 10 + ], + [ + 11, + 12 + ] + ] + ] + ], + [ + [ + [ + [ + 13, + 14 + ], + [ + 15, + 16 + ] + ], + [ + [ + 17, + 18 + ], + [ + 19, + 20 + ] + ] + ], + [ + [ + [ + 21, + 22 + ], + [ + 23, + 24 + ] + ], + [ + [ + 25, + 26 + ], + [ + 27, + 28 + ] + ] + ] + ] + ] + }, + { + "calls": 528, + "cap": 6, + "factors": 29, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 528, + "scratch": 6, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + 11, + 12, + 13 + ], + 14, + [ + 15, + 16, + 17 + ] + ], + [ + [ + [ + 18, + 19 + ], + [ + 20, + 21 + ] + ], + [ + 22, + 23, + 24 + ], + [ + [ + 25, + 26 + ], + [ + 27, + 28 + ] + ] + ] + ] + }, + { + "calls": 896, + "cap": 5, + "factors": 30, + "occurrences": [ + 16, + 32, + 16, + 16, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 896, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + [ + [ + 6, + 7 + ], + [ + 8, + 9 + ] + ], + [ + [ + 10, + 11 + ], + [ + 12, + 13 + ] + ] + ] + ], + [ + [ + [ + [ + 14, + 15 + ], + [ + 16, + 17 + ] + ], + [ + [ + 18, + 19 + ], + [ + 20, + 21 + ] + ] + ], + [ + [ + [ + 22, + 23 + ], + [ + 24, + 25 + ] + ], + [ + [ + 26, + 27 + ], + [ + 28, + 29 + ] + ] + ] + ] + ] + }, + { + "calls": 576, + "cap": 6, + "factors": 30, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16 + ], + "price": 576, + "scratch": 6, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + 11, + 12, + 13, + 14 + ], + [ + 15, + 16, + 17, + 18 + ] + ], + [ + [ + [ + 19, + 20 + ], + [ + 21, + 22 + ] + ], + [ + 23, + 24, + 25 + ], + [ + [ + 26, + 27 + ], + [ + 28, + 29 + ] + ] + ] + ] + }, + { + "calls": 960, + "cap": 5, + "factors": 31, + "occurrences": [ + 16, + 32, + 16, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 960, + "scratch": 5, + "tree": [ + [ + [ + [ + 0, + 1, + 2 + ], + [ + [ + 3, + 4 + ], + [ + 5, + 6 + ] + ] + ], + [ + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ], + [ + [ + 11, + 12 + ], + [ + 13, + 14 + ] + ] + ] + ], + [ + [ + [ + [ + 15, + 16 + ], + [ + 17, + 18 + ] + ], + [ + [ + 19, + 20 + ], + [ + 21, + 22 + ] + ] + ], + [ + [ + [ + 23, + 24 + ], + [ + 25, + 26 + ] + ], + [ + [ + 27, + 28 + ], + [ + 29, + 30 + ] + ] + ] + ] + ] + }, + { + "calls": 640, + "cap": 6, + "factors": 31, + "occurrences": [ + 16, + 16, + 16, + 16, + 16, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16 + ], + "price": 640, + "scratch": 6, + "tree": [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + 4, + 5, + 6 + ], + [ + [ + 7, + 8 + ], + [ + 9, + 10 + ] + ] + ], + [ + [ + 11, + 12, + 13, + 14 + ], + [ + 15, + 16, + 17, + 18 + ] + ], + [ + [ + [ + 19, + 20, + 21 + ], + [ + 22, + 23, + 24 + ] + ], + [ + [ + 25, + 26, + 27 + ], + [ + 28, + 29, + 30 + ] + ] + ] + ] + }, + { + "calls": 1024, + "cap": 5, + "factors": 32, + "occurrences": [ + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ], + "price": 1024, + "scratch": 5, + "tree": [ + [ + [ + [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + [ + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ] + ], + [ + [ + [ + 8, + 9 + ], + [ + 10, + 11 + ] + ], + [ + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ] + ] + ], + [ + [ + [ + [ + 16, + 17 + ], + [ + 18, + 19 + ] + ], + [ + [ + 20, + 21 + ], + [ + 22, + 23 + ] + ] + ], + [ + [ + [ + 24, + 25 + ], + [ + 26, + 27 + ] + ], + [ + [ + 28, + 29 + ], + [ + 30, + 31 + ] + ] + ] + ] + ] + }, + { + "calls": 704, + "cap": 6, + "factors": 32, + "occurrences": [ + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 32, + 16, + 16, + 32, + 16, + 16, + 32, + 16 + ], + "price": 704, + "scratch": 6, + "tree": [ + [ + [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + [ + 6, + 7, + 8, + 9 + ], + [ + [ + 10, + 11, + 12 + ], + [ + 13, + 14, + 15 + ] + ] + ], + [ + [ + [ + 16, + 17, + 18 + ], + [ + 19, + 20, + 21 + ] + ], + [ + 22, + 23, + 24, + 25 + ], + [ + [ + 26, + 27, + 28 + ], + [ + 29, + 30, + 31 + ] + ] + ] + ] + } + ], + "symbolic": [ + { + "calls": 1, + "factors": 1, + "nonlinear_atoms": 1, + "scratch": 0, + "word_sha256": "47d62cf50f4414a1b6669e711cbaf7bb5a21a6196ba5fa67bbd8e2b43a977b48" + }, + { + "calls": 4, + "factors": 2, + "nonlinear_atoms": 3, + "scratch": 1, + "word_sha256": "e11bfbfbf682fba49120ec63dc76cdc6ef66ddd6349c68b8d85a9832d6101a9f" + }, + { + "calls": 8, + "factors": 3, + "nonlinear_atoms": 5, + "scratch": 2, + "word_sha256": "c8aaa79b9a7250526e1d81c184d3c0e225af86ca4973105954a63bf4662d67c6" + }, + { + "calls": 16, + "factors": 4, + "nonlinear_atoms": 8, + "scratch": 2, + "word_sha256": "1c906eb140c64325d675c038c884a3bdba4f33ecc4cabac52182dbe3a2971381" + }, + { + "calls": 12, + "factors": 4, + "nonlinear_atoms": 7, + "scratch": 3, + "word_sha256": "aa5651161ff81ce1e2473c14fc5e3afc0bb46e9b30e43c1832c78503a795f325" + }, + { + "calls": 20, + "factors": 5, + "nonlinear_atoms": 10, + "scratch": 3, + "word_sha256": "af9f492ef9bb95dc0c403d095a998e8c724c0e4673de6615557a516bd0067b4d" + }, + { + "calls": 16, + "factors": 5, + "nonlinear_atoms": 9, + "scratch": 4, + "word_sha256": "0217e187903e06b4552b8de642b41c12d7871c9462d9766f6808c88bc0ee4da8" + }, + { + "calls": 32, + "factors": 6, + "nonlinear_atoms": 13, + "scratch": 3, + "word_sha256": "777f69138ab48c0cb8fae9c2b6cce689d43669f378bdb4fd297ae2aa3684a5e5" + }, + { + "calls": 24, + "factors": 6, + "nonlinear_atoms": 12, + "scratch": 4, + "word_sha256": "981d0cc10e8665807cbb3a755d63bd5d022cc0cce2b9acc2f9e649497dc7b0bf" + }, + { + "calls": 48, + "factors": 7, + "nonlinear_atoms": 17, + "scratch": 3, + "word_sha256": "75b66a541911eb2bef0f660020c95a948b7b85ac82dd267ce6048178d4224019" + }, + { + "calls": 36, + "factors": 7, + "nonlinear_atoms": 15, + "scratch": 4, + "word_sha256": "25ea52e67eb017d411d26af339d5a7fd035b72d758d25e29c8d53c1aec9ef7ea" + }, + { + "calls": 64, + "factors": 8, + "nonlinear_atoms": 20, + "scratch": 3, + "word_sha256": "86f067c08b75654f04327b8f05e256fd19a555fd544782fb5476117506f4b824" + }, + { + "calls": 48, + "factors": 8, + "nonlinear_atoms": 18, + "scratch": 4, + "word_sha256": "61be0aa6d2074a1b654288751a9f7052397a10dd3716b77ecbd55892ec5f2b9f" + }, + { + "calls": 64, + "factors": 9, + "nonlinear_atoms": 22, + "scratch": 4, + "word_sha256": "f0ef6adc8c908a99d4cb52a5d3c170c9969c7b962feee7965a289cce679aa833" + }, + { + "calls": 52, + "factors": 9, + "nonlinear_atoms": 20, + "scratch": 5, + "word_sha256": "a09495826f1f2b4d92a804d5dec5c7f5e91f18e3be53c584b7cce5495be42316" + }, + { + "calls": 80, + "factors": 10, + "nonlinear_atoms": 25, + "scratch": 4, + "word_sha256": "969d57e8a2ff2ec20815a0aab10bf51c102aa00f90eeb52a8042323d3cd703a4" + }, + { + "calls": 64, + "factors": 10, + "nonlinear_atoms": 23, + "scratch": 5, + "word_sha256": "5cf7d0fd70b9f25ad7362fc9956520fb333fa93208660b951bfc19e0a692e8b8" + }, + { + "calls": 96, + "factors": 11, + "nonlinear_atoms": 28, + "scratch": 4, + "word_sha256": "787a9b53ae2accb06e74a25e919d3aaac0a1e24b1bb78d8515bb7d1dfa91d951" + }, + { + "calls": 80, + "factors": 11, + "nonlinear_atoms": 27, + "scratch": 5, + "word_sha256": "500dcd78902b375bed625dd527d578329003fa3c619889e4ff93babcafb1f3e5" + }, + { + "calls": 128, + "factors": 12, + "nonlinear_atoms": 32, + "scratch": 4, + "word_sha256": "253755d75f8b997b81c5adbad552f8a43d0a30cf016927b614883c875b53601e" + }, + { + "calls": 96, + "factors": 12, + "nonlinear_atoms": 30, + "scratch": 5, + "word_sha256": "445ef7389a7c14ca0d32be19da04b44ef094b79caaabc458415ef7d5be3ae6e2" + }, + { + "calls": 160, + "factors": 13, + "nonlinear_atoms": 37, + "scratch": 4, + "word_sha256": "85a0bd6672375652844de1cb38c419490e0e986e29887c8874e0402bd9188559" + }, + { + "calls": 112, + "factors": 13, + "nonlinear_atoms": 33, + "scratch": 5, + "word_sha256": "7e76a56154fa4d43ef62c12900ee12dfc1a87af0649f91dbc6f90f68ff3ba2c5" + }, + { + "calls": 192, + "factors": 14, + "nonlinear_atoms": 41, + "scratch": 4, + "word_sha256": "574ab5455ca4766e0d2f4fa816d097572998d8a7290ace7432d0bd07203b33b1" + }, + { + "calls": 128, + "factors": 14, + "nonlinear_atoms": 36, + "scratch": 5, + "word_sha256": "15f918d7bfcd64fa934bc50400694212b3e0a1d64c88b4f355a016d4b73269ea" + }, + { + "calls": 224, + "factors": 15, + "nonlinear_atoms": 45, + "scratch": 4, + "word_sha256": "5866ffebaf1d4ca9940cdfea1105343fedd6f248930110b5ffbcd10ff8a9d727" + }, + { + "calls": 152, + "factors": 15, + "nonlinear_atoms": 40, + "scratch": 5, + "word_sha256": "d0ad9a498558181ea284db0f6a0484f9b5a47c88968c7e42b6eff8042ac75ab9" + }, + { + "calls": 256, + "factors": 16, + "nonlinear_atoms": 48, + "scratch": 4, + "word_sha256": "57b5c39fcb51f57cfceab8f6d7b2b7fb93024729c5f5692bf3f6d8518ac1857d" + }, + { + "calls": 176, + "factors": 16, + "nonlinear_atoms": 43, + "scratch": 5, + "word_sha256": "9f0a8f403690a3adf251a085372f5e9d2eccbace7f6179ca38e6ce59a29585a5" + }, + { + "calls": 208, + "factors": 17, + "nonlinear_atoms": 48, + "scratch": 5, + "word_sha256": "0dca6ffe9ba7f480b77869c8b231b00c3e066165fb563b717c9203d4fe1ee420" + }, + { + "calls": 160, + "factors": 17, + "nonlinear_atoms": 44, + "scratch": 6, + "word_sha256": "930468570f6d1d23023a1d68d88037c3e042a8062ce1ca7a8917604362f17ec3" + }, + { + "calls": 240, + "factors": 18, + "nonlinear_atoms": 52, + "scratch": 5, + "word_sha256": "67d689bdbf3d31766d8482be024a6c807922cb79a76e94035efc6b8247d42801" + }, + { + "calls": 176, + "factors": 18, + "nonlinear_atoms": 47, + "scratch": 6, + "word_sha256": "e032c122a989ca3a38603138629d91da423b4d3c50a6e615d3386048c4b7c9d9" + }, + { + "calls": 272, + "factors": 19, + "nonlinear_atoms": 56, + "scratch": 5, + "word_sha256": "d1b817a659082bc2813a427500d70fcff1aab8e119e39a7fb00f0a6cdf0a4a25" + }, + { + "calls": 200, + "factors": 19, + "nonlinear_atoms": 51, + "scratch": 6, + "word_sha256": "53f215a3871f3efd7081dc3fec29787c1a894e6e44ed4c0de7e5b868177c91b7" + }, + { + "calls": 304, + "factors": 20, + "nonlinear_atoms": 60, + "scratch": 5, + "word_sha256": "42ca52460ccf9711e0158a9a8b8db20f00d6b14b086bb54f3f785af9a9967b0b" + }, + { + "calls": 224, + "factors": 20, + "nonlinear_atoms": 54, + "scratch": 6, + "word_sha256": "d0a3ccae230c38b0c0bed6c8b2c7a7ac0ec9ebe575bdbc3cc93c1d23f1fdc081" + }, + { + "calls": 336, + "factors": 21, + "nonlinear_atoms": 63, + "scratch": 5, + "word_sha256": "749bcdc51ee482a25e3bd6500c48019107c4f40e24d993d22345d7b7916bfa43" + }, + { + "calls": 256, + "factors": 21, + "nonlinear_atoms": 58, + "scratch": 6, + "word_sha256": "b20da500df9ee7970f9ba022bdae42a9e11334b42d77d7d29059ebd989e71782" + }, + { + "calls": 384, + "factors": 22, + "nonlinear_atoms": 67, + "scratch": 5, + "word_sha256": "5c01d954b243fe5706a278d89e9d225783e23e0186acc90f25b7d0adb9e1221d" + }, + { + "calls": 288, + "factors": 22, + "nonlinear_atoms": 63, + "scratch": 6, + "word_sha256": "7c687eea2e15f09c614c835df82a06cb90ce1d9e5755355a5e899b9a4b53f108" + }, + { + "calls": 448, + "factors": 23, + "nonlinear_atoms": 72, + "scratch": 5, + "word_sha256": "e21a9349b0993c6ed33ccafb65b67e6f577918f466069c6563a685224c2a1cd1" + }, + { + "calls": 320, + "factors": 23, + "nonlinear_atoms": 67, + "scratch": 6, + "word_sha256": "223574ac851f4481f234e79f0dcfd85af3305389528e6b1a561a9d969168f7ea" + }, + { + "calls": 512, + "factors": 24, + "nonlinear_atoms": 78, + "scratch": 5, + "word_sha256": "8aaefe345e60847b17f14f2455003fc176f601c05c5ee944d4077a3694d52d07" + }, + { + "calls": 352, + "factors": 24, + "nonlinear_atoms": 71, + "scratch": 6, + "word_sha256": "fe1af504e52470988471d04d12510f014c704b051c2a7448b34da978e6de767f" + }, + { + "calls": 576, + "factors": 25, + "nonlinear_atoms": 83, + "scratch": 5, + "word_sha256": "1c04fce5f3ce5b649959204ba3124969dbf466e2310a907a9d29be43616dc826" + }, + { + "calls": 384, + "factors": 25, + "nonlinear_atoms": 75, + "scratch": 6, + "word_sha256": "50da14fa178c735303e6853b014f5c3a047444c616c31d4e34f6f66de53a99e5" + }, + { + "calls": 640, + "factors": 26, + "nonlinear_atoms": 88, + "scratch": 5, + "word_sha256": "cca4d0d3e80c44a9642b76c9bbc75af73cd37968fe804f802be66777b850b2e7" + }, + { + "calls": 416, + "factors": 26, + "nonlinear_atoms": 79, + "scratch": 6, + "word_sha256": "d863596db70c7a43c807e120f5b9a21e4cf09095777dd4db61c7c9587239703e" + }, + { + "calls": 704, + "factors": 27, + "nonlinear_atoms": 92, + "scratch": 5, + "word_sha256": "c2c425b08041fe8a0f8afb4a17207a41808385f51dca7663ad9f3a246b5a82c0" + }, + { + "calls": 448, + "factors": 27, + "nonlinear_atoms": 82, + "scratch": 6, + "word_sha256": "afbe416f927e0df4ad4668030048a6cd3de0c83c807c37a7d7faf6b4e73ad82c" + }, + { + "calls": 768, + "factors": 28, + "nonlinear_atoms": 96, + "scratch": 5, + "word_sha256": "4feb8b52440082f71f9b9647beae282398085f732d702b40772fd1853cfe97c4" + }, + { + "calls": 480, + "factors": 28, + "nonlinear_atoms": 85, + "scratch": 6, + "word_sha256": "7457d2d97b36e92785dc65b0b03e02c3ae632314d79078ba8c04b410fd26931a" + }, + { + "calls": 832, + "factors": 29, + "nonlinear_atoms": 101, + "scratch": 5, + "word_sha256": "7de248e3a87fe708e3866ed7270e20fdca88573c4405aad3fe7021393032f21f" + }, + { + "calls": 528, + "factors": 29, + "nonlinear_atoms": 89, + "scratch": 6, + "word_sha256": "15b352393327354e3f47161aa7cff71ff6a396b781451f77635fae1a2e16d334" + }, + { + "calls": 896, + "factors": 30, + "nonlinear_atoms": 105, + "scratch": 5, + "word_sha256": "255ad4ec5476944ae3f1be8df2ab60c01ba9f0ea857cc7410da5ee3f3123d75e" + }, + { + "calls": 576, + "factors": 30, + "nonlinear_atoms": 93, + "scratch": 6, + "word_sha256": "6317b61306a2b18510319d9ceb5a83a767d1875e07cf917eff90c050ad26bc81" + }, + { + "calls": 960, + "factors": 31, + "nonlinear_atoms": 109, + "scratch": 5, + "word_sha256": "943c2b7baf2169b78faa3d46c4c0863d8e12bf529a2045da8b40f9925253b481" + }, + { + "calls": 640, + "factors": 31, + "nonlinear_atoms": 98, + "scratch": 6, + "word_sha256": "1513cf283e0a566150e3b51f5c1e38309b9c3569c4ed52f0881d2c2891eac1f3" + }, + { + "calls": 1024, + "factors": 32, + "nonlinear_atoms": 112, + "scratch": 5, + "word_sha256": "17485f46a8e8c3be29dec4b6cd7b8f7763a59134efd3951cfbf394097ad49433" + }, + { + "calls": 704, + "factors": 32, + "nonlinear_atoms": 102, + "scratch": 6, + "word_sha256": "61df444b2960c180c76e6c26935a39c205f6595965fa89c59a3d5ff97ad4e103" + }, + { + "calls": 1600, + "factors": 58, + "nonlinear_atoms": 199, + "scratch": 8, + "word_sha256": "a721c6f90d1965173a543333788e432d3fc5fa658ce80569cb3f055936e9f679" + } + ] + } +} diff --git a/research/space-capped-dirty-echo/LICENSE b/research/space-capped-dirty-echo/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/space-capped-dirty-echo/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/space-capped-dirty-echo/NOTICE.md b/research/space-capped-dirty-echo/NOTICE.md new file mode 100644 index 0000000000..3d19f09aaa --- /dev/null +++ b/research/space-capped-dirty-echo/NOTICE.md @@ -0,0 +1,77 @@ +# Attribution and license + +New exact space-capped interval planner, literal plans, bounded experiments, +verification and written scope: **Koroffstrogov**, with substantial **OpenAI +Codex assistance**. New material is Apache-2.0, as in the included LICENSE. +No independent human peer review or priority over the general dynamic +programming/reversible-pebbling literature is claimed. + +- **androolloyd, PR673**, pinned at + `bfff94e78f0e75ebd2593e3cc7710ae5290e8be3`: the multiway echo identity, + arbitrary nonlinear source/scratch restoration, endpoint/interior execution + multiplicities, inherited error argument, generic fanout tradeoff, and later + all-role adapter cost obstruction. `vendor/pr673` retains exact source and + proof bytes with their original disclosure. This contribution optimizes + partitions/arity at a hard space cap; it does not originate the echo or its + subquadratic fixed-fanout bound and does not review the rest of that PR. +- **Dillon Amburgey / dillona, PR689**, pinned at + `0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a`: the improved balanced ternary + partition and 160-call/five-array comparison. Its `ternary.py`, README and + full NOTICE are retained byte-for-byte. Its explicit exclusion of unbalanced + partitions/other arities/unequal prices motivates the new class here. The + exact balanced predecessor word is recounted, not reconstructed from its PR + title. Our checkers and optimizer are new implementations; the earlier + symbolic-audit methodology is acknowledged. +- **Chafik Boukhalfa / chafreaky, PR628**, pinned at + `0768f97d06c623b8211e651543c66135796b62bf`: cyclic inverse leaves, exact + integer source lifts, finite root enclosures, coefficient preparation and + rounding bounds, dense rational reference routines and original binary + dispatcher. Its original notice is retained in `vendor/pr628/NOTICE.md`, + including Ali Romman / PR621, OpenAI's exact-DFT source, Kuznetsov, Pan, + Mehlhorn, Sagraloff, Wang, Brent and Briand-Davy. We use its unchanged leaf + and declared contracts; we do not reprove their analytic algorithms. Its + old public `compose` is not used, including its known phase-alias defect. +- **0xkilgore, PR663**, `e0e546fd01b396478c68b6b6c5a16d87515983ba`: + predecessor independent audit of nonlinear dirty restoration and the binary + call count. Credited context, not an executable dependency. +- **Jeremy Kothe, Chafik Boukhalfa, eumemic**, #622/#623/#626 and #543, and + their full cumulative lineage in the selected maintainer review: the base + repository's conditional accepted construction. It is unchanged and is not + newly cold-replayed here. + +Classical borrowed-workspace and cancellation methods have substantial prior +literature; PR673 and PR689 preserve their relevant Bennett/catalytic-space +and related ladder attributions. Their complete notices remain applicable. +This package makes a scoped minimum/count claim for an explicitly defined +tree family, not a new general reversible-computation theorem. + +Nearby pending #665 (spectral residual splitting), #677 (native DATA-shear +boundaries), and #679 (selector-volume batching) concern different interfaces. +None supplies executable code to this package. PR673's full-transform negative +result is explicitly retained rather than silently reopened by a lower local +leaf count. + +**FanPUYen, concurrent PR714**, inspected at +`efad8a40094ab453c0525efef0b0eff2a5d8b850`, improves the root split when one +array is genuinely clean, while retaining balanced binary dirty children. +Our entire pool is arbitrary dirty input; we change the whole tree's arities +and partitions without a clean-array premise. The interfaces and optimization +domains differ. No PR714 implementation or claimed optimum is consumed. + +**Sagar Thakrar / thakrarsagar, concurrent PR730**, at +`d222e348179cc02a54d6d26dbd2838944f62c6e5`, published an exact interval +optimizer for unbalanced contiguous binary/ternary echo trees and unequal +positive prices during this contribution's verification. It is prior published +work on that class; no priority for unbalanced/weighted optimization is claimed +here. Its byte-exact `optimize.py` and full NOTICE are retained in `vendor/pr730` +and pinned separately. The comparison runs that actual optimizer and its +literal words. The strict additional gain here comes from higher arities: +at 15 factors / five arrays, 160 becomes 152 through a four-child node. + +**Ali Romman, concurrent PR744**, at +`576c6b20065fff3402c1eed2ad74c5c7d03029e8`, independently audits the strict +ternary class with a larger finite state table, literal witnesses and rounded +leaf tests. Its code is not consumed. This package does not duplicate that +state-table claim; it supplies the higher-arity optimum and an actual pinned +radix-16 weighted fixture. Both concurrent submissions retain their independent +evidence and source credits. diff --git a/research/space-capped-dirty-echo/PROOF.md b/research/space-capped-dirty-echo/PROOF.md new file mode 100644 index 0000000000..e256de5db9 --- /dev/null +++ b/research/space-capped-dirty-echo/PROOF.md @@ -0,0 +1,242 @@ +# Exact planning under a borrowed-array cap + +This is a written proof about a restricted recursive interface, accompanied by +finite checks. It is not a proof-assistant formalization. The multiway echo and +its nonlinear restoration argument are credited to androolloyd's PR673; PR689 +by Dillon Amburgey supplies the balanced ternary baseline. Our addition is +optimization over **all contiguous partitions and all arities** under a fixed +peak-space cap, including nonuniform positive integer leaf prices. + +Concurrent PR730 (Sagar Thakrar) published the analogous interval optimization +for binary/ternary trees during this work; PR744 (Ali Romman) independently +audits strict ternary trees. We claim no priority for their shared optimization +or proof principles. Our k>=2 recurrence admits higher arities, and the pinned +comparison in CONCURRENT.json shows the strict gain from doing so. + +## 1. Contract and admitted program class + +There are ordered factors F_0,...,F_(n-1), a source x, a target y and S arbitrary +borrowed length-L arrays. All arrays are distinct. A positive leaf adds a +deterministic function of its source to its target, preserves the source, and +restores any scalar/data work it borrows. The increment is independent of the +target. A negative leaf subtracts exactly that same value. Factor descriptors, +phase data and every other read-only dependency are fixed and do not alias +mutable arrays. Stateful callbacks and overlapping views are outside this API. + +An internal node has k>=2 **nonempty consecutive** children. It reserves k-1 +distinct arrays for its complete duration. Its children run sequentially and +share a deeper pool that excludes every reserved array and every ancestor +source/target. A leaf has no borrowed-array requirement. Thus these are ordered +rooted trees without unary nodes. The optimization does not cover arbitrary +pebbling, simultaneous children, borrowing idle ancestor arrays, alternative +echo words, commuting-factor reordering, or deletion of identity factors. + +For child maps A_1,...,A_k, let C be the ascending ladder + +``` +z_1 += A_1(x); z_2 += A_2(z_1); ...; z_(k-1) += A_(k-1)(z_(k-2)). +``` + +Let D be that ladder with its first instruction omitted. PR673's word is + +``` +C; y += A_k(z_(k-1)); C^-1; +D; y -= A_k(z_(k-1)); D^-1. +``` + +The inverses reverse chronological order AND signs. A child inverse encounters +the same source and deeper dirt as its forward mate: later ladder changes have +already been undone, and target updates touch only y. Consequently source and +all dirt are restored, even for nonlinear deterministic leaves. The result is +an additive, target-independent increment. It can depend on dirt when leaves +are nonlinear. For ideal linear leaves the difference between the C and D +states propagates as A_j...A_1 x, giving exactly A_k...A_1 x. Commutativity is +not assumed. This proves the recursive contract by induction. + +The first and last children occur twice; every interior child occurs four +times. There is no free cleanup pass or clean length-L copy. + +## 2. Bellman recurrence and its scope of optimality + +Let c_i be a positive integer price for one complete signed invocation of +factor i, equal for the two signs. Prices are fixed at the chosen L and working +precision, and include whatever operation is being optimized. For instance, +c_i=1 counts completed leaves; c_i=(5L-2) or (6L-2) counts the actual PR628 +outer/inner phase reads. Phase reads alone are not total runtime. + +Define D(i,j,s) as the minimum price in the stated tree class for factors +[i,j) using at most s borrowed arrays. A singleton costs c_i for every s>=0. +A nonsingleton with s=0 is infeasible. For all other states: + +``` +D(i,j,s) = min over 2 <= k <= min(j-i,s+1), i=t_0<...2^s are exactly infeasible. +Clamping s to n-1 also loses no tree: along any root-to-leaf path, each of the +sum(k-1) side subtrees contains a distinct leaf other than the final leaf. + +## 3. Literal primary result + +Assignment seed 58 selects radix 16 from the predeclared eight-radix list; +there are 15 factors, kept in their original order. At the five-array budget +used by PR689, the uniform-price optimum is **152** complete leaf calls, versus +160 for PR689's optimized balanced ternary word and 208 for PR673's original +ternary partition. The optimum tree, with zero-based leaves, is + +``` +(((0,1),2,(3,4)), (5,6,7,8), ((9,10,11),(12,13,14))). +``` + +Its root child counts are 20, 12, 32 and child spaces are 3, 3, 3. Hence +N=2*20+4*12+2*32=152 and S=2+3=5. All restoration is already in these counts. +The middle child has arity four, outside PR730's class. Its pinned optimum is +160 here, so the improvement is not merely a different optimum tree within +that concurrently published class. +Leaf multiplicities are + +``` +8,8,8,8,8,8,16,16,8,8,16,8,8,16,8. +``` + +At four arrays the class optimum is 224. At fourteen arrays the flat word +reaches 56. These comparisons are a space/work tradeoff, not a free removal +of scratch. `EXPECTED.json` retains every optimum for caps 4 through 14, each +checked by the all-cuts oracle, and the phase-read-weighted radix-16 instance. + +At cycle length L=5 the pinned radix-16 factors have phase-read prices +`23,28,28,28,23,23,23,23,23,23,23,23,23,28,23`. Optimizing these prices at +five arrays retains 152 calls but selects a different last root child: +`((9,10),(11,12),(13,14))`. Its complete phase bill is **3656**, compared with +3696 for the uniform-price tie choice and 3840 for PR689's balanced word. +This is the exact phase-read minimum in the stated tree class at this fixed +length. The optimum is not asserted to minimize total bit work. + +## 4. Complete execution, preparation and precision bill + +For a literal tree t, let v_i(t) be its occurrence vector. At an internal node +the vectors of the two endpoint children are doubled and those of interior +children quadrupled. Then + +``` +N(t) = sum_i v_i(t), +S(t) = (k-1) + max_child S(child), +T_t(L,w) = 2 T_first(L,w) + 4 sum_interior T_child(L,w) + + 2 T_last(L,w) + control_t. +``` + +The complete external charge is + +``` +P_plan(n,S,c) + P_factor_phase(n,L,w) + P_admit(n,S,L) + + sum_i v_i(t) * [A_i(L,w) + Q_i(L,w) + R_i(L,w)] + + P_schedule(t) + P_boundary(t,L,w). +``` + +Here A_i pays the leaf's arithmetic, coefficient work, validation, normalization +and exact source undo; Q_i pays all source/phase/table access; R_i pays each +leaf's required routing. P_factor_phase pays certified coefficient and phase +preparation, with original-input scaling. P_admit includes array-length, +alias, descriptor and unit-phase admission. No fixed-tape route is free. +P_boundary is zero only at this array-level interface, where every factor +already shares a layout; a supplier integration must supply and charge its +layout, frame, hosting and final-boundary work. There is no newly inserted +copy, erase, transform, or clean length-L workspace in this dispatcher. + +In the pinned PR628 leaf, each invocation executes three L-loop traversals, +plus stability/grid scans. All are retained. Its complete phase accesses are +(5L-2) for an outer factor and (6L-2) for an inner factor, including inverse +source lifts. Instrumented real-leaf execution checks these formulas separately +from the planner's weights. Mutable storage is source, target and S(t) borrowed +arrays; a test-only spectator is never touched. Scalar arithmetic workspace and +the immutable O(n) factor/tree descriptors are additional, not clean data arrays. + +Planning is also paid. This implementation is an exact indexed-RAM reference, +not a fast uniform tape compiler. With the clamped S<=n-1 and B-bit input +prices, it has O(S*n^2) interval states and O(S^3*n^4) candidate evaluations. +Prices have O(B+S+log n) bits. Including tuple bookkeeping gives the deliberately +loose O(S^4*n^4*(B+S+log n)) bit-work bound, plus input/output, in an ordinary +RAM implementation. Retained trees and temporary prefix tables can safely be +bounded by O(S^2*n^3) references. The emitted execution word is streamed, with +O(n) stored tree nodes and O(S) active child descriptors along a path. For this +fixed 15-factor contribution the supplied literal tree needs no runtime search; +for growing n the planning term must not be suppressed. We claim no new +asymptotic exponent or measured wall-time acceleration. + +For rounded execution inherit PR628/PR673's hypotheses: ideal factor norms +at most K=r/beta; deterministic completed-leaf error at most a(B+1)u on source +norm B; a=13(r+1)/beta^3; u=2^-w; au<=1 and u<=beta^2/2. Set G=2+K and let D +bound all initial arrays, including dirt. After j completed leaves, + +``` +M_j+1 <= G^j(D+1), +E_(j+1) <= (1+K)E_j + a*u*G^j(D+1), +E_N <= N*a*(D+1)*u*G^(N-1). +``` + +These inequalities concern the complete word, including every inverse leaf. +Actual source and scratch restoration is exact by Section 1; the target has +the bounded rounding error. Sufficient working precision is + +``` +w >= p+1+ceil(log2(N*a*(D+1)))+(N-1)*ceil(log2 G), +``` + +together with the two leaf conditions. Factor/phase preparation must separately +consume at most the other half of the 2^-p error budget, scaled by the original +source norm. The retained finite root fixtures are not asserted to meet an +arbitrary stronger preparation target. Our tests check represented-factor +execution against the complete polynomial and separately run their original +root certificate. They do not reprove the analytic preparation algorithm. +The new dispatcher changes neither leaf semantics nor the inherited estimates. + +## 5. Why the local saving does not imply a new kappa + +PR673's later [all-role adapter analysis](vendor/pr673/INTEGRATION-PROOF.md) +already prices the missing outputs on borrowed roles. Its optimistic moment +is 3*N(n)/(2*n^(1-b)), even granting one recursive child per additive leaf and +zero routing, phase, preparation and precision work. For our primary count at +n=15 and b=0 it is **76/5**, still far above 1. This is a hypothetical price +for 15 equal-width factor groups in that adapter, not an assertion that the +radix-16 cyclic factors implement its Clifford endpoint. + +The inherited general tree bound N(n)>=4n-4 survives arbitrary partitions and +arities: first inductively N(n)>=2n-1; then endpoint children contribute at +least 4n_i-2 each, and interior children at least 4n_i. Summation gives 4n-4. +Thus even the flat optimum has moment at least 6-6/n>=3 for n>=2 and b>=0. +We do not reopen that closed direct-adapter search. The useful result here is +a smaller **local restored-array bill**, with its exact space/weight contract. + +The selected construction remains #626/#543 at +51110230636731/31250000000000000. The complex supplier still binds there. No +selected child histogram, owner schedule, supplier exponent or outer inequality +is changed. All-size compilation, common-label/mutable-basis realization, +physical hosting, fixed-tape implementation, precision/exact recovery and +analytic transfer remain inherited or unresolved. diff --git a/research/space-capped-dirty-echo/README.md b/research/space-capped-dirty-echo/README.md new file mode 100644 index 0000000000..8c416d82b2 --- /dev/null +++ b/research/space-capped-dirty-echo/README.md @@ -0,0 +1,168 @@ +# Space-capped dirty echoes: 152 calls instead of 160 + +**Recursive-interface research / construction refinement; no new kappa.** +Allowing unbalanced contiguous groups and mixed arities in PR673's multiway +echo reduces a 15-factor composition from PR689's **160 to 152 complete leaf +calls, with the same five arbitrary borrowed arrays**. Every inverse and +restoration call is counted. The supplied dynamic program proves the minimum +within the stated sequential echo-tree class, rather than only finding a +better tree. It also supports unequal positive integer leaf costs without +reordering the factors. + +**Concurrent #730 also optimizes unbalanced trees and unequal prices, restricted +to binary/ternary nodes.** Its pinned optimizer still gives 160 at this primary +instance. Admitting the four-child node yields the strict **160 -> 152** gain. +Concurrent #744 independently audits the ternary class with broader finite +coverage. Neither package admits our higher arities. We credit their prior +publication and make no priority claim for unbalanced or weighted optimization. + +For the pinned radix-16 cyclic factors on a length-five cycle, weighting actual +phase accesses selects another 152-call tree: **3656 phase reads**, versus +3840 for the balanced baseline and 3696 for the uniform-price tie choice. +These are exact operation counts, not measured runtime speedups. Arbitrary +dirty source/scratch restoration and complete-word inversion hold in the +rounded test cases; approximation error is separately bounded. + +| Five-array comparison, 15 ordered factors | Complete calls | Phase reads at length 5 | +|---|---:|---:| +| PR673's original ternary partition | 208 | Not used as the phase baseline | +| PR689's improved balanced ternary tree | 160 | 3840 | +| This package, uniform-price optimum | 152 | 3696 | +| This package, phase-price optimum | 152 | 3656 | + +The new search class matters: PR689 explicitly excludes unbalanced splits, +other arities and unequal costs. Seed 58 happens to match PR689's assignment +seed; the distinct contribution is the enlarged, exactly optimized tree class +and actual weighted fixture, not the seed. The echo identity, its generic +nonlinear restoration argument, and the rounded leaf are predecessor work. +Concurrent #714 instead supplies a clean-root checkpoint and a different +binary-root optimization; it requires one initially clean array. Our pool is +entirely arbitrary dirty input, and that work is credited in NOTICE.md. + +## Reproduce + +From the repository root, with Python 3.11+ and the standard library: + +```sh +python3 -I -B research/space-capped-dirty-echo/verify.py +python3 -I -O -B research/space-capped-dirty-echo/test_contracts.py +python3 -I -O -B research/space-capped-dirty-echo/compare_concurrent.py +``` + +Expected final line of the first command: + +``` +PASS_SPACE_CAPPED_DIRTY_ECHO calls=160->152 scratch=5 no_new_kappa +``` + +The second command runs nine tests and reports `OK`. Checks use explicit +exceptions and remain active under optimized Python. The verifier checks every +field of [EXPECTED.json](EXPECTED.json); it does not write files by default. +`--write /new/path.json` writes a new certificate and refuses an existing file. +The test harness needs a writable current directory for temporary corruption +fixtures and removes only those fixtures. No network or solver is required. +The third command runs the byte-exact #730 optimizer, checks its literal words, +and compares all fields of [CONCURRENT.json](CONCURRENT.json), ending with +`PASS_HIGHER_ARITY_COMPARISON`: + +| Factors / array cap | #730 binary/ternary minimum | All-arity minimum | +|---|---:|---:| +| 15 / 5 | 160 | 152 | +| 15 / 6 | 144 | 128 | +| 27 / 6 | 464 | 448 | +| 58 / 8 | 1728 | 1600 | + +On the actual weighted radix-16 instance, #730 gives 3840 phase reads; the +all-arity result is 3656. This comparison uses two separately pinned files in +[CONCURRENT-SOURCES.json](CONCURRENT-SOURCES.json). It is a scoped replay of +the optimizer/word, not a review of the rest of #730. + +The package consumes its vendored files plus exactly three repository context +files: `certificates/selected-result.json`, +`research/community-k492-audit/pr626/replay/ASSEMBLY.json`, and +`docs/research/community-k492-review.md`. Their hashes, as well as all vendored +bytes, are pinned in [SOURCES.json](SOURCES.json). A full supplier rebuild is +not performed by this command. + +## Result, coverage and limits + +[PROOF.md](PROOF.md) states the contract, recurrence, optimality induction, +workspace rule, full execution/preparation/precision invoice and integration +limit. [planner.py](planner.py) emits both signs of the literal word. +[verify.py](verify.py) contains separate exhaustive-tree and all-root-cut +oracles, and symbolic interpreters that consume the emitted instructions. + +Completed finite coverage retained in the certificate: + +- **5440 whole ordered trees** on 1–8 leaves; four weight vectors and every + cap 0 through n-1, giving 144 feasibility/optimum comparisons. +- Every primary 15-factor cap from 4 through 14 checked by explicit root-cut + enumeration, plus the weighted five-array optimum (18,212 root partitions + considered for that weighted recurrence). +- Uniform plans for n=1–32 at the minimum feasible cap and one extra array, + and the seed-related n=58/cap=8 diagnostic. There are 63 complete symbolic + word checks including the weighted primary tree. The n=58 object is generic; + it is not described as a prime-power kernel at radix 59. +- **48 generic rounded compositions and eight radix-16 compositions** using + the byte-exact PR628 leaf. Both cycle directions, two nonzero dirty fixtures, + an untouched spectator, dense rational references, actual phase-read counts + and exact whole-word inverses are checked. These are finite input tests, + not an exhaustive rounded-input proof. +- **326 rejecting controls**, including omission/sign changes at every one + of the 152 primary leaves, wrong factor/inverse order, scratch aliases and + invalid public inputs. Five actual implementation mutations are detected + by the additional tests; source/context corruption is rejected. A concrete + nonlinear example distinguishes exact restoration from dirt-independent + output, and a target-dependent callback demonstrates a violated premise. + +For the uniform 15-factor instance the full optimum row is: + +| Allowed arrays | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| Complete leaf calls | 224 | 152 | 128 | 112 | 100 | 92 | 84 | 76 | 68 | 60 | 56 | + +The stopping rule was one exact planner with this fixed verification domain. +The four small-tree weight vectors are uniform, increasing, decreasing, and +generated by Python `random.Random(58)` with entries 1–58; this pseudorandom +test sequence is separate from the OS-random assignment draw. Enumeration +completes the declared domain. It does not exclude other reversible programs, +alternative scratch-sharing rules, or mechanisms outside the echo-tree class. + +PR673's all-role adapter still has an unfavorable optimistic bill. Even after +this local improvement, its 15-group moment is **76/5 at saving zero**, and +the inherited class bound remains at least 3 for every nonnegative saving and +n>=2. No integration search is reopened, no selected supplier changes, and no +new kappa follows. A different physical integration and complete pricing would +be needed before this primitive could affect the multiplication bound. + +## Provenance and handoff + +Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +Selected construction: #626/#622/#623 with #543, +`kappa = 51110230636731/31250000000000000 = 0.001635527380375392`. +The linked assembly's SHA-256 is +`6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e`. +The review retains the all-size/compiler/common-label/mutable-basis, hosting, +normalized-residual, precision/tape/exact-recovery and analytic assumptions. + +Exact predecessor heads: + +- PR628: `0768f97d06c623b8211e651543c66135796b62bf`. +- PR673: `bfff94e78f0e75ebd2593e3cc7710ae5290e8be3` (including its later + full-transform cost obstruction, not just its original local echo). +- PR689: `0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a`. +- Concurrent comparator PR730: `d222e348179cc02a54d6d26dbd2838944f62c6e5`. +- Concurrent credited audit PR744: `576c6b20065fff3402c1eed2ad74c5c7d03029e8` + (no executable dependency). + +No predecessor PR must be merged for reproduction. All additions are in this +directory. `upstream/`, generators, accepted suppliers, selected frontier and +the review ledger are unchanged. [CLAIM.json](CLAIM.json) records the three +candidate tasks, selected scope, random assignment and overlap checks. +[VALIDATION.md](VALIDATION.md) separates fresh checks from inherited evidence. + +Prepared for **Koroffstrogov**, with substantial **OpenAI Codex assistance** in +the mathematics, implementation, checks and documentation. See +[NOTICE.md](NOTICE.md) for predecessor credit. Apache-2.0. No independent +human peer review, proof-assistant proof, full multiplication theorem, global +algorithmic optimality, or practical runtime improvement is claimed. diff --git a/research/space-capped-dirty-echo/SOURCES.json b/research/space-capped-dirty-echo/SOURCES.json new file mode 100644 index 0000000000..1c715b77fd --- /dev/null +++ b/research/space-capped-dirty-echo/SOURCES.json @@ -0,0 +1,116 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "sources": [ + { + "path": "vendor/pr628/dirty.py", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/dirty.py", + "sha256": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21" + }, + { + "path": "vendor/pr628/weighted.py", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/weighted.py", + "sha256": "8b0f93d131a30e64eb0ccd893779daffea79c0c00f1d2a30a91d23eb2bf0bff5" + }, + { + "path": "vendor/pr628/check.py", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/check.py", + "sha256": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d" + }, + { + "path": "vendor/pr628/scan.py", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/scan.py", + "sha256": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e" + }, + { + "path": "vendor/pr628/interval_kernel.py", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/interval_kernel.py", + "sha256": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe" + }, + { + "path": "vendor/pr628/FACTORS.json", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/FACTORS.json", + "sha256": "643d60ac24d5e67f6c9305175bd1c99bf5e42edfef6d1995c051e0b98ba446a7" + }, + { + "path": "vendor/pr628/DIRTY-PROOF.md", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/DIRTY-PROOF.md", + "sha256": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61" + }, + { + "path": "vendor/pr628/NOTICE.md", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/NOTICE.md", + "sha256": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68" + }, + { + "path": "vendor/pr628/check_budgets.py", + "commit": "0768f97d06c623b8211e651543c66135796b62bf", + "source_path": "research/prime-power-cyclic-scan/check_budgets.py", + "sha256": "581ba58a30e05cb09dadb35be6e25bd92232b2137a0cc7eb5b83e2ee20c0bf02" + }, + { + "path": "vendor/pr673/echo.py", + "commit": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3", + "source_path": "research/cyclic-dirty-commutator-audit/echo.py", + "sha256": "63d44c48801f51720a7cc994d6b5e2e857d1aa4fae4c6b83c0cca032b3d9e13b" + }, + { + "path": "vendor/pr673/ECHO-PROOF.md", + "commit": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3", + "source_path": "research/cyclic-dirty-commutator-audit/ECHO-PROOF.md", + "sha256": "e98e459720d8013618853bb4836558cf8bb06a4a1be03fe0954a76f178ecf403" + }, + { + "path": "vendor/pr689/ternary.py", + "commit": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a", + "source_path": "research/ternary-dirty-composition/ternary.py", + "sha256": "aea6122da02900da3362f888f9237362a1ec6800345d5205d3ef79e6fa4a731c" + }, + { + "path": "vendor/pr689/NOTICE.md", + "commit": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a", + "source_path": "research/ternary-dirty-composition/NOTICE.md", + "sha256": "65f7f2fd6b5628820d81d9218655901fcc95a133c7267e3d8fe64c5a3147cff5" + }, + { + "path": "vendor/pr689/README.md", + "commit": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a", + "source_path": "research/ternary-dirty-composition/README.md", + "sha256": "d316d01169e44a1879aab4eba9aec6ef63eaf6bad2cb70fddadb06a183946bbf" + }, + { + "context_only": true, + "path": "../../certificates/selected-result.json", + "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "source_path": "certificates/selected-result.json", + "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53" + }, + { + "context_only": true, + "path": "../../research/community-k492-audit/pr626/replay/ASSEMBLY.json", + "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "source_path": "research/community-k492-audit/pr626/replay/ASSEMBLY.json", + "sha256": "6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e" + }, + { + "context_only": true, + "path": "../../docs/research/community-k492-review.md", + "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "source_path": "docs/research/community-k492-review.md", + "sha256": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47" + }, + { + "path": "vendor/pr673/INTEGRATION-PROOF.md", + "source_path": "research/dirty-echo-integration/PROOF.md", + "commit": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3", + "sha256": "f25eb16d70f499091908107c5a314e2dab2fb71e956fe6150d7a188f1b90e517" + } + ] +} diff --git a/research/space-capped-dirty-echo/VALIDATION.md b/research/space-capped-dirty-echo/VALIDATION.md new file mode 100644 index 0000000000..ae57117212 --- /dev/null +++ b/research/space-capped-dirty-echo/VALIDATION.md @@ -0,0 +1,98 @@ +# Validation and limits + +Local validation on 2026-10-13, Windows, CPython **3.12.10**. Base commit: +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. This is author/AI-produced +computational evidence, not independent human review or formal verification. + +## Completed checks + +1. `python -X utf8 -I -O -B research/space-capped-dirty-echo/verify.py` + completed with + `PASS_SPACE_CAPPED_DIRTY_ECHO calls=160->152 scratch=5 no_new_kappa`. + The entire recomputed JSON certificate equals EXPECTED.json as canonical + compact/sorted JSON, converting tuple trees to arrays while distinguishing + integer, boolean and float values. Its canonical JSON SHA-256 is + `a37c11b94c0ac897e4dc537b2321daa64d2978f31ac033485326afdaf657919f`. + See README.md for the finite domains and PROOF.md for the general argument. +2. The same full isolated optimized replay passed from a **new minimal copy + in a path containing spaces**, containing only this research package and + the three pinned repository context files. It had no `.git`, surrounding + research packages, network access or source-tree import paths. Its complete + expected certificate matched. This tests relocation and dependency closure; + it is not a second hardware/platform result. +3. `python -X utf8 -I -O -B research/space-capped-dirty-echo/test_contracts.py` + passed **9/9 tests**. These exercise five actual implementation mutations, + nonlinear dirt dependence, a target-dependent invalid callback, complete + precision, source/context corruption, certificate corruption/normalization, + the primary all-cuts optimum and all 326 circuit/admission controls. The + earlier eight-test version also passed without optimization before the + serialization regression test was added. +4. `python -X utf8 -B scripts/verify_selected_result.py` passed: + `PASS selected record, exact kappa, original source inventory and proof supplement: 51110230636731/31250000000000000`. +5. All **18** source/context files were separately compared byte-for-byte to + `git show :`, as well as to their declared hashes. + Vendored bytes in the Git index also match the pins, including LF line + endings. The latest inspected PR673 head + `156f259b99723468cfdd2b5d47d0ba894f09bea7` changes none of the three consumed + files relative to pinned `bfff94e78f0e75ebd2593e3cc7710ae5290e8be3`. +6. New Python sources parse; local documentation links and staged whitespace + checks pass. The diff adds only this directory. Existing tracked sources, + `upstream/`, certificates, generators and the selected pointer are unchanged. + +The initial ordinary-Python generation run also completed all mathematical +checks and wrote the exact receipt. After documentation pins and the weighted +symbolic check were added, final verification used the current complete schema. +Only counts of operations are claimed; there is no before/after runtime claim. +After the integer/boolean/float comparison hardening, the ordinary isolated +full replay passed again, and a fresh minimal relocated copy passed both the +full optimized replay and the concurrent comparison. These completed by +2026-10-13 05:09:38 UTC. The main EXPECTED.json receipt is unchanged. + +## Failures found and corrected during development + +- The first corruption-fixture test could not create a subdirectory in this + Windows sandbox's default temporary location. The test now creates its + temporary directory under the caller's writable working directory and + verifies that containment before automatic cleanup. This was an environment + failure, not a failed mathematical identity. +- The first comparison-mode full replay completed the mathematics but rejected + its receipt because in-memory tuple trees were compared directly with JSON + list trees. `compare_certificate` now normalizes that representation and + still compares every field. The added test accepts the round trip and rejects + both a changed tree leaf and a changed call count. Follow-up hardening also + rejects boolean/float substitutions for integer fields. The corrected + comparison is covered by explicit regression tests. + +## Concurrent-publication comparison + +During the immediate publication refresh through #745, PR730 and PR744 had +arrived. This did not change the chosen mechanism: higher arities were already +included in the claimed scope, implemented, and independently verified. +The package now credits both prior publications and makes the distinction +testable instead of claiming novelty for unbalanced/weighted trees. + +`python -X utf8 -I -O -B research/space-capped-dirty-echo/compare_concurrent.py` +passes with `PASS_HIGHER_ARITY_COMPARISON`. It executes the pinned PR730 +optimizer and literal words, with two additional source files authenticated +by CONCURRENT-SOURCES.json. At (n,S)=(15,5),(15,6),(27,6),(58,8), its minima +are 160,144,464,1728 and ours are 152,128,448,1600. The same actual weighted +radix-16 instance gives 3840 versus 3656 phase reads. This comparison does not +audit PR730's other checks or claims. PR744's larger strict-ternary finite +coverage is credited; its implementation is not consumed. + +## Checks deliberately not represented as completed + +No repository-wide `make verify`, `frontier626-verify` cold supplier replay, +Linux/remote CI, Lean build or new formal multiplication proof was run. This +isolated addition changes no existing generator or selected construction; its +affected package checks and the selected-record integrity check were run. +The root aggregate would rebuild unrelated historical and supplier packages. + +The root certificate's 47 outer inequalities and supplier identities remain +inherited. The new all-size tree statement rests on the written Bellman and +restoration inductions, not extrapolation from the finite tests. The actual +cyclic factors' preparation, precision hypotheses and analytic provenance are +retained with their exact source notices. The minimum is only within the stated +tree class. Physical integration, common-label/mutable-basis realization, +all-size compilation, fixed-tape execution, exact recovery and analytic transfer +are unresolved or inherited; no new kappa is claimed. diff --git a/research/space-capped-dirty-echo/compare_concurrent.py b/research/space-capped-dirty-echo/compare_concurrent.py new file mode 100644 index 0000000000..5414ae96ff --- /dev/null +++ b/research/space-capped-dirty-echo/compare_concurrent.py @@ -0,0 +1,64 @@ +"""Reproduce the strict distinction from concurrent PR730's arity-2/3 class. + +Runs the byte-exact pinned PR730 optimizer; does not review the rest of that PR. +No dependency on Git objects or network at verification time. +""" + +import hashlib +import json +from pathlib import Path +import importlib.util + +ROOT=Path(__file__).resolve().parent + + +def load(name, path): + spec=importlib.util.spec_from_file_location(name,path) + mod=importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + + +def check(): + verify=load('local_verify',ROOT/'verify.py') + planner=load('all_arity_planner',ROOT/'planner.py') + for pin in json.loads((ROOT/'CONCURRENT-SOURCES.json').read_text())['sources']: + verify.need(hashlib.sha256((ROOT/pin['path']).read_bytes()).hexdigest()==pin['sha256'], + 'concurrent source pin: '+pin['path']) + old=load('pr730',ROOT/'vendor/pr730/optimize.py') + rows=[] + for n,cap in ((15,5),(15,6),(27,6),(58,8)): + charge,tree=old.optimize([1]*n,cap) + space,recount=old.resources(tree,[1]*n) + instructions=[(f,s,t,q) for s,t,f,q in old.instructions(tree)] + verify.need(charge==recount==len(instructions), 'PR730 literal count') + verify.linear_check(instructions,n,3+space) + new=planner.optimize([1]*n,cap) + verify.word_check(planner,new,n) + verify.need(new['calls'] 0 for w in weights), + "positive integer leaf weights") + + def walk(node): + if type(node) is int: + need(0 <= node < len(weights), "leaf index") + return [node], 0, {node: 1} + need(type(node) in (tuple, list) and len(node) >= 2, "tree arity") + leaves, peak, counts = [], 0, {} + for j, child in enumerate(node): + indices, space, occurrences = walk(child) + leaves.extend(indices) + peak = max(peak, space) + multiplier = 2 if j in (0, len(node)-1) else 4 + for i, count in occurrences.items(): + counts[i] = counts.get(i, 0) + multiplier * count + return leaves, len(node)-1+peak, counts + + leaves, space, counts = walk(tree) + need(leaves == list(range(len(weights))), "ordered complete factor list") + profile = [counts[i] for i in range(len(weights))] + return dict(price=sum(w*c for w, c in zip(weights, profile)), + calls=sum(profile), scratch=space, occurrences=profile) + + +def optimize(weights, budget): + """Return a minimum-price tree, then minimum calls among price ties. + + Leaves are ordered and cannot be deleted/reordered. Each k-child node + reserves k-1 arrays during every child call; the children share a deeper + pool sequentially. Infeasibility means only this explicit tree class. + """ + weights = tuple(weights) + need(weights and all(type(w) is int and w > 0 for w in weights), + "positive integer leaf weights") + need(type(budget) is int and budget >= 0, "nonnegative integer space cap") + budget = min(budget, len(weights)-1) + + @lru_cache(maxsize=None) + def best(lo, hi, space): + if hi-lo == 1: + return weights[lo], 1, lo + if space == 0 or hi-lo > 2**space: + return None + winner = None + for arity in range(2, min(space+1, hi-lo)+1): + remaining = space-arity+1 + # Partition DP: j complete consecutive children ending at a cut. + states = {lo: (0, 0, ())} + for j in range(arity): + next_states = {} + multiplier = 2 if j in (0, arity-1) else 4 + for cut, (cost, calls, children) in states.items(): + stop = min(hi-(arity-j-1), cut+2**remaining) + for end in range(cut+1, stop+1): + child = best(cut, end, remaining) + if child is None: + continue + candidate = (cost+multiplier*child[0], + calls+multiplier*child[1], children+(child[2],)) + old = next_states.get(end) + if old is None or candidate[:2] < old[:2]: + next_states[end] = candidate + states = next_states + candidate = states.get(hi) + if candidate is not None and (winner is None or candidate[:2] < winner[:2]): + winner = candidate + return winner + + answer = best(0, len(weights), budget) + need(answer is not None, "no tree fits space cap") + result = invoice(answer[2], weights) + need((result['price'], result['calls']) == answer[:2], "planner invoice") + need(result['scratch'] <= budget, "planner space") + return dict(tree=answer[2], **result) + + +def word(tree, sign=1): + """Stream (factor, source, target, sign), with source 0 and target 1.""" + need(type(sign) is int and sign in (-1, 1), "sign") + + def leaf_count(node): + if type(node) is int: + return 1 + need(type(node) in (tuple, list) and len(node) >= 2, "tree arity") + return sum(leaf_count(c) for c in node) + + invoice(tree, [1]*leaf_count(tree)) + + def emit(node, source, target, first_scratch, direction): + if type(node) is int: + yield node, source, target, direction + return + k = len(node) + chain = [(node[j], source if j == 0 else first_scratch+j-1, + first_scratch+j, 1) for j in range(k-1)] + last = (node[-1], first_scratch+k-2, target, 1) + + def inverse(commands): + return [(t, s, d, -q) for t, s, d, q in reversed(commands)] + + commands = chain+[last]+inverse(chain)+chain[1:]+inverse([last])+inverse(chain[1:]) + if direction == -1: + commands = inverse(commands) + for child, src, dst, child_sign in commands: + yield from emit(child, src, dst, first_scratch+k-1, child_sign) + + yield from emit(tree, 0, 1, 2, sign) + + +def compose(tree, source, target, factors, scratch, leaf, sign=1, read_only=()): + """Execute with a deterministic source-restoring additive leaf callback. + + leaf(source, target, factor, sign) must obey PROOF.md's contract. Ordinary + list identity aliases are checked before mutation, including declared + read-only arrays. Overlapping views/hidden callback state are not supported. + """ + bill = invoice(tree, [1]*len(factors)) + need(type(sign) is int and sign in (-1, 1), "sign") + need(len(scratch) >= bill['scratch'], "insufficient scratch") + arrays = [source, target, *scratch] + need(len({id(a) for a in arrays}) == len(arrays), "mutable arrays alias") + need(not any(ro is a for ro in read_only for a in arrays), "read-only alias") + need(len(source) > 0 and all(len(a) == len(source) for a in arrays), + "equal positive array lengths") + for factor, src, dst, direction in word(tree, sign): + leaf(arrays[src], arrays[dst], factors[factor], direction) diff --git a/research/space-capped-dirty-echo/test_contracts.py b/research/space-capped-dirty-echo/test_contracts.py new file mode 100644 index 0000000000..b8f9f334a8 --- /dev/null +++ b/research/space-capped-dirty-echo/test_contracts.py @@ -0,0 +1,132 @@ +"""Fast adversarial tests for the planner, checker and public array contract.""" + +import copy +import importlib.util +import json +from pathlib import Path +import tempfile +import types +import unittest + +ROOT = Path(__file__).resolve().parent + + +def load(name, filename): + spec = importlib.util.spec_from_file_location(name, ROOT/filename) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + + +p = load('echo_planner', 'planner.py') +v = load('echo_verify', 'verify.py') + + +class Contracts(unittest.TestCase): + def test_certificate_normalization_and_corruption(self): + result=dict(tree=((0,1),(2,3)), calls=16) + disk=json.loads(json.dumps(result)) + v.compare_certificate(result,disk) + disk['tree'][1][0]=1 + with self.assertRaisesRegex(ValueError,'exact certificate mismatch'): + v.compare_certificate(result,disk) + disk=json.loads(json.dumps(result));disk['calls']=15 + with self.assertRaisesRegex(ValueError,'exact certificate mismatch'): + v.compare_certificate(result,disk) + for altered in (False, 0.0): + disk=json.loads(json.dumps(result));disk['tree'][0][0]=altered + with self.assertRaisesRegex(ValueError,'exact certificate mismatch'): + v.compare_certificate(result,disk) + + def test_hand_computed_primary(self): + self.assertEqual(p.optimize([1]*15, 5)['calls'], 152) + self.assertEqual(p.optimize([1]*15, 4)['calls'], 224) + self.assertEqual(p.optimize([1]*15, 14)['calls'], 56) + self.assertEqual(v.cuts_oracle((1,)*15, 5)[0], (152, 152)) + + def test_weight_orientation_is_not_assumed_symmetric(self): + for weights in ([1,59,2,3,7,11], [11,7,3,2,59,1]): + row = p.optimize(weights, 4) + self.assertEqual((row['price'],row['calls']), v.cuts_oracle(tuple(weights),4)[0]) + v.word_check(p, row, len(weights)) + + def test_real_implementation_mutations(self): + source = (ROOT/'planner.py').read_text(encoding='utf-8') + changes = [ + ('underprice_interior', '2 if j in (0, arity-1) else 4', '2'), + ('reuse_reserved_space', 'remaining = space-arity+1', 'remaining = space'), + ('exclude_binary', 'range(2, min(space+1, hi-lo)+1)', 'range(3, min(space+1, hi-lo)+1)'), + ('prune_capacity_equality', 'hi-lo > 2**space', 'hi-lo >= 2**space'), + ('wrong_inverse_order', 'for t, s, d, q in reversed(commands)', 'for t, s, d, q in commands'), + ] + for name, old, new in changes: + with self.subTest(name=name): + self.assertEqual(source.count(old),1) + mutant = types.ModuleType(name) + exec(compile(source.replace(old,new), name, 'exec'),mutant.__dict__) + with self.assertRaises(ValueError): + v.enumeration_check(mutant) + v.word_check(mutant, mutant.optimize([1]*15,5),15) + + def test_nonlinear_restoration_does_not_mean_dirt_independence(self): + increments=[] + for dirt in (0,1): + arrays=[[1],[0],[dirt],[7]] + def leaf(src,dst,f,sign): + dst[0] += sign*(src[0]**2 if f==1 else src[0]) + p.compose((0,1,2),arrays[0],arrays[1],[0,1,2],arrays[2:],leaf) + self.assertEqual(arrays[0],[1]) + self.assertEqual(arrays[2:],[[dirt],[7]]) + increments.append(arrays[1][0]) + self.assertEqual(increments,[1,3]) + + def test_nonadditive_leaf_is_outside_contract(self): + arrays=[[1],[2],[3]] + initial=copy.deepcopy(arrays) + def bad(src,dst,f,sign): + dst[0] += sign*(src[0]+dst[0]**2) + for sign in (1,-1): + p.compose((0,1),arrays[0],arrays[1],[0,1],arrays[2:],bad,sign) + self.assertNotEqual(arrays,initial) + + def test_source_and_context_corruption_rejected(self): + # No full mathematical rerun is needed: source authentication runs first. + saved=v.ROOT + # Use the caller's writable working directory, including sandboxed Windows. + with tempfile.TemporaryDirectory(prefix='.echo-source-controls-', dir=Path.cwd()) as tmp: + self.assertTrue(Path(tmp).resolve().is_relative_to(Path.cwd().resolve())) + root=Path(tmp)/'research'/'space-capped-dirty-echo' + root.mkdir(parents=True) + manifest=json.loads((ROOT/'SOURCES.json').read_text()) + (root/'SOURCES.json').write_text(json.dumps(manifest),encoding='utf-8') + for row in manifest['sources']: + dest=root/row['path'] + dest.parent.mkdir(parents=True,exist_ok=True) + dest.write_bytes((ROOT/row['path']).read_bytes()) + try: + v.ROOT=root + v.sources() + for row in (manifest['sources'][0], manifest['sources'][-2]): + path=root/row['path']; original=path.read_bytes() + path.write_bytes(original+b'\n') + with self.assertRaisesRegex(ValueError,'source pin'): + v.sources() + path.write_bytes(original) + finally: + v.ROOT=saved + + def test_failed_admission_has_no_callback(self): + controls=v.negative_controls(p) + self.assertEqual(controls['rejected_count'],326) + + def test_precision_bound_is_complete(self): + from fractions import Fraction as F + bits,bound=v.precision(152,F(1,512),16,F(18),64) + self.assertLessEqual(bound,F(1,2**65)) + a=F(13*17)*512**3; G=2+16*512 + self.assertGreater(152*a*19*G**151/2**128,F(1,2**65)) + self.assertGreater(bits,128) + + +if __name__=='__main__': + unittest.main(verbosity=2) diff --git a/research/space-capped-dirty-echo/vendor/pr628/DIRTY-PROOF.md b/research/space-capped-dirty-echo/vendor/pr628/DIRTY-PROOF.md new file mode 100644 index 0000000000..caf4aafc78 --- /dev/null +++ b/research/space-capped-dirty-echo/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/space-capped-dirty-echo/vendor/pr628/FACTORS.json b/research/space-capped-dirty-echo/vendor/pr628/FACTORS.json new file mode 100644 index 0000000000..d3894bd2a1 --- /dev/null +++ b/research/space-capped-dirty-echo/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/space-capped-dirty-echo/vendor/pr628/NOTICE.md b/research/space-capped-dirty-echo/vendor/pr628/NOTICE.md new file mode 100644 index 0000000000..22fbeb8ef0 --- /dev/null +++ b/research/space-capped-dirty-echo/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/space-capped-dirty-echo/vendor/pr628/check.py b/research/space-capped-dirty-echo/vendor/pr628/check.py new file mode 100644 index 0000000000..5ef6dd67b6 --- /dev/null +++ b/research/space-capped-dirty-echo/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/space-capped-dirty-echo/vendor/pr628/check_budgets.py b/research/space-capped-dirty-echo/vendor/pr628/check_budgets.py new file mode 100644 index 0000000000..ff21b6e190 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr628/check_budgets.py @@ -0,0 +1,59 @@ +"""Exact integer checks of the explicit uniform precision budgets.""" +from pathlib import Path +import argparse,json,math + +def need(ok,msg): + if not ok:raise ValueError(msg) +def ceil_log2(n): + need(type(n)==int and n>0,'positive integer log argument') + return (n-1).bit_length() +def prime_power_data(r): + need(type(r)==int and r>=3,'radix') + prime=next((d for d in range(2,math.isqrt(r)+1) if r%d==0),r) + q=r + while q%prime==0:q//=prime + need(q==1,'prime power') + return r-r//prime +def budgets(r,p): + D=prime_power_data(r);need(type(p)==int and p>=1,'target bits') + n=r-1;ell=ceil_log2(r);d=1+2*ell+r*n*D;g=d+ell+2*r+2;a=ell+n*g + e=max(d+1,a+1,p+2*a+3);b=max(n*ell,e+r+3) + w=max(2*g+ceil_log2(14*n),p+(n+2)*g+ceil_log2(28*n*(r+1))) + return dict(radix=r,target_bits=p,n=n,D=D,ell=ell,d=d,g=g,a=a,e=e,b=b,w=w) +def check(x): + r,p,n,D,ell,d,g,a,e,b,w=(x[k] for k in ('radix','target_bits','n','D','ell','d','g','a','e','b','w')) + need(D==prime_power_data(r) and n==r-1 and ell==ceil_log2(r),'kernel parameters') + need(d>=1+2*ell+r*(n*D-1),'delta bound exponent') + need(g>=d+ell+2*r and g>=2,'root gap exponent') + need(a>=ell+n*g,'inverse prefix bound') + need(e>=d+1 and e>=a+1 and e>=p+2*a+3,'factor perturbation budget') + need(b>=n*ell and b>=e+r+3,'approximate factorization precision') + need(w-2*g>=ceil_log2(14*n),'rounded recurrence growth budget') + gap=w-p-(n+2)*g-1 + need(gap>=0 and 14*n*(r+1)<=1<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/space-capped-dirty-echo/vendor/pr628/weighted.py b/research/space-capped-dirty-echo/vendor/pr628/weighted.py new file mode 100644 index 0000000000..da90ee6e83 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr628/weighted.py @@ -0,0 +1,118 @@ +"""Exact certificates for varying unit phases on a cyclic neighbor shift.""" +from pathlib import Path +from fractions import Fraction as F +import argparse, importlib.util, json +P=Path(__file__).resolve().parent +s=importlib.util.spec_from_file_location('kernel',P/'check.py');k=importlib.util.module_from_spec(s);s.loader.exec_module(k) +c=k.c + +def scan(x,bs,beta,bits,direction): + c.need(len(x)>0 and len(bs)==len(x),'coefficient length') + c.need(direction in (-1,1),'direction') + c.need(0=(beta/2)**2,'closure denominator') + previous=c.rounded(c.div(z,den),bits);y=[c.ZERO]*len(x) + for i in order: + previous=c.rounded(c.add(x[i],c.mul(bs[i],previous)),bits);y[i]=previous + return y + +def apply(x,state,phases,direction,wrong_phase=False): + n=len(x);c.need(n>0 and len(phases)==n,'phase length') + c.need(all(c.norm2(t)==1 for t in phases),'unit phases') + y=[(v[0]*state['radix'],v[1]*state['radix'])for v in x] + for inside,b in state['factors']: + if inside: + inv=[(phases[(i+direction)%n][0],-phases[(i+direction)%n][1])for i in range(n)] + if wrong_phase:inv=[(v[0],-v[1])for v in phases] + bs=[c.mul(b,t)for t in inv] + y=scan(y,bs,state['beta'],state['bits'],-direction) + y=[c.rounded(c.mul(inv[i],y[(i+direction)%n]),state['bits'])for i in range(n)] + else: + y=scan(y,[c.mul(b,t)for t in phases],state['beta'],state['bits'],direction) + y=[c.rounded(c.neg(c.mul(b,v)),state['bits'])for v in y] + return y + +def matrix(q,phases,direction): + # Independently expand W^j entry-by-entry, including wrap-around phases. + n=len(phases);a=[[c.ZERO for _ in range(n)]for _ in range(n)] + for i in range(n): + weight=c.ONE + for j,v in enumerate(q): + col=(i-direction*j)%n;a[i][col]=c.add(a[i][col],c.mul(v,weight)) + weight=c.mul(weight,phases[col]) + return a + +def residual(x,y,a,bound): + for i,row in enumerate(a): + v=c.ZERO + for z,t in zip(row,y):v=c.add(v,c.mul(z,t)) + c.need(c.norm2(c.sub(v,x[i]))<=bound**2,'expanded weighted residual') + +def solve(a,x): + a=[row[:]+[v]for row,v in zip(a,x)];n=len(a) + for j in range(n): + i=next(i for i in range(j,n)if a[i][j]!=c.ZERO);a[i],a[j]=a[j],a[i] + z=a[j][j];a[j]=[c.div(v,z)for v in a[j]] + for i in range(n): + if i!=j: + z=a[i][j];a[i]=[c.sub(v,c.mul(z,t))for v,t in zip(a[i],a[j])] + return [row[-1]for row in a] + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + units=[c.ONE,(F(0),F(1)),(F(3,5),F(4,5)),(F(-5,13),F(12,13))] + cases=[];certs=[];generic=[];controls=[] + for beta in (F(1,2),F(1,16),F(1,4096)): + for n in (1,2,3,8,17,64): + bs=[c.mul((1-beta,F(0)),units[(i*i+3*i+1)%4])for i in range(n)] + # Alternate magnitudes as well as phases. + bs=[(z[0]/(1+i%2),z[1]/(1+i%2))for i,z in enumerate(bs)] + x=[(F(i%5-2,4),F(i%7-3,8))for i in range(n)] + B=max(abs(z[0])+abs(z[1])for z in x);bound=6*(B+1)*F(1,1<<64)/beta**3 + for d in (-1,1): + y=scan(x,bs,beta,64,d) + m=[[c.ZERO for _ in range(n)]for _ in range(n)] + for i in range(n):m[i][i]=c.ONE;m[i][(i-d)%n]=c.sub(m[i][(i-d)%n],bs[i]) + residual(x,y,m,beta*bound) + if n<=8:c.need(all(c.norm2(c.sub(v,t))<=bound**2 for v,t in zip(y,solve(m,x))),'generic dense') + generic.append(dict(beta=str(beta),length=n,direction=d,dense=n<=8)) + sigma,nu,phase_cert=k.irrational_gauge() + for row in json.loads((P/'FACTORS.json').read_text()): + if row['radix'] not in (4,9,16):continue + st=k.certify(row);A=F(st['certificate']['inverse_norm_bound']) + eps=F(st['certificate']['coefficient_error_bound'])+sum(j*(abs(v[0])+abs(v[1]))for j,v in enumerate(st['q']))*nu + c.need(A*eps<1 and A*A*eps/(1-A*eps)+st['budgets'][-1]<=F(1,1<= 2 it uses O(n^alpha) factor calls, where +alpha = log_k(4k-4) < 2 for k > 2, with O(log n) borrowed length-L arrays. +It does not provide a common-label Clifford supplier, bit-reversible compiler, +transform layout, or new multiplication κ. The phase-alias repair is required +at this interface too and is included in `echo.py` before execution. + +## Exact algebra; no commutativity assumption + +Let A_1,...,A_k be arbitrary composable linear maps on equal-length arrays. +Source x, target y and dirty arrays z_1,...,z_(k-1) are all distinct. Define C +as the following ordered sequence of shears: + + z_1 += A_1 x + z_2 += A_2 z_1 + ... + z_(k-1) += A_(k-1) z_(k-2) + +Define D as C with its first shear omitted. Execute + + C; y += A_k z_(k-1); C^-1; + D; y -= A_k z_(k-1); D^-1. + +C^-1 and D^-1 reverse the operation order and negate every shear. They restore +all dirty arrays. The two target updates occur on dirty-chain states that differ +only by the propagated contribution of the first link. Inductively that +difference at z_i is A_i ... A_1 x. Consequently the net target increment is +A_k ... A_1 x. This proof holds for noncommuting maps and arbitrary initial dirt. +The source is never a target of an ideal shear. With k=2, D is empty and this +reduces to the original binary commutator. + +The complete count is + + (k-1) + 1 + (k-1) + (k-2) + 1 + (k-2) = 4k-4. + +It includes both ladders, both inverse ladders and both target updates. There +is no clean length-L work array or implicit copying. The two endpoint maps +are each called twice; each interior map is called four times. + +## Recursive schedule and storage + +Partition n factors into k' = min(k,n) consecutive groups, as evenly as +possible, preserving their order. Use k'-1 dirty arrays for this node. Recursively +implement each group map using a disjoint pool of deeper borrowed arrays, +which can be reused between calls because every call restores that pool. +Neither an ancestor source nor an ancestor target belongs to the deeper pool. +All mutable arrays, including surplus scratch, are checked distinct at entry. + +For group sizes n_i, the exact recurrences implemented by `resources` are + + S(1) = 0, N(1) = 1 + S(n) = k'-1 + max_i S(n_i) + N(n) = 2 N(n_1) + 2 N(n_k') + 4 sum_(10, a sufficiently large *fixed* k makes alpha<1+epsilon. +The flat choice k=n instead uses n-1 borrowed arrays and exactly 4n-4 calls. + +| Factors | Binary: arrays / calls | Fanout 8: arrays / calls | Flat: arrays / calls | +|---|---:|---:|---:| +| 8 | 3 / 64 | 7 / 28 | 7 / 28 | +| 16 | 4 / 256 | 8 / 112 | 15 / 60 | +| 64 | 6 / 4096 | 14 / 784 | 63 / 252 | +| 512 | 9 / 262144 | 21 / 21952 | 511 / 2044 | + +The generator streams instructions using O(k log_k n) active scheduling +records. It does not retain the expanded word. A positive or negative child +call takes the same resources. Negative calls reverse the full instruction +word, rather than negating signs in forward order. + +## Exact restoration despite rounded, nonlinear increments + +A valid PR628 leaf adds a deterministic function of its source to its target, +restores its source exactly, and does not read its target when computing the +increment. Its negative leaf subtracts exactly that same grid value. Fixed, +non-aliased phase and factor data are essential here. + +Inductively, a recursive call adds a deterministic function of its source and +initial deeper dirt, independently of its target, and restores the source and +all deeper dirt. Thus C's child calls can be undone in reverse order: each sees +the same source and deeper dirt as its forward mate. The intervening target +update changes only y, which is excluded from every ladder's scratch pool. +The same argument applies to D. This proves exact source and scratch restoration +at every level for valid finite-grid inputs. Reversing the complete word gives +an exact inverse. It does **not** prove that the rounded target increment is +independent of dirt; the error estimate below bounds that dependence. + +As with the pinned leaf, all input contracts must hold throughout execution. +This is not transactional rollback on arbitrary malformed coefficients or +stateful callbacks. The explicit alias checks reject ordinary list-identity +aliasing before any mutation; arbitrary overlapping views are outside the API. + +## Complete inherited error and cost budget + +Use PR628's leaf estimates with n=r-1, beta in (0,1], grid u=2^-w, and +multipliers bounded by r. The same hypotheses and preparation remain required. +Let D bound the initial joint max norm, K=r/beta, +a=13(r+1)/beta^3 and G=2+K. A rounded leaf on input norm at most B has error +at most a(B+1)u; an ideal shear has Lipschitz norm at most 1+K. Enforce +au<=1 and u<=beta^2/2. + +Writing M_j for the computed joint norm after j leaves gives +(M_j + 1) <= G^j(D+1). Comparing the complete rounded instruction word with the +complete ideal word gives, by propagation through each remaining ideal shear, + + E_N <= N a (D+1) u G^(N-1). + +This argument applies to the actual expanded word, including every restoration +operation. Substitute the new exact N; do not reuse the predecessor's 4n² +upper bound when measuring the improvement. The ideal identity proved above +cancels all initial borrowed dirt. Hence this E_N bounds target error while +actual source and scratch restoration are exact. + +For requested p bits choose + + w >= p+1+ceil(log2(N a (D+1)))+(N-1)ceil(log2 G), + +as well as the two leaf precision conditions. This budgets execution error +at most 2^(-p-1). The inherited coefficient/phase preparation error must still +be budgeted to 2^(-p-1), scaled for the original source norm as specified in +PR628. It does not receive a free exact phase table from this construction. + +Under PR628's log2(beta^-1)=O(r³), fixed fanout k gives + + N = O(r^alpha), + w = O(p + log(D+1) + r^(3+alpha)). + +Joint transient integer magnitudes add O(log(D+1)+N log G) bits; the leaf's +causal state and closure add O(log(beta^-1)+log r), all covered by that budget. +Borrowed data storage is O(L log r) words for fixed k. Clean arithmetic storage, +read-only factor descriptors, indexing and fast-arithmetic workspace retain +PR628's qualifications. Charging the same factor preparation and leaf arithmetic +as PR628 gives the conditional local work upper bound + + soft-O((L r^alpha + r³) (p + log(D+1) + r^(3+alpha))) + +plus charged phase-oracle and routing work. Every leaf still includes its +forward pass, output pass, undo pass and validation/access costs; none are +removed by a speedup claim. With k=8, alpha=log_8 28≈1.602452, replacing the +binary precision power 5 by about 4.602452. With flat k=n the corresponding +power is 4, but borrowed arrays become O(r), not O(log r). + +The Fraction prototype tests identities, rounding and restoration; its timings +are **not** evidence for a fast fixed-precision implementation. No complete +multiplication recurrence follows without integrating the required transform, +paid storage/layout, bit supplier and all conditional assembly assumptions. + +## Evidence and attribution + +`verify_echo.py` compares the streamed ideal word against direct composition of +arbitrary noncommuting 2x2 integer matrices. It separately compares rounded +execution with an integer-grid arithmetic interpreter (sharing only the tested +schedule), and with PR628's independently assembled dense cyclic inverse oracle. +The latter checks the complete error bound at a precision chosen by the formula +above, with positive, zero and negative initial dirt. These finite tests support +the implementation; they are not a formal proof of the general statement. +The algebraic and inductive arguments above state the general obligations. + +The schedule and analysis here were prepared for @androolloyd with substantial +OpenAI Codex assistance, under Apache-2.0. The rounded leaf and original binary +dirty inverse are Chafik Boukhalfa / chafreaky's PR628 work, with OpenAI Codex +assistance, built on Ali Romman's PR621 kernel and the sources retained in +SOURCE.json. This note claims an improvement relative to that pinned binary +schedule, not priority over all historical reversible-pebbling literature. diff --git a/research/space-capped-dirty-echo/vendor/pr673/INTEGRATION-PROOF.md b/research/space-capped-dirty-echo/vendor/pr673/INTEGRATION-PROOF.md new file mode 100644 index 0000000000..9540138bf3 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr673/INTEGRATION-PROOF.md @@ -0,0 +1,243 @@ +# Full-transform and bit integration: an exact adapter with an unfavorable bill + +This note continues PR673 at `0e35f56cab3cae1eb0a99447135569d687c5695a`. +Its result has two parts: an implemented functional adapter, and a rejection +of **this adapter's** recursive cost as a source of a positive saving. It does +not rule out other integrations of the echo mechanism or another supplier. +The PR628 inverse and PR673 local cost improvement remain separate valid +objects under their stated contracts. + +## 1. The interfaces that must be connected + +PR673 supplies an additive shear + + E(A): (x,y,z) -> (x,y+A x,z), + +where z contains arbitrary borrowed data. A supplier for the recursive +framework must instead apply its required operator to **every physical role**, +including roles used as scratch in its scalar word. The complex endpoint is a +product of C kernels on selected binary address positions; the bit endpoint +is an interchange of two address chunks, acting on Boolean data. +`upstream/03-motifs.tex`, `04-swap.tex` and `05-layers.tex` specify these +contracts. Restoring a scratch role is insufficient when that role is owed +its own endpoint transform. + +Let A be an invertible operator. Three shears, in execution order, + + y += A x; x -= A^-1 y; y += A x + +send (x,y) to (-A^-1 y, A x). Exchanging the two roles and negating the +second gives (A x,A^-1 y). Each shear is implemented with the same distinct +borrowed pool, excluding both current pair roles, and restores that pool. +No fresh zero array is assumed. Pair all W roles, with W even and at least +two plus the echo's scratch depth. Process the pairs serially. A borrowed +role may already have been transformed or may still contain its original +value; the shear contract permits either, and restores it before proceeding. + +### Complex endpoint + +For the selected positions let A=C^tensor_d, with +C=((1+i)I+(1-i)X)/2. From the retained identities, + + A^-1 = gamma Z A Z, gamma=(-i)^d, + +where Z is the product of sign changes on those positions. Before the three +shears, replace y by Z y. After the exchange/negation, replace the second +output by gamma^-1 Z times that output. The final pair is exactly (A x,A y). +Both forward and inverse C leaves are implemented explicitly. For grouped +positions of width f the same identity holds with d replaced by df; the +inverse wrappers add no recursive children under the inherited interface. + +### Bit endpoint + +Let the address consist of H_1,...,H_d,D_1,...,D_d, with arbitrary other +fields held fixed. Each A_i interchanges H_i and D_i. These permutations +commute and are involutions, so A=product_i A_i satisfies A^-1=A. +Over Boolean data subtraction equals addition. The same three shears followed +by a role exchange therefore yield (A x,A y), without complex phases. +The implemented tests use radix 3 or 5 with one digit per field. The identity +is valid for arbitrary equal-length fields and spectators: it is an identity +of commuting address permutations, not an interpolation from finite tests. + +`adapter.py` implements both endpoints, streams the additive leaf results, +and uses scalar swaps for the role exchange. It needs no clean full-array +output buffer. Its indexed source reads are explicit **reference operations**; +they are not a free tape-routing primitive. Permutation tables used by the +finite test are read-only test descriptions, not a claimed constant-size +uniform machine description. + +## 2. Complete synthetic Fourier transform integration + +The multiplication framework's transform is over R_r=C[y]/(y^r+1), with +power-of-two r. It uses normalized butterflies and signed coefficient +permutations. It is not an ordinary complex DFT on independently approximated +roots. `transform.py` implements the retained contract for axis lengths t_i +that divide 2r, with M=product_i t_i. + +In each decimation-in-frequency round, one address position on each active +axis is selected. The identity + + H0^tensor_d = b^d S_d C^tensor_d S_d, b=(1-i)/2, + +converts the all-role C adapter to the normalized butterfly layer. At address +x, S_d is the fourth-root phase i^(sum of selected bits). The grouped twiddle +is multiplication of each polynomial record by + + y^E, E = -sum_i (2r/u_i) b_i k_i mod 2r, + +where u_i is the current recursive axis length, b_i the selected branch bit +and k_i its lower unprocessed bits. The monomial acts by a signed rotation of +coefficients; the implementation cycles in place with one held scalar. + +The output stays in bit-reversed frequency order B. There is **no hidden +frequency permutation** in the implementation. Reversing the rounds applies +the inverse twiddle first and then the same normalized butterfly. Thus the +two procedures implement B F-minus and F-plus B^-1, and their composite is +I/M. A convolution uses two forward transforms, pointwise multiplication in +R_r, then the opposite transform, followed by scaling by M². Both forward +transforms and the opposite transform include a 1/M normalization; charging +only a factor M would give the wrong answer. The direct convolution oracle +checks the cyclic address wrap and the negacyclic coefficient wrap separately. + +The harness includes nonzero data on every role, entire input-basis checks +for the all-role C adapter, full Boolean symbolic columns, and independent +DFT/convolution definitions. No rounded numerical equality is used. Fraction +arithmetic is a prototype, not a fixed-precision or fixed-tape implementation. + +For a simple exact resource bound, each C shear adds at most two source +values, with dyadic coefficients of denominator 2, into one target. After J +such leaves the common fractional-bit budget grows by at most J, while the +joint max magnitude grows by less than 3^J. Phase, sign and role-exchange +wrappers are isometries. The additional H0 factors add at most sum_round d +fractional bits and are contractions. Signed twiddles add none. This gives +a deliberately loose word budget + + initial_fraction_bits + O(J + sum_round d + log(initial_norm+1)). + +This is an explicit bound for this exact prototype schedule. It does not +establish the retained O(p) precision guard in the growing-parameter +multiplication reduction. Preparation, source access and routing remain paid +obligations. The cost rejection below already holds with all of them free. + +## 3. The complete recursive bill rejects this route + +Suppose d=n f selected coordinates are grouped into n groups of f. Let N(n) +be the exact leaf count of one echo. There are three shears per pair and W/2 +pairs, so the complete all-role program invokes + + L = 3 W N(n)/2 + +additive leaves. Grant an optimistic oracle in which each additive leaf costs +only **one** recursive child on f coordinates and one role of volume V/W. +This is already more generous than the ordinary lowering: applying a child +to the source, adding it to the target and undoing the child takes two child +calls. Charge zero for the surrounding scalar operations, phases, role +exchange, storage, preparation, routing and precision. These favorable +omissions can only make admission easier. + +For a candidate exponent sigma=1-b, the normalized recurrence moment is + + Phi(b) = (L/W) (1/n)^(1-b) = 3 N(n)/(2 n^(1-b)). + +Even Phi(0) must be below 1 to obtain a strict saving by this bill. The flat +echo has N(n)=4n-4, giving + + Phi(0) = 6 - 6/n >= 3, for n>=2. + +Recursive grouping does not improve this lower bound. First, induction gives +N(t)>=2t-1: at an internal node each group is invoked at least twice and +the number of groups is at most t. For an internal node with group sizes +n_1,...,n_k, use 2N(n_i)>=4n_i-2 on each endpoint and 4N(n_i)>=4n_i on +each interior group. Summing yields N(n)>=4n-4. Hence every fanout supported +here has Phi(0)>=6-6/n. Since n>1, Phi(b) increases with b, so **every b>=0 +is rejected**. This is a lower bound on the cost of this specific all-role +adapter, not an optimality theorem for arbitrary suppliers. + +The corresponding optimistic finite profile is H_1=L, m=n and W physical +roles. Its deficit Wm-sum_j j H_j is negative. The same calculation applies +to the Boolean and complex adapters. Borrowing more roles does not help: +the W factor cancels because every role is owed an output transform. + +For example, a flat eight-factor shear needs 28 leaves and seven scratch +roles. Taking W=10 roles, all outputs require 420 leaves, yielding moment +420/(10*8)=5.25 at b=0. Pricing only the raw 28-leaf shear while counting ten +completed outputs would give the false coefficient 28/80=0.35. The missing +outputs are detected by the `skip_borrowed_outputs` functional control. + +Pointwise scalar shortening in an otherwise unchanged supplier likewise does +not change its child histogram, recursive volume fractions or strict moment. +It can improve constants or finite cutoffs. It cannot by itself be multiplied +into κ. This experiment does not modify any accepted supplier's profile. + +## 4. Why the literal cyclic inverse is not an automatic replacement + +### The Newton factor is triangular + +In the pinned exact-DFT source, with h_j=1/product_(s=1)^j(1-u^s), the Newton +factor is T=P(J_r), where J_r is the **nilpotent lower shift**. PR621/628 instead +handle C=P(Z_L), a cyclic shift polynomial. For L=r, C-T is strictly upper +triangular and every first-superdiagonal entry is h_(r-1)=1/r. Its rank is +exactly r-1, as seen from rows 0 through r-2 and columns 1 through r-1. +Where C is invertible, the inverse difference C^-1(C-T)T^-1 also has rank r-1. + +This identifies a missing boundary correction; rank alone is not a lower +bound on all algorithms for this structured correction. At r=4, replacing T +by C in the actual Newton factorization sends e_0 to + + (13/16-i/16, 21/32+3i/32, 1/2+i/8, 1/4) + +instead of F_4 e_0=(1,1,1,1). `boundaries.py` checks both the correct full +factorization and this counterexample exactly. The present functional adapter +uses the correct retained C butterfly; it does not pretend that cyclic and +triangular P operators agree. + +### Complex nonvanishing does not transfer to bit arithmetic + +Allow even a two-bit extension field GF(4)=GF(2)[u]/(u²+u+1). The primitive +radix-3 kernel has nonzero preparation denominators and is + + P(z)=1+u z+z². + +Nevertheless, + + (1+u z+z²)(1+u z+u z²+z³)=1+z⁵. + +Thus on a length-5 cycle, the nonzero vector (1,u,u,1,0) lies in the kernel +of P(S_5). Expanding each GF(4) value into two F2 coordinates preserves this +counterexample. There is no inverse to implement on that domain. + +More generally, any nonconstant polynomial over a finite field with nonzero +constant term has a nonzero root alpha in a finite extension. Its multiplicative +order L is finite, so it shares a nonconstant factor with z^L-1. Multiplication +by P modulo z^L-1 is therefore singular. This rules out the *all-cycle-length* +finite-field analogue of the particular complex nonvanishing premise; it does +not rule out restrictions on admissible lengths, another kernel, or bit +address permutations. The Boolean adapter above works with permutations and +makes no use of this invalid cyclic inverse. + +## 5. What a substantial κ improvement must change + +For the retained outer assembly, kappa < a/(1+a), with a below both supplier +endpoints. Therefore kappa=0.01 requires **both** supplier savings above 1/99. +The current pinned bit profile gives c≈0.0017334270. Its strict adjacent root +bracket gives an upper outer ceiling below 0.001730427469824 even if the +complex supplier ceases to bind. Scalar-call speedups do not alter this ceiling. + +`price.py` evaluates both pinned paid moments at the necessary rates for +kappa 0.002, 0.005 and 0.01, retaining the bit fallback charge. At the 0.01 +target, uniformly scaling **every paid term**, with unchanged width and live +volume, would need a reduction strictly exceeding about **2.6990784206%** on +the bit side and **2.4734894761%** on the pinned PR659 complex side. These are +optimistic diagnostic budget targets, not feasible fractional gate deletions +or admitted replacement profiles. They identify the quantity a new construction +must improve: the weighted recursive bill at the desired rate, including +its physical hosting and fallback obligations. + +Credit: the OpenAI #109 integer-multiplication interfaces and pinned exact-DFT +source; classical Newton/q-calculus sources credited by Ali Romman's #621; +Chafik Boukhalfa's #628 leaf; PR673's echo schedule; DreamingOfClouds/eumemic and +the retained #589 lineage; Jeremy Kothe's #659 and its source notices. The +source-suppressed replay principle already appears in the pinned exact-DFT +source's `loc:replay`, with Bennett and catalytic-space attribution. This +continuation does not claim that general principle as new. Prepared for +@androolloyd with substantial OpenAI Codex assistance, under Apache-2.0. diff --git a/research/space-capped-dirty-echo/vendor/pr673/echo.py b/research/space-capped-dirty-echo/vendor/pr673/echo.py new file mode 100644 index 0000000000..76a3117136 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr673/echo.py @@ -0,0 +1,75 @@ +"""Multiway dirty echo composition of PR628's restored-input leaf shears. + +Prepared for androolloyd with substantial OpenAI Codex assistance. Apache-2.0. +No new multiplication exponent is asserted. Read ECHO-PROOF.md for the storage +tradeoff and the complete inherited local error recurrence. +""" + + +def partition(count, fanout): + if count < 1 or fanout < 2: + raise ValueError('positive factor count and fanout >= 2 required') + k = min(count, fanout) + quotient, remainder = divmod(count, k) + return [quotient + (i < remainder) for i in range(k)] + + +def resources(count, fanout): + if count < 1 or fanout < 2: + raise ValueError('positive factor count and fanout >= 2 required') + if count == 1: + return 0, 1 + sizes = partition(count, fanout) + children = [resources(n, fanout) for n in sizes] + scratch = len(sizes)-1 + max(depth for depth, _ in children) + calls = sum((2 if i in (0, len(sizes)-1) else 4)*cost + for i, (_, cost) in enumerate(children)) + return scratch, calls + + +def instructions(first, count, src, dst, scratch_first, fanout, sign=1): + """Stream the exact instruction word or its reverse inverse.""" + if count == 1: + yield src, dst, first, sign + return + sizes = partition(count, fanout) + k = len(sizes) + offsets = [first] + for size in sizes[:-1]: + offsets.append(offsets[-1]+size) + # C: populate the whole dirty chain. D: the same chain without its first link. + chain = [(offsets[i], sizes[i], src if i == 0 else scratch_first+i-1, + scratch_first+i, 1) for i in range(k-1)] + last = (offsets[-1], sizes[-1], scratch_first+k-2, dst, 1) + invert = lambda commands: [(a,n,s,t,-q) for a,n,s,t,q in reversed(commands)] + commands = chain + [last] + invert(chain) + chain[1:] + invert([last]) + invert(chain[1:]) + if sign == -1: + commands = invert(commands) + for a,n,s,t,q in commands: + yield from instructions(a,n,s,t,scratch_first+k-1,fanout,q) + + +def compose(leaf_module, x, y, factors, scratch, phases, beta, bits, direction, + sign=1, fanout=8): + """Apply the dirty echo using a pinned PR628 leaf, restoring x and scratch.""" + if direction not in (-1,1) or sign not in (-1,1): + raise ValueError('orientation and sign') + depth, count = resources(len(factors), fanout) + arrays = [x,y]+scratch + if len(scratch) < depth: + raise ValueError('dirty depth') + if len({id(a) for a in arrays}) != len(arrays): + raise ValueError('all ancestor arrays distinct') + if any(phases is a for a in arrays): + raise ValueError('phase array aliases mutable data') + if not x or any(len(a) != len(x) for a in arrays) or len(phases) != len(x): + raise ValueError('array lengths') + if any(a*a+b*b != 1 for a,b in phases): + raise ValueError('unit phases') + stats = dict(leaves=0,scalar_steps=0) + for src,dst,index,q in instructions(0,len(factors),0,1,2,fanout,sign): + leaf_module.leaf(arrays[src],arrays[dst],factors[index],phases,beta,bits, + direction,q,stats) + if stats['leaves'] != count: + raise ValueError('leaf accounting') + return stats diff --git a/research/space-capped-dirty-echo/vendor/pr689/NOTICE.md b/research/space-capped-dirty-echo/vendor/pr689/NOTICE.md new file mode 100644 index 0000000000..cc0966a001 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr689/NOTICE.md @@ -0,0 +1,47 @@ +# Attribution and license + +New refinement, implementation, verification and documentation: Dillon +Amburgey, with substantial OpenAI Codex assistance. Apache-2.0, as in the +repository and the included LICENSE. No independent human review, formal +multiplication proof, practical speedup, or literature-priority claim is made. + +- androolloyd, [PR673](https://github.com/CrocSwap/integer-mult-bounds/pull/673) + at `0e35f56cab3cae1eb0a99447135569d687c5695a`: the general multiway dirty + echo, its nonlinear restoration proof, inherited precision accounting, and + `O(n^log_k(4k-4))` call bound. Its exact `echo.py` and `ECHO-PROOF.md` are + retained in `vendor/pr673`, including the source's OpenAI Codex disclosure. + This package refines balanced size placement at fanout three and supplies an + independent free-term/noncommutative audit of the actual pinned generator. + The echo identity and exponent are predecessor results. This package does + not review PR673's separate phase-alias repair or κ appendix. +- Chafik Boukhalfa / chafreaky, PR628 at + `0768f97d06c623b8211e651543c66135796b62bf`: cyclic inverse leaves, rounded + integer lifts, balanced binary dirty commutator, preparation/precision + arguments, dense reference solvers, kernel fixtures and executable sources. + The original notice is preserved at `vendor/pr628/NOTICE.md`; its credits to + Ali Romman / PR621, the exact-DFT preprint, Alexey Kuznetsov, Pan, Mehlhorn, + Sagraloff, Wang, Brent and Briand-Davy remain in force. This package does not + reprove their analytic or algorithmic results. +- 0xkilgore, PR663 at `e0e546fd01b396478c68b6b6c5a16d87515983ba`: + independent nonlinear restoration audit and the exact binary count + `3qn-2q²`. The count provides the fair baseline here; the original `4n²` + allowance is also retained in the precision comparisons. The symbolic + verifier in this package is separately implemented; PR663 supplies the + predecessor audit, not proof of the refined instruction schedule. +- Jeremy Kothe, Chafik Boukhalfa and eumemic, #622/#623/#626 and #543, and the + preceding lineage credited in the selected review: the base repository's + accepted conditional finite construction. Their multiplier bound is neither + changed nor newly verified by this package. +- Borrowed-workspace cancellation and ladder methods have substantial prior + literature. A related quantum setting is Khattar and Gidney, + [Rise of conditionally clean ancillae for efficient quantum circuit + constructions, §4](https://arxiv.org/html/2407.17966v2#S4), laddered toggle + detection. That paper is cited as related work, not as the correctness proof + or source of the exact eight-call array word retained from PR673. No quantum + implementation is asserted. + +Concurrent PR665 investigates spectral residual splitting and PR666/PR668 +verify cyclic certificates/resultants. Those are distinct scopes; none is an +executable dependency of this contribution. Existing scoped negative results +for fixed incidence graphs, grouped frames, and commuting duplicate scalar +gates do not test this change to the product-of-shears composition tree. diff --git a/research/space-capped-dirty-echo/vendor/pr689/README.md b/research/space-capped-dirty-echo/vendor/pr689/README.md new file mode 100644 index 0000000000..cc58c0a9e3 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr689/README.md @@ -0,0 +1,304 @@ +# Cheaper balanced ternary dirty echoes + +**Construction / recursive-interface research; no new multiplication κ.** +At fanout three, androolloyd's +[PR673](https://github.com/CrocSwap/integer-mult-bounds/pull/673) executes the +first and last child twice and the middle child four times. Its balanced split +puts remainder factors in the first blocks, sometimes making the middle child +longer. Placing extra factors at the **ends** reduces the complete recursive +leaf count: at 15 factors, **208 → 160 calls with the same 5 borrowed arrays**. +All forward, inverse and restoration calls are included. These are operation +counts, not measured runtime improvements. + +The contribution is a proof that this placement minimizes **uniform leaf-call +count among recursively balanced ternary splits**, an implementation, and an +independent symbolic audit of the actual pinned PR673 instruction generator. +The audit checks arbitrary nonlinear restoration and the ideal noncommutative +product. It also confirms that changing only PR673's partition hook produces +exactly the new word, for both signs, on the stated finite domain. + +PR673 already supplies the general multiway echo and its subquadratic call +bound. This refinement preserves its ternary exponent `α = log₃ 8` and scratch +bound; it improves counts at nonuniform splits. PR673's other fanouts offer +different call/workspace tradeoffs. No optimum over those choices, unbalanced +splits, or unequal leaf costs is asserted. The rounded leaves and inherited +precision assumptions come from Chafik Boukhalfa's +[PR628](https://github.com/CrocSwap/integer-mult-bounds/pull/628). + +## Reproduction and source boundary + +From the repository root, using Python 3.11+ and its standard library: + +```sh +python3 -B research/ternary-dirty-composition/verify.py +``` + +Expected final line: `PASS_TERNARY_DIRTY_COMPOSITION`. The checker authenticates +the vendored inputs, recomputes every certificate field, and compares the +complete result with [EXPECTED.json](EXPECTED.json). All new checks use explicit +exceptions and stay active under `python3 -I -O -B`. For a new output file, use +`--write /absolute/new/certificate.json`; an existing file is rejected. + +Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +PR628 dependency: `0768f97d06c623b8211e651543c66135796b62bf`. +PR673 dependency: `0e35f56cab3cae1eb0a99447135569d687c5695a`. +The retained files are byte-exact in [vendor/pr628](vendor/pr628) and +[vendor/pr673](vendor/pr673), with SHA-256 and original paths in +[SOURCES.json](SOURCES.json). PR663 at +`e0e546fd01b396478c68b6b6c5a16d87515983ba` is credited for the independent +binary audit and sharp count; it is not an executable dependency. No pending PR +must be merged to replay this package. The assignment, candidate selection, +overlap checks, and time limit are recorded in [CLAIM.json](CLAIM.json). + +At this base, the selected conditional value is +`51110230636731/31250000000000000 = 0.001635527380375392`, from #626/#543. +Its certificate is `research/community-k492-audit/pr626/replay/ASSEMBLY.json`, +SHA-256 `6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e`. +The associated `docs/research/community-k492-review.md` retains the all-size, +compiler, hosting, normalized-residual, precision, tape, and analytic assumptions. +This package changes none of those suppliers or the selected pointer. + +## Interface and eight-call identity + +Arrays are elements of an abelian group. A child call adds a deterministic +function of its source and the **initial deeper scratch** to its target, +preserves its source, restores every deeper scratch array, and has an increment +independent of its target. Its negative call is the exact inverse instruction +word. Read-only factors, phases, and coefficients stay fixed between calls. +All active source, target, and scratch arrays are distinct; no ancestor array +is reused as deeper scratch. Overlapping views and hidden mutable dependencies +are outside this contract. + +Let `A`, `B`, `C` be the three consecutive factor-block functions and `u,v` two +borrowed arrays. PR673's chronological eight-call sequence at fanout three is + +```text +u += A(x) +v += B(u) +y += C(v) +v -= B(u) +u -= A(x) +v += B(u) +y -= C(v) +v -= B(u) +``` + +Every call restores the same deeper scratch `t`. For initial `u₀,v₀`, write + +```text +a = A(x;t). +``` + +The first target update sees `v₀+B(u₀+a;t)`. Calls four and five restore +`v₀,u₀`; the second target update sees `v₀+B(u₀;t)`. The final call restores +`v₀` again. The target increment is + +```text +C(v₀+B(u₀+a;t);t) - C(v₀+B(u₀;t);t). +``` + +It does not depend on the initial target. This proves the recursive interface +by induction, even for nonlinear functions. The exact inverse reverses the +eight calls and reverses their signs, recursively. Negating signs without +reversing order is not valid in general. + +For ideal linear children, the two arguments differ by `BAx`, and the increment +is `CBAx`. Induction thus +gives `Fₙ₋₁ ... F₁ F₀ x` in the original factor-list order. Commutation is not +assumed. The ideal increment is independent of all dirt. The rounded increment +can depend on dirt: `A(x)=x, B(u)=u², C(v)=v, x=1` gives increments `1` and `3` +for `u₀=0` and `u₀=1`, although both scratch arrays are exactly restored. + +## Optimal placement within balanced ternary recursion + +There is no search or factor reordering. Seed 58 selects arity +`2 + (58 mod 3) = 3`. At `n>=3`, write `n=3q+r`, `0<=r<3`, and split the +original list into consecutive lengths + +```text +a = q + [r>=1], b = q, c = q + [r=2]. +``` + +The longer blocks go to the ends, which execute twice; the middle executes +four times. For a singleton there is one leaf and no scratch. For two factors, +the ordinary four-call binary commutator uses one scratch array. Exactly: + +```text +N(1)=1, N(2)=4; N(n)=2N(a)+4N(b)+2N(c) (n>=3) +S(1)=0, S(2)=1; S(n)=2+max(S(a),S(b),S(c)) (n>=3). +``` + +**Optimality in this class.** A balanced split has sizes `q` or `q+1`. The +displayed placement gives + +```text +N(3q) = 8N(q) +N(3q+1) = 6N(q) + 2N(q+1) +N(3q+2) = 4N(q) + 4N(q+1). +``` + +These values are strictly increasing. Indeed `N(2)-N(1)=3` and +`N(3)-N(2)=4`; for every `q>=1`, the next three successive differences are +`2Δ, 2Δ, 4Δ`, with `Δ=N(q+1)-N(q)>0` by strong induction. For any larger +child placed in the middle while a smaller one is at an end, exchanging their +sizes saves `2(N(q+1)-N(q))>0`. Optimizing each child recursively and applying +this exchange proves the minimum over all recursively balanced ternary size +placements. Blocks stay contiguous and factors keep their original order; +only the cut positions change. This argument uses uniform leaf-call costs. + +**Workspace.** No child, inverse, source restoration, or identity factor is +omitted. Children +reuse the same deeper pool **sequentially**, so peak storage takes a maximum, +not a sum. Every balanced placement has the same multiset of child sizes, so +the scratch recurrence is unchanged from PR673 at fanout three. For `n=3^d`, +`N(n)=8^d` and `S(n)=2d`. In general let +`h=ceil(log₃ n)`. Every child has length at most `ceil(n/3) <= 3^(h-1)`; +induction gives `N(n)<=8^h < 8 n^α` and `S(n)<=2h`, with the singleton handled +separately. Hence the all-`n` bounds are `O(n^α)` calls and `O(log n)` arrays. +The strict comparison `α<2` follows from `8<9`, not a numerical logarithm. + +For completeness, if `3^d <= n < 3^(d+1)`, the exact scratch count is `2d` +when `n=3^d`, `2d+1` when `3^d= p+1+ceil(log₂(N(n) a (D+1))) + (N(n)-1)ceil(log₂ G), +``` + +in addition to the two leaf precision conditions. Execution then consumes at +most half the `2^-p` error budget. PR628's independent factor/phase preparation +must still supply the other half, scaled by the original source magnitude: +use its preparation target `p+1+ceil(log₂(max(1,||x||)))`. Dirt enters the +execution bound but not the ideal operator perturbation. This is conditional +on the inherited leaf and preparation estimates, not a new audit of them. + +All cost components remain visible: + +| Resource | Charge / condition | +|---|---| +| Completed leaves | Exactly `N(n)`, including every inverse leaf | +| Mutable array space | Source, target, and `S(n)` arbitrary length-`L` arrays; `O(L(S(n)+2)w)` bits, with transient integer magnitude included in word size | +| Leaf traversal | Three computational passes (`3L` loop visits) per leaf, plus its coefficient-stability and grid-validation scans; `O(L)` arithmetic work per call | +| Source and phase access | Every causal update, closure-product update, target update, and undo is paid. The leaf uses `(5L-2)` phase reads for an outer factor and `(6L-2)` for an inner factor. Multiply by each factor's actual occurrence count. The test fixture separately checks its `L` unit phases; a concrete public phase-taking wrapper must admit immutable, nonaliasing phases and charge that scan | +| Helpers / restoration | Two outer borrowed arrays at each ternary level; deeper pools reused only after exact restoration. No zero-initialized length-`L` helper is required | +| Control | Streamed word, `O(log n)` live control frames / `O(log² n)` indexing bits, plus `O(n)` read-only factor descriptors; no expanded instruction list in `compose` | +| Arithmetic | PR628's charged clean scalar arithmetic and counters; no reversible-bit implementation supplied | +| Coefficient and phase preparation | The same certified approximations, enclosures, original-input scaling, and charged oracle/table access as PR628 | +| Normalization / frame changes | The radix scalar is included in one leaf's multiplier and its error bound. No additional frame conversion appears in this array-level construction; conversion to a physical supplier remains an obligation | +| Routing | Neighboring cyclic layout in either direction. PR628's arbitrary-stride two-sort cost remains additional; no free route or owner allocation is assumed | + +Under PR628's `log₂(beta^-1)=O(r³)`, `n=r-1`, these bounds give +`w=O(p+log(D+1)+r^(3+α))` and `O(r^α)` leaf passes. Interior causal/closure +magnitudes add only `O(log(beta^-1)+log r)` bits per leaf beyond the completed +array bound. With the **same conditional fast-arithmetic and preparation +interfaces**, the resulting work bound is + +```text +soft-O((L r^α + r³) (p + log(D+1) + r^(3+α))) +``` + +plus charged phase-oracle and routing costs. The exact-rational prototype is +not an implementation or benchmark of that fast bit bound. A fixed number of +dirty data arrays, common-label realization, fixed-tape scheduling, complete +transform composition, analytic transfer, and integer multiplication are still +outside the result. No currently binding supplier/assembly constraint changes, +so none of these local savings imply a new complex exponent or κ. + +## Evidence and stopping rule + +The refined schedule is tested with free nonlinear function terms and +independent noncommutative linear expressions for every `n=1,...,64`, plus +`81,128,243`. The pinned PR673 generator is independently checked with both +engines for `n=1,...,64` and `81,127,128,243,255`. On that same 69-case domain, +replacing only its partition function in memory emits exactly the refined +forward and inverse words, with the same scratch count. Vendored source bytes +remain unchanged. This audits PR673's fanout-three word and resource functions; +its other fanouts, phase-alias repair, and κ appendix are outside this audit. + +The checker also minimizes over all 23,328 balanced size placements arising +for `n=3,...,10000`, using independent dynamic programming. It agrees with the +refined recurrence in all 10,000 sizes, finds strict savings over the original +ternary placement at 9,919 sizes, and checks the closed scratch formula. +The written induction supplies the all-`n` proof; this finite replay is not a +formal proof of the full multiplication theorem. + +Rounded tests use the unchanged PR628 leaf with mixed inside/outside factors, +both cycle directions, nonzero targets, arbitrary dirty arrays, a spectator, +independent dense inverse solves, and exact whole-word inversion. Additional +cases use PR628's authenticated factor certificates at radices 4, 9, and 16 +and independently expand the complete kernel polynomial. They certify the +execution error against the represented factors; the separately inherited +coefficient perturbation remains part of the full kernel accuracy contract. + +Controls remove or flip each of the 64 leaves of the `n=9` word, reverse factor +order, alias the two ternary scratch roles, misuse inverse ordering, violate +the public array interface, and demonstrate nonlinear dependence on dirt. +There are 141 rejecting controls, plus the concrete nonlinear dirt example. +The complete finite domains, case digests, and results are in EXPECTED.json. +The integer budget domain is all prime-power `r` in `[3,256]`, targets +`{1,128,1048576}`, and initial-magnitude bit bounds `{0,20,1024}`. There is no +search exhaustion or general impossibility claim. Work stops after this fixed +refinement, its stated coverage, and independent review; other arities, +unbalanced splits, unequal leaf costs, and supplier integration are not +investigated here. + +## Credit and license + +Prepared by **Dillon Amburgey**, with substantial **OpenAI Codex** assistance. +[NOTICE.md](NOTICE.md) preserves predecessor and related-work attribution. +All new files use Apache-2.0; the original PR628 notice and PR673 source credit +are retained verbatim. The echo construction and its exponent are credited to +PR673. This contribution is the balanced ternary placement minimum, its +scratch-preserving savings, and independent symbolic and rounded evidence. diff --git a/research/space-capped-dirty-echo/vendor/pr689/ternary.py b/research/space-capped-dirty-echo/vendor/pr689/ternary.py new file mode 100644 index 0000000000..a8c2eb5775 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr689/ternary.py @@ -0,0 +1,101 @@ +"""A streaming three-block composition of source-restoring additive shears. + +The leaf callback must add a deterministic function of its source to its target, +restore its source, and implement its exact inverse when sign is -1. Its +increment must not depend on the target. Coefficients and read-only data must +stay fixed throughout a call. See README.md for the proof and charged scope. +""" + +from functools import lru_cache + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def split(n): + """Contiguous block sizes; extra factors go to the less-repeated ends.""" + need(type(n) is int and n >= 3, "ternary split requires at least three factors") + q, remainder = divmod(n, 3) + return q + (remainder > 0), q, q + (remainder > 1) + + +def resources(n): + """Return (executed leaf calls, simultaneously borrowed arrays).""" + need(type(n) is int and n >= 1, "positive integer factor count") + + @lru_cache(maxsize=None) + def count(size): + if size == 1: + return 1, 0 + if size == 2: + return 4, 1 + a, b, c = (count(k) for k in split(size)) + return 2 * a[0] + 4 * b[0] + 2 * c[0], 2 + max(a[1], b[1], c[1]) + + return count(n) + + +def word(n, sign=1): + """Yield (factor_index, source_array, target_array, sign) in execution order. + + Array 0 is the source, array 1 the target, and arrays 2 onward are borrowed. + Only O(log n) control frames are live; the expanded word is never stored. + Negative calls reverse the instruction order as well as the signs. + """ + need(type(n) is int and n >= 1, "positive integer factor count") + need(type(sign) is int and sign in (-1, 1), "sign must be +1 or -1") + + def emit(lo, hi, source, target, depth, direction): + size = hi - lo + if size == 1: + yield lo, source, target, direction + return + u = 2 + depth + if size == 2: + operations = [ + (lo, lo + 1, source, u, 1), + (lo + 1, hi, u, target, 1), + (lo, lo + 1, source, u, -1), + (lo + 1, hi, u, target, -1), + ] + child_depth = depth + 1 + else: + a, b, _ = split(size) + v = u + 1 + # PR673's echo at fanout 3, with longer blocks at the ends. + # Chronological order: A B C B^-1 A^-1 B C^-1 B^-1. + A = (lo, lo + a, source, u) + B = (lo + a, lo + a + b, u, v) + C = (lo + a + b, hi, v, target) + operations = [ + (*A, 1), (*B, 1), (*C, 1), (*B, -1), + (*A, -1), (*B, 1), (*C, -1), (*B, -1), + ] + child_depth = depth + 2 + if direction == -1: + operations = [(*op[:-1], -op[-1]) for op in reversed(operations)] + for left, right, src, dst, child_sign in operations: + yield from emit(left, right, src, dst, child_depth, child_sign) + + yield from emit(0, n, 0, 1, 0, sign) + + +def compose(source, target, factors, scratch, leaf, sign=1): + """Run the word using leaf(source, target, factor, sign). + + Scratch arrays are caller-supplied arbitrary data, not initialized copies. + Extra supplied arrays are admitted but untouched. Array aliasing is rejected + before the first leaf. Overlapping views and hidden mutable dependencies + are outside this contract; the reference uses ordinary lists of scalars. + """ + n = len(factors) + _, required = resources(n) + need(type(sign) is int and sign in (-1, 1), "sign must be +1 or -1") + need(len(scratch) >= required, "insufficient distinct dirty arrays") + arrays = [source, target, *scratch] + need(len({id(a) for a in arrays}) == len(arrays), "source, target and scratch must be distinct") + need(len(source) > 0 and all(len(a) == len(source) for a in arrays), "equal positive array lengths") + for factor, src, dst, direction in word(n, sign): + leaf(arrays[src], arrays[dst], factors[factor], direction) diff --git a/research/space-capped-dirty-echo/vendor/pr730/NOTICE.md b/research/space-capped-dirty-echo/vendor/pr730/NOTICE.md new file mode 100644 index 0000000000..38f2decc43 --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr730/NOTICE.md @@ -0,0 +1,41 @@ +# Attribution and license + +Prepared for **Sagar Thakrar (@thakrarsagar)** with substantial **OpenAI Codex +assistance**, including separate workers for the written proof and independent +verification. New code and documentation are Apache-2.0 under the repository's +root [LICENSE](../../LICENSE). No independent human review is claimed. + +- **androolloyd**, [PR #673](https://github.com/CrocSwap/integer-mult-bounds/pull/673): + the multiway dirty echo, its nonlinear restoration identity, recursive + instruction generator, and precision/resource argument. Its full-transform + experiment supplies the scoped negative result for a direct all-role adapter. + `vendor/pr673_echo.py` retains the exact source, including its AI disclosure. + `optimize.py` adapts that emitter to an explicit ordered tree; this package + contributes the interval optimization and its independently checked witnesses. +- **Dillon Amburgey (@dillona)**, + [PR #689](https://github.com/CrocSwap/integer-mult-bounds/pull/689): the minimum + among recursively balanced ternary splits with uniform leaf costs, and the + corrected baseline used here. The result at 15 factors is credited to #689; + this package's savings at 27 and 56 factors use a larger, explicitly scoped + tree class. No claim of priority over general alphabetic-tree optimization + algorithms is made. +- **Chafik Boukhalfa (@chafreaky)**, + [PR #628](https://github.com/CrocSwap/integer-mult-bounds/pull/628), head + `0768f97d06c623b8211e651543c66135796b62bf`: the rounded cyclic-inverse leaves, + balanced binary dirty commutator, and inherited preparation/precision + contracts. Those analytic and numerical implementations are not re-audited + or copied here. Their cited mathematical predecessors retain their credit. +- **0xkilgore**, [PR #663](https://github.com/CrocSwap/integer-mult-bounds/pull/663), + head `e0e546fd01b396478c68b6b6c5a16d87515983ba`: independent nonlinear + restoration audit and the exact count for the balanced binary dispatcher. + +[SOURCES.json](SOURCES.json) records exact source commits, SHA-256 hashes and +Git blob identifiers. The checker needs no network or pending-PR checkout. +Only the vendored echo is an executable predecessor dependency. The other +pins document comparisons, mathematical dependencies, and the selected-result +context at the base commit. + +The accepted #626 construction remains credited to Jeremy Kothe's K-triangle +construction and the complete supplier/owner-allocation lineage in the +[maintainer review](../../docs/research/community-k492-review.md). This local +interface research neither alters that construction nor establishes a new κ. diff --git a/research/space-capped-dirty-echo/vendor/pr730/optimize.py b/research/space-capped-dirty-echo/vendor/pr730/optimize.py new file mode 100644 index 0000000000..d48f14658f --- /dev/null +++ b/research/space-capped-dirty-echo/vendor/pr730/optimize.py @@ -0,0 +1,86 @@ +"""Exact ordered binary/ternary dirty-echo trees at a fixed scratch budget. + +Prepared for Sagar Thakrar with substantial OpenAI Codex assistance. +Apache-2.0. The instruction emitter adapts androolloyd's PR673 echo.py; +see NOTICE.md and vendor/pr673_echo.py for its unchanged source. +""" + +from functools import lru_cache + + +def optimize(costs, budget): + """Return (minimum charged cost, tree); raise ValueError if infeasible. + + Prices cover complete leaf calls at one common precision. A tree is a + factor index or a tuple of two/three children, in original factor order. + All connector arrays remain reserved during every descendant call. + """ + costs = tuple(costs) + if not costs or any(type(c) is not int or c <= 0 for c in costs): + raise ValueError("positive integer leaf costs required") + if type(budget) is not int or budget < 0: + raise ValueError("nonnegative integer scratch budget required") + + @lru_cache(None) + def solve(lo, hi, available): + if hi - lo == 1: + return costs[lo], lo + if available < 1: + return None + best = None + for mid in range(lo + 1, hi): + left = solve(lo, mid, available - 1) + right = solve(mid, hi, available - 1) + if left is not None and right is not None: + charge = 2 * (left[0] + right[0]) + if best is None or charge < best[0]: + best = charge, (left[1], right[1]) + if available >= 2: + for first in range(lo + 1, hi - 1): + left = solve(lo, first, available - 2) + if left is None: + continue + for second in range(first + 1, hi): + middle = solve(first, second, available - 2) + right = solve(second, hi, available - 2) + if middle is not None and right is not None: + charge = 2 * left[0] + 4 * middle[0] + 2 * right[0] + if best is None or charge < best[0]: + best = charge, (left[1], middle[1], right[1]) + return best + + result = solve(0, len(costs), budget) + if result is None: + raise ValueError("scratch budget cannot hold an ordered echo tree") + return result + + +def resources(tree, costs): + """Return actual peak reserved scratch and the complete leaf charge.""" + if isinstance(tree, int): + return 0, costs[tree] + children = [resources(child, costs) for child in tree] + scratch = len(tree) - 1 + max(depth for depth, _ in children) + charge = sum((2 if i in (0, len(tree) - 1) else 4) * cost + for i, (_, cost) in enumerate(children)) + return scratch, charge + + +def instructions(tree, src=0, dst=1, scratch_first=2, sign=1): + """Emit the PR673 echo, or its reverse inverse, for an optimized tree.""" + pending = [(tree, src, dst, scratch_first, sign)] + while pending: + node, source, target, first, direction = pending.pop() + if isinstance(node, int): + yield source, target, node, direction + continue + k = len(node) + chain = [(node[i], source if i == 0 else first + i - 1, + first + i, 1) for i in range(k - 1)] + last = (node[-1], first + k - 2, target, 1) + invert = lambda commands: [(t, s, d, -q) for t, s, d, q in reversed(commands)] + commands = chain + [last] + invert(chain) + chain[1:] + invert([last]) + invert(chain[1:]) + if direction == -1: + commands = invert(commands) + pending.extend((child, s, d, first + k - 1, q) + for child, s, d, q in reversed(commands)) diff --git a/research/space-capped-dirty-echo/verify.py b/research/space-capped-dirty-echo/verify.py new file mode 100644 index 0000000000..7f3d9ec4c4 --- /dev/null +++ b/research/space-capped-dirty-echo/verify.py @@ -0,0 +1,437 @@ +"""Offline exact certificate for space-capped dirty-echo planning. + +No solver, network, floating arithmetic, or assertion-dependent checks. +Small-tree enumeration and an all-cuts recurrence do not import the planner. +The symbolic interpreter checks the emitted operations, including dirty inputs. +""" + +import argparse +from collections import Counter +from fractions import Fraction as F +from functools import lru_cache +import hashlib +import importlib.util +from itertools import combinations, product +import json +from pathlib import Path +import random + +ROOT = Path(__file__).resolve().parent + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def module(name, path): + spec = importlib.util.spec_from_file_location(name, path) + value = importlib.util.module_from_spec(spec) + spec.loader.exec_module(value) + return value + + +def digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def compare_certificate(result, expected): + # Trees are tuples in memory and JSON arrays on disk. Compare every field + # after this representation-only normalization, not a selected summary. + # Canonical JSON also distinguishes integer 1 from boolean true / float 1.0. + need(json.dumps(result, sort_keys=True, separators=(',', ':')) == + json.dumps(expected, sort_keys=True, separators=(',', ':')), + 'exact certificate mismatch') + + +def sources(): + data = json.loads((ROOT/'SOURCES.json').read_text(encoding='utf-8')) + for row in data['sources']: + need(hashlib.sha256((ROOT/row['path']).read_bytes()).hexdigest() == row['sha256'], + 'source pin: '+row['path']) + selected = json.loads((ROOT/'../../certificates/selected-result.json').read_text()) + assembly = json.loads((ROOT/'../../research/community-k492-audit/pr626/replay/ASSEMBLY.json').read_text()) + need(selected['kappa'] == assembly['kappa'] == '51110230636731/31250000000000000', + 'selected context') + return dict(base_commit=data['base_commit'], files=len(data['sources']), + selected_kappa=selected['kappa']) + + +@lru_cache(None) +def shapes(n): + """Enumerate ALL ordered rooted trees with n leaves and arities >= 2.""" + if n == 1: + return (None,) + result = [] + # A subset of n-1 gaps is exactly one ordered positive composition of n. + for mask in range(1, 1 << (n-1)): + cuts = (0,)+tuple(i for i in range(1, n) if mask & (1 << (i-1)))+(n,) + for children in product(*(shapes(b-a) for a, b in zip(cuts, cuts[1:]))): + result.append(children) + return tuple(result) + + +def shape_bill(shape): + """Different representation: leaves are anonymous; result is a coefficient vector.""" + if shape is None: + return 0, (1,) + rows = [shape_bill(x) for x in shape] + coefficients = tuple(c*(2 if j == 0 or j+1 == len(rows) else 4) + for j, (_, cs) in enumerate(rows) for c in cs) + return len(rows)-1+max(s for s, _ in rows), coefficients + + +def cuts_oracle(weights, cap): + """Exact independent recurrence: explicitly enumerate each root cut set. + + Unlike planner.py, no prefix partition DP, capacity pruning, or stored + witness is used. This is practical for the primary 15-factor instance. + """ + visited = 0 + + @lru_cache(None) + def opt(left, right, budget): + nonlocal visited + if right-left == 1: + return weights[left], 1 + answer = None + for k in range(2, min(right-left, budget+1)+1): + for middle in combinations(range(left+1, right), k-1): + visited += 1 + ends = (left,)+middle+(right,) + children = [opt(a, b, budget-k+1) for a, b in zip(ends, ends[1:])] + if any(x is None for x in children): + continue + coefficients = (2,)+(4,)*(k-2)+(2,) + candidate = tuple(sum(m*row[j] for m, row in zip(coefficients, children)) + for j in (0, 1)) + if answer is None or candidate < answer: + answer = candidate + return answer + + result = opt(0, len(weights), cap) + return result, visited + + +def enumeration_check(planner): + rng = random.Random(58) + rows, comparisons, tree_count = [], 0, 0 + for n in range(1, 9): + bills = [shape_bill(t) for t in shapes(n)] + tree_count += len(bills) + need(len(shapes(n)) == len(set(shapes(n))), 'duplicate exhaustive tree') + # Four separately specified cost vectors; uniform and both orientations. + costs = [(1,)*n, tuple(range(1, n+1)), tuple(range(n, 0, -1)), + tuple(rng.randrange(1, 59) for _ in range(n))] + for weights in costs: + for cap in range(n): + candidates = [(sum(a*b for a, b in zip(weights, profile)), sum(profile)) + for space, profile in bills if space <= cap] + expected = min(candidates) if candidates else None + if expected is None: + try: + planner.optimize(weights, cap) + except ValueError: + pass + else: + raise ValueError('accepted infeasible cap') + else: + actual = planner.optimize(weights, cap) + need((actual['price'], actual['calls']) == expected, 'exhaustive optimum') + need(actual['scratch'] <= cap, 'exhaustive space') + comparisons += 1 + rows.append((weights, cap, expected)) + need([len(shapes(i)) for i in range(1, 9)] == [1, 1, 3, 11, 45, 197, 903, 4279], + 'complete small-tree census') + return dict(trees=tree_count, comparisons=comparisons, rows_sha256=digest(rows), + domain='all reduced ordered rooted trees, n=1..8; four weight vectors; cap=0..n-1') + + +def plus(target, increment, sign): + result = dict(target) + for key, value in increment.items(): + result[key] = result.get(key, 0)+sign*value + if not result[key]: + del result[key] + return result + + +def linear_state(steps, slots): + state = [{((), i): 1} for i in range(slots)] + for f, src, dst, sign in steps: + need(src != dst and 0 <= src < slots and 0 <= dst < slots, 'linear array address') + state[dst] = plus(state[dst], {((f,)+word, var): c + for (word, var), c in state[src].items()}, sign) + return state + + +def linear_check(steps, n, slots, sign=1): + expected = [{((), i): 1} for i in range(slots)] + expected[1][(tuple(reversed(range(n))), 0)] = sign + need(linear_state(steps, slots) == expected, 'noncommutative endpoint/restoration') + + +def nonlinear_check(steps, inverse, slots): + # Opaque deterministic function atoms on canonical additive source values. + # No distributivity through a function is used. + state = [{i: 1} for i in range(slots)] + initial = [dict(x) for x in state] + atoms, dependencies = {}, {i: {i} for i in range(slots)} + + def execute(program): + for factor, src, dst, sign in program: + need(src != dst and 0 <= src < slots and 0 <= dst < slots, 'nonlinear array address') + key = factor, tuple(sorted(state[src].items())) + if key not in atoms: + index = slots+len(atoms) + atoms[key] = index + dependencies[index] = set().union(*(dependencies[x] for x in state[src])) + state[dst] = plus(state[dst], {atoms[key]: 1}, sign) + + execute(steps) + need(state[0] == initial[0] and state[2:] == initial[2:], 'nonlinear restoration') + change = plus(state[1], initial[1], -1) + need(all(1 not in dependencies[atom] for atom in change), 'target-independent increment') + execute(inverse) + need(state == initial, 'nonlinear exact inverse') + return len(atoms) + + +def word_check(planner, plan, n): + forward = list(planner.word(plan['tree'])) + backward = list(planner.word(plan['tree'], -1)) + need(backward == [(f, s, t, -q) for f, s, t, q in reversed(forward)], 'inverse chronology') + counts = Counter(f for f, _, _, _ in forward) + need([counts[i] for i in range(n)] == plan['occurrences'], 'literal child invoice') + peak = max(max(s, t) for _, s, t, _ in forward)-1 + need(peak == plan['scratch'], 'literal workspace peak') + slots = 3+plan['scratch'] # extra untouched spectator + linear_check(forward, n, slots) + linear_check(backward, n, slots, -1) + atoms = nonlinear_check(forward, backward, slots) + return dict(factors=n, calls=len(forward), scratch=peak, nonlinear_atoms=atoms, + word_sha256=digest(forward)) + + +def uniform_checks(planner, ternary, echo): + records, symbolic = [], [] + for n in range(1, 33): + floor = (n-1).bit_length() + for cap in sorted({floor, min(n-1, floor+1)}): + plan = planner.optimize([1]*n, cap) + records.append(dict(factors=n, cap=cap, **plan)) + symbolic.append(word_check(planner, plan, n)) + # Primary full Pareto row for radix 16. No claim that radix 59 is a kernel. + primary = [] + for cap in range(4, 15): + plan = planner.optimize([1]*15, cap) + oracle, visited = cuts_oracle((1,)*15, cap) + need(oracle == (plan['price'], plan['calls']), 'primary all-cuts optimum') + primary.append(dict(cap=cap, **plan, oracle_root_partitions=visited)) + row = next(x for x in primary if x['cap'] == 5) + need(row['calls'] == 152 and row['scratch'] == 5, 'primary exact result') + balanced_calls, balanced_space = ternary.resources(15) + need((balanced_calls, balanced_space) == (160, 5), 'PR689 primary baseline') + need(len(list(ternary.word(15))) == balanced_calls, 'PR689 literal baseline') + old_space, old_calls = echo.resources(15, 3) + need((old_calls, old_space) == (208, 5), 'PR673 primary baseline') + need(len(list(echo.instructions(0, 15, 0, 1, 2, 3))) == old_calls, 'PR673 literal baseline') + extra = planner.optimize([1]*58, 8) + symbolic.append(word_check(planner, extra, 58)) + return dict(domain='n=1..32 at minimum feasible cap and one extra; n=15 caps 4..14; n=58 cap 8', + resource_rows=records, primary_pareto=primary, + pr689_primary=dict(calls=balanced_calls, scratch=balanced_space), + pr673_primary=dict(calls=old_calls, scratch=old_space), + n58=extra, symbolic=symbolic) + + +def ceil_log2_fraction(x): + need(x > 0, 'positive logarithm argument') + k = x.numerator.bit_length()-x.denominator.bit_length() + while F(2)**k < x: + k += 1 + while F(2)**(k-1) >= x: + k -= 1 + return k + + +def precision(calls, beta, r, magnitude, target): + a = F(13*(r+1))/beta**3 + G = 2+F(r)/beta + bits = max(ceil_log2_fraction(a), ceil_log2_fraction(2/beta**2), + target+1+ceil_log2_fraction(calls*a*(magnitude+1)) + +(calls-1)*ceil_log2_fraction(G)) + bound = calls*a*(magnitude+1)*G**(calls-1)/2**bits + need(a/2**bits <= 1 and F(1, 2**bits) <= beta**2/2, 'leaf precision conditions') + need(bound <= F(1, 2**(target+1)), 'complete word error bound') + return bits, bound + + +def rounded_case(planner, leaf_module, tree, factors, beta, r, length, direction, dirt, q=None): + c = leaf_module.c + bill = planner.invoice(tree, [1]*len(factors)) + arrays = [[(F(2+j+i, 8), F(3-j+2*i, 8)) for i in range(length)] + for j in range(3+bill['scratch'])] + for j in range(2, len(arrays)): + arrays[j] = [(a+dirt, b-dirt) for a, b in arrays[j]] + initial = [x[:] for x in arrays] + D = max(abs(a)+abs(b) for row in arrays for a, b in row) + bits, bound = precision(bill['calls'], beta, r, D, 64) + units = [c.ONE, (F(0), F(1)), (F(3, 5), F(4, 5))] + values = [units[i % len(units)] for i in range(length)] + + class Phases: + reads = 0 + + def __getitem__(self, i): + self.reads += 1 + return values[i] + + phases = Phases() + stats = dict(leaves=0, scalar_steps=0) + + def leaf(src, dst, factor, sign): + leaf_module.leaf(src, dst, factor, phases, beta, bits, direction, sign, stats) + + planner.compose(tree, arrays[0], arrays[1], factors, arrays[2:], leaf, read_only=(values,)) + need(arrays[0] == initial[0] and arrays[2:] == initial[2:], 'rounded dirty restoration') + reads = sum(n*((6 if f[0] else 5)*length-2) for f, n in zip(factors, bill['occurrences'])) + need(phases.reads == reads and stats == dict(leaves=bill['calls'], scalar_steps=3*length*bill['calls']), + 'actual phase-access and traversal invoice') + exact = (leaf_module.exact_operator(initial[0], factors, values, direction) if q is None else + leaf_module.w.solve(leaf_module.w.matrix(q, values, direction), initial[0])) + net = [c.sub(v, start) for v, start in zip(arrays[1], initial[1])] + need(all(c.norm2(c.sub(v, e)) <= bound**2 for v, e in zip(net, exact)), 'rounded dense comparison') + output_hash = digest([[str(a), str(b)] for a, b in net]) + planner.compose(tree, arrays[0], arrays[1], factors, arrays[2:], leaf, -1, read_only=(values,)) + need(arrays == initial, 'rounded exact inverse') + need(phases.reads == 2*reads and stats['leaves'] == 2*bill['calls'], 'inverse invoice') + return dict(factors=len(factors), length=length, direction=direction, dirt=dirt, + calls=bill['calls'], scratch=bill['scratch'], phase_reads=reads, + lift_loop_visits=3*length*bill['calls'], working_bits=bits, + execution_target_bits=64, output_sha256=output_hash) + + +def rounded_checks(planner, ternary, old): + generic = [] + for n in (1, 2, 3, 5, 8, 15): + plan = planner.optimize([1]*n, min(n-1, (n-1).bit_length()+1)) + factors = [(i % 2 == 0, (F(1, 4), F((-1)**i, 8)), F(3 if i == 0 else 1)) + for i in range(n)] + for length, direction, dirt in product((1, 3), (-1, 1), (-7, 5)): + generic.append(rounded_case(planner, old, plan['tree'], factors, F(1, 2), 3, + length, direction, dirt)) + fixture = next(x for x in json.loads((ROOT/'vendor/pr628/FACTORS.json').read_text()) + if x['radix'] == 16 and x['embedding'] == 1) + certified = old.w.k.certify(fixture) + factors = [(inside, b, F(16 if i == 0 else 1)) + for i, (inside, b) in enumerate(certified['factors'])] + # The weights are the ACTUAL leaf phase reads on a length-five cycle. + weights = [(6 if inside else 5)*5-2 for inside, _, _ in factors] + plan = planner.optimize(weights, 5) + oracle, visited = cuts_oracle(tuple(weights), 5) + need(oracle == (plan['price'], plan['calls']), 'weighted all-cuts optimum') + balanced = Counter(f for f, _, _, _ in ternary.word(15)) + baseline_reads = sum(weights[i]*balanced[i] for i in range(15)) + uniform = planner.optimize([1]*15, 5) + kernel = [] + for label, tree in (('uniform', uniform['tree']), ('phase_weighted', plan['tree'])): + for direction, dirt in product((-1, 1), (-7, 5)): + # The independent polynomial reference uses the full five-cycle matrix. + row = rounded_case(planner, old, tree, factors, certified['beta'], 16, 5, + direction, dirt, certified['q']) + row['objective'] = label + kernel.append(row) + return dict(generic=generic, kernel=kernel, + weighted=dict(weights=weights, **plan, pr689_phase_reads=baseline_reads, + uniform_phase_reads=sum(a*b for a,b in zip(weights, uniform['occurrences'])), + oracle_root_partitions=visited, + symbolic=word_check(planner, plan, len(factors))), + kernel_scope='radix 16 embedding 1, length 5, both directions, two arbitrary-dirt fixtures; represented-factor polynomial and inherited root certificate') + + +def negative_controls(planner): + rejected = [] + + def reject(name, function): + try: + function() + except ValueError: + rejected.append(name) + else: + raise ValueError('accepted negative control: '+name) + + plan = planner.optimize([1]*15, 5) + steps = list(planner.word(plan['tree'])) + slots = 3+plan['scratch'] + for index in range(len(steps)): + reject('omit_'+str(index), lambda i=index: linear_check(steps[:i]+steps[i+1:], 15, slots)) + f, s, t, q = steps[index] + mutant = steps[:index]+[(f,s,t,-q)]+steps[index+1:] + reject('sign_'+str(index), lambda m=mutant: linear_check(m, 15, slots)) + reject('factor_order', lambda: linear_check([(14-f,s,t,q) for f,s,t,q in steps], 15, slots)) + reject('inverse_order', lambda: nonlinear_check(steps, [(f,s,t,-q) for f,s,t,q in steps], slots)) + reject('scratch_alias', lambda: linear_check([(f,2 if s==3 else s,2 if t==3 else t,q) + for f,s,t,q in steps], 15, slots)) + for name, weights, cap in [('empty',[],1), ('zero',[0],0), ('negative',[-1],0), + ('bool_weight',[True],0), ('bool_cap',[1],True), + ('negative_cap',[1],-1), ('infeasible',[1]*15,3)]: + reject(name, lambda w=weights,c=cap: planner.optimize(w,c)) + reject('missing_factor', lambda: planner.invoice((0,1), [1,1,1])) + reject('reordered_factor', lambda: planner.invoice((1,0), [1,1])) + reject('unary_node', lambda: planner.invoice((0,), [1])) + called = [] + + def admission(**kw): + args = dict(tree=(0,1,2), source=[1], target=[2], factors=[0,1,2], + scratch=[[3],[4]], leaf=lambda *a: called.append(a)) + args.update(kw) + planner.compose(**args) + + same = [1] + for name, kw in [('source_target',dict(source=same,target=same)), + ('source_scratch',dict(source=same,scratch=[same,[4]])), + ('target_scratch',dict(target=same,scratch=[same,[4]])), + ('scratch_pair',dict(scratch=[same,same])), + ('phase_alias',dict(source=same,read_only=(same,))), + ('short_scratch',dict(scratch=[[1]])), ('length',dict(target=[1,2])), + ('sign',dict(sign=0)), ('bool_sign',dict(sign=True))]: + reject(name, lambda kw=kw: admission(**kw)) + need(not called, 'admission must reject before mutation') + return dict(rejected_count=len(rejected), rejected=rejected) + + +def verify(): + bindings = sources() + planner = module('planner', ROOT/'planner.py') + ternary = module('ternary_baseline', ROOT/'vendor/pr689/ternary.py') + echo = module('echo_baseline', ROOT/'vendor/pr673/echo.py') + old = module('rounded_leaf', ROOT/'vendor/pr628/dirty.py') + result = dict(status='PASS_SPACE_CAPPED_DIRTY_ECHO', sources=bindings) + result['enumeration'] = enumeration_check(planner) + print('PASS exhaustive small-tree oracle', flush=True) + result['uniform'] = uniform_checks(planner, ternary, echo) + print('PASS primary all-cuts optimum, literal words and symbolic restoration', flush=True) + result['controls'] = negative_controls(planner) + result['rounded'] = rounded_checks(planner, ternary, old) + print('PASS weighted optimum, rounded leaves and charged phase accesses', flush=True) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', type=Path, help='write a new certificate; never overwrite') + args = parser.parse_args() + if args.write: + need(not args.write.exists(), 'output already exists') + result = verify() + if args.write: + with args.write.open('x', encoding='utf-8', newline='\n') as stream: + stream.write(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: + compare_certificate(result, json.loads((ROOT/'EXPECTED.json').read_text())) + print('PASS_SPACE_CAPPED_DIRTY_ECHO calls=160->152 scratch=5 no_new_kappa') + + +if __name__ == '__main__': + main()