From 13d7ced3972f499f0913c78e76ae62de68db5138 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:23:46 -0500
Subject: [PATCH 1/6] Research p=25 E8 root-pair decoder floor

---
 .../CERTIFICATE.json                          | 126 +++++++
 .../p25-root-pair-bound-seed632639/README.md  | 136 +++++++
 .../SOURCES.json                              |  96 +++++
 .../p25-root-pair-bound-seed632639/TASK.json  |  95 +++++
 .../VERIFY.json                               |  41 +++
 .../p25-root-pair-bound-seed632639/verify.py  | 336 ++++++++++++++++++
 6 files changed, 830 insertions(+)
 create mode 100644 research/p25-root-pair-bound-seed632639/CERTIFICATE.json
 create mode 100644 research/p25-root-pair-bound-seed632639/README.md
 create mode 100644 research/p25-root-pair-bound-seed632639/SOURCES.json
 create mode 100644 research/p25-root-pair-bound-seed632639/TASK.json
 create mode 100644 research/p25-root-pair-bound-seed632639/VERIFY.json
 create mode 100644 research/p25-root-pair-bound-seed632639/verify.py

diff --git a/research/p25-root-pair-bound-seed632639/CERTIFICATE.json b/research/p25-root-pair-bound-seed632639/CERTIFICATE.json
new file mode 100644
index 0000000000..b00be1246f
--- /dev/null
+++ b/research/p25-root-pair-bound-seed632639/CERTIFICATE.json
@@ -0,0 +1,126 @@
+{
+  "conclusion": "The complete root-pair family at p=25 misses the selected local-word ceiling gate even with zero added implementation charges.",
+  "copy_bound": {
+    "exceptional_term_floor_if_used_on_both_sides_of_same_dual_term": 5,
+    "exceptional_term_floor_if_used_on_one_side": 6,
+    "negative_controls": {
+      "exceptional_pair_bound": 5,
+      "regular_seven_term_floor": 49,
+      "total_floor_recomputed": true
+    },
+    "number_of_terms_below_7": "at most one",
+    "ordinary_term_floor": 7,
+    "pairing_rank_inequality": "rank(X,Y) >= dim(X)+dim(Y)-9",
+    "reason": "one p=25 puncture mask lowers at most one root-normal support; distinctness and duality place it in at most one term",
+    "scope": "exact eight-term all-pairs decoders whose row and column normals are E8 roots, at exactly 25 punctures",
+    "total_copy_floor": 54,
+    "unique_exceptional_root_span": 7
+  },
+  "optimistic_price": {
+    "a_ceiling_interval": [
+      "307709262007/200000000000000",
+      "384636577509/250000000000000"
+    ],
+    "a_ceiling_upper_decimal": "0.001538546310036",
+    "additional_ports_from_selected_P112": 17,
+    "center_charge": 54,
+    "copy_floor": 54,
+    "extra_setup_frame_hosting_precision_restoration_charges": 0,
+    "families_per_replica": 760,
+    "five_percent_gate": "35491136290869/20000000000000000",
+    "idle_mass": "830",
+    "idle_rank_cap": 51,
+    "kappa_translation_cap_only": "384636577509/250384636577509",
+    "live_ports": 95,
+    "most_favorable_center_rank_profile": {
+      "5": 1,
+      "7": 7
+    },
+    "negative_controls": {
+      "floor_upper_below_five_percent_gate": true,
+      "floor_upper_below_selected": true,
+      "rank_55_profiles": {
+        "exceptional_rank_6": {
+          "a_ceiling_interval": [
+            "1488030253437/1000000000000000",
+            "744015126719/500000000000000"
+          ],
+          "center_charge": 55,
+          "profile": {
+            "1": 2293,
+            "2": 418,
+            "3": 432,
+            "4": 125,
+            "5": 65,
+            "6": 1,
+            "7": 7
+          }
+        },
+        "one_regular_rank_8": {
+          "a_ceiling_interval": [
+            "1488053610999/1000000000000000",
+            "1488053611/1000000000000"
+          ],
+          "center_charge": 55,
+          "profile": {
+            "1": 2293,
+            "2": 418,
+            "3": 432,
+            "4": 125,
+            "5": 66,
+            "7": 6,
+            "8": 1
+          }
+        }
+      }
+    },
+    "p_total": 25,
+    "per_call_local_profile": {
+      "1": 2293,
+      "2": 418,
+      "3": 432,
+      "4": 125,
+      "5": 66,
+      "7": 7
+    },
+    "relative_to_selected_upper_percent": "-8.964671500054",
+    "selected_a_ceiling_upper": "1690054109089/1000000000000000",
+    "stages": 9
+  },
+  "pins": {
+    "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+    "review_sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb",
+    "selected_certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045",
+    "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+    "source_manifest_sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+  },
+  "status": "PASS_P25_ROOT_PAIR_BOUND",
+  "support_census": {
+    "all_extremal_live_spans": [
+      7
+    ],
+    "candidate_functional_pairs_per_root": 130305,
+    "extremal_mask_root_pairs_sha256": "ffda2df06beb08f68652d04030ebbaf46e9e855b1425d5c4348d508c20bb5da2",
+    "global_unique_size_25_masks": 7560,
+    "label_pairing_rank": 9,
+    "maximum_root_normals_per_mask": 1,
+    "minimum_punctures_for_live_label_span_at_most_7": 25,
+    "negative_controls": {
+      "24_puncture_near_miss_span_8": 8,
+      "all_120_roots_first_drop_at_25": true,
+      "same_puncture_other_root_span_at_least_8": true
+    },
+    "pair_representations_per_mask": 3,
+    "positive_fixture": {
+      "live_span": 7,
+      "minimum_other_root_span": 8,
+      "one_puncture_restored_span": 8,
+      "puncture_mask_hex": "0xffff000000000003c03d",
+      "root_index": 0
+    },
+    "root_lines": 120,
+    "root_normal_count": 120,
+    "size_25_unordered_functional_pairs_per_root": 189,
+    "unique_size_25_masks_per_root": 63
+  }
+}
diff --git a/research/p25-root-pair-bound-seed632639/README.md b/research/p25-root-pair-bound-seed632639/README.md
new file mode 100644
index 0000000000..875c92a1d1
--- /dev/null
+++ b/research/p25-root-pair-bound-seed632639/README.md
@@ -0,0 +1,136 @@
+# The p=25 root-pair support boundary misses the local-word gate
+
+**Scoped structural obstruction; no supplier or new κ.** For eight-term exact
+all-pairs decoders whose row and column normals are E8 roots, an exact 25-line
+puncture can lower at most one root-normal support to a seven-dimensional
+label span. The resulting separate-copy bill is at least **54**. Its most
+favorable profile under the pinned selected-word relaxation has ceiling
+`a < 0.001538546310036`, about **8.965% below** the selected local-word ceiling.
+The support transition at the first puncture beyond the p≤24 floor is exact,
+but it cannot supply the task's 5% gain inside this root-pair family.
+
+## Exact support result
+
+Use the 120 E8 root lines and the binary pairing
+
+```text
+B[i,j] = ( <r_i,r_j> + 1 ) mod 2.
+```
+
+For a root normal `a`, let `C(a)` be the lines with nonzero real inner product
+with `a`. The live support label span drops to dimension at most seven exactly
+when two independent functionals of the nine-dimensional label space vanish
+on every live label. The corresponding puncture mask is the union of their
+violators, intersected with `C(a)`.
+
+The exact enumeration checks all 130,305 distinct functional pairs for each of
+the 120 root normals. For every root, the least such union has 25 lines. There
+are 189 pair representatives and 63 distinct masks of that size per root; each
+mask has three pair representatives and leaves span exactly seven. Across all
+roots, the 7,560 masks are distinct: one mask never lowers two root-normal
+supports. Reinstating any one punctured line in a positive fixture returns its
+support span to eight.
+
+For a root-pair decoder, the row and column normals in each term are roots and
+the two eight-element normal lists are dual bases. The F2 rank inequality gives
+
+```text
+copy(term) >= dim(row labels) + dim(column labels) - 9.
+```
+
+Every term without the unique seven-span root has bill at least seven. Duality
+forces the unique exceptional root, if used on both sides, to occur in the same
+term. That term costs at least five when used on both sides, or six when used
+on only one. Thus the total copy bill is at least `5 + 7*7 = 54` (and at
+least 55 if the exceptional root is used on only one side). If no support drops,
+the total is at least 56. The bound covers every 25-line puncture in this
+root-pair family. It does not cover arbitrary real or complex dual bases,
+masked identities, or nine or more terms.
+
+## Optimistic price
+
+The selected #1094 local profile and ceiling calculator are pinned in
+[SOURCES.json](SOURCES.json). Moving from its 112 ports to 95 ports removes 17
+ports under PR717's favorable per-port model. The support floor 54 is priced
+with the most favorable compatible rank histogram, one rank-five center child
+and seven rank-seven center children. Added setup, frame, hosting, precision,
+transition, and restoration costs are all set to zero. Raising any one center
+rank raises its child moment and its center charge by the same amount, leaving
+idle mass fixed; therefore this minimum rank vector upper-bounds the ceiling
+of every more expensive root-pair invoice. The verifier also screens two
+one-unit rank increases as controls.
+
+| Quantity | Value |
+|---|---:|
+| Total punctures / live ports | 25 / 95 |
+| Added port reductions from P112 | 17 |
+| Separate-copy floor | 54 |
+| Per-call local profile | `{1:2293, 2:418, 3:432, 4:125, 5:66, 7:7}` |
+| Families / stages / center charge | `760 / 9 / 54` |
+| Idle rank cap / idle mass | `51 / 830` |
+| Certified `a` interval | `[0.001538546310035, 0.001538546310036]` |
+| Selected `a` ceiling upper endpoint | `0.001690054109089` |
+| Five-percent gate | `0.00177455681454345` |
+
+The exact upper endpoint is below the selected ceiling itself, so no allocation
+of idle work or additional physical overhead can make this p=25 root-pair route
+pass the card's gate under the stated coverage law and halving guard. The
+`kappa` translation recorded in [CERTIFICATE.json](CERTIFICATE.json) is only a
+planning cap; it is not a new supplier or exponent result.
+
+## Provenance and overlap
+
+- Exact base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`.
+- Accepted assignment: seed `632639f1d387026a8b953fa82c286d82`,
+  `complex-mechanisms / complex-rank-shape-decoder`, priority revision 4.
+- Catalogue SHA-256: `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`.
+- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Selected certificate SHA-256: `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`.
+- Selected review SHA-256: `7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb`.
+- Selected source-manifest SHA-256: `79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b`.
+- The selected-record reproduction command is `make frontier1094-verify`; it was not rerun because this package does not alter the selected source chain.
+
+PR717/PR968 and [the frame-pair package](../complex-frame-pair-decoders/PROOF.md)
+establish the exact eight-term copy floor through 24 punctures. PR1619 prices
+that range. PR1624 and [Discussion #1570](https://github.com/CrocSwap/integer-mult-bounds/discussions/1570)
+handle one fixed p=26 paired-normal object. This result covers the p=25
+root-pair family as a whole; it does not audit or extend that fixed p=26
+completion. The active ten-term P112 gauge and rank-six schedule claims were
+checked before the scope claim and use different objects.
+
+The scope claim and handoff are tracked at
+[Discussion #1167 comment 18937692](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692).
+
+## Reproduce
+
+From the repository root:
+
+```sh
+python3 -I -B research/p25-root-pair-bound-seed632639/verify.py
+python3 scripts/research_package.py --package research/p25-root-pair-bound-seed632639 --check-only
+python3.12 scripts/research_package.py --package research/p25-root-pair-bound-seed632639
+```
+
+To regenerate the deterministic certificate, run the verifier with `--write`.
+The implementation uses exact integer and rational arithmetic, checks input
+hashes and Git object pins, enumerates the complete functional-pair domain, and
+recomputes the moment bracket with the pinned standard-library ceiling engine.
+
+## Open next questions
+
+Can a non-root dual basis or an overcomplete/masked decoder at p=25 avoid the
+one-exceptional-root restriction and pass the fully charged local moment gate?
+That would test a genuinely broader support mechanism. The first step is to
+choose one explicit non-root support alphabet, derive its exact support-rank
+floor, and screen the complete profile before building a local network. No
+source-aligned frame, hosting, precision, or restoration invoice for such a
+family is presently identified.
+
+## Credit
+
+The E8 root and label model, p≤24 argument, selected ceiling, and p=26 fixed
+completion retain their original PR and author credit in the pinned sources.
+Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope
+selection, exact enumeration, cost screening, verifier implementation, and
+writing. No independent human or proof-assistant review is claimed. New work
+is Apache-2.0.
diff --git a/research/p25-root-pair-bound-seed632639/SOURCES.json b/research/p25-root-pair-bound-seed632639/SOURCES.json
new file mode 100644
index 0000000000..55e951d0cb
--- /dev/null
+++ b/research/p25-root-pair-bound-seed632639/SOURCES.json
@@ -0,0 +1,96 @@
+{
+  "schema_version": 1,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "files": [
+    {
+      "path": "AGENTS.md",
+      "usage": "provenance",
+      "git_blob": "1dce1b16a687a5d1a507ef64b9d4da19dd9e43f9",
+      "sha256": "5378ffbf3a119fcd0c23bcce20f34e5dd2fa792a00a0033e47667aeba72bbc37"
+    },
+    {
+      "path": "CONTRIBUTING.md",
+      "usage": "provenance",
+      "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853",
+      "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a"
+    },
+    {
+      "path": "autoresearch.md",
+      "usage": "provenance",
+      "git_blob": "9b6cbfef0fb725f28c177038d32f482706e12c94",
+      "sha256": "79d0c8be61d90dd6c46b6e7250e0c88713d29854128d8d1361b6343682dad1d8"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "e8870e5917057d59b730eb14721a778639eca050",
+      "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "input",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "input",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "input",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/complex-frame-pair-decoders/PROOF.md",
+      "usage": "input",
+      "git_blob": "889f3a653ed1bdbb7df61ebe3af4f2103602a1f4",
+      "sha256": "ba53c1d8a9bc2d935d546bde46ca7341bd65f8515013e07b073296b4db2a9a74"
+    },
+    {
+      "path": "research/complex-frame-pair-decoders/SOURCES.json",
+      "usage": "input",
+      "git_blob": "2adbb52d527060abc1cefdf923b5250b65269278",
+      "sha256": "488af5eba0f500fe0bff3c9709ab4cd3ba4529f289a162b9f132b5e2401b24da"
+    },
+    {
+      "path": "research/complex-frame-pair-decoders/verify.py",
+      "usage": "input",
+      "git_blob": "57dd8993e8ac016e8a92a9a885392b58014137bb",
+      "sha256": "bdf7ee497dc04dfc634ee5b7848f6a2b39b0169668fb1a60a9715111dbd15395"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/RESULT.json",
+      "usage": "input",
+      "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9",
+      "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/ceiling.py",
+      "usage": "input",
+      "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c",
+      "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+    },
+    {
+      "path": "research/complex-paired26-completion/README.md",
+      "usage": "input",
+      "git_blob": "6712df1150d88a8b5ecc51871e8919fac93766e3",
+      "sha256": "ba2ebeb515190b7279ee490cd2ed450c9a48e91a22602ac7e384b9840367c0bc"
+    },
+    {
+      "path": "research/complex-paired26-completion/proof.md",
+      "usage": "input",
+      "git_blob": "4a89efa74126836857c73fddc48147b0446ec4d7",
+      "sha256": "0305c955d39a0b11b9e3a3b58606882ceb85daac765050583645765c7a35fad3"
+    }
+  ]
+}
diff --git a/research/p25-root-pair-bound-seed632639/TASK.json b/research/p25-root-pair-bound-seed632639/TASK.json
new file mode 100644
index 0000000000..110a0fec82
--- /dev/null
+++ b/research/p25-root-pair-bound-seed632639/TASK.json
@@ -0,0 +1,95 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 4,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md",
+      "research/selected-k8-unrestricted-ends/README.md",
+      "research/eisenstein-reduction-copy-floor/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope.",
+      "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.",
+      "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "For every 25-line puncture of the 120 E8 root lines, classify root-normal supports with live label span at most seven, derive the separate COPY floor for exact eight-term root-pair dual-basis decoders, and price the best compatible profile under the pinned selected-word ceiling.",
+  "scope_change_reason": "The selector card focuses on larger-rank block climbs. The bounded experiment changes the proved eight-term all-pairs puncture range from p<=24 to exactly p=25 and restricts the decoder to root-pair dual bases. This is the first support-rank boundary beyond the prior floor and gives a precise exact mask census; the selected-word screen rejects this family before network synthesis.",
+  "bottleneck_link": "A support-rank drop can lower the copied-information charge and replace rank-eight centre children with smaller-rank children. The complete favorable profile test determines whether this newly reachable boundary can change the selected recursive moment.",
+  "budget_minutes": 60,
+  "stop_rule": "Enumerate all 130305 distinct functional pairs for each of 120 root normals, classify every size-25 extremal mask, prove the root-pair copy floor, and screen its best compatible histogram. Stop without searching another family if its zero-overhead ceiling is below the selected word.",
+  "outcome": "negative-result",
+  "evidence": "CERTIFICATE.json: 7560 distinct p=25 masks, each shared by one root normal only; every residual support has dimension seven; root-pair COPY >=54; exact best-case a upper 0.001538546310036, below selected 0.001690054109089 and the +5% gate.",
+  "author": "Cinna Davis",
+  "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, exact enumeration, proof development, cost screening, verifier implementation, and writing. No independent human or proof-assistant review is claimed.",
+  "open_questions": [
+    {
+      "question": "Can a non-root dual basis or an overcomplete/masked decoder at p=25 avoid the one-exceptional-root restriction and pass the fully charged local moment gate?",
+      "why_it_matters": "The exact result closes only eight-term root-pair dual bases; a broader support alphabet may permit several larger-rank children and change the paid local profile.",
+      "first_step": "Choose one explicit non-root support alphabet, derive its exact F2 support-rank floor, and screen the complete per-call profile before constructing a network.",
+      "blocked_by": "No source-aligned frame or complete setup, hosting, precision, and restoration invoice is currently identified for a changed support alphabet."
+    }
+  ],
+  "track": "complex-mechanisms",
+  "research_seed": "632639f1d387026a8b953fa82c286d82",
+  "selector_scope_key": "02b31ebd160542c86299",
+  "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7",
+  "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+  "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692",
+  "overlap_checked_at": "2026-10-15T01:13:02Z",
+  "predecessors": [
+    {
+      "reference": "PR717 / PR968; research/complex-frame-pair-decoders",
+      "relation": "Exact eight-term root-pair model and copy floor through p<=24; new scope begins at p=25."
+    },
+    {
+      "reference": "PR1619",
+      "relation": "Per-port and copy-charge favorable ceiling prices for p<=24; this package applies the pinned model at 17 added ports."
+    },
+    {
+      "reference": "PR1624 / Discussion #1570",
+      "relation": "One fixed p=26 paired-normal completion; this result is the p=25 root-pair family census, not that fixed object."
+    },
+    {
+      "reference": "PR2061, PR2062, PR2228; Discussions #1622, #1952, #2119",
+      "relation": "Nearby overcomplete, masked, root-unit, and phase-schedule scopes checked and distinguished before claiming."
+    }
+  ]
+}
diff --git a/research/p25-root-pair-bound-seed632639/VERIFY.json b/research/p25-root-pair-bound-seed632639/VERIFY.json
new file mode 100644
index 0000000000..df0e0319d5
--- /dev/null
+++ b/research/p25-root-pair-bound-seed632639/VERIFY.json
@@ -0,0 +1,41 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "docs/research/community-batch1099-review.md",
+    "research/community-frontier1094-audit/ASSEMBLY.json",
+    "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+    "research/complex-frame-pair-decoders/PROOF.md",
+    "research/complex-frame-pair-decoders/SOURCES.json",
+    "research/complex-frame-pair-decoders/verify.py",
+    "research/complex-local-word-ceiling/RESULT.json",
+    "research/complex-local-word-ceiling/ceiling.py",
+    "research/complex-paired26-completion/README.md",
+    "research/complex-paired26-completion/proof.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Exact 120-root by 130305-functional-pair support census, unique p=25 masks, dual-basis COPY lower bound, pinned exact ceiling, positive support fixture and 24-puncture/rank-increase negative controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Repeat the full exact certificate replay with Python optimization enabled; all rejection controls use explicit checks and remain active."
+    }
+  ]
+}
diff --git a/research/p25-root-pair-bound-seed632639/verify.py b/research/p25-root-pair-bound-seed632639/verify.py
new file mode 100644
index 0000000000..e2eb4848a5
--- /dev/null
+++ b/research/p25-root-pair-bound-seed632639/verify.py
@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+"""Exact p=25 support census and optimistic price for E8 root-pair decoders."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import itertools
+import json
+import subprocess
+from collections import Counter
+from fractions import Fraction
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def require(ok: bool, message: str) -> None:
+    if not ok:
+        raise ValueError(message)
+
+
+def read_json(path: Path):
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def check_pins() -> dict:
+    source = read_json(HERE / "SOURCES.json")
+    base = source["base_commit"]
+    rows = source["files"]
+    for row in rows:
+        path = ROOT / row["path"]
+        payload = path.read_bytes()
+        require(hashlib.sha256(payload).hexdigest() == row["sha256"],
+                "working input SHA drift: " + row["path"])
+        blob = subprocess.check_output(
+            ["git", "rev-parse", f"{base}:{row['path']}"], cwd=ROOT, text=True
+        ).strip()
+        require(blob == row["git_blob"], "Git blob drift: " + row["path"])
+    by_path = {r["path"]: r for r in rows}
+    selected = read_json(ROOT / "certificates/selected-result.json")
+    require(by_path["certificates/selected-result.json"]["sha256"] ==
+            hashlib.sha256((ROOT / "certificates/selected-result.json").read_bytes()).hexdigest(),
+            "selected record pin mismatch")
+    require(selected["certificate_sha256"] == by_path[
+        "research/community-frontier1094-audit/ASSEMBLY.json"]["sha256"],
+        "selected certificate hash mismatch")
+    require(selected["proof"] == "docs/research/community-batch1099-review.md",
+            "selected review path drift")
+    return {"base_commit": base,
+            "selected_record_sha256": by_path["certificates/selected-result.json"]["sha256"],
+            "selected_certificate_sha256": selected["certificate_sha256"],
+            "review_sha256": by_path[selected["proof"]]["sha256"],
+            "source_manifest_sha256": by_path[
+                "research/community-frontier1094-audit/SELECTED-SOURCE.json"]["sha256"]}
+
+
+def neg(v):
+    return tuple(-x for x in v)
+
+
+def e8_lines():
+    roots = []
+    for i, j in itertools.combinations(range(8), 2):
+        for si in (1, -1):
+            for sj in (1, -1):
+                v = [0] * 8
+                v[i], v[j] = 2 * si, 2 * sj
+                roots.append(tuple(v))
+    for signs in itertools.product((1, -1), repeat=8):
+        if signs.count(-1) % 2 == 0:
+            roots.append(tuple(signs))
+    lines = []
+    seen = set()
+    for root in roots:
+        line = root if root > neg(root) else neg(root)
+        if line not in seen:
+            seen.add(line)
+            lines.append(line)
+    require(len(roots) == 240 and len(lines) == 120, "E8 root-line construction failed")
+    return lines
+
+
+def dot(x, y):
+    return sum(a * b for a, b in zip(x, y))
+
+
+def f2_rank(rows):
+    basis = {}
+    for value in rows:
+        value = int(value)
+        while value:
+            pivot = value.bit_length() - 1
+            if pivot in basis:
+                value ^= basis[pivot]
+            else:
+                basis[pivot] = value
+                break
+    return len(basis)
+
+
+def exact_support_census():
+    lines = e8_lines()
+    ip = []
+    for a in lines:
+        row = []
+        for b in lines:
+            d = dot(a, b)
+            require(d % 4 == 0, "nonintegral E8 inner product")
+            row.append(d // 4)
+        ip.append(row)
+    label_rows = [sum(((ip[i][j] + 1) & 1) << j for j in range(120))
+                  for i in range(120)]
+    require(f2_rank(label_rows) == 9, "the label-pairing code is not rank nine")
+
+    # Coordinates in any selected basis of the nine-dimensional label span.
+    basis_lines = []
+    for i, row in enumerate(label_rows):
+        if f2_rank([label_rows[j] for j in basis_lines] + [row]) == len(basis_lines) + 1:
+            basis_lines.append(i)
+        if len(basis_lines) == 9:
+            break
+    require(len(basis_lines) == 9, "failed to extract label coordinates")
+    phi = [sum(((row >> j) & 1) << k for k, j in enumerate(basis_lines))
+           for row in label_rows]
+    lambdas = list(range(1, 512))
+    violators = []
+    for lam in lambdas:
+        violators.append(sum(((phi[i] & lam).bit_count() % 2) << i for i in range(120)))
+
+    global_owners = {}
+    per_root = []
+    witness = None
+    for alpha in range(120):
+        support = sum((ip[alpha][i] != 0) << i for i in range(120))
+        minima = 121
+        candidate_pair_count = 0
+        masks = Counter()
+        for x in range(511):
+            vx = violators[x] & support
+            for y in range(x + 1, 511):
+                puncture = vx | (violators[y] & support)
+                size = puncture.bit_count()
+                if size < minima:
+                    minima = size
+                if size != 25:
+                    continue
+                candidate_pair_count += 1
+                masks[puncture] += 1
+                live_labels = [label_rows[i] for i in range(120)
+                               if ((support >> i) & 1) and not ((puncture >> i) & 1)]
+                rank = f2_rank(live_labels)
+                require(rank == 7, "a size-25 pair mask has live span other than seven")
+                if witness is None:
+                    witness = (alpha, support, puncture, rank)
+                global_owners.setdefault(puncture, set()).add(alpha)
+        require(minima == 25, "root support does not first drop at 25 punctures")
+        require(candidate_pair_count == 189, "unexpected number of ordered-independent pair representatives")
+        require(len(masks) == 63 and set(masks.values()) == {3},
+                "root support does not have 63 masks with three pair representatives each")
+        per_root.append(len(masks))
+
+    require(len(global_owners) == 120 * 63, "wrong global count of exact extremal masks")
+    require(max(len(owners) for owners in global_owners.values()) == 1,
+            "one p=25 mask lowers two root-normal supports to dimension seven")
+    require(all(len(owners) == 1 for owners in global_owners.values()),
+            "an extremal mask has ambiguous root-normal ownership")
+    mask_rows = "".join(f"{puncture:030x}:{next(iter(owners))}\n"
+                        for puncture, owners in sorted(global_owners.items()))
+    require(witness is not None, "missing positive p=25 support witness")
+    alpha, support, puncture, rank = witness
+    added_back = puncture & -puncture
+    near_miss = puncture ^ added_back
+    near_miss_rank = f2_rank([label_rows[i] for i in range(120)
+                              if ((support >> i) & 1) and not ((near_miss >> i) & 1)])
+    require(near_miss_rank == 8, "24-puncture negative control did not restore rank eight")
+    root_supports = [sum((ip[b][i] != 0) << i for i in range(120))
+                     for b in range(120)]
+    other_root_ranks = [f2_rank([label_rows[i] for i in range(120)
+                                 if ((root_supports[b] >> i) & 1)
+                                 and not ((puncture >> i) & 1)])
+                        for b in range(120) if b != alpha]
+    require(min(other_root_ranks) >= 8,
+            "the witness mask unexpectedly lowers another root-normal support")
+
+    return {
+        "root_lines": len(lines),
+        "label_pairing_rank": f2_rank(label_rows),
+        "root_normal_count": 120,
+        "minimum_punctures_for_live_label_span_at_most_7": 25,
+        "candidate_functional_pairs_per_root": 130305,
+        "size_25_unordered_functional_pairs_per_root": 189,
+        "unique_size_25_masks_per_root": 63,
+        "pair_representations_per_mask": 3,
+        "global_unique_size_25_masks": len(global_owners),
+        "extremal_mask_root_pairs_sha256": hashlib.sha256(mask_rows.encode("ascii")).hexdigest(),
+        "maximum_root_normals_per_mask": max(len(x) for x in global_owners.values()),
+        "all_extremal_live_spans": [7],
+        "positive_fixture": {"root_index": alpha, "puncture_mask_hex": hex(puncture),
+                             "live_span": rank, "one_puncture_restored_span": near_miss_rank,
+                             "minimum_other_root_span": min(other_root_ranks)},
+        "negative_controls": {"all_120_roots_first_drop_at_25": True,
+                              "24_puncture_near_miss_span_8": near_miss_rank,
+                              "same_puncture_other_root_span_at_least_8": min(other_root_ranks) >= 8},
+    }
+
+
+def price_floor():
+    result = read_json(ROOT / "research/complex-local-word-ceiling/RESULT.json")
+    selected = result["selected"]
+    baseline = {int(r): int(n) for r, n in selected["local_profile_per_call"].items()}
+    require(baseline == {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8},
+            "selected local profile drift")
+
+    # P112 to P95 removes 17 ports. PR717's favorable per-port knob removes
+    # seven rank-one children plus one rank-four and one rank-five child.
+    local = dict(baseline)
+    extra_ports = 17
+    local[1] -= 7 * extra_ports
+    local[4] -= extra_ports
+    local[5] -= extra_ports
+    port_profile = dict(local)
+
+    spec = importlib.util.spec_from_file_location(
+        "pinned_ceiling", ROOT / "research/complex-local-word-ceiling/ceiling.py")
+    ceiling = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(ceiling)
+
+    def priced_profile(rank_vector):
+        center = sum(rank_vector)
+        profile = dict(port_profile)
+        profile[8] -= 8
+        for rank in rank_vector:
+            profile[rank] = profile.get(rank, 0) + 1
+        profile = {r: n for r, n in profile.items() if n}
+        require(all(n >= 0 for n in profile.values()), "negative candidate child count")
+        interval = ceiling.ceiling(profile, 73, 8 * 95, 9, center,
+                                   grid=Fraction(1, 10**15), R=51)
+        return profile, center, interval
+
+    # The floor profile is the most favorable compatible child profile:
+    # one exceptional term at rank 5 and seven regular terms at rank 7.
+    rank_floor = (5,) + (7,) * 7
+    local, center, (lo, hi) = priced_profile(rank_floor)
+    model = ceiling.model(local, 73, 8 * 95, 9, center, R=51)
+    selected_hi = Fraction(result["ceiling"]["a_ceiling"])
+    gate = selected_hi * Fraction(105, 100)
+    require(hi < selected_hi, "p=25 root-pair floor reaches the selected ceiling")
+    require(hi < gate, "p=25 root-pair floor clears the five-percent gate")
+
+    # Exact negative controls increase the exceptional rank or one regular rank.
+    controls = {}
+    for name, ranks in (("exceptional_rank_6", (6,) + (7,) * 7),
+                        ("one_regular_rank_8", (5,) + (7,) * 6 + (8,))):
+        profile, charge, interval = priced_profile(ranks)
+        require(charge == 55 and interval[1] < hi,
+                "one-unit rank increase did not lower the certified ceiling: " + name)
+        controls[name] = {"center_charge": charge,
+                          "profile": {str(r): n for r, n in sorted(profile.items())},
+                          "a_ceiling_interval": [str(interval[0]), str(interval[1])]}
+    return {
+        "p_total": 25,
+        "additional_ports_from_selected_P112": extra_ports,
+        "live_ports": 95,
+        "families_per_replica": 760,
+        "stages": 9,
+        "copy_floor": 54,
+        "most_favorable_center_rank_profile": {"5": 1, "7": 7},
+        "per_call_local_profile": {str(r): n for r, n in sorted(local.items())},
+        "center_charge": center,
+        "idle_rank_cap": 51,
+        "idle_mass": str(model["idle_mass"]),
+        "a_ceiling_interval": [str(lo), str(hi)],
+        "a_ceiling_upper_decimal": f"{float(hi):.15f}",
+        "selected_a_ceiling_upper": str(selected_hi),
+        "five_percent_gate": str(gate),
+        "relative_to_selected_upper_percent": f"{float((hi / selected_hi - 1) * 100):.12f}",
+        "kappa_translation_cap_only": str(hi / (1 + hi)),
+        "extra_setup_frame_hosting_precision_restoration_charges": 0,
+        "negative_controls": {"rank_55_profiles": controls,
+                              "floor_upper_below_selected": hi < selected_hi,
+                              "floor_upper_below_five_percent_gate": hi < gate},
+    }
+
+
+def build_certificate():
+    pins = check_pins()
+    census = exact_support_census()
+    # Binary rank inequality: rank(X,Y) >= dim(X)+dim(Y)-9.
+    # At most one of the 16 basis normals can be the unique seven-span root.
+    # Its term costs at least 5; each other term has two spans >=8 and costs >=7.
+    copy = {
+        "pairing_rank_inequality": "rank(X,Y) >= dim(X)+dim(Y)-9",
+        "ordinary_term_floor": 7,
+        "unique_exceptional_root_span": 7,
+        "exceptional_term_floor_if_used_on_one_side": 6,
+        "exceptional_term_floor_if_used_on_both_sides_of_same_dual_term": 5,
+        "number_of_terms_below_7": "at most one",
+        "total_copy_floor": 54,
+        "scope": "exact eight-term all-pairs decoders whose row and column normals are E8 roots, at exactly 25 punctures",
+        "reason": "one p=25 puncture mask lowers at most one root-normal support; distinctness and duality place it in at most one term",
+        "negative_controls": {"regular_seven_term_floor": 49,
+                              "exceptional_pair_bound": 5,
+                              "total_floor_recomputed": 5 + 7 * 7 == 54},
+    }
+    price = price_floor()
+    return {"status": "PASS_P25_ROOT_PAIR_BOUND",
+            "pins": pins,
+            "support_census": census,
+            "copy_bound": copy,
+            "optimistic_price": price,
+            "conclusion": "The complete root-pair family at p=25 misses the selected local-word ceiling gate even with zero added implementation charges."}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--write", action="store_true", help="write the deterministic certificate")
+    args = parser.parse_args()
+    certificate = build_certificate()
+    path = HERE / "CERTIFICATE.json"
+    encoded = json.dumps(certificate, indent=2, sort_keys=True) + "\n"
+    if args.write:
+        path.write_text(encoded, encoding="utf-8")
+    else:
+        require(path.is_file(), "missing CERTIFICATE.json; run verify.py --write once")
+        require(path.read_text(encoding="utf-8") == encoded, "saved certificate differs from exact replay")
+    print("PASS_P25_ROOT_PAIR_BOUND masks=" + str(certificate["support_census"]["global_unique_size_25_masks"])
+          + " max_root_normals_per_mask=" + str(certificate["support_census"]["maximum_root_normals_per_mask"])
+          + " copy_floor=" + str(certificate["copy_bound"]["total_copy_floor"])
+          + " a_hi=" + certificate["optimistic_price"]["a_ceiling_upper_decimal"])
+
+
+if __name__ == "__main__":
+    main()

From 73cd7eb4ffe4620aa2e7ca20695650d4c537e641 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:25:19 -0500
Subject: [PATCH 2/6] Pin p=25 decoder predecessors

---
 .../p25-root-pair-bound-seed632639/README.md  | 20 ++++++++++------
 .../p25-root-pair-bound-seed632639/TASK.json  | 24 ++++++++++++++++++-
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/research/p25-root-pair-bound-seed632639/README.md b/research/p25-root-pair-bound-seed632639/README.md
index 875c92a1d1..51dc99cd6c 100644
--- a/research/p25-root-pair-bound-seed632639/README.md
+++ b/research/p25-root-pair-bound-seed632639/README.md
@@ -90,13 +90,19 @@ planning cap; it is not a new supplier or exponent result.
 - Selected source-manifest SHA-256: `79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b`.
 - The selected-record reproduction command is `make frontier1094-verify`; it was not rerun because this package does not alter the selected source chain.
 
-PR717/PR968 and [the frame-pair package](../complex-frame-pair-decoders/PROOF.md)
-establish the exact eight-term copy floor through 24 punctures. PR1619 prices
-that range. PR1624 and [Discussion #1570](https://github.com/CrocSwap/integer-mult-bounds/discussions/1570)
-handle one fixed p=26 paired-normal object. This result covers the p=25
-root-pair family as a whole; it does not audit or extend that fixed p=26
-completion. The active ten-term P112 gauge and rank-six schedule claims were
-checked before the scope claim and use different objects.
+PR717 head `4a97676294f9fa413b65986e9984fddeda71e4cc` and PR968 head
+`6a99e7240b961ac5e115ae6aa0301ec7c4a45d77` establish the exact eight-term
+copy-floor lineage through 24 punctures, retained in
+[the frame-pair package](../complex-frame-pair-decoders/PROOF.md). PR1619 head
+`6c96bc1a0e374a713e9ae493228247f49be49dd5` prices that range. PR1624 head
+`712a9b9aa8802d0135a578c0debee7b56c8e492f` and
+[Discussion #1570](https://github.com/CrocSwap/integer-mult-bounds/discussions/1570)
+handle one fixed p=26 paired-normal object, with PR1020 head
+`bf4ee95df4ee6e3101a88f5d015c8aa85b688b6d` credited for its puncture and
+baseline decoder. This result covers the p=25 root-pair family as a whole; it
+does not audit or extend that fixed p=26 completion. The active ten-term P112
+gauge and rank-six schedule claims were checked before the scope claim and use
+different objects.
 
 The scope claim and handoff are tracked at
 [Discussion #1167 comment 18937692](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692).
diff --git a/research/p25-root-pair-bound-seed632639/TASK.json b/research/p25-root-pair-bound-seed632639/TASK.json
index 110a0fec82..638b1a878e 100644
--- a/research/p25-root-pair-bound-seed632639/TASK.json
+++ b/research/p25-root-pair-bound-seed632639/TASK.json
@@ -91,5 +91,27 @@
       "reference": "PR2061, PR2062, PR2228; Discussions #1622, #1952, #2119",
       "relation": "Nearby overcomplete, masked, root-unit, and phase-schedule scopes checked and distinguished before claiming."
     }
-  ]
+  ],
+  "predecessor_heads": {
+    "PR717": {
+      "head": "4a97676294f9fa413b65986e9984fddeda71e4cc",
+      "merge_commit": null
+    },
+    "PR968": {
+      "head": "6a99e7240b961ac5e115ae6aa0301ec7c4a45d77",
+      "merge_commit": "55645f9d4d806d67875c1c8b9840b0b039ece22e"
+    },
+    "PR1619": {
+      "head": "6c96bc1a0e374a713e9ae493228247f49be49dd5",
+      "merge_commit": "cf162d9439aa654c013cc288869ae6dd18ca3e0d"
+    },
+    "PR1624": {
+      "head": "712a9b9aa8802d0135a578c0debee7b56c8e492f",
+      "merge_commit": "299eb8effe080183313757ac36e76c1b98ed9fae"
+    },
+    "PR1020": {
+      "head": "bf4ee95df4ee6e3101a88f5d015c8aa85b688b6d",
+      "role": "fixed p=26 puncture and prior decoder"
+    }
+  }
 }

From 593cea1911a3d7700ecc3833b7c777bbee7ecf12 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:29:02 -0500
Subject: [PATCH 3/6] Record live p25 decoder overlap

---
 .../p25-root-pair-bound-seed632639/README.md     | 13 ++++++++++---
 .../p25-root-pair-bound-seed632639/TASK.json     | 16 ++++++++++++++++
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/research/p25-root-pair-bound-seed632639/README.md b/research/p25-root-pair-bound-seed632639/README.md
index 51dc99cd6c..85c43c8c21 100644
--- a/research/p25-root-pair-bound-seed632639/README.md
+++ b/research/p25-root-pair-bound-seed632639/README.md
@@ -100,9 +100,16 @@ copy-floor lineage through 24 punctures, retained in
 handle one fixed p=26 paired-normal object, with PR1020 head
 `bf4ee95df4ee6e3101a88f5d015c8aa85b688b6d` credited for its puncture and
 baseline decoder. This result covers the p=25 root-pair family as a whole; it
-does not audit or extend that fixed p=26 completion. The active ten-term P112
-gauge and rank-six schedule claims were checked before the scope claim and use
-different objects.
+does not audit or extend that fixed p=26 completion. The pre-submission refresh
+also found open PR #2232 (head `3391f27dd0f226f0e1ead8b2b829eb6d3ec567d3`), an
+E6 rank-four projected-Gram screen with an adapted pairing. It uses 36 E6 lines
+and four-term projections, not the E8 p=25 root-pair support family here. Open
+PR #2228 (head `ad1757e319225f3a5b86e3d3fa72897bd9f6db40`) gives a general dense
+root-code floor and lists E8, P112 and P104 cases; its broader framework is
+adjacent, while this package contributes the exact p=25 extremal-mask census
+and an eight-term dual-root COPY bound. No claim is made that this result
+exceeds the broader root-code theorem. The active ten-term P112 gauge, cyclic
+mask and rank-six schedule claims use different objects.
 
 The scope claim and handoff are tracked at
 [Discussion #1167 comment 18937692](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692).
diff --git a/research/p25-root-pair-bound-seed632639/TASK.json b/research/p25-root-pair-bound-seed632639/TASK.json
index 638b1a878e..3415eb8a44 100644
--- a/research/p25-root-pair-bound-seed632639/TASK.json
+++ b/research/p25-root-pair-bound-seed632639/TASK.json
@@ -112,6 +112,22 @@
     "PR1020": {
       "head": "bf4ee95df4ee6e3101a88f5d015c8aa85b688b6d",
       "role": "fixed p=26 puncture and prior decoder"
+    },
+    "PR2228": {
+      "head": "ad1757e319225f3a5b86e3d3fa72897bd9f6db40",
+      "status": "open; general dense root-code floor, adjacent framework"
+    },
+    "PR2232": {
+      "head": "3391f27dd0f226f0e1ead8b2b829eb6d3ec567d3",
+      "status": "open; distinct E6 rank-four projected-Gram adapted-pairing screen"
     }
+  },
+  "final_overlap_snapshot": {
+    "open_prs": 470,
+    "open_prs_fetched_at": "2026-10-15T01:23:58Z",
+    "discussions": 931,
+    "discussions_fetched_at": "2026-10-15T01:27:13Z",
+    "complete_pagination": true,
+    "warnings": []
   }
 }

From 2cf4b737dd3f7e4b347212015af21b04779fc99a Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:30:06 -0500
Subject: [PATCH 4/6] Link p25 support result for review

---
 research/p25-root-pair-bound-seed632639/README.md | 3 +++
 research/p25-root-pair-bound-seed632639/TASK.json | 5 +++++
 2 files changed, 8 insertions(+)

diff --git a/research/p25-root-pair-bound-seed632639/README.md b/research/p25-root-pair-bound-seed632639/README.md
index 85c43c8c21..e190b6c439 100644
--- a/research/p25-root-pair-bound-seed632639/README.md
+++ b/research/p25-root-pair-bound-seed632639/README.md
@@ -113,6 +113,9 @@ mask and rank-six schedule claims use different objects.
 
 The scope claim and handoff are tracked at
 [Discussion #1167 comment 18937692](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692).
+The focused package is submitted for review as
+[PR #2237](https://github.com/CrocSwap/integer-mult-bounds/pull/2237), head
+`593cea1911a3d7700ecc3833b7c777bbee7ecf12`.
 
 ## Reproduce
 
diff --git a/research/p25-root-pair-bound-seed632639/TASK.json b/research/p25-root-pair-bound-seed632639/TASK.json
index 3415eb8a44..70766376bd 100644
--- a/research/p25-root-pair-bound-seed632639/TASK.json
+++ b/research/p25-root-pair-bound-seed632639/TASK.json
@@ -129,5 +129,10 @@
     "discussions_fetched_at": "2026-10-15T01:27:13Z",
     "complete_pagination": true,
     "warnings": []
+  },
+  "pull_request": {
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2237",
+    "head_commit": "593cea1911a3d7700ecc3833b7c777bbee7ecf12",
+    "status": "open; hosted checks pending at 2026-10-15T01:31Z"
   }
 }

From 71b3b00ad5a4c1f277da197f946c5878104a243e Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:30:17 -0500
Subject: [PATCH 5/6] Pin final p25 review head

---
 research/p25-root-pair-bound-seed632639/README.md | 2 +-
 research/p25-root-pair-bound-seed632639/TASK.json | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/research/p25-root-pair-bound-seed632639/README.md b/research/p25-root-pair-bound-seed632639/README.md
index e190b6c439..cc0df95535 100644
--- a/research/p25-root-pair-bound-seed632639/README.md
+++ b/research/p25-root-pair-bound-seed632639/README.md
@@ -115,7 +115,7 @@ The scope claim and handoff are tracked at
 [Discussion #1167 comment 18937692](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692).
 The focused package is submitted for review as
 [PR #2237](https://github.com/CrocSwap/integer-mult-bounds/pull/2237), head
-`593cea1911a3d7700ecc3833b7c777bbee7ecf12`.
+`2cf4b737dd3f7e4b347212015af21b04779fc99a`.
 
 ## Reproduce
 
diff --git a/research/p25-root-pair-bound-seed632639/TASK.json b/research/p25-root-pair-bound-seed632639/TASK.json
index 70766376bd..cbfa235f5c 100644
--- a/research/p25-root-pair-bound-seed632639/TASK.json
+++ b/research/p25-root-pair-bound-seed632639/TASK.json
@@ -132,7 +132,7 @@
   },
   "pull_request": {
     "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2237",
-    "head_commit": "593cea1911a3d7700ecc3833b7c777bbee7ecf12",
-    "status": "open; hosted checks pending at 2026-10-15T01:31Z"
+    "head_commit": "2cf4b737dd3f7e4b347212015af21b04779fc99a",
+    "status": "open; hosted checks pending after final head update"
   }
 }

From bc63155a531d814dd8fa98993d84dc287756ad47 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:30:30 -0500
Subject: [PATCH 6/6] Keep review link stable in package

---
 research/p25-root-pair-bound-seed632639/README.md | 3 +--
 research/p25-root-pair-bound-seed632639/TASK.json | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/research/p25-root-pair-bound-seed632639/README.md b/research/p25-root-pair-bound-seed632639/README.md
index cc0df95535..51f4d6599e 100644
--- a/research/p25-root-pair-bound-seed632639/README.md
+++ b/research/p25-root-pair-bound-seed632639/README.md
@@ -114,8 +114,7 @@ mask and rank-six schedule claims use different objects.
 The scope claim and handoff are tracked at
 [Discussion #1167 comment 18937692](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18937692).
 The focused package is submitted for review as
-[PR #2237](https://github.com/CrocSwap/integer-mult-bounds/pull/2237), head
-`2cf4b737dd3f7e4b347212015af21b04779fc99a`.
+[PR #2237](https://github.com/CrocSwap/integer-mult-bounds/pull/2237).
 
 ## Reproduce
 
diff --git a/research/p25-root-pair-bound-seed632639/TASK.json b/research/p25-root-pair-bound-seed632639/TASK.json
index cbfa235f5c..e669e6b94e 100644
--- a/research/p25-root-pair-bound-seed632639/TASK.json
+++ b/research/p25-root-pair-bound-seed632639/TASK.json
@@ -132,7 +132,6 @@
   },
   "pull_request": {
     "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2237",
-    "head_commit": "2cf4b737dd3f7e4b347212015af21b04779fc99a",
-    "status": "open; hosted checks pending after final head update"
+    "status": "open; hosted checks pending after metadata-only update"
   }
 }