From 8f01a45b7a4cf7c70494b51e4a33f3f7f8a28537 Mon Sep 17 00:00:00 2001
From: Aaron Wang <warhawk947@gmail.com>
Date: Tue, 13 Oct 2026 01:59:40 -0400
Subject: [PATCH 1/2] test: verify prime-power valuations by division

---
 .../prime-power-newton-valuation/CLAIM.md     |   55 +
 .../CORROBORATION.json                        |   22 +
 .../EXPECTED.json                             | 1349 +++++++++++++++++
 .../prime-power-newton-valuation/NOTICE.md    |   36 +
 .../prime-power-newton-valuation/PROOF.md     |  270 ++++
 .../prime-power-newton-valuation/README.md    |  128 ++
 .../prime-power-newton-valuation/SOURCE.json  |   42 +
 .../VALIDATION.md                             |  118 ++
 .../test_verify.py                            |  110 ++
 .../prime-power-newton-valuation/verify.py    |  276 ++++
 10 files changed, 2406 insertions(+)
 create mode 100644 research/prime-power-newton-valuation/CLAIM.md
 create mode 100644 research/prime-power-newton-valuation/CORROBORATION.json
 create mode 100644 research/prime-power-newton-valuation/EXPECTED.json
 create mode 100644 research/prime-power-newton-valuation/NOTICE.md
 create mode 100644 research/prime-power-newton-valuation/PROOF.md
 create mode 100644 research/prime-power-newton-valuation/README.md
 create mode 100644 research/prime-power-newton-valuation/SOURCE.json
 create mode 100644 research/prime-power-newton-valuation/VALIDATION.md
 create mode 100644 research/prime-power-newton-valuation/test_verify.py
 create mode 100644 research/prime-power-newton-valuation/verify.py

diff --git a/research/prime-power-newton-valuation/CLAIM.md b/research/prime-power-newton-valuation/CLAIM.md
new file mode 100644
index 0000000000..2a97e69b10
--- /dev/null
+++ b/research/prime-power-newton-valuation/CLAIM.md
@@ -0,0 +1,55 @@
+# Sprint claim and implementation plan
+
+- Track: independent verification; OS-random assignment seed **80**.
+- Exact base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+- Branch: `research/seed80-independent-verification`.
+- Claimed at 2026-10-13 05:40 UTC; expected finish by 06:15 UTC.
+- Object: the coefficient valuations and lower Newton polygon of PR621's
+  integral prime-power kernel, not a proposed multiplication construction.
+- Method: build tail products in the integer cyclic group ring, reduce in the
+  cyclotomic power basis, substitute `u=1-pi`, and extract the ramified valuation.
+  Compare with the independent tail-sum formula and a convex-hull computation.
+- Domain: every primitive embedding at orders 3, 5, 7 and every repeated
+  prime power through `seed+1=81`: 4, 8, 9, 16, 25, 27, 32, 49, 64, 81.
+- Deliverable: one standard-library verifier, exact deterministic receipt,
+  tests, scoped mathematical note, source pins and handoff. No new kappa.
+- Stop after the complete fixed domain, or report the first discrepant exact
+  coefficient. No adaptive search or extra computation on a closed search.
+
+## Selection and coordination
+
+Three candidates were inspected: (1) R420 compensation algebra, already covered
+by open #731/#737/#760/#762; (2) prime-power resultant replay, already covered by
+#668 and composite extensions #666; (3) ramified coefficient valuations and
+Newton polygons for #621. Candidate 3 changes the proof obligation and arithmetic
+method, rather than merely using a new seed. The open-PR inventory and primary
+package contain no Newton-polygon or p-adic-valuation contribution at selection.
+The pinned-issue GraphQL query returned no issues, so this is a local claim.
+No separate reservation issue was opened.
+
+Selected status was followed from `certificates/selected-result.json` to
+`research/community-k492-audit/pr626/replay/ASSEMBLY.json`, its source manifest,
+the #626 construction README and maintainer review. The accepted conditional
+value is `51110230636731/31250000000000000`, not the pending PR-title values.
+
+## Implementation plan
+
+Goal: independently check exact valuations before deriving any conclusion.
+Architecture: a standalone integer engine and rational convex hull; no imports
+from the predecessor's field, determinant, inverse or SymPy implementations.
+Tech stack: Python 3.11+ standard library. Scope and design are the claim above.
+
+1. Write tests with hand-calculated radix-4 coefficients and radix-8/27 hulls,
+   plus nonprimitive/composite and altered-coefficient controls; observe failure.
+2. Implement `tail_coefficients(r, power)`, `coefficient_valuation(c, p, a)` and
+   `lower_hull(values)`; compare exact expansion against the tail-sum formula.
+3. Replay the fixed domain, recording every primitive power and a digest of
+   every reconstructed coefficient. Add controls that preserve the old mod-ideal
+   zero/nonzero pattern while changing the stronger valuation obligation.
+4. A single scoped background worker checks the uniform mathematical argument
+   and writes only `PROOF.md`; it does not change the implementation or scope.
+5. Reserve the final ten minutes for fresh normal/optimized replay, predecessor
+   checks, receipt-mutation failure, source integrity and overlap refresh.
+6. Submit at most one independent-verification/research-note PR, with exact
+   attribution, AI disclosure and unresolved obligations. Do not alter upstream
+   or the selected record.
diff --git a/research/prime-power-newton-valuation/CORROBORATION.json b/research/prime-power-newton-valuation/CORROBORATION.json
new file mode 100644
index 0000000000..db195e0ac2
--- /dev/null
+++ b/research/prime-power-newton-valuation/CORROBORATION.json
@@ -0,0 +1,22 @@
+{
+  "status": "PASS_EXACT_SHARED_RECEIPT_COMPARISON",
+  "source_pr": 796,
+  "author": "Hao Yan (@FanPUYen)",
+  "source_head": "22902155c7875139e43e4fdf15723142d6709bdd",
+  "source_receipt": "research/prime-power-newton-audit/EXPECTED.json",
+  "source_receipt_sha256": "d074f1c2f87324e81cf8aa94784077694230cf35d95f8b0c173755c89f876333",
+  "shared_radices": [3, 4, 5, 7, 8, 9, 16, 25, 27, 32, 49, 64],
+  "shared_primitive_embeddings": 160,
+  "shared_coefficient_obligations": 5894,
+  "equal_fields": [
+    "primitive powers",
+    "every coefficient valuation",
+    "lower hull vertices",
+    "every root valuation and algebraic multiplicity"
+  ],
+  "additional_radices": [81],
+  "additional_primitive_embeddings": 54,
+  "additional_coefficient_obligations": 4374,
+  "distinct_method": "Repeated exact integral division by pi=1-u, independent of the weighted-minimum valuation extractor shared with PR796.",
+  "scope": "Pinned receipt corroboration, not execution or review of the full PR796 package and not independent human review."
+}
diff --git a/research/prime-power-newton-valuation/EXPECTED.json b/research/prime-power-newton-valuation/EXPECTED.json
new file mode 100644
index 0000000000..592bc483f0
--- /dev/null
+++ b/research/prime-power-newton-valuation/EXPECTED.json
@@ -0,0 +1,1349 @@
+{
+  "status": "PASS_PRIME_POWER_NEWTON_VALUATIONS",
+  "assignment_seed": 80,
+  "domain": [
+    3,
+    4,
+    5,
+    7,
+    8,
+    9,
+    16,
+    25,
+    27,
+    32,
+    49,
+    64,
+    81
+  ],
+  "embedding_count": 214,
+  "coefficient_count": 10268,
+  "valuation_methods": [
+    "weighted_uniformizer_basis_minimum",
+    "repeated_exact_integral_uniformizer_division"
+  ],
+  "source_files_sha256_lf": {
+    "research/prime-power-cyclic-inverse/PROOF.md": "2b8056c88e66f692f407450fff0414d41bcd09db8597be22e274a6c3dc20eb9e",
+    "research/prime-power-cyclic-inverse/SOURCE.json": "81217e4ecbb1da767d6a23f043d66e69d53c9001c056176efc641ddadea275f2",
+    "research/prime-power-cyclic-inverse/verify.py": "40e5e18cbd98d39ba6d0bb036778ccacc077dff009099a54b9c8f441af5d6a56"
+  },
+  "cases": [
+    {
+      "radix": 3,
+      "prime": 3,
+      "prime_exponent": 1,
+      "ramification_degree": 2,
+      "primitive_powers": [
+        1,
+        2
+      ],
+      "coefficient_valuations": [
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          2
+        ],
+        [
+          2,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 2,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "ef8848bcc2c7565595887d65c55ee1054c230d80be107fdaf2cec4bafdd8fff6",
+        "2": "2a5a0014e19a1444fed1f7ea2869b81554918d45f09a34c7dec3c8a4cafe9760"
+      }
+    },
+    {
+      "radix": 4,
+      "prime": 2,
+      "prime_exponent": 2,
+      "ramification_degree": 2,
+      "primitive_powers": [
+        1,
+        3
+      ],
+      "coefficient_valuations": [
+        4,
+        3,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          4
+        ],
+        [
+          2,
+          1
+        ],
+        [
+          3,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 2,
+          "valuation": "3/2"
+        },
+        {
+          "multiplicity": 1,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "3ac32afa666724ef10b85cd087cb6953129e18846eeb80260b607d20f49b6b12",
+        "3": "064ebbf67f855c0b92a20f9dc2d92365e5d2fbf9d0bb8750421903f551aa2ae3"
+      }
+    },
+    {
+      "radix": 5,
+      "prime": 5,
+      "prime_exponent": 1,
+      "ramification_degree": 4,
+      "primitive_powers": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "coefficient_valuations": [
+        4,
+        3,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          4
+        ],
+        [
+          4,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 4,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "001f67e6555914bfd7b1e0073afce578d2a696163af31833b391096f5ede16ee",
+        "2": "f601fc23cb7b115a680fb1dba0d030e1367210bf4bf8da1108b710be0b9e25e1",
+        "3": "c86377c21349fc243fc6226a1ab680479a6dbf2fd46435b57445227c6481133e",
+        "4": "588b8f8a4212511587cb7ef69584510cb8cfeeb9840bd89243a5a996a1bc79e6"
+      }
+    },
+    {
+      "radix": 7,
+      "prime": 7,
+      "prime_exponent": 1,
+      "ramification_degree": 6,
+      "primitive_powers": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6
+      ],
+      "coefficient_valuations": [
+        6,
+        5,
+        4,
+        3,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          6
+        ],
+        [
+          6,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 6,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "9ec008f3c6a6606951978e88826115be0c4460b1e27868f757f2d336a064112a",
+        "2": "3cdfac6f3424528963097c10e8405df5bc8a8fd86fd32646630ec20e4f9b394b",
+        "3": "13bbf915b998b786dacf9e002b2fcdb30f4bee2cdc8189567c0e639e7cf42763",
+        "4": "5e0394fb9a3ef8f7c65597760f2197681d9eca87b5a4ced654bc4142b443a042",
+        "5": "8126a9009825b1c76c68b7e8aa1ad3e95bd3604e05e3b5fa9f2cdfc7c73f4c68",
+        "6": "85746c9b20018d52198132d589012dbd68ba64845b4f9588d0a524677ea32121"
+      }
+    },
+    {
+      "radix": 8,
+      "prime": 2,
+      "prime_exponent": 3,
+      "ramification_degree": 4,
+      "primitive_powers": [
+        1,
+        3,
+        5,
+        7
+      ],
+      "coefficient_valuations": [
+        12,
+        11,
+        9,
+        8,
+        4,
+        3,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          12
+        ],
+        [
+          4,
+          4
+        ],
+        [
+          6,
+          1
+        ],
+        [
+          7,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 4,
+          "valuation": "2"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "3/2"
+        },
+        {
+          "multiplicity": 1,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "05bcb596e8f8a3bb0d1d0e45bca14bc505e9a66853d2f1c2ddfb2ebde17804a7",
+        "3": "76ba49778fb4a5f764bd447acb20145b3133850cc3e79ffba13fc997a530c806",
+        "5": "da254097e5a641601d612b9c2ef4297a8d58fbd8d3cf334e9ee8c31d1d4b6c6d",
+        "7": "dcc144109f5c2fb0043a783d24d1596d1c92b6bb4211525f1f57e7a3ed6ae701"
+      }
+    },
+    {
+      "radix": 9,
+      "prime": 3,
+      "prime_exponent": 2,
+      "ramification_degree": 6,
+      "primitive_powers": [
+        1,
+        2,
+        4,
+        5,
+        7,
+        8
+      ],
+      "coefficient_valuations": [
+        12,
+        11,
+        10,
+        7,
+        6,
+        5,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          12
+        ],
+        [
+          6,
+          2
+        ],
+        [
+          8,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 6,
+          "valuation": "5/3"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "0001c28206234a681d0a4335c0334fb8bf2f4a4e6b3673e8f0a830dfbdd83676",
+        "2": "d668ae6544fbfdf01a4551b7636f2aaf509191229dd10f45738930989eeab23e",
+        "4": "55047ed48701f3916cf2479ce5989b6540bd42a796d9848312d8d937b8b5429d",
+        "5": "a977f4da9ed9e2aa0abae422b647092992f53392d00a40da464dbbe2c20eb4c0",
+        "7": "82fe8dede079b4757ee94def3e758addc1cf2e882305b556310af2db6355c78d",
+        "8": "1453639f4b1678b324de85f461adc037adf30e6d41ee50916a46aa11302c8fac"
+      }
+    },
+    {
+      "radix": 16,
+      "prime": 2,
+      "prime_exponent": 4,
+      "ramification_degree": 8,
+      "primitive_powers": [
+        1,
+        3,
+        5,
+        7,
+        9,
+        11,
+        13,
+        15
+      ],
+      "coefficient_valuations": [
+        32,
+        31,
+        29,
+        28,
+        24,
+        23,
+        21,
+        20,
+        12,
+        11,
+        9,
+        8,
+        4,
+        3,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          32
+        ],
+        [
+          8,
+          12
+        ],
+        [
+          12,
+          4
+        ],
+        [
+          14,
+          1
+        ],
+        [
+          15,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 8,
+          "valuation": "5/2"
+        },
+        {
+          "multiplicity": 4,
+          "valuation": "2"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "3/2"
+        },
+        {
+          "multiplicity": 1,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "94a2078f71c60cd02352193719250c25dbfc9c91239af6f89ce984990a22c383",
+        "3": "171fcff5b942e255b8e345d011feffc4b19b119ed4d0b7bb8336e5f44f4b5eaf",
+        "5": "0213d906aecc9ac38bfa1ca94a659f329cf3a4beefb96b5c51430c6e6530c532",
+        "7": "4ba49fe7e68dfbaed42df816e7d24bfd1be67222ff47f8577fa9f14c44e76687",
+        "9": "db440f1d979c3bcb9c29d5834dce248274103a4ddec5827d338877f64ac66b17",
+        "11": "07251f5c6f46847428f312d9348c2b946d081b2b9ac55cf959af13711bc30b28",
+        "13": "f3f4b8ba4a8ce2f90a7eba1cb181829084d57008e1a7c3c0718e3452cb80791b",
+        "15": "5f1aa3c2fa941948cd8201332aeb3507adb1e648ee5c4e342c575beaba180345"
+      }
+    },
+    {
+      "radix": 25,
+      "prime": 5,
+      "prime_exponent": 2,
+      "ramification_degree": 20,
+      "primitive_powers": [
+        1,
+        2,
+        3,
+        4,
+        6,
+        7,
+        8,
+        9,
+        11,
+        12,
+        13,
+        14,
+        16,
+        17,
+        18,
+        19,
+        21,
+        22,
+        23,
+        24
+      ],
+      "coefficient_valuations": [
+        40,
+        39,
+        38,
+        37,
+        36,
+        31,
+        30,
+        29,
+        28,
+        27,
+        22,
+        21,
+        20,
+        19,
+        18,
+        13,
+        12,
+        11,
+        10,
+        9,
+        4,
+        3,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          40
+        ],
+        [
+          20,
+          4
+        ],
+        [
+          24,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 20,
+          "valuation": "9/5"
+        },
+        {
+          "multiplicity": 4,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "b4af27c3e641961b53f5fd6728e3c3b7e15efde9fec8df9111c6deeb0081211d",
+        "2": "a2c90cb322ed78be804a78b5ed3d0af9adafda024c1af2154c88affbfb44b723",
+        "3": "76dbc5a16a8531576a9e2d4280aec34e55d4f0951361df9506708d3cdd6cb9b5",
+        "4": "c3102131f08087005d48b16e1bb784ab6778cbf476728816f01be95bb551ce30",
+        "6": "d69c679998e6004d35fe33fb3b3fab271b5362da90414f049b0fa16aada0875c",
+        "7": "a2c3a0ac60e1ff437f04c8198f826bb7b048add068e937095d9fd9bb2ea4cc6d",
+        "8": "e392fb8e61403bef939f7a5f9f3138bae1b4e20e0d8f57357730a87e690aeec8",
+        "9": "2810b86364f9547b64ea30bb0f4d712d946751de2179bb09971aa22add414b7e",
+        "11": "bce50f429ad5a28ec205872f7932b5fd5015d8195520cdc06e4c7cfa47cfba1d",
+        "12": "c09241ac7d47b88b97d809f30de648358ba41f39db9bac594f798124cc0a7d9b",
+        "13": "ff6d808535bcd6dad3a8184185824eb5bf6661dd17055052448305595a29b010",
+        "14": "903f2abb486d7f82ac54e2619ac456c879d6d0d5b9197a1824c332ba1fe14f09",
+        "16": "3b9b658960cda4212d320f5031b2c1d06d5eab2acee7eeab886401400da24692",
+        "17": "4e8ad80540805eee0a16ad3fa1c87697e06df739a840bc74826b93bcf08e8259",
+        "18": "d1ef32a3b6978613bf2c5191f511317b9939ea8b1b4ea57f155ebf939d317422",
+        "19": "8411d9cbc1e60de6a45790f268235e424c0dcd92d64088998671eff16d11450a",
+        "21": "0af68da8b57a821fb41ecc4264dfe378f4719088afa058e9dd574df0e0a244a3",
+        "22": "e534de13da53737ea561bda643d329ba5658a260aafae7d312e2a5ff489f0696",
+        "23": "09873d9f30d1b8cb243b5f6ef3997a6d9a40838f46c85a6df1551eb2e743d477",
+        "24": "97e8a26cbb74c423f8fae7fee8e8811b35afc5bc6805732d67d2af330259d1cb"
+      }
+    },
+    {
+      "radix": 27,
+      "prime": 3,
+      "prime_exponent": 3,
+      "ramification_degree": 18,
+      "primitive_powers": [
+        1,
+        2,
+        4,
+        5,
+        7,
+        8,
+        10,
+        11,
+        13,
+        14,
+        16,
+        17,
+        19,
+        20,
+        22,
+        23,
+        25,
+        26
+      ],
+      "coefficient_valuations": [
+        54,
+        53,
+        52,
+        49,
+        48,
+        47,
+        44,
+        43,
+        42,
+        33,
+        32,
+        31,
+        28,
+        27,
+        26,
+        23,
+        22,
+        21,
+        12,
+        11,
+        10,
+        7,
+        6,
+        5,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          54
+        ],
+        [
+          18,
+          12
+        ],
+        [
+          24,
+          2
+        ],
+        [
+          26,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 18,
+          "valuation": "7/3"
+        },
+        {
+          "multiplicity": 6,
+          "valuation": "5/3"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "317f8e4df3740488b60c57efd969e8d38ba7b089d3a9d9ca9a520c14546a1b37",
+        "2": "78bd8899f141d4aab2718c34ce00b350541de4b632a72b4ceec8bde672f55454",
+        "4": "d92058c75df12612fc0cb1f4dbe59a606e1d947b2f908d5b90ed754d4af91fef",
+        "5": "11e2fe9d31309d213388461cd218248acac08fa482f6064ffce89364446fec03",
+        "7": "4261d1587b32e6d52d458155622b16433ce176873318695eb89c162c18d33007",
+        "8": "57c76de6ba3e88ea1de3f653de3781efe8f8d3e471f6913039c0ce6d75e0e356",
+        "10": "97bffb7aa03c7b23b0a97e6db4d69f16ec469b799739d737b634f10e94282a42",
+        "11": "22543670fbc417c45cd42ee62b8e7972e2b9dfdd7be1ca36a12b3c743870f25a",
+        "13": "2dce4f4236a5f4d680d9362c3f134df57ccef6821b1e4ac20dba06b1adbf7d29",
+        "14": "785c3143dbb1bd2f93e5a3dd881e809966438ca24f7442eff258cbebe5c1eee7",
+        "16": "09588edf215b89bd4b9be522fa891e4901aa826053e24fe1cad1fa2c6bdddfe5",
+        "17": "bc589bc96e2c2448382b0fe9e1185d46cfc2d468f81a63bc59794241d7800413",
+        "19": "ca170fb97863991e374974c93931c653c8d314c8ebd491dfbb6363e87a333c1f",
+        "20": "086b23743e0d26e8759e63b5380184ef203862912878179fb88a35b0c7f07031",
+        "22": "8ca3f52326b5292ebb14d1a73537422bdc2a7329cbbd2fae06b2438a98fb2e1f",
+        "23": "24fd60bed3b28980fdc3e1857de034eff8691028e8e7a045faab3dc936bf921d",
+        "25": "1fdfe3b9eb7fa1dab5f7852a216efcc9520e1859361b5193ab9e558b4bb0ce25",
+        "26": "16164c2ffeff631301b193243f179e237732703da53220206ccd6fe1cecd7b98"
+      }
+    },
+    {
+      "radix": 32,
+      "prime": 2,
+      "prime_exponent": 5,
+      "ramification_degree": 16,
+      "primitive_powers": [
+        1,
+        3,
+        5,
+        7,
+        9,
+        11,
+        13,
+        15,
+        17,
+        19,
+        21,
+        23,
+        25,
+        27,
+        29,
+        31
+      ],
+      "coefficient_valuations": [
+        80,
+        79,
+        77,
+        76,
+        72,
+        71,
+        69,
+        68,
+        60,
+        59,
+        57,
+        56,
+        52,
+        51,
+        49,
+        48,
+        32,
+        31,
+        29,
+        28,
+        24,
+        23,
+        21,
+        20,
+        12,
+        11,
+        9,
+        8,
+        4,
+        3,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          80
+        ],
+        [
+          16,
+          32
+        ],
+        [
+          24,
+          12
+        ],
+        [
+          28,
+          4
+        ],
+        [
+          30,
+          1
+        ],
+        [
+          31,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 16,
+          "valuation": "3"
+        },
+        {
+          "multiplicity": 8,
+          "valuation": "5/2"
+        },
+        {
+          "multiplicity": 4,
+          "valuation": "2"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "3/2"
+        },
+        {
+          "multiplicity": 1,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "f66fb28b4ccc198bc122680ae5177a0cbb13882598a31cd1828f1f923345b783",
+        "3": "db7da1a57fff7e2c205b655c9c04caffb7da7b8b867e0afdf41a47f21f7b12bd",
+        "5": "70f4c52538927d58853633bf2d15faa5fb05ecda971af22a739b0a6a44348df1",
+        "7": "5ed821d94f86d6daa47938f3b7d52673d38eb8f09500c07c06c755c97d1672f9",
+        "9": "fffe52da7d2cb94c17f83cdb9c573429227ebc0c065ea6b9b4de4cc86f474111",
+        "11": "7dc76cc9ad95c52c8513cae9b770a9c20ecbd5fb47345cdda65dfcbf356665cb",
+        "13": "95a6537b3e0991e79652359561c0734e720ef2ebf61e43689025a054744c7c4d",
+        "15": "53e11bf5749a5d587fd3220539c8b39b517b3c8488c9b3b4f135f1a40783cc99",
+        "17": "1fdbd793b7d9fcdd46881b3ed564fa2955fec6e9709c7b18f71e8faab95c132f",
+        "19": "a21233b385817c2d44641754b94b49ff5b3407a06a6e9f6bba6deba42d0a1e5e",
+        "21": "5406e57d3d8a25b6f50114aedcc3fcf3da0c421d0653b33c3d509fe1ad940ba7",
+        "23": "cf84e7193faa84780b7eba760748847fd7db6ea8d3d3207e0b8aff20fa173246",
+        "25": "29dd1e4bdd206f084064e0e1a90f669a2ecc10ce9a50d821232a13c6ce91531f",
+        "27": "846b48560f5b32d619897d0db0cfd062c7518115674802739cd962cd5a247afa",
+        "29": "c881d4070afd69f5c194b26730a2ef4ff881d0cd522f8ca8095fe241531b9c0a",
+        "31": "d8fecd671ff4220d7dbf796bd4994d981a79e99e65110bd3210168c9b71375ab"
+      }
+    },
+    {
+      "radix": 49,
+      "prime": 7,
+      "prime_exponent": 2,
+      "ramification_degree": 42,
+      "primitive_powers": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        22,
+        23,
+        24,
+        25,
+        26,
+        27,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48
+      ],
+      "coefficient_valuations": [
+        84,
+        83,
+        82,
+        81,
+        80,
+        79,
+        78,
+        71,
+        70,
+        69,
+        68,
+        67,
+        66,
+        65,
+        58,
+        57,
+        56,
+        55,
+        54,
+        53,
+        52,
+        45,
+        44,
+        43,
+        42,
+        41,
+        40,
+        39,
+        32,
+        31,
+        30,
+        29,
+        28,
+        27,
+        26,
+        19,
+        18,
+        17,
+        16,
+        15,
+        14,
+        13,
+        6,
+        5,
+        4,
+        3,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          84
+        ],
+        [
+          42,
+          6
+        ],
+        [
+          48,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 42,
+          "valuation": "13/7"
+        },
+        {
+          "multiplicity": 6,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "98c221cf538c844bc50bccb3d5778898152f4b8cd0fb83f132bb67d3eabd1639",
+        "2": "956b4e7747aaec210fe5ab45c5ec8239fa6fc2e2cf4c60de96b50c62eaf7dce0",
+        "3": "31d3558d131f2cbf8bc30ac9d44e53f573f84b33dafd63999f8b05d8dba210e7",
+        "4": "318105da9261f371f3867812e2ecf1e65816e975fc3d5cce1d2f464d73ce3a64",
+        "5": "c125f3b59d297ed5b30771fb2ea573ecf0ccc79a40cfbe6d541e41f703b69831",
+        "6": "025ab27063434c145113d65b70b087836508c6ca828a7604c91a1fd539e6940e",
+        "8": "e36df4153a385b743ce88a54e71a3d88fd69b9514be5505ca0e912ca3c23afbc",
+        "9": "f217505abecdcd7ae4fa94daa40bfbaa767dc8fb4d4726c8f38962cd817b724a",
+        "10": "74121ec4f9b40f4cca5f791ab1460b767d199d538cbfd8bdf6f8c85d149208b7",
+        "11": "df709a32a19930606321524d212c710990b6e797774365bf1e5e269e7f22f29a",
+        "12": "495af959f7ea9b84aebbd5d481956d884b82d0616d32dc5bd9ef086c9585d317",
+        "13": "47882ad5cd93e8eb1d2897603b44578ff8ac5c53f27fe3411baa5a7d750d9c28",
+        "15": "ae3221b943f13c9faf289227b7dd10b421c62daf71ce25a7cbc7cc3fef073911",
+        "16": "8f538f8f78c68f36b38421f63dc7e966d36b45c0aa9416aabbb63813710ad2f4",
+        "17": "9d07512706da18c4cb14099b42512822270ffb6b36a797cbd66b514ab77ccd72",
+        "18": "cc78a8353033060878b4e279c151454ff38a998645c273430414e717e54ecea5",
+        "19": "0cdda057f8e76b57c1691d117e26a62eb71fedd38f0848c91c422cc615e27e77",
+        "20": "a33f2ac6f47e55144b1b742483de15253530f612afbad95e2e15d2f4279fd841",
+        "22": "d66c91208b0eb58409cebde7f728f6a192e75c5bba8d6e3dd4be027046a20832",
+        "23": "e59b72234f3873947fae92af33ef038532e9c264cbba35d1283200a5bf520efd",
+        "24": "f4d8dd1b18ba4268d26f976cf922f8af0208737c6b77a1a7cec4534ec6e651a3",
+        "25": "c6cb647880d80e973560120e246a9133ad86dd36cca01a72d059e00a6f64b779",
+        "26": "06bd60502cf3bce1abd31860bdd3c9016f67ebde9c8fb3367a4d8462b0d37dad",
+        "27": "5c22a921732d6118ee14ecca48b3536b851a7ef4ac6b3a05a24e3020ea5a2e55",
+        "29": "c3946412ff9d61b5ec12b10e6670ced32210ea8765d07f7da91d28b55807c27b",
+        "30": "5b1bdf3b9666c42667655b8435a89b5bb4ffe8c02676f67fbdf70c79ff166d05",
+        "31": "dc6ac978493c21cf7ade0b5b1fc88d60ede6125dcf71e92b552a0331b5e08077",
+        "32": "d2d70c25a2c2a90ec2ddcecde7d2eb8d5314d98950ff231174d69f068410f570",
+        "33": "a5cca1d9fe3520653ef06fc9c87665ef2bdc6b32e0a0922c16cd04ac2dab2fb9",
+        "34": "e0519e043ced5f7859ee61c17d0fef88cf5b667c3e05350172479fd6f32388ae",
+        "36": "acb6a25ef645a5f287cd5c5cd2eaf78a960eb46499bc41bb61d2e68a2de73826",
+        "37": "c2d580b49045834e24e5bf2a1c86e17a64d9e8d5955125e4ab0afc8fb220a664",
+        "38": "fe74e9093a572a6967f5fc77b9db93ba46d56d93989b73ae6db86fb9e5231fc9",
+        "39": "2ebd84e878c6cd3356a05c36caf601ac4a139c7abf597c945714ec2c2e16fe07",
+        "40": "cfb91caaf9736da69291e2eee792cda26ba6e62670ac2069947ecc198e260f57",
+        "41": "3fec24ebe84d24c173db011e51dd64168f74cb17e42fcdc6824ef6ef80642159",
+        "43": "7b9b5c20b34345e36b7f44bc57aba660ff30797bcf03711b04c24e123da09313",
+        "44": "33fd2754eb1c7b19cef8164b6f58ebfb1dc6dadc50daf50034a6830589b23b68",
+        "45": "fa3487d5568b3ef2140e7a537dddb758c8f9aa588538ca2dfd70e7b85d764c32",
+        "46": "66a95f7c9b183863da38b4fb8cd2e4f81edb72dab2469743a5a45095dbcb1018",
+        "47": "bb999e115c810dc5290c0614119560eaeecc0f17bc4eb80e112e36ccbed55770",
+        "48": "88d1927806b886ec481a706a3e9a4f08013424848cdce8b2dc3cb55fb6cdf519"
+      }
+    },
+    {
+      "radix": 64,
+      "prime": 2,
+      "prime_exponent": 6,
+      "ramification_degree": 32,
+      "primitive_powers": [
+        1,
+        3,
+        5,
+        7,
+        9,
+        11,
+        13,
+        15,
+        17,
+        19,
+        21,
+        23,
+        25,
+        27,
+        29,
+        31,
+        33,
+        35,
+        37,
+        39,
+        41,
+        43,
+        45,
+        47,
+        49,
+        51,
+        53,
+        55,
+        57,
+        59,
+        61,
+        63
+      ],
+      "coefficient_valuations": [
+        192,
+        191,
+        189,
+        188,
+        184,
+        183,
+        181,
+        180,
+        172,
+        171,
+        169,
+        168,
+        164,
+        163,
+        161,
+        160,
+        144,
+        143,
+        141,
+        140,
+        136,
+        135,
+        133,
+        132,
+        124,
+        123,
+        121,
+        120,
+        116,
+        115,
+        113,
+        112,
+        80,
+        79,
+        77,
+        76,
+        72,
+        71,
+        69,
+        68,
+        60,
+        59,
+        57,
+        56,
+        52,
+        51,
+        49,
+        48,
+        32,
+        31,
+        29,
+        28,
+        24,
+        23,
+        21,
+        20,
+        12,
+        11,
+        9,
+        8,
+        4,
+        3,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          192
+        ],
+        [
+          32,
+          80
+        ],
+        [
+          48,
+          32
+        ],
+        [
+          56,
+          12
+        ],
+        [
+          60,
+          4
+        ],
+        [
+          62,
+          1
+        ],
+        [
+          63,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 32,
+          "valuation": "7/2"
+        },
+        {
+          "multiplicity": 16,
+          "valuation": "3"
+        },
+        {
+          "multiplicity": 8,
+          "valuation": "5/2"
+        },
+        {
+          "multiplicity": 4,
+          "valuation": "2"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "3/2"
+        },
+        {
+          "multiplicity": 1,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "f526382acb023ac09b6ec3f50571bf5f28afa432417dea0537af120b5e71ad5f",
+        "3": "7124175ba16742a1bf4661b4ce97816dace4e0e867cb814b8e893ea5d5779e72",
+        "5": "3de472defe493b85e1fb59abda0f11a940e74dabc1241b64058e11ecaa653f25",
+        "7": "2b62cb39c05312241ec0c5b7700d2f3e764644486c1a02153dde1c2956631c15",
+        "9": "f8f7c7a699e070fcc3a98d431e38d9941d852049ef67d4c85d1d9d334b2c3dc6",
+        "11": "03fc04c083a13587d51b06cde03099eb77b295a698f981044f70af2e40e2497e",
+        "13": "25d7ec7d3c3b476df4e7467d9c0a58fe65b4dd8b570c30f0ae1d6eb12daa3935",
+        "15": "71c7db64fe23f9398520395d5fad0f0f069af0d609625c4f4163d2bd3b77850e",
+        "17": "0f2de8898743ef5102b2f872706732e4a5df2fb6a02e78128901a6101bbba006",
+        "19": "8a4b2f1e286c57c80fdb7a37c76b3dbab04f831150cd531d2b8830180d4d5c83",
+        "21": "c8f6fd3b25c8ccfd31bdd65b306c287200899ce95497e97c5fbfdbb2a60081b1",
+        "23": "d606c99059c97434bc52429582ec7ad567315e3ee309cd2e7270fc1c2438b3a5",
+        "25": "60a6c9e30524f4108db11f3d781c9c2cebe55e554edc2a2b42531efdbd656238",
+        "27": "6fd89040534683c2737b368009919ea4ebe6bcc6f990fccf4191fe96cf7d6afe",
+        "29": "a257cd7c6df1113a051d69ccf26ff9e03481f0f958cbf30a629cb9aae07eade4",
+        "31": "8c0ad88831ed13164cef4541438fb6fdaebe296506c6a8670f30fff30f041203",
+        "33": "2b34429f6491d4e9236410aac317f5f0a088fa806e531acba4401f88e6ab289e",
+        "35": "363fc471d850cb9410301a0f9dfae979bcff4fc526dd20c89f110dd4651edc5a",
+        "37": "fb11e9228ac09c6f0db4ca77693e78e95ad62f492690c0ec3896b4d911a2b592",
+        "39": "4bdaebd2a7c5877dabae66dbb17f5adacea888b19c43e556011958c8904de2eb",
+        "41": "cf41b91b0057580703748adb24770aa7a515dc6c40057c819187ee5781dda6b7",
+        "43": "4eb349917705b7bdbd89998e2e7126f2b8bc446e6f26c63a053e6ccd5c66ac04",
+        "45": "9da99439b2f72771edca336e65a8565597eb3b81b3fa50e5c03d493d09e98dc7",
+        "47": "91e8c8e43713ee83faa3d0ea3abf51f11d28926243013b548f5f72e088587759",
+        "49": "1baff41ab71b93fc46e3c6fb63a631973e12a0ed9832edfc50877cab447b14c1",
+        "51": "9c2c4d784fe639219e8bb12cc8d833c5728f2ff90ca338dd48fddd1f5af2d082",
+        "53": "398106f5bf986312b3f7613f47388b90160813bdd491d5cf44d82b517cd1bcfc",
+        "55": "33d9975127f61ac19ada49ca0a0aceec8b21c23795f520c7911c5855af2ba621",
+        "57": "3bd3c1f869fb0095be4cc9e7a3557a65ac8d3b13d7f89d74bf33fc71055ee656",
+        "59": "358f2e6b17de6a01cf1316597b02f781bc3bca6d94691f425228e8c5a4c6633b",
+        "61": "bdbff641cc819e7e9690471789798e615c7bca47f3250f4fd21800fba684b623",
+        "63": "238b82f5fca97e3dc14e5bcb43d76fcb6698e01e6902bf4e7b777df0504e9605"
+      }
+    },
+    {
+      "radix": 81,
+      "prime": 3,
+      "prime_exponent": 4,
+      "ramification_degree": 54,
+      "primitive_powers": [
+        1,
+        2,
+        4,
+        5,
+        7,
+        8,
+        10,
+        11,
+        13,
+        14,
+        16,
+        17,
+        19,
+        20,
+        22,
+        23,
+        25,
+        26,
+        28,
+        29,
+        31,
+        32,
+        34,
+        35,
+        37,
+        38,
+        40,
+        41,
+        43,
+        44,
+        46,
+        47,
+        49,
+        50,
+        52,
+        53,
+        55,
+        56,
+        58,
+        59,
+        61,
+        62,
+        64,
+        65,
+        67,
+        68,
+        70,
+        71,
+        73,
+        74,
+        76,
+        77,
+        79,
+        80
+      ],
+      "coefficient_valuations": [
+        216,
+        215,
+        214,
+        211,
+        210,
+        209,
+        206,
+        205,
+        204,
+        195,
+        194,
+        193,
+        190,
+        189,
+        188,
+        185,
+        184,
+        183,
+        174,
+        173,
+        172,
+        169,
+        168,
+        167,
+        164,
+        163,
+        162,
+        135,
+        134,
+        133,
+        130,
+        129,
+        128,
+        125,
+        124,
+        123,
+        114,
+        113,
+        112,
+        109,
+        108,
+        107,
+        104,
+        103,
+        102,
+        93,
+        92,
+        91,
+        88,
+        87,
+        86,
+        83,
+        82,
+        81,
+        54,
+        53,
+        52,
+        49,
+        48,
+        47,
+        44,
+        43,
+        42,
+        33,
+        32,
+        31,
+        28,
+        27,
+        26,
+        23,
+        22,
+        21,
+        12,
+        11,
+        10,
+        7,
+        6,
+        5,
+        2,
+        1,
+        0
+      ],
+      "lower_hull": [
+        [
+          0,
+          216
+        ],
+        [
+          54,
+          54
+        ],
+        [
+          72,
+          12
+        ],
+        [
+          78,
+          2
+        ],
+        [
+          80,
+          0
+        ]
+      ],
+      "root_valuations": [
+        {
+          "multiplicity": 54,
+          "valuation": "3"
+        },
+        {
+          "multiplicity": 18,
+          "valuation": "7/3"
+        },
+        {
+          "multiplicity": 6,
+          "valuation": "5/3"
+        },
+        {
+          "multiplicity": 2,
+          "valuation": "1"
+        }
+      ],
+      "coefficient_sha256_by_power": {
+        "1": "7d3f63572991032dd0ce427df71893020e29cbd1206edd7ea85c2bcc51f19bc0",
+        "2": "950ab1f083c93e4470ebfdf038a2594a1cb60ca4b1f60c1b8bdd6a7aa0abaacf",
+        "4": "3ea76f750fc7596129f856c24bf9e0a29c7640a859415b3030f4d2dc39d71418",
+        "5": "f34b759c0b52a2030b2d4fb093b14bf65fbd01469561f104c9ec3835eacb7e9c",
+        "7": "b22cf6e0884d2b46b0d1952a5e8945c6d782f69ae31fd363dd56514ba9e02fbc",
+        "8": "753a2ad345e861ddfdf741cc608d3813af791dffd68c44edfd8682d4af5efdf7",
+        "10": "4cb4aa34f6b59ff277912122796de8c302fa9e3f9eb04bc9b7142835812ef27e",
+        "11": "324d08775976e0872d5c8a811eba7250ff2fdd28fc658ae0a5e2cfe3c6a4e825",
+        "13": "5346efc3a84b10bcbabdbeb4011540f142b9614b484881b1a0998720527a673f",
+        "14": "7aff84b12457db10fddd17d130ebb1d1dbd81ed95297275f2544f5b730f4a6a9",
+        "16": "177b499feec12dd2f29e7f7a1f91fbd03d8c485bda7722c2c64bb06ed81693e2",
+        "17": "d4f85b6924667210ef572c5991f08a7184ca5039af0a7baba0b370aa8e61b12d",
+        "19": "bce7091e9483f46b0157a20a6e6af5a1a5b0ebee5be4ddbe9a6d2b53f469a630",
+        "20": "7e9d739a889727831fbe3188e84e26746a7bbca5b6cdb647fe15cbb0f4394d05",
+        "22": "a4a115ad5d14265a43a036669138583685e2b85053feb0b60081e1da68cf0c87",
+        "23": "5d7ce3e5178b1cb072a22726322139d1afd2b83e4b733145ab786ee9e074d650",
+        "25": "0d08050e992e5b96f36159a9807ddad67a4612bbd9c55c270880588449e63b0e",
+        "26": "f3ac51de9069e87965901baa5ec5231f907f6efef7c7b04e9539d0b23d732fd0",
+        "28": "bfe51d71a8ba572042134bf4b3ebd586387d8f1bd4a282836c22b70a69ef222c",
+        "29": "4186178481e79d9362b3cf1ec333fc96ded19426611960870aa151779ac189c3",
+        "31": "a5bd9cc5685458f102436d7002dc846ab5ff5c2c2fb7afedfe27512d78088836",
+        "32": "63f66f3b9ca709f84488fa42a7ea52922447940ff27cb25a683b773839c6c8ea",
+        "34": "05d4ff8c0fc51380035e2d6634f498a83624173874195fed106140727179ac9b",
+        "35": "bdd86b99841ead30bdec1c2e2f8c04bc5f4dd0eedda4a4d61166cb6f98dee450",
+        "37": "a027ebc0155d6da873ade6e952b41704ca59f448e882c9f673697776bfa6e94f",
+        "38": "fde1cfda75ebaddd8a0c505ee7fc111d26c358152b2d3f0c58d907d00ae1a440",
+        "40": "483f77cb1f165fe2be73bbc968c092f13d03dec7611c7cadccdea992c6148ce5",
+        "41": "9bfc3cd81d66b1b3680f369175260421285e2c7165448c68eca6496a24008838",
+        "43": "268a47228c38b3a169cb0b0cf4997542b8440a17d3cd066f6ce0de90eb777769",
+        "44": "236a5d1a3333c9a09ff6a18960df8a11cc6c8eaedd6316aa9eba17e0ea5218a6",
+        "46": "80e535bca507a236e6bd17b942affb82e344112a25049ef5f0acd307ca78e33f",
+        "47": "68901ce55a2ba74503c0cc60d043c5a2d9b31959c5da9654ab30f0b89824b5f9",
+        "49": "1639d04a18c571c4dc8213566df5dcbfbb09ea5751901a287b82ad05993d7074",
+        "50": "3a7c2ad619b309dbd6c49bb7c1ddd24a27c98e4870fd2522098bcac86fa199ab",
+        "52": "75798669a050755d6f2fa9d9c0c314f837fd85d7b51da132eaab4938b9d85bbf",
+        "53": "b08b0082282ca80c65b688b67ea138eb3b4fbd2174b1a850f3d1b805ae4bf7e8",
+        "55": "62cb9470b8e9582edf16bc98eb6de18e80ff7dd4eb92876e30c63c4b6add209e",
+        "56": "09d38d2159d18366ac73a826de1b3333ab16eca61a1dfe3298b0e9c04fcdec44",
+        "58": "8a9962c112d457057f4e5b56707e8ed60b28cbee0e870564c83e390b85f692b5",
+        "59": "87b35161e673ed5d64966df9504ed718f00ed6c109864142fc7c965ddb557dd4",
+        "61": "a236f48c699e9ca2b5ed701aba49cae1ac11e2addc80d976ba5f3359edeb871d",
+        "62": "4e8709a8b21bbe992cfed4a357c12e56b98c46ff24362ebd65c9ed42aa1421ac",
+        "64": "b1f45bae35b1eca23351240f534a8ae5d2bf3607be36ea97fc8c099286eb12bb",
+        "65": "50c154532d244bda22e0c20c1e3dbf8790e2732a315c37e1b0590c64450f0fe8",
+        "67": "3844f5e4dbc688a50a6798af9d498ae46120287da6adcbec460ae5921e6b0432",
+        "68": "95e25050ca06c7a029ce094b7b38a87c157d78931343317cb9436e1500cd0898",
+        "70": "844944b159d306daf7dcde2f7a9755484db5f450fad25f522e2cb5654cc4aea4",
+        "71": "bc3f04343e230540d8ff6685133898e1136cdda643f24ac3c95a76fbbe294b68",
+        "73": "364236d637a23448013b50c97396cf2c751836abe692f0791a8b6a6dc367580f",
+        "74": "940513151f0cdcf432e2151d8b148a3275cf4e4d463605a816458c056039782c",
+        "76": "f973afdaba28f950a522c8e2c56c8fc6a6960b98b2691a434bbd4860197ecb30",
+        "77": "206d6f103e75b83f15d909c00f50c02839d29af84f9cf93b538e7451ad7cf286",
+        "79": "ac20484d00cbc0a7480fbb658782aef22926ee5b16396bc313593249b6ca2745",
+        "80": "62781e5526b2dfabf6b3c1560cd76647d2ade25e402b7eb864e2b35f5c75a666"
+      }
+    }
+  ],
+  "negative_controls": [
+    "nonprimitive_4_2",
+    "nonprimitive_9_3",
+    "invalid_radix_1",
+    "invalid_radix_12",
+    "same_ideal_residues_wrong_valuation",
+    "omitted_tail_factor",
+    "unit_root_polynomial",
+    "zero_coefficient"
+  ],
+  "scope": "Exact finite coefficient and polygon replay; not an archimedean root bound, paid inverse program or multiplication theorem."
+}
diff --git a/research/prime-power-newton-valuation/NOTICE.md b/research/prime-power-newton-valuation/NOTICE.md
new file mode 100644
index 0000000000..0c84393919
--- /dev/null
+++ b/research/prime-power-newton-valuation/NOTICE.md
@@ -0,0 +1,36 @@
+# Attribution and license
+
+Prepared for **@navinor** with substantial **OpenAI GPT-6.1 Sol assistance** in
+research, mathematical reasoning, implementation, verification and writing.
+A scoped AI worker independently checked the written valuation/polygon argument;
+AI code review is recorded in the validation note. Neither is human peer review.
+
+New material is contributed under the repository's **Apache-2.0** license.
+No predecessor executable code is copied into this package.
+
+Ali Romman (@aliromman), [PR621](https://github.com/CrocSwap/integer-mult-bounds/pull/621)
+at `520774462b19b29af41554b74def31f9d01e997e`, supplied the prime-power kernel
+conditioning proof, integral tail-product representation and algebraic-nonunit
+conclusion. Those are predecessor results, not claimed as new here.
+
+The kernel originates in OpenAI's exact-DFT preprint at
+`openai/math@adc7f1241b42e322a6451854ab7e4b4c146bf78a`; PR621's source manifest
+retains the exact path, classical q-calculus attribution and earlier local-note
+context. This package does not import or relicense those sources.
+
+Related concurrent evidence was consulted and is credited: Scott Woolsey
+Biggart (@swbiggart), #668's CRT resultant replay; Jason Willems (@at1as),
+#666's composite Bezout/lifting package; Ryan Pinto (@Ambassators), #692's
+weighted-stride verification; and Chafik Boukhalfa (@chafreaky), #628's rounded
+cyclic scan and restoration work. None is a dependency of this verifier.
+
+Hao Yan (@FanPUYen), [PR796](https://github.com/CrocSwap/integer-mult-bounds/pull/796)
+at `22902155c7875139e43e4fdf15723142d6709bdd`, independently submitted the same
+root-valuation formula and an all-embedding weighted-minimum replay through
+radix 68. It appeared after this local claim but before this submission.
+The final source/receipt comparison explicitly corroborates its overlapping
+results. This contribution claims only distinct integral-divisibility evidence
+and radix-81 coverage, not priority for that concurrent formula.
+
+No literature-priority claim, new integer-multiplication exponent or practical
+runtime improvement is made.
diff --git a/research/prime-power-newton-valuation/PROOF.md b/research/prime-power-newton-valuation/PROOF.md
new file mode 100644
index 0000000000..4aa2a24925
--- /dev/null
+++ b/research/prime-power-newton-valuation/PROOF.md
@@ -0,0 +1,270 @@
+# Exact prime-power coefficient and root valuations
+
+## Statement and scope
+
+Let \(p\) be prime, \(a\geq1\), \(r=p^a\), and \(u\) a primitive
+\(r\)-th root of unity. Work in an algebraic closure of \(\mathbb Q_p\),
+with the extension of the additive valuation normalized by
+\(v(1-u)=1\). Put
+
+\[
+n=r-1,\qquad e_b=\varphi(p^b)=p^{b-1}(p-1)\quad(1\leq b\leq a),
+\qquad
+f(z)=\sum_{j=0}^{n}a_jz^j,\quad
+a_j=\prod_{s=j+1}^{n}(1-u^s).
+\]
+
+The empty product is one. Then
+
+\[
+v(p)=e_a,\qquad
+v(a_j)=\sum_{s=j+1}^{r-1}p^{v_p(s)}.
+\tag{1}
+\]
+
+Here \(v_p(s)\) is the usual exponent of \(p\) in the integer \(s\).
+The lower Newton polygon of \(f\) has vertices
+
+\[
+(r-p^b,\;b e_b)\quad(b=a,a-1,\ldots,1),
+\qquad (r-1,0).
+\tag{2}
+\]
+
+Its segment from level \(b\) to level \(b-1\) has horizontal length
+\(e_b\) and slope
+
+\[
+-\lambda_b,\qquad
+\lambda_b=1+\frac{(b-1)(p-1)}p.
+\tag{3}
+\]
+
+Consequently, counted with algebraic multiplicity, exactly \(e_b\)
+roots have valuation \(\lambda_b\), for every \(1\leq b\leq a\).
+All root valuations are positive. In the alternative normalization
+\(v_p(p)=1\), these valuations are \(\lambda_b/e_a\).
+
+The formula also includes \(r=2\), though the finite checker starts at order 3.
+This is an exact
+nonarchimedean refinement of the kernel and algebraic-nonunit conclusion
+in Ali Romman's PR621 [1]. It does not estimate complex root magnitudes,
+change any kappa, or prove an all-size multiplication theorem. No
+literature-priority or proof-assistant certification claim is made.
+Concurrent PR796 by Hao Yan [3] independently submitted the same formula
+before this package's final overlap refresh. The retained proof was developed
+independently; its inclusion does not claim priority over that contribution.
+
+## Eisenstein polynomial and root differences
+
+The prime-power cyclotomic polynomial is
+
+\[
+\Phi_{p^a}(T)=\sum_{k=0}^{p-1}T^{k p^{a-1}}.
+\]
+
+In \(\mathbb F_p[T]\), the geometric-sum identity and Frobenius give
+
+\[
+\Phi_{p^a}(T)
+=(T^{p^{a-1}}-1)^{p-1}=(T-1)^{e_a}.
+\]
+
+Thus \(F_a(X)=\Phi_{p^a}(1-X)\) has leading coefficient
+\((-1)^{e_a}\), constant coefficient \(p\), and every other
+coefficient divisible by \(p\). Its constant coefficient is not
+divisible by \(p^2\). Up to its unit leading sign, \(F_a\) is
+Eisenstein at \(p\), so it is irreducible over \(\mathbb Q_p\).
+
+For completeness, its root valuation also follows directly. A root
+of unity is a valuation unit. In the residue field of characteristic
+\(p\), \(u^{p^a}=1\) implies \((\bar u-1)^{p^a}=0\), hence
+\(\bar u=1\). Write \(x=v_p(1-u)>0\), initially using
+\(v_p(p)=1\). In \(F_a(1-u)=0\), the constant term has valuation
+one, each intermediate term has valuation at least \(1+i x>1\),
+and the leading term has valuation \(e_a x\). The least valuation
+cannot occur only once, so \(e_a x=1\). Therefore \(v=e_a v_p\)
+has \(v(1-u)=1\) and \(v(p)=e_a\).
+
+Take \(1\leq s<r\), and write \(s=p^t m\), with \(p\nmid m\).
+The same argument applied to the primitive \(p^{a-t}\)-th root
+\(u^{p^t}\) gives
+
+\[
+v(1-u^{p^t})=\frac{e_a}{\varphi(p^{a-t})}=p^t.
+\]
+
+The factorization
+
+\[
+1-u^s=(1-u^{p^t})\sum_{k=0}^{m-1}u^{k p^t}
+\]
+
+has a second factor reducing to \(m\neq0\) in the residue field.
+It is a valuation unit. Hence
+
+\[
+v(1-u^s)=p^{v_p(s)}.
+\tag{4}
+\]
+
+More generally, for \(i\not\equiv j\pmod r\), choose
+\(s\in\{1,\ldots,r-1\}\) congruent to \(i-j\). Since \(u^j\)
+is a unit, \(v(u^i-u^j)=p^{v_p(s)}\). Additivity on the nonzero
+product defining \(a_j\) proves (1).
+
+## Convex-hull inequality and attaining points
+
+Define
+
+\[
+W(k)=\sum_{s=1}^{k}p^{v_p(s)}\quad(0\leq k\leq r-1).
+\]
+
+For \(1\leq s<r\), \(v_p(r-s)=v_p(s)\), so (1) gives
+\(v(a_j)=W(r-1-j)\). Expanding each summand as
+\(p^t=1+(p-1)\sum_{h=1}^{t}p^{h-1}\) yields the exact formula
+
+\[
+W(k)=k+(p-1)\sum_{t=1}^{a-1}p^{t-1}
+                    \left\lfloor\frac{k}{p^t}\right\rfloor.
+\tag{5}
+\]
+
+In particular, \(W(0)=0\), and for \(1\leq b\leq a\),
+
+\[
+W(p^b-1)
+=p^b-1+(p-1)\sum_{t=1}^{b-1}p^{t-1}(p^{b-t}-1)
+=b e_b.
+\tag{6}
+\]
+
+Fix \(1\leq b\leq a\), set \(q=p^{b-1}\), and write
+\(k=q-1+h\), where \(0\leq h\leq(p-1)q=e_b\) is an integer.
+Terms with \(t\geq b\) in (5) vanish. For \(1\leq t<b\),
+
+\[
+\left\lfloor\frac{q-1+h}{p^t}\right\rfloor
+=\frac q{p^t}-1+\left\lceil\frac h{p^t}\right\rceil.
+\]
+
+Subtracting (5) at \(q-1\) therefore gives
+
+\[
+\begin{aligned}
+W(q-1+h)-W(q-1)
+&=h+(p-1)\sum_{t=1}^{b-1}p^{t-1}
+                         \left\lceil\frac h{p^t}\right\rceil\\
+&\geq h+(p-1)\sum_{t=1}^{b-1}p^{t-1}\frac h{p^t}
+=\lambda_b h.
+\end{aligned}
+\tag{7}
+\]
+
+For \(b\geq2\), equality holds precisely when \(q\mid h\).
+For \(b=1\), both sums are empty and equality always holds.
+In particular, both endpoints attain equality. Thus every coefficient
+point lies on or above the chord between the consecutive points in
+(2). The chord lengths are \(e_b\); (6) and (7) give slopes
+\(-\lambda_b\), also for the last segment \(b=1\).
+
+As \(j\) increases, \(b\) decreases, so these slopes strictly increase
+when there is more than one segment. The resulting broken line is
+convex, below every coefficient point, and attained at every listed
+vertex. It is therefore exactly the lower convex hull. Indeed any
+convex function below the coefficient points is below the chord on
+each interval between these attained endpoints. There can be other
+collinear coefficient points, but no additional vertices.
+
+## From the polygon to root valuations
+
+Here is a direct form of the Newton-polygon argument. For a nonzero
+polynomial \(g(z)=\sum c_jz^j\) and real \(t\), define
+
+\[
+M_g(t)=\min_{c_j\neq0}\bigl(v(c_j)+jt\bigr).
+\]
+
+One has \(M_{gh}(t)=M_g(t)+M_h(t)\). To see equality despite possible
+cancellation, choose the smallest minimizing coefficient indices
+\(i_0,j_0\) for \(g,h\). In the coefficient of degree \(i_0+j_0\)
+of their product, the term using these two indices is the unique
+term with minimum weighted valuation. Any other equally small term
+would require two minimizing indices, both at least the chosen ones,
+with the same sum, which is impossible.
+
+Since \(f\) is monic and \(a_0\neq0\), factor it over the algebraic
+closure as \(f(z)=\prod_{\ell=1}^{n}(z-\alpha_\ell)\). The identity gives
+
+\[
+M_f(t)=\sum_{\ell=1}^{n}\min\{t,v(\alpha_\ell)\}.
+\tag{8}
+\]
+
+By (2)--(3), \(M_f\) has a breakpoint at each \(t=\lambda_b\),
+where its slope decreases by \(e_b\): at that value the minimum
+passes across the corresponding polygon segment. In (8), each root
+of valuation \(t\) causes exactly one such decrease. Thus the root
+valuations and multiplicities are precisely (3). The lengths sum to
+\(\sum_{b=1}^{a}e_b=p^a-1\), so all roots are accounted for.
+
+For \(r=8\), the vertices are \((0,12),(4,4),(6,1),(7,0)\).
+For \(r=27\), they are \((0,54),(18,12),(24,2),(26,0)\), as proposed.
+
+## Exact extraction in the finite replay
+
+The verifier represents each coefficient as an integer polynomial of degree
+less than \(e_a\) in \(u\), then substitutes \(u=1-\pi\). If
+\(c=\sum_{i=0}^{e_a-1}c_i\pi^i\), the nonzero summands have valuations
+\(e_a v_p(c_i)+i\). Distinct indices give distinct residues modulo \(e_a\),
+so there is a unique minimum and no cancellation at that valuation. This
+justifies the first exact extraction method.
+
+For the second method, write \(F_a(\pi)=p+\sum_{i=1}^{e_a}F_i\pi^i=0\).
+Reduction modulo \(\pi\) sends every coefficient to its constant term modulo
+\(p\). Thus \(c\) is divisible by \(\pi\) in the integral local ring exactly
+when \(p\mid c_0\). In that case put \(m=c_0/p\) and compute
+
+\[
+ c/\pi=\sum_{i=1}^{e_a-1}(c_i-mF_i)\pi^{i-1}
+             -mF_{e_a}\pi^{e_a-1}.
+\]
+
+Repeating this integer operation until the constant residue is nonzero counts
+\(v(c)\) exactly. Both methods use the same binomial basis conversion, but
+different valuation extraction operations; neither uses the tail-sum formula
+as its answer. The finite replay is supporting implementation evidence, not
+the proof of the uniform formulas above.
+
+## Sources and attribution
+
+1. Ali Romman, [PR621](https://github.com/CrocSwap/integer-mult-bounds/pull/621),
+   "Prove uniform prime-power cyclic inverse bounds (no kappa claim)."
+   Merged head: `520774462b19b29af41554b74def31f9d01e997e` (not the merge
+   commit). The [pinned proof](https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/520774462b19b29af41554b74def31f9d01e997e/research/prime-power-cyclic-inverse/PROOF.md),
+   section "Integral polynomial and unit roots," supplies the integral
+   tail kernel and algebraic-nonunit conclusion; those are prior work,
+   not claims originating here. Locally consulted:
+   `research/prime-power-cyclic-inverse/PROOF.md` and `SOURCE.json`.
+   The [primary PR metadata](https://api.github.com/repos/CrocSwap/integer-mult-bounds/pulls/621)
+   confirms its author, merged status, and exact head.
+2. OpenAI, exact-DFT preprint source, commit
+   `adc7f1241b42e322a6451854ab7e4b4c146bf78a`,
+   [pinned `local.tex`](https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/An-explicit-power-saving-for-the-exact-discrete-Fourier-transform-September-25-2026/build/sections/local.tex),
+   labels `loc:newton` and `loc:fourier-factorization`. It defines
+   \(H_j=\prod_{s=1}^j(1-u^s)\) and \(h_j=H_j^{-1}\).
+   The identity \(H_{r-1}=r\), obtained by evaluating
+   \((T^r-1)/(T-1)\) at \(T=1\), turns
+    \(r\sum h_jz^j\) into the integral tail kernel above.
+3. Hao Yan (@FanPUYen), [PR796](https://github.com/CrocSwap/integer-mult-bounds/pull/796),
+   "Research audit: exact prime-power kernel root valuations (no new kappa)."
+   Compared head: `22902155c7875139e43e4fdf15723142d6709bdd`. Its
+   `research/prime-power-newton-audit/cyclotomic.py` extracts coefficient
+   valuations by weighted uniformizer-basis minima. Its exact receipt agrees
+   on every shared radix and primitive embedding. The repeated integral
+   division method in this package is distinct corroborating evidence.
+
+The valuation and convex-hull calculations are proved here; no external
+classification of these roots is assumed. This is a written mathematical
+proof, independent of any finite verification script.
diff --git a/research/prime-power-newton-valuation/README.md b/research/prime-power-newton-valuation/README.md
new file mode 100644
index 0000000000..97e82fef96
--- /dev/null
+++ b/research/prime-power-newton-valuation/README.md
@@ -0,0 +1,128 @@
+# Prime-power kernel valuations and Newton polygons
+
+Independent verification and a scoped research note; **no new kappa**.
+Concurrent [#796][796] submitted the same mathematical formula before this
+package's final overlap refresh. The distinct contribution here is exact
+integral uniformizer division, corroboration of its pinned receipt, and every
+primitive embedding at radix 81, beyond its cutoff of 68. No priority is claimed.
+
+For Ali Romman's PR621 kernel
+
+    f(z) = sum_{j=0}^{r-1} a_j z^j,
+    a_j = product_{s=j+1}^{r-1} (1-u^s),   r=p^a,
+
+normalize the nonarchimedean valuation by `v(1-u)=1`. The exact result is
+
+    v(a_j) = sum_{s=j+1}^{r-1} p^{v_p(s)}.
+
+The lower Newton polygon has vertices
+`(r-p^b, b*phi(p^b))` for `b=a,...,1`, followed by `(r-1,0)`.
+Exactly `phi(p^b)` roots, counted with algebraic multiplicity, have valuation
+`1+(b-1)(p-1)/p`. In the normalization `v_p(p)=1`, divide these values by
+`phi(r)`. For example, radix 8 has four roots of valuation 2, two of valuation
+3/2 and one of valuation 1 in the first normalization.
+
+[PROOF.md](PROOF.md) supplies the uniform written argument. The finite replay
+does not prove the uniform statement. The kernel and the earlier conclusion
+that its algebraic roots are not units belong to [PR621][621]; the additional
+result here is their exact ramified valuation distribution.
+
+## Reproduce
+
+From the repository root, using Python 3.11+ and no external dependencies:
+
+```sh
+python -B -I -O research/prime-power-newton-valuation/verify.py --check research/prime-power-newton-valuation/EXPECTED.json
+```
+
+Expected output:
+
+```text
+PASS 214 primitive embeddings; 10268 exact coefficients; 8 negative controls
+```
+
+The focused tests are:
+
+```sh
+python -B -I research/prime-power-newton-valuation/test_verify.py
+```
+
+Expected: nine tests pass. If Python is managed by uv, prefix either command
+with `uv run --no-project`. To regenerate only this receipt, replace `--check`
+with `--output` and a new output path. Verification reads, but does not rewrite,
+the predecessor package or selected frontier.
+
+## What is independently checked
+
+The new engine imports no predecessor field arithmetic, determinant, inverse,
+SymPy or scan code. It builds each tail product in `Z[u]/(u^r-1)` using integer
+cyclic differences, reduces by the explicit cyclotomic polynomial, and
+substitutes `u=1-pi` using binomial coefficients. It checks the shifted
+cyclotomic polynomial is Eisenstein and obtains every coefficient valuation
+in two ways:
+
+- The minimum of `phi(r)*v_p(c_i)+i` in the uniformizer basis.
+- The number of exact integral divisions by `pi` before the residue is nonzero.
+
+Both are compared with the separate factor-valuation sum. An integer
+cross-product convex-hull algorithm is then compared with the proposed
+rational segment formula. No numerical root finding or floating arithmetic
+is used. Each reconstructed coefficient tuple is bound by a canonical JSON
+SHA-256 digest, separately for every primitive power, in `EXPECTED.json`.
+
+The completed fixed domain is orders **3, 5, 7**, plus every repeated prime
+power through **81**: **4, 8, 9, 16, 25, 27, 32, 49, 64, 81**. Every primitive
+power at every listed order is checked. The OS-random assignment seed is 80;
+`seed+1` sets the repeated-prime-power cutoff. The stopping rule was completion
+of this domain, not finding a favorable example.
+
+The eight rejection controls include nonprimitive powers, non-prime-power
+inputs, an omitted tail factor, a polynomial with a unit root, and a
+radix-4 coefficient doubled from `2+2u` to `4+4u`. The last mutation preserves
+all modulo-`(1-u)` residues, the monic endpoint and the full-product endpoint,
+but changes the exact coefficient valuation from 3 to 5. This demonstrates
+the additional coverage of this check; it is not a defect in PR621. Tests also
+execute a changed-receipt rejection under optimized Python and a source-pin
+failure against an altered predecessor file.
+
+## Pins, overlap and limitations
+
+Exact base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+PR621 source head: `520774462b19b29af41554b74def31f9d01e997e`.
+PR796 comparison head: `22902155c7875139e43e4fdf15723142d6709bdd`.
+[SOURCE.json](SOURCE.json) retains the kernel source pin and checked
+predecessor-file hashes. [CLAIM.md](CLAIM.md) records selection and scope.
+[VALIDATION.md](VALIDATION.md) records the completed checks and handoff.
+
+Concurrent [#668][668] checks resultants through radix 27 using CRT;
+[#666][666] extends selected composite families using Bezout lifting;
+[#692][692] checks weighted-stride resolvents; [#628][628] supplies rounded
+scans and dirty restoration. Those are credited related work, not dependencies
+or results imported here. The valuations, all-embedding repeated-prime-power
+coverage and integer-divisibility engine are different obligations from those
+packages. #796 overlaps the mathematical formula and the weighted-minimum
+method. Its twelve shared radices, 160 primitive embeddings and 5,894
+coefficient valuations agree exactly with this receipt; all shared hulls and
+root multiplicities also agree. Radix 81 adds 54 embeddings and 4,374
+coefficients. The integral-division extraction is not present in #796's pinned
+`cyclotomic.py`; it independently corroborates both implementations' weighted
+minimum extraction. [CORROBORATION.json](CORROBORATION.json) records the pins
+and comparison scope.
+
+Positive p-adic valuations do not say that complex roots lie inside the unit
+disk. This note does not strengthen the archimedean conditioning constant,
+implement a paid inverse, or settle coefficient preparation, rounded execution,
+restoration, tape routing, recursive hosting or the inherited all-size/compiler/
+analytic multiplication obligations. It is not proof-assistant formalization
+or independent human peer review. The selected conditional kappa and
+`upstream/` are unchanged.
+
+[NOTICE.md](NOTICE.md) records attribution, Apache-2.0 licensing and substantial
+AI assistance.
+
+[621]: https://github.com/CrocSwap/integer-mult-bounds/pull/621
+[628]: https://github.com/CrocSwap/integer-mult-bounds/pull/628
+[666]: https://github.com/CrocSwap/integer-mult-bounds/pull/666
+[668]: https://github.com/CrocSwap/integer-mult-bounds/pull/668
+[692]: https://github.com/CrocSwap/integer-mult-bounds/pull/692
+[796]: https://github.com/CrocSwap/integer-mult-bounds/pull/796
diff --git a/research/prime-power-newton-valuation/SOURCE.json b/research/prime-power-newton-valuation/SOURCE.json
new file mode 100644
index 0000000000..5381faad0b
--- /dev/null
+++ b/research/prime-power-newton-valuation/SOURCE.json
@@ -0,0 +1,42 @@
+{
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "predecessor": {
+    "pr": 621,
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/621",
+    "author": "Ali Romman (@aliromman)",
+    "head": "520774462b19b29af41554b74def31f9d01e997e",
+    "scope": "Kernel definition and antecedent nonunit/circle-bound proof only; no predecessor arithmetic code imported."
+  },
+  "kernel_source": {
+    "repository": "openai/math",
+    "commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a",
+    "path": "preprints/An-explicit-power-saving-for-the-exact-discrete-Fourier-transform-September-25-2026/build/sections/local.tex",
+    "git_blob": "260a19bd8f7189afbe89b0af0508d979cd1e1ca6",
+    "scope": "Inherited kernel provenance from PR621 SOURCE.json; external source not executed."
+  },
+  "files_sha256_lf": {
+    "research/prime-power-cyclic-inverse/PROOF.md": "2b8056c88e66f692f407450fff0414d41bcd09db8597be22e274a6c3dc20eb9e",
+    "research/prime-power-cyclic-inverse/SOURCE.json": "81217e4ecbb1da767d6a23f043d66e69d53c9001c056176efc641ddadea275f2",
+    "research/prime-power-cyclic-inverse/verify.py": "40e5e18cbd98d39ba6d0bb036778ccacc077dff009099a54b9c8f441af5d6a56"
+  },
+  "hash_convention": "SHA-256 of text source bytes after CRLF-to-LF normalization only. No field or whitespace stripping.",
+  "selected_at_base": {
+    "kappa": "51110230636731/31250000000000000",
+    "source_prs": [626, 543],
+    "scope": "Orientation record only; this contribution does not modify or certify the selected construction."
+  },
+  "overlap_at_selection": {
+    "668": "Exact CRT resultants through radix 27; different obligation and engine.",
+    "666": "Composite cyclic Bezout identities and modular lifting; not duplicated.",
+    "692": "Weighted-stride resolvents and bilinear dual; not duplicated.",
+    "628": "Rounded cyclic scans and dirty restoration; not duplicated."
+  },
+  "concurrent_corroboration": {
+    "pr": 796,
+    "author": "Hao Yan (@FanPUYen)",
+    "head": "22902155c7875139e43e4fdf15723142d6709bdd",
+    "receipt_path": "research/prime-power-newton-audit/EXPECTED.json",
+    "receipt_sha256": "d074f1c2f87324e81cf8aa94784077694230cf35d95f8b0c173755c89f876333",
+    "scope": "Final overlap comparison only, not required for the standalone verifier. Same formula and weighted-minimum extraction; this package adds integral division and radix 81."
+  }
+}
diff --git a/research/prime-power-newton-valuation/VALIDATION.md b/research/prime-power-newton-valuation/VALIDATION.md
new file mode 100644
index 0000000000..df9cf67745
--- /dev/null
+++ b/research/prime-power-newton-valuation/VALIDATION.md
@@ -0,0 +1,118 @@
+# Verification and handoff
+
+Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+Branch: `research/seed80-independent-verification`.
+Platform: Windows x86-64. Actual interpreter runs: CPython 3.14.7 and 3.12.14.
+Python 3.11 is the documented floor; it was not installed or executed here.
+
+## Completed local checks
+
+The commands below were run from the repository root. Here `uv run --no-project`
+selects an already installed interpreter; the verifier itself has no uv dependency.
+
+```sh
+uv run --no-project python -B -I research/prime-power-newton-valuation/test_verify.py
+uv run --no-project python -B -I -O research/prime-power-newton-valuation/verify.py --check research/prime-power-newton-valuation/EXPECTED.json
+uv run --no-project --python 3.12 python -B -I -O research/prime-power-newton-valuation/verify.py --check research/prime-power-newton-valuation/EXPECTED.json
+uv run --no-project python -B scripts/verify_selected_result.py
+```
+
+Results: nine focused tests pass; both optimized interpreter replays report
+`PASS 214 primitive embeddings; 10268 exact coefficients; 8 negative controls`;
+the selected record, complete original source inventory and proof supplements
+retain exact kappa `51110230636731/31250000000000000`. The checker also ran
+normally when generating the receipt; the normal and optimized outputs agree.
+
+The tests were written first. The initial five tests failed because the integer
+engine was absent, then passed after implementation. The receipt, Eisenstein and
+source-pin tests subsequently failed before their features were implemented.
+The integral-division test likewise failed before that second extraction method
+was added. No failing test or rejected control was described as a theorem failure.
+
+The unchanged PR621 primary verifier was separately run with `-B -I -O`, writing
+to the approved external temporary directory. Its complete JSON result equals
+`research/prime-power-cyclic-inverse/EXPECTED.json`, not just its PASS field.
+Its three checked files retain the SHA-256 pins in `SOURCE.json`.
+
+One scoped AI worker checked the written uniform argument and produced the
+proof note. A separate read-only AI reviewer ran all focused tests and the
+optimized replay, and additionally compared every coefficient tuple with an
+in-memory descending cyclotomic long-division reference. It reported no
+correctness finding; its one documentation finding was the then-absent validation
+note, supplied here. The shared basis conversion between the two valuation
+extractors is disclosed in README and PROOF. No human or proof-assistant review
+is claimed.
+
+## Concurrent result comparison
+
+The final open-PR refresh at approximately 05:52 UTC found Hao Yan's #796,
+created at 05:47:56 UTC, after this package's local claim. At pinned head
+`22902155c7875139e43e4fdf15723142d6709bdd`, its `cyclotomic.py` uses weighted
+uniformizer-basis minima and no repeated integral-division extraction.
+
+The exact source receipt was read through `git show` after fetching that head.
+Its SHA-256 is `d074f1c2f87324e81cf8aa94784077694230cf35d95f8b0c173755c89f876333`.
+Every shared coefficient valuation, primitive power list, hull vertex, root
+valuation and multiplicity agrees: twelve radices, 160 embeddings and 5,894
+coefficient obligations. Radix 81 adds 54 embeddings and 4,374 coefficients.
+The full #796 executable package was not run or certified by this comparison.
+
+To reproduce the comparison, fetch the pinned object once:
+
+```sh
+git fetch --no-tags https://github.com/CrocSwap/integer-mult-bounds.git 22902155c7875139e43e4fdf15723142d6709bdd
+```
+
+Then run this Python snippet from the repository root (or save it to an external
+temporary file and execute it). It consumes the two complete exact receipts:
+
+```python
+import hashlib, json, subprocess
+from pathlib import Path
+
+package = Path("research/prime-power-newton-valuation")
+claim = json.loads((package / "CORROBORATION.json").read_text())
+raw = subprocess.check_output([
+    "git", "show", claim["source_head"] + ":" + claim["source_receipt"]
+])
+if hashlib.sha256(raw).hexdigest() != claim["source_receipt_sha256"]:
+    raise ValueError("comparison source pin mismatch")
+theirs = {c["r"]: c for c in json.loads(raw)["cases"]}
+ours = json.loads((package / "EXPECTED.json").read_text())
+shared, extra, embeddings, coefficients = [], [], 0, 0
+for c in ours["cases"]:
+    r = c["radix"]
+    if r not in theirs:
+        extra.append(r)
+        continue
+    t = theirs[r]
+    roots = [{"multiplicity": s["multiplicity"], "valuation": s["valuation"]}
+             for s in t["segments"]]
+    if (c["coefficient_valuations"] != t["coefficient_valuations"]
+        or c["primitive_powers"] != t["primitive_powers"]
+        or c["lower_hull"] != t["vertices"] or c["root_valuations"] != roots):
+        raise ValueError("exact shared-receipt mismatch")
+    shared.append(r)
+    embeddings += len(c["primitive_powers"])
+    coefficients += r * len(c["primitive_powers"])
+if (shared != claim["shared_radices"] or extra != claim["additional_radices"]
+    or embeddings != claim["shared_primitive_embeddings"]
+    or coefficients != claim["shared_coefficient_obligations"]):
+    raise ValueError("comparison coverage mismatch")
+print("PASS PR796: 160 shared embeddings; 5894 shared coefficients; radix 81 added")
+```
+
+## Verification boundary
+
+Only this new research package is changed. No existing generator, selected
+construction, global ledger or `upstream/` file is edited. The repository-wide
+`make verify`, selected cold supplier replay, optional SymPy, Linux execution and
+remote CI are **not** claimed. GNU make is not available on this session's PATH;
+the scoped Python checks above and unchanged predecessor replay were run directly.
+
+The uniform proof concerns one prime-power polynomial family. Finite replay is
+not a proof of all prime powers, archimedean conditioning, a paid exact inverse,
+rounded preparation/restoration, recursive hosting, fixed-tape execution or the
+conditional integer-multiplication theorem. There is no new kappa or global
+optimality claim. The useful handoff is the integral-divisibility evidence and
+radix-81 coverage, with explicit credit for #796's concurrent shared result.
diff --git a/research/prime-power-newton-valuation/test_verify.py b/research/prime-power-newton-valuation/test_verify.py
new file mode 100644
index 0000000000..2492f3377d
--- /dev/null
+++ b/research/prime-power-newton-valuation/test_verify.py
@@ -0,0 +1,110 @@
+"""Hand-derived controls for the independent valuation engine."""
+
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+SPEC = importlib.util.spec_from_file_location(
+    "newton_verify", Path(__file__).with_name("verify.py")
+)
+ENGINE = importlib.util.module_from_spec(SPEC)
+if SPEC.loader is not None and Path(SPEC.origin).exists():
+    SPEC.loader.exec_module(ENGINE)
+
+
+class ValuationTests(unittest.TestCase):
+    def test_radix_four_integer_coefficients(self):
+        # Dropping a tail factor, rotating in the wrong direction, or reducing
+        # x^2 as +1 instead of -1 breaks this hand-calculated fixture.
+        self.assertTrue(hasattr(ENGINE, "tail_coefficients"), "engine not implemented")
+        self.assertEqual(
+            ENGINE.tail_coefficients(4, 1),
+            [(4, 0), (2, 2), (1, 1), (1, 0)],
+        )
+
+    def test_ramified_weights_include_integer_prime_factors(self):
+        # v(2)=2 and v(1-i)=1 in Q_2(i); a plain mod-2 residue is insufficient.
+        self.assertTrue(hasattr(ENGINE, "coefficient_valuation"), "engine not implemented")
+        self.assertEqual(
+            [ENGINE.coefficient_valuation(c, 2, 2)
+             for c in [(4, 0), (2, 2), (1, 1), (1, 0)]],
+            [4, 3, 1, 0],
+        )
+
+    def test_polygon_excludes_points_above_its_edges(self):
+        self.assertTrue(hasattr(ENGINE, "lower_hull"), "engine not implemented")
+        self.assertEqual(
+            ENGINE.lower_hull([12, 11, 9, 8, 4, 3, 1, 0]),
+            [(0, 12), (4, 4), (6, 1), (7, 0)],
+        )
+        self.assertEqual(
+            ENGINE.lower_hull([12, 11, 10, 7, 6, 5, 2, 1, 0]),
+            [(0, 12), (6, 2), (8, 0)],
+        )
+
+    def test_rejects_nonprimitive_and_non_prime_power_inputs(self):
+        self.assertTrue(hasattr(ENGINE, "tail_coefficients"), "engine not implemented")
+        for radix, power in [(4, 2), (9, 3), (12, 1), (1, 1)]:
+            with self.subTest(radix=radix, power=power):
+                with self.assertRaises(ValueError):
+                    ENGINE.tail_coefficients(radix, power)
+
+    def test_mod_ideal_preserving_tamper_is_rejected(self):
+        self.assertTrue(hasattr(ENGINE, "check_coefficients"), "engine not implemented")
+        # Both 2+2i and 4+4i vanish modulo (1-i), but their valuations differ.
+        coefficients = [(4, 0), (4, 4), (1, 1), (1, 0)]
+        with self.assertRaises(ValueError):
+            ENGINE.check_coefficients(4, coefficients)
+
+    def test_shifted_cyclotomic_is_eisenstein(self):
+        # A dropped geometric-sum term or wrong binomial sign breaks these.
+        self.assertTrue(hasattr(ENGINE, "shifted_cyclotomic"), "not implemented")
+        self.assertEqual(ENGINE.shifted_cyclotomic(4), [2, -2, 1])
+        self.assertEqual(ENGINE.shifted_cyclotomic(9), [3, -9, 18, -21, 15, -6, 1])
+
+    def test_repeated_integral_division_counts_uniformizer_factors(self):
+        # The second engine must divide by 1-i, not by the rational prime 2.
+        self.assertTrue(hasattr(ENGINE, "division_valuation"), "not implemented")
+        self.assertEqual(
+            [ENGINE.division_valuation(c, 4)
+             for c in [(4, 0), (2, 2), (1, 1), (1, 0), (1, -1)]],
+            [4, 3, 1, 0, 1],
+        )
+        with self.assertRaises(ValueError):
+            ENGINE.division_valuation((0, 0), 4)
+
+    def test_checker_rejects_changed_receipt(self):
+        # Success cannot be reported from an unchecked stored status string.
+        self.assertTrue(hasattr(ENGINE, "replay"), "replay not implemented")
+        receipt = ENGINE.replay()
+        self.assertEqual(receipt["embedding_count"], 214)
+        self.assertEqual(receipt["coefficient_count"], 10268)
+        receipt["embedding_count"] = 213
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "tampered.json"
+            path.write_text(json.dumps(receipt), encoding="utf-8")
+            process = subprocess.run(
+                [sys.executable, "-B", "-I", "-O", SPEC.origin, "--check", str(path)],
+                capture_output=True, text=True,
+            )
+        self.assertNotEqual(process.returncode, 0)
+        self.assertIn("receipt mismatch", process.stderr)
+
+    def test_source_pin_rejects_changed_predecessor(self):
+        self.assertTrue(hasattr(ENGINE, "check_sources"), "pin check not implemented")
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            path = root / "research/prime-power-cyclic-inverse/PROOF.md"
+            path.parent.mkdir(parents=True)
+            path.write_text("altered kernel\n", encoding="utf-8")
+            with self.assertRaisesRegex(ValueError, "source pin mismatch"):
+                ENGINE.check_sources(root)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/research/prime-power-newton-valuation/verify.py b/research/prime-power-newton-valuation/verify.py
new file mode 100644
index 0000000000..9309002d50
--- /dev/null
+++ b/research/prime-power-newton-valuation/verify.py
@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""Independent integer reconstruction of prime-power kernel valuations."""
+
+import argparse
+from fractions import Fraction
+from hashlib import sha256
+import json
+from math import comb, gcd
+from pathlib import Path
+
+
+DOMAIN = (3, 4, 5, 7, 8, 9, 16, 25, 27, 32, 49, 64, 81)
+PACKAGE = Path(__file__).resolve().parent
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def prime_power(radix):
+    require(isinstance(radix, int) and radix >= 3, "radix must be at least three")
+    prime = next(p for p in range(2, radix + 1) if radix % p == 0)
+    remainder, exponent = radix, 0
+    while remainder % prime == 0:
+        remainder //= prime
+        exponent += 1
+    require(remainder == 1, "radix must be a prime power")
+    return prime, exponent
+
+
+def prime_order(value, prime):
+    require(value != 0, "zero has no finite valuation")
+    order = 0
+    while value % prime == 0:
+        value //= prime
+        order += 1
+    return order
+
+
+def tail_coefficients(radix, power):
+    """Return a_j in the integral u power basis, without field division."""
+    prime, exponent = prime_power(radix)
+    require(isinstance(power, int) and gcd(radix, power) == 1, "nonprimitive power")
+    step = prime ** (exponent - 1)
+    degree = (prime - 1) * step
+    # First compute in Z[u]/(u^r-1): multiply by 1-u^s as a cyclic difference.
+    cyclic = [1] + [0] * (radix - 1)
+    coefficients = [None] * radix
+    for j in range(radix - 1, -1, -1):
+        reduced = cyclic.copy()
+        # Phi_r(u) = 1+u^step+...+u^degree. Each high monomial reduces
+        # directly to exponents below degree, since the input degree is < r.
+        for h in range(degree, radix):
+            for k in range(prime - 1):
+                reduced[h - degree + k * step] -= reduced[h]
+        coefficients[j] = tuple(reduced[:degree])
+        if j:
+            shift = (power * j) % radix
+            cyclic = [cyclic[h] - cyclic[(h - shift) % radix]
+                      for h in range(radix)]
+    return coefficients
+
+
+def in_uniformizer_basis(coefficients):
+    """Substitute u=1-pi using the binomial theorem over the integers."""
+    degree = len(coefficients)
+    return [(-1) ** i * sum(coefficients[h] * comb(h, i)
+                            for h in range(i, degree))
+            for i in range(degree)]
+
+
+def coefficient_valuation(coefficients, prime, exponent):
+    degree = (prime - 1) * prime ** (exponent - 1)
+    require(len(coefficients) == degree, "wrong cyclotomic basis length")
+    shifted = in_uniformizer_basis(coefficients)
+    weights = [degree * prime_order(value, prime) + i
+               for i, value in enumerate(shifted) if value]
+    require(bool(weights), "zero coefficient")
+    # The nonzero summands have different valuations modulo degree, so the
+    # least valuation cannot cancel. v(pi)=1 and v(prime)=degree.
+    return min(weights)
+
+
+def lower_hull(values):
+    hull = []
+    for point in enumerate(values):
+        while len(hull) >= 2:
+            a, b = hull[-2:]
+            cross = ((b[0] - a[0]) * (point[1] - b[1])
+                     - (b[1] - a[1]) * (point[0] - b[0]))
+            if cross > 0:
+                break
+            hull.pop()
+        hull.append(point)
+    return hull
+
+
+def predicted_hull(radix):
+    prime, exponent = prime_power(radix)
+    x = 0
+    y = Fraction(exponent * (prime - 1) * prime ** (exponent - 1))
+    hull = [(x, int(y))]
+    for b in range(exponent, 0, -1):
+        multiplicity = (prime - 1) * prime ** (b - 1)
+        valuation = 1 + Fraction((b - 1) * (prime - 1), prime)
+        x += multiplicity
+        y -= multiplicity * valuation
+        require(y.denominator == 1, "nonintegral predicted vertex")
+        hull.append((x, int(y)))
+    require(hull[-1] == (radix - 1, 0), "wrong predicted endpoint")
+    return hull
+
+
+def check_coefficients(radix, coefficients):
+    prime, exponent = prime_power(radix)
+    require(len(coefficients) == radix, "wrong polynomial length")
+    values = [coefficient_valuation(c, prime, exponent) for c in coefficients]
+    expected = [0] * radix
+    for j in range(radix - 2, -1, -1):
+        expected[j] = expected[j + 1] + prime ** prime_order(j + 1, prime)
+    require(values == expected, "exact coefficient valuations disagree with tail sum")
+    require(lower_hull(values) == predicted_hull(radix), "Newton polygon mismatch")
+    return values
+
+
+def shifted_cyclotomic(radix):
+    prime, exponent = prime_power(radix)
+    step = prime ** (exponent - 1)
+    degree = (prime - 1) * step
+    polynomial = [sum((-1) ** i * comb(k * step, i)
+                      for k in range(prime) if k * step >= i)
+                  for i in range(degree + 1)]
+    require(polynomial[0] == prime and abs(polynomial[-1]) == 1,
+            "wrong shifted cyclotomic endpoints")
+    require(all(c % prime == 0 for c in polynomial[:-1]),
+            "shifted cyclotomic is not Eisenstein")
+    require(polynomial[0] % (prime * prime) != 0,
+            "shifted cyclotomic constant is not Eisenstein")
+    return polynomial
+
+
+def division_valuation(coefficients, radix):
+    """Count exact integral divisions by pi, rather than weighted minima."""
+    prime, _ = prime_power(radix)
+    polynomial = shifted_cyclotomic(radix)
+    shifted = in_uniformizer_basis(coefficients)
+    require(len(shifted) == len(polynomial) - 1, "wrong cyclotomic basis length")
+    require(any(shifted), "zero coefficient")
+    count = 0
+    while shifted[0] % prime == 0:
+        multiple = shifted[0] // prime
+        # F(pi)=p+F_1*pi+...+F_e*pi^e=0. If c_0=m*p, replace
+        # c_0 by -m*sum(F_i*pi^i), then divide the entire expression by pi.
+        shifted = [shifted[i] - multiple * polynomial[i]
+                   for i in range(1, len(shifted))] + [-multiple * polynomial[-1]]
+        count += 1
+    return count
+
+
+def check_sources(root=None):
+    root = Path(root) if root is not None else PACKAGE.parents[1]
+    pins = json.loads((PACKAGE / "SOURCE.json").read_text(encoding="utf-8"))
+    for path, digest in pins["files_sha256_lf"].items():
+        data = (root / path).read_bytes().replace(b"\r\n", b"\n")
+        require(sha256(data).hexdigest() == digest, "source pin mismatch: " + path)
+    return pins
+
+
+def negative_controls():
+    rejected = []
+
+    def reject(label, operation, reason):
+        try:
+            operation()
+        except ValueError as error:
+            require(reason in str(error), "wrong rejection for " + label)
+            rejected.append(label)
+        else:
+            raise ValueError("negative control accepted: " + label)
+
+    for radix, power in ((4, 2), (9, 3)):
+        reject("nonprimitive_%d_%d" % (radix, power),
+               lambda: tail_coefficients(radix, power), "nonprimitive")
+    for radix in (1, 12):
+        reject("invalid_radix_%d" % radix,
+               lambda: tail_coefficients(radix, 1), "radix must")
+    coefficients = tail_coefficients(4, 1)
+    tampered = coefficients.copy()
+    tampered[1] = tuple(2 * c for c in tampered[1])
+    # This preserves every residue checked in #621 modulo (1-u), including
+    # a_0=r and a_n=1, but v(a_1) changes from 3 to 5.
+    require([sum(c) % 2 for c in coefficients]
+            == [sum(c) % 2 for c in tampered], "control changed ideal residues")
+    reject("same_ideal_residues_wrong_valuation",
+           lambda: check_coefficients(4, tampered), "coefficient valuations")
+    omitted = coefficients[1:] + [coefficients[-1]]
+    reject("omitted_tail_factor", lambda: check_coefficients(4, omitted),
+           "coefficient valuations")
+    reject("unit_root_polynomial", lambda: check_coefficients(4, [(1, 0)] * 4),
+           "coefficient valuations")
+    reject("zero_coefficient", lambda: coefficient_valuation((0, 0), 2, 2),
+           "zero coefficient")
+    return rejected
+
+
+def replay():
+    pins = check_sources()
+    cases = []
+    embedding_count = coefficient_count = 0
+    for radix in DOMAIN:
+        prime, exponent = prime_power(radix)
+        shifted_cyclotomic(radix)
+        degree = (prime - 1) * prime ** (exponent - 1)
+        powers = [power for power in range(1, radix) if gcd(power, radix) == 1]
+        digests = {}
+        common_values = None
+        for power in powers:
+            coefficients = tail_coefficients(radix, power)
+            require(coefficients[0] == (radix,) + (0,) * (degree - 1),
+                    "full tail product is not radix")
+            require(coefficients[-1] == (1,) + (0,) * (degree - 1),
+                    "kernel is not monic")
+            values = check_coefficients(radix, coefficients)
+            require([division_valuation(c, radix) for c in coefficients] == values,
+                    "integral-division valuation disagrees with weighted minimum")
+            require(all(value > 0 for value in values[:-1]),
+                    "nonleading coefficient has nonpositive valuation")
+            if common_values is None:
+                common_values = values
+            require(values == common_values, "primitive embeddings disagree")
+            payload = json.dumps(coefficients, separators=(",", ":")).encode("ascii")
+            digests[str(power)] = sha256(payload).hexdigest()
+            embedding_count += 1
+            coefficient_count += radix
+        hull = lower_hull(common_values)
+        root_values = [{"multiplicity": b[0] - a[0],
+                        "valuation": str(Fraction(a[1] - b[1], b[0] - a[0]))}
+                       for a, b in zip(hull, hull[1:])]
+        cases.append({"radix": radix, "prime": prime, "prime_exponent": exponent,
+                      "ramification_degree": degree, "primitive_powers": powers,
+                      "coefficient_valuations": common_values,
+                      "lower_hull": hull, "root_valuations": root_values,
+                      "coefficient_sha256_by_power": digests})
+    return {"status": "PASS_PRIME_POWER_NEWTON_VALUATIONS",
+            "assignment_seed": 80, "domain": list(DOMAIN),
+            "embedding_count": embedding_count, "coefficient_count": coefficient_count,
+            "valuation_methods": ["weighted_uniformizer_basis_minimum",
+                                  "repeated_exact_integral_uniformizer_division"],
+            "source_files_sha256_lf": pins["files_sha256_lf"],
+            "cases": cases, "negative_controls": negative_controls(),
+            "scope": "Exact finite coefficient and polygon replay; not an archimedean "
+                     "root bound, paid inverse program or multiplication theorem."}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--check", type=Path)
+    args = parser.parse_args()
+    result = replay()
+    payload = json.dumps(result, indent=2) + "\n"
+    if args.check:
+        # JSON equality includes every proof-relevant field; converting through
+        # JSON also canonicalizes the tuples emitted by the hull calculation.
+        expected = json.loads(args.check.read_text(encoding="utf-8"))
+        require(json.loads(payload) == expected, "receipt mismatch")
+    if args.output:
+        args.output.write_text(payload, encoding="utf-8", newline="\n")
+    print("PASS %d primitive embeddings; %d exact coefficients; %d negative controls"
+          % (result["embedding_count"], result["coefficient_count"],
+             len(result["negative_controls"])))
+
+
+if __name__ == "__main__":
+    main()

From 1f387e7090359165a0df046183eb8fa16c246d7d Mon Sep 17 00:00:00 2001
From: Aaron Wang <warhawk947@gmail.com>
Date: Tue, 13 Oct 2026 02:00:52 -0400
Subject: [PATCH 2/2] docs: link completed valuation verification

---
 .../prime-power-newton-valuation/CLAIM.md     | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/research/prime-power-newton-valuation/CLAIM.md b/research/prime-power-newton-valuation/CLAIM.md
index 2a97e69b10..b4096a2506 100644
--- a/research/prime-power-newton-valuation/CLAIM.md
+++ b/research/prime-power-newton-valuation/CLAIM.md
@@ -53,3 +53,28 @@ Tech stack: Python 3.11+ standard library. Scope and design are the claim above.
 6. Submit at most one independent-verification/research-note PR, with exact
    attribution, AI disclosure and unresolved obligations. Do not alter upstream
    or the selected record.
+
+## Final result and handoff (one claim update)
+
+Completed 2026-10-13 at approximately 06:00 UTC, with the final verification
+and handoff phase beginning at 05:51 UTC. Submitted one focused contribution:
+[PR804](https://github.com/CrocSwap/integer-mult-bounds/pull/804).
+
+The fixed domain completed: 214 primitive embeddings, 10,268 exact coefficient
+valuations, two valuation extractors and eight rejecting controls. Nine focused
+tests pass on installed Python 3.12.14 and 3.14.7. The unchanged #621 replay
+matches its full published receipt; selected-record/source integrity passes.
+
+The submission refresh discovered Hao Yan's concurrent #796, posted at
+05:47:56 UTC, with the same formula and weighted-minimum extraction. The
+handoff was therefore narrowed to distinct repeated integral-divisibility
+evidence and radix-81 coverage, not priority for the shared theorem. Its pinned
+receipt agrees on 160 shared embeddings and 5,894 coefficients, with all shared
+hulls and root multiplicities identical. Radix 81 adds 54 embeddings and 4,374
+coefficients. The final metadata refresh retained #796 head
+`22902155c7875139e43e4fdf15723142d6709bdd`; #800's Clifford path-valuation work
+is a different object. Exact comparison pins are in `CORROBORATION.json`.
+
+No kappa change, full repository-suite pass, Linux/CI result, paid inverse,
+proof-assistant formalization or independent human review is claimed.
+`VALIDATION.md` supplies the commands, scope and remaining obligations.