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/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..20eb3c65fe
--- /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
+```
+
+Full verification passed on research commit `97750ec74fc714638c0aa4f31aaa880e56cb8b4d`: `make -j1 verify`, package verification and 14 controls completed in 3733.46 seconds with no source drift. All 42 GitHub checks on that research commit passed. See [validation.json](validation.json) for commands, log/archive hashes and scope. The inherited general interfaces remain conditional. 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..e68a3a4a55
--- /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": "f93df36578a831e05be4f348258a1fbd2e73eb813447527b8f29b08b3590bdd1",
+    "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/validation.json b/research/cube-deferred/validation.json
new file mode 100644
index 0000000000..dd37ce890b
--- /dev/null
+++ b/research/cube-deferred/validation.json
@@ -0,0 +1,485 @@
+{
+  "schema_version": 1,
+  "research_commit": "97750ec74fc714638c0aa4f31aaa880e56cb8b4d",
+  "verification": "passed",
+  "audited_at": "2026-10-09T11:11:23.976798+00:00",
+  "runs": [
+    {
+      "archive": "full-verify-evidence.tar.gz",
+      "archive_sha256": "88b706c1a02e79f8f6a039506c3d4239fec94d657bd87047e21472b82f3f2330",
+      "status": {
+        "state": "passed",
+        "tested_commit": "97750ec74fc714638c0aa4f31aaa880e56cb8b4d",
+        "started_at": "2026-10-09T00:35:00.329720+00:00",
+        "pid": 114,
+        "commands": [
+          [
+            "make",
+            "-j1",
+            "verify"
+          ],
+          [
+            "python",
+            "research/cube-deferred/verify.py"
+          ],
+          [
+            "python",
+            "research/cube-deferred/test_controls.py"
+          ]
+        ],
+        "platform": "Linux Daytona python:3.11-slim with g++ and libboost-dev",
+        "compiler": "c++ -include algorithm",
+        "returncode": 0,
+        "elapsed_seconds": 3733.4615275859833,
+        "completed_at": "2026-10-09T01:37:13.791184+00:00",
+        "log_sha256": "478debc99c5205c2b24ccefd940c5edf3c5c42318a024cf2787ed1fe8871a3b7",
+        "git_status": "",
+        "drift": []
+      },
+      "executed_commands": [
+        [
+          "make",
+          "-j1",
+          "verify"
+        ],
+        [
+          "python",
+          "research/cube-deferred/verify.py"
+        ],
+        [
+          "python",
+          "research/cube-deferred/test_controls.py"
+        ]
+      ],
+      "source_drift_patch_empty": true
+    }
+  ],
+  "research_head_ci": {
+    "commit": "97750ec74fc714638c0aa4f31aaa880e56cb8b4d",
+    "successful_checks": 42,
+    "checks": [
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:39:43Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435177/job/113610919331",
+        "name": "focused (3.11)",
+        "startedAt": "2026-10-09T00:34:56Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify cube deferred witness"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:39:27Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865434990/job/113610918593",
+        "name": "focused (3.11)",
+        "startedAt": "2026-10-09T00:34:28Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify cyclic deferred witness"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:42:13Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918942",
+        "name": "verify (3.11, community)",
+        "startedAt": "2026-10-09T00:37:57Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:37:40Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435177/job/113610919211",
+        "name": "focused (3.13)",
+        "startedAt": "2026-10-09T00:34:35Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify cube deferred witness"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:03Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865434990/job/113610918415",
+        "name": "focused (3.13)",
+        "startedAt": "2026-10-09T00:34:13Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify cyclic deferred witness"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:31Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918903",
+        "name": "verify (3.11, producers)",
+        "startedAt": "2026-10-09T00:35:51Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:37:56Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435177/job/113610919054",
+        "name": "focused (3.14)",
+        "startedAt": "2026-10-09T00:34:54Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify cube deferred witness"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:38:30Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865434990/job/113610918634",
+        "name": "focused (3.14)",
+        "startedAt": "2026-10-09T00:34:56Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify cyclic deferred witness"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:43:13Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919019",
+        "name": "verify (3.11, certificates)",
+        "startedAt": "2026-10-09T00:39:17Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:16Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918917",
+        "name": "verify (3.11, ternary)",
+        "startedAt": "2026-10-09T00:37:08Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:43:15Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918884",
+        "name": "verify (3.11, research)",
+        "startedAt": "2026-10-09T00:35:48Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:41:04Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918896",
+        "name": "verify (3.11, tests)",
+        "startedAt": "2026-10-09T00:35:42Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:41:54Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918922",
+        "name": "verify (3.11, strips)",
+        "startedAt": "2026-10-09T00:37:38Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:14Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918815",
+        "name": "verify (3.11, clones)",
+        "startedAt": "2026-10-09T00:35:08Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:37:52Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918912",
+        "name": "verify (3.11, positive)",
+        "startedAt": "2026-10-09T00:36:30Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:39Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918940",
+        "name": "verify (3.11, joint)",
+        "startedAt": "2026-10-09T00:36:16Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:41:05Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918965",
+        "name": "verify (3.11, pair)",
+        "startedAt": "2026-10-09T00:37:16Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:38:55Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918857",
+        "name": "verify (3.13, community)",
+        "startedAt": "2026-10-09T00:35:18Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:42:09Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919036",
+        "name": "verify (3.13, producers)",
+        "startedAt": "2026-10-09T00:36:45Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:39:27Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918936",
+        "name": "verify (3.13, certificates)",
+        "startedAt": "2026-10-09T00:35:54Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:26Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919001",
+        "name": "verify (3.13, ternary)",
+        "startedAt": "2026-10-09T00:36:48Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:47:42Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919095",
+        "name": "verify (3.13, research)",
+        "startedAt": "2026-10-09T00:38:22Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:43:22Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919267",
+        "name": "verify (3.13, tests)",
+        "startedAt": "2026-10-09T00:38:18Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:41:59Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918974",
+        "name": "verify (3.13, strips)",
+        "startedAt": "2026-10-09T00:36:44Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:41:39Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918957",
+        "name": "verify (3.13, clones)",
+        "startedAt": "2026-10-09T00:36:11Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:37:28Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919044",
+        "name": "verify (3.13, positive)",
+        "startedAt": "2026-10-09T00:36:30Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:42:07Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918937",
+        "name": "verify (3.13, joint)",
+        "startedAt": "2026-10-09T00:36:30Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:38:20Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918949",
+        "name": "verify (3.13, pair)",
+        "startedAt": "2026-10-09T00:35:54Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:43:11Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919055",
+        "name": "verify (3.14, community)",
+        "startedAt": "2026-10-09T00:39:36Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:42:51Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919070",
+        "name": "verify (3.14, producers)",
+        "startedAt": "2026-10-09T00:37:48Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:39:43Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918986",
+        "name": "verify (3.14, certificates)",
+        "startedAt": "2026-10-09T00:37:02Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:37:55Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918956",
+        "name": "verify (3.14, ternary)",
+        "startedAt": "2026-10-09T00:35:31Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:44:17Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919037",
+        "name": "verify (3.14, research)",
+        "startedAt": "2026-10-09T00:36:57Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:41:38Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919185",
+        "name": "verify (3.14, tests)",
+        "startedAt": "2026-10-09T00:37:47Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:42:12Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919014",
+        "name": "verify (3.14, strips)",
+        "startedAt": "2026-10-09T00:37:53Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:40:49Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918944",
+        "name": "verify (3.14, clones)",
+        "startedAt": "2026-10-09T00:35:28Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:39:52Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919094",
+        "name": "verify (3.14, positive)",
+        "startedAt": "2026-10-09T00:38:18Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:44:15Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610919042",
+        "name": "verify (3.14, joint)",
+        "startedAt": "2026-10-09T00:38:05Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:39:36Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918846",
+        "name": "verify (3.14, pair)",
+        "startedAt": "2026-10-09T00:35:47Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:42:41Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918502",
+        "name": "formal (historical)",
+        "startedAt": "2026-10-09T00:35:07Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:35:52Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918632",
+        "name": "formal (gaussian)",
+        "startedAt": "2026-10-09T00:35:20Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      },
+      {
+        "__typename": "CheckRun",
+        "completedAt": "2026-10-09T00:36:28Z",
+        "conclusion": "SUCCESS",
+        "detailsUrl": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/37865435021/job/113610918716",
+        "name": "formal (matrix)",
+        "startedAt": "2026-10-09T00:35:53Z",
+        "status": "COMPLETED",
+        "workflowName": "Verify research artifacts"
+      }
+    ]
+  },
+  "scope": "Finite conditional witness. Passing tests do not prove inherited all-size analytic, stopped-product, fixed-tape or residual-to-child interfaces.",
+  "receipt_change_scope": "Only this validation receipt, package README status and its SOURCE README hash change after the tested research commit."
+}
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-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()