diff --git a/research/five-subset-common-frame-seed48b/ASSIGNMENT.json b/research/five-subset-common-frame-seed48b/ASSIGNMENT.json
new file mode 100644
index 0000000000..0b36521690
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/ASSIGNMENT.json
@@ -0,0 +1,7 @@
+{
+  "seed": 48,
+  "random_source": "secrets.randbelow(100), OS randomness, one fresh draw",
+  "start_utc": "2026-10-13T20:14:05Z",
+  "deadline_utc": "2026-10-13T20:44:05Z",
+  "verification_reserve_utc": "2026-10-13T20:36:35Z"
+}
diff --git a/research/five-subset-common-frame-seed48b/CENSUS.json b/research/five-subset-common-frame-seed48b/CENSUS.json
new file mode 100644
index 0000000000..1a2d8c2e55
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/CENSUS.json
@@ -0,0 +1,875 @@
+{
+  "schema": 1,
+  "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+  "seed": 48,
+  "ambient_dimension": 9,
+  "frame_dimension": 4,
+  "complement_dimension": 5,
+  "domain": "Both sides contain a degenerate pair; constant weight five; one U4/W5; historical orthonormal incident residuals; signed rank one.",
+  "coverage": "Every source pair is coordinate-isomorphic to one of the two anchored pairs. Every U4 containing E is a two-plane in V/E. Every S containing that pair is exhausted; maximal T are normalized signed column classes.",
+  "stopping_rule": "Complete finite exhaustion; no sampled frames or endpoints.",
+  "orbits": [
+    {
+      "source_intersection": 1,
+      "source_pair": [
+        31,
+        481
+      ],
+      "counts": {
+        "degenerate_frames": 1643,
+        "frames_examined": 2667,
+        "frames_with_qualifying_biclique": 1024,
+        "inclusion_maximal_bicliques": 2800,
+        "nondegenerate_frames": 1024,
+        "qualifying_target_classes": 10656,
+        "source_subsets_examined": 9024
+      },
+      "qualifying_sizes": [
+        [
+          2,
+          6,
+          512
+        ],
+        [
+          2,
+          9,
+          512
+        ],
+        [
+          3,
+          3,
+          576
+        ],
+        [
+          3,
+          4,
+          576
+        ],
+        [
+          3,
+          5,
+          288
+        ],
+        [
+          3,
+          6,
+          1440
+        ],
+        [
+          3,
+          7,
+          288
+        ],
+        [
+          3,
+          9,
+          128
+        ],
+        [
+          4,
+          2,
+          144
+        ],
+        [
+          4,
+          3,
+          1440
+        ],
+        [
+          4,
+          4,
+          864
+        ],
+        [
+          4,
+          6,
+          1168
+        ],
+        [
+          5,
+          2,
+          288
+        ],
+        [
+          5,
+          3,
+          1152
+        ],
+        [
+          5,
+          4,
+          288
+        ],
+        [
+          5,
+          6,
+          448
+        ],
+        [
+          6,
+          2,
+          144
+        ],
+        [
+          6,
+          3,
+          288
+        ],
+        [
+          6,
+          6,
+          112
+        ]
+      ],
+      "inclusion_maximal_sizes": [
+        [
+          2,
+          9,
+          384
+        ],
+        [
+          3,
+          5,
+          288
+        ],
+        [
+          3,
+          6,
+          96
+        ],
+        [
+          3,
+          7,
+          288
+        ],
+        [
+          3,
+          9,
+          128
+        ],
+        [
+          4,
+          4,
+          288
+        ],
+        [
+          4,
+          6,
+          496
+        ],
+        [
+          5,
+          4,
+          288
+        ],
+        [
+          6,
+          2,
+          144
+        ],
+        [
+          6,
+          3,
+          288
+        ],
+        [
+          6,
+          6,
+          112
+        ]
+      ],
+      "frame_maximum_area_histogram": [
+        [
+          18,
+          96
+        ],
+        [
+          21,
+          288
+        ],
+        [
+          24,
+          400
+        ],
+        [
+          27,
+          128
+        ],
+        [
+          36,
+          112
+        ]
+      ],
+      "ordered_frame_stream_sha256": "4fe9ea79285edd51d93f010bd246dcfd0f479f2d6f969af41db261fa84d63d0f"
+    },
+    {
+      "source_intersection": 3,
+      "source_pair": [
+        31,
+        103
+      ],
+      "counts": {
+        "degenerate_frames": 1643,
+        "frames_examined": 2667,
+        "frames_with_qualifying_biclique": 960,
+        "inclusion_maximal_bicliques": 2400,
+        "nondegenerate_frames": 1024,
+        "qualifying_target_classes": 9544,
+        "source_subsets_examined": 9136
+      },
+      "qualifying_sizes": [
+        [
+          2,
+          3,
+          288
+        ],
+        [
+          2,
+          4,
+          496
+        ],
+        [
+          2,
+          5,
+          80
+        ],
+        [
+          2,
+          6,
+          240
+        ],
+        [
+          2,
+          7,
+          96
+        ],
+        [
+          3,
+          2,
+          288
+        ],
+        [
+          3,
+          3,
+          1584
+        ],
+        [
+          3,
+          4,
+          824
+        ],
+        [
+          3,
+          5,
+          200
+        ],
+        [
+          3,
+          6,
+          280
+        ],
+        [
+          3,
+          7,
+          48
+        ],
+        [
+          4,
+          2,
+          720
+        ],
+        [
+          4,
+          3,
+          1656
+        ],
+        [
+          4,
+          4,
+          508
+        ],
+        [
+          4,
+          5,
+          72
+        ],
+        [
+          4,
+          6,
+          124
+        ],
+        [
+          5,
+          2,
+          552
+        ],
+        [
+          5,
+          3,
+          960
+        ],
+        [
+          5,
+          4,
+          72
+        ],
+        [
+          5,
+          5,
+          32
+        ],
+        [
+          5,
+          6,
+          16
+        ],
+        [
+          6,
+          2,
+          168
+        ],
+        [
+          6,
+          3,
+          216
+        ],
+        [
+          6,
+          4,
+          12
+        ],
+        [
+          6,
+          5,
+          8
+        ],
+        [
+          6,
+          6,
+          4
+        ]
+      ],
+      "inclusion_maximal_sizes": [
+        [
+          2,
+          4,
+          144
+        ],
+        [
+          2,
+          5,
+          24
+        ],
+        [
+          2,
+          6,
+          72
+        ],
+        [
+          2,
+          7,
+          48
+        ],
+        [
+          3,
+          3,
+          384
+        ],
+        [
+          3,
+          4,
+          168
+        ],
+        [
+          3,
+          5,
+          120
+        ],
+        [
+          3,
+          6,
+          88
+        ],
+        [
+          3,
+          7,
+          48
+        ],
+        [
+          4,
+          2,
+          168
+        ],
+        [
+          4,
+          3,
+          120
+        ],
+        [
+          4,
+          4,
+          364
+        ],
+        [
+          4,
+          5,
+          24
+        ],
+        [
+          4,
+          6,
+          100
+        ],
+        [
+          5,
+          3,
+          96
+        ],
+        [
+          5,
+          4,
+          24
+        ],
+        [
+          6,
+          2,
+          168
+        ],
+        [
+          6,
+          3,
+          216
+        ],
+        [
+          6,
+          4,
+          12
+        ],
+        [
+          6,
+          5,
+          8
+        ],
+        [
+          6,
+          6,
+          4
+        ]
+      ],
+      "frame_maximum_area_histogram": [
+        [
+          0,
+          64
+        ],
+        [
+          9,
+          96
+        ],
+        [
+          12,
+          96
+        ],
+        [
+          15,
+          96
+        ],
+        [
+          16,
+          268
+        ],
+        [
+          18,
+          208
+        ],
+        [
+          20,
+          48
+        ],
+        [
+          21,
+          24
+        ],
+        [
+          24,
+          112
+        ],
+        [
+          30,
+          8
+        ],
+        [
+          36,
+          4
+        ]
+      ],
+      "ordered_frame_stream_sha256": "3ebcd8cacb342dddb95c18b555c42075af077b22ee2095b1c69d2b463df5d6f6"
+    }
+  ],
+  "maximum_area": 36,
+  "common_record_count": 2048,
+  "common_records_sha256": "ac3520884ea295130595b20b4703217ed6838ba49dae1e4ca63412371803be7a",
+  "maximum_dirty_wrapper_saving": 12,
+  "maximum_area_witness": {
+    "frame_basis": [
+      14,
+      17,
+      33,
+      448
+    ],
+    "frame_vectors": [
+      0,
+      14,
+      17,
+      31,
+      33,
+      47,
+      48,
+      62,
+      448,
+      462,
+      465,
+      479,
+      481,
+      495,
+      496,
+      510
+    ],
+    "complement_basis": [
+      6,
+      10,
+      49,
+      192,
+      320
+    ],
+    "frame_characteristic": 462,
+    "complement_characteristic": 49,
+    "sources": [
+      31,
+      47,
+      62,
+      465,
+      481,
+      496
+    ],
+    "targets": [
+      55,
+      59,
+      61,
+      241,
+      369,
+      433
+    ],
+    "source_signs": [
+      1,
+      1,
+      1,
+      -1,
+      -1,
+      -1
+    ],
+    "target_signs": [
+      1,
+      1,
+      1,
+      -1,
+      -1,
+      -1
+    ],
+    "size": [
+      6,
+      6
+    ],
+    "area": 36,
+    "dirty_wrapper_adds": 24,
+    "adds_saved_vs_one_add_per_entry": 12,
+    "wrapper_incident_rank_mass": 84,
+    "incoming_residual_bases": [
+      {
+        "label": 31,
+        "basis": [
+          47,
+          62,
+          448
+        ]
+      },
+      {
+        "label": 47,
+        "basis": [
+          31,
+          62,
+          448
+        ]
+      },
+      {
+        "label": 62,
+        "basis": [
+          31,
+          47,
+          448
+        ]
+      },
+      {
+        "label": 465,
+        "basis": [
+          14,
+          481,
+          496
+        ]
+      },
+      {
+        "label": 481,
+        "basis": [
+          14,
+          465,
+          496
+        ]
+      },
+      {
+        "label": 496,
+        "basis": [
+          14,
+          465,
+          481
+        ]
+      }
+    ],
+    "outgoing_residual_bases": [
+      {
+        "label": 55,
+        "basis": [
+          59,
+          253,
+          381,
+          445
+        ]
+      },
+      {
+        "label": 59,
+        "basis": [
+          55,
+          253,
+          381,
+          445
+        ]
+      },
+      {
+        "label": 61,
+        "basis": [
+          55,
+          251,
+          379,
+          443
+        ]
+      },
+      {
+        "label": 241,
+        "basis": [
+          369,
+          439,
+          443,
+          445
+        ]
+      },
+      {
+        "label": 369,
+        "basis": [
+          241,
+          439,
+          443,
+          445
+        ]
+      },
+      {
+        "label": 433,
+        "basis": [
+          241,
+          375,
+          379,
+          381
+        ]
+      }
+    ]
+  },
+  "maximum_saving_witness": {
+    "frame_basis": [
+      14,
+      17,
+      33,
+      448
+    ],
+    "frame_vectors": [
+      0,
+      14,
+      17,
+      31,
+      33,
+      47,
+      48,
+      62,
+      448,
+      462,
+      465,
+      479,
+      481,
+      495,
+      496,
+      510
+    ],
+    "complement_basis": [
+      6,
+      10,
+      49,
+      192,
+      320
+    ],
+    "frame_characteristic": 462,
+    "complement_characteristic": 49,
+    "sources": [
+      31,
+      47,
+      62,
+      465,
+      481,
+      496
+    ],
+    "targets": [
+      55,
+      59,
+      61,
+      241,
+      369,
+      433
+    ],
+    "source_signs": [
+      1,
+      1,
+      1,
+      -1,
+      -1,
+      -1
+    ],
+    "target_signs": [
+      1,
+      1,
+      1,
+      -1,
+      -1,
+      -1
+    ],
+    "size": [
+      6,
+      6
+    ],
+    "area": 36,
+    "dirty_wrapper_adds": 24,
+    "adds_saved_vs_one_add_per_entry": 12,
+    "wrapper_incident_rank_mass": 84,
+    "incoming_residual_bases": [
+      {
+        "label": 31,
+        "basis": [
+          47,
+          62,
+          448
+        ]
+      },
+      {
+        "label": 47,
+        "basis": [
+          31,
+          62,
+          448
+        ]
+      },
+      {
+        "label": 62,
+        "basis": [
+          31,
+          47,
+          448
+        ]
+      },
+      {
+        "label": 465,
+        "basis": [
+          14,
+          481,
+          496
+        ]
+      },
+      {
+        "label": 481,
+        "basis": [
+          14,
+          465,
+          496
+        ]
+      },
+      {
+        "label": 496,
+        "basis": [
+          14,
+          465,
+          481
+        ]
+      }
+    ],
+    "outgoing_residual_bases": [
+      {
+        "label": 55,
+        "basis": [
+          59,
+          253,
+          381,
+          445
+        ]
+      },
+      {
+        "label": 59,
+        "basis": [
+          55,
+          253,
+          381,
+          445
+        ]
+      },
+      {
+        "label": 61,
+        "basis": [
+          55,
+          251,
+          379,
+          443
+        ]
+      },
+      {
+        "label": 241,
+        "basis": [
+          369,
+          439,
+          443,
+          445
+        ]
+      },
+      {
+        "label": 369,
+        "basis": [
+          241,
+          439,
+          443,
+          445
+        ]
+      },
+      {
+        "label": 433,
+        "basis": [
+          241,
+          375,
+          379,
+          381
+        ]
+      }
+    ]
+  },
+  "scope": "Exact finite geometry and scalar wrapper accounting only; no supplier, paid recurrence or kappa claim."
+}
diff --git a/research/five-subset-common-frame-seed48b/CLAIM.json b/research/five-subset-common-frame-seed48b/CLAIM.json
new file mode 100644
index 0000000000..d5cae23dfc
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/CLAIM.json
@@ -0,0 +1,41 @@
+{
+  "seed": 48,
+  "random_receipt": "ASSIGNMENT.json",
+  "track": "structural decoder research",
+  "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+  "scope_key": "weight5/h9/common-U4-W5/multiway-signed-rank-one/degenerate-both-sides",
+  "question": "Maximum multiway signed rank-one block supported by one common legal orthogonal separator, rather than independently chosen pairwise separators.",
+  "start_utc": "2026-10-13T20:14:05Z",
+  "expected_finish_utc": "2026-10-13T20:44:05Z",
+  "verification_reserve_utc": "2026-10-13T20:36:35Z",
+  "candidates": [
+    {
+      "task": "common-frame multiway star",
+      "chosen": true,
+      "changed_hypothesis": "Simultaneous common separator for >=3 endpoints per side, extending pairwise existence to joint aggregation."
+    },
+    {
+      "task": "optimize bases on four incident interfaces",
+      "chosen": false,
+      "reason": "Rank costs3,3,4,4 are invariant subspace distances, so basis ordering cannot save."
+    },
+    {
+      "task": "mixed odd-weight labels at h8",
+      "chosen": false,
+      "reason": "General norm-one geometry already falls under PR920; poor novelty."
+    }
+  ],
+  "domain": "All U4 containing canonical degenerate source pair of weight5/intersection1 or3 in F2^9; all weight5 endpoints in U and Uperp, excluding characteristic endpoints; signed rank-one SxT with degenerate pair on each side. Complete quotient-plane enumeration, no heuristic seed-only novelty.",
+  "method": "Independent XOR-subspace and Gram/row-elimination enumerations; signed column-class maximization; exact full dirty scalar endpoint columns.",
+  "stopping_rule": "Exhaust finite domain by20:36:35UTC; no wider dimension or unrestricted supplier search.",
+  "optimistic_cost": "For s sources/t targets dirty helper, 2s+2t signed ADDs, preserves arbitrary helper dirt. Nested incident rank bill is 2s*3+2t*4, excludes unresolved physical lifecycle/adoption; determine those before any supplier claim.",
+  "expected_deliverable": "Scoped geometry maximum, explicit multiway residual bases and complete dirty scalar wrapper with reproducible exact verifier; no new kappa.",
+  "coordination": "No pinned coordination issue exists; local claim fallback. Live discussion board and open PRs inspected; pairwise PR1173/1139 and incorporated PR920 credited.",
+  "status": "DONE",
+  "scope_status": "refined",
+  "scope_reason": "The explicit structural track was narrowed before experimentation to simultaneous weight-five common-frame sharing; no catalogue operation-alphabet card was assigned.",
+  "result": "Sharp area36 and dirty-wrapper saving12; explicit6x6 witness with24ADD and twelve residual bases; two exhaustive implementations agree.",
+  "result_link": "https://github.com/ToikY/integer-mult-bounds/tree/codex/structural-seed48b/research/five-subset-common-frame-seed48b",
+  "upstream_refresh": "49b3157d1d89adcef16df8be98445451672be5ba",
+  "final_overlap_through_pr": 1227
+}
diff --git a/research/five-subset-common-frame-seed48b/INDEPENDENT.json b/research/five-subset-common-frame-seed48b/INDEPENDENT.json
new file mode 100644
index 0000000000..c7f8309ac2
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/INDEPENDENT.json
@@ -0,0 +1,99 @@
+{
+  "ambient_dimension": 9,
+  "fixture": {
+    "U_basis_rref": [
+      481,
+      482,
+      52,
+      40
+    ],
+    "characteristic_U": 40,
+    "characteristic_W": 471,
+    "source_signs": [
+      1,
+      1,
+      -1,
+      -1,
+      -1,
+      -1
+    ],
+    "sources": [
+      31,
+      55,
+      457,
+      458,
+      481,
+      482
+    ],
+    "target_signs": [
+      1,
+      1,
+      1,
+      1,
+      1,
+      -1
+    ],
+    "targets": [
+      47,
+      59,
+      87,
+      151,
+      279,
+      451
+    ]
+  },
+  "global_bound_method": "exhaust source subsets and saturate each pivot target by exact 2x2 minors; crude endpoint cardinalities alone give only 54",
+  "legal_record_count": 2048,
+  "legal_records_sha256": "ac3520884ea295130595b20b4703217ed6838ba49dae1e4ca63412371803be7a",
+  "maximum_area": 36,
+  "method": "quotient RREF planes; Gauss-Jordan Gram tests; literal signed 2x2 minor saturation",
+  "negative_control_count": 3,
+  "schema": "independent-common-frame-census-v1",
+  "summaries": [
+    {
+      "area_histogram": {
+        "18": 96,
+        "21": 288,
+        "24": 400,
+        "27": 128,
+        "36": 112
+      },
+      "excluded_singular_planes": 1643,
+      "legal_planes": 1024,
+      "max_available_sources": 6,
+      "max_available_targets": 9,
+      "overlap": 1,
+      "pair": [
+        31,
+        481
+      ],
+      "quotient_planes": 2667
+    },
+    {
+      "area_histogram": {
+        "0": 64,
+        "12": 96,
+        "15": 96,
+        "16": 268,
+        "18": 208,
+        "20": 48,
+        "21": 24,
+        "24": 112,
+        "30": 8,
+        "36": 4,
+        "9": 96
+      },
+      "excluded_singular_planes": 1643,
+      "legal_planes": 1024,
+      "max_available_sources": 6,
+      "max_available_targets": 9,
+      "overlap": 3,
+      "pair": [
+        31,
+        103
+      ],
+      "quotient_planes": 2667
+    }
+  ],
+  "weight": 5
+}
diff --git a/research/five-subset-common-frame-seed48b/NOTICE.md b/research/five-subset-common-frame-seed48b/NOTICE.md
new file mode 100644
index 0000000000..e30d589ce7
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/NOTICE.md
@@ -0,0 +1,26 @@
+Apache-2.0, following the repository license.
+
+Prepared for ToikY with substantial OpenAI Codex assistance in mathematics,
+implementation, separate exact enumerations, verification, review and writing.
+No independent human mathematical review is claimed.
+
+Predecessor credit:
+- Douglas Colkitt: the historical signed parity-side kernel, scalar sharing,
+  dirty-state compiler and common-span obstruction.
+- ArnavSwiggy, PR920 at 913817423bbfaf241dec1d6b9edb1c7ded349508:
+  characteristic-vector residual criterion and four-plus-four floor.
+- woklerx, PR1139 at 82da1e827c51d94691134c6aec346357d89622bc:
+  sharp triple-only ten-coordinate classification.
+- ToikY with OpenAI Codex, PR1173 at 72bfdf66d9823244ee8dab4c8898af834e34853b:
+  sharp weight-five nine-coordinate threshold, pairwise census and the frame
+  extended by this package. Three original documents are retained unchanged
+  in vendor/pr1173, including their original attribution text.
+- ToikY with OpenAI Codex: seed47 constrained frame-completion construction,
+  which explicitly leaves simultaneous residual/frame assignments open.
+- icekylinx with OpenAI GPT-6 Astra: the general Clifford preimage-frame
+  distance, nested transition and dirty-tail formulas.
+- DreamingOfClouds and eumemic: retained format/nested-frame lineage.
+
+This package adds a simultaneous common-frame maximum and a full dirty
+integer-normalized scalar macro. It does not adopt or modify any selected
+supplier, close predecessor PRs, or assert a new multiplication exponent.
diff --git a/research/five-subset-common-frame-seed48b/PROOF.md b/research/five-subset-common-frame-seed48b/PROOF.md
new file mode 100644
index 0000000000..e6b02e3122
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/PROOF.md
@@ -0,0 +1,129 @@
+# One common frame supports at most 36 signed entries
+
+This is a finite structural theorem in the historical parity-side interface.
+It does not establish a physical supplier or a multiplication exponent.
+
+Let V=F2^9 with its standard dot product. Endpoint labels are distinct
+weight-five vectors. A single nondegenerate separator U contains the source
+labels S; U-perp contains the target labels T. Both sides contain a pair
+with dot product one. Each incident residual must have an orthonormal basis.
+The integer-normalized signed kernel is
+
+    K(s,t) = Re(i^popcount(s&t)) = [1,0,-1,0][popcount(s&t) mod 4].
+
+The matrix K on S×T must have rational rank one. This is stronger than
+cross-orthogonality: the latter makes entries nonzero but need not make signs
+factor. A common frame is stronger than independently completing every 2×2
+rectangle, the question addressed by PR1173.
+
+**Result.** In this class |S||T|≤36. A 6×6 block attains 36 with twelve legal
+incident residuals. Among the explicit dirty-helper wrappers described below,
+the maximum saving relative to one signed ADD per entry is twelve ADDs.
+The area upper bound holds for both possible separator dimensions, four and
+five. The finite enumerations explicitly cover dimension four; transposition
+covers dimension five because K is symmetric.
+
+## Reduction to the complete finite census
+
+PR920 supplies the residual criterion: for a nondegenerate binary space X
+and norm-one label x in X, the residual X∩x-perp is alternating exactly when
+x equals the characteristic w_X, defined by w_X·v=v·v. It then has no
+orthonormal basis unless it is zero. A degenerate pair of distinct norm-one
+labels forces dimension at least four if both incident residuals are legal.
+Applying this on both sides gives 4≤dim U≤5 at h=9. These are inherited
+geometric facts, not new classification claims here. Every witness also has
+its actual residual bases checked directly.
+
+For dim U=4, select a degenerate source pair a,b from S. Its intersection has
+odd size. Since the labels are distinct five-subsets of nine coordinates,
+the only possibilities are one and three. Coordinate permutations reduce
+them to (31,481) and (31,103), with masks in little-endian bit coordinates.
+This reduction preserves dot products, weights, kernel signs and the full
+residual interface. It does not claim the anchored counts are counts of
+distinct labeled global frames.
+
+The span E=<a,b> has dimension two. U4 containing E corresponds bijectively
+to a two-plane in V/E, which has dimension seven. There are exactly
+(127×126)/(3×2)=2667 such planes. The primary implementation forms all pairs
+of nonzero quotient cosets and deduplicates their three-element plane sets.
+The independent implementation constructs all rank-two RREF quotient planes.
+Each orbit has 1643 singular and 1024 nondegenerate lifts. For each legal U,
+all eligible labels are enumerated in U and U-perp, excluding characteristics.
+No coordinate-frame restriction or sampled subspace is imposed.
+
+Every source subset containing a,b is tested. For fixed S, nonzero target
+columns belong to one signed rank-one block exactly when they agree up to a
+common sign. Thus a maximal T is an entire normalized column class. Reject
+classes lacking a degenerate target pair. Taking the entire class cannot
+decrease area. It cannot decrease st−2(s+t), since s≥2. This is a complete
+maximization, including nonsaturated subblocks. The independent program uses
+literal 2×2-minor saturation instead of the primary column-pattern grouping.
+
+The two programs agree on all 2048 nondegenerate-frame maximum records,
+including their full endpoint counts and maximizing sizes. Their canonical
+record digest is ac3520884ea295130595b20b4703217ed6838ba49dae1e4ca63412371803be7a.
+The maximum area is 36; the maximum wrapper saving is twelve. Independently,
+AM-GM gives st−2(s+t)≤st−4sqrt(st)≤12 for 4≤st≤36, confirming this saving
+bound from the area theorem. The 6×6 witness attains equality. Some frames
+have nine eligible targets: a simple six-by-six cardinality argument would
+be false. The sign test is essential. Swapping S,T proves the same area and
+symmetric scalar saving bounds for U5.
+
+## Explicit common-frame block and complete scalar wrapper
+
+The fixture extends PR1173's actual frame U=<31,481,3,40>. Its characteristic
+is 40, and the complement characteristic is 471. Use
+
+    S = [31,55,457,458,481,482], alpha = [1,1,-1,-1,-1,-1]
+    T = [47,59,87,151,279,451], beta = [1,1,1,1,1,-1].
+
+Every one of the 36 entries equals alpha_i beta_j. WITNESS.json records an
+orthonormal basis for every incoming residual of dimension three and every
+outgoing residual of dimension four. The independently chosen canonical
+optimum in CENSUS.json is another checked attaining frame.
+
+With immutable sources x_i, dirty accumulating outputs y_j and an arbitrary
+dirty helper q, execute:
+
+1. Six signed ADDs: q += sum alpha_i x_i.
+2. Six signed ADDs: y_j += beta_j q.
+3. Six inverse ADDs in reverse order: q -= sum alpha_i x_i.
+4. Six old-value corrections: y_j -= beta_j q.
+
+The final q equals its original value, sources are unchanged, and each
+y_j gains sum K(s_i,t_j)x_i. Thus the complete word has 24 signed ADDs,
+including restoration and dirty cancellation; the direct entry-by-entry
+word has 36. This identity holds over any coefficient ring. The checker
+compares all thirteen integer input columns, including dirty outputs and
+helper dirt, and checks the literal inverse. Source columns alone miss the
+omitted old-value correction, which is retained as a negative control.
+
+## Geometric invoice and limits
+
+For a caller already supplying the source-line frames, target-hyperplane
+frames and the helper at U, all 24 incident transfers are nested. Their
+residual ranks are twelve of rank three and twelve of rank four, mass 84.
+Direct source-line to target-hyperplane transfers have rank seven, mass
+36×7=252. No COPY, ERASE or clean-helper assumption appears in this scalar
+word. These are conditional incident-edge invoices, not complete supplier
+prices. They cannot be substituted into the selected recursive moment.
+
+In particular, if one instead uses the zero-entrance dirty-role convention
+in general-clifford-frames.tex, this helper needs a rank-four birth and a
+rank-five Fourier tail (total nine), rather than free boundary changes.
+Even that favorable local screen is only 84+9=93. It excludes still-unbuilt
+caller/source access, exact phase and rank-zero adapters, the inherited
+side-matrix factor 1/2, gather/scatter layout, copies needed by a larger DAG,
+global restoration, recursive children/whole-owner hosting, precision/tape
+and analytic transfer. None of those expenses is asserted to vanish.
+The package stops at the finite geometry and integer-normalized macro;
+it does not implement or claim that favorable supplier budget.
+
+The selected E8 suppliers use different label units. Global label coverage,
+compatible station choices across multiple nodes and actual compiled words
+remain open. This local extension neither reopens the rejected unchanged
+ParitySide DAG nor removes its common-span obstructions. It does not optimize
+arbitrary nonnested transport, mixed weights, higher dimensions, multiple
+stations or unrestricted decoders. The finite theorem is supported by a
+complete bounded certificate with an explicit coverage argument, not a
+formal proof of the full integer-multiplication theorem.
diff --git a/research/five-subset-common-frame-seed48b/README.md b/research/five-subset-common-frame-seed48b/README.md
new file mode 100644
index 0000000000..4b6092b661
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/README.md
@@ -0,0 +1,72 @@
+# Sharp multiway capacity of one weight-five common frame
+
+**Structural research note; no new kappa or physical supplier.** One common
+legal frame at h=9 supports at most **36** entries of a signed rank-one
+weight-five block when both endpoint families contain a degenerate pair.
+An explicit **6×6** block attains this bound. Its complete dirty-helper
+scalar wrapper takes **24 signed ADDs**, saving twelve versus 36 direct
+entries, with all twelve orthonormal residual bases exhibited.
+
+This extends [PR1173](https://github.com/CrocSwap/integer-mult-bounds/pull/1173)
+from independently completable pairs to simultaneous multiway sharing at
+one station. It changes the common-frame obligation, not just the seed or
+size of a previous label census. The sharp nine-coordinate threshold and
+PR920's dimension/residual facts remain predecessor results.
+
+From the repository root, Python3.9+, standard library only:
+
+```sh
+python3 -I -O -B research/five-subset-common-frame-seed48b/test_package.py
+```
+
+Expected final marker:
+`PASS_COMMON_FRAME_WEIGHT5_PACKAGE frames=5334 area=36 adds=24 controls=PASS no_new_kappa`.
+See PROOF.md for the complete finite-domain argument, WITNESS.json for the
+literal scalar word and twelve residual bases, CENSUS.json and INDEPENDENT.json
+for exact independent exhaustive receipts, and VALIDATION.md for completed
+checks and limitations. Individual replay commands are census.py,
+independent.py and verify.py under the same Python flags. None rewrites saved
+evidence; their explicit generation options are documented in their usage.
+
+Both enumerations cover **5334** U4 lifts, of which **2048** are nondegenerate,
+and agree on every legal frame's maximum. Dimension-five separators follow
+by transposition. The primary additionally checks 18160 anchored source
+subsets and 20200 qualifying saturated target classes. These counts include
+anchored duplicates across source-pair choices; no global labeled census
+or unique-frame count is inferred from them.
+
+The macro's conditional incident rank bill is **12 rank-three + 12 rank-four
+edges, mass84**. The helper, sources and outputs are explicit dirty roles;
+cleanup and old-helper cancellation are included. Those edge ranks exclude
+unimplemented global caller/boundary, exact phase, half-factor, copy/lifecycle,
+hosting, precision and analytic obligations. A full recursive invoice is
+not supplied. The selected frontier and upstream/ are unchanged.
+
+Exact base: `1b59b624d21924f8e3537cdc1ac52d3be6eda2fe`.
+Fresh OS assignment seed **48** (a repeated numeric draw from a new OS call),
+structural track. CLAIM.json records three candidate tasks, the new common-frame
+scope, bounded stopping rule and overlap review. Source pins and retained
+predecessor documents are in SOURCES.json. PR1173 is pinned at
+`72bfdf66d9823244ee8dab4c8898af834e34853b`; no predecessor code is imported.
+
+Credit Douglas Colkitt's signed parity kernel and historical obstruction;
+ArnavSwiggy's PR920 residual criterion/floor; @woklerx's PR1139 triple
+classification; ToikY's PR1173 and seed47 frame-completion note; icekylinx's
+general Clifford-frame rank construction and the retained format lineage.
+Prepared for **@ToikY** with substantial **OpenAI Codex** assistance, including
+two bounded workers for primary/independent census and review. The separately
+implemented checks are AI-assisted evidence, not independent human review.
+Apache-2.0; original retained notices are preserved. See NOTICE.md.
+
+## Open next questions
+
+Can this 6×6 common-frame block be embedded in a real parity-side circuit with
+all caller, phase, helper boundary and recursive costs paid? This determines
+whether the local twelve-ADD saving survives physical realization. A feasible
+first step is to compile just the explicit thirteen-register word into the
+historical frame format and replay all phases against its exact integer
+endpoint, including the side-matrix factor 1/2. The current blocker is the lack
+of a compatible caller/source-access and helper lifecycle construction; the
+incident mass84 is not an admission certificate. Stop that route if the
+complete favorable invoice loses the local saving. This question does not
+reopen the unchanged rejected global ParitySide DAG.
diff --git a/research/five-subset-common-frame-seed48b/SOURCES.json b/research/five-subset-common-frame-seed48b/SOURCES.json
new file mode 100644
index 0000000000..7befa039d2
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/SOURCES.json
@@ -0,0 +1,90 @@
+{
+  "repository_inputs": [
+    {
+      "path": "research/complex-parity-frames-seed35/README.md",
+      "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+      "git_blob": "cd785b84d99ce9347c836d00f55e5f7e59113e73",
+      "sha256": "b7d8c49293d770c0c3037fcd5eda36881adb7042c46c0d87dfbe47d9610d104c"
+    },
+    {
+      "path": "docs/research/parity-side.md",
+      "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+      "git_blob": "b36c404820b3e9c0f28be64ba4ea2a8e924704b3",
+      "sha256": "75de20f8dcd3d1a2e2d19bc087eda50a6cc77027651f48198868426a80cd12f2"
+    },
+    {
+      "path": "research/frame-completion-seed47/README.md",
+      "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+      "git_blob": "2f0f2cc00d29de4af68dc9ca22bdbe5649f28e0a",
+      "sha256": "b24cf3ed7cf5b651f4c2c463e10918dc4d1a2323bf268bcd35fbcbb0f79d9253"
+    },
+    {
+      "path": "notes/general-clifford-frames.tex",
+      "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+      "git_blob": "0367eeb005298601f28a673861d6f71bf1d0ebbb",
+      "sha256": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    }
+  ],
+  "retained_inputs": [
+    {
+      "path": "vendor/pr1173/CERTIFICATE.json",
+      "source_pr": 1173,
+      "source_head": "72bfdf66d9823244ee8dab4c8898af834e34853b",
+      "source_repository": "ToikY/integer-mult-bounds",
+      "source_path": "research/five-subset-shared-node-seed48/CERTIFICATE.json",
+      "sha256": "034b071aa64fbcee1acefed2cbeeb0300c8f272995d502e7813ebcc22d9907a2"
+    },
+    {
+      "path": "vendor/pr1173/PROOF.md",
+      "source_pr": 1173,
+      "source_head": "72bfdf66d9823244ee8dab4c8898af834e34853b",
+      "source_repository": "ToikY/integer-mult-bounds",
+      "source_path": "research/five-subset-shared-node-seed48/PROOF.md",
+      "sha256": "5de5045a1d15e1c95b28899851a2ef2fb2e9821a20979cdffad12c14feffb102"
+    },
+    {
+      "path": "vendor/pr1173/README.md",
+      "source_pr": 1173,
+      "source_head": "72bfdf66d9823244ee8dab4c8898af834e34853b",
+      "source_repository": "ToikY/integer-mult-bounds",
+      "source_path": "research/five-subset-shared-node-seed48/README.md",
+      "sha256": "b4a85b975f7e0e58440bb0018f007b37842734fc14afd7b93bb3d8d2dfd57584"
+    }
+  ],
+  "predecessors": {
+    "920": "913817423bbfaf241dec1d6b9edb1c7ded349508",
+    "1139": "82da1e827c51d94691134c6aec346357d89622bc",
+    "1173": "72bfdf66d9823244ee8dab4c8898af834e34853b"
+  },
+  "selected_certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045",
+  "package_sources": [
+    {
+      "path": "census.py",
+      "sha256": "a9f1611c6501cf9747504e41f688292949e29ad12eb9eb5631c80ea5cd6e509f"
+    },
+    {
+      "path": "independent.py",
+      "sha256": "26c18b2ce5a38b424709abfc244054cc1f194c9adbbce35e50a642e9069769e6"
+    },
+    {
+      "path": "verify.py",
+      "sha256": "98347d4e0d7516ee56c316fbd3854cafced79a736ffd596e852af4c4bda565bb"
+    },
+    {
+      "path": "test_package.py",
+      "sha256": "8efce3186c9bec2c8ead8f5f2f635b212ac39bc34c77a3cc35e298e4b33644c5"
+    }
+  ]
+}
diff --git a/research/five-subset-common-frame-seed48b/VALIDATION.md b/research/five-subset-common-frame-seed48b/VALIDATION.md
new file mode 100644
index 0000000000..fcb40a1e9e
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/VALIDATION.md
@@ -0,0 +1,64 @@
+# Completed verification and limits
+
+On 2026-10-13, macOS arm64, CPython3.9.6, standard library only:
+
+```sh
+python3 -I -O -B research/five-subset-common-frame-seed48b/test_package.py
+python3 -B scripts/verify_selected_result.py
+```
+
+Expected final lines:
+
+```text
+PASS_COMMON_FRAME_WEIGHT5_PACKAGE frames=5334 area=36 adds=24 controls=PASS no_new_kappa
+PASS selected record, exact kappa, original source inventory and proof supplement: 836330098538459/500000000000000000
+```
+
+Primary and independent enumerations passed in normal and optimized modes.
+They independently enumerate all 5334 anchored lifts and agree on all 2048
+legal-frame maxima, histogram counts and digest
+`ac3520884ea295130595b20b4703217ed6838ba49dae1e4ca63412371803be7a`.
+The primary replay took about1.4s and the independent about2.0s on this host;
+these timings describe verification, not a supplier performance comparison.
+All twelve residual bases, all thirteen integer endpoint columns, and the
+literal inverse passed. The witness verifier checks twelve semantic negative
+controls, including omitted dirty cancellation that clean input columns miss.
+
+The package test replays all three commands under isolation and optimization,
+checks exact cross-implementation receipts, relocates the package to a spaced
+path, and rejects ten actual on-disk faults: an omitted outgoing basis,
+boolean sign, wrong word, missing source pin, duplicate JSON key,
+incomplete primary coverage, corrupted independent receipt, missing independent
+receipt without auto-creation, changed repository source and changed verifier
+source. The in-memory controls separately omit both incoming and outgoing bases. No saved evidence is rewritten
+by default verification. The original package hashes are unchanged after its
+corruption tests. Missing evidence is a failure.
+
+Investigation base: `1b59b624d21924f8e3537cdc1ac52d3be6eda2fe`.
+The final upstream refresh found
+`49b3157d1d89adcef16df8be98445451672be5ba`; its updated AGENTS/CONTRIBUTING/
+autoresearch/package guidance was read. All six pinned scientific/context
+inputs remain byte-identical, including the selected record and review. The
+new package includes the requested open next question. The optional package
+generator/replay registration is not used; the explicit standalone replay
+and source guards are retained. upstream/ and every existing repository file
+are unchanged.
+
+Overlap was checked using relevant open PR bodies and exact predecessor heads,
+the ledger, prior parity-side/frame negative results, and the live Discussion
+board. The final latest-30 open-PR refresh reached PR1227; PR1226's masked
+root-star census and PR1224's nine-term E8 normal form are different objects.
+PR1173 proves pairwise existence and PR1139 triple classification; this package
+adds simultaneous common-station capacity, not a repeated pair census. All
+other scopes are checked only to the extent described here; no novelty theorem
+is claimed. The newly introduced find_overlap.py was additionally run offline
+against local notes: twelve possible matches, no usable remote cache. Live
+connector/browser checks supplied the remote coverage, not that offline run.
+The Discussion board still had no matching common-frame claim. No pinned sprint
+coordination issue exists, so the claim/result is retained locally.
+
+Not run: repository-wide regeneration, full selected-construction cold replay,
+native/physical admission, Linux replay, formalization or independent human
+review. This exact finite census plus explicit reduction argument is not a
+formal proof of the full multiplication theorem. All supplier hosting,
+precision/tape and analytic-transfer conditions remain unresolved here.
diff --git a/research/five-subset-common-frame-seed48b/WITNESS.json b/research/five-subset-common-frame-seed48b/WITNESS.json
new file mode 100644
index 0000000000..d76a28c3a3
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/WITNESS.json
@@ -0,0 +1,275 @@
+{
+  "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe",
+  "seed": 48,
+  "witness": {
+    "h": 9,
+    "source_labels": [
+      31,
+      55,
+      457,
+      458,
+      481,
+      482
+    ],
+    "target_labels": [
+      47,
+      59,
+      87,
+      151,
+      279,
+      451
+    ],
+    "U_basis": [
+      31,
+      481,
+      3,
+      40
+    ],
+    "U_characteristic": 40,
+    "W_characteristic": 471,
+    "incoming_residual_bases": [
+      [
+        52,
+        457,
+        458
+      ],
+      [
+        28,
+        481,
+        482
+      ],
+      [
+        31,
+        52,
+        458
+      ],
+      [
+        31,
+        52,
+        457
+      ],
+      [
+        28,
+        55,
+        482
+      ],
+      [
+        28,
+        55,
+        481
+      ]
+    ],
+    "outgoing_residual_bases": [
+      [
+        59,
+        67,
+        131,
+        259
+      ],
+      [
+        47,
+        67,
+        131,
+        259
+      ],
+      [
+        131,
+        279,
+        367,
+        379
+      ],
+      [
+        67,
+        279,
+        431,
+        443
+      ],
+      [
+        67,
+        151,
+        431,
+        443
+      ],
+      [
+        47,
+        251,
+        379,
+        443
+      ]
+    ],
+    "source_signs": [
+      1,
+      1,
+      -1,
+      -1,
+      -1,
+      -1
+    ],
+    "target_signs": [
+      1,
+      1,
+      1,
+      1,
+      1,
+      -1
+    ],
+    "word": [
+      [
+        12,
+        0,
+        1
+      ],
+      [
+        12,
+        1,
+        1
+      ],
+      [
+        12,
+        2,
+        -1
+      ],
+      [
+        12,
+        3,
+        -1
+      ],
+      [
+        12,
+        4,
+        -1
+      ],
+      [
+        12,
+        5,
+        -1
+      ],
+      [
+        6,
+        12,
+        1
+      ],
+      [
+        7,
+        12,
+        1
+      ],
+      [
+        8,
+        12,
+        1
+      ],
+      [
+        9,
+        12,
+        1
+      ],
+      [
+        10,
+        12,
+        1
+      ],
+      [
+        11,
+        12,
+        -1
+      ],
+      [
+        12,
+        5,
+        1
+      ],
+      [
+        12,
+        4,
+        1
+      ],
+      [
+        12,
+        3,
+        1
+      ],
+      [
+        12,
+        2,
+        1
+      ],
+      [
+        12,
+        1,
+        -1
+      ],
+      [
+        12,
+        0,
+        -1
+      ],
+      [
+        6,
+        12,
+        -1
+      ],
+      [
+        7,
+        12,
+        -1
+      ],
+      [
+        8,
+        12,
+        -1
+      ],
+      [
+        9,
+        12,
+        -1
+      ],
+      [
+        10,
+        12,
+        -1
+      ],
+      [
+        11,
+        12,
+        1
+      ]
+    ]
+  },
+  "checks": {
+    "kernel_entries": 36,
+    "input_columns": 13,
+    "scalar_adds": 24,
+    "direct_scalar_adds": 36,
+    "saved_scalar_adds": 12,
+    "incident_rank_histogram": {
+      "3": 12,
+      "4": 12
+    },
+    "incident_rank_mass": 84,
+    "direct_incident_rank_mass": 252,
+    "helpers": 1,
+    "copy_gates": 0,
+    "erase_gates": 0,
+    "residual_bases": 12,
+    "residual_dimensions": [
+      3,
+      3,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4
+    ],
+    "full_endpoint_sha256": "4bca71ecf772bc1665a14d4feda199022efb7be7a2c572028937a2782816606d",
+    "scope": "Integer-normalized scalar kernel and conditional incident-frame ranks; no physical supplier or complete recursive invoice."
+  },
+  "negative_controls": 12,
+  "source_pins": 13,
+  "new_kappa": false
+}
diff --git a/research/five-subset-common-frame-seed48b/census.py b/research/five-subset-common-frame-seed48b/census.py
new file mode 100644
index 0000000000..5e7f904d2f
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/census.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Exact h9 common-frame weight-five census; Apache-2.0, Codex for ToikY.
+
+This producer uses explicit XOR-closed subspaces and complete source subsets.
+It imports no predecessor implementation and certifies geometry only.
+"""
+from collections import Counter
+import hashlib
+from itertools import combinations
+import json
+from pathlib import Path
+import sys
+
+HERE = Path(__file__).resolve().parent
+H = 9
+BASE = '1b59b624d21924f8e3537cdc1ac52d3be6eda2fe'
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def unique_keys(pairs):
+    out = {}
+    for key, value in pairs:
+        need(key not in out, 'duplicate certificate key')
+        out[key] = value
+    return out
+
+
+def pc(x):
+    return bin(x).count('1')
+
+
+def dot(x, y):
+    return pc(x & y) % 2
+
+
+def kernel(s, t):
+    return (1, 0, -1, 0)[pc(s & t) % 4]
+
+
+def span(basis):
+    out = {0}
+    for x in basis:
+        out |= {v ^ x for v in out}
+    return out
+
+
+def character(space, basis):
+    candidates = [x for x in sorted(space)
+                  if all(dot(x, b) == dot(b, b) for b in basis)]
+    need(len(candidates) == 1, 'unique characteristic in nondegenerate frame')
+    return candidates[0]
+
+
+def basis_of(space):
+    basis, have = [], {0}
+    for x in sorted(space):
+        if x not in have:
+            basis.append(x)
+            have |= {v ^ x for v in have}
+    need(have == space, 'basis spans complete space')
+    return basis
+
+
+def orthonormal_basis(space):
+    """Exhaust all choices; choosing the first norm-one vector can fail."""
+    if space == {0}:
+        return []
+    for x in sorted(space):
+        if dot(x, x):
+            residual = {v for v in space if not dot(v, x)}
+            result = orthonormal_basis(residual)
+            if result is not None:
+                answer = [x] + result
+                need(span(answer) == space, 'orthonormal basis span')
+                need(all(dot(a, b) == int(i == j)
+                         for i, a in enumerate(answer)
+                         for j, b in enumerate(answer)), 'identity Gram')
+                return answer
+    return None
+
+
+def quotient_planes(a, b):
+    """All 2667 planes in V/E, represented by their three nonzero cosets."""
+    E = span([a, b])
+    need(len(E) == 4, 'source pair independence')
+    cosets = sorted({min(x ^ e for e in E) for x in range(1 << H)})
+    need(len(cosets) == 128 and cosets[0] == 0, 'quotient dimension seven')
+    planes = set()
+    for u, v in combinations(cosets[1:], 2):
+        w = min((u ^ v) ^ e for e in E)
+        need(w and len({u, v, w}) == 3, 'quotient plane independence')
+        planes.add(tuple(sorted((u, v, w))))
+    need(len(planes) == 2667, 'complete binary Gaussian coefficient [7,2]')
+    for u, v, w in sorted(planes):
+        basis = [a, b, u, v]
+        U = span(basis)
+        need(len(U) == 16 and w in U, 'lifted frame dimension four')
+        yield basis, U
+
+
+def has_degenerate_pair(labels):
+    return any(dot(a, b) for a, b in combinations(labels, 2))
+
+
+def fixture(basis, sources, targets):
+    U = span(basis)
+    W = {v for v in range(1 << H) if all(not dot(v, x) for x in U)}
+    need(len(U) == 16 and len(W) == 32 and U & W == {0}, 'fixture U4 W5')
+    wU = character(U, basis)
+    wW = character(W, basis_of(W))
+    need(wU ^ wW == 511, 'orthogonal characteristic splitting')
+    need(set(sources) <= U and set(targets) <= W, 'fixture endpoints')
+    need(all(pc(x) == 5 for x in sources + targets), 'fixture label weights')
+    need(wU not in sources and wW not in targets, 'fixture residual criterion')
+    need(has_degenerate_pair(sources) and has_degenerate_pair(targets),
+         'fixture degeneracy on both sides')
+    source_signs = [kernel(s, targets[0]) for s in sources]
+    target_signs = [kernel(sources[0], t) * source_signs[0] for t in targets]
+    need(all(kernel(s, t) == source_signs[i] * target_signs[j]
+             for i, s in enumerate(sources) for j, t in enumerate(targets)),
+         'fixture signed outer product')
+    incoming, outgoing = [], []
+    for labels, ambient, dimension, result in (
+            (sources, U, 3, incoming), (targets, W, 4, outgoing)):
+        for x in labels:
+            residual = {v for v in ambient if not dot(v, x)}
+            rows = orthonormal_basis(residual)
+            need(rows is not None and len(rows) == dimension,
+                 'complete incident orthonormal residual')
+            result.append({'label': x, 'basis': rows})
+    s, t = len(sources), len(targets)
+    return {'frame_basis': basis_of(U), 'frame_vectors': sorted(U),
+            'complement_basis': basis_of(W), 'frame_characteristic': wU,
+            'complement_characteristic': wW, 'sources': sources,
+            'targets': targets, 'source_signs': source_signs,
+            'target_signs': target_signs, 'size': [s, t], 'area': s * t,
+            'dirty_wrapper_adds': 2 * (s + t),
+            'adds_saved_vs_one_add_per_entry': s * t - 2 * (s + t),
+            'wrapper_incident_rank_mass': 2 * s * 3 + 2 * t * 4,
+            'incoming_residual_bases': incoming,
+            'outgoing_residual_bases': outgoing}
+
+
+def run():
+    orbits = []
+    common_records = []
+    best_area, best_saving = -1, -1000
+    area_key = saving_key = None
+    area_witness = saving_witness = None
+    for intersection, a, b in ((1, 31, 481), (3, 31, 103)):
+        need(pc(a) == pc(b) == 5 and pc(a & b) == intersection,
+             'canonical source pair')
+        counts = Counter()
+        size_histogram, maximal_sizes, frame_maximum = Counter(), Counter(), Counter()
+        digest = hashlib.sha256()
+        seen_frames = set()
+        for basis, U in quotient_planes(a, b):
+            frame_key = tuple(sorted(U))
+            need(frame_key not in seen_frames, 'unique lifted U4')
+            seen_frames.add(frame_key)
+            counts['frames_examined'] += 1
+            radical = {x for x in U if all(not dot(x, y) for y in basis)}
+            if radical != {0}:
+                counts['degenerate_frames'] += 1
+                digest.update((json.dumps([list(frame_key), 'degenerate'],
+                                          separators=(',', ':')) + '\n').encode())
+                continue
+            counts['nondegenerate_frames'] += 1
+            W = {x for x in range(1 << H) if all(not dot(x, y) for y in basis)}
+            need(len(W) == 32 and U & W == {0}, 'orthogonal U4 W5')
+            wU = character(U, basis)
+            wW = 511 ^ wU
+            need(wW in W and all(dot(wW, x) == dot(x, x) for x in W),
+                 'complement characteristic')
+            sources = sorted(x for x in U if pc(x) == 5 and x != wU)
+            targets = sorted(x for x in W if pc(x) == 5 and x != wW)
+            need(a in sources and b in sources, 'anchored source residuals')
+            other = [s for s in sources if s not in (a, b)]
+            source_subsets = qualifying = maximal = local_area = 0
+            best_sizes = set()
+            local_saving = -1000
+            for bits in range(1 << len(other)):
+                S = sorted([a, b] + [x for i, x in enumerate(other) if bits >> i & 1])
+                source_subsets += 1
+                groups = {}
+                for t in targets:
+                    signs = tuple(kernel(s, t) * kernel(S[0], t) for s in S)
+                    need(all(abs(z) == 1 for z in signs), 'nonzero common-frame kernel')
+                    groups.setdefault(signs, []).append(t)
+                for T in groups.values():
+                    if len(T) < 2 or not has_degenerate_pair(T):
+                        continue
+                    qualifying += 1
+                    s, t = len(S), len(T)
+                    area, saving = s * t, s * t - 2 * (s + t)
+                    size_histogram[s, t] += 1
+                    if area > local_area:
+                        local_area, best_sizes = area, {(s, t)}
+                    elif area == local_area:
+                        best_sizes.add((s, t))
+                    local_saving = max(local_saving, saving)
+                    closure = [x for x in sources if all(
+                        kernel(x, y) * kernel(S[0], y)
+                        == kernel(x, T[0]) * kernel(S[0], T[0]) for y in T)]
+                    if closure == S:
+                        maximal += 1
+                        maximal_sizes[s, t] += 1
+                    key = (tuple(S), tuple(T), frame_key)
+                    if area > best_area or (area == best_area and key < area_key):
+                        best_area, area_key = area, key
+                        area_witness = (basis, S, T)
+                    if saving > best_saving or (saving == best_saving and key < saving_key):
+                        best_saving, saving_key = saving, key
+                        saving_witness = (basis, S, T)
+            counts['source_subsets_examined'] += source_subsets
+            counts['qualifying_target_classes'] += qualifying
+            counts['inclusion_maximal_bicliques'] += maximal
+            counts['frames_with_qualifying_biclique'] += int(qualifying > 0)
+            frame_maximum[local_area] += 1
+            common_records.append([intersection, list(frame_key), len(sources),
+                                   len(targets), local_area,
+                                   [list(z) for z in sorted(best_sizes)]])
+            record = [list(frame_key), sources, targets, wU, wW, source_subsets,
+                      qualifying, maximal, local_area,
+                      local_saving if qualifying else None]
+            digest.update((json.dumps(record, separators=(',', ':')) + '\n').encode())
+        need(len(seen_frames) == 2667, 'all U4 containing canonical source E')
+        orbits.append({'source_intersection': intersection, 'source_pair': [a, b],
+                       'counts': dict(sorted(counts.items())),
+                       'qualifying_sizes': [[s, t, n] for (s, t), n in sorted(size_histogram.items())],
+                       'inclusion_maximal_sizes': [[s, t, n] for (s, t), n in sorted(maximal_sizes.items())],
+                       'frame_maximum_area_histogram': [[a, n] for a, n in sorted(frame_maximum.items())],
+                       'ordered_frame_stream_sha256': digest.hexdigest()})
+    need(area_witness is not None and saving_witness is not None, 'nonempty finite result')
+    return {'schema': 1, 'base_commit': BASE, 'seed': 48, 'ambient_dimension': H,
+            'frame_dimension': 4, 'complement_dimension': 5,
+            'domain': 'Both sides contain a degenerate pair; constant weight five; one U4/W5; historical orthonormal incident residuals; signed rank one.',
+            'coverage': 'Every source pair is coordinate-isomorphic to one of the two anchored pairs. Every U4 containing E is a two-plane in V/E. Every S containing that pair is exhausted; maximal T are normalized signed column classes.',
+            'stopping_rule': 'Complete finite exhaustion; no sampled frames or endpoints.',
+            'orbits': orbits, 'maximum_area': best_area,
+            'common_record_count': len(common_records),
+            'common_records_sha256': hashlib.sha256(json.dumps(
+                sorted(common_records), separators=(',', ':')).encode()).hexdigest(),
+            'maximum_dirty_wrapper_saving': best_saving,
+            'maximum_area_witness': fixture(*area_witness),
+            'maximum_saving_witness': fixture(*saving_witness),
+            'scope': 'Exact finite geometry and scalar wrapper accounting only; no supplier, paid recurrence or kappa claim.'}
+
+
+def main():
+    need(sys.argv[1:] in ([], ['--write']), 'usage: census.py [--write]')
+    result = run()
+    path = HERE / 'CENSUS.json'
+    if sys.argv[1:] == ['--write']:
+        path.write_text(json.dumps(result, indent=2) + '\n')
+    else:
+        saved = json.loads(path.read_text(), object_pairs_hook=unique_keys)
+        need(json.dumps(result, sort_keys=True, separators=(',', ':'))
+             == json.dumps(saved, sort_keys=True, separators=(',', ':')),
+             'committed census mismatch')
+    print('PASS_COMMON_FRAME_WEIGHT5_CENSUS frames=5334 maximum_area=%d maximum_dirty_wrapper_saving=%d no_new_kappa'
+          % (result['maximum_area'], result['maximum_dirty_wrapper_saving']))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/five-subset-common-frame-seed48b/independent.py b/research/five-subset-common-frame-seed48b/independent.py
new file mode 100644
index 0000000000..ee6afe2cc4
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/independent.py
@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""Independent finite census using quotient RREF planes and signed minors.
+
+Standard library only.  This does not import the discovery census.  Rows
+are binary linear maps, and the quotient planes have unique RREF matrices.
+"""
+
+import hashlib
+import itertools
+import json
+from pathlib import Path
+import sys
+
+
+HERE = Path(__file__).resolve().parent
+DIMENSION = 9
+OMEGA = (1 << DIMENSION) - 1
+WEIGHT5 = [sum(1 << i for i in c)
+           for c in itertools.combinations(range(DIMENSION), 5)]
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def parity(x):
+    return bin(x).count('1') & 1
+
+
+def inner(x, y):
+    return parity(x & y)
+
+
+def rref(rows, width=DIMENSION):
+    """Gauss-Jordan row elimination; pivots scan left (low bit) to right."""
+    work = list(rows)
+    pivot_row = 0
+    for col in range(width):
+        selected = next((j for j in range(pivot_row, len(work))
+                         if (work[j] >> col) & 1), None)
+        if selected is None:
+            continue
+        work[pivot_row], work[selected] = work[selected], work[pivot_row]
+        for j in range(len(work)):
+            if j != pivot_row and ((work[j] >> col) & 1):
+                work[j] ^= work[pivot_row]
+        pivot_row += 1
+    return tuple(work[:pivot_row])
+
+
+def image(rows, coefficients):
+    result = 0
+    for index, row in enumerate(rows):
+        if (coefficients >> index) & 1:
+            result ^= row
+    return result
+
+
+def elements(rows):
+    return sorted(image(rows, c) for c in range(1 << len(rows)))
+
+
+def contains(rows, vector):
+    for row in rows:
+        pivot = row & -row
+        if vector & pivot:
+            vector ^= row
+    return vector == 0
+
+
+def nullspace(rows, width=DIMENSION):
+    reduced = rref(rows, width)
+    pivots = [(row & -row).bit_length() - 1 for row in reduced]
+    free = [j for j in range(width) if j not in pivots]
+    result = []
+    for col in free:
+        vector = 1 << col
+        for row, pivot in zip(reduced, pivots):
+            if (row >> col) & 1:
+                vector |= 1 << pivot
+        result.append(vector)
+    return tuple(result)
+
+
+def gram(rows):
+    return tuple(sum(inner(x, y) << j for j, y in enumerate(rows))
+                 for x in rows)
+
+
+def characteristic(rows):
+    """Solve G c = diagonal(G), then map c back to the ambient space."""
+    size = len(rows)
+    equations = [row | (inner(x, x) << size)
+                 for row, x in zip(gram(rows), rows)]
+    reduced = rref(equations, size)
+    need(len(reduced) == size, 'singular Gram in characteristic solve')
+    coefficients = sum(((row >> size) & 1) << j
+                       for j, row in enumerate(reduced))
+    result = image(rows, coefficients)
+    need(all(inner(result, x) == inner(x, x) for x in rows),
+         'incorrect characteristic vector')
+    return result
+
+
+def quotient_complement(pair):
+    basis = rref(pair)
+    complement = []
+    for coordinate in range(DIMENSION):
+        candidate = 1 << coordinate
+        expanded = rref(basis + tuple(complement) + (candidate,))
+        if len(expanded) > len(basis) + len(complement):
+            complement.append(candidate)
+    need(len(complement) == 7, 'quotient dimension is not seven')
+    return tuple(complement)
+
+
+def quotient_planes():
+    """Every rank-two RREF row space in F2^7, once, by pivot pattern."""
+    for first, second in itertools.combinations(range(7), 2):
+        free_first = [j for j in range(first + 1, 7) if j != second]
+        free_second = list(range(second + 1, 7))
+        for bits in range(1 << (len(free_first) + len(free_second))):
+            row_first, row_second = 1 << first, 1 << second
+            for k, col in enumerate(free_first):
+                row_first |= ((bits >> k) & 1) << col
+            for k, col in enumerate(free_second, len(free_first)):
+                row_second |= ((bits >> k) & 1) << col
+            yield row_first, row_second
+
+
+def sign(source, target):
+    # cos(pi |source intersect target| / 2), evaluated exactly.
+    return (1, 0, -1, 0)[bin(source & target).count('1') % 4]
+
+
+def degenerate_pair(vectors):
+    return any(inner(a, b) == 1
+               for a, b in itertools.combinations(vectors, 2))
+
+
+def check_fixture(basis, sources, targets, row_signs, column_signs):
+    need(len(basis) == 4 and len(rref(gram(basis), 4)) == 4,
+         'fixture U is not a nonsingular four-space')
+    need(all(bin(x).count('1') == 5 for x in sources + targets),
+         'fixture endpoint does not have weight five')
+    char_u = characteristic(basis)
+    char_w = char_u ^ OMEGA
+    need(all(contains(basis, x) and x != char_u for x in sources),
+         'fixture source outside legal U')
+    need(all(all(inner(x, row) == 0 for row in basis) and x != char_w
+             for x in targets), 'fixture target outside legal W')
+    need(all(sign(s, t) == row_signs[i] * column_signs[j]
+             for i, s in enumerate(sources)
+             for j, t in enumerate(targets)), 'fixture signed minors failed')
+    need(degenerate_pair(sources) and degenerate_pair(targets),
+         'fixture lacks degenerate endpoint pairs')
+    return char_u, char_w
+
+
+def negative_controls():
+    sources = [31, 55, 457, 458, 481, 482]
+    targets = [47, 59, 87, 151, 279, 451]
+    basis = rref([31, 481, 3, 40])
+    row_signs, column_signs = [1, 1, -1, -1, -1, -1], [1, 1, 1, 1, 1, -1]
+    variants = [
+        (basis, sources, targets, [1, -1, -1, -1, -1, -1], column_signs),
+        (basis, sources, [46] + targets[1:], row_signs, column_signs),
+        (rref([31, 481]), sources, targets, row_signs, column_signs),
+    ]
+    for index, arguments in enumerate(variants):
+        rejected = False
+        try:
+            check_fixture(*arguments)
+        except ValueError:
+            rejected = True
+        need(rejected, 'negative control accepted: %d' % index)
+    return len(variants)
+
+
+def max_block(sources, targets, required_pair):
+    """Exhaust source subsets, then saturate T by literal 2x2 minors.
+
+    For any rank-one block with nonzero entries, selecting its first target
+    fixes all row ratios.  Every additional compatible target may be added
+    without destroying rank one or its required degenerate target pair.
+    Thus saturating each pivot target covers every maximum in this domain.
+    """
+    optional = [x for x in sources if x not in required_pair]
+    best_area = 0
+    best_sizes = set()
+    best_witness = None
+    for mask in range(1 << len(optional)):
+        chosen = sorted(list(required_pair) +
+                        [x for j, x in enumerate(optional) if (mask >> j) & 1])
+        first_source = chosen[0]
+        for pivot_target in targets:
+            corner = sign(first_source, pivot_target)
+            need(corner != 0, 'orthogonal spaces have a zero signed entry')
+            compatible = [t for t in targets
+                          if all(sign(s, t) * corner ==
+                                 sign(s, pivot_target) * sign(first_source, t)
+                                 for s in chosen)]
+            if not degenerate_pair(compatible):
+                continue
+            area = len(chosen) * len(compatible)
+            witness = [chosen, compatible]
+            if area > best_area:
+                best_area = area
+                best_sizes = {(len(chosen), len(compatible))}
+                best_witness = witness
+            elif area == best_area and area:
+                best_sizes.add((len(chosen), len(compatible)))
+                if witness < best_witness:
+                    best_witness = witness
+    return best_area, sorted([list(x) for x in best_sizes]), best_witness
+
+
+def census():
+    plane_matrices = list(quotient_planes())
+    expected_planes = ((2 ** 7 - 1) * (2 ** 7 - 2)) // ((4 - 1) * (4 - 2))
+    need(len(plane_matrices) == expected_planes == 2667,
+         'wrong Gaussian binomial plane count')
+    need(len(set(plane_matrices)) == 2667, 'repeated quotient RREF plane')
+    records = []
+    summaries = []
+    winner = None
+    for overlap, pair in ((1, (31, 481)), (3, (31, 103))):
+        complement = quotient_complement(pair)
+        seen = set()
+        legal = 0
+        histogram = {}
+        max_sources = max_targets = 0
+        for qrows in plane_matrices:
+            basis = rref(pair + tuple(image(complement, q) for q in qrows))
+            need(len(basis) == 4, 'quotient plane did not lift to dimension four')
+            need(basis not in seen, 'quotient lift repeated a U4')
+            seen.add(basis)
+            if len(rref(gram(basis), 4)) != 4:
+                continue
+            legal += 1
+            perpendicular = nullspace(basis)
+            need(len(perpendicular) == 5, 'perpendicular dimension is not five')
+            need(len(rref(gram(perpendicular), 5)) == 5,
+                 'nonsingular U has singular perpendicular')
+            char_u = characteristic(basis)
+            char_w = characteristic(perpendicular)
+            need(char_u ^ char_w == OMEGA, 'characteristic decomposition failed')
+            sources = sorted(x for x in WEIGHT5
+                             if x != char_u and contains(basis, x))
+            targets = sorted(x for x in WEIGHT5
+                             if x != char_w and all(inner(x, row) == 0
+                                                   for row in basis))
+            need(all(x in sources for x in pair), 'required sources were lost')
+            max_sources = max(max_sources, len(sources))
+            max_targets = max(max_targets, len(targets))
+            area, sizes, witness = max_block(sources, targets, pair)
+            histogram[str(area)] = histogram.get(str(area), 0) + 1
+            key = [overlap, elements(basis), len(sources), len(targets), area, sizes]
+            records.append(key)
+            if witness is not None:
+                candidate = [area, overlap, list(basis), witness]
+                if winner is None or candidate[0] > winner[0]:
+                    winner = candidate
+        summaries.append({'overlap': overlap, 'pair': list(pair),
+                          'quotient_planes': len(plane_matrices),
+                          'legal_planes': legal,
+                          'excluded_singular_planes': len(plane_matrices) - legal,
+                          'max_available_sources': max_sources,
+                          'max_available_targets': max_targets,
+                          'area_histogram': dict(sorted(histogram.items(),
+                                                        key=lambda item: int(item[0])))})
+    encoded = json.dumps(sorted(records), separators=(',', ':')).encode()
+    fixture_sources = [31, 55, 457, 458, 481, 482]
+    fixture_targets = [47, 59, 87, 151, 279, 451]
+    fixture_basis = rref([31, 481, 3, 40])
+    row_signs = [1, 1, -1, -1, -1, -1]
+    column_signs = [1, 1, 1, 1, 1, -1]
+    fixture_u, fixture_w = check_fixture(fixture_basis, fixture_sources,
+                                        fixture_targets, row_signs, column_signs)
+    return {'schema': 'independent-common-frame-census-v1',
+            'method': 'quotient RREF planes; Gauss-Jordan Gram tests; literal signed 2x2 minor saturation',
+            'ambient_dimension': DIMENSION, 'weight': 5,
+            'summaries': summaries,
+            'legal_record_count': len(records),
+            'legal_records_sha256': hashlib.sha256(encoded).hexdigest(),
+            'maximum_area': max(row[4] for row in records),
+            'fixture': {'U_basis_rref': list(fixture_basis),
+                        'characteristic_U': fixture_u,
+                        'characteristic_W': fixture_w,
+                        'sources': fixture_sources, 'targets': fixture_targets,
+                        'source_signs': row_signs, 'target_signs': column_signs},
+            'global_bound_method': 'exhaust source subsets and saturate each pivot target by exact 2x2 minors; crude endpoint cardinalities alone give only 54',
+            'negative_control_count': negative_controls()}
+
+
+def main():
+    need(sys.argv[1:] in ([], ['--write']), 'usage: independent.py [--write]')
+    result = census()
+    path = HERE / 'INDEPENDENT.json'
+    serialized = json.dumps(result, indent=2, sort_keys=True) + '\n'
+    if sys.argv[1:] == ['--write']:
+        path.write_text(serialized)
+    else:
+        need(path.read_text() == serialized, 'independent certificate mismatch')
+    print('PASS_INDEPENDENT_COMMON_FRAME_CENSUS',
+          result['maximum_area'], result['legal_records_sha256'])
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/five-subset-common-frame-seed48b/test_package.py b/research/five-subset-common-frame-seed48b/test_package.py
new file mode 100644
index 0000000000..eed325472b
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/test_package.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Complete bounded replay, source binding, and actual package fault tests.
+
+Apache-2.0; prepared for ToikY with substantial OpenAI Codex assistance.
+"""
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def invoke(path, accepted=True):
+    start = time.monotonic()
+    result = subprocess.run([sys.executable, '-I', '-O', '-B', str(path)],
+                            capture_output=True, text=True, timeout=120)
+    need((result.returncode == 0) == accepted,
+         'unexpected subprocess outcome for ' + path.name + '\n' + result.stdout + result.stderr)
+    if accepted:
+        need('PASS_' in result.stdout, 'missing success marker')
+    return result.stdout.strip(), round(time.monotonic() - start, 3)
+
+
+def compare():
+    primary = json.loads((HERE / 'CENSUS.json').read_text())
+    other = json.loads((HERE / 'INDEPENDENT.json').read_text())
+    need(primary['maximum_area'] == other['maximum_area'] == 36, 'independent area agreement')
+    need(primary['maximum_dirty_wrapper_saving'] == 12, 'complete wrapper saving')
+    need(primary['common_record_count'] == other['legal_record_count'] == 2048, 'legal frame coverage')
+    need(primary['common_records_sha256'] == other['legal_records_sha256']
+         == 'ac3520884ea295130595b20b4703217ed6838ba49dae1e4ca63412371803be7a',
+         'every legal-frame maximum agrees')
+    for a, b in zip(primary['orbits'], other['summaries']):
+        need(a['source_intersection'] == b['overlap'], 'orbit assignment')
+        need(a['counts']['frames_examined'] == b['quotient_planes'] == 2667, 'all quotient planes')
+        need(a['counts']['nondegenerate_frames'] == b['legal_planes'] == 1024, 'nondegenerate lifts')
+        need(a['counts']['degenerate_frames'] == b['excluded_singular_planes'] == 1643, 'singular lifts')
+        need({str(x): n for x, n in a['frame_maximum_area_histogram']} == b['area_histogram'],
+             'per-orbit maximum histograms')
+
+
+def faults_and_relocation():
+    sources = json.loads((HERE / 'SOURCES.json').read_text())
+    with tempfile.TemporaryDirectory(prefix='common frame seed48b ') as temp:
+        root = Path(temp)
+        package = root / 'research' / HERE.name
+        shutil.copytree(HERE, package)
+        for rec in sources['repository_inputs']:
+            dest = root / rec['path']; dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(ROOT / rec['path'], dest)
+        selected = json.loads((ROOT / 'certificates/selected-result.json').read_text())
+        certificate = root / selected['certificate']
+        certificate.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(ROOT / selected['certificate'], certificate)
+        invoke(package / 'verify.py')
+        witness = package / 'WITNESS.json'
+        original = witness.read_bytes()
+        d = json.loads(original)
+        mutations = []
+        for mode in ('missing_residual', 'bool_sign', 'wrong_word', 'missing_source_pin'):
+            value = json.loads(original)
+            if mode == 'missing_residual': value['witness']['outgoing_residual_bases'].pop()
+            if mode == 'bool_sign': value['witness']['source_signs'][0] = True
+            if mode == 'wrong_word': value['witness']['word'][0][2] *= -1
+            if mode == 'missing_source_pin': value['source_pins'] -= 1
+            mutations.append(json.dumps(value).encode())
+        mutations.append(original.replace(b'"new_kappa": false', b'"new_kappa": false, "new_kappa": false'))
+        for payload in mutations:
+            witness.write_bytes(payload); invoke(package / 'verify.py', accepted=False)
+        witness.write_bytes(original)
+        corpus = package / 'CENSUS.json'; original_corpus = corpus.read_bytes()
+        value = json.loads(original_corpus); value['orbits'][0]['counts']['frames_examined'] -= 1
+        corpus.write_text(json.dumps(value)); invoke(package / 'census.py', accepted=False)
+        corpus.write_bytes(original_corpus)
+        corpus = package / 'INDEPENDENT.json'; original_corpus = corpus.read_bytes()
+        value = json.loads(original_corpus); value['legal_record_count'] -= 1
+        corpus.write_text(json.dumps(value)); invoke(package / 'independent.py', accepted=False)
+        corpus.write_bytes(original_corpus)
+        absent = package / 'INDEPENDENT.json.absent'
+        corpus.rename(absent); invoke(package / 'independent.py', accepted=False)
+        need(not corpus.exists(), 'default replay must not create missing evidence')
+        absent.rename(corpus)
+        source = root / sources['repository_inputs'][0]['path']; original_source = source.read_bytes()
+        source.write_bytes(original_source + b'\nchanged source\n')
+        invoke(package / 'verify.py', accepted=False); source.write_bytes(original_source)
+        source = package / 'census.py'; original_source = source.read_bytes()
+        source.write_bytes(original_source + b'\n# changed generator\n')
+        invoke(package / 'verify.py', accepted=False); source.write_bytes(original_source)
+        invoke(package / 'verify.py')
+    return 10
+
+
+def main():
+    before = {str(p.relative_to(HERE)): hashlib.sha256(p.read_bytes()).hexdigest()
+              for p in HERE.rglob('*') if p.is_file() and '__pycache__' not in p.parts}
+    for name in ('census.py', 'independent.py', 'verify.py'):
+        stdout, seconds = invoke(HERE / name)
+        print(stdout)
+        print('REPLAY_SECONDS ' + name + '=' + str(seconds))
+    compare()
+    count = faults_and_relocation()
+    after = {str(p.relative_to(HERE)): hashlib.sha256(p.read_bytes()).hexdigest()
+             for p in HERE.rglob('*') if p.is_file() and '__pycache__' not in p.parts}
+    need(before == after, 'replay must preserve all package evidence')
+    need(count == 10, 'package fault coverage')
+    print('PASS_COMMON_FRAME_WEIGHT5_PACKAGE frames=5334 area=36 adds=24 controls=PASS no_new_kappa')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/five-subset-common-frame-seed48b/vendor/pr1173/CERTIFICATE.json b/research/five-subset-common-frame-seed48b/vendor/pr1173/CERTIFICATE.json
new file mode 100644
index 0000000000..5286567bba
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/vendor/pr1173/CERTIFICATE.json
@@ -0,0 +1,123 @@
+{
+  "format": "five-subset-shared-node-seed48-v1",
+  "base_commit": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08",
+  "seed": 48,
+  "new_kappa": false,
+  "sharp_ambient_threshold": 9,
+  "canonical_census": {
+    "8_source_intersection_3": {
+      "target_labels": 11,
+      "target_pairs_tested": 55,
+      "rectangles": 0,
+      "labeled_source_pairs": 840,
+      "target_intersection_histogram": {}
+    },
+    "9_source_intersection_1": {
+      "target_labels": 32,
+      "target_pairs_tested": 496,
+      "rectangles": 288,
+      "labeled_source_pairs": 315,
+      "target_intersection_histogram": {
+        "3": 288
+      },
+      "dimension_four_frames_tested": 44640,
+      "legal_frame_count_histogram": {
+        "48": 288
+      }
+    },
+    "9_source_intersection_3": {
+      "target_labels": 30,
+      "target_pairs_tested": 435,
+      "rectangles": 96,
+      "labeled_source_pairs": 3780,
+      "target_intersection_histogram": {
+        "1": 24,
+        "3": 72
+      },
+      "dimension_four_frames_tested": 14880,
+      "legal_frame_count_histogram": {
+        "48": 96
+      }
+    }
+  },
+  "labeled_rectangles": {
+    "8": 0,
+    "9": 453600
+  },
+  "labeled_by_source_intersection": {
+    "8": {
+      "3": 0
+    },
+    "9": {
+      "1": 90720,
+      "3": 362880
+    }
+  },
+  "canonical_frame_records_sha256": "402c740ffe67383768de7439144e917fa4bf8d4ac6e7643be3ed415b13d84417",
+  "fixture": {
+    "h": 9,
+    "sources": [
+      31,
+      481
+    ],
+    "targets": [
+      47,
+      87
+    ],
+    "kernel": [
+      [
+        1,
+        1
+      ],
+      [
+        -1,
+        -1
+      ]
+    ],
+    "frame_basis": [
+      31,
+      481,
+      3,
+      40
+    ],
+    "frame_characteristic": 40,
+    "complement_characteristic": 471,
+    "incoming_residual_bases": [
+      [
+        52,
+        457,
+        458
+      ],
+      [
+        28,
+        55,
+        482
+      ]
+    ],
+    "outgoing_residual_bases": [
+      [
+        59,
+        67,
+        131,
+        259
+      ],
+      [
+        131,
+        279,
+        367,
+        379
+      ]
+    ],
+    "incident_residual_dimensions": [
+      3,
+      3,
+      4,
+      4
+    ]
+  },
+  "controls": {
+    "semantic_controls": 6,
+    "isometry_vector_pairs": 65536,
+    "five_subset_kernel_pairs": 3136
+  }
+}
diff --git a/research/five-subset-common-frame-seed48b/vendor/pr1173/PROOF.md b/research/five-subset-common-frame-seed48b/vendor/pr1173/PROOF.md
new file mode 100644
index 0000000000..95b63ee885
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/vendor/pr1173/PROOF.md
@@ -0,0 +1,89 @@
+# Sharp threshold in the weight-five class
+
+Use the class defined in README.md, over the standard binary dot product.
+The proof combines PR920's residual dimension floor with PR1139's triple
+support classification. The eight-coordinate complement step and the
+nine-coordinate weight-five fixture are this package's additions.
+
+## The four-plus-four floor
+
+For any nondegenerate binary space W, its characteristic w_W uniquely satisfies
+w_W dot x = x dot x for all x in W. A norm-one vector s splits W as its line
+orthogonally summed with the nondegenerate residual W intersect s-perp.
+That residual is alternating exactly when w_W=s: its characteristic vanishes
+exactly when the characteristic of W lies in the line spanned by s.
+This is the historical criterion used in PR920.
+
+Distinct norm-one sources with s1 dot s2=1 span a degenerate plane E with
+radical r=s1+s2. A nondegenerate U containing E cannot have dimension two.
+If dim U=3, then E=r-perp inside U. Since r has norm zero, w_U lies in E.
+Pairing w_U with both sources must give one; the only two possibilities
+inside E are s1 and s2. At least one incoming residual is therefore an
+alternating plane and has no orthonormal basis. Hence dim U>=4. Apply the
+same argument to the targets inside U-perp to obtain dim U-perp>=4.
+Thus h>=8 for every legal doubly degenerate norm-one rectangle.
+
+## Eight-coordinate complements preserve the interface
+
+In F2^8 let w be the all-ones vector and define J(x)=x+(x dot w)w.
+The map is linear, w dot w=0, and J is its own inverse. Expanding the two
+cross terms shows J(x) dot J(y)=x dot y. It is therefore an isometry and
+preserves every containment, orthogonal complement, nondegeneracy and
+orthonormal basis condition in the local interface. It also preserves
+disjointness of E and T, since it is an invertible linear map.
+
+Every weight-five label has odd parity, so J sends it to its three-element
+complement. For two weight-five supports with intersection size k,
+their complements intersect in k-2. Consequently
+K(J(s),J(t))=-K(s,t); the entire 2x2 matrix changes by one common sign and
+rank one is preserved. Degenerate pairs remain degenerate. A legal weight-five
+rectangle at h=8 would therefore give a legal triple rectangle there.
+
+## Why a doubly degenerate triple rectangle needs ten coordinates
+
+The following is PR1139's small support classification, included to make the
+dependency inspectable without importing pending code. Write source triples
+as {c,a,b} and {c,d,e}, and let O be the other coordinates. Every triple
+even-orthogonal to both sources has one of four forms:
+
+| Type | Support | Signed kernel column |
+| --- | --- | --- |
+| A | three elements of O | (+1,+1) |
+| B | {a,b,o}, o in O | (-1,+1) |
+| C | {d,e,o}, o in O | (+1,-1) |
+| D | {c,x,y}, x in {a,b}, y in {d,e} | (-1,-1) |
+
+If c is present, parity forces one element from each displayed pair. If c
+is absent, each pair contributes zero or two elements. This proves the list
+complete. Rank one groups the two targets into A/D or B/C. A/D targets are
+disjoint, and two distinct B or two distinct C targets intersect twice,
+so those pairs are not degenerate. Two D targets intersect once only when
+their x and y both differ; their sum is the nonzero source radical
+{a,b,d,e}. Likewise a B/C pair intersects once only with a common o, and
+then has the same sum. These possibilities violate E intersect T={0}.
+Only A/A remains, requiring five coordinates outside the five source
+coordinates. Thus h>=10. In particular no such triple rectangle exists
+at h=8, even before checking incident residuals.
+
+The isometry excludes weight-five rectangles at h=8. The general floor
+excludes h<8. Together these prove the lower bound h>=9 in our local class.
+
+## Nine coordinates attain the bound
+
+Take sources (31,481), targets (47,87), and U=span(31,481,3,40) in F2^9,
+with the masks defined in README.md. The endpoint intersections are one and
+three, every cross intersection is even, and the kernel is
+[[1,1],[-1,-1]]. Direct span inspection gives E intersect T={0}.
+U is nondegenerate, contains E, and is orthogonal to T. The four explicit
+residual bases in README.md each span their full residual and have identity
+Gram matrix. These exact finite vector identities certify this witness;
+both implementations check them. Therefore the minimum ambient dimension
+for this weight-five class is exactly nine.
+
+For h>9 embed these supports and U by zero extension. The complement becomes
+the old U-perp orthogonally summed with standard coordinate lines; each
+outgoing residual gains those same orthonormal lines. Thus existence holds
+for every h>=9. This proves a threshold, not a classification or count of
+all weight-five rectangles in larger dimensions. The h=9 exhaustive census
+is separate finite evidence. No complete supplier, global simultaneous
+frame assignment, cost recurrence or new multiplication exponent follows.
diff --git a/research/five-subset-common-frame-seed48b/vendor/pr1173/README.md b/research/five-subset-common-frame-seed48b/vendor/pr1173/README.md
new file mode 100644
index 0000000000..eb62066005
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/vendor/pr1173/README.md
@@ -0,0 +1,132 @@
+# Five-subset shared nodes: sharp nine-coordinate threshold
+
+**Structural geometry research note; no new kappa or paid supplier.** In the
+historical orthonormal-residual interface, a doubly degenerate two-source,
+two-target shared node with constant-weight-five labels first exists at
+ambient dimension **nine**. This changes the label alphabet in the triple-only
+ten-coordinate classification of [woklerx's PR1139](https://github.com/CrocSwap/integer-mult-bounds/pull/1139).
+It does not lower the eight-coordinate floor for unrestricted norm-one labels
+already attained in [ArnavSwiggy's PR920](https://github.com/CrocSwap/integer-mult-bounds/pull/920).
+
+From the repository root, Python 3.9 or later, standard library only:
+
+```sh
+python3 -I -B research/five-subset-shared-node-seed48/verify.py
+python3 -I -B research/five-subset-shared-node-seed48/independent.py
+```
+
+The first command prints
+`PASS_FIVE_SUBSET_SHARED_NODE threshold=9 rectangles_h9=453600 canonical_frames=59520 residual_bases=4 no_new_kappa`.
+The second independently exhausts all labeled rectangles at h=8,9 and checks
+the four residual bases using coordinate sets. Its final lines are
+`PASS_INDEPENDENT_FIVE_SUBSET_RECTANGLES h8=0 h9=453600` and
+`PASS_INDEPENDENT_RESIDUAL_BASES dimensions=3,3,4,4`.
+Both commands are offline, read-only and retain checks under optimized Python.
+The optional `verify.py --write-certificate` regenerates only this package's
+certificate. See [VALIDATION.md](VALIDATION.md) for completed checks.
+
+## Precise local class
+
+Labels are incidence vectors of five-subsets of a labeled h-coordinate ground
+set, in the standard dot-product space F2^h. Each side is an unordered pair
+of distinct labels; source and target sides are distinguished. Require:
+
+1. Both endpoint spans E=span(s1,s2) and T=span(t1,t2) are degenerate, so
+   both pair intersections have odd size (one or three).
+2. Every cross dot product is zero, and the 2x2 signed scalar matrix
+   K(s,t)=Re(i^|s intersection t|) has rank one over Q.
+3. E intersects T only in zero.
+4. A nondegenerate U satisfies E subset U subset T-perp, and all four
+   incident residuals U intersect si-perp and U-perp intersect tj-perp
+   have orthonormal bases.
+
+The historical side kernel has a common factor 1/2, irrelevant to its rank.
+The label lines and target hyperplanes are fixed; no copied carriers, phases,
+multiple shared nodes or relaxed residual contract enter this class.
+The lower bound is proved in [PROOF.md](PROOF.md), independently of enumeration.
+
+## Exact nine-coordinate witness
+
+Masks use zero-based coordinates, with bit i representing coordinate i:
+
+```text
+sources = (31,481) = ({0,1,2,3,4}, {0,5,6,7,8})
+targets = (47,87)  = ({0,1,2,3,5}, {0,1,2,4,6})
+K = [[1,1],[-1,-1]]
+U = span(31,481,3,40), dimension 4
+w_U = 40, w_(U-perp) = 471
+```
+
+U and U-perp have orthonormal bases `(28,55,481,482)` and
+`(47,59,67,131,259)`, respectively. The exact incident residual bases are:
+
+| Endpoint | Orthonormal basis | Dimension |
+| --- | --- | ---: |
+| Source 31 | 52,457,458 | 3 |
+| Source 481 | 28,55,482 | 3 |
+| Target 47 | 59,67,131,259 | 4 |
+| Target 87 | 131,279,367,379 | 4 |
+
+Both implementations compare each basis's complete generated vector set with
+the actual residual and check every Gram-matrix entry. These dimensions are
+local geometry, not a paid recursive profile.
+
+## Completed finite coverage
+
+Coordinate permutations reduce source pairs to intersection sizes one and
+three. At h=8 only intersection three is possible. At h=9, every valid
+rectangle has a dimension-four frame, and each has exactly **48** such legal
+frames. The complete canonical frame census tests all 155 two-dimensional
+subspaces of T-perp/E for every rectangle: **59,520** candidates total.
+
+| h | Source intersection | Compatible target labels | Canonical valid rectangles | Labeled source pairs | Labeled rectangles |
+| ---: | ---: | ---: | ---: | ---: | ---: |
+| 8 | 3 | 11 | 0 | 840 | 0 |
+| 9 | 1 | 32 | 288 | 315 | 90,720 |
+| 9 | 3 | 30 | 96 | 3,780 | 362,880 |
+
+The independent implementation visits every labeled source pair and every
+cross-compatible target pair, using set intersections, literal integer kernel
+values, determinants and explicit nonzero spans. It imports no primary code
+and uses no symmetry multiplier. It also checks source/target swap symmetry.
+At h=8 all 4,200 degenerate signed-rank-one candidates fail common-span
+disjointness. At h=9 there are 511,560 such candidates, of which 57,960 fail
+that condition. The survivors total **453,600**.
+
+The seed is **48**, one fresh OS-random draw. It selects structural decoder
+research and the odd-weight-five extension, rather than another triple or
+current-frontier search. The fixed domain, three candidate tasks, scope,
+stopping rule and local claim are in [CLAIM.json](CLAIM.json). This is complete
+finite coverage at h=8,9, not an all-dimension census or a formal proof of the
+full multiplication theorem.
+
+## Cost decision, scope and attribution
+
+This mechanism changes copied-information geometry by changing the label
+alphabet. No complete cost improvement follows. Even setting local operations
+optimistically to zero leaves global label coverage, source access, scalar
+gates, helper stock, frame changes, copies, compensation, restoration, recursive
+children, whole-call hosting, precision/tape and analytic transfer obligations
+unresolved. No global decoder is implemented or fed to assembly. The experiment
+stops after the sharp local threshold, witness and exact census; it does not
+reopen the rejected fixed h=26 parity-DAG repair with more computation.
+
+Exact base: **ce7ad1b6ab09452c3478723a2e96ed5ff212dc08**. The reviewed selected
+result at this base is PR1094 with conditional
+kappa=836330098538459/500000000000000000. Its manifest, actual rare-pattern
+construction, assembly certificate and maintainer review were followed.
+Neither the selected frontier nor upstream/ is changed. [SOURCES.json](SOURCES.json)
+records exact source commits and hashes, including pending PR1139's proof.
+Our lower-bound proof restates the small triple classification with attribution,
+so reproducing the new certificate requires no pending code or network access.
+
+Credit Douglas Colkitt's historical parity-side kernel and frame obstruction;
+ArnavSwiggy's PR920 for the residual criterion, four-plus-four floor and general
+norm-one fixtures; woklerx's PR1139 for the triple support classification; and
+the seed47 frame-completion note for the distinction between separating frames
+and legal incident transfers. No predecessor implementation is imported.
+
+Prepared for GitHub contributor **ToikY**, with substantial **OpenAI Codex**
+assistance in mathematics, implementation, algorithmically independent checks,
+review and writing. This is not independent human peer review. New files are
+under Apache-2.0, matching the repository.
diff --git a/research/five-subset-common-frame-seed48b/verify.py b/research/five-subset-common-frame-seed48b/verify.py
new file mode 100644
index 0000000000..c71b20f2de
--- /dev/null
+++ b/research/five-subset-common-frame-seed48b/verify.py
@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Exact common-frame witness and dirty scalar macro. Apache-2.0.
+
+Prepared for ToikY with substantial OpenAI Codex assistance. This checker
+imports neither census implementation nor predecessor executable code.
+"""
+from copy import deepcopy
+import hashlib
+import json
+from pathlib import Path
+import sys
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def load(path):
+    def unique(pairs):
+        result = {}
+        for key, value in pairs:
+            need(key not in result, 'duplicate JSON key')
+            result[key] = value
+        return result
+    return json.loads(path.read_text(), object_pairs_hook=unique)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'))
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def dot(a, b):
+    return bin(a & b).count('1') % 2
+
+
+def closure(rows):
+    out = {0}
+    for row in rows:
+        out = out | {x ^ row for x in out}
+    return out
+
+
+def orthonormal(rows, ambient):
+    need(len(rows) == (len(ambient).bit_length() - 1), 'basis cardinality')
+    need(all(type(x) is int and 0 < x < 512 for x in rows), 'basis vector type/range')
+    need(closure(rows) == ambient, 'basis span')
+    need(all(dot(x, y) == (i == j) for i, x in enumerate(rows)
+             for j, y in enumerate(rows)), 'identity Gram')
+
+
+def find_basis(space):
+    if space == {0}:
+        return []
+    for x in sorted(space):
+        if dot(x, x):
+            tail = find_basis({y for y in space if not dot(x, y)})
+            if tail is not None:
+                answer = [x] + tail
+                orthonormal(answer, space)
+                return answer
+    return None
+
+
+def K(s, t):
+    return (1, 0, -1, 0)[bin(s & t).count('1') % 4]
+
+
+def fixture():
+    sources = [31, 55, 457, 458, 481, 482]
+    targets = [47, 59, 87, 151, 279, 451]
+    U = closure([31, 481, 3, 40])
+    W = {x for x in range(512) if all(not dot(x, u) for u in U)}
+    incoming = [find_basis({u for u in U if not dot(u, s)}) for s in sources]
+    outgoing = [find_basis({w for w in W if not dot(w, t)}) for t in targets]
+    alpha = [1, 1, -1, -1, -1, -1]
+    beta = [1, 1, 1, 1, 1, -1]
+    # Registers: six immutable inputs, six dirty accumulating outputs, one
+    # dirty helper. Its old contribution is removed after literal ungather.
+    word = ([[12, i, c] for i, c in enumerate(alpha)]
+            + [[6 + j, 12, c] for j, c in enumerate(beta)]
+            + [[12, i, -c] for i, c in reversed(list(enumerate(alpha)))]
+            + [[6 + j, 12, -c] for j, c in enumerate(beta)])
+    return {'h': 9, 'source_labels': sources, 'target_labels': targets,
+            'U_basis': [31, 481, 3, 40], 'U_characteristic': 40,
+            'W_characteristic': 471, 'incoming_residual_bases': incoming,
+            'outgoing_residual_bases': outgoing, 'source_signs': alpha,
+            'target_signs': beta, 'word': word}
+
+
+def endpoint(word):
+    matrix = [[int(i == j) for j in range(13)] for i in range(13)]
+    for record in word:
+        need(len(record) == 3 and all(type(v) is int for v in record), 'gate encoding')
+        dst, src, coefficient = record
+        need(0 <= dst < 13 and 0 <= src < 13 and dst != src and abs(coefficient) == 1,
+             'signed ADD operands')
+        matrix[dst] = [x + coefficient * y for x, y in zip(matrix[dst], matrix[src])]
+    return matrix
+
+
+def check(f):
+    need(f['h'] == 9 and type(f['h']) is int, 'ambient dimension')
+    S, T = f['source_labels'], f['target_labels']
+    need(len(S) == len(T) == 6 and len(set(S)) == len(set(T)) == 6, 'endpoint coverage')
+    need(all(type(x) is int and 0 < x < 512 and bin(x).count('1') == 5 for x in S + T),
+         'constant weight-five labels')
+    U = closure(f['U_basis'])
+    W = {v for v in range(512) if all(not dot(v, u) for u in U)}
+    need(len(U) == 16 and len(W) == 32 and U & W == {0}, 'common nondegenerate separator')
+    need(set(S) <= U and set(T) <= W, 'common-frame containment')
+    need(any(dot(x, y) for i, x in enumerate(S) for y in S[i + 1:])
+         and any(dot(x, y) for i, x in enumerate(T) for y in T[i + 1:]),
+         'degenerate pair on both sides')
+    for name, space, labels in [('U_characteristic', U, S), ('W_characteristic', W, T)]:
+        w = f[name]
+        need(w in space and all(dot(w, x) == dot(x, x) for x in space), 'characteristic')
+        need(w not in labels, 'nonalternating incident residuals')
+    need(f['U_characteristic'] ^ f['W_characteristic'] == 511, 'characteristic splitting')
+    for labels, space, key in [(S, U, 'incoming_residual_bases'), (T, W, 'outgoing_residual_bases')]:
+        need(len(f[key]) == len(labels), 'all incident residuals covered')
+        for label, rows in zip(labels, f[key]):
+            orthonormal(rows, {x for x in space if not dot(x, label)})
+    alpha, beta = f['source_signs'], f['target_signs']
+    need(len(alpha) == len(S) and len(beta) == len(T) and all(type(v) is int and abs(v) == 1
+                                                          for v in alpha + beta), 'sign coverage')
+    kernel = [[K(s, t) for s in S] for t in T]
+    need(all(kernel[j][i] == alpha[i] * beta[j] for j in range(6) for i in range(6)),
+         'all 36 signed kernel entries')
+    expected = [[int(i == j) for j in range(13)] for i in range(13)]
+    for j in range(6):
+        expected[6 + j][:6] = kernel[j]
+    need(len(f['word']) == 24 and endpoint(f['word']) == expected, 'full dirty endpoint')
+    inverse = [[d, s, -c] for d, s, c in reversed(f['word'])]
+    identity = [[int(i == j) for j in range(13)] for i in range(13)]
+    need(endpoint(f['word'] + inverse) == identity, 'literal inverse restores all columns')
+    # These are conditional *incident* nested-edge ranks, not a supplier bill.
+    ranks = [3 if dst == 12 else 4 for dst, src, c in f['word']]
+    need(ranks.count(3) == ranks.count(4) == 12 and sum(ranks) == 84, 'incident ranks')
+    return {'kernel_entries': 36, 'input_columns': 13, 'scalar_adds': 24,
+            'direct_scalar_adds': 36, 'saved_scalar_adds': 12,
+            'incident_rank_histogram': {'3': 12, '4': 12}, 'incident_rank_mass': 84,
+            'direct_incident_rank_mass': 252, 'helpers': 1, 'copy_gates': 0,
+            'erase_gates': 0, 'residual_bases': 12, 'residual_dimensions': [3] * 6 + [4] * 6,
+            'full_endpoint_sha256': hashlib.sha256(json.dumps(expected, separators=(',', ':')).encode()).hexdigest(),
+            'scope': 'Integer-normalized scalar kernel and conditional incident-frame ranks; no physical supplier or complete recursive invoice.'}
+
+
+def controls(f):
+    count = 0
+    def rejects(g):
+        nonlocal count
+        try:
+            check(g)
+        except (ValueError, KeyError, IndexError, TypeError):
+            count += 1
+            return
+        raise ValueError('negative control accepted')
+    for index in (0, 6, 12, 18):
+        g = deepcopy(f); del g['word'][index]; rejects(g)
+    g = deepcopy(f); g['word'][0][2] *= -1; rejects(g)
+    g = deepcopy(f); g['source_signs'][0] *= -1; rejects(g)
+    g = deepcopy(f); g['incoming_residual_bases'][0].pop(); rejects(g)
+    g = deepcopy(f); g['outgoing_residual_bases'].pop(); rejects(g)
+    g = deepcopy(f); g['outgoing_residual_bases'][0][0] ^= 1; rejects(g)
+    g = deepcopy(f); g['U_basis'].pop(); rejects(g)
+    g = deepcopy(f); g['W_characteristic'] ^= 1; rejects(g)
+    g = deepcopy(f); g['word'][0][0] = True; rejects(g)
+    # All source columns can look correct if old helper cancellation is absent.
+    missing = endpoint(f['word'][:18])
+    correct = endpoint(f['word'])
+    need(all(row[:6] == ref[:6] for row, ref in zip(missing, correct))
+         and missing != correct, 'dirty-state omission is invisible to clean-source-only tests')
+    return count
+
+
+def pins():
+    sources = load(HERE / 'SOURCES.json')
+    for rec in sources['repository_inputs']:
+        need(hashlib.sha256((ROOT / rec['path']).read_bytes()).hexdigest() == rec['sha256'], 'repository source pin')
+    for rec in sources['retained_inputs']:
+        need(hashlib.sha256((HERE / rec['path']).read_bytes()).hexdigest() == rec['sha256'], 'retained source pin')
+    for rec in sources.get('package_sources', []):
+        need(hashlib.sha256((HERE / rec['path']).read_bytes()).hexdigest() == rec['sha256'], 'package source pin')
+    selected = load(ROOT / 'certificates/selected-result.json')
+    need(selected['source_prs'][0] == 1094 and selected['certificate_sha256'] == sources['selected_certificate_sha256'], 'selected record guard')
+    need(hashlib.sha256((ROOT / selected['certificate']).read_bytes()).hexdigest()
+         == sources['selected_certificate_sha256'], 'selected certificate guard')
+    return len(sources['repository_inputs']) + len(sources['retained_inputs']) + len(sources.get('package_sources', []))
+
+
+def main():
+    need(sys.argv[1:] in ([], ['--write']), 'usage: verify.py [--write]')
+    f = fixture()
+    result = {'base_commit': '1b59b624d21924f8e3537cdc1ac52d3be6eda2fe', 'seed': 48,
+              'witness': f, 'checks': check(f), 'negative_controls': controls(f),
+              'source_pins': pins(), 'new_kappa': False}
+    path = HERE / 'WITNESS.json'
+    if sys.argv[1:] == ['--write']:
+        path.write_text(json.dumps(result, indent=2) + '\n')
+    else:
+        need(canonical(load(path)) == canonical(result), 'witness certificate mismatch')
+    print('PASS_COMMON_FRAME_WEIGHT5_WITNESS area=36 residuals=12 dirty_columns=13 adds=24 incident_rank_mass=84 controls=12 no_new_kappa')
+
+
+if __name__ == '__main__':
+    main()