diff --git a/research/balanced-cyclic-lift/CERTIFICATE.json b/research/balanced-cyclic-lift/CERTIFICATE.json
new file mode 100644
index 0000000000..149e35aecf
--- /dev/null
+++ b/research/balanced-cyclic-lift/CERTIFICATE.json
@@ -0,0 +1,764 @@
+{
+  "status": "PASS_BALANCED_CYCLIC_LIFT",
+  "assignment_seed": 55,
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "predecessor_count_cases": 128,
+  "predecessor_count_sha256": "f6718d19b18e13b4831d7a67e094b6e810a2041422a9a85d0f0080d62032e0dc",
+  "comparison_n55": {
+    "original_additive_leaf_calls": 3232,
+    "original_dirty_arrays": 6,
+    "stabilized_factor_executions": 220,
+    "stabilized_dirty_arrays": 1,
+    "stabilized_dirty_scalars": 1,
+    "units": "different leaf interfaces; not a runtime comparison"
+  },
+  "factor_checks": {
+    "factors": 1560,
+    "full_columns": 7420,
+    "rounded_cases": 4680,
+    "max_error": "51/31",
+    "output_sha256": "9a34de1febf32ccbb6ac3ff61ee3bbf0bc86a61f97dfb322a06df7df12aeaf78"
+  },
+  "product_checks": {
+    "cases": 315,
+    "output_sha256": "b2cbc9555955277107c3e87fecb277763f84eccf9b18c12886c1e9a79cd7ec55",
+    "seed55_fixture": {
+      "factors": [
+        [
+          [
+            "-3/8",
+            "3/8",
+            "-1/4",
+            "1/2",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "-3/8",
+            "3/8",
+            "-3/8",
+            "-1/4",
+            "3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "1/2",
+            "3/8",
+            "1/2",
+            "-1/4",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/4",
+            "1/4",
+            "-1/4",
+            "-3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "1/2",
+            "-3/8",
+            "1/2",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "3/8",
+            "1/4",
+            "1/2",
+            "-3/8",
+            "3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/2",
+            "3/8",
+            "3/8",
+            "3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "1/2",
+            "-1/2",
+            "1/2",
+            "-3/8",
+            "-1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "3/8",
+            "-1/2",
+            "-1/2",
+            "-1/4",
+            "-3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/2",
+            "3/8",
+            "-1/4",
+            "3/8",
+            "-1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/2",
+            "1/2",
+            "-1/4",
+            "3/8",
+            "-3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "1/2",
+            "1/4",
+            "-1/4",
+            "-1/4",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/2",
+            "1/2",
+            "-3/8",
+            "1/4",
+            "-1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/2",
+            "1/4",
+            "1/4",
+            "3/8",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/4",
+            "1/2",
+            "1/4",
+            "-1/4",
+            "1/4"
+          ],
+          1
+        ],
+        [
+          [
+            "3/8",
+            "1/4",
+            "-3/8",
+            "-1/2",
+            "3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/2",
+            "-3/8",
+            "-3/8",
+            "-1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/4",
+            "1/2",
+            "1/2",
+            "1/4",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/2",
+            "-1/4",
+            "-1/2",
+            "1/2",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "-3/8",
+            "-1/2",
+            "-1/2",
+            "-1/4",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/2",
+            "-3/8",
+            "3/8",
+            "-1/2",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "3/8",
+            "-3/8",
+            "-3/8",
+            "1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "-3/8",
+            "1/4",
+            "-1/4",
+            "1/2",
+            "-3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "1/2",
+            "1/4",
+            "-3/8",
+            "-3/8",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/4",
+            "-3/8",
+            "-3/8",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/4",
+            "-3/8",
+            "3/8",
+            "3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/2",
+            "-1/4",
+            "1/4",
+            "1/2",
+            "3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/2",
+            "-3/8",
+            "-1/2",
+            "1/2",
+            "1/4"
+          ],
+          1
+        ],
+        [
+          [
+            "3/8",
+            "-3/8",
+            "3/8",
+            "-3/8",
+            "1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "3/8",
+            "-1/4",
+            "1/2",
+            "-1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/4",
+            "1/2",
+            "1/4",
+            "-3/8",
+            "-1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/2",
+            "-1/4",
+            "1/2",
+            "-1/2",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "-3/8",
+            "1/2",
+            "3/8",
+            "3/8",
+            "3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/2",
+            "1/4",
+            "-1/4",
+            "3/8",
+            "-3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "-3/8",
+            "-1/4",
+            "1/4",
+            "3/8",
+            "-1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "1/4",
+            "-1/4",
+            "-1/2",
+            "1/4",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/2",
+            "1/4",
+            "3/8",
+            "-1/4",
+            "-1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "1/2",
+            "3/8",
+            "1/4",
+            "-3/8",
+            "3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "3/8",
+            "-1/2",
+            "1/4",
+            "1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "1/4",
+            "-1/4",
+            "-3/8",
+            "-1/4"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/2",
+            "3/8",
+            "1/2",
+            "3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "3/8",
+            "1/4",
+            "1/2",
+            "1/2",
+            "-1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/4",
+            "3/8",
+            "-1/4",
+            "3/8",
+            "-3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "3/8",
+            "3/8",
+            "-1/4",
+            "-1/2",
+            "-1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "3/8",
+            "1/2",
+            "1/2",
+            "3/8",
+            "1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "1/4",
+            "3/8",
+            "1/4",
+            "-1/4",
+            "3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "1/4",
+            "1/2",
+            "1/4",
+            "-3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-3/8",
+            "3/8",
+            "-1/4",
+            "1/2",
+            "3/8"
+          ],
+          1
+        ],
+        [
+          [
+            "-3/8",
+            "1/4",
+            "-1/4",
+            "-1/2",
+            "1/2"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "3/8",
+            "1/2",
+            "3/8",
+            "-3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "-1/4",
+            "-1/4",
+            "-1/4",
+            "-1/2",
+            "1/4"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/4",
+            "-3/8",
+            "3/8",
+            "1/4",
+            "3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "3/8",
+            "-3/8",
+            "1/4",
+            "3/8",
+            "-3/8"
+          ],
+          -1
+        ],
+        [
+          [
+            "1/2",
+            "3/8",
+            "-1/2",
+            "-3/8",
+            "1/2"
+          ],
+          1
+        ],
+        [
+          [
+            "-1/2",
+            "-1/4",
+            "1/4",
+            "3/8",
+            "1/4"
+          ],
+          -1
+        ]
+      ],
+      "grid_bits": 80,
+      "increment": [
+        4496955551756772354861140,
+        -13055416318292148735097840,
+        -102949877395095921346344629,
+        -67700633152316873223113405,
+        -44852990786431749914412216
+      ],
+      "stats": {
+        "factor_executions": 220,
+        "coordinate_updates": 2660,
+        "borrowed_array_words": 5,
+        "borrowed_scalar_words": 1
+      },
+      "error_ceiling_grid_units": 36,
+      "uniform_error_bound_grid_units": 360287970189639670
+    }
+  },
+  "controls": {
+    "rejected": [
+      "omit_shear_0",
+      "omit_shear_1",
+      "omit_shear_2",
+      "omit_shear_3",
+      "omit_shear_4",
+      "omit_shear_5",
+      "omit_shear_6",
+      "omit_shear_7",
+      "omit_shear_8",
+      "omit_shear_9",
+      "omit_shear_10",
+      "omit_shear_11",
+      "source_target_alias",
+      "source_scratch_alias",
+      "target_scratch_alias",
+      "helper_alias",
+      "unstable_coefficient",
+      "float_coefficient",
+      "empty_factors",
+      "unequal_factors",
+      "boolean_sign",
+      "invalid_direction",
+      "reversed_factor_order",
+      "unpaired_pivot_scaling",
+      "omitted_pipeline_restoration"
+    ],
+    "noncommuting_ab": [
+      "80/63",
+      "16/21"
+    ],
+    "noncommuting_ba": [
+      "20/21",
+      "16/21"
+    ],
+    "pivot_collision": [
+      1,
+      1
+    ],
+    "dirt_dependence_all_25_states": [
+      [
+        -2,
+        -2,
+        1
+      ],
+      [
+        -2,
+        -1,
+        0
+      ],
+      [
+        -2,
+        0,
+        1
+      ],
+      [
+        -2,
+        1,
+        0
+      ],
+      [
+        -2,
+        2,
+        1
+      ],
+      [
+        -1,
+        -2,
+        1
+      ],
+      [
+        -1,
+        -1,
+        1
+      ],
+      [
+        -1,
+        0,
+        0
+      ],
+      [
+        -1,
+        1,
+        1
+      ],
+      [
+        -1,
+        2,
+        0
+      ],
+      [
+        0,
+        -2,
+        0
+      ],
+      [
+        0,
+        -1,
+        1
+      ],
+      [
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1,
+        1
+      ],
+      [
+        0,
+        2,
+        1
+      ],
+      [
+        1,
+        -2,
+        1
+      ],
+      [
+        1,
+        -1,
+        0
+      ],
+      [
+        1,
+        0,
+        1
+      ],
+      [
+        1,
+        1,
+        0
+      ],
+      [
+        1,
+        2,
+        1
+      ],
+      [
+        2,
+        -2,
+        1
+      ],
+      [
+        2,
+        -1,
+        1
+      ],
+      [
+        2,
+        0,
+        1
+      ],
+      [
+        2,
+        1,
+        1
+      ],
+      [
+        2,
+        2,
+        0
+      ]
+    ]
+  }
+}
diff --git a/research/balanced-cyclic-lift/CLAIM.md b/research/balanced-cyclic-lift/CLAIM.md
new file mode 100644
index 0000000000..a357624d1a
--- /dev/null
+++ b/research/balanced-cyclic-lift/CLAIM.md
@@ -0,0 +1,80 @@
+# Seed 55: determinant-balanced cyclic lifts
+
+Track: recursive interfaces. Assignment seed **55**, drawn using
+`secrets.randbelow(100)` from OS randomness on 2026-10-13 at 05:18 UTC.
+Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`, freshly fetched `origin/main`.
+Selected result: PR626 with PR543, conditional kappa
+`51110230636731/31250000000000000`; it is not a target for editing here.
+
+Three candidates considered:
+
+1. Multiple clean checkpoints in a dirty factor chain. Not chosen: PR714,
+   PR730 and PR758 already cover nearby checkpoint/tree scheduling questions.
+2. Batch multiple Gaussian boundary right-hand sides. Not chosen: PR481's
+   concrete Strassen construction already covers the most immediate mechanism.
+3. Enlarge a stable real cyclic factor by one scalar to balance its determinant;
+   implement the enlarged map by rounded integer shears and compose it in place.
+   **Chosen:** this changes the leaf interface, rather than the echo tree.
+
+Exact scope: a length-L real cyclic recurrence with position-dependent rational
+coefficients of absolute value at most 1/2. One arbitrary dirty length-L array
+and one arbitrary dirty scalar are borrowed. Test a reversible LU/pivot lift,
+then a two-evaluation conjugation adapter for an ordered factor product.
+Seed 55 selects the 55-factor, length-5 signed dyadic fixture. Include genuinely
+noncommuting factors, complete rounding and restoration checks, an independent
+dense rational reference, instruction corruption controls and a complete cost
+recurrence. No common-label primitive or new multiplication exponent is assumed.
+
+Expected deliverable: standalone research construction and exact certificate,
+or a scoped obstruction if the mechanism fails. Stop after the stated finite
+domain and one implementation; do not search for a new frontier. Target finish:
+2026-10-13 01:18 America/Chicago (06:18 UTC); reserve 06:03 onward for verification
+and publication/handoff. The scope was selected within the first 20% of this hour.
+
+Preimplementation cost screen: the adapter pays four executions of the enlarged
+pipeline, two source translations and two target scatters; exact prefix/closure
+coefficients can grow with L. A smaller factor-execution count therefore does not
+imply a supplier moment improvement. The experiment targets the changed leaf
+contract and exact restoration, with that coefficient expense retained.
+
+Coordination: GitHub reported no pinned issue at 05:18 UTC; the only open issue
+was #650 (Discussions). No reservation issue is created. Relevant pending PRs
+#628, #663, #665, #673, #689, #705, #714, #730, #744, #758 and #764 were inspected
+at the description/source level as applicable. The chosen one-scalar leaf lift
+is distinct from their additive leaf/echo-tree and spectral-hosting contracts.
+PR756's balanced-Fano verification tooling is reserved for the coordinating chat.
+
+Contributor: Wentao Li (@VictorLiwentao; X: [@Is__Victor](https://x.com/Is__Victor)), with substantial OpenAI Codex
+assistance. No independent human review or priority claim is made.
+
+## Completed result (one final claim update)
+
+Published [PR805](https://github.com/CrocSwap/integer-mult-bounds/pull/805) on
+2026-10-13 at approximately 01:02 America/Chicago (06:02 UTC).
+Status: research construction / recursive interface; **no new kappa**.
+The exact real half-stable cyclic leaf and ordered product restore one arbitrary
+dirty array, one dirty scalar and the source. The n55/L5 fixture uses 220 enlarged
+factor executions and 2,660 coordinate updates. The predecessor's 3,232 additive
+leaf calls have a different leaf interface and price.
+
+The frozen mathematical source commit is
+`055e34ecc195529841f0a75c7b53a61c12cce694`; publication receipt changes are documentation
+and context pins only. The base and consumed PR628 source pins remain above and
+in SOURCES.json. Reproduce with
+`python3 -I -O -B research/balanced-cyclic-lift/verify.py`; expect
+`PASS_BALANCED_CYCLIC_LIFT` with 1,560 factors, 7,420 columns, 4,680 rounded factor
+cases, 315 products and 25 controls. Optimized/offline/package-corruption and
+Python 3.9.6/3.13.2 checks pass. Root make verify passed seven historical groups,
+then failed at gen4-bank-verify because the unchanged base environment lacks SymPy.
+
+The final full overlap refresh covered 621 open PRs through #802, followed by
+an immediate pre-creation inspection of #803's separate analytic inverse bound.
+No matching cyclic in-place leaf contribution was identified. Related echo-tree,
+checkpoint and analytic authors are credited in NOTICE.md; no concurrent code is
+consumed. The original selected result and upstream files are unchanged.
+
+Verification and handoff began early, at approximately 05:40 UTC, retaining more
+than the final quarter of this work for checks and publication. Remaining limits:
+exact coefficient entries grow with cycle length; the full complex/root/scaling,
+physical compiler, tape/layout, supplier invoice and multiplication transfer are
+not supplied. The bounded experiment ends at this one reviewable contribution.
diff --git a/research/balanced-cyclic-lift/LICENSE b/research/balanced-cyclic-lift/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/research/balanced-cyclic-lift/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/research/balanced-cyclic-lift/NOTICE.md b/research/balanced-cyclic-lift/NOTICE.md
new file mode 100644
index 0000000000..e9a8cb9d5e
--- /dev/null
+++ b/research/balanced-cyclic-lift/NOTICE.md
@@ -0,0 +1,47 @@
+# Attribution, license and scope
+
+Prepared for **Wentao Li** ([GitHub: VictorLiwentao](https://github.com/VictorLiwentao),
+[X: @Is__Victor](https://x.com/Is__Victor)) with substantial **OpenAI Codex
+assistance** in derivation, implementation, exact checking, writing and packaging.
+No independent human peer review is claimed. New work is Apache-2.0.
+
+Chafik Boukhalfa / chafreaky's [PR628](https://github.com/CrocSwap/integer-mult-bounds/pull/628),
+head `0768f97d06c623b8211e651543c66135796b62bf`, supplies the cyclic equation,
+additive integer-lift leaf, dirty product contract and predecessor dispatcher.
+Its original proof, dispatcher file and attribution notice are retained unchanged
+under `vendor/`. Their original notices and referenced sources remain credited;
+none of their claims are relabeled as this contributor's work.
+
+The four-shear realization of diag(t,t^-1), Gaussian elimination, rounded
+lifting and compute/uncompute are standard tools. No literature-priority claim
+is made. The new contribution is their explicit one-scalar cyclic leaf,
+ordered in-place product adapter, uniform exact-coefficient error accounting
+and source-bound evidence under the specified real half-stable contract.
+
+Concurrent context: 0xkilgore's PR663 independently audits the original binary
+dispatcher; androolloyd's PR673 develops multiway dirty echoes; Dillon Amburgey's
+PR689 refines balanced ternary placement; Hao Yan / FanPUYen's PR714 supplies a
+clean root checkpoint; Sagar Thakrar's PR730 optimizes ordered echo trees; PR744
+checks ternary echoes; PR758 studies higher arity. These keep or change other
+storage/leaf contracts. Their code is not imported. Charles Bethin's PR764
+tightens the ordinary cyclic scan's error bound; this package uses a different
+stabilized rounded word. PR665's spectral residual dilation and PR705's
+register-path determinant obstruction concern different operators/interfaces.
+The pre-submission refresh additionally inspected Alexander Schwartzman's PR784
+on a sharp reserved-scratch echo-tree bound and Stephen Shore's PR788 on reusable
+clean checkpoints. Both retain different leaf/storage contracts; their code is
+not consumed. Exact inspected heads are in SOURCES.json as context only.
+The immediate final refresh also read Hao Yan's PR796 root-valuation audit;
+its nonarchimedean claim is separate from this real-coefficient leaf contract.
+Immediately before creation, Rafael Guevara / alephnan's PR803 degree-controlled
+analytic inverse bound was inspected as a separate result. It is not consumed.
+
+The selected #626/#543 construction and its Kothe/Boukhalfa/eumemic and retained
+supplier lineage are credited context, not a claimed dependency yielding a new
+bound. The exact base and context source hashes are retained in SOURCES.json.
+The coordinating worker's PR756 on balanced-Fano verification is separate.
+
+This is scoped recursive-interface research, with a written all-length identity
+and exact finite regression checks. It supplies no common-label supplier word,
+owner schedule, complete prime-power/complex inversion, fast truncated coefficient
+construction, fixed-tape implementation or new multiplication exponent.
diff --git a/research/balanced-cyclic-lift/PROOF.md b/research/balanced-cyclic-lift/PROOF.md
new file mode 100644
index 0000000000..83a1e8e063
--- /dev/null
+++ b/research/balanced-cyclic-lift/PROOF.md
@@ -0,0 +1,233 @@
+# A determinant-balanced real cyclic leaf
+
+Wentao Li, with substantial OpenAI Codex assistance. Apache-2.0.
+
+## Contract and changed mechanism
+
+Let L>=1, let d in {-1,1}, and let b_i be exact real rational numbers with
+|b_i|<=1/2. Define C by (Cv)_i=b_i v_(i-d mod L), and B=(I-C)^(-1).
+All payload values lie on one grid u Z, u=2^(-w). Source x and target y are
+length-L arrays. A length-L array z and a scalar h are borrowed with arbitrary
+initial values. All four storage objects are distinct. The source is read-only.
+
+The result adds an approximation to an **ordered** product B_n ... B_1 x,
+and restores z, h and x exactly. Exact rational coefficient preparation and
+ordinary clean scalar arithmetic are charged. This is a real, half-stable,
+indexed reference contract; it does not instantiate PR628's full complex
+prime-power factorization, a supplier word, or a fixed-tape implementation.
+
+PR628's additive leaf restores its source and cannot be composed in place.
+Its dirty product therefore uses nested additive commutators. This contribution
+changes the leaf: it realizes the **enlarged** map diag(B,det(I-C)) by integer
+lifts. A single scalar absorbs the nonunit determinant. The enlarged leaf can
+be composed in place, then uncomputed. No clean checkpoint is assumed.
+
+## Exact factorization for every cycle length
+
+List cyclic positions in direction d as 0,...,L-1, renaming indices only in this
+argument. Put a_j=b_(position j), p_j=a_0...a_j,
+delta=1-p_(L-1), and t=1/delta. Since |a_j|<=1/2,
+
+    1/2 <= delta <= 3/2,    2/3 <= t <= 2.
+
+The equations for B are v_0-a_0 v_(L-1)=x_0 and
+v_j-a_j v_(j-1)=x_j for j>=1. Consecutive row eliminations leave
+
+    v_j - p_j v_(L-1) = z_j       (0<=j<L-1),
+    delta v_(L-1) = z_(L-1),
+    z_0=x_0, z_j=x_j+a_j z_(j-1).
+
+Each row elimination has determinant one, so det(I-C)=delta. For L=1 there
+are no causal or return additions and the sole equation is delta v_0=x_0.
+
+In place, first execute z_j += a_j z_(j-1), j=1,...,L-1. Next scale the pair
+(z_(L-1),h) by (t,delta). Finally execute z_j += p_j z_(L-1), j=0,...,L-2.
+The exact rational result is (Bz,delta h), including for nonzero initial h.
+
+The pair scale is four ordinary shears. With U(c) sending z to z+c h and
+L(c) sending h to h+c z, its chronological word is
+
+    L(-t), U(delta-1), L(1), U(t-1).
+
+Indeed U(t-1)L(1)U(delta-1)L(-t)=diag(t,delta), since t delta=1.
+Every factor therefore consists of 2L+2 shears: L-1 causal, four pair, and
+L-1 return shears. This proof is uniform in L and in position-dependent signed
+coefficients. Factor commutativity is never used.
+
+## Rounded shears and exact restoration
+
+Replace a shear q += c r by q += RN(c r/u) u, where RN is nearest integer
+rounding with ties away from zero. Its exact inverse subtracts **the same**
+rounded value. The source r does not change during that shear. Every shear is
+thus a bijection on the two-coordinate integer grid. Reverse the word and
+subtract its increments to obtain the exact inverse, for every initial value.
+
+Directly overwriting the pivot by RN(t q/u)u would not suffice. For the legal
+L=1 coefficient a=-1/2, t=2/3, integers 1 and 2 both round to 1. That loses
+information. The borrowed scalar and the four-shear pair avoid this collision.
+Neither clearing that scalar nor assuming it starts at zero is permitted.
+
+## Length-independent error with exact coefficients
+
+One rounded shear introduces error at most u/2. The causal pass's error at
+position j obeys e_j<=e_(j-1)/2+u/2, hence e_j<=u.
+
+For the pair alone, let its three possible rounding errors be r_1,r_2,r_4,
+each at most u/2 in absolute value; L(1) is an exact grid addition. Starting
+from exact pair inputs, the errors after U(delta-1) are
+
+    e_z=(delta-1)r_1+r_2,    e_h=r_1.
+
+After L(1), |e_h|<=5u/4 and |e_z|<=3u/4. After the final U(t-1),
+|e_z|<=3u/4+5u/4+u/2=5u/2. The exact pair's final map is diagonal, so the
+causal pivot error adds at most t u<=2u to the final pivot and **zero** to
+the final helper. Therefore the pivot error is at most 9u/2, and the helper
+error is at most 5u/4. Each other return coordinate has error at most
+
+    u + |p_j|(9u/2) + u/2 <= 15u/4,
+
+because |p_j|<=1/2. The rounded factor Khat satisfies
+
+    ||Khat(v)-K(v)||_infinity <= 5u,
+    K=diag(B,delta),             ||K||_infinity <= 2.
+
+The norm bound uses the convergent Neumann series for B: ||C||<=1/2, so
+||B||<=2, while delta<=3/2. The rounding bound depends on neither L nor the
+initial dirt magnitude. Its **exact coefficient** hypothesis matters: rounding
+coefficient tables without a separate perturbation budget is not allowed.
+
+For n factors, let F=Khat_n ... Khat_1 and K=K_n ... K_1. Starting at the
+same input, accumulated error obeys E_0=0, E_j<=2E_(j-1)+5u. Thus
+
+    ||F(v)-Kv|| <= 5(2^n-1)u.
+
+This is a proof of the stated error bound; the finite dense comparisons below
+are regression evidence for the implementation, not its all-length proof.
+
+## Two evaluations of the composed bijection
+
+Execute the following, where pi projects away the helper scalar:
+
+    (z,h) <- F(z,h);          y -= pi(z,h);
+    (z,h) <- F^-1(z,h);
+    z += x;
+    (z,h) <- F(z,h);          y += pi(z,h);
+    (z,h) <- F^-1(z,h);
+    z -= x.
+
+Each inverse is the exact inverse integer instruction word. The source and
+borrowed storage are restored exactly. The net increment is
+
+    pi(F((z,h)+(x,0))-F(z,h)).
+
+The ideal enlarged product is diag(B_n...B_1,delta_n...delta_1); its difference
+is exactly (B_n...B_1 x,0). The increment error is therefore at most
+
+    10(2^n-1)u.
+
+Choosing w=p+n+4 ensures absolute error <2^(-p). Actual rounding may make
+the increment depend on initial dirt inside this error allowance. The replay
+records all 25 small dirt states for a concrete one-factor example; it does
+not claim exact dirt independence. A negative call uses the same calculations
+and opposite target additions. Since the target is never a computational
+source and the borrowed inputs are restored, this cancels the increment exactly.
+
+## Complete cost recurrence and early cost screen
+
+The cost unit differs from PR628's **additive** factor leaf. For n=55 its pinned
+dispatcher uses 3,232 additive leaf calls and six dirty arrays. Here there are
+220 executions of an **in-place stabilized factor**, one dirty array and one
+dirty scalar. These counts are not a benchmark or an equal-price comparison.
+
+Let P_i be the paid preparation cost of factor i, including validation,
+L prefix products, delta, t, and the coefficient table. Let R_i price all
+factor routing/returns and coefficient/source reads. Let A(Q,Hc) price the
+nearest rational product with a Q-bit grid integer and a coefficient of Hc
+bits, including multiplication, division, rounding, the destination addition
+and writing the result.
+Let J(Q) price an exact grid addition. If original coefficients have at most
+H numerator/denominator bits, prepared coefficients have at most LH+O(1)
+bits. One stabilized factor execution has complete arithmetic price
+
+    C_i = (L-1) A(Q,H) + (L+2) A(Q,LH+O(1)) + J(Q) + R_i.
+
+The three nonunit pair shears account for the +3 inside L+2; the unit shear
+is J(Q). Even zero coefficients remain in this conservative bill. For the
+ordered pipeline, C(empty)=0 and C(prefix+i)=C(prefix)+C_i. Its inverse has
+the same conservative price. The whole additive interface costs
+
+    T = sum_i P_i + 4 sum_i C_i
+        + 4L J(Q) + R_source_target + V_admission.
+
+The last four length-L passes are two source translations and two target
+scatters. R_source_target prices their source reads, storage access and returns;
+V_admission covers all input/grid/alias/coefficient checks. No recursive child,
+closure scale, copy, inverse, helper restoration or table access is omitted.
+At the indexed word level each shear uses two payload reads and one write, so
+R_i includes 3(2L+2) payload accesses and 2L+2 coefficient reads per execution,
+plus loop/indexing and any required returns. The four copy/scatter passes add
+12L payload accesses. Writes already included in A or J may be omitted from R
+to avoid double counting; they cannot be omitted from both. This reference's
+word-access bill is explicit; a tape layout requires its own realization.
+The reference records exactly 8n(L+1)+4L coordinate updates: **2,660** for
+n=55,L=5. It does not charge a hidden n-factor recursive cancellation tree.
+
+If initial physical magnitudes are at most D, factor endpoints satisfy
+M_j<=2^j(M_0+5u), and M_0<=2D in either forward evaluation. A conservative
+prefix bound uses a pivot bounded by 2M after the causal pass and a helper
+bounded by M. The four pair prefixes have bounds 5M, 5M, 19M/2 and 14M;
+their cumulative rounding deviations are at most 17u/2. The return pass
+has smaller bounds. Thus every intermediate is at most 32(M+u).
+Inverse executions exactly
+retrace those states. Including target scatters, 2^(n+8)(D+u) bounds all mutable
+payload magnitudes. For u<=1, Q=w+n+11+ceil(log2(D+1)) signed bits suffice.
+Ordinary scalar multiplication/division workspace is additionally paid.
+
+**The coefficient expense remains material.** An exact dyadic input can have
+prefix denominators of length proportional to L. A fully stored coefficient
+table occupies O(nL^2 H) bits; borrowed payload occupies (L+1)Q bits. With
+schoolbook integer multiplication/division, A is bounded by O((Q+LH)^2), and
+the complete arithmetic bound is
+
+    sum_i P_i + O(nL(Q+LH)^2) + all routing/access/admission costs.
+
+This does not inherit PR628's length-independent *coefficient word size* or
+its fast approximate preparation. Truncating the tables, extending to complex
+roots, scaling factors, translating arbitrary strides, and mapping all roles
+of a transform require separate paid constructions. Source and helper words
+also need a legal physical lifetime. Those are limitations of this result.
+
+The favorable count does not establish a κ improvement: no narrower recursive
+child, complete common-label word, replacement invoice or owner schedule is
+provided. The selected #626/#543 profiles remain exactly the base profiles.
+The bounded experiment therefore stops at this explicit interface construction
+and its fully exposed coefficient/layout expense.
+
+## Exact evidence and completed coverage
+
+`verify.py` builds I-C independently and uses dense rational Gauss-Jordan
+elimination. Exhaustive coefficients {-1/2,-1/4,0,1/4,1/2} through L=4 in both
+orientations give 1,560 factors and 7,420 complete enlarged-operator columns.
+Each factor is rounded on three initial dirty states, including 220-bit dirt:
+4,680 cases, with exact inverse restoration. The observed maximum factor error
+is 51/31 grid units, below the proved bound 5.
+
+315 product executions cover n in {1,2,3,5,8,16,55}, L in {1,2,3,5,8}, grid
+bits {0,16,80}, and three dirty magnitudes. Coefficients include signed eighths
+and vary by position; orientations vary by factor. The generator is fixed at
+`random.Random(55)`, and the seed-selected n=55,L=5 coefficients are retained
+literally in the certificate. All outputs meet the dense-reference bound and
+restore source/helper/data. Negative calls cancel exactly. The n55 fixture's
+observed error is below 36 grid units; its 80-bit grid gives error <36*2^-80.
+
+The 25 mathematical/admission controls include every single-shear omission in
+one nonzero-coefficient factor, a noncommuting order witness, the pivot collision,
+missing restoration, aliases, unstable/nonrational coefficients, invalid direction,
+empty/mismatched factors and a Boolean sign. The original PR628 dispatcher is
+extracted from its pinned source and executed with a counting leaf stub through
+128 factors. This checks its call counts only; its numerical leaf is not replayed.
+
+Source pins and predecessor credits are in SOURCES.json and NOTICE.md. No solver,
+numerical search, optimality claim, proof assistant or new selected certificate
+is used. The finite package does not discharge the multiplication theorem's
+compiler, physical, precision/tape or analytic obligations.
diff --git a/research/balanced-cyclic-lift/README.md b/research/balanced-cyclic-lift/README.md
new file mode 100644
index 0000000000..6ddc65ec22
--- /dev/null
+++ b/research/balanced-cyclic-lift/README.md
@@ -0,0 +1,62 @@
+# One dirty scalar makes a cyclic factor composable in place
+
+Research construction / recursive-interface refinement; **no new κ**.
+
+A real cyclic recurrence with position-dependent rational coefficients of
+absolute value at most 1/2 can be enlarged by one scalar and implemented by
+reversible rounded shears. The scalar carries the determinant correction.
+An ordered factor chain then runs in place, and a two-evaluation adapter restores
+one arbitrary dirty array and one arbitrary dirty scalar exactly.
+
+For the retained 55-factor, length-5 fixture the adapter executes 220 stabilized
+factors and 2,660 coordinate updates. PR628's original binary dispatcher performs
+3,232 **additive** leaf calls with six dirty arrays. The leaf contracts and prices
+differ; these figures are not a runtime speedup. Exact coefficient tables can
+have O(L)-bit entries, and that expense is explicitly charged.
+
+[PROOF.md](PROOF.md) gives the all-length factorization, the complete precision
+and cost recurrences, and remaining interface obligations. [CERTIFICATE.json](CERTIFICATE.json)
+retains the exact coverage, hashes, controls, seed-selected fixture and operation
+bill. [SOURCES.json](SOURCES.json), [NOTICE.md](NOTICE.md) and [CLAIM.md](CLAIM.md)
+record pins, attribution, assignment and overlap.
+
+Reproduce from the repository root with Python 3.9+ and the standard library:
+
+```sh
+python3 -I -O -B research/balanced-cyclic-lift/verify.py
+```
+
+Expected final line:
+
+```text
+PASS_BALANCED_CYCLIC_LIFT: 1560 factors; 7420 full columns; 4680 rounded factors; 315 products; 25 controls; n55: 3232 additive leaves vs 220 stabilized factor executions
+```
+
+The same command works on an offline copy of this directory in a path with spaces.
+The verifier checks all vendored source hashes and compares a freshly generated
+complete evidence object with the frozen certificate. `--write-certificate` is an
+explicit developer regeneration mode. Mathematical failures use exceptions and
+remain active under optimized Python.
+
+Coverage: exhaustive five-letter coefficients through length four in both
+orientations; independent dense rational full-column references; noncommuting
+signed eighth-coefficient products through 55 factors and length eight; 220-bit
+dirt; exact payload restoration and cancellation; single-instruction omissions,
+order/restoration/pivot-collision controls and pre-mutation alias/admission checks.
+The pinned predecessor dispatcher is checked through 128 factors with a counting
+stub. Its numerical scan/kernel suite is not included in this replay.
+
+The construction handles exact real rational coefficients in the stated range.
+The proof's length-independent error bound does not grant constant-size exact
+coefficient tables. Extending to complex roots, approximate table preparation,
+scaled factors, arbitrary strides and a complete physical transform remains work.
+No finite replay is described as a formal proof of the multiplication theorem.
+
+Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. Consumed PR628 head:
+`0768f97d06c623b8211e651543c66135796b62bf`. Selected conditional κ at this base:
+`51110230636731/31250000000000000`, PR626 with PR543. This package changes no
+selected construction or frontier data. Local validation is in [VALIDATION.md](VALIDATION.md).
+
+Prepared for **Wentao Li** ([VictorLiwentao](https://github.com/VictorLiwentao),
+[@Is__Victor](https://x.com/Is__Victor)), with substantial OpenAI Codex assistance.
+Apache-2.0; predecessor notices retained.
diff --git a/research/balanced-cyclic-lift/SOURCES.json b/research/balanced-cyclic-lift/SOURCES.json
new file mode 100644
index 0000000000..f983a6663a
--- /dev/null
+++ b/research/balanced-cyclic-lift/SOURCES.json
@@ -0,0 +1,132 @@
+{
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "dependency_pr": 628,
+  "dependency_head": "0768f97d06c623b8211e651543c66135796b62bf",
+  "consumed": [
+    {
+      "local_path": "vendor/pr628-dirty.py",
+      "source_path": "research/prime-power-cyclic-scan/dirty.py",
+      "commit": "0768f97d06c623b8211e651543c66135796b62bf",
+      "sha256": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21",
+      "git_blob": "2b9471083706a37519a1af7598e012f5fecf2636"
+    },
+    {
+      "local_path": "vendor/pr628-DIRTY-PROOF.md",
+      "source_path": "research/prime-power-cyclic-scan/DIRTY-PROOF.md",
+      "commit": "0768f97d06c623b8211e651543c66135796b62bf",
+      "sha256": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61",
+      "git_blob": "caf4aafc784a630d61ca7874a0bd19cbcb34e585"
+    },
+    {
+      "local_path": "vendor/pr628-NOTICE.md",
+      "source_path": "research/prime-power-cyclic-scan/NOTICE.md",
+      "commit": "0768f97d06c623b8211e651543c66135796b62bf",
+      "sha256": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68",
+      "git_blob": "22fbeb8ef0a28dd6b3feea718492091319ceb96e"
+    }
+  ],
+  "context_only": [
+    {
+      "path": "CONTRIBUTING.md",
+      "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+      "sha256": "a10dd640ec6f4b1d8b6acc31220af512335dc093f634cd25f601acb07ac53d53"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+      "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+    },
+    {
+      "path": "research/community-k492-audit/pr626/replay/ASSEMBLY.json",
+      "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+      "sha256": "6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e"
+    },
+    {
+      "path": "docs/research/community-k492-review.md",
+      "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+      "sha256": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47"
+    },
+    {
+      "path": "research/complex-k492-owner-repair/PROOF-NOTE.md",
+      "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+      "sha256": "337d70fe7abd9afca1d90954c23bde87f4dc27888cc1a6b4bb80506fd6fbf8c5"
+    },
+    {
+      "path": "docs/research/pr-ledger.md",
+      "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+      "sha256": "2e811684201e08007377ee97b1c35c0f0b3c026dd8207e7b0de3ff7cd1e13a91"
+    }
+  ],
+  "related_work_context_only": [
+    {
+      "pr": 788,
+      "head": "ff8251519e009a01ede6b27e3f5af703eaa70132",
+      "title": "Research: reusable clean checkpoint lowers weighted binary leaf bill 20 to 16 (no new kappa)"
+    },
+    {
+      "pr": 784,
+      "head": "548e42022b37a300f8bf745e848c38baccbce056",
+      "title": "Research theorem: sharp scratch-dependent call bound for dirty echoes"
+    },
+    {
+      "pr": 764,
+      "head": "983d66f0f2e48ee500ec7eee2da9244c001c5064",
+      "title": "Research: sharp inverse-square rounding bound for cyclic scans"
+    },
+    {
+      "pr": 758,
+      "head": "a164f06263e438ead570b169e5b7103aa45bf228",
+      "title": "Research: higher-arity dirty echoes use 152 calls at five-array cap (no new kappa)"
+    },
+    {
+      "pr": 744,
+      "head": "302383e0c1ec71c50860362d3f394f85664c2445",
+      "title": "Independent verification: fixed-space ternary echo minima and rounded leaves"
+    },
+    {
+      "pr": 730,
+      "head": "d222e348179cc02a54d6d26dbd2838944f62c6e5",
+      "title": "Research: optimize ordered dirty echoes at fixed scratch (no new kappa)"
+    },
+    {
+      "pr": 714,
+      "head": "efad8a40094ab453c0525efef0b0eff2a5d8b850",
+      "title": "Research: optimal clean root checkpoint saves 25\u201340% of binary product-shear calls"
+    },
+    {
+      "pr": 705,
+      "head": "eeb0cd605415a73b792915aaa9185000f293c84a",
+      "title": "Research: determinant obstruction for rank-homogeneous register paths (no kappa)"
+    },
+    {
+      "pr": 689,
+      "head": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a",
+      "title": "Research: minimize balanced ternary dirty echo calls at fixed scratch"
+    },
+    {
+      "pr": 673,
+      "head": "b3917936aafbd0d680a954a86e25c4ce7e28a9f9",
+      "title": "Research: dirty echo, alias repair, and fully priced bit-sharing gates"
+    },
+    {
+      "pr": 665,
+      "head": "d0e4f1eb295e5cce508dc76c6937290a9175e42b",
+      "title": "Research note: price a width-9 spectral split with dirty restoration"
+    },
+    {
+      "pr": 663,
+      "head": "e0e546fd01b396478c68b6b6c5a16d87515983ba",
+      "title": "Independent audit: nonlinear dirty restoration and exact PR628 leaf count"
+    },
+    {
+      "pr": 796,
+      "head": "22902155c7875139e43e4fdf15723142d6709bdd",
+      "title": "Research audit: exact prime-power kernel root valuations (no new kappa)"
+    },
+    {
+      "pr": 803,
+      "head": "d213ac12d4a1ab8f717d942e844df318ceb395fb",
+      "title": "Research: degree-controlled cyclic inverse bound by root reflection (no new kappa)"
+    }
+  ]
+}
diff --git a/research/balanced-cyclic-lift/VALIDATION.md b/research/balanced-cyclic-lift/VALIDATION.md
new file mode 100644
index 0000000000..fa60ff44dc
--- /dev/null
+++ b/research/balanced-cyclic-lift/VALIDATION.md
@@ -0,0 +1,56 @@
+# Local validation receipt
+
+Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+Dependency: PR628 `0768f97d06c623b8211e651543c66135796b62bf`.
+Host: macOS arm64; CPython 3.13.2 and 3.9.6; Python standard library only.
+Contributor: Wentao Li, with substantial OpenAI Codex assistance.
+
+Completed 2026-10-13:
+
+- Ordinary replay and isolated optimized replay reproduce the exact certificate.
+  1,560 factor instances, 7,420 full columns, 4,680 rounded factor executions,
+  315 ordered products (each with a cancelling negative call), and 25 controls.
+  The isolated optimized replay also passes with the host's CPython 3.9.6.
+- Independent dense rational inversion supplies the factor and product references.
+  All dirty arrays/scalars and source values restore exactly, including 220-bit dirt.
+- The pinned original PR628 dispatcher matches the closed count formula through
+  128 factors when run with a counting leaf stub. This is not its numerical replay.
+- `python3 -B research/balanced-cyclic-lift/check_package.py` passes on an offline
+  directory with spaces under `-I -O -B`. It rejects altered immutable source,
+  replacement of the scalar-word invoice integer 1 by Boolean true, and a changed
+  pair-shear sign. The last mutation fails the independent full-column identity.
+- `make selected-record-check` passes, including exact selected κ, source inventory
+  and proof supplement binding.
+
+The finite regression domain and seed are explicit in PROOF.md and CERTIFICATE.json.
+The written factorization and error argument cover all L under their exact real
+rational/half-stable hypotheses; finite enumeration is not presented as their proof.
+No solver search, arbitrary-program optimum, runtime benchmark, full prime-power
+kernel, common-label supplier or multiplication theorem is claimed.
+
+Pre-submission coordination refresh at approximately 05:41 UTC covered **612 open
+PRs through #793**, and re-fetched main at the same base. No pinned coordination
+issue exists. Related heads are recorded in SOURCES.json. In particular, #784
+and #788 improve other echo-tree/clean-storage contracts and do not provide this
+determinant-balanced in-place leaf. They are credited in NOTICE.md.
+
+The immediate publication refresh at approximately 05:57 UTC covered **621 open
+PRs through #802**. PR628 remains at the consumed head, main was freshly fetched
+at the exact base again, and no matching in-place cyclic leaf submission was
+identified. PR796's root valuations were read separately and credited as context.
+An immediate pre-creation check also inspected PR803's analytic inverse bound,
+head `d213ac12d4a1ab8f717d942e844df318ceb395fb`; its mechanism is distinct.
+
+The root `make verify` was launched once on an untouched exported base snapshot,
+so historical generators cannot change this contribution or the primary checkout.
+It passed seven historical groups (`verify-community`, `verify-producers`,
+`verify-partial-gauge`, `verify-three-stage-cover`, `verify-paired-cube`,
+`verify-recycled-bit`, `verify-entrance-banks`) and stopped at `gen4-bank-verify`:
+`ModuleNotFoundError: No module named 'sympy'` in the baseline's verifier, with
+make exit status 2. This is an environment limitation on the unchanged base;
+no full-suite pass is claimed. The new standalone package requires no SymPy.
+
+Staged whitespace checks pass; every added file is under this package's directory.
+All original vendor source bytes match their Git/SHA-256 pins. Selected construction
+and `upstream/` files are unchanged. No supplier cold replay, remote/Linux CI or
+proof-assistant validation is claimed for this new package.
diff --git a/research/balanced-cyclic-lift/check_package.py b/research/balanced-cyclic-lift/check_package.py
new file mode 100644
index 0000000000..02ad389d50
--- /dev/null
+++ b/research/balanced-cyclic-lift/check_package.py
@@ -0,0 +1,52 @@
+"""Offline/optimized replay plus proof-relevant package-corruption controls."""
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def run(path, success):
+    result = subprocess.run([sys.executable, "-I", "-O", "-B", str(path / "verify.py")],
+                            cwd=path.parent, capture_output=True, text=True)
+    if (result.returncode == 0) != success:
+        raise ValueError("unexpected package result\n" + result.stdout + result.stderr)
+    if success and "PASS_BALANCED_CYCLIC_LIFT" not in result.stdout:
+        raise ValueError("missing success evidence")
+    return (result.stdout + result.stderr).splitlines()[-1]
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix="balanced cyclic offline ") as root:
+        path = Path(root) / "standalone research package"
+        shutil.copytree(HERE, path, ignore=shutil.ignore_patterns("__pycache__"))
+        results = {"offline_optimized": run(path, True)}
+        source = path / "vendor/pr628-DIRTY-PROOF.md"
+        original = source.read_bytes()
+        source.write_bytes(original + b"\nchanged immutable input\n")
+        results["source_drift"] = run(path, False)
+        source.write_bytes(original)
+        certificate = path / "CERTIFICATE.json"
+        original = certificate.read_bytes()
+        obj = json.loads(original)
+        obj["product_checks"]["seed55_fixture"]["stats"]["borrowed_scalar_words"] = True
+        certificate.write_text(json.dumps(obj))
+        results["certificate_boolean"] = run(path, False)
+        certificate.write_bytes(original)
+        program = path / "lift.py"
+        original = program.read_text()
+        changed = original.replace("(helper, pivot, Fraction(1))", "(helper, pivot, Fraction(-1))")
+        if changed == original:
+            raise ValueError("ineffective instruction mutation")
+        program.write_text(changed)
+        results["instruction_sign"] = run(path, False)
+        program.write_text(original)
+        print(json.dumps(results, indent=2))
+    print("PASS_BALANCED_CYCLIC_PACKAGE: offline optimized replay; 3 rejected corruptions")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/balanced-cyclic-lift/lift.py b/research/balanced-cyclic-lift/lift.py
new file mode 100644
index 0000000000..1b93a2f494
--- /dev/null
+++ b/research/balanced-cyclic-lift/lift.py
@@ -0,0 +1,109 @@
+"""Real cyclic inverses stabilized by one dirty scalar.
+
+Integer-grid reference: exact rational coefficients, nearest rounding with
+ties away from zero, no fixed-tape or fast coefficient-preparation claim.
+"""
+from fractions import Fraction
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def nearest(value):
+    """Round a rational to an integer; odd under sign reversal."""
+    value = Fraction(value)
+    numerator, denominator = value.numerator, value.denominator
+    sign = -1 if numerator < 0 else 1
+    return sign * ((2 * abs(numerator) + denominator) // (2 * denominator))
+
+
+def factor_word(coefficients, direction=1):
+    """Return shears for diag((I-C)^-1, det(I-C)), C_ij=b_i[i-j=d]."""
+    need(type(direction) is int and direction in (-1, 1), "direction")
+    need(len(coefficients) > 0, "nonempty cyclic factor")
+    need(all(type(b) in (int, Fraction) for b in coefficients), "rational coefficients")
+    coefficients = tuple(Fraction(b) for b in coefficients)
+    need(all(abs(b) <= Fraction(1, 2) for b in coefficients), "half-stable coefficients")
+    length = len(coefficients)
+    order = tuple(range(length)) if direction == 1 else tuple(range(length - 1, -1, -1))
+    prefixes = []
+    product = Fraction(1)
+    for index in order:
+        product *= coefficients[index]
+        prefixes.append(product)
+    delta = 1 - product
+    scale = 1 / delta
+    pivot, helper = order[-1], length
+    word = [(order[j], order[j - 1], coefficients[order[j]]) for j in range(1, length)]
+    # Chronological L(-t), U(delta-1), L(1), U(t-1) scales the pair by (t,delta).
+    word.extend(((helper, pivot, -scale), (pivot, helper, delta - 1),
+                 (helper, pivot, Fraction(1)), (pivot, helper, scale - 1)))
+    word.extend((index, pivot, prefix) for index, prefix in zip(order[:-1], prefixes[:-1]))
+    return tuple(word)
+
+
+def compile_factors(factors):
+    need(len(factors) > 0, "nonempty ordered product")
+    words = tuple(factor_word(coefficients, direction) for coefficients, direction in factors)
+    length = len(factors[0][0])
+    need(all(len(coefficients) == length for coefficients, _ in factors), "common length")
+    return words
+
+
+def run_word(data, helper, word, inverse=False):
+    """Mutate borrowed storage directly, using no copied payload array."""
+    length = len(data)
+    sequence = reversed(word) if inverse else iter(word)
+    sign = -1 if inverse else 1
+    for destination, source, coefficient in sequence:
+        value = helper[0] if source == length else data[source]
+        increment = sign * nearest(coefficient * value)
+        if destination == length:
+            helper[0] += increment
+        else:
+            data[destination] += increment
+
+
+def run_pipeline(data, helper, words, inverse=False):
+    for word in reversed(words) if inverse else words:
+        run_word(data, helper, word, inverse)
+
+
+def admit(source, target, data, helper, factors, sign):
+    need(type(sign) is int and sign in (-1, 1), "sign")
+    need(all(type(v) is list for v in (source, target, data, helper)), "list storage")
+    need(len({id(v) for v in (source, target, data, helper)}) == 4, "distinct storage")
+    length = len(source)
+    need(length > 0 and len(target) == len(data) == length and len(helper) == 1, "storage lengths")
+    need(all(type(x) is int for v in (source, target, data, helper) for x in v), "integer-grid data")
+    words = compile_factors(factors)
+    need(len(factors[0][0]) == length, "factor/storage length")
+    return words
+
+
+def add_product(source, target, data, helper, factors, sign=1):
+    """Add sign*(F(data+source)-F(data)); restore data/helper/source exactly."""
+    words = admit(source, target, data, helper, factors, sign)
+    run_pipeline(data, helper, words)
+    for j in range(len(data)):
+        target[j] -= sign * data[j]
+    run_pipeline(data, helper, words, inverse=True)
+    for j in range(len(data)):
+        data[j] += source[j]
+    run_pipeline(data, helper, words)
+    for j in range(len(data)):
+        target[j] += sign * data[j]
+    run_pipeline(data, helper, words, inverse=True)
+    for j in range(len(data)):
+        data[j] -= source[j]
+    return {"factor_executions": 4 * len(words),
+            "coordinate_updates": 4 * sum(map(len, words)) + 4 * len(data),
+            "borrowed_array_words": len(data), "borrowed_scalar_words": 1}
+
+
+def error_bound(factor_count):
+    """Absolute increment error in grid units; exact-coefficient contract."""
+    need(type(factor_count) is int and factor_count >= 1, "positive factor count")
+    return 10 * ((1 << factor_count) - 1)
diff --git a/research/balanced-cyclic-lift/vendor/pr628-DIRTY-PROOF.md b/research/balanced-cyclic-lift/vendor/pr628-DIRTY-PROOF.md
new file mode 100644
index 0000000000..caf4aafc78
--- /dev/null
+++ b/research/balanced-cyclic-lift/vendor/pr628-DIRTY-PROOF.md
@@ -0,0 +1,128 @@
+# Cyclic inverse shears with dirty array restoration
+
+This extends the classical rounded cyclic-inverse primitive of PR628. It removes
+its need for a clean length-L intermediate array. It does not supply a common-label
+Clifford realization, reversible bit arithmetic, transform layout, or the complete
+integer-multiplication reduction. No new kappa follows from this lemma.
+
+## Contract
+
+Input x, target y and h borrowed arrays are complex dyadic grids of spacing u=2^-w.
+Every array has length L>=1 and may initially contain arbitrary data. The arrays
+are distinct. Their initial infinity norms are at most D. Read-only phases tau_i
+have modulus one. Phase generation/storage and coefficient preparation are paid;
+there is no free phase table. The primitive adds an approximation to Q(W)^-1 x
+to y, restores x and every borrowed array exactly, and needs only a constant number
+of clean scalar arithmetic registers besides loop counters and factor descriptors.
+Here (Wx)_i=tau_i*x_(i-d), initially for d=+/-1 in a cyclic layout, and
+Q(z)=r^-1 product_(j=1)^n(z-rho_j), n=r-1, with stable reciprocal/inner factors
+of norm at most 1-beta. The final increment can depend on the initial dirt within
+the stated approximation error. Exact independence of the increment from dirt is
+not claimed for rounded arithmetic.
+
+## One factor
+
+First consider T x = y defined by y_i=x_i+b_i*y_(i-d), |b_i|<=1-beta.
+Choose the cyclic order in direction d. Let z be the zero-boundary causal solution
+and p_i the product of b from the first position through i. Let c be the complete
+product. Then y_i=z_i+p_i*s, s=z_last/(1-c). The stable cyclic equation itself
+implies ||y||<=B/beta when ||x||<=B, so |s|<=B/beta.
+
+On the dyadic grid, perform the causal pass directly in x, skipping the first
+position: x_i += round(b_i*x_previous). These are integer lifts. Reversing their
+order and subtracting the same rounded source products restores x exactly,
+including arbitrary nonzero initial values. During the first pass also accumulate
+the rounded scalar product c_hat. Compute s_hat=round(z_hat_last/(1-c_hat)).
+In a second pass accumulate rounded prefix products p_hat_i and add
+round(m_i*(z_hat_i+round(p_hat_i*s_hat))) to the appropriate target position.
+Finally undo the causal lifts. Each target position is written exactly once;
+its existing value never enters the computed increment. Scalar arithmetic and
+coefficient scratch can be cleared classically; no reversible arithmetic gate
+claim is made. Three passes suffice, excluding validation scans and paid
+coefficient access. O(1) clean scalar words and O(log L) indexing bits suffice.
+
+Nearest complex rounding has norm error at most u. Assuming u<=beta^2/2,
+|z_hat-z|<=u/beta, |p_hat-p|<=u/beta, |c_hat-c|<=u/beta, and
+|1-c_hat|>=beta/2. Using s=z_last/(1-c), rather than separately bounding the
+numerator and denominator, gives
+
+    |s_hat-s| <= u + (2/beta)*(u/beta + (B/beta)*(u/beta))
+              <= 5*(B+1)*u/beta^3.
+
+Also |p_hat|<=1+u/beta<=3/2. Hence the corrected output before m multiplication
+has error at most 12*(B+1)*u/beta^3. If |m_i|<=r, the final rounded multiplication
+has error at most a*(B+1)*u, a=13*(r+1)/beta^3. None of these constants depends
+on L.
+
+For an outer root, b_i=rho^-1*tau_i, m_i=-rho^-1. For an inner root, scan in
+direction -d with b_i=rho*conjugate(tau_(i+d)); the value at position i is
+multiplied by conjugate(tau_i) and added at i-d. This is
+(W-rho I)^-1=(I-rho W^-1)^-1 W^-1. The scalar r is included in one leaf's
+multiplier. Each exact factor has operator norm at most K=r/beta. No permutation
+of the mutable source array is required for the inner factor.
+
+## Product of factors
+
+For exact linear maps A,B and a dirty scratch array z, the sequence
+
+    z += B*x; y += A*z; z -= B*x; y -= A*z
+
+adds AB*x to y and restores z. Split the factor list in halves recursively;
+use one distinct borrowed array per recursion depth. A negative call executes
+the exact inverse instruction word (reverse operation order and invert signs).
+It is not obtained by negating signs in the original order.
+
+The rounded construction still restores every borrowed array and x exactly.
+Inductively each call preserves its input and all deeper scratch, and its increment
+is independent of its target. The paired calls computing B therefore see the same
+input and deeper initial dirt. Never use an ancestor input or target as deeper
+scratch: the ancestor target may have changed between the paired calls. This is
+an explicit alias exclusion in the executable contract.
+
+There are h=ceil(log2 n) borrowed arrays and at most N=4*n^2 leaf calls. Pad to the
+next power of two for this count if desired (identity leaves require no rounded
+inverse). The implementation splits without padding and checks the actual count.
+
+For the ideal elementary shears, the joint max norm grows by at most C=1+K per
+leaf. With a*u<=1 the computed trajectory satisfies
+
+    M_j+1 <= G^j*(D+1), G=C+1.
+
+Comparing the complete rounded word with the ideal word on the same initial
+arrays, and summing the propagated leaf errors, gives
+
+    E_N <= N*a*(D+1)*u*G^(N-1).
+
+The ideal word cancels all borrowed initial data exactly. This proves the target
+error bound for every length and every initial dirt bounded by D, while actual
+restoration is exact without an error allowance. Choosing
+
+    w >= p+1+ceil(log2(N*a*(D+1)))+(N-1)*ceil(log2 G)
+
+and enforcing a*u<=1 and u<=beta^2/2 gives execution error <=2^(-p-1).
+PR628's coefficient/phase perturbation bound, budgeted to <=2^(-p-1) for the
+original x, then gives total <=2^-p. That perturbation bound scales with ||x||;
+for general input bound X use p+ceil(log2(max(1,X))) in its preparation budget.
+The initial borrowed dirt does not enter the ideal operator perturbation bound.
+
+PR628 has log2(beta^-1)=O(r^3). Therefore these deliberately loose budgets need
+w=O(p+log(D+1)+r^5) bits, and O(r^2) passes. Inside a leaf, the causal state and closure scalars add at most another
+O(log(beta^-1)+log r) magnitude bits. Maximum transient magnitudes thus add
+O(log(D+1)+r^5) integer bits, already covered by this word-size bound. Standard
+fast fixed-precision arithmetic yields soft-O((L*r^2+r^3)*(p+log(D+1)+r^5))
+bit work plus charged phase-oracle and routing costs. Factor preparation and
+coefficient enclosures are inherited from PR628. Borrowed storage is
+O(L log r) words; clean arithmetic storage is O(w+log L) bits up to the chosen
+multiplication implementation's workspace, plus O(r) read-only factor descriptors.
+A machine with only a fixed number of dirty data arrays is not covered by this
+contract. Arbitrary stride still incurs PR628's explicitly charged routing.
+
+## Executable evidence
+
+`dirty.py` uses exact rational arithmetic and explicit nearest dyadic rounding.
+It checks generic variable-coefficient leaves, dense independently assembled
+factor inverses, both orientations, nonzero targets, several initial dirty arrays,
+exact source/scratch restoration, exact whole-word inversion, and the leaf count.
+Finite checks support the implementation; the inequalities above are the all-L
+argument. The exact-rational prototype does not itself implement the claimed
+fast fixed-precision arithmetic cost.
diff --git a/research/balanced-cyclic-lift/vendor/pr628-NOTICE.md b/research/balanced-cyclic-lift/vendor/pr628-NOTICE.md
new file mode 100644
index 0000000000..22fbeb8ef0
--- /dev/null
+++ b/research/balanced-cyclic-lift/vendor/pr628-NOTICE.md
@@ -0,0 +1,24 @@
+# Attribution and scope
+
+Ali Romman's PR621, exact head 520774462b19b29af41554b74def31f9d01e997e,
+supplies the prime-power kernel circle bound. Its kernel attribution is
+OpenAI's exact-DFT preprint at adc7f1241b42e322a6451854ab7e4b4c146bf78a
+(`loc:newton`, `loc:fourier-factorization`) and classical q-Pochhammer/Newton
+factorization, including Alexey Kuznetsov's cited q-calculus work. This
+package does not claim to originate those constructions.
+
+Pan's approximate-factorization theorem is used in the form stated by
+Mehlhorn, Sagraloff and Wang; Brent's work supplies fast elementary-function
+evaluation. Causal/anticausal recursive filtering is standard, as illustrated
+by the Briand-Davy source listed in SOURCE.json. Sources are cited for these
+specific tools, not as proofs of this package's complete claim.
+
+The scan rounding analysis, explicit budget composition, interval and
+factor certificates, routed reference execution, and packaging were
+prepared with substantial OpenAI Codex assistance for chafreaky. The dense
+matrix solver and algebraic coefficient crosschecks provide independent
+computational paths, not human peer review or formal Lean verification.
+
+No new multiplication exponent, literature priority, maintainer acceptance,
+physical tape execution, or production performance result is claimed.
+The code and documents use the repository's Apache-2.0 license.
diff --git a/research/balanced-cyclic-lift/vendor/pr628-dirty.py b/research/balanced-cyclic-lift/vendor/pr628-dirty.py
new file mode 100644
index 0000000000..2b94710837
--- /dev/null
+++ b/research/balanced-cyclic-lift/vendor/pr628-dirty.py
@@ -0,0 +1,133 @@
+"""Integer lifting for cyclic inverse shears using borrowed dirty arrays.
+Exact rational prototype. Arithmetic workspace and phase access are charged in the proof;
+this is not a common-label Clifford word or a bit-reversible arithmetic compiler.
+"""
+from pathlib import Path
+from fractions import Fraction as F
+import importlib.util,json,argparse,itertools
+P=Path(__file__).resolve().parent
+s=importlib.util.spec_from_file_location('weighted',P/'weighted.py');w=importlib.util.module_from_spec(s);s.loader.exec_module(w);c=w.c
+
+def scaled(z,q):return(z[0]*q,z[1]*q)
+def conj(z):return(z[0],-z[1])
+def ordered(n,d):return range(n)if d==1 else range(n-1,-1,-1)
+
+def lift(x,y,coefficient,beta,bits,d,sign=1,destination=None,multiplier=None,stats=None):
+    """y += sign*F(x), restoring x exactly; no length-dependent clean data array."""
+    n=len(x);c.need(x is not y and n==len(y)>0,'distinct equally sized arrays')
+    c.need(d in(-1,1)and sign in(-1,1),'orientation and sign')
+    c.need(0<beta<=1 and F(1,1<<bits)<=beta*beta/2,'closure precision')
+    c.need(all(c.norm2(coefficient(i))<=(1-beta)**2 for i in range(n)),'stable coefficients')
+    c.need(all(c.rounded(z,bits)==z for z in itertools.chain(x,y)),'fixed grid data')
+    destination=destination or (lambda i:i);multiplier=multiplier or (lambda i:c.ONE)
+    power=c.ONE;previous=None
+    for i in ordered(n,d):
+        if previous is not None:x[i]=c.add(x[i],c.rounded(c.mul(coefficient(i),x[previous]),bits))
+        power=c.rounded(c.mul(coefficient(i),power),bits);previous=i
+    denominator=c.sub(c.ONE,power);c.need(c.norm2(denominator)>=(beta/2)**2,'closure denominator')
+    seed=c.rounded(c.div(x[previous],denominator),bits)
+    power=c.ONE
+    for i in ordered(n,d):
+        power=c.rounded(c.mul(coefficient(i),power),bits)
+        value=c.add(x[i],c.rounded(c.mul(power,seed),bits))
+        value=c.rounded(c.mul(multiplier(i),value),bits)
+        j=destination(i);y[j]=c.add(y[j],scaled(value,sign))
+    # The scalar seed and coefficient scratch may be cleared by ordinary classical
+    # arithmetic. The dirty data itself is restored by exact inverse integer lifts.
+    first=0 if d==1 else n-1
+    for i in ordered(n,-d):
+        if i!=first:x[i]=c.sub(x[i],c.rounded(c.mul(coefficient(i),x[i-d]),bits))
+    if stats is not None:stats['leaves']+=1;stats['scalar_steps']+=3*n
+
+def leaf(x,y,factor,phases,beta,bits,d,sign,stats):
+    inside,b,scale=factor;n=len(x)
+    if inside:
+        lift(x,y,lambda i:c.mul(b,conj(phases[(i+d)%n])),beta,bits,-d,sign,
+             lambda i:(i-d)%n,lambda i:scaled(conj(phases[i]),scale),stats)
+    else:
+        lift(x,y,lambda i:c.mul(b,phases[i]),beta,bits,d,sign,
+             multiplier=lambda i:scaled(c.neg(b),scale),stats=stats)
+
+def compose(x,y,factors,scratch,phases,beta,bits,d,sign=1,stats=None):
+    """Balanced commutator; negative call is the exact inverse instruction word."""
+    c.need(sign in(-1,1)and d in(-1,1),'orientation and sign')
+    c.need(factors and len(scratch)>=(len(factors)-1).bit_length(),'dirty depth')
+    arrays=[x,y]+scratch;c.need(len({id(v)for v in arrays})==len(arrays),'all ancestor arrays distinct')
+    c.need(len(x)>0 and all(len(v)==len(x)for v in arrays)and len(phases)==len(x),'array lengths')
+    c.need(all(c.norm2(t)==1 for t in phases),'unit phases')
+    if len(factors)==1:return leaf(x,y,factors[0],phases,beta,bits,d,sign,stats)
+    mid=len(factors)//2;B,A=factors[:mid],factors[mid:];z=scratch[0];rest=scratch[1:]
+    operations=[(x,z,B,1),(z,y,A,1),(x,z,B,-1),(z,y,A,-1)]
+    if sign==-1:operations=[(src,dst,fs,-sgn)for src,dst,fs,sgn in reversed(operations)]
+    for src,dst,fs,sgn in operations:compose(src,dst,fs,rest,phases,beta,bits,d,sgn,stats)
+
+def exact_operator(x,factors,phases,d):
+    # Dense rational oracle constructed independently from the lifting recurrence.
+    n=len(x);out=x[:]
+    for inside,b,scale in factors:
+        a=[[c.ZERO for _ in range(n)]for _ in range(n)]
+        if inside:
+            for i in range(n):a[i][i]=c.neg(b);a[i][(i-d)%n]=c.add(a[i][(i-d)%n],phases[i])
+        else:
+            rho=c.div(c.ONE,b)
+            for i in range(n):a[i][i]=c.neg(rho);a[i][(i-d)%n]=c.add(a[i][(i-d)%n],phases[i])
+        out=[scaled(z,scale)for z in w.solve(a,out)]
+    return out
+
+def certificate(n,beta,r,D,bits):
+    N=4*n*n;a=13*(r+1)/beta**3;G=2+F(r)/beta;u=F(1,1<<bits)
+    c.need(a*u<=1 and u<=beta**2/2,'uniform precision')
+    return N*a*(D+1)*u*G**(N-1)
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);args=ap.parse_args()
+    units=[c.ONE,(F(0),F(1)),(F(3,5),F(4,5)),(F(-5,13),F(12,13))]
+    cases=[];controls=[];generic=[]
+    for beta in(F(1,2),F(1,16),F(1,4096)):
+        for n in(1,2,3,8,17,64):
+            bs=[scaled(units[(i*i+i+1)%4],(1-beta)/(1+i%2))for i in range(n)]
+            original=[(F(i%5-2,4),F(i%7-3,8))for i in range(n)]
+            for d in(-1,1):
+                x=original[:];y=[(F(19+i,4),F(3-i,8))for i in range(n)];y0=y[:];bits=128
+                lift(x,y,lambda i:bs[i],beta,bits,d);c.need(x==original,'exact source restoration')
+                net=[c.sub(z,t)for z,t in zip(y,y0)];B=max(abs(a)+abs(b)for a,b in original);bound=13*(B+1)*F(1,1<<bits)/beta**3
+                matrix=[[c.ZERO for _ in range(n)]for _ in range(n)]
+                for i in range(n):matrix[i][i]=c.ONE;matrix[i][(i-d)%n]=c.sub(matrix[i][(i-d)%n],bs[i])
+                w.residual(original,net,matrix,(2-beta)*bound)
+                if n<=8:c.need(all(c.norm2(c.sub(z,t))<=bound**2 for z,t in zip(net,w.solve(matrix,original))),'leaf dense')
+                lift(x,y,lambda i:bs[i],beta,bits,d,-1);c.need(y==y0 and x==original,'exact leaf cancellation')
+                generic.append(dict(beta=str(beta),length=n,direction=d,dense=n<=8))
+    for nf in(1,2,3,5,8):
+        factors=[(i%2==0,(F(1,4),F((-1)**i,8)),F(3)if i==0 else F(1))for i in range(nf)]
+        for n in(1,2,3,8):
+            for d in(-1,1):
+                for dirt in(0,7,-13):
+                    x=[(F(i%5-2,4),F(i%3-1,8))for i in range(n)];x0=x[:]
+                    y=[(F(dirt+i,4),F(dirt-i,8))for i in range(n)];y0=y[:]
+                    scratch=[[(F(dirt+2*i+j,4),F(dirt-3*i-j,8))for i in range(n)]for j in range((nf-1).bit_length())];s0=[z[:]for z in scratch]
+                    phases=[units[(i*i+3*i+1)%4]for i in range(n)];bits=4096;stats=dict(leaves=0,scalar_steps=0)
+                    D=max(abs(a)+abs(b)for v in[x,y]+scratch for a,b in v);bound=certificate(nf,F(1,2),3,D,bits)
+                    compose(x,y,factors,scratch,phases,F(1,2),bits,d,stats=stats)
+                    c.need(x==x0 and scratch==s0,'exact dirty restoration')
+                    expected=exact_operator(x0,factors,phases,d);net=[c.sub(z,t)for z,t in zip(y,y0)]
+                    c.need(all(c.norm2(c.sub(z,t))<=bound**2 for z,t in zip(net,expected)),'commutator dense')
+                    calls=stats['leaves'];c.need(calls<=4*nf*nf,'quadratic leaf count')
+                    compose(x,y,factors,scratch,phases,F(1,2),bits,d,-1)
+                    c.need(x==x0 and scratch==s0 and y==y0,'exact whole word inverse')
+                    cases.append(dict(factors=nf,length=n,direction=d,dirt=dirt,leaf_calls=calls,dirty_arrays=len(scratch),bound=str(bound)))
+        print('PASS factors',nf,flush=True)
+    def reject(name,fn):
+        try:fn()
+        except ValueError as e:controls.append(dict(name=name,rejected=str(e)))
+        else:raise ValueError('control accepted '+name)
+    x=[c.ONE,c.ZERO];y=[c.ZERO,c.ONE];fs=[(True,(F(1,4),F(0)),F(1))]*2
+    reject('borrowed_outer_target',lambda:compose(x,y,fs,[y],[c.ONE]*2,F(1,2),128,1))
+    reject('borrowed_source',lambda:compose(x,y,fs,[x],[c.ONE]*2,F(1,2),128,1))
+    reject('missing_dirty_level',lambda:compose(x,y,fs,[],[c.ONE]*2,F(1,2),128,1))
+    reject('nonunit_phase',lambda:compose(x,y,fs,[[c.ZERO]*2],[c.ONE,(F(2),F(0))],F(1,2),128,1))
+    reject('underprecision',lambda:lift(x,y,lambda i:c.ZERO,F(1,16),4,1))
+    reject('unstable_site',lambda:lift(x,y,lambda i:c.ONE,F(1,2),128,1))
+    reject('off_grid_source',lambda:lift([(F(1,3),F(0))]*2,y,lambda i:c.ZERO,F(1,2),128,1))
+    args.out.write_text(json.dumps(dict(status='passed',generic=generic,cases=cases,controls=controls,scope='Classical fixed-grid dirty-array shear; excludes bit-reversible arithmetic and full multiplication reduction'),indent=2)+'\n')
+    print('PASS',len(generic),'leaf cases',len(cases),'compositions',len(controls),'controls')
+if __name__=='__main__':main()
diff --git a/research/balanced-cyclic-lift/verify.py b/research/balanced-cyclic-lift/verify.py
new file mode 100644
index 0000000000..105c00755f
--- /dev/null
+++ b/research/balanced-cyclic-lift/verify.py
@@ -0,0 +1,282 @@
+"""Independent dense reference, exact regression evidence, and negative controls."""
+import ast
+from fractions import Fraction as F
+import hashlib
+import itertools
+import json
+from pathlib import Path
+import random
+import sys
+from types import SimpleNamespace
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import lift
+
+
+def check(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def inverse(matrix):
+    """Gauss-Jordan over Q; independent of the cyclic scan/pivot factorization."""
+    n = len(matrix)
+    rows = [[F(x) for x in row] + [F(i == j) for j in range(n)]
+            for i, row in enumerate(matrix)]
+    for j in range(n):
+        pivot = next(i for i in range(j, n) if rows[i][j])
+        rows[j], rows[pivot] = rows[pivot], rows[j]
+        scale = rows[j][j]
+        rows[j] = [x / scale for x in rows[j]]
+        for i in range(n):
+            if i != j:
+                scale = rows[i][j]
+                rows[i] = [x - scale * y for x, y in zip(rows[i], rows[j])]
+    return [row[n:] for row in rows]
+
+
+def factor_matrix(coefficients, direction):
+    n = len(coefficients)
+    matrix = [[F(i == j) for j in range(n)] for i in range(n)]
+    for i, b in enumerate(coefficients):
+        matrix[i][(i - direction) % n] -= b
+    return inverse(matrix)
+
+
+def matvec(matrix, vector):
+    return [sum(a * b for a, b in zip(row, vector)) for row in matrix]
+
+
+def rational_word(word, vector):
+    vector = list(map(F, vector))
+    for destination, source, coefficient in word:
+        vector[destination] += coefficient * vector[source]
+    return vector
+
+
+def delta(coefficients):
+    product = F(1)
+    for b in coefficients:
+        product *= b
+    return 1 - product
+
+
+def expected_column(coefficients, direction, column):
+    n = len(coefficients)
+    if column == n:
+        return [F(0)] * n + [delta(coefficients)]
+    return [row[column] for row in factor_matrix(coefficients, direction)] + [F(0)]
+
+
+def ceil_fraction(x):
+    return (x.numerator + x.denominator - 1) // x.denominator
+
+
+def payload_digest(items):
+    data = json.dumps(items, sort_keys=True, separators=(",", ":")).encode()
+    return hashlib.sha256(data).hexdigest()
+
+
+def pinned_sources():
+    source = json.loads((HERE / "SOURCES.json").read_text())
+    for item in source["consumed"]:
+        data = (HERE / item["local_path"]).read_bytes()
+        check(hashlib.sha256(data).hexdigest() == item["sha256"], "pinned source drift")
+    check(source["base_commit"] == "66849e1475c930fd7732b1a0067ffee7e1e95f60", "base pin")
+    return source
+
+
+def original_dispatcher_counts():
+    """Execute only the pinned compose definition, with a counting leaf stub.
+
+    This checks original dispatcher counts, not the predecessor's numerical leaf.
+    """
+    tree = ast.parse((HERE / "vendor/pr628-dirty.py").read_text())
+    definition = next(node for node in tree.body if isinstance(node, ast.FunctionDef)
+                      and node.name == "compose")
+    calls = []
+
+    def leaf(*arguments):
+        calls.append(1)
+
+    namespace = {"c": SimpleNamespace(need=check, norm2=lambda _: 1), "leaf": leaf}
+    exec(compile(ast.Module(body=[definition], type_ignores=[]), "pinned-compose", "exec"), namespace)
+    rows = []
+    for n in range(1, 129):
+        calls.clear()
+        scratch = [[0] for _ in range((n - 1).bit_length())]
+        namespace["compose"]([0], [0], [None] * n, scratch, [1], F(1, 2), 128, 1)
+        h = n.bit_length() - 1
+        closed = (1 << h) * (3 * n - (1 << (h + 1)))
+        check(len(calls) == closed, "predecessor dispatcher count")
+        rows.append([n, closed])
+    return rows
+
+
+def factor_checks():
+    alphabet = (F(-1, 2), F(-1, 4), F(0), F(1, 4), F(1, 2))
+    count, columns, rounded, maximum = 0, 0, 0, F(0)
+    digest_rows = []
+    for length in range(1, 5):
+        for coefficients in itertools.product(alphabet, repeat=length):
+            for direction in (-1, 1):
+                word = lift.factor_word(coefficients, direction)
+                matrix = factor_matrix(coefficients, direction)
+                for column in range(length + 1):
+                    vector = [F(i == column) for i in range(length + 1)]
+                    expected = [row[column] for row in matrix] + [F(0)] if column < length else [F(0)] * length + [delta(coefficients)]
+                    check(rational_word(word, vector) == expected, "stabilized full-column identity")
+                    columns += 1
+                for magnitude in (0, 7, -(1 << 220)):
+                    data = [magnitude + (i * 3 % 11) - 5 for i in range(length)]
+                    helper = [magnitude - 19]
+                    original, initial_helper = data[:], helper[:]
+                    exact = matvec(matrix, data) + [delta(coefficients) * helper[0]]
+                    lift.run_word(data, helper, word)
+                    error = max(abs(x - y) for x, y in zip(data + helper, exact))
+                    maximum = max(maximum, error)
+                    check(error <= 5, "uniform factor rounding error")
+                    digest_rows.append(data + helper)
+                    lift.run_word(data, helper, word, True)
+                    check(data == original and helper == initial_helper, "exact factor inverse")
+                    rounded += 1
+                count += 1
+    return {"factors": count, "full_columns": columns, "rounded_cases": rounded,
+            "max_error": str(maximum), "output_sha256": payload_digest(digest_rows)}
+
+
+def fixture(n, length, rng):
+    alphabet = (F(-1, 2), F(-3, 8), F(-1, 4), F(1, 4), F(3, 8), F(1, 2))
+    return [(tuple(rng.choice(alphabet) for _ in range(length)), rng.choice((-1, 1)))
+            for _ in range(n)]
+
+
+def product_checks():
+    rng = random.Random(55)
+    count, rows, largest = 0, [], None
+    for n in (1, 2, 3, 5, 8, 16, 55):
+        maximum = F(0)
+        for length in (1, 2, 3, 5, 8):
+            factors = fixture(n, length, rng)
+            matrices = [factor_matrix(b, d) for b, d in factors]
+            for bits in (0, 16, 80):
+                source = [((i * 7 % 13) - 6) * (1 << bits) for i in range(length)]
+                expected = source[:]
+                for matrix in matrices:
+                    expected = matvec(matrix, expected)
+                for dirt in (0, 7, -(1 << 220)):
+                    target = [19 - 3 * i for i in range(length)]
+                    data = [dirt + i * i - 5 for i in range(length)]
+                    helper = [dirt - 17]
+                    original = [source[:], target[:], data[:], helper[:]]
+                    stats = lift.add_product(source, target, data, helper, factors)
+                    error = max(abs(y - y0 - wanted) for y, y0, wanted in zip(target, original[1], expected))
+                    maximum = max(maximum, error)
+                    check(error <= lift.error_bound(n), "complete product error")
+                    check([source, data, helper] == [original[0], original[2], original[3]], "product dirty restoration")
+                    check(stats["coordinate_updates"] == 8 * n * (length + 1) + 4 * length, "complete operation bill")
+                    net = [a - b for a, b in zip(target, original[1])]
+                    lift.add_product(source, target, data, helper, factors, -1)
+                    check([source, target, data, helper] == original, "negative product cancellation")
+                    rows.append([n, length, bits, str(dirt), net])
+                    count += 1
+                    if (n, length, bits, dirt) == (55, 5, 80, 7):
+                        largest = {"factors": [[list(map(str, b)), d] for b, d in factors],
+                                   "grid_bits": bits, "increment": net, "stats": stats,
+                                   "error_ceiling_grid_units": ceil_fraction(error),
+                                   "uniform_error_bound_grid_units": lift.error_bound(n)}
+        rows.append([n, "max_error_ceiling", ceil_fraction(maximum)])
+    return {"cases": count, "output_sha256": payload_digest(rows), "seed55_fixture": largest}
+
+
+def controls():
+    coefficients = (F(1, 2), F(-1, 4), F(3, 8), F(-1, 2), F(1, 4))
+    word = lift.factor_word(coefficients)
+    rejected = []
+    for omitted in range(len(word)):
+        altered = word[:omitted] + word[omitted + 1:]
+        check(any(rational_word(altered, [F(i == c) for i in range(6)]) != expected_column(coefficients, 1, c)
+                  for c in range(6)), "ineffective omission control")
+        rejected.append("omit_shear_" + str(omitted))
+    source, target, data, helper = [1, -2], [7, 9], [-5, 11], [19]
+    factors = [((F(1, 2), F(-1, 4)), 1)]
+    initial = [source[:], target[:], data[:], helper[:]]
+
+    def reject(name, call):
+        try:
+            call()
+        except ValueError:
+            rejected.append(name)
+        else:
+            raise ValueError("admission control accepted: " + name)
+        check([source, target, data, helper] == initial, "rejection mutated inputs")
+
+    reject("source_target_alias", lambda: lift.add_product(source, source, data, helper, factors))
+    reject("source_scratch_alias", lambda: lift.add_product(source, target, source, helper, factors))
+    reject("target_scratch_alias", lambda: lift.add_product(source, target, target, helper, factors))
+    reject("helper_alias", lambda: lift.add_product(source, target, data, source, factors))
+    reject("unstable_coefficient", lambda: lift.add_product(source, target, data, helper, [((F(3, 4), F(0)), 1)]))
+    reject("float_coefficient", lambda: lift.add_product(source, target, data, helper, [((0.5, F(0)), 1)]))
+    reject("empty_factors", lambda: lift.add_product(source, target, data, helper, []))
+    reject("unequal_factors", lambda: lift.add_product(source, target, data, helper, factors + [((F(0),), 1)]))
+    reject("boolean_sign", lambda: lift.add_product(source, target, data, helper, factors, True))
+    reject("invalid_direction", lambda: lift.add_product(source, target, data, helper, [(factors[0][0], 0)]))
+    # Noncommuting varying-coefficient factors prevent a silent order substitution.
+    a = factor_matrix((F(1, 2), F(1, 4)), 1)
+    b = factor_matrix((F(-1, 4), F(1, 2)), 1)
+    ab, ba = matvec(a, matvec(b, [1, 0])), matvec(b, matvec(a, [1, 0]))
+    check(ab != ba, "factor-order control")
+    rejected.append("reversed_factor_order")
+    # Direct rounded pivot division is not a permutation; the stabilized pair is.
+    collision = [lift.nearest(F(2, 3) * z) for z in (1, 2)]
+    check(collision == [1, 1], "pivot collision witness")
+    rejected.append("unpaired_pivot_scaling")
+    # Omit an inverse pipeline: exact restoration must fail on an explicit state.
+    dirty, aux = [5, -7, 3, 2, 11], [-19]
+    lift.run_word(dirty, aux, word)
+    check([dirty, aux] != [[5, -7, 3, 2, 11], [-19]], "missing inverse witness")
+    rejected.append("omitted_pipeline_restoration")
+    # All 25 small dirt states are examined; rounding need not be dirt independent.
+    increments = []
+    for dirt, scalar in itertools.product(range(-2, 3), repeat=2):
+        out = [0]
+        lift.add_product([1], out, [dirt], [scalar], [((F(-1, 2),), 1)])
+        increments.append([dirt, scalar, out[0]])
+    check(len({row[2] for row in increments}) > 1, "dirt-dependence control")
+    return {"rejected": rejected, "noncommuting_ab": list(map(str, ab)),
+            "noncommuting_ba": list(map(str, ba)), "pivot_collision": collision,
+            "dirt_dependence_all_25_states": increments}
+
+
+def evidence():
+    source = pinned_sources()
+    predecessor = original_dispatcher_counts()
+    return {"status": "PASS_BALANCED_CYCLIC_LIFT", "assignment_seed": 55,
+            "base_commit": source["base_commit"], "predecessor_count_cases": len(predecessor),
+            "predecessor_count_sha256": payload_digest(predecessor),
+            "comparison_n55": {"original_additive_leaf_calls": dict(predecessor)[55],
+                               "original_dirty_arrays": 6, "stabilized_factor_executions": 220,
+                               "stabilized_dirty_arrays": 1, "stabilized_dirty_scalars": 1,
+                               "units": "different leaf interfaces; not a runtime comparison"},
+            "factor_checks": factor_checks(), "product_checks": product_checks(),
+            "controls": controls()}
+
+
+def main():
+    check(sys.argv[1:] in ([], ["--write-certificate"]), "usage: verify.py [--write-certificate]")
+    actual = evidence()
+    output = HERE / "CERTIFICATE.json"
+    if sys.argv[1:]:
+        output.write_text(json.dumps(actual, indent=2) + "\n")
+    else:
+        # Canonical JSON distinguishes true from 1 and 1.0 from 1 under -O.
+        check(json.dumps(actual, sort_keys=True) == json.dumps(json.loads(output.read_text()), sort_keys=True), "certificate mismatch")
+    print("PASS_BALANCED_CYCLIC_LIFT: {} factors; {} full columns; {} rounded factors; {} products; {} controls; n55: 3232 additive leaves vs 220 stabilized factor executions".format(
+        actual["factor_checks"]["factors"], actual["factor_checks"]["full_columns"],
+        actual["factor_checks"]["rounded_cases"], actual["product_checks"]["cases"],
+        len(actual["controls"]["rejected"])))
+
+
+if __name__ == "__main__":
+    main()