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/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/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/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()