diff --git a/.github/workflows/birth-read-reuse.yml b/.github/workflows/birth-read-reuse.yml
new file mode 100644
index 0000000000..2e20ee9934
--- /dev/null
+++ b/.github/workflows/birth-read-reuse.yml
@@ -0,0 +1,23 @@
+name: Verify birth-read reuse witness
+on: [push, pull_request, workflow_dispatch]
+permissions:
+  contents: read
+jobs:
+  focused:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11', '3.13', '3.14']
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Reconstruct and check the frozen birth-read witness
+        run: python3 research/birth-read-reuse/run_checks.py
+      - name: Require unchanged tracked inputs and receipts
+        run: git diff --exit-code
diff --git a/.github/workflows/cube-deferred.yml b/.github/workflows/cube-deferred.yml
new file mode 100644
index 0000000000..2c75aeec3f
--- /dev/null
+++ b/.github/workflows/cube-deferred.yml
@@ -0,0 +1,21 @@
+name: Verify cube deferred witness
+on: [push, pull_request, workflow_dispatch]
+permissions:
+  contents: read
+jobs:
+  focused:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 25
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11', '3.13', '3.14']
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python3 research/cube-deferred/verify.py
+      - run: git diff --exit-code
diff --git a/.github/workflows/cyclic-deferred.yml b/.github/workflows/cyclic-deferred.yml
new file mode 100644
index 0000000000..48ef40fb9a
--- /dev/null
+++ b/.github/workflows/cyclic-deferred.yml
@@ -0,0 +1,21 @@
+name: Verify cyclic deferred witness
+on: [push, pull_request, workflow_dispatch]
+permissions:
+  contents: read
+jobs:
+  focused:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 25
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11', '3.13', '3.14']
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python3 research/cyclic-deferred/verify.py
+      - run: git diff --exit-code
diff --git a/Makefile b/Makefile
index 84fe8290f3..e60b843993 100644
--- a/Makefile
+++ b/Makefile
@@ -30,6 +30,7 @@ verify-community: community-audit-check community-followup-check copied-reversed
 	$(MAKE) climbed-48-verify
 
 verify-producers:
+	$(MAKE) stopped-product-verify
 	$(MAKE) copied-centers-verify
 	$(MAKE) structured-bulk-verify
 	$(MAKE) endpoint-gauge-producer endpoint-gauge-certificate
@@ -428,3 +429,12 @@ pair-assembly-verify: pair-assembly-producer pair-assembly-check
 .PHONY: verify-pair
 verify-pair: pair-assembly-verify
 	python3 scripts/audit_pair_candidate.py --check docs/research/community-pair-arithmetic.json
+
+.PHONY: stopped-product-producer stopped-product-certificate stopped-product-verify
+stopped-product-producer:
+	python3 scripts/stopped_product_producer.py
+
+stopped-product-certificate:
+	python3 scripts/stopped_product_network.py
+
+stopped-product-verify: stopped-product-producer stopped-product-certificate
diff --git a/NOTICE b/NOTICE
index b565637758..50c6d1236d 100644
--- a/NOTICE
+++ b/NOTICE
@@ -302,3 +302,20 @@ inherited PR #48 sources. The stacked witness in research/pair-assembly/frame
 uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier
 are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and
 verify_skip_frame.py. Original notices are retained.
+
+Stopped product-ring extension, 9 October 2026
+Copyright 2026 icekylinx
+
+The opposite-bank generic projector factorization, componentwise atom-ring
+adapters, stopped recurrence and outer ordinary-interchange conversion,
+aligned pair-star producer with rational centers, exact denominator-21
+grid and selected (23,23)/(24,24) composition are contributed by icekylinx
+with substantial OpenAI GPT-6 Astra and Codex assistance. This extension
+builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is
+integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37.
+
+The retained ordinary leaf uses the preceding projector, corner and
+copied-center proofs. The selected two-stage topology retains Aurel Prosz
+(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly
+retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching,
+original source notices and each imported license remain unchanged.
diff --git a/PATCHING.md b/PATCHING.md
index b60f3f101b..a02e230256 100644
--- a/PATCHING.md
+++ b/PATCHING.md
@@ -1,6 +1,6 @@
 # Applying the inherited manuscript patch
 
-This patch is the PR #10 baseline. The current copied-center extension is
+This patch is the PR #10 baseline. The PR #36 copied-center extension is
 presented in `notes/copied-centers-note.tex`; it is not included
 in this historical combined manuscript patch.
 
@@ -30,3 +30,6 @@ alternatives for the same base. PR7 is pinned at
 `6725c6a17b17871a35353fd29157f4ed851bc114` for the retained producer sources.
 The old uniform recurrences keep their original exponents. The active consumers
 use `lem:batched-chunk-swap` and `prop:batched-simultaneous-layer`.
+
+The stopped product-ring extension is supplied separately in
+`notes/stopped-product-note.tex`; it does not regenerate this historical patch.
diff --git a/README.md b/README.md
index 035c259b68..31aa46c2e2 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,36 @@
 **Community research maintained by Douglas Colkitt — conditional on the original
 OpenAI #109 framework.**
 
+## Stopped product-ring extension
+
+The new construction contributed by **icekylinx**, extending merged
+[PR #36](https://github.com/CrocSwap/integer-mult-bounds/pull/36), gives
+
+$$
+T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad
+\kappa=\frac{194869}{2500000000}=7.79476\times10^{-5}.
+$$
+
+It combines a stopped product-ring bit interchange on `(23,23)` with an
+all-disjoint rational-center complex network on `(24,24)`. The new generic
+opposite-bank factorization pays one reversed child per projector rank;
+atom adapters, ordinary leaves, endpoint copies and the exact denominator-21
+grid are included in the proof. The bound retains the original analytic
+and fixed-tape hypotheses.
+
+[Proof source](notes/stopped-product-note.tex) ·
+[Exact certificate](certificates/stopped-product-network.json) ·
+[Incremental reproduction](docs/stopped-product.md)
+
+```sh
+make stopped-product-verify
+```
+
+The maintainer-reviewed community checkpoint below remains its own result
+and validation record.
+
+## Reviewed community checkpoint
+
 The reviewed community witness gives
 
 $$
diff --git a/SOURCES.json b/SOURCES.json
index 6096d5aff9..380b5425c2 100644
--- a/SOURCES.json
+++ b/SOURCES.json
@@ -234,5 +234,47 @@
       }
     ],
     "continuing_analytic_dependencies": "See structured_bulk_extension.adopted and references/semantic-bulk/MANIFEST.json."
+  },
+  "stopped_product_extension": {
+    "contributor": "icekylinx",
+    "base_commit": "56b66d58297deca1d7dd130247d720e960f77a37",
+    "proof_predecessor_PR": "https://github.com/CrocSwap/integer-mult-bounds/pull/36",
+    "proof_predecessor_commit": "11817ccacb564bb7f98789c20dc11d3fece207e3",
+    "predecessor_merged": true,
+    "archive": "integer_mult_round5_kappa_7_79476e-5_complete.zip",
+    "archive_sha256": "714cbffa0cccba3c18f046a63e62d6981683cb386b5d5cd09761be7b70f0b0be",
+    "kappa": "194869/2500000000",
+    "proof": "notes/stopped-product-note.tex",
+    "certificate": "certificates/stopped-product-network.json",
+    "producer": "scripts/stopped_product_producer.py",
+    "assistance": "Substantial OpenAI GPT-6 Astra and Codex assistance.",
+    "scope": "Conditional on the retained analytic and fixed-tape framework; new product-ring and exact rational-grid arguments supplied as written proofs.",
+    "continuing_dependencies": [
+      "copied_centers_extension",
+      "structured_bulk_extension"
+    ],
+    "icekylinx_lineage": [
+      {
+        "pr": 10,
+        "commit": "62691e395a0458ce089a1c7b5d89e74291e95e29"
+      },
+      {
+        "pr": 18,
+        "commit": "f2ab41aebad47861caf6316282c1793e5513845e"
+      },
+      {
+        "pr": 24,
+        "commit": "ed90fd940279c336ebc45968631bdebfb087b505"
+      },
+      {
+        "pr": 32,
+        "commit": "0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52"
+      },
+      {
+        "pr": 36,
+        "commit": "11817ccacb564bb7f98789c20dc11d3fece207e3"
+      }
+    ],
+    "curation": "Selected h23/h24 inputs, generator, exact certificate and proofs only; excludes raw graphs, research alternatives and recursive predecessor copies."
   }
 }
diff --git a/certificates/joint-dual-kappa.json b/certificates/joint-dual-kappa.json
index d92f653fe4..31628a32dc 100644
--- a/certificates/joint-dual-kappa.json
+++ b/certificates/joint-dual-kappa.json
@@ -842,7 +842,7 @@
     "scripts/experiments/pin_joint_dual_sources.py": "4d31cc0e38b7902709ca5f8f714cba109760d2592346dd7f8dc0b900a2d9fe00",
     "scripts/experiments/verify_joint_dual.py": "7a31bba1e9c0ded32ae285df2ca9bc91ef20c330f6789fdba361876f3c7a1985"
   },
-  "source_manifest_sha256": "fd1aab7d75753b4b55b2377f26119dae74f367b0b4fab66cba42d944b3042cc9",
+  "source_manifest_sha256": "db926540bbc818963af5ac78ed8949e6263afffdbbe2f05ee781ef7d3cde48f0",
   "sources": [
     {
       "files": {
diff --git a/certificates/joint-dual-validation.json b/certificates/joint-dual-validation.json
index 99adb4cf74..b2624180c2 100644
--- a/certificates/joint-dual-validation.json
+++ b/certificates/joint-dual-validation.json
@@ -226,7 +226,7 @@
     }
   },
   "bit_saving": "2382370177/50000000000000",
-  "certificate_sha256": "2ed658f05365b28825e24a6e7bac9fc9cc015d5a5d63d9579f4ac6e0640ae559",
+  "certificate_sha256": "b8263db0d04aabb98a31965a40c198667709bd6a6c7f98df2990baf523bcd075",
   "kappa": "4764513337/100000000000000",
   "margins": 7,
   "producer_words_regenerated_and_matched": true,
diff --git a/certificates/stopped-product-bit-axis.json b/certificates/stopped-product-bit-axis.json
new file mode 100644
index 0000000000..5824891de9
--- /dev/null
+++ b/certificates/stopped-product-bit-axis.json
@@ -0,0 +1,38 @@
+{
+  "h": 23,
+  "v": 1771,
+  "c": 34764,
+  "q": 5336,
+  "baseline_R": 40100,
+  "matching": 1324,
+  "R": 38776,
+  "loss": 506,
+  "histogram": [
+    9840,
+    38409,
+    32471,
+    8898,
+    9754,
+    2116,
+    5737,
+    1725,
+    4145,
+    1547,
+    3128,
+    1551,
+    2893,
+    1925,
+    2841,
+    2450,
+    2327,
+    3096,
+    2344,
+    3628,
+    9435,
+    2110,
+    23,
+    23
+  ],
+  "label_source": "positive",
+  "description": "Retained-total aligned triple producer, base-two recursion, original maximum carrier matching, and compatible positive labels."
+}
diff --git a/certificates/stopped-product-complex-input.json b/certificates/stopped-product-complex-input.json
new file mode 100644
index 0000000000..7b1d99c518
--- /dev/null
+++ b/certificates/stopped-product-complex-input.json
@@ -0,0 +1,41 @@
+{
+  "h": 24,
+  "v": 2024,
+  "c": 45764,
+  "q": 8120,
+  "baseline_R": 53884,
+  "matched": 8966,
+  "R": 44918,
+  "orientation_changes": 7338,
+  "rank_sum": 1079136,
+  "loss": 552,
+  "histogram": [
+    8930,
+    49042,
+    30844,
+    15972,
+    11883,
+    8272,
+    6399,
+    4356,
+    6682,
+    2263,
+    5109,
+    1808,
+    5317,
+    1733,
+    5391,
+    1757,
+    4908,
+    3290,
+    6233,
+    4363,
+    4056,
+    264,
+    564,
+    24,
+    24
+  ],
+  "central_disjoint": 24,
+  "center_denominator": 21
+}
diff --git a/certificates/stopped-product-input.json b/certificates/stopped-product-input.json
new file mode 100644
index 0000000000..f0a910a495
--- /dev/null
+++ b/certificates/stopped-product-input.json
@@ -0,0 +1,253 @@
+{
+  "bit": {
+    "dimensions": [
+      23,
+      23
+    ],
+    "m": 529,
+    "N": 3136441,
+    "W": 143617474,
+    "L": 1792252,
+    "total_rank": 75972299557,
+    "deficit": 1344189,
+    "maxchild": 506,
+    "child_multiplicities": {
+      "1": 139262585,
+      "2": 115012282,
+      "3": 31516716,
+      "4": 34548668,
+      "5": 7494872,
+      "6": 20320454,
+      "7": 6109950,
+      "8": 14681590,
+      "9": 5479474,
+      "10": 11079376,
+      "11": 5493642,
+      "12": 10247006,
+      "13": 6818350,
+      "14": 10062822,
+      "15": 8677900,
+      "16": 8242234,
+      "17": 10966032,
+      "18": 8302448,
+      "19": 12850376,
+      "20": 33418770,
+      "21": 7473620,
+      "22": 12627230,
+      "484": 6272882,
+      "506": 137344592
+    }
+  },
+  "complex": {
+    "dimensions": [
+      24,
+      24
+    ],
+    "m": 576,
+    "N": 4096576,
+    "B1": 90914032,
+    "B2": 90914032,
+    "W": 190021216,
+    "L": 2234496,
+    "total_rank": 109450358336,
+    "deficit": 1862080,
+    "child_multiplicities": {
+      "552": 181828064,
+      "529": 8193152,
+      "1": 202715744,
+      "2": 124856512,
+      "3": 64654656,
+      "4": 48102384,
+      "5": 33485056,
+      "6": 25903152,
+      "7": 17633088,
+      "8": 27048736,
+      "9": 9160624,
+      "10": 20681232,
+      "11": 7318784,
+      "12": 21523216,
+      "13": 7015184,
+      "14": 21822768,
+      "15": 7112336,
+      "16": 19867584,
+      "17": 13317920,
+      "18": 25231184,
+      "19": 17661424,
+      "20": 16418688,
+      "21": 1068672,
+      "22": 2283072,
+      "23": 16483456
+    },
+    "maxchild": 552,
+    "copied_histogram": [
+      8930,
+      49066,
+      30844,
+      15972,
+      11883,
+      8272,
+      6399,
+      4356,
+      6682,
+      2263,
+      5109,
+      1808,
+      5317,
+      1733,
+      5391,
+      1757,
+      4908,
+      3290,
+      6233,
+      4363,
+      4056,
+      264,
+      564,
+      24,
+      0
+    ]
+  },
+  "bit_moment_gap": "5833629405069796335513229037/13595148940731587639987765177686687744",
+  "complex_moment_gap": "5499421901694541095908997425024101371546537414283732387206104389099738183215366564793192567257041780652609318673168302647523216560182242981533611801155442603608986943408777543208667066118724847925169249370145237707441178592436788856344246441565482324551821454604550454953780270300756671351666361036963486701477553679079126088067165335949185500960812006586245961913848693714754073033035419679174118868763905107326417918471742975833959733450001524553321932789312500612407132407690299/41230077325513267360846956938521502341474073689326505257121676970478810391277326276471865083362032190646188250982499628351612283105589897175543987487125650452330304348151388045812369968133964037865011250349179368669257862504666828211703334554008512518414563221340357395437053315115874615168412042904680012697363239611038021437069048505672439008745508864584512067644825937731293242352557278635159598633861792145775836588122497044363982384099548431927704944786606529202786560000000000000000000",
+  "finite_bridge": {
+    "bit_coarse": {
+      "m": 529,
+      "W": 143617474,
+      "maxchild": 506,
+      "halving_degree": 16,
+      "wire_bits": 28
+    },
+    "ordinary_leaf_row_degree": 252,
+    "complex": {
+      "m": 576,
+      "W": 190021216,
+      "s": 109450358336,
+      "maxchild": 552,
+      "halving_degree": 17,
+      "wire_bits": 28,
+      "scalar_terms": [
+        {
+          "h": 24,
+          "v": 2024,
+          "c": 45764,
+          "invocations": 2024,
+          "local_group_upper": 408200,
+          "copied_center_extra_groups": 48
+        },
+        {
+          "h": 24,
+          "v": 2024,
+          "c": 45764,
+          "invocations": 2024,
+          "local_group_upper": 408200,
+          "copied_center_extra_groups": 48
+        }
+      ],
+      "scalar_group_upper": 1656684480
+    },
+    "semantic": {
+      "E": 403063477262941121443761178688,
+      "literal_charge": 119639333593035096270287748,
+      "strict_literal_gap": 402943837929348086347490890940,
+      "B": 403063477262941121553211537024,
+      "C0": 2994465792675104952757349965746759652008778122322142627817848832,
+      "C1": 1,
+      "induction_gap": 18943983431358232713000942240128,
+      "fixed_odd_divisor": 21,
+      "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding"
+    },
+    "rows": {
+      "coefficient": 1176,
+      "degree": 4000,
+      "suffix_slope": 16000,
+      "degree_gap": "40024/25",
+      "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse"
+    }
+  },
+  "assembly": {
+    "parameters": {
+      "actual_bit_saving": "803380799/10000000000000",
+      "a_bit": "1948995551/25000000000000",
+      "a_complex": "1949/25000000",
+      "tau": "24998051004449/25000000000000",
+      "sigma": "24998051/25000000",
+      "eta": "1/100000000",
+      "beta": "1/1000000",
+      "q": "97449775601004449/1250000000000000000000",
+      "c": "9744977657550220501004449/125000000000000000000000000000",
+      "epsilon": "124999998750000000000000000000/125019489955217650665401004449",
+      "lambda_": "2499805100446848995551/2500000000000000000000",
+      "lambda_prime": "1249902550224398995551/1250000000000000000000",
+      "alpha_squared_power": "14618091340150667350000000/125019489955217650665401004449",
+      "delta": "1/800000000",
+      "C0": 2994465792675104952757349965746759652008778122322142627817848832,
+      "C1": 1,
+      "kappa": "194869/2500000000"
+    },
+    "strict_constraints": {
+      "bit_positive": "1948995551/25000000000000",
+      "complex_above_bit": "4449/25000000000000",
+      "complex_below_one_over32": "779301/25000000",
+      "beta_positive": "1/1000000",
+      "beta_below_one": "999999/1000000",
+      "leaf_saving_above_bit": "1/10000000000",
+      "q_positive": "97449775601004449/1250000000000000000000",
+      "q_below_internal": "1948995551/1250000000000000000000",
+      "q_below_leaf": "126948995551/1250000000000000000000",
+      "c_positive": "9744977657550220501004449/125000000000000000000000000000",
+      "c_below_one": "124990255022342449779498995551/125000000000000000000000000000",
+      "q_below_reservations": "97449775601004449/125000000000000000000000000000",
+      "lambda_above_tau": "1948995551/2500000000000000000000",
+      "lambda_above_sigma": "446848995551/2500000000000000000000",
+      "lambda_above_internal": "1948995551/2500000000000000000000",
+      "lambda_prime_above_lambda": "1948995551/2500000000000000000000",
+      "compact_leaf": "126948995551/1250000000000000000000",
+      "compact_reservations": "97449775601004449/125000000000000000000000000000",
+      "lambda_prime_below_one": "97449775601004449/1250000000000000000000",
+      "epsilon_positive": "124999998750000000000000000000/125019489955217650665401004449",
+      "epsilon_below_one": "19491205217650665401004449/125019489955217650665401004449",
+      "guard_width": "19491205217650665401004449/125019489955217650665401004449",
+      "K_geometry": "974622765755022147550220501004449/12501948995521765066540100444900000000",
+      "K_dominates_log": "974497756010044392550224398995551/12501948995521765066540100444900000000",
+      "record_suffix": "19491205217650665401004449/125019489955217650665401004449",
+      "phase_local": "15592839154630577103152893798995551/100015591964174120532320803559200000000",
+      "phase_boundary": "11694348052630578662349334598995551/100015591964174120532320803559200000000",
+      "gamma_sublinear": "4873113877499998051004449/125019489955217650665401004449",
+      "cell_above_band": "124995125636122500001948995551/250038979910435301330802008898",
+      "prime_interval_packing": "19491205217650665401004449/125019489955217650665401004449",
+      "alpha_positive": "14618091340150667350000000/125019489955217650665401004449",
+      "alpha_below_one": "125004871863877499998051004449/125019489955217650665401004449",
+      "alpha_below_one_fourth": "124961017589857047996001004449/500077959820870602661604017796",
+      "delta_positive": "1/800000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "short_record_fallback": "3124756306320288991609616461252697967793601/3125487248880441266635025111225000000000000",
+      "small_field_exposure": "9746227754999996102008898/125019489955217650665401004449",
+      "artificial_boundary": "700128635079475474301789581367398995551/100015591964174120532320803559200000000",
+      "literal_scalar_guard": "402943837929348086347490890940",
+      "row_product_gap": "40024/25",
+      "original_prefix_above_kappa": "786538948061330309871047284761/78137181222011031665875627780625000000",
+      "coordinate_movement_above_kappa": "305551/25000000000000",
+      "compact_phase_layer_above_kappa": "20668543364879972849164027819/312548724888044126663502511122500000000",
+      "bulk_exposure_above_kappa": "305551/25000000000000",
+      "Gaussian_arithmetic_above_kappa": "97459317411097999618605138287111327/2500389799104353013308020088980000000000",
+      "scalar_work_above_kappa": "194921594961097960638694118287111327/2500389799104353013308020088980000000000",
+      "dimension_above_kappa": "312475634452011916691632483971664027819/312548724888044126663502511122500000000"
+    },
+    "margins": {
+      "original_prefix": "974622765755022147550220501004449/12501948995521765066540100444900000000",
+      "coordinate_movement": "1948995551/25000000000000",
+      "compact_phase_layer": "9744977462650669298995551/125019489955217650665401004449",
+      "bulk_exposure": "1948995551/25000000000000",
+      "Gaussian_arithmetic": "11694348052630578662349334598995551/100015591964174120532320803559200000000",
+      "scalar_work": "15592839154630577103152893798995551/100015591964174120532320803559200000000",
+      "dimension": "124999998750000000000000000000/125019489955217650665401004449"
+    },
+    "minimum_margin": "9744977462650669298995551/125019489955217650665401004449",
+    "absorption_gap": "20668543364879972849164027819/312548724888044126663502511122500000000",
+    "recurrence": {
+      "internal": "24998051004449/25000000000000",
+      "leaf": "24998051001949/25000000000000",
+      "reservations": "124990255022342449779498995551/125000000000000000000000000000"
+    }
+  }
+}
diff --git a/certificates/stopped-product-network.json b/certificates/stopped-product-network.json
new file mode 100644
index 0000000000..998a8a7ea2
--- /dev/null
+++ b/certificates/stopped-product-network.json
@@ -0,0 +1,482 @@
+{
+  "assembly": {
+    "absorption_gap": "20668543364879972849164027819/312548724888044126663502511122500000000",
+    "margins": {
+      "Gaussian_arithmetic": "11694348052630578662349334598995551/100015591964174120532320803559200000000",
+      "bulk_exposure": "1948995551/25000000000000",
+      "compact_phase_layer": "9744977462650669298995551/125019489955217650665401004449",
+      "coordinate_movement": "1948995551/25000000000000",
+      "dimension": "124999998750000000000000000000/125019489955217650665401004449",
+      "original_prefix": "974622765755022147550220501004449/12501948995521765066540100444900000000",
+      "scalar_work": "15592839154630577103152893798995551/100015591964174120532320803559200000000"
+    },
+    "minimum_margin": "9744977462650669298995551/125019489955217650665401004449",
+    "parameters": {
+      "C0": 2994465792675104952757349965746759652008778122322142627817848832,
+      "C1": 1,
+      "a_bit": "1948995551/25000000000000",
+      "a_complex": "1949/25000000",
+      "actual_bit_saving": "803380799/10000000000000",
+      "alpha_squared_power": "14618091340150667350000000/125019489955217650665401004449",
+      "beta": "1/1000000",
+      "c": "9744977657550220501004449/125000000000000000000000000000",
+      "delta": "1/800000000",
+      "epsilon": "124999998750000000000000000000/125019489955217650665401004449",
+      "eta": "1/100000000",
+      "kappa": "194869/2500000000",
+      "lambda_": "2499805100446848995551/2500000000000000000000",
+      "lambda_prime": "1249902550224398995551/1250000000000000000000",
+      "q": "97449775601004449/1250000000000000000000",
+      "sigma": "24998051/25000000",
+      "tau": "24998051004449/25000000000000"
+    },
+    "recurrence": {
+      "internal": "24998051004449/25000000000000",
+      "leaf": "24998051001949/25000000000000",
+      "reservations": "124990255022342449779498995551/125000000000000000000000000000"
+    },
+    "strict_constraints": {
+      "Gaussian_arithmetic_above_kappa": "97459317411097999618605138287111327/2500389799104353013308020088980000000000",
+      "K_dominates_log": "974497756010044392550224398995551/12501948995521765066540100444900000000",
+      "K_geometry": "974622765755022147550220501004449/12501948995521765066540100444900000000",
+      "alpha_below_one": "125004871863877499998051004449/125019489955217650665401004449",
+      "alpha_below_one_fourth": "124961017589857047996001004449/500077959820870602661604017796",
+      "alpha_positive": "14618091340150667350000000/125019489955217650665401004449",
+      "artificial_boundary": "700128635079475474301789581367398995551/100015591964174120532320803559200000000",
+      "beta_below_one": "999999/1000000",
+      "beta_positive": "1/1000000",
+      "bit_positive": "1948995551/25000000000000",
+      "bulk_exposure_above_kappa": "305551/25000000000000",
+      "c_below_one": "124990255022342449779498995551/125000000000000000000000000000",
+      "c_positive": "9744977657550220501004449/125000000000000000000000000000",
+      "cell_above_band": "124995125636122500001948995551/250038979910435301330802008898",
+      "compact_leaf": "126948995551/1250000000000000000000",
+      "compact_phase_layer_above_kappa": "20668543364879972849164027819/312548724888044126663502511122500000000",
+      "compact_reservations": "97449775601004449/125000000000000000000000000000",
+      "complex_above_bit": "4449/25000000000000",
+      "complex_below_one_over32": "779301/25000000",
+      "coordinate_movement_above_kappa": "305551/25000000000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "delta_positive": "1/800000000",
+      "dimension_above_kappa": "312475634452011916691632483971664027819/312548724888044126663502511122500000000",
+      "epsilon_below_one": "19491205217650665401004449/125019489955217650665401004449",
+      "epsilon_positive": "124999998750000000000000000000/125019489955217650665401004449",
+      "gamma_sublinear": "4873113877499998051004449/125019489955217650665401004449",
+      "guard_width": "19491205217650665401004449/125019489955217650665401004449",
+      "lambda_above_internal": "1948995551/2500000000000000000000",
+      "lambda_above_sigma": "446848995551/2500000000000000000000",
+      "lambda_above_tau": "1948995551/2500000000000000000000",
+      "lambda_prime_above_lambda": "1948995551/2500000000000000000000",
+      "lambda_prime_below_one": "97449775601004449/1250000000000000000000",
+      "leaf_saving_above_bit": "1/10000000000",
+      "literal_scalar_guard": "402943837929348086347490890940",
+      "original_prefix_above_kappa": "786538948061330309871047284761/78137181222011031665875627780625000000",
+      "phase_boundary": "11694348052630578662349334598995551/100015591964174120532320803559200000000",
+      "phase_local": "15592839154630577103152893798995551/100015591964174120532320803559200000000",
+      "prime_interval_packing": "19491205217650665401004449/125019489955217650665401004449",
+      "q_below_internal": "1948995551/1250000000000000000000",
+      "q_below_leaf": "126948995551/1250000000000000000000",
+      "q_below_reservations": "97449775601004449/125000000000000000000000000000",
+      "q_positive": "97449775601004449/1250000000000000000000",
+      "record_suffix": "19491205217650665401004449/125019489955217650665401004449",
+      "row_product_gap": "40024/25",
+      "scalar_work_above_kappa": "194921594961097960638694118287111327/2500389799104353013308020088980000000000",
+      "short_record_fallback": "3124756306320288991609616461252697967793601/3125487248880441266635025111225000000000000",
+      "small_field_exposure": "9746227754999996102008898/125019489955217650665401004449"
+    }
+  },
+  "base_commit": "56b66d58297deca1d7dd130247d720e960f77a37",
+  "bit": {
+    "counts": {
+      "B1": 68672296,
+      "B2": 68672296,
+      "L": 1792252,
+      "N": 3136441,
+      "W": 143617474,
+      "child_multiplicities": {
+        "1": 139262585,
+        "10": 11079376,
+        "11": 5493642,
+        "12": 10247006,
+        "13": 6818350,
+        "14": 10062822,
+        "15": 8677900,
+        "16": 8242234,
+        "17": 10966032,
+        "18": 8302448,
+        "19": 12850376,
+        "2": 115012282,
+        "20": 33418770,
+        "21": 7473620,
+        "22": 12627230,
+        "3": 31516716,
+        "4": 34548668,
+        "484": 6272882,
+        "5": 7494872,
+        "506": 137344592,
+        "6": 20320454,
+        "7": 6109950,
+        "8": 14681590,
+        "9": 5479474
+      },
+      "copied_histogram": [
+        9840,
+        38432,
+        32471,
+        8898,
+        9754,
+        2116,
+        5737,
+        1725,
+        4145,
+        1547,
+        3128,
+        1551,
+        2893,
+        1925,
+        2841,
+        2450,
+        2327,
+        3096,
+        2344,
+        3628,
+        9435,
+        2110,
+        23,
+        0
+      ],
+      "deficit": 1344189,
+      "dimensions": [
+        23,
+        23
+      ],
+      "m": 529,
+      "maxchild": 506,
+      "total_rank": 75972299557
+    },
+    "exponent": "49995981/50000000",
+    "logarithm_upper_bounds": {
+      "1": "1987355562417364065669439618237/316912650057057350374175801344",
+      "10": "2515274437229490418617839725263/633825300114114700748351602688",
+      "11": "4909728867822167960512763283247/1267650600228229401496703205376",
+      "12": "2399714421777289519579293961239/633825300114114700748351602688",
+      "13": "4697962657128327885574713503543/1267650600228229401496703205376",
+      "14": "1151004910436491358992364195459/316912650057057350374175801344",
+      "15": "2258280393397031167285649759463/633825300114114700748351602688",
+      "16": "2217374245868088984102352158015/633825300114114700748351602688",
+      "17": "4357897653501964928993364503311/1267650600228229401496703205376",
+      "18": "4285440755889660536494207989699/1267650600228229401496703205376",
+      "19": "1054225602598430741931079593279/316912650057057350374175801344",
+      "2": "3535376905093068344529747466859/633825300114114700748351602688",
+      "20": "4151880434975661263617415911297/1267650600228229401496703205376",
+      "21": "4090031554081046933305076849055/1267650600228229401496703205376",
+      "22": "4031060428338848386894499744017/1267650600228229401496703205376",
+      "3": "6556765722521218186395115000937/1267650600228229401496703205376",
+      "4": "6192085370702817115441231394489/1267650600228229401496703205376",
+      "484": "28174651752060127777810254067/316912650057057350374175801344",
+      "5": "1477304328485575102713485747439/316912650057057350374175801344",
+      "506": "28174651752060127777810254067/633825300114114700748351602688",
+      "6": "1419524320759474653194212865427/316912650057057350374175801344",
+      "7": "2741344040614642504793860160533/633825300114114700748351602688",
+      "8": "5313416931219497541822967855259/1267650600228229401496703205376",
+      "9": "161378412355405628441014735279/39614081257132168796771975168"
+    },
+    "moment_upper": "13595148934897958234917968842173458707/13595148940731587639987765177686687744",
+    "rank_moment": "1865129/1865162",
+    "rounding_denominator": 1267650600228229401496703205376,
+    "saving": "4019/50000000",
+    "stopped_adapter": {
+      "atom_exponent": "1/1000",
+      "base_ordinary_saving": "384599/10000000000",
+      "coarse_toll_exponent": "999/1000",
+      "coarse_toll_subordinate_gap": "45981/50000000",
+      "effective_saving": "803380799/10000000000000"
+    },
+    "strict_gap": "5833629405069796335513229037/13595148940731587639987765177686687744"
+  },
+  "complex": {
+    "child_width_multiplicities": [
+      [
+        1,
+        202715744
+      ],
+      [
+        2,
+        124856512
+      ],
+      [
+        3,
+        64654656
+      ],
+      [
+        4,
+        48102384
+      ],
+      [
+        5,
+        33485056
+      ],
+      [
+        6,
+        25903152
+      ],
+      [
+        7,
+        17633088
+      ],
+      [
+        8,
+        27048736
+      ],
+      [
+        9,
+        9160624
+      ],
+      [
+        10,
+        20681232
+      ],
+      [
+        11,
+        7318784
+      ],
+      [
+        12,
+        21523216
+      ],
+      [
+        13,
+        7015184
+      ],
+      [
+        14,
+        21822768
+      ],
+      [
+        15,
+        7112336
+      ],
+      [
+        16,
+        19867584
+      ],
+      [
+        17,
+        13317920
+      ],
+      [
+        18,
+        25231184
+      ],
+      [
+        19,
+        17661424
+      ],
+      [
+        20,
+        16418688
+      ],
+      [
+        21,
+        1068672
+      ],
+      [
+        22,
+        2283072
+      ],
+      [
+        23,
+        16483456
+      ],
+      [
+        529,
+        8193152
+      ],
+      [
+        552,
+        181828064
+      ]
+    ],
+    "counts": {
+      "B1": 90914032,
+      "B2": 90914032,
+      "L": 2234496,
+      "N": 4096576,
+      "W": 190021216,
+      "child_multiplicities": {
+        "1": 202715744,
+        "10": 20681232,
+        "11": 7318784,
+        "12": 21523216,
+        "13": 7015184,
+        "14": 21822768,
+        "15": 7112336,
+        "16": 19867584,
+        "17": 13317920,
+        "18": 25231184,
+        "19": 17661424,
+        "2": 124856512,
+        "20": 16418688,
+        "21": 1068672,
+        "22": 2283072,
+        "23": 16483456,
+        "3": 64654656,
+        "4": 48102384,
+        "5": 33485056,
+        "529": 8193152,
+        "552": 181828064,
+        "6": 25903152,
+        "7": 17633088,
+        "8": 27048736,
+        "9": 9160624
+      },
+      "copied_histogram": [
+        8930,
+        49066,
+        30844,
+        15972,
+        11883,
+        8272,
+        6399,
+        4356,
+        6682,
+        2263,
+        5109,
+        1808,
+        5317,
+        1733,
+        5391,
+        1757,
+        4908,
+        3290,
+        6233,
+        4363,
+        4056,
+        264,
+        564,
+        24,
+        0
+      ],
+      "deficit": 1862080,
+      "dimensions": [
+        24,
+        24
+      ],
+      "m": 576,
+      "maxchild": 552,
+      "total_rank": 109450358336
+    },
+    "enclosure": "1+u+u^2/(2(1-u/3))",
+    "exponent": "24998051/25000000",
+    "logarithm_upper_bounds": {
+      "1": "794513457587/125000000000",
+      "10": "2026761283851/500000000000",
+      "11": "1979106193949/500000000000",
+      "12": "967800252727/250000000000",
+      "13": "758231660647/200000000000",
+      "14": "3717050331081/1000000000000",
+      "15": "1824028729797/500000000000",
+      "16": "3583518938457/1000000000000",
+      "17": "22018089479/6250000000",
+      "18": "8664339757/2500000000",
+      "19": "341166868153/100000000000",
+      "2": "707870060017/125000000000",
+      "20": "1680187693571/500000000000",
+      "21": "3311585222973/1000000000000",
+      "22": "1632532603669/500000000000",
+      "23": "3220613444767/1000000000000",
+      "3": "1314373843007/250000000000",
+      "4": "4969813299577/1000000000000",
+      "5": "2373334874131/500000000000",
+      "529": "42559614419/500000000000",
+      "552": "42559614419/1000000000000",
+      "6": "1141087047867/250000000000",
+      "7": "4410197511641/1000000000000",
+      "8": "4276666119017/1000000000000",
+      "9": "25993019271/6250000000"
+    },
+    "moment_upper": "41230077320013845459152415842612504916449972317779967842837944583272706002177588093256498518568839623389146470329890309678443980458066680615361744505592038651174861744542401102403592424925296971746286402424010119299112624797225649619266545697664266076849080896788535940832502860162094344867655371553013651660399752909560467757989922417605273672796323363623700061058579975817444548637803205602124178954687673277011931480796079125892239408265588698477703420233284596413474059387592867592309701/41230077325513267360846956938521502341474073689326505257121676970478810391277326276471865083362032190646188250982499628351612283105589897175543987487125650452330304348151388045812369968133964037865011250349179368669257862504666828211703334554008512518414563221340357395437053315115874615168412042904680012697363239611038021437069048505672439008745508864584512067644825937731293242352557278635159598633861792145775836588122497044363982384099548431927704944786606529202786560000000000000000000",
+    "saving": "1949/25000000",
+    "strict_gap": "5499421901694541095908997425024101371546537414283732387206104389099738183215366564793192567257041780652609318673168302647523216560182242981533611801155442603608986943408777543208667066118724847925169249370145237707441178592436788856344246441565482324551821454604550454953780270300756671351666361036963486701477553679079126088067165335949185500960812006586245961913848693714754073033035419679174118868763905107326417918471742975833959733450001524553321932789312500612407132407690299/41230077325513267360846956938521502341474073689326505257121676970478810391277326276471865083362032190646188250982499628351612283105589897175543987487125650452330304348151388045812369968133964037865011250349179368669257862504666828211703334554008512518414563221340357395437053315115874615168412042904680012697363239611038021437069048505672439008745508864584512067644825937731293242352557278635159598633861792145775836588122497044363982384099548431927704944786606529202786560000000000000000000"
+  },
+  "finite_bridge": {
+    "bit_coarse": {
+      "W": 143617474,
+      "halving_degree": 16,
+      "m": 529,
+      "maxchild": 506,
+      "wire_bits": 28
+    },
+    "complex": {
+      "W": 190021216,
+      "halving_degree": 17,
+      "m": 576,
+      "maxchild": 552,
+      "s": 109450358336,
+      "scalar_group_upper": 1656684480,
+      "scalar_terms": [
+        {
+          "c": 45764,
+          "copied_center_extra_groups": 48,
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 408200,
+          "v": 2024
+        },
+        {
+          "c": 45764,
+          "copied_center_extra_groups": 48,
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 408200,
+          "v": 2024
+        }
+      ],
+      "wire_bits": 28
+    },
+    "ordinary_leaf_row_degree": 252,
+    "rows": {
+      "coefficient": 1176,
+      "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse",
+      "degree": 4000,
+      "degree_gap": "40024/25",
+      "suffix_slope": 16000
+    },
+    "semantic": {
+      "B": 403063477262941121553211537024,
+      "C0": 2994465792675104952757349965746759652008778122322142627817848832,
+      "C1": 1,
+      "E": 403063477262941121443761178688,
+      "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding",
+      "fixed_odd_divisor": 21,
+      "induction_gap": 18943983431358232713000942240128,
+      "literal_charge": 119639333593035096270287748,
+      "strict_literal_gap": 402943837929348086347490890940
+    }
+  },
+  "kappa": "194869/2500000000",
+  "proof_predecessor_commit": "11817ccacb564bb7f98789c20dc11d3fece207e3",
+  "scope": "Exact finite moments, stopped savings and assembly; the new complex producer is checked separately. Opposite-bank factorization, atom streaming, ordinary conversion, common exact grid and retained analytic/tape interfaces are written proof dependencies.",
+  "source_sha256": {
+    "certificates/copied-centers-bit-axes.json": "ed307cef595091b11ba8f8e6ff11302ad8db190227a2fbf34c232fd680206254",
+    "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf",
+    "certificates/stopped-product-bit-axis.json": "52f493a0019b7e4ce69a4c26bd3d35af5d3397461126abc4be44d1430ae8930d",
+    "certificates/stopped-product-complex-input.json": "5bcf00402bbfb768bd2fc0935f32ad329ee0780a3dfe5827bb010831d7909c4d",
+    "certificates/stopped-product-input.json": "8185c7bf8c307728f32484c5972af9a1b948ac5d0838e02f85c86cb438060417",
+    "notes/stopped-product-assembly.tex": "1c3c7147851f30f1ff97679cfcda157b1cbe2655b8766e34f1345f20c630eaec",
+    "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a",
+    "notes/stopped-product-factorization.tex": "70d5a4405e1be9c7b6cfb326bb4ffdf88e5585d1fb3d16c7bb5ad62ac421fae3",
+    "notes/stopped-product-interface.tex": "454a8f3924afc26e575b2a8cec6d0860397cb7f2dc431f3ba63fb8a7142cc96b",
+    "notes/stopped-product-note.tex": "486d14c599f4c2551c019f3358898f72e6ecafeb04ad590726ea69ed987fe025",
+    "scripts/copied_centers/physical.py": "837345d1f8753eab0e70f105b1d1bb0db965b993da037b1825ddef3672609d7d",
+    "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9",
+    "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782",
+    "scripts/stopped_product/README.md": "6c1805dda45b01ed0ef420c674ec2cd0048fb9d7a1b015ab6cd837067fe66176",
+    "scripts/stopped_product/__init__.py": "7b794c22bccc00bb6ae8ba4d3379f469570565bbcb1a86090699133b8cf1b7d3",
+    "scripts/stopped_product/complex.py": "407650d56dceb5cb09d74928658cebed1bb42f4d7e28ca9e3fd36eea075f1ad0",
+    "scripts/stopped_product_network.py": "a8baaa87dd7679db4f2dd1a18a720397ee6f443262ad04fa26cf51b39909b74c",
+    "scripts/stopped_product_producer.py": "2c5c71399136ebcfebb8e5277317d5f334eb8df5716ad287391d0996fcc1492c",
+    "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d"
+  },
+  "status": "Conditional stopped product-ring multiplication witness"
+}
diff --git a/docs/reproducibility.md b/docs/reproducibility.md
index e48f4190cd..7b966039e0 100644
--- a/docs/reproducibility.md
+++ b/docs/reproducibility.md
@@ -1,5 +1,10 @@
 # Reproducing the result
 
+For the new stopped product-ring extension, run `make stopped-product-verify`.
+Its [incremental reproduction guide](stopped-product.md) covers the h24
+rational-center producer, new moments, stopping parameters and assembly.
+The community checkpoint and historical targets below retain their own scope.
+
 The selected release is documented in the [joint-frame community review](research/community-round2-review.md)
 and [current status](research/current-status.md), with the
 [selected parameter certificate](../research/matrix-exponent-synthesis/candidate/arithmetic.json).
diff --git a/docs/stopped-product.md b/docs/stopped-product.md
new file mode 100644
index 0000000000..a53cfa9638
--- /dev/null
+++ b/docs/stopped-product.md
@@ -0,0 +1,46 @@
+# Stopped product-ring reproduction
+
+The extension gives the conditional saving `194869/2500000000 = 7.79476e-5`.
+It starts from merged PR #36 and is submitted on upstream main at
+`56b66d58297deca1d7dd130247d720e960f77a37`.
+
+From the repository root, with Python 3.11+, Make and a C++17 compiler:
+
+```sh
+make stopped-product-verify
+```
+
+The incremental checks:
+
+- Match the unchanged positive-label h23 bit producer to its verified
+  copied-center input, preserving the same matching and histogram.
+- Rebuild only the new h24 all-disjoint complex producer with aligned pair
+  stars, exact rational center decoding, support and binary-frame checks,
+  then reproduce every matching count and histogram entry.
+- Reconstruct both child lists and strict rational moments; derive the
+  stopped ordinary-bit saving and check that the atom-adapter toll is lower.
+- Check the denominator-21 semantic charge, product row stock `p^4000`,
+  seven assembly margins and all 47 strict constraints.
+
+Intermediate DAGs and the matcher executable are temporary. To retain them:
+
+```sh
+python3 scripts/stopped_product_producer.py --work-dir /tmp/stopped-product-producers
+```
+
+For arithmetic alone, use `make stopped-product-certificate`. The inherited
+`make verify-producers` also includes this target; the full `make verify`
+retains the community and historical checks. Those unchanged suites are
+not part of this round's local incremental validation.
+
+The [proof](../notes/stopped-product-note.tex) is supplied as LaTeX source;
+no PDF is generated. Its common-basis factorization, atom streaming and
+stopping argument, outer ordinary conversion and shared exact rational
+grid are written proofs. Finite checks verify the selected scalar data and
+arithmetic, not the complete all-size theorem.
+
+[SOURCES.json](../SOURCES.json) and [NOTICE](../NOTICE) preserve contribution
+credits and source pins. Existing two-stage, ordinary-leaf and semantic
+proof dependencies remain in `references/copied-centers/` and
+`references/semantic-bulk/`. Research alternatives, raw binary DAGs and
+recursive predecessor copies are excluded from this submission.
diff --git a/notes/stopped-product-assembly.tex b/notes/stopped-product-assembly.tex
new file mode 100644
index 0000000000..3932d3ade5
--- /dev/null
+++ b/notes/stopped-product-assembly.tex
@@ -0,0 +1,108 @@
+\subsection{Simultaneous row reserves}
+Use a conservative global width bound $e$ for every adapter and child.
+For each recursive family $j$, the least integer $t_j$ with
+$m_j^{t_j}>2r_j^{t_j}$ gives depth at most
+$t_j\lceil\log_2\max(2,e)\rceil$ plus a fixed constant.
+The new coarse bit family has $(t_j,\operatorname{bitlength}W_j)=(16,28)$,
+the ordinary leaf family $(9,28)$, and the complex family $(17,28)$.
+The required reserve is the product of all three stocks:
+\[
+ Q=W_c^{D_c}W_b^{D_b}W_{\rm old}^{D_{\rm old}}.
+\]
+After the complex and coarse divisions, the old stock remains available
+to every peeled-atom or stopped-leaf call. Sequential copies and outer
+ordinary wrappers reuse restored rows; they introduce no independent
+row factor. The combined coefficient is
+\[
+ 16\cdot28+9\cdot28+17\cdot28=1176,
+ \qquad4000-\frac{51}{25}\,1176=\frac{40024}{25}>0.
+\]
+Thus the retained logarithmic comparison, for eventual $e\le Cp$,
+supplies a sufficient $p^{4000}$ stock including the fixed constants.
+Use one physically preceding transformed prefix and one complete-row
+padding, as in \path{notes/structured-bulk-assembly.tex}. Complete
+spectators and parked fields are preserved by every descendant.
+The suffix condition
+$b_{\rm in}^{1-\epsilon}>16000(\log_2b_{\rm in}+8)$ is eventual
+for every fixed $\epsilon<1$.
+
+\subsection{Analytic transfer and selected parameters}
+The retained analytic proof map in
+\path{notes/structured-bulk-assembly.tex} supplies the active-masked
+arbitrary-source router with paid repair scans, the rounded phase-cell
+inverse, persistent bulk halos with original period cuts, sequential
+overlap tapes and factor pages, prime packing and exact recovery.
+The new ordinary bit primitive has precisely the arbitrary-width,
+complete-spectator and restored-row contract consumed by that router.
+The new complex primitive supplies the exact completed tensor contract
+on one common grid. Its outer grid conversions add only logarithmic
+work. The changed finite implementations therefore meet the same
+analytic interfaces, including the full bulk bound
+\[
+ O\!\left(Tp\left[p^\tau\operatorname{polylog}p+
+ d\operatorname{polylog}p+dp^\delta+w_G^2p^\delta+
+ dw_G^2p^\delta/L\right]\right)+n^{o(1)},
+\]
+where $L=2^{\lceil8\log_2p\rceil}$, Gaussian band width
+$w_G^2=O(p^{1-r})$, and normalization retains $\epsilon+r<1$.
+Here $w_G$ is unrelated to the address atom width.
+
+Use the proved ordinary bit saving $a_b=803380799/10^{13}$ and complex
+saving $b=1949/25000000$. To instantiate the retained assembly, weaken
+the bit parameter explicitly to
+\[
+ \beta=10^{-6},\qquad
+ a=(1-\beta)b-10^{-10}=\frac{1948995551}{25000000000000}<a_b.
+\]
+Thus the bit time bound also holds at $\tau=1-a$, and the complex
+leaf saving exceeds $a$ by exactly $10^{-10}$. Put $\sigma=1-b$ and
+\[
+\begin{gathered}
+ \eta=10^{-8},\quad q_0=a(1-2\eta),\quad c=q_0(1+\eta),\quad
+ \epsilon=\frac{1-\eta}{1+c+q_0},\\
+ \lambda'=1-q_0,\quad\lambda=(\tau+\lambda')/2,\quad
+ g=\epsilon q_0,\quad r=(g+1-\epsilon)/2,\quad\delta=\eta/8.
+\end{gathered}
+\]
+The notation $q_0$ denotes the assembly saving parameter, not the
+fixed address prime. Since $\sigma<\tau$, the internal paid-adapter
+exponent is $\tau$; the stopped complex leaf exponent is
+$\sigma+\beta(1-\sigma)$. Both are strictly below $\lambda'$.
+
+\begin{theorem}[Conditional fixed-tape multiplication bound]
+Under the retained analytic, exact-recovery and fixed-tape interfaces,
+the selected construction gives
+\[
+ T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad
+ \boxed{\kappa=\frac{194869}{2500000000}=0.0000779476}.
+\]
+\end{theorem}
+\begin{proof}
+The exact certificate checks 47 strictly positive conditions of the
+retained semantic/bulk assembly with the new finite constants. They
+include the primitive and leaf orderings, compact reservations and
+geometry, linear precision, row product, short-record fallback,
+normalization, phase-cell/band separation, prime supply and all
+artificial-boundary charges. The seven final savings are
+\[
+ 1-\epsilon(1+c),\quad a,\quad g,\quad a,\quad
+ \min(1-\epsilon-\delta,r-\delta),\quad
+ 1-\epsilon-\delta,\quad\epsilon.
+\]
+Their exact minimum is $g$, and the prefix margin is $g+\eta$.
+Exact rational subtraction gives
+\[
+ g-\kappa=
+ \frac{20668543364879972849164027819}
+      {312548724888044126663502511122500000000}
+ >6.6129027953\times10^{-11}>0.
+\]
+The strict gaps absorb fixed logarithms, including the common-grid
+conversions. The stopped atom recurrence supplies the ordinary
+interchange interface, the rational-center construction supplies the
+exact complex interface, and the product stock supports all nested
+recursions. The unchanged analytic transfer then proves the stated
+bound, with its constructive setup, descriptor and catalogue domination,
+prime-existence and exact-recovery thresholds retained as eventual
+conditions.
+\end{proof}
diff --git a/notes/stopped-product-complex.tex b/notes/stopped-product-complex.tex
new file mode 100644
index 0000000000..4a9037137c
--- /dev/null
+++ b/notes/stopped-product-complex.tex
@@ -0,0 +1,137 @@
+\subsection{All-disjoint retained centers}
+Use two factors $h=24$. For triple inputs write $G=\sum_TX_T$,
+$T_i=\sum_{T\ni i}X_T$, and retain all $A_i=G-T_i$.
+Each input triple avoids exactly 21 points, so
+\[
+ \sum_{i=1}^{24}A_i=21G,\qquad G=\frac1{21}\sum_i A_i.
+\]
+For a target triple $S$ the central correction is
+\[
+ G-\frac12\sum_{i\in S}A_i
+       =\frac{\sum_{i\in S}T_i-G}{2}.
+\]
+An input triple meeting $S$ in $j$ points has central coefficient
+$(j-1)/2$. Adding half the disjoint sum and subtracting half the
+intersection-two sum leaves coefficient one exactly when $j=3$.
+The scalar source-to-scatter transfer is therefore the identity.
+The transparent old-value subtraction and new-value addition use this
+identity only on fresh contributions and restore arbitrary old values.
+
+The base-two paired exclusion and aligned pair-star producer retains
+nested binary labels: common-pair supports have their orthonormal triple
+span, other ordinary sums have their coordinate cover. Each retained
+$A_i$ has the nondegenerate coordinate hyperplane excluding $i$,
+of dimension 23. Hence all copied-center arguments and general
+nondegenerate binary residuals of the preceding proof apply. The
+selected local counts are
+\[
+ v=2024,\quad c_h=45764,\quad q_h=8120,\quad
+ |\mathcal M|=8966,\quad R=44918,\quad\ell=552.
+\]
+The old internal histogram, starting at rank zero, is
+\begin{small}\begin{align*}
+[&8930,49042,30844,15972,11883,8272,6399,4356,6682,2263,\\
+ &5109,1808,5317,1733,5391,1757,4908,3290,6233,4363,\\
+ &4056,264,564,24,24].
+\end{align*}\end{small}
+It has rank mass $24R+2\ell$. Replace 24 rank-24 original transitions
+by 24 rank-one transitions; all rank-23 copied transforms remain.
+The new mass is $24R+\ell$.
+
+\subsection{Physical endpoints and strict complex moment}
+The copied-center two-stage complex contract in
+\path{notes/copied-centers-complex.tex} is unchanged by the scalar
+center decoding. For the tensor triple line $U$, let
+$T=C_U$, $F=C_I$, $E=C_{U^\perp}=FT^{-1}$.
+The two data outputs are $A=-Fy$ and $B=FT^{-2}x+Ey$.
+Add $T^{-1}$ applied to a copy of $A$ into $B$, paying one rank-one
+child per data pair. The inherited input/output $Z$ phases and
+$i^{9f}$ scalar normalize $FT^{-2}$ to $F$; sign and bank corrections
+complete the exact tensor $C$. Auxiliary source/sink operators remain
+$C_{D_0}$ and $FC_{D_0}$ in the second stage. Every original role
+therefore returns the exact selected-axis tensor operation on arbitrary
+inputs. This algebraic statement holds over $\mathbb Q(i)$ as well as
+over Gaussian dyadics.
+
+With $m_c=576$, $N_c=v^2=4096576$, $B_c=vR=90914032$, put
+\[
+ W_c=2N_c+2B_c=190021216,\quad L_c=2v\ell=2234496,
+\]
+\[
+ s_c=W_cm_c-N_c+L_c=109450358336,\qquad N_c-L_c=1862080.
+\]
+The complete list is $2B_c$ width-552 auxiliary exteriors,
+$2N_c$ width-529 data macros, $2vH'_r$ width-$r$ internal children,
+$4N_c$ width-23 data fronts, and $N_c$ width-one endpoint copies.
+These disjoint classes include both kinds of paid copies and sum to
+$s_c$. All binary residuals, including alternating forms, use the retained
+one-child Gauss normal form with paid bit adapters and unit phases.
+At $a_c=1949/25000000$ the exact rational enclosure gives
+\[
+ \sum_r\frac{n_r}{W_c}(r/m_c)^{1-a_c}
+ <1-1.3338373969\times10^{-10}.
+\]
+
+\subsection{One exact odd-denominator grid}
+The only new odd divisor is 21. Let $d$ bound the root axis count,
+$D$ bound its maximum complex recursion depth, and $G_0$ bound the
+number of grouped scalar operations per node. Choose
+\[
+ K=G_0(D+1),\qquad \text{common grid }2^{-P}21^{-K}.
+\]
+Root inputs and arbitrary dirty auxiliaries start Gaussian dyadic.
+Multiply their integer numerators by $21^K$ once at the outer boundary.
+Every local coefficient contains at most one factor 21 in its denominator,
+so a local finite program adds at most $G_0$ to the odd-denominator
+exponent. A completed $u$-axis child has Gaussian-dyadic coefficients
+and therefore preserves its input's existing odd-denominator exponent;
+it adds no new odd factor. Only the active chain of unfinished calls
+can accumulate new factors. Its length is at most $D+1$, proving that
+all intermediates lie on the common grid and every local division by
+21 is an exact integer division of its encoded numerator.
+
+This divisibility claim uses the root dyadic-input invariant, not an
+assumption about arbitrary numerators on the finest grid. Internal values
+may have odd denominators. They are neither rounded nor re-encoded when
+a child returns. At the completed outer return the operator is the exact
+Gaussian-dyadic tensor on root dyadic inputs, so the final numerators
+are divisible by $21^K$; exact unscaling restores dyadic encoding.
+
+Since the largest child is $552<576$, $D=O(\log d)$ and
+$K=O(\log d)$ with fixed constants. Constant-divisor long division
+is linear in numerator length. Initial and final scaling by $K$
+successive constant multiplications/divisions cost $O(V\log d)$ and
+occur only at the outer boundary. The extra numerator length is
+$O(\log d)$, preserving the retained $O(p)$ word bound. This overhead
+is subordinate to the positive-power complex layer bound.
+
+For explicit semantic constants use
+\[
+ g_h=4(c_h+v)+10v+4hv+4h^2+8h+8=408200,
+\]
+\[
+ G_0=N_c+2v(g_h+2h)=1656684480,
+\]
+where endpoint additions and copied-center scalar work are included.
+The complete child contributes at most $u$ binary denominator bits
+and row-norm factor $2^u$, with no additional odd exponent. A local
+21-division contributes fewer than five denominator-height bits,
+covered by the fixed scalar charge. Set
+\[
+\begin{aligned}
+ E_0&=64(W_c+m_c+G_0+1)^3=403063477262941121443761178688,\\
+ \mathcal E&=2G_0W_c^2+8s_c+4W_c+4+32m_c\\
+           &=119639333593035096270287748<E_0,\\
+ B_0&=s_c+E_0,\qquad C_0=32m_cB_0^2.
+\end{aligned}
+\]
+With $f=\lfloor e/m_c\rfloor$, the completed-child induction is
+\[
+ A(e)\le A(552f)+s_cf+E_0\le2B_0e,
+\]
+since $2B_0(m_c-552)\ge s_c+E_0$. It counts total denominator height
+and magnitude, including the local odd factor. The retained prefix and
+normalization allowance $18e$ fits inside $C_0e$. Together with the
+$O(\log d)$ common-grid encoding overhead this gives $C_1=1$ and
+$O(p)$ records for $d=\lfloor b_{\rm in}^{\epsilon}\rfloor$,
+$p=6b_{\rm in}$, fixed $\epsilon<1$.
diff --git a/notes/stopped-product-factorization.tex b/notes/stopped-product-factorization.tex
new file mode 100644
index 0000000000..94f7b81397
--- /dev/null
+++ b/notes/stopped-product-factorization.tex
@@ -0,0 +1,112 @@
+\subsection{Atom algebra and the global frame convention}
+Fix an odd prime $q$ and an atom width $w\ge1$ throughout one invocation.
+An atom is a consecutive $w$-digit radix-$q$ field. A field of $f$ atoms
+is the product ring $R_f=(\mathbb Z/q^w\mathbb Z)^f$, with rational
+unit coefficients acting componentwise. Let $C_f$ reverse the atoms,
+preserving their internal digits. The target is
+\[
+ F_n(H,D)=(C_nD,C_nH).
+\]
+It acts on two contiguous chunks with arbitrary complete spectators.
+The product-ring interpretation preserves the original complete address
+set and its lexicographic order. No standalone reversal is assumed free.
+
+At a node with $n=mf$ atoms, conjugate every frame, source gauge and
+endpoint of the finite network by the same $\operatorname{diag}(I,C_n)$.
+For a projector $P$ the new partial swap is
+\[
+ D'_P=\begin{pmatrix}
+ (I-P)\otimes I_f&(PC_m)\otimes C_f\\
+ (C_mP)\otimes C_f&C_m(I-P)C_m\otimes I_f
+ \end{pmatrix}.
+\]
+Global conjugation preserves common-frame scalar identities, nested
+residuals, copied-center schedules and arbitrary auxiliary restoration.
+The full endpoint is now $F_n$. These frame choices define the logical
+interpretation of physical inputs; they are not preprocessing passes.
+
+\subsection{Simultaneous generic basis and full involution factorization}
+For every proper nonzero residual projector $P_j$ of rank $r_j$, require
+all leading principal minors of sizes $1,\ldots,r_j$ to be nonzero in
+one common rational basis. For each individual minor, similarity to
+$\operatorname{diag}(I_{r_j},0)$ witnesses nonvanishing. Clearing
+denominators and taking the finite product on irreducible
+$\operatorname{GL}_m$ proves a common rational choice exists; exact
+rational enumeration terminates. Include exteriors, data residuals,
+internal edges, copied centers and endpoint corrections in this finite
+list. The basis is fixed label preparation, not an executed dense map.
+
+For $M=PC_m$, every northeast $i$-by-$j$ rectangle has rank
+$\min(i,j,r)$: after reversing its columns it is the leading rectangle
+of $P$ and contains the corresponding nonsingular leading square.
+Hence physical lower-triangular matrices $L,R$ give
+\[
+ LMR=\Pi=EF^t,\quad E=(e_1,\ldots,e_r),\quad
+ F=(e_m,e_{m-1},\ldots,e_{m-r+1}).
+\]
+The full involution, not just this corner, must be normalized.
+At $f=1$, put $Q=\operatorname{diag}(L,R^{-1})$ and
+$g=QD'_PQ^{-1}$. Since $\operatorname{rank}(g-I)=r$ and its upper-right
+block is $EF^t$, there are $A\in\mathbb Q^{r\times m}$ and
+$B\in\mathbb Q^{m\times r}$ with
+\[
+ g-I=\binom EB(A,F^t),\qquad AE+F^tB=-2I_r.
+\]
+The second identity follows from $g^2=I$ and the full column and row
+ranks of the factorization. Define
+\[
+ K=-(B+F)E^t+FA(I-EE^t),\qquad
+ S=\begin{pmatrix}I&0\\K&I\end{pmatrix}.
+\]
+Then $KE=-B-F$, $F^tK=A+E^t$, and direct multiplication yields
+\[
+ SgS^{-1}=I+\binom E{-F}(-E^t,F^t)
+ =\begin{pmatrix}I-EE^t&EF^t\\FE^t&I-FF^t\end{pmatrix}.
+\]
+This swaps precisely the first $r$ head coordinates and last $r$ tail
+coordinates in opposite orders, fixing all others.
+
+For $f$ atoms use $Q_f=\operatorname{diag}(L\otimes I_f,R^{-1}\otimes I_f)$
+and $S_f=\left(\begin{smallmatrix}I&0\\K\otimes C_f&I\end{smallmatrix}\right)$.
+The rank factorization lifts with $\bar E=E\otimes I_f$,
+$\bar F=F\otimes C_f$, $\bar A=A\otimes I_f$ and
+$\bar B=B\otimes C_f$. Its middle cross block is $\Pi\otimes C_f$.
+Since $C_r\otimes C_f=C_{rf}$ on the selected physical intervals,
+it is exactly one child $F_{rf}$ of the same family. There is no
+recursive orientation conversion or extra gathering.
+
+Choose $q$ after the finite basis and factorizations, excluding all
+needed nonzero numerators, denominators and pivots. The identities hold
+on every atom ring. They use only componentwise scalar arithmetic;
+reversal commutes with those scalars, without inter-atom carries.
+
+\subsection{Selected finite network}
+Use the retained compatible positive-label producer on both axes $h=23$:
+\[
+ v=1771,\quad c=34764,\quad q_h=5336,\quad
+ |\mathcal M|=1324,\quad R=38776,\quad\ell=506.
+\]
+The copied-center lemma changes $H_{23}$ by $-23$ and $H_1$ by $+23$.
+Thus $\sum_r rH'_r=23R+506$; the rank-22 copies are still paid.
+The new common basis preserves the producer's scalar map, label
+inclusions, matching and endpoint identities. With
+\[
+ m_b=529,\quad N_b=3136441,\quad B_b=68672296,\quad
+ W_b=143617474,\quad L_b=1792252,
+\]
+the complete list is $2B_b$ width-506 auxiliary exteriors,
+$2N_b$ width-484 data residuals, $4N_b$ width-22 data fronts,
+$2vH'_r$ width-$r$ local residuals, and $N_b$ width-one endpoint copies.
+Every call has volume fraction $1/W_b$, and
+\[
+ s_b=W_bm_b-N_b+L_b=75972299557,\qquad W_bm_b-s_b=1344189.
+\]
+Every width is at most $506<m_b$. For $a_*=4019/50000000$,
+$\tau_*=1-a_*$, the exact rational moment certificate gives
+\[
+ \mu_{\tau_*}:=\sum_r\frac{n_r}{W_b}(r/m_b)^{\tau_*}<1,
+ \qquad 1-\mu_{\tau_*}>4.2909639537\times10^{-10}.
+\]
+It uses the retained 24-term positive atanh-series logarithm enclosure,
+its geometric tail, range reduction and upward rational exponential
+bound. Also $\mu_1=s_b/(W_bm_b)<1$. These are the two gaps used below.
diff --git a/notes/stopped-product-interface.tex b/notes/stopped-product-interface.tex
new file mode 100644
index 0000000000..20c44ce486
--- /dev/null
+++ b/notes/stopped-product-interface.tex
@@ -0,0 +1,95 @@
+\subsection{Paid atom adapters and remainders}
+Expand each fixed lower-triangular formal factor into unit scalings and
+additions from earlier to later formal fields. Execute intrabank targets
+in descending formal-field order, so earlier controls still have their
+required original values. Every atom update reads only physically earlier
+controls. In a cross-bank shear the update is
+\[
+ D_{i,t}\leftarrow D_{i,t}+k_{ij}H_{j,f-1-t}.
+\]
+Even with the reversed source index, the source lies in the earlier head
+bank. The retained ordered-affine streaming primitive applies to each
+ordinary width-$w$ atom update, costing $O(V)$ per pass.
+There are $O(f)$ passes per fixed matrix and thus $O(Vn)$ per finite
+node. The reversed control is an indexed earlier atom, not a reversed
+field operation. Atom loops use binary descriptors on a fixed tape set;
+all inactive digits remain complete spectators. The inherited parking
+schedule never scans through parked ancestors, and polynomial descriptor
+work is absorbed by the complete stream volume.
+
+For $n=m_bf+\delta$, $0\le\delta<m_b$, pair the first $\delta$
+head atoms with the last $\delta$ tail atoms in reverse order. Each pair
+uses the retained ordinary width-$w$ interchange. The remaining two
+contiguous $m_bf$-atom intervals receive the finite construction.
+When $n<m_b$, at most $m_b$ such ordinary calls complete $F_n$.
+Both cases cost $O(Vw^{1-a_{\rm old}})$ in addition to the node adapters,
+where $a_{\rm old}=384599/10^{10}$. A radix-$q$ atom can be padded to
+the next binary power and treated by that ordinary interface, with
+volume factor below four and binary width $O(w)$, so the old leaf
+algorithm need not use the same address prime.
+
+\subsection{Stopped recurrence}
+Let $T(n,w)$ denote time normalized by logical volume. The complete
+recursive list, including copied streams, yields
+\[
+\begin{aligned}
+ T(n,w)&\le\sum_r\frac{n_r}{W_b}
+       T(r\lfloor n/m_b\rfloor,w)+C n+Cw^{1-a_{\rm old}}
+                         &&(n\ge m_b),\\
+ T(n,w)&\le Cw^{1-a_{\rm old}}&&(1\le n<m_b).
+\end{aligned}
+\]
+The constant includes finite scalar gates, split/merge, parking, all
+adapter passes and remainders at every node. Choose constants $A,B$
+using the positive gaps $1-\mu_1$ and $1-\mu_{\tau_*}$.
+Strong induction, with child widths at most $(r/m_b)n$, gives
+\[
+ T(n,w)\le An+Bn^{\tau_*}w^{1-a_{\rm old}}.
+\]
+Indeed the linear child terms use at most $\mu_1 An$, leaving the
+linear toll, and the other child terms use at most
+$\mu_{\tau_*}Bn^{\tau_*}w^{1-a_{\rm old}}$, leaving the peeled-atom
+toll since $n^{\tau_*}\ge1$. Enlarge $B$ for the bounded base cases.
+All constants are independent of both $n$ and $w$.
+
+\subsection{Outer ordinary wrapper and arbitrary widths}
+Write $C=C_n$. The map $F_n(H,D)=(CD,CH)$ obeys
+$F_nLF_n(H,D)=(H+D,D)$ for $L(H,D)=(H,D+H)$.
+Accordingly the chronological sequence
+\[
+ D\leftarrow D-H;\quad F_n;\quad D\leftarrow D+H;\quad
+ F_n;\quad D\leftarrow H-D
+\]
+is exactly $(H,D)\mapsto(D,H)$. The three lower updates cost $O(Vn)$
+in the atom model. Both calls reuse their restored row reserve.
+This is a constant outside the entire recursion, so it does not multiply
+any recursive child count or characteristic.
+
+For a radix-$q$ width $e$ choose $\theta=1/1000$,
+$w=\lceil e^\theta\rceil$ and $n=\lfloor e/w\rfloor$.
+Apply the ordinary wrapper to the atom body and the old ordinary
+algorithm to the fewer than $w$ residual digits. For large $e$ the cost is
+\[
+ O\!\left(V\left[e^{1-\theta}+
+ e^{(1-\theta)(1-a_*)+\theta(1-a_{\rm old})}\right]\right).
+\]
+The remainder is bounded by the second term. Thus the ordinary saving is
+\[
+ a_b=(1-\theta)a_*+\theta a_{\rm old}
+     =\frac{803380799}{10^{13}}=0.0000803380799.
+\]
+Since $\theta>a_b$, the paid adapter term is strictly lower order.
+All bounded widths use the old interface. Numerical padding of a binary
+chunk range to the least suitable radix-$q$ range has volume factor
+below $q^2$; it preserves numerical order and is removed after the
+completed ordinary wrapper, whose endpoint is ordinary interchange.
+
+If external rows are unavailable, use the inherited ordinary high-digit
+borrowing construction from \path{notes/batched-bit-rows.tex}.
+Borrow $O(\log e)$ high digits, exchange and join them into a preceding
+row field, pad that field once, act on the body, and separate the high
+parts. It applies literally to the completed ordinary wrapper; no claim
+about borrowed high positions is made for an unwrapped reversed call.
+Single-digit moves cost $O(V\log e)$, and small widths use the old
+algorithm. Atom indices and rational coefficients are finitely specified;
+the algorithm uses the same fixed tape set and complete spectator ranges.
diff --git a/notes/stopped-product-note.tex b/notes/stopped-product-note.tex
new file mode 100644
index 0000000000..a8b23254c8
--- /dev/null
+++ b/notes/stopped-product-note.tex
@@ -0,0 +1,76 @@
+\documentclass[11pt]{article}
+\usepackage[margin=1in]{geometry}
+\usepackage[T1]{fontenc}
+\usepackage{lmodern,amsmath,amssymb,amsthm,mathtools,booktabs,longtable,microtype}
+\usepackage[hidelinks]{hyperref}
+\setlength{\emergencystretch}{3em}
+\allowdisplaybreaks
+\newtheorem{theorem}{Theorem}[section]
+\newtheorem{lemma}[theorem]{Lemma}
+\newtheorem{proposition}[theorem]{Proposition}
+\title{A conditional integer-multiplication saving of $194869/2500000000$\\
+\large Stopped product-ring interchange and rational retained centers}
+\author{icekylinx\\\small With substantial OpenAI GPT-6 Astra and Codex assistance}
+\date{9 October 2026}
+\begin{document}\maketitle
+\begin{abstract}
+A common rational basis and opposite bank orders reduce each projector
+residual to one contiguous reversed child over a fixed atom product ring.
+Ordered atom adapters are paid explicitly; stopping at a growing atom
+width and using the retained ordinary primitive supplies an ordinary
+bit interface. An independent 24-dimensional complex producer uses
+rational retained-center decoding on one exact common grid. The selected
+interfaces and retained semantic/bulk assembly give the conditional bound
+$T(n)=O(n(\log n)^{1-\kappa})$, where
+$\kappa=194869/2500000000=0.0000779476$.
+\end{abstract}
+
+\section{Scope and retained dependencies}
+The model is the retained fixed finite-alphabet multitape Turing machine.
+Finite graphs, rational bases, address primes, coefficient tables and tape
+counts are fixed independently of input length. Bit payload arithmetic is
+binary, while its address geometry is rational and then evaluated on atom
+rings. Complex payloads use exact Gaussian rational arithmetic with the
+specified common grid; their address labels remain binary.
+
+The proof predecessor is icekylinx's merged copied-center PR36,
+\texttt{11817ccacb564bb7f98789c20dc11d3fece207e3}, whose proof is
+\path{notes/copied-centers-note.tex}. Its ordinary interchange saving
+$a_{\rm old}=384599/10^{10}$, copied-center schedule in both orientations,
+two-stage data and auxiliary endpoint identities, general binary residual
+normal form, and fixed-tape complete-row contracts are retained.
+The present opposite-bank factorization, stopped product-ring interface,
+rational-center specialization and exact composition are by icekylinx,
+with substantial OpenAI GPT-6 Astra assistance and Codex integration.
+Earlier own contributions include PR10 batching, PR18 partial swaps,
+PR24 endpoint gauges and PR32 structured blocks and semantic composition.
+
+Aurel Prosz (Paureel) supplies the two-stage topology and paid endpoint
+copy, with Swapnil Jain's linked development credited by Zhihao Chen's
+PR29. The retained leaf proof also credits Rohan Arun's PR31 corner method
+and Dominik Scholz's PR33 parameterization. Zhihao Chen's PR21/23 and the
+RaD/hipotures PR20 source provide the phase endpoints, semantic guard,
+arbitrary-source routing, phase-cell inverse and bulk locality/tape
+interfaces. Their pinned proof map remains in
+\path{notes/structured-bulk-assembly.tex}; adopted sources and notices are
+in \path{references/semantic-bulk/} and \path{references/copied-centers/}.
+The underlying Douglas Colkitt framework, OpenAI manuscript, eumemic,
+Bortlesboat, dleen, earlier finite contributions and Harvey--van der Hoeven
+analytic work retain their credits and recorded AI assistance in
+\texttt{NOTICE} and \texttt{SOURCES.json}.
+
+The conclusion remains conditional on those analytic, ordered-affine,
+exact-recovery and machine interfaces and their eventual setup and
+prime-existence thresholds. The new algebraic and tape constructions
+below establish the changed finite interfaces; exact arithmetic certifies
+their selected counts and margins.
+
+\section{One reversed child for each projector}
+\input{notes/stopped-product-factorization.tex}
+\section{Stopped atom recursion and ordinary interchange}
+\input{notes/stopped-product-interface.tex}
+\section{Rational centers and exact semantic precision}
+\input{notes/stopped-product-complex.tex}
+\section{Product rows and exact assembly}
+\input{notes/stopped-product-assembly.tex}
+\end{document}
diff --git a/research/birth-read-reuse/BASE_INPUTS.json b/research/birth-read-reuse/BASE_INPUTS.json
new file mode 100644
index 0000000000..36c46849a3
--- /dev/null
+++ b/research/birth-read-reuse/BASE_INPUTS.json
@@ -0,0 +1,9 @@
+{
+  "head": "6ec868e8568ca9a74b7245494de1b187c7be78fe",
+  "files": {
+    "research/deferred-replayed-117/complex-dag.json.gz": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b",
+    "research/deferred-replayed-117/complex-profile.json": "ff5e9bbc1a3794d8dd3f75e194ea002cef8439c40a5d434c4a84e46967edc98e",
+    "research/deferred-replayed-117/certificate.json": "f1d77d26036cf2b01bc630a572b2cdea0027e0faa2e4899b5b907b9d455ff916",
+    "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf"
+  }
+}
diff --git a/research/birth-read-reuse/BIRTH_AUDIT.json b/research/birth-read-reuse/BIRTH_AUDIT.json
new file mode 100644
index 0000000000..95bb9fb93b
--- /dev/null
+++ b/research/birth-read-reuse/BIRTH_AUDIT.json
@@ -0,0 +1,24 @@
+{
+  "status": "PASS original complete forward/reflected paid frame scan",
+  "source_head": "6ec868e8568ca9a74b7245494de1b187c7be78fe",
+  "matches": 2106,
+  "physical_original_roles": 26599,
+  "virtual_roles": 28705,
+  "word_blocks": 277775,
+  "workspace_forward_gates": 120475,
+  "all_data_source_target_banks_disjoint": true,
+  "targets_never_controls": true,
+  "donors_dead_before_birth": true,
+  "recipients_untouched_before_birth": true,
+  "all_selected_recipients_have_no_source_injection": true,
+  "inverse_order": "Reverse actual workspace and source events chronologically at full frame",
+  "forward_frame_transitions": 235337,
+  "reverse_frame_transitions": 235337,
+  "copies_per_direction": 24,
+  "all_histogram_bins_match": true,
+  "forward_word_sha256": "5a5b636125766e2298b790257a8849a45ce5c7311d0f75edeb043fbed15f434f",
+  "reverse_word_sha256": "f674eed9455e89316cdf1e35ff811627beb621398a88ad76ea427e251aad1132",
+  "scalar_scope": "All-size arbitrary dirty algebra is the birth-cut identity with exact old-readout responses; complete source supports checked, no dense dirty-square expansion",
+  "seconds": 7.160254608999821,
+  "rss_KiB": 381252
+}
diff --git a/research/birth-read-reuse/BIRTH_MATCHES.json.gz b/research/birth-read-reuse/BIRTH_MATCHES.json.gz
new file mode 100644
index 0000000000..4dc46617e4
Binary files /dev/null and b/research/birth-read-reuse/BIRTH_MATCHES.json.gz differ
diff --git a/research/birth-read-reuse/CANDIDATE.json b/research/birth-read-reuse/CANDIDATE.json
new file mode 100644
index 0000000000..baaf87cd36
--- /dev/null
+++ b/research/birth-read-reuse/CANDIDATE.json
@@ -0,0 +1,176 @@
+{
+  "status": "AUTHOR_CHECKED_CONDITIONAL_ASSEMBLY; independent review pending",
+  "source_head": "6ec868e8568ca9a74b7245494de1b187c7be78fe",
+  "profile_source_head": "ec862a5af51537495c745d9f2323e8a5736ee265",
+  "pins": {
+    "new/BIRTH_MATCHES.json.gz": "0d5b0d183d7fae082572e5d1459962c9bcff007e0b4691dec4ff1aecf817408c",
+    "new/READOUT_COST.json": "f728c380abcc2540e667e3c04829f59e0c7bb49abcaf8eb027eb8b823bfacd3d",
+    "base/research/deferred-replayed-117/certificate.json": "f1d77d26036cf2b01bc630a572b2cdea0027e0faa2e4899b5b907b9d455ff916",
+    "base/certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf"
+  },
+  "kappa": "5519166047173/50000000000000000",
+  "complex_saving": "11040781/100000000000",
+  "actual_bit_saving": "1240189553/10000000000000",
+  "supported_bit_parameter": "11040769859219/100000000000000000",
+  "moments": [
+    {
+      "label": "coarse_bit",
+      "m": 529,
+      "W": 108516254,
+      "saving": "620523/5000000000",
+      "rank": 57403754177,
+      "lower": "784637716922602063515542551544255819453717996929624743891/784637716923335095479473677900958302012794430558004314112",
+      "upper": "6277101735380816508124340412354046570438871708765866670471/6277101735386680763835789423207666416102355444464034512896",
+      "strict_gap": "5864255711449010853619845663483735698167842425/6277101735386680763835789423207666416102355444464034512896",
+      "enclosure_grid_bits": 192,
+      "log_terms": 40,
+      "exponential_degree": 8
+    },
+    {
+      "label": "old_ordinary",
+      "m": 575,
+      "W": 188181929,
+      "saving": "384599/10000000000",
+      "rank": 108202762275,
+      "lower": "3138550867686721189167984360005808400490072591471054502465/3138550867693340381917894711603833208051177722232017256448",
+      "upper": "1569275433843360594583992180002904200245357738750846857189/1569275433846670190958947355801916604025588861116008628224",
+      "strict_gap": "3309596374955175799012403780231122365161771035/1569275433846670190958947355801916604025588861116008628224",
+      "enclosure_grid_bits": 192,
+      "log_terms": 40,
+      "exponential_degree": 8
+    },
+    {
+      "label": "birth_reused_complex",
+      "m": 576,
+      "W": 115865904,
+      "saving": "11040781/100000000000",
+      "rank": 66736898624,
+      "lower": "6277101735382321508129685478727696076870887623968283610229/6277101735386680763835789423207666416102355444464034512896",
+      "upper": "1569275433845580377032421369681924021027032349608600110115/1569275433846670190958947355801916604025588861116008628224",
+      "strict_gap": "1089813926525986119992582998556511507408518109/1569275433846670190958947355801916604025588861116008628224",
+      "enclosure_grid_bits": 192,
+      "log_terms": 40,
+      "exponential_degree": 8
+    }
+  ],
+  "finite_bridge": {
+    "m": 576,
+    "W": 115865904,
+    "rank": 66736898624,
+    "R": 26599,
+    "maxchild": 574,
+    "G": 3113921927424,
+    "E": 1932642881240371272040452135872748328000,
+    "literal_charge": 83608228981988458892886294212,
+    "B": 1932642881240371272040452135939485226624,
+    "C0": 68845519990132232905167052999896129702712483320195776417730326486472166903677714432,
+    "C1": 1,
+    "stock": [
+      {
+        "m": 529,
+        "W": 108516254,
+        "maxchild": 528,
+        "depth": 367,
+        "wire_bits": 27
+      },
+      {
+        "m": 575,
+        "W": 188181929,
+        "maxchild": 529,
+        "depth": 9,
+        "wire_bits": 28
+      },
+      {
+        "m": 576,
+        "W": 115865904,
+        "maxchild": 574,
+        "depth": 200,
+        "wire_bits": 27
+      }
+    ],
+    "rows": 15561,
+    "row_degree": 32000,
+    "row_gap": "6389/25",
+    "suffix_slope": 128000,
+    "odd_grid": "2^-P21^-K; K=G*(D_complex+1), with completed child preserving incoming odd exponent"
+  },
+  "assembly": {
+    "parameters": {
+      "a": "11040769859219/100000000000000000",
+      "b": "11040781/100000000000",
+      "beta": "1/1000000",
+      "eta": "1/100000000",
+      "q": "552038481920180140781/5000000000000000000000000",
+      "c": "55203848744056495998280140781/500000000000000000000000000000000",
+      "epsilon": "499999995000000000000000000000000/500110407696936074510076380140781",
+      "lambda_": "9998895923025118869859219/10000000000000000000000000",
+      "lambda_prime": "4999447961518079819859219/5000000000000000000000000",
+      "r": "82808272288027021117150000000/500110407696936074510076380140781",
+      "delta": "1/800000000",
+      "C0": 68845519990132232905167052999896129702712483320195776417730326486472166903677714432,
+      "C1": 1
+    },
+    "constraints": {
+      "bit_positive": "11040769859219/100000000000000000",
+      "complex_above_bit": "11140781/100000000000000000",
+      "complex_below_one_over32": "3113959219/100000000000",
+      "beta_positive": "1/1000000",
+      "beta_below_one": "999999/1000000",
+      "leaf_saving_above_bit": "1/1000000000000",
+      "q_positive": "552038481920180140781/5000000000000000000000000",
+      "q_below_internal": "11040769859219/5000000000000000000000000",
+      "q_below_leaf": "16040769859219/5000000000000000000000000",
+      "c_positive": "55203848744056495998280140781/500000000000000000000000000000000",
+      "c_below_one": "499944796151255943504001719859219/500000000000000000000000000000000",
+      "q_below_reservations": "552038481920180140781/500000000000000000000000000000000",
+      "lambda_above_tau": "11040769859219/10000000000000000000000000",
+      "lambda_above_sigma": "1125118869859219/10000000000000000000000000",
+      "lambda_above_internal": "11040769859219/10000000000000000000000000",
+      "lambda_prime_above_lambda": "11040769859219/10000000000000000000000000",
+      "compact_leaf": "16040769859219/5000000000000000000000000",
+      "compact_reservations": "552038481920180140781/500000000000000000000000000000000",
+      "lambda_prime_below_one": "552038481920180140781/5000000000000000000000000",
+      "epsilon_positive": "499999995000000000000000000000000/500110407696936074510076380140781",
+      "epsilon_below_one": "110412696936074510076380140781/500110407696936074510076380140781",
+      "guard_width": "110412696936074510076380140781/500110407696936074510076380140781",
+      "K_geometry": "5520884874405650151866495998280140781/50011040769693607451007638014078100000000",
+      "K_dominates_log": "5520384819201800855771518079819859219/50011040769693607451007638014078100000000",
+      "record_suffix": "110412696936074510076380140781/500110407696936074510076380140781",
+      "phase_local": "88329657438451911125029602548419859219/400088326157548859608061104112624800000000",
+      "phase_boundary": "66246117720013919957645489923619859219/400088326157548859608061104112624800000000",
+      "gamma_sublinear": "27604424648047488959230140781/500110407696936074510076380140781",
+      "cell_above_band": "499972390575351952511040769859219/1000220815393872149020152760281562",
+      "prime_interval_packing": "110412696936074510076380140781/500110407696936074510076380140781",
+      "alpha_positive": "82808272288027021117150000000/500110407696936074510076380140781",
+      "alpha_below_one": "500027599424648047488959230140781/500110407696936074510076380140781",
+      "alpha_below_one_fourth": "499779174607783966425607780140781/2000441630787744298040305520563124",
+      "delta_positive": "1/800000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "short_record_fallback": "49994477896084417942402613741510036132231229289961/50011040769693607451007638014078100000000000000000",
+      "small_field_exposure": "55208849296094977918460281562/500110407696936074510076380140781",
+      "artificial_boundary": "2800728696299998907158720142503546819859219/400088326157548859608061104112624800000000",
+      "literal_scalar_guard": "1932642881156763043058463676979862033788",
+      "row_product_gap": "6389/25",
+      "original_prefix_above_kappa": "250055204048927036202341600163601472937887/25005520384846803725503819007039050000000000000000",
+      "coordinate_movement_above_kappa": "2437764873/100000000000000000",
+      "compact_phase_layer_above_kappa": "200458998947303410093210972937887/25005520384846803725503819007039050000000000000000",
+      "bulk_exposure_above_kappa": "2437764873/100000000000000000",
+      "Gaussian_arithmetic_above_kappa": "1380189975502093848455797462686334412160437887/25005520384846803725503819007039050000000000000000",
+      "scalar_work_above_kappa": "2760411207904468296417304501736334412160437887/25005520384846803725503819007039050000000000000000",
+      "dimension_above_kappa": "24997239557618001223851102954342460093210972937887/25005520384846803725503819007039050000000000000000"
+    },
+    "margins": {
+      "original_prefix": "5520884874405650151866495998280140781/50011040769693607451007638014078100000000",
+      "coordinate_movement": "11040769859219/100000000000000000",
+      "compact_phase_layer": "55203847639979532157919859219/500110407696936074510076380140781",
+      "bulk_exposure": "11040769859219/100000000000000000",
+      "Gaussian_arithmetic": "66246117720013919957645489923619859219/400088326157548859608061104112624800000000",
+      "scalar_work": "88329657438451911125029602548419859219/400088326157548859608061104112624800000000",
+      "dimension": "499999995000000000000000000000000/500110407696936074510076380140781"
+    },
+    "minimum_margin": "55203847639979532157919859219/500110407696936074510076380140781",
+    "absorption_gap": "200458998947303410093210972937887/25005520384846803725503819007039050000000000000000"
+  },
+  "next_grid": "11038332094347/100000000000000000",
+  "next_grid_gap": "-99192409802329254323654434265007/50011040769693607451007638014078100000000000000000"
+}
diff --git a/research/birth-read-reuse/FRAMES_CHECK.json b/research/birth-read-reuse/FRAMES_CHECK.json
new file mode 100644
index 0000000000..ab600a1f10
--- /dev/null
+++ b/research/birth-read-reuse/FRAMES_CHECK.json
@@ -0,0 +1,11 @@
+{
+  "status": "PASS original114 full frame/profile reconstruction",
+  "roles": 28705,
+  "deferred": 3020,
+  "maxchild": 574,
+  "weighted_rank": 71647349312,
+  "all_bins_match": true,
+  "frame_sha256": "56e542713d156a93273d0fa69bc0106738356530fe36920691f5cc3c5c2a5f46",
+  "seconds": 16.050913337996462,
+  "rss_KiB": 389268
+}
diff --git a/research/birth-read-reuse/GRAPH_CHECK.json b/research/birth-read-reuse/GRAPH_CHECK.json
new file mode 100644
index 0000000000..945c856fa5
--- /dev/null
+++ b/research/birth-read-reuse/GRAPH_CHECK.json
@@ -0,0 +1,10 @@
+{
+  "status": "PASS original full-source/frame reconstruction of pinned117 DAG for118",
+  "source_sha256": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b",
+  "graph_sha256": "35443d283a9f307dab6dc42c0c46804fd63f18be2449ac3da5fbba4710b481a2",
+  "additions": 91770,
+  "roots": 8120,
+  "root_order": "pair stars ascending i",
+  "seconds": 0.30043780099367723,
+  "rss_KiB": 84952
+}
diff --git a/research/birth-read-reuse/PROOF.md b/research/birth-read-reuse/PROOF.md
new file mode 100644
index 0000000000..870ac02975
--- /dev/null
+++ b/research/birth-read-reuse/PROOF.md
@@ -0,0 +1,45 @@
+# Dirty readouts permit physical slot reuse
+
+Base: rohanarun/integer-mult-bounds at6ec868e8568ca9a74b7245494de1b187c7be78fe (corrected PR118). The operand/root DAG and virtual role/frame profile are unchanged fromec862a5af51537495c745d9f2323e8a5736ee265. Under its retained analytic, exact-recovery, prime, whole-residual, complete-row and fixed-tape hypotheses, this construction gives
+
+    T(n)=O(n(log n)^(1−kappa)),
+    kappa=5519166047173/50000000000000000=0.00011038332094346.
+
+This is an author-checked conditional draft; independent review remains pending. No upstream program is executed by the supplied checks.
+
+## The new operation
+
+In a linear virtual program, regard the initial value of each newly born register as an independent symbol g_a. Let D_a be its exact future contribution to output accumulators, cutting propagation at each subsequent birth on that storage. Then the output is Fx+sum(D_a g_a). A physical birth may leave any old value in its slot: read that value and add −D_a g_a to the output. The corrections cancel identically even if birth values contain source signals or are correlated with earlier dirt. Reverse every actual workspace/source gate chronologically to restore all original workspace.
+
+Sources, workspace and output banks must be disjoint. Outputs are never later controls, sources, guards or addresses. Every correction is paid and must occur at a legal common frame. There is no physical dirty reset and no assumption that a fresh-signal relation is equality of dirty contents.
+
+PR118 already reads each untouched deferred register B negatively at sigma_B after center phase one. Choose an old role A whose last forward gate and every terminal read are already finished, with final frame E contained in sigma_B. Raise A to sigma_B; use its actual value in B's existing negative readout; route B's future virtual life through A. The virtual program and D_B are unchanged. The new offset is canceled by the same readout. Selected pairs are disjoint, and all selected recipients have no source injection. The implementation nevertheless uses true reverse chronology for every inverse source gate.
+
+Per matched local role, put e=dim E and s=dim sigma_B. Remove children24−e and552+s; add child s−e (record zero rank explicitly); remove one original physical role. Weighted rank drops by576. All target read frames, copied centers and response coefficients remain unchanged. Added positive residuals are checked nonalternating. For0<p<1,
+
+    576^p+(s−e)^p < (24−e)^p+(552+s)^p,
+
+by strict concavity and majorization, so each legal reuse increases the unnormalized feasibility slack W*576^p−sum(n_t*t^p). The normalized moment decreases at previously feasible exponents (moment at most one); no monotonicity claim is made for arbitrary infeasible exponents.
+
+## Actual witness and costs
+
+The original reconstruction checks every source support in the91,770-addition DAG, its ascending pair-star root order,71,185 legal carrier links,28,705 virtual roles and3,020 deferred frames, reproducing every base histogram bin. A deterministic containment matching finds2,106 legal reuses. The literal forward word and reversed/sign-negated/bank-exchanged/complemented word each check235,337 frame transitions and24 copied centers, across277,775 word blocks. Their complete paid histograms agree exactly:
+
+    m=576, R=26599, W=115865904,
+    weighted rank=66736898624, deficit=1862080, largest child=574.
+
+Both rank529 connectors, source/target fronts, translated auxiliary endpoints, copied-center transforms and the inverse rank-one endpoint correction remain charged as in the base. The source and target terminal banks are unchanged, so the same inherited complete C/inverse and spectator interface applies. Arbitrary dirty cancellation follows from the birth-cut identity; no sampled modular identity replaces it.
+
+Exact backward integer propagation gives11,862,912 nonzero old-readout terms with numerator L1 norm46,704,391 over42. The maximum is55/42 at virtual role22053. We do not assume coefficients have magnitude at most one. For each read, form one complete computed copy divided by42, perform the required signed unit additions, then discard that computed copy. Terminal numerator L1 is370,392. Copies/scans,120,475 forward source/workspace gates, their inverse, role bookkeeping, phase/sign wrappers and endpoint groups are covered by the explicit conservative
+
+    G=3113921927424.
+
+Set E=64(W+576+G+1)^3, B=rank+E, C0=32*576*B^2. Exact checks verify the literal-work and semantic induction inequalities with C1=1. Retain the common grid2^-P21^-K with K=G(D_complex+1); completed exact children preserve incoming odd-denominator exponent. No child rounding or free final conversion is added. All these are fixed constants; practical thresholds are not claimed.
+
+## Assembly and scope
+
+Use complex saving b=11040781/10^11, unchanged ordinary stopped-bit saving A=1240189553/10^13, beta=10^-6, eta=10^-8, and a=min(A,(1−beta)b−10^-12). The original exact checker verifies all three strict moments,47 inequalities and seven final margins above kappa. The simultaneous row-stock coefficient is15561; degree32000 has positive gap6389/25, and suffix slope128000 is retained. The next10^-17 grid point fails for these fixed parameters only.
+
+Author checks include the complete graph/role/frame/profile reconstruction, exact integer old-readout responses, both literal frame directions, the arbitrary-dirty birth lemma, and exact assembly. The retained copied-stream, residual-to-child, translated-gauge, routing, all-size transfer and analytic hypotheses remain explicit. This is neither an unconditional theorem nor a practical-time or global-optimality claim.
+
+Credit: Rohan Arun's PR118 integration and corrected unit readouts; eumemic's PR117 DAG; Swapnil Jain's deferred-readout/round-seven bit word; icekylinx's stopped-product/rational-center interfaces; Avi Eisenberg, Zhihao Chen and all preceding contributors named by the base NOTICE/SOURCES. This contribution is the compensated physical slot reuse and its original checks, developed with OpenAI assistance. No exclusive priority or official OpenAI endorsement is claimed.
diff --git a/research/birth-read-reuse/README.md b/research/birth-read-reuse/README.md
new file mode 100644
index 0000000000..4b9bdb21cd
--- /dev/null
+++ b/research/birth-read-reuse/README.md
@@ -0,0 +1,11 @@
+# Compensated birth-read reuse
+
+Author-checked conditional kappa=5519166047173/50000000000000000=1.1038332094346e-4. Independent review pending.
+
+Run from the repository root:
+
+    python3 research/birth-read-reuse/run_checks.py
+
+Python3.11+ standard library only. The runner hashes its four base inputs and reconstructs the graph, matching, frames, birth pairs, exact readout bill, both frame directions and assembly in a temporary directory. Original individual stages took0.3,2.0,16.1,0.8,0.8,7.2 and0.4seconds respectively; each reconstruction stage has a30-second/512-MiB cap. No upstream script is imported or executed. Frozen JSON/gzip inputs and receipts are preserved.
+
+PROOF.md contains the operation and conditional theorem. BIRTH_MATCHES.json.gz contains every donor/recipient/frame pair and the complete paid profile. CANDIDATE.json contains exact moments,47 inequalities,7 margins and all changed guard/row constants. BIRTH_AUDIT.json records the complete forward/reflected frame checks; READOUT_COST.json records exact signed coefficients and their paid literal expansion. Existing base notices and attribution remain in force.
diff --git a/research/birth-read-reuse/READOUT_COST.json b/research/birth-read-reuse/READOUT_COST.json
new file mode 100644
index 0000000000..54600f16c0
--- /dev/null
+++ b/research/birth-read-reuse/READOUT_COST.json
@@ -0,0 +1,23 @@
+{
+  "status": "PASS exact integer old-readout response and explicit conservative scalar bill; no <=1 coefficient assumption",
+  "denominator": 42,
+  "readout_nonzero_terms": 11862912,
+  "readout_numerator_L1": 46704391,
+  "max_abs_numerator": 55,
+  "max_abs_coefficient": "55/42",
+  "max_role": 22053,
+  "deferred_readout_terms": 12087,
+  "terminal_terms": 56672,
+  "terminal_numerator_L1": 370392,
+  "source_injection_count": 13481,
+  "workspace_gate_count": 106994,
+  "readout_copy_scan_bill": 47369383,
+  "local_scalar_upper": 48069997,
+  "global_scalar_group_upper": 3113921927424,
+  "expansion": "At each readout, form one complete computed copy divided by42, then |numerator| signed unit additions to targets. Reverse all workspace/source gates chronologically. Factor16 and explicit endpoint groups bound scalar bookkeeping/wrappers.",
+  "odd_grid": "Denominator42=2*21; retain common odd21 grid with per-local-word G and completed-child preservation.",
+  "exact_response_sha256": "61631cf8189e99212bbb9b38faf11e32f10147e085054e7c84b5474b116c8ea8",
+  "seconds": 0.8341371089991299,
+  "rss_KiB": 238592,
+  "checkpoint_sha256": "3fc2db8947189be57880cb55a5cb028592431f2c4175ea85827af53829c0dedb"
+}
diff --git a/research/birth-read-reuse/REVIEW.md b/research/birth-read-reuse/REVIEW.md
new file mode 100644
index 0000000000..9630d2fe8b
--- /dev/null
+++ b/research/birth-read-reuse/REVIEW.md
@@ -0,0 +1,40 @@
+# Post-publication AI-agent technical review
+
+Reviewed scientific commit: `f36782865dfe81abaa40254e8f41b8ccb3c54556`.
+Proof clarification: `6cf4477f77c60edb8982fbc342a659206b5afceb`.
+Review completed on 2026-10-09 UTC by a separate OpenAI AI agent after PR #124 was published.
+
+The review supports the conditional saving
+`kappa = 5519166047173/50000000000000000 = 0.00011038332094346`
+under the retained analytic, recovery, prime, whole-residual, complete-row/copy,
+and fixed-tape interfaces. It found no blocking mathematical gap or required
+numerical correction in this construction. This is AI-agent technical review,
+not human peer review, formal verification, or an official endorsement.
+
+## Scope checked
+
+- Birth-cut cancellation with correlated arbitrary dirty values and earlier source signals.
+- All 2,106 pairs' liveness, nonaliasing, added residuals, and true reverse source chronology.
+- Complete forward/inverse C operators and preserved spectators.
+- Exact expanded readout coefficients, including 55/42, and the conservative charge G=3113921927424.
+- Active-stack odd-denominator grid, boundary conversions, and row stock 15561 with degree 32000.
+- Three strict moments, all 47 inequalities, and all seven final margins.
+
+The exact published entrypoint was rerun in an isolated cloud mirror with four
+hash-verified passive base inputs. It passed in 28.18 seconds with 380.1 MiB peak
+memory; all 20 published files and the base inputs remained unchanged. No upstream
+program was executed in that replay. The package's `run_checks.py` is the
+reproduction entrypoint.
+
+## Clarification applied
+
+The concavity argument improves the unnormalized feasibility slack. The
+normalized moment decreases at already feasible exponents; it need not decrease
+at arbitrary infeasible exponents. The corrected proof makes this qualification
+explicit. Its SHA256 is
+`46b815acd08735170ae4060d1236df9ccfe2f44e1966ddb594a3a39a14980ebc`.
+The numerical certificate and construction are unchanged.
+
+This review does not establish an unconditional multiplication theorem, practical
+speedup, global optimum, or successful upstream CI. The inherited general
+interfaces remain explicit assumptions, and CI status is reported separately.
diff --git a/research/birth-read-reuse/ROLES_CHECK.json b/research/birth-read-reuse/ROLES_CHECK.json
new file mode 100644
index 0000000000..cdc99d7f72
--- /dev/null
+++ b/research/birth-read-reuse/ROLES_CHECK.json
@@ -0,0 +1,41 @@
+{
+  "status": "PASS original exact118 matching/role/source reconstruction",
+  "links": 71185,
+  "roles": 28705,
+  "ops": 120475,
+  "phase_one_ops": 18844,
+  "phase_one_roles": 13555,
+  "augmenting_rounds": [
+    [
+      1,
+      68174
+    ],
+    [
+      2,
+      2102
+    ],
+    [
+      3,
+      317
+    ],
+    [
+      4,
+      421
+    ],
+    [
+      5,
+      46
+    ],
+    [
+      6,
+      124
+    ],
+    [
+      7,
+      1
+    ]
+  ],
+  "checkpoint_sha256": "909fcbaafa6fa6e6d0cf104ec1a620f7ba03fa34fce890ef4177837ba177052d",
+  "seconds": 2.0339603180036647,
+  "rss_KiB": 224976
+}
diff --git a/research/birth-read-reuse/SCALAR_LEMMA_CHECKS.json b/research/birth-read-reuse/SCALAR_LEMMA_CHECKS.json
new file mode 100644
index 0000000000..1886e8d369
--- /dev/null
+++ b/research/birth-read-reuse/SCALAR_LEMMA_CHECKS.json
@@ -0,0 +1,32 @@
+{
+  "status": "PASS exact scalar lemma controls; no actual114 word or bound yet",
+  "cases": 96,
+  "complete_source_dirty_basis_vectors": 520,
+  "dense_rational_cases": 96,
+  "nonzero_dependent_birth_values": 2334,
+  "largest_test_response_coefficient": "139/6",
+  "rejected_controls": {
+    "omit_reuse_readout": true,
+    "do_not_cut_next_birth": true,
+    "omit_inverse_workspace": true,
+    "group_negative_sources_at_end": true
+  },
+  "one_slot_example": {
+    "source": [
+      "3",
+      "5"
+    ],
+    "dirty": "7",
+    "birth_values": [
+      "7",
+      "10"
+    ],
+    "output": [
+      "3",
+      "5"
+    ],
+    "restored": "7"
+  },
+  "seconds": 0.07150795699999435,
+  "rss_KiB": 9472
+}
diff --git a/research/birth-read-reuse/audit_birth_frames.py b/research/birth-read-reuse/audit_birth_frames.py
new file mode 100644
index 0000000000..5e157d174d
--- /dev/null
+++ b/research/birth-read-reuse/audit_birth_frames.py
@@ -0,0 +1,134 @@
+"""Original complete local forward/reflected frame scan for birth-read slot reuse.
+Scalar correctness uses exact virtual responses plus the proved birth-cut identity.
+"""
+import sys,os,gzip
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from collections import Counter
+from functools import lru_cache
+import pickle,json,time,resource,hashlib
+ROOT=Path(__file__).resolve().parent;start=time.monotonic();resource.setrlimit(resource.RLIMIT_AS,(512*1024**2,512*1024**2));resource.setrlimit(resource.RLIMIT_CPU,(30,30))
+g=pickle.loads((ROOT/'FRAMES.pkl').read_bytes());choice=json.loads(gzip.decompress((ROOT/'BIRTH_MATCHES.json.gz').read_bytes()));v=g['v'];R=len(g['first']);fulltuple=tuple(1<<i for i in range(23,-1,-1));ALL=(1<<v)-1
+merge={p['recipient']:p['donor']for p in choice['pairs']};removed=set(merge);live=[s for s in range(R)if s not in removed];physical=lambda s:2*v+merge.get(s,s)
+assert len(live)==choice['R'] and not removed&set(merge.values())
+assert all(g['first'][s]>v for s in removed),'Selected deferred source injection requires explicit inverse insertion review'
+for b,a in merge.items():assert a not in g['placed']and b in g['placed']and b not in g['touched']and g['last'][a]in g['phase']and a not in g['terminal']
+frames=[()];ids={():0}
+def fid(F):
+ if F not in ids:ids[F]=len(frames);frames.append(F)
+ return ids[F]
+FULL=fid(fulltuple);tm=[fid((m,))for m in g['tm']];U=[fid(F)for F in g['U']]
+def basis(rows):
+ piv={}
+ for x in rows:
+  for p in sorted(piv,reverse=True):
+   if x>>p&1:x^=piv[p]
+  if x:
+   p=x.bit_length()-1
+   for q in piv:
+    if piv[q]>>p&1:piv[q]^=x
+   piv[p]=x
+ return tuple(piv[p]for p in sorted(piv,reverse=True))
+@lru_cache(None)
+def dual(i):
+ A=frames[i];piv={r.bit_length()-1 for r in A};out=[]
+ for j in range(24):
+  if j not in piv:
+   x=1<<j
+   for r in A:
+    if r>>j&1:x|=1<<(r.bit_length()-1)
+   out.append(x)
+ return fid(basis(out))
+@lru_cache(131072)
+def nested(i,j):
+ for x in frames[i]:
+  for r in frames[j]:
+   if x>>(r.bit_length()-1)&1:x^=r
+  if x:return False
+ return True
+word=[];forward_workspace=[]
+def gate(d,s,c,F,remember=False):
+ assert d!=s;word.append(('g',d,s,c,F))
+ if remember:forward_workspace.append((d,s,c,F))
+def oldread(s,F):
+ mask=ALL if g['reach_all'][s]else g['reach'][s]
+ word.append(('r',physical(s),v,mask,-1,F,('old',s)))
+def source(s):
+ x=g['first'][s];assert 1<=x<=v;gate(physical(s),x-1,1,U[x],True)
+def mix(i):
+ op,s,t,x=g['ops'][i]
+ if op==1:gate(physical(s),physical(t),1,U[x],True)
+ elif op==2:gate(physical(t),physical(s),1,U[x],True)
+for s in range(R):
+ if s not in g['placed']:oldread(s,0)
+for s,x in enumerate(g['first']):
+ if x<=v and s not in g['placed']:source(s)
+for i in sorted(g['phase']):mix(i)
+for s in g['center_roles']:
+ j=g['terminal'][s];F=fid(g['U'][g['roots'][j]]);assert len(frames[F])==23
+ word.append(('c',physical(s),v,ALL,1,F,0,('center',j-(len(g['roots'])-24))))
+for s,F in sorted(g['placed'].items(),key=lambda item:(len(item[1]),item[0])):oldread(s,fid(F))
+for s,x in enumerate(g['first']):
+ if x<=v and s in g['placed']:source(s)
+for i in range(len(g['ops'])):
+ if i not in g['phase']:mix(i)
+for s,j in sorted(g['terminal'].items(),key=lambda item:item[1]):
+ if j<len(g['roots'])-24:
+  t=g['targets'][j];word.append(('r',physical(s),v,1<<t,1,dual(tm[t]),('side',j)))
+# Correct order includes the source gates: no commutation of injections is assumed.
+for d,s,c,F in reversed(forward_workspace):gate(d,s,-c,FULL)
+active=list(range(2*v))+[2*v+s for s in live]
+initial=[None]*(2*v+R)
+for t in range(v):initial[t]=tm[t];initial[v+t]=0
+for s in live:initial[2*v+s]=fid(g['placed'].get(s,()))
+finish=[None]*len(initial)
+for t in range(v):finish[t]=FULL;finish[v+t]=dual(tm[t])
+for s in live:finish[2*v+s]=FULL
+
+def scan(events,begin,end):
+ current=begin[:];hist=Counter();copies=0;counts=[Counter(current[:v]),Counter(current[v:2*v])];digest=hashlib.sha256();incidences=0
+ def promote(s,F):
+  nonlocal incidences
+  assert s in active_set and current[s] is not None
+  old=current[s]
+  if old==F:return
+  assert nested(old,F),('Illegal frame',s,frames[old],frames[F]);r=len(frames[F])-len(frames[old]);assert r>0
+  hist[r]+=1;current[s]=F;incidences+=1
+  if s<2*v:
+   bank=s//v;counts[bank][old]-=1
+   if not counts[bank][old]:del counts[bank][old]
+   counts[bank][F]+=1
+ def targets(bank,mask,F):
+  if len(counts[bank//v])==1 and counts[bank//v].get(F)==v:return
+  while mask:
+   b=mask&-mask;mask-=b;promote(bank+b.bit_length()-1,F)
+ for e in events:
+  digest.update(repr(e).encode())
+  if e[0]=='g':_,d,s,c,F=e;assert c in(-1,1);promote(d,F);promote(s,F)
+  elif e[0]=='r':_,s,bank,mask,sign,F,key=e;assert mask>=0 and not(mask&~ALL);promote(s,F);targets(bank,mask,F)
+  else:
+   _,s,bank,mask,sign,F,T,key=e;promote(s,F);targets(bank,mask,T)
+   assert (F==FULL and T==0)or nested(F,T)or nested(T,F)
+   r=abs(len(frames[F])-len(frames[T]));assert r==23;hist[r]+=1;copies+=1
+ for s in active:promote(s,end[s])
+ assert current==end
+ return hist,copies,incidences,digest.hexdigest()
+active_set=set(active);forward=scan(word,initial,finish)
+def swap(s):return s+v if s<v else(s-v if s<2*v else s)
+def reflect(e):
+ if e[0]=='g':_,d,s,c,F=e;return('g',swap(d),swap(s),-c,dual(F))
+ if e[0]=='r':_,s,bank,mask,sign,F,key=e;return('r',swap(s),v-bank,mask,-sign,dual(F),key)
+ _,s,bank,mask,sign,F,T,key=e;return('c',swap(s),v-bank,mask,-sign,dual(F),dual(T),key)
+reverse=[reflect(e)for e in reversed(word)];assert [reflect(e)for e in reversed(reverse)]==word
+rb=[None]*len(initial);re=[None]*len(initial)
+for s in active:rb[swap(s)]=dual(finish[s]);re[swap(s)]=dual(initial[s])
+backward=scan(reverse,rb,re);assert forward[:2]==backward[:2],(forward[:2],backward[:2])
+H=Counter({r:2*v*n for r,n in forward[0].items()})
+for s in live:H[552+len(frames[initial[2*v+s]])]+=2*v
+H[529]+=2*v*v;H[1]+=v*v
+assert dict(H)=={int(r):n for r,n in choice['child_histogram'].items()},('Whole paid profile mismatch',H)
+assert forward[1]==24 and sum(r*n for r,n in H.items())==choice['rank']
+# The exact source map and old response pass were independently reconstructed.
+bill=json.loads((ROOT/'READOUT_COST.json').read_text());assert bill['max_abs_numerator']==55 and bill['readout_numerator_L1']==46704391
+out=dict(status='PASS original complete forward/reflected paid frame scan',source_head='6ec868e8568ca9a74b7245494de1b187c7be78fe',matches=len(merge),physical_original_roles=len(live),virtual_roles=R,word_blocks=len(word),workspace_forward_gates=len(forward_workspace),all_data_source_target_banks_disjoint=True,targets_never_controls=True,donors_dead_before_birth=True,recipients_untouched_before_birth=True,all_selected_recipients_have_no_source_injection=True,inverse_order='Reverse actual workspace and source events chronologically at full frame',forward_frame_transitions=forward[2],reverse_frame_transitions=backward[2],copies_per_direction=forward[1],all_histogram_bins_match=True,forward_word_sha256=forward[3],reverse_word_sha256=backward[3],scalar_scope='All-size arbitrary dirty algebra is the birth-cut identity with exact old-readout responses; complete source supports checked, no dense dirty-square expansion',seconds=time.monotonic()-start,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+(ROOT/'BIRTH_AUDIT.json').write_text(json.dumps(out,indent=2)+'\n');print(json.dumps(out,indent=2))
diff --git a/research/birth-read-reuse/build_frames.py b/research/birth-read-reuse/build_frames.py
new file mode 100644
index 0000000000..ae876755f9
--- /dev/null
+++ b/research/birth-read-reuse/build_frames.py
@@ -0,0 +1,154 @@
+"""Original exact118 lifted/saturated frame reconstruction; no upstream imports."""
+import sys,os
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from itertools import combinations
+from collections import Counter,defaultdict
+from functools import lru_cache
+from fractions import Fraction
+import pickle,json,time,resource,hashlib
+ROOT=Path(__file__).resolve().parent;REPO=Path(os.environ.get('BIRTH_REPO',ROOT.parents[1]));start=time.monotonic();resource.setrlimit(resource.RLIMIT_AS,(512*1024**2,512*1024**2));resource.setrlimit(resource.RLIMIT_CPU,(30,30))
+H=24;FULL=(1<<H)-1
+
+def basis(rows):
+ piv={}
+ for x in rows:
+  for p in sorted(piv,reverse=True):
+   if x>>p&1:x^=piv[p]
+  if x:
+   p=x.bit_length()-1
+   for q in piv:
+    if piv[q]>>p&1:piv[q]^=x
+   piv[p]=x
+ return tuple(piv[p]for p in sorted(piv,reverse=True))
+@lru_cache(65536)
+def contained(A,B):
+ for x in A:
+  for r in B:
+   if x>>(r.bit_length()-1)&1:x^=r
+  if x:return False
+ return True
+@lru_cache(65536)
+def perpendicular(A):
+ piv={r.bit_length()-1 for r in A};out=[]
+ for j in range(H):
+  if j not in piv:
+   x=1<<j
+   for r in A:
+    if r>>j&1:x|=1<<(r.bit_length()-1)
+   out.append(x)
+ return basis(out)
+@lru_cache(65536)
+def intersection(A,B):return perpendicular(basis(perpendicular(A)+perpendicular(B)))
+@lru_cache(65536)
+def nondeg(A):return len(basis(sum(((x&y).bit_count()%2)<<j for j,y in enumerate(A))for x in A))==len(A)
+@lru_cache(65536)
+def regular_part(A):
+ remain=list(A);chosen=[]
+ while remain:
+  odd=next((i for i,x in enumerate(remain)if x.bit_count()%2),None)
+  if odd is not None:
+   a=remain.pop(odd);chosen.append(a);remain=[x^a if (x&a).bit_count()%2 else x for x in remain];continue
+  pair=next(((i,j)for i,x in enumerate(remain)for j in range(i+1,len(remain))if (x&remain[j]).bit_count()%2),None)
+  if pair is None:break
+  i,j=pair;a,b=remain[i],remain[j];chosen.extend((a,b));remain=[x^(a if(x&b).bit_count()%2 else 0)^(b if(x&a).bit_count()%2 else 0)for k,x in enumerate(remain)if k not in(i,j)]
+ return basis(chosen)
+def bits(mask):
+ while mask:
+  x=mask&-mask;mask-=x;yield x.bit_length()-1
+
+def save(name,value):
+ raw=pickle.dumps(value,protocol=4);(ROOT/name).write_bytes(raw);return hashlib.sha256(raw).hexdigest()
+
+if (ROOT/'LIFTED.pkl').exists():g=pickle.loads((ROOT/'LIFTED.pkl').read_bytes())
+else:
+ g=pickle.loads((ROOT/'ROLES.pkl').read_bytes());args,core,cover,rank,kind=[g[k]for k in('args','core','cover','rank','kind')];active=g['active'];roots=g['roots'];uses=g['uses'];use=g['use'];links=g['links'];matched=g['matched_use'];n=len(args);v=g['v']
+ tm=[sum(1<<i for i in t)for t in combinations(range(H),3)];fun=[tm[t]if t>=0 else 1<<(j-(len(roots)-H))for j,t in enumerate(g['targets'])]
+ succ=[set()for _ in range(n)];rootf=[[]for _ in range(n)]
+ def connect(x,uid):
+  _,typ,dest,_=use[uid]
+  if typ:rootf[x].append(fun[dest])
+  else:succ[x].add(dest)
+ for x in active:
+  for uid in uses[x]:
+   if matched[uid]<0:connect(x,uid)
+ for x,uid in links.items():connect(x,uid)
+ order=sorted(active,key=lambda x:(rank[x],x),reverse=True);demand=[()]*n
+ for x in order:demand[x]=basis(rootf[x]+[r for y in sorted(succ[x])for r in demand[y]])
+ def envelope(x):
+  if not args[x]:return (tm[x-1],)
+  if kind[x]==2:return basis(1<<i for i in bits(cover[x]))
+  assert kind[x]==1
+  return basis(core[x]|(1<<i)for i in bits(cover[x]&~core[x]))
+ U=[()]*n
+ for x in active:
+  E=envelope(x)
+  if not args[x]:U[x]=E
+  else:
+   K=perpendicular(demand[x]);assert contained(E,K);U[x]=K if nondeg(K)else E
+ changed=True
+ while changed:
+  changed=False
+  for x in order:
+   if args[x]and any(not contained(U[x],U[y])for y in succ[x]):
+    E=envelope(x)
+    if U[x]!=E:U[x]=E;changed=True
+ roles=len(g['first']);reach=[0]*roles;dense=[False]*roles
+ for s,j in g['terminal'].items():
+  if j>=len(roots)-H:dense[s]=True
+  else:reach[s]=1<<g['targets'][j]
+ for op,s,t,x in reversed(g['ops']):
+  if op==1:reach[t]|=reach[s];dense[t]|=dense[s]
+  elif op==2:reach[s]|=reach[t];dense[s]|=dense[t]
+ cand={}
+ for s,x in enumerate(g['first']):
+  if s in g['touched']or dense[s]:continue
+  constraint=basis(tm[t]for t in bits(reach[s]));X=intersection(U[x],perpendicular(constraint))
+  if X and nondeg(X):cand[s]=X
+ g.update(U=U,reach=reach,reach_all=dense,candidates=cand,tm=tm,lifted=sum(bool(args[x])and len(U[x])>rank[x]for x in active))
+ assert g['lifted']==39989,g['lifted'];save('LIFTED.pkl',g)
+ print('Lifted checkpoint',len(cand),'candidates',round(time.monotonic()-start,2),flush=True)
+# Only this saturating placement is repeated if a previous cap ended after LIFTED.
+U=g['U'];reach=g['reach'];cand=g['candidates'];bytarget=defaultdict(list);placed={};order=sorted(cand,key=lambda s:(-len(cand[s]),s))
+for step,s in enumerate(order):
+ X=cand[s];changed=True
+ while changed and X:
+  changed=False
+  for t in bits(reach[s]):
+   for prior in bytarget[t]:
+    B=placed[prior]
+    if (len(B)>=len(X)and not contained(X,B))or(len(B)<len(X)and not contained(B,X)):
+     X=intersection(X,B);changed=True
+    if not X:break
+   if not X:break
+ if X and nondeg(X):
+  assert nondeg(X)and contained(X,cand[s]);placed[s]=X
+  for t in bits(reach[s]):bytarget[t].append(s)
+ if step and step%2000==0:print('Placed',step,'/',len(order),'time',round(time.monotonic()-start,2),flush=True)
+for ss in bytarget.values():
+ ss.sort(key=lambda s:(len(placed[s]),s));assert all(contained(placed[a],placed[b])for a,b in zip(ss,ss[1:]))
+assert len(placed)==3020,len(placed)
+# Reconstruct EVERY paid bin, not merely total mass.
+v=g['v'];N=v*v;roles=len(g['first']);hist=Counter();chains={}
+for s,chain in enumerate(g['holds']):
+ actual=[placed.get(s,())]+[U[x]for x in chain]
+ if s in g['terminal']:
+  j=g['terminal'][s];terminal_frame=perpendicular((1<<(j-(len(g['roots'])-H)),))if j>=len(g['roots'])-H else perpendicular((g['tm'][g['targets'][j]],))
+  actual.append(terminal_frame)
+ assert all(contained(a,b)for a,b in zip(actual,actual[1:]))and all(nondeg(A)for A in actual)
+ ds=[len(A)for A in actual];chains[s]=ds
+ for a,b in zip(ds,ds[1:]):
+  if b>a:hist[b-a]+=2*v
+ if s in g['terminal']and g['terminal'][s]>=len(g['roots'])-H:hist[H-1]+=2*v
+ if H>ds[-1]:hist[H-ds[-1]]+=2*v
+ hist[576-H+ds[0]]+=2*v
+for t in range(v):
+ levels=sorted({0,H-1}|{len(placed[s])for s in bytarget[t]})
+ for a,b in zip(levels,levels[1:]):hist[b-a]+=2*v
+hist[H-1]+=2*N;hist[(H-1)**2]+=2*N;hist[1]+=N
+expected=json.loads((REPO/'research/deferred-replayed-117/complex-profile.json').read_text())
+assert dict(hist)=={int(k):v for k,v in expected['child_multiplicities'].items()},('Histogram mismatch',hist)
+assert Counter(len(A)for A in placed.values())==Counter({int(k):v for k,v in expected['deferred_dims'].items()})
+g.update(placed=placed,bytarget=dict(bytarget),histogram=dict(hist),chain_dims=chains);digest=save('FRAMES.pkl',g)
+result=dict(status='PASS original118 full frame/profile reconstruction',roles=roles,deferred=len(placed),maxchild=max(hist),weighted_rank=sum(t*n for t,n in hist.items()),all_bins_match=True,frame_sha256=digest,seconds=time.monotonic()-start,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+(ROOT/'FRAMES_CHECK.json').write_text(json.dumps(result,indent=2)+'\n');print(json.dumps(result,indent=2))
diff --git a/research/birth-read-reuse/build_roles.py b/research/birth-read-reuse/build_roles.py
new file mode 100644
index 0000000000..427d518e8f
--- /dev/null
+++ b/research/birth-read-reuse/build_roles.py
@@ -0,0 +1,109 @@
+"""Original exact carrier matching/role reconstruction, no upstream imports."""
+import sys,os
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from collections import deque
+import pickle,json,time,resource,hashlib
+ROOT=Path(__file__).resolve().parent;REPO=Path(os.environ.get('BIRTH_REPO',ROOT.parents[1]));start=time.monotonic()
+resource.setrlimit(resource.RLIMIT_AS,(512*1024**2,512*1024**2));resource.setrlimit(resource.RLIMIT_CPU,(30,30));sys.setrecursionlimit(5000)
+g=pickle.loads((ROOT/'GRAPH.pkl').read_bytes());h,v=g['h'],g['v'];args,core,cover,rank,kind=[g[k]for k in ('args','core','cover','rank','kind')];active=g['active'];roots=g['roots'];n=len(args);full=(1<<h)-1
+uses=[[]for _ in range(n)];use=[];edge={}
+for x in active:
+ if args[x]:
+  for pos,y in enumerate(args[x]):
+   uid=len(use);uses[y].append(uid);use.append((y,0,x,pos));edge[x,pos]=uid
+for j,x in enumerate(roots):uid=len(use);uses[x].append(uid);use.append((x,1,j,0))
+def contains(x,y):
+ tx,ty=kind[x],kind[y]
+ if tx==ty==1:return not(core[y]&~core[x]or cover[x]&~cover[y])
+ if tx in(1,2)and ty==2:return not cover[x]&~cover[y]
+ if tx==1 and ty==3:return bool(core[x]&core[y])
+ if tx==2 and ty==3:return not cover[x]&~core[y]
+ if tx==3 and ty==2:return cover[y]==full
+ return tx==ty==3 and core[x]==core[y]
+left=[];adj={}
+for x in active:
+ if not args[x]:continue
+ choices=[]
+ for y in args[x]:
+  for uid in uses[y]:
+   _,typ,dest,pos=use[uid];target=roots[dest]if typ else dest
+   orderid=n+dest if typ else dest
+   if (rank[x],x)<(rank[target],orderid)and contains(x,target):choices.append(uid)
+ if choices:
+  left.append(x);adj[x]=sorted(set(choices),key=lambda uid:(use[uid][0],uses[use[uid][0]].index(uid)))
+# Ordinary ordered Hopcroft-Karp, with explicit shortest augmenting layers.
+L=[-1]*n;R=[-1]*len(use);INF=n+1;rounds=[]
+while True:
+ dist=[INF]*n;queue=deque()
+ for x in left:
+  if L[x]<0:dist[x]=0;queue.append(x)
+ shortest=INF
+ while queue:
+  x=queue.popleft()
+  if dist[x]>=shortest:continue
+  for uid in adj[x]:
+   y=R[uid]
+   if y<0:shortest=dist[x]+1
+   elif dist[y]==INF:dist[y]=dist[x]+1;queue.append(y)
+ if shortest==INF:break
+ def augment(x):
+  for uid in adj[x]:
+   y=R[uid]
+   if (y<0 and dist[x]+1==shortest)or(y>=0 and dist[y]==dist[x]+1 and augment(y)):
+    L[x]=uid;R[uid]=x;return True
+  dist[x]=INF;return False
+ gained=sum(augment(x)for x in left if L[x]<0);assert gained;rounds.append((shortest,gained))
+links={x:L[x]for x in left if L[x]>=0};assert len(links)==71185,len(links)
+# Every matched edge is an actual unchanged input continuation into a later use.
+assert len(set(links.values()))==len(links)
+for x,uid in links.items():assert use[uid][0]in args[x]and uid in adj[x]
+held=[];first=[];ops=[];role_of={};terminal={}
+def alloc(x):
+ s=len(first);first.append(x);held.append([x]);return s
+for x in sorted(active,key=lambda x:(rank[x],x)):
+ free=[uid for uid in uses[x]if R[uid]<0]
+ if not args[x]:
+  for uid in free:
+   s=alloc(x);ops.append((0,s,x,-1));role_of[uid]=s
+  continue
+ a,b=args[x];sa,sb=role_of.pop(edge[x,0]),role_of.pop(edge[x,1]);assert sa!=sb
+ if x in links and use[links[x]][0]==a:sa,sb=sb,sa
+ ops.append((1,sa,sb,x));held[sa].append(x);held[sb].append(x)
+ if x in links:role_of[links[x]]=sb
+ assert free;role_of[free[0]]=sa
+ for uid in free[1:]:
+  s=alloc(x);ops.append((2,sa,s,x));role_of[uid]=s
+for uid,row in enumerate(use):
+ if row[1]:terminal[role_of.pop(uid)]=row[2]
+assert not role_of and len(first)==28705 and len(terminal)==len(roots)
+# All original-role fresh signals, not sampled values.
+values=[0]*len(first)
+for op,s,t,x in ops:
+ if op==0:values[s]=1<<(t-1)
+ elif op==1:
+  assert not(values[s]&values[t]);values[s]|=values[t];assert values[s]==g['support'][x]
+ else:assert values[t]==0;values[t]=values[s];assert values[t]==g['support'][x]
+for s,j in terminal.items():assert values[s]==g['support'][roots[j]]
+for chain in held:
+ for a,b in zip(chain,chain[1:]):assert contains(a,b)
+# Dependencies in the exact selected chronological program.
+previous=[-1]*len(first);pred=[[]for _ in ops];last=[-1]*len(first)
+for i,(op,s,t,x)in enumerate(ops):
+ if op:
+  for r in(s,t):
+   if previous[r]>=0:pred[i].append(previous[r])
+   previous[r]=i;last[r]=i
+centers=[s for s,j in terminal.items()if j>=len(roots)-h]
+phase=set();todo=[last[s]for s in centers]
+while todo:
+ i=todo.pop()
+ if i not in phase:phase.add(i);todo.extend(pred[i])
+touched=set(centers)
+for i in phase:
+ _,s,t,_=ops[i];touched.update((s,t))
+expected=json.loads((REPO/'research/deferred-replayed-117/complex-profile.json').read_text());assert (len(phase),len(touched))==(expected['phase_one_ops'],expected['phase_one_roles']),(len(phase),len(touched))
+g.update(uses=uses,use=use,links=links,matched_use=R,holds=held,first=first,ops=ops,terminal=terminal,last=last,phase=phase,touched=touched,center_roles=centers)
+raw=pickle.dumps(g,protocol=4);(ROOT/'ROLES.pkl').write_bytes(raw)
+receipt=dict(status='PASS original exact118 matching/role/source reconstruction',links=len(links),roles=len(first),ops=len(ops),phase_one_ops=len(phase),phase_one_roles=len(touched),augmenting_rounds=rounds,checkpoint_sha256=hashlib.sha256(raw).hexdigest(),seconds=time.monotonic()-start,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+(ROOT/'ROLES_CHECK.json').write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps(receipt,indent=2))
diff --git a/research/birth-read-reuse/check_assembly.py b/research/birth-read-reuse/check_assembly.py
new file mode 100644
index 0000000000..088f44ee93
--- /dev/null
+++ b/research/birth-read-reuse/check_assembly.py
@@ -0,0 +1,71 @@
+"""Original exact assembly for paid birth-read slot reuse. No upstream imports."""
+import sys,os,gzip
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from fractions import Fraction as Q
+from math import factorial
+import json,hashlib,time,resource
+root=Path(__file__).resolve().parent;repo=Path(os.environ.get('BIRTH_REPO',root.parents[1]));start=time.monotonic()
+profile=json.loads(gzip.decompress((root/'BIRTH_MATCHES.json.gz').read_bytes()));bill=json.loads((root/'READOUT_COST.json').read_text())
+source=repo/'research/deferred-replayed-117/certificate.json'
+oldpath=repo/'certificates/copied-centers-network.json'
+cert=json.loads(source.read_text());old_leaf=json.loads(oldpath.read_text())
+logcache={}
+def smalllog(x):
+ z=(x-1)/(x+1);N=40;lo=2*sum((z**(2*j+1)/Q(2*j+1)for j in range(N)),Q(0));tail=2*z**(2*N+1)/(Q(2*N+1)*(1-z*z));return lo,lo+tail
+ln2=smalllog(Q(2))
+def logbound(x):
+ if x in logcache:return logcache[x]
+ k=0;y=x
+ while y>=2:y/=2;k+=1
+ lo,hi=smalllog(y);out=(k*ln2[0]+lo,k*ln2[1]+hi);logcache[x]=out;return out
+
+def expbound(lo,hi):
+ n=8;assert 0<=lo<=hi<1
+ a=sum((lo**j/Q(factorial(j))for j in range(n+1)),Q(0));b=sum((hi**j/Q(factorial(j))for j in range(n+1)),Q(0));b+=hi**(n+1)/Q(factorial(n+1))/(1-hi/Q(n+2));return a,b
+
+def moment(label,m,W,children,saving):
+ rows={int(t):int(n)for t,n in children.items()};assert rows and all(0<t<m and n>0 for t,n in rows.items());lo=Q(0);hi=Q(0)
+ for t,n in sorted(rows.items()):
+  ll,lh=logbound(Q(m,t));a,b=expbound(saving*ll,saving*lh);weight=Q(n*t,m*W);lo+=weight*a;hi+=weight*b
+ scale=1<<192
+ lo=Q((lo*scale).numerator//(lo*scale).denominator,scale)
+ u=hi*scale;hi=Q((u.numerator+u.denominator-1)//u.denominator,scale)
+ assert hi<1,label
+ return dict(label=label,m=m,W=W,saving=saving,rank=sum(t*n for t,n in rows.items()),lower=lo,upper=hi,strict_gap=1-hi,enclosure_grid_bits=192,log_terms=40,exponential_degree=8)
+
+
+coarse=cert['bit_profile'];old=old_leaf['bit']['counts'];alpha=Q(1,1000);a0=Q(620523,5000000000);old_a=Q(384599,10**10)
+aactual=(1-alpha)*a0+alpha*old_a;b=Q(11040781,10**11);beta=Q(1,10**6);buffer=Q(1,10**12);a=min(aactual,(1-beta)*b-buffer)
+assert aactual==Q(1240189553,10**13)==Q(cert['actual_bit_saving'])and aactual>a>0
+moments=[moment('coarse_bit',529,coarse['W'],coarse['child_multiplicities'],a0),moment('old_ordinary',old['m'],old['W'],old['child_multiplicities'],old_a),moment('birth_reused_complex',576,profile['W'],profile['child_histogram'],b)]
+m,W,s,rmax,R=576,profile['W'],profile['rank'],max(map(int,profile['child_histogram'])),profile['R'];G=bill['global_scalar_group_upper']
+assert (W,s,R,rmax)==(115865904,66736898624,26599,574)
+E=64*(W+m+G+1)**3;charge=2*G*W*W+8*s+4*W+4+32*m;B=s+E;C0=32*m*B*B
+assert charge<E and 2*B*(m-rmax)>=s+E and 2*B+18<C0
+halving=lambda m,r:next(t for t in range(1,1000)if m**t>2*r**t)
+stock=[dict(m=mm,W=ww,maxchild=rr,depth=halving(mm,rr),wire_bits=ww.bit_length())for mm,ww,rr in [(529,coarse['W'],528),(575,old['W'],529),(576,W,rmax)]]
+rows=sum(x['depth']*x['wire_bits']for x in stock);rowgap=Q(32000)-Q(51,25)*rows
+assert rows==15561 and rowgap==Q(6389,25)
+bridge=dict(m=m,W=W,rank=s,R=R,maxchild=rmax,G=G,E=E,literal_charge=charge,B=B,C0=C0,C1=1,stock=stock,rows=rows,row_degree=32000,row_gap=rowgap,suffix_slope=128000,odd_grid='2^-P21^-K; K=G*(D_complex+1), with completed child preserving incoming odd exponent')
+# Exact retained assembly formulas, written independently and never imported.
+eta=Q(1,10**8);beta=Q(1,10**6);tau=1-a;sigma=1-b;q=a*(1-2*eta);c=q*(1+eta);eps=(1-eta)/(1+c+q);lp=1-q;lam=(tau+lp)/2;g=eps*q;rr=(g+1-eps)/2;delta=eta/8
+internal=tau+(1-beta)*max(sigma-tau,Q(0));leaf=sigma+beta*(1-sigma)
+grid=10**17;kappa=Q((g*grid).numerator//(g*grid).denominator,grid)
+if kappa==g:kappa-=Q(1,grid)
+margins=dict(original_prefix=1-eps*(1+c),coordinate_movement=a,compact_phase_layer=g,bulk_exposure=a,Gaussian_arithmetic=min(1-eps-delta,rr-delta),scalar_work=1-eps-delta,dimension=eps)
+slacks=dict(bit_positive=a,complex_above_bit=b-a,complex_below_one_over32=Q(1,32)-b,beta_positive=beta,beta_below_one=1-beta,leaf_saving_above_bit=(1-beta)*b-a,q_positive=q,q_below_internal=1-internal-q,q_below_leaf=1-leaf-q,c_positive=c,c_below_one=1-c,q_below_reservations=c-q,lambda_above_tau=lam-tau,lambda_above_sigma=lam-sigma,lambda_above_internal=lam-internal,lambda_prime_above_lambda=lp-lam,compact_leaf=lp-leaf,compact_reservations=lp-(1-c),lambda_prime_below_one=q,epsilon_positive=eps,epsilon_below_one=1-eps,guard_width=1-eps,K_geometry=1-eps*(1+c),K_dominates_log=eps*c,record_suffix=1-eps,phase_local=1-eps-delta,phase_boundary=rr-delta,gamma_sublinear=1-eps-rr,cell_above_band=eps-(1-rr)/2,prime_interval_packing=1-eps,alpha_positive=rr,alpha_below_one=1-rr,alpha_below_one_fourth=Q(1,4)-rr,delta_positive=delta,delta_below_one_eighth=Q(1,8)-delta,short_record_fallback=eps-a,small_field_exposure=1-eps-g,artificial_boundary=8-eps+rr-delta-g,literal_scalar_guard=Q(E-charge),row_product_gap=rowgap)
+slacks.update({name+'_above_kappa':v-kappa for name,v in margins.items()})
+assert len(slacks)==47 and len(margins)==7 and all(v>0 for v in slacks.values());assert min(margins.values())==g and margins['original_prefix']-g==eta
+next_kappa=kappa+Q(1,grid);assert g-next_kappa<=0
+
+
+inputfiles=[root/'BIRTH_MATCHES.json.gz',root/'READOUT_COST.json',source,oldpath]
+pins={('new/'+p.name)if p.parent==root else('base/'+str(p.relative_to(repo))):hashlib.sha256(p.read_bytes()).hexdigest()for p in inputfiles}
+out=dict(status='AUTHOR_CHECKED_CONDITIONAL_ASSEMBLY; independent review pending',source_head='6ec868e8568ca9a74b7245494de1b187c7be78fe',profile_source_head='ec862a5af51537495c745d9f2323e8a5736ee265',pins=pins,kappa=kappa,complex_saving=b,actual_bit_saving=aactual,supported_bit_parameter=a,moments=moments,finite_bridge=bridge,assembly=dict(parameters=dict(a=a,b=b,beta=beta,eta=eta,q=q,c=c,epsilon=eps,lambda_=lam,lambda_prime=lp,r=rr,delta=delta,C0=C0,C1=1),constraints=slacks,margins=margins,minimum_margin=g,absorption_gap=g-kappa),next_grid=next_kappa,next_grid_gap=g-next_kappa)
+def js(x):
+ if isinstance(x,Q):return str(x)
+ if isinstance(x,dict):return {str(k):js(v)for k,v in x.items()}
+ if isinstance(x,(list,tuple)):return [js(v)for v in x]
+ return x
+(root/'CANDIDATE.json').write_text(json.dumps(js(out),indent=2)+'\n');print(json.dumps(dict(kappa=str(kappa),decimal=float(kappa),complex_saving=str(b),G=G,W=W,R=R,constraints=len(slacks),margins=len(margins),seconds=time.monotonic()-start),indent=2))
diff --git a/research/birth-read-reuse/check_birth_lemma.py b/research/birth-read-reuse/check_birth_lemma.py
new file mode 100644
index 0000000000..67f9e2c1e9
--- /dev/null
+++ b/research/birth-read-reuse/check_birth_lemma.py
@@ -0,0 +1,87 @@
+"""Original exact adversarial check of reset compensation; no upstream imports."""
+import sys,os
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from fractions import Fraction as F
+from random import Random
+from pathlib import Path
+import json,time,resource
+T0=time.monotonic()
+def add(a,b,c=F(1)):
+ for i,x in enumerate(b):a[i]+=c*x
+
+def response(events,R,X,Y,cut=True):
+ B=[[F(0)for _ in range(Y)]for _ in range(R)];M=[[F(0)for _ in range(Y)]for _ in range(X)];D={}
+ for k in range(len(events)-1,-1,-1):
+  e=events[k];kind,r=e[:2]
+  if kind=='read':_,r,t,c=e;B[r][t]+=c
+  elif kind=='gate':_,r,s,c=e;add(B[s],B[r],c)
+  elif kind=='source':_,r,j,c=e;add(M[j],B[r],c)
+  elif kind=='birth':
+   D[k]=B[r][:]
+   if cut:B[r]=[F(0)for _ in range(Y)]
+  else:raise AssertionError(e)
+ return B,M,D
+
+def run(events,R,X,Y,x,z,D=None,uncompute=True,omit=None,fresh_only=False):
+ a=z[:];out=[F(0)for _ in range(Y)];gates=[];births=[]
+ for k,e in enumerate(events):
+  kind,r=e[:2]
+  if kind=='birth':
+   if D is None:a[r]=F(0)
+   else:
+    g=a[r];births.append((k,g))
+    if k!=omit:
+     for t,d in enumerate(D[k]):out[t]-=d*g
+  elif kind=='gate':_,r,s,c=e;a[r]+=c*a[s];gates.append(e)
+  elif kind=='source':_,r,j,c=e;a[r]+=c*x[j];gates.append(e)
+  elif kind=='read':_,r,t,c=e;out[t]+=c*a[r]
+ if D is not None and uncompute:
+  for e in reversed(gates):
+   kind,r,j,c=e;a[r]-=c*(a[j]if kind=='gate'else x[j])
+ return out,a,births
+rng=Random(114113);basis_checks=0;dependent_nonzero_births=0;coefficient_max=F(0)
+for case in range(96):
+ R=1+case%5;X=1+(case//5)%4;Y=1+(case//20)%4
+ events=[('birth',r)for r in range(R)]
+ for step in range(24):
+  kind=rng.choice(['birth','source','read','gate']if R>1 else['birth','source','read'])
+  r=rng.randrange(R);c=rng.choice([F(1),F(-1),F(2),F(-2),F(1,2),F(-1,3)])
+  if kind=='birth':events.append((kind,r))
+  elif kind=='source':events.append((kind,r,rng.randrange(X),c))
+  elif kind=='read':events.append((kind,r,rng.randrange(Y),c))
+  else:
+   s=rng.choice([i for i in range(R)if i!=r]);events.append((kind,r,s,c))
+ # Force a genuinely used reuse with a nonzero old-source offset.
+ events += [('source',0,0,F(1)),('read',0,0,F(1)),('birth',0),('source',0,0,F(2)),('read',0,Y-1,F(1))]
+ B,M,D=response(events,R,X,Y);assert all(not any(row)for row in B)
+ coefficient_max=max(coefficient_max,max((abs(c)for row in D.values()for c in row),default=F(0)))
+ for b in range(X+R):
+  x=[F(i==b)for i in range(X)];z=[F(X+i==b)for i in range(R)]
+  expected=run(events,R,X,Y,x,[F(0)]*R)[0]
+  actual,restored,births=run(events,R,X,Y,x,z,D)
+  assert actual==expected and restored==z
+  assert expected==[sum(M[i][t]*x[i]for i in range(X))for t in range(Y)]
+  basis_checks+=1;dependent_nonzero_births+=sum(bool(g)for _,g in births)
+ # Dense signed rational source/dirty inputs exercise dependent birth values.
+ x=[F(rng.randrange(-7,8),rng.randrange(1,5))for _ in range(X)];z=[F(rng.randrange(-7,8),rng.randrange(1,5))for _ in range(R)]
+ assert run(events,R,X,Y,x,z,D)[:2]==(run(events,R,X,Y,x,[F(0)]*R)[0],z)
+# A one-slot two-life example: x0 is still in the slot at its second birth.
+e=[('birth',0),('source',0,0,F(1)),('read',0,0,F(1)),('birth',0),('source',0,1,F(1)),('read',0,1,F(1))]
+B,M,D=response(e,1,2,2);x=[F(3),F(5)];z=[F(7)]
+out,restored,births=run(e,1,2,2,x,z,D);assert out==x and restored==z and births==[(0,F(7)),(3,F(10))]
+controls={}
+controls['omit_reuse_readout']=run(e,1,2,2,x,z,D,omit=3)[0]!=x
+controls['do_not_cut_next_birth']=run(e,1,2,2,x,z,response(e,1,2,2,cut=False)[2])[0]!=x
+controls['omit_inverse_workspace']=run(e,1,2,2,x,z,D,uncompute=False)[1]!=z
+# Grouping negative source injections at the end fails after role aliasing.
+e2=[('birth',0),('birth',1),('source',0,0,F(1)),('gate',1,0,F(1)),('read',1,0,F(1)),('birth',0),('source',0,1,F(1)),('read',0,1,F(1))]
+_,_,D2=response(e2,2,2,2);z2=[F(7),F(11)]
+assert run(e2,2,2,2,x,z2,D2)[:2]==(x,z2)
+a=run(e2,2,2,2,x,z2,D2,uncompute=False)[1]
+for kind,r,s,c in reversed([v for v in e2 if v[0]=='gate']):a[r]-=c*a[s]
+for kind,r,j,c in reversed([v for v in e2 if v[0]=='source']):a[r]-=c*x[j]
+controls['group_negative_sources_at_end']=a!=z2
+# The gate/readout model forbids source-target-workspace aliasing by construction.
+assert all(controls.values())
+result=dict(status='PASS exact scalar lemma controls; no actual114 word or bound yet',cases=96,complete_source_dirty_basis_vectors=basis_checks,dense_rational_cases=96,nonzero_dependent_birth_values=dependent_nonzero_births,largest_test_response_coefficient=str(coefficient_max),rejected_controls=controls,one_slot_example=dict(source=['3','5'],dirty='7',birth_values=['7','10'],output=['3','5'],restored='7'),seconds=time.monotonic()-T0,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+Path(__file__).with_name('CHECKS.json').write_text(json.dumps(result,indent=2)+'\n');print(json.dumps(result,indent=2))
diff --git a/research/birth-read-reuse/load_graph.py b/research/birth-read-reuse/load_graph.py
new file mode 100644
index 0000000000..72118a4c86
--- /dev/null
+++ b/research/birth-read-reuse/load_graph.py
@@ -0,0 +1,31 @@
+"""Original exact reconstruction from PR117's passive operand/root witness."""
+import sys,os
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from itertools import combinations
+import json,gzip,pickle,time,resource,hashlib
+ROOT=Path(__file__).resolve().parent;REPO=Path(os.environ.get('BIRTH_REPO',ROOT.parents[1]));start=time.monotonic();resource.setrlimit(resource.RLIMIT_AS,(512*1024**2,512*1024**2));resource.setrlimit(resource.RLIMIT_CPU,(30,30))
+p=REPO/'research/deferred-replayed-117/complex-dag.json.gz';raw=p.read_bytes();assert hashlib.sha256(raw).hexdigest()=='3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b';w=json.loads(gzip.decompress(raw));h=24;tr=list(combinations(range(h),3));v=len(tr);assert (w['h'],w['v'],w['central_disjoint'],w['center_denominator'])==(24,v,24,21)
+args=[None]*(v+1);support=[0]+[1<<i for i in range(v)];core=[0]+[sum(1<<i for i in t)for t in tr];cover=core[:];rank=[0]+[1]*v;kind=[0]+[1]*v
+assert len(w['args'])==2*91770
+for a,b in zip(w['args'][::2],w['args'][1::2]):
+ x=len(args);assert type(a)is int and type(b)is int and 0<a<x and 0<b<x and not(support[a]&support[b]);args.append((a,b));support.append(support[a]|support[b]);core.append(core[a]&core[b]);cover.append(cover[a]|cover[b]);ty=1 if core[x].bit_count()>=2 else 2;kind.append(ty);rank.append(support[x].bit_count()if ty==1 else cover[x].bit_count())
+point=[sum(1<<j for j,t in enumerate(tr)if i in t)for i in range(h)];full=(1<<v)-1;roots=w['D']+w['P']+w['A'];targets=list(range(v));idx={t:i for i,t in enumerate(tr)}
+assert (len(w['D']),len(w['P']),len(w['A']))==(2024,6072,24)
+for t,x in zip(tr,w['D']):assert support[x]==full&~(point[t[0]]|point[t[1]]|point[t[2]])
+stars=[(a,b,i)for a,b in combinations(range(h),2)for i in range(h)if i not in(a,b)]
+for (a,b,i),x in zip(stars,w['P']):assert support[x]==point[a]&point[b]&~point[i];targets.append(idx[tuple(sorted((a,b,i)))])
+for i,x in enumerate(w['A']):assert support[x]==full&~point[i]and rank[x]==23;targets.append(-1)
+active=set(roots);todo=roots[:]
+while todo:
+ x=todo.pop()
+ for y in args[x]or():
+  if y not in active:active.add(y);todo.append(y)
+assert sum(args[x]is not None for x in active)==91770
+for x in active:
+ for y in args[x]or():
+  if kind[y]==kind[x]==1:assert not(core[x]&~core[y]or cover[y]&~cover[x])
+  else:assert kind[x]==2 and not cover[y]&~cover[x]
+g=dict(h=h,v=v,args=args,support=support,core=core,cover=cover,rank=rank,kind=kind,roots=roots,targets=targets,centers=w['A'],active=sorted(active));blob=pickle.dumps(g,protocol=4);(ROOT/'GRAPH.pkl').write_bytes(blob)
+out=dict(status='PASS original full-source/frame reconstruction of pinned117 DAG for118',source_sha256=hashlib.sha256(raw).hexdigest(),graph_sha256=hashlib.sha256(blob).hexdigest(),additions=91770,roots=len(roots),root_order='pair stars ascending i',seconds=time.monotonic()-start,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+(ROOT/'GRAPH_CHECK.json').write_text(json.dumps(out,indent=2)+'\n');print(json.dumps(out,indent=2))
diff --git a/research/birth-read-reuse/match_births.py b/research/birth-read-reuse/match_births.py
new file mode 100644
index 0000000000..9d94b7092f
--- /dev/null
+++ b/research/birth-read-reuse/match_births.py
@@ -0,0 +1,92 @@
+"""Bounded original paid birth-reuse screen on reconstructed118 frames."""
+import sys,os,gzip
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from collections import Counter,defaultdict
+from functools import lru_cache
+import pickle,json,time,resource,math,hashlib
+ROOT=Path(__file__).resolve().parent;start=time.monotonic();resource.setrlimit(resource.RLIMIT_AS,(512*1024**2,512*1024**2));resource.setrlimit(resource.RLIMIT_CPU,(30,30));g=pickle.loads((ROOT/'FRAMES.pkl').read_bytes());Hdim=24
+
+def basis(rows):
+ piv={}
+ for x in rows:
+  for p in sorted(piv,reverse=True):
+   if x>>p&1:x^=piv[p]
+  if x:
+   p=x.bit_length()-1
+   for q in piv:
+    if piv[q]>>p&1:piv[q]^=x
+   piv[p]=x
+ return tuple(piv[p]for p in sorted(piv,reverse=True))
+def perp(A):
+ piv={x.bit_length()-1 for x in A};out=[]
+ for j in range(24):
+  if j not in piv:
+   x=1<<j
+   for r in A:
+    if r>>j&1:x|=1<<(r.bit_length()-1)
+   out.append(x)
+ return basis(out)
+def contained(A,B):return all(not any((a&b).bit_count()%2 for a in A)for b in perp(B))
+@lru_cache(None)
+def characteristic(A):
+ k=len(A);rows=[sum(((a&b).bit_count()%2)<<j for j,b in enumerate(A))|((a.bit_count()%2)<<k)for a in A]
+ for j in range(k):
+  p=next(i for i in range(j,k)if rows[i]>>j&1);rows[j],rows[p]=rows[p],rows[j]
+  for i in range(k):
+   if i!=j and rows[i]>>j&1:rows[i]^=rows[j]
+ result=0
+ for j in range(k):
+  if rows[j]>>k&1:result^=A[j]
+ return result
+DG=defaultdict(list)
+for s,last in enumerate(g['last']):
+ if last in g['phase']and(s not in g['terminal']or s in g['center_roles']):DG[g['U'][g['holds'][s][-1]]].append(s)
+frames=sorted(DG,key=lambda F:(-len(F),F));pool=[DG[F][:]for F in frames];byB=defaultdict(list)
+for b,F in g['placed'].items():byB[F].append(b)
+allgroups=(1<<len(frames))-1
+@lru_cache(None)
+def annihilated(q):
+ mask=0
+ for i,A in enumerate(frames):
+  if all(not((a&q).bit_count()%2)for a in A):mask|=1<<i
+ return mask
+eligible={};capacity={}
+for F in byB:
+ mask=allgroups
+ for q in perp(F):
+  mask &= annihilated(q)
+  if not mask:break
+ # Do not introduce an unproved alternating residual normalization.
+ cs=characteristic(F);good=0;total=0
+ while mask:
+  bit=mask&-mask;mask-=bit;i=bit.bit_length()-1;A=frames[i]
+  if A==F or characteristic(A)!=cs:good|=bit;total+=len(pool[i])
+ eligible[F]=good;capacity[F]=total
+ if time.monotonic()-start>25:raise RuntimeError('Bounded eligibility screen capped before matching; no partial claim')
+# Deterministic most-constrained frame classes, highest-rank legal donor first.
+available=allgroups;pairs=[]
+for F in sorted(byB,key=lambda F:(capacity[F],len(F),F)):
+ for b in sorted(byB[F]):
+  mask=eligible[F]&available
+  if not mask:break
+  i=(mask&-mask).bit_length()-1;a=pool[i].pop();A=frames[i]
+  if not pool[i]:available^=1<<i
+  assert a!=b and a not in g['placed']and b not in g['touched'];assert g['last'][a]in g['phase'];assert contained(A,F)
+  assert A==F or characteristic(A)!=characteristic(F)
+  pairs.append(dict(donor=a,recipient=b,donor_frame=list(A),birth_frame=list(F),e=len(A),s=len(F),last_donor_operation=g['last'][a],source_injection_removal='true reverse chronology at full frame'))
+H=Counter(g['histogram']);v=g['v']
+for row in pairs:
+ e,s=row['e'],row['s'];H[24-e]-=2*v;H[552+s]-=2*v
+ if s>e:H[s-e]+=2*v
+assert min(H.values())>=0
+roles=len(g['first'])-len(pairs);W=2*v*v+2*v*roles;mass=sum(r*n for r,n in H.items());assert mass==576*W-1862080
+assert len({p['donor']for p in pairs})==len(pairs)==len({p['recipient']for p in pairs})
+def moment(a):return math.fsum(n*r*math.exp(a*math.log(576/r))for r,n in H.items()if n)/(576*W)
+lo,hi=0.,.001
+for _ in range(65):
+ mid=(lo+hi)/2
+ if moment(mid)<1:lo=mid
+ else:hi=mid
+res=dict(status='Author exact liveness/containment/paid-profile birth-reuse screen; scalar expansion and full reflected word still to check',source_head='ec862a5af51537495c745d9f2323e8a5736ee265',base_roles=len(g['first']),donors=sum(len(v)for v in DG.values()),donor_frame_classes=len(frames),births=len(g['placed']),matched=len(pairs),R=roles,W=W,rank=mass,deficit=1862080,child_histogram=dict(sorted((r,n)for r,n in H.items()if n)),match_ranks=dict(Counter(f"{r['e']}->{r['s']}"for r in pairs)),new_positive_residuals_nonalternating=True,root_float_screen=(lo+hi)/2,zero_rank_merge_records=sum(r['e']==r['s']for r in pairs),pairs=pairs,source_frame_checkpoint_sha256=hashlib.sha256((ROOT/'FRAMES.pkl').read_bytes()).hexdigest(),seconds=time.monotonic()-start,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+(ROOT/'BIRTH_MATCHES.json.gz').write_bytes(gzip.compress((json.dumps(res,indent=2)+'\n').encode(),mtime=0));print(json.dumps({k:v for k,v in res.items()if k not in('pairs','child_histogram','match_ranks')},indent=2))
diff --git a/research/birth-read-reuse/readout_cost.py b/research/birth-read-reuse/readout_cost.py
new file mode 100644
index 0000000000..a5b3bc5075
--- /dev/null
+++ b/research/birth-read-reuse/readout_cost.py
@@ -0,0 +1,70 @@
+"""Original exact signed integer dirty-readout responses and literal unit bill.
+All coefficients are represented over42 by unsigned bitplanes; no modular test.
+"""
+import sys,os
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+from pathlib import Path
+from functools import reduce
+from operator import or_
+from itertools import combinations
+import pickle,json,time,resource,hashlib
+ROOT=Path(__file__).resolve().parent;start=time.monotonic();resource.setrlimit(resource.RLIMIT_AS,(512*1024**2,512*1024**2));resource.setrlimit(resource.RLIMIT_CPU,(30,30))
+g=pickle.loads((ROOT/'FRAMES.pkl').read_bytes());R=len(g['first']);v=g['v'];N=v*v;allbits=(1<<v)-1;tr=list(combinations(range(24),3));point=[sum(1<<j for j,t in enumerate(tr)if i in t)for i in range(24)]
+def scaled(mask,n):return tuple(mask if n>>i&1 else 0 for i in range(n.bit_length()))
+def plus(a,b):
+ out=[];carry=0
+ for i in range(max(len(a),len(b))):
+  x=a[i]if i<len(a)else 0;y=b[i]if i<len(b)else 0;out.append(x^y^carry);carry=(x&y)|(x&carry)|(y&carry)
+ if carry:out.append(carry)
+ while out and not out[-1]:out.pop()
+ return tuple(out)
+def absdiff(a,b):
+ out=[];borrow=0
+ for i in range(max(len(a),len(b))+1):
+  x=a[i]if i<len(a)else 0;y=b[i]if i<len(b)else 0;out.append(x^y^borrow);borrow=((~x&(y|borrow))|(y&borrow))&allbits
+ neg=borrow;carry=neg;absolute=[]
+ for x in out:
+  y=x^neg;absolute.append(y^carry);carry=y&carry
+ assert not carry
+ while absolute and not absolute[-1]:absolute.pop()
+ return tuple(absolute),neg
+P=[()]*R;M=[()]*R
+for s,j in g['terminal'].items():
+ if j>=len(g['roots'])-24:
+  i=j-(len(g['roots'])-24);P[s]=scaled(allbits^point[i],2);M[s]=scaled(point[i],19)
+ elif j<v:P[s]=scaled(1<<g['targets'][j],21)
+ else:M[s]=scaled(1<<g['targets'][j],21)
+seeds=(P[:],M[:]);source_ops=0;workspace_ops=0
+for op,s,t,x in reversed(g['ops']):
+ if op==0:source_ops+=1;continue
+ workspace_ops+=1
+ a,b=(t,s)if op==1 else(s,t);P[a]=plus(P[a],P[b]);M[a]=plus(M[a],M[b])
+# Check the carry/subtract primitives exactly on adversarial small masks.
+for a in range(80):
+ for b in range(80):
+  z,neg=absdiff(scaled(1,a),scaled(1,b));assert sum((1<<i)for i,w in enumerate(z)if w&1)==abs(a-b);assert bool(neg&1)==(a<b)
+count=weight=maximum=0;max_role=-1;digest=hashlib.sha256();dense_reached=0
+for s,(a,b)in enumerate(zip(P,M)):
+ z,neg=absdiff(a,b);nonzero=reduce(or_,z,0);count+=nonzero.bit_count();weight+=sum(w.bit_count()*(1<<i)for i,w in enumerate(z))
+ candidates=nonzero;maxhere=0
+ for i in range(len(z)-1,-1,-1):
+  if candidates&z[i]:maxhere|=1<<i;candidates &= z[i]
+ if maxhere>maximum:maximum=maxhere;max_role=s
+ # Pin full exact responses, including zero coefficients and signs.
+ digest.update(s.to_bytes(4,'little'));digest.update(len(z).to_bytes(4,'little'));digest.update(neg.to_bytes((v+7)//8,'little'))
+ for w in z:digest.update(w.to_bytes((v+7)//8,'little'))
+ if s in g['placed']:
+  # Deferred origin has no center contribution; every actual target is in the conservative reach set.
+  assert not(nonzero&~g['reach'][s]);dense_reached+=nonzero.bit_count()
+terminal_weight=0;terminal_count=0
+for a,b in zip(*seeds):
+ z,_=absdiff(a,b);terminal_weight+=sum(w.bit_count()*(1<<i)for i,w in enumerate(z));terminal_count+=reduce(or_,z,0).bit_count()
+# A read divides a computed complete copy by42 and uses signed unit adds.
+# Eight scans per origin/terminal covers copy, division, parking and discard.
+read_bill=weight+terminal_weight+8*(R+len(g['terminal']))
+# True chronological forward/inverse injections and workspace gates; finite slot bookkeeping.
+local=read_bill+2*(source_ops+workspace_ops)+16*R+16*24
+# A factor16 additionally covers phase/sign wrappers and implementation scans.
+G=16*(2*v*local+8*N)
+record=dict(status='PASS exact integer old-readout response and explicit conservative scalar bill; no <=1 coefficient assumption',denominator=42,readout_nonzero_terms=count,readout_numerator_L1=weight,max_abs_numerator=maximum,max_abs_coefficient=f'{maximum}/42',max_role=max_role,deferred_readout_terms=dense_reached,terminal_terms=terminal_count,terminal_numerator_L1=terminal_weight,source_injection_count=source_ops,workspace_gate_count=workspace_ops,readout_copy_scan_bill=read_bill,local_scalar_upper=local,global_scalar_group_upper=G,expansion='At each readout, form one complete computed copy divided by42, then |numerator| signed unit additions to targets. Reverse all workspace/source gates chronologically. Factor16 and explicit endpoint groups bound scalar bookkeeping/wrappers.',odd_grid='Denominator42=2*21; retain common odd21 grid with per-local-word G and completed-child preservation.',exact_response_sha256=digest.hexdigest(),seconds=time.monotonic()-start,rss_KiB=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
+blob=pickle.dumps(dict(positive=P,negative=M,terminal_positive=seeds[0],terminal_negative=seeds[1]),protocol=4);(ROOT/'READOUTS.pkl').write_bytes(blob);record['checkpoint_sha256']=hashlib.sha256(blob).hexdigest();(ROOT/'READOUT_COST.json').write_text(json.dumps(record,indent=2)+'\n');print(json.dumps(record,indent=2))
diff --git a/research/birth-read-reuse/run_checks.py b/research/birth-read-reuse/run_checks.py
new file mode 100644
index 0000000000..c0356625c6
--- /dev/null
+++ b/research/birth-read-reuse/run_checks.py
@@ -0,0 +1,25 @@
+"""Run original checks in a temporary directory, preserving all frozen inputs."""
+import sys,os,json,gzip,hashlib,tempfile,shutil,subprocess
+from pathlib import Path
+if sys.flags.optimize or os.environ.get('PYTHONOPTIMIZE'):raise RuntimeError('Assertions required')
+ROOT=Path(__file__).resolve().parent;REPO=Path(os.environ.get('BIRTH_REPO',ROOT.parents[1])).resolve()
+for name,digest in json.loads((ROOT/'BASE_INPUTS.json').read_text())['files'].items():
+ if hashlib.sha256((REPO/name).read_bytes()).hexdigest()!=digest:raise ValueError('Changed base input: '+name)
+keys={'BIRTH_MATCHES.json.gz':['R','W','rank','matched','child_histogram','pairs'], 'READOUT_COST.json':['readout_nonzero_terms','readout_numerator_L1','max_abs_numerator','global_scalar_group_upper','exact_response_sha256'], 'BIRTH_AUDIT.json':['matches','physical_original_roles','word_blocks','forward_frame_transitions','reverse_frame_transitions','all_histogram_bins_match','forward_word_sha256','reverse_word_sha256']}
+def read(p):return json.loads(gzip.decompress(p.read_bytes())if p.suffix=='.gz'else p.read_text())
+with tempfile.TemporaryDirectory(prefix='birth-read-reuse-')as temp:
+ work=Path(temp)
+ for p in ROOT.iterdir():
+  if p.is_file():shutil.copyfile(p,work/p.name)
+ env=dict(os.environ,BIRTH_REPO=str(REPO))
+ for program in ['check_birth_lemma.py','load_graph.py','build_roles.py','build_frames.py','match_births.py','readout_cost.py','audit_birth_frames.py']:
+  subprocess.run([sys.executable,str(work/program)],env=env,check=True,timeout=40)
+ for name,fields in keys.items():
+  got,want=read(work/name),read(ROOT/name)
+  for field in fields:
+   if got[field]!=want[field]:raise ValueError(('Changed scientific result',name,field))
+ # Assembly binds the exact frozen receipts, not run-dependent timing fields.
+ for name in ['BIRTH_MATCHES.json.gz','READOUT_COST.json']:shutil.copyfile(ROOT/name,work/name)
+ subprocess.run([sys.executable,str(work/'check_assembly.py')],env=env,check=True,timeout=10)
+ if read(work/'CANDIDATE.json')!=read(ROOT/'CANDIDATE.json'):raise ValueError('Changed exact candidate')
+print('PASS all author checks; frozen package unchanged; no upstream code executed')
diff --git a/research/cube-deferred/PROOF.md b/research/cube-deferred/PROOF.md
new file mode 100644
index 0000000000..27e7e066e3
--- /dev/null
+++ b/research/cube-deferred/PROOF.md
@@ -0,0 +1,9 @@
+# Conditional extension and review boundary
+
+The changed component is a scalar producer, not a new multiplication reduction. Fix h=24, the same 2,024 triple variables, retained coordinate hyperplanes and divisor21 as PR114. For three paired groups, PR115's cube recurrence groups the eight surviving-subset contributions into two four-output planes, combining the plane without the third coordinate and the appropriate plane containing it. Each plane is a partition into disjoint source supports. All additions are therefore ordinary disjoint sums with coefficient1; interning equal supports changes sharing, not the linear map. The cube implementation and its dependencies retain icekylinx's source attribution.
+
+Within those planes and contracted pair calls, retain PR114's balanced column coarse sums and core-aware pair assembly. The final pair-star leave-one-out outputs retain PR111/55's dual-suffix identities. Retained center outputs are computed after restoring inherited class methods, exactly as in the selected implementation. The resulting selected source map is verified for every triple output, every pair-star output and all24 centers, not just sampled values. Every scalar-to-target correction remains (j-1+[j=0]-[j=2])/2 for intersection size j, hence equals the diagonal identity.
+
+The unchanged PR114 compiler builds an explicit legal carrier matching and chronological role word. It checks full root values, two arbitrary-data/scratch replays, every lifted-frame containment and nondegeneracy condition, untouched-center dependency cuts, deferred target nesting and all source/target chains. The independent PR114 reflection audit additionally checks integer source coefficients, the old-value transpose, the literal inverse/sign-negate/bank-swap word, complemented frame incidences and the complete reflected histogram, with three adversarial mutations. These finite checks establish the stated local extension only; simultaneous rational bases, routing/recovery, stopped atom streaming, translated endpoint gauges, analytic estimates and fixed-tape interfaces remain inherited assumptions.
+
+The full physical histogram is recomputed from actual chains. Its rank mass must equal Wm-N+L. The ordinary bit profile is unchanged and regenerated from the two SHA-bound Swapnil round-seven inputs. Scalar guard G includes literal expanded readouts according to PR114's conservative bound; no free basis transform or omitted cleanup is introduced. Exact rational moment enclosures reject the next bit and complex grid points. The retained assembly checks all47 strict constraints and seven margins and rejects the next final grid point. PR114's old complete complex profile must fail at the new complex saving. A finite search does not prove global optimality.
diff --git a/research/cube-deferred/README.md b/research/cube-deferred/README.md
new file mode 100644
index 0000000000..62ee5b270c
--- /dev/null
+++ b/research/cube-deferred/README.md
@@ -0,0 +1,18 @@
+# Cube recurrence with balanced core pairs and deferred readouts
+
+Conditional κ = **49349675169/500000000000000 = 9.8699350338×10⁻⁵**, approximately **4.17409% above PR114** (9.4744627892×10⁻⁵). The strict complex saving is 98718939/10¹²; the retained stopped bit saving is 1240189553/10¹³.
+
+This composes icekylinx's PR115 pair-first cube recurrence with eumemic's PR114 balanced core-aware pair subproblems, Rohan Arun's PR111 dual-suffix pair stars, and Avi Eisenberg's PR110 lifted/deferred compiler. The cube recurrence replaces the entire triple-exclusion recurrence. Its outputs are assembled from the same disjoint coefficient partitions, so the existing producer checks all scalar supports and frame inclusions. The selected circuit has 70,252 additions, 8,120 roots, 42,694 legal matched carriers, 35,678 roles and 4,909 deferred roles. PR114 has 37,859 roles; a smaller role count alone is not used to claim improvement.
+
+The bit supplier is unchanged. All copied-center transforms, auxiliary exteriors, source and target fronts, data residuals, endpoint corrections, scalar work and three row reserves remain paid. In particular, this retains PR114's conservative expanded-readout scalar charge. The complete complex histogram and exact moments determine the comparison.
+
+The implementation deliberately preserves the tested producer's two construction phases: the initial CubeTriple output construction uses PR114 core-pair/vector overrides; after the overrides are removed, the retained center outputs use the inherited CubeTriple/IntervalTriple methods. Both sets of selected roots are checked together by the complete scalar and frame compiler.
+
+```sh
+python3 research/cube-deferred/verify.py
+make verify
+```
+
+Draft status: forward arbitrary-scratch replay, exact nondegenerate nested frames, complete histogram and exact assembly passed in the independent exploration. The independent exact integer/scalar and literal complemented reflection audit also passed, including its three mutations. Repository-wide verification remains pending. Read the current validation receipt when one is added. No claim of an unconditional theorem, global optimality or measured runtime improvement is made.
+
+See [PROOF.md](PROOF.md). Credits: icekylinx (PR115 cube recurrence; PR104 stopped products), eumemic (PR114 balanced core pairs, independent reflection verifier and conservative scalar accounting), Avi Eisenberg/ikeboy (PR62/110 primitives and deferred compiler, Claude assistance), Rohan Gupta/gupt1156 (PR55 dual-suffix identity), Rohan Arun (PR111/113, Claude assistance), Swapnil Jain (frozen round-seven deferred bit word), Zhihao Chen/jacklightChen, RaD/hipotures, Aurel Prosz/Paureel, Douglas Colkitt, OpenAI and all inherited contributors. Imported Apache-2.0 code retains original notices. This integration was prepared by Rohan Arun with OpenAI Codex assistance.
diff --git a/research/cube-deferred/SOURCE.json b/research/cube-deferred/SOURCE.json
new file mode 100644
index 0000000000..ca1f9054e7
--- /dev/null
+++ b/research/cube-deferred/SOURCE.json
@@ -0,0 +1,69 @@
+{
+  "attribution": "Avi Eisenberg / ikeboy (PR62 and PR110, Anthropic Claude assistance); Rohan Arun (PR111, Anthropic Claude assistance); Swapnil Jain (round-seven bit word); icekylinx (retained stopped-product, copied-center and finite assembly interfaces); Zhihao Chen and RaD (retained assembly). Core-aware pair transfer, integration and verification for eumemic with OpenAI Codex assistance. Original source notices remain authoritative.",
+  "package_files": {
+    "PROOF.md": "cf0463a037196fe1ed60e45c68c6d8b9d127f1dd1e47aad52830cdbc87e154f4",
+    "README.md": "077ac390b09a40554c01ee087d340df3b886dc66aa95dc15fc609b4061ccd659",
+    "bit-profile.json": "7293f330518b78650bd86d76b93681e43f3a55541cdb8110993714148a4b4a6a",
+    "bit_round7.py": "35d261a9248c2e06f9179e3c47e554a96b8fe763a9a3de2731256b8c0fbc74b0",
+    "certificate.json": "aa2d182046cbf7aa45a42d79f902ed577e30b2027b969c1e35500d742a198445",
+    "certificate.py": "441b727a07466388456205deec685a52bb464bbb50dce2a2b27cf3decd98e10d",
+    "complex-profile.json": "56fd54d316129d90c4c91d500f38afa712434e5622ee6ea3b20fa795f8424680",
+    "complex_deferred.py": "6bea79108859a98523b3fc8ad9d374f28209c2d4fdf71b6edfc4ca685acfc3ad",
+    "core_pair_block.py": "b97da88c5635688859b3330b66dd64756e28e3713da88954d519f8ea3a3f9568",
+    "cube115.py": "afad64cbea7f943a9a87233576aaf1a94ff0270ad853d1f8b4df7b12144914e2",
+    "inputs/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+    "inputs/witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+    "interval115.py": "b85106476cd041e2b85e884beee0beeaf850d32f61c22d091ce1beb8238dbd40",
+    "producer.py": "79e106a35b42d9ea07f4353933a477f3a3c3a08192724f45763667a458e8f795",
+    "reflection-audit.json": "306a8090c9fcf5c2f6f14e7837f8e6c82137f4df7c11fa95895e673cc3a2eb5e",
+    "reflection_audit.py": "7f534ddc406b1454f71831790b0f519007fa4120a025a30fe162ef9c9215a9d7",
+    "test_controls.py": "264f5c3e7de6bb5ba4d4205b8480ee3c6ae91054fe6128ed05e42da083f84384",
+    "verify.py": "c78e5cc09ee08c3de54aee969f69f31433281cd000e1e5b2f7b6fb3845a08b86"
+  },
+  "provenance": {
+    "base": "https://github.com/CrocSwap/integer-mult-bounds/pull/114",
+    "base_commit": "51cd8934128be37830981ca391d3d6fd28b0fce8",
+    "core_aware_pair_assembly": "https://github.com/CrocSwap/integer-mult-bounds/pull/62",
+    "cube": "https://github.com/CrocSwap/integer-mult-bounds/pull/115",
+    "cube_commit": "cf60442983c153a3a0f5272ea4713f99eba13c86",
+    "cyclic_strips": "https://github.com/CrocSwap/integer-mult-bounds/pull/111",
+    "round7_commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+    "round7_repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+    "round7_sha256": {
+      "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+      "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588"
+    }
+  },
+  "reflection": {
+    "receipt": "reflection-audit.json",
+    "script": "reflection_audit.py"
+  },
+  "repository_files": {
+    "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf",
+    "research/cyclic-deferred/complex-profile.json": "6b6c8a40a1d27cd792e12feb42baba91d792caafe49c476527b3ce79511c7da5",
+    "scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1",
+    "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e",
+    "scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f",
+    "scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1",
+    "scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b",
+    "scripts/copied_centers/__init__.py": "13db4f09038a2ff5335cbd4dbd93274b0fb16b3c7b51e4de67cbb2801a3f78e1",
+    "scripts/copied_centers/corners.py": "9eecdc39c67cc18c806a33f0be03986c28591d322881fd60c11f52c625c8067b",
+    "scripts/copied_centers/physical.py": "837345d1f8753eab0e70f105b1d1bb0db965b993da037b1825ddef3672609d7d",
+    "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9",
+    "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0",
+    "scripts/fast_gaussian.py": "11430c2df0783b933dc91080595bb7514bb052b8c7b12107e27a1ef701e31e43",
+    "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2",
+    "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7",
+    "scripts/paired_triple_circuit.py": "8f5f2de32fdbd8e0005154638660ff416e5a8cd59623bd0dc03f6f7f97ce2fb1",
+    "scripts/partial_swap/__init__.py": "0438eaa34134600467a5864f93c3e15142eb025b35cef189c2e969cffea72a7f",
+    "scripts/partial_swap/binary.py": "d32d7a23548cc738e974e8e55dd1fa2a8b11d2b80228515617ffe35410bb8805",
+    "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782",
+    "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947",
+    "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a",
+    "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba",
+    "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697",
+    "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d"
+  },
+  "schema": 1,
+  "scope": "Frozen finite producer, profiles, exact assembly and reflection audit; inherited all-size transfer remains conditional."
+}
diff --git a/research/cube-deferred/bit-profile.json b/research/cube-deferred/bit-profile.json
new file mode 100644
index 0000000000..36105e819a
--- /dev/null
+++ b/research/cube-deferred/bit-profile.json
@@ -0,0 +1,69 @@
+{
+ "h": 23,
+ "v": 1771,
+ "R": 28866,
+ "m": 529,
+ "N": 3136441,
+ "W": 108516254,
+ "L": 1792252,
+ "total_rank": 57403754177,
+ "deficit": 1344189,
+ "maxchild": 528,
+ "deferred_slots": 11565,
+ "source": {
+  "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+  "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+  "sha256": {
+   "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+   "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c"
+  }
+ },
+ "child_multiplicities": {
+  "1": 239511811,
+  "2": 238288050,
+  "3": 53377940,
+  "4": 46970462,
+  "5": 23632224,
+  "6": 7409864,
+  "7": 4105178,
+  "8": 5755750,
+  "9": 2082696,
+  "10": 878416,
+  "11": 1388464,
+  "12": 1080310,
+  "13": 945714,
+  "14": 226688,
+  "15": 2451064,
+  "16": 1508892,
+  "17": 4771074,
+  "18": 2149994,
+  "19": 7367360,
+  "20": 8182020,
+  "21": 1466388,
+  "22": 88550,
+  "484": 6272882,
+  "506": 61280142,
+  "507": 545468,
+  "508": 173558,
+  "509": 293986,
+  "510": 580888,
+  "511": 14168,
+  "512": 322322,
+  "513": 17710,
+  "514": 1129898,
+  "515": 127512,
+  "516": 410872,
+  "517": 99176,
+  "518": 1186570,
+  "519": 340032,
+  "520": 322322,
+  "521": 106260,
+  "522": 1583274,
+  "523": 626934,
+  "524": 2854852,
+  "525": 13711082,
+  "526": 4629394,
+  "527": 5653032,
+  "528": 6233920
+ }
+}
diff --git a/research/cube-deferred/bit_round7.py b/research/cube-deferred/bit_round7.py
new file mode 100644
index 0000000000..3c5df409a6
--- /dev/null
+++ b/research/cube-deferred/bit_round7.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""One-child bit profile of Swapnil Jain's round-seven deferred word (h=23), under PR104's opposite-bank rule.
+
+Reads the two frozen round-seven data files (vendored in inputs/; pinned by SHA-256 below) from a directory given on
+the command line, e.g. a checkout of https://github.com/Swapnil-jain/integer-mult-kappa at
+741e7aa078392553815df7926ee17ac5e25a8c38 (certificates/round7/), or PR97's imported copy
+(research/deferred-signed/swapnil-round7/certificates/round7/). The frame dimensions are the ones recorded in
+the data file; Swapnil's check_frames.py re-derives each of them exactly and PR97 replays the word.
+
+Every projector residual of rank r is one child of width r (PR104, notes/stopped-product-factorization.tex):
+  each slot: its chain steps from the deferral frame sigma_u to F, and one exterior child m - (h - dim sigma_u);
+  each retained centre: one copied transform of width h-1;
+  each target y_T: its chain 0 -> deferred readout levels -> t_T^perp;  each data wire X_S: its chain of V frames;
+  each data pair: one data residual of width (h-1)^2 and one endpoint copy.
+Usage: python3 research/deferred-stopped/bit_round7.py DIR      (writes bit-profile.json next to this file)
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance. Apache-2.0.
+"""
+import gzip
+import hashlib
+import json
+import sys
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PINS = {'witness_23.json.gz': 'b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588',
+        'deferred_23.json.gz': '8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c'}
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def main(directory):
+    data = {}
+    for name, digest in PINS.items():
+        raw = (Path(directory) / name).read_bytes()
+        require(hashlib.sha256(raw).hexdigest() == digest, 'pinned hash of ' + name)
+        data[name] = json.loads(gzip.decompress(raw))
+    W, D = data['witness_23.json.gz'], data['deferred_23.json.gz']
+    h = D['h']; R = D['R']; trip = list(combinations(range(h), 3)); v = len(trip); m = h * h; N = v * v
+    tid = {T: i for i, T in enumerate(trip)}
+    args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()}
+    late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()}
+    ops = [tuple(o[:2]) + (tuple(o[2]),) if o[0] == 'fan' else tuple(o) for o in D['ops']]
+    hold, start = D['hold'], D['start']
+    out = {s: (c, tuple(T)) for s, c, T in D['out']}; ret = {s: c for s, c in D['ret']}
+    sigma = dict(zip(D['readout_order'], D['sigma'])); sel = set(D['readout_order'])
+    f = [0] * R
+    for s, B in sigma.items(): f[s] = len(B)
+    vstart = dict(zip(D['vleaf_slots'], D['vleaf_start']))
+    node_dims = {n: d for n, d in D['node_dims']}
+    late_dims = {(n, tuple(lt)): d for n, lt, d in D['late_dims']}
+    pivslot = {o[3]: o[1] for o in ops if o[0] == 'add'}
+
+    def start_key(s):
+        n0 = hold[s][0]
+        if args[n0] is None: return ('v', s)
+        st = start[s]; k = st[2] if len(st) > 2 else None; dec = late.get(n0)
+        if dec is None or k in dec[0]: return ('n', n0)
+        lt = dec[1]; return ('c', n0, tuple(lt[lt.index(k):]))
+
+    def chain(s):
+        ch = [('sigma', s) if s in sel else ('0',), start_key(s)]
+        for idx, n in enumerate(hold[s]):
+            if idx > 0: ch.append(('n', n))
+            if args[n] is not None and pivslot.get(n) == s and n in late:
+                lt = late[n][1]
+                for i in range(len(lt) - 1): ch.append(('c', n, tuple(lt[i:])))
+        if s in out: ch.append(('out',))
+        if s in ret: ch.append(('ret',))
+        ch.append(('F',)); return ch
+
+    def dim(key):
+        k = key[0]
+        if k == '0': return 0
+        if k == 'F': return h
+        if k in ('out', 'ret'): return h - 1
+        if k == 'n': return node_dims[key[1]]
+        if k == 'c': return late_dims[key[1], key[2]]
+        if k == 'sigma': return f[key[1]]
+        if k == 'v': return len(vstart[key[1]])
+        raise KeyError(key)
+
+    # garbage supports (transpose sweep) for the deferred levels on each target
+    cov = [set() for _ in range(R)]
+    for s, (c, T) in out.items(): cov[s].add(tid[T])
+    for s, c in ret.items(): cov[s].update(t for t, T in enumerate(trip) if c in T)
+    for o in reversed(ops):
+        if o[0] == 'add': cov[o[2]] |= cov[o[1]]
+        elif o[0] == 'fan':
+            for g in o[2]: cov[o[1]] |= cov[g]
+    levels = defaultdict(set)
+    for s in sel:
+        for t in cov[s]: levels[t].add(f[s])
+
+    z = Counter()
+    for s in range(R):
+        ds = [dim(k) for k in chain(s)]
+        require(all(b >= a for a, b in zip(ds, ds[1:])) and ds[-1] == h, 'monotone chain %d' % s)
+        for a, b in zip(ds, ds[1:]):
+            if b > a: z[b - a] += 2 * v
+        z[m - (h - f[s])] += 2 * v
+    z[h - 1] += 2 * v * h
+    for t in range(v):
+        ls = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ls, ls[1:]): z[b - a] += 2 * v
+    for n, us in D['xs_order']:
+        ds = [1] + [len(vstart[s]) for s in us] + [h]
+        ds = [d for i, d in enumerate(ds) if i == 0 or d != ds[i - 1]]
+        require(all(b > a for a, b in zip(ds, ds[1:])), 'data-wire chain')
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v
+    z[(h - 1) ** 2] += 2 * N
+    z[1] += N
+    Wb = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = Wb * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'bit rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    prof = dict(h=h, v=v, R=R, m=m, N=N, W=Wb, L=L, total_rank=s_, deficit=N - L, maxchild=max(z),
+                deferred_slots=len(sel), source=dict(repository='https://github.com/Swapnil-jain/integer-mult-kappa',
+                commit='741e7aa078392553815df7926ee17ac5e25a8c38', sha256=PINS),
+                child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'bit-profile.json').write_text(json.dumps(prof, indent=1) + '\n')
+    print('PASS bit: R=%d, deferred slots %d, maxchild %d, rank mass %d' % (R, len(sel), max(z), s_))
+
+
+if __name__ == '__main__':
+    main(sys.argv[1] if len(sys.argv) > 1 else '.')
diff --git a/research/cube-deferred/certificate.json b/research/cube-deferred/certificate.json
new file mode 100644
index 0000000000..cbce9a75d5
--- /dev/null
+++ b/research/cube-deferred/certificate.json
@@ -0,0 +1,321 @@
+{
+  "status": "Finite conditional cyclic/deferred witness",
+  "kappa": "49349675169/500000000000000",
+  "complex_saving": "98718939/1000000000000",
+  "coarse_bit_saving": "620523/5000000000",
+  "actual_bit_saving": "1240189553/10000000000000",
+  "bit_parameter": "98718840271061/1000000000000000000",
+  "complex_profile": {
+    "h": 24,
+    "v": 2024,
+    "additions": 70252,
+    "roots": 8120,
+    "links": 42694,
+    "R": 35678,
+    "m": 576,
+    "N": 4096576,
+    "W": 152617696,
+    "L": 2234496,
+    "total_rank": 87905930816,
+    "deficit": 1862080,
+    "maxchild": 574,
+    "phase_one_ops": 18517,
+    "phase_one_roles": 15404,
+    "deferred_roles": 4909,
+    "deferred_dims": {
+      "1": 4,
+      "2": 45,
+      "4": 60,
+      "5": 1,
+      "6": 39,
+      "8": 79,
+      "10": 241,
+      "12": 348,
+      "13": 1,
+      "14": 234,
+      "15": 1,
+      "16": 218,
+      "17": 1,
+      "18": 1511,
+      "19": 682,
+      "20": 236,
+      "21": 225,
+      "22": 983
+    },
+    "lifted_additions": 34513,
+    "replay": {
+      "seeds": [
+        1,
+        2
+      ],
+      "scratch_restored": true,
+      "y_plus_x": true,
+      "field": "Z/(2^61-1)"
+    },
+    "child_multiplicities": {
+      "1": 289160784,
+      "2": 238698416,
+      "3": 41451520,
+      "4": 67346576,
+      "5": 32064208,
+      "6": 32238272,
+      "7": 14451360,
+      "8": 14831872,
+      "9": 7549520,
+      "10": 10423600,
+      "11": 4849504,
+      "12": 8816544,
+      "13": 4602576,
+      "14": 12297824,
+      "15": 5505280,
+      "16": 8468416,
+      "17": 8828688,
+      "18": 9541136,
+      "19": 9367072,
+      "20": 4748304,
+      "21": 3149344,
+      "22": 6108432,
+      "23": 8322688,
+      "529": 8193152,
+      "552": 124552912,
+      "553": 16192,
+      "554": 182160,
+      "556": 242880,
+      "557": 4048,
+      "558": 157872,
+      "560": 319792,
+      "562": 975568,
+      "564": 1408704,
+      "565": 4048,
+      "566": 947232,
+      "567": 4048,
+      "568": 882464,
+      "569": 4048,
+      "570": 6116528,
+      "571": 2760736,
+      "572": 955328,
+      "573": 910800,
+      "574": 3979184
+    }
+  },
+  "bit_profile": {
+    "h": 23,
+    "v": 1771,
+    "R": 28866,
+    "m": 529,
+    "N": 3136441,
+    "W": 108516254,
+    "L": 1792252,
+    "total_rank": 57403754177,
+    "deficit": 1344189,
+    "maxchild": 528,
+    "deferred_slots": 11565,
+    "source": {
+      "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+      "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+      "sha256": {
+        "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+        "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c"
+      }
+    },
+    "child_multiplicities": {
+      "1": 239511811,
+      "2": 238288050,
+      "3": 53377940,
+      "4": 46970462,
+      "5": 23632224,
+      "6": 7409864,
+      "7": 4105178,
+      "8": 5755750,
+      "9": 2082696,
+      "10": 878416,
+      "11": 1388464,
+      "12": 1080310,
+      "13": 945714,
+      "14": 226688,
+      "15": 2451064,
+      "16": 1508892,
+      "17": 4771074,
+      "18": 2149994,
+      "19": 7367360,
+      "20": 8182020,
+      "21": 1466388,
+      "22": 88550,
+      "484": 6272882,
+      "506": 61280142,
+      "507": 545468,
+      "508": 173558,
+      "509": 293986,
+      "510": 580888,
+      "511": 14168,
+      "512": 322322,
+      "513": 17710,
+      "514": 1129898,
+      "515": 127512,
+      "516": 410872,
+      "517": 99176,
+      "518": 1186570,
+      "519": 340032,
+      "520": 322322,
+      "521": 106260,
+      "522": 1583274,
+      "523": 626934,
+      "524": 2854852,
+      "525": 13711082,
+      "526": 4629394,
+      "527": 5653032,
+      "528": 6233920
+    }
+  },
+  "bit_moment_gap": "210811394225115117568018038513239592855337768061996351784199300828041381607148420475711921673436778332750996651783152394205578153858435663243959795913385215868392831844509655226993164072062830500832781615792327068936897853818968534771730481866850519439187068953062899333771640996075361901014500735179763112430083120460814689994116646689670445286414265265018468311435502209195246240538069975559360544007937885404793780372701951022292660282948582656517071290400479729799954952580125532795274568021525151839594883237275569314958070368193662075730567130277424969924134425921633872848924585639423998410253779062359718371205767101510073996880454144801457072151080008705648366603197414406872289670642046369219405455128737300640897667220951127018547660455087533581513233999285275099394371781290865408274484542745086391849285198194905751058992419590161634431610100995441112613134240446609058758039909343152776920263419910572835208525277494067408376961456317/225678505065634612156474913616400633538202019254665477026878220214422133931127460164253533068001699469116755578965090566731480236912032281717920888140691998261537790258547549397061712443744511202265657747547567084090291301783866427704803156891369853685579999500594559805069402727752752227038426964007028952158078563045054314475625278140097385695241851533235641996467089273692960018822280793234080014352234618229252999217015923728814468917104222554059646947960375336061268431587018084270516494408656203498548153054913267707164839939006583338918817922618882667407408888179421052689449193499742148706302504238261936554897181289081072466758282367100305194479622149878636307463869297507337915811001244472279386614413535081936912313821531543735588465392499062010570720287729070905437080967709221039366272598541269000920375996285867953823816142239661027100714288630069735295241672325865922423925213948613346461034734632365263739073012128769510020000000000000000000000",
+  "complex_moment_gap": "8713002844707470603810572602811292071491073861680845100468422371355958805664066456911340430581799759600275009891823114363455829566580551875226631915385552312120196234612200803204747207581360283870615890933973275541564754841444929880722876454538980847382880418521125090192737893482026319811048890579527952283973971770565808566874123052772783728880396398501453926792854413801375581070904150758646234078385074698384766042470679842764127343147308702721937377031942962483179809457278468728016243855770540660748546130943436758631451390487721642687040141070692725038546160870511261869754088334985065355083171789000779136720105840161036647076727518225343113560482305684073025864624378546056184784682494133791860301459307496815192457520304549554230482449793458763471948201700244472296795468366154352663969582175552823611715631240040844525868091672812638299169911214584495614265716706603859560014103057335754226573090926347153532213808307662065799694509789753747254605469698072651442614773968667354348480268789577707428337/82004595540487109222410472477584395055225491990612804025505949409210739120479669585422360259650556631013333007897240375010898496811585023796883493143444442230421442067579096095992625288692678084097364687380712500354565103444673005468571785486668403984361592817616412790231595283157179174295196417719561001023285211289278916124290564007327793841455387378435404548160415050113934008394722146017891540035448075876605319966074939051969777457326758978562797928706674129126199967346585226840774785239700506261422039149360933383141939946634909499491199165047645095133906172497002898943912030078641043695394060930799110997796118255678267900941808208143351080782964611532545791013666853036267576749951161024850609430651823565128566811916696237249601001826588863053163566178603319010010171194364183773308589146646653448901324852152074358769410805096463824695542692196738974692473208326683945740548009619928898866419895976538089696888620694630599254827899786029946953622959760066903810758504244456789924369830656000000000000000000000000",
+  "finite_bridge": {
+    "complex": {
+      "m": 576,
+      "W": 152617696,
+      "s": 87905930816,
+      "maxchild": 574,
+      "halving_degree": 200,
+      "wire_bits": 28,
+      "scalar_terms": [
+        {
+          "h": 24,
+          "v": 2024,
+          "c": 70252,
+          "R": 35678,
+          "q": 8120,
+          "invocations": 2024,
+          "local_group_upper": 17730568072,
+          "description": "Expanded deferred readouts and forward/inverse/reflected words"
+        },
+        {
+          "h": 24,
+          "v": 2024,
+          "c": 70252,
+          "R": 35678,
+          "q": 8120,
+          "invocations": 2024,
+          "local_group_upper": 17730568072,
+          "description": "Expanded deferred readouts and forward/inverse/reflected words"
+        }
+      ],
+      "scalar_group_upper": 71773343652032
+    },
+    "semantic": {
+      "E": 23663134977676537687468327305713605031848000,
+      "literal_charge": 3343512570701091329748038698372,
+      "strict_literal_gap": 23663134977673194174897626214383856993149628,
+      "B": 23663134977676537687468327305713692937778816,
+      "C0": 10320887014903089483460091488744256300011976338006629722006596843490496619188358441485729792,
+      "C1": 1,
+      "induction_gap": 70989404933029613062404981917141078813336448,
+      "fixed_odd_divisor": 21,
+      "exact_grid": "2^(-P)*21^(-K), K=G*(D_complex+1); completed children preserve incoming odd denominator; no child rounding"
+    },
+    "rows": {
+      "coefficient": 15761,
+      "degree": 33000,
+      "suffix_slope": 132000,
+      "degree_gap": "21189/25",
+      "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; prefix and padding; sequential reuse"
+    },
+    "bit_coarse": {
+      "m": 529,
+      "W": 108516254,
+      "maxchild": 528,
+      "halving_degree": 367,
+      "wire_bits": 27
+    },
+    "ordinary_leaf_row_degree": 252
+  },
+  "assembly": {
+    "parameters": {
+      "a_bit": "98718840271061/1000000000000000000",
+      "a_complex": "98718939/1000000000000",
+      "tau": "999901281159728939/1000000000000000000",
+      "sigma": "999901281061/1000000000000",
+      "eta": "1/100000000",
+      "beta": "1/1000000",
+      "q": "4935941914834209728939/50000000000000000000000000",
+      "c": "493594196419362887728109728939/5000000000000000000000000000000000",
+      "epsilon": "4999999950000000000000000000000000/5000987188387902783860622009728939",
+      "lambda_": "99990128116071612740271061/100000000000000000000000000",
+      "lambda_prime": "49995064058085165790271061/50000000000000000000000000",
+      "alpha_squared_power": "740416287225131459340850000000/5000987188387902783860622009728939",
+      "delta": "1/800000000",
+      "C0": 10320887014903089483460091488744256300011976338006629722006596843490496619188358441485729792,
+      "C1": 1,
+      "kappa": "49349675169/500000000000000"
+    },
+    "strict_constraints": {
+      "bit_positive": "98718840271061/1000000000000000000",
+      "complex_above_bit": "98728939/1000000000000000000",
+      "complex_below_one_over32": "31151281061/1000000000000",
+      "beta_positive": "1/1000000",
+      "beta_below_one": "999999/1000000",
+      "leaf_saving_above_bit": "1/100000000000000",
+      "q_positive": "4935941914834209728939/50000000000000000000000000",
+      "q_below_internal": "98718840271061/50000000000000000000000000",
+      "q_below_leaf": "99218840271061/50000000000000000000000000",
+      "c_positive": "493594196419362887728109728939/5000000000000000000000000000000000",
+      "c_below_one": "4999506405803580637112271890271061/5000000000000000000000000000000000",
+      "q_below_reservations": "4935941914834209728939/5000000000000000000000000000000000",
+      "lambda_above_tau": "98718840271061/100000000000000000000000000",
+      "lambda_above_sigma": "9971612740271061/100000000000000000000000000",
+      "lambda_above_internal": "98718840271061/100000000000000000000000000",
+      "lambda_prime_above_lambda": "98718840271061/100000000000000000000000000",
+      "compact_leaf": "99218840271061/50000000000000000000000000",
+      "compact_reservations": "4935941914834209728939/5000000000000000000000000000000000",
+      "lambda_prime_below_one": "4935941914834209728939/50000000000000000000000000",
+      "epsilon_positive": "4999999950000000000000000000000000/5000987188387902783860622009728939",
+      "epsilon_below_one": "987238387902783860622009728939/5000987188387902783860622009728939",
+      "guard_width": "987238387902783860622009728939/5000987188387902783860622009728939",
+      "K_geometry": "49364419641936293708752887728109728939/500098718838790278386062200972893900000000",
+      "K_dominates_log": "49359419148342092353448085165790271061/500098718838790278386062200972893900000000",
+      "record_suffix": "987238387902783860622009728939/5000987188387902783860622009728939",
+      "phase_local": "789785709335038700594823922529190271061/4000789750710322227088497607783151200000000",
+      "phase_boundary": "592328028792916779569896139377990271061/4000789750710322227088497607783151200000000",
+      "gamma_sublinear": "246822100677652401281159728939/5000987188387902783860622009728939",
+      "cell_above_band": "4999753127899322347598718840271061/10001974376775805567721244019457878",
+      "prime_interval_packing": "987238387902783860622009728939/5000987188387902783860622009728939",
+      "alpha_positive": "740416287225131459340850000000/5000987188387902783860622009728939",
+      "alpha_below_one": "5000246772100677652401281159728939/5000987188387902783860622009728939",
+      "alpha_below_one_fourth": "4998025523239002258023258609728939/20003948753551611135442488038915756",
+      "delta_positive": "1/800000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "short_record_fallback": "4999506258344551912178872895357025046364910104065721/5000987188387902783860622009728939000000000000000000",
+      "small_field_exposure": "493644201355304802562319457878/5000987188387902783860622009728939",
+      "artificial_boundary": "28006515498362132750241103006187738790271061/4000789750710322227088497607783151200000000",
+      "literal_scalar_guard": "23663134977673194174897626214383856993149628",
+      "row_product_gap": "21189/25",
+      "original_prefix_above_kappa": "25004938407857391091926690133547305984309/2500493594193951391930311004864469500000000000000",
+      "coordinate_movement_above_kappa": "19489933061/1000000000000000000",
+      "compact_phase_layer_above_kappa": "2465917877172623580084902610984309/2500493594193951391930311004864469500000000000000",
+      "bulk_exposure_above_kappa": "19489933061/1000000000000000000",
+      "Gaussian_arithmetic_above_kappa": "123407924724299376078512575160828822024109309/2500493594193951391930311004864469500000000000000",
+      "scalar_work_above_kappa": "246818975063125576719092439630328822024109309/2500493594193951391930311004864469500000000000000",
+      "dimension_above_kappa": "2499753177906728726388847327488049584902610984309/2500493594193951391930311004864469500000000000000"
+    },
+    "margins": {
+      "original_prefix": "49364419641936293708752887728109728939/500098718838790278386062200972893900000000",
+      "coordinate_movement": "98718840271061/1000000000000000000",
+      "compact_phase_layer": "493594186547479058059690271061/5000987188387902783860622009728939",
+      "bulk_exposure": "98718840271061/1000000000000000000",
+      "Gaussian_arithmetic": "592328028792916779569896139377990271061/4000789750710322227088497607783151200000000",
+      "scalar_work": "789785709335038700594823922529190271061/4000789750710322227088497607783151200000000",
+      "dimension": "4999999950000000000000000000000000/5000987188387902783860622009728939"
+    },
+    "minimum_margin": "493594186547479058059690271061/5000987188387902783860622009728939",
+    "absorption_gap": "2465917877172623580084902610984309/2500493594193951391930311004864469500000000000000",
+    "recurrence": {
+      "internal": "999901281159728939/1000000000000000000",
+      "leaf": "999901281159718939/1000000000000000000",
+      "reservations": "4999506405803580637112271890271061/5000000000000000000000000000000000"
+    }
+  },
+  "next_grid_rejections": {
+    "bit": "1e-10",
+    "complex": "1e-12",
+    "kappa": "1e-15"
+  }
+}
\ No newline at end of file
diff --git a/research/cube-deferred/certificate.py b/research/cube-deferred/certificate.py
new file mode 100644
index 0000000000..b31e1ed0c9
--- /dev/null
+++ b/research/cube-deferred/certificate.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Exact finite assembly for cyclic strips with deferred readouts.
+
+Built on Avi Eisenberg's PR110 (Anthropic Claude assistance), icekylinx's
+PR104 stopped-product and copied-center interfaces, and Zhihao Chen's
+assembly of the RaD interfaces. Integration for eumemic with OpenAI Codex
+assistance. Apache-2.0. General transfer hypotheses remain inherited.
+"""
+import argparse
+import json
+import sys
+from fractions import Fraction as Q
+from pathlib import Path
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+from partial_swap_network import moment
+from copied_centers_network import finite_bridge as copied_bridge
+from structured_bulk_assembly import assembly, js
+ATOM = Q(1, 1000)
+OLD = Q(384599, 10**10)
+BETA = Q(1, 10**6)
+COARSE = Q(620523, 5000000000)
+COMPLEX = Q(98718939, 1000000000000)
+KGRID = 10**15
+
+def profile(name):
+    p = json.loads((HERE / name).read_text())
+    p['child_multiplicities'] = {int(t): c for t, c in p['child_multiplicities'].items()}
+    z = p['child_multiplicities']
+    assert all(0 < t < p['m'] and c > 0 for t,c in z.items())
+    assert sum(t*c for t,c in z.items()) == p['total_rank'] == p['W']*p['m']-p['N']+p['L']
+    assert max(z) == p['maxchild']
+    return p
+
+def contracts(p, a):
+    try: moment(p['m'],p['W'],p['child_multiplicities'],a,True)
+    except ValueError: return False
+    return True
+
+def exact(bit=None, phase=None):
+    bit = profile('bit-profile.json') if bit is None else bit
+    phase = profile('complex-profile.json') if phase is None else phase
+    assert (bit['h'], phase['h']) == (23,24)
+    bm = moment(bit['m'],bit['W'],bit['child_multiplicities'],COARSE,True)
+    cm = moment(phase['m'],phase['W'],phase['child_multiplicities'],COMPLEX,True)
+    assert not contracts(bit,COARSE+Q(1,10**10))
+    assert not contracts(phase,COMPLEX+Q(1,10**12))
+    ab = (1-ATOM)*COARSE+ATOM*OLD
+    assert 0 < OLD < COARSE < ATOM and ab < ATOM
+    a = min(ab,(1-BETA)*COMPLEX-Q(1,10**14))
+    row = dict(h=phase['h'],v=phase['v'],c=phase['additions'],central_disjoint=24)
+    bridge = copied_bridge(bit,phase,[row,row])
+    # A literal expanded readout is charged even if it could be factored.
+    # Each row has <=c+R mixer operations and <=R leaf copies. There are
+    # <=R+q readouts, each containing <=h center coefficients and <=v direct
+    # coefficients; <=4*v*(h+1) scalar groups suffice per readout. A factor
+    # eight covers forward/inverse words, both reflected words, and copies.
+    h,v,R,q,c = (phase[k] for k in ('h','v','R','roots','additions'))
+    local = 8*(c+2*R+(R+q)*v*(h+1)+h*h+h+1)
+    G = phase['N'] + 2*v*local
+    m,W,s = (phase[k] for k in ('m','W','total_rank'))
+    E=64*(W+m+G+1)**3
+    charge=2*G*W*W+8*s+4*W+4+32*m
+    B=s+E; C0=32*m*B*B
+    assert charge<E and 2*B*(m-phase['maxchild']) >= s+E and 2*B+18<C0
+    bridge['complex']['scalar_group_upper']=G
+    bridge['complex']['scalar_terms']=[dict(h=h,v=v,c=c,R=R,q=q,invocations=v,
+        local_group_upper=local,description='Expanded deferred readouts and forward/inverse/reflected words')]*2
+    bridge['semantic'].update(E=E,literal_charge=charge,strict_literal_gap=E-charge,
+        B=B,C0=C0,C1=1,induction_gap=2*B*(m-phase['maxchild'])-s-E,
+        fixed_odd_divisor=21,exact_grid='2^(-P)*21^(-K), K=G*(D_complex+1); completed children preserve incoming odd denominator; no child rounding')
+    coarse_bridge=bridge.pop('bit')
+    previous=json.loads((ROOT/'certificates/copied-centers-network.json').read_text())
+    oldbit=previous['finite_bridge']['bit']
+    old_degree=oldbit['halving_degree']*oldbit['wire_bits']
+    assert old_degree==252
+    cp=bridge['complex']
+    coeff=coarse_bridge['halving_degree']*coarse_bridge['wire_bits']+old_degree+cp['halving_degree']*cp['wire_bits']
+    degree=1000*((51*coeff)//25000+1)
+    bridge.update(bit_coarse=coarse_bridge,ordinary_leaf_row_degree=old_degree)
+    bridge['rows']=dict(coefficient=coeff,degree=degree,suffix_slope=4*degree,
+        degree_gap=Q(degree)-Q(51*coeff,25),contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; prefix and padding; sequential reuse')
+    def accepts(k):
+        try: assembly(a,COMPLEX,bridge,Q(k,KGRID),beta=BETA)
+        except AssertionError: return False
+        return True
+    lo,hi=0,int(COMPLEX*KGRID)+1
+    assert accepts(lo) and not accepts(hi)
+    while hi-lo>1:
+        mid=(lo+hi)//2
+        if accepts(mid): lo=mid
+        else: hi=mid
+    k=Q(lo,KGRID)
+    assembled=assembly(a,COMPLEX,bridge,k,beta=BETA)
+    assert len(assembled['strict_constraints'])==47 and len(assembled['margins'])==7
+    assert not accepts(lo+1)
+    return dict(status='Finite conditional cyclic/deferred witness',kappa=k,
+        complex_saving=COMPLEX,coarse_bit_saving=COARSE,actual_bit_saving=ab,
+        bit_parameter=a,complex_profile=phase,bit_profile=bit,
+        bit_moment_gap=bm['strict_gap'],complex_moment_gap=cm['strict_gap'],
+        finite_bridge=bridge,assembly=assembled,
+        next_grid_rejections=dict(bit='1e-10',complex='1e-12',kappa='1e-15'))
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--write',action='store_true');args=parser.parse_args()
+    assert not sys.flags.optimize
+    result=js(exact()); path=HERE/'certificate.json'
+    if args.write:path.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:assert result==json.loads(path.read_text()),'Frozen exact certificate mismatch'
+    print('PASS conditional kappa = %s = %.12e; 47 constraints, 7 margins; expanded scalar charge' % (result['kappa'],float(Q(result['kappa']))))
+if __name__=='__main__':main()
diff --git a/research/cube-deferred/complex-profile.json b/research/cube-deferred/complex-profile.json
new file mode 100644
index 0000000000..49cfd4740c
--- /dev/null
+++ b/research/cube-deferred/complex-profile.json
@@ -0,0 +1,93 @@
+{
+ "h": 24,
+ "v": 2024,
+ "additions": 70252,
+ "roots": 8120,
+ "links": 42694,
+ "R": 35678,
+ "m": 576,
+ "N": 4096576,
+ "W": 152617696,
+ "L": 2234496,
+ "total_rank": 87905930816,
+ "deficit": 1862080,
+ "maxchild": 574,
+ "phase_one_ops": 18517,
+ "phase_one_roles": 15404,
+ "deferred_roles": 4909,
+ "deferred_dims": {
+  "1": 4,
+  "2": 45,
+  "4": 60,
+  "5": 1,
+  "6": 39,
+  "8": 79,
+  "10": 241,
+  "12": 348,
+  "13": 1,
+  "14": 234,
+  "15": 1,
+  "16": 218,
+  "17": 1,
+  "18": 1511,
+  "19": 682,
+  "20": 236,
+  "21": 225,
+  "22": 983
+ },
+ "lifted_additions": 34513,
+ "replay": {
+  "seeds": [
+   1,
+   2
+  ],
+  "scratch_restored": true,
+  "y_plus_x": true,
+  "field": "Z/(2^61-1)"
+ },
+ "child_multiplicities": {
+  "1": 289160784,
+  "2": 238698416,
+  "3": 41451520,
+  "4": 67346576,
+  "5": 32064208,
+  "6": 32238272,
+  "7": 14451360,
+  "8": 14831872,
+  "9": 7549520,
+  "10": 10423600,
+  "11": 4849504,
+  "12": 8816544,
+  "13": 4602576,
+  "14": 12297824,
+  "15": 5505280,
+  "16": 8468416,
+  "17": 8828688,
+  "18": 9541136,
+  "19": 9367072,
+  "20": 4748304,
+  "21": 3149344,
+  "22": 6108432,
+  "23": 8322688,
+  "529": 8193152,
+  "552": 124552912,
+  "553": 16192,
+  "554": 182160,
+  "556": 242880,
+  "557": 4048,
+  "558": 157872,
+  "560": 319792,
+  "562": 975568,
+  "564": 1408704,
+  "565": 4048,
+  "566": 947232,
+  "567": 4048,
+  "568": 882464,
+  "569": 4048,
+  "570": 6116528,
+  "571": 2760736,
+  "572": 955328,
+  "573": 910800,
+  "574": 3979184
+ }
+}
diff --git a/research/cube-deferred/complex_deferred.py b/research/cube-deferred/complex_deferred.py
new file mode 100644
index 0000000000..59012fc43c
--- /dev/null
+++ b/research/cube-deferred/complex_deferred.py
@@ -0,0 +1,466 @@
+#!/usr/bin/env python3
+"""Cyclic strips and core-aware pair assembly with lifted frames and deferred readouts.
+
+The scalar h=24 producer uses PR111's cyclic PairedTriple strips and dual-suffix
+pair stars, with PR62's core-aware pair assembly, a two-point base case, and
+column-pair coarse sums inside contracted pair subproblems. PR110's maximum
+carrier matching, explicit role compiler, lifted binary frames, deferred
+readouts, finite-field replay, exact F2 frame checks, and actual one-child
+profile are retained. The selected graph has 70252 additions, 8120 roots,
+42694 carrier links, and 35678 roles.
+
+Credits: Avi Eisenberg (PR110 deferred complex compiler and PR62 pair assembly),
+Rohan Arun (PR111 cyclic-strip and dual-suffix producer), Swapnil Jain (deferred
+readouts), icekylinx (PR104 stopped product-ring and PairedTriple lineage), and
+all predecessors credited in those sources. Integration and the contracted
+pair replacement were prepared with OpenAI Codex assistance. Apache-2.0.
+
+This script checks the original assertions and writes complex-profile.json
+next to itself. Reflected-word verification is a separate audit.
+"""
+import array
+import json
+import random
+import struct
+import sys
+import tempfile
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+import importlib.util
+producer_path = HERE / 'producer.py'
+spec = importlib.util.spec_from_file_location('cyclic_producer', producer_path)
+producer = importlib.util.module_from_spec(spec); spec.loader.exec_module(producer)
+build = producer.build
+
+P = (1 << 61) - 1
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def load(prefix):
+    def rd(fh, typ, cnt):
+        a = array.array(typ); a.fromfile(fh, cnt); return a
+    with open(str(prefix) + '.bin', 'rb') as f:
+        h, v, n, q = struct.unpack('<4I', f.read(16))
+        flat = rd(f, 'I', 2 * n); core = rd(f, 'Q', n); cover = rd(f, 'Q', n)
+        roots = rd(f, 'I', q); kind = rd(f, 'I', q); active = rd(f, 'B', n)
+    with open(str(prefix) + '.labels', 'rb') as f:
+        ranks = rd(f, 'I', n); types = rd(f, 'B', n)
+    args = [(flat[2 * i], flat[2 * i + 1]) for i in range(n)]
+    return h, v, n, q, args, core, cover, roots, kind, active, ranks, types
+
+
+# ---------------------------------------------------------------- F2 linear algebra on bit vectors
+def dot(a, b): return bin(a & b).count('1') & 1
+
+
+def reduce(basis):
+    rows = []; piv = []
+    for vec in basis:
+        for p, r in zip(piv, rows):
+            if vec >> p & 1: vec ^= r
+        if vec:
+            p = vec.bit_length() - 1
+            for i in range(len(rows)):
+                if rows[i] >> p & 1: rows[i] ^= vec
+            rows.append(vec); piv.append(p)
+    return rows
+
+
+def kernel(funcs, h):
+    K = reduce(funcs); piv = [r.bit_length() - 1 for r in K]
+    out = []
+    for c in (i for i in range(h) if i not in piv):
+        vec = 1 << c
+        for r, p in zip(K, piv):
+            if r >> c & 1: vec |= 1 << p
+        out.append(vec)
+    return out
+
+
+def restrict(basis, funcs):
+    B = reduce(basis)
+    for f in funcs:
+        if not B: break
+        vals = [dot(b, f) for b in B]
+        if not any(vals): continue
+        k = vals.index(1); pv = B[k]
+        B = [b ^ pv if val else b for b, val in zip(B, vals)]; B.pop(k)
+    return reduce(B)
+
+
+def contains(A, B):
+    RB = reduce(B)
+    return len(reduce(RB + list(A))) == len(RB)
+
+
+def cap(A, B):
+    A = reduce(A); B = reduce(B)
+    if not A or not B: return []
+    ker = []; red = []
+    for i, vec in enumerate(A + B):
+        tag = 1 << i
+        for rv, rt in red:
+            if vec >> (rv.bit_length() - 1) & 1: vec ^= rv; tag ^= rt
+        if vec: red.append((vec, tag))
+        else:
+            comb_ = 0
+            for k in range(len(A)):
+                if tag >> k & 1: comb_ ^= A[k]
+            ker.append(comb_)
+    return reduce(ker)
+
+
+def nondeg(B):
+    B = reduce(B); k = len(B)
+    if not k: return True
+    M = [sum(dot(B[i], B[j]) << j for j in range(k)) for i in range(k)]
+    return len(reduce(M)) == k
+
+
+def hopcroft_karp(left, adj):
+    """maximum bipartite matching; adj[x] = sorted list of right vertices."""
+    INF = 1 << 60
+    mate_l = {x: None for x in left}; mate_r = {}
+    while True:
+        dist = {}; queue = []
+        for x in left:
+            if mate_l[x] is None: dist[x] = 0; queue.append(x)
+            else: dist[x] = INF
+        found = INF; head = 0
+        while head < len(queue):
+            x = queue[head]; head += 1
+            if dist[x] >= found: continue
+            for r in adj[x]:
+                y = mate_r.get(r)
+                if y is None: found = min(found, dist[x] + 1)
+                elif dist[y] == INF: dist[y] = dist[x] + 1; queue.append(y)
+        if found == INF: break
+        gained = 0
+        for x0 in left:
+            if mate_l[x0] is not None: continue
+            stack = [(x0, iter(adj[x0]))]; path = []
+            while stack:
+                x, it = stack[-1]
+                advanced = False
+                for r in it:
+                    y = mate_r.get(r)
+                    if (y is None and dist[x] + 1 == found) or (y is not None and dist[y] == dist[x] + 1):
+                        path.append((x, r))
+                        if y is None:
+                            for xx, rr in path: mate_l[xx] = rr; mate_r[rr] = xx
+                            gained += 1; stack = []; break
+                        stack.append((y, iter(adj[y]))); advanced = True; break
+                else:
+                    dist[x] = INF; stack.pop()
+                    if path: path.pop()
+                    continue
+                if not advanced: break
+        if not gained: break
+    return mate_l
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix='deferred-stopped-') as work:
+        prefix = Path(work) / 'complex'
+        build(24, prefix, central_disjoint=24)
+        h, v, n, q, args, core, cover, roots, kind, active, ranks, types = load(prefix)
+    trip = list(combinations(range(h), 3)); require(len(trip) == v, 'triple count')
+    m = h * h; N = v * v; FULL = (1 << h) - 1
+    tmask = [sum(1 << p for p in T) for T in trip]
+    tid = {T: i for i, T in enumerate(trip)}
+
+    # ------------------------------------------------------------ uses and matching (inherited adjacency)
+    degree = [0] * n; uses = defaultdict(list); c_add = 0
+    for x in range(1, n):
+        if active[x] and args[x][0]:
+            c_add += 1
+            for pos, y in enumerate(args[x]): degree[y] += 1; uses[y].append(('gate', x, pos))
+    for j, x in enumerate(roots): degree[x] += 1; uses[x].append(('root', j))
+    def unode(u): return roots[u[1]] if u[0] == 'root' else u[1]
+    def before(x, u):
+        y = unode(u)
+        return (ranks[x], x) < (ranks[y], (n + u[1]) if u[0] == 'root' else y)
+    def incl(x, y):
+        tx, ty = types[x], types[y]
+        if tx == 1 and ty == 1: return not (core[y] & ~core[x]) and not (cover[x] & ~cover[y])
+        if tx in (1, 2) and ty == 2: return not (cover[x] & ~cover[y])
+        if tx == 1 and ty == 3: return bool(core[x] & core[y])
+        if tx == 2 and ty == 3: return not (cover[x] & ~core[y])
+        if tx == 3 and ty == 2: return cover[y] == FULL
+        if tx == 3 and ty == 3: return core[x] == core[y]
+        return False
+    left = []; adj = {}
+    for x in range(1, n):
+        if not (active[x] and args[x][0]): continue
+        rs = sorted({(y, k) for y in args[x] for k, u in enumerate(uses[y]) if before(x, u) and incl(x, unode(u))})
+        if rs: left.append(x); adj[x] = rs
+    mate = hopcroft_karp(left, adj)
+    links = {x: r for x, r in mate.items() if r is not None}
+    R = c_add + q - len(links)
+    require((c_add, q, len(links), R) == (70252, 8120, 42694, 35678),
+            'selected graph size: additions=%d, roots=%d, matching=%d, roles=%d' % (c_add, q, len(links), R))
+    linked_use = {(y, k): x for x, (y, k) in links.items()}
+
+    # ------------------------------------------------------------ root targets, read coefficients, root functionals
+    target = [None] * q
+    for j in range(v): target[j] = j
+    idx = v
+    for a, b in combinations(range(h), 2):
+        others = sorted((i for i in range(h) if i not in (a, b)), key=lambda i: ((i ^ 1) in (a, b), i))
+        for i in others: target[idx] = tid[tuple(sorted((a, b, i)))]; idx += 1
+    centre_of = {}
+    for j in range(q):
+        if kind[j]:
+            miss = FULL & ~cover[roots[j]]; require(bin(miss).count('1') == 1, 'centre cover')
+            centre_of[j] = miss.bit_length() - 1
+    require(idx + len(centre_of) == q, 'root order')
+    rootfun = [(1 << centre_of[j]) if kind[j] else tmask[target[j]] for j in range(q)]
+
+    # ------------------------------------------------------------ lifted binary frames, monotone
+    succ = defaultdict(set); droot = defaultdict(set)
+    for x in range(1, n):
+        if not active[x]: continue
+        for k, u in enumerate(uses[x]):
+            if (x, k) in linked_use: continue
+            (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    for x, (y, k) in links.items():
+        u = uses[y][k]; (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    order_desc = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x), reverse=True)
+    K = {}
+    for x in order_desc:
+        rows = [rootfun[j] for j in droot[x]]
+        for t in succ[x]: rows += K[t]
+        K[x] = reduce(rows)
+    def envelope(x):
+        if not args[x][0]: return [tmask[x - 1]]
+        if types[x] == 2: return [1 << i for i in range(h) if cover[x] >> i & 1]
+        require(types[x] == 1, 'only ordinary and common-pair labels occur')
+        ks = [i for i in range(h) if (cover[x] & ~core[x]) >> i & 1]
+        require(len(ks) == ranks[x], 'common-pair support')
+        return [core[x] | (1 << k) for k in ks]
+    U = {}
+    for x in range(1, n):
+        if not active[x]: continue
+        if not args[x][0]: U[x] = envelope(x); continue
+        B = kernel(K[x], h)
+        require(contains(envelope(x), B), 'label outside lifted frame')
+        U[x] = B if nondeg(B) else envelope(x)
+    changed = True
+    while changed:
+        changed = False
+        for x in order_desc:
+            if args[x][0] and any(not contains(U[x], U[t]) for t in succ[x]):
+                env = envelope(x)
+                if len(reduce(U[x])) != len(reduce(env)) or not contains(U[x], env): U[x] = env; changed = True
+    dimU = {x: len(reduce(B)) for x, B in U.items()}
+
+    # ------------------------------------------------------------ explicit role compile
+    order = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x))
+    holds = []; first_node = []; ops = []; edge_key = {}; role_root = {}
+    def new_role(node): holds.append([node]); first_node.append(node); return len(holds) - 1
+    def serve(s, y, k):
+        u = uses[y][k]
+        if u[0] == 'gate': edge_key[(y, k)] = s
+        else: role_root[s] = u[1]
+    for x in order:
+        free = [k for k in range(len(uses[x])) if (x, k) not in linked_use]
+        if not args[x][0]:
+            for k in free:
+                s = new_role(x); ops.append(('src', s, x)); serve(s, x, k)
+            continue
+        a, b = args[x]
+        ka = next(k for k, u in enumerate(uses[a]) if u == ('gate', x, 0))
+        kb = next(k for k, u in enumerate(uses[b]) if u == ('gate', x, 1))
+        sa, sb = edge_key.pop((a, ka)), edge_key.pop((b, kb))
+        if x in links and links[x][0] == a: sa, sb = sb, sa
+        piv, oth = sa, sb
+        ops.append(('add', piv, oth, x)); holds[piv].append(x); holds[oth].append(x)
+        if x in links: serve(oth, *links[x])
+        require(free, 'every use linked at node %d' % x)
+        serve(piv, x, free[0])
+        for k in free[1:]:
+            f = new_role(x); ops.append(('copy', piv, f, x)); serve(f, x, k)
+    require(not edge_key and len(holds) == R, 'compile')
+    Rr = R
+
+    # ------------------------------------------------------------ B. the word computes every root value
+    rng = random.Random(20261008)
+    xs = [rng.randrange(P) for _ in range(v)]
+    val = [0] * n
+    for i in range(v): val[i + 1] = xs[i]
+    for x in order:
+        if args[x][0]: val[x] = (val[args[x][0]] + val[args[x][1]]) % P
+    leaf_of = {s: first_node[s] for s in range(Rr) if not args[first_node[s]][0]}
+    a_ = [0] * Rr
+    for s, leaf in leaf_of.items(): a_[s] = xs[leaf - 1]
+    for o in ops:
+        if o[0] == 'add': a_[o[1]] = (a_[o[1]] + a_[o[2]]) % P
+        elif o[0] == 'copy': a_[o[2]] = (a_[o[2]] + a_[o[1]]) % P
+    require(all(a_[s] == val[roots[j]] for s, j in role_root.items()), 'root values')
+
+    # ------------------------------------------------------------ phase one and garbage reach
+    def touch(o): return [o[1], o[2]] if o[0] in ('add', 'copy') else []
+    prev = {}; pred = defaultdict(list); last = {}
+    for i, o in enumerate(ops):
+        for s in touch(o):
+            if s in prev: pred[i].append(prev[s])
+            prev[s] = i; last[s] = i
+    centre_roles = [s for s, j in role_root.items() if kind[j]]
+    Anc = set(); st = [last[s] for s in centre_roles]
+    while st:
+        i = st.pop()
+        if i not in Anc: Anc.add(i); st.extend(pred[i])
+    touched = set(centre_roles)
+    for i in Anc: touched.update(touch(ops[i]))
+    require(all(last[s] in Anc for s in centre_roles), 'centres complete in phase one')
+    reach = [set() for _ in range(Rr)]; reach_all = [False] * Rr
+    for s, j in role_root.items():
+        if kind[j]: reach_all[s] = True
+        else: reach[s].add(target[j])
+    for o in reversed(ops):
+        if o[0] == 'add': reach[o[2]] |= reach[o[1]]; reach_all[o[2]] = reach_all[o[2]] or reach_all[o[1]]
+        elif o[0] == 'copy': reach[o[1]] |= reach[o[2]]; reach_all[o[1]] = reach_all[o[1]] or reach_all[o[2]]
+
+    # ------------------------------------------------------------ deferral frames, insertion nesting
+    def F0(s): return U[first_node[s]]
+    cand = {}
+    for s in range(Rr):
+        if s in touched or reach_all[s]: continue
+        S_ = restrict(F0(s), [tmask[t] for t in reach[s]])
+        if S_ and nondeg(S_): cand[s] = S_
+    byT = defaultdict(list); placed = {}
+    for s in sorted(cand, key=lambda s: (-len(cand[s]), s)):
+        X = cand[s]; changed = True
+        while changed and X:
+            changed = False
+            for t in reach[s]:
+                for w in byT[t]:
+                    B = placed[w]
+                    if (len(B) >= len(X) and not contains(X, B)) or (len(B) < len(X) and not contains(B, X)):
+                        X = cap(X, B); changed = True
+                    if not X: break
+                if not X: break
+        if X and nondeg(X):
+            placed[s] = X
+            for t in reach[s]: byT[t].append(s)
+    deferred = sorted(placed, key=lambda s: (len(placed[s]), s)); dset = set(deferred)
+
+    # ------------------------------------------------------------ C. replay with arbitrary scratch and data
+    inv = lambda a: pow(a % P, P - 2, P); HALF = inv(2); I21 = inv(21)
+    cvec = [None] * Rr; dpart = [dict() for _ in range(Rr)]
+    for s, j in role_root.items():
+        if kind[j]: c = [0] * h; c[centre_of[j]] = 1; cvec[s] = c
+        else: dpart[s][target[j]] = (P - HALF) if j >= v else HALF
+    seed_c = {s: (None if cvec[s] is None else list(cvec[s])) for s in role_root}
+    seed_d = {s: dict(dpart[s]) for s in role_root}
+    def addc(dst, src):
+        if cvec[src] is not None:
+            cvec[dst] = list(cvec[src]) if cvec[dst] is None else [(p + q_) % P for p, q_ in zip(cvec[dst], cvec[src])]
+        for t, c in dpart[src].items(): dpart[dst][t] = (dpart[dst].get(t, 0) + c) % P
+    for o in reversed(ops):
+        if o[0] == 'add': addc(o[2], o[1])
+        elif o[0] == 'copy': addc(o[1], o[2])
+    scatter = [[(I21 - (HALF if i in trip[t] else 0)) % P for t in range(v)] for i in range(h)]
+    def readout(y, s, value, sign, seed=False):
+        cv = seed_c[s] if seed else cvec[s]; dp = seed_d[s] if seed else dpart[s]
+        if cv is not None:
+            for i, ci in enumerate(cv):
+                if ci:
+                    f = sign * ci * value % P; row = scatter[i]
+                    for t in range(v): y[t] = (y[t] + f * row[t]) % P
+        for t, c in dp.items(): y[t] = (y[t] + sign * c * value) % P
+    phase1 = sorted(Anc); rest = [i for i in range(len(ops)) if i not in Anc]
+    def replay(seed):
+        rng = random.Random(seed)
+        x = [rng.randrange(P) for _ in range(v)]; z = [rng.randrange(P) for _ in range(Rr)]
+        y0 = [rng.randrange(P) for _ in range(v)]; a = list(z); y = list(y0)
+        for s in range(Rr):
+            if s not in dset: readout(y, s, a[s], -1)
+        for s, leaf in leaf_of.items():
+            if s not in dset: a[s] = (a[s] + x[leaf - 1]) % P
+        def run(i, sign=1):
+            o = ops[i]
+            if o[0] == 'add': a[o[1]] = (a[o[1]] + sign * a[o[2]]) % P
+            elif o[0] == 'copy': a[o[2]] = (a[o[2]] + sign * a[o[1]]) % P
+        for i in phase1: run(i)
+        for s in centre_roles: readout(y, s, a[s], +1, True)
+        for s in deferred: readout(y, s, a[s], -1)
+        for s in deferred:
+            if s in leaf_of: a[s] = (a[s] + x[leaf_of[s] - 1]) % P
+        for i in rest: run(i)
+        for s, j in role_root.items():
+            if not kind[j]: readout(y, s, a[s], +1, True)
+        for i in reversed(range(len(ops))): run(i, -1)
+        for s, leaf in leaf_of.items(): a[s] = (a[s] - x[leaf - 1]) % P
+        return a == z, all((y[t] - y0[t] - x[t]) % P == 0 for t in range(v))
+    rep = [replay(seed) for seed in (1, 2)]
+    require(all(r == (True, True) for r in rep), 'replay %s' % rep)
+
+    # ------------------------------------------------------------ D. exact F2 frame facts
+    root_frame = {}
+    for s, j in role_root.items():
+        root_frame[s] = [1 << i for i in range(h) if i != centre_of[j]] if kind[j] else kernel([tmask[target[j]]], h)
+    FULLB = [1 << i for i in range(h)]
+    chain_dims = []
+    for s in range(Rr):
+        seq = [placed.get(s, []), F0(s)] + [U[x] for x in holds[s][1:]]
+        if s in root_frame: seq.append(root_frame[s])
+        seq.append(FULLB)
+        require(all(contains(A, B) for A, B in zip(seq, seq[1:])), 'role chain nesting %d' % s)
+        require(all(nondeg(B) for B in seq[1:-1] if B), 'degenerate frame on role %d' % s)
+        chain_dims.append([len(reduce(B)) for B in seq])
+    for s, X in placed.items():
+        require(contains(X, F0(s)) and nondeg(X), 'deferral frame %d' % s)
+        require(all(not any(dot(xv, tmask[t]) for xv in X) for t in reach[s]), 'target frame %d' % s)
+    byT2 = defaultdict(list)
+    for s in deferred:
+        for t in reach[s]: byT2[t].append(s)
+    for t, ss in byT2.items():
+        ss.sort(key=lambda s: (len(placed[s]), s))
+        require(all(contains(placed[p], placed[q_]) for p, q_ in zip(ss, ss[1:])), 'target chain %d' % t)
+
+    # ------------------------------------------------------------ E. one-child histogram
+    z = Counter()
+    for s in range(Rr):
+        ds = chain_dims[s]
+        for a, b in zip(ds[:-1], ds[1:-1]):
+            if b > a: z[b - a] += 2 * v
+        lastd = ds[-2]
+        if s in role_root and kind[role_root[s]]: z[h - 1] += 2 * v           # copied centre transform
+        z[h - lastd] += 2 * v                                                  # final growth to F
+        z[m - h + ds[0]] += 2 * v                                              # exterior, gauged by sigma
+    levels = defaultdict(set)
+    for s in deferred:
+        for t in reach[s]: levels[t].add(len(placed[s]))
+    for t in range(v):
+        ds = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v                       # target fronts
+    z[h - 1] += 2 * N                                                          # data-wire fronts
+    z[(h - 1) ** 2] += 2 * N                                                   # data macros
+    z[1] += N                                                                  # endpoint copies
+    z.pop(0, None)
+    W = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = W * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'complex rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    out = dict(h=h, v=v, additions=c_add, roots=q, links=len(links), R=R, m=m, N=N, W=W, L=L, total_rank=s_,
+               deficit=N - L, maxchild=max(z), phase_one_ops=len(Anc), phase_one_roles=len(touched),
+               deferred_roles=len(deferred),
+               deferred_dims=dict(sorted(Counter(len(X) for X in placed.values()).items())),
+               lifted_additions=sum(1 for x in U if args[x][0] and dimU[x] > ranks[x]),
+               replay=dict(seeds=[1, 2], scratch_restored=True, y_plus_x=True, field='Z/(2^61-1)'),
+               child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'complex-profile.json').write_text(json.dumps(out, indent=1) + '\n')
+    print('PASS complex: R=%d, deferred roles %d, maxchild %d, rank mass %d' % (R, len(deferred), max(z), s_))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/cube-deferred/core_pair_block.py b/research/cube-deferred/core_pair_block.py
new file mode 100644
index 0000000000..b80eb8b5cb
--- /dev/null
+++ b/research/cube-deferred/core_pair_block.py
@@ -0,0 +1,47 @@
+"""Core-aware pair assembly within PairedTriple's contracted pair subproblems.
+
+Adapted from Avi Eisenberg's PR62 interval-strip/core-aware pair producer
+(Apache-2.0, Anthropic Claude assistance), on the inherited icekylinx paired
+exclusion recursion. This adaptation uses a two-point base case, the caller's
+cyclic-strip vector routine, and column-pair coarse sums at every level.
+Prepared with OpenAI Codex assistance. All operations remain disjoint sums;
+the enclosing producer checks exact supports and binary frame inclusions.
+"""
+from itertools import combinations
+
+def block(self,points,edges,weights):
+ if len(points)<=2:
+  total=lambda omit:self.total([x for p,x in edges.items()if not set(p)&set(omit)]+[x for p,x in weights.items()if p not in omit])
+  return total(()),{a:total((a,))for a in points},{(a,b):total((a,b))for a,b in combinations(points,2)}
+ groups=self.grouping(points);ng=len(groups);e=lambda a,b:edges[tuple(sorted((a,b)))]
+ coarse={(i,j):self.total([self.total([e(a,b)for a in groups[i]])for b in groups[j]])for i,j in combinations(range(ng),2)}
+ wt={i:self.total([weights[a]for a in g]+[e(a,b)for a,b in combinations(g,2)])for i,g in enumerate(groups)}
+ total,outside,far=self.block(list(range(ng)),coarse,wt)
+ strips={};sums={}
+ for i,g in enumerate(groups):
+  other=[j for j in range(ng)if j!=i]
+  for a in g:
+   carry=self.total([weights[u]for u in g if u!=a])
+   vals=[self.total([e(u,v)for u in g if u!=a for v in groups[j]])for j in other]
+   st,one,_=self.vector([carry]+vals,False)
+   strips[a]={j:z for j,z in zip(other,one[1:])};sums[a]=st
+ out={};single={a:self.add(outside[i],sums[a])for i,g in enumerate(groups)for a in g}
+ for i,g in enumerate(groups):
+  for a,b in combinations(g,2):out[a,b]=outside[i]
+ for i,j in combinations(range(ng),2):
+  if len(groups[i])==2 and len(groups[j])==2:
+   (a,a2),(b,b2)=groups[i],groups[j];F=far[i,j]
+   Sa,Sa2,Sb,Sb2=strips[a][j],strips[a2][j],strips[b][i],strips[b2][i]
+   FSa,FSa2=self.add(F,Sa),self.add(F,Sa2)
+   FSb,FSb2=self.add(F,Sb),self.add(F,Sb2)
+   Y1=self.add(FSb,Sa);Y2=self.add(FSa,Sb2)
+   Y3=self.add(FSa2,e(a,b2));Y4=self.add(FSb2,e(a,b))
+   out[a,b]=self.add(e(a2,b2),Y1);out[a,b2]=self.add(e(a2,b),Y2)
+   out[a2,b]=self.add(Y3,Sb);out[a2,b2]=self.add(Y4,Sa2)
+  else:
+   for a in groups[i]:
+    left=self.add(far[i,j],strips[a][j])
+    for b in groups[j]:
+     cross=self.total([e(u,v)for u in groups[i]if u!=a for v in groups[j]if v!=b])
+     out[a,b]=self.add(left,self.add(strips[b][i],cross))
+ return total,single,out
diff --git a/research/cube-deferred/cube115.py b/research/cube-deferred/cube115.py
new file mode 100644
index 0000000000..136c0898d6
--- /dev/null
+++ b/research/cube-deferred/cube115.py
@@ -0,0 +1,93 @@
+# Imported from icekylinx PR115 cf60442983c153a3a0f5272ea4713f99eba13c86; local import adapted.
+# Copyright 2026 icekylinx. Apache-2.0.
+# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE.
+"""Pair-first cube override of the retained PairedTriple recursion."""
+from itertools import combinations
+from collections import defaultdict
+from interval115 import IntervalTriple
+
+def cube_values(self,G,groups,out_coarse,one,two,w):
+    (a,a2),(b,b2),(c,c2)=[groups[g] for g in G]
+    def piece(*points):
+        p=tuple(sorted(points))
+        if not p:return out_coarse[G]
+        if len(p)==1:
+            u=p[0];omit=tuple(g for g in G if u not in groups[g]);return one[u][omit]
+        if len(p)==2:
+            omit=tuple(g for g in G if not set(p)&set(groups[g]));return two[p][omit]
+        return w.get(p,0)
+    def plane(z):
+        val=lambda *p:piece(*(p+(() if z is None else (z,))))
+        F=val();Sa,Sa2,Sb,Sb2=[val(x) for x in (a2,a,b2,b)]
+        e=lambda u,v:val(u,v)
+        FSa,FSa2,FSb,FSb2=[self.add(F,x) for x in (Sa,Sa2,Sb,Sb2)]
+        Y1=self.add(FSb,Sa);Y2=self.add(FSa,Sb2)
+        Y3=self.add(FSa2,e(a,b2));Y4=self.add(FSb2,e(a,b))
+        return {(a2,b2):self.add(e(a2,b2),Y1),(a2,b):self.add(e(a2,b),Y2),
+                (a,b2):self.add(Y3,Sb),(a,b):self.add(Y4,Sa2)}
+    F=plane(None);V={z:plane(z) for z in (c,c2)}
+    return {tuple(sorted((u,v,z))):self.add(F[u,v],V[z][u,v]) for u,v in F for z in (c,c2)}
+
+class CubeTriple(IntervalTriple):
+    cube_values=cube_values
+    def triple(self,pts,w):
+        subsets=[s for k in range(4) for s in combinations(pts,k)]
+        if len(pts)<=self.base:
+            return {s:self.total([v for t,v in w.items() if not set(s)&set(t)]) for s in subsets}
+        groups=self.grouping(pts);ng=len(groups)
+        group_of={u:i for i,g in enumerate(groups) for u in g}
+        coarse_parts=defaultdict(list)
+        for t,v in w.items():coarse_parts[tuple(sorted({group_of[u] for u in t}))].append(v)
+        coarse={s:self.total(xs) for s,xs in coarse_parts.items()}
+        out_coarse=self.triple(list(range(ng)),coarse)
+        # Contract one surviving point and aggregate by the other point groups.
+        one={}
+        for u in pts:
+            g=group_of[u];others=[j for j in range(ng) if j!=g]
+            pieces=defaultdict(list)
+            for t,v in w.items():
+                if u not in t:continue
+                rest=[a for a in t if a!=u]
+                if any(group_of[a]==g for a in rest):continue
+                pieces[tuple(sorted({group_of[a] for a in rest}))].append(v)
+            coeff={s:self.total(xs) for s,xs in pieces.items()}
+            edges={s:coeff.get(s,0) for s in combinations(others,2)}
+            weights={j:coeff.get((j,),0) for j in others}
+            total,single,pair=self.block(others,edges,weights)
+            const=coeff.get((),0)
+            one[u]={():self.add(const,total)}
+            one[u].update({(j,):self.add(const,x) for j,x in single.items()})
+            one[u].update({s:self.add(const,x) for s,x in pair.items()})
+        # Contract two surviving points. The remaining degree is at most one.
+        two={}
+        for u,v in combinations(pts,2):
+            i,j=group_of[u],group_of[v]
+            if i==j:continue
+            others=[k for k in range(ng) if k not in (i,j)]
+            vals=[self.total([w.get(tuple(sorted((u,v,a))),0) for a in groups[k]]) for k in others]
+            total,leave,_=self.vector([w.get((u,v),0)]+vals,False)
+            two[u,v]={():total}|{(k,):x for k,x in zip(others,leave[1:])}
+
+        result={};cube_cache={}
+        for excluded in subsets:
+            E=set(excluded);G=tuple(sorted({group_of[a] for a in E}))
+            survivors=[u for i in G for u in groups[i] if u not in E]
+            assert len(survivors)<=3
+            pieces={():out_coarse[G]}
+            for u in survivors:
+                omit=tuple(i for i in G if i!=group_of[u])
+                pieces[u,]=one[u][omit]
+            for u,v in combinations(survivors,2):
+                omit=tuple(i for i in G if i not in (group_of[u],group_of[v]))
+                pieces[u,v]=two[u,v][omit]
+            if len(survivors)==3:pieces[tuple(survivors)]=w.get(tuple(survivors),0)
+            if len(survivors)==3 and all(len(groups[g])==2 for g in G):
+                if G not in cube_cache:cube_cache[G]=self.cube_values(G,groups,out_coarse,one,two,w)
+                result[excluded]=cube_cache[G][tuple(sorted(survivors))]
+                continue
+            if len(survivors)==3:
+                a,b,c=survivors
+                order=[(),(a,),(b,),(a,b),(c,),(a,c),(b,c),(a,b,c)]
+            else:order=[s for k in range(len(survivors)+1) for s in combinations(survivors,k)]
+            result[excluded]=self.total([pieces[s] for s in order])
+        return result
diff --git a/research/cube-deferred/inputs/deferred_23.json.gz b/research/cube-deferred/inputs/deferred_23.json.gz
new file mode 100644
index 0000000000..4a4431bd42
Binary files /dev/null and b/research/cube-deferred/inputs/deferred_23.json.gz differ
diff --git a/research/cube-deferred/inputs/witness_23.json.gz b/research/cube-deferred/inputs/witness_23.json.gz
new file mode 100644
index 0000000000..3d86f83b87
Binary files /dev/null and b/research/cube-deferred/inputs/witness_23.json.gz differ
diff --git a/research/cube-deferred/interval115.py b/research/cube-deferred/interval115.py
new file mode 100644
index 0000000000..980555b0ab
--- /dev/null
+++ b/research/cube-deferred/interval115.py
@@ -0,0 +1,71 @@
+# Imported from icekylinx PR115 cf60442983c153a3a0f5272ea4713f99eba13c86; local import adapted.
+# Copyright 2026 icekylinx. Apache-2.0.
+# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE.
+"""Cyclic intervals and core-aware pairs, adapted from Avi Eisenberg PR62."""
+from pathlib import Path
+from itertools import combinations
+import sys
+from paired_triple_circuit import PairedTriple
+from paired_exclusion_circuit import PairedExclusionCircuit
+
+def interval_sums(add,values):
+    nz=[(i,x) for i,x in enumerate(values) if x]
+    n=len(nz)
+    if not n:return 0,[0]*len(values)
+    if n==1:
+        result=[nz[0][1]]*len(values);result[nz[0][0]]=0
+        return nz[0][1],result
+    v=[x for _,x in nz];states={(a,1):x for a,x in enumerate(v)}
+    for length in range(2,n):
+        for a in range(n):states[a,length]=add(states[a,length-1],v[(a+length-1)%n])
+    total=add(states[0,n-1],v[-1])
+    out=[total]*len(values)
+    for j,(i,x) in enumerate(nz):out[i]=states[(j+1)%n,n-1]
+    return total,out
+
+class IntervalTriple(PairedTriple):
+    def vector(self,values,two=True):
+        if two:return super().vector(values,two)
+        total,one=interval_sums(self.add,values)
+        return total,one,{}
+
+    def block(self,points,edges,weights):
+        if len(points)<=2:
+            return PairedExclusionCircuit.block(self,points,edges,weights)
+        groups=self.grouping(points);ng=len(groups)
+        edge=lambda a,b:edges[tuple(sorted((a,b)))]
+        coarse={(i,j):self.total([edge(a,b) for a in groups[i] for b in groups[j]])
+                for i,j in combinations(range(ng),2)}
+        wt={i:self.total([weights[a] for a in g]+[edge(a,b) for a,b in combinations(g,2)])
+            for i,g in enumerate(groups)}
+        total,outside,far=self.block(list(range(ng)),coarse,wt)
+        strips={};sums={}
+        for i,g in enumerate(groups):
+            other=[j for j in range(ng) if j!=i]
+            for a in g:
+                carry=self.total([weights[u] for u in g if u!=a])
+                vals=[self.total([edge(u,v) for u in g if u!=a for v in groups[j]]) for j in other]
+                st,one=interval_sums(self.add,[carry]+vals)
+                strips[a]={j:z for j,z in zip(other,one[1:])};sums[a]=st
+        out={};single={a:self.add(outside[i],sums[a]) for i,g in enumerate(groups) for a in g}
+        for i,g in enumerate(groups):
+            for a,b in combinations(g,2):out[a,b]=outside[i]
+        for i,j in combinations(range(ng),2):
+            if len(groups[i])==len(groups[j])==2:
+                (a,a2),(b,b2)=groups[i],groups[j]
+                F=far[i,j];Sa,Sa2,Sb,Sb2=strips[a][j],strips[a2][j],strips[b][i],strips[b2][i]
+                FSa,FSa2=self.add(F,Sa),self.add(F,Sa2)
+                FSb,FSb2=self.add(F,Sb),self.add(F,Sb2)
+                Y1=self.add(FSb,Sa);Y2=self.add(FSa,Sb2)
+                Y3=self.add(FSa2,edge(a,b2));Y4=self.add(FSb2,edge(a,b))
+                out[a,b]=self.add(edge(a2,b2),Y1)
+                out[a,b2]=self.add(edge(a2,b),Y2)
+                out[a2,b]=self.add(Y3,Sb)
+                out[a2,b2]=self.add(Y4,Sa2)
+            else:
+                for a in groups[i]:
+                    left=self.add(far[i,j],strips[a][j])
+                    for b in groups[j]:
+                        cross=self.total([edge(u,v) for u in groups[i] if u!=a for v in groups[j] if v!=b])
+                        out[a,b]=self.add(left,self.add(strips[b][i],cross))
+        return total,single,out
diff --git a/research/cube-deferred/producer.py b/research/cube-deferred/producer.py
new file mode 100644
index 0000000000..03831b4e4f
--- /dev/null
+++ b/research/cube-deferred/producer.py
@@ -0,0 +1,276 @@
+# Cube recurrence from icekylinx PR115 composed with eumemic PR114 core pairs and Rohan Arun PR111 pair stars.
+# Cyclic-strip recursion plus dual-suffix pair stars, by Rohan Arun with Anthropic Claude assistance.
+# Parent: PR107 (Rohan Arun with OpenAI Codex) on icekylinx PR104 at 854ba7dca98651eab2050402384e1a7784534f0a.
+# Pair-star leave-one-out identity: PR55 dual-suffix strips (credited there).
+# Original copyright, Apache-2.0 notice and scalar/frame assertions retained.
+"""Aligned h=24 rational-center producer with cyclic strips and core-aware pairs.
+
+PR111's cyclic-strip PairedTriple recursion and dual-suffix pair stars are
+retained. Contracted pair subproblems use core_pair_block.py: PR62's core-aware
+four-output assembly, two-point base cases, and balanced column coarse sums.
+All ordinary-support, exact rational-scatter, center, and binary-frame
+assertions from PR111/PR104 remain enabled.
+
+Copyright 2026 icekylinx and the credited contributors, Apache-2.0. PR111 by
+Rohan Arun with Anthropic Claude assistance; PR62 pair assembly by Avi
+Eisenberg with Anthropic Claude assistance. This integration was prepared
+with OpenAI Codex assistance. See the inherited NOTICE and source credits.
+"""
+import json, struct, array
+from itertools import combinations
+from pathlib import Path
+from partial_swap.binary import write_array
+from cube115 import CubeTriple as PairedTriple
+from exclusion_circuit import ExclusionCircuit
+
+
+def cyclic_vector(self,values,two=True):
+    """Leave-one-out by cyclic interval strips (PR62 idea): I(a,m)=I(a,m-1)+v_(a+m-1).
+
+    Used for every strip of the PairedTriple recursion; leave-two-out vectors are unchanged.
+    Zero entries are omitted (their leave-one-out value is the total), exactly as before."""
+    if two:return ExclusionCircuit.vector(self,values,two)
+    vals=list(values);n=len(vals)
+    if n==0:return 0,[],{}
+    nz=[i for i,x in enumerate(vals) if x]
+    if not nz:return 0,[0]*n,{}
+    if len(nz)==1:
+        x=vals[nz[0]];return x,[0 if i==nz[0] else x for i in range(n)],{}
+    v=[vals[i] for i in nz];k=len(v)
+    if k<3:
+        tot=self.add(v[0],v[1]);one=[v[1],v[0]]
+    else:
+        full=(1<<k)-1;iv=lambda a,m:sum(1<<((a+t)%k) for t in range(m))
+        node={1<<i:x for i,x in enumerate(v)}
+        for m in range(2,k):
+            for a in range(k):node[iv(a,m)]=self.add(node[iv(a,m-1)],node[1<<((a+m-1)%k)])
+        node[full]=self.add(node[iv(0,k-1)],node[1<<(k-1)])
+        tot=node[full];one=[node[full^(1<<j)] for j in range(k)]
+    out=[tot]*n
+    for i,y in zip(nz,one):out[i]=y
+    return tot,out,{}
+
+def build(h, prefix, central_disjoint, base=2):
+    assert (h, central_disjoint, base) == (24,24,2)
+    d=central_disjoint
+    assert 0<d<=h
+    divisor=abs(3-d)
+    assert divisor == 21
+    triples=list(combinations(range(h),3)); v=len(triples)
+    args=[(0,0)]; support=[0]; core=[0]; cover=[0]; types=[0]; ranks=[0]
+    lookup={}; inputs={}; center_coeff={}
+    # Each central tree adds h-1 ordinary pair totals, so every intermediate
+    # coefficient is at most h-1. Wider lanes rule out hidden integer carries.
+    coefficient_bits=h.bit_length()
+    def packed(mask):
+        result=0
+        while mask:
+            bit=mask&-mask; mask-=bit
+            result |= 1 << (coefficient_bits*(bit.bit_length()-1))
+        return result
+    for j,t in enumerate(triples):
+        mask=sum(1<<a for a in t); x=len(args); inputs[t]=x
+        args.append((0,0));support.append(1<<j);core.append(mask);cover.append(mask)
+        types.append(1);ranks.append(1);lookup[1<<j]=x
+    def add(a,b,center=None):
+        if not a:return b
+        if not b:return a
+        if center is None:
+            assert not support[a]&support[b], "Ordinary additions must be cancellation-free"
+        s=support[a]|support[b]
+        if center is None and s in lookup:return lookup[s]
+        x=len(args);args.append((a,b));support.append(s)
+        core.append(core[a]&core[b]);cover.append(cover[a]|cover[b])
+        if center is not None:
+            types.append(3);ranks.append(h-1);core[x]=1<<center
+            ca=center_coeff[a] if a in center_coeff else packed(support[a])
+            cb=center_coeff[b] if b in center_coeff else packed(support[b])
+            center_coeff[x]=ca+cb
+        elif core[x].bit_count()>=2:
+            types.append(1);ranks.append(s.bit_count());lookup[s]=x
+        else:
+            types.append(2);ranks.append(cover[x].bit_count());lookup[s]=x
+        return x
+    def total(xs,center=None):
+        xs=[x for x in xs if x]
+        while len(xs)>1:
+            xs=[add(xs[i],xs[i+1],center) if i+1<len(xs) else xs[i] for i in range(0,len(xs),2)]
+        return xs[0] if xs else 0
+    from core_pair_block import block as core_pair_block
+    PairedTriple.block=core_pair_block
+    PairedTriple.vector=cyclic_vector
+    try:paired=PairedTriple(h,base)
+    finally:del PairedTriple.vector;del PairedTriple.block
+    allresults=paired.triple(list(range(h)),paired.variables)
+    selected=list(paired.outputs.values())+[allresults[(i,)] for i in range(d)]
+    active=set();stack=list(selected)
+    while stack:
+        x=stack.pop()
+        if not x or x in active:continue
+        active.add(x)
+        if paired.args[x]:stack.extend(paired.args[x])
+    mapping={0:0}|{j+1:inputs[t] for j,t in enumerate(triples)}
+    for x in sorted(active):
+        if paired.args[x]:
+            a,b=paired.args[x];mapping[x]=add(mapping[a],mapping[b])
+    roots=[mapping[paired.outputs[t]] for t in triples];kind=[0]*v
+    center_disjoint_roots=[mapping[allresults[(i,)]] for i in range(d)]
+    del paired, mapping, active, allresults
+    pairtotals={}; pair_outputs={}
+    point_masks=[sum(1<<j for j,t in enumerate(triples) if a in t) for a in range(h)]
+    full_support=(1<<v)-1
+    for t,node in zip(triples,roots):
+        assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]])
+        target_mask=sum(1<<a for a in t)
+        if types[node]==2:
+            assert not cover[node]&target_mask
+        else:
+            assert types[node]==1
+            assert not support[node]&(point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]])
+    for i,node in enumerate(center_disjoint_roots):
+        assert support[node] == full_support & ~point_masks[i]
+        assert types[node]==2 and cover[node]==((1<<h)-1)^(1<<i)
+        assert ranks[node]==h-1
+    for a,b in combinations(range(h),2):
+        others=[i for i in range(h) if i not in (a,b)]
+        others.sort(key=lambda i:((i^1) in (a,b),i))
+        # Dual-suffix leave-one-out (the PR55 strip identity, here on pair stars):
+        # s_j = (A_{j-1} + v_{j+1}) + B_{j+2}, s_k = A_{k-1}, with prefix sums A
+        # and suffix sums B. Each A_{j-1} feeds A_j and A_{j-1}+v_{j+1}; nested
+        # covers let the legal carrier matcher join far more additions.
+        vals=[inputs[tuple(sorted((a,b,i)))] for i in others];k=len(vals)
+        assert k>=3
+        A=[0]*(k+1)
+        for t in range(1,k):A[t]=add(A[t-1],vals[t-1])
+        B=[0]*(k+2)
+        for t in range(k,1,-1):B[t]=add(vals[t-1],B[t+1])
+        dual=[add(add(A[t-1],vals[t]),B[t+2]) for t in range(1,k)]+[A[k-1]]
+        pre=[A[k-1],add(A[k-1],vals[k-1])]
+        for j,i in enumerate(others):
+            node=dual[j]
+            roots.append(node);kind.append(0)
+            pair_outputs[a,b,i]=node
+            assert support[node] == point_masks[a]&point_masks[b]&~point_masks[i]
+            assert types[node]==1
+            assert not support[node]&(point_masks[a]^point_masks[b]^point_masks[i])
+        pairtotals[a,b]=pre[-1]
+        assert support[pre[-1]] == point_masks[a]&point_masks[b]
+    for a in range(d,h):
+        root=total([pairtotals[tuple(sorted((a,b)))] for b in range(h) if b!=a],center=a)
+        assert center_coeff[root] == 2*packed(point_masks[a]), "Center coefficients must be exactly doubled"
+        roots.append(root);kind.append(1)
+    roots.extend(center_disjoint_roots);kind.extend([1]*d)
+    # Mixed retained centers recover the total by
+    # (sum B_i - 2 sum D_i)/(2(3-d)); check each source coefficient.
+    Dset=set(range(d))
+    for triple in triples:
+        k=len(Dset.intersection(triple))
+        assert 2*(3-k)-2*(d-k)==2*(3-d)
+    # Check the rational substituted center scatter for every realizable pair of
+    # target/source memberships. Its coefficient is (intersection-1)/2.
+    from fractions import Fraction
+    # Every A_i avoids i, so sum A_i = (h-3)T. The selected decoder is
+    # T=sum A_i/21 and scatter T-(1/2)sum_{i in target} A_i.
+    decoder=Fraction(1,h-3)
+    assert decoder==Fraction(1,21)
+    scatter_coefficients=[decoder,decoder-Fraction(1,2)]
+    for coefficient in scatter_coefficients:
+        odd_denominator=coefficient.denominator
+        while odd_denominator%2==0:
+            odd_denominator//=2
+        assert 21%odd_denominator==0 and abs(coefficient)<=1
+    for source in triples:
+        assert sum(i not in source for i in range(h))*decoder==1
+    patterns={}
+    for target in triples:
+        chosen=len(Dset.intersection(target))
+        if chosen not in patterns:
+            patterns[chosen]=target
+    for chosen,target in patterns.items():
+        target_set=set(target)
+        for source in triples:
+            k=len(Dset.intersection(source))
+            total_coefficient=Fraction(2*(3-k)-2*(d-k),2*(3-d))
+            scalar=Fraction(len((target_set-Dset).intersection(source)),2)
+            scalar-=Fraction(len((target_set&Dset)-set(source)),2)
+            scalar+=Fraction(chosen-1,2)*total_coefficient
+            assert scalar==Fraction(len(target_set.intersection(source))-1,2)
+    # Check the scalar correction for each target, using the verified exact
+    # roots. Twice the coefficient is (intersection-1)+[intersection=0]
+    # -[intersection=2], which is two precisely for the diagonal.
+    for j,t in enumerate(triples):
+        masks=[point_masks[a] for a in t]
+        two=(masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0])
+        actual=0
+        for a,b in combinations(t,2):
+            excluded=next(i for i in t if i not in (a,b))
+            actual |= support[pair_outputs[a,b,excluded]]
+        assert actual == two
+        assert masks[0]&masks[1]&masks[2] == 1<<j
+    assert [((k-1)+(k==0)-(k==2)) for k in range(4)] == [0,0,0,2]
+    def contained(x,y):
+        tx,ty=types[x],types[y]
+        if tx==1 and ty==1: return not(core[y]&~core[x] or cover[x]&~cover[y])
+        if tx in (1,2) and ty==2: return not cover[x]&~cover[y]
+        if tx==1 and ty==3: return bool(core[x]&core[y])
+        if tx==2 and ty==3: return not cover[x]&~core[y]
+        if tx==3 and ty==2: return cover[y]==(1<<h)-1
+        if tx==3 and ty==3: return core[x]==core[y]
+        return False
+    active=[0]*len(args);stack=list(roots)
+    while stack:
+        x=stack.pop()
+        if not x or active[x]:continue
+        active[x]=1
+        if args[x][0]:stack.extend(args[x])
+    degree=[0]*len(args)
+    for x in range(1,len(args)):
+        if active[x]:
+            if types[x]==1:
+                # Shared-pair triple indicators have self-dot one and
+                # pairwise dot zero over F2; a source is a single such line.
+                assert core[x].bit_count()>=2 and ranks[x]==support[x].bit_count()
+            elif types[x]==2:
+                assert ranks[x]==cover[x].bit_count()
+            else:
+                # E_a is the orthogonal complement of the odd vector 1+e_a.
+                assert types[x]==3 and core[x].bit_count()==1 and ranks[x]==h-1
+        if active[x] and args[x][0]:
+            for y in args[x]:
+                assert y<x and contained(y,x), "Binary frame nesting failed"
+                degree[y]+=1
+    for x in roots:degree[x]+=1
+    H=[0]*(h+1);c=0;loss=0
+    for x in range(1,len(args)):
+        if not active[x]:continue
+        r=ranks[x]
+        if args[x][0]:
+            c+=1;H[r]+=degree[x]-1;H[h-r]+=1
+            for y in args[x]:
+                assert r>=ranks[y]
+                H[r-ranks[y]]+=1
+        else:H[1]+=degree[x]
+    for x,k in zip(roots,kind):
+        r=ranks[x]
+        if k:H[r]+=1;H[h]+=1;loss+=r
+        else:H[h-1-r]+=1;H[1]+=1
+    q=len(roots);R=c+q
+    result=dict(h=h,v=v,c=c,q=q,R=R,loss=loss,central_disjoint=d,histogram=H,rank_sum=sum(r*n for r,n in enumerate(H)))
+    assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss
+    prefix=Path(prefix)
+    result['center_denominator']=21
+    result['scalar_validation']=dict(ordinary_supports_exact=True, centers_exact=True,
+        center_decoder='sum A_i / 21', scatter_coefficients=list(map(str,scatter_coefficients)),
+        rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True,
+        binary_frames_nondegenerate=True)
+    with open(str(prefix)+'.bin','wb') as f:
+        f.write(struct.pack('<4I',h,v,len(args),q))
+        write_array(f,array.array('I',(a for pair in args for a in pair)))
+        write_array(f,array.array('Q',core));write_array(f,array.array('Q',cover))
+        write_array(f,array.array('I',roots));write_array(f,array.array('I',kind))
+        write_array(f,array.array('B',active))
+    with open(str(prefix)+'.labels','wb') as f:
+        write_array(f,array.array('I',ranks));write_array(f,array.array('B',types))
+    Path(str(prefix)+'.json').write_text(json.dumps(result,indent=2)+'\n')
+
+    return result
diff --git a/research/cube-deferred/reflection-audit.json b/research/cube-deferred/reflection-audit.json
new file mode 100644
index 0000000000..986626671e
--- /dev/null
+++ b/research/cube-deferred/reflection-audit.json
@@ -0,0 +1,76 @@
+{
+  "R": 35678,
+  "all_frames_nondegenerate": true,
+  "audit_sha256": "7f534ddc406b1454f71831790b0f519007fa4120a025a30fe162ef9c9215a9d7",
+  "child_multiplicities": {
+    "1": 289160784,
+    "10": 10423600,
+    "11": 4849504,
+    "12": 8816544,
+    "13": 4602576,
+    "14": 12297824,
+    "15": 5505280,
+    "16": 8468416,
+    "17": 8828688,
+    "18": 9541136,
+    "19": 9367072,
+    "2": 238698416,
+    "20": 4748304,
+    "21": 3149344,
+    "22": 6108432,
+    "23": 8322688,
+    "3": 41451520,
+    "4": 67346576,
+    "5": 32064208,
+    "529": 8193152,
+    "552": 124552912,
+    "553": 16192,
+    "554": 182160,
+    "556": 242880,
+    "557": 4048,
+    "558": 157872,
+    "560": 319792,
+    "562": 975568,
+    "564": 1408704,
+    "565": 4048,
+    "566": 947232,
+    "567": 4048,
+    "568": 882464,
+    "569": 4048,
+    "570": 6116528,
+    "571": 2760736,
+    "572": 955328,
+    "573": 910800,
+    "574": 3979184,
+    "6": 32238272,
+    "7": 14451360,
+    "8": 14831872,
+    "9": 7549520
+  },
+  "conservative_local_G": 17730568072,
+  "exact_arbitrary_dirty_cancellation_by_dependency_cut": true,
+  "exact_fresh_source_map": true,
+  "exact_integer_old_readout_transpose": true,
+  "expanded_old_readout_additions": 12065108,
+  "expanded_scalar_operations_per_stage": 12333688,
+  "forward_incidence_sha256": "4dc9ea5cbfe8727bb6d5e009b98c3bb33d740d5b5af79af9acf9a58f898b2f9c",
+  "h": 24,
+  "largest_readout_numerator_over_42": 40,
+  "literal_frame_incidences_both_directions": true,
+  "literal_global_scalar_groups": 49930865600,
+  "old_readout_coefficients_over_42_sha256": "fd8e31c159ad00071108ac2a45785d5544df76e1f95815d89621939965235d5e",
+  "reflected_incidence_sha256": "97a09ff5078809cfc20144d5b92b6ecdabb7298009f294c8b5376d32c2629aa2",
+  "reflected_residual_rank_histogram_equal": true,
+  "reflected_scalar_map": "X becomes X-Y; Y unchanged; all auxiliary coordinates restored.",
+  "reflected_word_rule": "Reverse literal order, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.",
+  "rejected_controls": [
+    "inverse-sign",
+    "uncomplemented-frame",
+    "signed-root-readout"
+  ],
+  "scope": "Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.",
+  "source_sha256": "6bea79108859a98523b3fc8ad9d374f28209c2d4fdf71b6edfc4ca685acfc3ad",
+  "two_stage_scalar_map": "(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.",
+  "v": 2024,
+  "word_blocks": 255658
+}
diff --git a/research/cube-deferred/reflection_audit.py b/research/cube-deferred/reflection_audit.py
new file mode 100644
index 0000000000..c036c36b4c
--- /dev/null
+++ b/research/cube-deferred/reflection_audit.py
@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""Literal inverse/reflection and exact finite scalar/frame audit.
+
+Captures an unchanged deferred producer before its output write, then checks
+the scalar computation on every source symbol, the exact signed old-readout
+transpose, the dependency cut and the complete complemented incidence ledger.
+This is finite verification; the inherited residual-to-child implementation,
+all-size transfer and analytic interfaces are not proved by this script.
+"""
+import ast
+from collections import Counter
+from functools import lru_cache
+from hashlib import sha256
+from itertools import combinations
+import argparse,json,pickle,sys
+from pathlib import Path
+sys.dont_write_bytecode=True
+assert not sys.flags.optimize,'Assertions must remain enabled'
+
+
+def capture(source):
+    source=Path(source).resolve();sys.path.insert(0,str(source.parent))
+    tree=ast.parse(source.read_text(),filename=str(source))
+    main=next(n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='main')
+    at=next(i for i,n in enumerate(main.body) if isinstance(n,ast.Expr) and isinstance(n.value,ast.Call) and isinstance(n.value.func,ast.Attribute) and n.value.func.attr=='write_text')
+    main.body[at:]=[ast.Return(ast.Call(ast.Name('locals',ast.Load()),[],[]))]
+    ast.fix_missing_locations(tree)
+    ns={'__file__':str(source),'__name__':'reflection_capture'}
+    exec(compile(tree,str(source)+' [read-only capture]','exec'),ns)
+    data=ns['main']();data['source']=str(source);return data
+
+
+def basis(vectors):
+    piv={}
+    for x in vectors:
+        for p in sorted(piv,reverse=True):
+            if x>>p&1:x^=piv[p]
+        if x:
+            p=x.bit_length()-1
+            for q in piv:
+                if piv[q]>>p&1:piv[q]^=x
+            piv[p]=x
+    return tuple(piv[p] for p in sorted(piv,reverse=True))
+
+
+def dot(a,b):return (a&b).bit_count()&1
+
+
+@lru_cache(None)
+def contained(A,B):return len(basis(A+B))==len(B)
+
+
+@lru_cache(None)
+def complement(A,h):
+    A=basis(A);piv={x.bit_length()-1:x for x in A};result=[]
+    for j in range(h):
+        if j not in piv:
+            x=1<<j
+            for p,row in piv.items():
+                if row>>j&1:x|=1<<p
+            result.append(x)
+    return basis(result)
+
+
+@lru_cache(None)
+def nondeg(A):
+    return len(basis(sum(dot(x,y)<<j for j,y in enumerate(A)) for x in A))==len(A)
+
+
+def root_readout(d,s):
+    h,v,j=d['h'],d['v'],d['role_root'][s];p=(1<<61)-1
+    if d['kind'][j]:
+        assert d['seed_c'][s]==[int(i==d['centre_of'][j]) for i in range(h)],'Root centre readout'
+        assert d['seed_d'][s]=={},'Root centre extra target'
+    else:
+        assert d['seed_c'][s] is None,'Root extra centre'
+        expected=pow(2,-1,p)*(1 if j<v else -1)%p
+        assert d['seed_d'][s]=={d['target'][j]:expected},'Root signed readout'
+
+
+@lru_cache(None)
+def dual_frames(A,B,h):
+    return len(A)+len(B)==h and all(not dot(x,y) for x in A for y in B)
+
+
+def check_reflection(forward,backward,h,v):
+    def bank(s):return s+v if s<v else s-v if s<2*v else s
+    assert len(forward)==len(backward),'Reflected event count'
+    for left,right in zip(reversed(forward),backward):
+        k,a,b,c,F,*tail=left;kk,aa,bb,cc,FF,*tt=right
+        assert kk==k and aa==bank(a) and cc==-c,'Reflected inverse shear'
+        assert bb==(bank(b) if k=='gate' else tuple(bank(t) for t in reversed(b))),'Reflected port incidence'
+        assert dual_frames(F,FF,h),'Reflected frame complement'
+        if k=='centre':
+            assert dual_frames(tail[0],tt[0],h) and tail[1:]==tt[1:],'Reflected centre copy'
+        else:assert tail==tt,'Reflected coefficient-row binding'
+
+
+def audit(d):
+    h,v,R=d['h'],d['v'],d['R'];ops=d['ops'];q=d['q'];p=(1<<61)-1
+    trip=list(combinations(range(h),3));assert d['trip']==trip
+    for s in d['role_root']:root_readout(d,s)
+    full=(1<<v)-1;point=[sum(1<<j for j,T in enumerate(trip) if i in T) for i in range(h)]
+    # All fresh-source coefficients, exactly over the integers. No modular
+    # replay is used for this check, and no stored DAG support is trusted.
+    nodes={};values=[0]*R
+    for n in d['order']:
+        a,b=d['args'][n]
+        if not a:nodes[n]=1<<(n-1)
+        else:
+            assert not nodes[a]&nodes[b],('DAG overlap',n)
+            nodes[n]=nodes[a]|nodes[b]
+    for s,n in d['leaf_of'].items():values[s]=1<<(n-1)
+    for o in ops:
+        if o[0]=='src':continue
+        a,b=(o[1],o[2]) if o[0]=='add' else (o[2],o[1])
+        assert not values[a]&values[b],('literal signal overlap',o)
+        values[a]|=values[b]
+        assert values[a]==nodes[o[3]],('literal source coefficients',o)
+    negative=[0]*v;positive=[None]*v;centres={}
+    for s,j in d['role_root'].items():
+        assert values[s]==nodes[d['roots'][j]]
+        if d['kind'][j]:centres[d['centre_of'][j]]=values[s]
+        elif j<v:
+            t=d['target'][j];assert positive[t] is None;positive[t]=values[s]
+        else:
+            t=d['target'][j];assert not negative[t]&values[s];negative[t]|=values[s]
+    assert set(centres)==set(range(h))
+    for i,S in centres.items():assert S==full^point[i]
+    for t,T in enumerate(trip):
+        A,B,C=(point[i] for i in T)
+        assert positive[t]==full^(A|B|C)
+        assert negative[t]==((A&B&~C)|(A&C&~B)|(B&C&~A))
+    assert h-3==21
+    assert [((k-1)+(k==0)-(k==2)) for k in range(4)]==[0,0,0,2]
+    # Every centre decoder coefficient is 1/21-[i in T]/2. Thus the
+    # preceding source-support identities prove J L V = I over Q.
+
+    # Independently form J L on arbitrary scratch as integer centre rows
+    # and signed half-output rows. Compare every coefficient, not hashes.
+    cc=[None]*R;dd=[{} for _ in range(R)]
+    for s,j in d['role_root'].items():
+        if d['kind'][j]:cc[s]=[int(i==d['centre_of'][j]) for i in range(h)]
+        else:dd[s][d['target'][j]]=1 if j<v else -1
+        assert cc[s]==d['seed_c'][s],'Root centre readout'
+        assert {t:(x*pow(2,-1,p))%p for t,x in dd[s].items()}==d['seed_d'][s],'Root signed readout'
+    def addrow(a,b):
+        if cc[b] is not None:
+            cc[a]=list(cc[b]) if cc[a] is None else [x+y for x,y in zip(cc[a],cc[b])]
+        for t,x in dd[b].items():dd[a][t]=dd[a].get(t,0)+x
+    for o in reversed(ops):
+        if o[0]=='add':addrow(o[2],o[1])
+        elif o[0]=='copy':addrow(o[1],o[2])
+    maxcoef=0;readcount=0;actual_reach={};coefficient_digest=sha256()
+    for s in range(R):
+        assert cc[s] is None and d['cvec'][s] is None or cc[s] is not None and [x%p for x in cc[s]]==d['cvec'][s]
+        assert {t:(x*pow(2,-1,p))%p for t,x in dd[s].items()}==d['dpart'][s]
+        # Exact expanded readout numerators over the single denominator42.
+        if cc[s] is None:
+            reached=tuple(t for t,x in sorted(dd[s].items()) if x)
+            maxcoef=max(maxcoef,max((abs(21*x) for x in dd[s].values()),default=0))
+            coefficient_digest.update(repr((s,[(t,21*dd[s][t]) for t in reached])).encode()+b'\n')
+        else:
+            total=2*sum(cc[s]);reached=[]
+            for t,T in enumerate(trip):
+                num=total-21*sum(cc[s][i] for i in T)+21*dd[s].get(t,0)
+                maxcoef=max(maxcoef,abs(num))
+                if num:
+                    reached.append(t)
+                    coefficient_digest.update(s.to_bytes(4,'little')+t.to_bytes(4,'little')+num.to_bytes(8,'little',signed=True))
+            reached=tuple(reached)
+        readcount+=len(reached);actual_reach[s]=reached
+    assert maxcoef<=42,'Expanded readout coefficient exceeds one in absolute value'
+    # Early/remainder order is a legal commutation of independent shears.
+    # Deferred inputs are untouched by the early word; completed centre
+    # roles are untouched by its remainder. These facts make deferred
+    # readout placement equivalent to the canonical -JL, V, L, J,L^-1,-V.
+    early=set(d['phase1']);assert early==set(d['Anc'])
+    assert sorted(d['phase1'])==d['phase1'] and d['rest']==[i for i in range(len(ops)) if i not in early]
+    seen_late=set();early_touched=set();late_touched=set()
+    for i,o in enumerate(ops):
+        touched=set(o[1:3]) if o[0] in ('add','copy') else set()
+        if i in early:
+            assert not touched&seen_late;early_touched.update(touched)
+        else:seen_late.update(touched);late_touched.update(touched)
+    assert not set(d['deferred'])&early_touched
+    assert not set(d['centre_roles'])&late_touched
+    assert all(cc[s] is None for s in d['deferred'])
+    for s in d['deferred']:assert set(actual_reach[s])<=set(d['reach'][s])
+
+    # Frame-labelled literal chronological word. Readout blocks mean the
+    # explicit commuting additions to their individual named target ports;
+    # their scalar count and target incidences are expanded above.
+    ZERO=();FULL=basis(1<<i for i in range(h))
+    U={n:basis(B) for n,B in d['U'].items()}
+    sigma={s:basis(B) for s,B in d['placed'].items()}
+    rootframe={s:basis(B) for s,B in d['root_frame'].items()}
+    tm=[basis((sum(1<<i for i in T),)) for T in trip]
+    X=lambda t:t;Y=lambda t:v+t;A=lambda s:2*v+s
+    word=[]
+    def gate(a,b,c,F):word.append(('gate',a,b,c,F))
+    def read(s,sgn,F,targets,row):word.append(('read',A(s),tuple(Y(t) for t in targets),sgn,F,row))
+    def run(i,sign=1,F=None):
+        o=ops[i]
+        if o[0]=='add':gate(A(o[1]),A(o[2]),sign,U[o[3]] if F is None else F)
+        elif o[0]=='copy':gate(A(o[2]),A(o[1]),sign,U[o[3]] if F is None else F)
+    deferred=set(d['deferred'])
+    for s in range(R):
+        if s not in deferred:read(s,-1,ZERO,actual_reach[s],('old',s))
+    for s,n in d['leaf_of'].items():
+        if s not in deferred:gate(A(s),X(n-1),1,U[n])
+    for i in d['phase1']:run(i)
+    for s in d['centre_roles']:word.append(('centre',A(s),tuple(Y(t) for t in range(v)),1,rootframe[s],ZERO,d['centre_of'][d['role_root'][s]]))
+    for s in d['deferred']:read(s,-1,sigma[s],actual_reach[s],('old',s))
+    for s in d['deferred']:
+        if s in d['leaf_of']:n=d['leaf_of'][s];gate(A(s),X(n-1),1,U[n])
+    for i in d['rest']:run(i)
+    for s,j in d['role_root'].items():
+        if not d['kind'][j]:read(s,1,rootframe[s],(d['target'][j],),('root',21 if j<v else -21))
+    for i in reversed(range(len(ops))):run(i,-1,FULL)
+    for s,n in d['leaf_of'].items():gate(A(s),X(n-1),-1,FULL)
+
+    def swap(s):return s+v if s<v else s-v if s<2*v else s
+    def reflect(event):
+        k,a,b,c,F,*rest=event
+        if k=='gate':return (k,swap(a),swap(b),-c,complement(F,h))
+        tail=(complement(rest[0],h),rest[1]) if k=='centre' else tuple(rest)
+        return (k,swap(a),tuple(swap(t) for t in reversed(b)),-c,complement(F,h),*tail)
+    reverse=[reflect(e) for e in reversed(word)]
+    assert [reflect(e) for e in reversed(reverse)]==word
+    check_reflection(word,reverse,h,v)
+    # Reuse this exact captured word for targeted failure controls.
+    rejected=[]
+    for failure in ('inverse-sign','uncomplemented-frame'):
+        damaged=list(reverse);first=list(damaged[0])
+        if failure=='inverse-sign':first[3]*=-1
+        else:first[4]=word[-1][4]
+        damaged[0]=tuple(first)
+        try:check_reflection(word,damaged,h,v)
+        except AssertionError:rejected.append(failure)
+        else:raise AssertionError('Accepted reflection mutation: '+failure)
+    s=next(s for s,j in d['role_root'].items() if not d['kind'][j]);original=d['seed_d'][s]
+    d['seed_d'][s]={t:(-c)%p for t,c in original.items()}
+    try:
+        try:root_readout(d,s)
+        except AssertionError:rejected.append('signed-root-readout')
+        else:raise AssertionError('Accepted signed root mutation')
+    finally:d['seed_d'][s]=original
+
+    def framescan(events,initial,expected):
+        current=list(initial);hist=Counter();copies=Counter();scalar=0;digest=sha256()
+        def promote(s,F):
+            old=current[s];assert contained(old,F),(s,old,F)
+            assert nondeg(F);assert nondeg(complement(F,h))
+            if len(F)>len(old):hist[len(F)-len(old)]+=1
+            current[s]=F
+        for event in events:
+            k,a,b,c,F,*rest=event
+            assert c in (-1,1)
+            promote(a,F)
+            if k=='gate':promote(b,F);scalar+=1
+            elif k=='read':
+                for t in b:promote(t,F)
+                scalar+=len(b)
+            else:
+                assert k=='centre';G=rest[0]
+                assert contained(G,F) or contained(F,G)
+                assert nondeg(G);copies[abs(len(F)-len(G))]+=1
+                for t in b:promote(t,G)
+                scalar+=len(b)+2 # temporary copy and erasure
+            digest.update(repr(event).encode()+b'\n')
+        # Each literal role cleanup reaches full space; any unused final
+        # endpoint is still represented explicitly in the expected chain.
+        for s,F in enumerate(expected):promote(s,F)
+        assert current==expected
+        return hist,copies,scalar,digest.hexdigest()
+    start=tm+[ZERO]*v+[sigma.get(s,ZERO) for s in range(R)]
+    finish=[FULL]*v+[complement(T,h) for T in tm]+[FULL]*R
+    H,C,scalar,digest=framescan(word,start,finish)
+    revstart=[None]*len(start);revfinish=[None]*len(start)
+    for s in range(len(start)):
+        revstart[swap(s)]=complement(finish[s],h);revfinish[swap(s)]=complement(start[s],h)
+    HR,CR,scalarR,reverse_digest=framescan(reverse,revstart,revfinish)
+    assert (H,C,scalar)==(HR,CR,scalarR)
+    z=Counter({r:2*v*n for r,n in (H+C).items()})
+    for s in range(R):z[h*h-h+len(sigma.get(s,ZERO))]+=2*v
+    z[(h-1)**2]+=2*v*v;z[1]+=v*v
+    z.pop(0,None)
+    assert dict(sorted(z.items()))=={int(r):n for r,n in d['out']['child_multiplicities'].items()},'Literal reflected child histogram'
+    assert sum(r*n for r,n in z.items())==d['out']['total_rank']
+    G=v*v+2*v*scalar
+    safe=8*(d['c_add']+2*R+(R+q)*v*(h+1)+h*h+h+1) if 'c_add' in d else 8*(d['out']['additions']+2*R+(R+q)*v*(h+1)+h*h+h+1)
+    assert safe>=scalar
+    return dict(h=h,v=v,R=R,exact_fresh_source_map=True,exact_integer_old_readout_transpose=True,
+                exact_arbitrary_dirty_cancellation_by_dependency_cut=True,
+                reflected_word_rule='Reverse literal order, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.',
+                reflected_scalar_map='X becomes X-Y; Y unchanged; all auxiliary coordinates restored.',
+                two_stage_scalar_map='(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.',
+                literal_frame_incidences_both_directions=True,all_frames_nondegenerate=True,
+                reflected_residual_rank_histogram_equal=True,child_multiplicities=dict(sorted(z.items())),
+                word_blocks=len(word),expanded_scalar_operations_per_stage=scalar,
+                expanded_old_readout_additions=readcount,largest_readout_numerator_over_42=maxcoef,
+                old_readout_coefficients_over_42_sha256=coefficient_digest.hexdigest(),
+                literal_global_scalar_groups=G,conservative_local_G=safe,
+                forward_incidence_sha256=digest,reflected_incidence_sha256=reverse_digest,
+                rejected_controls=rejected,
+                scope='Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.')
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path);ap.add_argument('--state',type=Path)
+    ap.add_argument('--output',type=Path);ap.add_argument('--check',type=Path);a=ap.parse_args()
+    assert bool(a.source)!=bool(a.state)
+    d=capture(a.source) if a.source else pickle.loads(a.state.read_bytes())
+    result=audit(d);source=Path(d['source'])
+    result['source_sha256']=sha256(source.read_bytes()).hexdigest()
+    result['audit_sha256']=sha256(Path(__file__).read_bytes()).hexdigest()
+    result=json.loads(json.dumps(result));encoded=json.dumps(result,indent=2,sort_keys=True)+'\n'
+    if a.check:assert result==json.loads(a.check.read_text())
+    if a.output:a.output.write_text(encoded)
+    else:print(encoded,end='')
+    print('PASS exact scalar and literal complement reflection audit',file=sys.stderr)
+
+
+if __name__=='__main__':main()
diff --git a/research/cube-deferred/test_controls.py b/research/cube-deferred/test_controls.py
new file mode 100644
index 0000000000..622887c74d
--- /dev/null
+++ b/research/cube-deferred/test_controls.py
@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Negative controls for the cyclic/deferred frozen finite witness.
+
+These controls target source omissions, altered inputs, paid rank accounting,
+noncontracting children and invalid exact arithmetic. They do not substitute
+for the full producer and literal reflection checks. Prepared for eumemic with
+OpenAI Codex assistance; Apache-2.0, inherited notices retained.
+"""
+import sys
+sys.dont_write_bytecode = True
+if sys.flags.optimize:
+    raise ValueError('Negative controls require assertions')
+
+import argparse
+import copy
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+
+from verify import check_sources, compare_json, safe_file, validate_profile
+
+HERE = Path(__file__).resolve().parent
+REPOSITORY = HERE.parents[1]
+
+
+class FrozenControls(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.manifest = check_sources(HERE, REPOSITORY)
+        cls.profiles = {label: json.loads((HERE / (label + '-profile.json')).read_text())
+                        for label in ('bit', 'complex')}
+        sys.path.insert(0, str(REPOSITORY / 'scripts'))
+        spec = importlib.util.spec_from_file_location('checked_cyclic_certificate', HERE / 'certificate.py')
+        cls.certificate = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(cls.certificate)
+        cls.certificate.ROOT = REPOSITORY
+
+    def test_all_frozen_profiles_satisfy_physical_ledgers(self):
+        for label, profile in self.profiles.items():
+            validate_profile(profile, label)
+
+    def test_frozen_exact_certificate_recomputed(self):
+        expected = json.loads((HERE / 'certificate.json').read_text())
+        actual = self.certificate.js(self.certificate.exact())
+        self.assertEqual(actual, expected)
+
+    def test_previous_pr114_profile_rejects_new_complex_saving(self):
+        old = json.loads((REPOSITORY / 'research/cyclic-deferred/complex-profile.json').read_text())
+        old['child_multiplicities'] = {int(k): v for k,v in old['child_multiplicities'].items()}
+        self.assertFalse(self.certificate.contracts(old, self.certificate.COMPLEX))
+
+    def test_omitted_endpoint_charge_rejected(self):
+        for label, original in self.profiles.items():
+            changed = copy.deepcopy(original)
+            changed['child_multiplicities']['1'] -= changed['N']
+            with self.assertRaisesRegex(ValueError, 'rank mass'):
+                validate_profile(changed, label)
+
+    def test_nonshrinking_recursive_child_rejected(self):
+        for label, original in self.profiles.items():
+            changed = copy.deepcopy(original)
+            changed['child_multiplicities'][str(changed['m'])] = 1
+            with self.assertRaisesRegex(ValueError, 'recursive child'):
+                validate_profile(changed, label)
+
+    def test_understated_role_count_rejected(self):
+        changed = copy.deepcopy(self.profiles['complex'])
+        changed['R'] -= 1
+        with self.assertRaisesRegex(ValueError, 'physical ledger'):
+            validate_profile(changed, 'complex')
+
+    def test_overstated_matching_rejected(self):
+        changed = copy.deepcopy(self.profiles['complex'])
+        changed['links'] += 1
+        with self.assertRaisesRegex(ValueError, 'matching role ledger'):
+            validate_profile(changed, 'complex')
+
+    def test_missing_transitive_dependency_rejected(self):
+        changed = copy.deepcopy(self.manifest)
+        del changed['repository_files']['scripts/exclusion_circuit.py']
+        with self.assertRaisesRegex(ValueError, 'dependency closure'):
+            check_sources(HERE, REPOSITORY, changed)
+
+    def test_omitted_physical_input_rejected(self):
+        changed = copy.deepcopy(self.manifest)
+        del changed['package_files']['inputs/deferred_23.json.gz']
+        with self.assertRaisesRegex(ValueError, 'finite-input closure'):
+            check_sources(HERE, REPOSITORY, changed)
+
+    def test_changed_input_digest_rejected(self):
+        changed = copy.deepcopy(self.manifest)
+        changed['package_files']['inputs/witness_23.json.gz'] = '0' * 64
+        with self.assertRaisesRegex(ValueError, 'hash mismatch'):
+            check_sources(HERE, REPOSITORY, changed)
+
+    def test_manifest_parent_escape_rejected(self):
+        with self.assertRaisesRegex(ValueError, 'Unsafe manifest path'):
+            safe_file(HERE, '../certificate.json')
+
+    def test_changed_regenerated_profile_rejected(self):
+        with tempfile.TemporaryDirectory(prefix='cyclic-deferred-negative-') as directory:
+            changed = copy.deepcopy(self.profiles['complex'])
+            changed['child_multiplicities']['1'] += 1
+            path = Path(directory) / 'changed.json'
+            path.write_text(json.dumps(changed))
+            with self.assertRaisesRegex(ValueError, 'Frozen generated record mismatch'):
+                compare_json(path, HERE / 'complex-profile.json')
+
+    def test_next_bit_and_complex_grid_points_rejected(self):
+        from fractions import Fraction as Q
+        module = self.certificate
+        self.assertFalse(module.contracts(module.profile('bit-profile.json'), module.COARSE + Q(1, 10**10)))
+        self.assertFalse(module.contracts(module.profile('complex-profile.json'), module.COMPLEX + Q(1, 10**12)))
+
+    def test_optimized_verifier_rejected_before_any_regeneration(self):
+        result = subprocess.run([sys.executable, '-O', str(HERE / 'verify.py')],
+                                capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn('optimized Python is forbidden', result.stderr)
+
+
+def main():
+    global REPOSITORY
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--repository-root', type=Path, default=REPOSITORY)
+    args = parser.parse_args()
+    REPOSITORY = args.repository_root.resolve()
+    suite = unittest.defaultTestLoader.loadTestsFromTestCase(FrozenControls)
+    result = unittest.TextTestRunner(verbosity=2).run(suite)
+    if not result.wasSuccessful():
+        raise SystemExit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/cube-deferred/verify.py b/research/cube-deferred/verify.py
new file mode 100644
index 0000000000..c198ee1ff6
--- /dev/null
+++ b/research/cube-deferred/verify.py
@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""Read-only verification of the frozen cyclic/deferred finite package.
+
+Regeneration occurs only in a temporary repository-shaped copy. Source hashes,
+complete profile ledgers, the exact certificate, and the independent reflection
+audit are required. General transfer proofs and the inherited round-seven bit
+word/frame justification remain separate dependencies. Prepared for eumemic
+with OpenAI Codex assistance; inherited authorship and licenses are retained.
+"""
+import sys
+sys.dont_write_bytecode = True
+if sys.flags.optimize:
+    raise ValueError('Verification requires assertions; optimized Python is forbidden')
+
+import argparse
+import ast
+from hashlib import sha256
+import json
+from math import comb
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+BIT_PINS = {
+    'witness_23.json.gz': 'b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588',
+    'deferred_23.json.gz': '8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c',
+}
+REQUIRED = {
+    'verify.py', 'test_controls.py', 'producer.py', 'complex_deferred.py',
+    'bit_round7.py', 'certificate.py', 'bit-profile.json',
+    'complex-profile.json', 'certificate.json', 'README.md', 'PROOF.md',
+    *('inputs/' + name for name in BIT_PINS),
+}
+DATA_DEPENDENCIES = {'certificates/copied-centers-network.json', 'research/cyclic-deferred/complex-profile.json'}
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def safe_file(directory, name):
+    relative = Path(name)
+    require(not relative.is_absolute() and '..' not in relative.parts,
+            'Unsafe manifest path: ' + name)
+    path = (directory / relative).resolve()
+    require(path.is_relative_to(directory.resolve()) and path.is_file(),
+            'Missing or escaping manifest file: ' + name)
+    return path
+
+
+def digest(path):
+    return sha256(path.read_bytes()).hexdigest()
+
+
+def dependency_closure(package, repository, package_scripts):
+    """Include every local Python import, including package __init__ modules.
+
+    All package scripts are roots, also covering explicit importlib loading of
+    the producer and audited source. Only stdlib imports may be unresolved.
+    The sole external data read used by exact assembly is listed separately.
+    """
+    pending = [package / name for name in package_scripts]
+    seen, dependencies = set(), set(DATA_DEPENDENCIES)
+    while pending:
+        path = pending.pop().resolve()
+        if path in seen:
+            continue
+        seen.add(path)
+        imports = []
+        for node in ast.walk(ast.parse(path.read_text(), filename=str(path))):
+            if isinstance(node, ast.Import):
+                imports.extend((alias.name, 0) for alias in node.names)
+            elif isinstance(node, ast.ImportFrom) and node.module:
+                imports.append((node.module, node.level))
+        for name, level in imports:
+            parts = name.split('.')
+            if not level and parts[0] in sys.stdlib_module_names:
+                continue
+            found = None
+            bases = ((path.parent.parents[level-2] if level > 1 else path.parent),) if level else (package, repository / 'scripts')
+            for base in bases:
+                module = base.joinpath(*parts)
+                for candidate in (module.with_suffix('.py'), module / '__init__.py'):
+                    if candidate.is_file():
+                        found = candidate.resolve()
+                        break
+                if found is not None:
+                    pending.append(found)
+                    if found.is_relative_to((repository / 'scripts').resolve()):
+                        dependencies.add(str(found.relative_to(repository.resolve())))
+                        parent = found.parent
+                        while parent != (repository / 'scripts').resolve():
+                            initializer = parent / '__init__.py'
+                            if initializer.is_file():
+                                pending.append(initializer)
+                                dependencies.add(str(initializer.relative_to(repository)))
+                            parent = parent.parent
+                    break
+            require(found is not None, 'Unpinned non-stdlib Python import: ' + name)
+    return dependencies
+
+
+def create_manifest(package, repository, reflection_script, reflection_receipt):
+    scripts = sorted(path.name for path in package.glob('*.py'))
+    names = REQUIRED | set(scripts) | {reflection_script, reflection_receipt}
+    dependencies = dependency_closure(package, repository, scripts)
+    return dict(
+        schema=1,
+        scope='Frozen finite producer, profiles, exact assembly and reflection audit; inherited all-size transfer remains conditional.',
+        package_files={name: digest(safe_file(package, name)) for name in sorted(names)},
+        repository_files={name: digest(safe_file(repository, name)) for name in sorted(dependencies)},
+        reflection=dict(script=reflection_script, receipt=reflection_receipt),
+        provenance=dict(
+            base='https://github.com/CrocSwap/integer-mult-bounds/pull/114',
+            base_commit='51cd8934128be37830981ca391d3d6fd28b0fce8',
+            cube='https://github.com/CrocSwap/integer-mult-bounds/pull/115',
+            cube_commit='cf60442983c153a3a0f5272ea4713f99eba13c86',
+            cyclic_strips='https://github.com/CrocSwap/integer-mult-bounds/pull/111',
+            core_aware_pair_assembly='https://github.com/CrocSwap/integer-mult-bounds/pull/62',
+            round7_repository='https://github.com/Swapnil-jain/integer-mult-kappa',
+            round7_commit='741e7aa078392553815df7926ee17ac5e25a8c38',
+            round7_sha256=BIT_PINS),
+        attribution='Avi Eisenberg / ikeboy (PR62 and PR110, Anthropic Claude assistance); Rohan Arun (PR111, Anthropic Claude assistance); Swapnil Jain (round-seven bit word); icekylinx (retained stopped-product, copied-center and finite assembly interfaces); Zhihao Chen and RaD (retained assembly). Core-aware pair transfer, integration and verification for eumemic with OpenAI Codex assistance. Original source notices remain authoritative.')
+
+
+def check_sources(package, repository, manifest=None):
+    manifest = manifest or json.loads((package / 'SOURCE.json').read_text())
+    require(manifest['schema'] == 1, 'Unsupported source-manifest schema')
+    names = set(manifest['package_files'])
+    reflection = manifest['reflection']
+    require(REQUIRED | {reflection['script'], reflection['receipt']} <= names,
+            'Incomplete package source/finite-input closure')
+    for collection, base in ((manifest['package_files'], package),
+                             (manifest['repository_files'], repository)):
+        for name, expected in collection.items():
+            require(digest(safe_file(base, name)) == expected, 'Source hash mismatch: ' + name)
+    scripts = sorted(name for name in names if name.endswith('.py'))
+    expected = dependency_closure(package, repository, scripts)
+    require(set(manifest['repository_files']) == expected,
+            'Incomplete or stale transitive repository dependency closure')
+    for name, expected in BIT_PINS.items():
+        require(manifest['package_files']['inputs/' + name] == expected,
+                'Round-seven provenance digest mismatch: ' + name)
+    return manifest
+
+
+def validate_profile(profile, label):
+    fields = ('h', 'v', 'R', 'm', 'N', 'W', 'L', 'total_rank', 'deficit', 'maxchild')
+    require(all(type(profile[key]) is int and profile[key] > 0 for key in fields),
+            label + ': nonpositive or noninteger ledger value')
+    h, v, R, m, N, W, L = (profile[key] for key in fields[:7])
+    require(v == comb(h, 3) and m == h*h and N == v*v, label + ': dimensions')
+    require(W == 2*N + 2*v*R and L == 2*v*h*(h-1), label + ': physical ledger')
+    rows = {int(t): count for t, count in profile['child_multiplicities'].items()}
+    require(len(rows) == len(profile['child_multiplicities']), label + ': duplicate child widths')
+    require(all(0 < t < m and type(count) is int and count > 0 for t, count in rows.items()),
+            label + ': invalid recursive child')
+    require(sum(t*count for t, count in rows.items()) == profile['total_rank'] == W*m-N+L,
+            label + ': rank mass')
+    require(profile['deficit'] == N-L and profile['maxchild'] == max(rows),
+            label + ': deficit or maximum child')
+    require(rows.get((h-1)**2) == 2*N and rows.get(1, 0) >= N,
+            label + ': omitted data projector or endpoint charge')
+    if label == 'complex':
+        require(R == profile['additions']+profile['roots']-profile['links'],
+                'complex: addition/roots/matching role ledger')
+        require(sum(profile['deferred_dims'].values()) == profile['deferred_roles'],
+                'complex: deferral inventory')
+    return rows
+
+
+def compare_json(actual, expected):
+    require(json.loads(actual.read_text()) == json.loads(expected.read_text()),
+            'Frozen generated record mismatch: ' + expected.name)
+
+
+def snapshot(package, repository, manifest):
+    return {
+        **{'package:' + n: digest(package / n) for n in manifest['package_files']},
+        **{'repository:' + n: digest(repository / n) for n in manifest['repository_files']},
+        'manifest': digest(package / 'SOURCE.json'),
+    }
+
+
+def verify(package, repository):
+    manifest = check_sources(package, repository)
+    before = snapshot(package, repository, manifest)
+    for label in ('bit', 'complex'):
+        validate_profile(json.loads((package / (label + '-profile.json')).read_text()), label)
+    environment = dict(os.environ, PYTHONDONTWRITEBYTECODE='1')
+    environment.pop('PYTHONPATH', None)
+    with tempfile.TemporaryDirectory(prefix='cyclic-deferred-verify-') as directory:
+        root = Path(directory)
+        target = root / 'research/cube-deferred'
+        for collection, source, destination in (
+                (manifest['package_files'], package, target),
+                (manifest['repository_files'], repository, root)):
+            for name in collection:
+                out = destination / name
+                out.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(source / name, out)
+        shutil.copyfile(package / 'SOURCE.json', target / 'SOURCE.json')
+
+        def run(script, *arguments):
+            subprocess.run([sys.executable, str(target / script), *map(str, arguments)],
+                           cwd=root, env=environment, check=True)
+
+        run('bit_round7.py', target / 'inputs')
+        compare_json(target / 'bit-profile.json', package / 'bit-profile.json')
+        print('PASS pinned round-seven bit ledger regenerated', flush=True)
+        run('complex_deferred.py')
+        compare_json(target / 'complex-profile.json', package / 'complex-profile.json')
+        print('PASS complete complex producer and deferred profile regenerated', flush=True)
+        run('certificate.py')
+        reflection = manifest['reflection']
+        actual_reflection = root / 'actual-reflection.json'
+        run(reflection['script'], '--source', target / 'complex_deferred.py',
+            '--output', actual_reflection)
+        compare_json(actual_reflection, package / reflection['receipt'])
+        print('PASS independent literal reflection and scalar-charge audit', flush=True)
+        run('test_controls.py', '--repository-root', root)
+    require(snapshot(package, repository, manifest) == before,
+            'Verification changed the frozen package or a dependency')
+    print('PASS read-only finite package verification; inherited transfer remains conditional', flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--repository-root', type=Path, default=HERE.parents[1])
+    parser.add_argument('--freeze-manifest', action='store_true',
+                        help='Explicit authoring operation: replace SOURCE.json from reviewed files')
+    parser.add_argument('--reflection-script', default='reflection_audit.py')
+    parser.add_argument('--reflection-receipt', default='reflection-audit.json')
+    args = parser.parse_args()
+    repository = args.repository_root.resolve()
+    if args.freeze_manifest:
+        manifest = create_manifest(HERE, repository, args.reflection_script, args.reflection_receipt)
+        (HERE / 'SOURCE.json').write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n')
+        print('Frozen source manifest; this operation does not certify the package')
+    else:
+        verify(HERE, repository)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/cyclic-deferred/README.md b/research/cyclic-deferred/README.md
new file mode 100644
index 0000000000..053338080c
--- /dev/null
+++ b/research/cyclic-deferred/README.md
@@ -0,0 +1,65 @@
+# Core-aware cyclic strips with deferred readouts
+
+Conditional **κ = 9.4744627892e-5 = 23686156973/250000000000000**.
+Human-readable form: **κ ≈ 94744627892/10¹⁵ > 2⁻¹⁴**.
+
+Concurrent PR113 independently publishes the direct PR110+PR111 combination.
+This package adds the core-aware pair refinement and independent reflection audit.
+
+This combines PR111's cyclic strip / dual-suffix complex producer with PR110's
+lifted frames and deferred readouts, then replaces the contracted pair
+subproblems with PR62's core-aware pair assembly and balanced column coarse
+sums from PR69. The bit supplier remains Swapnil Jain's pinned round-seven
+word under PR104's stopped product-ring interface.
+
+The resulting complex word has 68,800 additions, 39,061 carrier links,
+37,859 roles, 5,182 deferred roles, W = 161,446,384 and largest child 574 of
+576. Every center, copied-center loss, exterior child, data correction and
+endpoint copy remains charged. Its strict complex saving is
+47381341/500000000000 = 9.4762682e-5. The stopped bit saving is
+1240189553/10¹³ = 1.240189553e-4, so the complex side still limits κ.
+
+On the same deferred compiler, the direct PR110+PR111 combination has
+38,506 roles and complex saving 9.3925307e-5. The core-aware pair change
+improves that complete profile by about 0.89%; it is not a scalar-count-only
+claim. A cyclic pair-star variant reduced roles further but worsened the
+moment and was rejected.
+
+Run `python3 research/cyclic-deferred/verify.py` from the repository root.
+The default verifier preserves frozen inputs and regenerates into a temporary
+checkout. `test_controls.py` exercises corrupted inputs and unpaid costs.
+`certificate.py` checks the frozen exact arithmetic certificate; its explicit
+`--write` option is for authoring a new certificate.
+
+The producer checks all exact source supports, rational center scatter and
+inherited binary-frame rules. The role compiler checks every chain,
+nondegeneracy and nested deferred target chain, and replays arbitrary scratch
+and data over Z/(2^61-1). The separate reflection audit checks the literal
+inverse word after swapping data banks and the complemented frame chains.
+These finite checks do not formally prove all-size transfer.
+
+The exact assembly includes both moments, the stopped ordinary-bit saving,
+three product-row reserves, all 47 strict constraints and seven margins, and
+next-grid rejection. Expanded old-readout scalar operations are charged with
+an explicit conservative upper bound, rather than reusing the original DAG's
+addition count. Enlarging this guard changes precision constants and eventual
+thresholds; it does not increase the claimed exponent.
+
+All PR104/PR110 transfer hypotheses remain: simultaneous rational bases and
+opposite-bank factorization for the listed residuals, stopped atom streaming,
+ordinary wrapper, translated complex endpoint gauges, exact odd-denominator
+grid, routing, recovery, prime selection, analytic estimates and fixed-tape
+implementation. This is a finite conditional witness, not an unconditional
+multiplication theorem or a practical running-time claim.
+
+Credits: icekylinx (stopped products, rational centers and PR104); Avi Eisenberg
+/ ikeboy (PR62 pair assembly and PR110 complex deferred construction, with
+Anthropic Claude assistance); Rohan Arun (PR111 cyclic-strip integration,
+with Anthropic Claude assistance); Rohan Gupta / gupt1156 (PR55 dual-suffix
+identity); Swapnil Jain (deferred readouts, lifted frames, V leaves and the
+round-seven bit word); Zhihao Chen / jacklightChen (reflected bit integration,
+translated gauges and semantic/bulk assembly); Aurel Prosz / Paureel
+(two-stage topology); RaD / hipotures (analytic and tape interfaces); eumemic
+(PR69 balanced coarse columns and this integration). All inherited NOTICE,
+SOURCES and license attributions remain. This package was prepared for the
+repository contributor eumemic with substantial OpenAI Codex assistance.
diff --git a/research/cyclic-deferred/SOURCE.json b/research/cyclic-deferred/SOURCE.json
new file mode 100644
index 0000000000..fe4319d3a6
--- /dev/null
+++ b/research/cyclic-deferred/SOURCE.json
@@ -0,0 +1,61 @@
+{
+  "attribution": "Avi Eisenberg / ikeboy (PR62 and PR110, Anthropic Claude assistance); Rohan Arun (PR111, Anthropic Claude assistance); Swapnil Jain (round-seven bit word); icekylinx (retained stopped-product, copied-center and finite assembly interfaces); Zhihao Chen and RaD (retained assembly). Core-aware pair transfer, integration and verification for eumemic with OpenAI Codex assistance. Original source notices remain authoritative.",
+  "package_files": {
+    "bit-profile.json": "7293f330518b78650bd86d76b93681e43f3a55541cdb8110993714148a4b4a6a",
+    "bit_round7.py": "35d261a9248c2e06f9179e3c47e554a96b8fe763a9a3de2731256b8c0fbc74b0",
+    "certificate.json": "bd69dcc64b21eaa8a2ba0e569d78fde4834ec9e536168859a981ba757fbd566a",
+    "certificate.py": "9dc3b76a284945448be754715e971d644cccd815387fe17c1d2b04b93a0e2a64",
+    "complex-profile.json": "6b6c8a40a1d27cd792e12feb42baba91d792caafe49c476527b3ce79511c7da5",
+    "complex_deferred.py": "de328c6eda1863375a21f5b81689739001fb05411873c2ac70470ddfafe3286c",
+    "core_pair_block.py": "b97da88c5635688859b3330b66dd64756e28e3713da88954d519f8ea3a3f9568",
+    "inputs/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+    "inputs/witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+    "producer.py": "0ca95666c48a86ed68cf35b59f725e51228fdc849600d15cd6e645fb30d764b9",
+    "reflection-audit.json": "28657ec3dc72b20d9e7017cb71170d7ac1de27439aa50ef05ca9bce2e6c5ac43",
+    "reflection_audit.py": "7f534ddc406b1454f71831790b0f519007fa4120a025a30fe162ef9c9215a9d7",
+    "test_controls.py": "ebf8483b78de88edaf77737326e5c2e7b60e8b68851cc310b47b0b8ad8ea5280",
+    "verify.py": "51c3818e4842f73ba6a4330f7e6527ac4d70d90996eb201100d0a9b81ea560ae"
+  },
+  "provenance": {
+    "base": "https://github.com/CrocSwap/integer-mult-bounds/pull/110",
+    "core_aware_pair_assembly": "https://github.com/CrocSwap/integer-mult-bounds/pull/62",
+    "cyclic_strips": "https://github.com/CrocSwap/integer-mult-bounds/pull/111",
+    "round7_commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+    "round7_repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+    "round7_sha256": {
+      "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+      "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588"
+    }
+  },
+  "reflection": {
+    "receipt": "reflection-audit.json",
+    "script": "reflection_audit.py"
+  },
+  "repository_files": {
+    "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf",
+    "scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1",
+    "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e",
+    "scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f",
+    "scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1",
+    "scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b",
+    "scripts/copied_centers/__init__.py": "13db4f09038a2ff5335cbd4dbd93274b0fb16b3c7b51e4de67cbb2801a3f78e1",
+    "scripts/copied_centers/corners.py": "9eecdc39c67cc18c806a33f0be03986c28591d322881fd60c11f52c625c8067b",
+    "scripts/copied_centers/physical.py": "837345d1f8753eab0e70f105b1d1bb0db965b993da037b1825ddef3672609d7d",
+    "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9",
+    "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0",
+    "scripts/fast_gaussian.py": "11430c2df0783b933dc91080595bb7514bb052b8c7b12107e27a1ef701e31e43",
+    "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2",
+    "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7",
+    "scripts/paired_triple_circuit.py": "8f5f2de32fdbd8e0005154638660ff416e5a8cd59623bd0dc03f6f7f97ce2fb1",
+    "scripts/partial_swap/__init__.py": "0438eaa34134600467a5864f93c3e15142eb025b35cef189c2e969cffea72a7f",
+    "scripts/partial_swap/binary.py": "d32d7a23548cc738e974e8e55dd1fa2a8b11d2b80228515617ffe35410bb8805",
+    "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782",
+    "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947",
+    "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a",
+    "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba",
+    "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697",
+    "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d"
+  },
+  "schema": 1,
+  "scope": "Frozen finite producer, profiles, exact assembly and reflection audit; inherited all-size transfer remains conditional."
+}
diff --git a/research/cyclic-deferred/bit-profile.json b/research/cyclic-deferred/bit-profile.json
new file mode 100644
index 0000000000..36105e819a
--- /dev/null
+++ b/research/cyclic-deferred/bit-profile.json
@@ -0,0 +1,69 @@
+{
+ "h": 23,
+ "v": 1771,
+ "R": 28866,
+ "m": 529,
+ "N": 3136441,
+ "W": 108516254,
+ "L": 1792252,
+ "total_rank": 57403754177,
+ "deficit": 1344189,
+ "maxchild": 528,
+ "deferred_slots": 11565,
+ "source": {
+  "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+  "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+  "sha256": {
+   "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+   "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c"
+  }
+ },
+ "child_multiplicities": {
+  "1": 239511811,
+  "2": 238288050,
+  "3": 53377940,
+  "4": 46970462,
+  "5": 23632224,
+  "6": 7409864,
+  "7": 4105178,
+  "8": 5755750,
+  "9": 2082696,
+  "10": 878416,
+  "11": 1388464,
+  "12": 1080310,
+  "13": 945714,
+  "14": 226688,
+  "15": 2451064,
+  "16": 1508892,
+  "17": 4771074,
+  "18": 2149994,
+  "19": 7367360,
+  "20": 8182020,
+  "21": 1466388,
+  "22": 88550,
+  "484": 6272882,
+  "506": 61280142,
+  "507": 545468,
+  "508": 173558,
+  "509": 293986,
+  "510": 580888,
+  "511": 14168,
+  "512": 322322,
+  "513": 17710,
+  "514": 1129898,
+  "515": 127512,
+  "516": 410872,
+  "517": 99176,
+  "518": 1186570,
+  "519": 340032,
+  "520": 322322,
+  "521": 106260,
+  "522": 1583274,
+  "523": 626934,
+  "524": 2854852,
+  "525": 13711082,
+  "526": 4629394,
+  "527": 5653032,
+  "528": 6233920
+ }
+}
diff --git a/research/cyclic-deferred/bit_round7.py b/research/cyclic-deferred/bit_round7.py
new file mode 100644
index 0000000000..3c5df409a6
--- /dev/null
+++ b/research/cyclic-deferred/bit_round7.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""One-child bit profile of Swapnil Jain's round-seven deferred word (h=23), under PR104's opposite-bank rule.
+
+Reads the two frozen round-seven data files (vendored in inputs/; pinned by SHA-256 below) from a directory given on
+the command line, e.g. a checkout of https://github.com/Swapnil-jain/integer-mult-kappa at
+741e7aa078392553815df7926ee17ac5e25a8c38 (certificates/round7/), or PR97's imported copy
+(research/deferred-signed/swapnil-round7/certificates/round7/). The frame dimensions are the ones recorded in
+the data file; Swapnil's check_frames.py re-derives each of them exactly and PR97 replays the word.
+
+Every projector residual of rank r is one child of width r (PR104, notes/stopped-product-factorization.tex):
+  each slot: its chain steps from the deferral frame sigma_u to F, and one exterior child m - (h - dim sigma_u);
+  each retained centre: one copied transform of width h-1;
+  each target y_T: its chain 0 -> deferred readout levels -> t_T^perp;  each data wire X_S: its chain of V frames;
+  each data pair: one data residual of width (h-1)^2 and one endpoint copy.
+Usage: python3 research/deferred-stopped/bit_round7.py DIR      (writes bit-profile.json next to this file)
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance. Apache-2.0.
+"""
+import gzip
+import hashlib
+import json
+import sys
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PINS = {'witness_23.json.gz': 'b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588',
+        'deferred_23.json.gz': '8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c'}
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def main(directory):
+    data = {}
+    for name, digest in PINS.items():
+        raw = (Path(directory) / name).read_bytes()
+        require(hashlib.sha256(raw).hexdigest() == digest, 'pinned hash of ' + name)
+        data[name] = json.loads(gzip.decompress(raw))
+    W, D = data['witness_23.json.gz'], data['deferred_23.json.gz']
+    h = D['h']; R = D['R']; trip = list(combinations(range(h), 3)); v = len(trip); m = h * h; N = v * v
+    tid = {T: i for i, T in enumerate(trip)}
+    args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()}
+    late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()}
+    ops = [tuple(o[:2]) + (tuple(o[2]),) if o[0] == 'fan' else tuple(o) for o in D['ops']]
+    hold, start = D['hold'], D['start']
+    out = {s: (c, tuple(T)) for s, c, T in D['out']}; ret = {s: c for s, c in D['ret']}
+    sigma = dict(zip(D['readout_order'], D['sigma'])); sel = set(D['readout_order'])
+    f = [0] * R
+    for s, B in sigma.items(): f[s] = len(B)
+    vstart = dict(zip(D['vleaf_slots'], D['vleaf_start']))
+    node_dims = {n: d for n, d in D['node_dims']}
+    late_dims = {(n, tuple(lt)): d for n, lt, d in D['late_dims']}
+    pivslot = {o[3]: o[1] for o in ops if o[0] == 'add'}
+
+    def start_key(s):
+        n0 = hold[s][0]
+        if args[n0] is None: return ('v', s)
+        st = start[s]; k = st[2] if len(st) > 2 else None; dec = late.get(n0)
+        if dec is None or k in dec[0]: return ('n', n0)
+        lt = dec[1]; return ('c', n0, tuple(lt[lt.index(k):]))
+
+    def chain(s):
+        ch = [('sigma', s) if s in sel else ('0',), start_key(s)]
+        for idx, n in enumerate(hold[s]):
+            if idx > 0: ch.append(('n', n))
+            if args[n] is not None and pivslot.get(n) == s and n in late:
+                lt = late[n][1]
+                for i in range(len(lt) - 1): ch.append(('c', n, tuple(lt[i:])))
+        if s in out: ch.append(('out',))
+        if s in ret: ch.append(('ret',))
+        ch.append(('F',)); return ch
+
+    def dim(key):
+        k = key[0]
+        if k == '0': return 0
+        if k == 'F': return h
+        if k in ('out', 'ret'): return h - 1
+        if k == 'n': return node_dims[key[1]]
+        if k == 'c': return late_dims[key[1], key[2]]
+        if k == 'sigma': return f[key[1]]
+        if k == 'v': return len(vstart[key[1]])
+        raise KeyError(key)
+
+    # garbage supports (transpose sweep) for the deferred levels on each target
+    cov = [set() for _ in range(R)]
+    for s, (c, T) in out.items(): cov[s].add(tid[T])
+    for s, c in ret.items(): cov[s].update(t for t, T in enumerate(trip) if c in T)
+    for o in reversed(ops):
+        if o[0] == 'add': cov[o[2]] |= cov[o[1]]
+        elif o[0] == 'fan':
+            for g in o[2]: cov[o[1]] |= cov[g]
+    levels = defaultdict(set)
+    for s in sel:
+        for t in cov[s]: levels[t].add(f[s])
+
+    z = Counter()
+    for s in range(R):
+        ds = [dim(k) for k in chain(s)]
+        require(all(b >= a for a, b in zip(ds, ds[1:])) and ds[-1] == h, 'monotone chain %d' % s)
+        for a, b in zip(ds, ds[1:]):
+            if b > a: z[b - a] += 2 * v
+        z[m - (h - f[s])] += 2 * v
+    z[h - 1] += 2 * v * h
+    for t in range(v):
+        ls = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ls, ls[1:]): z[b - a] += 2 * v
+    for n, us in D['xs_order']:
+        ds = [1] + [len(vstart[s]) for s in us] + [h]
+        ds = [d for i, d in enumerate(ds) if i == 0 or d != ds[i - 1]]
+        require(all(b > a for a, b in zip(ds, ds[1:])), 'data-wire chain')
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v
+    z[(h - 1) ** 2] += 2 * N
+    z[1] += N
+    Wb = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = Wb * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'bit rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    prof = dict(h=h, v=v, R=R, m=m, N=N, W=Wb, L=L, total_rank=s_, deficit=N - L, maxchild=max(z),
+                deferred_slots=len(sel), source=dict(repository='https://github.com/Swapnil-jain/integer-mult-kappa',
+                commit='741e7aa078392553815df7926ee17ac5e25a8c38', sha256=PINS),
+                child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'bit-profile.json').write_text(json.dumps(prof, indent=1) + '\n')
+    print('PASS bit: R=%d, deferred slots %d, maxchild %d, rank mass %d' % (R, len(sel), max(z), s_))
+
+
+if __name__ == '__main__':
+    main(sys.argv[1] if len(sys.argv) > 1 else '.')
diff --git a/research/cyclic-deferred/certificate.json b/research/cyclic-deferred/certificate.json
new file mode 100644
index 0000000000..f1034ef27f
--- /dev/null
+++ b/research/cyclic-deferred/certificate.json
@@ -0,0 +1,319 @@
+{
+  "actual_bit_saving": "1240189553/10000000000000",
+  "assembly": {
+    "absorption_gap": "362424153041781526501060540894207/625118453232257348977642464096585250000000000000",
+    "margins": {
+      "Gaussian_arithmetic": "284295255522385837331524089430143613659/2000379050343223516728455885109072800000000",
+      "bulk_exposure": "47381293613659/500000000000000000",
+      "compact_phase_layer": "236906460961101005332443613659/2500473812929029395910569856386341",
+      "coordinate_movement": "47381293613659/500000000000000000",
+      "dimension": "2499999975000000000000000000000000/2500473812929029395910569856386341",
+      "original_prefix": "23693146569923029562640271935756386341/250047381292902939591056985638634100000000",
+      "scalar_work": "379067842749703799426489198502943613659/2000379050343223516728455885109072800000000"
+    },
+    "minimum_margin": "236906460961101005332443613659/2500473812929029395910569856386341",
+    "parameters": {
+      "C0": 13814775795484097104716662036947617991975574571712574765959755765084731813011074713741426688,
+      "C1": 1,
+      "a_bit": "47381293613659/500000000000000000",
+      "a_complex": "47381341/500000000000",
+      "alpha_squared_power": "355372194995248457951150000000/2500473812929029395910569856386341",
+      "beta": "1/1000000",
+      "c": "236906465699230271935756386341/2500000000000000000000000000000000",
+      "delta": "1/800000000",
+      "epsilon": "2499999975000000000000000000000000/2500473812929029395910569856386341",
+      "eta": "1/100000000",
+      "kappa": "23686156973/250000000000000",
+      "lambda_": "49995261870686015393613659/50000000000000000000000000",
+      "lambda_prime": "24997630935366698343613659/25000000000000000000000000",
+      "q": "2369064633301656386341/25000000000000000000000000",
+      "sigma": "499952618659/500000000000",
+      "tau": "499952618706386341/500000000000000000"
+    },
+    "recurrence": {
+      "internal": "499952618706386341/500000000000000000",
+      "leaf": "499952618706381341/500000000000000000",
+      "reservations": "2499763093534300769728064243613659/2500000000000000000000000000000000"
+    },
+    "strict_constraints": {
+      "Gaussian_arithmetic_above_kappa": "29615652110832746986032156058670939809331707/625118453232257348977642464096585250000000000000",
+      "K_dominates_log": "23690646333016561494345366698343613659/250047381292902939591056985638634100000000",
+      "K_geometry": "23693146569923029562640271935756386341/250047381292902939591056985638634100000000",
+      "alpha_below_one": "2500118440734034147452618706386341/2500473812929029395910569856386341",
+      "alpha_below_one_fourth": "2499052324149048402078765256386341/10001895251716117583642279425545364",
+      "alpha_positive": "355372194995248457951150000000/2500473812929029395910569856386341",
+      "artificial_boundary": "14003127192832541638860712650071085343613659/2000379050343223516728455885109072800000000",
+      "beta_below_one": "999999/1000000",
+      "beta_positive": "1/1000000",
+      "bit_positive": "47381293613659/500000000000000000",
+      "bulk_exposure_above_kappa": "8979667659/500000000000000000",
+      "c_below_one": "2499763093534300769728064243613659/2500000000000000000000000000000000",
+      "c_positive": "236906465699230271935756386341/2500000000000000000000000000000000",
+      "cell_above_band": "2499881509265965852547381293613659/5000947625858058791821139712772682",
+      "compact_leaf": "47631293613659/25000000000000000000000000",
+      "compact_phase_layer_above_kappa": "362424153041781526501060540894207/625118453232257348977642464096585250000000000000",
+      "compact_reservations": "2369064633301656386341/2500000000000000000000000000000000",
+      "complex_above_bit": "47386341/500000000000000000",
+      "complex_below_one_over32": "15577618659/500000000000",
+      "coordinate_movement_above_kappa": "8979667659/500000000000000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "delta_positive": "1/800000000",
+      "dimension_above_kappa": "624940767134760087172819930878111751060540894207/625118453232257348977642464096585250000000000000",
+      "epsilon_below_one": "473837929029395910569856386341/2500473812929029395910569856386341",
+      "epsilon_positive": "2499999975000000000000000000000000/2500473812929029395910569856386341",
+      "gamma_sublinear": "118465734034147452618706386341/2500473812929029395910569856386341",
+      "guard_width": "473837929029395910569856386341/2500473812929029395910569856386341",
+      "lambda_above_internal": "47381293613659/50000000000000000000000000",
+      "lambda_above_sigma": "4786015393613659/50000000000000000000000000",
+      "lambda_above_tau": "47381293613659/50000000000000000000000000",
+      "lambda_prime_above_lambda": "47381293613659/50000000000000000000000000",
+      "lambda_prime_below_one": "2369064633301656386341/25000000000000000000000000",
+      "leaf_saving_above_bit": "1/100000000000000",
+      "literal_scalar_guard": "27376989514486601059024941507046227835122300",
+      "original_prefix_above_kappa": "6251184894746726531557951142026393394207/625118453232257348977642464096585250000000000000",
+      "phase_boundary": "284295255522385837331524089430143613659/2000379050343223516728455885109072800000000",
+      "phase_local": "379067842749703799426489198502943613659/2000379050343223516728455885109072800000000",
+      "prime_interval_packing": "473837929029395910569856386341/2500473812929029395910569856386341",
+      "q_below_internal": "47381293613659/25000000000000000000000000",
+      "q_below_leaf": "47631293613659/25000000000000000000000000",
+      "q_below_reservations": "2369064633301656386341/2500000000000000000000000000000000",
+      "q_positive": "2369064633301656386341/25000000000000000000000000",
+      "record_suffix": "473837929029395910569856386341/2500473812929029395910569856386341",
+      "row_product_gap": "21189/25",
+      "scalar_work_above_kappa": "59232085619369610140708752643920939809331707/625118453232257348977642464096585250000000000000",
+      "short_record_fallback": "1249881511816096344210418533037772506468380901368281/1250236906464514697955284928193170500000000000000000",
+      "small_field_exposure": "236931468068294905237412772682/2500473812929029395910569856386341"
+    }
+  },
+  "bit_moment_gap": "210811394225115117568018038513239592855337768061996351784199300828041381607148420475711921673436778332750996651783152394205578153858435663243959795913385215868392831844509655226993164072062830500832781615792327068936897853818968534771730481866850519439187068953062899333771640996075361901014500735179763112430083120460814689994116646689670445286414265265018468311435502209195246240538069975559360544007937885404793780372701951022292660282948582656517071290400479729799954952580125532795274568021525151839594883237275569314958070368193662075730567130277424969924134425921633872848924585639423998410253779062359718371205767101510073996880454144801457072151080008705648366603197414406872289670642046369219405455128737300640897667220951127018547660455087533581513233999285275099394371781290865408274484542745086391849285198194905751058992419590161634431610100995441112613134240446609058758039909343152776920263419910572835208525277494067408376961456317/225678505065634612156474913616400633538202019254665477026878220214422133931127460164253533068001699469116755578965090566731480236912032281717920888140691998261537790258547549397061712443744511202265657747547567084090291301783866427704803156891369853685579999500594559805069402727752752227038426964007028952158078563045054314475625278140097385695241851533235641996467089273692960018822280793234080014352234618229252999217015923728814468917104222554059646947960375336061268431587018084270516494408656203498548153054913267707164839939006583338918817922618882667407408888179421052689449193499742148706302504238261936554897181289081072466758282367100305194479622149878636307463869297507337915811001244472279386614413535081936912313821531543735588465392499062010570720287729070905437080967709221039366272598541269000920375996285867953823816142239661027100714288630069735295241672325865922423925213948613346461034734632365263739073012128769510020000000000000000000000",
+  "bit_parameter": "47381293613659/500000000000000000",
+  "bit_profile": {
+    "L": 1792252,
+    "N": 3136441,
+    "R": 28866,
+    "W": 108516254,
+    "child_multiplicities": {
+      "1": 239511811,
+      "10": 878416,
+      "11": 1388464,
+      "12": 1080310,
+      "13": 945714,
+      "14": 226688,
+      "15": 2451064,
+      "16": 1508892,
+      "17": 4771074,
+      "18": 2149994,
+      "19": 7367360,
+      "2": 238288050,
+      "20": 8182020,
+      "21": 1466388,
+      "22": 88550,
+      "3": 53377940,
+      "4": 46970462,
+      "484": 6272882,
+      "5": 23632224,
+      "506": 61280142,
+      "507": 545468,
+      "508": 173558,
+      "509": 293986,
+      "510": 580888,
+      "511": 14168,
+      "512": 322322,
+      "513": 17710,
+      "514": 1129898,
+      "515": 127512,
+      "516": 410872,
+      "517": 99176,
+      "518": 1186570,
+      "519": 340032,
+      "520": 322322,
+      "521": 106260,
+      "522": 1583274,
+      "523": 626934,
+      "524": 2854852,
+      "525": 13711082,
+      "526": 4629394,
+      "527": 5653032,
+      "528": 6233920,
+      "6": 7409864,
+      "7": 4105178,
+      "8": 5755750,
+      "9": 2082696
+    },
+    "deferred_slots": 11565,
+    "deficit": 1344189,
+    "h": 23,
+    "m": 529,
+    "maxchild": 528,
+    "source": {
+      "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+      "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+      "sha256": {
+        "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+        "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588"
+      }
+    },
+    "total_rank": 57403754177,
+    "v": 1771
+  },
+  "coarse_bit_saving": "620523/5000000000",
+  "complex_moment_gap": "2253977273811425088685583302279490867638171291741975813686072855203082525566495544165706456373449462299093118306691583153612488116256660869320886905830707143978101693929837376969934225135579318605731114630932103679447620735329406427664395344511295325970420157097445189095426368480266871200272560895210228068326825134109268495527612035808700342702072956060690436324427861857730640271968581443051789266735015052855965858031313483532489302320400156198995433800495494095546674538095534536641498570469523235602132048948175030867707564002028086561532437070331462550532365907366761478239931795973670545873785551915106226061773811857648314821819315696513051508569485278850271270561873075993999144474624985118917465669823889916910436665667296289635171961589875091172858967844587718309367833890154528960634122399472634041297179682831533482431638956370550551276483449659824031100101013947981966936515479090052947571291254777201890850699049748100704336422569028215570514305634273123551471/64703773230087949188975238040281278177952449760182623195799512737170349903939769350763943867384466510835954878802481320037044259391214920415647507734712480838543084125734782588090202106634507410404061147275849107663470138791196247792154610378611438781845615513719533975716207016891830295787124794230503716617993812361146595478225221076888897262380863778770164314872495309819511547338828068629940138110591102522925324944280047836586576433227196632402516119611483347363220713957307305191086450812515984575598362143090941197911711645428415148236021811725617757721143556730400862390384944839465431612593304474126193266028646377523921523678713979413076461322587710052217113640213362690247564746415658592980275833390303553474466232757828180181227441498937721462123982955426995444897745886546185368672150625867164508137966278457355011588351351745456869793795426431706578376516362858536188057343052462138147891449142938513195572734780001317973933139028577491428663812220864000000000000000000000000",
+  "complex_profile": {
+    "L": 2234496,
+    "N": 4096576,
+    "R": 37859,
+    "W": 161446384,
+    "additions": 68800,
+    "child_multiplicities": {
+      "1": 285772608,
+      "10": 9411600,
+      "11": 5553856,
+      "12": 7363312,
+      "13": 5128816,
+      "14": 11237248,
+      "15": 5756256,
+      "16": 8201248,
+      "17": 7849072,
+      "18": 10751488,
+      "19": 10099760,
+      "2": 252696400,
+      "20": 5974848,
+      "21": 4234208,
+      "22": 12063040,
+      "23": 8302448,
+      "3": 41917040,
+      "4": 62112512,
+      "5": 30736464,
+      "529": 8193152,
+      "552": 132276496,
+      "553": 12144,
+      "554": 133584,
+      "556": 210496,
+      "558": 157872,
+      "560": 388608,
+      "562": 655776,
+      "564": 1133440,
+      "565": 4048,
+      "566": 1623248,
+      "567": 24288,
+      "568": 1177968,
+      "569": 20240,
+      "570": 4456848,
+      "571": 2671680,
+      "572": 1218448,
+      "573": 663872,
+      "574": 6424176,
+      "6": 33096448,
+      "7": 15572656,
+      "8": 14289440,
+      "9": 8144576
+    },
+    "deferred_dims": {
+      "1": 3,
+      "10": 162,
+      "12": 280,
+      "13": 1,
+      "14": 401,
+      "15": 6,
+      "16": 291,
+      "17": 5,
+      "18": 1101,
+      "19": 660,
+      "2": 33,
+      "20": 301,
+      "21": 164,
+      "22": 1587,
+      "4": 52,
+      "6": 39,
+      "8": 96
+    },
+    "deferred_roles": 5182,
+    "deficit": 1862080,
+    "h": 24,
+    "lifted_additions": 32718,
+    "links": 39061,
+    "m": 576,
+    "maxchild": 574,
+    "phase_one_ops": 18439,
+    "phase_one_roles": 15373,
+    "replay": {
+      "field": "Z/(2^61-1)",
+      "scratch_restored": true,
+      "seeds": [
+        1,
+        2
+      ],
+      "y_plus_x": true
+    },
+    "roots": 8120,
+    "total_rank": 92991255104,
+    "v": 2024
+  },
+  "complex_saving": "47381341/500000000000",
+  "finite_bridge": {
+    "bit_coarse": {
+      "W": 108516254,
+      "halving_degree": 367,
+      "m": 529,
+      "maxchild": 528,
+      "wire_bits": 27
+    },
+    "complex": {
+      "W": 161446384,
+      "halving_degree": 200,
+      "m": 576,
+      "maxchild": 574,
+      "s": 92991255104,
+      "scalar_group_upper": 75347290791872,
+      "scalar_terms": [
+        {
+          "R": 37859,
+          "c": 68800,
+          "description": "Expanded deferred readouts and forward/inverse/reflected words",
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 18613460152,
+          "q": 8120,
+          "v": 2024
+        },
+        {
+          "R": 37859,
+          "c": 68800,
+          "description": "Expanded deferred readouts and forward/inverse/reflected words",
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 18613460152,
+          "q": 8120,
+          "v": 2024
+        }
+      ],
+      "wire_bits": 28
+    },
+    "ordinary_leaf_row_degree": 252,
+    "rows": {
+      "coefficient": 15761,
+      "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; prefix and padding; sequential reuse",
+      "degree": 33000,
+      "degree_gap": "21189/25",
+      "suffix_slope": 132000
+    },
+    "semantic": {
+      "B": 27376989514490528903484710488354131695609472,
+      "C0": 13814775795484097104716662036947617991975574571712574765959755765084731813011074713741426688,
+      "C1": 1,
+      "E": 27376989514490528903484710488354038704354368,
+      "exact_grid": "2^(-P)*21^(-K), K=G*(D_complex+1); completed children preserve incoming odd denominator; no child rounding",
+      "fixed_odd_divisor": 21,
+      "induction_gap": 82130968543471586710454131465062395086828416,
+      "literal_charge": 3927844459768981307810869232068,
+      "strict_literal_gap": 27376989514486601059024941507046227835122300
+    }
+  },
+  "kappa": "23686156973/250000000000000",
+  "next_grid_rejections": {
+    "bit": "1e-10",
+    "complex": "1e-12",
+    "kappa": "1e-15"
+  },
+  "status": "Finite conditional cyclic/deferred witness"
+}
diff --git a/research/cyclic-deferred/certificate.py b/research/cyclic-deferred/certificate.py
new file mode 100644
index 0000000000..8a1d3672ab
--- /dev/null
+++ b/research/cyclic-deferred/certificate.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Exact finite assembly for cyclic strips with deferred readouts.
+
+Built on Avi Eisenberg's PR110 (Anthropic Claude assistance), icekylinx's
+PR104 stopped-product and copied-center interfaces, and Zhihao Chen's
+assembly of the RaD interfaces. Integration for eumemic with OpenAI Codex
+assistance. Apache-2.0. General transfer hypotheses remain inherited.
+"""
+import argparse
+import json
+import sys
+from fractions import Fraction as Q
+from pathlib import Path
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+from partial_swap_network import moment
+from copied_centers_network import finite_bridge as copied_bridge
+from structured_bulk_assembly import assembly, js
+ATOM = Q(1, 1000)
+OLD = Q(384599, 10**10)
+BETA = Q(1, 10**6)
+COARSE = Q(620523, 5000000000)
+COMPLEX = Q(47381341, 500000000000)
+KGRID = 10**15
+
+def profile(name):
+    p = json.loads((HERE / name).read_text())
+    p['child_multiplicities'] = {int(t): c for t, c in p['child_multiplicities'].items()}
+    z = p['child_multiplicities']
+    assert all(0 < t < p['m'] and c > 0 for t,c in z.items())
+    assert sum(t*c for t,c in z.items()) == p['total_rank'] == p['W']*p['m']-p['N']+p['L']
+    assert max(z) == p['maxchild']
+    return p
+
+def contracts(p, a):
+    try: moment(p['m'],p['W'],p['child_multiplicities'],a,True)
+    except ValueError: return False
+    return True
+
+def exact(bit=None, phase=None):
+    bit = profile('bit-profile.json') if bit is None else bit
+    phase = profile('complex-profile.json') if phase is None else phase
+    assert (bit['h'], phase['h']) == (23,24)
+    bm = moment(bit['m'],bit['W'],bit['child_multiplicities'],COARSE,True)
+    cm = moment(phase['m'],phase['W'],phase['child_multiplicities'],COMPLEX,True)
+    assert not contracts(bit,COARSE+Q(1,10**10))
+    assert not contracts(phase,COMPLEX+Q(1,10**12))
+    ab = (1-ATOM)*COARSE+ATOM*OLD
+    assert 0 < OLD < COARSE < ATOM and ab < ATOM
+    a = min(ab,(1-BETA)*COMPLEX-Q(1,10**14))
+    row = dict(h=phase['h'],v=phase['v'],c=phase['additions'],central_disjoint=24)
+    bridge = copied_bridge(bit,phase,[row,row])
+    # A literal expanded readout is charged even if it could be factored.
+    # Each row has <=c+R mixer operations and <=R leaf copies. There are
+    # <=R+q readouts, each containing <=h center coefficients and <=v direct
+    # coefficients; <=4*v*(h+1) scalar groups suffice per readout. A factor
+    # eight covers forward/inverse words, both reflected words, and copies.
+    h,v,R,q,c = (phase[k] for k in ('h','v','R','roots','additions'))
+    local = 8*(c+2*R+(R+q)*v*(h+1)+h*h+h+1)
+    G = phase['N'] + 2*v*local
+    m,W,s = (phase[k] for k in ('m','W','total_rank'))
+    E=64*(W+m+G+1)**3
+    charge=2*G*W*W+8*s+4*W+4+32*m
+    B=s+E; C0=32*m*B*B
+    assert charge<E and 2*B*(m-phase['maxchild']) >= s+E and 2*B+18<C0
+    bridge['complex']['scalar_group_upper']=G
+    bridge['complex']['scalar_terms']=[dict(h=h,v=v,c=c,R=R,q=q,invocations=v,
+        local_group_upper=local,description='Expanded deferred readouts and forward/inverse/reflected words')]*2
+    bridge['semantic'].update(E=E,literal_charge=charge,strict_literal_gap=E-charge,
+        B=B,C0=C0,C1=1,induction_gap=2*B*(m-phase['maxchild'])-s-E,
+        fixed_odd_divisor=21,exact_grid='2^(-P)*21^(-K), K=G*(D_complex+1); completed children preserve incoming odd denominator; no child rounding')
+    coarse_bridge=bridge.pop('bit')
+    previous=json.loads((ROOT/'certificates/copied-centers-network.json').read_text())
+    oldbit=previous['finite_bridge']['bit']
+    old_degree=oldbit['halving_degree']*oldbit['wire_bits']
+    assert old_degree==252
+    cp=bridge['complex']
+    coeff=coarse_bridge['halving_degree']*coarse_bridge['wire_bits']+old_degree+cp['halving_degree']*cp['wire_bits']
+    degree=1000*((51*coeff)//25000+1)
+    bridge.update(bit_coarse=coarse_bridge,ordinary_leaf_row_degree=old_degree)
+    bridge['rows']=dict(coefficient=coeff,degree=degree,suffix_slope=4*degree,
+        degree_gap=Q(degree)-Q(51*coeff,25),contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; prefix and padding; sequential reuse')
+    def accepts(k):
+        try: assembly(a,COMPLEX,bridge,Q(k,KGRID),beta=BETA)
+        except AssertionError: return False
+        return True
+    lo,hi=0,int(COMPLEX*KGRID)+1
+    assert accepts(lo) and not accepts(hi)
+    while hi-lo>1:
+        mid=(lo+hi)//2
+        if accepts(mid): lo=mid
+        else: hi=mid
+    k=Q(lo,KGRID)
+    assembled=assembly(a,COMPLEX,bridge,k,beta=BETA)
+    assert len(assembled['strict_constraints'])==47 and len(assembled['margins'])==7
+    assert not accepts(lo+1)
+    return dict(status='Finite conditional cyclic/deferred witness',kappa=k,
+        complex_saving=COMPLEX,coarse_bit_saving=COARSE,actual_bit_saving=ab,
+        bit_parameter=a,complex_profile=phase,bit_profile=bit,
+        bit_moment_gap=bm['strict_gap'],complex_moment_gap=cm['strict_gap'],
+        finite_bridge=bridge,assembly=assembled,
+        next_grid_rejections=dict(bit='1e-10',complex='1e-12',kappa='1e-15'))
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--write',action='store_true');args=parser.parse_args()
+    assert not sys.flags.optimize
+    result=js(exact()); path=HERE/'certificate.json'
+    if args.write:path.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:assert result==json.loads(path.read_text()),'Frozen exact certificate mismatch'
+    print('PASS conditional kappa = %s = %.12e; 47 constraints, 7 margins; expanded scalar charge' % (result['kappa'],float(Q(result['kappa']))))
+if __name__=='__main__':main()
diff --git a/research/cyclic-deferred/complex-profile.json b/research/cyclic-deferred/complex-profile.json
new file mode 100644
index 0000000000..dc8d740063
--- /dev/null
+++ b/research/cyclic-deferred/complex-profile.json
@@ -0,0 +1,91 @@
+{
+ "h": 24,
+ "v": 2024,
+ "additions": 68800,
+ "roots": 8120,
+ "links": 39061,
+ "R": 37859,
+ "m": 576,
+ "N": 4096576,
+ "W": 161446384,
+ "L": 2234496,
+ "total_rank": 92991255104,
+ "deficit": 1862080,
+ "maxchild": 574,
+ "phase_one_ops": 18439,
+ "phase_one_roles": 15373,
+ "deferred_roles": 5182,
+ "deferred_dims": {
+  "1": 3,
+  "2": 33,
+  "4": 52,
+  "6": 39,
+  "8": 96,
+  "10": 162,
+  "12": 280,
+  "13": 1,
+  "14": 401,
+  "15": 6,
+  "16": 291,
+  "17": 5,
+  "18": 1101,
+  "19": 660,
+  "20": 301,
+  "21": 164,
+  "22": 1587
+ },
+ "lifted_additions": 32718,
+ "replay": {
+  "seeds": [
+   1,
+   2
+  ],
+  "scratch_restored": true,
+  "y_plus_x": true,
+  "field": "Z/(2^61-1)"
+ },
+ "child_multiplicities": {
+  "1": 285772608,
+  "2": 252696400,
+  "3": 41917040,
+  "4": 62112512,
+  "5": 30736464,
+  "6": 33096448,
+  "7": 15572656,
+  "8": 14289440,
+  "9": 8144576,
+  "10": 9411600,
+  "11": 5553856,
+  "12": 7363312,
+  "13": 5128816,
+  "14": 11237248,
+  "15": 5756256,
+  "16": 8201248,
+  "17": 7849072,
+  "18": 10751488,
+  "19": 10099760,
+  "20": 5974848,
+  "21": 4234208,
+  "22": 12063040,
+  "23": 8302448,
+  "529": 8193152,
+  "552": 132276496,
+  "553": 12144,
+  "554": 133584,
+  "556": 210496,
+  "558": 157872,
+  "560": 388608,
+  "562": 655776,
+  "564": 1133440,
+  "565": 4048,
+  "566": 1623248,
+  "567": 24288,
+  "568": 1177968,
+  "569": 20240,
+  "570": 4456848,
+  "571": 2671680,
+  "572": 1218448,
+  "573": 663872,
+  "574": 6424176
+ }
+}
diff --git a/research/cyclic-deferred/complex_deferred.py b/research/cyclic-deferred/complex_deferred.py
new file mode 100644
index 0000000000..765d3b1c12
--- /dev/null
+++ b/research/cyclic-deferred/complex_deferred.py
@@ -0,0 +1,466 @@
+#!/usr/bin/env python3
+"""Cyclic strips and core-aware pair assembly with lifted frames and deferred readouts.
+
+The scalar h=24 producer uses PR111's cyclic PairedTriple strips and dual-suffix
+pair stars, with PR62's core-aware pair assembly, a two-point base case, and
+column-pair coarse sums inside contracted pair subproblems. PR110's maximum
+carrier matching, explicit role compiler, lifted binary frames, deferred
+readouts, finite-field replay, exact F2 frame checks, and actual one-child
+profile are retained. The selected graph has 68,800 additions, 8,120 roots,
+39,061 carrier links, and 37,859 roles.
+
+Credits: Avi Eisenberg (PR110 deferred complex compiler and PR62 pair assembly),
+Rohan Arun (PR111 cyclic-strip and dual-suffix producer), Swapnil Jain (deferred
+readouts), icekylinx (PR104 stopped product-ring and PairedTriple lineage), and
+all predecessors credited in those sources. Integration and the contracted
+pair replacement were prepared with OpenAI Codex assistance. Apache-2.0.
+
+This script checks the original assertions and writes complex-profile.json
+next to itself. Reflected-word verification is a separate audit.
+"""
+import array
+import json
+import random
+import struct
+import sys
+import tempfile
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+import importlib.util
+producer_path = HERE / 'producer.py'
+spec = importlib.util.spec_from_file_location('cyclic_producer', producer_path)
+producer = importlib.util.module_from_spec(spec); spec.loader.exec_module(producer)
+build = producer.build
+
+P = (1 << 61) - 1
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def load(prefix):
+    def rd(fh, typ, cnt):
+        a = array.array(typ); a.fromfile(fh, cnt); return a
+    with open(str(prefix) + '.bin', 'rb') as f:
+        h, v, n, q = struct.unpack('<4I', f.read(16))
+        flat = rd(f, 'I', 2 * n); core = rd(f, 'Q', n); cover = rd(f, 'Q', n)
+        roots = rd(f, 'I', q); kind = rd(f, 'I', q); active = rd(f, 'B', n)
+    with open(str(prefix) + '.labels', 'rb') as f:
+        ranks = rd(f, 'I', n); types = rd(f, 'B', n)
+    args = [(flat[2 * i], flat[2 * i + 1]) for i in range(n)]
+    return h, v, n, q, args, core, cover, roots, kind, active, ranks, types
+
+
+# ---------------------------------------------------------------- F2 linear algebra on bit vectors
+def dot(a, b): return bin(a & b).count('1') & 1
+
+
+def reduce(basis):
+    rows = []; piv = []
+    for vec in basis:
+        for p, r in zip(piv, rows):
+            if vec >> p & 1: vec ^= r
+        if vec:
+            p = vec.bit_length() - 1
+            for i in range(len(rows)):
+                if rows[i] >> p & 1: rows[i] ^= vec
+            rows.append(vec); piv.append(p)
+    return rows
+
+
+def kernel(funcs, h):
+    K = reduce(funcs); piv = [r.bit_length() - 1 for r in K]
+    out = []
+    for c in (i for i in range(h) if i not in piv):
+        vec = 1 << c
+        for r, p in zip(K, piv):
+            if r >> c & 1: vec |= 1 << p
+        out.append(vec)
+    return out
+
+
+def restrict(basis, funcs):
+    B = reduce(basis)
+    for f in funcs:
+        if not B: break
+        vals = [dot(b, f) for b in B]
+        if not any(vals): continue
+        k = vals.index(1); pv = B[k]
+        B = [b ^ pv if val else b for b, val in zip(B, vals)]; B.pop(k)
+    return reduce(B)
+
+
+def contains(A, B):
+    RB = reduce(B)
+    return len(reduce(RB + list(A))) == len(RB)
+
+
+def cap(A, B):
+    A = reduce(A); B = reduce(B)
+    if not A or not B: return []
+    ker = []; red = []
+    for i, vec in enumerate(A + B):
+        tag = 1 << i
+        for rv, rt in red:
+            if vec >> (rv.bit_length() - 1) & 1: vec ^= rv; tag ^= rt
+        if vec: red.append((vec, tag))
+        else:
+            comb_ = 0
+            for k in range(len(A)):
+                if tag >> k & 1: comb_ ^= A[k]
+            ker.append(comb_)
+    return reduce(ker)
+
+
+def nondeg(B):
+    B = reduce(B); k = len(B)
+    if not k: return True
+    M = [sum(dot(B[i], B[j]) << j for j in range(k)) for i in range(k)]
+    return len(reduce(M)) == k
+
+
+def hopcroft_karp(left, adj):
+    """maximum bipartite matching; adj[x] = sorted list of right vertices."""
+    INF = 1 << 60
+    mate_l = {x: None for x in left}; mate_r = {}
+    while True:
+        dist = {}; queue = []
+        for x in left:
+            if mate_l[x] is None: dist[x] = 0; queue.append(x)
+            else: dist[x] = INF
+        found = INF; head = 0
+        while head < len(queue):
+            x = queue[head]; head += 1
+            if dist[x] >= found: continue
+            for r in adj[x]:
+                y = mate_r.get(r)
+                if y is None: found = min(found, dist[x] + 1)
+                elif dist[y] == INF: dist[y] = dist[x] + 1; queue.append(y)
+        if found == INF: break
+        gained = 0
+        for x0 in left:
+            if mate_l[x0] is not None: continue
+            stack = [(x0, iter(adj[x0]))]; path = []
+            while stack:
+                x, it = stack[-1]
+                advanced = False
+                for r in it:
+                    y = mate_r.get(r)
+                    if (y is None and dist[x] + 1 == found) or (y is not None and dist[y] == dist[x] + 1):
+                        path.append((x, r))
+                        if y is None:
+                            for xx, rr in path: mate_l[xx] = rr; mate_r[rr] = xx
+                            gained += 1; stack = []; break
+                        stack.append((y, iter(adj[y]))); advanced = True; break
+                else:
+                    dist[x] = INF; stack.pop()
+                    if path: path.pop()
+                    continue
+                if not advanced: break
+        if not gained: break
+    return mate_l
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix='deferred-stopped-') as work:
+        prefix = Path(work) / 'complex'
+        build(24, prefix, central_disjoint=24)
+        h, v, n, q, args, core, cover, roots, kind, active, ranks, types = load(prefix)
+    trip = list(combinations(range(h), 3)); require(len(trip) == v, 'triple count')
+    m = h * h; N = v * v; FULL = (1 << h) - 1
+    tmask = [sum(1 << p for p in T) for T in trip]
+    tid = {T: i for i, T in enumerate(trip)}
+
+    # ------------------------------------------------------------ uses and matching (inherited adjacency)
+    degree = [0] * n; uses = defaultdict(list); c_add = 0
+    for x in range(1, n):
+        if active[x] and args[x][0]:
+            c_add += 1
+            for pos, y in enumerate(args[x]): degree[y] += 1; uses[y].append(('gate', x, pos))
+    for j, x in enumerate(roots): degree[x] += 1; uses[x].append(('root', j))
+    def unode(u): return roots[u[1]] if u[0] == 'root' else u[1]
+    def before(x, u):
+        y = unode(u)
+        return (ranks[x], x) < (ranks[y], (n + u[1]) if u[0] == 'root' else y)
+    def incl(x, y):
+        tx, ty = types[x], types[y]
+        if tx == 1 and ty == 1: return not (core[y] & ~core[x]) and not (cover[x] & ~cover[y])
+        if tx in (1, 2) and ty == 2: return not (cover[x] & ~cover[y])
+        if tx == 1 and ty == 3: return bool(core[x] & core[y])
+        if tx == 2 and ty == 3: return not (cover[x] & ~core[y])
+        if tx == 3 and ty == 2: return cover[y] == FULL
+        if tx == 3 and ty == 3: return core[x] == core[y]
+        return False
+    left = []; adj = {}
+    for x in range(1, n):
+        if not (active[x] and args[x][0]): continue
+        rs = sorted({(y, k) for y in args[x] for k, u in enumerate(uses[y]) if before(x, u) and incl(x, unode(u))})
+        if rs: left.append(x); adj[x] = rs
+    mate = hopcroft_karp(left, adj)
+    links = {x: r for x, r in mate.items() if r is not None}
+    R = c_add + q - len(links)
+    require((c_add, q, len(links), R) == (68800, 8120, 39061, 37859),
+            'selected graph size: additions=%d, roots=%d, matching=%d, roles=%d' % (c_add, q, len(links), R))
+    linked_use = {(y, k): x for x, (y, k) in links.items()}
+
+    # ------------------------------------------------------------ root targets, read coefficients, root functionals
+    target = [None] * q
+    for j in range(v): target[j] = j
+    idx = v
+    for a, b in combinations(range(h), 2):
+        others = sorted((i for i in range(h) if i not in (a, b)), key=lambda i: ((i ^ 1) in (a, b), i))
+        for i in others: target[idx] = tid[tuple(sorted((a, b, i)))]; idx += 1
+    centre_of = {}
+    for j in range(q):
+        if kind[j]:
+            miss = FULL & ~cover[roots[j]]; require(bin(miss).count('1') == 1, 'centre cover')
+            centre_of[j] = miss.bit_length() - 1
+    require(idx + len(centre_of) == q, 'root order')
+    rootfun = [(1 << centre_of[j]) if kind[j] else tmask[target[j]] for j in range(q)]
+
+    # ------------------------------------------------------------ lifted binary frames, monotone
+    succ = defaultdict(set); droot = defaultdict(set)
+    for x in range(1, n):
+        if not active[x]: continue
+        for k, u in enumerate(uses[x]):
+            if (x, k) in linked_use: continue
+            (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    for x, (y, k) in links.items():
+        u = uses[y][k]; (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    order_desc = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x), reverse=True)
+    K = {}
+    for x in order_desc:
+        rows = [rootfun[j] for j in droot[x]]
+        for t in succ[x]: rows += K[t]
+        K[x] = reduce(rows)
+    def envelope(x):
+        if not args[x][0]: return [tmask[x - 1]]
+        if types[x] == 2: return [1 << i for i in range(h) if cover[x] >> i & 1]
+        require(types[x] == 1, 'only ordinary and common-pair labels occur')
+        ks = [i for i in range(h) if (cover[x] & ~core[x]) >> i & 1]
+        require(len(ks) == ranks[x], 'common-pair support')
+        return [core[x] | (1 << k) for k in ks]
+    U = {}
+    for x in range(1, n):
+        if not active[x]: continue
+        if not args[x][0]: U[x] = envelope(x); continue
+        B = kernel(K[x], h)
+        require(contains(envelope(x), B), 'label outside lifted frame')
+        U[x] = B if nondeg(B) else envelope(x)
+    changed = True
+    while changed:
+        changed = False
+        for x in order_desc:
+            if args[x][0] and any(not contains(U[x], U[t]) for t in succ[x]):
+                env = envelope(x)
+                if len(reduce(U[x])) != len(reduce(env)) or not contains(U[x], env): U[x] = env; changed = True
+    dimU = {x: len(reduce(B)) for x, B in U.items()}
+
+    # ------------------------------------------------------------ explicit role compile
+    order = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x))
+    holds = []; first_node = []; ops = []; edge_key = {}; role_root = {}
+    def new_role(node): holds.append([node]); first_node.append(node); return len(holds) - 1
+    def serve(s, y, k):
+        u = uses[y][k]
+        if u[0] == 'gate': edge_key[(y, k)] = s
+        else: role_root[s] = u[1]
+    for x in order:
+        free = [k for k in range(len(uses[x])) if (x, k) not in linked_use]
+        if not args[x][0]:
+            for k in free:
+                s = new_role(x); ops.append(('src', s, x)); serve(s, x, k)
+            continue
+        a, b = args[x]
+        ka = next(k for k, u in enumerate(uses[a]) if u == ('gate', x, 0))
+        kb = next(k for k, u in enumerate(uses[b]) if u == ('gate', x, 1))
+        sa, sb = edge_key.pop((a, ka)), edge_key.pop((b, kb))
+        if x in links and links[x][0] == a: sa, sb = sb, sa
+        piv, oth = sa, sb
+        ops.append(('add', piv, oth, x)); holds[piv].append(x); holds[oth].append(x)
+        if x in links: serve(oth, *links[x])
+        require(free, 'every use linked at node %d' % x)
+        serve(piv, x, free[0])
+        for k in free[1:]:
+            f = new_role(x); ops.append(('copy', piv, f, x)); serve(f, x, k)
+    require(not edge_key and len(holds) == R, 'compile')
+    Rr = R
+
+    # ------------------------------------------------------------ B. the word computes every root value
+    rng = random.Random(20261008)
+    xs = [rng.randrange(P) for _ in range(v)]
+    val = [0] * n
+    for i in range(v): val[i + 1] = xs[i]
+    for x in order:
+        if args[x][0]: val[x] = (val[args[x][0]] + val[args[x][1]]) % P
+    leaf_of = {s: first_node[s] for s in range(Rr) if not args[first_node[s]][0]}
+    a_ = [0] * Rr
+    for s, leaf in leaf_of.items(): a_[s] = xs[leaf - 1]
+    for o in ops:
+        if o[0] == 'add': a_[o[1]] = (a_[o[1]] + a_[o[2]]) % P
+        elif o[0] == 'copy': a_[o[2]] = (a_[o[2]] + a_[o[1]]) % P
+    require(all(a_[s] == val[roots[j]] for s, j in role_root.items()), 'root values')
+
+    # ------------------------------------------------------------ phase one and garbage reach
+    def touch(o): return [o[1], o[2]] if o[0] in ('add', 'copy') else []
+    prev = {}; pred = defaultdict(list); last = {}
+    for i, o in enumerate(ops):
+        for s in touch(o):
+            if s in prev: pred[i].append(prev[s])
+            prev[s] = i; last[s] = i
+    centre_roles = [s for s, j in role_root.items() if kind[j]]
+    Anc = set(); st = [last[s] for s in centre_roles]
+    while st:
+        i = st.pop()
+        if i not in Anc: Anc.add(i); st.extend(pred[i])
+    touched = set(centre_roles)
+    for i in Anc: touched.update(touch(ops[i]))
+    require(all(last[s] in Anc for s in centre_roles), 'centres complete in phase one')
+    reach = [set() for _ in range(Rr)]; reach_all = [False] * Rr
+    for s, j in role_root.items():
+        if kind[j]: reach_all[s] = True
+        else: reach[s].add(target[j])
+    for o in reversed(ops):
+        if o[0] == 'add': reach[o[2]] |= reach[o[1]]; reach_all[o[2]] = reach_all[o[2]] or reach_all[o[1]]
+        elif o[0] == 'copy': reach[o[1]] |= reach[o[2]]; reach_all[o[1]] = reach_all[o[1]] or reach_all[o[2]]
+
+    # ------------------------------------------------------------ deferral frames, insertion nesting
+    def F0(s): return U[first_node[s]]
+    cand = {}
+    for s in range(Rr):
+        if s in touched or reach_all[s]: continue
+        S_ = restrict(F0(s), [tmask[t] for t in reach[s]])
+        if S_ and nondeg(S_): cand[s] = S_
+    byT = defaultdict(list); placed = {}
+    for s in sorted(cand, key=lambda s: (-len(cand[s]), s)):
+        X = cand[s]; changed = True
+        while changed and X:
+            changed = False
+            for t in reach[s]:
+                for w in byT[t]:
+                    B = placed[w]
+                    if (len(B) >= len(X) and not contains(X, B)) or (len(B) < len(X) and not contains(B, X)):
+                        X = cap(X, B); changed = True
+                    if not X: break
+                if not X: break
+        if X and nondeg(X):
+            placed[s] = X
+            for t in reach[s]: byT[t].append(s)
+    deferred = sorted(placed, key=lambda s: (len(placed[s]), s)); dset = set(deferred)
+
+    # ------------------------------------------------------------ C. replay with arbitrary scratch and data
+    inv = lambda a: pow(a % P, P - 2, P); HALF = inv(2); I21 = inv(21)
+    cvec = [None] * Rr; dpart = [dict() for _ in range(Rr)]
+    for s, j in role_root.items():
+        if kind[j]: c = [0] * h; c[centre_of[j]] = 1; cvec[s] = c
+        else: dpart[s][target[j]] = (P - HALF) if j >= v else HALF
+    seed_c = {s: (None if cvec[s] is None else list(cvec[s])) for s in role_root}
+    seed_d = {s: dict(dpart[s]) for s in role_root}
+    def addc(dst, src):
+        if cvec[src] is not None:
+            cvec[dst] = list(cvec[src]) if cvec[dst] is None else [(p + q_) % P for p, q_ in zip(cvec[dst], cvec[src])]
+        for t, c in dpart[src].items(): dpart[dst][t] = (dpart[dst].get(t, 0) + c) % P
+    for o in reversed(ops):
+        if o[0] == 'add': addc(o[2], o[1])
+        elif o[0] == 'copy': addc(o[1], o[2])
+    scatter = [[(I21 - (HALF if i in trip[t] else 0)) % P for t in range(v)] for i in range(h)]
+    def readout(y, s, value, sign, seed=False):
+        cv = seed_c[s] if seed else cvec[s]; dp = seed_d[s] if seed else dpart[s]
+        if cv is not None:
+            for i, ci in enumerate(cv):
+                if ci:
+                    f = sign * ci * value % P; row = scatter[i]
+                    for t in range(v): y[t] = (y[t] + f * row[t]) % P
+        for t, c in dp.items(): y[t] = (y[t] + sign * c * value) % P
+    phase1 = sorted(Anc); rest = [i for i in range(len(ops)) if i not in Anc]
+    def replay(seed):
+        rng = random.Random(seed)
+        x = [rng.randrange(P) for _ in range(v)]; z = [rng.randrange(P) for _ in range(Rr)]
+        y0 = [rng.randrange(P) for _ in range(v)]; a = list(z); y = list(y0)
+        for s in range(Rr):
+            if s not in dset: readout(y, s, a[s], -1)
+        for s, leaf in leaf_of.items():
+            if s not in dset: a[s] = (a[s] + x[leaf - 1]) % P
+        def run(i, sign=1):
+            o = ops[i]
+            if o[0] == 'add': a[o[1]] = (a[o[1]] + sign * a[o[2]]) % P
+            elif o[0] == 'copy': a[o[2]] = (a[o[2]] + sign * a[o[1]]) % P
+        for i in phase1: run(i)
+        for s in centre_roles: readout(y, s, a[s], +1, True)
+        for s in deferred: readout(y, s, a[s], -1)
+        for s in deferred:
+            if s in leaf_of: a[s] = (a[s] + x[leaf_of[s] - 1]) % P
+        for i in rest: run(i)
+        for s, j in role_root.items():
+            if not kind[j]: readout(y, s, a[s], +1, True)
+        for i in reversed(range(len(ops))): run(i, -1)
+        for s, leaf in leaf_of.items(): a[s] = (a[s] - x[leaf - 1]) % P
+        return a == z, all((y[t] - y0[t] - x[t]) % P == 0 for t in range(v))
+    rep = [replay(seed) for seed in (1, 2)]
+    require(all(r == (True, True) for r in rep), 'replay %s' % rep)
+
+    # ------------------------------------------------------------ D. exact F2 frame facts
+    root_frame = {}
+    for s, j in role_root.items():
+        root_frame[s] = [1 << i for i in range(h) if i != centre_of[j]] if kind[j] else kernel([tmask[target[j]]], h)
+    FULLB = [1 << i for i in range(h)]
+    chain_dims = []
+    for s in range(Rr):
+        seq = [placed.get(s, []), F0(s)] + [U[x] for x in holds[s][1:]]
+        if s in root_frame: seq.append(root_frame[s])
+        seq.append(FULLB)
+        require(all(contains(A, B) for A, B in zip(seq, seq[1:])), 'role chain nesting %d' % s)
+        require(all(nondeg(B) for B in seq[1:-1] if B), 'degenerate frame on role %d' % s)
+        chain_dims.append([len(reduce(B)) for B in seq])
+    for s, X in placed.items():
+        require(contains(X, F0(s)) and nondeg(X), 'deferral frame %d' % s)
+        require(all(not any(dot(xv, tmask[t]) for xv in X) for t in reach[s]), 'target frame %d' % s)
+    byT2 = defaultdict(list)
+    for s in deferred:
+        for t in reach[s]: byT2[t].append(s)
+    for t, ss in byT2.items():
+        ss.sort(key=lambda s: (len(placed[s]), s))
+        require(all(contains(placed[p], placed[q_]) for p, q_ in zip(ss, ss[1:])), 'target chain %d' % t)
+
+    # ------------------------------------------------------------ E. one-child histogram
+    z = Counter()
+    for s in range(Rr):
+        ds = chain_dims[s]
+        for a, b in zip(ds[:-1], ds[1:-1]):
+            if b > a: z[b - a] += 2 * v
+        lastd = ds[-2]
+        if s in role_root and kind[role_root[s]]: z[h - 1] += 2 * v           # copied centre transform
+        z[h - lastd] += 2 * v                                                  # final growth to F
+        z[m - h + ds[0]] += 2 * v                                              # exterior, gauged by sigma
+    levels = defaultdict(set)
+    for s in deferred:
+        for t in reach[s]: levels[t].add(len(placed[s]))
+    for t in range(v):
+        ds = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v                       # target fronts
+    z[h - 1] += 2 * N                                                          # data-wire fronts
+    z[(h - 1) ** 2] += 2 * N                                                   # data macros
+    z[1] += N                                                                  # endpoint copies
+    z.pop(0, None)
+    W = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = W * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'complex rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    out = dict(h=h, v=v, additions=c_add, roots=q, links=len(links), R=R, m=m, N=N, W=W, L=L, total_rank=s_,
+               deficit=N - L, maxchild=max(z), phase_one_ops=len(Anc), phase_one_roles=len(touched),
+               deferred_roles=len(deferred),
+               deferred_dims=dict(sorted(Counter(len(X) for X in placed.values()).items())),
+               lifted_additions=sum(1 for x in U if args[x][0] and dimU[x] > ranks[x]),
+               replay=dict(seeds=[1, 2], scratch_restored=True, y_plus_x=True, field='Z/(2^61-1)'),
+               child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'complex-profile.json').write_text(json.dumps(out, indent=1) + '\n')
+    print('PASS complex: R=%d, deferred roles %d, maxchild %d, rank mass %d' % (R, len(deferred), max(z), s_))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/cyclic-deferred/core_pair_block.py b/research/cyclic-deferred/core_pair_block.py
new file mode 100644
index 0000000000..b80eb8b5cb
--- /dev/null
+++ b/research/cyclic-deferred/core_pair_block.py
@@ -0,0 +1,47 @@
+"""Core-aware pair assembly within PairedTriple's contracted pair subproblems.
+
+Adapted from Avi Eisenberg's PR62 interval-strip/core-aware pair producer
+(Apache-2.0, Anthropic Claude assistance), on the inherited icekylinx paired
+exclusion recursion. This adaptation uses a two-point base case, the caller's
+cyclic-strip vector routine, and column-pair coarse sums at every level.
+Prepared with OpenAI Codex assistance. All operations remain disjoint sums;
+the enclosing producer checks exact supports and binary frame inclusions.
+"""
+from itertools import combinations
+
+def block(self,points,edges,weights):
+ if len(points)<=2:
+  total=lambda omit:self.total([x for p,x in edges.items()if not set(p)&set(omit)]+[x for p,x in weights.items()if p not in omit])
+  return total(()),{a:total((a,))for a in points},{(a,b):total((a,b))for a,b in combinations(points,2)}
+ groups=self.grouping(points);ng=len(groups);e=lambda a,b:edges[tuple(sorted((a,b)))]
+ coarse={(i,j):self.total([self.total([e(a,b)for a in groups[i]])for b in groups[j]])for i,j in combinations(range(ng),2)}
+ wt={i:self.total([weights[a]for a in g]+[e(a,b)for a,b in combinations(g,2)])for i,g in enumerate(groups)}
+ total,outside,far=self.block(list(range(ng)),coarse,wt)
+ strips={};sums={}
+ for i,g in enumerate(groups):
+  other=[j for j in range(ng)if j!=i]
+  for a in g:
+   carry=self.total([weights[u]for u in g if u!=a])
+   vals=[self.total([e(u,v)for u in g if u!=a for v in groups[j]])for j in other]
+   st,one,_=self.vector([carry]+vals,False)
+   strips[a]={j:z for j,z in zip(other,one[1:])};sums[a]=st
+ out={};single={a:self.add(outside[i],sums[a])for i,g in enumerate(groups)for a in g}
+ for i,g in enumerate(groups):
+  for a,b in combinations(g,2):out[a,b]=outside[i]
+ for i,j in combinations(range(ng),2):
+  if len(groups[i])==2 and len(groups[j])==2:
+   (a,a2),(b,b2)=groups[i],groups[j];F=far[i,j]
+   Sa,Sa2,Sb,Sb2=strips[a][j],strips[a2][j],strips[b][i],strips[b2][i]
+   FSa,FSa2=self.add(F,Sa),self.add(F,Sa2)
+   FSb,FSb2=self.add(F,Sb),self.add(F,Sb2)
+   Y1=self.add(FSb,Sa);Y2=self.add(FSa,Sb2)
+   Y3=self.add(FSa2,e(a,b2));Y4=self.add(FSb2,e(a,b))
+   out[a,b]=self.add(e(a2,b2),Y1);out[a,b2]=self.add(e(a2,b),Y2)
+   out[a2,b]=self.add(Y3,Sb);out[a2,b2]=self.add(Y4,Sa2)
+  else:
+   for a in groups[i]:
+    left=self.add(far[i,j],strips[a][j])
+    for b in groups[j]:
+     cross=self.total([e(u,v)for u in groups[i]if u!=a for v in groups[j]if v!=b])
+     out[a,b]=self.add(left,self.add(strips[b][i],cross))
+ return total,single,out
diff --git a/research/cyclic-deferred/inputs/deferred_23.json.gz b/research/cyclic-deferred/inputs/deferred_23.json.gz
new file mode 100644
index 0000000000..4a4431bd42
Binary files /dev/null and b/research/cyclic-deferred/inputs/deferred_23.json.gz differ
diff --git a/research/cyclic-deferred/inputs/witness_23.json.gz b/research/cyclic-deferred/inputs/witness_23.json.gz
new file mode 100644
index 0000000000..3d86f83b87
Binary files /dev/null and b/research/cyclic-deferred/inputs/witness_23.json.gz differ
diff --git a/research/cyclic-deferred/producer.py b/research/cyclic-deferred/producer.py
new file mode 100644
index 0000000000..68322160f5
--- /dev/null
+++ b/research/cyclic-deferred/producer.py
@@ -0,0 +1,275 @@
+# Cyclic-strip recursion plus dual-suffix pair stars, by Rohan Arun with Anthropic Claude assistance.
+# Parent: PR107 (Rohan Arun with OpenAI Codex) on icekylinx PR104 at 854ba7dca98651eab2050402384e1a7784534f0a.
+# Pair-star leave-one-out identity: PR55 dual-suffix strips (credited there).
+# Original copyright, Apache-2.0 notice and scalar/frame assertions retained.
+"""Aligned h=24 rational-center producer with cyclic strips and core-aware pairs.
+
+PR111's cyclic-strip PairedTriple recursion and dual-suffix pair stars are
+retained. Contracted pair subproblems use core_pair_block.py: PR62's core-aware
+four-output assembly, two-point base cases, and balanced column coarse sums.
+All ordinary-support, exact rational-scatter, center, and binary-frame
+assertions from PR111/PR104 remain enabled.
+
+Copyright 2026 icekylinx and the credited contributors, Apache-2.0. PR111 by
+Rohan Arun with Anthropic Claude assistance; PR62 pair assembly by Avi
+Eisenberg with Anthropic Claude assistance. This integration was prepared
+with OpenAI Codex assistance. See the inherited NOTICE and source credits.
+"""
+import json, struct, array
+from itertools import combinations
+from pathlib import Path
+from partial_swap.binary import write_array
+from paired_triple_circuit import PairedTriple
+from exclusion_circuit import ExclusionCircuit
+
+
+def cyclic_vector(self,values,two=True):
+    """Leave-one-out by cyclic interval strips (PR62 idea): I(a,m)=I(a,m-1)+v_(a+m-1).
+
+    Used for every strip of the PairedTriple recursion; leave-two-out vectors are unchanged.
+    Zero entries are omitted (their leave-one-out value is the total), exactly as before."""
+    if two:return ExclusionCircuit.vector(self,values,two)
+    vals=list(values);n=len(vals)
+    if n==0:return 0,[],{}
+    nz=[i for i,x in enumerate(vals) if x]
+    if not nz:return 0,[0]*n,{}
+    if len(nz)==1:
+        x=vals[nz[0]];return x,[0 if i==nz[0] else x for i in range(n)],{}
+    v=[vals[i] for i in nz];k=len(v)
+    if k<3:
+        tot=self.add(v[0],v[1]);one=[v[1],v[0]]
+    else:
+        full=(1<<k)-1;iv=lambda a,m:sum(1<<((a+t)%k) for t in range(m))
+        node={1<<i:x for i,x in enumerate(v)}
+        for m in range(2,k):
+            for a in range(k):node[iv(a,m)]=self.add(node[iv(a,m-1)],node[1<<((a+m-1)%k)])
+        node[full]=self.add(node[iv(0,k-1)],node[1<<(k-1)])
+        tot=node[full];one=[node[full^(1<<j)] for j in range(k)]
+    out=[tot]*n
+    for i,y in zip(nz,one):out[i]=y
+    return tot,out,{}
+
+def build(h, prefix, central_disjoint, base=2):
+    assert (h, central_disjoint, base) == (24,24,2)
+    d=central_disjoint
+    assert 0<d<=h
+    divisor=abs(3-d)
+    assert divisor == 21
+    triples=list(combinations(range(h),3)); v=len(triples)
+    args=[(0,0)]; support=[0]; core=[0]; cover=[0]; types=[0]; ranks=[0]
+    lookup={}; inputs={}; center_coeff={}
+    # Each central tree adds h-1 ordinary pair totals, so every intermediate
+    # coefficient is at most h-1. Wider lanes rule out hidden integer carries.
+    coefficient_bits=h.bit_length()
+    def packed(mask):
+        result=0
+        while mask:
+            bit=mask&-mask; mask-=bit
+            result |= 1 << (coefficient_bits*(bit.bit_length()-1))
+        return result
+    for j,t in enumerate(triples):
+        mask=sum(1<<a for a in t); x=len(args); inputs[t]=x
+        args.append((0,0));support.append(1<<j);core.append(mask);cover.append(mask)
+        types.append(1);ranks.append(1);lookup[1<<j]=x
+    def add(a,b,center=None):
+        if not a:return b
+        if not b:return a
+        if center is None:
+            assert not support[a]&support[b], "Ordinary additions must be cancellation-free"
+        s=support[a]|support[b]
+        if center is None and s in lookup:return lookup[s]
+        x=len(args);args.append((a,b));support.append(s)
+        core.append(core[a]&core[b]);cover.append(cover[a]|cover[b])
+        if center is not None:
+            types.append(3);ranks.append(h-1);core[x]=1<<center
+            ca=center_coeff[a] if a in center_coeff else packed(support[a])
+            cb=center_coeff[b] if b in center_coeff else packed(support[b])
+            center_coeff[x]=ca+cb
+        elif core[x].bit_count()>=2:
+            types.append(1);ranks.append(s.bit_count());lookup[s]=x
+        else:
+            types.append(2);ranks.append(cover[x].bit_count());lookup[s]=x
+        return x
+    def total(xs,center=None):
+        xs=[x for x in xs if x]
+        while len(xs)>1:
+            xs=[add(xs[i],xs[i+1],center) if i+1<len(xs) else xs[i] for i in range(0,len(xs),2)]
+        return xs[0] if xs else 0
+    from core_pair_block import block as core_pair_block
+    PairedTriple.block=core_pair_block
+    PairedTriple.vector=cyclic_vector
+    try:paired=PairedTriple(h,base)
+    finally:del PairedTriple.vector;del PairedTriple.block
+    allresults=paired.triple(list(range(h)),paired.variables)
+    selected=list(paired.outputs.values())+[allresults[(i,)] for i in range(d)]
+    active=set();stack=list(selected)
+    while stack:
+        x=stack.pop()
+        if not x or x in active:continue
+        active.add(x)
+        if paired.args[x]:stack.extend(paired.args[x])
+    mapping={0:0}|{j+1:inputs[t] for j,t in enumerate(triples)}
+    for x in sorted(active):
+        if paired.args[x]:
+            a,b=paired.args[x];mapping[x]=add(mapping[a],mapping[b])
+    roots=[mapping[paired.outputs[t]] for t in triples];kind=[0]*v
+    center_disjoint_roots=[mapping[allresults[(i,)]] for i in range(d)]
+    del paired, mapping, active, allresults
+    pairtotals={}; pair_outputs={}
+    point_masks=[sum(1<<j for j,t in enumerate(triples) if a in t) for a in range(h)]
+    full_support=(1<<v)-1
+    for t,node in zip(triples,roots):
+        assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]])
+        target_mask=sum(1<<a for a in t)
+        if types[node]==2:
+            assert not cover[node]&target_mask
+        else:
+            assert types[node]==1
+            assert not support[node]&(point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]])
+    for i,node in enumerate(center_disjoint_roots):
+        assert support[node] == full_support & ~point_masks[i]
+        assert types[node]==2 and cover[node]==((1<<h)-1)^(1<<i)
+        assert ranks[node]==h-1
+    for a,b in combinations(range(h),2):
+        others=[i for i in range(h) if i not in (a,b)]
+        others.sort(key=lambda i:((i^1) in (a,b),i))
+        # Dual-suffix leave-one-out (the PR55 strip identity, here on pair stars):
+        # s_j = (A_{j-1} + v_{j+1}) + B_{j+2}, s_k = A_{k-1}, with prefix sums A
+        # and suffix sums B. Each A_{j-1} feeds A_j and A_{j-1}+v_{j+1}; nested
+        # covers let the legal carrier matcher join far more additions.
+        vals=[inputs[tuple(sorted((a,b,i)))] for i in others];k=len(vals)
+        assert k>=3
+        A=[0]*(k+1)
+        for t in range(1,k):A[t]=add(A[t-1],vals[t-1])
+        B=[0]*(k+2)
+        for t in range(k,1,-1):B[t]=add(vals[t-1],B[t+1])
+        dual=[add(add(A[t-1],vals[t]),B[t+2]) for t in range(1,k)]+[A[k-1]]
+        pre=[A[k-1],add(A[k-1],vals[k-1])]
+        for j,i in enumerate(others):
+            node=dual[j]
+            roots.append(node);kind.append(0)
+            pair_outputs[a,b,i]=node
+            assert support[node] == point_masks[a]&point_masks[b]&~point_masks[i]
+            assert types[node]==1
+            assert not support[node]&(point_masks[a]^point_masks[b]^point_masks[i])
+        pairtotals[a,b]=pre[-1]
+        assert support[pre[-1]] == point_masks[a]&point_masks[b]
+    for a in range(d,h):
+        root=total([pairtotals[tuple(sorted((a,b)))] for b in range(h) if b!=a],center=a)
+        assert center_coeff[root] == 2*packed(point_masks[a]), "Center coefficients must be exactly doubled"
+        roots.append(root);kind.append(1)
+    roots.extend(center_disjoint_roots);kind.extend([1]*d)
+    # Mixed retained centers recover the total by
+    # (sum B_i - 2 sum D_i)/(2(3-d)); check each source coefficient.
+    Dset=set(range(d))
+    for triple in triples:
+        k=len(Dset.intersection(triple))
+        assert 2*(3-k)-2*(d-k)==2*(3-d)
+    # Check the rational substituted center scatter for every realizable pair of
+    # target/source memberships. Its coefficient is (intersection-1)/2.
+    from fractions import Fraction
+    # Every A_i avoids i, so sum A_i = (h-3)T. The selected decoder is
+    # T=sum A_i/21 and scatter T-(1/2)sum_{i in target} A_i.
+    decoder=Fraction(1,h-3)
+    assert decoder==Fraction(1,21)
+    scatter_coefficients=[decoder,decoder-Fraction(1,2)]
+    for coefficient in scatter_coefficients:
+        odd_denominator=coefficient.denominator
+        while odd_denominator%2==0:
+            odd_denominator//=2
+        assert 21%odd_denominator==0 and abs(coefficient)<=1
+    for source in triples:
+        assert sum(i not in source for i in range(h))*decoder==1
+    patterns={}
+    for target in triples:
+        chosen=len(Dset.intersection(target))
+        if chosen not in patterns:
+            patterns[chosen]=target
+    for chosen,target in patterns.items():
+        target_set=set(target)
+        for source in triples:
+            k=len(Dset.intersection(source))
+            total_coefficient=Fraction(2*(3-k)-2*(d-k),2*(3-d))
+            scalar=Fraction(len((target_set-Dset).intersection(source)),2)
+            scalar-=Fraction(len((target_set&Dset)-set(source)),2)
+            scalar+=Fraction(chosen-1,2)*total_coefficient
+            assert scalar==Fraction(len(target_set.intersection(source))-1,2)
+    # Check the scalar correction for each target, using the verified exact
+    # roots. Twice the coefficient is (intersection-1)+[intersection=0]
+    # -[intersection=2], which is two precisely for the diagonal.
+    for j,t in enumerate(triples):
+        masks=[point_masks[a] for a in t]
+        two=(masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0])
+        actual=0
+        for a,b in combinations(t,2):
+            excluded=next(i for i in t if i not in (a,b))
+            actual |= support[pair_outputs[a,b,excluded]]
+        assert actual == two
+        assert masks[0]&masks[1]&masks[2] == 1<<j
+    assert [((k-1)+(k==0)-(k==2)) for k in range(4)] == [0,0,0,2]
+    def contained(x,y):
+        tx,ty=types[x],types[y]
+        if tx==1 and ty==1: return not(core[y]&~core[x] or cover[x]&~cover[y])
+        if tx in (1,2) and ty==2: return not cover[x]&~cover[y]
+        if tx==1 and ty==3: return bool(core[x]&core[y])
+        if tx==2 and ty==3: return not cover[x]&~core[y]
+        if tx==3 and ty==2: return cover[y]==(1<<h)-1
+        if tx==3 and ty==3: return core[x]==core[y]
+        return False
+    active=[0]*len(args);stack=list(roots)
+    while stack:
+        x=stack.pop()
+        if not x or active[x]:continue
+        active[x]=1
+        if args[x][0]:stack.extend(args[x])
+    degree=[0]*len(args)
+    for x in range(1,len(args)):
+        if active[x]:
+            if types[x]==1:
+                # Shared-pair triple indicators have self-dot one and
+                # pairwise dot zero over F2; a source is a single such line.
+                assert core[x].bit_count()>=2 and ranks[x]==support[x].bit_count()
+            elif types[x]==2:
+                assert ranks[x]==cover[x].bit_count()
+            else:
+                # E_a is the orthogonal complement of the odd vector 1+e_a.
+                assert types[x]==3 and core[x].bit_count()==1 and ranks[x]==h-1
+        if active[x] and args[x][0]:
+            for y in args[x]:
+                assert y<x and contained(y,x), "Binary frame nesting failed"
+                degree[y]+=1
+    for x in roots:degree[x]+=1
+    H=[0]*(h+1);c=0;loss=0
+    for x in range(1,len(args)):
+        if not active[x]:continue
+        r=ranks[x]
+        if args[x][0]:
+            c+=1;H[r]+=degree[x]-1;H[h-r]+=1
+            for y in args[x]:
+                assert r>=ranks[y]
+                H[r-ranks[y]]+=1
+        else:H[1]+=degree[x]
+    for x,k in zip(roots,kind):
+        r=ranks[x]
+        if k:H[r]+=1;H[h]+=1;loss+=r
+        else:H[h-1-r]+=1;H[1]+=1
+    q=len(roots);R=c+q
+    result=dict(h=h,v=v,c=c,q=q,R=R,loss=loss,central_disjoint=d,histogram=H,rank_sum=sum(r*n for r,n in enumerate(H)))
+    assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss
+    prefix=Path(prefix)
+    result['center_denominator']=21
+    result['scalar_validation']=dict(ordinary_supports_exact=True, centers_exact=True,
+        center_decoder='sum A_i / 21', scatter_coefficients=list(map(str,scatter_coefficients)),
+        rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True,
+        binary_frames_nondegenerate=True)
+    with open(str(prefix)+'.bin','wb') as f:
+        f.write(struct.pack('<4I',h,v,len(args),q))
+        write_array(f,array.array('I',(a for pair in args for a in pair)))
+        write_array(f,array.array('Q',core));write_array(f,array.array('Q',cover))
+        write_array(f,array.array('I',roots));write_array(f,array.array('I',kind))
+        write_array(f,array.array('B',active))
+    with open(str(prefix)+'.labels','wb') as f:
+        write_array(f,array.array('I',ranks));write_array(f,array.array('B',types))
+    Path(str(prefix)+'.json').write_text(json.dumps(result,indent=2)+'\n')
+
+    return result
diff --git a/research/cyclic-deferred/reflection-audit.json b/research/cyclic-deferred/reflection-audit.json
new file mode 100644
index 0000000000..dba4ceb2ca
--- /dev/null
+++ b/research/cyclic-deferred/reflection-audit.json
@@ -0,0 +1,75 @@
+{
+  "R": 37859,
+  "all_frames_nondegenerate": true,
+  "audit_sha256": "7f534ddc406b1454f71831790b0f519007fa4120a025a30fe162ef9c9215a9d7",
+  "child_multiplicities": {
+    "1": 285772608,
+    "10": 9411600,
+    "11": 5553856,
+    "12": 7363312,
+    "13": 5128816,
+    "14": 11237248,
+    "15": 5756256,
+    "16": 8201248,
+    "17": 7849072,
+    "18": 10751488,
+    "19": 10099760,
+    "2": 252696400,
+    "20": 5974848,
+    "21": 4234208,
+    "22": 12063040,
+    "23": 8302448,
+    "3": 41917040,
+    "4": 62112512,
+    "5": 30736464,
+    "529": 8193152,
+    "552": 132276496,
+    "553": 12144,
+    "554": 133584,
+    "556": 210496,
+    "558": 157872,
+    "560": 388608,
+    "562": 655776,
+    "564": 1133440,
+    "565": 4048,
+    "566": 1623248,
+    "567": 24288,
+    "568": 1177968,
+    "569": 20240,
+    "570": 4456848,
+    "571": 2671680,
+    "572": 1218448,
+    "573": 663872,
+    "574": 6424176,
+    "6": 33096448,
+    "7": 15572656,
+    "8": 14289440,
+    "9": 8144576
+  },
+  "conservative_local_G": 18613460152,
+  "exact_arbitrary_dirty_cancellation_by_dependency_cut": true,
+  "exact_fresh_source_map": true,
+  "exact_integer_old_readout_transpose": true,
+  "expanded_old_readout_additions": 12065228,
+  "expanded_scalar_operations_per_stage": 12335266,
+  "forward_incidence_sha256": "8ecdad0c9bbf54c6b0be027fa432379b0907da2b33e92a0ba2d461e58063a21f",
+  "h": 24,
+  "largest_readout_numerator_over_42": 40,
+  "literal_frame_incidences_both_directions": true,
+  "literal_global_scalar_groups": 49937253344,
+  "old_readout_coefficients_over_42_sha256": "ff4b51cae7cdc36ec8545347cefd93ea274d0d1a6320b2b15a2844cd69195580",
+  "reflected_incidence_sha256": "b1178edf415afdcfc38f66bc543308e7038b0a89106ad95404a0a2683463f2a0",
+  "reflected_residual_rank_histogram_equal": true,
+  "reflected_scalar_map": "X becomes X-Y; Y unchanged; all auxiliary coordinates restored.",
+  "reflected_word_rule": "Reverse literal order, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.",
+  "rejected_controls": [
+    "inverse-sign",
+    "uncomplemented-frame",
+    "signed-root-readout"
+  ],
+  "scope": "Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.",
+  "source_sha256": "de328c6eda1863375a21f5b81689739001fb05411873c2ac70470ddfafe3286c",
+  "two_stage_scalar_map": "(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.",
+  "v": 2024,
+  "word_blocks": 259297
+}
diff --git a/research/cyclic-deferred/reflection_audit.py b/research/cyclic-deferred/reflection_audit.py
new file mode 100644
index 0000000000..c036c36b4c
--- /dev/null
+++ b/research/cyclic-deferred/reflection_audit.py
@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""Literal inverse/reflection and exact finite scalar/frame audit.
+
+Captures an unchanged deferred producer before its output write, then checks
+the scalar computation on every source symbol, the exact signed old-readout
+transpose, the dependency cut and the complete complemented incidence ledger.
+This is finite verification; the inherited residual-to-child implementation,
+all-size transfer and analytic interfaces are not proved by this script.
+"""
+import ast
+from collections import Counter
+from functools import lru_cache
+from hashlib import sha256
+from itertools import combinations
+import argparse,json,pickle,sys
+from pathlib import Path
+sys.dont_write_bytecode=True
+assert not sys.flags.optimize,'Assertions must remain enabled'
+
+
+def capture(source):
+    source=Path(source).resolve();sys.path.insert(0,str(source.parent))
+    tree=ast.parse(source.read_text(),filename=str(source))
+    main=next(n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='main')
+    at=next(i for i,n in enumerate(main.body) if isinstance(n,ast.Expr) and isinstance(n.value,ast.Call) and isinstance(n.value.func,ast.Attribute) and n.value.func.attr=='write_text')
+    main.body[at:]=[ast.Return(ast.Call(ast.Name('locals',ast.Load()),[],[]))]
+    ast.fix_missing_locations(tree)
+    ns={'__file__':str(source),'__name__':'reflection_capture'}
+    exec(compile(tree,str(source)+' [read-only capture]','exec'),ns)
+    data=ns['main']();data['source']=str(source);return data
+
+
+def basis(vectors):
+    piv={}
+    for x in vectors:
+        for p in sorted(piv,reverse=True):
+            if x>>p&1:x^=piv[p]
+        if x:
+            p=x.bit_length()-1
+            for q in piv:
+                if piv[q]>>p&1:piv[q]^=x
+            piv[p]=x
+    return tuple(piv[p] for p in sorted(piv,reverse=True))
+
+
+def dot(a,b):return (a&b).bit_count()&1
+
+
+@lru_cache(None)
+def contained(A,B):return len(basis(A+B))==len(B)
+
+
+@lru_cache(None)
+def complement(A,h):
+    A=basis(A);piv={x.bit_length()-1:x for x in A};result=[]
+    for j in range(h):
+        if j not in piv:
+            x=1<<j
+            for p,row in piv.items():
+                if row>>j&1:x|=1<<p
+            result.append(x)
+    return basis(result)
+
+
+@lru_cache(None)
+def nondeg(A):
+    return len(basis(sum(dot(x,y)<<j for j,y in enumerate(A)) for x in A))==len(A)
+
+
+def root_readout(d,s):
+    h,v,j=d['h'],d['v'],d['role_root'][s];p=(1<<61)-1
+    if d['kind'][j]:
+        assert d['seed_c'][s]==[int(i==d['centre_of'][j]) for i in range(h)],'Root centre readout'
+        assert d['seed_d'][s]=={},'Root centre extra target'
+    else:
+        assert d['seed_c'][s] is None,'Root extra centre'
+        expected=pow(2,-1,p)*(1 if j<v else -1)%p
+        assert d['seed_d'][s]=={d['target'][j]:expected},'Root signed readout'
+
+
+@lru_cache(None)
+def dual_frames(A,B,h):
+    return len(A)+len(B)==h and all(not dot(x,y) for x in A for y in B)
+
+
+def check_reflection(forward,backward,h,v):
+    def bank(s):return s+v if s<v else s-v if s<2*v else s
+    assert len(forward)==len(backward),'Reflected event count'
+    for left,right in zip(reversed(forward),backward):
+        k,a,b,c,F,*tail=left;kk,aa,bb,cc,FF,*tt=right
+        assert kk==k and aa==bank(a) and cc==-c,'Reflected inverse shear'
+        assert bb==(bank(b) if k=='gate' else tuple(bank(t) for t in reversed(b))),'Reflected port incidence'
+        assert dual_frames(F,FF,h),'Reflected frame complement'
+        if k=='centre':
+            assert dual_frames(tail[0],tt[0],h) and tail[1:]==tt[1:],'Reflected centre copy'
+        else:assert tail==tt,'Reflected coefficient-row binding'
+
+
+def audit(d):
+    h,v,R=d['h'],d['v'],d['R'];ops=d['ops'];q=d['q'];p=(1<<61)-1
+    trip=list(combinations(range(h),3));assert d['trip']==trip
+    for s in d['role_root']:root_readout(d,s)
+    full=(1<<v)-1;point=[sum(1<<j for j,T in enumerate(trip) if i in T) for i in range(h)]
+    # All fresh-source coefficients, exactly over the integers. No modular
+    # replay is used for this check, and no stored DAG support is trusted.
+    nodes={};values=[0]*R
+    for n in d['order']:
+        a,b=d['args'][n]
+        if not a:nodes[n]=1<<(n-1)
+        else:
+            assert not nodes[a]&nodes[b],('DAG overlap',n)
+            nodes[n]=nodes[a]|nodes[b]
+    for s,n in d['leaf_of'].items():values[s]=1<<(n-1)
+    for o in ops:
+        if o[0]=='src':continue
+        a,b=(o[1],o[2]) if o[0]=='add' else (o[2],o[1])
+        assert not values[a]&values[b],('literal signal overlap',o)
+        values[a]|=values[b]
+        assert values[a]==nodes[o[3]],('literal source coefficients',o)
+    negative=[0]*v;positive=[None]*v;centres={}
+    for s,j in d['role_root'].items():
+        assert values[s]==nodes[d['roots'][j]]
+        if d['kind'][j]:centres[d['centre_of'][j]]=values[s]
+        elif j<v:
+            t=d['target'][j];assert positive[t] is None;positive[t]=values[s]
+        else:
+            t=d['target'][j];assert not negative[t]&values[s];negative[t]|=values[s]
+    assert set(centres)==set(range(h))
+    for i,S in centres.items():assert S==full^point[i]
+    for t,T in enumerate(trip):
+        A,B,C=(point[i] for i in T)
+        assert positive[t]==full^(A|B|C)
+        assert negative[t]==((A&B&~C)|(A&C&~B)|(B&C&~A))
+    assert h-3==21
+    assert [((k-1)+(k==0)-(k==2)) for k in range(4)]==[0,0,0,2]
+    # Every centre decoder coefficient is 1/21-[i in T]/2. Thus the
+    # preceding source-support identities prove J L V = I over Q.
+
+    # Independently form J L on arbitrary scratch as integer centre rows
+    # and signed half-output rows. Compare every coefficient, not hashes.
+    cc=[None]*R;dd=[{} for _ in range(R)]
+    for s,j in d['role_root'].items():
+        if d['kind'][j]:cc[s]=[int(i==d['centre_of'][j]) for i in range(h)]
+        else:dd[s][d['target'][j]]=1 if j<v else -1
+        assert cc[s]==d['seed_c'][s],'Root centre readout'
+        assert {t:(x*pow(2,-1,p))%p for t,x in dd[s].items()}==d['seed_d'][s],'Root signed readout'
+    def addrow(a,b):
+        if cc[b] is not None:
+            cc[a]=list(cc[b]) if cc[a] is None else [x+y for x,y in zip(cc[a],cc[b])]
+        for t,x in dd[b].items():dd[a][t]=dd[a].get(t,0)+x
+    for o in reversed(ops):
+        if o[0]=='add':addrow(o[2],o[1])
+        elif o[0]=='copy':addrow(o[1],o[2])
+    maxcoef=0;readcount=0;actual_reach={};coefficient_digest=sha256()
+    for s in range(R):
+        assert cc[s] is None and d['cvec'][s] is None or cc[s] is not None and [x%p for x in cc[s]]==d['cvec'][s]
+        assert {t:(x*pow(2,-1,p))%p for t,x in dd[s].items()}==d['dpart'][s]
+        # Exact expanded readout numerators over the single denominator42.
+        if cc[s] is None:
+            reached=tuple(t for t,x in sorted(dd[s].items()) if x)
+            maxcoef=max(maxcoef,max((abs(21*x) for x in dd[s].values()),default=0))
+            coefficient_digest.update(repr((s,[(t,21*dd[s][t]) for t in reached])).encode()+b'\n')
+        else:
+            total=2*sum(cc[s]);reached=[]
+            for t,T in enumerate(trip):
+                num=total-21*sum(cc[s][i] for i in T)+21*dd[s].get(t,0)
+                maxcoef=max(maxcoef,abs(num))
+                if num:
+                    reached.append(t)
+                    coefficient_digest.update(s.to_bytes(4,'little')+t.to_bytes(4,'little')+num.to_bytes(8,'little',signed=True))
+            reached=tuple(reached)
+        readcount+=len(reached);actual_reach[s]=reached
+    assert maxcoef<=42,'Expanded readout coefficient exceeds one in absolute value'
+    # Early/remainder order is a legal commutation of independent shears.
+    # Deferred inputs are untouched by the early word; completed centre
+    # roles are untouched by its remainder. These facts make deferred
+    # readout placement equivalent to the canonical -JL, V, L, J,L^-1,-V.
+    early=set(d['phase1']);assert early==set(d['Anc'])
+    assert sorted(d['phase1'])==d['phase1'] and d['rest']==[i for i in range(len(ops)) if i not in early]
+    seen_late=set();early_touched=set();late_touched=set()
+    for i,o in enumerate(ops):
+        touched=set(o[1:3]) if o[0] in ('add','copy') else set()
+        if i in early:
+            assert not touched&seen_late;early_touched.update(touched)
+        else:seen_late.update(touched);late_touched.update(touched)
+    assert not set(d['deferred'])&early_touched
+    assert not set(d['centre_roles'])&late_touched
+    assert all(cc[s] is None for s in d['deferred'])
+    for s in d['deferred']:assert set(actual_reach[s])<=set(d['reach'][s])
+
+    # Frame-labelled literal chronological word. Readout blocks mean the
+    # explicit commuting additions to their individual named target ports;
+    # their scalar count and target incidences are expanded above.
+    ZERO=();FULL=basis(1<<i for i in range(h))
+    U={n:basis(B) for n,B in d['U'].items()}
+    sigma={s:basis(B) for s,B in d['placed'].items()}
+    rootframe={s:basis(B) for s,B in d['root_frame'].items()}
+    tm=[basis((sum(1<<i for i in T),)) for T in trip]
+    X=lambda t:t;Y=lambda t:v+t;A=lambda s:2*v+s
+    word=[]
+    def gate(a,b,c,F):word.append(('gate',a,b,c,F))
+    def read(s,sgn,F,targets,row):word.append(('read',A(s),tuple(Y(t) for t in targets),sgn,F,row))
+    def run(i,sign=1,F=None):
+        o=ops[i]
+        if o[0]=='add':gate(A(o[1]),A(o[2]),sign,U[o[3]] if F is None else F)
+        elif o[0]=='copy':gate(A(o[2]),A(o[1]),sign,U[o[3]] if F is None else F)
+    deferred=set(d['deferred'])
+    for s in range(R):
+        if s not in deferred:read(s,-1,ZERO,actual_reach[s],('old',s))
+    for s,n in d['leaf_of'].items():
+        if s not in deferred:gate(A(s),X(n-1),1,U[n])
+    for i in d['phase1']:run(i)
+    for s in d['centre_roles']:word.append(('centre',A(s),tuple(Y(t) for t in range(v)),1,rootframe[s],ZERO,d['centre_of'][d['role_root'][s]]))
+    for s in d['deferred']:read(s,-1,sigma[s],actual_reach[s],('old',s))
+    for s in d['deferred']:
+        if s in d['leaf_of']:n=d['leaf_of'][s];gate(A(s),X(n-1),1,U[n])
+    for i in d['rest']:run(i)
+    for s,j in d['role_root'].items():
+        if not d['kind'][j]:read(s,1,rootframe[s],(d['target'][j],),('root',21 if j<v else -21))
+    for i in reversed(range(len(ops))):run(i,-1,FULL)
+    for s,n in d['leaf_of'].items():gate(A(s),X(n-1),-1,FULL)
+
+    def swap(s):return s+v if s<v else s-v if s<2*v else s
+    def reflect(event):
+        k,a,b,c,F,*rest=event
+        if k=='gate':return (k,swap(a),swap(b),-c,complement(F,h))
+        tail=(complement(rest[0],h),rest[1]) if k=='centre' else tuple(rest)
+        return (k,swap(a),tuple(swap(t) for t in reversed(b)),-c,complement(F,h),*tail)
+    reverse=[reflect(e) for e in reversed(word)]
+    assert [reflect(e) for e in reversed(reverse)]==word
+    check_reflection(word,reverse,h,v)
+    # Reuse this exact captured word for targeted failure controls.
+    rejected=[]
+    for failure in ('inverse-sign','uncomplemented-frame'):
+        damaged=list(reverse);first=list(damaged[0])
+        if failure=='inverse-sign':first[3]*=-1
+        else:first[4]=word[-1][4]
+        damaged[0]=tuple(first)
+        try:check_reflection(word,damaged,h,v)
+        except AssertionError:rejected.append(failure)
+        else:raise AssertionError('Accepted reflection mutation: '+failure)
+    s=next(s for s,j in d['role_root'].items() if not d['kind'][j]);original=d['seed_d'][s]
+    d['seed_d'][s]={t:(-c)%p for t,c in original.items()}
+    try:
+        try:root_readout(d,s)
+        except AssertionError:rejected.append('signed-root-readout')
+        else:raise AssertionError('Accepted signed root mutation')
+    finally:d['seed_d'][s]=original
+
+    def framescan(events,initial,expected):
+        current=list(initial);hist=Counter();copies=Counter();scalar=0;digest=sha256()
+        def promote(s,F):
+            old=current[s];assert contained(old,F),(s,old,F)
+            assert nondeg(F);assert nondeg(complement(F,h))
+            if len(F)>len(old):hist[len(F)-len(old)]+=1
+            current[s]=F
+        for event in events:
+            k,a,b,c,F,*rest=event
+            assert c in (-1,1)
+            promote(a,F)
+            if k=='gate':promote(b,F);scalar+=1
+            elif k=='read':
+                for t in b:promote(t,F)
+                scalar+=len(b)
+            else:
+                assert k=='centre';G=rest[0]
+                assert contained(G,F) or contained(F,G)
+                assert nondeg(G);copies[abs(len(F)-len(G))]+=1
+                for t in b:promote(t,G)
+                scalar+=len(b)+2 # temporary copy and erasure
+            digest.update(repr(event).encode()+b'\n')
+        # Each literal role cleanup reaches full space; any unused final
+        # endpoint is still represented explicitly in the expected chain.
+        for s,F in enumerate(expected):promote(s,F)
+        assert current==expected
+        return hist,copies,scalar,digest.hexdigest()
+    start=tm+[ZERO]*v+[sigma.get(s,ZERO) for s in range(R)]
+    finish=[FULL]*v+[complement(T,h) for T in tm]+[FULL]*R
+    H,C,scalar,digest=framescan(word,start,finish)
+    revstart=[None]*len(start);revfinish=[None]*len(start)
+    for s in range(len(start)):
+        revstart[swap(s)]=complement(finish[s],h);revfinish[swap(s)]=complement(start[s],h)
+    HR,CR,scalarR,reverse_digest=framescan(reverse,revstart,revfinish)
+    assert (H,C,scalar)==(HR,CR,scalarR)
+    z=Counter({r:2*v*n for r,n in (H+C).items()})
+    for s in range(R):z[h*h-h+len(sigma.get(s,ZERO))]+=2*v
+    z[(h-1)**2]+=2*v*v;z[1]+=v*v
+    z.pop(0,None)
+    assert dict(sorted(z.items()))=={int(r):n for r,n in d['out']['child_multiplicities'].items()},'Literal reflected child histogram'
+    assert sum(r*n for r,n in z.items())==d['out']['total_rank']
+    G=v*v+2*v*scalar
+    safe=8*(d['c_add']+2*R+(R+q)*v*(h+1)+h*h+h+1) if 'c_add' in d else 8*(d['out']['additions']+2*R+(R+q)*v*(h+1)+h*h+h+1)
+    assert safe>=scalar
+    return dict(h=h,v=v,R=R,exact_fresh_source_map=True,exact_integer_old_readout_transpose=True,
+                exact_arbitrary_dirty_cancellation_by_dependency_cut=True,
+                reflected_word_rule='Reverse literal order, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.',
+                reflected_scalar_map='X becomes X-Y; Y unchanged; all auxiliary coordinates restored.',
+                two_stage_scalar_map='(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.',
+                literal_frame_incidences_both_directions=True,all_frames_nondegenerate=True,
+                reflected_residual_rank_histogram_equal=True,child_multiplicities=dict(sorted(z.items())),
+                word_blocks=len(word),expanded_scalar_operations_per_stage=scalar,
+                expanded_old_readout_additions=readcount,largest_readout_numerator_over_42=maxcoef,
+                old_readout_coefficients_over_42_sha256=coefficient_digest.hexdigest(),
+                literal_global_scalar_groups=G,conservative_local_G=safe,
+                forward_incidence_sha256=digest,reflected_incidence_sha256=reverse_digest,
+                rejected_controls=rejected,
+                scope='Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.')
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path);ap.add_argument('--state',type=Path)
+    ap.add_argument('--output',type=Path);ap.add_argument('--check',type=Path);a=ap.parse_args()
+    assert bool(a.source)!=bool(a.state)
+    d=capture(a.source) if a.source else pickle.loads(a.state.read_bytes())
+    result=audit(d);source=Path(d['source'])
+    result['source_sha256']=sha256(source.read_bytes()).hexdigest()
+    result['audit_sha256']=sha256(Path(__file__).read_bytes()).hexdigest()
+    result=json.loads(json.dumps(result));encoded=json.dumps(result,indent=2,sort_keys=True)+'\n'
+    if a.check:assert result==json.loads(a.check.read_text())
+    if a.output:a.output.write_text(encoded)
+    else:print(encoded,end='')
+    print('PASS exact scalar and literal complement reflection audit',file=sys.stderr)
+
+
+if __name__=='__main__':main()
diff --git a/research/cyclic-deferred/test_controls.py b/research/cyclic-deferred/test_controls.py
new file mode 100644
index 0000000000..aac1c069ef
--- /dev/null
+++ b/research/cyclic-deferred/test_controls.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Negative controls for the cyclic/deferred frozen finite witness.
+
+These controls target source omissions, altered inputs, paid rank accounting,
+noncontracting children and invalid exact arithmetic. They do not substitute
+for the full producer and literal reflection checks. Prepared for eumemic with
+OpenAI Codex assistance; Apache-2.0, inherited notices retained.
+"""
+import sys
+sys.dont_write_bytecode = True
+if sys.flags.optimize:
+    raise ValueError('Negative controls require assertions')
+
+import argparse
+import copy
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+
+from verify import check_sources, compare_json, safe_file, validate_profile
+
+HERE = Path(__file__).resolve().parent
+REPOSITORY = HERE.parents[1]
+
+
+class FrozenControls(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.manifest = check_sources(HERE, REPOSITORY)
+        cls.profiles = {label: json.loads((HERE / (label + '-profile.json')).read_text())
+                        for label in ('bit', 'complex')}
+        sys.path.insert(0, str(REPOSITORY / 'scripts'))
+        spec = importlib.util.spec_from_file_location('checked_cyclic_certificate', HERE / 'certificate.py')
+        cls.certificate = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(cls.certificate)
+        cls.certificate.ROOT = REPOSITORY
+
+    def test_all_frozen_profiles_satisfy_physical_ledgers(self):
+        for label, profile in self.profiles.items():
+            validate_profile(profile, label)
+
+    def test_frozen_exact_certificate_recomputed(self):
+        expected = json.loads((HERE / 'certificate.json').read_text())
+        actual = self.certificate.js(self.certificate.exact())
+        self.assertEqual(actual, expected)
+
+    def test_omitted_endpoint_charge_rejected(self):
+        for label, original in self.profiles.items():
+            changed = copy.deepcopy(original)
+            changed['child_multiplicities']['1'] -= changed['N']
+            with self.assertRaisesRegex(ValueError, 'rank mass'):
+                validate_profile(changed, label)
+
+    def test_nonshrinking_recursive_child_rejected(self):
+        for label, original in self.profiles.items():
+            changed = copy.deepcopy(original)
+            changed['child_multiplicities'][str(changed['m'])] = 1
+            with self.assertRaisesRegex(ValueError, 'recursive child'):
+                validate_profile(changed, label)
+
+    def test_understated_role_count_rejected(self):
+        changed = copy.deepcopy(self.profiles['complex'])
+        changed['R'] -= 1
+        with self.assertRaisesRegex(ValueError, 'physical ledger'):
+            validate_profile(changed, 'complex')
+
+    def test_overstated_matching_rejected(self):
+        changed = copy.deepcopy(self.profiles['complex'])
+        changed['links'] += 1
+        with self.assertRaisesRegex(ValueError, 'matching role ledger'):
+            validate_profile(changed, 'complex')
+
+    def test_missing_transitive_dependency_rejected(self):
+        changed = copy.deepcopy(self.manifest)
+        del changed['repository_files']['scripts/exclusion_circuit.py']
+        with self.assertRaisesRegex(ValueError, 'dependency closure'):
+            check_sources(HERE, REPOSITORY, changed)
+
+    def test_omitted_physical_input_rejected(self):
+        changed = copy.deepcopy(self.manifest)
+        del changed['package_files']['inputs/deferred_23.json.gz']
+        with self.assertRaisesRegex(ValueError, 'finite-input closure'):
+            check_sources(HERE, REPOSITORY, changed)
+
+    def test_changed_input_digest_rejected(self):
+        changed = copy.deepcopy(self.manifest)
+        changed['package_files']['inputs/witness_23.json.gz'] = '0' * 64
+        with self.assertRaisesRegex(ValueError, 'hash mismatch'):
+            check_sources(HERE, REPOSITORY, changed)
+
+    def test_manifest_parent_escape_rejected(self):
+        with self.assertRaisesRegex(ValueError, 'Unsafe manifest path'):
+            safe_file(HERE, '../certificate.json')
+
+    def test_changed_regenerated_profile_rejected(self):
+        with tempfile.TemporaryDirectory(prefix='cyclic-deferred-negative-') as directory:
+            changed = copy.deepcopy(self.profiles['complex'])
+            changed['child_multiplicities']['1'] += 1
+            path = Path(directory) / 'changed.json'
+            path.write_text(json.dumps(changed))
+            with self.assertRaisesRegex(ValueError, 'Frozen generated record mismatch'):
+                compare_json(path, HERE / 'complex-profile.json')
+
+    def test_next_bit_and_complex_grid_points_rejected(self):
+        from fractions import Fraction as Q
+        module = self.certificate
+        self.assertFalse(module.contracts(module.profile('bit-profile.json'), module.COARSE + Q(1, 10**10)))
+        self.assertFalse(module.contracts(module.profile('complex-profile.json'), module.COMPLEX + Q(1, 10**12)))
+
+    def test_optimized_verifier_rejected_before_any_regeneration(self):
+        result = subprocess.run([sys.executable, '-O', str(HERE / 'verify.py')],
+                                capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn('optimized Python is forbidden', result.stderr)
+
+
+def main():
+    global REPOSITORY
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--repository-root', type=Path, default=REPOSITORY)
+    args = parser.parse_args()
+    REPOSITORY = args.repository_root.resolve()
+    suite = unittest.defaultTestLoader.loadTestsFromTestCase(FrozenControls)
+    result = unittest.TextTestRunner(verbosity=2).run(suite)
+    if not result.wasSuccessful():
+        raise SystemExit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/cyclic-deferred/verify.py b/research/cyclic-deferred/verify.py
new file mode 100644
index 0000000000..409e64cc7d
--- /dev/null
+++ b/research/cyclic-deferred/verify.py
@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""Read-only verification of the frozen cyclic/deferred finite package.
+
+Regeneration occurs only in a temporary repository-shaped copy. Source hashes,
+complete profile ledgers, the exact certificate, and the independent reflection
+audit are required. General transfer proofs and the inherited round-seven bit
+word/frame justification remain separate dependencies. Prepared for eumemic
+with OpenAI Codex assistance; inherited authorship and licenses are retained.
+"""
+import sys
+sys.dont_write_bytecode = True
+if sys.flags.optimize:
+    raise ValueError('Verification requires assertions; optimized Python is forbidden')
+
+import argparse
+import ast
+from hashlib import sha256
+import json
+from math import comb
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+BIT_PINS = {
+    'witness_23.json.gz': 'b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588',
+    'deferred_23.json.gz': '8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c',
+}
+REQUIRED = {
+    'verify.py', 'test_controls.py', 'producer.py', 'complex_deferred.py',
+    'bit_round7.py', 'certificate.py', 'bit-profile.json',
+    'complex-profile.json', 'certificate.json',
+    *('inputs/' + name for name in BIT_PINS),
+}
+DATA_DEPENDENCIES = {'certificates/copied-centers-network.json'}
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def safe_file(directory, name):
+    relative = Path(name)
+    require(not relative.is_absolute() and '..' not in relative.parts,
+            'Unsafe manifest path: ' + name)
+    path = (directory / relative).resolve()
+    require(path.is_relative_to(directory.resolve()) and path.is_file(),
+            'Missing or escaping manifest file: ' + name)
+    return path
+
+
+def digest(path):
+    return sha256(path.read_bytes()).hexdigest()
+
+
+def dependency_closure(package, repository, package_scripts):
+    """Include every local Python import, including package __init__ modules.
+
+    All package scripts are roots, also covering explicit importlib loading of
+    the producer and audited source. Only stdlib imports may be unresolved.
+    The sole external data read used by exact assembly is listed separately.
+    """
+    pending = [package / name for name in package_scripts]
+    seen, dependencies = set(), set(DATA_DEPENDENCIES)
+    while pending:
+        path = pending.pop().resolve()
+        if path in seen:
+            continue
+        seen.add(path)
+        imports = []
+        for node in ast.walk(ast.parse(path.read_text(), filename=str(path))):
+            if isinstance(node, ast.Import):
+                imports.extend((alias.name, 0) for alias in node.names)
+            elif isinstance(node, ast.ImportFrom) and node.module:
+                imports.append((node.module, node.level))
+        for name, level in imports:
+            parts = name.split('.')
+            if not level and parts[0] in sys.stdlib_module_names:
+                continue
+            found = None
+            bases = ((path.parent.parents[level-2] if level > 1 else path.parent),) if level else (package, repository / 'scripts')
+            for base in bases:
+                module = base.joinpath(*parts)
+                for candidate in (module.with_suffix('.py'), module / '__init__.py'):
+                    if candidate.is_file():
+                        found = candidate.resolve()
+                        break
+                if found is not None:
+                    pending.append(found)
+                    if found.is_relative_to((repository / 'scripts').resolve()):
+                        dependencies.add(str(found.relative_to(repository.resolve())))
+                        parent = found.parent
+                        while parent != (repository / 'scripts').resolve():
+                            initializer = parent / '__init__.py'
+                            if initializer.is_file():
+                                pending.append(initializer)
+                                dependencies.add(str(initializer.relative_to(repository)))
+                            parent = parent.parent
+                    break
+            require(found is not None, 'Unpinned non-stdlib Python import: ' + name)
+    return dependencies
+
+
+def create_manifest(package, repository, reflection_script, reflection_receipt):
+    scripts = sorted(path.name for path in package.glob('*.py'))
+    names = REQUIRED | set(scripts) | {reflection_script, reflection_receipt}
+    dependencies = dependency_closure(package, repository, scripts)
+    return dict(
+        schema=1,
+        scope='Frozen finite producer, profiles, exact assembly and reflection audit; inherited all-size transfer remains conditional.',
+        package_files={name: digest(safe_file(package, name)) for name in sorted(names)},
+        repository_files={name: digest(safe_file(repository, name)) for name in sorted(dependencies)},
+        reflection=dict(script=reflection_script, receipt=reflection_receipt),
+        provenance=dict(
+            base='https://github.com/CrocSwap/integer-mult-bounds/pull/110',
+            cyclic_strips='https://github.com/CrocSwap/integer-mult-bounds/pull/111',
+            core_aware_pair_assembly='https://github.com/CrocSwap/integer-mult-bounds/pull/62',
+            round7_repository='https://github.com/Swapnil-jain/integer-mult-kappa',
+            round7_commit='741e7aa078392553815df7926ee17ac5e25a8c38',
+            round7_sha256=BIT_PINS),
+        attribution='Avi Eisenberg / ikeboy (PR62 and PR110, Anthropic Claude assistance); Rohan Arun (PR111, Anthropic Claude assistance); Swapnil Jain (round-seven bit word); icekylinx (retained stopped-product, copied-center and finite assembly interfaces); Zhihao Chen and RaD (retained assembly). Core-aware pair transfer, integration and verification for eumemic with OpenAI Codex assistance. Original source notices remain authoritative.')
+
+
+def check_sources(package, repository, manifest=None):
+    manifest = manifest or json.loads((package / 'SOURCE.json').read_text())
+    require(manifest['schema'] == 1, 'Unsupported source-manifest schema')
+    names = set(manifest['package_files'])
+    reflection = manifest['reflection']
+    require(REQUIRED | {reflection['script'], reflection['receipt']} <= names,
+            'Incomplete package source/finite-input closure')
+    for collection, base in ((manifest['package_files'], package),
+                             (manifest['repository_files'], repository)):
+        for name, expected in collection.items():
+            require(digest(safe_file(base, name)) == expected, 'Source hash mismatch: ' + name)
+    scripts = sorted(name for name in names if name.endswith('.py'))
+    expected = dependency_closure(package, repository, scripts)
+    require(set(manifest['repository_files']) == expected,
+            'Incomplete or stale transitive repository dependency closure')
+    for name, expected in BIT_PINS.items():
+        require(manifest['package_files']['inputs/' + name] == expected,
+                'Round-seven provenance digest mismatch: ' + name)
+    return manifest
+
+
+def validate_profile(profile, label):
+    fields = ('h', 'v', 'R', 'm', 'N', 'W', 'L', 'total_rank', 'deficit', 'maxchild')
+    require(all(type(profile[key]) is int and profile[key] > 0 for key in fields),
+            label + ': nonpositive or noninteger ledger value')
+    h, v, R, m, N, W, L = (profile[key] for key in fields[:7])
+    require(v == comb(h, 3) and m == h*h and N == v*v, label + ': dimensions')
+    require(W == 2*N + 2*v*R and L == 2*v*h*(h-1), label + ': physical ledger')
+    rows = {int(t): count for t, count in profile['child_multiplicities'].items()}
+    require(len(rows) == len(profile['child_multiplicities']), label + ': duplicate child widths')
+    require(all(0 < t < m and type(count) is int and count > 0 for t, count in rows.items()),
+            label + ': invalid recursive child')
+    require(sum(t*count for t, count in rows.items()) == profile['total_rank'] == W*m-N+L,
+            label + ': rank mass')
+    require(profile['deficit'] == N-L and profile['maxchild'] == max(rows),
+            label + ': deficit or maximum child')
+    require(rows.get((h-1)**2) == 2*N and rows.get(1, 0) >= N,
+            label + ': omitted data projector or endpoint charge')
+    if label == 'complex':
+        require(R == profile['additions']+profile['roots']-profile['links'],
+                'complex: addition/roots/matching role ledger')
+        require(sum(profile['deferred_dims'].values()) == profile['deferred_roles'],
+                'complex: deferral inventory')
+    return rows
+
+
+def compare_json(actual, expected):
+    require(json.loads(actual.read_text()) == json.loads(expected.read_text()),
+            'Frozen generated record mismatch: ' + expected.name)
+
+
+def snapshot(package, repository, manifest):
+    return {
+        **{'package:' + n: digest(package / n) for n in manifest['package_files']},
+        **{'repository:' + n: digest(repository / n) for n in manifest['repository_files']},
+        'manifest': digest(package / 'SOURCE.json'),
+    }
+
+
+def verify(package, repository):
+    manifest = check_sources(package, repository)
+    before = snapshot(package, repository, manifest)
+    for label in ('bit', 'complex'):
+        validate_profile(json.loads((package / (label + '-profile.json')).read_text()), label)
+    environment = dict(os.environ, PYTHONDONTWRITEBYTECODE='1')
+    environment.pop('PYTHONPATH', None)
+    with tempfile.TemporaryDirectory(prefix='cyclic-deferred-verify-') as directory:
+        root = Path(directory)
+        target = root / 'research/cyclic-deferred'
+        for collection, source, destination in (
+                (manifest['package_files'], package, target),
+                (manifest['repository_files'], repository, root)):
+            for name in collection:
+                out = destination / name
+                out.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(source / name, out)
+        shutil.copyfile(package / 'SOURCE.json', target / 'SOURCE.json')
+
+        def run(script, *arguments):
+            subprocess.run([sys.executable, str(target / script), *map(str, arguments)],
+                           cwd=root, env=environment, check=True)
+
+        run('bit_round7.py', target / 'inputs')
+        compare_json(target / 'bit-profile.json', package / 'bit-profile.json')
+        print('PASS pinned round-seven bit ledger regenerated', flush=True)
+        run('complex_deferred.py')
+        compare_json(target / 'complex-profile.json', package / 'complex-profile.json')
+        print('PASS complete complex producer and deferred profile regenerated', flush=True)
+        run('certificate.py')
+        reflection = manifest['reflection']
+        actual_reflection = root / 'actual-reflection.json'
+        run(reflection['script'], '--source', target / 'complex_deferred.py',
+            '--output', actual_reflection)
+        compare_json(actual_reflection, package / reflection['receipt'])
+        print('PASS independent literal reflection and scalar-charge audit', flush=True)
+        run('test_controls.py', '--repository-root', root)
+    require(snapshot(package, repository, manifest) == before,
+            'Verification changed the frozen package or a dependency')
+    print('PASS read-only finite package verification; inherited transfer remains conditional', flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--repository-root', type=Path, default=HERE.parents[1])
+    parser.add_argument('--freeze-manifest', action='store_true',
+                        help='Explicit authoring operation: replace SOURCE.json from reviewed files')
+    parser.add_argument('--reflection-script', default='reflection_audit.py')
+    parser.add_argument('--reflection-receipt', default='reflection-audit.json')
+    args = parser.parse_args()
+    repository = args.repository_root.resolve()
+    if args.freeze_manifest:
+        manifest = create_manifest(HERE, repository, args.reflection_script, args.reflection_receipt)
+        (HERE / 'SOURCE.json').write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n')
+        print('Frozen source manifest; this operation does not certify the package')
+    else:
+        verify(HERE, repository)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/deferred-replayed-117/PROOF.md b/research/deferred-replayed-117/PROOF.md
new file mode 100644
index 0000000000..29ed472a4f
--- /dev/null
+++ b/research/deferred-replayed-117/PROOF.md
@@ -0,0 +1,30 @@
+# Finite composition and unit readout decomposition
+
+The scalar DAG and replay routine are copied byte-for-byte from eumemic's PR117 at cbb05ce504d571546d9b7794c186a613c659c3bf. Its support checks establish the same triple-disjoint, pair-star and 24 retained center outputs, with decoder denominator 21. PR116's inherited PR110 deferral construction is applied to that DAG with its lexicographic pair-star root order. All matching eligibility, lifted frame, untouched-prefix, dirty-scratch and rank-mass checks are retained. This composition changes the physical schedule's readout placement; it does not add the savings of two different schedules.
+
+## Why the old coefficient check failed
+
+The old readout is the transpose-propagated row JL acting on arbitrary initial scratch. Even though the fresh-source DAG is cancellation-free, different scratch paths can combine into a readout coefficient larger than one. For the selected graph, independent exact integer expansion finds a largest numerator magnitude of 55 over the common denominator 42. The previous PR116 audit required a numerator magnitude at most 42. That assertion correctly fails on the new graph. Random finite-field replay and a contracting moment alone do not establish the missing scalar implementation.
+
+## Exact replacement by bounded shears
+
+For every expanded coefficient n/42, write |n| = 42q+r with 0 <= r < 42. Replace its shear by q shears with coefficient sign(n), followed, when r is nonzero, by one shear with coefficient sign(n) r/42. The selected witness is checked exhaustively to require at most two pieces for every coefficient. The implementation verifies their exact integer sum and that each piece has magnitude at most one. In particular 55/42 becomes 1 + 13/42. Zero coefficients produce no operation.
+
+These shears share the same source port, target port and frame. If E is the source-to-target elementary off-diagonal matrix, E^2=0, so (I+aE)(I+bE)=I+(a+b)E. Thus splitting preserves the map over the exact rational coefficient ring, for arbitrary dirty data. Its inverse negates the coefficients in reverse order; the reflected schedule swaps the ports and complements the unchanged frames as before. Consecutive pieces introduce no frame transition and hence no additional recursive child. Their odd denominator still divides 21, so the retained fixed odd-denominator grid applies.
+
+The audit independently expands every old readout coefficient, verifies its decomposition, charges each actual piece in both literal directions, checks frame continuity, and requires exactly the same complete child histogram and rank sum. The audit also retains the wrong-inverse-sign, uncomplemented-frame and wrong-signed-root controls. Additional controls reject an unpaid third piece, a dropped fractional piece, an oversized unsplit shear, and a wrong sign, and verify exact shear/inverse action on arbitrary rational dirty values.
+
+## Paid scalar accounting
+
+Let C=2 be the audited maximum number of pieces, and let c,R,q,v,h denote the actual circuit quantities. We conservatively multiply the entire previous scalar bound by C, rather than charging only the split readouts:
+
+    local = C * 8 * (c + 2R + (R+q)v(h+1) + h^2 + h + 1)
+    G = N + 2v * local.
+
+The independent literal audit checks its expanded scalar count against this bound. The exact certificate recomputes E, the literal charge, B, C0, the induction gaps and all row/cutoff quantities using this G. All 47 strict constraints and seven margins must still hold. The complete recursive profile, strict bit/complex savings and final kappa are unchanged by this additional scalar work; the certificate verifies this rather than assuming it.
+
+## Proof boundary and attribution
+
+This is a finite conditional construction. The opposite-bank factorization, nondegenerate residual-to-child rule (including permitted alternating residuals), stopped atom streaming, common rational/odd-denominator interfaces, analytic transfer and fixed-tape assumptions remain the inherited written interfaces. Finite tests are not a formal proof of those general interfaces or a claim of global optimality.
+
+Credit eumemic for PR117's DAG and PR114's accounting, Avi Eisenberg for PR110's deferral construction, Rohan Arun's PR116 integration, Swapnil Jain's round-seven bit word, icekylinx's stopped-product and rational-center interfaces, and all predecessors retained in the original notices. The composition was supplied with Anthropic Claude assistance. The independent audit, failure diagnosis, unit-shear correction and verification were prepared by Rohan Arun with OpenAI Codex assistance.
diff --git a/research/deferred-replayed-117/README.md b/research/deferred-replayed-117/README.md
new file mode 100644
index 0000000000..6b0a0b4e28
--- /dev/null
+++ b/research/deferred-replayed-117/README.md
@@ -0,0 +1,53 @@
+# Deferred readouts on PR117's 28,705-role complex producer
+
+Conditional κ = 6783925373/(6.25·10^13) = **1.085428059680 × 10^-4** — **+3.875% over PR #117**
+(1044939/10^10) and +9.97% over PR #116.
+
+PR #117 (eumemic) found an h = 24 all-disjoint complex DAG with only 28,705 roles, but charged its
+complex side with PR #104's plain profile (no deferral): a_c = 26129/(2.5·10^8) binds.
+PR #110 (and #114/#116) showed deferred readouts pay on the complex network under PR #104's
+one-child rule. This witness runs the same deferral algorithm, with its producer adapter, expected graph counts and pair-star order updated on PR #117's DAG.
+
+| h = 24 complex | PR #117 | this |
+|---|---:|---:|
+| additions / matched / roles | 91,770 / 71,185 / 28,705 | same DAG, same 28,705 roles |
+| deferred roles | — | 3,020 |
+| complex saving (binding) | 26129/2.5·10^8 = 1.045160e-4 | **108566486/10^12 = 1.085665e-4** |
+| κ | 1.044939e-4 | **1.085428e-4** |
+
+Bit side: Swapnil Jain's round-seven deferred word under PR #104's one-child rule — the same bit word
+as PR #117 and PR #110/#116 (`bit-profile.json`, coarse 620523/(5·10^9), stopped 1.2402e-4).
+
+## Files and checks
+
+```sh
+python3 research/deferred-replayed-117/complex_deferred.py   # ~2 min; DAG replay, matching, lifted frames,
+                                                              # deferral, arbitrary-scratch replay, exact F2 checks
+python3 research/deferred-replayed-117/certificate.py         # exact moments, next-grid rejections,
+                                                              # expanded scalar charge, 47 constraints, 7 margins
+```
+
+- `replayed.py`, `complex-dag.json.gz`: copied unchanged from PR #117; every support, label, rank,
+  root identity, ÷21 decoder/scatter identity, nesting and nondegeneracy is recomputed from operand pairs.
+- `producer.py`: adapter exposing `build` and the pair-star order (ascending) to the deferral compiler.
+- `complex_deferred.py`, `certificate.py`: PR #116's deferral compiler and certificate with only paths, the
+  pinned graph size (91,770 / 8,120 / 71,185 / 28,705) and the complex constant changed; the certificate
+  also requires κ above PR #117 and PR #116. The unit-shear correction below additionally increases the scalar guard.
+
+Scope: finite conditional witness under PR #104's written interfaces and PR #110's stated deferral argument
+(see the PROOF.md files of PR #110/#116 and PR #117). No optimality or practical-speed claim.
+
+Credit: eumemic (PR #117 DAG and PR #114), Avi Eisenberg (PR #110 deferral), Swapnil Jain (deferred
+readouts, round-seven word), icekylinx (PR #104/#115), PR #116, and all predecessors in PR #104's
+NOTICE/SOURCES. Composition by Rohan Arun with Anthropic Claude assistance. Apache-2.0.
+
+## Unit-shear audit correction
+
+Independent exact expansion found a largest old-readout coefficient of 55/42, so the inherited PR116 audit's bound of one was insufficient. The corrected implementation splits each coefficient into at most two unit-magnitude shears at the same frame (55/42 = 1 + 13/42). The exact audit checks every decomposition, charges every piece in both directions and preserves the full child histogram. The certificate doubles the previous conservative local scalar-work bound and recomputes all guards; kappa remains unchanged. Eight new controls cover unpaid pieces, incorrect signs, dropped terms and exact dirty-value shear/inverse action. See [PROOF.md](PROOF.md).
+
+```sh
+python3 research/deferred-replayed-117/test_unit_readouts.py
+python3 research/deferred-replayed-117/audit.py --source research/deferred-replayed-117/complex_deferred.py
+```
+
+The original failed audit log is preserved in the local build evidence. The corrected independent audit passed: all 11,862,912 nonzero old readout coefficients are covered by 11,862,944 unit shears (32 extra scalar additions), and the forward/reflected child histogram is unchanged. The doubled conservative scalar guard still supports the same exact kappa. `python3 research/deferred-replayed-117/verify.py --full` reproduces source pins, profiles, assembly, controls and this audit. Full verification of the initial research commit is still running; corrected-package coverage must pass before readiness. No passing full rerun is claimed yet.
diff --git a/research/deferred-replayed-117/SOURCE.json b/research/deferred-replayed-117/SOURCE.json
new file mode 100644
index 0000000000..39b1e4d02a
--- /dev/null
+++ b/research/deferred-replayed-117/SOURCE.json
@@ -0,0 +1,55 @@
+{
+  "attribution": "eumemic PR117/114, Avi Eisenberg PR110, Swapnil Jain, icekylinx, Rohan Arun PR116 and inherited contributors; user handoff with Anthropic Claude; unit-shear correction and independent audit with OpenAI Codex.",
+  "package_files": {
+    "PROOF.md": "eafe1e9b45a38237c829fadba406c0e76454559927a0f61c9207122e3dd01b71",
+    "README.md": "b16ba9c9d78a0c51ef691fa03d520c91a6405b03390fd58d394461a7f3910d7a",
+    "audit-result.json": "0437936707efd33a0cbb369029a6118bc87c8ec193decc7d6f20f71162cd8b00",
+    "audit.py": "052101c7e6ad160f3564cd2752c2d498ff90ef6de847de41b8599c969a9201c6",
+    "bit-profile.json": "7293f330518b78650bd86d76b93681e43f3a55541cdb8110993714148a4b4a6a",
+    "bit_round7.py": "35d261a9248c2e06f9179e3c47e554a96b8fe763a9a3de2731256b8c0fbc74b0",
+    "certificate.json": "f1d77d26036cf2b01bc630a572b2cdea0027e0faa2e4899b5b907b9d455ff916",
+    "certificate.py": "3f0d0502ef88bfca50adffae6371c916140b7655007235f6910ff4231604b205",
+    "complex-dag.json.gz": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b",
+    "complex-profile.json": "ff5e9bbc1a3794d8dd3f75e194ea002cef8439c40a5d434c4a84e46967edc98e",
+    "complex_deferred.py": "ebc3f0f5df35faaca953a4dedbea8fad011b2d252118760a7e4912a07903eb33",
+    "producer.py": "34bcc5f7753fb9bfbf7a555ac4e3279fb48de7d7ec598c3cfa1e9254f64d3d5a",
+    "replayed.py": "99c1e3694ae06a7ce7a370b04ecb45ea3fcfe69a6e6e7f4c4606e0a6c74c3184",
+    "test_unit_readouts.py": "30055d18a9f243d42a22a7c7dd950b3c460d952e9b513ff813a9adb909d39a70",
+    "unit_readouts.py": "344fe1b7d1cf3a669b90c4042755abe2a69fa7bfcad8ee6221e3d9fe907dffd5",
+    "verify.py": "0699f161f0ddd52fae90539b0c81d6a58c8081db2c048e19464cd60fda3a46e4"
+  },
+  "provenance": {
+    "base_pr116_commit": "97750ec74fc714638c0aa4f31aaa880e56cb8b4d",
+    "pr117_commit": "cbb05ce504d571546d9b7794c186a613c659c3bf",
+    "pr117_dag_path": "certificates/deferred-product-complex-dag.json.gz",
+    "pr117_replay_path": "scripts/deferred_product/replayed.py"
+  },
+  "repository_files": {
+    "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf",
+    "research/cube-deferred/inputs/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+    "research/cube-deferred/inputs/witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+    "research/cyclic-deferred/complex-profile.json": "6b6c8a40a1d27cd792e12feb42baba91d792caafe49c476527b3ce79511c7da5",
+    "scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1",
+    "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e",
+    "scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f",
+    "scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1",
+    "scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b",
+    "scripts/copied_centers/__init__.py": "13db4f09038a2ff5335cbd4dbd93274b0fb16b3c7b51e4de67cbb2801a3f78e1",
+    "scripts/copied_centers/corners.py": "9eecdc39c67cc18c806a33f0be03986c28591d322881fd60c11f52c625c8067b",
+    "scripts/copied_centers/physical.py": "837345d1f8753eab0e70f105b1d1bb0db965b993da037b1825ddef3672609d7d",
+    "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9",
+    "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0",
+    "scripts/fast_gaussian.py": "11430c2df0783b933dc91080595bb7514bb052b8c7b12107e27a1ef701e31e43",
+    "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2",
+    "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7",
+    "scripts/paired_triple_circuit.py": "8f5f2de32fdbd8e0005154638660ff416e5a8cd59623bd0dc03f6f7f97ce2fb1",
+    "scripts/partial_swap/__init__.py": "0438eaa34134600467a5864f93c3e15142eb025b35cef189c2e969cffea72a7f",
+    "scripts/partial_swap/binary.py": "d32d7a23548cc738e974e8e55dd1fa2a8b11d2b80228515617ffe35410bb8805",
+    "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782",
+    "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947",
+    "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a",
+    "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba",
+    "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697",
+    "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d"
+  }
+}
diff --git a/research/deferred-replayed-117/audit-result.json b/research/deferred-replayed-117/audit-result.json
new file mode 100644
index 0000000000..ae12deb6f1
--- /dev/null
+++ b/research/deferred-replayed-117/audit-result.json
@@ -0,0 +1,73 @@
+{
+  "R": 28705,
+  "all_frames_nondegenerate": true,
+  "audit_sha256": "052101c7e6ad160f3564cd2752c2d498ff90ef6de847de41b8599c969a9201c6",
+  "child_multiplicities": {
+    "1": 340181776,
+    "10": 8087904,
+    "11": 9407552,
+    "12": 15358112,
+    "13": 10796016,
+    "14": 1198208,
+    "15": 1194160,
+    "16": 1246784,
+    "17": 497904,
+    "18": 3040048,
+    "19": 2100912,
+    "2": 351342112,
+    "20": 850080,
+    "21": 1222496,
+    "22": 64768,
+    "23": 8359120,
+    "3": 36998720,
+    "4": 71762944,
+    "5": 29999728,
+    "529": 8193152,
+    "552": 103972880,
+    "554": 8096,
+    "556": 514096,
+    "560": 311696,
+    "562": 64768,
+    "564": 1505856,
+    "566": 979616,
+    "568": 1388464,
+    "569": 8096,
+    "570": 3720112,
+    "571": 2343792,
+    "572": 850080,
+    "573": 44528,
+    "574": 485760,
+    "6": 13038608,
+    "7": 14285392,
+    "8": 30481440,
+    "9": 6266304
+  },
+  "conservative_local_G": 29815916496,
+  "exact_arbitrary_dirty_cancellation_by_dependency_cut": true,
+  "exact_fresh_source_map": true,
+  "exact_integer_old_readout_transpose": true,
+  "expanded_old_readout_additions": 11862912,
+  "expanded_old_readout_unit_shears": 11862944,
+  "expanded_scalar_operations_per_stage": 12160614,
+  "forward_incidence_sha256": "8ba7b36a78e1c7f364815be6d039f03b9ca07df18af4ee9f15ee265198de5f28",
+  "h": 24,
+  "largest_readout_numerator_over_42": 55,
+  "literal_frame_incidences_both_directions": true,
+  "literal_global_scalar_groups": 49230262048,
+  "maximum_paid_unit_pieces": 2,
+  "old_readout_coefficients_over_42_sha256": "e0666f81e1d35e002d61b8f2b2b1ca0d1d79cc7fbcbc76063eb333294d875e5e",
+  "reflected_incidence_sha256": "fa30885e184f52dfea0929665a0289e92df2499ec605e2a9a65cd5de52f85d14",
+  "reflected_residual_rank_histogram_equal": true,
+  "reflected_scalar_map": "X becomes X-Y; Y unchanged; all auxiliary coordinates restored.",
+  "reflected_word_rule": "Reverse literal order, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.",
+  "rejected_controls": [
+    "inverse-sign",
+    "uncomplemented-frame",
+    "signed-root-readout"
+  ],
+  "scope": "Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.",
+  "source_sha256": "ebc3f0f5df35faaca953a4dedbea8fad011b2d252118760a7e4912a07903eb33",
+  "two_stage_scalar_map": "(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.",
+  "v": 2024,
+  "word_blocks": 277775
+}
diff --git a/research/deferred-replayed-117/audit.py b/research/deferred-replayed-117/audit.py
new file mode 100644
index 0000000000..eeaffd37e5
--- /dev/null
+++ b/research/deferred-replayed-117/audit.py
@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+"""Literal inverse/reflection and exact finite scalar/frame audit with paid unit shears.
+
+Adapted from PR116 by Rohan Arun with OpenAI Codex assistance.
+Original coefficient<=1 failure is preserved in build evidence. Every new
+coefficient is decomposed exactly and the scalar ledger charges each piece.
+
+Captures an unchanged deferred producer before its output write, then checks
+the scalar computation on every source symbol, the exact signed old-readout
+transpose, the dependency cut and the complete complemented incidence ledger.
+This is finite verification; the inherited residual-to-child implementation,
+all-size transfer and analytic interfaces are not proved by this script.
+"""
+import ast
+from unit_readouts import MAX_PIECES, DENOMINATOR, split_numerator
+from collections import Counter
+from functools import lru_cache
+from hashlib import sha256
+from itertools import combinations
+import argparse,json,pickle,sys
+from pathlib import Path
+sys.dont_write_bytecode=True
+assert not sys.flags.optimize,'Assertions must remain enabled'
+
+
+def capture(source):
+    source=Path(source).resolve();sys.path.insert(0,str(source.parent))
+    tree=ast.parse(source.read_text(),filename=str(source))
+    main=next(n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='main')
+    at=next(i for i,n in enumerate(main.body) if isinstance(n,ast.Expr) and isinstance(n.value,ast.Call) and isinstance(n.value.func,ast.Attribute) and n.value.func.attr=='write_text')
+    main.body[at:]=[ast.Return(ast.Call(ast.Name('locals',ast.Load()),[],[]))]
+    ast.fix_missing_locations(tree)
+    ns={'__file__':str(source),'__name__':'reflection_capture'}
+    exec(compile(tree,str(source)+' [read-only capture]','exec'),ns)
+    data=ns['main']();data['source']=str(source);return data
+
+
+def basis(vectors):
+    piv={}
+    for x in vectors:
+        for p in sorted(piv,reverse=True):
+            if x>>p&1:x^=piv[p]
+        if x:
+            p=x.bit_length()-1
+            for q in piv:
+                if piv[q]>>p&1:piv[q]^=x
+            piv[p]=x
+    return tuple(piv[p] for p in sorted(piv,reverse=True))
+
+
+def dot(a,b):return (a&b).bit_count()&1
+
+
+@lru_cache(None)
+def contained(A,B):return len(basis(A+B))==len(B)
+
+
+@lru_cache(None)
+def complement(A,h):
+    A=basis(A);piv={x.bit_length()-1:x for x in A};result=[]
+    for j in range(h):
+        if j not in piv:
+            x=1<<j
+            for p,row in piv.items():
+                if row>>j&1:x|=1<<p
+            result.append(x)
+    return basis(result)
+
+
+@lru_cache(None)
+def nondeg(A):
+    return len(basis(sum(dot(x,y)<<j for j,y in enumerate(A)) for x in A))==len(A)
+
+
+def root_readout(d,s):
+    h,v,j=d['h'],d['v'],d['role_root'][s];p=(1<<61)-1
+    if d['kind'][j]:
+        assert d['seed_c'][s]==[int(i==d['centre_of'][j]) for i in range(h)],'Root centre readout'
+        assert d['seed_d'][s]=={},'Root centre extra target'
+    else:
+        assert d['seed_c'][s] is None,'Root extra centre'
+        expected=pow(2,-1,p)*(1 if j<v else -1)%p
+        assert d['seed_d'][s]=={d['target'][j]:expected},'Root signed readout'
+
+
+@lru_cache(None)
+def dual_frames(A,B,h):
+    return len(A)+len(B)==h and all(not dot(x,y) for x in A for y in B)
+
+
+def check_reflection(forward,backward,h,v):
+    def bank(s):return s+v if s<v else s-v if s<2*v else s
+    assert len(forward)==len(backward),'Reflected event count'
+    for left,right in zip(reversed(forward),backward):
+        k,a,b,c,F,*tail=left;kk,aa,bb,cc,FF,*tt=right
+        assert kk==k and aa==bank(a) and cc==-c,'Reflected inverse shear'
+        assert bb==(bank(b) if k=='gate' else tuple(bank(t) for t in reversed(b))),'Reflected port incidence'
+        assert dual_frames(F,FF,h),'Reflected frame complement'
+        if k=='centre':
+            assert dual_frames(tail[0],tt[0],h) and tail[1:]==tt[1:],'Reflected centre copy'
+        else:assert tail==tt,'Reflected coefficient-row binding'
+
+
+def audit(d):
+    h,v,R=d['h'],d['v'],d['R'];ops=d['ops'];q=d['q'];p=(1<<61)-1
+    trip=list(combinations(range(h),3));assert d['trip']==trip
+    for s in d['role_root']:root_readout(d,s)
+    full=(1<<v)-1;point=[sum(1<<j for j,T in enumerate(trip) if i in T) for i in range(h)]
+    # All fresh-source coefficients, exactly over the integers. No modular
+    # replay is used for this check, and no stored DAG support is trusted.
+    nodes={};values=[0]*R
+    for n in d['order']:
+        a,b=d['args'][n]
+        if not a:nodes[n]=1<<(n-1)
+        else:
+            assert not nodes[a]&nodes[b],('DAG overlap',n)
+            nodes[n]=nodes[a]|nodes[b]
+    for s,n in d['leaf_of'].items():values[s]=1<<(n-1)
+    for o in ops:
+        if o[0]=='src':continue
+        a,b=(o[1],o[2]) if o[0]=='add' else (o[2],o[1])
+        assert not values[a]&values[b],('literal signal overlap',o)
+        values[a]|=values[b]
+        assert values[a]==nodes[o[3]],('literal source coefficients',o)
+    negative=[0]*v;positive=[None]*v;centres={}
+    for s,j in d['role_root'].items():
+        assert values[s]==nodes[d['roots'][j]]
+        if d['kind'][j]:centres[d['centre_of'][j]]=values[s]
+        elif j<v:
+            t=d['target'][j];assert positive[t] is None;positive[t]=values[s]
+        else:
+            t=d['target'][j];assert not negative[t]&values[s];negative[t]|=values[s]
+    assert set(centres)==set(range(h))
+    for i,S in centres.items():assert S==full^point[i]
+    for t,T in enumerate(trip):
+        A,B,C=(point[i] for i in T)
+        assert positive[t]==full^(A|B|C)
+        assert negative[t]==((A&B&~C)|(A&C&~B)|(B&C&~A))
+    assert h-3==21
+    assert [((k-1)+(k==0)-(k==2)) for k in range(4)]==[0,0,0,2]
+    # Every centre decoder coefficient is 1/21-[i in T]/2. Thus the
+    # preceding source-support identities prove J L V = I over Q.
+
+    # Independently form J L on arbitrary scratch as integer centre rows
+    # and signed half-output rows. Compare every coefficient, not hashes.
+    cc=[None]*R;dd=[{} for _ in range(R)]
+    for s,j in d['role_root'].items():
+        if d['kind'][j]:cc[s]=[int(i==d['centre_of'][j]) for i in range(h)]
+        else:dd[s][d['target'][j]]=1 if j<v else -1
+        assert cc[s]==d['seed_c'][s],'Root centre readout'
+        assert {t:(x*pow(2,-1,p))%p for t,x in dd[s].items()}==d['seed_d'][s],'Root signed readout'
+    def addrow(a,b):
+        if cc[b] is not None:
+            cc[a]=list(cc[b]) if cc[a] is None else [x+y for x,y in zip(cc[a],cc[b])]
+        for t,x in dd[b].items():dd[a][t]=dd[a].get(t,0)+x
+    for o in reversed(ops):
+        if o[0]=='add':addrow(o[2],o[1])
+        elif o[0]=='copy':addrow(o[1],o[2])
+    maxcoef=0;readcount=0;actual_reach={};unit_counts={};coefficient_digest=sha256()
+    for s in range(R):
+        assert cc[s] is None and d['cvec'][s] is None or cc[s] is not None and [x%p for x in cc[s]]==d['cvec'][s]
+        assert {t:(x*pow(2,-1,p))%p for t,x in dd[s].items()}==d['dpart'][s]
+        # Exact expanded readout numerators over the single denominator42.
+        unit_counts[s]=0
+        if cc[s] is None:
+            unit_counts[s]=sum(len(split_numerator(21*x)) for x in dd[s].values())
+            reached=tuple(t for t,x in sorted(dd[s].items()) if x)
+            maxcoef=max(maxcoef,max((abs(21*x) for x in dd[s].values()),default=0))
+            coefficient_digest.update(repr((s,[(t,21*dd[s][t]) for t in reached])).encode()+b'\n')
+        else:
+            total=2*sum(cc[s]);reached=[]
+            for t,T in enumerate(trip):
+                num=total-21*sum(cc[s][i] for i in T)+21*dd[s].get(t,0)
+                unit_counts[s]+=len(split_numerator(num))
+                maxcoef=max(maxcoef,abs(num))
+                if num:
+                    reached.append(t)
+                    coefficient_digest.update(s.to_bytes(4,'little')+t.to_bytes(4,'little')+num.to_bytes(8,'little',signed=True))
+            reached=tuple(reached)
+        readcount+=len(reached);actual_reach[s]=reached
+    assert maxcoef<=DENOMINATOR*MAX_PIECES,'Expanded readout exceeds paid unit decomposition'
+    assert sum(unit_counts.values())<=MAX_PIECES*readcount
+    # Early/remainder order is a legal commutation of independent shears.
+    # Deferred inputs are untouched by the early word; completed centre
+    # roles are untouched by its remainder. These facts make deferred
+    # readout placement equivalent to the canonical -JL, V, L, J,L^-1,-V.
+    early=set(d['phase1']);assert early==set(d['Anc'])
+    assert sorted(d['phase1'])==d['phase1'] and d['rest']==[i for i in range(len(ops)) if i not in early]
+    seen_late=set();early_touched=set();late_touched=set()
+    for i,o in enumerate(ops):
+        touched=set(o[1:3]) if o[0] in ('add','copy') else set()
+        if i in early:
+            assert not touched&seen_late;early_touched.update(touched)
+        else:seen_late.update(touched);late_touched.update(touched)
+    assert not set(d['deferred'])&early_touched
+    assert not set(d['centre_roles'])&late_touched
+    assert all(cc[s] is None for s in d['deferred'])
+    for s in d['deferred']:assert set(actual_reach[s])<=set(d['reach'][s])
+
+    # Frame-labelled literal chronological word. Readout blocks mean the
+    # explicit commuting additions to their individual named target ports;
+    # their scalar count and target incidences are expanded above.
+    ZERO=();FULL=basis(1<<i for i in range(h))
+    U={n:basis(B) for n,B in d['U'].items()}
+    sigma={s:basis(B) for s,B in d['placed'].items()}
+    rootframe={s:basis(B) for s,B in d['root_frame'].items()}
+    tm=[basis((sum(1<<i for i in T),)) for T in trip]
+    X=lambda t:t;Y=lambda t:v+t;A=lambda s:2*v+s
+    word=[]
+    def gate(a,b,c,F):word.append(('gate',a,b,c,F))
+    def read(s,sgn,F,targets,row):word.append(('read',A(s),tuple(Y(t) for t in targets),sgn,F,row))
+    def run(i,sign=1,F=None):
+        o=ops[i]
+        if o[0]=='add':gate(A(o[1]),A(o[2]),sign,U[o[3]] if F is None else F)
+        elif o[0]=='copy':gate(A(o[2]),A(o[1]),sign,U[o[3]] if F is None else F)
+    deferred=set(d['deferred'])
+    for s in range(R):
+        if s not in deferred:read(s,-1,ZERO,actual_reach[s],('old',s))
+    for s,n in d['leaf_of'].items():
+        if s not in deferred:gate(A(s),X(n-1),1,U[n])
+    for i in d['phase1']:run(i)
+    for s in d['centre_roles']:word.append(('centre',A(s),tuple(Y(t) for t in range(v)),1,rootframe[s],ZERO,d['centre_of'][d['role_root'][s]]))
+    for s in d['deferred']:read(s,-1,sigma[s],actual_reach[s],('old',s))
+    for s in d['deferred']:
+        if s in d['leaf_of']:n=d['leaf_of'][s];gate(A(s),X(n-1),1,U[n])
+    for i in d['rest']:run(i)
+    for s,j in d['role_root'].items():
+        if not d['kind'][j]:read(s,1,rootframe[s],(d['target'][j],),('root',21 if j<v else -21))
+    for i in reversed(range(len(ops))):run(i,-1,FULL)
+    for s,n in d['leaf_of'].items():gate(A(s),X(n-1),-1,FULL)
+
+    def swap(s):return s+v if s<v else s-v if s<2*v else s
+    def reflect(event):
+        k,a,b,c,F,*rest=event
+        if k=='gate':return (k,swap(a),swap(b),-c,complement(F,h))
+        tail=(complement(rest[0],h),rest[1]) if k=='centre' else tuple(rest)
+        return (k,swap(a),tuple(swap(t) for t in reversed(b)),-c,complement(F,h),*tail)
+    reverse=[reflect(e) for e in reversed(word)]
+    assert [reflect(e) for e in reversed(reverse)]==word
+    check_reflection(word,reverse,h,v)
+    # Reuse this exact captured word for targeted failure controls.
+    rejected=[]
+    for failure in ('inverse-sign','uncomplemented-frame'):
+        damaged=list(reverse);first=list(damaged[0])
+        if failure=='inverse-sign':first[3]*=-1
+        else:first[4]=word[-1][4]
+        damaged[0]=tuple(first)
+        try:check_reflection(word,damaged,h,v)
+        except AssertionError:rejected.append(failure)
+        else:raise AssertionError('Accepted reflection mutation: '+failure)
+    s=next(s for s,j in d['role_root'].items() if not d['kind'][j]);original=d['seed_d'][s]
+    d['seed_d'][s]={t:(-c)%p for t,c in original.items()}
+    try:
+        try:root_readout(d,s)
+        except AssertionError:rejected.append('signed-root-readout')
+        else:raise AssertionError('Accepted signed root mutation')
+    finally:d['seed_d'][s]=original
+
+    def framescan(events,initial,expected):
+        current=list(initial);hist=Counter();copies=Counter();scalar=0;digest=sha256()
+        def promote(s,F):
+            old=current[s];assert contained(old,F),(s,old,F)
+            assert nondeg(F);assert nondeg(complement(F,h))
+            if len(F)>len(old):hist[len(F)-len(old)]+=1
+            current[s]=F
+        for event in events:
+            k,a,b,c,F,*rest=event
+            assert c in (-1,1)
+            promote(a,F)
+            if k=='gate':promote(b,F);scalar+=1
+            elif k=='read':
+                for t in b:promote(t,F)
+                row=rest[0]
+                scalar+=unit_counts[row[1]] if row[0]=='old' else len(b)
+            else:
+                assert k=='centre';G=rest[0]
+                assert contained(G,F) or contained(F,G)
+                assert nondeg(G);copies[abs(len(F)-len(G))]+=1
+                for t in b:promote(t,G)
+                scalar+=len(b)+2 # temporary copy and erasure
+            digest.update(repr(event).encode()+b'\n')
+        # Each literal role cleanup reaches full space; any unused final
+        # endpoint is still represented explicitly in the expected chain.
+        for s,F in enumerate(expected):promote(s,F)
+        assert current==expected
+        return hist,copies,scalar,digest.hexdigest()
+    start=tm+[ZERO]*v+[sigma.get(s,ZERO) for s in range(R)]
+    finish=[FULL]*v+[complement(T,h) for T in tm]+[FULL]*R
+    H,C,scalar,digest=framescan(word,start,finish)
+    revstart=[None]*len(start);revfinish=[None]*len(start)
+    for s in range(len(start)):
+        revstart[swap(s)]=complement(finish[s],h);revfinish[swap(s)]=complement(start[s],h)
+    HR,CR,scalarR,reverse_digest=framescan(reverse,revstart,revfinish)
+    assert (H,C,scalar)==(HR,CR,scalarR)
+    z=Counter({r:2*v*n for r,n in (H+C).items()})
+    for s in range(R):z[h*h-h+len(sigma.get(s,ZERO))]+=2*v
+    z[(h-1)**2]+=2*v*v;z[1]+=v*v
+    z.pop(0,None)
+    assert dict(sorted(z.items()))=={int(r):n for r,n in d['out']['child_multiplicities'].items()},'Literal reflected child histogram'
+    assert sum(r*n for r,n in z.items())==d['out']['total_rank']
+    G=v*v+2*v*scalar
+    safe=MAX_PIECES*8*(d['c_add']+2*R+(R+q)*v*(h+1)+h*h+h+1) if 'c_add' in d else MAX_PIECES*8*(d['out']['additions']+2*R+(R+q)*v*(h+1)+h*h+h+1)
+    assert safe>=scalar
+    return dict(h=h,v=v,R=R,exact_fresh_source_map=True,exact_integer_old_readout_transpose=True,
+                exact_arbitrary_dirty_cancellation_by_dependency_cut=True,
+                reflected_word_rule='Reverse literal order, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.',
+                reflected_scalar_map='X becomes X-Y; Y unchanged; all auxiliary coordinates restored.',
+                two_stage_scalar_map='(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.',
+                literal_frame_incidences_both_directions=True,all_frames_nondegenerate=True,
+                reflected_residual_rank_histogram_equal=True,child_multiplicities=dict(sorted(z.items())),
+                word_blocks=len(word),expanded_scalar_operations_per_stage=scalar,
+                expanded_old_readout_additions=readcount,expanded_old_readout_unit_shears=sum(unit_counts.values()),
+                maximum_paid_unit_pieces=MAX_PIECES,largest_readout_numerator_over_42=maxcoef,
+                old_readout_coefficients_over_42_sha256=coefficient_digest.hexdigest(),
+                literal_global_scalar_groups=G,conservative_local_G=safe,
+                forward_incidence_sha256=digest,reflected_incidence_sha256=reverse_digest,
+                rejected_controls=rejected,
+                scope='Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.')
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path);ap.add_argument('--state',type=Path)
+    ap.add_argument('--output',type=Path);ap.add_argument('--check',type=Path);a=ap.parse_args()
+    assert bool(a.source)!=bool(a.state)
+    d=capture(a.source) if a.source else pickle.loads(a.state.read_bytes())
+    result=audit(d);source=Path(d['source'])
+    result['source_sha256']=sha256(source.read_bytes()).hexdigest()
+    result['audit_sha256']=sha256(Path(__file__).read_bytes()).hexdigest()
+    result=json.loads(json.dumps(result));encoded=json.dumps(result,indent=2,sort_keys=True)+'\n'
+    if a.check:assert result==json.loads(a.check.read_text())
+    if a.output:a.output.write_text(encoded)
+    else:print(encoded,end='')
+    print('PASS exact scalar and literal complement reflection audit',file=sys.stderr)
+
+
+if __name__=='__main__':main()
diff --git a/research/deferred-replayed-117/bit-profile.json b/research/deferred-replayed-117/bit-profile.json
new file mode 100644
index 0000000000..36105e819a
--- /dev/null
+++ b/research/deferred-replayed-117/bit-profile.json
@@ -0,0 +1,69 @@
+{
+ "h": 23,
+ "v": 1771,
+ "R": 28866,
+ "m": 529,
+ "N": 3136441,
+ "W": 108516254,
+ "L": 1792252,
+ "total_rank": 57403754177,
+ "deficit": 1344189,
+ "maxchild": 528,
+ "deferred_slots": 11565,
+ "source": {
+  "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+  "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+  "sha256": {
+   "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+   "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c"
+  }
+ },
+ "child_multiplicities": {
+  "1": 239511811,
+  "2": 238288050,
+  "3": 53377940,
+  "4": 46970462,
+  "5": 23632224,
+  "6": 7409864,
+  "7": 4105178,
+  "8": 5755750,
+  "9": 2082696,
+  "10": 878416,
+  "11": 1388464,
+  "12": 1080310,
+  "13": 945714,
+  "14": 226688,
+  "15": 2451064,
+  "16": 1508892,
+  "17": 4771074,
+  "18": 2149994,
+  "19": 7367360,
+  "20": 8182020,
+  "21": 1466388,
+  "22": 88550,
+  "484": 6272882,
+  "506": 61280142,
+  "507": 545468,
+  "508": 173558,
+  "509": 293986,
+  "510": 580888,
+  "511": 14168,
+  "512": 322322,
+  "513": 17710,
+  "514": 1129898,
+  "515": 127512,
+  "516": 410872,
+  "517": 99176,
+  "518": 1186570,
+  "519": 340032,
+  "520": 322322,
+  "521": 106260,
+  "522": 1583274,
+  "523": 626934,
+  "524": 2854852,
+  "525": 13711082,
+  "526": 4629394,
+  "527": 5653032,
+  "528": 6233920
+ }
+}
diff --git a/research/deferred-replayed-117/bit_round7.py b/research/deferred-replayed-117/bit_round7.py
new file mode 100644
index 0000000000..3c5df409a6
--- /dev/null
+++ b/research/deferred-replayed-117/bit_round7.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""One-child bit profile of Swapnil Jain's round-seven deferred word (h=23), under PR104's opposite-bank rule.
+
+Reads the two frozen round-seven data files (vendored in inputs/; pinned by SHA-256 below) from a directory given on
+the command line, e.g. a checkout of https://github.com/Swapnil-jain/integer-mult-kappa at
+741e7aa078392553815df7926ee17ac5e25a8c38 (certificates/round7/), or PR97's imported copy
+(research/deferred-signed/swapnil-round7/certificates/round7/). The frame dimensions are the ones recorded in
+the data file; Swapnil's check_frames.py re-derives each of them exactly and PR97 replays the word.
+
+Every projector residual of rank r is one child of width r (PR104, notes/stopped-product-factorization.tex):
+  each slot: its chain steps from the deferral frame sigma_u to F, and one exterior child m - (h - dim sigma_u);
+  each retained centre: one copied transform of width h-1;
+  each target y_T: its chain 0 -> deferred readout levels -> t_T^perp;  each data wire X_S: its chain of V frames;
+  each data pair: one data residual of width (h-1)^2 and one endpoint copy.
+Usage: python3 research/deferred-stopped/bit_round7.py DIR      (writes bit-profile.json next to this file)
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance. Apache-2.0.
+"""
+import gzip
+import hashlib
+import json
+import sys
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PINS = {'witness_23.json.gz': 'b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588',
+        'deferred_23.json.gz': '8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c'}
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def main(directory):
+    data = {}
+    for name, digest in PINS.items():
+        raw = (Path(directory) / name).read_bytes()
+        require(hashlib.sha256(raw).hexdigest() == digest, 'pinned hash of ' + name)
+        data[name] = json.loads(gzip.decompress(raw))
+    W, D = data['witness_23.json.gz'], data['deferred_23.json.gz']
+    h = D['h']; R = D['R']; trip = list(combinations(range(h), 3)); v = len(trip); m = h * h; N = v * v
+    tid = {T: i for i, T in enumerate(trip)}
+    args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()}
+    late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()}
+    ops = [tuple(o[:2]) + (tuple(o[2]),) if o[0] == 'fan' else tuple(o) for o in D['ops']]
+    hold, start = D['hold'], D['start']
+    out = {s: (c, tuple(T)) for s, c, T in D['out']}; ret = {s: c for s, c in D['ret']}
+    sigma = dict(zip(D['readout_order'], D['sigma'])); sel = set(D['readout_order'])
+    f = [0] * R
+    for s, B in sigma.items(): f[s] = len(B)
+    vstart = dict(zip(D['vleaf_slots'], D['vleaf_start']))
+    node_dims = {n: d for n, d in D['node_dims']}
+    late_dims = {(n, tuple(lt)): d for n, lt, d in D['late_dims']}
+    pivslot = {o[3]: o[1] for o in ops if o[0] == 'add'}
+
+    def start_key(s):
+        n0 = hold[s][0]
+        if args[n0] is None: return ('v', s)
+        st = start[s]; k = st[2] if len(st) > 2 else None; dec = late.get(n0)
+        if dec is None or k in dec[0]: return ('n', n0)
+        lt = dec[1]; return ('c', n0, tuple(lt[lt.index(k):]))
+
+    def chain(s):
+        ch = [('sigma', s) if s in sel else ('0',), start_key(s)]
+        for idx, n in enumerate(hold[s]):
+            if idx > 0: ch.append(('n', n))
+            if args[n] is not None and pivslot.get(n) == s and n in late:
+                lt = late[n][1]
+                for i in range(len(lt) - 1): ch.append(('c', n, tuple(lt[i:])))
+        if s in out: ch.append(('out',))
+        if s in ret: ch.append(('ret',))
+        ch.append(('F',)); return ch
+
+    def dim(key):
+        k = key[0]
+        if k == '0': return 0
+        if k == 'F': return h
+        if k in ('out', 'ret'): return h - 1
+        if k == 'n': return node_dims[key[1]]
+        if k == 'c': return late_dims[key[1], key[2]]
+        if k == 'sigma': return f[key[1]]
+        if k == 'v': return len(vstart[key[1]])
+        raise KeyError(key)
+
+    # garbage supports (transpose sweep) for the deferred levels on each target
+    cov = [set() for _ in range(R)]
+    for s, (c, T) in out.items(): cov[s].add(tid[T])
+    for s, c in ret.items(): cov[s].update(t for t, T in enumerate(trip) if c in T)
+    for o in reversed(ops):
+        if o[0] == 'add': cov[o[2]] |= cov[o[1]]
+        elif o[0] == 'fan':
+            for g in o[2]: cov[o[1]] |= cov[g]
+    levels = defaultdict(set)
+    for s in sel:
+        for t in cov[s]: levels[t].add(f[s])
+
+    z = Counter()
+    for s in range(R):
+        ds = [dim(k) for k in chain(s)]
+        require(all(b >= a for a, b in zip(ds, ds[1:])) and ds[-1] == h, 'monotone chain %d' % s)
+        for a, b in zip(ds, ds[1:]):
+            if b > a: z[b - a] += 2 * v
+        z[m - (h - f[s])] += 2 * v
+    z[h - 1] += 2 * v * h
+    for t in range(v):
+        ls = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ls, ls[1:]): z[b - a] += 2 * v
+    for n, us in D['xs_order']:
+        ds = [1] + [len(vstart[s]) for s in us] + [h]
+        ds = [d for i, d in enumerate(ds) if i == 0 or d != ds[i - 1]]
+        require(all(b > a for a, b in zip(ds, ds[1:])), 'data-wire chain')
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v
+    z[(h - 1) ** 2] += 2 * N
+    z[1] += N
+    Wb = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = Wb * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'bit rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    prof = dict(h=h, v=v, R=R, m=m, N=N, W=Wb, L=L, total_rank=s_, deficit=N - L, maxchild=max(z),
+                deferred_slots=len(sel), source=dict(repository='https://github.com/Swapnil-jain/integer-mult-kappa',
+                commit='741e7aa078392553815df7926ee17ac5e25a8c38', sha256=PINS),
+                child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'bit-profile.json').write_text(json.dumps(prof, indent=1) + '\n')
+    print('PASS bit: R=%d, deferred slots %d, maxchild %d, rank mass %d' % (R, len(sel), max(z), s_))
+
+
+if __name__ == '__main__':
+    main(sys.argv[1] if len(sys.argv) > 1 else '.')
diff --git a/research/deferred-replayed-117/certificate.json b/research/deferred-replayed-117/certificate.json
new file mode 100644
index 0000000000..dd54365b6e
--- /dev/null
+++ b/research/deferred-replayed-117/certificate.json
@@ -0,0 +1,313 @@
+{
+  "actual_bit_saving": "1240189553/10000000000000",
+  "assembly": {
+    "absorption_gap": "62119330572924300398089645710361/156283926992435943227434578830515187500000000000",
+    "margins": {
+      "Gaussian_arithmetic": "325706625213727475614068361046738711757/2000434265503180073311162609030594400000000",
+      "bulk_exposure": "54283188711757/500000000000000000",
+      "compact_phase_layer": "271415935416306747519638711757/2500542831878975091638953261288243",
+      "coordinate_movement": "54283188711757/500000000000000000",
+      "dimension": "2499999975000000000000000000000000/2500542831878975091638953261288243",
+      "original_prefix": "27144094084462553727055510128961288243/250054283187897509163895326128824300000000",
+      "scalar_work": "434283002637241432187517391641138711757/2000434265503180073311162609030594400000000"
+    },
+    "minimum_margin": "271415935416306747519638711757/2500542831878975091638953261288243",
+    "parameters": {
+      "C0": 233381908694176291933450216223479465293178572223076498761271341113260583100530739555545907200,
+      "C1": 1,
+      "a_bit": "54283188711757/500000000000000000",
+      "a_complex": "54283243/500000000000",
+      "alpha_squared_power": "407136407195699193236450000000/2500542831878975091638953261288243",
+      "beta": "1/1000000",
+      "c": "271415940844625510128961288243/2500000000000000000000000000000000",
+      "delta": "1/800000000",
+      "epsilon": "2499999975000000000000000000000000/2500542831878975091638953261288243",
+      "eta": "1/100000000",
+      "kappa": "6783925373/62500000000000",
+      "lambda_": "49994571681183107488711757/50000000000000000000000000",
+      "lambda_prime": "24997285840618695338711757/25000000000000000000000000",
+      "q": "2714159381304661288243/25000000000000000000000000",
+      "sigma": "499945716757/500000000000",
+      "tau": "499945716811288243/500000000000000000"
+    },
+    "recurrence": {
+      "internal": "499945716811288243/500000000000000000",
+      "leaf": "499945716811283243/500000000000000000",
+      "reservations": "2499728584059155374489871038711757/2500000000000000000000000000000000"
+    },
+    "strict_constraints": {
+      "Gaussian_arithmetic_above_kappa": "4241167065682703321472297761181025750862993/78141963496217971613717289415257593750000000000",
+      "K_dominates_log": "27141593813046610168270618695338711757/250054283187897509163895326128824300000000",
+      "K_geometry": "27144094084462553727055510128961288243/250054283187897509163895326128824300000000",
+      "alpha_below_one": "2500135695471779392445716811288243/2500542831878975091638953261288243",
+      "alpha_below_one_fourth": "2498914286250192294866007461288243/10002171327515900366555813045152972",
+      "alpha_positive": "407136407195699193236450000000/2500542831878975091638953261288243",
+      "artificial_boundary": "14003582717902321268566899229636396338711757/2000434265503180073311162609030594400000000",
+      "beta_below_one": "999999/1000000",
+      "beta_positive": "1/1000000",
+      "bit_positive": "54283188711757/500000000000000000",
+      "bulk_exposure_above_kappa": "11785727757/500000000000000000",
+      "c_below_one": "2499728584059155374489871038711757/2500000000000000000000000000000000",
+      "c_positive": "271415940844625510128961288243/2500000000000000000000000000000000",
+      "cell_above_band": "2499864254528220607554283188711757/5001085663757950183277906522576486",
+      "compact_leaf": "54533188711757/25000000000000000000000000",
+      "compact_phase_layer_above_kappa": "62119330572924300398089645710361/156283926992435943227434578830515187500000000000",
+      "compact_reservations": "2714159381304661288243/2500000000000000000000000000000000",
+      "complex_above_bit": "54288243/500000000000000000",
+      "complex_below_one_over32": "15570716757/500000000000",
+      "coordinate_movement_above_kappa": "11785727757/500000000000000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "delta_positive": "1/800000000",
+      "dimension_above_kappa": "156233034941536542947610595504815585589645710361/156283926992435943227434578830515187500000000000",
+      "epsilon_below_one": "542856878975091638953261288243/2500542831878975091638953261288243",
+      "epsilon_positive": "2499999975000000000000000000000000/2500542831878975091638953261288243",
+      "gamma_sublinear": "135720471779392445716811288243/2500542831878975091638953261288243",
+      "guard_width": "542856878975091638953261288243/2500542831878975091638953261288243",
+      "lambda_above_internal": "54283188711757/50000000000000000000000000",
+      "lambda_above_sigma": "5483107488711757/50000000000000000000000000",
+      "lambda_above_tau": "54283188711757/50000000000000000000000000",
+      "lambda_prime_above_lambda": "54283188711757/50000000000000000000000000",
+      "lambda_prime_below_one": "2714159381304661288243/25000000000000000000000000",
+      "leaf_saving_above_bit": "1/100000000000000",
+      "literal_scalar_guard": "112524570208056586133351530450639872643713276",
+      "original_prefix_above_kappa": "1562839332043690005198646186394797585361/156283926992435943227434578830515187500000000000",
+      "phase_boundary": "325706625213727475614068361046738711757/2000434265503180073311162609030594400000000",
+      "phase_local": "434283002637241432187517391641138711757/2000434265503180073311162609030594400000000",
+      "prime_interval_packing": "542856878975091638953261288243/2500542831878975091638953261288243",
+      "q_below_internal": "54283188711757/25000000000000000000000000",
+      "q_below_leaf": "54533188711757/25000000000000000000000000",
+      "q_below_reservations": "2714159381304661288243/2500000000000000000000000000000000",
+      "q_positive": "2714159381304661288243/25000000000000000000000000",
+      "record_suffix": "542856878975091638953261288243/2500542831878975091638953261288243",
+      "row_product_gap": "6389/25",
+      "scalar_work_above_kappa": "8482431808788717250122650518774775750862993/78141963496217971613717289415257593750000000000",
+      "short_record_fallback": "1249864250061575282337463561797694610726646580027049/1250271415939487545819476630644121500000000000000000",
+      "small_field_exposure": "271440943558784891433622576486/2500542831878975091638953261288243"
+    }
+  },
+  "bit_moment_gap": "210811394225115117568018038513239592855337768061996351784199300828041381607148420475711921673436778332750996651783152394205578153858435663243959795913385215868392831844509655226993164072062830500832781615792327068936897853818968534771730481866850519439187068953062899333771640996075361901014500735179763112430083120460814689994116646689670445286414265265018468311435502209195246240538069975559360544007937885404793780372701951022292660282948582656517071290400479729799954952580125532795274568021525151839594883237275569314958070368193662075730567130277424969924134425921633872848924585639423998410253779062359718371205767101510073996880454144801457072151080008705648366603197414406872289670642046369219405455128737300640897667220951127018547660455087533581513233999285275099394371781290865408274484542745086391849285198194905751058992419590161634431610100995441112613134240446609058758039909343152776920263419910572835208525277494067408376961456317/225678505065634612156474913616400633538202019254665477026878220214422133931127460164253533068001699469116755578965090566731480236912032281717920888140691998261537790258547549397061712443744511202265657747547567084090291301783866427704803156891369853685579999500594559805069402727752752227038426964007028952158078563045054314475625278140097385695241851533235641996467089273692960018822280793234080014352234618229252999217015923728814468917104222554059646947960375336061268431587018084270516494408656203498548153054913267707164839939006583338918817922618882667407408888179421052689449193499742148706302504238261936554897181289081072466758282367100305194479622149878636307463869297507337915811001244472279386614413535081936912313821531543735588465392499062010570720287729070905437080967709221039366272598541269000920375996285867953823816142239661027100714288630069735295241672325865922423925213948613346461034734632365263739073012128769510020000000000000000000000",
+  "bit_parameter": "54283188711757/500000000000000000",
+  "bit_profile": {
+    "L": 1792252,
+    "N": 3136441,
+    "R": 28866,
+    "W": 108516254,
+    "child_multiplicities": {
+      "1": 239511811,
+      "10": 878416,
+      "11": 1388464,
+      "12": 1080310,
+      "13": 945714,
+      "14": 226688,
+      "15": 2451064,
+      "16": 1508892,
+      "17": 4771074,
+      "18": 2149994,
+      "19": 7367360,
+      "2": 238288050,
+      "20": 8182020,
+      "21": 1466388,
+      "22": 88550,
+      "3": 53377940,
+      "4": 46970462,
+      "484": 6272882,
+      "5": 23632224,
+      "506": 61280142,
+      "507": 545468,
+      "508": 173558,
+      "509": 293986,
+      "510": 580888,
+      "511": 14168,
+      "512": 322322,
+      "513": 17710,
+      "514": 1129898,
+      "515": 127512,
+      "516": 410872,
+      "517": 99176,
+      "518": 1186570,
+      "519": 340032,
+      "520": 322322,
+      "521": 106260,
+      "522": 1583274,
+      "523": 626934,
+      "524": 2854852,
+      "525": 13711082,
+      "526": 4629394,
+      "527": 5653032,
+      "528": 6233920,
+      "6": 7409864,
+      "7": 4105178,
+      "8": 5755750,
+      "9": 2082696
+    },
+    "deferred_slots": 11565,
+    "deficit": 1344189,
+    "h": 23,
+    "m": 529,
+    "maxchild": 528,
+    "source": {
+      "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+      "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+      "sha256": {
+        "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
+        "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588"
+      }
+    },
+    "total_rank": 57403754177,
+    "v": 1771
+  },
+  "coarse_bit_saving": "620523/5000000000",
+  "complex_moment_gap": "1684243256760201612339221541184730408942386651785738326364489356761224915889711142348240318799323373659784727422152540869353618411431362437370314263044297759203823908594932216573617964672681880849529865247872885481143279986429578411494833658254472589055229327185546152977917885772679941196667079799174921734871735702048865948362053677149909547314938840449820259653031127797669208900451613028155251533545798333847726341441324969398727491960173378546562573148603993465126399473216305212076329960013263985789894664091565996268581791940576586077829109481822682898338637111508079980221905170355560434086556323227807509002090243629825254125960881356321343918523779591683829539351700755599574074186263050643283413056551788678679104019059103179795049441758502375100875709402163606036189088962178326801674902625672563948527605463897280749989086942273121201951849366410957227801321956524972509458294283/13076176422768752941045928436389224430904338371422537716929791440877477702819638712043295577885330822669107911874919538936403020681324064799817816162179193190224176015137644573061605373655452433346189868920294060288704646250614230715903128987500876073882224491303687353660877935604538655463361337349350615966709170438445656737115595270284822543018094407430047898666737456853762248702186650433929374240168820329172367590226449955218939007877433285373386672798919963785233442539110210375032370281476295090754849366200391809771014731376013876907422377525822620440991852588645588719987982019468909940120238382631020369895264178541956686815709707404349397122739559654609255101406090860516163714145958519878656806027155347109208742610634600531966281524309290120927240305500229740714599509956505333371963736169384354708455378520101218876656972894075362373134290743310164984573798705668032000000000000000000000000",
+  "complex_profile": {
+    "L": 2234496,
+    "N": 4096576,
+    "R": 28705,
+    "W": 124390992,
+    "additions": 91770,
+    "child_multiplicities": {
+      "1": 340181776,
+      "10": 8087904,
+      "11": 9407552,
+      "12": 15358112,
+      "13": 10796016,
+      "14": 1198208,
+      "15": 1194160,
+      "16": 1246784,
+      "17": 497904,
+      "18": 3040048,
+      "19": 2100912,
+      "2": 351342112,
+      "20": 850080,
+      "21": 1222496,
+      "22": 64768,
+      "23": 8359120,
+      "3": 36998720,
+      "4": 71762944,
+      "5": 29999728,
+      "529": 8193152,
+      "552": 103972880,
+      "554": 8096,
+      "556": 514096,
+      "560": 311696,
+      "562": 64768,
+      "564": 1505856,
+      "566": 979616,
+      "568": 1388464,
+      "569": 8096,
+      "570": 3720112,
+      "571": 2343792,
+      "572": 850080,
+      "573": 44528,
+      "574": 485760,
+      "6": 13038608,
+      "7": 14285392,
+      "8": 30481440,
+      "9": 6266304
+    },
+    "deferred_dims": {
+      "10": 16,
+      "12": 372,
+      "14": 242,
+      "16": 343,
+      "17": 2,
+      "18": 919,
+      "19": 579,
+      "2": 2,
+      "20": 210,
+      "21": 11,
+      "22": 120,
+      "4": 127,
+      "8": 77
+    },
+    "deferred_roles": 3020,
+    "deficit": 1862080,
+    "h": 24,
+    "lifted_additions": 39989,
+    "links": 71185,
+    "m": 576,
+    "maxchild": 574,
+    "phase_one_ops": 18844,
+    "phase_one_roles": 13555,
+    "replay": {
+      "field": "Z/(2^61-1)",
+      "scratch_restored": true,
+      "seeds": [
+        1,
+        2
+      ],
+      "y_plus_x": true
+    },
+    "roots": 8120,
+    "total_rank": 71647349312,
+    "v": 2024
+  },
+  "complex_saving": "54283243/500000000000",
+  "finite_bridge": {
+    "bit_coarse": {
+      "W": 108516254,
+      "halving_degree": 367,
+      "m": 529,
+      "maxchild": 528,
+      "wire_bits": 27
+    },
+    "complex": {
+      "W": 124390992,
+      "halving_degree": 200,
+      "m": 576,
+      "maxchild": 574,
+      "s": 71647349312,
+      "scalar_group_upper": 120694834072384,
+      "scalar_terms": [
+        {
+          "R": 28705,
+          "c": 91770,
+          "description": "Expanded readouts split into unit-magnitude shears; forward/inverse/reflected words",
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 29815916496,
+          "maximum_unit_pieces": 2,
+          "q": 8120,
+          "v": 2024
+        },
+        {
+          "R": 28705,
+          "c": 91770,
+          "description": "Expanded readouts split into unit-magnitude shears; forward/inverse/reflected words",
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 29815916496,
+          "maximum_unit_pieces": 2,
+          "q": 8120,
+          "v": 2024
+        }
+      ],
+      "wire_bits": 27
+    },
+    "ordinary_leaf_row_degree": 252,
+    "rows": {
+      "coefficient": 15561,
+      "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; prefix and padding; sequential reuse",
+      "degree": 32000,
+      "degree_gap": "6389/25",
+      "suffix_slope": 128000
+    },
+    "semantic": {
+      "B": 112524570208060321184385731700998023956096640,
+      "C0": 233381908694176291933450216223479465293178572223076498761271341113260583100530739555545907200,
+      "C1": 1,
+      "E": 112524570208060321184385731700997952308747328,
+      "exact_grid": "2^(-P)*21^(-K), K=G*(D_complex+1); completed children preserve incoming odd denominator; no child rounding",
+      "fixed_odd_divisor": 21,
+      "induction_gap": 337573710624180963553157195102994071868289920,
+      "literal_charge": 3735051034201250358079665034052,
+      "strict_literal_gap": 112524570208056586133351530450639872643713276
+    }
+  },
+  "kappa": "6783925373/62500000000000",
+  "next_grid_rejections": {
+    "bit": "1e-10",
+    "complex": "1e-12",
+    "kappa": "1e-15"
+  },
+  "status": "Finite conditional cyclic/deferred witness"
+}
diff --git a/research/deferred-replayed-117/certificate.py b/research/deferred-replayed-117/certificate.py
new file mode 100644
index 0000000000..97c0f21515
--- /dev/null
+++ b/research/deferred-replayed-117/certificate.py
@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Exact finite assembly for cyclic strips with deferred readouts.
+
+Built on Avi Eisenberg's PR110 (Anthropic Claude assistance), icekylinx's
+PR104 stopped-product and copied-center interfaces, and Zhihao Chen's
+assembly of the RaD interfaces. Integration for eumemic with OpenAI Codex
+assistance. Apache-2.0. General transfer hypotheses remain inherited.
+"""
+import argparse
+from unit_readouts import MAX_PIECES
+import json
+import sys
+from fractions import Fraction as Q
+from pathlib import Path
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+from partial_swap_network import moment
+from copied_centers_network import finite_bridge as copied_bridge
+from structured_bulk_assembly import assembly, js
+ATOM = Q(1, 1000)
+OLD = Q(384599, 10**10)
+BETA = Q(1, 10**6)
+COARSE = Q(620523, 5000000000)
+COMPLEX = Q(108566486, 1000000000000)
+KGRID = 10**15
+
+def profile(name):
+    p = json.loads((HERE / name).read_text())
+    p['child_multiplicities'] = {int(t): c for t, c in p['child_multiplicities'].items()}
+    z = p['child_multiplicities']
+    assert all(0 < t < p['m'] and c > 0 for t,c in z.items())
+    assert sum(t*c for t,c in z.items()) == p['total_rank'] == p['W']*p['m']-p['N']+p['L']
+    assert max(z) == p['maxchild']
+    return p
+
+def contracts(p, a):
+    try: moment(p['m'],p['W'],p['child_multiplicities'],a,True)
+    except ValueError: return False
+    return True
+
+def exact(bit=None, phase=None):
+    bit = profile('bit-profile.json') if bit is None else bit
+    phase = profile('complex-profile.json') if phase is None else phase
+    assert (bit['h'], phase['h']) == (23,24)
+    bm = moment(bit['m'],bit['W'],bit['child_multiplicities'],COARSE,True)
+    cm = moment(phase['m'],phase['W'],phase['child_multiplicities'],COMPLEX,True)
+    assert not contracts(bit,COARSE+Q(1,10**10))
+    assert not contracts(phase,COMPLEX+Q(1,10**12))
+    ab = (1-ATOM)*COARSE+ATOM*OLD
+    assert 0 < OLD < COARSE < ATOM and ab < ATOM
+    a = min(ab,(1-BETA)*COMPLEX-Q(1,10**14))
+    row = dict(h=phase['h'],v=phase['v'],c=phase['additions'],central_disjoint=24)
+    bridge = copied_bridge(bit,phase,[row,row])
+    # A literal expanded readout is charged even if it could be factored.
+    # Each row has <=c+R mixer operations and <=R leaf copies. There are
+    # <=R+q readouts, each containing <=h center coefficients and <=v direct
+    # coefficients; <=4*v*(h+1) scalar groups suffice per readout. A factor
+    # eight covers forward/inverse words, both reflected words, and copies.
+    # Multiply the entire bound by MAX_PIECES to pay for splitting coefficients
+    # such as 55/42 into 1 + 13/42; audit.py verifies every split exactly.
+    h,v,R,q,c = (phase[k] for k in ('h','v','R','roots','additions'))
+    local = MAX_PIECES*8*(c+2*R+(R+q)*v*(h+1)+h*h+h+1)
+    G = phase['N'] + 2*v*local
+    m,W,s = (phase[k] for k in ('m','W','total_rank'))
+    E=64*(W+m+G+1)**3
+    charge=2*G*W*W+8*s+4*W+4+32*m
+    B=s+E; C0=32*m*B*B
+    assert charge<E and 2*B*(m-phase['maxchild']) >= s+E and 2*B+18<C0
+    bridge['complex']['scalar_group_upper']=G
+    bridge['complex']['scalar_terms']=[dict(h=h,v=v,c=c,R=R,q=q,invocations=v,
+        local_group_upper=local,maximum_unit_pieces=MAX_PIECES,description='Expanded readouts split into unit-magnitude shears; forward/inverse/reflected words')]*2
+    bridge['semantic'].update(E=E,literal_charge=charge,strict_literal_gap=E-charge,
+        B=B,C0=C0,C1=1,induction_gap=2*B*(m-phase['maxchild'])-s-E,
+        fixed_odd_divisor=21,exact_grid='2^(-P)*21^(-K), K=G*(D_complex+1); completed children preserve incoming odd denominator; no child rounding')
+    coarse_bridge=bridge.pop('bit')
+    previous=json.loads((ROOT/'certificates/copied-centers-network.json').read_text())
+    oldbit=previous['finite_bridge']['bit']
+    old_degree=oldbit['halving_degree']*oldbit['wire_bits']
+    assert old_degree==252
+    cp=bridge['complex']
+    coeff=coarse_bridge['halving_degree']*coarse_bridge['wire_bits']+old_degree+cp['halving_degree']*cp['wire_bits']
+    degree=1000*((51*coeff)//25000+1)
+    bridge.update(bit_coarse=coarse_bridge,ordinary_leaf_row_degree=old_degree)
+    bridge['rows']=dict(coefficient=coeff,degree=degree,suffix_slope=4*degree,
+        degree_gap=Q(degree)-Q(51*coeff,25),contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; prefix and padding; sequential reuse')
+    def accepts(k):
+        try: assembly(a,COMPLEX,bridge,Q(k,KGRID),beta=BETA)
+        except AssertionError: return False
+        return True
+    lo,hi=0,int(COMPLEX*KGRID)+1
+    assert accepts(lo) and not accepts(hi)
+    while hi-lo>1:
+        mid=(lo+hi)//2
+        if accepts(mid): lo=mid
+        else: hi=mid
+    k=Q(lo,KGRID)
+    assembled=assembly(a,COMPLEX,bridge,k,beta=BETA)
+    assert len(assembled['strict_constraints'])==47 and len(assembled['margins'])==7
+    assert not accepts(lo+1)
+    return dict(status='Finite conditional cyclic/deferred witness',kappa=k,
+        complex_saving=COMPLEX,coarse_bit_saving=COARSE,actual_bit_saving=ab,
+        bit_parameter=a,complex_profile=phase,bit_profile=bit,
+        bit_moment_gap=bm['strict_gap'],complex_moment_gap=cm['strict_gap'],
+        finite_bridge=bridge,assembly=assembled,
+        next_grid_rejections=dict(bit='1e-10',complex='1e-12',kappa='1e-15'))
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--write',action='store_true');args=parser.parse_args()
+    assert not sys.flags.optimize
+    result=js(exact()); path=HERE/'certificate.json'
+    if args.write:path.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:assert result==json.loads(path.read_text()),'Frozen exact certificate mismatch'
+    assert Q(result['kappa'])>Q(1044939,10**10) and Q(result['kappa'])>Q(49349675169,500000000000000),'kappa exceeds PR117 and PR116'
+    print('PASS conditional kappa = %s = %.12e; 47 constraints, 7 margins; expanded scalar charge' % (result['kappa'],float(Q(result['kappa']))))
+if __name__=='__main__':main()
diff --git a/research/deferred-replayed-117/complex-dag.json.gz b/research/deferred-replayed-117/complex-dag.json.gz
new file mode 100644
index 0000000000..a5b0598e4c
Binary files /dev/null and b/research/deferred-replayed-117/complex-dag.json.gz differ
diff --git a/research/deferred-replayed-117/complex-profile.json b/research/deferred-replayed-117/complex-profile.json
new file mode 100644
index 0000000000..0efaedf3e9
--- /dev/null
+++ b/research/deferred-replayed-117/complex-profile.json
@@ -0,0 +1,83 @@
+{
+ "h": 24,
+ "v": 2024,
+ "additions": 91770,
+ "roots": 8120,
+ "links": 71185,
+ "R": 28705,
+ "m": 576,
+ "N": 4096576,
+ "W": 124390992,
+ "L": 2234496,
+ "total_rank": 71647349312,
+ "deficit": 1862080,
+ "maxchild": 574,
+ "phase_one_ops": 18844,
+ "phase_one_roles": 13555,
+ "deferred_roles": 3020,
+ "deferred_dims": {
+  "2": 2,
+  "4": 127,
+  "8": 77,
+  "10": 16,
+  "12": 372,
+  "14": 242,
+  "16": 343,
+  "17": 2,
+  "18": 919,
+  "19": 579,
+  "20": 210,
+  "21": 11,
+  "22": 120
+ },
+ "lifted_additions": 39989,
+ "replay": {
+  "seeds": [
+   1,
+   2
+  ],
+  "scratch_restored": true,
+  "y_plus_x": true,
+  "field": "Z/(2^61-1)"
+ },
+ "child_multiplicities": {
+  "1": 340181776,
+  "2": 351342112,
+  "3": 36998720,
+  "4": 71762944,
+  "5": 29999728,
+  "6": 13038608,
+  "7": 14285392,
+  "8": 30481440,
+  "9": 6266304,
+  "10": 8087904,
+  "11": 9407552,
+  "12": 15358112,
+  "13": 10796016,
+  "14": 1198208,
+  "15": 1194160,
+  "16": 1246784,
+  "17": 497904,
+  "18": 3040048,
+  "19": 2100912,
+  "20": 850080,
+  "21": 1222496,
+  "22": 64768,
+  "23": 8359120,
+  "529": 8193152,
+  "552": 103972880,
+  "554": 8096,
+  "556": 514096,
+  "560": 311696,
+  "562": 64768,
+  "564": 1505856,
+  "566": 979616,
+  "568": 1388464,
+  "569": 8096,
+  "570": 3720112,
+  "571": 2343792,
+  "572": 850080,
+  "573": 44528,
+  "574": 485760
+ }
+}
diff --git a/research/deferred-replayed-117/complex_deferred.py b/research/deferred-replayed-117/complex_deferred.py
new file mode 100644
index 0000000000..2f6eed15ee
--- /dev/null
+++ b/research/deferred-replayed-117/complex_deferred.py
@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+"""Cyclic strips and core-aware pair assembly with lifted frames and deferred readouts.
+
+The scalar h=24 producer uses PR111's cyclic PairedTriple strips and dual-suffix
+pair stars, with PR62's core-aware pair assembly, a two-point base case, and
+column-pair coarse sums inside contracted pair subproblems. PR110's maximum
+carrier matching, explicit role compiler, lifted binary frames, deferred
+readouts, finite-field replay, exact F2 frame checks, and actual one-child
+profile are retained. The selected graph has 70252 additions, 8120 roots,
+42694 carrier links, and 35678 roles.
+
+Credits: Avi Eisenberg (PR110 deferred complex compiler and PR62 pair assembly),
+Rohan Arun (PR111 cyclic-strip and dual-suffix producer), Swapnil Jain (deferred
+readouts), icekylinx (PR104 stopped product-ring and PairedTriple lineage), and
+all predecessors credited in those sources. Integration and the contracted
+pair replacement were prepared with OpenAI Codex assistance. Apache-2.0.
+
+This script checks the original assertions and writes complex-profile.json
+next to itself. Reflected-word verification is a separate audit.
+"""
+import array
+import json
+import random
+import struct
+import sys
+import tempfile
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+import importlib.util
+import os as _o3
+producer_path = Path(_o3.environ.get('CX_PRODUCER', str(HERE / 'producer.py')))
+spec = importlib.util.spec_from_file_location('cyclic_producer', producer_path)
+producer = importlib.util.module_from_spec(spec); spec.loader.exec_module(producer)
+build = producer.build
+
+P = (1 << 61) - 1
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def load(prefix):
+    def rd(fh, typ, cnt):
+        a = array.array(typ); a.fromfile(fh, cnt); return a
+    with open(str(prefix) + '.bin', 'rb') as f:
+        h, v, n, q = struct.unpack('<4I', f.read(16))
+        flat = rd(f, 'I', 2 * n); core = rd(f, 'Q', n); cover = rd(f, 'Q', n)
+        roots = rd(f, 'I', q); kind = rd(f, 'I', q); active = rd(f, 'B', n)
+    with open(str(prefix) + '.labels', 'rb') as f:
+        ranks = rd(f, 'I', n); types = rd(f, 'B', n)
+    args = [(flat[2 * i], flat[2 * i + 1]) for i in range(n)]
+    return h, v, n, q, args, core, cover, roots, kind, active, ranks, types
+
+
+# ---------------------------------------------------------------- F2 linear algebra on bit vectors
+def dot(a, b): return bin(a & b).count('1') & 1
+
+
+def reduce(basis):
+    rows = []; piv = []
+    for vec in basis:
+        for p, r in zip(piv, rows):
+            if vec >> p & 1: vec ^= r
+        if vec:
+            p = vec.bit_length() - 1
+            for i in range(len(rows)):
+                if rows[i] >> p & 1: rows[i] ^= vec
+            rows.append(vec); piv.append(p)
+    return rows
+
+
+def kernel(funcs, h):
+    K = reduce(funcs); piv = [r.bit_length() - 1 for r in K]
+    out = []
+    for c in (i for i in range(h) if i not in piv):
+        vec = 1 << c
+        for r, p in zip(K, piv):
+            if r >> c & 1: vec |= 1 << p
+        out.append(vec)
+    return out
+
+
+def restrict(basis, funcs):
+    B = reduce(basis)
+    for f in funcs:
+        if not B: break
+        vals = [dot(b, f) for b in B]
+        if not any(vals): continue
+        k = vals.index(1); pv = B[k]
+        B = [b ^ pv if val else b for b, val in zip(B, vals)]; B.pop(k)
+    return reduce(B)
+
+
+def contains(A, B):
+    RB = reduce(B)
+    return len(reduce(RB + list(A))) == len(RB)
+
+
+def cap(A, B):
+    A = reduce(A); B = reduce(B)
+    if not A or not B: return []
+    ker = []; red = []
+    for i, vec in enumerate(A + B):
+        tag = 1 << i
+        for rv, rt in red:
+            if vec >> (rv.bit_length() - 1) & 1: vec ^= rv; tag ^= rt
+        if vec: red.append((vec, tag))
+        else:
+            comb_ = 0
+            for k in range(len(A)):
+                if tag >> k & 1: comb_ ^= A[k]
+            ker.append(comb_)
+    return reduce(ker)
+
+
+def nondeg(B):
+    B = reduce(B); k = len(B)
+    if not k: return True
+    M = [sum(dot(B[i], B[j]) << j for j in range(k)) for i in range(k)]
+    return len(reduce(M)) == k
+
+
+def hopcroft_karp(left, adj):
+    """maximum bipartite matching; adj[x] = sorted list of right vertices."""
+    INF = 1 << 60
+    mate_l = {x: None for x in left}; mate_r = {}
+    while True:
+        dist = {}; queue = []
+        for x in left:
+            if mate_l[x] is None: dist[x] = 0; queue.append(x)
+            else: dist[x] = INF
+        found = INF; head = 0
+        while head < len(queue):
+            x = queue[head]; head += 1
+            if dist[x] >= found: continue
+            for r in adj[x]:
+                y = mate_r.get(r)
+                if y is None: found = min(found, dist[x] + 1)
+                elif dist[y] == INF: dist[y] = dist[x] + 1; queue.append(y)
+        if found == INF: break
+        gained = 0
+        for x0 in left:
+            if mate_l[x0] is not None: continue
+            stack = [(x0, iter(adj[x0]))]; path = []
+            while stack:
+                x, it = stack[-1]
+                advanced = False
+                for r in it:
+                    y = mate_r.get(r)
+                    if (y is None and dist[x] + 1 == found) or (y is not None and dist[y] == dist[x] + 1):
+                        path.append((x, r))
+                        if y is None:
+                            for xx, rr in path: mate_l[xx] = rr; mate_r[rr] = xx
+                            gained += 1; stack = []; break
+                        stack.append((y, iter(adj[y]))); advanced = True; break
+                else:
+                    dist[x] = INF; stack.pop()
+                    if path: path.pop()
+                    continue
+                if not advanced: break
+        if not gained: break
+    return mate_l
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix='deferred-stopped-') as work:
+        prefix = Path(work) / 'complex'
+        build(24, prefix, central_disjoint=24)
+        h, v, n, q, args, core, cover, roots, kind, active, ranks, types = load(prefix)
+    trip = list(combinations(range(h), 3)); require(len(trip) == v, 'triple count')
+    m = h * h; N = v * v; FULL = (1 << h) - 1
+    tmask = [sum(1 << p for p in T) for T in trip]
+    tid = {T: i for i, T in enumerate(trip)}
+
+    # ------------------------------------------------------------ uses and matching (inherited adjacency)
+    degree = [0] * n; uses = defaultdict(list); c_add = 0
+    for x in range(1, n):
+        if active[x] and args[x][0]:
+            c_add += 1
+            for pos, y in enumerate(args[x]): degree[y] += 1; uses[y].append(('gate', x, pos))
+    for j, x in enumerate(roots): degree[x] += 1; uses[x].append(('root', j))
+    def unode(u): return roots[u[1]] if u[0] == 'root' else u[1]
+    def before(x, u):
+        y = unode(u)
+        return (ranks[x], x) < (ranks[y], (n + u[1]) if u[0] == 'root' else y)
+    def incl(x, y):
+        tx, ty = types[x], types[y]
+        if tx == 1 and ty == 1: return not (core[y] & ~core[x]) and not (cover[x] & ~cover[y])
+        if tx in (1, 2) and ty == 2: return not (cover[x] & ~cover[y])
+        if tx == 1 and ty == 3: return bool(core[x] & core[y])
+        if tx == 2 and ty == 3: return not (cover[x] & ~core[y])
+        if tx == 3 and ty == 2: return cover[y] == FULL
+        if tx == 3 and ty == 3: return core[x] == core[y]
+        return False
+    left = []; adj = {}
+    for x in range(1, n):
+        if not (active[x] and args[x][0]): continue
+        rs = sorted({(y, k) for y in args[x] for k, u in enumerate(uses[y]) if before(x, u) and incl(x, unode(u))})
+        if rs: left.append(x); adj[x] = rs
+    mate = hopcroft_karp(left, adj)
+    links = {x: r for x, r in mate.items() if r is not None}
+    R = c_add + q - len(links)
+    require((c_add, q, len(links), R) == (91770, 8120, 71185, 28705),
+            'selected graph size: additions=%d, roots=%d, matching=%d, roles=%d' % (c_add, q, len(links), R))
+    linked_use = {(y, k): x for x, (y, k) in links.items()}
+
+    # ------------------------------------------------------------ root targets, read coefficients, root functionals
+    target = [None] * q
+    for j in range(v): target[j] = j
+    idx = v
+    for a, b in combinations(range(h), 2):
+        others = sorted((i for i in range(h) if i not in (a, b)), key=(lambda i: producer.ORDER(i, a, b)) if hasattr(producer, 'ORDER') else (lambda i: ((i ^ 1) in (a, b), i)))
+        for i in others: target[idx] = tid[tuple(sorted((a, b, i)))]; idx += 1
+    centre_of = {}
+    for j in range(q):
+        if kind[j]:
+            miss = FULL & ~cover[roots[j]]; require(bin(miss).count('1') == 1, 'centre cover')
+            centre_of[j] = miss.bit_length() - 1
+    require(idx + len(centre_of) == q, 'root order')
+    rootfun = [(1 << centre_of[j]) if kind[j] else tmask[target[j]] for j in range(q)]
+
+    # ------------------------------------------------------------ lifted binary frames, monotone
+    succ = defaultdict(set); droot = defaultdict(set)
+    for x in range(1, n):
+        if not active[x]: continue
+        for k, u in enumerate(uses[x]):
+            if (x, k) in linked_use: continue
+            (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    for x, (y, k) in links.items():
+        u = uses[y][k]; (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    order_desc = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x), reverse=True)
+    K = {}
+    for x in order_desc:
+        rows = [rootfun[j] for j in droot[x]]
+        for t in succ[x]: rows += K[t]
+        K[x] = reduce(rows)
+    def envelope(x):
+        if not args[x][0]: return [tmask[x - 1]]
+        if types[x] == 2: return [1 << i for i in range(h) if cover[x] >> i & 1]
+        require(types[x] == 1, 'only ordinary and common-pair labels occur')
+        ks = [i for i in range(h) if (cover[x] & ~core[x]) >> i & 1]
+        require(len(ks) == ranks[x], 'common-pair support')
+        return [core[x] | (1 << k) for k in ks]
+    U = {}
+    for x in range(1, n):
+        if not active[x]: continue
+        if not args[x][0]: U[x] = envelope(x); continue
+        B = kernel(K[x], h)
+        require(contains(envelope(x), B), 'label outside lifted frame')
+        U[x] = B if nondeg(B) else envelope(x)
+    changed = True
+    while changed:
+        changed = False
+        for x in order_desc:
+            if args[x][0] and any(not contains(U[x], U[t]) for t in succ[x]):
+                env = envelope(x)
+                if len(reduce(U[x])) != len(reduce(env)) or not contains(U[x], env): U[x] = env; changed = True
+    dimU = {x: len(reduce(B)) for x, B in U.items()}
+
+    # ------------------------------------------------------------ explicit role compile
+    order = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x))
+    holds = []; first_node = []; ops = []; edge_key = {}; role_root = {}
+    def new_role(node): holds.append([node]); first_node.append(node); return len(holds) - 1
+    def serve(s, y, k):
+        u = uses[y][k]
+        if u[0] == 'gate': edge_key[(y, k)] = s
+        else: role_root[s] = u[1]
+    for x in order:
+        free = [k for k in range(len(uses[x])) if (x, k) not in linked_use]
+        if not args[x][0]:
+            for k in free:
+                s = new_role(x); ops.append(('src', s, x)); serve(s, x, k)
+            continue
+        a, b = args[x]
+        ka = next(k for k, u in enumerate(uses[a]) if u == ('gate', x, 0))
+        kb = next(k for k, u in enumerate(uses[b]) if u == ('gate', x, 1))
+        sa, sb = edge_key.pop((a, ka)), edge_key.pop((b, kb))
+        if x in links and links[x][0] == a: sa, sb = sb, sa
+        piv, oth = sa, sb
+        ops.append(('add', piv, oth, x)); holds[piv].append(x); holds[oth].append(x)
+        if x in links: serve(oth, *links[x])
+        require(free, 'every use linked at node %d' % x)
+        serve(piv, x, free[0])
+        for k in free[1:]:
+            f = new_role(x); ops.append(('copy', piv, f, x)); serve(f, x, k)
+    require(not edge_key and len(holds) == R, 'compile')
+    Rr = R
+
+    # ------------------------------------------------------------ B. the word computes every root value
+    rng = random.Random(20261008)
+    xs = [rng.randrange(P) for _ in range(v)]
+    val = [0] * n
+    for i in range(v): val[i + 1] = xs[i]
+    for x in order:
+        if args[x][0]: val[x] = (val[args[x][0]] + val[args[x][1]]) % P
+    leaf_of = {s: first_node[s] for s in range(Rr) if not args[first_node[s]][0]}
+    a_ = [0] * Rr
+    for s, leaf in leaf_of.items(): a_[s] = xs[leaf - 1]
+    for o in ops:
+        if o[0] == 'add': a_[o[1]] = (a_[o[1]] + a_[o[2]]) % P
+        elif o[0] == 'copy': a_[o[2]] = (a_[o[2]] + a_[o[1]]) % P
+    require(all(a_[s] == val[roots[j]] for s, j in role_root.items()), 'root values')
+
+    # ------------------------------------------------------------ phase one and garbage reach
+    def touch(o): return [o[1], o[2]] if o[0] in ('add', 'copy') else []
+    prev = {}; pred = defaultdict(list); last = {}
+    for i, o in enumerate(ops):
+        for s in touch(o):
+            if s in prev: pred[i].append(prev[s])
+            prev[s] = i; last[s] = i
+    centre_roles = [s for s, j in role_root.items() if kind[j]]
+    Anc = set(); st = [last[s] for s in centre_roles]
+    while st:
+        i = st.pop()
+        if i not in Anc: Anc.add(i); st.extend(pred[i])
+    touched = set(centre_roles)
+    for i in Anc: touched.update(touch(ops[i]))
+    require(all(last[s] in Anc for s in centre_roles), 'centres complete in phase one')
+    reach = [set() for _ in range(Rr)]; reach_all = [False] * Rr
+    for s, j in role_root.items():
+        if kind[j]: reach_all[s] = True
+        else: reach[s].add(target[j])
+    for o in reversed(ops):
+        if o[0] == 'add': reach[o[2]] |= reach[o[1]]; reach_all[o[2]] = reach_all[o[2]] or reach_all[o[1]]
+        elif o[0] == 'copy': reach[o[1]] |= reach[o[2]]; reach_all[o[1]] = reach_all[o[1]] or reach_all[o[2]]
+
+    # ------------------------------------------------------------ deferral frames, insertion nesting
+    def F0(s): return U[first_node[s]]
+    cand = {}
+    for s in range(Rr):
+        if s in touched or reach_all[s]: continue
+        S_ = restrict(F0(s), [tmask[t] for t in reach[s]])
+        if S_ and nondeg(S_): cand[s] = S_
+    byT = defaultdict(list); placed = {}
+    for s in sorted(cand, key=lambda s: (-len(cand[s]), s)):
+        X = cand[s]; changed = True
+        while changed and X:
+            changed = False
+            for t in reach[s]:
+                for w in byT[t]:
+                    B = placed[w]
+                    if (len(B) >= len(X) and not contains(X, B)) or (len(B) < len(X) and not contains(B, X)):
+                        X = cap(X, B); changed = True
+                    if not X: break
+                if not X: break
+        if X and nondeg(X):
+            placed[s] = X
+            for t in reach[s]: byT[t].append(s)
+    deferred = sorted(placed, key=lambda s: (len(placed[s]), s)); dset = set(deferred)
+
+    # ------------------------------------------------------------ C. replay with arbitrary scratch and data
+    inv = lambda a: pow(a % P, P - 2, P); HALF = inv(2); I21 = inv(21)
+    cvec = [None] * Rr; dpart = [dict() for _ in range(Rr)]
+    for s, j in role_root.items():
+        if kind[j]: c = [0] * h; c[centre_of[j]] = 1; cvec[s] = c
+        else: dpart[s][target[j]] = (P - HALF) if j >= v else HALF
+    seed_c = {s: (None if cvec[s] is None else list(cvec[s])) for s in role_root}
+    seed_d = {s: dict(dpart[s]) for s in role_root}
+    def addc(dst, src):
+        if cvec[src] is not None:
+            cvec[dst] = list(cvec[src]) if cvec[dst] is None else [(p + q_) % P for p, q_ in zip(cvec[dst], cvec[src])]
+        for t, c in dpart[src].items(): dpart[dst][t] = (dpart[dst].get(t, 0) + c) % P
+    for o in reversed(ops):
+        if o[0] == 'add': addc(o[2], o[1])
+        elif o[0] == 'copy': addc(o[1], o[2])
+    scatter = [[(I21 - (HALF if i in trip[t] else 0)) % P for t in range(v)] for i in range(h)]
+    def readout(y, s, value, sign, seed=False):
+        cv = seed_c[s] if seed else cvec[s]; dp = seed_d[s] if seed else dpart[s]
+        if cv is not None:
+            for i, ci in enumerate(cv):
+                if ci:
+                    f = sign * ci * value % P; row = scatter[i]
+                    for t in range(v): y[t] = (y[t] + f * row[t]) % P
+        for t, c in dp.items(): y[t] = (y[t] + sign * c * value) % P
+    phase1 = sorted(Anc); rest = [i for i in range(len(ops)) if i not in Anc]
+    def replay(seed):
+        rng = random.Random(seed)
+        x = [rng.randrange(P) for _ in range(v)]; z = [rng.randrange(P) for _ in range(Rr)]
+        y0 = [rng.randrange(P) for _ in range(v)]; a = list(z); y = list(y0)
+        for s in range(Rr):
+            if s not in dset: readout(y, s, a[s], -1)
+        for s, leaf in leaf_of.items():
+            if s not in dset: a[s] = (a[s] + x[leaf - 1]) % P
+        def run(i, sign=1):
+            o = ops[i]
+            if o[0] == 'add': a[o[1]] = (a[o[1]] + sign * a[o[2]]) % P
+            elif o[0] == 'copy': a[o[2]] = (a[o[2]] + sign * a[o[1]]) % P
+        for i in phase1: run(i)
+        for s in centre_roles: readout(y, s, a[s], +1, True)
+        for s in deferred: readout(y, s, a[s], -1)
+        for s in deferred:
+            if s in leaf_of: a[s] = (a[s] + x[leaf_of[s] - 1]) % P
+        for i in rest: run(i)
+        for s, j in role_root.items():
+            if not kind[j]: readout(y, s, a[s], +1, True)
+        for i in reversed(range(len(ops))): run(i, -1)
+        for s, leaf in leaf_of.items(): a[s] = (a[s] - x[leaf - 1]) % P
+        return a == z, all((y[t] - y0[t] - x[t]) % P == 0 for t in range(v))
+    rep = [replay(seed) for seed in (1, 2)]
+    require(all(r == (True, True) for r in rep), 'replay %s' % rep)
+
+    # ------------------------------------------------------------ D. exact F2 frame facts
+    root_frame = {}
+    for s, j in role_root.items():
+        root_frame[s] = [1 << i for i in range(h) if i != centre_of[j]] if kind[j] else kernel([tmask[target[j]]], h)
+    FULLB = [1 << i for i in range(h)]
+    chain_dims = []
+    for s in range(Rr):
+        seq = [placed.get(s, []), F0(s)] + [U[x] for x in holds[s][1:]]
+        if s in root_frame: seq.append(root_frame[s])
+        seq.append(FULLB)
+        require(all(contains(A, B) for A, B in zip(seq, seq[1:])), 'role chain nesting %d' % s)
+        require(all(nondeg(B) for B in seq[1:-1] if B), 'degenerate frame on role %d' % s)
+        chain_dims.append([len(reduce(B)) for B in seq])
+    for s, X in placed.items():
+        require(contains(X, F0(s)) and nondeg(X), 'deferral frame %d' % s)
+        require(all(not any(dot(xv, tmask[t]) for xv in X) for t in reach[s]), 'target frame %d' % s)
+    byT2 = defaultdict(list)
+    for s in deferred:
+        for t in reach[s]: byT2[t].append(s)
+    for t, ss in byT2.items():
+        ss.sort(key=lambda s: (len(placed[s]), s))
+        require(all(contains(placed[p], placed[q_]) for p, q_ in zip(ss, ss[1:])), 'target chain %d' % t)
+
+    # ------------------------------------------------------------ E. one-child histogram
+    z = Counter()
+    for s in range(Rr):
+        ds = chain_dims[s]
+        for a, b in zip(ds[:-1], ds[1:-1]):
+            if b > a: z[b - a] += 2 * v
+        lastd = ds[-2]
+        if s in role_root and kind[role_root[s]]: z[h - 1] += 2 * v           # copied centre transform
+        z[h - lastd] += 2 * v                                                  # final growth to F
+        z[m - h + ds[0]] += 2 * v                                              # exterior, gauged by sigma
+    levels = defaultdict(set)
+    for s in deferred:
+        for t in reach[s]: levels[t].add(len(placed[s]))
+    for t in range(v):
+        ds = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v                       # target fronts
+    z[h - 1] += 2 * N                                                          # data-wire fronts
+    z[(h - 1) ** 2] += 2 * N                                                   # data macros
+    z[1] += N                                                                  # endpoint copies
+    z.pop(0, None)
+    W = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = W * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'complex rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    out = dict(h=h, v=v, additions=c_add, roots=q, links=len(links), R=R, m=m, N=N, W=W, L=L, total_rank=s_,
+               deficit=N - L, maxchild=max(z), phase_one_ops=len(Anc), phase_one_roles=len(touched),
+               deferred_roles=len(deferred),
+               deferred_dims=dict(sorted(Counter(len(X) for X in placed.values()).items())),
+               lifted_additions=sum(1 for x in U if args[x][0] and dimU[x] > ranks[x]),
+               replay=dict(seeds=[1, 2], scratch_restored=True, y_plus_x=True, field='Z/(2^61-1)'),
+               child_multiplicities=dict(sorted(z.items())))
+    Path(_o3.environ.get('CX_OUT', str(HERE / 'complex-profile.json'))).write_text(json.dumps(out, indent=1) + '\n')
+    print('PASS complex: R=%d, deferred roles %d, maxchild %d, rank mass %d' % (R, len(deferred), max(z), s_))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/deferred-replayed-117/producer.py b/research/deferred-replayed-117/producer.py
new file mode 100644
index 0000000000..5ac122ca61
--- /dev/null
+++ b/research/deferred-replayed-117/producer.py
@@ -0,0 +1,16 @@
+"""Producer adapter: PR117's replayed h=24 complex DAG for the PR110/PR114/PR116 deferral compiler.
+
+replayed.py and complex-dag.json.gz are copied unchanged from PR117 (eumemic, Apache-2.0,
+scripts/deferred_product/replayed.py and certificates/deferred-product-complex-dag.json.gz).
+replayed.build recomputes every support, label, rank, root identity, the /21 decoder and
+scatter identity, frame nesting and nondegeneracy from the operand pairs. Pair-star roots are
+listed in ascending i order, hence ORDER below. Adapter by Rohan Arun with Anthropic Claude assistance.
+"""
+import importlib.util
+from pathlib import Path
+HERE=Path(__file__).resolve().parent
+_s=importlib.util.spec_from_file_location('replayed117',HERE/'replayed.py');_m=importlib.util.module_from_spec(_s);_s.loader.exec_module(_m)
+ORDER=lambda i,a,b:(i,)
+def build(h,prefix,central_disjoint=24,base=2):
+    assert (h,central_disjoint)==(24,24)
+    return _m.build(HERE/'complex-dag.json.gz',prefix)
diff --git a/research/deferred-replayed-117/replayed.py b/research/deferred-replayed-117/replayed.py
new file mode 100644
index 0000000000..673fbbba70
--- /dev/null
+++ b/research/deferred-replayed-117/replayed.py
@@ -0,0 +1,179 @@
+"""Replayed h=24 complex producer with all centers disjoint (rational divisor 21).
+
+Copyright 2026 eumemic, Apache-2.0. AI-assisted (Claude). The DAG was found by an
+automated search over producers of the retained paired-triple, pair-star and
+center-disjoint interfaces. The checks below are adapted from
+stopped_product/complex.py (copyright 2026 icekylinx, Apache-2.0, PR #104).
+
+The witness complex-dag.json.gz lists the ordinary
+additions after the v triple inputs and the retained roots: the disjoint sums
+D[t], the pair stars P(a,b,i) and the center-disjoint sums A_i. Every support,
+core, cover, type and rank is recomputed here from the operands; nothing is
+read from the witness except the operand pairs and the root indices.
+"""
+import gzip, json, struct, sys, array
+from fractions import Fraction
+from itertools import combinations
+from pathlib import Path
+
+
+def write_array(f, values):
+    """Little-endian array writer, as partial_swap.binary.write_array."""
+    if sys.byteorder != 'little' and values.itemsize > 1:
+        values = array.array(values.typecode, values)
+        values.byteswap()
+    values.tofile(f)
+
+
+def build(witness, prefix):
+    w = json.loads(gzip.decompress(Path(witness).read_bytes()))
+    h, v, d = w['h'], w['v'], w['central_disjoint']
+    assert (h, d, w['center_denominator']) == (24, 24, 21)
+    triples = list(combinations(range(h), 3))
+    assert v == len(triples)
+    args = [(0, 0)]; support = [0]; core = [0]; cover = [0]; types = [0]; ranks = [0]
+    for j, t in enumerate(triples):
+        mask = sum(1 << a for a in t)
+        args.append((0, 0)); support.append(1 << j); core.append(mask); cover.append(mask)
+        types.append(1); ranks.append(1)
+    flat = w['args']
+    assert len(flat) % 2 == 0
+    for k in range(0, len(flat), 2):
+        a, b, x = flat[k], flat[k+1], len(args)
+        assert 0 < a < x and 0 < b < x, 'Operands must precede their sum'
+        assert not support[a] & support[b], 'Ordinary additions must be cancellation-free'
+        args.append((a, b)); support.append(support[a] | support[b])
+        core.append(core[a] & core[b]); cover.append(cover[a] | cover[b])
+        if core[x].bit_count() >= 2:
+            types.append(1); ranks.append(support[x].bit_count())
+        else:
+            types.append(2); ranks.append(cover[x].bit_count())
+    n = len(args)
+    point_masks = [sum(1 << j for j, t in enumerate(triples) if a in t) for a in range(h)]
+    full_support = (1 << v) - 1
+    roots, kind = [], []
+    assert len(w['D']) == v
+    for t, node in zip(triples, w['D']):
+        assert 0 < node < n
+        assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]])
+        target_mask = sum(1 << a for a in t)
+        if types[node] == 2:
+            assert not cover[node] & target_mask
+        else:
+            assert types[node] == 1
+            assert not support[node] & (point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]])
+        roots.append(node); kind.append(0)
+    stars = [(a, b, i) for a, b in combinations(range(h), 2) for i in range(h) if i not in (a, b)]
+    assert len(w['P']) == len(stars)
+    pair_outputs = {}
+    for (a, b, i), node in zip(stars, w['P']):
+        assert 0 < node < n
+        assert support[node] == point_masks[a] & point_masks[b] & ~point_masks[i]
+        assert types[node] == 1
+        assert not support[node] & (point_masks[a]^point_masks[b]^point_masks[i])
+        pair_outputs[a, b, i] = node
+        roots.append(node); kind.append(0)
+    assert len(w['A']) == d
+    for i, node in enumerate(w['A']):
+        assert 0 < node < n
+        assert support[node] == full_support & ~point_masks[i]
+        assert types[node] == 2 and cover[node] == ((1 << h)-1) ^ (1 << i)
+        assert ranks[node] == h-1
+        roots.append(node); kind.append(1)
+    # Every A_i avoids i, so sum A_i = (h-3)T. The decoder is T=sum A_i/21
+    # and the scatter is T-(1/2)sum_{i in target} A_i.
+    decoder = Fraction(1, h-3)
+    assert decoder == Fraction(1, 21)
+    scatter_coefficients = [decoder, decoder-Fraction(1, 2)]
+    for coefficient in scatter_coefficients:
+        odd_denominator = coefficient.denominator
+        while odd_denominator % 2 == 0:
+            odd_denominator //= 2
+        assert 21 % odd_denominator == 0 and abs(coefficient) <= 1
+    for source in triples:
+        assert sum(i not in source for i in range(h))*decoder == 1
+    Dset = set(range(d))
+    for triple in triples:
+        k = len(Dset.intersection(triple))
+        assert 2*(3-k)-2*(d-k) == 2*(3-d)
+    patterns = {}
+    for target in triples:
+        chosen = len(Dset.intersection(target))
+        if chosen not in patterns:
+            patterns[chosen] = target
+    for chosen, target in patterns.items():
+        target_set = set(target)
+        for source in triples:
+            k = len(Dset.intersection(source))
+            total_coefficient = Fraction(2*(3-k)-2*(d-k), 2*(3-d))
+            scalar = Fraction(len((target_set-Dset).intersection(source)), 2)
+            scalar -= Fraction(len((target_set & Dset)-set(source)), 2)
+            scalar += Fraction(chosen-1, 2)*total_coefficient
+            assert scalar == Fraction(len(target_set.intersection(source))-1, 2)
+    for j, t in enumerate(triples):
+        masks = [point_masks[a] for a in t]
+        two = (masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0])
+        actual = 0
+        for a, b in combinations(t, 2):
+            excluded = next(i for i in t if i not in (a, b))
+            actual |= support[pair_outputs[a, b, excluded]]
+        assert actual == two
+        assert masks[0]&masks[1]&masks[2] == 1 << j
+    assert [((k-1)+(k == 0)-(k == 2)) for k in range(4)] == [0, 0, 0, 2]
+
+    def contained(x, y):
+        tx, ty = types[x], types[y]
+        if tx == 1 and ty == 1: return not(core[y]&~core[x] or cover[x]&~cover[y])
+        if tx in (1, 2) and ty == 2: return not cover[x]&~cover[y]
+        return False
+    active = [0]*n; stack = list(roots)
+    while stack:
+        x = stack.pop()
+        if not x or active[x]: continue
+        active[x] = 1
+        if args[x][0]: stack.extend(args[x])
+    degree = [0]*n
+    for x in range(1, n):
+        if active[x]:
+            if types[x] == 1:
+                assert core[x].bit_count() >= 2 and ranks[x] == support[x].bit_count()
+            else:
+                assert types[x] == 2 and ranks[x] == cover[x].bit_count()
+        if active[x] and args[x][0]:
+            for y in args[x]:
+                assert y < x and contained(y, x), 'Binary frame nesting failed'
+                degree[y] += 1
+    for x in roots: degree[x] += 1
+    H = [0]*(h+1); c = 0; loss = 0
+    for x in range(1, n):
+        if not active[x]: continue
+        r = ranks[x]
+        if args[x][0]:
+            c += 1; H[r] += degree[x]-1; H[h-r] += 1
+            for y in args[x]:
+                assert r >= ranks[y]
+                H[r-ranks[y]] += 1
+        else: H[1] += degree[x]
+    for x, k in zip(roots, kind):
+        r = ranks[x]
+        if k: H[r] += 1; H[h] += 1; loss += r
+        else: H[h-1-r] += 1; H[1] += 1
+    q = len(roots); R = c+q
+    result = dict(h=h, v=v, c=c, q=q, R=R, loss=loss, central_disjoint=d, histogram=H,
+                  rank_sum=sum(r*m for r, m in enumerate(H)))
+    assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss
+    result['center_denominator'] = 21
+    result['scalar_validation'] = dict(ordinary_supports_exact=True, centers_exact=True,
+        center_decoder='sum A_i / 21', scatter_coefficients=list(map(str, scatter_coefficients)),
+        rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True,
+        binary_frames_nondegenerate=True)
+    with open(str(prefix)+'.bin', 'wb') as f:
+        f.write(struct.pack('<4I', h, v, n, q))
+        write_array(f, array.array('I', (a for pair in args for a in pair)))
+        write_array(f, array.array('Q', core)); write_array(f, array.array('Q', cover))
+        write_array(f, array.array('I', roots)); write_array(f, array.array('I', kind))
+        write_array(f, array.array('B', active))
+    with open(str(prefix)+'.labels', 'wb') as f:
+        write_array(f, array.array('I', ranks)); write_array(f, array.array('B', types))
+    Path(str(prefix)+'.json').write_text(json.dumps(result, indent=2)+'\n')
+    return result
diff --git a/research/deferred-replayed-117/test_unit_readouts.py b/research/deferred-replayed-117/test_unit_readouts.py
new file mode 100644
index 0000000000..5ac25bb5de
--- /dev/null
+++ b/research/deferred-replayed-117/test_unit_readouts.py
@@ -0,0 +1,25 @@
+import unittest
+from fractions import Fraction as Q
+from unit_readouts import split_numerator, validate_pieces
+class Controls(unittest.TestCase):
+    def test_actual_larger_coefficient(self): self.assertEqual(split_numerator(55),(42,13))
+    def test_negative_coefficient(self): self.assertEqual(split_numerator(-55),(-42,-13))
+    def test_zero(self): self.assertEqual(split_numerator(0),())
+    def test_unpaid_third_piece_rejected(self):
+        with self.assertRaises(AssertionError): split_numerator(85)
+    def test_dropped_piece_rejected(self):
+        with self.assertRaises(AssertionError): validate_pieces(55,(42,))
+    def test_oversized_single_shear_rejected(self):
+        with self.assertRaises(AssertionError): validate_pieces(55,(55,))
+    def test_wrong_inverse_sign_rejected(self):
+        with self.assertRaises(AssertionError): validate_pieces(55,(42,-13))
+    def test_exact_shear_and_inverse_on_dirty_values(self):
+        for numerator in range(-84,85):
+            x,y=Q(17,13),Q(-29,11)
+            pieces=split_numerator(numerator)
+            z=y
+            for a in pieces:z+=Q(a,42)*x
+            self.assertEqual(z,y+Q(numerator,42)*x)
+            for a in reversed(pieces):z-=Q(a,42)*x
+            self.assertEqual(z,y)
+if __name__=='__main__':unittest.main()
diff --git a/research/deferred-replayed-117/unit_readouts.py b/research/deferred-replayed-117/unit_readouts.py
new file mode 100644
index 0000000000..32345c7ab6
--- /dev/null
+++ b/research/deferred-replayed-117/unit_readouts.py
@@ -0,0 +1,23 @@
+"""Exact unit-magnitude splitting of fixed rational readout shears.
+
+The selected PR117 DAG has numerator magnitudes at most 55 over 42. Two
+pieces suffice; audit.py checks this bound on every expanded coefficient.
+A second piece uses the same frame, so adds scalar work and no rank child.
+"""
+DENOMINATOR = 42
+MAX_PIECES = 2
+
+def validate_pieces(numerator, pieces):
+    assert len(pieces) <= MAX_PIECES, 'Unpaid readout pieces'
+    assert all(0 < abs(x) <= DENOMINATOR for x in pieces), 'Non-unit readout shear'
+    assert sum(pieces) == numerator, 'Readout coefficient changed'
+    return len(pieces)
+
+def split_numerator(numerator):
+    assert isinstance(numerator, int)
+    sign = -1 if numerator < 0 else 1
+    whole, remainder = divmod(abs(numerator), DENOMINATOR)
+    assert whole + bool(remainder) <= MAX_PIECES, 'Unpaid readout pieces'
+    pieces = (sign * DENOMINATOR,) * whole + ((sign * remainder,) if remainder else ())
+    validate_pieces(numerator, pieces)
+    return pieces
diff --git a/research/deferred-replayed-117/verify.py b/research/deferred-replayed-117/verify.py
new file mode 100644
index 0000000000..0ae09b3ff2
--- /dev/null
+++ b/research/deferred-replayed-117/verify.py
@@ -0,0 +1,25 @@
+"""Verify frozen source pins, exact accounting, controls and optional full replay."""
+import sys
+assert not sys.flags.optimize, 'Assertions must remain enabled'
+sys.dont_write_bytecode = True
+import argparse, hashlib, json, os, subprocess
+from pathlib import Path
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[1]
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--full',action='store_true');args=ap.parse_args()
+    manifest=json.loads((HERE/'SOURCE.json').read_text())
+    for base,key in ((HERE,'package_files'),(ROOT,'repository_files')):
+        for name,expected in manifest[key].items():
+            assert hashlib.sha256((base/name).read_bytes()).hexdigest()==expected, name
+    env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1');env.pop('CX_PRODUCER',None)
+    run=lambda cmd:subprocess.run([sys.executable,*cmd],cwd=ROOT,env=env,check=True)
+    frozen={n:json.loads((HERE/n).read_text()) for n in ('complex-profile.json','bit-profile.json','certificate.json')}
+    run([str(HERE/'certificate.py')]);run([str(HERE/'test_unit_readouts.py')])
+    if args.full:
+        run([str(HERE/'complex_deferred.py')]);run([str(HERE/'bit_round7.py'),str(ROOT/'research/cube-deferred/inputs')])
+        run([str(HERE/'certificate.py')]);run([str(HERE/'audit.py'),'--source',str(HERE/'complex_deferred.py'),'--check',str(HERE/'audit-result.json')])
+    for name,data in frozen.items():assert json.loads((HERE/name).read_text())==data, name
+    print('PASS deferred PR117 source pins, exact unit-shear accounting and controls'+(' with full physical/reflected replay' if args.full else ''))
+if __name__=='__main__':main()
diff --git a/research/deferred-stopped/PROOF.md b/research/deferred-stopped/PROOF.md
new file mode 100644
index 0000000000..58237eccf0
--- /dev/null
+++ b/research/deferred-stopped/PROOF.md
@@ -0,0 +1,114 @@
+# Deferred readouts on both networks of the stopped product-ring interchange
+
+## 1. Claim
+
+Under every hypothesis that PR #104 retains, the stopped product-ring interchange with
+
+- the bit network replaced by Swapnil Jain's round-seven deferred word (h = 23), and
+- PR #104's own complex network (h = 24) given lifted binary frames and deferred readouts,
+
+gives the conditional bound T(n) = O(n (log n)^(1-κ)) with
+
+κ = 429239/5000000000 = 8.58478 × 10^-5,
+
+which is +10.1% over PR #104 (7.79476 × 10^-5). The next κ grid point at denominator 10^10 is rejected.
+This is a finite conditional certificate only.
+
+| | PR #104 | here |
+|---|---|---|
+| bit network | positive-label producer, R = 38,776 | Swapnil round seven, R = 28,866, 11,565 deferred slots |
+| coarse bit saving | 4019/50000000 = 8.038e-5 | 620523/5000000000 = 1.241046e-4 |
+| stopped bit saving | 8.034e-5 | 1.240190e-4 |
+| complex network | aligned rational centres, R = 44,918 | same DAG and roles, lifted frames, 8,893 deferred roles |
+| complex saving | 1949/25000000 = 7.796e-5 | 214657/2500000000 = 8.58628e-5 |
+| κ | 7.79476e-5 | 8.58478e-5 |
+
+## 2. What changes
+
+Nothing in PR #104's interface changes: opposite-bank factorization, stopped atom recursion, ordinary
+wrapper, rational centres, common odd grid, product rows and the balanced assembly are used as they are.
+Two finite inputs change.
+
+**Bit network.** Swapnil Jain's round-seven witness (commit 741e7aa078392553815df7926ee17ac5e25a8c38, files pinned by SHA-256 in
+`bit_round7.py`): PR #62's producer, lifted frames, late copies, deferred readouts and V leaves. Swapnil's own
+checkers verify the word and every frame exactly, and PR #97 replays its forward and reflected ledgers. We do not
+change it. Under PR #104's rule every residual of rank r is one child of width r, so the slot chains, the gauged
+exteriors (width m - (h - dim σ_u)), the copied-centre transforms, the target and data-wire chains, the data
+residuals and the endpoint copies give the child list in `bit-profile.json` (rank mass 57,403,754,177, the
+value PR #97 reports).
+
+**Complex network.** PR #104's DAG (`scripts/stopped_product/complex.py`, unchanged) and its role count
+R = c + q - |M| = 45,764 + 8,120 - 8,966 = 44,918. New:
+
+1. *Matching.* A maximum carrier matching under the inherited matcher's adjacency (order by rank and node, the
+   inherited label-inclusion rules), size 8,966.
+2. *Roles.* An explicit compile: one role per free leaf use, the pivot continues each addition, copies serve the
+   other free uses, a linked operand stays on the non-pivot and continues to its linked use.
+3. *Lifted frames.* For an addition n, U_n is the common kernel over F2 of the functionals of every root reachable
+   along slot successors (t_S for an output read into y_S, e_i for the retained centre A_i, whose frame is
+   span{e_j : j ≠ i}). Every label lies in its kernel (outputs have even intersection with their target; A_i
+   avoids i). The lift is used where U_n is nondegenerate and kept monotone along successors; elsewhere the
+   inherited label stays. 20,234 additions are lifted.
+4. *Deferred readouts* (Swapnil's design B on the complex word). Phase one is the closure of the 24 centre
+   completions under per-role precedence. A role untouched by phase one, whose garbage does not reach a centre
+   (a centre scatters to every target), reads its garbage out at
+   σ_u ⊆ F0(u) ∩ ⋂ t_S^⊥ over its reached targets, nondegenerate. An insertion rule (largest first) shrinks each
+   new frame only as far as nesting on its targets requires. Readouts run in increasing (dim σ_u, role).
+
+The stage-one word is: readouts of the non-deferred roles at frame 0, early V gates, phase one, centre copies
+read into their targets, deferred readouts in order, deferred V gates, the rest of L, output reads, L^-1, V^-1.
+The readout coefficients come from the transpose sweep of L applied to the root reads (output reads ±1/2, centre
+scatter 1/21 - [i ∈ S]/2); their only odd denominator is PR #104's 21.
+
+## 3. What is checked (`complex_deferred.py`)
+
+- **A.** Matching size 8,966 and R = 44,918.
+- **B.** With zero scratch the compiled word computes every one of the 8,120 root values.
+- **C.** The deferred word, replayed over Z/(2^61 - 1) with arbitrary scratch and data (two seeds), restores every
+  role and adds exactly x_S to every target.
+- **D.** Exactly over F2: every role chain (start σ_u or 0, start frame, every gate, linked continuations, root
+  frame, F) is nested; every lifted and deferral frame is nondegenerate; every σ_u lies in its start frame and in
+  t_S^⊥ for each reached target; on every target the deferral frames are nested in readout order.
+- **E.** The one-child histogram from the explicit role chains has total rank W m - N + L = 109,450,358,336,
+  every child is below m = 576 (the largest is 574).
+
+`certificate.py` recomputes both moments exactly with PR #104's routines, the stopped bit saving
+(1 - 1/1000)·coarse + (1/1000)·384599/10^10, the finite bridge and the 47-constraint assembly.
+
+## 4. Endpoints, stage two and the bridge
+
+- *Endpoints.* A deferred auxiliary role starts at the gauge of σ_u and ends at the complementary gauge, so its
+  endpoint action is the identity shear on arbitrary inputs: the bit identity D_{I-P} D_P = D_I and its phase
+  analogue, the translated source C_{D_0} with sink C_I C_{D_0} of `notes/copied-centers-complex.tex` and
+  `notes/endpoint-gauge-complex.tex` (PR21/PR24). Its exterior residual has rank m - h + dim σ_u.
+- *Stage two.* As in Swapnil's round seven and PR #104's two-stage counts, stage two is the complement time
+  reversal of stage one with the same edge multiset. PR #97 replays the reflected ledger for the bit word; for the
+  complex deferred word this is stated here, not machine-checked.
+- *Bridge.* The larger children (bit 528 of 529, complex 574 of 576) raise the halving degrees to 367 and 200,
+  so the product-row stock becomes p^33000 (PR #104 used p^4000; PR29 p^47000). As in PR #104, the stock enters
+  only the row-product slack and the eventual cutoffs, not κ. The semantic induction 2B(m - r) ≥ s + E holds.
+
+## 5. Scope
+
+All of PR #104's inherited hypotheses remain: the opposite-bank factorization for every residual class in the
+finite lists (including the new gauged exteriors, deferral starts and target levels on both networks, and the
+binary one-child normal form on the complex side), atom streaming and the ordinary wrapper, the common exact grid,
+routing, recovery, the fixed-tape transfer and the analytic interfaces. The stage-two statement above is the one
+new written assumption for the complex network. No global optimality is claimed.
+
+## 6. Credits
+
+- **icekylinx**: PR #104's stopped product-ring interchange, opposite-bank factorization, rational centres and the
+  h = 24 complex producer used unchanged; PR #10/#18/#24/#32/#36 lineage.
+- **Swapnil Jain**: deferred readouts (design B), V leaves, lifted frames, late copies and the round-seven bit
+  witness used unchanged (https://github.com/Swapnil-jain/integer-mult-kappa, commit
+  741e7aa078392553815df7926ee17ac5e25a8c38).
+- **Zhihao Chen (jacklightChen)**: PR #97's integration of the deferred bit word and its reflected ledgers;
+  PR21/PR29 translated gauges and two-stage accounting.
+- **Aurel Prosz (Paureel)**: the two-stage topology and paid endpoint correction.
+- All earlier authors credited in PR #104's NOTICE and SOURCES.json, including Avi Eisenberg/ikeboy (PR #53, #62,
+  whose producer is the round-seven bit DAG), RaD/hipotures, Rohan Arun, eumemic, Dominik Scholz, Chafik
+  Boukhalfa, James Chang and Douglas Colkitt.
+
+The complex deferral construction, its checks and this certificate were prepared by Avi Eisenberg (ikeboy) with
+Anthropic Claude assistance.
diff --git a/research/deferred-stopped/README.md b/research/deferred-stopped/README.md
new file mode 100644
index 0000000000..a46910f4ed
--- /dev/null
+++ b/research/deferred-stopped/README.md
@@ -0,0 +1,37 @@
+# Deferred readouts on both stopped networks
+
+Conditional κ = 429239/5000000000 = **8.58478 × 10^-5** (+10.1% over PR #104's 7.79476 × 10^-5).
+
+PR #104's stopped product-ring interchange compiles every projector residual of rank r as one child of width r.
+Under that rule deferred readouts pay on both networks:
+
+- **bit**: Swapnil Jain's round-seven deferred word (h = 23), unchanged, gives a stopped saving of 1.2402 × 10^-4;
+- **complex**: PR #104's h = 24 network, with lifted binary frames and deferred readouts on 8,893 of its 44,918
+  roles, gives 214657/2500000000 = 8.58628 × 10^-5, which is now the binding side.
+
+See [PROOF.md](PROOF.md) for the construction, the checks and the inherited assumptions.
+
+## Reproduce
+
+From the repository root (standard-library Python 3; about two minutes):
+
+```sh
+python3 research/deferred-stopped/complex_deferred.py
+python3 research/deferred-stopped/bit_round7.py DIR
+python3 research/deferred-stopped/certificate.py
+```
+
+`DIR` holds Swapnil's two round-seven files, `witness_23.json.gz` and `deferred_23.json.gz`, for example
+`certificates/round7/` of https://github.com/Swapnil-jain/integer-mult-kappa at commit
+`741e7aa078392553815df7926ee17ac5e25a8c38`, or PR #97's copy in `research/deferred-signed/swapnil-round7/`.
+`bit_round7.py` checks both files against their SHA-256 pins. The three scripts write `complex-profile.json`,
+`bit-profile.json` and `certificate.json`.
+
+## Files
+
+| file | content |
+|---|---|
+| `complex_deferred.py` | complex DAG (PR #104 producer), matching, roles, lifted frames, deferral, replay and exact F2 checks |
+| `bit_round7.py` | one-child bit profile of the round-seven deferred word |
+| `certificate.py` | exact moments, stopped bit saving, finite bridge, 47-constraint assembly, κ |
+| `*-profile.json`, `certificate.json` | generated outputs |
diff --git a/research/deferred-stopped/bit-profile.json b/research/deferred-stopped/bit-profile.json
new file mode 100644
index 0000000000..36105e819a
--- /dev/null
+++ b/research/deferred-stopped/bit-profile.json
@@ -0,0 +1,69 @@
+{
+ "h": 23,
+ "v": 1771,
+ "R": 28866,
+ "m": 529,
+ "N": 3136441,
+ "W": 108516254,
+ "L": 1792252,
+ "total_rank": 57403754177,
+ "deficit": 1344189,
+ "maxchild": 528,
+ "deferred_slots": 11565,
+ "source": {
+  "repository": "https://github.com/Swapnil-jain/integer-mult-kappa",
+  "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
+  "sha256": {
+   "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588",
+   "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c"
+  }
+ },
+ "child_multiplicities": {
+  "1": 239511811,
+  "2": 238288050,
+  "3": 53377940,
+  "4": 46970462,
+  "5": 23632224,
+  "6": 7409864,
+  "7": 4105178,
+  "8": 5755750,
+  "9": 2082696,
+  "10": 878416,
+  "11": 1388464,
+  "12": 1080310,
+  "13": 945714,
+  "14": 226688,
+  "15": 2451064,
+  "16": 1508892,
+  "17": 4771074,
+  "18": 2149994,
+  "19": 7367360,
+  "20": 8182020,
+  "21": 1466388,
+  "22": 88550,
+  "484": 6272882,
+  "506": 61280142,
+  "507": 545468,
+  "508": 173558,
+  "509": 293986,
+  "510": 580888,
+  "511": 14168,
+  "512": 322322,
+  "513": 17710,
+  "514": 1129898,
+  "515": 127512,
+  "516": 410872,
+  "517": 99176,
+  "518": 1186570,
+  "519": 340032,
+  "520": 322322,
+  "521": 106260,
+  "522": 1583274,
+  "523": 626934,
+  "524": 2854852,
+  "525": 13711082,
+  "526": 4629394,
+  "527": 5653032,
+  "528": 6233920
+ }
+}
diff --git a/research/deferred-stopped/bit_round7.py b/research/deferred-stopped/bit_round7.py
new file mode 100644
index 0000000000..56f972277b
--- /dev/null
+++ b/research/deferred-stopped/bit_round7.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""One-child bit profile of Swapnil Jain's round-seven deferred word (h=23), under PR104's opposite-bank rule.
+
+Reads the two frozen round-seven data files (not vendored; pinned by SHA-256 below) from a directory given on
+the command line, e.g. a checkout of https://github.com/Swapnil-jain/integer-mult-kappa at
+741e7aa078392553815df7926ee17ac5e25a8c38 (certificates/round7/), or PR97's imported copy
+(research/deferred-signed/swapnil-round7/certificates/round7/). The frame dimensions are the ones recorded in
+the data file; Swapnil's check_frames.py re-derives each of them exactly and PR97 replays the word.
+
+Every projector residual of rank r is one child of width r (PR104, notes/stopped-product-factorization.tex):
+  each slot: its chain steps from the deferral frame sigma_u to F, and one exterior child m - (h - dim sigma_u);
+  each retained centre: one copied transform of width h-1;
+  each target y_T: its chain 0 -> deferred readout levels -> t_T^perp;  each data wire X_S: its chain of V frames;
+  each data pair: one data residual of width (h-1)^2 and one endpoint copy.
+Usage: python3 research/deferred-stopped/bit_round7.py DIR      (writes bit-profile.json next to this file)
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance. Apache-2.0.
+"""
+import gzip
+import hashlib
+import json
+import sys
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PINS = {'witness_23.json.gz': 'b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588',
+        'deferred_23.json.gz': '8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c'}
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def main(directory):
+    data = {}
+    for name, digest in PINS.items():
+        raw = (Path(directory) / name).read_bytes()
+        require(hashlib.sha256(raw).hexdigest() == digest, 'pinned hash of ' + name)
+        data[name] = json.loads(gzip.decompress(raw))
+    W, D = data['witness_23.json.gz'], data['deferred_23.json.gz']
+    h = D['h']; R = D['R']; trip = list(combinations(range(h), 3)); v = len(trip); m = h * h; N = v * v
+    tid = {T: i for i, T in enumerate(trip)}
+    args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()}
+    late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()}
+    ops = [tuple(o[:2]) + (tuple(o[2]),) if o[0] == 'fan' else tuple(o) for o in D['ops']]
+    hold, start = D['hold'], D['start']
+    out = {s: (c, tuple(T)) for s, c, T in D['out']}; ret = {s: c for s, c in D['ret']}
+    sigma = dict(zip(D['readout_order'], D['sigma'])); sel = set(D['readout_order'])
+    f = [0] * R
+    for s, B in sigma.items(): f[s] = len(B)
+    vstart = dict(zip(D['vleaf_slots'], D['vleaf_start']))
+    node_dims = {n: d for n, d in D['node_dims']}
+    late_dims = {(n, tuple(lt)): d for n, lt, d in D['late_dims']}
+    pivslot = {o[3]: o[1] for o in ops if o[0] == 'add'}
+
+    def start_key(s):
+        n0 = hold[s][0]
+        if args[n0] is None: return ('v', s)
+        st = start[s]; k = st[2] if len(st) > 2 else None; dec = late.get(n0)
+        if dec is None or k in dec[0]: return ('n', n0)
+        lt = dec[1]; return ('c', n0, tuple(lt[lt.index(k):]))
+
+    def chain(s):
+        ch = [('sigma', s) if s in sel else ('0',), start_key(s)]
+        for idx, n in enumerate(hold[s]):
+            if idx > 0: ch.append(('n', n))
+            if args[n] is not None and pivslot.get(n) == s and n in late:
+                lt = late[n][1]
+                for i in range(len(lt) - 1): ch.append(('c', n, tuple(lt[i:])))
+        if s in out: ch.append(('out',))
+        if s in ret: ch.append(('ret',))
+        ch.append(('F',)); return ch
+
+    def dim(key):
+        k = key[0]
+        if k == '0': return 0
+        if k == 'F': return h
+        if k in ('out', 'ret'): return h - 1
+        if k == 'n': return node_dims[key[1]]
+        if k == 'c': return late_dims[key[1], key[2]]
+        if k == 'sigma': return f[key[1]]
+        if k == 'v': return len(vstart[key[1]])
+        raise KeyError(key)
+
+    # garbage supports (transpose sweep) for the deferred levels on each target
+    cov = [set() for _ in range(R)]
+    for s, (c, T) in out.items(): cov[s].add(tid[T])
+    for s, c in ret.items(): cov[s].update(t for t, T in enumerate(trip) if c in T)
+    for o in reversed(ops):
+        if o[0] == 'add': cov[o[2]] |= cov[o[1]]
+        elif o[0] == 'fan':
+            for g in o[2]: cov[o[1]] |= cov[g]
+    levels = defaultdict(set)
+    for s in sel:
+        for t in cov[s]: levels[t].add(f[s])
+
+    z = Counter()
+    for s in range(R):
+        ds = [dim(k) for k in chain(s)]
+        require(all(b >= a for a, b in zip(ds, ds[1:])) and ds[-1] == h, 'monotone chain %d' % s)
+        for a, b in zip(ds, ds[1:]):
+            if b > a: z[b - a] += 2 * v
+        z[m - (h - f[s])] += 2 * v
+    z[h - 1] += 2 * v * h
+    for t in range(v):
+        ls = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ls, ls[1:]): z[b - a] += 2 * v
+    for n, us in D['xs_order']:
+        ds = [1] + [len(vstart[s]) for s in us] + [h]
+        ds = [d for i, d in enumerate(ds) if i == 0 or d != ds[i - 1]]
+        require(all(b > a for a, b in zip(ds, ds[1:])), 'data-wire chain')
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v
+    z[(h - 1) ** 2] += 2 * N
+    z[1] += N
+    Wb = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = Wb * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'bit rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    prof = dict(h=h, v=v, R=R, m=m, N=N, W=Wb, L=L, total_rank=s_, deficit=N - L, maxchild=max(z),
+                deferred_slots=len(sel), source=dict(repository='https://github.com/Swapnil-jain/integer-mult-kappa',
+                commit='741e7aa078392553815df7926ee17ac5e25a8c38', sha256=PINS),
+                child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'bit-profile.json').write_text(json.dumps(prof, indent=1) + '\n')
+    print('PASS bit: R=%d, deferred slots %d, maxchild %d, rank mass %d' % (R, len(sel), max(z), s_))
+
+
+if __name__ == '__main__':
+    main(sys.argv[1] if len(sys.argv) > 1 else '.')
diff --git a/research/deferred-stopped/certificate.json b/research/deferred-stopped/certificate.json
new file mode 100644
index 0000000000..00b4ec1e4a
--- /dev/null
+++ b/research/deferred-stopped/certificate.json
@@ -0,0 +1,175 @@
+{
+  "assembly": {
+    "absorption_gap": "4333030679469840929768124093977/62510732826606157597419467323285000000000",
+    "margins": {
+      "Gaussian_arithmetic": "1287976684152650437608480516106535343/10001717252256985215587114771725600000000",
+      "bulk_exposure": "214656535343/2500000000000000",
+      "compact_phase_layer": "1073282644516519913206535343/12502146565321231519483893464657",
+      "coordinate_movement": "214656535343/2500000000000000",
+      "dimension": "12499999875000000000000000000000/12502146565321231519483893464657",
+      "original_prefix": "107340766598217312552173018193464657/1250214656532123151948389346465700000000",
+      "scalar_work": "1717339754838650265883252241706535343/10001717252256985215587114771725600000000"
+    },
+    "minimum_margin": "1073282644516519913206535343/12502146565321231519483893464657",
+    "parameters": {
+      "C0": 2994465792675104952757349965746759652008778122322142627817848832,
+      "C1": 1,
+      "a_bit": "214656535343/2500000000000000",
+      "a_complex": "214657/2500000000",
+      "actual_bit_saving": "1240189553/10000000000000",
+      "alpha_squared_power": "1609986482874019698550000000/12502146565321231519483893464657",
+      "beta": "1/1000000",
+      "c": "1073282665982173018193464657/12500000000000000000000000000000",
+      "delta": "1/800000000",
+      "epsilon": "12499999875000000000000000000000/12502146565321231519483893464657",
+      "eta": "1/100000000",
+      "kappa": "429239/5000000000",
+      "lambda_": "249978534346680356535343/250000000000000000000000",
+      "lambda_prime": "124989267173447506535343/125000000000000000000000",
+      "q": "10732826552493464657/125000000000000000000000",
+      "sigma": "2499785343/2500000000",
+      "tau": "2499785343464657/2500000000000000"
+    },
+    "recurrence": {
+      "internal": "2499785343464657/2500000000000000",
+      "leaf": "2499785343214657/2500000000000000",
+      "reservations": "12498926717334017826981806535343/12500000000000000000000000000000"
+    },
+    "strict_constraints": {
+      "Gaussian_arithmetic_above_kappa": "10733781545608580555445025115159759483/250042931306424630389677869293140000000000",
+      "K_dominates_log": "107328265524934635837173447506535343/1250214656532123151948389346465700000000",
+      "K_geometry": "107340766598217312552173018193464657/1250214656532123151948389346465700000000",
+      "alpha_below_one": "12500536578838357499785343464657/12502146565321231519483893464657",
+      "alpha_below_one_fourth": "12495706619389735440689693464657/50008586261284926077935573858628",
+      "alpha_positive": "1609986482874019698550000000/12502146565321231519483893464657",
+      "artificial_boundary": "70014167468624421159203961426046506535343/10001717252256985215587114771725600000000",
+      "beta_below_one": "999999/1000000",
+      "beta_positive": "1/1000000",
+      "bit_positive": "214656535343/2500000000000000",
+      "bulk_exposure_above_kappa": "37035343/2500000000000000",
+      "c_below_one": "12498926717334017826981806535343/12500000000000000000000000000000",
+      "c_positive": "1073282665982173018193464657/12500000000000000000000000000000",
+      "cell_above_band": "12499463171161642500214656535343/25004293130642463038967786929314",
+      "compact_leaf": "12714656535343/125000000000000000000000",
+      "compact_phase_layer_above_kappa": "4333030679469840929768124093977/62510732826606157597419467323285000000000",
+      "compact_reservations": "10732826552493464657/12500000000000000000000000000000",
+      "complex_above_bit": "464657/2500000000000000",
+      "complex_below_one_over32": "77910343/2500000000",
+      "coordinate_movement_above_kappa": "37035343/2500000000000000",
+      "delta_below_one_eighth": "99999999/800000000",
+      "delta_positive": "1/800000000",
+      "dimension_above_kappa": "62494632966110448079903808253053124093977/62510732826606157597419467323285000000000",
+      "epsilon_below_one": "2146690321231519483893464657/12502146565321231519483893464657",
+      "epsilon_positive": "12499999875000000000000000000000/12502146565321231519483893464657",
+      "gamma_sublinear": "536703838357499785343464657/12502146565321231519483893464657",
+      "guard_width": "2146690321231519483893464657/12502146565321231519483893464657",
+      "lambda_above_internal": "214656535343/250000000000000000000000",
+      "lambda_above_sigma": "46680356535343/250000000000000000000000",
+      "lambda_above_tau": "214656535343/250000000000000000000000",
+      "lambda_prime_above_lambda": "214656535343/250000000000000000000000",
+      "lambda_prime_below_one": "10732826552493464657/125000000000000000000000",
+      "leaf_saving_above_bit": "1/10000000000",
+      "literal_scalar_guard": "402943837929348086347490890940",
+      "original_prefix_above_kappa": "629440358945531416903962797326827/62510732826606157597419467323285000000000",
+      "phase_boundary": "1287976684152650437608480516106535343/10001717252256985215587114771725600000000",
+      "phase_local": "1717339754838650265883252241706535343/10001717252256985215587114771725600000000",
+      "prime_interval_packing": "2146690321231519483893464657/12502146565321231519483893464657",
+      "q_below_internal": "214656535343/125000000000000000000000",
+      "q_below_leaf": "12714656535343/125000000000000000000000",
+      "q_below_reservations": "10732826552493464657/12500000000000000000000000000000",
+      "q_positive": "10732826552493464657/125000000000000000000000",
+      "record_suffix": "2146690321231519483893464657/12502146565321231519483893464657",
+      "row_product_gap": "21189/25",
+      "scalar_work_above_kappa": "21467858312758576262314318255159759483/250042931306424630389677869293140000000000",
+      "short_record_fallback": "31247316020033937757008189620029384607958127649/31255366413303078798709733661642500000000000000",
+      "small_field_exposure": "1073407676714999570686929314/12502146565321231519483893464657"
+    }
+  },
+  "base": "PR104 head 854ba7dca98651eab2050402384e1a7784534f0a",
+  "bit": {
+    "coarse_saving": "620523/5000000000",
+    "counts": {
+      "R": 28866,
+      "W": 108516254,
+      "deferred_slots": 11565,
+      "h": 23,
+      "m": 529,
+      "maxchild": 528,
+      "total_rank": 57403754177,
+      "v": 1771
+    },
+    "moment_gap": "210811394225115117568018038513239592855337768061996351784199300828041381607148420475711921673436778332750996651783152394205578153858435663243959795913385215868392831844509655226993164072062830500832781615792327068936897853818968534771730481866850519439187068953062899333771640996075361901014500735179763112430083120460814689994116646689670445286414265265018468311435502209195246240538069975559360544007937885404793780372701951022292660282948582656517071290400479729799954952580125532795274568021525151839594883237275569314958070368193662075730567130277424969924134425921633872848924585639423998410253779062359718371205767101510073996880454144801457072151080008705648366603197414406872289670642046369219405455128737300640897667220951127018547660455087533581513233999285275099394371781290865408274484542745086391849285198194905751058992419590161634431610100995441112613134240446609058758039909343152776920263419910572835208525277494067408376961456317/225678505065634612156474913616400633538202019254665477026878220214422133931127460164253533068001699469116755578965090566731480236912032281717920888140691998261537790258547549397061712443744511202265657747547567084090291301783866427704803156891369853685579999500594559805069402727752752227038426964007028952158078563045054314475625278140097385695241851533235641996467089273692960018822280793234080014352234618229252999217015923728814468917104222554059646947960375336061268431587018084270516494408656203498548153054913267707164839939006583338918817922618882667407408888179421052689449193499742148706302504238261936554897181289081072466758282367100305194479622149878636307463869297507337915811001244472279386614413535081936912313821531543735588465392499062010570720287729070905437080967709221039366272598541269000920375996285867953823816142239661027100714288630069735295241672325865922423925213948613346461034734632365263739073012128769510020000000000000000000000",
+    "stopped_saving": "1240189553/10000000000000"
+  },
+  "complex": {
+    "counts": {
+      "R": 44918,
+      "W": 190021216,
+      "deferred_roles": 8893,
+      "h": 24,
+      "m": 576,
+      "maxchild": 574,
+      "total_rank": 109450358336,
+      "v": 2024
+    },
+    "moment_gap": "88301284141942852349786272358911595120000420578552187561142071843083140835081165954598269953603159972525663693558868972689146185155411834676228714955329059432394778298100545891381302421394794303237626549527713862261276656942246868839949845155337175702657628564964600909613181267405991527055947538283019556031587158098318798755637269980823599499009552235241463891126134912516374961621697669023792194774305349574435245146518419799694178664643594108583316149754557776251922460810128999706784941841740847389653952435807583800062182165911883618980285421081541915510402227182490035361011191674206574792045268082637368945733008419490087505310344811508745393581449139761913559952494272322223808007836813175902382766819729906991789797044140283347524500198153199375890634896941931622814963367507249808681003857076806191317833919071452335898024170995119906284068985721462680222566297431686072161795896181548150927924607598240580782210064261914540490641568966426778147251/38567646380471990066846323528257836937304900418571665458488647335738525964839401421162181723482413035129710616602006898867035617030508100341220985070552885919489004210392740293654574535114858149929488168983623251817921624399761542587906296152985111009541140777876971526639421362325581838554355340456733298659299558103166845735904917705525545917977763439849396606704910357032922787157529838149607648539023383581492909176298859827611384377284000467495755998769776989475028380041994440168558308474514943668961421778304739693567885686710949313112429918061388147558166502860588101321963799112097800740240024875708063144007409056818296375362429458681617944441266401553094477220896677057264283075058375992973747610948147134524276528806960610780471475495100666041243705609728626257304886601414783085155723501606613314074979295066720153503485896357460909958593539684309751023373339104134081577618563270169710365314887102059427502899064010200818867353355720320000000000000000000000",
+    "saving": "214657/2500000000"
+  },
+  "finite_bridge": {
+    "bit_coarse": {
+      "W": 108516254,
+      "halving_degree": 367,
+      "m": 529,
+      "maxchild": 528,
+      "wire_bits": 27
+    },
+    "complex": {
+      "W": 190021216,
+      "halving_degree": 200,
+      "m": 576,
+      "maxchild": 574,
+      "s": 109450358336,
+      "scalar_group_upper": 1656684480,
+      "scalar_terms": [
+        {
+          "c": 45764,
+          "copied_center_extra_groups": 48,
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 408200,
+          "v": 2024
+        },
+        {
+          "c": 45764,
+          "copied_center_extra_groups": 48,
+          "h": 24,
+          "invocations": 2024,
+          "local_group_upper": 408200,
+          "v": 2024
+        }
+      ],
+      "wire_bits": 28
+    },
+    "ordinary_leaf_row_degree": 252,
+    "rows": {
+      "coefficient": 15761,
+      "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse",
+      "degree": 33000,
+      "degree_gap": "21189/25",
+      "suffix_slope": 132000
+    },
+    "semantic": {
+      "B": 403063477262941121553211537024,
+      "C0": 2994465792675104952757349965746759652008778122322142627817848832,
+      "C1": 1,
+      "E": 403063477262941121443761178688,
+      "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding",
+      "fixed_odd_divisor": 21,
+      "induction_gap": 1209190431788823364659634611072,
+      "literal_charge": 119639333593035096270287748,
+      "strict_literal_gap": 402943837929348086347490890940
+    }
+  },
+  "kappa": "429239/5000000000",
+  "status": "Conditional witness: deferred readouts on both networks of the stopped product-ring interchange"
+}
diff --git a/research/deferred-stopped/certificate.py b/research/deferred-stopped/certificate.py
new file mode 100644
index 0000000000..d7685100c1
--- /dev/null
+++ b/research/deferred-stopped/certificate.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Exact certificate: deferred readouts on both networks of PR104's stopped product-ring interchange.
+
+Inputs (regenerated by the two scripts in this directory):
+  bit-profile.json      Swapnil Jain's round-seven deferred bit word, one child per residual (bit_round7.py);
+  complex-profile.json  PR104's h=24 complex network with lifted binary frames and deferred readouts
+                        (complex_deferred.py).
+Computes, with PR104's inherited exact routines: the largest coarse bit saving and complex saving on the
+10^-10 grid with a contracting moment, the stopped ordinary bit saving (PR104 stopping at theta = 1/1000),
+the finite semantic/product-row bridge (row stock raised as the larger children require; it enters only the
+row slack and cutoffs) and the 47-constraint balanced assembly at the largest kappa on the 10^-10 grid.
+Usage: python3 research/deferred-stopped/certificate.py      (writes certificate.json)
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance. Apache-2.0.
+"""
+import json
+import sys
+from fractions import Fraction as Q
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+from partial_swap_network import moment                                    # noqa: E402
+from copied_centers_network import finite_bridge as copied_bridge          # noqa: E402
+from structured_bulk_assembly import assembly, js                          # noqa: E402
+
+GRID = 10**10
+ATOM = Q(1, 1000)                       # PR104 stopping exponent theta
+OLD = Q(384599, 10**10)                 # PR104 retained ordinary leaf saving
+PHASE_STOP = Q(1, 10**6)                # PR104 beta
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def profile(name):
+    p = json.loads((HERE / name).read_text())
+    p['child_multiplicities'] = {int(t): c for t, c in p['child_multiplicities'].items()}
+    z = p['child_multiplicities']
+    require(sum(t * c for t, c in z.items()) == p['total_rank'] == p['W'] * p['m'] - p['N'] + p['L'], name + ' rank mass')
+    require(all(0 < t < p['m'] and c > 0 for t, c in z.items()), name + ' children')
+    require(max(z) == p['maxchild'], name + ' maxchild')
+    return p
+
+
+def contracts(p, a):
+    try:
+        moment(p['m'], p['W'], p['child_multiplicities'], a, True)
+        return True
+    except SystemExit:
+        return False
+    except Exception:
+        return False
+
+
+def largest(p, lo, hi):
+    a, b = int(lo * GRID), int(hi * GRID)
+    require(contracts(p, Q(a, GRID)) and not contracts(p, Q(b, GRID)), 'bracket')
+    while b - a > 1:
+        mid = (a + b) // 2
+        a, b = (mid, b) if contracts(p, Q(mid, GRID)) else (a, mid)
+    return Q(a, GRID)
+
+
+def main():
+    bit, phase = profile('bit-profile.json'), profile('complex-profile.json')
+    coarse = largest(bit, Q(7, 10**5), Q(2, 10**4))
+    ac = largest(phase, Q(7, 10**5), Q(2, 10**4))
+    bm = moment(bit['m'], bit['W'], bit['child_multiplicities'], coarse, True)
+    cm = moment(phase['m'], phase['W'], phase['child_multiplicities'], ac, True)
+    require(not contracts(bit, coarse + Q(1, GRID)) and not contracts(phase, ac + Q(1, GRID)), 'next grid points rejected')
+    require(0 < OLD <= coarse < ATOM < 1, 'stopped-adapter exponents')
+    ab = (1 - ATOM) * coarse + ATOM * OLD
+    require(ATOM > ab, 'adapter toll subordinate to the stopped saving')
+    abit = min(ab, (1 - PHASE_STOP) * ac - Q(1, GRID))
+
+    row = dict(h=phase['h'], v=phase['v'], c=phase['additions'], central_disjoint=24)
+    previous = json.loads((ROOT / 'certificates' / 'copied-centers-network.json').read_text())
+    bridge = copied_bridge(bit, phase, [row, row])
+    old_bit = previous['finite_bridge']['bit']
+    old_degree = old_bit['halving_degree'] * old_bit['wire_bits']
+    require(old_degree == 252, 'inherited ordinary leaf row stock')
+    coarse_bridge = bridge.pop('bit'); cpx = bridge['complex']
+    coefficient = (coarse_bridge['halving_degree'] * coarse_bridge['wire_bits'] + old_degree +
+                   cpx['halving_degree'] * cpx['wire_bits'])
+    degree = 1000 * ((51 * coefficient) // 25000 + 1)
+    require(Q(degree) > Q(51 * coefficient, 25), 'product stock strictly sufficient')
+    bridge.update(bit_coarse=coarse_bridge, ordinary_leaf_row_degree=old_degree)
+    bridge['rows'] = dict(coefficient=coefficient, degree=degree, suffix_slope=4 * degree,
+                          degree_gap=Q(degree) - Q(51 * coefficient, 25),
+                          contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse')
+    bridge['semantic'].update(fixed_odd_divisor=21,
+                              exact_grid='One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding')
+
+    def accepted(k):
+        try:
+            assembly(abit, ac, bridge, Q(k, GRID), beta=PHASE_STOP)
+            return True
+        except AssertionError:
+            return False
+    lo, hi = int(Q(7, 10**5) * GRID), int(ac * GRID) + 1
+    require(accepted(lo) and not accepted(hi), 'kappa bracket')
+    while hi - lo > 1:
+        mid = (lo + hi) // 2
+        lo, hi = (mid, hi) if accepted(mid) else (lo, mid)
+    kappa = Q(lo, GRID)
+    assembled = assembly(abit, ac, bridge, kappa, beta=PHASE_STOP)
+    require(not accepted(lo + 1), 'next kappa grid point rejected')
+    require(len(assembled['strict_constraints']) == 47 and len(assembled['margins']) == 7, 'complete assembly')
+    assembled['parameters']['actual_bit_saving'] = ab
+    result = dict(status='Conditional witness: deferred readouts on both networks of the stopped product-ring interchange',
+                  kappa=kappa, bit=dict(coarse_saving=coarse, stopped_saving=ab, moment_gap=bm['strict_gap'],
+                                        counts={k: bit[k] for k in ('h', 'v', 'R', 'm', 'W', 'total_rank', 'maxchild', 'deferred_slots')}),
+                  complex=dict(saving=ac, moment_gap=cm['strict_gap'],
+                               counts={k: phase[k] for k in ('h', 'v', 'R', 'm', 'W', 'total_rank', 'maxchild', 'deferred_roles')}),
+                  finite_bridge=bridge, assembly=assembled,
+                  base='PR104 head 854ba7dca98651eab2050402384e1a7784534f0a')
+    (HERE / 'certificate.json').write_text(json.dumps(js(result), indent=2, sort_keys=True) + '\n')
+    print('PASS kappa = %s = %.10e' % (kappa, float(kappa)))
+    print('coarse bit saving %s, stopped %s, complex saving %s' % (coarse, ab, ac))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/deferred-stopped/complex-profile.json b/research/deferred-stopped/complex-profile.json
new file mode 100644
index 0000000000..400e10fbbe
--- /dev/null
+++ b/research/deferred-stopped/complex-profile.json
@@ -0,0 +1,99 @@
+{
+ "h": 24,
+ "v": 2024,
+ "additions": 45764,
+ "roots": 8120,
+ "links": 8966,
+ "R": 44918,
+ "m": 576,
+ "N": 4096576,
+ "W": 190021216,
+ "L": 2234496,
+ "total_rank": 109450358336,
+ "deficit": 1862080,
+ "maxchild": 574,
+ "phase_one_ops": 17811,
+ "phase_one_roles": 15082,
+ "deferred_roles": 8893,
+ "deferred_dims": {
+  "1": 6,
+  "2": 206,
+  "4": 259,
+  "5": 1,
+  "6": 680,
+  "7": 1,
+  "8": 542,
+  "9": 8,
+  "10": 681,
+  "11": 40,
+  "12": 725,
+  "13": 133,
+  "14": 717,
+  "15": 143,
+  "16": 614,
+  "17": 233,
+  "18": 1007,
+  "19": 526,
+  "20": 612,
+  "21": 237,
+  "22": 1522
+ },
+ "lifted_additions": 20234,
+ "replay": {
+  "seeds": [
+   1,
+   2
+  ],
+  "scratch_restored": true,
+  "y_plus_x": true,
+  "field": "Z/(2^61-1)"
+ },
+ "child_multiplicities": {
+  "1": 242993344,
+  "2": 116792896,
+  "3": 37808320,
+  "4": 59355824,
+  "5": 46325312,
+  "6": 32234224,
+  "7": 19661136,
+  "8": 30449056,
+  "9": 9715200,
+  "10": 21725616,
+  "11": 6861360,
+  "12": 20555744,
+  "13": 5145008,
+  "14": 21919920,
+  "15": 4048000,
+  "16": 18390064,
+  "17": 8055520,
+  "18": 17013744,
+  "19": 8739632,
+  "20": 9460176,
+  "21": 1716352,
+  "22": 8937984,
+  "23": 8290304,
+  "529": 8193152,
+  "552": 145829200,
+  "553": 24288,
+  "554": 833888,
+  "556": 1048432,
+  "557": 4048,
+  "558": 2752640,
+  "559": 4048,
+  "560": 2194016,
+  "561": 32384,
+  "562": 2756688,
+  "563": 161920,
+  "564": 2934800,
+  "565": 538384,
+  "566": 2902416,
+  "567": 578864,
+  "568": 2485472,
+  "569": 943184,
+  "570": 4076336,
+  "571": 2129248,
+  "572": 2477376,
+  "573": 959376,
+  "574": 6161056
+ }
+}
diff --git a/research/deferred-stopped/complex_deferred.py b/research/deferred-stopped/complex_deferred.py
new file mode 100644
index 0000000000..9eb572013c
--- /dev/null
+++ b/research/deferred-stopped/complex_deferred.py
@@ -0,0 +1,458 @@
+#!/usr/bin/env python3
+"""Deferred readouts on PR104's h=24 complex network, with lifted binary frames.
+
+Builds PR104's aligned rational-center DAG (scripts/stopped_product/complex.py, unchanged), a maximum carrier
+matching under the inherited matcher's adjacency rules, an explicit role compile, lifted binary frames,
+phase one, deferred readout frames and the stage-one word. Checks:
+  A. the matching has the inherited size (8966) and the role count R = c + q - links = 44918;
+  B. the compiled word computes every root value (zero scratch, random data, mod p);
+  C. replay of the deferred word with arbitrary scratch and data (two seeds, mod p): every role restored and
+     every target y_S receives exactly x_S;
+  D. exact F2 frame facts: lifted frames nondegenerate and nested along every role chain (gates, links, copies,
+     root frames), every deferral frame inside its start frame and inside t_S^perp for every reached target,
+     nondegenerate, and nested on every target in readout order;
+  E. the one-child histogram from the explicit role chains, with total rank W m - N + L.
+Writes complex-profile.json next to this file.  Usage: python3 research/deferred-stopped/complex_deferred.py
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance. Apache-2.0.
+"""
+import array
+import json
+import random
+import struct
+import sys
+import tempfile
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(ROOT / 'scripts'))
+from stopped_product.complex import build  # noqa: E402  (PR104 producer, unchanged)
+
+P = (1 << 61) - 1
+
+
+def require(ok, msg):
+    if not ok:
+        raise SystemExit('FAIL: ' + msg)
+
+
+def load(prefix):
+    def rd(fh, typ, cnt):
+        a = array.array(typ); a.fromfile(fh, cnt); return a
+    with open(str(prefix) + '.bin', 'rb') as f:
+        h, v, n, q = struct.unpack('<4I', f.read(16))
+        flat = rd(f, 'I', 2 * n); core = rd(f, 'Q', n); cover = rd(f, 'Q', n)
+        roots = rd(f, 'I', q); kind = rd(f, 'I', q); active = rd(f, 'B', n)
+    with open(str(prefix) + '.labels', 'rb') as f:
+        ranks = rd(f, 'I', n); types = rd(f, 'B', n)
+    args = [(flat[2 * i], flat[2 * i + 1]) for i in range(n)]
+    return h, v, n, q, args, core, cover, roots, kind, active, ranks, types
+
+
+# ---------------------------------------------------------------- F2 linear algebra on bit vectors
+def dot(a, b): return bin(a & b).count('1') & 1
+
+
+def reduce(basis):
+    rows = []; piv = []
+    for vec in basis:
+        for p, r in zip(piv, rows):
+            if vec >> p & 1: vec ^= r
+        if vec:
+            p = vec.bit_length() - 1
+            for i in range(len(rows)):
+                if rows[i] >> p & 1: rows[i] ^= vec
+            rows.append(vec); piv.append(p)
+    return rows
+
+
+def kernel(funcs, h):
+    K = reduce(funcs); piv = [r.bit_length() - 1 for r in K]
+    out = []
+    for c in (i for i in range(h) if i not in piv):
+        vec = 1 << c
+        for r, p in zip(K, piv):
+            if r >> c & 1: vec |= 1 << p
+        out.append(vec)
+    return out
+
+
+def restrict(basis, funcs):
+    B = reduce(basis)
+    for f in funcs:
+        if not B: break
+        vals = [dot(b, f) for b in B]
+        if not any(vals): continue
+        k = vals.index(1); pv = B[k]
+        B = [b ^ pv if val else b for b, val in zip(B, vals)]; B.pop(k)
+    return reduce(B)
+
+
+def contains(A, B):
+    RB = reduce(B)
+    return len(reduce(RB + list(A))) == len(RB)
+
+
+def cap(A, B):
+    A = reduce(A); B = reduce(B)
+    if not A or not B: return []
+    ker = []; red = []
+    for i, vec in enumerate(A + B):
+        tag = 1 << i
+        for rv, rt in red:
+            if vec >> (rv.bit_length() - 1) & 1: vec ^= rv; tag ^= rt
+        if vec: red.append((vec, tag))
+        else:
+            comb_ = 0
+            for k in range(len(A)):
+                if tag >> k & 1: comb_ ^= A[k]
+            ker.append(comb_)
+    return reduce(ker)
+
+
+def nondeg(B):
+    B = reduce(B); k = len(B)
+    if not k: return True
+    M = [sum(dot(B[i], B[j]) << j for j in range(k)) for i in range(k)]
+    return len(reduce(M)) == k
+
+
+def hopcroft_karp(left, adj):
+    """maximum bipartite matching; adj[x] = sorted list of right vertices."""
+    INF = 1 << 60
+    mate_l = {x: None for x in left}; mate_r = {}
+    while True:
+        dist = {}; queue = []
+        for x in left:
+            if mate_l[x] is None: dist[x] = 0; queue.append(x)
+            else: dist[x] = INF
+        found = INF; head = 0
+        while head < len(queue):
+            x = queue[head]; head += 1
+            if dist[x] >= found: continue
+            for r in adj[x]:
+                y = mate_r.get(r)
+                if y is None: found = min(found, dist[x] + 1)
+                elif dist[y] == INF: dist[y] = dist[x] + 1; queue.append(y)
+        if found == INF: break
+        gained = 0
+        for x0 in left:
+            if mate_l[x0] is not None: continue
+            stack = [(x0, iter(adj[x0]))]; path = []
+            while stack:
+                x, it = stack[-1]
+                advanced = False
+                for r in it:
+                    y = mate_r.get(r)
+                    if (y is None and dist[x] + 1 == found) or (y is not None and dist[y] == dist[x] + 1):
+                        path.append((x, r))
+                        if y is None:
+                            for xx, rr in path: mate_l[xx] = rr; mate_r[rr] = xx
+                            gained += 1; stack = []; break
+                        stack.append((y, iter(adj[y]))); advanced = True; break
+                else:
+                    dist[x] = INF; stack.pop()
+                    if path: path.pop()
+                    continue
+                if not advanced: break
+        if not gained: break
+    return mate_l
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix='deferred-stopped-') as work:
+        prefix = Path(work) / 'complex'
+        build(24, prefix, central_disjoint=24)
+        h, v, n, q, args, core, cover, roots, kind, active, ranks, types = load(prefix)
+    trip = list(combinations(range(h), 3)); require(len(trip) == v, 'triple count')
+    m = h * h; N = v * v; FULL = (1 << h) - 1
+    tmask = [sum(1 << p for p in T) for T in trip]
+    tid = {T: i for i, T in enumerate(trip)}
+
+    # ------------------------------------------------------------ uses and matching (inherited adjacency)
+    degree = [0] * n; uses = defaultdict(list); c_add = 0
+    for x in range(1, n):
+        if active[x] and args[x][0]:
+            c_add += 1
+            for pos, y in enumerate(args[x]): degree[y] += 1; uses[y].append(('gate', x, pos))
+    for j, x in enumerate(roots): degree[x] += 1; uses[x].append(('root', j))
+    def unode(u): return roots[u[1]] if u[0] == 'root' else u[1]
+    def before(x, u):
+        y = unode(u)
+        return (ranks[x], x) < (ranks[y], (n + u[1]) if u[0] == 'root' else y)
+    def incl(x, y):
+        tx, ty = types[x], types[y]
+        if tx == 1 and ty == 1: return not (core[y] & ~core[x]) and not (cover[x] & ~cover[y])
+        if tx in (1, 2) and ty == 2: return not (cover[x] & ~cover[y])
+        if tx == 1 and ty == 3: return bool(core[x] & core[y])
+        if tx == 2 and ty == 3: return not (cover[x] & ~core[y])
+        if tx == 3 and ty == 2: return cover[y] == FULL
+        if tx == 3 and ty == 3: return core[x] == core[y]
+        return False
+    left = []; adj = {}
+    for x in range(1, n):
+        if not (active[x] and args[x][0]): continue
+        rs = sorted({(y, k) for y in args[x] for k, u in enumerate(uses[y]) if before(x, u) and incl(x, unode(u))})
+        if rs: left.append(x); adj[x] = rs
+    mate = hopcroft_karp(left, adj)
+    links = {x: r for x, r in mate.items() if r is not None}
+    R = c_add + q - len(links)
+    require(len(links) == 8966 and R == 44918, 'matching size %d, roles %d' % (len(links), R))
+    linked_use = {(y, k): x for x, (y, k) in links.items()}
+
+    # ------------------------------------------------------------ root targets, read coefficients, root functionals
+    target = [None] * q
+    for j in range(v): target[j] = j
+    idx = v
+    for a, b in combinations(range(h), 2):
+        others = sorted((i for i in range(h) if i not in (a, b)), key=lambda i: ((i ^ 1) in (a, b), i))
+        for i in others: target[idx] = tid[tuple(sorted((a, b, i)))]; idx += 1
+    centre_of = {}
+    for j in range(q):
+        if kind[j]:
+            miss = FULL & ~cover[roots[j]]; require(bin(miss).count('1') == 1, 'centre cover')
+            centre_of[j] = miss.bit_length() - 1
+    require(idx + len(centre_of) == q, 'root order')
+    rootfun = [(1 << centre_of[j]) if kind[j] else tmask[target[j]] for j in range(q)]
+
+    # ------------------------------------------------------------ lifted binary frames, monotone
+    succ = defaultdict(set); droot = defaultdict(set)
+    for x in range(1, n):
+        if not active[x]: continue
+        for k, u in enumerate(uses[x]):
+            if (x, k) in linked_use: continue
+            (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    for x, (y, k) in links.items():
+        u = uses[y][k]; (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1]))
+    order_desc = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x), reverse=True)
+    K = {}
+    for x in order_desc:
+        rows = [rootfun[j] for j in droot[x]]
+        for t in succ[x]: rows += K[t]
+        K[x] = reduce(rows)
+    def envelope(x):
+        if not args[x][0]: return [tmask[x - 1]]
+        if types[x] == 2: return [1 << i for i in range(h) if cover[x] >> i & 1]
+        require(types[x] == 1, 'only ordinary and common-pair labels occur')
+        ks = [i for i in range(h) if (cover[x] & ~core[x]) >> i & 1]
+        require(len(ks) == ranks[x], 'common-pair support')
+        return [core[x] | (1 << k) for k in ks]
+    U = {}
+    for x in range(1, n):
+        if not active[x]: continue
+        if not args[x][0]: U[x] = envelope(x); continue
+        B = kernel(K[x], h)
+        require(contains(envelope(x), B), 'label outside lifted frame')
+        U[x] = B if nondeg(B) else envelope(x)
+    changed = True
+    while changed:
+        changed = False
+        for x in order_desc:
+            if args[x][0] and any(not contains(U[x], U[t]) for t in succ[x]):
+                env = envelope(x)
+                if len(reduce(U[x])) != len(reduce(env)) or not contains(U[x], env): U[x] = env; changed = True
+    dimU = {x: len(reduce(B)) for x, B in U.items()}
+
+    # ------------------------------------------------------------ explicit role compile
+    order = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x))
+    holds = []; first_node = []; ops = []; edge_key = {}; role_root = {}
+    def new_role(node): holds.append([node]); first_node.append(node); return len(holds) - 1
+    def serve(s, y, k):
+        u = uses[y][k]
+        if u[0] == 'gate': edge_key[(y, k)] = s
+        else: role_root[s] = u[1]
+    for x in order:
+        free = [k for k in range(len(uses[x])) if (x, k) not in linked_use]
+        if not args[x][0]:
+            for k in free:
+                s = new_role(x); ops.append(('src', s, x)); serve(s, x, k)
+            continue
+        a, b = args[x]
+        ka = next(k for k, u in enumerate(uses[a]) if u == ('gate', x, 0))
+        kb = next(k for k, u in enumerate(uses[b]) if u == ('gate', x, 1))
+        sa, sb = edge_key.pop((a, ka)), edge_key.pop((b, kb))
+        if x in links and links[x][0] == a: sa, sb = sb, sa
+        piv, oth = sa, sb
+        ops.append(('add', piv, oth, x)); holds[piv].append(x); holds[oth].append(x)
+        if x in links: serve(oth, *links[x])
+        require(free, 'every use linked at node %d' % x)
+        serve(piv, x, free[0])
+        for k in free[1:]:
+            f = new_role(x); ops.append(('copy', piv, f, x)); serve(f, x, k)
+    require(not edge_key and len(holds) == R, 'compile')
+    Rr = R
+
+    # ------------------------------------------------------------ B. the word computes every root value
+    rng = random.Random(20261008)
+    xs = [rng.randrange(P) for _ in range(v)]
+    val = [0] * n
+    for i in range(v): val[i + 1] = xs[i]
+    for x in order:
+        if args[x][0]: val[x] = (val[args[x][0]] + val[args[x][1]]) % P
+    leaf_of = {s: first_node[s] for s in range(Rr) if not args[first_node[s]][0]}
+    a_ = [0] * Rr
+    for s, leaf in leaf_of.items(): a_[s] = xs[leaf - 1]
+    for o in ops:
+        if o[0] == 'add': a_[o[1]] = (a_[o[1]] + a_[o[2]]) % P
+        elif o[0] == 'copy': a_[o[2]] = (a_[o[2]] + a_[o[1]]) % P
+    require(all(a_[s] == val[roots[j]] for s, j in role_root.items()), 'root values')
+
+    # ------------------------------------------------------------ phase one and garbage reach
+    def touch(o): return [o[1], o[2]] if o[0] in ('add', 'copy') else []
+    prev = {}; pred = defaultdict(list); last = {}
+    for i, o in enumerate(ops):
+        for s in touch(o):
+            if s in prev: pred[i].append(prev[s])
+            prev[s] = i; last[s] = i
+    centre_roles = [s for s, j in role_root.items() if kind[j]]
+    Anc = set(); st = [last[s] for s in centre_roles]
+    while st:
+        i = st.pop()
+        if i not in Anc: Anc.add(i); st.extend(pred[i])
+    touched = set(centre_roles)
+    for i in Anc: touched.update(touch(ops[i]))
+    require(all(last[s] in Anc for s in centre_roles), 'centres complete in phase one')
+    reach = [set() for _ in range(Rr)]; reach_all = [False] * Rr
+    for s, j in role_root.items():
+        if kind[j]: reach_all[s] = True
+        else: reach[s].add(target[j])
+    for o in reversed(ops):
+        if o[0] == 'add': reach[o[2]] |= reach[o[1]]; reach_all[o[2]] = reach_all[o[2]] or reach_all[o[1]]
+        elif o[0] == 'copy': reach[o[1]] |= reach[o[2]]; reach_all[o[1]] = reach_all[o[1]] or reach_all[o[2]]
+
+    # ------------------------------------------------------------ deferral frames, insertion nesting
+    def F0(s): return U[first_node[s]]
+    cand = {}
+    for s in range(Rr):
+        if s in touched or reach_all[s]: continue
+        S_ = restrict(F0(s), [tmask[t] for t in reach[s]])
+        if S_ and nondeg(S_): cand[s] = S_
+    byT = defaultdict(list); placed = {}
+    for s in sorted(cand, key=lambda s: (-len(cand[s]), s)):
+        X = cand[s]; changed = True
+        while changed and X:
+            changed = False
+            for t in reach[s]:
+                for w in byT[t]:
+                    B = placed[w]
+                    if (len(B) >= len(X) and not contains(X, B)) or (len(B) < len(X) and not contains(B, X)):
+                        X = cap(X, B); changed = True
+                    if not X: break
+                if not X: break
+        if X and nondeg(X):
+            placed[s] = X
+            for t in reach[s]: byT[t].append(s)
+    deferred = sorted(placed, key=lambda s: (len(placed[s]), s)); dset = set(deferred)
+
+    # ------------------------------------------------------------ C. replay with arbitrary scratch and data
+    inv = lambda a: pow(a % P, P - 2, P); HALF = inv(2); I21 = inv(21)
+    cvec = [None] * Rr; dpart = [dict() for _ in range(Rr)]
+    for s, j in role_root.items():
+        if kind[j]: c = [0] * h; c[centre_of[j]] = 1; cvec[s] = c
+        else: dpart[s][target[j]] = (P - HALF) if j >= v else HALF
+    seed_c = {s: (None if cvec[s] is None else list(cvec[s])) for s in role_root}
+    seed_d = {s: dict(dpart[s]) for s in role_root}
+    def addc(dst, src):
+        if cvec[src] is not None:
+            cvec[dst] = list(cvec[src]) if cvec[dst] is None else [(p + q_) % P for p, q_ in zip(cvec[dst], cvec[src])]
+        for t, c in dpart[src].items(): dpart[dst][t] = (dpart[dst].get(t, 0) + c) % P
+    for o in reversed(ops):
+        if o[0] == 'add': addc(o[2], o[1])
+        elif o[0] == 'copy': addc(o[1], o[2])
+    scatter = [[(I21 - (HALF if i in trip[t] else 0)) % P for t in range(v)] for i in range(h)]
+    def readout(y, s, value, sign, seed=False):
+        cv = seed_c[s] if seed else cvec[s]; dp = seed_d[s] if seed else dpart[s]
+        if cv is not None:
+            for i, ci in enumerate(cv):
+                if ci:
+                    f = sign * ci * value % P; row = scatter[i]
+                    for t in range(v): y[t] = (y[t] + f * row[t]) % P
+        for t, c in dp.items(): y[t] = (y[t] + sign * c * value) % P
+    phase1 = sorted(Anc); rest = [i for i in range(len(ops)) if i not in Anc]
+    def replay(seed):
+        rng = random.Random(seed)
+        x = [rng.randrange(P) for _ in range(v)]; z = [rng.randrange(P) for _ in range(Rr)]
+        y0 = [rng.randrange(P) for _ in range(v)]; a = list(z); y = list(y0)
+        for s in range(Rr):
+            if s not in dset: readout(y, s, a[s], -1)
+        for s, leaf in leaf_of.items():
+            if s not in dset: a[s] = (a[s] + x[leaf - 1]) % P
+        def run(i, sign=1):
+            o = ops[i]
+            if o[0] == 'add': a[o[1]] = (a[o[1]] + sign * a[o[2]]) % P
+            elif o[0] == 'copy': a[o[2]] = (a[o[2]] + sign * a[o[1]]) % P
+        for i in phase1: run(i)
+        for s in centre_roles: readout(y, s, a[s], +1, True)
+        for s in deferred: readout(y, s, a[s], -1)
+        for s in deferred:
+            if s in leaf_of: a[s] = (a[s] + x[leaf_of[s] - 1]) % P
+        for i in rest: run(i)
+        for s, j in role_root.items():
+            if not kind[j]: readout(y, s, a[s], +1, True)
+        for i in reversed(range(len(ops))): run(i, -1)
+        for s, leaf in leaf_of.items(): a[s] = (a[s] - x[leaf - 1]) % P
+        return a == z, all((y[t] - y0[t] - x[t]) % P == 0 for t in range(v))
+    rep = [replay(seed) for seed in (1, 2)]
+    require(all(r == (True, True) for r in rep), 'replay %s' % rep)
+
+    # ------------------------------------------------------------ D. exact F2 frame facts
+    root_frame = {}
+    for s, j in role_root.items():
+        root_frame[s] = [1 << i for i in range(h) if i != centre_of[j]] if kind[j] else kernel([tmask[target[j]]], h)
+    FULLB = [1 << i for i in range(h)]
+    chain_dims = []
+    for s in range(Rr):
+        seq = [placed.get(s, []), F0(s)] + [U[x] for x in holds[s][1:]]
+        if s in root_frame: seq.append(root_frame[s])
+        seq.append(FULLB)
+        require(all(contains(A, B) for A, B in zip(seq, seq[1:])), 'role chain nesting %d' % s)
+        require(all(nondeg(B) for B in seq[1:-1] if B), 'degenerate frame on role %d' % s)
+        chain_dims.append([len(reduce(B)) for B in seq])
+    for s, X in placed.items():
+        require(contains(X, F0(s)) and nondeg(X), 'deferral frame %d' % s)
+        require(all(not any(dot(xv, tmask[t]) for xv in X) for t in reach[s]), 'target frame %d' % s)
+    byT2 = defaultdict(list)
+    for s in deferred:
+        for t in reach[s]: byT2[t].append(s)
+    for t, ss in byT2.items():
+        ss.sort(key=lambda s: (len(placed[s]), s))
+        require(all(contains(placed[p], placed[q_]) for p, q_ in zip(ss, ss[1:])), 'target chain %d' % t)
+
+    # ------------------------------------------------------------ E. one-child histogram
+    z = Counter()
+    for s in range(Rr):
+        ds = chain_dims[s]
+        for a, b in zip(ds[:-1], ds[1:-1]):
+            if b > a: z[b - a] += 2 * v
+        lastd = ds[-2]
+        if s in role_root and kind[role_root[s]]: z[h - 1] += 2 * v           # copied centre transform
+        z[h - lastd] += 2 * v                                                  # final growth to F
+        z[m - h + ds[0]] += 2 * v                                              # exterior, gauged by sigma
+    levels = defaultdict(set)
+    for s in deferred:
+        for t in reach[s]: levels[t].add(len(placed[s]))
+    for t in range(v):
+        ds = sorted(levels[t] | {0, h - 1})
+        for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v                       # target fronts
+    z[h - 1] += 2 * N                                                          # data-wire fronts
+    z[(h - 1) ** 2] += 2 * N                                                   # data macros
+    z[1] += N                                                                  # endpoint copies
+    z.pop(0, None)
+    W = 2 * N + 2 * v * R; L = 2 * v * h * (h - 1); s_ = W * m - N + L
+    require(sum(t * c for t, c in z.items()) == s_, 'complex rank mass')
+    require(all(0 < t < m for t in z), 'children below m')
+    out = dict(h=h, v=v, additions=c_add, roots=q, links=len(links), R=R, m=m, N=N, W=W, L=L, total_rank=s_,
+               deficit=N - L, maxchild=max(z), phase_one_ops=len(Anc), phase_one_roles=len(touched),
+               deferred_roles=len(deferred),
+               deferred_dims=dict(sorted(Counter(len(X) for X in placed.values()).items())),
+               lifted_additions=sum(1 for x in U if args[x][0] and dimU[x] > ranks[x]),
+               replay=dict(seeds=[1, 2], scratch_restored=True, y_plus_x=True, field='Z/(2^61-1)'),
+               child_multiplicities=dict(sorted(z.items())))
+    (HERE / 'complex-profile.json').write_text(json.dumps(out, indent=1) + '\n')
+    print('PASS complex: R=%d, deferred roles %d, maxchild %d, rank mass %d' % (R, len(deferred), max(z), s_))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/joint-dual/SOURCE.json b/research/joint-dual/SOURCE.json
index 80c0f29dc4..a119bae377 100644
--- a/research/joint-dual/SOURCE.json
+++ b/research/joint-dual/SOURCE.json
@@ -3,9 +3,9 @@
   "base_pr57_commit": "cd350f76c9bc01489ec83568bded532cb69be938",
   "base_pr58_commit": "bc2f7ed4c20dc18898305ab17165c0c995cbb804",
   "files": {
-    "Makefile": "97620e0205736d9c0fce736e8ac6ab67f8ed0e490c381f6cac152cc6a003dca7",
-    "NOTICE": "1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f",
-    "README.md": "fd92de31aece76b1f5ff897e6e0dbc38dd3bf67c140579bbcb03a1a11a792668",
+    "Makefile": "0bd8071c6a4899b9e6975b53690069b4ffc70ac3514c019485b59f02ed994a6b",
+    "NOTICE": "46b84a2254d554c8adbe67ddaf33640e1b99e31168a1d90305d470e4fdab8e23",
+    "README.md": "083799d50375b5a16bd5af0eb1b0e4f630a6d05b414fe7010bc266206d9eda11",
     "certificates/joint-dual-compiler.json": "516c4d85158553dabd0a98216a064b2a7397957a9d5dd0df1d6e5aec53a4e805",
     "certificates/joint-dual-profiles-23.json": "159fa8fee175fc1d24f63e72d3c2f1dc9f4fcd78b938c5e7d2f735fd0fd37209",
     "certificates/joint-dual-profiles-25.json": "8d190ce42d097e828c5756918c52f2963df576cf4c6600b0fc7f2b7fdb6ad223",
diff --git a/scripts/stopped_product/README.md b/scripts/stopped_product/README.md
new file mode 100644
index 0000000000..6c18be051f
--- /dev/null
+++ b/scripts/stopped_product/README.md
@@ -0,0 +1,36 @@
+# Selected rational-center producer
+
+Run from the repository root:
+
+```sh
+python3 scripts/stopped_product_producer.py --output /tmp/stopped-product-producers.json
+```
+
+Only the new aligned complex producer at h=24 is rebuilt. It retains all
+24 disjoint-point sums and decodes the total by exact division by21. The
+pair-star input order is aligned with global pairs. Its generator adapts
+`structured_bulk.complex`, preserving exact support, output orthogonality,
+binary frame nesting and nondegeneracy checks. Rational decoder and scatter
+coefficients are checked with `Fraction`; their only odd denominator is21.
+The unchanged deterministic matcher compares every count and histogram
+entry against `stopped-product-complex-input.json`.
+
+The h23 bit record is compared with the preceding validated copied-center
+input. No old bit DAG, matching, or corner is regenerated. Both copied-center
+histogram transformations reuse the established exact rank-mass checker.
+
+All DAGs, labels and the compiled matcher are temporary by default;
+`--work-dir` retains them. Python assertions must be enabled. Standard-library
+Python and a C++17 compiler suffice. No binary archive is an input.
+
+The odd-grid extension is a written recursive invariant, not a claim proved
+by the finite scalar tests. With dyadic root inputs, K=G(D+1) supplies enough
+odd-divisor reserve along the active chain. A completed child preserves its
+incoming odd valuation; it does not generally make rational child inputs
+dyadic. Only the completed outer dyadic operator restores the original
+dyadic grid. No child return is rounded.
+
+Copyright 2026 icekylinx, Apache-2.0. New selected alignment, rational centers
+and integration were prepared with OpenAI GPT-6 Astra/Codex assistance.
+Underlying paired producers and deterministic carrier matching retain the
+previous contributors' attribution in `NOTICE` and `SOURCES.json`.
diff --git a/scripts/stopped_product/__init__.py b/scripts/stopped_product/__init__.py
new file mode 100644
index 0000000000..f7a6e90661
--- /dev/null
+++ b/scripts/stopped_product/__init__.py
@@ -0,0 +1 @@
+"""Selected stopped-product inputs and rational producer; icekylinx, 2026."""
diff --git a/scripts/stopped_product/complex.py b/scripts/stopped_product/complex.py
new file mode 100644
index 0000000000..ef1af25507
--- /dev/null
+++ b/scripts/stopped_product/complex.py
@@ -0,0 +1,228 @@
+"""Selected aligned rational-center producer, h=24 with all centers disjoint.
+
+Copyright 2026 icekylinx, Apache-2.0. AI-assisted adaptation of the research
+round-five handoff, using the credited retained PairedTriple circuit; see NOTICE.
+Adapted from structured_bulk.complex: align pair-star inputs and permit the
+fixed rational divisor21; retain all exact support/frame/scalar checks.
+
+Builds a concrete scalar addition DAG, its nondegenerate binary frames, and
+the unmixed carrier histogram. No historical audit suite is invoked.
+"""
+import json, struct, array
+from itertools import combinations
+from pathlib import Path
+from partial_swap.binary import write_array
+from paired_triple_circuit import PairedTriple
+
+def build(h, prefix, central_disjoint, base=2):
+    assert (h, central_disjoint, base) == (24,24,2)
+    d=central_disjoint
+    assert 0<d<=h
+    divisor=abs(3-d)
+    assert divisor == 21
+    triples=list(combinations(range(h),3)); v=len(triples)
+    args=[(0,0)]; support=[0]; core=[0]; cover=[0]; types=[0]; ranks=[0]
+    lookup={}; inputs={}; center_coeff={}
+    # Each central tree adds h-1 ordinary pair totals, so every intermediate
+    # coefficient is at most h-1. Wider lanes rule out hidden integer carries.
+    coefficient_bits=h.bit_length()
+    def packed(mask):
+        result=0
+        while mask:
+            bit=mask&-mask; mask-=bit
+            result |= 1 << (coefficient_bits*(bit.bit_length()-1))
+        return result
+    for j,t in enumerate(triples):
+        mask=sum(1<<a for a in t); x=len(args); inputs[t]=x
+        args.append((0,0));support.append(1<<j);core.append(mask);cover.append(mask)
+        types.append(1);ranks.append(1);lookup[1<<j]=x
+    def add(a,b,center=None):
+        if not a:return b
+        if not b:return a
+        if center is None:
+            assert not support[a]&support[b], "Ordinary additions must be cancellation-free"
+        s=support[a]|support[b]
+        if center is None and s in lookup:return lookup[s]
+        x=len(args);args.append((a,b));support.append(s)
+        core.append(core[a]&core[b]);cover.append(cover[a]|cover[b])
+        if center is not None:
+            types.append(3);ranks.append(h-1);core[x]=1<<center
+            ca=center_coeff[a] if a in center_coeff else packed(support[a])
+            cb=center_coeff[b] if b in center_coeff else packed(support[b])
+            center_coeff[x]=ca+cb
+        elif core[x].bit_count()>=2:
+            types.append(1);ranks.append(s.bit_count());lookup[s]=x
+        else:
+            types.append(2);ranks.append(cover[x].bit_count());lookup[s]=x
+        return x
+    def total(xs,center=None):
+        xs=[x for x in xs if x]
+        while len(xs)>1:
+            xs=[add(xs[i],xs[i+1],center) if i+1<len(xs) else xs[i] for i in range(0,len(xs),2)]
+        return xs[0] if xs else 0
+    paired=PairedTriple(h,base)
+    allresults=paired.triple(list(range(h)),paired.variables)
+    selected=list(paired.outputs.values())+[allresults[(i,)] for i in range(d)]
+    active=set();stack=list(selected)
+    while stack:
+        x=stack.pop()
+        if not x or x in active:continue
+        active.add(x)
+        if paired.args[x]:stack.extend(paired.args[x])
+    mapping={0:0}|{j+1:inputs[t] for j,t in enumerate(triples)}
+    for x in sorted(active):
+        if paired.args[x]:
+            a,b=paired.args[x];mapping[x]=add(mapping[a],mapping[b])
+    roots=[mapping[paired.outputs[t]] for t in triples];kind=[0]*v
+    center_disjoint_roots=[mapping[allresults[(i,)]] for i in range(d)]
+    del paired, mapping, active, allresults
+    pairtotals={}; pair_outputs={}
+    point_masks=[sum(1<<j for j,t in enumerate(triples) if a in t) for a in range(h)]
+    full_support=(1<<v)-1
+    for t,node in zip(triples,roots):
+        assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]])
+        target_mask=sum(1<<a for a in t)
+        if types[node]==2:
+            assert not cover[node]&target_mask
+        else:
+            assert types[node]==1
+            assert not support[node]&(point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]])
+    for i,node in enumerate(center_disjoint_roots):
+        assert support[node] == full_support & ~point_masks[i]
+        assert types[node]==2 and cover[node]==((1<<h)-1)^(1<<i)
+        assert ranks[node]==h-1
+    for a,b in combinations(range(h),2):
+        others=[i for i in range(h) if i not in (a,b)]
+        others.sort(key=lambda i:((i^1) in (a,b),i))
+        pre=[0]
+        for i in others:pre.append(add(pre[-1],inputs[tuple(sorted((a,b,i)))]))
+        suf=[0]*(len(others)+1)
+        for j in range(len(others)-1,-1,-1):suf[j]=add(inputs[tuple(sorted((a,b,others[j])))],suf[j+1])
+        for j,i in enumerate(others):
+            node=add(pre[j],suf[j+1])
+            roots.append(node);kind.append(0)
+            pair_outputs[a,b,i]=node
+            assert support[node] == point_masks[a]&point_masks[b]&~point_masks[i]
+            assert types[node]==1
+            assert not support[node]&(point_masks[a]^point_masks[b]^point_masks[i])
+        pairtotals[a,b]=pre[-1]
+        assert support[pre[-1]] == point_masks[a]&point_masks[b]
+    for a in range(d,h):
+        root=total([pairtotals[tuple(sorted((a,b)))] for b in range(h) if b!=a],center=a)
+        assert center_coeff[root] == 2*packed(point_masks[a]), "Center coefficients must be exactly doubled"
+        roots.append(root);kind.append(1)
+    roots.extend(center_disjoint_roots);kind.extend([1]*d)
+    # Mixed retained centers recover the total by
+    # (sum B_i - 2 sum D_i)/(2(3-d)); check each source coefficient.
+    Dset=set(range(d))
+    for triple in triples:
+        k=len(Dset.intersection(triple))
+        assert 2*(3-k)-2*(d-k)==2*(3-d)
+    # Check the rational substituted center scatter for every realizable pair of
+    # target/source memberships. Its coefficient is (intersection-1)/2.
+    from fractions import Fraction
+    # Every A_i avoids i, so sum A_i = (h-3)T. The selected decoder is
+    # T=sum A_i/21 and scatter T-(1/2)sum_{i in target} A_i.
+    decoder=Fraction(1,h-3)
+    assert decoder==Fraction(1,21)
+    scatter_coefficients=[decoder,decoder-Fraction(1,2)]
+    for coefficient in scatter_coefficients:
+        odd_denominator=coefficient.denominator
+        while odd_denominator%2==0:
+            odd_denominator//=2
+        assert 21%odd_denominator==0 and abs(coefficient)<=1
+    for source in triples:
+        assert sum(i not in source for i in range(h))*decoder==1
+    patterns={}
+    for target in triples:
+        chosen=len(Dset.intersection(target))
+        if chosen not in patterns:
+            patterns[chosen]=target
+    for chosen,target in patterns.items():
+        target_set=set(target)
+        for source in triples:
+            k=len(Dset.intersection(source))
+            total_coefficient=Fraction(2*(3-k)-2*(d-k),2*(3-d))
+            scalar=Fraction(len((target_set-Dset).intersection(source)),2)
+            scalar-=Fraction(len((target_set&Dset)-set(source)),2)
+            scalar+=Fraction(chosen-1,2)*total_coefficient
+            assert scalar==Fraction(len(target_set.intersection(source))-1,2)
+    # Check the scalar correction for each target, using the verified exact
+    # roots. Twice the coefficient is (intersection-1)+[intersection=0]
+    # -[intersection=2], which is two precisely for the diagonal.
+    for j,t in enumerate(triples):
+        masks=[point_masks[a] for a in t]
+        two=(masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0])
+        actual=0
+        for a,b in combinations(t,2):
+            excluded=next(i for i in t if i not in (a,b))
+            actual |= support[pair_outputs[a,b,excluded]]
+        assert actual == two
+        assert masks[0]&masks[1]&masks[2] == 1<<j
+    assert [((k-1)+(k==0)-(k==2)) for k in range(4)] == [0,0,0,2]
+    def contained(x,y):
+        tx,ty=types[x],types[y]
+        if tx==1 and ty==1: return not(core[y]&~core[x] or cover[x]&~cover[y])
+        if tx in (1,2) and ty==2: return not cover[x]&~cover[y]
+        if tx==1 and ty==3: return bool(core[x]&core[y])
+        if tx==2 and ty==3: return not cover[x]&~core[y]
+        if tx==3 and ty==2: return cover[y]==(1<<h)-1
+        if tx==3 and ty==3: return core[x]==core[y]
+        return False
+    active=[0]*len(args);stack=list(roots)
+    while stack:
+        x=stack.pop()
+        if not x or active[x]:continue
+        active[x]=1
+        if args[x][0]:stack.extend(args[x])
+    degree=[0]*len(args)
+    for x in range(1,len(args)):
+        if active[x]:
+            if types[x]==1:
+                # Shared-pair triple indicators have self-dot one and
+                # pairwise dot zero over F2; a source is a single such line.
+                assert core[x].bit_count()>=2 and ranks[x]==support[x].bit_count()
+            elif types[x]==2:
+                assert ranks[x]==cover[x].bit_count()
+            else:
+                # E_a is the orthogonal complement of the odd vector 1+e_a.
+                assert types[x]==3 and core[x].bit_count()==1 and ranks[x]==h-1
+        if active[x] and args[x][0]:
+            for y in args[x]:
+                assert y<x and contained(y,x), "Binary frame nesting failed"
+                degree[y]+=1
+    for x in roots:degree[x]+=1
+    H=[0]*(h+1);c=0;loss=0
+    for x in range(1,len(args)):
+        if not active[x]:continue
+        r=ranks[x]
+        if args[x][0]:
+            c+=1;H[r]+=degree[x]-1;H[h-r]+=1
+            for y in args[x]:
+                assert r>=ranks[y]
+                H[r-ranks[y]]+=1
+        else:H[1]+=degree[x]
+    for x,k in zip(roots,kind):
+        r=ranks[x]
+        if k:H[r]+=1;H[h]+=1;loss+=r
+        else:H[h-1-r]+=1;H[1]+=1
+    q=len(roots);R=c+q
+    result=dict(h=h,v=v,c=c,q=q,R=R,loss=loss,central_disjoint=d,histogram=H,rank_sum=sum(r*n for r,n in enumerate(H)))
+    assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss
+    prefix=Path(prefix)
+    result['center_denominator']=21
+    result['scalar_validation']=dict(ordinary_supports_exact=True, centers_exact=True,
+        center_decoder='sum A_i / 21', scatter_coefficients=list(map(str,scatter_coefficients)),
+        rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True,
+        binary_frames_nondegenerate=True)
+    with open(str(prefix)+'.bin','wb') as f:
+        f.write(struct.pack('<4I',h,v,len(args),q))
+        write_array(f,array.array('I',(a for pair in args for a in pair)))
+        write_array(f,array.array('Q',core));write_array(f,array.array('Q',cover))
+        write_array(f,array.array('I',roots));write_array(f,array.array('I',kind))
+        write_array(f,array.array('B',active))
+    with open(str(prefix)+'.labels','wb') as f:
+        write_array(f,array.array('I',ranks));write_array(f,array.array('B',types))
+    Path(str(prefix)+'.json').write_text(json.dumps(result,indent=2)+'\n')
+
+    return result
diff --git a/scripts/stopped_product_network.py b/scripts/stopped_product_network.py
new file mode 100644
index 0000000000..5f349a2676
--- /dev/null
+++ b/scripts/stopped_product_network.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Exact stopped product-ring moments, rational-center guard and assembly.
+
+Copyright 2026 icekylinx. Apache-2.0.
+Developed with substantial OpenAI GPT-6 Astra and Codex assistance.
+Retains the copied-center two-stage construction, Paureel/PR29 topology,
+PR23 semantic assembly and RaD analytic interfaces; see SOURCES.json.
+"""
+import argparse
+from collections import Counter
+from fractions import Fraction as Q
+from hashlib import sha256
+from math import comb
+from pathlib import Path
+import json
+import sys
+
+from certify import require
+from copied_centers.physical import copied_histogram
+from copied_centers_network import finite_bridge as copied_bridge, grid_upper
+from partial_swap_network import moment
+from structured_bulk_assembly import assembly, js
+
+ROOT = Path(__file__).resolve().parents[1]
+COARSE = Q(4019, 50000000)
+ATOM = Q(1, 1000)
+OLD = Q(384599, 10**10)
+AB = (1-ATOM)*COARSE+ATOM*OLD
+AC = Q(1949, 25000000)
+PHASE_STOP = Q(1, 10**6)
+ASSEMBLY_BIT = min(AB, (1-PHASE_STOP)*AC-Q(1, 10**10))
+KAPPA = Q(194869, 2500000000)
+
+
+def profile(row):
+    h, v, R, ell = (row[k] for k in ('h', 'v', 'R', 'loss'))
+    require(v == comb(h, 3), 'Triple count')
+    H = copied_histogram(row)['histogram']
+    m, N, B = h*h, v*v, v*R
+    W, L = 2*N+2*B, 2*v*ell
+    z = Counter({m-h:2*B, (h-1)**2:2*N, h-1:4*N, 1:N})
+    for r, n in enumerate(H):
+        if r and n:
+            z[r] += 2*v*n
+    z = dict(sorted((t,n) for t,n in z.items() if n))
+    s = W*m-N+L
+    require(all(0 < t < m and n > 0 for t,n in z.items()), 'Shrinking children')
+    require(sum(t*n for t,n in z.items()) == s, 'Complete rank mass')
+    return dict(dimensions=[h,h], m=m, N=N, B1=B, B2=B, W=W, L=L,
+                total_rank=s, deficit=N-L, maxchild=max(z),
+                copied_histogram=H, child_multiplicities=z)
+
+
+def coarse_moment(p):
+    def log_upper(x):
+        power = 0
+        while x >= 2:
+            x /= 2
+            power += 1
+        def small(y):
+            z = (y-1)/(y+1)
+            return 2*sum((z**(2*j+1)/(2*j+1) for j in range(24)), Q(0)) + 2*z**49/(49*(1-z*z))
+        return grid_upper(power*small(Q(2))+small(x))
+    total, logs = Q(0), {}
+    for t, n in p['child_multiplicities'].items():
+        logs[t] = log_upper(Q(p['m'],t))
+        u = COARSE*logs[t]
+        require(0 < u < 3, 'Coarse exponential enclosure')
+        total += n*t*grid_upper(1+u+u*u/(2*(1-u/3)))
+    upper = total/(p['W']*p['m'])
+    mass = Q(p['total_rank'],p['W']*p['m'])
+    require(mass < 1 and upper < 1, 'Both stopped-recurrence moments')
+    require(0 < OLD <= COARSE < ATOM < 1, 'Stopped-adapter exponents')
+    require(ATOM > AB, 'Adapter toll subordinate to the stopped saving')
+    return dict(saving=COARSE, exponent=1-COARSE, moment_upper=upper,
+                strict_gap=1-upper, rank_moment=mass,
+                logarithm_upper_bounds=logs, rounding_denominator=1 << 100,
+                stopped_adapter=dict(atom_exponent=ATOM, base_ordinary_saving=OLD,
+                    effective_saving=AB, coarse_toll_exponent=1-ATOM,
+                    coarse_toll_subordinate_gap=ATOM-COARSE))
+
+
+def finite_bridge(bit, phase, row, previous):
+    bridge = copied_bridge(bit, phase, [row,row])
+    old_bit = previous['finite_bridge']['bit']
+    old_degree = old_bit['halving_degree']*old_bit['wire_bits']
+    require(old_degree == 252, 'Inherited ordinary leaf row stock')
+    coarse = bridge.pop('bit')
+    c = bridge['complex']
+    coefficient = (coarse['halving_degree']*coarse['wire_bits']+old_degree+
+                   c['halving_degree']*c['wire_bits'])
+    degree = 4000
+    require(Q(degree) > Q(51*coefficient,25), 'Product stock strictly sufficient')
+    bridge.update(bit_coarse=coarse, ordinary_leaf_row_degree=old_degree)
+    bridge['rows'] = dict(coefficient=coefficient, degree=degree, suffix_slope=4*degree,
+        degree_gap=Q(degree)-Q(51*coefficient,25),
+        contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse')
+    require(row['h'] == row['central_disjoint'] == 24, 'Selected all-disjoint centers')
+    divisor = row['h']-3
+    require(divisor == 21, 'Selected fixed odd divisor')
+    bridge['semantic'].update(fixed_odd_divisor=divisor,
+        exact_grid='One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding')
+    return bridge
+
+
+def certificate():
+    require(not sys.flags.optimize, 'Run without -O')
+    def read(name):
+        return json.loads((ROOT/'certificates'/name).read_text())
+    bit_row = read('stopped-product-bit-axis.json')
+    complex_row = read('stopped-product-complex-input.json')
+    expected = read('stopped-product-input.json')
+    previous = read('copied-centers-network.json')
+    require(Q(previous['bit']['saving']) == OLD, 'Certified ordinary leaf saving')
+    require(bit_row['h'] == 23, 'Selected bit dimension')
+    bit, phase = profile(bit_row), profile(complex_row)
+    for label,p in (('bit',bit),('complex',phase)):
+        for key,value in expected[label].items():
+            require(js(p[key]) == value, label+' saved '+key)
+    bm = coarse_moment(bit)
+    cm = moment(phase['m'],phase['W'],phase['child_multiplicities'],AC,True)
+    require(bm['strict_gap'] == Q(expected['bit_moment_gap']), 'Saved coarse moment')
+    require(cm['strict_gap'] == Q(expected['complex_moment_gap']), 'Saved complex moment')
+    bridge = finite_bridge(bit,phase,complex_row,previous)
+    assembled = assembly(ASSEMBLY_BIT,AC,bridge,KAPPA,beta=PHASE_STOP)
+    require(ASSEMBLY_BIT <= AB, 'Assembly saving supported by actual bit interface')
+    assembled['parameters']['actual_bit_saving'] = AB
+    require(js(bridge) == expected['finite_bridge'], 'Saved semantic and product bridge')
+    require(js(assembled) == expected['assembly'], 'Saved exact assembly')
+    require(len(assembled['strict_constraints']) == 47 and len(assembled['margins']) == 7,
+            'Complete assembly constraints')
+    sources = sorted(p for p in (ROOT/'certificates').glob('stopped-product-*.json')
+                     if p.name != 'stopped-product-network.json')
+    sources += sorted((ROOT/'scripts').glob('stopped_product*.py'))
+    sources += sorted(p for p in (ROOT/'scripts/stopped_product').rglob('*')
+                      if p.is_file() and '__pycache__' not in p.parts)
+    sources += sorted((ROOT/'notes').glob('stopped-product-*.tex'))
+    sources += [ROOT/path for path in (
+        'scripts/copied_centers/physical.py','scripts/copied_centers_network.py',
+        'scripts/partial_swap_network.py','scripts/structured_bulk_assembly.py',
+        'certificates/copied-centers-network.json','certificates/copied-centers-bit-axes.json')]
+    return dict(status='Conditional stopped product-ring multiplication witness',kappa=KAPPA,
+        bit=dict(counts=bit,**bm),complex=dict(counts=phase,**cm),
+        finite_bridge=bridge,assembly=assembled,
+        base_commit='56b66d58297deca1d7dd130247d720e960f77a37',
+        proof_predecessor_commit='11817ccacb564bb7f98789c20dc11d3fece207e3',
+        source_sha256={str(p.relative_to(ROOT)):sha256(p.read_bytes()).hexdigest() for p in sources},
+        scope='Exact finite moments, stopped savings and assembly; the new complex producer is checked separately. '
+              'Opposite-bank factorization, atom streaming, ordinary conversion, common exact grid and retained analytic/tape interfaces are written proof dependencies.')
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--output',type=Path,default=ROOT/'certificates/stopped-product-network.json')
+    args = parser.parse_args()
+    result = certificate()
+    args.output.write_text(json.dumps(js(result),indent=2,sort_keys=True)+'\n')
+    print('PASS kappa=194869/2500000000 = 7.79476e-5')
+    print('Coarse and complex moments; stopped bit saving; exact rational-center guard; p^4000 stock; 47 strict constraints')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/stopped_product_producer.py b/scripts/stopped_product_producer.py
new file mode 100644
index 0000000000..aefc91d9a7
--- /dev/null
+++ b/scripts/stopped_product_producer.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Regenerate only the new h24 aligned all-disjoint rational-center producer.
+
+Copyright 2026 icekylinx, Apache-2.0. Prepared with OpenAI GPT-6 Astra and
+Codex assistance. Prior paired circuit and matcher attribution is retained
+in NOTICE. No old bit producer is regenerated.
+"""
+import argparse
+import gc
+import json
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+import tempfile
+
+from copied_centers.corners import require
+from copied_centers.physical import copied_histogram
+from endpoint_gauge_producer import compare
+from stopped_product.complex import build
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def read(path):
+    return json.loads(path.read_text())
+
+
+def regenerate(work, bit, expected, previous_bits, compiler):
+    require(sys.flags.optimize == 0, 'Run without -O: mathematical assertions must remain enabled')
+    require(bit['h'] == 23 and bit['label_source'] == 'positive', 'Wrong selected bit axis')
+    old = next(row for row in previous_bits if row['h'] == 23)
+    for key in ('h','v','c','q','baseline_R','matching','R','loss','histogram','label_source'):
+        require(bit[key] == old[key], 'Reused bit producer mismatch: '+key)
+    require(bit['R'] == bit['c']+bit['q']-bit['matching'], 'Bit role identity failed')
+    bit_copied = copied_histogram(bit)
+    require((expected['h'],expected['central_disjoint'],expected['center_denominator']) ==
+            (24,24,21), 'Wrong rational-center parameters')
+    print('Regenerating only complex h=24: aligned pair stars, all24 disjoint centers, divisor21',
+          file=sys.stderr, flush=True)
+    prefix = work/'complex_rational_d24_24'
+    construction = build(24, prefix, central_disjoint=24)
+    gc.collect()
+    program = work/'match_complex_general'
+    source = ROOT/'scripts'/'endpoint_gauge'/'match_complex_general.cpp'
+    subprocess.run([*shlex.split(compiler), '-O3', '-std=c++17', str(source),
+                    '-o', str(program)], check=True)
+    matched = json.loads(subprocess.check_output(
+        [str(program), str(prefix)+'.bin', str(prefix)+'.labels'], text=True))
+    compare(matched, expected, 'complex h=24 rational centers')
+    require(construction['R'] == matched['baseline_R'], 'Wrong raw complex roles')
+    phase_copied = copied_histogram(matched)
+    return dict(bit=dict(reused_validated_producer=True, certificate_equal=True,
+                         copied=bit_copied),
+                complex=dict(**matched, central_disjoint=24, center_denominator=21,
+                             construction=construction, copied=phase_copied,
+                             certificate_equal=True),
+                old_bit_regeneration_skipped=True,
+                scope='Exact new scalar supports, rational scatter, nested frames and matching histogram. '
+                      'The common odd-denominator grid and recursive tape transfer remain written proof interfaces.')
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    for name, filename in (
+            ('bit-axis','stopped-product-bit-axis.json'),
+            ('complex-input','stopped-product-complex-input.json'),
+            ('previous-bits','copied-centers-bit-axes.json')):
+        parser.add_argument('--'+name, type=Path, default=ROOT/'certificates'/filename)
+    parser.add_argument('--cxx', default=os.environ.get('CXX','c++'))
+    parser.add_argument('--work-dir', type=Path, help='Keep generated intermediate files')
+    parser.add_argument('--output', type=Path, help='Write full incremental verification JSON')
+    args = parser.parse_args()
+    inputs = [read(path) for path in (args.bit_axis,args.complex_input,args.previous_bits)]
+    def run(work):
+        return regenerate(work,*inputs,args.cxx)
+    if args.work_dir:
+        args.work_dir.mkdir(parents=True,exist_ok=True)
+        result = run(args.work_dir.resolve())
+    else:
+        with tempfile.TemporaryDirectory(prefix='stopped-product-') as directory:
+            result = run(Path(directory))
+    encoded = json.dumps(result,indent=2)+'\n'
+    if args.output:
+        args.output.write_text(encoded)
+    else:
+        print(encoded,end='')
+
+
+if __name__ == '__main__':
+    main()