diff --git a/research/current-serial-monomial-leaf/DEPENDENCIES.json b/research/current-serial-monomial-leaf/DEPENDENCIES.json
new file mode 100644
index 0000000000..0fb28bde24
--- /dev/null
+++ b/research/current-serial-monomial-leaf/DEPENDENCIES.json
@@ -0,0 +1,877 @@
+{
+  "schema_version": 1,
+  "files": [
+    {
+      "path": "vendor/monomial/phase_binding.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/phase_binding.py",
+      "git_blob": "7f51953eb91c53fb7b6923d3278638e1857d69ac",
+      "sha256": "7624e2421c4188f7339231263d6d8504bf7eb3acaf91dcfd745952b87a6f1cda"
+    },
+    {
+      "path": "vendor/monomial/phase_adapter.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/phase_adapter.py",
+      "git_blob": "02f0fdc3ba178f13c27c97c36260107d2c0bba82",
+      "sha256": "42687d9cd5f8f4a964e2ddd79aa404432ff26f9ebb55e9c069bbba30f0c3044f"
+    },
+    {
+      "path": "vendor/monomial/selected_service.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/selected_service.py",
+      "git_blob": "fc3cbdc16be69eeab39e887e1d3a33ea21a80cb7",
+      "sha256": "afd4ba2ae8f833e8a47456a8c2dc502fb3e12158601aba999b0d0994085bf4b0"
+    },
+    {
+      "path": "vendor/monomial/DEPENDENCIES.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/DEPENDENCIES.json",
+      "git_blob": "cbe38bbf8f0b912daddfaf6f1eb69d89343ca8ec",
+      "sha256": "40f200759a2f56a13b3cbcd1f6de9e5d6eaf9125270a7fc5dc09b82c4b4c1ed1"
+    },
+    {
+      "path": "vendor/monomial/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/PROOF.md",
+      "git_blob": "5bd585e03ce948261ef979b748a1c6df8cbc2fb4",
+      "sha256": "5bd00e9764cb628cbd92a113419c2cd79c77ba81b1e15b04519026c26ff3091f"
+    },
+    {
+      "path": "vendor/monomial/README.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/README.md",
+      "git_blob": "28d2611cd3c3cc7555451af1e36f9c4701e5a0ec",
+      "sha256": "6419eccd7796e78ae25d3c1c42ad60d6e8d0da8f8f4d4c1e3adafdf45a8c4c69"
+    },
+    {
+      "path": "vendor/monomial/SOURCES.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/SOURCES.json",
+      "git_blob": "43555e2f2717f404b752607da27a86b07c38a40d",
+      "sha256": "01b27507feb5ce1ebfd3541c280cff74ceebcc1b705a4632afe14013ab4c4e64"
+    },
+    {
+      "path": "vendor/monomial/TASK.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/TASK.json",
+      "git_blob": "4ab3215b61316d565ec6dc99c7db129c937b1e67",
+      "sha256": "4f27bee7c18e7b777e29afb11cc224fe72640b46b746d9abf1a0f075628a9982"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/DEPENDENCIES.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/DEPENDENCIES.json",
+      "git_blob": "9e68f7226669eb4b92330023e16a86739aa859ce",
+      "sha256": "8481fde09d925fe143a604a4924f05bb1ade2d1ac8f9068389680c9406f71507"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/PROOF.md",
+      "git_blob": "859eb593d3b5bb07b3fd8a3b1034b4ac19a8dd6c",
+      "sha256": "acabf664e97b35d5c63998c6f08bbea27369b36db14b203c4ef62180a9535faf"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/binding_sources.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/binding_sources.py",
+      "git_blob": "15469f097247a4627336b9bb77d03b8696533276",
+      "sha256": "e3b1cd40a2436381b3688aa3a5a740d402d08d0611dc43a629634bb1a6f7b299"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/codec.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/codec.py",
+      "git_blob": "bf3bd0d5a6fbfa1e7a56c36578c2caaa0130c7c5",
+      "sha256": "60f94c991568981c1ae8633bbc9c4d3c259e2df0654e8720d7f4554737d8e136"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/provider.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/provider.py",
+      "git_blob": "481013b988e5ae8189a0dddfcbb2f521e3142cab",
+      "sha256": "3b7bb4f7940ffa9fafd34d25bbb1a9225e1b671924ed194ad012cb26251d7460"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/DEFERRED-PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/DEFERRED-PROOF.md",
+      "git_blob": "de725a73e97496836100aa6e0ed9cd70985373da",
+      "sha256": "3a7ac6dae3b76d5f78849f521635da034fe99b1ea6c942175a3652b53f6262c2"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/SELECTED-RESULT.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/SELECTED-RESULT.json",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/TASK-CATALOG.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/TASK-CATALOG.json",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/PROOF.md",
+      "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb",
+      "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/compact_control.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/compact_control.py",
+      "git_blob": "13af719b5844f14f5cf05c919e84204cd21caf6a",
+      "sha256": "73a9ace4f91aeb383fdbc6f7762498fe707b4e4b45b1c63920bb90cc8795e284"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/compact_counts.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/compact_counts.py",
+      "git_blob": "064b508efd12f7d5a33729b2344b6890f0c75d2f",
+      "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/compact_engine.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/compact_engine.py",
+      "git_blob": "5c5ca75567f85b042c156e0ed5a8afe81671b1b8",
+      "sha256": "2cacff4d36a6e029add115f47cd8ffbf3c61e7ece0900308b98e6032e652f098"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/compact_layout.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/compact_layout.py",
+      "git_blob": "03ca12aed77741f40d824fcb33cc4eedb85abfd9",
+      "sha256": "5be2be9c32c15742da18fde438a5559a45a86eb661105027b1b233a7c397e0ce"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/compact_streams.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/compact_streams.py",
+      "git_blob": "5699cc7f20def3bc873d2da05b13a252246367a1",
+      "sha256": "3b5cce3be9763c6bd7803d6223d2784d1975eeac6c7c99f5e00dfc49bb11d249"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/compact/native_sources.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/compact/native_sources.py",
+      "git_blob": "3d2834c5fff39481c9a0442a514c10eaf50f98d2",
+      "sha256": "865c97c4f261fde37e86eb16a910eaa5b2f26daaa7d2648ae0322ba8c0286572"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/dispatch/PROOF.md",
+      "git_blob": "96b032f662397d496c4d827839441b6794881a53",
+      "sha256": "b0ed45deb84fa2ce835246d7de3c85ccdacf24ab68235cf1138fe6ff4c4ce5d9"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/TASK.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/dispatch/TASK.json",
+      "git_blob": "70bb2c54a6dbf9f17a55bbae8383d9bfde933e52",
+      "sha256": "6b5334d10044644ba646452b0e9e21528061768726d124a4a97af26785aa9ec9"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/compiler_routes.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/dispatch/compiler_routes.py",
+      "git_blob": "5752189b8a838596346df8dde89024621b513e41",
+      "sha256": "d375f8c2e666ffd2ebe6de34ccb7756ac9fa4a4cd5f866cb025a781f8538c599"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/row_programs.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/dispatch/row_programs.py",
+      "git_blob": "30ba41725f7e1ba3dd058abd30c66d19820a008d",
+      "sha256": "a59510516d1397382de6141edc1eb69cf3ba5e6e330198deb5e335e543300be4"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/vendor/occurrence_geometry.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/dispatch/vendor/occurrence_geometry.py",
+      "git_blob": "9c3c97d86a7bdd7b95944218bf1e6e4a5a1746a1",
+      "sha256": "f3504a73803da120040cc62ee8f5e8b849237daf508a7146272d55624c3f8396"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/vendor/row_padding.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/dispatch/vendor/row_padding.py",
+      "git_blob": "1e3533efa92c3bab35916ae6844290586d18ff27",
+      "sha256": "24270408e87b028791670cd63908adeb03162f0919237e8644065c5898fecf2f"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/lifecycle/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/lifecycle/PROOF.md",
+      "git_blob": "605981247e27de68fe78d3a36e2b454efbd6b11e",
+      "sha256": "9a088fa00f10e59df48090b67c6ef7c3641bc9cc36b223deb917740372d57993"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/lifecycle/machine.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/lifecycle/machine.py",
+      "git_blob": "acf475e4fccaff2fb64bd5b0b3f3fc0d246dc592",
+      "sha256": "ec597bce13275003ff30e4be481c936401826c1d4af642b55eec0c410774d1df"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/lifecycle/source_ir.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/lifecycle/source_ir.py",
+      "git_blob": "79c95fa79439f3c893de52991173bd3a5eae2729",
+      "sha256": "54dd93bc50bd10e974c70794df1c13da27f0e3d8cdb6cfe6791a63280096f1b1"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/lockstep_executor.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/lockstep_executor.py",
+      "git_blob": "9469443a3d7cc6310a7369daf77c7756d5bd3f38",
+      "sha256": "0bda14a3e5f4da348cd5c89ebe29d717e7a5406ec31b164d5b9e1d25f7f38e0e"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/PROOF.md",
+      "git_blob": "12be1f06062090fcc68e598bae250f185e3d8524",
+      "sha256": "8a1c2145cd8f080026488a571d95813c09679aa323f19aeaef0ea98030136e1c"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/binary.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/binary.py",
+      "git_blob": "651185a9eec51438949580a34e707f6dd1adbd4b",
+      "sha256": "578fb5bc793fc544dca8111605bf9f6067b8ba7dc7489a3ac243e1df3cd37953"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/encoded.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/encoded.py",
+      "git_blob": "2280fa98ff5e4da7c4909814ce4a1c405605ada8",
+      "sha256": "10ad2fa5902a48d49cf2b89a30b3f2711d63a6a43b9512a6427affcdf07335a7"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/ordinary.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/ordinary.py",
+      "git_blob": "81b330a4b886a0f4deab7b0811478bab3fbc107a",
+      "sha256": "7f8338e748bcd42fbef1e7cc47b6c5040dfb3aad216e34759bcb12b8e14f7705"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/physical_words.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/physical_words.py",
+      "git_blob": "44b464714277786297c8ee7fd04470dc6394896d",
+      "sha256": "89ba40442297ec35368e426770f44852b39807ca426710ded2735678651bef61"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/session.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/session.py",
+      "git_blob": "09f645bbf0c6c3d41d0c03e8031adc4e81744ac1",
+      "sha256": "45ee809b27a69ca5576361922fd2760f568c9a98864d4c55c4fee3003ee3c9ad"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/ordinary/source.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/ordinary/source.py",
+      "git_blob": "8594fc62cee8a111958561b75045c8ec16ebfa47",
+      "sha256": "4bd047a1272374880962d3074f1e50de717518a3a181f11607e820afe50dd4e5"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/record_lift/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/record_lift/PROOF.md",
+      "git_blob": "69e07e58c5468e2045281335a56f4918b474c79d",
+      "sha256": "8442243130d4a9932f78eb42419196d2866d4496256e3bb2d6143fd52b44ddb3"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/record_lift/lift.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/record_lift/lift.py",
+      "git_blob": "167d085a9191e3b3545bcf39d5e6edc94e54d514",
+      "sha256": "21c77119c004a86a603cca91ce1366629431db18e9e0554942492f1b5afebe4a"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/reference/NOTICE.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/reference/NOTICE.md",
+      "git_blob": "e82bfef53054bd753ba0aa8a966f84427faa2293",
+      "sha256": "74a9f03e9ce467c75f5f7cf1b8465d349ea38ef114afad261824c3bcf13da00f"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/reference/compact.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/reference/compact.py",
+      "git_blob": "60bc206c78150f23563a4775800b0dd32025843d",
+      "sha256": "0e1027a60f38c21cfd808c8ce44dcc2423810efdab0e15f02b07f261ad48fc3c"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/reference/streams.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/reference/streams.py",
+      "git_blob": "61542ce4c9eb51bfc113475b4f98649cb90a853e",
+      "sha256": "718a582a50aee8f1f04945ed942be1d4162962fe47dbf05c6ff37b7fb8c61257"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2808/outer.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2808/outer.py",
+      "git_blob": "1341d394481fb13beb826b944409b11083d8e7f8",
+      "sha256": "9a26702a853805da7f97da7272d3b610c4d69767ecc6b450efbc4b6722dc3f19"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2808/vendor/pr2786/padding.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2808/vendor/pr2786/padding.py",
+      "git_blob": "0229304638de6c78ebc519b33a6ce34b1d396ca7",
+      "sha256": "9f58bf2d343e13a70dc765d86c590b912d5987669d507ab14bd36deed94a76ee"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/consumer.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/consumer.py",
+      "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd",
+      "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/driver.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/driver.py",
+      "git_blob": "5b7846a70aada53d87480b337e1c04217118771b",
+      "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md",
+      "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e",
+      "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md",
+      "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8",
+      "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/layout.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/layout.py",
+      "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb",
+      "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/linear_sign.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/linear_sign.py",
+      "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c",
+      "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/node.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/node.py",
+      "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e",
+      "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/packet_engine.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/packet_engine.py",
+      "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7",
+      "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/peel.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/peel.py",
+      "git_blob": "38502515afc928082c849cd2cda8578d33a5050a",
+      "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md",
+      "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0",
+      "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py",
+      "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e",
+      "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py",
+      "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29",
+      "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py",
+      "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2",
+      "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py",
+      "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093",
+      "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py",
+      "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990",
+      "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py",
+      "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8",
+      "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py",
+      "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca",
+      "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py",
+      "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208",
+      "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py",
+      "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b",
+      "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py",
+      "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60",
+      "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py",
+      "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d",
+      "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py",
+      "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226",
+      "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py",
+      "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe",
+      "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py",
+      "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398",
+      "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py",
+      "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6",
+      "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py",
+      "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d",
+      "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py",
+      "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611",
+      "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py",
+      "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f",
+      "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py",
+      "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453",
+      "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py",
+      "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8",
+      "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py",
+      "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3",
+      "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py",
+      "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194",
+      "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py",
+      "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700",
+      "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py",
+      "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4",
+      "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py",
+      "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389",
+      "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/recursive_call.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/recursive_call.py",
+      "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402",
+      "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/scheduler.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/scheduler.py",
+      "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f",
+      "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/stream_runner.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/stream_runner.py",
+      "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b",
+      "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/trace.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/trace.py",
+      "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71",
+      "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/NOTICE.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/NOTICE.md",
+      "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02",
+      "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/codec.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/codec.py",
+      "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31",
+      "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py",
+      "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19",
+      "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/words.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/words.py",
+      "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50",
+      "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_binding.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/macro_binding.py",
+      "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0",
+      "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_code.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/macro_code.py",
+      "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7",
+      "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_machine.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/macro_machine.py",
+      "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16",
+      "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/residual_blocks.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/residual_blocks.py",
+      "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22",
+      "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/role_parking.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/role_parking.py",
+      "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef",
+      "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3"
+    },
+    {
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/scratch_pool.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/binding/vendor/runtime/pr2809/scratch_pool.py",
+      "git_blob": "0f22807c65d1bca374b905538512bf8c43702070",
+      "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/PROOF.md",
+      "git_blob": "82e9a8b0b50f26844528af9e07632800679805ea",
+      "sha256": "20885a8a137fc670121429625912ceae54db95ac5e574b8c64c90f477aebacb7"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/SOURCES.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/SOURCES.json",
+      "git_blob": "e040a558800e719e2d8b6237bec39e7e10a3641b",
+      "sha256": "0dd57a4fe4fc97826df0eb215975d013ac0e18f185c73cd93e34c95a9a2b4b16"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/monomial_engine.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/monomial_engine.py",
+      "git_blob": "2251fd98ba01a171f5d39b25a93c895245f10e55",
+      "sha256": "fc02c6c5159d6c258063a36ef3dc9313a34d7ba9781b650e451cc0ce971e9667"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/pair_dispatch.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/pair_dispatch.py",
+      "git_blob": "0e467bdb3727d7f354f98dee54f320f1f072aa2c",
+      "sha256": "fc0eaa2a9d0855660b15a15d894137eeebc64c6418f52b6af0d0f79d86f2e0d9"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/phase_recipe.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/phase_recipe.py",
+      "git_blob": "a2f684fb588257cc182dc88dded59ed70f5c2585",
+      "sha256": "8215e5e55daf019694e55b2acfcd42ecf109a2faf767a2181d664ba9b4957e46"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/phase_sources.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/phase_sources.py",
+      "git_blob": "aaa5c663a4bb6b0ca4d9119c1ae92064509d79c8",
+      "sha256": "3944ecbffe91fb561b2b8a810461cd2b8229f1f2611ca6a70e3d86451efb220b"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/reference.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/reference.py",
+      "git_blob": "5fa4494167c4ba668993a2b1c902969518728a4c",
+      "sha256": "394f9a465ac9148af0c20844d375e4befbef17d92b2fcc840d83419480dd4740"
+    },
+    {
+      "path": "vendor/monomial/vendor/monomial/signed_phase.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/monomial/signed_phase.py",
+      "git_blob": "bab32b0c5da7f364d6a79171c09b02d123a05bd9",
+      "sha256": "e21818674133a2bd7e63fadaf719eb45ce80db4b3806ca8ef99c247be22c2a39"
+    },
+    {
+      "path": "vendor/monomial/vendor/selected/RESULT.json",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/selected/RESULT.json",
+      "git_blob": "e4a03118d585fb80c9ac932281b528ac394ccc5f",
+      "sha256": "84fcbe2a0b64307b5703c363408042bdd91555b0419509aa50daa43b3b1924ad"
+    },
+    {
+      "path": "vendor/monomial/vendor/selected/WORD.json.gz",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/selected/WORD.json.gz",
+      "git_blob": "22f9ab02d1b73ea0aa4b07ce445a14cc2602c760",
+      "sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f"
+    },
+    {
+      "path": "vendor/monomial/vendor/selected/clifford_exact.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/selected/clifford_exact.py",
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    },
+    {
+      "path": "vendor/monomial/vendor/selected/native_verify.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/vendor/selected/native_verify.py",
+      "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c",
+      "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38"
+    },
+    {
+      "path": "vendor/monomial/check_fixture.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+      "source_path": "research/current-coded-gaussian-monomial/check_fixture.py",
+      "git_blob": "1399f50d7bedab45806cc9e1ffe74c654aa33aab",
+      "sha256": "9a7b0e372798586f63c657ba756589541ba7923175783c4a43adcdb5b31d2b41"
+    }
+  ]
+}
diff --git a/research/current-serial-monomial-leaf/INDEPENDENT-REVIEW.json b/research/current-serial-monomial-leaf/INDEPENDENT-REVIEW.json
new file mode 100644
index 0000000000..ba3f06d362
--- /dev/null
+++ b/research/current-serial-monomial-leaf/INDEPENDENT-REVIEW.json
@@ -0,0 +1,420 @@
+{
+  "artifacts": {
+    "bounded_results": "/workspace/scratch/a365d332d434/compiler-owned-serial-review/independent-check-results.json",
+    "hash_inventory": "/workspace/scratch/a365d332d434/compiler-owned-serial-review/reviewed-source-hashes.json",
+    "independent_script": "/workspace/scratch/a365d332d434/compiler-owned-serial-review/independent_checks.py"
+  },
+  "bounded_independent_checks": {
+    "canonical_preserved_only_fields": [
+      "D",
+      "cutoff",
+      "entry_start",
+      "p",
+      "q0",
+      "qB",
+      "qF",
+      "stock"
+    ],
+    "consumer_semantic_fields": [
+      "G",
+      "H",
+      "K",
+      "active_start",
+      "back_start",
+      "d",
+      "f",
+      "outer",
+      "record_bits",
+      "remainder",
+      "rho",
+      "row_bits",
+      "rows",
+      "selected_axes",
+      "within_bits"
+    ],
+    "controls": [
+      "parent-write",
+      "outside-jump",
+      "unscaled-private-stride",
+      "batched-admission-does-not-imply-intermediate-admission",
+      "late-quarter-turn-overflow",
+      "missing-tensor-constant"
+    ],
+    "counterexample_widths": [
+      2,
+      20
+    ],
+    "descriptor_fields": 23,
+    "disjoint_selected_positions": 43940,
+    "fixed_rank_compilations": 73,
+    "is_universal_proof": false,
+    "maximum_observed_child_parent_header_ratio": 1.0209059233449478,
+    "methods": {
+      "finite_tables": "read-only import of emitted implementation; separate structural validator",
+      "geometry": "direct integer identities; no package oracle import",
+      "physical": "no long numeric fixtures rerun",
+      "signed": "direct complex signed-pair permutation; no phase implementation import"
+    },
+    "next_table_rows": 1206,
+    "prepare_table_rows_range": [
+      2887,
+      2899
+    ],
+    "private_ports": 45,
+    "private_views": 1820,
+    "proof_support": "Universal claims separately reviewed by algebra/source reasoning; these are bounded failure detectors.",
+    "release_table_rows": 547,
+    "signed_phase_cases": 349504,
+    "signed_widths": [
+      2,
+      8
+    ],
+    "status": "PASS_INDEPENDENT_SMALL_CHECKS",
+    "strict_signed_pairs": 86367,
+    "valid_parent_geometries": 560
+  },
+  "canonical_base": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "check_script_sha256": "d394f177dbd979cc9bd6c1a799b7890445e249b24caa0a2eb017644a9f3ba53c",
+  "commands_executed": [
+    "python /workspace/scratch/a365d332d434/compiler-owned-serial-review/independent_checks.py"
+  ],
+  "created_utc": "2026-11-09T18:06:26.001936+00:00",
+  "exact_23_field_consumer_guard_map": [
+    {
+      "field": "outer",
+      "guard_or_treatment": "positive; outer-row count retained",
+      "raw_role": 2
+    },
+    {
+      "field": "rows",
+      "guard_or_treatment": "positive; row count retained",
+      "raw_role": 3
+    },
+    {
+      "field": "stock",
+      "guard_or_treatment": "canonical only; retained",
+      "raw_role": 4
+    },
+    {
+      "field": "row_bits",
+      "guard_or_treatment": "positive; record_bits * 2^within_bits; retained",
+      "raw_role": 5
+    },
+    {
+      "field": "within_bits",
+      "guard_or_treatment": "a, with a-z >= H; retained",
+      "raw_role": 16
+    },
+    {
+      "field": "record_bits",
+      "guard_or_treatment": "positive; exact 6*r*(h+1), positive integer r; retained",
+      "raw_role": 17
+    },
+    {
+      "field": "p",
+      "guard_or_treatment": "canonical only; retained",
+      "raw_role": 18
+    },
+    {
+      "field": "d",
+      "guard_or_treatment": "selected_axes <= d; retained",
+      "raw_role": 19
+    },
+    {
+      "field": "K",
+      "guard_or_treatment": "positive; replaced by f*K",
+      "raw_role": 20
+    },
+    {
+      "field": "G",
+      "guard_or_treatment": "positive; retained; zero used compact width at f'=1",
+      "raw_role": 21
+    },
+    {
+      "field": "H",
+      "guard_or_treatment": "positive; retained",
+      "raw_role": 22
+    },
+    {
+      "field": "q0",
+      "guard_or_treatment": "canonical only; retained",
+      "raw_role": 23
+    },
+    {
+      "field": "qF",
+      "guard_or_treatment": "canonical only; retained",
+      "raw_role": 24
+    },
+    {
+      "field": "qB",
+      "guard_or_treatment": "canonical only; retained",
+      "raw_role": 25
+    },
+    {
+      "field": "D",
+      "guard_or_treatment": "canonical only; retained",
+      "raw_role": 26
+    },
+    {
+      "field": "f",
+      "guard_or_treatment": "positive; replaced by 1",
+      "raw_role": 27
+    },
+    {
+      "field": "rho",
+      "guard_or_treatment": "0<=rho<K; replaced by j*K+rho",
+      "raw_role": 28
+    },
+    {
+      "field": "active_start",
+      "guard_or_treatment": "u>=2H; retained",
+      "raw_role": 29
+    },
+    {
+      "field": "back_start",
+      "guard_or_treatment": "z>=u+m*f*K; retained",
+      "raw_role": 30
+    },
+    {
+      "field": "selected_axes",
+      "guard_or_treatment": "equals m*f+e<=d; replaced by m+e",
+      "raw_role": 31
+    },
+    {
+      "field": "entry_start",
+      "guard_or_treatment": "canonical only; retained; producer relations with the new K need not hold",
+      "raw_role": 32
+    },
+    {
+      "field": "remainder",
+      "guard_or_treatment": "0<=e<m; retained",
+      "raw_role": 33
+    },
+    {
+      "field": "cutoff",
+      "guard_or_treatment": "canonical only; retained; global leaf cutoff remains separate",
+      "raw_role": 34
+    }
+  ],
+  "limitations": [
+    "No long physical fixture rerun. Structural table inspection imports implementation, but mathematical oracles import none of the submitted checkers.",
+    "Source/conditional theorem audit, not proof of every inherited primitive or a whole lifecycle flat-table export.",
+    "No full selected nine-axis physical MOVE, full caller, selected kappa or foundational multiplication assumption is established by these bounded checks.",
+    "Only exact recorded hashes are reviewed. Subsequent changes require delta review; the root still owns registered gates and publication."
+  ],
+  "mid_review_document_delta": [
+    {
+      "delta_review": "Read exact diff: adds h>=2, complete format, origins/disjointness/blank-prefix premises, and private-consumer-only restrictions. Accepted.",
+      "new_sha256": "08ccee8847d1ea697f4c08e29072066bed37b6bd9b96b5559776a776268a1ce9",
+      "old_sha256": "46932576af8e080bc41f692d05cb89440f24829cebd36b749fa736eeba41efe6",
+      "path": "PROOF.md"
+    }
+  ],
+  "nonblocking_clarifications": [
+    {
+      "location": "PROOF section 1",
+      "status": "addressed by reviewed delta",
+      "text": "Explicit h>=2, uniform canonical field format, initially blank private current prefixes, aligned origin markers, actual physical disjointness."
+    },
+    {
+      "location": "PROOF section 1",
+      "status": "addressed by reviewed delta",
+      "text": "Private consumer views need not satisfy unrelated entry_start/p producer relations; never passed to ordinary."
+    },
+    {
+      "location": "PROOF section 4",
+      "status": "minor wording suggestion",
+      "text": "Use intermediate negation instead of intermediate negative: negating the most-negative signed word creates an out-of-range positive."
+    }
+  ],
+  "package": "/workspace/scratch/a365d332d434/serial-monomial/research/current-serial-monomial-leaf",
+  "preexisting_receipts_read_not_rerun": {
+    "actual_forward_physical_actions": 85897601,
+    "actual_inverse_physical_actions": 86035950,
+    "actual_selected_nine_axis_move": false,
+    "history_fresh_and_reused_small_actions": 4269685,
+    "history_fresh_private_cells": 41133,
+    "history_reused_private_cells": 134719,
+    "note": "These are root receipts, not independently rerun physical tests.",
+    "ordinary_entry_failure_detector": true
+  },
+  "public_monomial_dependency": "CubeJerry/integer-mult-bounds@7d1ff23714e6f9182c1d0ff9214f65def2f30e04",
+  "publication_status": "Draft review only; root owns remaining gates/packaging/publication",
+  "review_type": "Independent complementary reasoning/source audit with bounded code-assisted checks",
+  "reviewed_source_hashes": [
+    {
+      "bytes": 9174,
+      "git_blob": "6e7c0d919f5c0eb973067295a5b9e4a12ee13f30",
+      "path": "PROOF.md",
+      "sha256": "08ccee8847d1ea697f4c08e29072066bed37b6bd9b96b5559776a776268a1ce9"
+    },
+    {
+      "bytes": 6733,
+      "git_blob": "f547ed7a72d89fdfd23f6c54a9983b522e16076d",
+      "path": "column_view.py",
+      "sha256": "fb19f59af7c8ef8f502c99cc4837d55a4e35f42b6334a3589cb37795b7627117"
+    },
+    {
+      "bytes": 2314,
+      "git_blob": "54ab34373b67d61bddd44d1cc8d36491c8a2015c",
+      "path": "serial_sources.py",
+      "sha256": "dbed4c5d139f5d4da0b9db9f8f7105d5eb59e44df4dbe4f499272a1e0130dbc4"
+    },
+    {
+      "bytes": 51654,
+      "git_blob": "0fb28bde24d05254418ccd2b73e01bcdc697c839",
+      "path": "DEPENDENCIES.json",
+      "sha256": "6fadae340babb68b55076127bed4deecd2b4d4a3bcf1963b26f8631c32b61f1a"
+    },
+    {
+      "bytes": 2371,
+      "git_blob": "09004fa542a41f7753c6683a2d48cbe9e0a1bcd5",
+      "path": "SOURCES.json",
+      "sha256": "4b1a0a1bb46370e3a8425e596b73a4c80f58ad8baa15424543157574a3c9aa28"
+    },
+    {
+      "bytes": 13438,
+      "git_blob": "ba50c9cf41b57c080b48dee5bca39a4937a6493e",
+      "path": "RESULT.json",
+      "sha256": "a423c0dd332954fa7f4a666709ed53449939a393e38792f2e01c542a1f0f3f38"
+    },
+    {
+      "bytes": 6768,
+      "git_blob": "8bcdc6f53cf20e0e0877c3337673721a64d1a9f4",
+      "path": "check_descriptor.py",
+      "sha256": "ba8ac01a0bd6b17764505f4bb18f9ff028196e696472ecf95da54a96e4083edf"
+    },
+    {
+      "bytes": 4336,
+      "git_blob": "97326a5aaa67a47e420e8c75ea8922852310c3ca",
+      "path": "check_algebra.py",
+      "sha256": "df23088def20d28a47fe21de75c5388fa35bddf9e66bedee54a82eb30a734d32"
+    },
+    {
+      "bytes": 6765,
+      "git_blob": "573d8472ff0b368182c8d37fbceca7bb5a0eb0e7",
+      "path": "check_numeric.py",
+      "sha256": "30c052af1d52a4ce822b9bbaf55d7cc7725e9602473ced156edd93cfb49e4b9f"
+    },
+    {
+      "bytes": 1663,
+      "git_blob": "c636243c6993dc084634c030f6f87b6e34564a19",
+      "path": "verify.py",
+      "sha256": "94a6b7a539fb4b1f02bebaad61e46feb32aa8b6571e87345101864b4f977d30a"
+    },
+    {
+      "bytes": 9463,
+      "git_blob": "02f0fdc3ba178f13c27c97c36260107d2c0bba82",
+      "path": "vendor/monomial/phase_adapter.py",
+      "sha256": "42687d9cd5f8f4a964e2ddd79aa404432ff26f9ebb55e9c069bbba30f0c3044f"
+    },
+    {
+      "bytes": 24018,
+      "git_blob": "5bd585e03ce948261ef979b748a1c6df8cbc2fb4",
+      "path": "vendor/monomial/PROOF.md",
+      "sha256": "5bd00e9764cb628cbd92a113419c2cd79c77ba81b1e15b04519026c26ff3091f"
+    },
+    {
+      "bytes": 8584,
+      "git_blob": "2251fd98ba01a171f5d39b25a93c895245f10e55",
+      "path": "vendor/monomial/vendor/monomial/monomial_engine.py",
+      "sha256": "fc02c6c5159d6c258063a36ef3dc9313a34d7ba9781b650e451cc0ce971e9667"
+    },
+    {
+      "bytes": 12856,
+      "git_blob": "82e9a8b0b50f26844528af9e07632800679805ea",
+      "path": "vendor/monomial/vendor/monomial/PROOF.md",
+      "sha256": "20885a8a137fc670121429625912ceae54db95ac5e574b8c64c90f477aebacb7"
+    },
+    {
+      "bytes": 9914,
+      "git_blob": "bf3bd0d5a6fbfa1e7a56c36578c2caaa0130c7c5",
+      "path": "vendor/monomial/vendor/binding/codec.py",
+      "sha256": "60f94c991568981c1ae8633bbc9c4d3c259e2df0654e8720d7f4554737d8e136"
+    },
+    {
+      "bytes": 10325,
+      "git_blob": "481013b988e5ae8189a0dddfcbb2f521e3142cab",
+      "path": "vendor/monomial/vendor/binding/provider.py",
+      "sha256": "3b7bb4f7940ffa9fafd34d25bbb1a9225e1b671924ed194ad012cb26251d7460"
+    },
+    {
+      "bytes": 23631,
+      "git_blob": "30ba41725f7e1ba3dd058abd30c66d19820a008d",
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/row_programs.py",
+      "sha256": "a59510516d1397382de6141edc1eb69cf3ba5e6e330198deb5e335e543300be4"
+    },
+    {
+      "bytes": 10721,
+      "git_blob": "1e3533efa92c3bab35916ae6844290586d18ff27",
+      "path": "vendor/monomial/vendor/binding/vendor/dispatch/vendor/row_padding.py",
+      "sha256": "24270408e87b028791670cd63908adeb03162f0919237e8644065c5898fecf2f"
+    },
+    {
+      "bytes": 5621,
+      "git_blob": "064b508efd12f7d5a33729b2344b6890f0c75d2f",
+      "path": "vendor/monomial/vendor/binding/vendor/compact/compact_counts.py",
+      "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d"
+    },
+    {
+      "bytes": 1861,
+      "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e",
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py",
+      "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f"
+    },
+    {
+      "bytes": 1695,
+      "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d",
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py",
+      "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069"
+    },
+    {
+      "bytes": 5523,
+      "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389",
+      "path": "vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py",
+      "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5"
+    },
+    {
+      "bytes": 2265,
+      "git_blob": "a2f684fb588257cc182dc88dded59ed70f5c2585",
+      "path": "vendor/monomial/vendor/monomial/phase_recipe.py",
+      "sha256": "8215e5e55daf019694e55b2acfcd42ecf109a2faf767a2181d664ba9b4957e46"
+    }
+  ],
+  "reviewer": "/root/compiler_owned, OpenAI-assisted agent; no human or proof-kernel independence claimed",
+  "root_source_files_edited": false,
+  "schema_version": 1,
+  "status": "NO_MATHEMATICAL_BLOCKER_FOUND_UNDER_EXPLICIT_AND_INHERITED_PREMISES",
+  "track": 75,
+  "universal_reasoning": [
+    {
+      "argument": "For 0<=j<f, K'=fK and rho'=jK+rho give 0<=rho'<K'. Rank admission becomes m+e<=mf+e<=d. n'=0 gives compact=0, rest=H, before=u-2H, after=z-u-mfK, suffix=a-z. All are admitted by parent inequalities. All 19 retained fields are unchanged. Eight fields are parsed but not semantically used by this exact consumer; the private view must not be passed to generic producer/ordinary interfaces.",
+      "claim": "Descriptor guards"
+    },
+    {
+      "argument": "One-column widths sum to z; the coefficient suffix is a-z. Thus 2^z*(2hr*2^(a-z))=2^a*2hr for every complete row. Chosen positions equal u+(if+j)K+rho. Columns have disjoint coordinate factors, so their full monomial maps commute and multiply to the parent tensor map, including one constant phase per column. Inverses commute likewise.",
+      "claim": "Complete field and phase"
+    },
+    {
+      "argument": "The unchanged engine computes n=f'-1=0, hence every affine gate enters single_column_rows. It invokes flip_digit/digit_permutation and cannot call compact_gate, the route into PairDispatch/ordinary. Ordinary construction and its fixed port inventory still exist and must remain charged.",
+      "claim": "Exact one-column branch"
+    },
+    {
+      "argument": "PREPARE increments an encoded counter from 0 to f while adding K, then resets column to zero. Every NEXT follows a completed native call, increments column once, and either emits rho+jK or finishes exactly at f. All scans are over admitted finite prefixes; all current private prefixes are erased and heads restored by RELEASE. Parent/markers are never written. Arbitrary malformed origin markers are outside this cleanup theorem.",
+      "claim": "Finite control and cleanup"
+    },
+    {
+      "argument": "A phase i^p acts by a signed pair permutation: p=1 requires imaginary != most-negative; p=2 requires both != most-negative; p=3 requires real != most-negative; p=0 has no negation restriction. Strict symmetric component headroom is invariant. The constant-2/f=2 and constant-1/f=4 examples have representable batched endpoints but unrepresentable intermediate serial phases. Later rejection can leave earlier columns committed, so no whole-job rollback follows.",
+      "claim": "Signed domain"
+    },
+    {
+      "argument": "The inherited one-column source bill is charged f times, including full-field import/export, protected copies, affine gates, signed scans, encoded setup, cohort marker initialization, retirement, and every fixed Q role including unused ordinary ports. Metadata O(f(E+1)) is absorbed by displayed f(E+1)^4. Count multiplication scans binary digits, so zero times large G is polynomial in descriptor length. power_two loops at most a, bounded by E from row_bits=record_bits*2^a; signed-format counting uses amortized ripple counters. This validates the repeated bill relative to the cited inherited native cost theorem.",
+      "claim": "Complete repeated time"
+    },
+    {
+      "argument": "Both the 45 descriptor roles and all native roles retain historical maximum physical backing. Current-prefix retirement does not free old cells. A later small call can stop at a fresh blank current frontier without scanning erased older allocation, which remains in space. O(fV) requires both explicit R1>=A1^6 and (E+1)^4+Q=O(V); these do not follow for arbitrary admitted geometry. The global rank-times-f cutoff and full compiler/precision/ownership composition remain open.",
+      "claim": "Backing and absorption"
+    }
+  ],
+  "wave": 4
+}
diff --git a/research/current-serial-monomial-leaf/PR-DESCRIPTION.md b/research/current-serial-monomial-leaf/PR-DESCRIPTION.md
new file mode 100644
index 0000000000..929bdfb2ba
--- /dev/null
+++ b/research/current-serial-monomial-leaf/PR-DESCRIPTION.md
@@ -0,0 +1,51 @@
+## Result
+
+A direct current-format f-column monomial can use the unchanged one-column
+branch f times, with **zero ordinary-runtime calls**, on an explicit
+intermediate signed-headroom domain. 45 fixed ports and literal tables compute
+`f'=1, K'=fK, rho'=jK+rho, selected_axes'=m+remainder` without host size decoding.
+Every complete field/spectator and absolute tensor phase is retained.
+
+The full cost is f times the complete one-column bill, including format/setup,
+history and fixed inventory. Under stated long-record/metadata absorption it
+is `F_template+O_m(fV)`. No faster nonleaf tariff or global cutoff is claimed.
+
+The original batched acceptance domain is larger: an actual constant-minus-one
+f=2 packet accepts its most-negative signed component when batched and rejects
+at the first serialized negation. Strict symmetric headroom suffices. A paid
+protected stage remains necessary for whole-job rollback.
+
+## Novelty and pins
+
+CrocSwap/integer-mult-bounds#4172 already gives the one-column zero-ordinary
+fact and history theorem. CrocSwap/integer-mult-bounds#3087 supplies the
+monomial lineage; CrocSwap/integer-mult-bounds#6293 and
+CrocSwap/integer-mult-bounds#6930 supply source phases. This contribution is
+the physically encoded multi-column direct implication and its precise domain.
+
+Base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`. Unchanged current monomial:
+`CubeJerry/integer-mult-bounds@7d1ff23714e6f9182c1d0ff9214f65def2f30e04`.
+All 109 dependency files have exact blob/SHA256 pins and are vendored unchanged.
+
+## Reproduction
+
+```
+python3.12 -B scripts/research_package.py --package research/current-serial-monomial-leaf
+```
+
+Normal/optimized bounded gates check 30 physical descriptor cases, 6,144 algebra
+cases, actual 128-record forward/inverse packets, the executed acceptance-domain
+counterexample and reusable history. Exact receipts are in RESULT.json and
+publication verification in VERIFICATION.md. Smaller numerical recipes do not
+constitute a complete selected nine-axis MOVE execution.
+
+## Limitations and credit
+
+**No new kappa.** All five framework assumptions remain. Full source/child
+composition, global cutoff/precision/stock and complete source-to-table export
+are open; only descriptor iteration is literal finite tables. A finite test
+does not replace the universal source argument.
+
+Prepared for **@CubeJerry**, with substantial OpenAI assistance in research,
+proofs, implementation and adversarial review. Preserve the credited
+predecessors and notices, including Clear1nsight and unpaidmoon.
diff --git a/research/current-serial-monomial-leaf/PR-TITLE.txt b/research/current-serial-monomial-leaf/PR-TITLE.txt
new file mode 100644
index 0000000000..1413313b7a
--- /dev/null
+++ b/research/current-serial-monomial-leaf/PR-TITLE.txt
@@ -0,0 +1 @@
+Serialize current monomials through direct one-column views (no new kappa)
diff --git a/research/current-serial-monomial-leaf/PROOF.md b/research/current-serial-monomial-leaf/PROOF.md
new file mode 100644
index 0000000000..f6097b1855
--- /dev/null
+++ b/research/current-serial-monomial-leaf/PROOF.md
@@ -0,0 +1,160 @@
+# Direct current monomials without ordinary runtime calls
+
+**Conditional enabling lemma; executed gates and complementary review passed. No new kappa.**
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+
+Canonical base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+Exact unchanged monomial dependency:
+`CubeJerry/integer-mult-bounds@7d1ff23714e6f9182c1d0ff9214f65def2f30e04`,
+`research/current-coded-gaussian-monomial`. Every reused byte is separately
+authenticated by DEPENDENCIES.json. No retained monomial, Compact, Count,
+Tape, or ordinary constructor source is changed.
+
+## Claim, useful domain and predecessor distinction
+
+The retained monomial already has a genuine one-column branch with no ordinary
+runtime invocation. That fact and source history/action analysis are prior
+results, including [#3087](https://github.com/CrocSwap/integer-mult-bounds/pull/3087)
+and [#4172](https://github.com/CrocSwap/integer-mult-bounds/pull/4172). Current
+descriptor adaptation is the public monomial package above. Literal local
+header views are also supplied by public commit
+`772198276518065c6ae42ef4bafc77df9c3c73b3`. These mechanisms are not claimed new.
+The new implication serializes a complete valid current multi-column monomial
+through actual one-column calls, with an exact private descriptor identity,
+absolute tensor phases, a physically encoded iterator, and its repeated bill.
+
+**Conditional theorem.** On valid current geometry and the domain where every
+serialized intermediate signed phase fits, SerialProvider executes exactly
+the parent tensor monomial, including its absolute phase, without any ordinary
+runtime call. A sufficient uniform domain has every real and imaginary signed
+component strictly between -2^(h-1) and 2^(h-1). This is narrower than the
+original batched provider's success domain; see the counterexample in section4.
+
+This is a direct leaf alternative, with all costs below. It does not establish
+the faster nonleaf ordinary tariff or an accepted recursive recurrence. It
+removes a completed ordinary runtime numerical/rate premise from this route,
+while retaining its finite constructor/inventory and all digit-permutation,
+signed-phase, physical-tape, ownership and format contracts.
+
+## 1. Exact geometry and operator identity
+
+Retain the monomial provider's complete coded-field contract: uniform signed
+component width h>=2, its exact record delimiters and common quantum, supplied
+local LEFT markers and aligned origins, and actually disjoint public, context
+and private segments. Current private prefixes start physically blank; previous
+erased backing remains allocated. These are caller premises, not inferred
+from object identity or a short fixture.
+
+Let a valid parent monomial descriptor have fixed recipe rank m, positive f,K,
+0<=rho<K, active start u, back start z, address width a, positive H,G, and
+remainder e with 0<=e<m. Its selected axes are mf+e<=d. It obeys
+
+    (f-1)G <= H,  2H <= u,  u+mfK <= z,  z+H <= a.
+
+The complete row satisfies row_bits=record_bits*2^a, with unchanged outer
+count, row count, signed component width and common grid. The parent recipe
+acts on bit positions u+(if+j)K+rho, for i=0,...,m-1 and j=0,...,f-1.
+
+For column j construct a private descriptor with exactly four changed fields:
+
+    f'=1,  K'=fK,  rho'=jK+rho,  selected_axes'=m+e.
+
+All nineteen other fields remain unchanged, including e,p,d,H,G,u,z,a,
+entry_start, row_bits, record_bits, grids and cutoff. This private monomial
+view is never supplied to an ordinary provider. It need not preserve unused
+global producer relationships involving p or entry_start. Only the exact
+retained monomial consumer and its stated guards receive it.
+
+We have 0<=rho'<K' and m+e<=mf+e<=d. The used compact reservation t' is zero;
+before=u-2H and after=z-u-mfK are unchanged. Used widths become
+(0,H,0,H,before,fK,...,fK,after,0). The coefficient suffix grows to a-z,
+exactly offsetting the smaller enumerated address extent z, so no complete
+field bit is dropped. The chosen position is exactly
+u+iK'+rho'=u+(if+j)K+rho. Each actual one-column call therefore applies the
+recipe on column j, preserving every other coordinate, coefficient and row.
+
+Different columns use disjoint coordinate factors. Their complete linear maps
+commute and their product is the parent tensor monomial. The constant Gaussian
+phase occurs once per column, giving i^(f*c), not i^c. Inverse one-column maps
+likewise multiply to the inverse parent map. Equality includes absolute phase.
+
+The unchanged engine computes n=f'-1=0 and uses single_column_rows for every
+affine gate. Its flip_digit/digit_permutation route never calls compact_gate
+or the ordinary engine. Signed phases, full-field conversion/copying and
+cleanup still execute. Exact numerical success requires the stated additional
+intermediate representability condition.
+
+## 2. Physically encoded descriptor iteration
+
+column_view.py emits finite PREPARE, NEXT and RELEASE tables from the unchanged
+Builder. Runtime instructions are local symbol reads/writes, unit moves,
+jumps and two fixed terminal labels. Forty-five fixed private raw binary ports
+hold decoded fields, saved f and K, a counter, sum and private child view.
+No runtime shape is decoded into a Python integer or used to allocate work.
+
+PREPARE decodes 23 canonical fields, checks positive f,K and computes fK by
+physically encoded repeated addition of K, comparing an encoded counter to f.
+It writes f'=1 and m+e, resets j=0 and emits the first view. NEXT destroys the
+private view, increments j and compares it with f. For j<f it adds old K to
+rho' and encodes another complete view; at equality it returns `finished`.
+RELEASE clears all current private prefixes and restores origins. The wrapper
+invokes one real unchanged monomial provider between `ready` and NEXT.
+
+The provider is constructed/bound once and never reset or recreated between
+columns; its closed ordinary object remains allocated. Parent bytes and all
+ancestor prefixes are read-only. Valid parent geometry is an input premise,
+not a consequence of checking canonical encoding and positive f,K.
+
+Let E be the original descriptor length. bitlength(fK)<=bitlength(f)+bitlength(K)
+and bitlength(jK+rho)<=bitlength(fK), so child and working lengths are O(E+1).
+PREPARE costs O(f(E+1)), each NEXT O(E+1), and RELEASE O(E+1). Thus metadata
+cost is O(f(E+1)), with O(E+1) current backing per fixed role. Historical
+backing remains counted. Later small calls scan their current prefixes and
+receive no free allocator/history reset.
+
+## 3. Full optimistic invoice and useful asymptotic domain
+
+Write C=outer*rows, R1=2hr*2^(a-z), M1=C*2^z, Vraw=M1*R1,
+and A1=2+z+ceil(log2(R1+1)). Let g count the finite affine gates and V be the
+complete coded field length. Each one-column call pays its entire inherited
+bill, codec, encoded setup and retirement, hence
+
+    F_template + O_m(f*((g+1)*(Vraw+M1*A1^6) + V + (E+1)^4 + Q)).
+
+Q includes the complete fixed work inventory, including unused ordinary
+tapes. Setup is paid f times; provider/ancestor historical maxima remain in
+the space bill. No ordinary cost is subtracted from an unrelated upper bound.
+Under explicit R1>=A1^6 and (E+1)^4+Q=O(V), this is F_template+O_m(fV).
+The larger displayed bill remains if either absorption condition fails.
+
+This can match a direct PAID-leaf budget when a separate global cutoff admits
+the complete source construction, including rf<=cutoff for a rank-r leaf.
+No such cutoff, compiled stock/precision substitution, new supplier rate or
+assembled kappa is established here.
+
+## 4. Strict numerical-domain distinction and rejection
+
+Phases act as signed permutations of the real/imaginary components. Strict
+symmetric component headroom is invariant under every such phase and address
+permutation, proving all intermediate representability in the sufficient
+domain. The unchanged common grid needs no extra arithmetic rounding.
+
+The original combined-phase admission does not suffice. For a constant-phase-2
+monomial with f=2, the tensor phase is +1, so a most-negative h-bit component
+can pass the batched phase. The first serialized column multiplies it by -1,
+which cannot fit. Thus the two acceptance domains are provably different.
+For the actual selected right recipe, whose constant is1, f=4 and an input
+supported on the all-zero selected bits similarly has combined phase +1;
+serial quarter rotations can expose an unrepresentable intermediate negation.
+This caveat was found by the separate native worker's adversarial review.
+
+Each retained one-column call preserves its input on its named arithmetic
+rejection. Earlier completed columns can nevertheless have changed the serial
+field. SerialProvider therefore has no whole-job rollback guarantee. A full
+protected stage, such as the separately published atomic MOVE wrapper, must
+pay transfer/commit/retirement to obtain that property. No interruption or
+malformed-success rollback is claimed.
+
+Global native source correctness, the full compiler placement, ownership,
+precision and analytic multiplication assumptions remain. Finite witnesses
+do not discharge those universal premises, and no accepted certificate changes.
diff --git a/research/current-serial-monomial-leaf/README.md b/research/current-serial-monomial-leaf/README.md
new file mode 100644
index 0000000000..dba6861e01
--- /dev/null
+++ b/research/current-serial-monomial-leaf/README.md
@@ -0,0 +1,92 @@
+# Direct current monomials through one-column views
+
+**No new kappa. Conditional enabling lemma; executed gates and complementary review passed.**
+
+A current f-column monomial can be serialized through the unchanged source's
+genuine one-column branch, using private descriptors
+`f'=1, K'=fK, rho'=jK+rho, selected_axes'=m+remainder`. All other 19 fields,
+complete numerical records, spectators and absolute tensor phases are retained.
+Finite local tables compute/iterate these views on 45 fixed physical ports;
+runtime sizes never become host numerical loop bounds. The actual branch
+executes no ordinary runtime call.
+
+The required domain is narrower than the original batched success domain.
+Every intermediate signed phase must fit; strict symmetric component headroom
+suffices. An executed constant-minus-one example at f=2 accepts the most-negative
+signed value when batched and rejects when serialized. SerialProvider itself
+does not undo earlier completed columns after a later rejection; whole-job
+atomicity needs a paid protected full-field stage.
+
+## Complete result and cost
+
+[PROOF.md](PROOF.md) gives the quantified source/geometry proof and full bill:
+
+```
+F_template + O_m(f*((g+1)*(Vraw+M1*A1^6) + V + (E+1)^4 + Q)).
+```
+
+Only under explicit `R1>=A1^6` and `(E+1)^4+Q=O(V)` does this become
+`F_template+O_m(fV)`. The alternative removes a completed ordinary runtime
+numerical/rate premise. Finite constructors, the entire fixed inventory,
+all phase/permutation primitives, copies, retirement and historical backing
+remain paid. It proves no faster nonleaf tariff or global cutoff admission.
+
+## Evidence and reproduction
+
+[RESULT.json](RESULT.json) records 30 descriptor cases, a 4096-bit unused source
+field and history/rejection controls; 6,144 source-coordinate tensor/inverse
+checks including both actual raw MOVE9896 factors; and actual rank-two
+two-column forward/inverse 128-record packets. The numerical packets cost
+85,897,601 and 86,035,950 actions with zero ordinary runtime entry and exact
+independently predicted endpoints. The 32-record batch/serial domain
+counterexample is executed on both paths. A reusable longer-to-shorter call
+preserves old backing while matching the fresh short call's 4,269,685 actions.
+Materialized-cell observations are distinguished from the full backing theorem.
+
+These smaller genuine numerical recipes do not constitute a complete nine-axis
+selected MOVE execution. Only the descriptor iterator is literal finite tables;
+the numerical service remains unchanged structured source control.
+
+```
+python3.12 -B scripts/research_package.py --package research/current-serial-monomial-leaf
+```
+
+The eight normal/optimized registered commands each have a 90-second cap. They
+authenticate 109 vendored source files and compare exact outputs/actions to
+receipts; nondeterministic wall times are excluded from equality.
+
+Canonical base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`. Current monomial:
+[7d1ff237](https://github.com/CubeJerry/integer-mult-bounds/tree/7d1ff23714e6f9182c1d0ff9214f65def2f30e04/research/current-coded-gaussian-monomial).
+[DEPENDENCIES.json](DEPENDENCIES.json) pins every unchanged foreign source byte;
+all required bytes are committed here, without an unmerged ancestry requirement.
+[SOURCES.json](SOURCES.json) retains canonical provenance.
+
+## Novelty, obligations and credit
+
+[#4172](https://github.com/CrocSwap/integer-mult-bounds/pull/4172) already proves
+the one-column zero-ordinary fact and history/action coupling. The monomial
+and source-phase lineage includes
+[#3087](https://github.com/CrocSwap/integer-mult-bounds/pull/3087),
+[#6293](https://github.com/CrocSwap/integer-mult-bounds/pull/6293) and
+[#6930](https://github.com/CrocSwap/integer-mult-bounds/pull/6930).
+The public native header view 772198276518065c6ae42ef4bafc77df9c3c73b3 and
+row-dispatch Builder precede this work. The contribution is their exact
+physically encoded multi-column implication, full repeated bill and necessary
+acceptance-domain distinction, not a new one-column primitive.
+
+All five selected assumptions remain. [TASK.json](TASK.json) lists the remaining
+source/child composition, global cutoff/precision/stock and complete table
+export obligations. No selected certificate changes.
+
+## Open next questions
+
+The structured questions in [TASK.json](TASK.json) give the reasons, first
+steps and blockers for composing all actual source/child boundaries, proving
+the global cutoff and long-record admission, and exporting the complete
+numerical service as lifecycle tables. These are separate obligations; this
+package does not resolve them by changing a descriptor.
+
+Prepared for **@CubeJerry** with substantial OpenAI assistance. Retain all
+predecessor notices and credits, including Clear1nsight's history work and
+unpaidmoon's phase audit. Independent AI review is not human or proof-kernel
+acceptance.
diff --git a/research/current-serial-monomial-leaf/RESULT.json b/research/current-serial-monomial-leaf/RESULT.json
new file mode 100644
index 0000000000..ba50c9cf41
--- /dev/null
+++ b/research/current-serial-monomial-leaf/RESULT.json
@@ -0,0 +1,552 @@
+{
+  "descriptor": {
+    "cases": [
+      {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 151,
+        "maximum_view_bits": 151,
+        "physical_actions": 6309,
+        "rank": 1,
+        "retained_materialized_cells": 476
+      },
+      {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 161,
+        "maximum_view_bits": 161,
+        "physical_actions": 6686,
+        "rank": 1,
+        "retained_materialized_cells": 496
+      },
+      {
+        "columns": 2,
+        "f": 2,
+        "input_bits": 163,
+        "maximum_view_bits": 161,
+        "physical_actions": 9583,
+        "rank": 1,
+        "retained_materialized_cells": 503
+      },
+      {
+        "columns": 2,
+        "f": 2,
+        "input_bits": 179,
+        "maximum_view_bits": 179,
+        "physical_actions": 10506,
+        "rank": 1,
+        "retained_materialized_cells": 532
+      },
+      {
+        "columns": 3,
+        "f": 3,
+        "input_bits": 177,
+        "maximum_view_bits": 177,
+        "physical_actions": 13378,
+        "rank": 1,
+        "retained_materialized_cells": 534
+      },
+      {
+        "columns": 3,
+        "f": 3,
+        "input_bits": 195,
+        "maximum_view_bits": 199,
+        "physical_actions": 14909,
+        "rank": 1,
+        "retained_materialized_cells": 570
+      },
+      {
+        "columns": 7,
+        "f": 7,
+        "input_bits": 231,
+        "maximum_view_bits": 231,
+        "physical_actions": 32723,
+        "rank": 1,
+        "retained_materialized_cells": 634
+      },
+      {
+        "columns": 7,
+        "f": 7,
+        "input_bits": 265,
+        "maximum_view_bits": 269,
+        "physical_actions": 37871,
+        "rank": 1,
+        "retained_materialized_cells": 705
+      },
+      {
+        "columns": 17,
+        "f": 17,
+        "input_bits": 349,
+        "maximum_view_bits": 349,
+        "physical_actions": 105263,
+        "rank": 1,
+        "retained_materialized_cells": 859
+      },
+      {
+        "columns": 17,
+        "f": 17,
+        "input_bits": 423,
+        "maximum_view_bits": 423,
+        "physical_actions": 127308,
+        "rank": 1,
+        "retained_materialized_cells": 1006
+      },
+      {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 165,
+        "maximum_view_bits": 165,
+        "physical_actions": 6780,
+        "rank": 2,
+        "retained_materialized_cells": 500
+      },
+      {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 185,
+        "maximum_view_bits": 185,
+        "physical_actions": 7477,
+        "rank": 2,
+        "retained_materialized_cells": 539
+      },
+      {
+        "columns": 2,
+        "f": 2,
+        "input_bits": 181,
+        "maximum_view_bits": 179,
+        "physical_actions": 10452,
+        "rank": 2,
+        "retained_materialized_cells": 547
+      },
+      {
+        "columns": 2,
+        "f": 2,
+        "input_bits": 209,
+        "maximum_view_bits": 209,
+        "physical_actions": 11939,
+        "rank": 2,
+        "retained_materialized_cells": 587
+      },
+      {
+        "columns": 3,
+        "f": 3,
+        "input_bits": 199,
+        "maximum_view_bits": 199,
+        "physical_actions": 14765,
+        "rank": 2,
+        "retained_materialized_cells": 589
+      },
+      {
+        "columns": 3,
+        "f": 3,
+        "input_bits": 235,
+        "maximum_view_bits": 239,
+        "physical_actions": 17412,
+        "rank": 2,
+        "retained_materialized_cells": 643
+      },
+      {
+        "columns": 7,
+        "f": 7,
+        "input_bits": 261,
+        "maximum_view_bits": 261,
+        "physical_actions": 36406,
+        "rank": 2,
+        "retained_materialized_cells": 688
+      },
+      {
+        "columns": 7,
+        "f": 7,
+        "input_bits": 329,
+        "maximum_view_bits": 333,
+        "physical_actions": 45702,
+        "rank": 2,
+        "retained_materialized_cells": 826
+      },
+      {
+        "columns": 17,
+        "f": 17,
+        "input_bits": 397,
+        "maximum_view_bits": 397,
+        "physical_actions": 118342,
+        "rank": 2,
+        "retained_materialized_cells": 950
+      },
+      {
+        "columns": 17,
+        "f": 17,
+        "input_bits": 545,
+        "maximum_view_bits": 545,
+        "physical_actions": 160515,
+        "rank": 2,
+        "retained_materialized_cells": 1244
+      },
+      {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 231,
+        "maximum_view_bits": 231,
+        "physical_actions": 8958,
+        "rank": 9,
+        "retained_materialized_cells": 615
+      },
+      {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 311,
+        "maximum_view_bits": 311,
+        "physical_actions": 11575,
+        "rank": 9,
+        "retained_materialized_cells": 772
+      },
+      {
+        "columns": 2,
+        "f": 2,
+        "input_bits": 257,
+        "maximum_view_bits": 257,
+        "physical_actions": 14150,
+        "rank": 9,
+        "retained_materialized_cells": 776
+      },
+      {
+        "columns": 2,
+        "f": 2,
+        "input_bits": 371,
+        "maximum_view_bits": 373,
+        "physical_actions": 19679,
+        "rank": 9,
+        "retained_materialized_cells": 897
+      },
+      {
+        "columns": 3,
+        "f": 3,
+        "input_bits": 293,
+        "maximum_view_bits": 293,
+        "physical_actions": 20659,
+        "rank": 9,
+        "retained_materialized_cells": 903
+      },
+      {
+        "columns": 3,
+        "f": 3,
+        "input_bits": 443,
+        "maximum_view_bits": 447,
+        "physical_actions": 30374,
+        "rank": 9,
+        "retained_materialized_cells": 1041
+      },
+      {
+        "columns": 7,
+        "f": 7,
+        "input_bits": 411,
+        "maximum_view_bits": 411,
+        "physical_actions": 54772,
+        "rank": 9,
+        "retained_materialized_cells": 1051
+      },
+      {
+        "columns": 7,
+        "f": 7,
+        "input_bits": 705,
+        "maximum_view_bits": 709,
+        "physical_actions": 91640,
+        "rank": 9,
+        "retained_materialized_cells": 1560
+      },
+      {
+        "columns": 17,
+        "f": 17,
+        "input_bits": 679,
+        "maximum_view_bits": 681,
+        "physical_actions": 195622,
+        "rank": 9,
+        "retained_materialized_cells": 1575
+      },
+      {
+        "columns": 17,
+        "f": 17,
+        "input_bits": 1335,
+        "maximum_view_bits": 1337,
+        "physical_actions": 375971,
+        "rank": 9,
+        "retained_materialized_cells": 2811
+      }
+    ],
+    "complete_numeric_execution": false,
+    "controls": [
+      "zero_f",
+      "zero_K",
+      "child_f_zero_mutant"
+    ],
+    "history": {
+      "fresh_small": {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 199,
+        "maximum_view_bits": 199,
+        "physical_actions": 7914,
+        "rank": 9,
+        "retained_materialized_cells": 559
+      },
+      "reused_small": {
+        "columns": 1,
+        "f": 1,
+        "input_bits": 199,
+        "maximum_view_bits": 199,
+        "physical_actions": 7914,
+        "rank": 9,
+        "retained_materialized_cells": 17109
+      }
+    },
+    "long": {
+      "columns": 3,
+      "f": 3,
+      "input_bits": 8511,
+      "maximum_view_bits": 8513,
+      "physical_actions": 530389,
+      "rank": 9,
+      "retained_materialized_cells": 17109
+    },
+    "ports": 45,
+    "status": "PASS_SERIAL_MONOMIAL_DESCRIPTOR"
+  },
+  "algebra": {
+    "controls": [
+      "missing_tensor_constant",
+      "unscaled_stride",
+      "batched_vs_serial_headroom"
+    ],
+    "exact_tensor_address_cases": 6144,
+    "recipes": 4,
+    "source": {
+      "current_source_events": 22803,
+      "event": 9896,
+      "left": {
+        "linear_Z4": [
+          2,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          3,
+          4,
+          9,
+          16,
+          1,
+          32,
+          64,
+          128,
+          256
+        ],
+        "offset": 0,
+        "phase": 0,
+        "quadratic_rows": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      },
+      "owner": 236,
+      "phase_algebra_inherited_from": [
+        3087,
+        6293,
+        6930
+      ],
+      "rank": 1,
+      "raw": [
+        "MOVE",
+        236,
+        3,
+        7,
+        false
+      ],
+      "record_sha256": "0fb29a9ddca346f0b17d11f720d80607a0a64859d75afb50e9680be7a4647ac4",
+      "right": {
+        "linear_Z4": [
+          3,
+          0,
+          3,
+          0,
+          2,
+          0,
+          0,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          21,
+          17,
+          2,
+          20,
+          8,
+          32,
+          64,
+          128,
+          256
+        ],
+        "offset": 1,
+        "phase": 1,
+        "quadratic_rows": [
+          5,
+          0,
+          5,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      },
+      "selected_frontier_changed": false,
+      "source_phase_audit": "unpaidmoon/integer-mult-bounds@c726399fbdb6d80dd13bed760b56572fb4ea1022",
+      "source_token": [
+        "move-in",
+        "local",
+        9896,
+        [
+          "MOVE",
+          236,
+          3,
+          7,
+          false
+        ]
+      ]
+    },
+    "status": "PASS_SERIAL_MONOMIAL_ALGEBRA",
+    "universal_claim": "descriptor identity and disjoint tensor factors proved separately"
+  },
+  "forward": {
+    "actual_selected_nine_axis_move": false,
+    "mode": "forward",
+    "ordinary_entry_detector_checked": true,
+    "result": {
+      "columns": 2,
+      "endpoint_sha256": "4a73bb57012e1ed213bc9d408e2f1c81f7473d1cf70e5c47de57744056fad8c0",
+      "fixed_private_ports": 1811,
+      "materialized_private_cells": 140641,
+      "ordinary_runtime_calls": 0,
+      "physical_actions": 85897601,
+      "physical_bits": 3840,
+      "rank": 2,
+      "records": 128,
+      "signed_guard_rejected": false
+    },
+    "status": "PASS_SERIAL_MONOMIAL_ACTUAL_NUMERIC"
+  },
+  "inverse": {
+    "actual_selected_nine_axis_move": false,
+    "mode": "inverse",
+    "ordinary_entry_detector_checked": true,
+    "result": {
+      "columns": 2,
+      "endpoint_sha256": "b622e27fcb273d61c2635d3d20d2106c66a7270cb587657d0509a27ac786f6a8",
+      "fixed_private_ports": 1811,
+      "materialized_private_cells": 128497,
+      "ordinary_runtime_calls": 0,
+      "physical_actions": 86035950,
+      "physical_bits": 3840,
+      "rank": 2,
+      "records": 128,
+      "signed_guard_rejected": false
+    },
+    "status": "PASS_SERIAL_MONOMIAL_ACTUAL_NUMERIC"
+  },
+  "phase-domain": {
+    "actual_selected_nine_axis_move": false,
+    "mode": "phase-domain",
+    "ordinary_entry_detector_checked": true,
+    "result": {
+      "actual_batched": {
+        "accepted": true,
+        "actual_batched_execution": true,
+        "endpoint_sha256": "e0ef1b0100fb1f590e8a03e72315c39dfc7bff78385d8db9a9b7217b59b9b3ad",
+        "physical_actions": 12991172
+      },
+      "batched_endpoint_representable": true,
+      "combined_phase": 0,
+      "first_serial_phase": 2,
+      "serial_rejection": {
+        "columns": 2,
+        "endpoint_sha256": "e0ef1b0100fb1f590e8a03e72315c39dfc7bff78385d8db9a9b7217b59b9b3ad",
+        "fixed_private_ports": 1795,
+        "materialized_private_cells": 47791,
+        "ordinary_runtime_calls": 0,
+        "physical_actions": 2232451,
+        "physical_bits": 768,
+        "rank": 1,
+        "records": 32,
+        "signed_guard_rejected": true
+      },
+      "success": {
+        "columns": 2,
+        "endpoint_sha256": "f16e00b5b5298461409a9b17ac267661c0a9b3d9c3f14e7951557d2c6e3ac803",
+        "fixed_private_ports": 1795,
+        "materialized_private_cells": 47791,
+        "ordinary_runtime_calls": 0,
+        "physical_actions": 15421913,
+        "physical_bits": 768,
+        "rank": 1,
+        "records": 32,
+        "signed_guard_rejected": false
+      }
+    },
+    "status": "PASS_SERIAL_MONOMIAL_ACTUAL_NUMERIC"
+  },
+  "history": {
+    "actual_selected_nine_axis_move": false,
+    "mode": "history",
+    "ordinary_entry_detector_checked": true,
+    "result": {
+      "fresh_small": {
+        "columns": 1,
+        "endpoint_sha256": "7ffc13ab2e84aafa1ce74175a15840e3ed437a6162c25bfee945696efade6d42",
+        "fixed_private_ports": 1795,
+        "materialized_private_cells": 41133,
+        "ordinary_runtime_calls": 0,
+        "physical_actions": 4269685,
+        "physical_bits": 384,
+        "rank": 1,
+        "records": 16,
+        "signed_guard_rejected": false
+      },
+      "large": {
+        "columns": 2,
+        "endpoint_sha256": "fa0d9bb7fedd3e559a6e399bd02557cd1da176130afc9cc1a745abc224e477c4",
+        "fixed_private_ports": 1795,
+        "materialized_private_cells": 134719,
+        "ordinary_runtime_calls": 0,
+        "physical_actions": 84674613,
+        "physical_bits": 6144,
+        "rank": 1,
+        "records": 256,
+        "signed_guard_rejected": false
+      },
+      "reused_small": {
+        "columns": 1,
+        "endpoint_sha256": "7ffc13ab2e84aafa1ce74175a15840e3ed437a6162c25bfee945696efade6d42",
+        "fixed_private_ports": 1795,
+        "materialized_private_cells": 134719,
+        "ordinary_runtime_calls": 0,
+        "physical_actions": 4269685,
+        "physical_bits": 384,
+        "rank": 1,
+        "records": 16,
+        "signed_guard_rejected": false
+      }
+    },
+    "status": "PASS_SERIAL_MONOMIAL_ACTUAL_NUMERIC"
+  }
+}
diff --git a/research/current-serial-monomial-leaf/SOURCES.json b/research/current-serial-monomial-leaf/SOURCES.json
new file mode 100644
index 0000000000..09004fa542
--- /dev/null
+++ b/research/current-serial-monomial-leaf/SOURCES.json
@@ -0,0 +1,60 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "82e9a8b0b50f26844528af9e07632800679805ea",
+      "sha256": "20885a8a137fc670121429625912ceae54db95ac5e574b8c64c90f477aebacb7"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/SOURCES.json",
+      "usage": "provenance",
+      "git_blob": "e040a558800e719e2d8b6237bec39e7e10a3641b",
+      "sha256": "0dd57a4fe4fc97826df0eb215975d013ac0e18f185c73cd93e34c95a9a2b4b16"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/monomial_engine.py",
+      "usage": "provenance",
+      "git_blob": "2251fd98ba01a171f5d39b25a93c895245f10e55",
+      "sha256": "fc02c6c5159d6c258063a36ef3dc9313a34d7ba9781b650e451cc0ce971e9667"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/pair_dispatch.py",
+      "usage": "provenance",
+      "git_blob": "0e467bdb3727d7f354f98dee54f320f1f072aa2c",
+      "sha256": "fc0eaa2a9d0855660b15a15d894137eeebc64c6418f52b6af0d0f79d86f2e0d9"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/phase_recipe.py",
+      "usage": "provenance",
+      "git_blob": "a2f684fb588257cc182dc88dded59ed70f5c2585",
+      "sha256": "8215e5e55daf019694e55b2acfcd42ecf109a2faf767a2181d664ba9b4957e46"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/phase_sources.py",
+      "usage": "provenance",
+      "git_blob": "aaa5c663a4bb6b0ca4d9119c1ae92064509d79c8",
+      "sha256": "3944ecbffe91fb561b2b8a810461cd2b8229f1f2611ca6a70e3d86451efb220b"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/signed_phase.py",
+      "usage": "provenance",
+      "git_blob": "bab32b0c5da7f364d6a79171c09b02d123a05bd9",
+      "sha256": "e21818674133a2bd7e63fadaf719eb45ce80db4b3806ca8ef99c247be22c2a39"
+    }
+  ]
+}
diff --git a/research/current-serial-monomial-leaf/TASK.json b/research/current-serial-monomial-leaf/TASK.json
new file mode 100644
index 0000000000..489144ddc2
--- /dev/null
+++ b/research/current-serial-monomial-leaf/TASK.json
@@ -0,0 +1,102 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "scope_change_reason": "Fresh complementary scope: ordinary-free direct monomial serialization with explicit intermediate-phase domain and paid header iteration. Prior #4172 one-column branch is credited.",
+  "actual_scope": "Finite encoded serialization of current rank-m f-column monomials into actual f=1 calls without ordinary runtime, on an explicit intermediate headroom domain.",
+  "bottleneck_link": "Removes completed ordinary runtime supplier from a direct current monomial alternative at full f-times cost and strict signed headroom. Global cutoff, compiler export and nonleaf tariffs remain open.",
+  "stop_rule": "Stop or narrow if source geometry, tensor phase, history or full bill fails. Bound actual numerical fixture by90s per process; distinguish smaller genuine recipes from selected-source phase controls.",
+  "evidence": "Draft proof and actual descriptor/forward/inverse/domain/history tests; independent review and registered gates pending.",
+  "author": "@CubeJerry",
+  "ai_assistance": "Substantial OpenAI assistance in research, proof development, implementation, tests and documentation; no independent human or proof-kernel admission claimed.",
+  "outcome": "partial",
+  "open_questions": [
+    {
+      "question": "Compose this alternative with every exact current MOVE and positive rank child.",
+      "why_it_matters": "A monomial alternative does not install the child/caller boundaries.",
+      "first_step": "Combine frozen all-source child-header and protected-stage packages with separate inventories and intermediate headroom.",
+      "blocked_by": "Full source/provider contracts and stage precision."
+    },
+    {
+      "question": "Prove global cutoff and long-record admission.",
+      "why_it_matters": "O(fV) requires explicit metadata/long-record absorption.",
+      "first_step": "Substitute actual row/record and child widths into the full larger bill.",
+      "blocked_by": "Selected recursive compiler/precision and stock recurrence."
+    },
+    {
+      "question": "Export the complete serial provider as flat lifecycle tables.",
+      "why_it_matters": "Only the descriptor iterator is literal tables; retained monomial is structured source control.",
+      "first_step": "Flatten the exact source graph with port bindings and failure semantics.",
+      "blocked_by": "Retained source-to-table numerical equivalence."
+    }
+  ],
+  "time_budget_minutes": 90,
+  "freshness": {
+    "checked_utc": "2026-11-09T17:20:11Z",
+    "canonical_main": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+    "bounded_overlap": "Read monomial7d1ff, header772198, #4172 and #4129; bounded searches for serialized/one-column/ordinary-free routes. One-column zero-ordinary and history facts preexist. New scope is encoded current multi-column replacement and narrowed domain. Not exhaustive."
+  },
+  "wave": 4,
+  "worker": "lead",
+  "track": "00/60/75"
+}
diff --git a/research/current-serial-monomial-leaf/VERIFICATION.md b/research/current-serial-monomial-leaf/VERIFICATION.md
new file mode 100644
index 0000000000..65ccf550d1
--- /dev/null
+++ b/research/current-serial-monomial-leaf/VERIFICATION.md
@@ -0,0 +1,42 @@
+# Verification record
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+
+All eight registered normal and optimized gates passed through the canonical
+research-package runner. Each authenticates all 109 vendored input files before
+the source executes, then compares exact scientific receipts. The gates group
+descriptor/algebra, forward, inverse, and acceptance-domain/history checks;
+each has a 90-second process limit. They passed under Python 3.12. The result
+does not depend on assertions being enabled.
+
+The separate native research worker identified the intermediate signed-domain
+obstruction. The implementation now states and tests the strictly narrower
+domain, with actual batched acceptance and serial rejection on the same input.
+A second worker independently reviewed the source, geometry and cost proof.
+The review found no blocker under the explicit contracts and checked 560
+geometries, 1,820 views, 43,940 selected positions, all 73 finite rank tables,
+and 349,504 signed-phase cases with six controls. INDEPENDENT-REVIEW.json
+records the exact reviewed hashes. The later proof delta only removes the
+draft label and corrects “negative” to “negation”; no scientific code changed.
+The portable review/independent_checks.py changes only the original script's
+workspace path to a package-relative path. These are separate AI-assisted
+oracles sharing the source context, not a human or kernel-checked review.
+
+The numerical traces execute the unchanged monomial source. An ordinary-entry
+trap is a failure detector, not a numerical substitute: successful traces must
+never enter it, and a deliberate entry is checked to fail. Compact invocation
+counters also remain zero. The expected full signed numerical outputs use the
+authenticated predecessor's separate coordinate oracle. The new finite source
+algebra checks bind both actual selected factors, but do not execute their
+entire nine-axis field. The exact universal argument is in PROOF.md.
+
+Fresh and reused shorter calls have identical actual action receipts while old
+materialized backing remains allocated. Those array extents do not measure
+every visited blank address and are not used as an independent asymptotic space
+theorem; all source rolewise history bounds and constructor inventories remain
+inherited and charged.
+
+Committed-byte/mode and Git-free export checks are recorded in the lead
+publication receipt after the tree is frozen.
+No upstream pull request or accepted-certificate change is authorized by these
+checks. Only an independently reviewed frozen tree may be published.
diff --git a/research/current-serial-monomial-leaf/VERIFY.json b/research/current-serial-monomial-leaf/VERIFY.json
new file mode 100644
index 0000000000..d3b5c4225d
--- /dev/null
+++ b/research/current-serial-monomial-leaf/VERIFY.json
@@ -0,0 +1,109 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "metadata"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Normal actual metadata replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "forward"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Normal actual forward replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "inverse"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Normal actual inverse replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "domain-history"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Normal actual domain-history replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "-O",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "metadata"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Optimized actual metadata replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "-O",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "forward"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Optimized actual forward replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "-O",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "inverse"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Optimized actual inverse replay with exact source/result and controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "-O",
+        "research/current-serial-monomial-leaf/verify.py",
+        "--suite",
+        "domain-history"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Optimized actual domain-history replay with exact source/result and controls."
+    }
+  ]
+}
diff --git a/research/current-serial-monomial-leaf/check_algebra.py b/research/current-serial-monomial-leaf/check_algebra.py
new file mode 100644
index 0000000000..97326a5aaa
--- /dev/null
+++ b/research/current-serial-monomial-leaf/check_algebra.py
@@ -0,0 +1,85 @@
+"""Source-coordinate tensor oracle and signed-domain failure controls.
+
+The address/phase oracle does not call the native numerical implementation.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+import json
+from serial_sources import activate, need
+
+
+def one(recipe, word):
+    phase=recipe['phase'];m=len(recipe['matrix_rows'])
+    for i in range(m):
+        if word>>i&1:
+            phase+=recipe['linear_Z4'][i]
+            for j in range(i+1,m):
+                if word>>j&1 and recipe['quadratic_rows'][i]>>j&1:phase+=2
+    out=recipe['offset']
+    for i,row in enumerate(recipe['matrix_rows']):
+        if (row&word).bit_count()%2:out^=1<<i
+    return out,phase%4
+
+
+def apply_column(address, a, u, m, stride, rho, recipe):
+    positions=[a-1-(u+i*stride+rho) for i in range(m)]
+    old=sum(((address>>p)&1)<<i for i,p in enumerate(positions))
+    new,phase=one(recipe,old);out=address
+    for i,p in enumerate(positions):
+        if (old^new)>>i&1:out^=1<<p
+    return out,phase
+
+
+def run():
+    S=activate()
+    _entry,_exit,record,source=S.selected.source_boundary()
+    recipes=[record['right'],record['left'],
+             dict(matrix_rows=(1,),offset=0,linear_Z4=(0,),quadratic_rows=(0,),phase=2),
+             dict(matrix_rows=(1,3),offset=2,linear_Z4=(3,1),quadratic_rows=(2,0),phase=3)]
+    counts=0;phase_control=spacing_control=False
+    for recipe in recipes:
+        m=len(recipe['matrix_rows'])
+        inverse_map={one(recipe,x)[0]:(x,one(recipe,x)[1]) for x in range(1<<m)}
+        need(len(inverse_map)==1<<m,'recipe address map invertible')
+        for f in (1,2,3,4):
+            for K in (1,2,3):
+                for rho in range(K):
+                    H=max(1,f-1);u=2*H+2;z=u+m*f*K+3;a=z+H+1
+                    for salt in range(32):
+                        seed=((salt*0x9e3779b97f4a7c15)^(salt<<(a//2)))&((1<<a)-1)
+                        for address in (seed,seed^((1<<a)-1)):
+                            expected=address;total=0
+                            for j in range(f):
+                                # Batched endpoint reads every original column.
+                                new,phase=apply_column(address,a,u,m,f*K,j*K+rho,recipe)
+                                selected=sum(1<<(a-1-(u+(i*f+j)*K+rho)) for i in range(m))
+                                expected=(expected&~selected)|(new&selected);total+=phase
+                            actual=address;acc=0
+                            for j in range(f):
+                                actual,phase=apply_column(actual,a,u,m,f*K,j*K+rho,recipe);acc+=phase
+                            need((actual,acc%4)==(expected,total%4),'exact batched versus serial tensor action')
+                            restored=actual;inverse_phase=0
+                            for j in reversed(range(f)):
+                                pos=[a-1-(u+(i*f+j)*K+rho) for i in range(m)]
+                                y=sum(((restored>>p)&1)<<i for i,p in enumerate(pos))
+                                x,phase=inverse_map[y]
+                                for i,p in enumerate(pos):
+                                    if (x^y)>>i&1:restored^=1<<p
+                                inverse_phase-=phase
+                            need(restored==address and (acc+inverse_phase)%4==0,'complete inverse with absolute phase')
+                            phase_control |= (total-(f-1)*recipe['phase'])%4 != total%4
+                            if f>1:
+                                wrong,_=apply_column(address,a,u,m,K,rho,recipe)
+                                good,_=apply_column(address,a,u,m,f*K,rho,recipe)
+                                spacing_control |= wrong!=good
+                            counts+=1
+    need(phase_control and spacing_control,'tensor constant and unscaled-stride controls discriminate')
+    lo=-8
+    need((-1)**2*lo==lo and -lo>7,'batched cancellation versus intermediate overflow')
+    return dict(status='PASS_SERIAL_MONOMIAL_ALGEBRA',source=source,
+                exact_tensor_address_cases=counts,recipes=len(recipes),
+                controls=['missing_tensor_constant','unscaled_stride','batched_vs_serial_headroom'],
+                universal_claim='descriptor identity and disjoint tensor factors proved separately')
+
+
+if __name__=='__main__':
+    print(json.dumps(run(),sort_keys=True))
diff --git a/research/current-serial-monomial-leaf/check_descriptor.py b/research/current-serial-monomial-leaf/check_descriptor.py
new file mode 100644
index 0000000000..8bcdc6f53c
--- /dev/null
+++ b/research/current-serial-monomial-leaf/check_descriptor.py
@@ -0,0 +1,165 @@
+"""Actual physical iterator checked against a separate integer observer.
+
+Fixture arrays and decoded integers occur only in this checker.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+import json
+from column_view import ColumnView, S, ROLES, PARENT, VIEW, PRIVATE, R
+from serial_sources import need
+
+SCHEMA = tuple(ROLES)
+
+
+def encode(values):
+    out = []
+    for name in SCHEMA:
+        digits = [int(x) for x in bin(values[name])[2:][::-1]]
+        out += [1] * len(digits) + [0] + digits
+    return out
+
+
+def decode(bits):
+    at, out = 0, {}
+    for name in SCHEMA:
+        length = 0
+        while at < len(bits) and bits[at] == 1:
+            length += 1
+            at += 1
+        need(length > 0 and at < len(bits) and bits[at] == 0, "positive header prefix")
+        at += 1
+        digits = bits[at:at+length]
+        need(len(digits) == length and all(x in (0, 1) for x in digits)
+             and (length == 1 or digits[-1] == 1), "canonical header digits")
+        out[name] = sum(x << i for i, x in enumerate(digits))
+        at += length
+    need(at == len(bits), "exact header end")
+    return out
+
+
+def put(tape, bits):
+    stop = tape.origin + len(bits)
+    if len(tape.cells) < stop:
+        tape.cells.extend([6] * (stop - len(tape.cells)))
+    tape.cells[tape.origin:stop] = bytearray(bits)
+    for i in range(stop, len(tape.cells)):
+        tape.cells[i] = 6
+    tape.head = tape.origin
+    tape.high = max(tape.high, stop)
+
+
+def body(tape):
+    out, ended = [], False
+    for value in tape.cells[tape.origin:]:
+        if value == 6:
+            ended = True
+        else:
+            need(not ended and value in (0, 1), "complete raw prefix")
+            out.append(value)
+    return out
+
+
+def values(m=9, f=3, K=2, rho=1, remainder=0, long=0):
+    H = max(1, f-1)
+    u = 2*H + remainder*K + 3
+    z = u + m*f*K + 5
+    a = z + H + 2
+    b = 30
+    return dict(outer=(1 << long)+1, rows=3, stock=1, row_bits=b << a,
+                within_bits=a, record_bits=b, p=max(m*f+remainder, 2),
+                d=m*f+remainder, K=K, G=1, H=H, q0=3, qF=4, qB=5,
+                D=m*f+remainder, f=f, rho=rho, active_start=u, back_start=z,
+                selected_axes=m*f+remainder, entry_start=u-remainder*K,
+                remainder=remainder, cutoff=3*m*f)
+
+
+def hardware(m):
+    v = ColumnView(m)
+    work = [S.codec.DenseTape(3+i%5) for i in PRIVATE]
+    parent = S.codec.DenseTape(11)
+    for tape in (*work, parent):
+        for j in range(tape.origin-1):
+            tape.cells[j] = j % 2
+    v.bind(work, S.abi.BinaryContextPort(parent))
+    return v, work, parent
+
+
+def case(m, parent_values, reuse=None):
+    owner, work, parent = hardware(m) if reuse is None else reuse
+    initial = encode(parent_values)
+    put(parent, initial)
+    ancestors = [bytes(t.cells[:t.origin]) for t in (*work, parent)]
+    before = sum(t.actions() for t in (*work, parent))
+    owner.prepare()
+    seen, maximum = [], 0
+    try:
+        for j in range(parent_values['f']):
+            current = body(owner.context.tape)
+            expected = dict(parent_values, f=1, K=parent_values['f']*parent_values['K'],
+                            rho=j*parent_values['K']+parent_values['rho'],
+                            selected_axes=m+parent_values['remainder'])
+            need(decode(current) == expected and current == encode(expected), "all23 exact private fields")
+            need(body(parent) == initial and parent.head == parent.origin, "borrowed parent preserved")
+            need(all(t.head == t.origin for t in work), "all native-cut private origins")
+            for i in range(m):
+                need(expected['active_start']+i*expected['K']+expected['rho'] ==
+                     parent_values['active_start']+(i*parent_values['f']+j)*parent_values['K']+parent_values['rho'],
+                     "original source bit positions")
+            maximum = max(maximum, len(current))
+            seen.append(expected['rho'])
+            need(owner.advance() == ('finished' if j+1 == parent_values['f'] else 'ready'),
+                 "exact finite iteration stopping")
+    finally:
+        owner.release()
+    need(body(parent) == initial and parent.head == parent.origin, "parent restored at return")
+    need(all(t.head == t.origin and not body(t) for t in work), "all private current prefixes erased")
+    need([bytes(t.cells[:t.origin]) for t in (*work,parent)] == ancestors, "ancestors preserved")
+    bill = sum(t.actions() for t in (*work,parent))-before
+    # A deliberately loose bound proved by finite per-digit loop accounting.
+    need(bill <= 10000*(parent_values['f']+1)*(len(initial)+1), "explicit positive metadata ceiling")
+    report = dict(rank=m, f=parent_values['f'], input_bits=len(initial),
+                  maximum_view_bits=maximum, columns=len(seen), physical_actions=bill,
+                  retained_materialized_cells=sum(len(t.cells) for t in work))
+    return report, (owner,work,parent)
+
+
+def run():
+    results = []
+    for m in (1,2,9):
+        reused = None
+        for f in (1,2,3,7,17):
+            for K in (1,3):
+                v=values(m=m,f=f,K=K,rho=K-1,remainder=m-1)
+                report,reused=case(m,v,reused)
+                results.append(report)
+    long,reused=case(9,values(long=4096))
+    short,reused=case(9,values(f=1,K=1,rho=0),reused)
+    fresh,_=case(9,values(f=1,K=1,rho=0))
+    need(short['physical_actions']==fresh['physical_actions'], "no old-backing time surcharge")
+    need(short['retained_materialized_cells']>fresh['retained_materialized_cells'], "old backing retained")
+    rejected=[]
+    for key in ('f','K'):
+        v,work,parent=hardware(2)
+        bad=values(m=2);bad[key]=0
+        put(parent,encode(bad))
+        try:v.prepare()
+        except ValueError:rejected.append('zero_'+key)
+        else:raise ValueError('invalid positive field accepted')
+        need(not v.active and all(not body(t) and t.head==t.origin for t in work), "failed view retired")
+        case(2,values(m=2),(v,work,parent))
+    v,work,parent=hardware(2)
+    bad=list(v.prepare_table)
+    at=max(i for i,row in enumerate(bad) if row==('write',ROLES['f'],'1'))
+    bad[at]=('write',ROLES['f'],'0')
+    v.prepare_table=tuple(bad)
+    put(parent,encode(values(m=2)))
+    v.prepare()
+    need(decode(body(v.context.tape))['f'] != 1, "unscaled/malformed child-f mutant detected by exact oracle")
+    v.release()
+    return dict(status='PASS_SERIAL_MONOMIAL_DESCRIPTOR', cases=results,
+                long=long,history=dict(reused_small=short,fresh_small=fresh),
+                controls=rejected+['child_f_zero_mutant'],
+                ports=ColumnView.port_count, complete_numeric_execution=False)
+
+
+if __name__=='__main__':
+    print(json.dumps(run(),sort_keys=True))
diff --git a/research/current-serial-monomial-leaf/check_numeric.py b/research/current-serial-monomial-leaf/check_numeric.py
new file mode 100644
index 0000000000..573d8472ff
--- /dev/null
+++ b/research/current-serial-monomial-leaf/check_numeric.py
@@ -0,0 +1,136 @@
+"""Actual bounded serial calls, independently predicted full signed outputs.
+
+The numerical oracle is the authenticated predecessor's address formula;
+the production service consumes only current tape ports. No source algorithm
+is replaced. Prepared for @CubeJerry with substantial OpenAI assistance.
+Apache-2.0.
+"""
+from argparse import ArgumentParser
+from hashlib import sha256
+import json
+import time
+from column_view import SerialProvider, S
+from serial_sources import need
+from check_descriptor import put, body, encode as header_bits
+from check_fixture import factory, literal, fixture, encode
+from ordinary import Ordinary
+
+
+def hardware(recipe, inverse=False):
+    owner=SerialProvider(recipe,factory,inverse=inverse)
+    work=[S.codec.DenseTape(3+i%5) for i in range(owner.port_count)]
+    field,context=S.codec.DenseTape(9),S.codec.DenseTape(11)
+    for t in (*work,field,context):
+        for j in range(t.origin-1):t.cells[j]=j%2
+    owner.bind(work,S.abi.CodedPort(field),S.abi.BinaryContextPort(context))
+    return owner,work,field,context
+
+
+def execute(state, values, initial, expected, reject=False):
+    owner,work,field,context=state
+    put(field,initial);put(context,header_bits(values))
+    tapes=(*work,field,context)
+    ancestors=[bytes(t.cells[:t.origin]) for t in tapes]
+    before=sum(t.actions() for t in tapes)
+    old=Ordinary.run
+    def forbidden(*args,**kwargs):
+        raise ValueError('ordinary-runtime-entry-trap')
+    # A failure detector, not a numerical substitute: every successful trace
+    # must avoid the entry point entirely. All monomial bytes are unchanged.
+    Ordinary.run=forbidden
+    failed=False
+    started=time.monotonic()
+    try:
+        try:owner.run()
+        except S.state.phase.SignedHeadroomError:failed=True
+    finally:
+        Ordinary.run=old
+    need(failed==reject,'expected exact signed-domain outcome')
+    need(body(field)==expected,'independent complete signed endpoint')
+    need(body(context)==header_bits(values),'parent descriptor preserved')
+    need(all(t.head==t.origin for t in tapes),'complete heads restored')
+    need(all(not body(t) for t in work),'current private bodies erased')
+    need([bytes(t.cells[:t.origin]) for t in tapes]==ancestors,'all ancestors preserved')
+    need(not owner.view.active and not owner.native.pool.live
+         and owner.native.engine.closed and not owner.native.engine.pool.live,
+         'all serial and monomial scopes closed')
+    need(all(n==0 for n in owner.native.engine.compact.calls.values()),'zero Compact/ordinary runtime calls')
+    return dict(columns=values['f'],rank=owner.native.rank,
+                records=values['outer']*values['rows']*(1<<values['within_bits']),
+                physical_bits=len(initial),physical_actions=sum(t.actions() for t in tapes)-before,
+                materialized_private_cells=sum(len(t.cells) for t in work),
+                fixed_private_ports=owner.port_count,ordinary_runtime_calls=0,
+                signed_guard_rejected=failed,endpoint_sha256=sha256(bytes(body(field))).hexdigest(),
+                elapsed_seconds=round(time.monotonic()-started,6))
+
+
+def ordinary_trap_control():
+    original=Ordinary.run
+    def trap(*args,**kwargs):raise ValueError('ordinary-runtime-entry-trap')
+    Ordinary.run=trap
+    try:
+        try:factory().run(None,None,None)
+        except ValueError as e:need(str(e)=='ordinary-runtime-entry-trap','entry detector fired')
+        else:raise ValueError('ordinary entry detector missing')
+    finally:Ordinary.run=original
+
+
+def batched_counterexample(recipe, values, initial):
+    """The unmodified multi-column provider accepts the cancellation case."""
+    owner=S.adapter.Provider(recipe,factory)
+    work=[S.codec.DenseTape(3+i%5) for i in range(owner.port_count)]
+    field,context=S.codec.DenseTape(9),S.codec.DenseTape(11)
+    owner.bind(work)
+    put(field,initial);put(context,header_bits(values))
+    tapes=(*work,field,context)
+    before=sum(t.actions() for t in tapes)
+    owner.run(S.abi.CodedPort(field),S.abi.BinaryContextPort(context))
+    need(body(field)==initial and body(context)==header_bits(values),
+         'actual batched cancellation accepts most-negative component')
+    need(all(t.head==t.origin for t in tapes) and all(not body(t) for t in work),
+         'actual batched counterexample cleanup')
+    return dict(actual_batched_execution=True,accepted=True,
+                physical_actions=sum(t.actions() for t in tapes)-before,
+                endpoint_sha256=sha256(bytes(initial)).hexdigest())
+
+
+def run(mode):
+    ordinary_trap_control()
+    if mode in ('forward','inverse'):
+        recipe=literal()
+        inverse=mode=='inverse'
+        v,initial,expected=fixture(recipe,f=2,K=1,h=4,coefficients=1,inverse=inverse)
+        result=execute(hardware(recipe,inverse),v,initial,expected)
+    elif mode=='phase-domain':
+        recipe=dict(matrix_rows=(1,),offset=0,linear_Z4=(0,),quadratic_rows=(0,),phase=2)
+        v,initial,expected=fixture(recipe,f=2,K=1,h=3,coefficients=1)
+        state=hardware(recipe)
+        result=execute(state,v,initial,expected)
+        records=[((-(1<<2),0),)]*(1<<v['within_bits'])
+        bad=encode(records,3)
+        # Batched total phase is +1 and its exact output is the same representable
+        # word. Serial column1 is a negation and rejects before any public write.
+        rejected=execute(state,v,bad,bad,True)
+        result=dict(success=result,serial_rejection=rejected,
+                    combined_phase=0,first_serial_phase=2,
+                    batched_endpoint_representable=True,
+                    actual_batched=batched_counterexample(recipe,v,bad))
+    elif mode=='history':
+        recipe=dict(matrix_rows=(1,),offset=0,linear_Z4=(1,),quadratic_rows=(0,),phase=1)
+        state=hardware(recipe)
+        v,a,b=fixture(recipe,f=2,K=1,H=2,h=3,coefficients=1)
+        large=execute(state,v,a,b)
+        v,a,b=fixture(recipe,f=1,K=1,H=1,h=3,coefficients=1)
+        short=execute(state,v,a,b)
+        fresh=execute(hardware(recipe),v,a,b)
+        need(short['physical_actions']==fresh['physical_actions'],'same small-call actions after longer history')
+        need(short['materialized_private_cells']>fresh['materialized_private_cells'],'history backing retained')
+        result=dict(large=large,reused_small=short,fresh_small=fresh)
+    else:raise ValueError('unknown fixed fixture')
+    return dict(status='PASS_SERIAL_MONOMIAL_ACTUAL_NUMERIC',mode=mode,result=result,
+                actual_selected_nine_axis_move=False,ordinary_entry_detector_checked=True)
+
+
+if __name__=='__main__':
+    parser=ArgumentParser();parser.add_argument('mode',choices=('forward','inverse','phase-domain','history'))
+    print(json.dumps(run(parser.parse_args().mode),sort_keys=True))
diff --git a/research/current-serial-monomial-leaf/column_view.py b/research/current-serial-monomial-leaf/column_view.py
new file mode 100644
index 0000000000..f547ed7a72
--- /dev/null
+++ b/research/current-serial-monomial-leaf/column_view.py
@@ -0,0 +1,200 @@
+"""Physically encoded serialization into genuine one-column monomial calls.
+
+Runtime integers remain on fixed raw binary tapes. Construction depends only
+on the finite recipe rank. Prepared for @CubeJerry with substantial OpenAI
+assistance. Apache-2.0.
+"""
+from serial_sources import activate, need
+
+S = activate()
+R = S.rows
+ROLES = dict(R.SCHEMA)
+PARENT, VIEW = R.HEADER, R.CHILD_HEADER
+FBOUND, OLD_K, COLUMN, ACC, SUM, M = range(40, 46)
+PORTS = 46
+PRIVATE = tuple(i for i in range(PORTS) if i != PARENT)
+FIELDS = tuple(port for _, port in R.SCHEMA)
+
+
+def literal(b, tape, value):
+    """Only a fixed compile-time integer is supplied here."""
+    need(type(value) is int and value >= 0, "fixed nonnegative literal")
+    b.empty(tape)
+    for digit in bin(value)[2:][::-1]:
+        b.write(tape, digit)
+        b.move(tape, 1)
+    b.rewind(tape)
+
+
+def compile_prepare(rank):
+    need(type(rank) is int and 1 <= rank <= 73, "fixed compiled monomial rank")
+    b = R.Builder()
+    for port in (PARENT, *PRIVATE):
+        b.boundary(port)
+    for port in PRIVATE:
+        b.empty(port)
+    b.decode(PARENT, FIELDS)
+    b.canonical(ROLES["f"], positive=True)
+    b.canonical(ROLES["K"], positive=True)
+    b.copy(ROLES["f"], FBOUND)
+    b.copy(ROLES["K"], OLD_K)
+    literal(b, COLUMN, 0)
+    literal(b, ACC, 0)
+    loop, more, end = (b.fresh("product") for _ in range(3))
+    b.mark(loop)
+    b.compare(COLUMN, FBOUND, more, end, "reject")
+    b.mark(more)
+    b.add(ACC, OLD_K, SUM)
+    b.clear(ACC)
+    b.copy(SUM, ACC)
+    b.clear(SUM)
+    b.increment(COLUMN)
+    b.go(loop)
+    b.mark(end)
+    b.clear(ROLES["K"])
+    b.copy(ACC, ROLES["K"])
+    b.clear(ACC)
+    b.clear(ROLES["f"])
+    literal(b, ROLES["f"], 1)
+    b.clear(ROLES["selected_axes"])
+    literal(b, M, rank)
+    b.add(M, ROLES["remainder"], ROLES["selected_axes"])
+    b.clear(M)
+    b.clear(COLUMN)
+    literal(b, COLUMN, 0)
+    b.encode(FIELDS, VIEW)
+    b.code.append(("result", "ready"))
+    return b.close()
+
+
+def compile_next():
+    b = R.Builder()
+    b.clear(VIEW)
+    b.increment(COLUMN)
+    more, end = (b.fresh("column") for _ in range(2))
+    b.compare(COLUMN, FBOUND, more, end, "reject")
+    b.mark(more)
+    b.add(ROLES["rho"], OLD_K, SUM)
+    b.clear(ROLES["rho"])
+    b.copy(SUM, ROLES["rho"])
+    b.clear(SUM)
+    b.encode(FIELDS, VIEW)
+    b.code.append(("result", "ready"))
+    b.mark(end)
+    b.code.append(("result", "finished"))
+    return b.close()
+
+
+def compile_release():
+    b = R.Builder()
+    for port in PRIVATE:
+        b.clear(port)
+    b.rewind(PARENT)
+    return b.close()
+
+
+NEXT, RELEASE = compile_next(), compile_release()
+
+
+def validate(table):
+    for row in table:
+        need(row[0] in ("read", "write", "move", "goto", "done", "result", "reject", "quarantine"),
+             "literal local instruction vocabulary")
+        if row[0] in ("read", "write", "move"):
+            need(type(row[1]) is int and 0 <= row[1] < PORTS, "fixed role")
+        if row[0] == "write":
+            need(row[1] != PARENT and row[2] in (R.ZERO, R.ONE, R.BLANK),
+                 "parent and markers are read-only")
+        if row[0] == "move":
+            need(row[2] in (-1, 1), "unit movement")
+        if row[0] == "result":
+            need(row[1] in ("ready", "finished"), "finite decision alphabet")
+    return len(table)
+
+
+class ColumnView:
+    port_count = len(PRIVATE)
+
+    def __init__(self, rank):
+        self.prepare_table = compile_prepare(rank)
+        for table in (self.prepare_table, NEXT, RELEASE):
+            validate(table)
+        self.ports = self.parent = self.work = None
+        self.active = False
+
+    def bind(self, work, context):
+        need(not self.active and len(work) == self.port_count,
+             "complete fixed descriptor bank before execution")
+        need(len(set(map(id, work))) == len(work)
+             and all(port is not context.tape for port in work),
+             "distinct descriptor segments; actual disjointness is a caller premise")
+        self.parent, self.work = context, tuple(work)
+        self.ports = {PARENT: R.PhysicalPort(context.tape)}
+        self.ports.update((role, R.PhysicalPort(port)) for role, port in zip(PRIVATE, work))
+
+    @property
+    def context(self):
+        need(self.ports is not None, "bound descriptor bank")
+        return S.abi.BinaryContextPort(self.ports[VIEW].tape)
+
+    def prepare(self):
+        need(self.ports is not None and not self.active, "single active descriptor iteration")
+        self.active = True
+        try:
+            result, _steps = R.run_choice(self.prepare_table, self.ports)
+            need(result == "ready", "first column available")
+        except Exception:
+            self.release()
+            raise
+
+    def advance(self):
+        need(self.active, "active descriptor iteration")
+        result, _steps = R.run_choice(NEXT, self.ports)
+        need(result in ("ready", "finished"), "finite column decision")
+        return result
+
+    def release(self):
+        need(self.active, "active descriptor iteration to retire")
+        try:
+            R.run(RELEASE, self.ports)
+        finally:
+            self.active = False
+
+
+class SerialProvider:
+    """Actual unchanged monomial, with physically priced descriptor iteration.
+
+Partial column updates can precede a later named arithmetic rejection. A
+protected whole-field wrapper is required for whole-job public atomicity.
+No provider is reset, recreated, or given decoded shape values between calls.
+"""
+    def __init__(self, literal_recipe, native_factory, inverse=False):
+        self.native = S.adapter.Provider(literal_recipe, native_factory, inverse=inverse)
+        self.view = ColumnView(self.native.rank)
+        self.field = self.work = None
+
+    @property
+    def port_count(self):
+        return self.view.port_count + self.native.port_count
+
+    def bind(self, work, field, context):
+        need(len(work) == self.port_count and len(set(map(id, work))) == len(work),
+             "fixed distinct complete inventory")
+        need(field.tape is not context.tape
+             and all(field.tape is not p and context.tape is not p for p in work),
+             "field, parent descriptor and work are disjoint")
+        self.work, self.field = tuple(work), field
+        self.view.bind(work[:self.view.port_count], context)
+        self.native.bind(work[self.view.port_count:])
+
+    def run(self):
+        need(self.work is not None, "bound serial monomial")
+        try:
+            self.view.prepare()
+            while True:
+                self.native.run(self.field, self.view.context)
+                if self.view.advance() == "finished":
+                    break
+        finally:
+            if self.view.active:
+                self.view.release()
diff --git a/research/current-serial-monomial-leaf/review/README.md b/research/current-serial-monomial-leaf/review/README.md
new file mode 100644
index 0000000000..5cd067a847
--- /dev/null
+++ b/research/current-serial-monomial-leaf/review/README.md
@@ -0,0 +1,5 @@
+# Complementary review reproduction
+
+Run `python3 -I -B research/current-serial-monomial-leaf/review/independent_checks.py` from any repository checkout. Only the original review script's absolute workspace path was replaced by a package-relative path. It rechecks geometry, source consumer fields, emitted tables and signed phases; it does not replay the long numerical packets.
+
+The unchanged original script SHA256 is `d394f177dbd979cc9bd6c1a799b7890445e249b24caa0a2eb017644a9f3ba53c`. The portable script SHA256 is `5c97e87dfd235e07ab76a1f267561fb60782b8fa86b7246df2a4ab70febe9ab7`. The original review record retains its historical local artifact paths; all reproduction inputs are included here.
diff --git a/research/current-serial-monomial-leaf/review/independent-check-results.json b/research/current-serial-monomial-leaf/review/independent-check-results.json
new file mode 100644
index 0000000000..32ad8cdcbc
--- /dev/null
+++ b/research/current-serial-monomial-leaf/review/independent-check-results.json
@@ -0,0 +1,69 @@
+{
+  "canonical_preserved_only_fields": [
+    "D",
+    "cutoff",
+    "entry_start",
+    "p",
+    "q0",
+    "qB",
+    "qF",
+    "stock"
+  ],
+  "consumer_semantic_fields": [
+    "G",
+    "H",
+    "K",
+    "active_start",
+    "back_start",
+    "d",
+    "f",
+    "outer",
+    "record_bits",
+    "remainder",
+    "rho",
+    "row_bits",
+    "rows",
+    "selected_axes",
+    "within_bits"
+  ],
+  "controls": [
+    "parent-write",
+    "outside-jump",
+    "unscaled-private-stride",
+    "batched-admission-does-not-imply-intermediate-admission",
+    "late-quarter-turn-overflow",
+    "missing-tensor-constant"
+  ],
+  "counterexample_widths": [
+    2,
+    20
+  ],
+  "descriptor_fields": 23,
+  "disjoint_selected_positions": 43940,
+  "fixed_rank_compilations": 73,
+  "is_universal_proof": false,
+  "maximum_observed_child_parent_header_ratio": 1.0209059233449478,
+  "methods": {
+    "finite_tables": "read-only import of emitted implementation; separate structural validator",
+    "geometry": "direct integer identities; no package oracle import",
+    "physical": "no long numeric fixtures rerun",
+    "signed": "direct complex signed-pair permutation; no phase implementation import"
+  },
+  "next_table_rows": 1206,
+  "prepare_table_rows_range": [
+    2887,
+    2899
+  ],
+  "private_ports": 45,
+  "private_views": 1820,
+  "proof_support": "Universal claims separately reviewed by algebra/source reasoning; these are bounded failure detectors.",
+  "release_table_rows": 547,
+  "signed_phase_cases": 349504,
+  "signed_widths": [
+    2,
+    8
+  ],
+  "status": "PASS_INDEPENDENT_SMALL_CHECKS",
+  "strict_signed_pairs": 86367,
+  "valid_parent_geometries": 560
+}
diff --git a/research/current-serial-monomial-leaf/review/independent_checks.py b/research/current-serial-monomial-leaf/review/independent_checks.py
new file mode 100644
index 0000000000..88e12196bb
--- /dev/null
+++ b/research/current-serial-monomial-leaf/review/independent_checks.py
@@ -0,0 +1,205 @@
+"""Complementary review checks; not a second physical provider replay.
+
+The integer geometry and signed-pair oracles are independent of the package
+checkers. Only emitted finite table inspection imports the implementation.
+Prepared by the compiler-owned review agent, with OpenAI assistance.
+"""
+from pathlib import Path
+import ast
+import hashlib
+import importlib.util
+import itertools
+import json
+import sys
+
+ROOT = Path(__file__).resolve().parent.parent
+OUT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT))
+import column_view as cv
+
+
+def require(ok, message):
+    if not ok:
+        raise AssertionError(message)
+
+
+SCHEMA = ('outer', 'rows', 'stock', 'row_bits', 'within_bits', 'record_bits',
+          'p', 'd', 'K', 'G', 'H', 'q0', 'qF', 'qB', 'D', 'f', 'rho',
+          'active_start', 'back_start', 'selected_axes', 'entry_start',
+          'remainder', 'cutoff')
+USED = {'outer', 'rows', 'row_bits', 'within_bits', 'record_bits', 'd', 'K',
+        'G', 'H', 'f', 'rho', 'active_start', 'back_start', 'selected_axes',
+        'remainder'}
+require(tuple(cv.ROLES) == SCHEMA, 'exact 23 field order')
+require(len(set(cv.ROLES.values())) == 23, 'separate decoded field ports')
+require(len(cv.PRIVATE) == 45 and cv.PARENT not in cv.PRIVATE,
+        'all 45 private roles include current child view')
+require(not set(cv.ROLES.values()) & {cv.FBOUND, cv.OLD_K, cv.COLUMN,
+                                    cv.ACC, cv.SUM, cv.M},
+        'iteration temporaries cannot clobber retained fields')
+tree = ast.parse((ROOT/'vendor/monomial/phase_adapter.py').read_text())
+consumer_fields = {n.slice.value for n in ast.walk(tree)
+    if isinstance(n, ast.Subscript) and isinstance(n.value, ast.Name)
+    and n.value.id == 'header' and isinstance(n.slice, ast.Constant)
+    and isinstance(n.slice.value, str)}
+# Eight positive checks use a fixed name tuple, so add those semantic reads.
+consumer_fields |= {'outer', 'rows', 'row_bits', 'record_bits', 'f', 'K', 'G', 'H'}
+require(consumer_fields == USED, 'reviewed exact consumer field set')
+
+
+def inspect_table(table):
+    for row in table:
+        op = row[0]
+        require(op in {'read','write','move','goto','done','result','reject','quarantine'},
+                'closed local instruction set')
+        if op in {'read','write','move'}:
+            require(type(row[1]) is int and 0 <= row[1] < 46, 'fixed port domain')
+        targets = list(row[2].values()) if op == 'read' else [row[1]] if op == 'goto' else []
+        require(all(type(t) is int and 0 <= t < len(table) for t in targets),
+                'all jump targets within immutable table')
+        if op == 'read':
+            require(set(row[2]) == {'0','1','_','|'}, 'complete local symbol cases')
+        if op == 'write':
+            require(row[1] != cv.PARENT and row[2] in {'0','1','_'},
+                    'parent and every origin marker immutable')
+        if op == 'move':
+            require(row[2] in {-1,1}, 'only unit movement')
+        if op == 'result':
+            require(row[1] in {'ready','finished'}, 'finite external branch alphabet')
+    return len(table)
+
+
+table_sizes = []
+for rank in range(1,74):
+    table_sizes.append(inspect_table(cv.compile_prepare(rank)))
+next_size, release_size = inspect_table(cv.NEXT), inspect_table(cv.RELEASE)
+controls = []
+for label, table in [('parent-write', [('write',cv.PARENT,'1'),('done',)]),
+                     ('outside-jump', [('goto',2),('done',)])]:
+    try:
+        inspect_table(table)
+    except AssertionError:
+        controls.append(label)
+    else:
+        raise AssertionError('static failure detector did not reject '+label)
+
+
+def enc_len(values):
+    return sum(2*max(1, values[name].bit_length())+1 for name in SCHEMA)
+
+
+geometries = views = selected_positions = 0
+max_child_parent_ratio = 0
+for m,f,K,G,slack in itertools.product((1,2,9,73),(1,2,3,7),(1,2,5),(1,3),(0,2)):
+    for rho in sorted({0,K-1}):
+        for e in sorted({0,m-1}):
+            H = max(1,(f-1)*G)+slack
+            u = 2*H + e*K + slack
+            z = u + m*f*K + slack
+            a = z + H + slack
+            h, r, C = 5, 3, 6
+            b = 6*r*(h+1)
+            parent = dict(outer=2, rows=3, stock=7, row_bits=b<<a,
+                within_bits=a, record_bits=b, p=max(m*f+e,2), d=m*f+e,
+                K=K, G=G, H=H, q0=5, qF=6, qB=7, D=m*f+e,
+                f=f, rho=rho, active_start=u, back_start=z,
+                selected_axes=m*f+e, entry_start=u-e*K, remainder=e,
+                cutoff=3*m*f)
+            all_parent = {u+(i*f+j)*K+rho for i in range(m) for j in range(f)}
+            seen = set()
+            for j in range(f):
+                child = dict(parent, f=1,K=f*K,rho=j*K+rho,selected_axes=m+e)
+                require(all(child[k] == parent[k] for k in SCHEMA
+                            if k not in {'f','K','rho','selected_axes'}), '19 unchanged fields')
+                require(0 <= child['rho'] < child['K'] and child['f'] == 1,
+                        'one-column residue admission')
+                require(child['selected_axes'] == m*child['f']+e <= child['d']
+                        and 0 <= e < m, 'rank/remainder admission')
+                compact = (child['f']-1)*G
+                before = u-2*H
+                after = z-u-m*child['f']*child['K']
+                suffix = a-z-compact
+                widths = [compact,H-compact,compact,H-compact,before] + [child['f']*child['K']]*m + [after,compact]
+                require(all(v >= 0 for v in widths) and a-z >= H and suffix >= 0,
+                        'all encoded subtractions and suffix admission')
+                require(sum(widths) == z, 'complete one-column enumerated address extent')
+                require((C<<sum(widths))*(2*h*r<<suffix) == (C*2*h*r<<a),
+                        'complete field volume unchanged after suffix folding')
+                position = {u+i*child['K']+child['rho'] for i in range(m)}
+                expected = {u+(i*f+j)*K+rho for i in range(m)}
+                require(position == expected and not seen & position,
+                        'exact disjoint tensor factors, preserving all spectator bits')
+                seen |= position
+                require(enc_len(child) <= 2*enc_len(parent)+10, 'finite encoded size sanity')
+                max_child_parent_ratio=max(max_child_parent_ratio,enc_len(child)/enc_len(parent))
+                views += 1
+                selected_positions += len(position)
+            require(seen == all_parent, 'all parent selected factors covered once')
+            require((f-1)*G <= H and 2*H <= u and u+m*f*K <= z and z+H <= a,
+                    'test domain is admitted parent geometry')
+            geometries += 1
+
+# This is an interface discriminator, not an error: an unused producer identity
+# need not hold in the private consumer view.
+e,K,f,u = 1,2,3,9
+entry = u-e*K
+require(entry+e*(f*K) != u, 'private header must not be advertised as generic producer descriptor')
+u,i,f,j,K,rho = 9,2,3,1,2,1
+require(u+(i*f+j)*K+rho != u+i*K+j*K+rho,
+        'unscaled stride negative control')
+controls.append('unscaled-private-stride')
+
+
+def rotate(z, phase):
+    x,y=z
+    return ((x,y),(-y,x),(-x,-y),(y,-x))[phase%4]
+
+
+signed_pairs = strict_pairs = 0
+for h in range(2,9):
+    low, high = -(1<<(h-1)), (1<<(h-1))-1
+    for x in range(low,high+1):
+        for y in range(low,high+1):
+            for p in range(4):
+                a,b=rotate((x,y),p)
+                admissible = low <= a <= high and low <= b <= high
+                formula = (p == 0 or p == 1 and y != low
+                           or p == 2 and x != low and y != low
+                           or p == 3 and x != low)
+                require(admissible == formula, 'exact signed phase iff')
+                if x != low and y != low:
+                    require(admissible and a != low and b != low,
+                            'strict symmetric signed domain invariant')
+                signed_pairs += 1
+            strict_pairs += x != low and y != low
+for h in range(2,21):
+    low,high=-(1<<(h-1)),(1<<(h-1))-1
+    z=(low,0)
+    require(rotate(z,2*2)==z and rotate(z,2)[0]>high,
+            'constant-2 two-column batched/serial domain counterexample')
+    first=rotate(z,1)
+    second=rotate(first,1)
+    require(all(low<=a<=high for a in first) and second[0]>high and rotate(z,4)==z,
+            'actual constant-1 four-column late failure, batched endpoint fits')
+controls += ['batched-admission-does-not-imply-intermediate-admission',
+             'late-quarter-turn-overflow', 'missing-tensor-constant']
+require((2*2)%4 != 2%4, 'tensor phase control separates per-column and one-time constant')
+
+report = dict(status='PASS_INDEPENDENT_SMALL_CHECKS',
+    methods={'geometry':'direct integer identities; no package oracle import',
+             'signed':'direct complex signed-pair permutation; no phase implementation import',
+             'finite_tables':'read-only import of emitted implementation; separate structural validator',
+             'physical':'no long numeric fixtures rerun'},
+    descriptor_fields=23, consumer_semantic_fields=sorted(USED),
+    canonical_preserved_only_fields=sorted(set(SCHEMA)-USED),
+    valid_parent_geometries=geometries,private_views=views,
+    disjoint_selected_positions=selected_positions,
+    maximum_observed_child_parent_header_ratio=max_child_parent_ratio,
+    fixed_rank_compilations=73,prepare_table_rows_range=[min(table_sizes),max(table_sizes)],
+    next_table_rows=next_size,release_table_rows=release_size,
+    private_ports=45,signed_phase_cases=signed_pairs,strict_signed_pairs=strict_pairs,
+    signed_widths=[2,8],counterexample_widths=[2,20],controls=controls,
+    is_universal_proof=False,
+    proof_support='Universal claims separately reviewed by algebra/source reasoning; these are bounded failure detectors.')
+(OUT/'independent-check-results.json').write_text(json.dumps(report,indent=2,sort_keys=True)+'\n')
+print(json.dumps(report,sort_keys=True))
diff --git a/research/current-serial-monomial-leaf/serial_sources.py b/research/current-serial-monomial-leaf/serial_sources.py
new file mode 100644
index 0000000000..54ab34373b
--- /dev/null
+++ b/research/current-serial-monomial-leaf/serial_sources.py
@@ -0,0 +1,64 @@
+"""Frozen unchanged current monomial and literal descriptor tables.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from hashlib import sha1, sha256
+import importlib.util
+import json
+from pathlib import Path, PurePosixPath
+from types import SimpleNamespace
+import sys
+
+HERE = Path(__file__).resolve().parent
+_loaded = None
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def authenticate(root=HERE):
+    rows = json.loads((root / "DEPENDENCIES.json").read_text())["files"]
+    seen = set()
+    for row in rows:
+        path = PurePosixPath(row["path"])
+        need(not path.is_absolute() and ".." not in path.parts
+             and path.parts[0] == "vendor" and str(path) not in seen,
+             "unique relative frozen source")
+        seen.add(str(path))
+        target = root / str(path)
+        need(target.is_file() and not target.is_symlink(), "regular frozen source")
+        raw = target.read_bytes()
+        need(sha256(raw).hexdigest() == row["sha256"]
+             and sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() == row["git_blob"],
+             "authenticated source " + str(path))
+    return len(rows)
+
+
+def load(name, path):
+    need(name not in sys.modules, "cold source namespace " + name)
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    exec(compile(path.read_bytes(), str(path), "exec"), module.__dict__)
+    return module
+
+
+def activate():
+    global _loaded
+    if _loaded is not None:
+        return _loaded
+    authenticate()
+    phase = HERE / "vendor/monomial"
+    sys.path.insert(0, str(phase))
+    binding = load("phase_binding", phase / "phase_binding.py")
+    state = binding.activate()
+    adapter = load("phase_adapter", phase / "phase_adapter.py")
+    selected = load("selected_service", phase / "selected_service.py")
+    dispatch = phase / "vendor/binding/vendor/dispatch"
+    rows = load("serial_monomial_retained_rows", dispatch / "row_programs.py")
+    _loaded = SimpleNamespace(binding=binding, state=state, adapter=adapter,
+                              selected=selected, rows=rows, phase=phase,
+                              abi=state.abi, codec=state.codec)
+    return _loaded
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/DEPENDENCIES.json b/research/current-serial-monomial-leaf/vendor/monomial/DEPENDENCIES.json
new file mode 100644
index 0000000000..cbe38bbf8f
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/DEPENDENCIES.json
@@ -0,0 +1,1203 @@
+{
+  "files": [
+    {
+      "git_blob": "9e68f7226669eb4b92330023e16a86739aa859ce",
+      "origin": {
+        "commit": "5629e7772d1720d6727465e328a45694f8620538",
+        "original_path": "research/compiled-compact-native-binding/DEPENDENCIES.json",
+        "repository": "CubeJerry/integer-mult-bounds"
+      },
+      "path": "vendor/binding/DEPENDENCIES.json",
+      "sha256": "8481fde09d925fe143a604a4924f05bb1ade2d1ac8f9068389680c9406f71507"
+    },
+    {
+      "git_blob": "859eb593d3b5bb07b3fd8a3b1034b4ac19a8dd6c",
+      "origin": {
+        "commit": "5629e7772d1720d6727465e328a45694f8620538",
+        "original_path": "research/compiled-compact-native-binding/PROOF.md",
+        "repository": "CubeJerry/integer-mult-bounds"
+      },
+      "path": "vendor/binding/PROOF.md",
+      "sha256": "acabf664e97b35d5c63998c6f08bbea27369b36db14b203c4ef62180a9535faf"
+    },
+    {
+      "git_blob": "15469f097247a4627336b9bb77d03b8696533276",
+      "origin": {
+        "commit": "5629e7772d1720d6727465e328a45694f8620538",
+        "original_path": "research/compiled-compact-native-binding/binding_sources.py",
+        "repository": "CubeJerry/integer-mult-bounds"
+      },
+      "path": "vendor/binding/binding_sources.py",
+      "sha256": "e3b1cd40a2436381b3688aa3a5a740d402d08d0611dc43a629634bb1a6f7b299"
+    },
+    {
+      "git_blob": "bf3bd0d5a6fbfa1e7a56c36578c2caaa0130c7c5",
+      "origin": {
+        "commit": "5629e7772d1720d6727465e328a45694f8620538",
+        "original_path": "research/compiled-compact-native-binding/codec.py",
+        "repository": "CubeJerry/integer-mult-bounds"
+      },
+      "path": "vendor/binding/codec.py",
+      "sha256": "60f94c991568981c1ae8633bbc9c4d3c259e2df0654e8720d7f4554737d8e136"
+    },
+    {
+      "git_blob": "481013b988e5ae8189a0dddfcbb2f521e3142cab",
+      "origin": {
+        "commit": "5629e7772d1720d6727465e328a45694f8620538",
+        "original_path": "research/compiled-compact-native-binding/provider.py",
+        "repository": "CubeJerry/integer-mult-bounds"
+      },
+      "path": "vendor/binding/provider.py",
+      "sha256": "3b7bb4f7940ffa9fafd34d25bbb1a9225e1b671924ed194ad012cb26251d7460"
+    },
+    {
+      "git_blob": "de725a73e97496836100aa6e0ed9cd70985373da",
+      "origin": {
+        "git_blob": "de725a73e97496836100aa6e0ed9cd70985373da",
+        "group": "deferred",
+        "original_path": "research/p104-6030-deferred-layer/PROOF.md",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "3a7ac6dae3b76d5f78849f521635da034fe99b1ea6c942175a3652b53f6262c2"
+      },
+      "path": "vendor/binding/vendor/DEFERRED-PROOF.md",
+      "sha256": "3a7ac6dae3b76d5f78849f521635da034fe99b1ea6c942175a3652b53f6262c2"
+    },
+    {
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "origin": {
+        "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+        "group": "selected",
+        "original_path": "certificates/selected-result.json",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+      },
+      "path": "vendor/binding/vendor/SELECTED-RESULT.json",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "origin": {
+        "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+        "group": "task",
+        "original_path": "docs/research/agent-task-catalog.json",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+      },
+      "path": "vendor/binding/vendor/TASK-CATALOG.json",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb",
+      "origin": {
+        "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/PROOF.md",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48"
+      },
+      "path": "vendor/binding/vendor/compact/PROOF.md",
+      "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48"
+    },
+    {
+      "git_blob": "13af719b5844f14f5cf05c919e84204cd21caf6a",
+      "origin": {
+        "git_blob": "13af719b5844f14f5cf05c919e84204cd21caf6a",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/compact_control.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "73a9ace4f91aeb383fdbc6f7762498fe707b4e4b45b1c63920bb90cc8795e284"
+      },
+      "path": "vendor/binding/vendor/compact/compact_control.py",
+      "sha256": "73a9ace4f91aeb383fdbc6f7762498fe707b4e4b45b1c63920bb90cc8795e284"
+    },
+    {
+      "git_blob": "064b508efd12f7d5a33729b2344b6890f0c75d2f",
+      "origin": {
+        "git_blob": "064b508efd12f7d5a33729b2344b6890f0c75d2f",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/compact_counts.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d"
+      },
+      "path": "vendor/binding/vendor/compact/compact_counts.py",
+      "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d"
+    },
+    {
+      "git_blob": "5c5ca75567f85b042c156e0ed5a8afe81671b1b8",
+      "origin": {
+        "git_blob": "5c5ca75567f85b042c156e0ed5a8afe81671b1b8",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/compact_engine.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "2cacff4d36a6e029add115f47cd8ffbf3c61e7ece0900308b98e6032e652f098"
+      },
+      "path": "vendor/binding/vendor/compact/compact_engine.py",
+      "sha256": "2cacff4d36a6e029add115f47cd8ffbf3c61e7ece0900308b98e6032e652f098"
+    },
+    {
+      "git_blob": "03ca12aed77741f40d824fcb33cc4eedb85abfd9",
+      "origin": {
+        "git_blob": "03ca12aed77741f40d824fcb33cc4eedb85abfd9",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/compact_layout.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "5be2be9c32c15742da18fde438a5559a45a86eb661105027b1b233a7c397e0ce"
+      },
+      "path": "vendor/binding/vendor/compact/compact_layout.py",
+      "sha256": "5be2be9c32c15742da18fde438a5559a45a86eb661105027b1b233a7c397e0ce"
+    },
+    {
+      "git_blob": "5699cc7f20def3bc873d2da05b13a252246367a1",
+      "origin": {
+        "git_blob": "5699cc7f20def3bc873d2da05b13a252246367a1",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/compact_streams.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "3b5cce3be9763c6bd7803d6223d2784d1975eeac6c7c99f5e00dfc49bb11d249"
+      },
+      "path": "vendor/binding/vendor/compact/compact_streams.py",
+      "sha256": "3b5cce3be9763c6bd7803d6223d2784d1975eeac6c7c99f5e00dfc49bb11d249"
+    },
+    {
+      "git_blob": "3d2834c5fff39481c9a0442a514c10eaf50f98d2",
+      "origin": {
+        "git_blob": "3d2834c5fff39481c9a0442a514c10eaf50f98d2",
+        "group": "compact",
+        "original_path": "research/physical-complex-compact/native_sources.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "865c97c4f261fde37e86eb16a910eaa5b2f26daaa7d2648ae0322ba8c0286572"
+      },
+      "path": "vendor/binding/vendor/compact/native_sources.py",
+      "sha256": "865c97c4f261fde37e86eb16a910eaa5b2f26daaa7d2648ae0322ba8c0286572"
+    },
+    {
+      "git_blob": "96b032f662397d496c4d827839441b6794881a53",
+      "origin": {
+        "git_blob": "96b032f662397d496c4d827839441b6794881a53",
+        "group": "dispatch",
+        "original_path": "research/compiled-row-stock-dispatch/PROOF.md",
+        "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "b0ed45deb84fa2ce835246d7de3c85ccdacf24ab68235cf1138fe6ff4c4ce5d9"
+      },
+      "path": "vendor/binding/vendor/dispatch/PROOF.md",
+      "sha256": "b0ed45deb84fa2ce835246d7de3c85ccdacf24ab68235cf1138fe6ff4c4ce5d9"
+    },
+    {
+      "git_blob": "70bb2c54a6dbf9f17a55bbae8383d9bfde933e52",
+      "origin": {
+        "git_blob": "70bb2c54a6dbf9f17a55bbae8383d9bfde933e52",
+        "group": "task",
+        "original_path": "research/compiled-row-stock-dispatch/TASK.json",
+        "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "6b5334d10044644ba646452b0e9e21528061768726d124a4a97af26785aa9ec9"
+      },
+      "path": "vendor/binding/vendor/dispatch/TASK.json",
+      "sha256": "6b5334d10044644ba646452b0e9e21528061768726d124a4a97af26785aa9ec9"
+    },
+    {
+      "git_blob": "5752189b8a838596346df8dde89024621b513e41",
+      "origin": {
+        "git_blob": "5752189b8a838596346df8dde89024621b513e41",
+        "group": "dispatch",
+        "original_path": "research/compiled-row-stock-dispatch/compiler_routes.py",
+        "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "d375f8c2e666ffd2ebe6de34ccb7756ac9fa4a4cd5f866cb025a781f8538c599"
+      },
+      "path": "vendor/binding/vendor/dispatch/compiler_routes.py",
+      "sha256": "d375f8c2e666ffd2ebe6de34ccb7756ac9fa4a4cd5f866cb025a781f8538c599"
+    },
+    {
+      "git_blob": "30ba41725f7e1ba3dd058abd30c66d19820a008d",
+      "origin": {
+        "git_blob": "30ba41725f7e1ba3dd058abd30c66d19820a008d",
+        "group": "dispatch",
+        "original_path": "research/compiled-row-stock-dispatch/row_programs.py",
+        "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "a59510516d1397382de6141edc1eb69cf3ba5e6e330198deb5e335e543300be4"
+      },
+      "path": "vendor/binding/vendor/dispatch/row_programs.py",
+      "sha256": "a59510516d1397382de6141edc1eb69cf3ba5e6e330198deb5e335e543300be4"
+    },
+    {
+      "git_blob": "9c3c97d86a7bdd7b95944218bf1e6e4a5a1746a1",
+      "origin": {
+        "git_blob": "9c3c97d86a7bdd7b95944218bf1e6e4a5a1746a1",
+        "group": "dispatch",
+        "original_path": "research/compiled-row-stock-dispatch/vendor/occurrence_geometry.py",
+        "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "f3504a73803da120040cc62ee8f5e8b849237daf508a7146272d55624c3f8396"
+      },
+      "path": "vendor/binding/vendor/dispatch/vendor/occurrence_geometry.py",
+      "sha256": "f3504a73803da120040cc62ee8f5e8b849237daf508a7146272d55624c3f8396"
+    },
+    {
+      "git_blob": "1e3533efa92c3bab35916ae6844290586d18ff27",
+      "origin": {
+        "git_blob": "1e3533efa92c3bab35916ae6844290586d18ff27",
+        "group": "dispatch",
+        "original_path": "research/compiled-row-stock-dispatch/vendor/row_padding.py",
+        "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "24270408e87b028791670cd63908adeb03162f0919237e8644065c5898fecf2f"
+      },
+      "path": "vendor/binding/vendor/dispatch/vendor/row_padding.py",
+      "sha256": "24270408e87b028791670cd63908adeb03162f0919237e8644065c5898fecf2f"
+    },
+    {
+      "git_blob": "605981247e27de68fe78d3a36e2b454efbd6b11e",
+      "origin": {
+        "git_blob": "605981247e27de68fe78d3a36e2b454efbd6b11e",
+        "group": "lifecycle",
+        "original_path": "research/compiled-owned-bank-lifecycle/PROOF.md",
+        "published_commit": "ab239cb6ee884e7a900dd9101c34448077fad0b0",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "9a088fa00f10e59df48090b67c6ef7c3641bc9cc36b223deb917740372d57993"
+      },
+      "path": "vendor/binding/vendor/lifecycle/PROOF.md",
+      "sha256": "9a088fa00f10e59df48090b67c6ef7c3641bc9cc36b223deb917740372d57993"
+    },
+    {
+      "git_blob": "acf475e4fccaff2fb64bd5b0b3f3fc0d246dc592",
+      "origin": {
+        "git_blob": "acf475e4fccaff2fb64bd5b0b3f3fc0d246dc592",
+        "group": "lifecycle",
+        "original_path": "research/compiled-owned-bank-lifecycle/machine.py",
+        "published_commit": "ab239cb6ee884e7a900dd9101c34448077fad0b0",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "ec597bce13275003ff30e4be481c936401826c1d4af642b55eec0c410774d1df"
+      },
+      "path": "vendor/binding/vendor/lifecycle/machine.py",
+      "sha256": "ec597bce13275003ff30e4be481c936401826c1d4af642b55eec0c410774d1df"
+    },
+    {
+      "git_blob": "79c95fa79439f3c893de52991173bd3a5eae2729",
+      "origin": {
+        "git_blob": "79c95fa79439f3c893de52991173bd3a5eae2729",
+        "group": "lifecycle",
+        "original_path": "research/compiled-owned-bank-lifecycle/source_ir.py",
+        "published_commit": "ab239cb6ee884e7a900dd9101c34448077fad0b0",
+        "repository": "CubeJerry/integer-mult-bounds",
+        "sha256": "54dd93bc50bd10e974c70794df1c13da27f0e3d8cdb6cfe6791a63280096f1b1"
+      },
+      "path": "vendor/binding/vendor/lifecycle/source_ir.py",
+      "sha256": "54dd93bc50bd10e974c70794df1c13da27f0e3d8cdb6cfe6791a63280096f1b1"
+    },
+    {
+      "git_blob": "9469443a3d7cc6310a7369daf77c7756d5bd3f38",
+      "origin": {
+        "git_blob": "9469443a3d7cc6310a7369daf77c7756d5bd3f38",
+        "group": "compiler",
+        "original_path": "research/lockstep-completion-pass/executor.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "0bda14a3e5f4da348cd5c89ebe29d717e7a5406ec31b164d5b9e1d25f7f38e0e"
+      },
+      "path": "vendor/binding/vendor/lockstep_executor.py",
+      "sha256": "0bda14a3e5f4da348cd5c89ebe29d717e7a5406ec31b164d5b9e1d25f7f38e0e"
+    },
+    {
+      "git_blob": "12be1f06062090fcc68e598bae250f185e3d8524",
+      "origin": {
+        "git_blob": "12be1f06062090fcc68e598bae250f185e3d8524",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/PROOF.md",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "8a1c2145cd8f080026488a571d95813c09679aa323f19aeaef0ea98030136e1c"
+      },
+      "path": "vendor/binding/vendor/ordinary/PROOF.md",
+      "sha256": "8a1c2145cd8f080026488a571d95813c09679aa323f19aeaef0ea98030136e1c"
+    },
+    {
+      "git_blob": "651185a9eec51438949580a34e707f6dd1adbd4b",
+      "origin": {
+        "git_blob": "651185a9eec51438949580a34e707f6dd1adbd4b",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/binary.py",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "578fb5bc793fc544dca8111605bf9f6067b8ba7dc7489a3ac243e1df3cd37953"
+      },
+      "path": "vendor/binding/vendor/ordinary/binary.py",
+      "sha256": "578fb5bc793fc544dca8111605bf9f6067b8ba7dc7489a3ac243e1df3cd37953"
+    },
+    {
+      "git_blob": "2280fa98ff5e4da7c4909814ce4a1c405605ada8",
+      "origin": {
+        "git_blob": "2280fa98ff5e4da7c4909814ce4a1c405605ada8",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/encoded.py",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "10ad2fa5902a48d49cf2b89a30b3f2711d63a6a43b9512a6427affcdf07335a7"
+      },
+      "path": "vendor/binding/vendor/ordinary/encoded.py",
+      "sha256": "10ad2fa5902a48d49cf2b89a30b3f2711d63a6a43b9512a6427affcdf07335a7"
+    },
+    {
+      "git_blob": "81b330a4b886a0f4deab7b0811478bab3fbc107a",
+      "origin": {
+        "git_blob": "81b330a4b886a0f4deab7b0811478bab3fbc107a",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/ordinary.py",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "7f8338e748bcd42fbef1e7cc47b6c5040dfb3aad216e34759bcb12b8e14f7705"
+      },
+      "path": "vendor/binding/vendor/ordinary/ordinary.py",
+      "sha256": "7f8338e748bcd42fbef1e7cc47b6c5040dfb3aad216e34759bcb12b8e14f7705"
+    },
+    {
+      "git_blob": "44b464714277786297c8ee7fd04470dc6394896d",
+      "origin": {
+        "git_blob": "44b464714277786297c8ee7fd04470dc6394896d",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/physical_words.py",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "89ba40442297ec35368e426770f44852b39807ca426710ded2735678651bef61"
+      },
+      "path": "vendor/binding/vendor/ordinary/physical_words.py",
+      "sha256": "89ba40442297ec35368e426770f44852b39807ca426710ded2735678651bef61"
+    },
+    {
+      "git_blob": "09f645bbf0c6c3d41d0c03e8031adc4e81744ac1",
+      "origin": {
+        "git_blob": "09f645bbf0c6c3d41d0c03e8031adc4e81744ac1",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/session.py",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "45ee809b27a69ca5576361922fd2760f568c9a98864d4c55c4fee3003ee3c9ad"
+      },
+      "path": "vendor/binding/vendor/ordinary/session.py",
+      "sha256": "45ee809b27a69ca5576361922fd2760f568c9a98864d4c55c4fee3003ee3c9ad"
+    },
+    {
+      "git_blob": "8594fc62cee8a111958561b75045c8ec16ebfa47",
+      "origin": {
+        "git_blob": "8594fc62cee8a111958561b75045c8ec16ebfa47",
+        "group": "ordinary",
+        "original_path": "research/physical-ordinary-interchange/source.py",
+        "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "4bd047a1272374880962d3074f1e50de717518a3a181f11607e820afe50dd4e5"
+      },
+      "path": "vendor/binding/vendor/ordinary/source.py",
+      "sha256": "4bd047a1272374880962d3074f1e50de717518a3a181f11607e820afe50dd4e5"
+    },
+    {
+      "git_blob": "69e07e58c5468e2045281335a56f4918b474c79d",
+      "origin": {
+        "git_blob": "69e07e58c5468e2045281335a56f4918b474c79d",
+        "group": "record_lift",
+        "original_path": "research/selected-monomial-tape-lift/PROOF.md",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "8442243130d4a9932f78eb42419196d2866d4496256e3bb2d6143fd52b44ddb3"
+      },
+      "path": "vendor/binding/vendor/record_lift/PROOF.md",
+      "sha256": "8442243130d4a9932f78eb42419196d2866d4496256e3bb2d6143fd52b44ddb3"
+    },
+    {
+      "git_blob": "167d085a9191e3b3545bcf39d5e6edc94e54d514",
+      "origin": {
+        "git_blob": "167d085a9191e3b3545bcf39d5e6edc94e54d514",
+        "group": "record_lift",
+        "original_path": "research/selected-monomial-tape-lift/lift.py",
+        "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "21c77119c004a86a603cca91ce1366629431db18e9e0554942492f1b5afebe4a"
+      },
+      "path": "vendor/binding/vendor/record_lift/lift.py",
+      "sha256": "21c77119c004a86a603cca91ce1366629431db18e9e0554942492f1b5afebe4a"
+    },
+    {
+      "git_blob": "e82bfef53054bd753ba0aa8a966f84427faa2293",
+      "origin": {
+        "git_blob": "e82bfef53054bd753ba0aa8a966f84427faa2293",
+        "group": "reference",
+        "original_path": "research/selected-complex-compact-adapters/NOTICE.md",
+        "published_commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "74a9f03e9ce467c75f5f7cf1b8465d349ea38ef114afad261824c3bcf13da00f"
+      },
+      "path": "vendor/binding/vendor/reference/NOTICE.md",
+      "sha256": "74a9f03e9ce467c75f5f7cf1b8465d349ea38ef114afad261824c3bcf13da00f"
+    },
+    {
+      "git_blob": "60bc206c78150f23563a4775800b0dd32025843d",
+      "origin": {
+        "git_blob": "60bc206c78150f23563a4775800b0dd32025843d",
+        "group": "reference",
+        "original_path": "research/selected-complex-compact-adapters/compact.py",
+        "published_commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "0e1027a60f38c21cfd808c8ce44dcc2423810efdab0e15f02b07f261ad48fc3c"
+      },
+      "path": "vendor/binding/vendor/reference/compact.py",
+      "sha256": "0e1027a60f38c21cfd808c8ce44dcc2423810efdab0e15f02b07f261ad48fc3c"
+    },
+    {
+      "git_blob": "61542ce4c9eb51bfc113475b4f98649cb90a853e",
+      "origin": {
+        "git_blob": "61542ce4c9eb51bfc113475b4f98649cb90a853e",
+        "group": "reference",
+        "original_path": "research/selected-complex-compact-adapters/streams.py",
+        "published_commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+        "repository": "CrocSwap/integer-mult-bounds",
+        "sha256": "718a582a50aee8f1f04945ed942be1d4162962fe47dbf05c6ff37b7fb8c61257"
+      },
+      "path": "vendor/binding/vendor/reference/streams.py",
+      "sha256": "718a582a50aee8f1f04945ed942be1d4162962fe47dbf05c6ff37b7fb8c61257"
+    },
+    {
+      "git_blob": "1341d394481fb13beb826b944409b11083d8e7f8",
+      "origin": {
+        "archive_name": "pr2808.tar",
+        "archive_sha256": "2ab59c6d0ad00c001ecbe44090b66871ec3d2c1fdc51daa503109e56f3285cab",
+        "git_blob": "1341d394481fb13beb826b944409b11083d8e7f8",
+        "member": "outer.py",
+        "sha256": "9a26702a853805da7f97da7272d3b610c4d69767ecc6b450efbc4b6722dc3f19"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2808/outer.py",
+      "sha256": "9a26702a853805da7f97da7272d3b610c4d69767ecc6b450efbc4b6722dc3f19"
+    },
+    {
+      "git_blob": "0229304638de6c78ebc519b33a6ce34b1d396ca7",
+      "origin": {
+        "archive_name": "pr2808.tar",
+        "archive_sha256": "2ab59c6d0ad00c001ecbe44090b66871ec3d2c1fdc51daa503109e56f3285cab",
+        "git_blob": "0229304638de6c78ebc519b33a6ce34b1d396ca7",
+        "member": "vendor/pr2786/padding.py",
+        "sha256": "9f58bf2d343e13a70dc765d86c590b912d5987669d507ab14bd36deed94a76ee"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2808/vendor/pr2786/padding.py",
+      "sha256": "9f58bf2d343e13a70dc765d86c590b912d5987669d507ab14bd36deed94a76ee"
+    },
+    {
+      "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd",
+        "member": "inputs/pr2753/consumer.py",
+        "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/consumer.py",
+      "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777"
+    },
+    {
+      "git_blob": "5b7846a70aada53d87480b337e1c04217118771b",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "5b7846a70aada53d87480b337e1c04217118771b",
+        "member": "inputs/pr2753/driver.py",
+        "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/driver.py",
+      "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf"
+    },
+    {
+      "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e",
+        "member": "inputs/pr2753/evidence/NOTICE.md",
+        "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md",
+      "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9"
+    },
+    {
+      "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8",
+        "member": "inputs/pr2753/evidence/pr2688-NOTICE.md",
+        "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md",
+      "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617"
+    },
+    {
+      "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb",
+        "member": "inputs/pr2753/layout.py",
+        "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/layout.py",
+      "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1"
+    },
+    {
+      "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c",
+        "member": "inputs/pr2753/linear_sign.py",
+        "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/linear_sign.py",
+      "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67"
+    },
+    {
+      "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e",
+        "member": "inputs/pr2753/node.py",
+        "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/node.py",
+      "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b"
+    },
+    {
+      "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7",
+        "member": "inputs/pr2753/packet_engine.py",
+        "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/packet_engine.py",
+      "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134"
+    },
+    {
+      "git_blob": "38502515afc928082c849cd2cda8578d33a5050a",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "38502515afc928082c849cd2cda8578d33a5050a",
+        "member": "inputs/pr2753/peel.py",
+        "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/peel.py",
+      "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e"
+    },
+    {
+      "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0",
+        "member": "inputs/pr2753/predecessor/NOTICE.md",
+        "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md",
+      "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943"
+    },
+    {
+      "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e",
+        "member": "inputs/pr2753/predecessor/cardinal_counts.py",
+        "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py",
+      "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f"
+    },
+    {
+      "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29",
+        "member": "inputs/pr2753/predecessor/catalogue.py",
+        "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py",
+      "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf"
+    },
+    {
+      "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2",
+        "member": "inputs/pr2753/predecessor/control.py",
+        "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py",
+      "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a"
+    },
+    {
+      "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093",
+        "member": "inputs/pr2753/predecessor/fresh_rows.py",
+        "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py",
+      "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d"
+    },
+    {
+      "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990",
+        "member": "inputs/pr2753/predecessor/topology.py",
+        "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py",
+      "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b"
+    },
+    {
+      "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8",
+        "member": "inputs/pr2753/predecessor/vendor/binding.py",
+        "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py",
+      "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b"
+    },
+    {
+      "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca",
+        "member": "inputs/pr2753/predecessor/vendor/bitstream.py",
+        "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py",
+      "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783"
+    },
+    {
+      "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208",
+        "member": "inputs/pr2753/predecessor/vendor/cardinality.py",
+        "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py",
+      "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22"
+    },
+    {
+      "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b",
+        "member": "inputs/pr2753/predecessor/vendor/children.py",
+        "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py",
+      "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6"
+    },
+    {
+      "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60",
+        "member": "inputs/pr2753/predecessor/vendor/controller.py",
+        "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py",
+      "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c"
+    },
+    {
+      "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d",
+        "member": "inputs/pr2753/predecessor/vendor/counts.py",
+        "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py",
+      "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069"
+    },
+    {
+      "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226",
+        "member": "inputs/pr2753/predecessor/vendor/directory.py",
+        "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py",
+      "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7"
+    },
+    {
+      "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe",
+        "member": "inputs/pr2753/predecessor/vendor/episode.py",
+        "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py",
+      "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff"
+    },
+    {
+      "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398",
+        "member": "inputs/pr2753/predecessor/vendor/forms.py",
+        "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py",
+      "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4"
+    },
+    {
+      "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6",
+        "member": "inputs/pr2753/predecessor/vendor/low_codes.py",
+        "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py",
+      "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87"
+    },
+    {
+      "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d",
+        "member": "inputs/pr2753/predecessor/vendor/matrices.py",
+        "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py",
+      "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459"
+    },
+    {
+      "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611",
+        "member": "inputs/pr2753/predecessor/vendor/numeric.py",
+        "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py",
+      "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514"
+    },
+    {
+      "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f",
+        "member": "inputs/pr2753/predecessor/vendor/oracle.py",
+        "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py",
+      "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67"
+    },
+    {
+      "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453",
+        "member": "inputs/pr2753/predecessor/vendor/packet.py",
+        "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py",
+      "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5"
+    },
+    {
+      "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8",
+        "member": "inputs/pr2753/predecessor/vendor/plan.py",
+        "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py",
+      "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3"
+    },
+    {
+      "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3",
+        "member": "inputs/pr2753/predecessor/vendor/records.py",
+        "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py",
+      "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372"
+    },
+    {
+      "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194",
+        "member": "inputs/pr2753/predecessor/vendor/routes.py",
+        "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py",
+      "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada"
+    },
+    {
+      "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700",
+        "member": "inputs/pr2753/predecessor/vendor/selection.py",
+        "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py",
+      "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b"
+    },
+    {
+      "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4",
+        "member": "inputs/pr2753/predecessor/vendor/sources.py",
+        "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py",
+      "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62"
+    },
+    {
+      "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389",
+        "member": "inputs/pr2753/predecessor/vendor/stream.py",
+        "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py",
+      "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5"
+    },
+    {
+      "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402",
+        "member": "inputs/pr2753/recursive_call.py",
+        "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/recursive_call.py",
+      "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e"
+    },
+    {
+      "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f",
+        "member": "inputs/pr2753/scheduler.py",
+        "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/scheduler.py",
+      "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f"
+    },
+    {
+      "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b",
+        "member": "inputs/pr2753/stream_runner.py",
+        "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/stream_runner.py",
+      "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801"
+    },
+    {
+      "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71",
+        "member": "inputs/pr2753/trace.py",
+        "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2753/trace.py",
+      "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2"
+    },
+    {
+      "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02",
+        "member": "inputs/pr2769/NOTICE.md",
+        "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2769/NOTICE.md",
+      "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178"
+    },
+    {
+      "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31",
+        "member": "inputs/pr2769/codec.py",
+        "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2769/codec.py",
+      "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3"
+    },
+    {
+      "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19",
+        "member": "inputs/pr2769/vendor/parking_machine.py",
+        "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py",
+      "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c"
+    },
+    {
+      "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50",
+        "member": "inputs/pr2769/vendor/words.py",
+        "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/words.py",
+      "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9"
+    },
+    {
+      "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0",
+        "member": "macro_binding.py",
+        "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/macro_binding.py",
+      "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a"
+    },
+    {
+      "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7",
+        "member": "macro_code.py",
+        "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/macro_code.py",
+      "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8"
+    },
+    {
+      "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16",
+        "member": "macro_machine.py",
+        "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/macro_machine.py",
+      "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a"
+    },
+    {
+      "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22",
+        "member": "residual_blocks.py",
+        "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/residual_blocks.py",
+      "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331"
+    },
+    {
+      "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef",
+        "member": "role_parking.py",
+        "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/role_parking.py",
+      "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3"
+    },
+    {
+      "git_blob": "0f22807c65d1bca374b905538512bf8c43702070",
+      "origin": {
+        "archive_name": "pr2809.tar",
+        "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+        "git_blob": "0f22807c65d1bca374b905538512bf8c43702070",
+        "member": "scratch_pool.py",
+        "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db"
+      },
+      "path": "vendor/binding/vendor/runtime/pr2809/scratch_pool.py",
+      "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db"
+    },
+    {
+      "git_blob": "82e9a8b0b50f26844528af9e07632800679805ea",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/PROOF.md",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/PROOF.md",
+      "sha256": "20885a8a137fc670121429625912ceae54db95ac5e574b8c64c90f477aebacb7"
+    },
+    {
+      "git_blob": "e040a558800e719e2d8b6237bec39e7e10a3641b",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/SOURCES.json",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/SOURCES.json",
+      "sha256": "0dd57a4fe4fc97826df0eb215975d013ac0e18f185c73cd93e34c95a9a2b4b16"
+    },
+    {
+      "git_blob": "2251fd98ba01a171f5d39b25a93c895245f10e55",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/monomial_engine.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/monomial_engine.py",
+      "sha256": "fc02c6c5159d6c258063a36ef3dc9313a34d7ba9781b650e451cc0ce971e9667"
+    },
+    {
+      "git_blob": "0e467bdb3727d7f354f98dee54f320f1f072aa2c",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/pair_dispatch.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/pair_dispatch.py",
+      "sha256": "fc0eaa2a9d0855660b15a15d894137eeebc64c6418f52b6af0d0f79d86f2e0d9"
+    },
+    {
+      "git_blob": "a2f684fb588257cc182dc88dded59ed70f5c2585",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/phase_recipe.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/phase_recipe.py",
+      "sha256": "8215e5e55daf019694e55b2acfcd42ecf109a2faf767a2181d664ba9b4957e46"
+    },
+    {
+      "git_blob": "aaa5c663a4bb6b0ca4d9119c1ae92064509d79c8",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/phase_sources.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/phase_sources.py",
+      "sha256": "3944ecbffe91fb561b2b8a810461cd2b8229f1f2611ca6a70e3d86451efb220b"
+    },
+    {
+      "git_blob": "5fa4494167c4ba668993a2b1c902969518728a4c",
+      "origin": {
+        "commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+        "original_path": "research/selected-complex-compact-adapters/monomial.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/reference.py",
+      "sha256": "394f9a465ac9148af0c20844d375e4befbef17d92b2fcc840d83419480dd4740"
+    },
+    {
+      "git_blob": "bab32b0c5da7f364d6a79171c09b02d123a05bd9",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/physical-gaussian-monomial/signed_phase.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/monomial/signed_phase.py",
+      "sha256": "e21818674133a2bd7e63fadaf719eb45ce80db4b3806ca8ef99c247be22c2a39"
+    },
+    {
+      "git_blob": "e4a03118d585fb80c9ac932281b528ac394ccc5f",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/p104-helper470-twin-rung-removal/RESULT.json",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/selected/RESULT.json",
+      "sha256": "84fcbe2a0b64307b5703c363408042bdd91555b0419509aa50daa43b3b1924ad"
+    },
+    {
+      "git_blob": "22f9ab02d1b73ea0aa4b07ce445a14cc2602c760",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/p104-helper470-twin-rung-removal/WORD.json.gz",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/selected/WORD.json.gz",
+      "sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f"
+    },
+    {
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/p104-native-channel/vendor/clifford_exact.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/selected/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    },
+    {
+      "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c",
+      "origin": {
+        "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+        "original_path": "research/p104-native-channel/vendor/native_verify.py",
+        "repository": "CrocSwap/integer-mult-bounds"
+      },
+      "path": "vendor/selected/native_verify.py",
+      "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38"
+    }
+  ],
+  "schema_version": 1
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/PROOF.md
new file mode 100644
index 0000000000..5bd585e03c
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/PROOF.md
@@ -0,0 +1,449 @@
+# Current coded Gaussian monomial with complete coefficient fibres
+
+Prepared for **@CubeJerry**, with substantial OpenAI assistance in source
+analysis, implementation, mathematical argument, and adversarial verification.
+Apache-2.0; predecessor notices and exact computational sources are retained.
+
+## 1. Claim and non-overlap
+
+This package supplies the missing format and context join between the physical
+Gaussian monomial of [#3087](https://github.com/CrocSwap/integer-mult-bounds/pull/3087)
+and the current three-bit `CodedPort` numeric field and twenty-three-field
+descriptor. It produces the old layout and signed coefficients through counted
+physical operations, executes the unchanged monomial, and returns the complete
+current format in place. It preserves the descriptor and all caller ancestors,
+and erases every owned current segment, including encoded logical blanks.
+
+The theorem below is a **structured finite-control, fixed-inventory source
+refinement**, relative to the stated completed ordinary supplier and current
+port contracts. It is not an emitted flat transition table for the lifecycle
+controller. It does not close a universal selected assumption or change kappa.
+
+The inherited phase formula, affine compiler, signed-pair theorem, Compact
+algorithm, and their cost are not new results. Jose Manuel (`jmbarrancoml`), with
+OpenAI assistance, already implemented those in #3087, building on #2250,
+#2378, #2422, and #3055. [#6293](https://github.com/CrocSwap/integer-mult-bounds/pull/6293)
+already treats the all-width phase convention, including the repeated constant.
+[#6930](https://github.com/CrocSwap/integer-mult-bounds/pull/6930), pinned at
+`c726399fbdb6d80dd13bed760b56572fb4ea1022`, already audits the primary phase
+integer of the selected MOVE used here. We inherit those results.
+
+Chris R (`Clear1nsight`), with OpenAI assistance, supplied the older prepared
+QQ16 common-grid conversion and signed packet join in
+[#4129](https://github.com/CrocSwap/integer-mult-bounds/pull/4129). Its raw/tagged
+packet and caller contracts differ from this current descriptor, current
+`CodedPort`, selected source token, and suffix layout. We neither repeat its
+quantum conversion nor identify its old component ABI with the current one.
+
+The separately credited [current Compact binding](https://github.com/CubeJerry/integer-mult-bounds/tree/5629e7772d1720d6727465e328a45694f8620538/research/compiled-compact-native-binding) supplies the
+shared current symbol codec, exact header parser, guarded old-tape refinement,
+and complete current-segment retirement. We reuse those exact bytes. Its opaque
+record permutation by itself does not establish arithmetic on the three-bit
+encoding: the new delimiter stripping, signed-field grouping, and exact return
+in this package are necessary for that step.
+
+## 2. Quantified current interface
+
+Compile a literal invertible binary monomial of fixed rank `1<=m<=73`, with
+matrix `L`, offset `v`, constant `c` modulo four, linear coefficients `l_i`
+modulo four, and strict-upper quadratic coefficients `q_ik` in `{0,1}`.
+Compile its direction and one completed ordinary supplier before numerical
+input. The supplier has the unchanged native interface and the contract used
+by #3087; its fixture elementary branch is not an admission of its faster rate.
+
+`Provider(literal,native_factory,inverse=False).bind(work)` fixes a finite set of
+physical work ports. `run(field,context)` receives a current `CodedPort` field
+and a read-only `BinaryContextPort` descriptor, both at their local origins.
+The caller supplies genuinely disjoint physical segments for field, context,
+and all work roles. The object-identity guards reject obvious aliasing but do
+not prove disjointness of distinct wrappers over the same physical segment.
+All current work segments are initially physically blank. Caller ancestors
+precede protected local origin markers and are outside the writable segments.
+
+The exact descriptor order is
+
+```
+outer, rows, stock, row_bits, within_bits, record_bits, p, d, K, G, H,
+q0, qF, qB, D, f, rho, active_start, back_start, selected_axes,
+entry_start, remainder, cutoff.
+```
+
+Each nonnegative integer is represented by a positive unary digit length,
+a zero separator, and that many canonical least-significant-first binary
+digits. The exact physical frontier follows field 23. All fields are scanned
+and returned unchanged; unused large metadata is not free. In particular,
+the address reservation `H` is not the signed component width below.
+
+Write `a=within_bits`, `b=record_bits`, `u=active_start`, `z=back_start`,
+`C=outer*rows`, and let `h>=2` be the uniform signed component width. Each
+original numeric record contains `r>=1` complex coefficient fields. Each field
+has `h` real bits then a component delimiter, and `h` imaginary bits then a
+component delimiter. The bits are little-endian two's-complement integers on
+one fixed common grid supplied by the caller. Each virtual bit or delimiter
+is encoded by the current three-bit code, so
+
+```
+b=6*r*(h+1),  row_bits=2^a*b,  V=C*2^a*b.
+```
+
+The delimiter is virtual symbol 2, physically `010`. A numeric zero component
+therefore retains its delimiter; it is not an unformatted run of physical zeros.
+Virtual blank 4 is the stream frontier, while physical blank is symbol 6.
+No internal physical blank is admitted inside a canonical complete field.
+
+The required geometry is
+
+```
+outer,rows,f,K,G,H > 0,    0<=rho<K,
+n=f-1,  t=n*G<=H,
+2H<=u,  u+m*f*K<=z,  z+H<=a,
+selected_axes=m*f+remainder<=d,  0<=remainder<m.
+```
+
+All positions are already within-row coordinates measured from the left.
+This service does not subtract a global prefix again, and does not change
+within-row geometry when `rows` or `stock` changes. Row counts may be arbitrary
+positive integers. The remaining current producer premises, such as `H=dG`,
+the correct occurrence placement and the global common-grid choice, are
+retained when this service is used by that producer.
+
+For each original address `x`, let `x_j` be the rank-m column at positions
+`u+(i*f+j)*K+rho`, `0<=i<m`, `0<=j<f`. The endpoint is exactly the inherited
+monomial
+
+```
+P(x)=f*c+sum_j(sum_i l_i*x_(j,i)
+                  +2*sum_(i<k) q_(i,k)*x_(j,i)*x_(j,k))  (mod 4).
+```
+
+It applies `x_j -> L*x_j+v` in each column, and applies `i^P(x)` to every one
+of the `r` original complex coefficients. All other address coordinates,
+outer-row labels, coefficient ordering, common quantum, and descriptor values
+are preserved. The inverse recovers the original address first and applies
+`i^-P(x)` there. No precision conversion or rounding occurs.
+
+## 3. Encoded geometry and the suffix-fibre identity
+
+Set `s=a-z-t>=0`. The last `s` unselected address bits are a complete consecutive
+suffix fibre. Interpret its `2^s` original records as additional coefficient
+fields of a single old-format record:
+
+```
+r'=2^s*r,  R=2*h*r',  a'=a-s=z+t,
+M0=2^a',  M=C*M0,  v0=M0*R,  Vraw=C*v0=C*2^a*2*h*r.
+```
+
+For `h>=2`, `Vraw/V=h/(3(h+1))` lies between `2/9` and `1/3`, so raw
+and current physical payload volumes differ by a bounded constant factor.
+
+The old field schema is fixed at construction:
+
+| Field | Width | Current interval |
+|---|---:|---|
+| `u` | `t` | first front prefix |
+| `u_rest` | `H-t` | remainder of first front field |
+| `t` | `t` | second front prefix |
+| `t_rest` | `H-t` | remainder of second front field |
+| `before` | `u-2H` | all positions before the vector blocks |
+| `v_i`, each `0<=i<m` | `fK` | current vector block i |
+| `after` | `z-u-mfK` | all positions before the back field |
+| `b` | `t` | back prefix |
+
+The field widths sum to `a'`. Every displayed width is nonnegative by the
+interface. The two front prefixes precede all vectors, and the back prefix
+follows them. All residual helper fields may contain arbitrary dirty address
+bits. No helper is initialized to zero or discarded.
+
+This is an equality of consecutive physical stream intervals after delimiter
+stripping, not an uncharged permutation. The old record traverses first the
+suffix address and then the original coefficient index, exactly their current
+stream order. Since no selected bit is in that suffix, every coefficient in
+the fibre has the same `P` and affine destination. The unchanged #3087 scan
+processes all `r'` coefficients. Thus grouping the suffix preserves each
+original coefficient's endpoint. Leaving the suffix among enumerated address
+bits would also be algebraically possible, but would lose the long-record
+accounting used below; the implementation performs this explicit grouping.
+
+Old native selected positions are counted from the least-significant end of
+each vector field. Set
+
+```
+rho_native=K-1-rho.
+```
+
+The old selected position `rho_native+jK` equals the current position with
+column ordinal `f-1-j`. The same reversal occurs in every vector block. Since
+the identical affine map acts independently on each column and the phase is
+the sum over all columns, this reversal changes neither endpoint. Merely
+passing current `rho` to the old API would generally select other bits.
+
+`prepare` constructs these integers with encoded Counts. It reads `h` by
+counting the first component's format symbols; it does not decode a signed
+value. It divides `b` by `6(h+1)` and checks positive quotient and zero
+remainder. It checks the exact complete row length and all intervals above.
+Its varying row counts, widths, shifts, and coefficient count remain on tapes.
+
+## 4. Signed conversion and the complete return
+
+`import_field` visits the current stream in order. For each complex pair it
+copies exactly `h` bits, checks and skips delimiter 2, then repeats for the
+imaginary component. It uses an encoded ripple counter for those widths and
+a lockstep guide for the current symbols. It checks each later component has
+the same width and delimiter. It preserves the complete `h`-bit representation,
+including leading zeros and redundant sign bits; components are never
+normalized as unsigned Counts. The old input has precisely the complete raw
+format of #3087. The inherited engine verifies its total extent against
+`C*2^a'*R`, so a whole-pair-aligned but incorrectly sized field is not silently
+accepted. The guide restores the current public head without decoding a
+payload length or consulting its allocated array length.
+
+The monomial runs on that separate borrowed raw copy while the parent scope
+is suspended. Its protected result is consumed before engine reuse. Only after
+the entire monomial has returned does `export_field` modify the public field.
+It copies every returned signed bit and reinserts each component delimiter at
+its existing position. It requires exact agreement of raw output, current
+field and guide frontiers. It restores the public origin and clears the
+protected return, marker, bridge and guide. Consequently the returned current
+body has exactly `V` physical bits in the same canonical format and on the
+same numerical grid.
+
+The only numerical admission is inherited signed representability. For phase
+0 no component is negated; phase 1 requires the imaginary component to exceed
+`-2^(h-1)`; phase 2 requires both; phase 3 requires the real component. These
+conditions are required separately for every coefficient in every folded
+fibre. The unchanged #3087 implementation checks both components before
+emitting that pair, and raises `SignedHeadroomError` when needed.
+
+On this named error for otherwise admitted shape and format, the inherited
+engine erases partial output, closes its counters and current packet, and
+returns to a reusable closed state. The wrapper has not written the public
+field, closes its setup Counts, and retires all coded work. Thus field and
+context remain unchanged and a subsequent valid input may use the same
+inventory. This statement does not promise rollback for arbitrary malformed
+streams, internal errors or interrupted execution.
+
+## 5. Physical refinement, ownership, and retained backing
+
+The source bootstrap loads the authenticated computational bodies of #3087
+unchanged. Its archive-discovery module is replaced only by a shim selecting
+the already authenticated shared Compact, Count, Tape and ordinary modules
+from `compiled-compact-native-binding`. Runtime identity checks require one
+actual Count/Tape vocabulary. `DEPENDENCIES.json` records Git blob and SHA256
+for all copied source files, together with original repository, commit or
+archive/member provenance. No numerical computation is delegated to a fixture
+callback or to a host array.
+
+That binding represents each old symbol by four current virtual bits, hence
+twelve physical bits. Logical blanks are coded nonblank physical strings.
+The old runtime `read`, `write`, `step`, origin guards and parking-table steps
+are refined by local physical operations. Runtime indexing of old `cells`
+is blocked; host head positions are not exposed to the algorithm. Fixed
+template data, fixed role identities, alphabet symbols and finite phase states
+may be in control. Varying coordinates and shapes use the encoded primitives.
+
+Construction, including the literal affine word and native inventory, occurs
+before input and has a positive fixed cost `F_template`. The wrapper adds
+192 setup scratch roles and four persistent buffers to the inherited finite
+engine inventory. The wrapper has 23 borrowed-header copies and a fixed
+number of setup temporaries: 24 `prepare` results and the component-width Count,
+with fewer than 32 additional arithmetic/counter roles at any source site.
+Thus fewer than 80 wrapper roles are simultaneously live. Its parent scope is suspended across the child,
+so these roles are not silently shared with active child leases. There is no
+physical tape allocation per row, coefficient, column, gate, or recursion depth.
+
+On completion, raw current retirement scans through coded logical blank tails
+to the first fresh physical blank and restores the local origin. It does not
+stop at an internal old logical blank. Therefore every owned current extent
+is physically blank, and ancestor prefixes are untouched. The normal and
+optimized executions below inspect all historical backing cells to test this
+claim; the mathematical invariant is the contiguous coded frontier and local
+origin, not the inspected array representation.
+
+Previously allocated backing remains allocated. For role i let `o_i(k)` be
+its current physical origin and `z_i(k)` its reached old-symbol extent in call
+k, including coded blank extension. An honest retained envelope includes
+
+```
+sum_i max_(k<=current) [o_i(k)+12*z_i(k)+O(1)],
+```
+
+as well as borrowed field/context backing and the caller's continuation bank.
+Smaller calls do not shrink this envelope. They also do not rescan a prior
+larger extent: a successful preceding retirement leaves it physically blank,
+and a new contiguous call stops at its own frontier.
+
+## 6. Complete cost and the favorable domain
+
+Let `E` be the physical header length, `Q` the fixed work-port count, and
+`A=2+a'+ceil(log2(R+1))`. Let `g_E` be the literal word's early XOR/toggle
+count, `g_L` its late XOR count, `g=g_E+g_L`, and `S=4g_E+12g_L`.
+For `f>1` set
+
+```
+delta=min(1,(f-1)*(2*2^(-G)+8*2^(G-K))).
+```
+
+The completed binary ordinary bill `T_B(v,beta)` includes real padding and
+restriction, its native work, borrowed preservation, return consumption and
+cleanup. #3087 and #3055 give the unchanged old-symbol invoice
+
+```
+T_old <= S*sum_(j=1)^C T_B(v0,(f-1)G)
+         + O_(m)((g+1)*(Vraw+M*A^6)
+                  +g*delta*M*A*(R+A)).                         (1)
+```
+
+There are actually `S*C` ordinary calls. At `f=1` there are no ordinary calls
+or exceptional term; retain `O_m((g+1)*Vraw+M*A^6)`. The phase-only recipe has
+`g=0` and still pays its complete coefficient scan and setup. No fixture timing
+is used to derive (1).
+
+The new wrapper incurs no per-payload-bit long length scan. Ripple counter
+initialization and decrements for an h-bit component cost `O(h)` in aggregate,
+and each current symbol is visited a bounded number of times by the bridge
+and guide. Hence signed format conversion costs `O(V)`. The first component
+width scan costs `O(h)` and is included in this bound. Since a valid header's
+`row_bits` value has at least `a+log2(b)` digits, and `h<=b`, all one-time
+geometry arithmetic has operand lengths `O_m(E+1)`. Repeated doublings build
+`2^a` and `2^s` in polynomial time in E. A conservative envelope for the fixed
+number of products, divisions, comparisons and such loops is `O_m((E+1)^4)`.
+
+Let `Z=sum_i z_i` denote **this call's** sum of reached old-symbol extents over
+all work, setup, bridge and parking roles. A complete current-physical bill is
+
+```
+T_current <= F_template + C_codec*T_old
+             + C_m*(V+(E+1)^4+Q) + 64*(Z+Q).                  (2)
+```
+
+The fixed `C_codec` covers the whole guarded source-control refinement,
+including local head and parking checks; it is not inferred solely from the
+constant for one read/write/move. The explicit last term pays current raw
+retirement, including encoded blanks and origin work. Every reached symbol
+costs a unit move or initialization in this call, so
+`Z=O(T_old+V+(E+1)^4+Q)`. Substitution gives the shape of (1), with a fixed
+codec factor and the displayed new setup/conversion bill. In contrast to
+#3087's specialized f=1 unused-G observation, this adapter reads the complete
+current descriptor and charges its E even when a field is unused.
+
+For occupied workspace, keep the inherited conservative monomial allowance
+
+```
+6*Vraw+2*delta*M*a'+M+O_m(A+log(C+1))
+    +W_B(v0,(f-1)G)+F_native,
+```
+
+with ordinary and exceptional terms omitted at f=1. Add the borrowed current
+field V, header E, setup/header guides `O(E+A)`, and the current field guide
+`O(V)`, multiply old-symbol owned extents by twelve, and include the fixed
+parking roles. For fresh backing also retain each inherited parent role's
+maximum `O(Vraw+A+log(C+1))`, each Compact role's maximum
+`O(v0+delta*M0*a'+A+log(C+1))`, protected output, and the actual ordinary
+supplier's per-role allowance. Fixed role capacities are genuine constants.
+For reuse use the historical maxima in Section 5 rather than fresh size alone.
+
+A favorable production specialization must state its hypotheses. If `H=dG`,
+`m>=2`, and `mf+remainder<=d`, then `f<=d/2` and
+
+```
+s>=H-(f-1)G>=dG/2,
+R=2*h*r*2^s >= 2*h*r*2^(dG/2).
+```
+
+For m=1 this automatic inequality is unavailable; long-record growth remains
+an explicit extra domain premise. In a root regime with `d->infinity`,
+`G=4ceil(log2 p)+6`, `A=O(p)`, and `E=O_m(p+log(C+1))`, R exceeds every fixed
+power of p. The selected schedule's `K=128G` satisfies the sufficient retained
+guard inequality `K>=G+4ceil(log2 p)+10`, giving `delta=O(p^-3)` for `f<=p`.
+Then `M*A^6/Vraw=A^6/R` and
+`delta*M*A*(R+A)/Vraw=delta*A*(1+A/R)` are bounded by the claimed lower order
+terms. The E-polynomial is absorbed using superpolynomial R and
+`log(C+1)^k=O_k(C)` for each fixed k. These are additional stated domain
+conditions, not consequences of an arbitrary valid finite header.
+
+If the admitted ordinary supplier has `T_B(v,beta)<=K_q*v*(1+beta^tau_B)`,
+the favorable specialization is
+`O_(q,m)(V*(1+((f-1)G)^tau_B))`. The retained historical exponent is
+`tau_B=99830289/100000000`. It does not imply the smaller current selected
+node exponent. Equations (1) and (2), the source supplier premises, and the
+backing envelopes remain the complete all-size statement; no new kappa is
+claimed.
+
+## 7. One actual selected source boundary
+
+`selected_service.py` authenticates the current selected word and canonical
+Clifford source. It locates raw event 9896,
+`["MOVE",236,3,7,false]`, through the current lifecycle `current_local` lowering.
+The exact service token is `("move-in","local",9896,raw_record)` on owner
+236, with the matching `move-out` cut. This raw four-field token is the
+established source boundary. The guard also accepts a syntactically flat prefix
+before that tuple, but this optional flat-prefix ABI is **not** the nested
+token emitted by `source_ir.remap`. The actual `caller-local` token contains
+the old token as its last tuple member, and is not accepted by this binder.
+An enclosing caller therefore still needs a separate typed token adapter;
+no complete nested caller-occurrence binding is claimed. The physical owner is
+bound explicitly through the event's field list; it is not an implicit global
+array reference.
+
+The event token alone does not normalize the enclosing occurrence's header.
+At this boundary the caller must expose the nine current vector blocks and
+their span with `selected_axes=9*f+remainder`, in the coordinates admitted in
+Section 2. A larger compiler occurrence needs its existing paid placement and
+descriptor service to establish this premise, in addition to the token adapter
+above. Matching a raw token or flat suffix is not a proof of that geometry.
+
+The literal comes from the authenticated canonical frame transition 3 to 7.
+The existing #6930 audit supplies the width-one phase interpretation. Its
+right monomial has constant 1 and the exact rows
+
+```
+matrix=(21,17,2,20,8,32,64,128,256), offset=1,
+linear=(3,0,3,0,2,0,0,0,0), quadratic=(5,0,5,0,0,0,0,0,0).
+```
+
+The resulting record hash and complete left literal are in `SELECTED-MOVE.json`.
+`Service` compiles the right monomial at `move-in`, and the left at `move-out`.
+The intermediate rank-one Fourier child is outside this contribution. This
+is not a new primary-phase audit, and not a numerical proof of the full MOVE.
+
+Four selected physical phase-control calls use the actual 23-field descriptor,
+native recipe, and codec with f=2,3,4. The zero-column f=2 case produces phase2,
+not a copied one-column phase1. A wrong residue and wrong frame token are
+discriminating negative controls. These execute the actual selected control
+interface but do not materialize its complete rank-nine packet. The all-size
+endpoint follows from Sections 2-5 and inherited monomial correctness; the
+finite evidence cannot replace those arguments.
+
+## 8. Evidence, limits, and remaining work
+
+The author fixture uses a separately coded signed/address endpoint oracle and
+complete current physical packets. It covers f=1 with nontrivial K/rho
+orientation, f=2 forward and inverse with real Compact/ordinary calls, all
+coefficient fields, multiple outer/inner rows, dirty spectators, folded suffix
+fibres, nonzero translated origins, later-field signed-headroom rejection and
+valid retry, and historical backing reuse. Both normal and optimized Python
+must reproduce the same exact action and endpoint receipts. It uses the actual
+ordinary elementary branch, never an oracle supplied to the numerical engine.
+Independent review is registered separately when its receipt is frozen.
+
+The selected rank-nine complete packet is not executed. These tests admit
+neither the retained faster ordinary rate nor the selected native exponent.
+The current placement/row service, actual complete numerical caller, flat-table
+export, global width/headroom allocation, full selected recurrence budget,
+coefficient arithmetic and analytic recovery remain outside this scoped join.
+All five selected framework assumptions remain listed in the receipt.
+
+## Open next questions
+
+1. Export the bounded current adapter control into the lifecycle controller's
+   literal transition-table syntax. First preserve this exact complete-format
+   endpoint and signed-error boundary on one occurrence; the existing semantic
+   service token alone is not a machine table.
+2. Supply a completed binary ordinary service at the current required rate,
+   or a different full invoice. Its source preservation, private cleanup and
+   output consumption must accompany the rate; this adapter cannot upgrade
+   the historical exponent.
+3. Join the current numerical caller's width/common-grid allocation to these
+   phase-specific headroom conditions and to the paid rank-one child between
+   the two MOVE monomials. The first useful check is a complete small actual
+   caller occurrence with its live descriptor and suspended private bank.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/README.md b/research/current-serial-monomial-leaf/vendor/monomial/README.md
new file mode 100644
index 0000000000..28d2611cd3
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/README.md
@@ -0,0 +1,179 @@
+# Current signed-format Gaussian monomial
+
+Prepared for **@CubeJerry**, with substantial OpenAI assistance in source
+analysis, mathematics, implementation, verification and prose. Apache-2.0.
+
+This package connects the retained physical Gaussian monomial to the current
+numeric field and twenty-three-field descriptor. It reads the actual coded
+signed components, preserves every coefficient and delimiter, builds the
+native layout with encoded arithmetic, executes the unchanged phase/affine
+engine, and returns the complete field with blank private current segments.
+
+The result is a **source-level finite-control, fixed-inventory refinement**
+under explicit completed ordinary-supplier and physical-port contracts. It is
+not a new phase identity, a flat lifecycle transition table, a complete selected
+replay, or a new kappa. The quantified endpoint and all-size invoice are in
+[PROOF.md](PROOF.md).
+
+## The actual interface that is closed
+
+A current numeric component consists of fixed-width signed little-endian bits
+followed by virtual delimiter 2, all in the three-physical-bit `CodedPort` code.
+For `r` complex coefficient fields of width `h`, a complete original record
+contains `6*r*(h+1)` physical bits. Treating those encoded bytes as the old
+engine's signed bits would be incorrect.
+
+`phase_adapter.py` strips only the component delimiters, preserving all signed
+bits, and reconstructs the exact current format after the whole native call
+returns. It changes no common quantum and rounds no coefficient. A lockstep
+guide restores the public head and checks the exact complete return frontier.
+Every original coefficient receives the same prescribed address phase.
+
+The descriptor supplies arbitrary positive outer and row counts, current
+within-row coordinates, selected width and residue, complete row/record
+lengths, and reserved front/back intervals. These stay as encoded Counts. The
+adapter maps the current left-counted residue to the native low-bit position
+`K-1-rho` and groups a complete untouched suffix of `s` address bits into
+`2^s*r` native coefficient fields. This preserves every suffix fibre and the
+long-record cost advantage without a hidden field permutation.
+
+Successful return preserves all 23 descriptor values and caller ancestors,
+restores origins, consumes the protected child output, and physically erases
+every owned current segment. On the named signed-headroom error for otherwise
+valid input, the public field is unchanged and the same inventory permits a
+valid retry. No arbitrary-malformation or interruption rollback is claimed.
+
+## Actual selected source binding
+
+`selected_service.py` binds event 9896 of the authenticated selected #6030
+word, `MOVE` on owner 236 from frame 3 to frame 7. It obtains the literal from
+the canonical Clifford source and connects the raw `current_local`
+`move-in`/`move-out` token to its right/left monomial. Its right constant phase
+is 1. The optional flat-prefix guard does not accept `source_ir.remap`'s actual
+nested caller token. A separate typed token adapter is still required before
+using this binder inside that enclosing caller; no full caller-occurrence
+binding is claimed.
+
+The width-one primary phase audit belongs to
+[#6930](https://github.com/CrocSwap/integer-mult-bounds/pull/6930), and the
+all-width convention belongs to
+[#6293](https://github.com/CrocSwap/integer-mult-bounds/pull/6293). This package
+executes four actual current-context phase-control cases with f=2,3,4, including
+the f=2 zero-column phase2. It rejects a wrong source frame, and discriminates
+an unconverted residue and a copied width-one constant. It does **not** execute
+the complete rank-nine selected packet or the intervening paid Fourier child.
+
+The caller must also expose the normalized nine-vector active span and matching
+header at this service cut. Inside a larger compiled occurrence, that remains
+the paid placement/descriptor service's contract. Matching the raw token alone
+does not establish this geometry.
+
+## Complete cost, including its limit
+
+Write `a=within_bits`, `z=back_start`, `t=(f-1)G`, `s=a-z-t`,
+`C=outer*rows`, and
+
+```
+a'=z+t, R=2*h*r*2^s, M=C*2^a', v0=2^a'*R, Vraw=C*v0,
+A=2+a'+ceil(log2(R+1)),
+delta=min(1,(f-1)*(2*2^(-G)+8*2^(G-K))).
+```
+
+For the fixed affine word let `g_E` count early XOR/toggle gates and `g_L` late
+XOR gates, with `g=g_E+g_L` and `S=4g_E+12g_L`. The inherited complete invoice
+for f>1 remains
+
+```
+T_old <= S*sum_(j=1)^C T_B(v0,(f-1)G)
+         + O_m((g+1)*(Vraw+M*A^6)+g*delta*M*A*(R+A)).
+```
+
+There are `S*C` actual ordinary calls. The new wrapper pays a fixed whole-source
+codec factor, linear current-format conversion, `O_m((E+1)^4)` encoded setup,
+positive fixed construction/inventory cost, and explicit retirement of this
+call's reached extent. Here E is the physical descriptor length; even unused
+large descriptors are charged. At f=1 the ordinary/exceptional terms disappear,
+while the complete phase, setup and format traversals remain.
+
+The proof keeps the completed ordinary workspace and each role's historical
+backing maximum. Erasure does not shrink backing. A smaller later call stops
+at its own fresh physical frontier and need not rescan the previous maximum.
+
+A favorable long-record regime can absorb setup and repair overhead. In the
+production geometry `H=dG`, fixed rank m>=2 gives `f<=d/2` and an exponentially
+long unselected suffix. For m=1, that growth is an explicit extra premise.
+All finite-size invoices remain valid without that absorption. The inherited
+ordinary exponent `99830289/100000000` does **not** establish the smaller
+current selected node exponent. No selected `.0034` rate or new kappa follows.
+
+## Executed evidence
+
+The complete normal and optimized replay must produce the same exact
+[RESULT.json](RESULT.json), including physical action counts and cleanup.
+The ordinary child uses its actual q2 elementary branch; this is not a
+faster-rate certificate. No oracle supplies an engine payload.
+
+| Complete physical case | Original records | Coefficients per record | Ordinary calls | Physical actions |
+|---|---:|---:|---:|---:|
+| f=1, K=2, signed phase and affine map | 128 | 2 | 0 | 61,104,394 |
+| f=2 forward monomial | 128 | 2 | 4 | 612,628,846 |
+| f=2 inverse monomial | 128 | 2 | 4 | 612,628,846 |
+| f=2 phase, two outer by two inner rows | 512 | 3 | 0 | 368,463,951 |
+
+Every fixture checks the complete independently computed signed/address
+endpoint, exact field frontier, unchanged context, restored heads, physically
+blank historical work bodies, and untouched ancestor bytes. A late coefficient
+headroom failure preserves input and allows a valid retry. A smaller reused
+phase call and a fresh one both take 12,536,555 actions; the reused one retains
+294,704 cells, compared with 67,952 fresh cells.
+
+The separate sparse-hardware review uses its own serialization and value oracle
+and covers both residue orientations, non-power-of-two row count, all folded
+coefficient fields, inverse recovery, admissible signed minima, and late
+rejection followed by retry. Its exact scope and provenance are recorded in
+[VERIFICATION.md](VERIFICATION.md). None of these fixtures independently
+reproves the retained monomial or ordinary theorem.
+
+## Replay and exact sources
+
+Use Python 3.12 and the standard library. From the repository root:
+
+```sh
+python3 -I -B research/current-coded-gaussian-monomial/verify.py
+python3 -I -O -B research/current-coded-gaussian-monomial/verify.py
+python3 -B scripts/research_package.py --package research/current-coded-gaussian-monomial --check-only
+```
+
+The package-local closure is authenticated by both Git blob and SHA256 hashes
+in `DEPENDENCIES.json`. The current shared codec/header export is pinned at
+[CubeJerry/integer-mult-bounds@5629e777](https://github.com/CubeJerry/integer-mult-bounds/tree/5629e7772d1720d6727465e328a45694f8620538/research/compiled-compact-native-binding).
+The original #3087 computational files are unchanged. Their discovery shim
+selects the shared authenticated native vocabulary; it does not execute or
+admit the old full selected theorem. Replay needs no network or external files.
+
+Canonical provenance in `SOURCES.json` stays at
+`7c49fe32c55de02c2c873655c804b16e4c3fef0a`. Selected kappa remains
+`781451/250000000`, and all five assumptions remain explicit:
+`native_all_columns`, `owned_erasure`, `compiler`, `precision_tape`, and
+`analytic_recovery`.
+
+Credit for the retained physical Gaussian monomial and its phase implementation
+belongs to Jose Manuel (`jmbarrancoml`) and predecessors
+[#3087](https://github.com/CrocSwap/integer-mult-bounds/pull/3087), #3055, #2250,
+#2378 and #2422. The older prepared common-grid binding by Chris R
+(`Clear1nsight`) is [#4129](https://github.com/CrocSwap/integer-mult-bounds/pull/4129).
+The current codec, lifecycle and row exports retain their own attribution and
+the unchanged runtime NOTICE files. No independent human review or proof-kernel
+admission is claimed.
+
+## Open next questions
+
+1. Export this bounded source control into the actual lifecycle transition
+   table format, starting with one current MOVE occurrence and preserving its
+   full format, origin and named-error contracts.
+2. Bind a completed ordinary supplier at the selected tariff, with its actual
+   padding, time, return, cleanup and retained-backing premises. An interface
+   adapter cannot strengthen the inherited exponent.
+3. Join the real caller's common-grid/headroom allocation and the intervening
+   paid Fourier child. The next useful complete fixture is a small actual
+   caller occurrence with its live descriptor and suspended private bank.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/SOURCES.json b/research/current-serial-monomial-leaf/vendor/monomial/SOURCES.json
new file mode 100644
index 0000000000..43555e2f27
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/SOURCES.json
@@ -0,0 +1,162 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/lockstep-completion-pass/executor.py",
+      "usage": "provenance",
+      "git_blob": "9469443a3d7cc6310a7369daf77c7756d5bd3f38",
+      "sha256": "0bda14a3e5f4da348cd5c89ebe29d717e7a5406ec31b164d5b9e1d25f7f38e0e"
+    },
+    {
+      "path": "research/p104-6030-deferred-layer/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "de725a73e97496836100aa6e0ed9cd70985373da",
+      "sha256": "3a7ac6dae3b76d5f78849f521635da034fe99b1ea6c942175a3652b53f6262c2"
+    },
+    {
+      "path": "research/p104-helper470-twin-rung-removal/RESULT.json",
+      "usage": "provenance",
+      "git_blob": "e4a03118d585fb80c9ac932281b528ac394ccc5f",
+      "sha256": "84fcbe2a0b64307b5703c363408042bdd91555b0419509aa50daa43b3b1924ad"
+    },
+    {
+      "path": "research/p104-helper470-twin-rung-removal/WORD.json.gz",
+      "usage": "provenance",
+      "git_blob": "22f9ab02d1b73ea0aa4b07ce445a14cc2602c760",
+      "sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f"
+    },
+    {
+      "path": "research/p104-native-channel/vendor/clifford_exact.py",
+      "usage": "provenance",
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    },
+    {
+      "path": "research/p104-native-channel/vendor/native_verify.py",
+      "usage": "provenance",
+      "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c",
+      "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38"
+    },
+    {
+      "path": "research/physical-complex-compact/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb",
+      "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48"
+    },
+    {
+      "path": "research/physical-complex-compact/compact_control.py",
+      "usage": "provenance",
+      "git_blob": "13af719b5844f14f5cf05c919e84204cd21caf6a",
+      "sha256": "73a9ace4f91aeb383fdbc6f7762498fe707b4e4b45b1c63920bb90cc8795e284"
+    },
+    {
+      "path": "research/physical-complex-compact/compact_counts.py",
+      "usage": "provenance",
+      "git_blob": "064b508efd12f7d5a33729b2344b6890f0c75d2f",
+      "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d"
+    },
+    {
+      "path": "research/physical-complex-compact/compact_engine.py",
+      "usage": "provenance",
+      "git_blob": "5c5ca75567f85b042c156e0ed5a8afe81671b1b8",
+      "sha256": "2cacff4d36a6e029add115f47cd8ffbf3c61e7ece0900308b98e6032e652f098"
+    },
+    {
+      "path": "research/physical-complex-compact/compact_layout.py",
+      "usage": "provenance",
+      "git_blob": "03ca12aed77741f40d824fcb33cc4eedb85abfd9",
+      "sha256": "5be2be9c32c15742da18fde438a5559a45a86eb661105027b1b233a7c397e0ce"
+    },
+    {
+      "path": "research/physical-complex-compact/compact_streams.py",
+      "usage": "provenance",
+      "git_blob": "5699cc7f20def3bc873d2da05b13a252246367a1",
+      "sha256": "3b5cce3be9763c6bd7803d6223d2784d1975eeac6c7c99f5e00dfc49bb11d249"
+    },
+    {
+      "path": "research/physical-complex-compact/native_sources.py",
+      "usage": "provenance",
+      "git_blob": "3d2834c5fff39481c9a0442a514c10eaf50f98d2",
+      "sha256": "865c97c4f261fde37e86eb16a910eaa5b2f26daaa7d2648ae0322ba8c0286572"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "82e9a8b0b50f26844528af9e07632800679805ea",
+      "sha256": "20885a8a137fc670121429625912ceae54db95ac5e574b8c64c90f477aebacb7"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/SOURCES.json",
+      "usage": "provenance",
+      "git_blob": "e040a558800e719e2d8b6237bec39e7e10a3641b",
+      "sha256": "0dd57a4fe4fc97826df0eb215975d013ac0e18f185c73cd93e34c95a9a2b4b16"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/monomial_engine.py",
+      "usage": "provenance",
+      "git_blob": "2251fd98ba01a171f5d39b25a93c895245f10e55",
+      "sha256": "fc02c6c5159d6c258063a36ef3dc9313a34d7ba9781b650e451cc0ce971e9667"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/pair_dispatch.py",
+      "usage": "provenance",
+      "git_blob": "0e467bdb3727d7f354f98dee54f320f1f072aa2c",
+      "sha256": "fc0eaa2a9d0855660b15a15d894137eeebc64c6418f52b6af0d0f79d86f2e0d9"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/phase_recipe.py",
+      "usage": "provenance",
+      "git_blob": "a2f684fb588257cc182dc88dded59ed70f5c2585",
+      "sha256": "8215e5e55daf019694e55b2acfcd42ecf109a2faf767a2181d664ba9b4957e46"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/phase_sources.py",
+      "usage": "provenance",
+      "git_blob": "aaa5c663a4bb6b0ca4d9119c1ae92064509d79c8",
+      "sha256": "3944ecbffe91fb561b2b8a810461cd2b8229f1f2611ca6a70e3d86451efb220b"
+    },
+    {
+      "path": "research/physical-gaussian-monomial/signed_phase.py",
+      "usage": "provenance",
+      "git_blob": "bab32b0c5da7f364d6a79171c09b02d123a05bd9",
+      "sha256": "e21818674133a2bd7e63fadaf719eb45ce80db4b3806ca8ef99c247be22c2a39"
+    },
+    {
+      "path": "research/qq16-recursive-binding/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "5de56af0213bf710ae3e832f21de74cf0ac9c7b0",
+      "sha256": "b547277ab5380b218893908a3e8e8874efc0cf3f9717b582f8972698d87418a2"
+    },
+    {
+      "path": "research/selected-complex-compact-adapters/monomial.py",
+      "usage": "provenance",
+      "git_blob": "5fa4494167c4ba668993a2b1c902969518728a4c",
+      "sha256": "394f9a465ac9148af0c20844d375e4befbef17d92b2fcc840d83419480dd4740"
+    },
+    {
+      "path": "research/selected-monomial-tape-lift/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "69e07e58c5468e2045281335a56f4918b474c79d",
+      "sha256": "8442243130d4a9932f78eb42419196d2866d4496256e3bb2d6143fd52b44ddb3"
+    },
+    {
+      "path": "research/selected-monomial-tape-lift/lift.py",
+      "usage": "provenance",
+      "git_blob": "167d085a9191e3b3545bcf39d5e6edc94e54d514",
+      "sha256": "21c77119c004a86a603cca91ce1366629431db18e9e0554942492f1b5afebe4a"
+    }
+  ]
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/TASK.json b/research/current-serial-monomial-leaf/vendor/monomial/TASK.json
new file mode 100644
index 0000000000..4ab3215b61
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/TASK.json
@@ -0,0 +1,93 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "scope_change_reason": "Assigned seed24 current numerical/native interface: join the retained Gaussian monomial to current signed CodedPort fields, all coefficient fibres, and the 23-field context. Phase algebra and primary phase audit are inherited.",
+  "actual_scope": "Prove and physically verify the paid signed-format/context/suffix-fibre join to unchanged #3087, with complete successful and named headroom-rejection cleanup, honest time/backing costs, and one actual raw current_local MOVE source binding. The existing nested caller token and its normalized local header still require a separate adapter; no full caller-occurrence binding is claimed.",
+  "bottleneck_link": "Replaces the current-format Gaussian monomial service seam by a source-level fixed-control refinement. The completed ordinary tariff, current numerical width allocation and flat-table exporter remain explicit.",
+  "stop_rule": "Stop after the current-format signed monomial join, authenticated actual selected record, complete invoice and adversarial physical checks. Do not re-audit phase algebra, claim full selected replay, change kappa, or remove a foundational assumption.",
+  "evidence": "PROOF.md and exact normal/optimized RESULT.json; independent sparse-hardware review is separately registered.",
+  "author": "@CubeJerry",
+  "ai_assistance": "Substantial OpenAI assistance in research, proof development, implementation, tests and documentation; no independent human or proof-kernel admission claimed.",
+  "outcome": "completed",
+  "open_questions": [
+    {
+      "question": "Export the current adapter into the literal lifecycle transition-table format.",
+      "why_it_matters": "The executed source refinement is not a Controller.execute_table native table.",
+      "first_step": "First adapt the existing nested caller token and establish its normalized local header; then flatten fixed codec, geometry and signed traversal controls while preserving complete field and headroom-return contracts.",
+      "blocked_by": "A source-equivalent table-format exporter."
+    },
+    {
+      "question": "Bind an ordinary supplier at the current selected tariff.",
+      "why_it_matters": "The historical ordinary exponent remains too large for the selected node bound.",
+      "first_step": "Review a completed exact supplier with time, stock, return and retained-backing contracts on this interface.",
+      "blocked_by": "A stronger upper-bound implication, not monomial phase algebra."
+    },
+    {
+      "question": "Join actual numerical headroom and the intervening paid Fourier child.",
+      "why_it_matters": "A complete MOVE needs both monomials and its paid child on a common live format.",
+      "first_step": "Run one small complete actual caller occurrence with current descriptor and suspended private bank.",
+      "blocked_by": "Current numerical width/common-grid allocation and remaining child services."
+    }
+  ]
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/check_fixture.py b/research/current-serial-monomial-leaf/vendor/monomial/check_fixture.py
new file mode 100644
index 0000000000..1399f50d7b
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/check_fixture.py
@@ -0,0 +1,187 @@
+"""Complete current-format physical packets and an independent address oracle.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+Fixture construction and observation may inspect arrays; the sealed call cannot.
+"""
+from argparse import ArgumentParser
+import json
+from types import SimpleNamespace
+from phase_adapter import Provider, SCHEMA, S
+from phase_binding import need
+from codec import DenseTape
+from ordinary import Ordinary
+from macro_code import Code
+
+
+def factory():
+    return Ordinary(2, SimpleNamespace(codes=SimpleNamespace(q=2)), SimpleNamespace(families=0),
+                    (Code((("unreachable",),), 0),), capacity=64)
+
+
+def literal(affine=True):
+    return dict(matrix_rows=(1, 3) if affine else (1, 2), offset=0,
+                linear_Z4=(1, 2), quadratic_rows=(2, 0), phase=1)
+
+
+def coded(symbols):
+    return [((value >> shift) & 1) for value in symbols for shift in (2, 1, 0)]
+
+
+def header_bits(values):
+    result = []
+    for name in SCHEMA:
+        digits = [int(bit) for bit in bin(values[name])[2:][::-1]]
+        result.extend([1] * len(digits) + [0] + digits)
+    return result
+
+
+def load(tape, body):
+    tape.cells[tape.origin:] = bytearray(body)
+    tape.head, tape.high = tape.origin, tape.origin + len(body)
+
+
+def body(tape):
+    out = []
+    for value in tape.cells[tape.origin:]:
+        if value == 6:
+            break
+        out.append(value)
+    return out
+
+
+def rotate(pair, phase):
+    a, b = pair
+    return ((a, b), (-b, a), (-a, -b), (b, -a))[phase % 4]
+
+
+def endpoint(address, values, recipe):
+    f, K, rho, rank = values["f"], values["K"], values["rho"], len(recipe["matrix_rows"])
+    bits, start = values["within_bits"], values["active_start"]
+    phase, destination = f * recipe["phase"], address
+    for j in range(f):
+        positions = [bits - 1 - (start + (i * f + j) * K + rho) for i in range(rank)]
+        column = sum(((address >> position) & 1) << i for i, position in enumerate(positions))
+        phase += sum(recipe["linear_Z4"][i] for i in range(rank) if column >> i & 1)
+        phase += 2 * sum(1 for i in range(rank) for k in range(i + 1, rank)
+                         if column >> i & 1 and column >> k & 1 and recipe["quadratic_rows"][i] >> k & 1)
+        result = recipe["offset"] ^ sum(((row & column).bit_count() % 2) << i
+                                         for i, row in enumerate(recipe["matrix_rows"]))
+        for i, position in enumerate(positions):
+            if ((column ^ result) >> i) & 1:
+                destination ^= 1 << position
+    return destination, phase % 4
+
+
+def encode(records, h):
+    out = []
+    for record in records:
+        for pair in record:
+            for value in pair:
+                need(-(1 << (h - 1)) <= value < 1 << (h - 1), "checker signed component range")
+                out.extend(coded([(value >> bit) & 1 for bit in range(h)] + [2]))
+    return out
+
+
+def fixture(recipe, *, f=1, K=1, rho=0, H=1, rows=1, outer=1, h=4, coefficients=2,
+            inverse=False, bad_field=False):
+    rank = len(recipe["matrix_rows"])
+    e, a = rank * f, 3 * H + rank * f * K
+    b = 6 * coefficients * (h + 1)
+    values = dict(outer=outer, rows=rows, stock=1, row_bits=(1 << a) * b, within_bits=a,
+        record_bits=b, p=max(e, 2), d=e, K=K, G=1, H=H, q0=3, qF=0, qB=0, D=e,
+        f=f, rho=rho, active_start=2 * H, back_start=2 * H + e * K,
+        selected_axes=e, entry_start=2 * H, remainder=0, cutoff=rank)
+    total = outer * rows * (1 << a)
+    maximum = (1 << (h - 1)) - 1
+    modulus = 2 * maximum + 1
+    records = [tuple(((i + 3 * c) % modulus - maximum,
+                      (i // modulus + 5 * c) % modulus - maximum)
+                     for c in range(coefficients)) for i in range(total)]
+    expected = [None] * total
+    for row in range(outer * rows):
+        for address in range(1 << a):
+            destination, phase = endpoint(address, values, recipe)
+            source_index, target_index = ((row * (1 << a) + destination, row * (1 << a) + address)
+                                          if inverse else
+                                         (row * (1 << a) + address, row * (1 << a) + destination))
+            expected[target_index] = tuple(rotate(pair, -phase if inverse else phase)
+                                           for pair in records[source_index])
+    if bad_field:
+        need(not inverse, "this guard fixture uses the forward phase boundary")
+        bad = max(i for i in range(total) if endpoint(i % (1 << a), values, recipe)[1] == 1)
+        record = list(records[bad])
+        record[-1] = (record[-1][0], -(1 << (h - 1)))
+        records[bad] = tuple(record)
+    return values, encode(records, h), encode(expected, h)
+
+
+def run_case(*, reuse=None, return_state=False, affine=True, guard=False, **case):
+    recipe = literal(affine)
+    values, initial, expected = fixture(recipe, bad_field=guard, **case)
+    if reuse is None:
+        owner = Provider(recipe, factory, case.get("inverse", False))
+        work = [DenseTape(3 + i % 5) for i in range(owner.port_count)]
+        field, context = DenseTape(9), DenseTape(11)
+        for tape in (*work, field, context):
+            for i in range(tape.origin - 1):
+                tape.cells[i] = i % 2
+        owner.bind(work)
+    else:
+        owner, work, field, context = reuse
+        need(owner.inverse == case.get("inverse", False), "same compiled direction in reused owner")
+    load(field, initial)
+    encoded_header = header_bits(values)
+    load(context, encoded_header)
+    ancestors = [bytes(t.cells[:t.origin]) for t in (*work, field, context)]
+    before = sum(t.actions() for t in (*work, field, context))
+    calls_before = dict(owner.engine.compact.calls)
+    rejected = False
+    try:
+        owner.run(S.abi.CodedPort(field), S.abi.BinaryContextPort(context))
+    except S.phase.SignedHeadroomError:
+        rejected = True
+    need(rejected == guard, "expected phase-specific signed guard outcome")
+    need(body(field) == (initial if guard else expected), "independent full signed-record endpoint")
+    need(body(context) == encoded_header, "all 23 context fields preserved")
+    need(field.head == field.origin and context.head == context.origin, "public and context origin restoration")
+    need(all(t.head == t.origin and all(x == 6 for x in t.cells[t.origin:]) for t in work),
+         "all native historical bodies physically erased at current origins")
+    need(all(bytes(t.cells[:t.origin]) == original for t, original in zip((*work, field, context), ancestors)),
+         "ancestor bytes and local physical origins protected")
+    need(not owner.pool.live and owner.engine.closed and not owner.engine.pool.live
+         and owner.engine.compact.closed, "closed reusable owner and child scopes")
+    report = dict(case=case, affine=affine, signed_guard_rejected=rejected,
+        records=values["outer"] * values["rows"] * (1 << values["within_bits"]),
+        coefficients=case.get("coefficients", 2), physical_bits=len(initial),
+        physical_actions=sum(t.actions() for t in (*work, field, context)) - before,
+        native_ports=owner.port_count, retained_cells=sum(len(t.cells) for t in work),
+        compact_calls={key: value - calls_before[key] for key, value in owner.engine.compact.calls.items()})
+    return (report, (owner, work, field, context)) if return_state else report
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument("case", choices=("single", "forward", "inverse", "phase", "guard", "reuse"))
+    args = parser.parse_args()
+    if args.case == "single":
+        result = run_case(f=1, K=2, rho=0)
+    elif args.case in ("forward", "inverse"):
+        result = run_case(f=2, K=1, inverse=args.case == "inverse")
+    elif args.case == "phase":
+        result = run_case(f=2, K=1, affine=False, outer=2, rows=2, coefficients=3)
+    elif args.case == "guard":
+        first, owner = run_case(guard=True, affine=False, coefficients=3, return_state=True)
+        second = run_case(reuse=owner, affine=False, coefficients=3)
+        result = dict(rejection=first, valid_retry=second)
+    else:
+        first, owner = run_case(H=2, affine=False, return_state=True)
+        second = run_case(H=1, affine=False, reuse=owner)
+        third = run_case(H=1, affine=False)
+        need(second["physical_actions"] == third["physical_actions"], "old backing does not increase a fresh short call")
+        need(second["retained_cells"] >= third["retained_cells"], "retained backing is honestly charged")
+        result = dict(large=first, reused_small=second, fresh_small=third)
+    print(json.dumps(result, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/phase_adapter.py b/research/current-serial-monomial-leaf/vendor/monomial/phase_adapter.py
new file mode 100644
index 0000000000..02f0fdc3ba
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/phase_adapter.py
@@ -0,0 +1,213 @@
+"""Paid current signed-format and 23-field context join to unchanged #3087.
+
+Runtime shapes stay on encoded Count tapes. The complete untouched back suffix
+is folded into additional coefficient fields, so every one receives its phase.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from contextlib import ExitStack
+from phase_binding import activate, need
+
+S = activate()
+from cardinal_counts import Count, positive
+from compact_counts import power_two
+from encoded import compare, divide, subtract
+from records import Tape
+from scratch_pool import ScratchPool
+from session import OuterScope, erase_marker
+from stream import Counter
+from codec import Cohort, collect_tapes, execution
+
+SCHEMA = S.provider.SCHEMA
+
+
+def scale(value, multiplier):
+    need(type(multiplier) is int and multiplier >= 0, "fixed template multiplier")
+    if multiplier == 0:
+        return Count.literal(0)
+    out = Count(value)
+    if multiplier != 1:
+        out.multiply_small(multiplier)
+    return out
+
+
+class Provider:
+    def __init__(self, literal, native_factory, inverse=False):
+        need(type(inverse) is bool, "compiled monomial direction")
+        self.rank = len(literal["matrix_rows"])
+        need(1 <= self.rank <= 73, "fixed source monomial rank")
+        self.inverse = inverse
+        self.vectors = tuple("v" + str(i) for i in range(self.rank))
+        self.names = ("u", "u_rest", "t", "t_rest", "before", *self.vectors, "after", "b")
+        with collect_tapes() as tapes:
+            native = native_factory()
+            need(type(native) is S.source.ordinary.Ordinary and native.observe is None
+                 and native.runtime.observe is None, "same closed ordinary supplier without payload callback")
+            self.engine = S.engine.MonomialEngine(self.names, self.vectors, literal, native)
+            self.pool = ScratchPool(192)
+            self.scope = OuterScope(self.pool)
+            self.bridge, self.field_guide, self.header_guide, self.length_guide = (Tape() for _ in range(4))
+        self.cohort = Cohort(tapes, native)
+        self.calls = 0
+
+    @property
+    def port_count(self):
+        return self.cohort.port_count
+
+    def bind(self, work):
+        self.cohort.bind(work)
+
+    def read_header(self, context):
+        return S.provider.Provider.read_header(self, context)
+
+    def component_width(self, field):
+        """Read only the first component's format length, never its integer."""
+        width = Count.literal(0)
+        while field.read() in (0, 1):
+            width.increment()
+            field.move(1)
+        need(field.read() == 2, "first canonical signed component terminator")
+        remaining = Counter(width)
+        try:
+            while not remaining.finished:
+                field.move(-1)
+                remaining.decrement()
+        finally:
+            remaining.close()
+        return width
+
+    def prepare(self, header, h, cleanup):
+        def own(value):
+            cleanup.callback(value.close)
+            return value
+        for name in ("outer", "rows", "row_bits", "record_bits", "f", "K", "G", "H"):
+            positive(header[name])
+        one, two = own(Count.literal(1)), own(Count.literal(2))
+        need(compare(h, two) >= 0 and compare(header["rho"], header["K"]) < 0,
+             "signed width and selected current residue")
+        n = own(subtract(header["f"], one))
+        compact = own(Count.product(n, header["G"]))
+        rest = own(subtract(header["H"], compact))
+        twice_H = own(scale(header["H"], 2))
+        before = own(subtract(header["active_start"], twice_H))
+        chunk = own(Count.product(header["f"], header["K"]))
+        active_end = own(scale(chunk, self.rank))
+        active_end.add(header["active_start"])
+        after = own(subtract(header["back_start"], active_end))
+        tail = own(subtract(header["within_bits"], header["back_start"]))
+        need(compare(tail, header["H"]) >= 0, "entire current back reservation")
+        suffix = own(subtract(tail, compact))
+        fibre = own(power_two(suffix))
+        top = own(subtract(header["K"], one))
+        rho = own(subtract(top, header["rho"]))
+        selected = own(scale(header["f"], self.rank))
+        selected.add(header["remainder"])
+        rank = own(Count.literal(self.rank))
+        need(compare(selected, header["selected_axes"]) == 0
+             and compare(header["remainder"], rank) < 0
+             and compare(header["selected_axes"], header["d"]) <= 0,
+             "current active width, fixed rank and untouched ordinary remainder")
+        complete = own(power_two(header["within_bits"]))
+        expected = own(Count.product(complete, header["record_bits"]))
+        need(compare(expected, header["row_bits"]) == 0, "exact complete current physical row")
+        pair_codes = own(Count(h))
+        pair_codes.increment()
+        pair_codes.multiply_small(6)
+        base_coefficients, remainder = divide(header["record_bits"], pair_codes)
+        own(base_coefficients); own(remainder)
+        need(remainder.zero(), "record_bits equals 6 r (h+1)")
+        positive(base_coefficients)
+        coefficients = own(Count.product(base_coefficients, fibre))
+        rows = own(Count.product(header["outer"], header["rows"]))
+        widths = (compact, rest, compact, rest, before,
+                  *(chunk for _ in self.vectors), after, compact)
+        return widths, rho, coefficients, rows
+
+    def rewind_field(self, field):
+        self.field_guide.rewind()
+        while self.field_guide.read() != 4:
+            need(self.field_guide.read() == 1, "complete current field guide")
+            field.move(-1)
+            self.field_guide.step(1)
+        self.field_guide.rewind()
+
+    def import_field(self, field, h):
+        """Strip actual component delimiters, preserving every signed bit."""
+        while field.read() != 4:
+            for _ in (0, 1):
+                remaining = Counter(h)
+                try:
+                    while not remaining.finished:
+                        value = field.read()
+                        need(value in (0, 1), "uniform complete signed component")
+                        self.bridge.append(value)
+                        self.field_guide.append(1)
+                        field.move(1)
+                        remaining.decrement()
+                finally:
+                    remaining.close()
+                need(field.read() == 2, "exact signed component delimiter")
+                self.field_guide.append(1)
+                field.move(1)
+        self.bridge.rewind()
+        self.rewind_field(field)
+
+    def export_field(self, field, returned, h):
+        """Reinsert the exact complete format at the unchanged common grid."""
+        returned.rewind()
+        self.field_guide.rewind()
+        while returned.read() != 4:
+            for _ in (0, 1):
+                remaining = Counter(h)
+                try:
+                    while not remaining.finished:
+                        value = returned.read()
+                        need(value in (0, 1) and field.read() in (0, 1)
+                             and self.field_guide.read() == 1, "exact returned signed component")
+                        field.write(value)
+                        field.move(1)
+                        returned.step(1)
+                        self.field_guide.step(1)
+                        remaining.decrement()
+                finally:
+                    remaining.close()
+                need(field.read() == 2 and self.field_guide.read() == 1,
+                     "same complete signed component boundary")
+                field.write(2)
+                field.move(1)
+                self.field_guide.step(1)
+        need(field.read() == self.field_guide.read() == 4, "exact full-format return frontier")
+        self.rewind_field(field)
+        self.field_guide.clear()
+        returned.rewind()
+
+    def run(self, field, context):
+        """Current CodedPort field and BinaryContextPort at their local origins.
+
+        SignedHeadroomError preserves field and context and allows a valid
+        retry. The all-size theorem concerns valid format and descriptors;
+        arbitrary malformed/interrupted execution has no rollback claim.
+        """
+        need(self.cohort.ports is not None and field.tape is not context.tape
+             and all(field.tape is not port and context.tape is not port for port in self.cohort.ports),
+             "distinct public/current-context and private physical segments")
+        self.cohort.start()
+        try:
+            with execution(), self.scope.installed(), ExitStack() as cleanup:
+                header = self.read_header(context)
+                for value in header.values():
+                    cleanup.callback(value.close)
+                h = self.component_width(field)
+                cleanup.callback(h.close)
+                widths, rho, coefficients, rows = self.prepare(header, h, cleanup)
+                self.import_field(field, h)
+                with self.scope.suspended():
+                    returned = self.engine.run(self.bridge, widths, header["f"], header["K"],
+                        header["G"], rho, h, coefficients, rows, self.inverse)
+                self.export_field(field, returned, h)
+                returned.clear()
+                erase_marker(returned)
+                self.bridge.clear()
+            self.pool.empty()
+            self.calls += 1
+        finally:
+            self.cohort.finish()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/phase_binding.py b/research/current-serial-monomial-leaf/vendor/monomial/phase_binding.py
new file mode 100644
index 0000000000..7f51953eb9
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/phase_binding.py
@@ -0,0 +1,80 @@
+"""Authenticate and bind unchanged #3087 to the current physical vocabulary.
+
+Only source discovery is replaced. All phase, signed-pair, monomial, Compact,
+Count and Tape computational source bodies remain their pinned bytes.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from hashlib import sha1, sha256
+import importlib.util
+import json
+from pathlib import Path, PurePosixPath
+import sys
+from types import ModuleType, SimpleNamespace
+
+HERE = Path(__file__).resolve().parent
+_state = None
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def authenticate(root=HERE):
+    rows = json.loads((root / "DEPENDENCIES.json").read_text())["files"]
+    seen = set()
+    for row in rows:
+        name = PurePosixPath(row["path"])
+        need(not name.is_absolute() and ".." not in name.parts and name.parts[0] == "vendor",
+             "regular relative frozen source path")
+        path = root / str(name)
+        need(str(name) not in seen and path.is_file() and not path.is_symlink(),
+             "unique regular frozen source")
+        seen.add(str(name))
+        raw = path.read_bytes()
+        need(sha256(raw).hexdigest() == row["sha256"]
+             and sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() == row["git_blob"],
+             "unchanged source bytes: " + str(name))
+    return len(rows)
+
+
+def load(name, path):
+    need(name not in sys.modules, "cold phase source module " + name)
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    exec(compile(Path(path).read_bytes(), str(path), "exec"), module.__dict__)
+    return module
+
+
+def activate():
+    global _state
+    if _state is not None:
+        return _state
+    authenticate()
+    binding, monomial = HERE / "vendor/binding", HERE / "vendor/monomial"
+    sys.path.insert(0, str(binding))
+    base = load("binding_sources", binding / "binding_sources.py")
+    state = base.activate()
+    reference = sys.modules["compact_reference"]
+    need("compact" not in sys.modules and "phase_sources" not in sys.modules,
+         "cold shared monomial source namespace")
+    sys.modules["compact"] = reference
+    finite = load("monomial_reference", monomial / "reference.py")
+    shim = ModuleType("phase_sources")
+    shim.activate = lambda: (sys.modules["native_sources"], reference, finite)
+    sys.modules["phase_sources"] = shim
+    sys.path.insert(0, str(monomial))
+    codec = load("codec", binding / "codec.py")
+    provider = load("provider", binding / "provider.py")
+    phase = load("signed_phase", monomial / "signed_phase.py")
+    recipe = load("phase_recipe", monomial / "phase_recipe.py")
+    pair = load("pair_dispatch", monomial / "pair_dispatch.py")
+    engine = load("monomial_engine", monomial / "monomial_engine.py")
+    need(engine.Count is state.counts.Count and engine.Tape is state.records.Tape
+         and phase.Count is engine.Count and recipe.Count is engine.Count,
+         "one actual Count/Tape vocabulary across the complete monomial")
+    _state = SimpleNamespace(source=state, codec=codec, provider=provider,
+                             phase=phase, recipe=recipe, engine=engine,
+                             reference=finite, pair=pair, abi=state.abi)
+    return _state
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/selected_service.py b/research/current-serial-monomial-leaf/vendor/monomial/selected_service.py
new file mode 100644
index 0000000000..fc3cbdc16b
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/selected_service.py
@@ -0,0 +1,76 @@
+"""One current #6030 MOVE boundary, with its actual source monomial.
+
+The width-one phase record and its tensor convention are inherited from #6293
+and #6930. This file binds the actual source token and owner to the current
+signed-format service; it does not re-audit the primary native recorder.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+import gzip
+from hashlib import sha256
+import json
+from phase_binding import HERE, authenticate, load, need
+from phase_adapter import Provider
+
+_selected = None
+EVENT = 9896
+RAW = ("MOVE", 236, 3, 7, False)
+
+
+def source_boundary():
+    global _selected
+    if _selected is not None:
+        return _selected
+    authenticate()
+    root = HERE / "vendor/selected"
+    word = json.loads(gzip.decompress((root / "WORD.json.gz").read_bytes()))
+    need(tuple(word["program"][EVENT]) == RAW, "actual selected MOVE source record")
+    ir = load("selected_phase_current_ir", HERE / "vendor/binding/vendor/lifecycle/source_ir.py")
+    events, stats = ir.current_local(word)
+    entry = next(e for e in events if e.op == "SERVICE" and e.token == ("move-in", "local", EVENT, RAW))
+    leave = next(e for e in events if e.op == "SERVICE" and e.token == ("move-out", "local", EVENT, RAW))
+    need(entry.fields == leave.fields == (236,), "actual selected field owner at both monomial cuts")
+    clifford = load("selected_phase_clifford", root / "clifford_exact.py")
+    start = clifford.canonical_frame(9, tuple(word["frames"][3]))
+    stop = clifford.canonical_frame(9, tuple(word["frames"][7]))
+    record, _compiled = clifford.lower_child(start.adjoint().then(stop))
+    need(record["rank"] == 1 and record["right"]["phase"] == 1
+         and record["left"]["phase"] == 0, "inherited #6930 actual chart record")
+    raw = json.dumps(record, sort_keys=True, separators=(",", ":")).encode()
+    report = dict(event=EVENT, raw=RAW, owner=236, rank=record["rank"],
+                  right=record["right"], left=record["left"], source_token=entry.token,
+                  record_sha256=sha256(raw).hexdigest(),
+                  source_phase_audit="unpaidmoon/integer-mult-bounds@c726399fbdb6d80dd13bed760b56572fb4ea1022",
+                  phase_algebra_inherited_from=[3087, 6293, 6930],
+                  current_source_events=stats["events"], selected_frontier_changed=False)
+    _selected = entry, leave, record, report
+    return _selected
+
+
+class Service:
+    def __init__(self, event, native_factory):
+        entry, leave, record, self.report = source_boundary()
+        need(event.op == "SERVICE" and len(event.fields) == 1 and len(event.token) >= 4,
+             "actual single-owner current MOVE service")
+        tail = event.token[-4:]
+        need(tail in (entry.token, leave.token), "fixed current source chart and occurrence token")
+        self.token, self.owner = event.token, event.fields[0]
+        self.side = "right" if tail == entry.token else "left"
+        self.provider = Provider(record[self.side], native_factory)
+        self.field = self.context = None
+
+    @property
+    def port_count(self):
+        return self.provider.port_count
+
+    def bind(self, work, fields, context):
+        need(self.owner in fields, "actual current MOVE owner has its physical field")
+        self.field, self.context = fields[self.owner], context
+        self.provider.bind(work)
+
+    def run(self):
+        need(self.field is not None, "fixed current source/field/context binding before input")
+        self.provider.run(self.field, self.context)
+
+
+if __name__ == "__main__":
+    print(json.dumps(source_boundary()[3], sort_keys=True))
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/DEPENDENCIES.json b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/DEPENDENCIES.json
new file mode 100644
index 0000000000..9e68f72266
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/DEPENDENCIES.json
@@ -0,0 +1,724 @@
+{
+  "schema_version": 1,
+  "files": [
+    {
+      "group": "lifecycle",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "ab239cb6ee884e7a900dd9101c34448077fad0b0",
+      "original_path": "research/compiled-owned-bank-lifecycle/machine.py",
+      "local_path": "vendor/lifecycle/machine.py",
+      "git_blob": "acf475e4fccaff2fb64bd5b0b3f3fc0d246dc592",
+      "sha256": "ec597bce13275003ff30e4be481c936401826c1d4af642b55eec0c410774d1df"
+    },
+    {
+      "group": "lifecycle",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "ab239cb6ee884e7a900dd9101c34448077fad0b0",
+      "original_path": "research/compiled-owned-bank-lifecycle/source_ir.py",
+      "local_path": "vendor/lifecycle/source_ir.py",
+      "git_blob": "79c95fa79439f3c893de52991173bd3a5eae2729",
+      "sha256": "54dd93bc50bd10e974c70794df1c13da27f0e3d8cdb6cfe6791a63280096f1b1"
+    },
+    {
+      "group": "lifecycle",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "ab239cb6ee884e7a900dd9101c34448077fad0b0",
+      "original_path": "research/compiled-owned-bank-lifecycle/PROOF.md",
+      "local_path": "vendor/lifecycle/PROOF.md",
+      "git_blob": "605981247e27de68fe78d3a36e2b454efbd6b11e",
+      "sha256": "9a088fa00f10e59df48090b67c6ef7c3641bc9cc36b223deb917740372d57993"
+    },
+    {
+      "group": "dispatch",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+      "original_path": "research/compiled-row-stock-dispatch/row_programs.py",
+      "local_path": "vendor/dispatch/row_programs.py",
+      "git_blob": "30ba41725f7e1ba3dd058abd30c66d19820a008d",
+      "sha256": "a59510516d1397382de6141edc1eb69cf3ba5e6e330198deb5e335e543300be4"
+    },
+    {
+      "group": "dispatch",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+      "original_path": "research/compiled-row-stock-dispatch/compiler_routes.py",
+      "local_path": "vendor/dispatch/compiler_routes.py",
+      "git_blob": "5752189b8a838596346df8dde89024621b513e41",
+      "sha256": "d375f8c2e666ffd2ebe6de34ccb7756ac9fa4a4cd5f866cb025a781f8538c599"
+    },
+    {
+      "group": "dispatch",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+      "original_path": "research/compiled-row-stock-dispatch/PROOF.md",
+      "local_path": "vendor/dispatch/PROOF.md",
+      "git_blob": "96b032f662397d496c4d827839441b6794881a53",
+      "sha256": "b0ed45deb84fa2ce835246d7de3c85ccdacf24ab68235cf1138fe6ff4c4ce5d9"
+    },
+    {
+      "group": "dispatch",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+      "original_path": "research/compiled-row-stock-dispatch/vendor/row_padding.py",
+      "local_path": "vendor/dispatch/vendor/row_padding.py",
+      "git_blob": "1e3533efa92c3bab35916ae6844290586d18ff27",
+      "sha256": "24270408e87b028791670cd63908adeb03162f0919237e8644065c5898fecf2f"
+    },
+    {
+      "group": "dispatch",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+      "original_path": "research/compiled-row-stock-dispatch/vendor/occurrence_geometry.py",
+      "local_path": "vendor/dispatch/vendor/occurrence_geometry.py",
+      "git_blob": "9c3c97d86a7bdd7b95944218bf1e6e4a5a1746a1",
+      "sha256": "f3504a73803da120040cc62ee8f5e8b849237daf508a7146272d55624c3f8396"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/compact_engine.py",
+      "local_path": "vendor/compact/compact_engine.py",
+      "git_blob": "5c5ca75567f85b042c156e0ed5a8afe81671b1b8",
+      "sha256": "2cacff4d36a6e029add115f47cd8ffbf3c61e7ece0900308b98e6032e652f098"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/compact_control.py",
+      "local_path": "vendor/compact/compact_control.py",
+      "git_blob": "13af719b5844f14f5cf05c919e84204cd21caf6a",
+      "sha256": "73a9ace4f91aeb383fdbc6f7762498fe707b4e4b45b1c63920bb90cc8795e284"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/compact_counts.py",
+      "local_path": "vendor/compact/compact_counts.py",
+      "git_blob": "064b508efd12f7d5a33729b2344b6890f0c75d2f",
+      "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/compact_layout.py",
+      "local_path": "vendor/compact/compact_layout.py",
+      "git_blob": "03ca12aed77741f40d824fcb33cc4eedb85abfd9",
+      "sha256": "5be2be9c32c15742da18fde438a5559a45a86eb661105027b1b233a7c397e0ce"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/compact_streams.py",
+      "local_path": "vendor/compact/compact_streams.py",
+      "git_blob": "5699cc7f20def3bc873d2da05b13a252246367a1",
+      "sha256": "3b5cce3be9763c6bd7803d6223d2784d1975eeac6c7c99f5e00dfc49bb11d249"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/native_sources.py",
+      "local_path": "vendor/compact/native_sources.py",
+      "git_blob": "3d2834c5fff39481c9a0442a514c10eaf50f98d2",
+      "sha256": "865c97c4f261fde37e86eb16a910eaa5b2f26daaa7d2648ae0322ba8c0286572"
+    },
+    {
+      "group": "compact",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/physical-complex-compact/PROOF.md",
+      "local_path": "vendor/compact/PROOF.md",
+      "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb",
+      "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/binary.py",
+      "local_path": "vendor/ordinary/binary.py",
+      "git_blob": "651185a9eec51438949580a34e707f6dd1adbd4b",
+      "sha256": "578fb5bc793fc544dca8111605bf9f6067b8ba7dc7489a3ac243e1df3cd37953"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/encoded.py",
+      "local_path": "vendor/ordinary/encoded.py",
+      "git_blob": "2280fa98ff5e4da7c4909814ce4a1c405605ada8",
+      "sha256": "10ad2fa5902a48d49cf2b89a30b3f2711d63a6a43b9512a6427affcdf07335a7"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/ordinary.py",
+      "local_path": "vendor/ordinary/ordinary.py",
+      "git_blob": "81b330a4b886a0f4deab7b0811478bab3fbc107a",
+      "sha256": "7f8338e748bcd42fbef1e7cc47b6c5040dfb3aad216e34759bcb12b8e14f7705"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/physical_words.py",
+      "local_path": "vendor/ordinary/physical_words.py",
+      "git_blob": "44b464714277786297c8ee7fd04470dc6394896d",
+      "sha256": "89ba40442297ec35368e426770f44852b39807ca426710ded2735678651bef61"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/session.py",
+      "local_path": "vendor/ordinary/session.py",
+      "git_blob": "09f645bbf0c6c3d41d0c03e8031adc4e81744ac1",
+      "sha256": "45ee809b27a69ca5576361922fd2760f568c9a98864d4c55c4fee3003ee3c9ad"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/source.py",
+      "local_path": "vendor/ordinary/source.py",
+      "git_blob": "8594fc62cee8a111958561b75045c8ec16ebfa47",
+      "sha256": "4bd047a1272374880962d3074f1e50de717518a3a181f11607e820afe50dd4e5"
+    },
+    {
+      "group": "ordinary",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/PROOF.md",
+      "local_path": "vendor/ordinary/PROOF.md",
+      "git_blob": "12be1f06062090fcc68e598bae250f185e3d8524",
+      "sha256": "8a1c2145cd8f080026488a571d95813c09679aa323f19aeaef0ea98030136e1c"
+    },
+    {
+      "group": "reference",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+      "original_path": "research/selected-complex-compact-adapters/streams.py",
+      "local_path": "vendor/reference/streams.py",
+      "git_blob": "61542ce4c9eb51bfc113475b4f98649cb90a853e",
+      "sha256": "718a582a50aee8f1f04945ed942be1d4162962fe47dbf05c6ff37b7fb8c61257"
+    },
+    {
+      "group": "reference",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+      "original_path": "research/selected-complex-compact-adapters/compact.py",
+      "local_path": "vendor/reference/compact.py",
+      "git_blob": "60bc206c78150f23563a4775800b0dd32025843d",
+      "sha256": "0e1027a60f38c21cfd808c8ce44dcc2423810efdab0e15f02b07f261ad48fc3c"
+    },
+    {
+      "group": "reference",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "d404b48a1e7b147556b309497d55089c837dddb2",
+      "original_path": "research/selected-complex-compact-adapters/NOTICE.md",
+      "local_path": "vendor/reference/NOTICE.md",
+      "git_blob": "e82bfef53054bd753ba0aa8a966f84427faa2293",
+      "sha256": "74a9f03e9ce467c75f5f7cf1b8465d349ea38ef114afad261824c3bcf13da00f"
+    },
+    {
+      "group": "record_lift",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/selected-monomial-tape-lift/lift.py",
+      "local_path": "vendor/record_lift/lift.py",
+      "git_blob": "167d085a9191e3b3545bcf39d5e6edc94e54d514",
+      "sha256": "21c77119c004a86a603cca91ce1366629431db18e9e0554942492f1b5afebe4a"
+    },
+    {
+      "group": "record_lift",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/selected-monomial-tape-lift/PROOF.md",
+      "local_path": "vendor/record_lift/PROOF.md",
+      "git_blob": "69e07e58c5468e2045281335a56f4918b474c79d",
+      "sha256": "8442243130d4a9932f78eb42419196d2866d4496256e3bb2d6143fd52b44ddb3"
+    },
+    {
+      "group": "compiler",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/lockstep-completion-pass/executor.py",
+      "local_path": "vendor/lockstep_executor.py",
+      "git_blob": "9469443a3d7cc6310a7369daf77c7756d5bd3f38",
+      "sha256": "0bda14a3e5f4da348cd5c89ebe29d717e7a5406ec31b164d5b9e1d25f7f38e0e"
+    },
+    {
+      "group": "selected",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "certificates/selected-result.json",
+      "local_path": "vendor/SELECTED-RESULT.json",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "group": "deferred",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "research/p104-6030-deferred-layer/PROOF.md",
+      "local_path": "vendor/DEFERRED-PROOF.md",
+      "git_blob": "de725a73e97496836100aa6e0ed9cd70985373da",
+      "sha256": "3a7ac6dae3b76d5f78849f521635da034fe99b1ea6c942175a3652b53f6262c2"
+    },
+    {
+      "group": "task",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "published_commit": "5c59d247d51c6e1fca0dead3ed2139b6802b3a15",
+      "original_path": "research/compiled-row-stock-dispatch/TASK.json",
+      "local_path": "vendor/dispatch/TASK.json",
+      "git_blob": "70bb2c54a6dbf9f17a55bbae8383d9bfde933e52",
+      "sha256": "6b5334d10044644ba646452b0e9e21528061768726d124a4a97af26785aa9ec9"
+    },
+    {
+      "group": "task",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "original_path": "docs/research/agent-task-catalog.json",
+      "local_path": "vendor/TASK-CATALOG.json",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    }
+  ],
+  "archive_members": [
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/consumer.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/consumer.py",
+      "sha256": "2f2a8604c23fb2c81f24320c71ed0142118d98dde3be6086adad28e89954a777",
+      "git_blob": "a66d9276f829ce2c619871866816649d5f3687fd"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/driver.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/driver.py",
+      "sha256": "ceaf8f75de9810a05ebf8f65780b6f8bd7599a5768401d5e4386182afe615cdf",
+      "git_blob": "5b7846a70aada53d87480b337e1c04217118771b"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/evidence/NOTICE.md",
+      "sha256": "fd7c42e89878cda6df86dde8720ece34625a337cf5edd795a421e2d3b42919e9",
+      "git_blob": "d0318d43ed420e21dc52166a19de703aa87fbb3e"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/evidence/pr2688-NOTICE.md",
+      "sha256": "c899fccf7bd32397f0ddd85e4af35a166cefb3e3ae3407ec40edc3ab2051b617",
+      "git_blob": "f2b49cdef83a4a685fad32c01fba93e12cfcb5a8"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/layout.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/layout.py",
+      "sha256": "3beef6534b02c3b011b741f957a7d9fb05a9ac0bba1fed53b2c71834e4ea6bc1",
+      "git_blob": "aa554b14fe0f6b308d9fba0a2afc92e5a28e20cb"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/linear_sign.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/linear_sign.py",
+      "sha256": "73e895fc701a4145cbe89d60f5775128354e7f08d0a45eacf22f423913f54e67",
+      "git_blob": "6a6e5c02f299fad8c4f7ab724fc36e14a22ab13c"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/node.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/node.py",
+      "sha256": "0bd4f640cafb5c8f070c161d86445910f77578a672bf5886936ed89e7f6bd21b",
+      "git_blob": "28c98a3573b458f7a055678d70b602b80e6e959e"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/packet_engine.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/packet_engine.py",
+      "sha256": "c80fc3aa9092f91cc309b2fb2dbc3618bf96bdb9b8498503993ea161f0ae2134",
+      "git_blob": "72543f684f38fefeacc2ee66d81661f1a2439cf7"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/peel.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/peel.py",
+      "sha256": "8b20888f74b4cd814a97b42ec72528fbfb6d2e936c5022df726f0785d0d01a2e",
+      "git_blob": "38502515afc928082c849cd2cda8578d33a5050a"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/NOTICE.md",
+      "sha256": "c446b32b8a621844fb2fbe654810c8122035bdd43fed2132f1137d98cb6f9943",
+      "git_blob": "ef9f81510db86eaf2f0a7191d85e92a6db30ddc0"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/cardinal_counts.py",
+      "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f",
+      "git_blob": "6a14feac45094ae9156e8c2c982d6727544f180e"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/catalogue.py",
+      "sha256": "83ea88f82d4a83c5f889774bfe3519b7ebaa24b6a0e2a969dafff012107a89bf",
+      "git_blob": "0efc0575a7623ac41c094d2e8772beda5a9fdc29"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/control.py",
+      "sha256": "d3a93e54bb7d333b73917586407d11674d38b5c3fda4fbdc436fb5293ae7786a",
+      "git_blob": "4f6ac09bffab43dbccc470bd0bde2ffbe969a8b2"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/fresh_rows.py",
+      "sha256": "e4ae08fbd658add630eb7754ebe0cbcb42c6f39cf4128f9cb92e27fcf5213a7d",
+      "git_blob": "aa3a327604308d3a5c7a27b65f5e631d430ab093"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/topology.py",
+      "sha256": "384d456ddba76de137a63b50019d5bba2e9f6daa4177c91643e0565d4cf1d44b",
+      "git_blob": "39a2916c207d04be5efc44750d8606f5da0c2990"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/binding.py",
+      "sha256": "20169a8af6ed2b34069fd353a2bc1c42335ab686c58de8479baef33dd3fb493b",
+      "git_blob": "21a5a21220a18ab62a19ac403a9944bc3a8665c8"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/bitstream.py",
+      "sha256": "f78bac9641007dbd8824984edcac057274fe016ce78bd9cb512d0c0913274783",
+      "git_blob": "4d1fd4abb0f2aabe833e5cbc9efb51039739e7ca"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/cardinality.py",
+      "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22",
+      "git_blob": "b8ba857e32c5903408e1e61ff916300848b4a208"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/children.py",
+      "sha256": "a78866939631214c1d1659203b2b5fc062e3c6255e9f11f975c310046b010bd6",
+      "git_blob": "ce4935f838516e2b08d13bec767cb803786fbc6b"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/controller.py",
+      "sha256": "fa09146991f6c04e6f4b6eb9bf0c8e103e70e90a0e402ff3d69814e6aac8ff8c",
+      "git_blob": "c631a9e77fbcccf0e8f448adc22978728aed7b60"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/counts.py",
+      "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069",
+      "git_blob": "81b48940ce222290a40d4fb349ce827f4788469d"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/directory.py",
+      "sha256": "4270e370b2bfe38ef73aadcd97d1b3496b56bd582115d74331eb9e5ceb90bec7",
+      "git_blob": "c74cacf5ce809c0561d374f137a52df0992b4226"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/episode.py",
+      "sha256": "38f79cb2a370548471063952d5f7c74bd795a2a8496fdcf3ce0996d79e3adaff",
+      "git_blob": "30d11ff4f333813855d36da3eb5a1ab0e154bafe"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/forms.py",
+      "sha256": "1fdf9d31b7eb107c396e33f94dad61c9d3f2c709cae61178268a44ca80dbc0b4",
+      "git_blob": "6667c0b772a63f0059c7caffec63e0d919a92398"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/low_codes.py",
+      "sha256": "f657e17f6088c840e3f7783e662257630f6d2c1e71c217721ffbca4d6ac93e87",
+      "git_blob": "737edfc4a10f4b7b3b97a7cef4b40864efd806e6"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/matrices.py",
+      "sha256": "00b687434039b54529ee092e34f9435cfcd66e0816eb3bd2a6688c73f4e01459",
+      "git_blob": "5d497353efbb9eeaaf4facd96ab40ffb0f3aa20d"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/numeric.py",
+      "sha256": "7327b05c4ec3e0f6d9c352cc7de85bfd4ebe940482553e77c59a773a8c09c514",
+      "git_blob": "6d4ebca8398008375b8f4762d1a9f1514e8c2611"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/oracle.py",
+      "sha256": "7bd18089e32ce48085b5e3a75159f6a82cdb2649ec682c53db05e399d97aef67",
+      "git_blob": "244f131466698a3ace10b657242fe1f65c07fd1f"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/packet.py",
+      "sha256": "970e7fe0719e3dfe122b248941e6f21cd90d7dd62089fa6acbd0e5412ce083a5",
+      "git_blob": "ebc9b616514412b80c56d523776e6ba5d6766453"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/plan.py",
+      "sha256": "d9c8dc93762db4d3a449814aa51e2211460648694469854d89cb48cb04188cf3",
+      "git_blob": "48255d5454308c07635fae4e7eb4873b0bd2a4f8"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/records.py",
+      "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372",
+      "git_blob": "4f00467a0ff580954ad2fd0c7380240c753ddef3"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/routes.py",
+      "sha256": "ed7dc3679451696ab1dd841146b215c9515a3eec5e4ff3763f33c315f1696ada",
+      "git_blob": "35531201dc349a811dfabc6f1f6e64697d665194"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/selection.py",
+      "sha256": "bc8e371fb1fa0b41fb05ef0b34d0f4c317b2396f9833d91f44f95c2b54b4052b",
+      "git_blob": "2c28f1aaec104a75c4e6c170b3e6a60300ee6700"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/sources.py",
+      "sha256": "f102edc7816d742bd89db8097254c19b843d0ef5cf6758ad42e93bcc0b214c62",
+      "git_blob": "16d5e7e6a28018f1e2d76d61efe2d54f6a6941d4"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/predecessor/vendor/stream.py",
+      "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5",
+      "git_blob": "5e5a4bb0f98971447043e25d4dd6991bfc070389"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/recursive_call.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/recursive_call.py",
+      "sha256": "157deaa5972557893d43494a81151483bdc46373448ec677cb6a738c9b7e6f1e",
+      "git_blob": "6d33224145aa04f7fbaf7b6cda7c9c164311a402"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/scheduler.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/scheduler.py",
+      "sha256": "0d96f7fbd6f90416167c5a52c0e3de942d1a0cae3d2968831932a9576701699f",
+      "git_blob": "60c2b6d065eba91dd5e0edb7a77fc087971eca3f"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/stream_runner.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/stream_runner.py",
+      "sha256": "b255feaf6cc6e40413ae73fe302bf8f290bf4dd89f4128b23a91cc9860601801",
+      "git_blob": "6ba5df130bb4a0fcb06b6c630830ae3a6922921b"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2753/trace.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2753/trace.py",
+      "sha256": "3a664224c558244f606b603cad816d75e94a17c9b2620a06a1530e893dfceac2",
+      "git_blob": "4b002201ce54cdecec9acf4e874b7f71cd75fe71"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2769/NOTICE.md",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2769/NOTICE.md",
+      "sha256": "8640d1b52fd21e5b20e8109ce9c4957ca1e19a95e26a1c80d019a6e6f4d5f178",
+      "git_blob": "307c2da733f7f3a76e97c77e71072e811f40df02"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2769/codec.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2769/codec.py",
+      "sha256": "5b9fda8136f7e60bece54e3fcc74f4ea0bec7145fa60e1ae3a4d252741b81fd3",
+      "git_blob": "9cd54d9417eb685dcd3f8293f01299ef9046ad31"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2769/vendor/parking_machine.py",
+      "sha256": "68134779debfb795468a1aaecbc2b9d321d7d4e451313ce7dc8fa7092561df4c",
+      "git_blob": "cafd614a3b7bc87b019361fcdf890ed976f26d19"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/inputs/pr2769/vendor/words.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "inputs/pr2769/vendor/words.py",
+      "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9",
+      "git_blob": "8d4ba37e2778acb35b34e0719df2caf138fbeb50"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/macro_binding.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "macro_binding.py",
+      "sha256": "9ef31765d03d2c54fad9296f2ff0707a190ce169e44de4f0f45214e3c410c01a",
+      "git_blob": "c197eb6458be9374cb4684c654bfc99e619dcaf0"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/macro_code.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "macro_code.py",
+      "sha256": "f626b018124747a5f17c1603bea36cd74c00a69a0647fd7b10e9c4e2964caea8",
+      "git_blob": "2f5f8ecfac6457171707b1b5ff02b5071954fcb7"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/macro_machine.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "macro_machine.py",
+      "sha256": "7bc6e42072a09a08ac961e05c3da01cde012d740d4b4c605f298d994f2ad7c5a",
+      "git_blob": "5a032e8923f7f8b22bb98f3e39b804beb9906c16"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/residual_blocks.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "residual_blocks.py",
+      "sha256": "ab7f3df8906decd2efecfb138eac1456c106bb520b2598761f699f80680d8331",
+      "git_blob": "fba75e7649cf77e352a75324495191bbd7853c22"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/role_parking.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "role_parking.py",
+      "sha256": "1884a3c260d81d5efbc0c33d86a810d6728e55e5764cfcd423f858cc685470f3",
+      "git_blob": "fc48c244eefdbaa3e320e86c75a7d187cb5765ef"
+    },
+    {
+      "local_path": "vendor/runtime/pr2809/scratch_pool.py",
+      "archive_name": "pr2809.tar",
+      "archive_sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "member": "scratch_pool.py",
+      "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db",
+      "git_blob": "0f22807c65d1bca374b905538512bf8c43702070"
+    },
+    {
+      "local_path": "vendor/runtime/pr2808/outer.py",
+      "archive_name": "pr2808.tar",
+      "archive_sha256": "2ab59c6d0ad00c001ecbe44090b66871ec3d2c1fdc51daa503109e56f3285cab",
+      "member": "outer.py",
+      "sha256": "9a26702a853805da7f97da7272d3b610c4d69767ecc6b450efbc4b6722dc3f19",
+      "git_blob": "1341d394481fb13beb826b944409b11083d8e7f8"
+    },
+    {
+      "local_path": "vendor/runtime/pr2808/vendor/pr2786/padding.py",
+      "archive_name": "pr2808.tar",
+      "archive_sha256": "2ab59c6d0ad00c001ecbe44090b66871ec3d2c1fdc51daa503109e56f3285cab",
+      "member": "vendor/pr2786/padding.py",
+      "sha256": "9f58bf2d343e13a70dc765d86c590b912d5987669d507ab14bd36deed94a76ee",
+      "git_blob": "0229304638de6c78ebc519b33a6ce34b1d396ca7"
+    }
+  ],
+  "archives": [
+    {
+      "name": "pr2809.tar",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/inputs/pr2809.tar",
+      "git_blob": "21ff4b5b9942dbc82b60b4546d39785daa22ba86",
+      "sha256": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+      "bytes": 962560
+    },
+    {
+      "name": "pr2808.tar",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "published_commit": "2f0911ad735643a069b9790302fbf179e49f74f8",
+      "original_path": "research/physical-ordinary-interchange/inputs/pr2808.tar",
+      "git_blob": "191b0b3342d12a630d60643439afa3284641c2d5",
+      "sha256": "2ab59c6d0ad00c001ecbe44090b66871ec3d2c1fdc51daa503109e56f3285cab",
+      "bytes": 296960
+    }
+  ],
+  "extraction": "Full local archive SHA256 matched the freshly fetched public ordinary/source.py anchors. Only the51 computational import-closure/NOTICE members listed here are exported. Member git_blob values are hashes of exact archive-member bytes, not separate API claims."
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/PROOF.md
new file mode 100644
index 0000000000..859eb593d3
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/PROOF.md
@@ -0,0 +1,490 @@
+# Retained Compact on the current complete coded field
+
+Prepared for **@CubeJerry**, with substantial OpenAI assistance in source
+analysis, mathematics, implementation, checking and prose. Apache-2.0.
+
+## 1. Scoped result and exact predecessors
+
+This package supplies one selected-bit XOR service for the actual record grammar
+emitted by the current compiler/occurrence route binder. It produces the retained
+Compact layout from the current twenty-three-field encoded descriptor, executes
+the actual retained operation on A's coded ports, and returns the same complete
+field and unchanged descriptor, with all private current segments physically
+blank. Both source orders and the separate `f=1` case are covered.
+
+This is a **structured finite-control, fixed-tape source refinement**. It is not
+an emitted flat transition table, and its tests do not run this service through
+A's `Controller.execute_table`. Section 6 gives the finite-control refinement
+argument. A table-format exporter remains an integration task, not an experiment
+claimed to have been performed here.
+
+The exact predecessors are:
+
+* [#3055](https://github.com/CrocSwap/integer-mult-bounds/pull/3055),
+  `research/physical-complex-compact`, at canonical
+  `7c49fe32c55de02c2c873655c804b16e4c3fef0a`: encoded Compact controls,
+  literal rotations, complete exceptional repair, final bit gate, fixed roles,
+  and the completed ordinary boundary. These mechanisms are inherited.
+* Its ordinary supplier [#2899](https://github.com/CrocSwap/integer-mult-bounds/pull/2899)
+  at `2f0911ad735643a069b9790302fbf179e49f74f8`, and compact word
+  [#2250](https://github.com/CrocSwap/integer-mult-bounds/pull/2250) at
+  `d404b48a1e7b147556b309497d55089c837dddb2`.
+* [#5445](https://github.com/CrocSwap/integer-mult-bounds/pull/5445),
+  `research/selected-monomial-tape-lift`, at the same canonical base:
+  `XROW(target,source)` acts on every selected column with zero phase.
+* [#5443](https://github.com/CrocSwap/integer-mult-bounds/pull/5443)'s executor
+  and [#6878](https://github.com/CrocSwap/integer-mult-bounds/pull/6878)'s
+  occurrence interface, through the exact public current-source exports
+  [A, owned lifecycle](https://github.com/CubeJerry/integer-mult-bounds/tree/ab239cb6ee884e7a900dd9101c34448077fad0b0/research/compiled-owned-bank-lifecycle)
+  and [B, row/occurrence dispatcher](https://github.com/CubeJerry/integer-mult-bounds/tree/5c59d247d51c6e1fca0dead3ed2139b6802b3a15/research/compiled-row-stock-dispatch).
+
+The new content is the actual complete-field/descriptor/encoding join and its
+whole current-call cleanup. It is not another construction of Compact or a
+record-list census. The ordinary supplier's all-size endpoint, rate and backing
+contracts remain named predecessors. A valid common numeric record format,
+current source placement, root descriptor and ordinary-caller contract are
+inherited from A/B. No Gaussian phase, nonpermutation native operation, scalar
+precision estimate, root producer or analytic recovery theorem is supplied.
+
+The pinned historical exponent is `tau_B1=99830289/100000000`. It is not the
+selected `.0034` primitive saving. Section 9 gives the exact rate implication
+limit. All five selected assumptions and `kappa=781451/250000000` remain unchanged.
+
+## 2. Complete current input and requested endpoint
+
+Fix a final template rank `N>=2` and distinct compiled block indices `s,t<N`.
+They are finite template constants, never decoded runtime integers. The current
+header supplies `f>=1`, `K,G,H>0`, `0<=rho_B<K`, within-row address width `a`,
+numeric record width `b`, and positive outer/row counts `C0,R0`. Put `C=C0*R0`.
+The public field, protected context and every work role are pairwise disjoint
+current segments. Every work segment is physically blank at entry, with its
+declared local origin marker. These are the owned caller's interface premises;
+the service never borrows an ancestor segment or aliases the public input with
+private workspace.
+One complete field contains
+
+```
+V=C*J physical bits,                 J=2^a*b.
+```
+
+Every row quotient retains this same within-row rectangle. A numeric record has
+two signed little-endian binary components of fixed positive width `w`, each
+followed by component delimiter2. A encodes each virtual symbol in three physical
+bits, so `b=6(w+1)`. The delimiter is `010`, not an all-zero filler. A permutation
+of complete records does not change the common precision grid.
+
+The two full front fields begin at within-row positions 0 and H. Write
+`u=active_start`, `z=back_start`. Require
+
+```
+2H<=u,     u+N*f*K<=z,     z+H<=a,     (f-1)G<=H.
+```
+
+These intervals suffice for the service endpoint. The production B header also
+has `H=dG`, `e=Nf+r<=d`, `0<=r<N`, and its root precision/reservation premises.
+The producer checks the required intervals, offset, exact row length and
+`e=Nf+r` geometry. It preserves every header field, including stock.
+
+**All starts are already within-row positions.** The B root producer has
+subtracted `q0*K` once. This service never subtracts it again, reinterprets a row
+quotient as a new binary prefix, or rounds the row count to a power of two.
+
+The endpoint changes exactly
+
+```
+address[u+(t*f+j)*K+rho_B] ^= address[u+(s*f+j)*K+rho_B],   0<=j<f,
+```
+
+where positions are numbered from the left within a row. It preserves every
+other address coordinate, every outer row, each complete numeric record and the
+order of its bits. Arbitrary dirty helper addresses and arbitrary coefficient
+values are allowed. A complete canonical zero row remains the same zero row.
+
+## 3. Encoded layout production without moving the field
+
+Set `n=f-1`, `h=nG`, `c=fK`, `l=u+min(s,t)c`, `r=u+max(s,t)c`,
+`S=a-z-h`, and `R=b*2^S`. The fixed native schema is:
+
+| Name | Encoded width | Existing consecutive interval |
+|---|---:|---|
+| `u` | `h` | first front-field prefix |
+| `u_rest` | `H-h` | rest of first front field |
+| `t` | `h` | second front-field prefix |
+| `t_rest` | `H-h` | rest of second front field |
+| `before` | `l-2H` | every coordinate before the earlier block |
+| `x` | `c` | earlier selected block |
+| `middle` | `r-l-c` | all intervening coordinates |
+| `y` | `c` | later selected block |
+| `after` | `z-r-c` | all remaining coordinates before the back field |
+| `b` | `h` | back-field prefix |
+
+All widths are nonnegative. The last field ends at `z+h`; all following
+coordinates remain in one opaque R-bit record. The width sum is `a'=z+h=a-S`, so
+
+```
+2^a'*R = 2^(a-S)*b*2^S = J.
+```
+
+This is an equality of existing consecutive stream intervals. No movement,
+sorting, dropped spectator or tensor-rank argument is hidden in it. Only the
+interpretation of a complete suffix fibre changes. Its encoded construction is
+paid. Both helper suffixes remain complete spectators, and no helper prefix is
+assumed zero. Choose native source `x`, target `y` for `s<t`, and source `y`, target `x`
+for `s>t`. Both front prefixes precede both wide blocks and the back prefix
+follows both, satisfying the retained ordering contract.
+
+The native layout numbers selected bits from the least significant end of a
+wide field. It therefore needs
+
+```
+rho_native=K-1-rho_B.
+```
+
+In a block starting at L, native low bit `rho_native+jK` is at position
+
+```
+L+fK-1-rho_native-jK = L+(f-1-j)K+rho_B.
+```
+
+This reverses the enumeration of selected columns in both source and target,
+pairing exactly the same bits. It requires no chunk reversal. The actual
+wrong-rho control fails a complete coded `K=2,f=1` endpoint check.
+
+`read_header` consumes the exact B format: `1^ell 0` followed by ell LSF bits for
+each of 23 fields. A unary length guide supplies each digit count; another guide
+records all consumed header positions and rewinds the read-only context. Binary
+canonicality uses finite last-bit states. All subsequent products, powers,
+differences and comparisons use retained Count tapes. No host numerical layout
+or decoded address supplies the operation.
+
+Let E be the physical header length. On valid inputs its `row_bits` field has
+bit length at least a. Thus constructing `2^a` is short-operand setup, not a
+payload-bit counter. Intermediate word lengths are `O_N(E+1)`. The fixed number
+of binary products, subtractions and repeated doublings costs `O_N((E+1)^2)`;
+we conservatively use `O_N((E+1)^4)` below. Setup occurs once per service.
+
+## 4. Exact alphabet and complete record bridge
+
+A's virtual alphabet is 0..6 with physical code length 3. The old native alphabet
+is 0..13, with blank 4, LEFT 2 and RIGHT 3. `SymbolPort` represents each old symbol
+by four virtual binary digits, most significant first, using A's unchanged
+`CodedPort` for each digit: **twelve physical bits per old symbol**.
+
+At an unmaterialized old cell the first virtual read is blank 4. At an occupied
+cell all four virtual digits are 0/1 and decode below 14. A read or write returns
+to the codeword origin. An old unit move makes four virtual moves. Before a
+right move over an unmaterialized cell, the full old blank code is written;
+there is no partial codeword or physical hole. Each old unit read/write/move
+takes fewer than 128 physical cell actions, including blank materialization.
+
+The old LEFT marker is coded inside the current A segment. A's physical LEFT
+remains outside that segment, and its local guard prevents ancestor access.
+Old tape bodies contain no internal LEFT 2: payloads are bits, Counts use RIGHT 3,
+and finite records use the retained higher tags. Retained completed-head guards
+are refined by preceding-marker reads, not host head addresses. Old host backing
+inspection rejects during execution; tests inspect the supplied physical ports.
+
+The input bridge scans every public virtual symbol 0/1/2 and appends its three
+physical code bits as three old opaque bit symbols. A unary field guide records
+one step per public symbol and rewinds the unchanged field. Native Compact gets
+the entire V-bit bridge, encoded widths, record width R and exact row count C.
+
+Return consumes three old output bits per guided public symbol, checks a valid
+code 0/1/2, and overwrites precisely that existing codeword. The guide and output
+must end together, at the unchanged public frontier. Moving right from the last
+occupied codeword reaches that frontier without extending it. A guided rewind
+restores the public head, and the raw descriptor remains unchanged.
+
+Native movement preserves complete R-bit records and R is a multiple of b. Thus
+each output triple is the original triple in an original complete numeric
+record. This proves delimiter, sign-bit, fixed-width and grid preservation for
+every positive w, with no arithmetic, rounding or coefficient truncation.
+
+## 5. Actual native execution and successful return
+
+For `f>=2`, `n>=1`. The unchanged `CompactEngine.run` executes four ordinary
+swaps/four rotations for an earlier source or twelve swaps/ten rotations for a
+later source, complete exceptional-record repair, and the highest selected bit.
+The retained #3055 endpoint gives Section 2's all-f XOR and restores all compact
+labels on every complete outer row. No identity replacement or indexed payload
+oracle is used.
+
+For `f=1`, `n=0` is outside the old positive-n Control domain. The separately
+paid `single` procedure builds the same encoded Layout, copies each complete row
+to an owned lease and invokes the retained four-bucket `digit_permutation` on
+the two selected bits. Its map is `(0,1,3,2)` for an earlier source and
+`(0,3,2,1)` for a later source. All intervening/suffix fibres are copied. No
+compact swaps, rotations or repair are required in this case. It is not a claim
+that the old positive-n guard accepted zero.
+
+Both branches preserve the protected output until it has been copied into the
+actual public field. They close numerical leases and erase old input, guides,
+output and owned markers. Old-symbol erasure leaves nonblank twelve-bit codes
+for blank 4, so the wrapper additionally performs A's literal raw retirement on
+**every** native work port. This erases the current call's complete encoded
+high-water prefix and restores each physical current origin. These ports belong
+to A's fixed continuation inventory; none is an unparked host bank.
+
+The ordinary object's two parking tapes are also coded physical ports.
+`ParkingAdapter` runs its unchanged seven-symbol transition table through local
+operations. An empty-stack guard requires blank at the current head and LEFT 2
+immediately before it. A nonempty stack with its head at a blank top therefore
+fails. The packet guard checks its expected marker, the immediately preceding
+LEFT 2, and blank body. Matched begin/push/pop/end preserve a contiguous prefix:
+push appends at the blank top and pop erases every removed suffix cell. This
+invariant excludes a hidden nonblank tail beyond a completed blank prefix.
+The actual table and nonempty/dirty/displaced-head controls are replayed.
+
+The guarantee is for successful admitted calls. No rollback after an arbitrary
+interruption or rejecting native operation is claimed.
+
+## 6. Fixed control and physical inventory
+
+The constructor receives compiled N, the ordered pair and an unchanged Ordinary
+factory. That factory is called once before runtime input exists. Arbitrary
+native observation/payload callbacks reject. `Service.bind` fixes the actual
+owner and context from the emitted token. Runtime `run()` gets no callback,
+address list, coefficient dictionary or decoded numerical parameter.
+
+All old Tape objects are allocated at template construction. Runtime Count and
+stream creation leases fixed roles, and old physical constructors remain sealed
+during native calls. The provider adds a fixed 160-slot setup pool, four bridge/
+guide tapes and the coded parking pair. Compact retains `8m+256` roles (`m=10`)
+and Binary retains 96; native ordinary roles and protected outputs are included.
+The exercised q2/capacity64 supplier uses 1413 physical work ports. That is a
+fixture inventory, not a selected supplier or eligible-prime certificate.
+
+Schema indices, multipliers such asN, source records, program counters and pool
+slots range over fixed finite sets. Unbounded values stay in Count/word tapes.
+Scratch/live maps range over fixed role sets. A fixed number of references is
+live in each bounded source frame; identity tests can be a finite alias relation
+on them, rather than an unbounded generation counter. Temporary contexts and
+cleanup callback lists have fixed static bounds. Native input-dependent
+recursion already uses encoded continuations. Observation counters never select
+instructions or operands.
+
+Replace these bounded choices and fixed-depth calls by finite states, and each
+symbol operation by its constant-size codec fragment. This yields fixed
+multitape control on the physical0..6 alphabet with the declared inventory.
+This is the supplied source-level physical refinement. Neither a flattened
+table nor a proof-assistant certificate is claimed.
+
+## 7. Full all-size time bill
+
+Define
+
+```
+a'=z+(f-1)G,  M0=2^a',  v0=M0*R=J,  M=C*M0,  V=C*v0,
+A0=2+a'+ceil(log2(R+1)),
+delta=min(1,(f-1)*(2*2^(-G)+8*2^(G-K))).
+```
+
+Let `T_B(v,beta)` be the retained completed binary ordinary-interchange bill,
+including actual padding/restriction, native output consumption and cleanup.
+The fixed eligible radix q and its proof constants are part of this contract;
+they are not inferred from the q2 fixture. For `f>=2`, #3055 supplies the complete
+old-symbol charge
+
+```
+T_compact <= s * sum_(j=1)^C T_B(v0,(f-1)G)
+            + O_m(V + M*A0^6 + delta*M*A0*(R+A0)),       (1)
+s=4 for an earlier source; s=12 for a later source.
+```
+
+There are actually sC ordinary calls. Treating the entire packet as one s-call
+volume without proving that interface would change the invocation bill. Both
+exceptional-fraction terms, complete keys, global repair scans, highest-bit
+operation, outer-row counter and rewinds remain in (1).
+
+Let Q be the fixed number of work ports. Let Z be the sum of relative old-symbol
+high-water extents reached **during this call**, including setup, bridge, guides,
+native and parking roles. The new wrapper has the explicit envelope
+
+```
+T_new <= C_codec*T_compact
+         + C_N*(V+(E+1)^4+Q) + 64*(Z+Q).                (2)
+```
+
+`C_codec` is a fixed constant for the complete guarded source-control refinement,
+including the bounded `OriginHead` and `ParkingView` local marker checks. The
+separate primitive lemma bounds one old read/write/step by 128 physical actions;
+it alone is not a bound for an entire guarded source instruction. The source
+bill in (1) includes its primitive and bounded-control operations, and each
+added marker check occurs at one such fixed source site. Thus a uniform fixed
+`C_codec` exists without multiplying by an input-dependent pass count.
+
+`C_N` is a finite constant for the stated fixed setup and bridge programs, not
+an additional input-dependent pass count. The constant64 covers A's complete
+raw retirement of a twelve-bit old-symbol extent and its fixed origin work.
+This separate Z term keeps encoded blank tails and cleanup from being free.
+
+Every newly reached old-symbol position costs a unit move or initial write in
+this invocation. Hence `Z=O(T_compact+V+(E+1)^4+Q)`. Substituting in (2) gives
+the full shape of(1), with a fixed codec factor and `O_N(V+(E+1)^4+Q)` extra.
+It does not scan a backing array's historical length. For `f=1`, set the ordinary
+sum and exceptional term to zero and use the conservative actual bucket/setup
+charge `O_m(V+M*A0^6)` in place of(1).
+
+There is no `V log J` generic counter loop in the new bridge. Payload traversal
+uses end markers and lockstep guides. Encoded length arithmetic occurs once on
+the binary descriptor. The retained Counter loops use their amortized binary
+traversal proof, not unit-cost random-access integers.
+
+## 8. Current workspace, retained backing and favorable absorption
+
+Keep the completed binary ordinary supplier's workspace and per-role backing
+maxima explicit. Compact's retained occupied envelope is
+
+```
+4V + 2*delta*M*a' + M + O_m(A0+log(C+1)),
+```
+
+with the completed binary/ordinary private allowance added separately. The new
+borrowed public field contributes V physical bits; the bridge is already the old
+borrowed Compact input. Field/header guides and the fixed setup pool add
+`O(V+E+A0)` old symbols. Multiply coded owned extents by 12 and add the two
+parking roles. This accounts for current occupied space without omitting the
+ordinary implementation's workspace.
+
+For fresh backing, the compact pool has per-role maximum
+`O(v0+delta*M0*a'+A0+log(C+1))`, and its fixed capacity is charged. Add the global
+input/output/guide extents and actual completed binary supplier maxima. For
+reuse, take each role's maximum over all preceding calls. On A's changing
+current segments the absolute bound is the maximum of `current origin + coded
+relative extent`; A's continuation/lifecycle bill separately covers those
+origins. Erasure and smaller children do not shrink retained arrays.
+
+Fresh blank current segments make the time claim different from the historical
+footprint claim. Each previous successful call physically erased its complete
+encoded extent. A new call materializes a contiguous prefix, and raw retirement
+stops at that prefix's physical frontier even if the allocated array is longer.
+The reuse replay checks the useful distinction: a smaller call following a
+larger six-row call has exactly its fresh-call action count while retaining
+the larger backing. This supports the invariant; it does not replace its proof.
+
+For the production B geometry, `H=dG` and `f=floor(e/N)<=d/2`. Consequently
+
+```
+S=a-z-(f-1)G >= H-(f-1)G >= dG/2,
+R >= b*2^(dG/2).
+```
+
+With `G=4ceil(log2 p)+6`, any retained root regime with `d->infinity` makes R
+larger than every fixed power ofp. Moreover
+
+```
+A0 <= 3+a+ceil(log2(b+1)) = O(p)
+```
+
+under the actual common-format address/precision premise. Arbitrary row division
+does not change this estimate because it preserves the full root rectangle.
+
+The selected deferred schedule has `K=128G`, not `K/log p -> infinity`. The
+actual sufficient guard estimate in #3055's proof only requires
+`K>=G+4ceil(log2 p)+10`, which 128G satisfies. With `f-1<=p`,
+
+```
+delta <= 5/(128*p^3),
+M*A0^6/V = A0^6/R -> 0,
+delta*M*A0*(R+A0)/V = delta*A0*(1+A0/R) = O(p^-2).
+```
+
+For setup, the retained root format gives `E=O_N(p+log(C+1))`; in particular
+fitted stock does not exceed its row count. Every fixed polynomial of E is
+absorbed by the superpolynomial R and `log(C+1)^k=O_k(C)` for fixed k. The outer
+count's logarithm does not enter each record's compact arithmetic. Initializing
+and cleaning Q fixed roles changes a fixed constant.
+
+Thus an admitted completed binary supplier
+`T_B(v,beta)<=K_q*v*(1+beta^tau_B)` yields
+
+```
+T_new = O_(q,N)(V*(1+((f-1)G)^tau_B))                 (3)
+```
+
+in this favorable domain. Current workspace is linear when the corresponding
+completed ordinary workspace premise is linear. Equations (1)--(2), with the
+explicit backing allowances, remain the full all-size statement.
+
+## 9. Current source binding and the rate boundary
+
+B emits
+
+```
+('selected-bit-xor', route_id, 'enter' or 'return', s, t, source_token)
+```
+
+on exactly one owner. `Service` retains that owner and token and converts it to
+#5445's `('XROW',t,s)` convention. Parameters come from the protected current
+header. A transposition's entry/return still comprises six charged services.
+Compiler-internal matched-field events consume no row stock: this provider
+neither divides rows nor allocates an ordinary child. B's exact occurrence map
+supplies the placement contract, rather than an imagined new row prefix.
+
+The fixture runs the actual #5443 executor, A's `lower` and B's `bind` on a
+declared compiler-control rule. At final rank 2 its elementary program emits
+actual axis entry/return words, including both source orders. The native tests
+bind those exact emitted tokens. This control rule is not a new Gaussian
+identity or the materialized selected uniform template. The proof applies to
+every valid emitted record using its fixed owner, ordered pair and common
+descriptor contract.
+
+For the frozen #6030 specialization in [#6115](https://github.com/CrocSwap/integer-mult-bounds/pull/6115),
+
+```
+tau_node = 1-kappa-4/1400000000 = 872264919/875000000,
+tau_B1   = 99830289/100000000,
+tau_B1-tau_node = 5000439/3500000000 > 0.
+```
+
+The historical upper bound (3) alone does not imply the selected node tariff.
+For growing f its extra positive power cannot be hidden by a fixed constant; in
+a polynomial active-width regime it cannot be hidden by a fixed polylogarithm
+either. This is a limit of this upper-bound implication, **not an algorithmic
+lower bound**. A stronger completed ordinary contract can be composed with the
+same geometry/codec proof. No new κ, current `.0034` primitive proof or
+assumption-status edit follows.
+
+## 10. Evidence, provenance and open next questions
+
+`verify.py` authenticates 32 exact public source exports and 51 bounded runtime/
+NOTICE exports from the authenticated ordinary archives. Their hashes are
+anchored in the freshly fetched public ordinary loader. Public archive Git
+blobs, lengths and exact member hashes are recorded in `DEPENDENCIES.json`.
+The new computational bootstrap replaces repository discovery, not a theorem
+verifier. It does not claim to rerun the old full selected proof chain.
+
+Physical fixtures use distinct complete signed-record labels, compare every
+output record with an independent address oracle, check exact physical
+frontiers/heads and descriptor bytes, and preserve translated-origin ancestor
+sentinels. The `f=2` early/late tests execute actual Compact rotations, repair
+and ordinary calls. They deliberately reduce helper widths and use a q2
+elementary supplier; they do not instantiate the huge selected root or establish
+an eligible-prime faster-rate theorem. Separate encoded producer tests satisfy
+`H=dG` and include an outer count above `10^70`.
+
+Adverse controls change rho conversion, omit raw retirement or the actual owner,
+introduce invalid codewords, mutate source bytes and alter geometry parameters.
+Parking controls reject nonempty blank-top stacks, a dirty packet and a displaced
+head. Normal and optimized registered replays compare a complete deterministic
+receipt. Finite execution is evidence for the all-size argument, not a substitute.
+
+Open next questions:
+
+1. Export this bounded source control into A's flat table syntax and run the
+   complete lifecycle controller with these native events. Start with the fixed
+   codec/parking fragments and actual emitted service tokens.
+2. Bind a completed ordinary supplier with a sufficiently small exponent.
+   Check its exact rate, stock and retained-backing contracts; do not relabel
+   the historical B1 estimate.
+3. Bind the retained phase/nonpermutation services, including the physical
+   Gaussian phase predecessor [#3087](https://github.com/CrocSwap/integer-mult-bounds/pull/3087),
+   to the current common record grid with their error and full cost bills.
+   This permutation introduces no coefficient error and supplies only XROW.
+
+Credit remains with the Compact identity/guard/repair authors and physical
+Compact/ordinary, record-lift, compiler, continuation and precision lineages.
+In particular retain Jose Manuel (`jmbarrancoml`), Douglas Colkitt, the authors
+credited in unchanged #2250 NOTICE, Mark (`Matarener`)'s record lift, and the
+contributors credited by the ordinary exports. No independent human review
+or proof-kernel admission is claimed.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/binding_sources.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/binding_sources.py
new file mode 100644
index 0000000000..15469f0972
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/binding_sources.py
@@ -0,0 +1,75 @@
+"""Authenticate computational exports and establish one cold source vocabulary.
+
+The new bootstrap replaces only archived host-side repository discovery. It
+does not replay or admit the old selected theorem. Ordinary's rate is a named
+predecessor premise. Computational exports remain byte-for-byte unchanged.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from pathlib import Path, PurePosixPath
+from hashlib import sha1, sha256
+import importlib.util
+import ast
+import json
+import sys
+from types import ModuleType, SimpleNamespace
+
+HERE=Path(__file__).resolve().parent
+_loaded=None
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+def authenticate(root=HERE):
+    manifest=json.loads((root/'DEPENDENCIES.json').read_text())
+    original=ast.parse((root/'vendor/ordinary/source.py').read_text())
+    anchors=next(ast.literal_eval(n.value) for n in original.body
+                 if isinstance(n,ast.Assign) and any(isinstance(t,ast.Name) and t.id=='ARCHIVES' for t in n.targets))
+    seen=set()
+    for row in (*manifest['files'],*manifest['archive_members']):
+        path=PurePosixPath(row['local_path'])
+        need(not path.is_absolute() and '..' not in path.parts and path.parts[0]=='vendor','relative frozen export')
+        need(str(path) not in seen,'unique frozen export');seen.add(str(path))
+        actual=root/str(path);need(actual.is_file() and not actual.is_symlink(),'regular source export')
+        data=actual.read_bytes()
+        need(sha256(data).hexdigest()==row['sha256'],'changed SHA256 export: '+str(path))
+        need(sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==row['git_blob'],
+             'changed Git blob export: '+str(path))
+        if 'archive_name' in row:
+            need(anchors[row['archive_name'].removesuffix('.tar')]==row['archive_sha256'],
+                 'public loader archive SHA256 anchor')
+    return len(seen)
+
+def module(name,path):
+    spec=importlib.util.spec_from_file_location(name,path)
+    out=importlib.util.module_from_spec(spec);sys.modules[name]=out
+    exec(compile(Path(path).read_bytes(),str(path),'exec'),out.__dict__)
+    return out
+
+def activate():
+    global _loaded
+    if _loaded is not None:return _loaded
+    authenticate()
+    need(not any(x in sys.modules for x in ('loader','source','native_sources','words','records')),
+         'cold computational namespace')
+    runtime=HERE/'vendor/runtime'
+    caller=runtime/'pr2809/inputs/pr2753'
+    loader=ModuleType('loader');loader.CALLER=caller;sys.modules['loader']=loader
+    for p in (caller/'predecessor/vendor',caller/'predecessor',caller,
+              runtime/'pr2809',runtime/'pr2809/inputs/pr2769/vendor'):
+        sys.path.insert(0,str(p))
+    codec=module('bank_codec',runtime/'pr2809/inputs/pr2769/codec.py')
+    loader.activate=lambda:codec
+    padding=module('padding',runtime/'pr2808/vendor/pr2786/padding.py')
+    outer=module('outer',runtime/'pr2808/outer.py')
+    source=ModuleType('source');source.activate=lambda:(loader,padding,outer);sys.modules['source']=source
+    sys.path.insert(0,str(HERE/'vendor/ordinary'))
+    module('streams',HERE/'vendor/reference/streams.py')
+    reference=module('compact_reference',HERE/'vendor/reference/compact.py')
+    native=ModuleType('native_sources');native.activate=lambda:(source,reference);sys.modules['native_sources']=native
+    sys.path.insert(0,str(HERE/'vendor/compact'))
+    import compact_engine, records, words, cardinal_counts, ordinary, session, scratch_pool
+    abi=module('current_lifecycle_abi',HERE/'vendor/lifecycle/machine.py')
+    _loaded=SimpleNamespace(engine=compact_engine,records=records,words=words,
+                           counts=cardinal_counts,ordinary=ordinary,session=session,
+                           scratch=scratch_pool,abi=abi,parking=codec)
+    return _loaded
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/codec.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/codec.py
new file mode 100644
index 0000000000..bf3bd0d5a6
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/codec.py
@@ -0,0 +1,235 @@
+"""Counted native alphabet adapter on current A CodedPort objects.
+
+Every old symbol0..13 is four virtual binary digits, hence twelve physical
+bits. No physical address or backing length selects a runtime instruction.
+The dense hardware below is checker-only; production receives caller ports.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from contextlib import contextmanager
+from binding_sources import activate,need
+
+S=activate();A=S.abi
+
+class SymbolPort:
+    def __init__(self,physical):
+        self.raw=physical;self.port=A.CodedPort(physical)
+
+    def read(self):
+        first=self.port.read()
+        if first==4:return 4
+        value=0
+        for i in range(4):
+            bit=first if i==0 else self.port.read()
+            need(bit in (0,1),'complete binary native symbol')
+            value=2*value+bit;self.port.move(1)
+        for _ in range(4):self.port.move(-1)
+        need(value<14,'native alphabet code')
+        return value
+
+    def write(self,value):
+        need(type(value) is int and 0<=value<14,'native alphabet')
+        for shift in (3,2,1,0):
+            self.port.write((value>>shift)&1);self.port.move(1)
+        for _ in range(4):self.port.move(-1)
+
+    def step(self,direction):
+        need(direction in (-1,1),'unit old-symbol move')
+        if direction==1 and self.port.read()==4:self.write(4)
+        for _ in range(4):self.port.move(direction)
+
+    def rewind(self):
+        self.step(-1)
+        while self.read()!=2:self.step(-1)
+        self.step(1)
+
+    def initialize(self,marker=2,body=(),head=1):
+        # marker/body/head are fixed compilation data, never decoded input.
+        need(self.raw.read()==6,'fresh blank native current segment')
+        self.write(marker)
+        for value in body:self.step(1);self.write(value)
+        for _ in body:self.step(-1)
+        for _ in range(head):self.step(1)
+
+
+_original={name:getattr(S.records.Tape,name) for name in ('__init__','read','write','step')}
+_executing=False
+_patched=False
+
+class OriginHead:
+    """Refine retained completed-head guards by local marker observations.
+
+    The only computational head comparisons in the retained closure are a
+    chained equality of returned heads ending in1. Equal nonorigin positions
+    cannot satisfy that complete guard. No numerical head address is exposed.
+    """
+    def __init__(self,tape):self.tape=tape
+    def restored(self):
+        port=self.tape.native_port
+        port.step(-1);ok=port.read()==2;port.step(1)
+        return ok
+    def __eq__(self,other):
+        if isinstance(other,OriginHead):return self.restored() and other.restored()
+        need(type(other) is int and other==1,'only retained origin-head comparisons')
+        return self.restored()
+
+def install_tape_methods():
+    global _patched
+    if _patched:return
+    def read(tape):
+        if not hasattr(tape,'native_port'):
+            need(not _executing,'unbound native tape during execution')
+            return _original['read'](tape)
+        tape.meter.reads+=1
+        return tape.native_port.read()
+    def write(tape,value):
+        if not hasattr(tape,'native_port'):
+            need(not _executing,'unbound native tape during execution')
+            return _original['write'](tape,value)
+        tape.meter.writes+=1;tape.native_port.write(value)
+    def step(tape,direction):
+        if not hasattr(tape,'native_port'):
+            need(not _executing,'unbound native tape during execution')
+            return _original['step'](tape,direction)
+        tape.native_port.step(direction)
+        tape._observed_head=tape.__dict__.get('_observed_head',tape.__dict__.get('head',1))+direction
+        tape.meter.moves+=1
+    def head(tape):
+        if _executing:
+            need(hasattr(tape,'native_port'),'bound head guard')
+            return OriginHead(tape)
+        return tape.__dict__.get('_observed_head',tape.__dict__.get('head',1))
+    def set_head(tape,value):tape._observed_head=value
+    def cells(tape):
+        need(not _executing and not hasattr(tape,'native_port'),
+             'obsolete host backing is construction-only; inspect supplied physical ports')
+        return tape.__dict__.get('_observer_cells',tape.__dict__.get('cells'))
+    def set_cells(tape,value):tape._observer_cells=value
+    S.records.Tape.read=read;S.records.Tape.write=write;S.records.Tape.step=step
+    S.records.Tape.head=property(head,set_head)
+    S.records.Tape.cells=property(cells,set_cells)
+    _patched=True
+
+@contextmanager
+def collect_tapes():
+    """Record finite allocation sites during template construction only."""
+    tapes=[];old=S.records.Tape.__init__
+    def initialize(tape):
+        _original['__init__'](tape);tapes.append(tape)
+    S.records.Tape.__init__=initialize
+    try:yield tapes
+    finally:S.records.Tape.__init__=old
+
+@contextmanager
+def execution():
+    global _executing
+    need(not _executing,'one active native cohort')
+    _executing=True
+    try:yield
+    finally:_executing=False
+
+class ParkingView:
+    """Only the predecessor's finite completed-baseline guard is exposed."""
+    def __init__(self,owner,index):self.owner=owner;self.index=index
+    def __eq__(self,expected):
+        need(expected in ({},{0:'^'}),'fixed parking baseline comparison')
+        p=self.owner.ports[self.index]
+        if self.index==0:
+            need(expected=={},'empty stack baseline')
+            blank=p.read()==4
+            p.step(-1);at_origin=p.read()==2;p.step(1)
+            return blank and at_origin
+        p.step(-1)
+        marker=p.read();p.step(-1);at_origin=p.read()==2
+        p.step(1);p.step(1)
+        return at_origin and marker==(5 if expected else 4) and p.read()==4
+
+class ParkingAdapter:
+    """The unchanged seven-symbol parking table on two coded local ports.
+
+BankParking's cell accessors are rebound to unit physical operations. Its
+mathematical register and frame algorithms and finite table stay unchanged.
+"""
+    chars=('_','0','1','^','$','F','R')
+    codes=(4,0,1,5,6,7,8)
+    def __init__(self,owner,ports):
+        from types import MethodType
+        self.owner=owner;self.ports=tuple(ports)
+        owner.machine.tapes=[ParkingView(self,0),ParkingView(self,1)]
+        def read(o,k):
+            o.codec_counts['reads']+=1
+            value=self.ports[k].read();need(value in self.codes,'parking alphabet')
+            return self.chars[self.codes.index(value)]
+        def write(o,k,value):
+            need(value in self.chars,'parking write alphabet');o.codec_counts['writes']+=1
+            self.ports[k].write(self.codes[self.chars.index(value)])
+        def move(o,k,direction):
+            need(direction in (-1,1),'parking unit move');o.codec_counts['moves']+=1
+            self.ports[k].step(direction)
+        def command(o,entry):
+            need(o.machine.state=='done','completed parking boundary')
+            o.codec_counts['commands']+=1;o.machine.state=entry
+            while o.machine.state not in ('done','reject'):
+                nxt,writes,moves=o.machine.table[(o.machine.state,read(o,0),read(o,1))]
+                for k in (0,1):
+                    if writes[k] is not None:write(o,k,writes[k])
+                    if moves[k]:move(o,k,moves[k])
+                o.machine.state=nxt
+            need(o.machine.state=='done','matched parking command')
+        for name,fn in (('_read',read),('_write',write),('_move',move),('_command',command)):
+            setattr(owner,name,MethodType(fn,owner))
+
+    def initialize(self):
+        self.ports[0].initialize(2,(),1)
+        self.ports[1].initialize(2,(4,),2)
+
+class Cohort:
+    def __init__(self,tapes,native):
+        install_tape_methods()
+        self.tapes=tuple(tapes);self.native=native
+        self.markers=[]
+        for tape in self.tapes:
+            need(tape.head==1 and tape.cells[0] in (2,4)
+                 and all(x==4 for x in tape.cells[1:]),'compiled blank native baseline')
+            self.markers.append(tape.cells[0])
+        need(native.runtime.numerical.machine.tapes==[{},{}],'closed native parking baseline')
+        self.ports=None
+
+    @property
+    def port_count(self):return len(self.tapes)+2
+
+    def bind(self,ports):
+        need(len(ports)==self.port_count and len(set(map(id,ports)))==len(ports),'exact fixed native inventory')
+        self.ports=tuple(ports)
+        for tape,port in zip(self.tapes,ports):tape.native_port=SymbolPort(port)
+        self.parking=ParkingAdapter(self.native.runtime.numerical,
+                                    tuple(SymbolPort(p) for p in ports[-2:]))
+
+    def start(self):
+        need(self.ports is not None,'native physical ports bound before input')
+        for tape,marker in zip(self.tapes,self.markers):
+            tape.native_port.initialize(marker);tape.head=1
+        self.parking.initialize()
+
+    def finish(self):
+        # Raw A retirement erases every encoded blank and the current-call
+        # high-water body. It stops at fresh physical BLANK, not backing length.
+        for port in self.ports:A.retire(port)
+
+
+class DenseTape:
+    """Independent checker hardware; no runtime routine reads these arrays."""
+    def __init__(self,origin=1):
+        self.cells=bytearray([6]*(origin+1));self.cells[origin-1]=2
+        self.head=origin;self.origin=origin;self.reads=self.writes=self.moves=0
+        self.high=origin
+    def read(self):
+        self.reads+=1
+        return self.cells[self.head] if self.head<len(self.cells) else 6
+    def write(self,value):
+        need(value in range(7),'physical alphabet');self.writes+=1
+        if self.head>=len(self.cells):self.cells.extend([6]*(self.head+1-len(self.cells)))
+        self.cells[self.head]=value;self.high=max(self.high,self.head+1)
+    def move(self,direction):
+        need(direction in (-1,1),'physical unit move')
+        self.head+=direction;self.moves+=1;need(self.head>=0,'physical boundary')
+    def actions(self):return self.reads+self.writes+self.moves
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/provider.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/provider.py
new file mode 100644
index 0000000000..481013b988
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/provider.py
@@ -0,0 +1,189 @@
+"""Current descriptor to retained Compact: a structured finite-control service.
+
+This is an executable source-level refinement, not an emitted A transition
+table. It accepts precisely A's numeric/context port views and fixed blank
+work ports. Runtime numerical values remain in Count tapes throughout.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from contextlib import ExitStack
+from binding_sources import need
+from codec import S,A,Cohort,collect_tapes,execution
+from cardinal_counts import Count,positive
+from compact_counts import power_two,copy_bits,append_bits
+from compact_layout import Layout
+from compact_streams import digit_permutation
+from encoded import compare,subtract
+from records import Tape
+from stream import Counter
+from session import OuterScope,borrowed_count,borrowed_tape,erase_marker,sealed_constructors
+from scratch_pool import ScratchPool
+
+SCHEMA=('outer','rows','stock','row_bits','within_bits','record_bits','p','d','K','G','H',
+        'q0','qF','qB','D','f','rho','active_start','back_start','selected_axes',
+        'entry_start','remainder','cutoff')
+NAMES=('u','u_rest','t','t_rest','before','x','middle','y','after','b')
+
+def scale(value,constant):
+    need(type(constant) is int and constant>=0,'compiled nonnegative multiplier')
+    if constant==0:return Count.literal(0)
+    out=Count(value)
+    if constant>1:out.multiply_small(constant)
+    return out
+
+class Provider:
+    def __init__(self,rank,source_block,target_block,native_factory):
+        need(type(rank) is int and rank>=2,'fixed compiled rank')
+        need(0<=source_block<rank and 0<=target_block<rank and source_block!=target_block,
+             'fixed distinct selected-block pair')
+        self.rank=rank;self.source_block=source_block;self.target_block=target_block
+        self.late=source_block>target_block
+        # native_factory constructs a fixed precompiled Ordinary supplier.
+        # It receives no runtime parameter or payload and is never called again.
+        with collect_tapes() as tapes:
+            native=native_factory()
+            need(type(native) is S.ordinary.Ordinary and native.observe is None
+                 and native.runtime.observe is None,'unchanged ordinary engine without payload callbacks')
+            self.engine=S.engine.CompactEngine(NAMES,'y' if self.late else 'x',
+                                              'x' if self.late else 'y',self.late,native)
+            self.pool=ScratchPool(160);self.scope=OuterScope(self.pool)
+            self.bridge,self.field_guide,self.header_guide,self.length_guide=(Tape() for _ in range(4))
+        self.cohort=Cohort(tapes,native)
+        self.observed_calls=0
+
+    @property
+    def port_count(self):return self.cohort.port_count
+
+    def bind(self,work):self.cohort.bind(work)
+
+    def read_header(self,context):
+        result={}
+        def advance():
+            self.header_guide.append(1);context.move(1)
+        for name in SCHEMA:
+            self.length_guide.rewind()
+            while context.read()==1:
+                self.length_guide.append(1);advance()
+            need(context.read()==0,'self-delimiting current header length');advance()
+            self.length_guide.rewind()
+            value=object.__new__(Count);value.tape=self.pool.acquire()
+            any_digit=multiple=False;last=0
+            while self.length_guide.read()!=4:
+                need(self.length_guide.read()==1,'unary current header length')
+                bit=context.read();need(bit in (0,1),'binary current header digit')
+                multiple=multiple or any_digit;any_digit=True;last=bit
+                value.tape.append(bit);advance();self.length_guide.step(1)
+            need(any_digit and (last==1 or not multiple),'canonical LSF current header value')
+            value.tape.append(3);value.rewind();result[name]=value
+            self.length_guide.clear()
+        need(context.read()==6,'exact current header frontier')
+        self.header_guide.rewind()
+        while self.header_guide.read()!=4:
+            context.move(-1);self.header_guide.step(1)
+        self.header_guide.clear()
+        return result
+
+    def prepare(self,header,cleanup):
+        def own(x):cleanup.callback(x.close);return x
+        for key in ('outer','rows','row_bits','record_bits','f','K','G','H'):
+            positive(header[key])
+        one=own(Count.literal(1));twoH=own(scale(header['H'],2))
+        need(compare(header['rho'],header['K'])<0,'selected offset inside one chunk')
+        n=own(subtract(header['f'],one))
+        compact=own(Count.product(n,header['G']))
+        rest=own(subtract(header['H'],compact))
+        chunk=own(Count.product(header['f'],header['K']))
+        left=own(scale(chunk,min(self.source_block,self.target_block)))
+        right=own(scale(chunk,max(self.source_block,self.target_block)))
+        left.add(header['active_start']);right.add(header['active_start'])
+        before=own(subtract(left,twoH))
+        difference=own(subtract(right,left));middle=own(subtract(difference,chunk))
+        right_end=own(Count(right));right_end.add(chunk)
+        after=own(subtract(header['back_start'],right_end))
+        tail=own(subtract(header['within_bits'],header['back_start']))
+        suffix=own(subtract(tail,compact))
+        # The full reserved back field exists, including its unused suffix.
+        need(compare(tail,header['H'])>=0,'complete root back reservation')
+        reduced=own(subtract(header['K'],one));rho=own(subtract(reduced,header['rho']))
+        fibre=own(power_two(suffix));record=own(Count.product(fibre,header['record_bits']))
+        rows=own(Count.product(header['outer'],header['rows']))
+        full=own(power_two(header['within_bits']));expected=own(Count.product(full,header['record_bits']))
+        need(compare(expected,header['row_bits'])==0,'exact complete physical row length')
+        active=own(scale(header['f'],self.rank));active.add(header['remainder'])
+        need(compare(active,header['selected_axes'])==0,'current f/remainder geometry')
+        rank=own(Count.literal(self.rank))
+        need(compare(header['remainder'],rank)<0,'ordinary remainder below fixed rank')
+        need(compare(header['selected_axes'],header['d'])<=0,'ordinary width within root budget')
+        active_end=own(scale(chunk,self.rank));active_end.add(header['active_start'])
+        need(compare(active_end,header['back_start'])<=0,'complete active block list precedes back field')
+        widths=(compact,rest,compact,rest,before,chunk,middle,chunk,after,compact)
+        return widths,n,rho,record,rows
+
+    def import_field(self,field):
+        while (symbol:=field.read())!=4:
+            need(symbol in (0,1,2),'complete canonical numerical field')
+            for shift in (2,1,0):self.bridge.append((symbol>>shift)&1)
+            self.field_guide.append(1);field.move(1)
+        self.bridge.rewind();self.field_guide.rewind()
+        while self.field_guide.read()!=4:
+            field.move(-1);self.field_guide.step(1)
+        self.field_guide.rewind()
+
+    def export_field(self,field,output):
+        output.rewind();self.field_guide.rewind()
+        while self.field_guide.read()!=4:
+            value=0
+            for _ in range(3):
+                bit=output.read();need(bit in (0,1),'complete returned physical codeword')
+                value=2*value+bit;output.step(1)
+            need(value in (0,1,2),'returned complete numerical record format')
+            need(field.read() in (0,1,2),'returned field has original exact extent')
+            field.write(value);field.move(1);self.field_guide.step(1)
+        need(output.read()==4 and field.read()==4,'exact full-field return frontier')
+        self.field_guide.rewind()
+        while self.field_guide.read()!=4:
+            field.move(-1);self.field_guide.step(1)
+        self.field_guide.clear();output.rewind()
+
+    def single(self,widths,rho,record,rows):
+        """f=1: the actual retained four-bucket bit gate, with no n>0 guard."""
+        e=self.engine;e.rearm();source=borrowed_tape(self.bridge)
+        with sealed_constructors(),e.scope.installed(),ExitStack() as cleanup:
+            plan=Layout(NAMES,widths,record);cleanup.callback(plan.close)
+            remaining=Counter(rows);cleanup.callback(remaining.close)
+            source_bit=plan.bit_position(e.source,rho);cleanup.callback(source_bit.close)
+            target_bit=plan.bit_position(e.target,rho);cleanup.callback(target_bit.close)
+            early=compare(source_bit,target_bit)<0
+            first,second=(source_bit,target_bit) if early else (target_bit,source_bit)
+            mapping=(0,1,3,2) if early else (0,3,2,1)
+            while not remaining.finished:
+                current=e.pool.acquire()
+                copy_bits(source,current,plan.row_bits);current.rewind()
+                following=digit_permutation(current,plan,first,second,mapping,e.pool.acquire)
+                append_bits(following,e.output);following.clear();remaining.decrement()
+                e.calls['rows']+=1
+            need(source.read()==4,'complete f=1 outer-row packet');source.rewind()
+        e.pool.empty()
+        for tape in e.pool.tapes:erase_marker(tape)
+        e.output.rewind();e.closed=True
+        return e.output
+
+    def run(self,field,context):
+        """field=A.CodedPort, context=A.BinaryContextPort; both start at origin.
+
+        The successful-input theorem leaves only field's exact output, context
+        unchanged, and every work port physically blank at its current origin.
+        No interrupted-service rollback contract is claimed.
+        """
+        self.cohort.start()
+        with execution(),self.scope.installed(),ExitStack() as cleanup:
+            header=self.read_header(context)
+            for value in header.values():cleanup.callback(value.close)
+            widths,n,rho,record,rows=self.prepare(header,cleanup)
+            self.import_field(field)
+            with self.scope.suspended():
+                returned=(self.single(widths,rho,record,rows) if n.zero() else
+                          self.engine.run(self.bridge,widths,n,header['K'],header['G'],rho,record,rows))
+            self.export_field(field,returned)
+            returned.clear();erase_marker(returned);self.bridge.clear()
+        self.pool.empty()
+        self.cohort.finish();self.observed_calls+=1
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/DEFERRED-PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/DEFERRED-PROOF.md
new file mode 100644
index 0000000000..de725a73e9
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/DEFERRED-PROOF.md
@@ -0,0 +1,122 @@
+# The selected uniform tree and deferred stock
+
+DLamdata, with substantial OpenAI Codex assistance. Apache-2.0.
+This is a conditional source-bound specialization, not a new deferred-reservoir method or supplier admission.
+
+## 1. Sources and the precise implication
+
+PR6110 at `7f82486e987e556a221085092d8f7aff271ecb35` asks for an audit of PR1673's `SUPPLIER-SUPPORT-AUDIT.md` §6. That older source replaces eager transformation of reserved axes by deferred phases at `K=128G`. The selected manifest binds its `bd5b06...` copy. A later PR1673 `review20261014/REVIEW-RESPONSE.md` §2 already writes the mixed T74 tree and full product-stock argument; its different bytes are an attributed predecessor, not the selected copy.
+
+More directly, the selected manifest binds `research/kappa-rebuild/transfer-audit/OUTER-TRANSFER-AUDIT.md` §5 and `FINITE-TEMPLATE-CLOSURE.md` §§2,5,6. Those sources already give the changed **uniform** supplier, sublinear BIT stock, deferred reservations and per-phase padding deletion. The present result supplies the exact PR6030 substitution and an explicit threshold certificate. It does not discover a missing proof of the generic mechanism. The strong-induction formulation also follows the credited PR4100 audit in `research/complex-stopped-recursion-cost/PROOF.md`; that different supplier is not rerun.
+
+Hereafter `U` denotes the selected uniform saving (not the historical source's mixed-unit count), `N=2^H` its fixed rank, `W` its productive fields and `P` its paid rank-one calls. The retained compiler contract is
+
+    P/W < N^(1-U).
+
+All of `N,W,P` are fixed before the eventual input size grows. They are not the raw mixed P104 productive-field count or raw paid-call histogram. At an ordinary width `e=Nf+r`, `0<=r<N`, each paid child has width `f=floor(e/N)` and volume `v/W`; all `P` children are counted, including those acting on owned fields. Thus the normalized child moment is
+
+    mu_x = (P/W) N^(-x).
+
+This is the explicit ordinary contract in `FINITE-TEMPLATE-CLOSURE.md` §§2,5,6 and `architecture/FINITE-PRECOMPILATION.md` §6. The selected review applies its compiler to PR6030. This audit assumes that compiler and physical contract; a rational check of its parameters is not a new proof of integer batching, native operators or tape implementation.
+
+## 2. Exact selected substitution
+
+The pinned PR6030 `RESULT.json` supplies
+
+    H = 65807000000000, d = 1/1400000000,
+    U = kappa+6d, b = kappa+5d, a = kappa+4d, q = kappa+3d,
+    eta = stop = d, alpha = BIT atom = 1/250,
+    sigma = 1-b, tau = 1-a, lambda_prime = 1-q,
+    gamma = sigma+eta*b = 1-(1-eta)*b.
+
+Here `eta` is the stopping exponent; the outer group exponent named `beta` is a different parameter. Every displayed equality and the following margins are checked with exact rationals:
+
+| Quantity | Exact value |
+| --- | --- |
+| `H*(U-b)` | `47005` |
+| `H*(U-a)` | `94010` |
+| `tau-sigma` | `1/1400000000` |
+| `lambda_prime-tau` | `1/1400000000` |
+| `tau-gamma` | `6978119347/9800000000000000000` |
+| `lambda_prime-gamma` | `13978119347/9800000000000000000` |
+
+Consequently
+
+    mu_sigma < 2^-47005 < 1,
+    mu_tau   < 2^-94010 < 1.
+
+These are compressed upper bounds, not equality claims for the unknown materialized `P/W`. They follow from the retained normalized compiler bill; no gigantic `N` or word is constructed. In particular `1/(1-mu_tau)<2`. This small contraction factor does **not** bound the enormous other fixed implementation constants.
+
+## 3. One phase, including integer widths
+
+Fix a phase width `h>=1`, a root active width `e<=h`, and `s=max(N,h^eta)`. All descendants use this same phase cutoff. Stop when `e<=s`. For integer positive `e`, assume:
+
+- a leaf costs at most `c_L v e`;
+- an internal node's own work, including its fewer than `N` elementary remainder kernels, is at most `c_N Lambda(p) v e^tau`;
+- its `P` children have width `floor(e/N)` and volume `v/W`; costs add with the same constants;
+- `Lambda(p)>=1` is one fixed polylogarithm, uniform over nodes and phases.
+
+The internal premise absorbs at most `(N-1)c_L v` remainder work into `c_N`, since `e^tau>=1`. It includes local parking, owned storage, monomial adapters, restoration and actual movement; those are inherited physical obligations, not asserted free.
+
+Use a weighted-tree potential, independently of the induction used by the separate checker. For an exponent `x>0`, put node mass `v e^x`. Floor contraction implies that its children's total mass is at most `mu_x` times its own. Therefore the total `tau`-mass at depth `j` is at most `mu_tau^j v e^tau`, even after leaves stop. Summing the strict geometric series bounds all internal tolls by
+
+    c_N Lambda(p) v e^tau/(1-mu_tau).
+
+For the leaf term, replacing an internal frontier node by its children cannot increase total `sigma`-mass, because `mu_sigma<=1`. Repeating this replacement on the finite stopped tree gives leaf mass at most `v e^sigma`. Each leaf has width at most `s`, so `e_leaf <= s^b e_leaf^sigma`. Thus
+
+    T(e,v) <= v [c_N Lambda(p)/(1-mu_tau) e^tau + c_L s^b e^sigma]. (1)
+
+The tree is finite because every internal child has positive width `floor(e/N)<e`. No equal-depth assumption or monotonicity of the cost function is used. Zero-width active calls cost nothing and may be omitted. Since `s^b<=N^b h^(eta*b)`, (1) at `e<=h` implies
+
+    T(e,v) <= v Lambda(p) [c_N/(1-mu_tau) h^tau + c_L N^b h^gamma].   (2)
+
+Both exponents are strictly below `lambda_prime`. The endpoint `e=s`, widths below `N`, and every remainder are covered. Choosing a larger finite elementary base threshold changes `N^b` in this bound to that base threshold's `b`-power, not the exponent.
+
+## 4. Actual BIT atom and an explicit deferred threshold
+
+The historical transfer audit's `0.003` atom cannot be copied numerically. The selected ordinary BIT atom is `alpha=1/250`. Retain the same stock contract, now `log S(e)=O(e^alpha log e)` (an inherited BIT implementation premise). A BIT call has width `O(h (log p)^2)`. For `1<=h<=p` and a further `O(log h)` nesting factor, its logarithmic product stock is `O(h^alpha L^(2alpha+2))`, where `L=max(1,ceil(log2 p))`. Because `alpha<1/2`, this is bounded by `O(h^alpha L^3)`. Complex row stock is `O(log h)`. Taking a product adds logarithmic stocks; replacing that product by a maximum is not justified.
+
+Choose one fixed `C>=1`, independent of `h,p`, that covers these constants and complete-chunk rounding. The conservative reservation premise is
+
+    R(h,p) <= 3h/128 + C*(log2 h + h^alpha L^3 + 1).          (3)
+
+An internal-stock implementation can use less. This audit does not numerically materialize `C`; its finiteness and the local stock law remain part of the inherited physical/compiler contract.
+
+Here is an explicit sufficient threshold, for any additional fixed finite base threshold `M>=1`:
+
+    H0(p) = ceil(max(M, 16, (192C)^2, (192C L^3)^(250/249))). (4)
+
+For `h>=16`, `log2 h+1<=2 sqrt(h)`. Indeed it holds at 16, and the derivative of `2 sqrt(h)-log2 h-1` is positive there and beyond. For `h>=H0`, therefore,
+
+    C*(log2 h+1) <= h/96,
+    C*h^(1/250)*L^3 <= h/192.
+
+The latter is exactly the threshold inequality `h^249 >= (192C L^3)^250`. Hence the excess in (3) is at most `h/64`, and
+
+    R(h,p) <= 5h/128 < h/16.                               (5)
+
+The degree of this explicit tail bound is `750/249=250/83` in `L`. All fixed constants, including those of the enormous uniform word, affect its coefficient and `M`. This is not a practical or numerically emitted PR6030 cutoff.
+
+## 5. Completed layer and the removed hypothesis
+
+At phase width `h`, expose complete selected neighborhoods in the **global complete tensor**, reserve `R` chunks, execute the ordinary active call, and return every reserved/spectator coordinate unchanged. Do not first transform reserved selected bits. The next phase acts only on those `R` selected bits. Exposure and restoration cost `O(V Lambda(p) h^tau)` under the retained support router.
+
+One phase pads its row count by a factor below two. Its complete endpoint is identity on the row coordinate, so appended zero rows return to zero and can be deleted **before** inverse placement and the next phase. Thus each phase volume is below `2V`; it is not `2^j V` at phase `j`. Exact return is an explicit premise: this argument does not authorize dropping rounded nonzero rows or clear residual errors for free.
+
+Above (4), successive widths obey `h_(j+1)<=h_j/16`. With `l=lambda_prime>1/2`,
+
+    sum_j h_j^l <= g^l/(1-16^(-l)) <= (4/3) g^l.
+
+By (2), `tau<l`, `gamma<l` and `h>=1`, all active-phase work, padding and exposure sum to `O(V Lambda(p) g^(1-q))`. The remaining at most `H0(p)` selected bits cost `O(V H0(p) polylog p)` elementarily. Since `g>=1` and (4) is polylogarithmic, the full result is
+
+    T_layer(g,V,p) = O(V g^(1-q) polylog p),  1<=g<=p, under the stated contracts.       (6)
+
+The cost implication is uniform over those roots **when the complete-layout and router premises hold**. It does not construct geometric support for every `g<=p`: the selected caller uses polynomially sublinear `g=Theta(p^beta)` with `beta<epsilon<1`, so its `O(g log^2 p)` reservoirs and complete neighborhoods fit eventually. In particular, this audit does not grant that geometry at `g=p` in a `Theta(p)`-bit address.
+
+The original `d^max(1-c,0)` term prices eager transformation of reserved axes with the old power-width choice of `K`. Equations (3)–(6) replace that operation. They neither choose a positive `c` for logarithmic `K` nor instantiate the old theorem literally. At polynomially growing outer group widths, the strict exponent margins absorb any fixed polylogarithm after a new eventual threshold. Arbitrarily small `g` is covered by the explicit polylog factor in (6).
+
+## 6. Boundary of the conclusion
+
+The exact selected arithmetic and conditional potential/threshold argument pass. The source-selected uniform contract, complete global fields, fresh product stock, support router, node-local tape bill, exact return/padding deletion, native all-column behavior, owned erasure and analytic recovery remain inherited. No complete selected replay, rounded multiplier, materialized uniform word or physical compiler proof is supplied. In particular this resolves the cost implication under those contracts, not all five selected framework assumptions.
+
+The added value is a current-source answer to PR6110: cite the already-selected finite-template/outer-transfer sources, use the compiled uniform tree, record the compressed moment witnesses, and replace the historical stock atom. It is not a new kappa or a correction to the selected frontier.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/SELECTED-RESULT.json b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/SELECTED-RESULT.json
new file mode 100644
index 0000000000..d59b5035e7
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/SELECTED-RESULT.json
@@ -0,0 +1,120 @@
+{
+  "status": "Selected maintainer-reviewed conditional P104 twin-rung construction with full primary and independent application audits",
+  "kappa": "781451/250000000",
+  "decimal": "0.003125804",
+  "source_prs": [
+    6030,
+    5907,
+    5827,
+    5811,
+    5960,
+    5599,
+    5565,
+    5580,
+    5569,
+    5561,
+    5551,
+    5545,
+    5544,
+    5550,
+    5567,
+    2305,
+    2152,
+    2219,
+    5398,
+    5400,
+    4610,
+    5241,
+    4470,
+    4447,
+    4441,
+    4440,
+    4416,
+    4433,
+    4359,
+    4268,
+    3945,
+    4085,
+    2979,
+    4076,
+    4088,
+    1673,
+    1758,
+    1786,
+    23,
+    555,
+    589
+  ],
+  "source_manifest": "certificates/frontier6030-source.json",
+  "certificate": "certificates/frontier6030/CLAIM.json",
+  "certificate_sha256": "9cee8a1304fa893be3d3b641eda42fdd9b2fd6a5ac2124fb891de7a1a5e8d92e",
+  "proof": "docs/research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md",
+  "proof_supplements": {
+    "notes/batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c",
+    "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c",
+    "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6",
+    "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54",
+    "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a",
+    "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511",
+    "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8",
+    "references/semantic-bulk/pr23/semantic-bulk-17-note.tex": "652242b05174bb776ffc6165af170df9c8cf220dbd0fc26c24d778f320dbabc8",
+    "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3",
+    "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca",
+    "research/e8-bit-p111-tuned/code/gen_p3.py": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd",
+    "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "research/e8-bit-p111-tuned/tune/apply.py": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1",
+    "research/e8-bit-p111-tuned/tune/wlib.py": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc",
+    "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962",
+    "docs/research/pr-intake-evidence/pr4359/PROOF-REVIEW.md": "7d67bb814285f7634029fbd378c6457156545f0b38858cc1c6ec34b68cd9d162",
+    "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md": "5c111dd56beb53dc44ab727d96e1af03aaf50f3023d4342e2b0a89ede6cf585b",
+    "docs/research/pr-intake-evidence/pr4416/PROOF-REVIEW.md": "2c2bbe6fe1bab44778192118f27e59a0d23dbe02c47aa8a42845093f1ce46f49",
+    "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md": "b84f833e3072cbab372fbda2ece98fbc031c15e590cf73003ddea35a5222e148",
+    "research/final4610-independent-admission/PROOF.md": "e573cbbe6fa5481c0533e773de404e10f4dc7907b5ebfe404bdcd02dcf9844d8",
+    "research/final4610-independent-admission/SPECIALIZATION.md": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c",
+    "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md": "7688e5d8bf40fcdfb5bea43ba47e1f8d60a77a91ede6c307bb8163a9a7e16b3f",
+    "research/p104-helper-subspace-splits/PROOF.md": "f4c68acf9373e34d88e14e1a7791b4b739c8b5297a1ae4c0121f579a02fde04e",
+    "research/p104-productive-controller/PROOF.md": "f4c4e400092954562252df6c4dd157a9b4c1642252168ce72738cdbecfc5ad41",
+    "research/p104-caller-independent-audit/PROOF.md": "d73ff9587a85db8063391919ffc4a17521ccd5759cdaf6338ba036703239d839",
+    "research/p104-free-endpoint-contract-audit/PROOF.md": "43aeae1c090b5657f326fd7c56a5e5fbe062db29591b660a903305ca58ce9598",
+    "docs/research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md": "8bd158b8ef68202000f167b9b78db0b31531b5b067b5cbd91b5bf35f3ddd1ab6",
+    "research/higher-moment-strictification/README.md": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d"
+  },
+  "review": "docs/research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md",
+  "validation": "docs/research/pr-intake-evidence/pr6030-audit/VALIDATION.json",
+  "integration": "docs/research/pr-intake-evidence/pr6030-audit/INTEGRATION.json",
+  "reproduce": "make frontier6030-verify",
+  "scope": "Conditional P104 helper-470 rung removal on the cumulative P104 construction and all-forward productive caller. The five inherited framework assumptions remain; no materialized uniform word or complete rounded multiplier.",
+  "previous_kappa": "62009/20000000",
+  "previous_record": "certificates/checkpoints/frontier5599.json",
+  "audited_source_head": "772dd10a5859a1d15f4851feb371519789213ad8",
+  "source_certificate": "research/p104-helper470-twin-rung-removal/RESULT.json",
+  "source_certificate_sha256": "84fcbe2a0b64307b5703c363408042bdd91555b0419509aa50daa43b3b1924ad",
+  "replay_mode": "Exact-source macOS/Linux primary evidence reused; fresh bounded macOS independent full-word/invoice/new-native checks, original caller positive control, candidate caller and optimized primary. Five framework assumptions retained.",
+  "contributors": "docs/research/community-p1046030-contributors.md",
+  "assumptions": [
+    {
+      "id": "native_all_columns",
+      "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity."
+    },
+    {
+      "id": "owned_erasure",
+      "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts."
+    },
+    {
+      "id": "compiler",
+      "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract."
+    },
+    {
+      "id": "precision_tape",
+      "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template."
+    },
+    {
+      "id": "analytic_recovery",
+      "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework."
+    }
+  ],
+  "audit_pr": 5550,
+  "audit_head": "6125c07ae8ba4b8550e2a0a28a2c6be503153059",
+  "repaired_source_head": "746ee5e1160ae64a15a81b2a432d5566142db850"
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/TASK-CATALOG.json b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/TASK-CATALOG.json
new file mode 100644
index 0000000000..3404fbdd5e
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/TASK-CATALOG.json
@@ -0,0 +1,1281 @@
+{
+  "schema_version": 1,
+  "priority_revision": 8,
+  "priority_log": "docs/research/research-priority-log.md",
+  "assessed_on": "2026-10-26",
+  "status": "Research suggestions, not reservations or assertions that these questions are unclaimed. Check current main and live PRs.",
+  "tracks": [
+    {
+      "id": "bit-mechanisms",
+      "weight": 20,
+      "tasks": [
+        {
+          "id": "bit-helper-contract",
+          "question": "Can a changed G20 helper path or independent-target split improve the complete BIT moment without losing its physical endpoint?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+            "research/g20-helper-split/README.md",
+            "research/g20-conjugation-admission/README.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "First read #5679/#5708 and their audits as pending component proposals. Choose one uncovered helper group/cut on an exact word; compare arbitrary-input native action, targets, owned storage, both orientations and full signed bill. Stop if the gain is only a scalar count or repaid by lost targets. Do not rerun the frozen #5609 common-frame domain without changing its hypothesis.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "G20",
+            "helper split",
+            "5679",
+            "5708",
+            "independent target"
+          ],
+          "existing_checks": [
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "bit-new-register-model",
+          "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?",
+          "starting_points": [
+            "docs/research/research-family-status.md",
+            "research/bit-three-register-lower-bound/README.md",
+            "certificates/selected-result.json",
+            "research/bit-gl3-mixed-targets-length10/README.md",
+            "docs/research/community-efficient1000-review.md"
+          ],
+          "methods": [
+            "Construct the smallest exact identity in a newly specified legal operation alphabet.",
+            "Derive a target-specific relaxation bound for that same explicit alphabet."
+          ],
+          "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.",
+          "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.",
+          "allowed_variations": [
+            "Choose a fixed larger register count or a specified nonabelian operation family."
+          ],
+          "scope_change_triggers": [
+            "Remaining inside the already-excluded three-register abelian model.",
+            "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result."
+          ],
+          "overlap_terms": [
+            "three-register",
+            "nonabelian",
+            "group algebra"
+          ]
+        },
+        {
+          "id": "r437-carrier-integration",
+          "question": "Can the paid R437 two-window carrier improvement be admitted by the actual pooled compiler and physical caller?",
+          "starting_points": [
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "research/r437-two-window-carrier/README.md",
+            "research/r437-reverse-row-coefficient/README.md"
+          ],
+          "methods": [
+            "Close one compiler/request, caller or precision/stock implication for the pinned paid exchange.",
+            "Falsify that exact interface with an arbitrary-dirty-state or chronology counterexample."
+          ],
+          "acceptance_gate": "Pin the complete source and destination contracts, exact paid and scalar deltas, and all remaining assumptions. A local moment gain is not a physical or all-size supplier admission.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Choose one unclaimed obligation: pooled compiler codebook/request alignment, actual physical caller, or precision/stock envelope using the already reported reverse coefficient. Pin the input and receiver, preserve dirty/source windows, and test one binding with a rejection control. Stop at unresolved dependencies; do not rederive the coefficient or quote the local moment as a completed bound.",
+          "bottleneck_link": "The exchange changes the paid profile; integration must establish that its gain survives the complete caller.",
+          "allowed_variations": [
+            "One compiler rebind, one actual caller boundary, or one precision/stock implication."
+          ],
+          "scope_change_triggers": [
+            "Ignoring added ADDs, retaining an obsolete reverse coefficient, or declaring global admission from the local histogram."
+          ],
+          "overlap_terms": [
+            "R437",
+            "two-window carrier",
+            "4067",
+            "4147",
+            "pooled compiler",
+            "request alignment",
+            "reverse row coefficient"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4067: source-bound two-window carrier with (2,2) to (1,3) paid exchange and fixed OQ4 host.",
+              "evidence": "research/r437-two-window-carrier/README.md",
+              "remaining": "Pooled compiler/request rebind, physical caller and precision/stock admission.",
+              "status": "author-checked",
+              "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4147: reverse row coefficient follow-up.",
+              "evidence": "research/r437-reverse-row-coefficient/README.md",
+              "remaining": "Use the exact coefficient in a caller-bound precision/stock proof rather than repeat the arithmetic.",
+              "status": "author-checked",
+              "source_commit": "72e7bb797adf82aeb525a399f56ab8adbab8e93c",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "complex-mechanisms",
+      "weight": 20,
+      "tasks": [
+        {
+          "id": "p104-side-correction",
+          "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+            "research/p104-helper-subspace-splits/README.md",
+            "research/dyadic-helper-channel-capacity/README.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "P104",
+            "helper basis",
+            "helper split",
+            "5718",
+            "dyadic capacity"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4133: literal-slot defect",
+              "evidence": "research/p104-literal-slot-defect/README.md",
+              "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+              "status": "author-checked",
+              "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4136: uniform commutation gap",
+              "evidence": "research/p104-uniform-commutation-gap/README.md",
+              "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+              "status": "author-checked",
+              "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4140: uniform encoding gap",
+              "evidence": "research/p104-uniform-encoding-gap/README.md",
+              "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+              "status": "author-checked",
+              "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance",
+              "evidence": "research/p104-source-chart-shortcut/README.md",
+              "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+              "status": "author-checked",
+              "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4154: fiber-tag seam mismatch",
+              "evidence": "research/p104-fiber-tag-seam/README.md",
+              "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+              "status": "author-checked",
+              "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "complex-rank-shape-decoder",
+          "question": "Can a legal decoder or coframe change improve the full signed moment, including changed helper targets?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+            "docs/research/recursive-invoice-preflight.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Price one complete changed itinerary with both paid and productive histograms. Check #5693/#5698 for overlap and their exact hypotheses before another coframe search. Use the signed invoice preflight where its boundary contract agrees; an inconclusive concave comparison is not a power crossing. Stop if an optimistic complete budget fails at the chosen target or native delivery remains unspecified.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "coframe",
+            "signed moment",
+            "5693",
+            "5698"
+          ],
+          "existing_checks": [
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "complex-new-helper-inventory",
+          "question": "Can a changed helper inventory earn productive credit that survives completion, compilation and the actual caller?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Specify all arbitrary inputs, owned fields, restored outputs and a physically legal consumer. Compare complete P and T, including target debits and precision/stock costs. #5599 is a positive control for target refinement, not permission to split every helper for free. #5614 is a hypothetical compiler budget, not an emitted 145-split word. Stop at the first unpaid boundary or a failing optimistic full bill.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "productive helper",
+            "target refinement",
+            "5599",
+            "5614"
+          ],
+          "existing_checks": [
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "recursive-interfaces",
+      "weight": 20,
+      "tasks": [
+        {
+          "id": "joint-query-controller",
+          "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "query demand",
+            "active mode",
+            "5720",
+            "5745",
+            "5747",
+            "caller"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.",
+              "evidence": "research/qq16-caller-install/README.md",
+              "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.",
+              "status": "author-checked",
+              "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "centre-path-sharing",
+          "question": "Can a specified persistent boundary eliminate a repeated centre operation in the current caller?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Write a two-call input/output contract on the current source word, including arbitrary centre baselines and every later read. Price producer, retention, native alignment and restoration jointly. Historical 64-per-call and 1.90x figures are not current budgets. Stop if a missing consumer or restored-input obligation consumes the saving; reopen only with a changed legal boundary.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "centre path",
+            "persistent boundary",
+            "dirty recoding"
+          ],
+          "existing_checks": [
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "coverage-law-change",
+          "question": "Can a completed call earn more independent productive target credit without an offsetting paid bill?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Use #5599 as a completed positive control, then choose one uncovered cut/module beyond an applicable frozen exclusion. Derive independence, saturation and chronological availability rather than counting rational rank alone. Price target credits and all new jobs together, then check compiler and actual caller compatibility. Stop on a nonphysical credit or an unfavorable complete relaxation.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "target credit",
+            "helper split",
+            "coverage law"
+          ],
+          "existing_checks": [
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "connector-alphabet-change",
+          "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?",
+          "starting_points": [
+            "docs/research/research-family-status.md",
+            "research/universal-connector-boundary/README.md",
+            "certificates/selected-result.json"
+          ],
+          "methods": [
+            "Construct and charge a legal extra operation on a minimal instance.",
+            "Prove a target-specific bound after adding one specified operation family."
+          ],
+          "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "research/universal-connector-boundary/verify.py"
+            ],
+            "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY",
+            "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.",
+            "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+          },
+          "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.",
+          "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.",
+          "allowed_variations": [
+            "Choose one additional operation and a small source count for its first counterexample."
+          ],
+          "scope_change_triggers": [
+            "Keeping the alphabet and only increasing the source count; record this as a changed assignment.",
+            "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions."
+          ],
+          "overlap_terms": [
+            "universal connector",
+            "source-toggle",
+            "connector alphabet"
+          ]
+        }
+      ]
+    },
+    {
+      "id": "adversarial-audit",
+      "weight": 15,
+      "tasks": [
+        {
+          "id": "selected-stock-envelope",
+          "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?",
+          "starting_points": [
+            "research/selected-bootstrap-stock-audit/README.md",
+            "research/bootstrap-cutoff-time-space-split/README.md",
+            "certificates/selected-result.json",
+            "docs/research/community-efficient1000-review.md",
+            "research/stock-margin-chain/README.md"
+          ],
+          "methods": [
+            "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.",
+            "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope."
+          ],
+          "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.",
+          "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.",
+          "allowed_variations": [
+            "One stage or one explicit reserve/depth implication.",
+            "An independently checked same-domain proof repair, retaining all remaining assumptions."
+          ],
+          "scope_change_triggers": [
+            "Importing the historical 57604 or 252 allowance without a selected-producer binding.",
+            "Calling a conditional fit lemma a full outer-proof adoption.",
+            "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality."
+          ],
+          "overlap_terms": [
+            "selected stock",
+            "stock envelope",
+            "bootstrap cutoff",
+            "1956",
+            "1965",
+            "1990",
+            "2972",
+            "stock-margin-chain",
+            "actual_stock_coefficient"
+          ],
+          "existing_checks": [
+            {
+              "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.",
+              "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation",
+              "remaining": "Derive one actual reserve/depth coefficient from the selected producer.",
+              "status": "reviewed",
+              "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            }
+          ]
+        },
+        {
+          "id": "supplier-boundary-audit",
+          "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "supplier admission",
+            "5717",
+            "5719",
+            "5708",
+            "owned lifetime"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.",
+              "evidence": "research/staged544-mixed-fourth-entry/README.md",
+              "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.",
+              "status": "author-checked",
+              "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #3801: successor scatter-boundary decision package.",
+              "evidence": "research/scatter-boundary-decision/README.md",
+              "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.",
+              "status": "author-checked",
+              "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "uniform-transfer-audit",
+          "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "native_all_columns",
+            "owned_erasure",
+            "compiler",
+            "precision_tape",
+            "analytic_recovery"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+              "evidence": "research/unconditional-batched-crt/README.md",
+              "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+              "status": "author-checked",
+              "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "census-pruning-audit",
+          "question": "Does the reported word-census parity-pruning error invalidate a specific exclusion we still rely on, and what bounded repair is justified?",
+          "starting_points": [
+            "research/f7-weight-parity-census-correction/README.md",
+            "docs/research/research-family-status.md"
+          ],
+          "methods": [
+            "Independently reconstruct the tiny counterexample and trace one affected exclusion to its exact pruning code.",
+            "Compare corrected and unpruned enumeration on a small exhaustive domain, then audit the changed pruning implication."
+          ],
+          "acceptance_gate": "Pin the old and proposed corrected engines, distinguish a disproved pruning rule from a disproved final bound, and state exactly which downstream exclusions need revalidation. #2973 is an author-checked source archive; neither its new f(7) claim nor all old conclusions are automatically accepted or rejected.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Reconstruct the eight prefix states of 01021323 and compare bit-0 versus Hamming-weight parity budgets independently. Trace the reported false prune to one pinned predecessor (#2542, #2634 or #2691), then test a small exhaustive domain. Stop after a source-impact handoff or corrected-prune proof; a full seven-label replay needs a separate resource budget and a named research decision it can change.",
+          "bottleneck_link": "An unsound exclusion can wrongly close a mechanism; correcting its dependency boundary is more useful than extending the same census.",
+          "allowed_variations": [
+            "One predecessor pruning rule, one independently exhaustive small domain, or one downstream dependency audit."
+          ],
+          "scope_change_triggers": [
+            "Launching a larger census before validating the prune and explaining which active decision it changes.",
+            "Treating a small-domain counterexample to the old rule as a counterexample to every reported seven-label bound."
+          ],
+          "overlap_terms": [
+            "2973",
+            "2542",
+            "2634",
+            "2691",
+            "weight parity",
+            "bit-0",
+            "01021323",
+            "census pruning"
+          ]
+        }
+      ]
+    },
+    {
+      "id": "independent-verification",
+      "weight": 10,
+      "tasks": [
+        {
+          "id": "independent-moment",
+          "question": "Does a changed construction's serialized target/paid invoice independently support its claimed improvement?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+            "docs/research/recursive-invoice-preflight.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Independently recount one changed emitted word and its complete caller, importing no constructor or pricing engine. Include target losses, owned lifetimes, native orientation and extra charges. Check existing #5633/#5708/#5717/#5719 coverage to avoid duplicate audits and preserve its exact head. Stop after the chosen missing implication; a correct root alone is not supplier admission.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "invoice",
+            "signed moment",
+            "productive target",
+            "independent recount"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.",
+              "evidence": "research/staged544-mixed-fourth-entry/README.md",
+              "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.",
+              "status": "author-checked",
+              "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.",
+              "evidence": "research/staged-fourth-mixture-ceiling/README.md",
+              "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.",
+              "status": "author-checked",
+              "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.",
+              "evidence": "research/r437-two-window-carrier/README.md",
+              "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.",
+              "status": "author-checked",
+              "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "formal-interface-lemma",
+          "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?",
+          "starting_points": [
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "research/gate-operand-parity-lean/README.md",
+            "research/staged544-certified-endpoint/README.md",
+            "research/unconditional-batched-crt/README.md"
+          ],
+          "methods": [
+            "Formalize a missing boundary lemma identified by the selected review.",
+            "Audit a formal theorem-to-certificate binding independently."
+          ],
+          "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.",
+          "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.",
+          "allowed_variations": [
+            "Narrow to one formal lemma or one theorem-to-certificate binding."
+          ],
+          "scope_change_triggers": [
+            "Formalizing already-covered arithmetic and claiming the full multiplication theorem."
+          ],
+          "overlap_terms": [
+            "hyperplane end",
+            "formal interface",
+            "Lean binding",
+            "3807",
+            "3857",
+            "4100",
+            "gate-operand-parity-lean",
+            "staged544-certified-endpoint",
+            "unconditional-batched-crt"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #3807: scoped gate-operand parity formalization.",
+              "evidence": "research/gate-operand-parity-lean/README.md",
+              "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.",
+              "status": "author-checked",
+              "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #3857: certified real-power moment/endpoint arithmetic.",
+              "evidence": "research/staged544-certified-endpoint/README.md",
+              "remaining": "Uniform algorithmic implications, not another endpoint digit.",
+              "status": "author-checked",
+              "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4100: compact-switch formalization proposed as future validation.",
+              "evidence": "research/unconditional-batched-crt/README.md",
+              "remaining": "Audit the statement and assumptions before a formal proof campaign.",
+              "status": "author-checked",
+              "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "verifier-engineering",
+      "weight": 8,
+      "tasks": [
+        {
+          "id": "replay-runtime",
+          "question": "Can one measured replay bottleneck be sped up without dropping coverage?",
+          "starting_points": [
+            "scripts/run_isolated_tests.py",
+            "scripts/verify_replay_coverage.py",
+            "certificates/selected-result.json"
+          ],
+          "methods": [
+            "Profile one isolated replay and optimize the measured bottleneck.",
+            "Design source-bound reuse with explicit dependency invalidation and negative controls."
+          ],
+          "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.",
+          "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.",
+          "allowed_variations": [
+            "Profile one stage or design one source-bound cache boundary."
+          ],
+          "scope_change_triggers": [
+            "Skipping coverage or comparing different fixtures to claim speedup."
+          ],
+          "overlap_terms": [
+            "replay runtime",
+            "cache invalidation",
+            "isolated tests"
+          ]
+        },
+        {
+          "id": "portable-replay",
+          "question": "Can one reproducible environment or artifact-comparison failure be repaired?",
+          "starting_points": [
+            "research/gzip-container-reproducibility/README.md",
+            "docs/ci-verification.md"
+          ],
+          "methods": [
+            "Reproduce one portability failure and add a minimal cross-environment fix.",
+            "Audit one canonical-payload comparison for omitted proof-relevant fields."
+          ],
+          "acceptance_gate": "Preserve immutable source hashes and proof-relevant content; a different compressed byte stream alone is not a mathematical mismatch.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Reproduce one specific mismatch or audit one canonical comparison for omitted proof-relevant fields.",
+          "bottleneck_link": "Portable exact checks prevent environment failures from blocking valid contributions.",
+          "allowed_variations": [
+            "One interpreter/version mismatch or one payload field comparison."
+          ],
+          "scope_change_triggers": [
+            "Removing immutable-source pins because generated compressed bytes differ."
+          ],
+          "overlap_terms": [
+            "gzip container",
+            "reproducibility",
+            "canonical payload"
+          ]
+        }
+      ]
+    },
+    {
+      "id": "consolidation",
+      "weight": 5,
+      "tasks": [
+        {
+          "id": "overlap-receipt",
+          "question": "What exact content and credit of a small named PR set has already been retained?",
+          "starting_points": [
+            "docs/research/pr-ledger.md",
+            "CONTRIBUTORS.md"
+          ],
+          "methods": [
+            "Compare exact heads and retained artifacts to write a source-bound disposition receipt.",
+            "Audit an existing receipt for missing content or predecessor attribution."
+          ],
+          "acceptance_gate": "Separate complete integration, partial retention and changed heads; make no autonomous closures.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Compare that set to retained artifacts; produce a complete or explicitly partial disposition receipt.",
+          "bottleneck_link": "Reliable overlap evidence preserves credit and prevents repeated review of already-retained material.",
+          "allowed_variations": [
+            "One small related PR family or one existing integration receipt."
+          ],
+          "scope_change_triggers": [
+            "Treating matching titles or one shared blob as proof of full incorporation."
+          ],
+          "overlap_terms": [
+            "overlap receipt",
+            "partial integration",
+            "attribution"
+          ]
+        },
+        {
+          "id": "scope-navigation",
+          "question": "Can one misleading historical-current claim or missing research cross-reference be corrected?",
+          "starting_points": [
+            "docs/research/current-status.md",
+            "docs/research/pr-ledger.md",
+            "certificates/selected-result.json"
+          ],
+          "methods": [
+            "Trace one confusing path from onboarding to its authoritative source.",
+            "Index one tightly related family of obstructions with explicit excluded and open hypotheses."
+          ],
+          "acceptance_gate": "Produce evidence-backed navigation, preserve historical records and avoid a duplicate global survey.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+            "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+          },
+          "first_experiment": "Repair one confusing path or produce a scoped map of one related obstruction family.",
+          "bottleneck_link": "Clear navigation lowers entry cost for central research; a global survey without a concrete fix is not required.",
+          "allowed_variations": [
+            "One historical-current ambiguity or one bounded family index."
+          ],
+          "scope_change_triggers": [
+            "Rewriting frozen scientific packages just to change their historical wording."
+          ],
+          "overlap_terms": [
+            "current status",
+            "historical checkpoint",
+            "scope navigation"
+          ]
+        }
+      ]
+    },
+    {
+      "id": "incumbent-optimization",
+      "weight": 2,
+      "tasks": [
+        {
+          "id": "selected-packing",
+          "question": "Is there meaningful uncovered packing headroom for an exact current word and boundary contract?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+            "docs/research/recursive-invoice-preflight.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "Check live overlap and exact model/source binding first. Distinguish a chronological construction from a pooled optimum. State the applicable fixed-inventory ceiling and remaining headroom; changed words or interfaces require a new fully charged model. Do not launch a residual search without an explicit scope and time cap.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Derive or authenticate a ceiling for the exact current paid/target inventory before searching. Old #1240/#4091 caps do not constrain #5599 automatically. Require an unclaimed domain, time cap and useful complete margin. Stop at the applicable ceiling; change the word or boundary instead of adding seeds.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "T16",
+            "owner exchange",
+            "packing",
+            "4091",
+            "4088",
+            "staged-fourth-mixture-ceiling",
+            "staged544-mixed-fourth-entry"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #4091: pooled optimum at one-third staging for pinned fixed words; not a chronological fill.",
+              "evidence": "research/staged-fourth-mixture-ceiling/README.md",
+              "remaining": "Independent scope/source check; any residual optimization is explicitly bounded and optional.",
+              "status": "author-checked",
+              "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4088: later 1090-call literal fill improves the earlier 1080-call witness.",
+              "evidence": "research/staged544-mixed-fourth-entry/README.md",
+              "remaining": "Complete admission remains separate; old residual-bin instructions must not be copied blindly.",
+              "status": "author-checked",
+              "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        },
+        {
+          "id": "scalar-to-moment",
+          "question": "Can a scalar/frame rewrite improve the complete signed moment through paid jobs, productive targets, or both?",
+          "starting_points": [
+            "docs/research/current-priorities.md",
+            "docs/research/research-family-status.md",
+            "certificates/selected-result.json",
+            "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+            "docs/research/recursive-invoice-preflight.md"
+          ],
+          "methods": [
+            "Construct and independently check one source-bound instance of the stated first experiment.",
+            "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+          ],
+          "acceptance_gate": "Require a legal chronological rewrite and favorable complete signed target-minus-paid moment with all extra charges. Unchanged ADD counts or unchanged paid-call counts alone decide neither success nor failure. Compiler, native and outer admission remain separate obligations.",
+          "first_step": {
+            "command": [
+              "python3",
+              "-B",
+              "scripts/research_selected_baseline.py"
+            ],
+            "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+            "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+            "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+          },
+          "first_experiment": "Construct one legal source-bound rewrite and compare complete before/after P and T. Charge restoration, source windows and owned helpers. A paid call need not disappear: a legal target split or rank redistribution may win. Stop if the signed moment is unchanged or the consumer repays the gain. Do not extend a scalar-only census on ADD counts.",
+          "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+          "allowed_variations": [
+            "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+          ],
+          "scope_change_triggers": [
+            "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+            "Treating an archived proposal or local numerical pass as complete supplier admission."
+          ],
+          "overlap_terms": [
+            "signed moment",
+            "target split",
+            "rank exchange",
+            "scalar rewrite"
+          ],
+          "existing_checks": [
+            {
+              "scope": "PR #3998: consecutive A2 scalar contraction",
+              "evidence": "research/staged544-a2-graph-rewrite/README.md",
+              "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+              "status": "author-checked",
+              "source_commit": "389268a6b5e0373a3125d5c6fcd6995f4ea324f5",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4019: separated A2 sites with unchanged recursive histogram",
+              "evidence": "research/staged544-separated-a2/README.md",
+              "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+              "status": "author-checked",
+              "source_commit": "f408e09df300b575235f7f77f81948071397e16d",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4112: composition audit",
+              "evidence": "research/staged544-a2-composition-audit/README.md",
+              "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+              "status": "author-checked",
+              "source_commit": "205b7380656ba4b6316a8a493b1a3c679b8f7a0e",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "PR #4152: A1858 contraction audit",
+              "evidence": "research/staged544-a1858-contraction-audit/README.md",
+              "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+              "status": "author-checked",
+              "source_commit": "caaa14cde5962adc372fdca71f63d0f29e73c8b2",
+              "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+            },
+            {
+              "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+              "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+              "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+              "status": "reviewed",
+              "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+              "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "selection_context": {
+    "refreshed_on": "2026-10-26",
+    "kappa": "62009/20000000",
+    "source_pr": 5599,
+    "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+    "record": "certificates/selected-result.json",
+    "review": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+    "orientation_command": "python3 -B scripts/research_selected_baseline.py",
+    "scope": "Revision-8 strategic reassessment. PR5599 is selected and independently replayed under five inherited assumptions. Archived successor claims are not admissions. Compare complete signed target/paid moments and the current nine outer rows; no historical balanced-transfer cap is imposed."
+  }
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/PROOF.md
new file mode 100644
index 0000000000..f65f38123c
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/PROOF.md
@@ -0,0 +1,334 @@
+# Encoded physical completion of the compact operation
+
+Jose Manuel (`jmbarrancoml`), with substantial OpenAI Codex assistance.
+
+I refine the compact algorithm from PR2250, head
+`d404b48a1e7b147556b309497d55089c837dddb2`, into marked unit-step streams and
+encoded control arithmetic. I use PR2899, head
+`2f0911ad735643a069b9790302fbf179e49f74f8`, for the completed binary ordinary
+callee. I preserve those exact archives and their source arguments. I do not
+derive their universal claims from the small fixtures in this package.
+
+## 1. Domain and result
+
+Fix a finite field schema with m named fields. Compile distinct wide source and
+target names, or a constant toggle, and the earlier/later source order. Supply
+canonical Count tapes for n>=1, K>=1, G>=1, 0<=rho<K, each field width, positive
+record width R and arbitrary positive outer-row count C. Supply the complete
+payload and borrowed parameter tapes with their heads at their local origins.
+
+Require width `(n+1)K` for each wide source/target. Require width nG for u,t,b,
+with u and t before the target and b after both wide slots. Require the declared wide-source
+order. Additional complete spectator fields may have width zero. These are
+exactly the fields the local operation visits; external parked regions remain
+outside its owned inventory.
+
+Write
+
+    f=n+1, a=sum(field widths), M0=2^a, v0=M0*R,
+    M=C*M0, V=C*v0, A=2+a+ceil(log2(R+1)),
+    delta=min(1,n*(2*2^(-G)+8*2^(G-K))).
+
+I implement XOR from the source into the target at positions `rho+jK`,
+`0<=j<f`, or toggle those positions for a constant source. I restore u,t,b,
+the wide source and unselected bits, preserve each R-bit record's order, and
+return rows in their original order. I preserve the borrowed input and parameter
+tapes and return a distinct protected output at its origin.
+
+Assume a completed binary ordinary upper bound
+
+    T_B1(v,b) <= K_q*v*(1+b^tau),  0<tau<=1,
+
+with arbitrary complete spectators, preserved source and restored owned work.
+The pinned B1 supplies `tau=99830289/100000000` under its named C0 endpoint,
+chronology, refinement and cost arguments. I require an eligible fixed prime q
+for that asymptotic statement. Small tests at q=2 or3 have their stated fixture
+scope and do not establish that large-prime theorem.
+
+I obtain the complete time bound
+
+    s*sum_(j=1)^C T_B1(v0,nG)
+       + O_m(V+M*A^6+delta*M*A*(R+A)),
+
+where s=4 for an earlier source or toggle and s=12 for a later source. There
+are sC actual binary calls. I use the volume-linear upper bound to sum their
+costs; I do not replace them by s whole-packet executions.
+
+In the retained domain `f<=p`, `A=O(p)`, `G=4*ceil(log2 p)+6`,
+`K/log p -> infinity`, with R exceeding each fixed power of p, I obtain
+`O_q,m(V*(1+((f-1)G)^tau))` time and linear workspace for a fresh invocation,
+plus fixed compilation storage. I retain the displayed terms at independent
+finite sizes. I state occupied and retained backing space separately below.
+
+I prove successful admitted execution. I make no rollback guarantee after an
+interrupted or invalid internal operation. The caller consumes the protected
+output before reuse. I do not complete a Gaussian monomial, recursive complex
+layer, formal machine refinement or multiplication theorem in this package.
+
+## 2. Encode the numerical controls
+
+I keep numerical parameters, field values, extents, keys and loop indices on
+canonical binary Count tapes. I use the inherited ripple Counter for countdowns.
+The fields' names, their order, the finite operation tags and source-order flag
+belong to compiled control; I do not decode widths or addresses into that control.
+
+`compact_counts.py` implements variable bit windows, shifts, XOR, modular sums
+and fixed-width key serialization through sequential reads, writes and unit
+moves. I build an empty Count body through its borrowed physical view so that
+I retain its active scratch lease. I normalize the result and release the lease
+only when the Count closes. I include discarded high zeros and markers in the
+write/erase accounting.
+
+`compact_layout.py` constructs field radices and complete-row extents by encoded
+arithmetic. I decode an address by repeated binary division through the fixed
+field tuple, and encode it by the inverse multiply/add sequence. Prefix decoding
+sets later fields to zero; rotation controls all precede their target, so those
+zeros cannot change the offset. I use a fixed number of field Counts, not one
+control register per address or per selected digit.
+
+For `compact_control.py`, I copy the finite operation word from the authenticated
+PR2250 `operations()` method. Its dummy numerical constructor constants never
+enter runtime arithmetic. I implement offsets, inverse execution, selected masks
+and the guard in the new encoded routines. The checker disables the reference
+class's numerical methods during physical execution.
+
+For each of n digits I extract the source bit and dirty t digit and accumulate
+the packed offset modulo the target radix. For `1-2t_i`, I branch only on zero:
+otherwise I form the positive magnitude `2t_i-1` and negate its reduced residue.
+I retain modular overflow on exceptional addresses. During inverse execution I
+reverse the finite word and evaluate each offset on the current inverse state.
+I never use the original forward controls for a later inverse step.
+
+Let `B=2^G`. I test the original guard using encoded comparisons:
+
+    t_i < B-1,
+    2B <= g_i < 2^(K-1)-2B,
+    u_i < B-1 for a later source,
+
+where g_i contains the K-1 target bits above selected bit i. If
+`2^(K-1)<=4B`, I mark the address exceptional: the guarded interval is empty.
+This handles negative or empty upper thresholds without unsigned underflow.
+
+## 3. Realize the raw word and binary boundary
+
+I retain Douglas Colkitt's raw modular word and the proof in PR2250. An earlier
+source or toggle uses four rotations and four width-nG swaps. A later source
+uses ten rotations and twelve swaps. The scalar dirty-control identity is
+
+    y += 2*z*t;
+    t += parity(y);
+    y += z*(1-2*t);
+    t -= parity(y) XOR z.
+
+On the guarded packed domain, this toggles the selected parity by z and restores
+t. The load/unload swaps move a front compact field to the complete back field;
+they do not initialize the original dirty back value.
+
+For a rotation with target radix Q and suffix extent L, I compute the offset
+u modulo Q from the encoded prefix ordinal. I split the next Q blocks into
+lengths `(Q-u)L` and `uL` on two owned streams. I recompute the same offset during
+merge and emit the second piece before the first. Both traversals enumerate
+prefixes in the same order. Thus I realize the modular address rotation for
+arbitrary wraparound while preserving the order inside each suffix block.
+
+For a compact swap I derive the complete preceding, intervening and trailing
+extents from the fixed field schema. I suspend the compact allocation scope and
+invoke the actual `Binary.run` with borrowed physical views. B1 uses its own
+fixed roles and its sealed C0 path. After return I restore the compact scope,
+copy the protected binary output into an owned lease, and clear its output and
+marker. I then consume the old owned row stream. This preserves B1's source
+contract and the compact interpreter's consuming-intermediate contract together.
+
+I use the binary interface here. PR2899 pads each active field to the least
+q-power above `2^(nG)` and restricts afterward; its native volume is below
+`q^2*v0`. Its bound already includes that fixed factor and its internal reserve.
+The native same-q shortcut used by the BIT successor does not apply to these
+binary compact fields.
+
+## 4. Complete exceptional repair and the final bit
+
+Let S be the raw word and T the desired operation on its low n selected bits.
+I retain the original exceptional set E. From PR2250's guarded identity, S=T
+on its complement. T preserves E because it changes selected parities while
+fixing the guard bits and dirty compact labels. Each raw rotation has a
+target-independent offset, and each swap is invertible. Thus S is a bijection;
+since it agrees with T on the complement, it also preserves E.
+
+I enumerate current row addresses q with an encoded counter. For each record
+I append its exception flag to the hole stream. I append a good record to the
+good stream. For an exceptional record I compute the full encoded destination
+`T(S^-1(q))` and append its fixed a-bit key followed by its opaque R-bit record.
+I use current inverse controls and the declared modular field widths throughout.
+
+`stable_radix` performs a literal stable two-bucket partition for each key bit,
+from least to most significant. It reads one key into a Count, visits the
+encoded pass position, writes the fixed-width key and copies the complete
+record into the chosen bucket. It concatenates bucket0 then bucket1 and clears
+the old stream and buckets. Induction on the pass position gives increasing
+order of the processed suffix of each key, with stability among equal suffixes.
+After a passes I obtain full numeric key order. I allocate no bucket per key.
+
+Because `T S^-1` permutes E, its destination keys are distinct and occupy
+exactly the recorded holes. During reinsertion I consume the next good record
+at a zero hole. At a one hole I read the next sorted key, require equality with
+the current encoded address, and consume its record. I check complete exhaustion
+of all three streams, clear them and rewind the output. The resulting payload
+has the low-selected endpoint T on the original input.
+
+I then apply the highest selected bit at `rho+nK`: a toggle or an XOR from
+the matching source bit. I derive its absolute address position on Count tapes.
+The toggle uses two complete suffix buckets; XOR uses four, with a fixed
+four-state permutation. I preserve the intervening and trailing extents and
+erase each owned bucket after its complete slab. This gives the requested f-bit
+endpoint and restores all other labels.
+
+I repair one complete outer row at a time. The raw and ideal words preserve
+that row label, so the domain is closed under both. A fixed dirty-field slice
+need not be closed. For example, the retained n=2,K=2,G=1,rho=1 early word sends
+`(u,t,x,y,b)=(0,1,2,2,0)` to `(0,3,2,8,0)`, whereas the ideal low endpoint is
+`(0,1,2,0,0)`. Repair must cross the two t slices. I retain that witness as a
+control and do not partition repair along dirty coordinates.
+
+The outer loop copies one complete row from the borrowed source, finishes its
+operation, appends its result to the protected output and clears the row lease.
+I advance the source cursor without rereading earlier rows and rewind it after
+the complete packet. I reassemble all rows before return; I introduce no complex
+child per row and no altered recursive schedule.
+
+## 5. Charge arithmetic, sorting and disposal
+
+All new field/control operands have O(A) bits. A shifted packed term can exceed
+its target width before reduction, but its bit length remains O(A): it has at
+most one compact digit's width plus one wide-field position and a constant
+margin. The number of fields and raw operations is fixed.
+
+The inherited Count product and division use O(A) iterations of linear scans,
+so I charge O(A^2). Dynamic power and shift routines perform at most O(A) such
+linear scans. Bit windows and the fixed tuple's encode/decode routines have
+polynomial cost. An offset processes n<=a digits; O(A^3) suffices for its shifts,
+modular reductions and sums. I use the conservative envelope O_m(A^6) for the
+complete preparation, inverse, guard and key work, including counter setup,
+normalization, copies, rewinds and erasure.
+
+For each rotation I compute an offset twice per prefix fibre and move each
+payload bit a bounded number of times. There are at most M0 fibres per row.
+I therefore charge `O_m(v0+M0*A^6)` per rotation, including its piece-length
+products and clearing. The highest-bit operation has one encoded extent setup
+and linear complete-slab movement. A suffix counter's initialization costs
+O(log(1+suffix)), which its ensuing complete suffix copy pays.
+
+During repair I evaluate the guard on all M0 addresses and compute inverse
+states and destinations on the exceptional ones. I charge `O_m(M0*A^6)`.
+For each of a radix passes I move at most `delta*M0` records of R+a bits.
+I include key scanning, serialization, bucket concatenation, rewinds and
+clearing in `O(delta*M0*a*(R+a))`. Any conservative extra polynomial key-control
+charge fits the already included `M0*A^6` term. Hole generation and reinsertion
+add O(v0) movement. Empty exceptional streams need only the polynomial pass
+overhead; they do not trigger a scan of the full payload for each radix bit.
+
+I create `Counter(C)` once, outside these preparations. Its complete ripple
+traversal costs `O(C+log(C+1))`; no row ordinal enters offset, guard, inverse
+or destination arithmetic. Since each row contains at least one bit, I absorb
+this charge into O(V). Initial row copies, final appending and the borrowed
+source rewind also cost O(V).
+
+I charge the sC binary calls with their individual row volumes, including the
+returned-port copies and marker operations. The uniform B1 upper bound then
+gives the time statement in section 1. I include fixed source compilation once;
+fixed q-dependent marker work per call belongs to its volume-linear constant.
+
+For asymptotic absorption, eventually `K>=G+4*ceil(log2 p)+10`. With n<=p and
+the retained G, the source estimate gives `delta<=5/(128*p^3)`. Consequently
+
+    M*A^6/V = A^6/R -> 0,
+    delta*M*A*(R+A)/V = delta*A*(1+A/R) = O(p^-2).
+
+I obtain the stated compact bound in that domain. I do not infer a practical
+cutoff or use finite timings to establish it.
+
+## 6. Fixed roles, blank return and backing extent
+
+I allocate `8*m+256` compact scratch tapes before reading numerical inputs.
+The layout retains m+3 Counts; at most one decoded state retains m Counts;
+fewer than 64 additional Count, Counter and payload roles suffice for the active
+branch, including nested product/division temporaries, keys and buckets. I close
+predecessors before advancing or replacing a result. Thus `2*m+64` gives a
+conservative live census within the configured allowance.
+
+I count the protected output, borrowed descriptors, Binary's 96-slot pool and
+the native ordinary inventory separately. I suspend the compact factories
+while the binary/native scopes use their own roles. The global constructor
+guard remains active during this switch. I never allocate a physical tape per
+row, prefix, selected digit, exceptional key or radix pass.
+
+For occupied contents, a conservative compact-side envelope, including borrowed
+input and protected output, is
+
+    4V+2*delta*M*a+M+O_m(A+log(C+1)).
+
+I include the good/bad/hole streams, current/output row streams, key buckets
+and fixed numerical operands. I add B1's private workspace and fixed source
+compilation storage. In the long-record domain, `a/R` is bounded and I obtain
+linear occupied workspace.
+
+I distinguish erasure from backing allocation. The retained Tape implementation
+blanks its cells but does not shrink the Python bytearray. For a fresh engine,
+each compact-pool tape has maximum extent
+
+    O(v0+delta*M0*a+A+log(C+1)).
+
+Multiplying by the fixed pool capacity bounds its backing storage. I add the
+global input/output and the inherited B1 backing allowance. For a reused engine,
+I take each role's maximum extent over preceding invocations. I do not bound
+retained arrays from an earlier larger input by a later smaller V. If these
+calls belong to one enclosing invocation, I use that enclosing volume to bound
+the maxima, with its retained source allowances.
+
+On successful return I require no live scratch leases, erase their markers,
+close numerical contexts and leave their heads at their local origins. I retain
+only the protected output contents. At reuse I restore blank markers with local
+writes. I do not scan an old blank backing tail to reclaim it. This gives the
+claimed locality independently of earlier physical extents.
+
+I treat Python object bookkeeping, Tape meters and provenance masks as simulator
+or checker machinery, not extra numerical registers of the tape program. The
+implementation selects no instruction or operand from those observations. I
+have not expanded this structured program into a complete transition table or
+proved its correspondence in a proof assistant.
+
+## 7. Evidence and the remaining complex boundary
+
+I compare encoded controls with the authenticated indexed oracle on 151 states,
+including 904 offsets, both guard regimes, modular inverse chronology and the
+cross-dirty-slice witness. I check complete physical early/late/toggle rows,
+odd-prime binary padding, reuse after erasing the protected marker, and two
+complete 4096-record two-digit rectangles. I check 8192 mixed-guard records
+through actual raw movement, repair and the final bit. For payloads I carry an
+independent mask per input bit in checker state while runtime cells remain
+Boolean. I disable indexed reference arithmetic during physical execution.
+
+The separate 1024-column handoff uses the actual Binary wrapper and a declared
+reduced fitted B1 body with two C0 roots. I verify its live parent numerical
+objects and suspended factory scope. The small complete Compact cases use
+B1's elementary branch. I retain its universal faster-rate argument as an
+explicit predecessor, not an inference from those timings or endpoints.
+
+The failure controls reject omitted repair, omitted inverse-key computation,
+reversed radix order, altered source archives, namespace contamination and
+physical allocation inside a sealed call. I also reject reuse of an unconsumed
+output while preserving its contents. These controls do not establish recovery
+after an arbitrary internal interruption.
+
+PR2534 already executes selected child 7 with retained Compact on complete dirty
+outer rows. I add encoded controls, fixed physical roles and the actual B1
+boundary. I do not claim that earlier fixture as new work. PR2378/2422 supply
+separate formal phase results; PR2476/2700/2756 supply repair accounting and
+partition boundaries. I preserve that division of scope.
+
+A complete Gaussian monomial still needs its encoded phase pass and signed
+record traversal, followed by integration with the actual complex caller,
+proper-width children, private lifetimes and root precision grid. The written
+PR2287/2298 implications remain separate from that payload execution. I leave
+the selected exponent unchanged. I also do not transfer B1's coarse rate to
+the higher modern candidate in PR2979: that would require a stronger ordinary
+contract or a different transfer argument.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_control.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_control.py
new file mode 100644
index 0000000000..13af719b58
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_control.py
@@ -0,0 +1,235 @@
+"""Encoded modular offsets, inverse states and the retained compact guard."""
+import native_sources
+_source, reference = native_sources.activate()
+from compact_counts import (add_mod, bit_at, bit_slice, bit_xor, negate_mod,
+                           power_two, reduced, shifted)
+from cardinal_counts import Count, positive
+from encoded import compare, subtract
+from stream import Counter
+from words import need
+
+
+class Control:
+    def __init__(self, n, K, G, rho, source, target, late=False):
+        self.n, self.K, self.G, self.rho = n, K, G, rho
+        self.source, self.target, self.late = source, target, late
+        # Only names/order flags enter this fixed compiler. The dummy numerical
+        # constants are unused by the authenticated operations() method.
+        self.operations = reference.Compact(1,1,1,0,source,target,late).operations()
+
+    def validate(self, layout):
+        for value in (self.n,self.K,self.G):
+            positive(value)
+        need(compare(self.rho,self.K) < 0, "selected residue lies in each wide chunk")
+        need(self.target not in ("u","t","b") and self.source not in ("u","t","b",self.target),
+             "distinct wide source/target and compact fields")
+        axes = Count(self.n)
+        axes.increment()
+        wide, compact = Count.product(axes,self.K), Count.product(self.n,self.G)
+        try:
+            need(compare(layout.width(self.target),wide) == 0, "complete wide target")
+            need(all(compare(layout.width(name),compact) == 0 for name in ("u","t","b")),
+                 "three complete equal compact fields")
+            at = layout.names.index(self.target)
+            need(layout.names.index("u") < at and layout.names.index("t") < at < layout.names.index("b"),
+                 "front/back compact placement")
+            if self.source is None:
+                need(not self.late, "constant toggle uses the early word")
+            else:
+                need(compare(layout.width(self.source),wide) == 0 and
+                     ((layout.names.index(self.source) > at) == self.late), "declared wide source order")
+            for operation in self.operations:
+                if operation[0] == "rotate":
+                    target, controls = operation[1:3]
+                    need(all(layout.names.index(name) < layout.names.index(target) for name in controls),
+                         "rotation reads only its preceding fields")
+        finally:
+            axes.close()
+            wide.close()
+            compact.close()
+
+    def selected(self, value):
+        """Pack the low n selected bits into the low bit of each G-bit digit."""
+        result, position, weight = Count.literal(0), Count(self.rho), Count.literal(1)
+        remaining = Counter(self.n)
+        try:
+            while not remaining.finished:
+                if bit_at(value,position):
+                    result.add(weight)
+                position.add(self.K)
+                following = shifted(weight,self.G)
+                weight.close()
+                weight = following
+                remaining.decrement()
+            return result
+        except BaseException:
+            result.close()
+            raise
+        finally:
+            position.close()
+            weight.close()
+            remaining.close()
+
+    def mask(self, state, compact=False, highest=False):
+        source = "u" if compact else self.source
+        source_position = Count.literal(0) if compact else Count(self.rho)
+        weight = power_two(self.rho)
+        result, axes = Count.literal(0), Count(self.n)
+        if highest:
+            axes.increment()
+        remaining = Counter(axes)
+        axes.close()
+        try:
+            while not remaining.finished:
+                if source is None or bit_at(state[source],source_position):
+                    result.add(weight)
+                source_position.add(self.G if compact else self.K)
+                following = shifted(weight,self.K)
+                weight.close()
+                weight = following
+                remaining.decrement()
+            return result
+        except BaseException:
+            result.close()
+            raise
+        finally:
+            source_position.close()
+            weight.close()
+            remaining.close()
+
+    def offset(self, state, operation, layout):
+        _tag,target,_controls,kind,sign = operation
+        modulus = layout.radices[target]
+        result = None
+        if kind in ("selected_x","selected_y"):
+            result = self.selected(state[self.source if kind == "selected_x" else self.target])
+        elif kind.startswith("original"):
+            mask = self.mask(state,kind.endswith("compact"))
+            original = bit_xor(state[self.target],mask)
+            mask.close()
+            try:
+                result = self.selected(original)
+            finally:
+                original.close()
+        else:
+            need(kind.startswith("first") or kind.startswith("second"), "compiled compact rotation kind")
+            compact = kind.endswith("compact")
+            source = "u" if compact else self.source
+            source_position = Count.literal(0) if compact else Count(self.rho)
+            compact_position, wide_position = Count.literal(0), Count(self.rho)
+            remaining, result = Counter(self.n), Count.literal(0)
+            one = Count.literal(1)
+            try:
+                while not remaining.finished:
+                    if source is None or bit_at(state[source],source_position):
+                        digit = bit_slice(state["t"],compact_position,self.G)
+                        negative = kind.startswith("second") and not digit.zero()
+                        if kind.startswith("first"):
+                            term = Count(digit)
+                            term.multiply_small(2)
+                        elif digit.zero():
+                            term = Count.literal(1)
+                        else:
+                            twice = Count(digit)
+                            twice.multiply_small(2)
+                            term = subtract(twice,one)
+                            twice.close()
+                        digit.close()
+                        following = shifted(term,wide_position)
+                        term.close()
+                        term = reduced(following,modulus)
+                        following.close()
+                        if negative:
+                            following = negate_mod(term,modulus)
+                            term.close()
+                            term = following
+                        following = add_mod(result,term,modulus)
+                        result.close()
+                        term.close()
+                        result = following
+                    source_position.add(self.G if compact else self.K)
+                    compact_position.add(self.G)
+                    wide_position.add(self.K)
+                    remaining.decrement()
+            except BaseException:
+                result.close()
+                raise
+            finally:
+                for value in (source_position,compact_position,wide_position,remaining,one):
+                    value.close()
+        try:
+            canonical = reduced(result,modulus)
+        finally:
+            result.close()
+        if sign < 0:
+            result = negate_mod(canonical,modulus)
+            canonical.close()
+            canonical = result
+        return canonical
+
+    def execute_state(self, state, layout, inverse=False):
+        """Mutate a fixed tuple of encoded fields, with current inverse controls."""
+        for operation in reversed(self.operations) if inverse else self.operations:
+            if operation[0] == "swap":
+                first,second = operation[1:]
+                state[first],state[second] = state[second],state[first]
+                continue
+            target = operation[1]
+            offset = self.offset(state,operation,layout)
+            try:
+                if inverse:
+                    following = negate_mod(offset,layout.radices[target])
+                    offset.close()
+                    offset = following
+                following = add_mod(state[target],offset,layout.radices[target])
+            finally:
+                offset.close()
+            state[target].close()
+            state[target] = following
+
+    def ideal_state(self, state, highest=False):
+        mask = self.mask(state,highest=highest)
+        try:
+            following = bit_xor(state[self.target],mask)
+        finally:
+            mask.close()
+        state[self.target].close()
+        state[self.target] = following
+
+    def bad(self, state):
+        one = Count.literal(1)
+        guard_width = subtract(self.K,one)
+        base, guard_radix = power_two(self.G), power_two(guard_width)
+        maximum = subtract(base,one)
+        lower, twice_lower = Count(base), Count(base)
+        lower.multiply_small(2)
+        twice_lower.multiply_small(4)
+        upper = compact_position = wide_position = remaining = None
+        try:
+            if compare(guard_radix,twice_lower) <= 0:
+                return True
+            upper = subtract(guard_radix,lower)
+            compact_position, wide_position = Count.literal(0), Count(self.rho)
+            wide_position.increment()
+            remaining = Counter(self.n)
+            while not remaining.finished:
+                for name in (("t","u") if self.late else ("t",)):
+                    digit = bit_slice(state[name],compact_position,self.G)
+                    saturated = compare(digit,maximum) == 0
+                    digit.close()
+                    if saturated:
+                        return True
+                guard = bit_slice(state[self.target],wide_position,guard_width)
+                outside = compare(guard,lower) < 0 or compare(guard,upper) >= 0
+                guard.close()
+                if outside:
+                    return True
+                compact_position.add(self.G)
+                wide_position.add(self.K)
+                remaining.decrement()
+            return False
+        finally:
+            for value in (one,guard_width,base,guard_radix,maximum,lower,twice_lower,
+                          upper,compact_position,wide_position,remaining):
+                if value is not None:
+                    value.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_counts.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_counts.py
new file mode 100644
index 0000000000..064b508efd
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_counts.py
@@ -0,0 +1,198 @@
+"""Compact numerical fields on canonical Count tapes, without decoded indices."""
+import native_sources
+native_sources.activate()
+from cardinal_counts import Count
+from encoded import compare, divide, subtract
+from session import borrowed_tape
+from stream import Counter
+from words import BLANK, ONE, RIGHT, ZERO, need
+
+
+def power_two(exponent):
+    result, remaining = Count.literal(1), Counter(exponent)
+    try:
+        while not remaining.finished:
+            result.multiply_small(2)
+            remaining.decrement()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        remaining.close()
+
+
+def shifted(value, amount, left=True):
+    result, remaining = Count(value), Counter(amount)
+    try:
+        while not remaining.finished:
+            if left:
+                result.multiply_small(2)
+            else:
+                result.divide_small(2)
+            remaining.decrement()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        remaining.close()
+
+
+def bit_slice(value, start, width):
+    """Read a variable bit window; fill positions above its end with zero."""
+    offset, remaining = Counter(start), Counter(width)
+    result = Count.literal(0)
+    borrowed_tape(result.tape).clear()
+    value.rewind()
+    try:
+        while not offset.finished:
+            if value.read() != RIGHT:
+                need(value.read() in (ZERO, ONE), "bit-window source digit")
+                value.step(1)
+            offset.decrement()
+        while not remaining.finished:
+            ended = value.read() == RIGHT
+            bit = ZERO if ended else value.read()
+            need(bit in (ZERO, ONE), "bit-window digit")
+            result.tape.append(bit)
+            if not ended:
+                value.step(1)
+            remaining.decrement()
+        result.tape.append(RIGHT)
+        result.normalize()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        value.rewind()
+        offset.close()
+        remaining.close()
+
+
+def bit_at(value, position):
+    one = Count.literal(1)
+    try:
+        selected = bit_slice(value, position, one)
+        try:
+            bit = selected.read()
+            need(bit in (ZERO, ONE), "one-bit finite control")
+            return bit
+        finally:
+            selected.close()
+    finally:
+        one.close()
+
+
+def bit_xor(left, right):
+    if left is right or left.tape is right.tape:
+        left.rewind()
+        return Count.literal(0)
+    result = Count.literal(0)
+    borrowed_tape(result.tape).clear()
+    left.rewind()
+    right.rewind()
+    try:
+        while left.read() != RIGHT or right.read() != RIGHT:
+            a_end, b_end = left.read() == RIGHT, right.read() == RIGHT
+            a, b = ZERO if a_end else left.read(), ZERO if b_end else right.read()
+            need(a in (ZERO, ONE) and b in (ZERO, ONE), "binary XOR digits")
+            result.tape.append(a ^ b)
+            if not a_end:
+                left.step(1)
+            if not b_end:
+                right.step(1)
+        result.tape.append(RIGHT)
+        result.normalize()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        left.rewind()
+        right.rewind()
+
+
+def reduced(value, modulus):
+    quotient, remainder = divide(value, modulus)
+    quotient.close()
+    return remainder
+
+
+def add_mod(left, right, modulus):
+    total = Count(left)
+    try:
+        total.add(right)
+        return reduced(total, modulus)
+    finally:
+        total.close()
+
+
+def negate_mod(value, modulus):
+    need(compare(value, modulus) < 0, "canonical modular operand")
+    return Count.literal(0) if value.zero() else subtract(modulus, value)
+
+
+def read_fixed(source, width):
+    """Consume exactly width binary cells and return one canonical Count."""
+    result, remaining = Count.literal(0), Counter(width)
+    borrowed_tape(result.tape).clear()
+    try:
+        while not remaining.finished:
+            bit = source.read()
+            need(bit in (ZERO, ONE), "complete fixed-width binary key")
+            result.tape.append(bit)
+            source.step(1)
+            remaining.decrement()
+        result.tape.append(RIGHT)
+        result.normalize()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        remaining.close()
+
+
+def write_fixed(value, target, width):
+    remaining = Counter(width)
+    value.rewind()
+    try:
+        while not remaining.finished:
+            ended = value.read() == RIGHT
+            bit = ZERO if ended else value.read()
+            need(bit in (ZERO, ONE), "fixed-width key digit")
+            target.append(bit)
+            if not ended:
+                value.step(1)
+            remaining.decrement()
+        need(value.read() == RIGHT or value.zero(), "key fits declared width")
+    finally:
+        value.rewind()
+        remaining.close()
+
+
+def copy_bits(source, target, count):
+    remaining = Counter(count)
+    try:
+        while not remaining.finished:
+            bit = source.read()
+            need(bit in (ZERO, ONE), "complete opaque binary payload")
+            target.append(bit)
+            source.step(1)
+            remaining.decrement()
+    finally:
+        remaining.close()
+
+
+def append_bits(source, target):
+    source.rewind()
+    try:
+        while source.read() != BLANK:
+            bit = source.read()
+            need(bit in (ZERO, ONE), "opaque binary stream alphabet")
+            target.append(bit)
+            source.step(1)
+    finally:
+        source.rewind()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_engine.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_engine.py
new file mode 100644
index 0000000000..5c5ca75567
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_engine.py
@@ -0,0 +1,153 @@
+"""A fixed physical inventory for complete Compact operations through B1."""
+import native_sources
+native_sources.activate()
+from binary import Binary
+from compact_control import Control
+from compact_counts import append_bits, copy_bits
+from compact_layout import Layout
+from compact_streams import digit_permutation, flip_digit, repair, rotate
+from cardinal_counts import Count, positive
+from encoded import compare
+from records import Tape
+from scratch_pool import ScratchPool
+from session import (OuterScope, borrowed_count, borrowed_tape, erase_marker,
+                     initialize_marker, sealed_constructors)
+from stream import Counter
+from words import BLANK, LEFT, need
+
+
+class CompactEngine:
+    """Compile names/order once; receive numerical widths only on Count tapes.
+
+    run() preserves its borrowed payload/descriptors and returns a protected
+    owned output. Consume that output before reuse. The successful-input
+    contract does not include interrupted-macro rollback.
+    """
+    def __init__(self, names, source, target, late, native):
+        need(type(names) is tuple and len(names) == len(set(names)), "fixed field schema")
+        need(not native.closed, "fresh private ordinary engine at compilation")
+        self.names, self.source, self.target, self.late = names,source,target,late
+        self.pool = ScratchPool(8*len(names)+256)
+        self.scope = OuterScope(self.pool)
+        self.output = Tape()
+        native.finish(False)
+        erase_marker(native.output)
+        self.binary = Binary(native)
+        # Establish one completely blank owned baseline before input loading.
+        for tape in (*self.binary.pool.tapes,self.binary.output,*self.pool.tapes,self.output):
+            erase_marker(tape)
+        self.binary.closed = self.closed = True
+        self.calls = dict(ordinary=0,rotations=0,rows=0)  # Checker observations only.
+
+    def rearm(self):
+        need(self.closed and self.output.read() == BLANK, "consume previous compact output")
+        self.output.step(-1)
+        marker = self.output.read()
+        need(marker in (LEFT,BLANK), "compact output origin")
+        if marker == BLANK:
+            self.output.write(LEFT)
+        self.output.step(1)
+        for tape in self.pool.tapes:
+            initialize_marker(tape)
+        self.closed = False
+
+    def swap(self, source, plan, first, second):
+        width = plan.width(first)
+        need(compare(width,plan.width(second)) == 0, "equal binary compact fields")
+        before,middle,suffix = plan.paired_extents(first,second)
+        output = None
+        try:
+            with self.scope.suspended():
+                returned = self.binary.run(borrowed_tape(source),borrowed_count(width),
+                                           borrowed_count(before),borrowed_count(middle),borrowed_count(suffix))
+            try:
+                output = self.pool.acquire()
+                append_bits(returned,output)
+                output.rewind()
+            finally:
+                returned.clear()
+                erase_marker(returned)
+            source.clear()
+            self.calls["ordinary"] += 1
+            result,output = output,None
+            return result
+        finally:
+            for value in (before,middle,suffix):
+                value.close()
+            if output is not None:
+                output.clear()
+
+    def complete_row(self, source, plan, control):
+        current = source
+        try:
+            for operation in control.operations:
+                if operation[0] == "swap":
+                    following = self.swap(current,plan,*operation[1:])
+                else:
+                    following = rotate(current,plan,control,operation,self.pool.acquire)
+                    self.calls["rotations"] += 1
+                current = following
+            current = repair(current,plan,control,self.pool.acquire)
+            last = Count.product(control.n,control.K)
+            last.add(control.rho)
+            target = plan.bit_position(control.target,last)
+            source_bit = None
+            try:
+                if control.source is None:
+                    following = flip_digit(current,plan,target,self.pool.acquire)
+                else:
+                    source_bit = plan.bit_position(control.source,last)
+                    early = compare(source_bit,target) < 0
+                    first,second = (source_bit,target) if early else (target,source_bit)
+                    mapping = (0,1,3,2) if early else (0,3,2,1)
+                    following = digit_permutation(current,plan,first,second,mapping,self.pool.acquire)
+                current = following
+            finally:
+                last.close()
+                target.close()
+                if source_bit is not None:
+                    source_bit.close()
+            result,current = current,None
+            return result
+        finally:
+            if current is not None:
+                current.clear()
+
+    def run(self, payload, widths, n, K, G, rho, record_bits, outer_rows):
+        source = borrowed_tape(payload)
+        need(source is not self.output, "distinct borrowed compact input")
+        positive(outer_rows)
+        self.rearm()
+        plan = rows = current = None
+        source.rewind()
+        with sealed_constructors(),self.scope.installed():
+            try:
+                plan = Layout(self.names,widths,record_bits)
+                control = Control(n,K,G,rho,self.source,self.target,self.late)
+                control.validate(plan)
+                rows = Counter(outer_rows)
+                while not rows.finished:
+                    current = self.pool.acquire()
+                    copy_bits(source,current,plan.row_bits)
+                    current.rewind()
+                    current = self.complete_row(current,plan,control)
+                    append_bits(current,self.output)
+                    current.clear()
+                    current = None
+                    rows.decrement()
+                    self.calls["rows"] += 1
+                need(source.read() == BLANK, "complete outer-row packet")
+            finally:
+                source.rewind()
+                if current is not None:
+                    current.clear()
+                if rows is not None:
+                    rows.close()
+                if plan is not None:
+                    plan.close()
+            self.pool.empty()
+        for tape in self.pool.tapes:
+            erase_marker(tape)
+        self.output.rewind()
+        self.closed = True
+        return self.output
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_layout.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_layout.py
new file mode 100644
index 0000000000..03ca12aed7
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_layout.py
@@ -0,0 +1,132 @@
+"""A fixed field schema with encoded widths, extents and address states."""
+import native_sources
+native_sources.activate()
+from compact_counts import power_two
+from cardinal_counts import Count, positive
+from encoded import compare, divide, subtract
+from words import need
+
+
+class Layout:
+    def __init__(self, names, widths, record_bits):
+        # The field count/order is compiled, not an input-dependent collection.
+        need(type(names) is tuple and len(names) == len(set(names)) and len(names) == len(widths),
+             "fixed unique field vocabulary")
+        self.names, self.widths, self.record_bits = names, widths, record_bits
+        positive(record_bits)
+        self.bits = Count.literal(0)
+        self.radices = {}
+        for name, width in zip(names, widths):
+            need(isinstance(width,Count), "encoded field width")
+            self.bits.add(width)
+            self.radices[name] = power_two(width)
+        self.records = power_two(self.bits)
+        self.row_bits = Count.product(self.records, record_bits)
+
+    def width(self, name):
+        return self.widths[self.names.index(name)]
+
+    def sum_widths(self, names):
+        result = Count.literal(0)
+        for name in names:
+            result.add(self.width(name))
+        return result
+
+    def decode(self, address):
+        need(compare(address, self.records) < 0, "complete local-row address")
+        current, state = Count(address), {}
+        try:
+            for name in reversed(self.names):
+                following, state[name] = divide(current, self.radices[name])
+                current.close()
+                current = following
+            need(current.zero(), "complete fixed-field decomposition")
+            return state
+        except BaseException:
+            self.close_state(state)
+            raise
+        finally:
+            current.close()
+
+    def encode(self, state):
+        result = Count.literal(0)
+        try:
+            for name in self.names:
+                need(compare(state[name], self.radices[name]) < 0, "canonical encoded field")
+                following = Count.product(result, self.radices[name])
+                result.close()
+                result = following
+                result.add(state[name])
+            return result
+        except BaseException:
+            result.close()
+            raise
+
+    def prefix_state(self, prefix, target):
+        before = self.names[:self.names.index(target)]
+        current, state = Count(prefix), {}
+        try:
+            for name in reversed(before):
+                following, state[name] = divide(current, self.radices[name])
+                current.close()
+                current = following
+            need(current.zero(), "complete rotation prefix")
+            for name in self.names[len(before):]:
+                state[name] = Count.literal(0)
+            return state
+        except BaseException:
+            self.close_state(state)
+            raise
+        finally:
+            current.close()
+
+    @staticmethod
+    def close_state(state):
+        for value in state.values():
+            value.close()
+
+    def single_extents(self, field):
+        at = self.names.index(field)
+        before_bits = self.sum_widths(self.names[:at])
+        after_bits = self.sum_widths(self.names[at+1:])
+        before, after = power_two(before_bits), power_two(after_bits)
+        try:
+            return before, Count.product(after, self.record_bits)
+        finally:
+            before_bits.close()
+            after_bits.close()
+            after.close()
+
+    def paired_extents(self, first, second):
+        i, j = sorted((self.names.index(first), self.names.index(second)))
+        need(i != j, "distinct ordinary compact fields")
+        before_bits = self.sum_widths(self.names[:i])
+        middle_bits = self.sum_widths(self.names[i+1:j])
+        after_bits = self.sum_widths(self.names[j+1:])
+        before, middle, after = power_two(before_bits), power_two(middle_bits), power_two(after_bits)
+        try:
+            return before, middle, Count.product(after, self.record_bits)
+        finally:
+            before_bits.close()
+            middle_bits.close()
+            after_bits.close()
+            after.close()
+
+    def bit_position(self, field, low_bit):
+        """An encoded position counted from the left of the complete address."""
+        need(compare(low_bit, self.width(field)) < 0, "selected field bit exists")
+        ending = self.sum_widths(self.names[:self.names.index(field)+1])
+        one = Count.literal(1)
+        try:
+            rest = subtract(ending, low_bit)
+            try:
+                return subtract(rest, one)
+            finally:
+                rest.close()
+        finally:
+            ending.close()
+            one.close()
+
+    def close(self):
+        for value in (*self.radices.values(), self.bits, self.records, self.row_bits):
+            value.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_streams.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_streams.py
new file mode 100644
index 0000000000..5699cc7f20
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/compact_streams.py
@@ -0,0 +1,257 @@
+"""Literal complete-row rotations, bit gates and exceptional-record repair."""
+import native_sources
+native_sources.activate()
+from compact_counts import (append_bits, bit_at, copy_bits, power_two,
+                            read_fixed, write_fixed)
+from cardinal_counts import Count
+from encoded import compare, subtract
+from session import borrowed_tape
+from stream import Counter
+from words import BLANK, need
+
+
+def rotate(source, plan, control, operation, factory):
+    target = operation[1]
+    before, suffix = plan.single_extents(target)
+    left, right, output = factory(), factory(), factory()
+    try:
+        source.rewind()
+        for merging in (False,True):
+            remaining, ordinal = Counter(before), Count.literal(0)
+            try:
+                while not remaining.finished:
+                    state = plan.prefix_state(ordinal,target)
+                    try:
+                        cut = control.offset(state,operation,plan)
+                    finally:
+                        plan.close_state(state)
+                    complement = subtract(plan.radices[target],cut)
+                    first,second = Count.product(complement,suffix),Count.product(cut,suffix)
+                    cut.close()
+                    complement.close()
+                    try:
+                        if merging:
+                            copy_bits(right,output,second)
+                            copy_bits(left,output,first)
+                        else:
+                            copy_bits(source,left,first)
+                            copy_bits(source,right,second)
+                    finally:
+                        first.close()
+                        second.close()
+                    ordinal.increment()
+                    remaining.decrement()
+            finally:
+                remaining.close()
+                ordinal.close()
+            if not merging:
+                need(source.read() == BLANK, "complete rotation source")
+                left.rewind()
+                right.rewind()
+        need(left.read() == right.read() == BLANK, "complete rotation pieces")
+        source.clear()
+        output.rewind()
+        return output
+    except BaseException:
+        output.clear()
+        raise
+    finally:
+        left.clear()
+        right.clear()
+        before.close()
+        suffix.close()
+
+
+def digit_permutation(source, plan, first, second, mapping, factory):
+    need(compare(first,second) < 0 and compare(second,plan.bits) < 0, "two ordered address bits")
+    need(tuple(sorted(mapping)) == (0,1,2,3), "fixed four-state permutation")
+    one = Count.literal(1)
+    difference, tail = subtract(second,first), subtract(plan.bits,second)
+    middle_bits, after_bits = subtract(difference,one), subtract(tail,one)
+    before, middle, after = power_two(first),power_two(middle_bits),power_two(after_bits)
+    suffix = Count.product(after,plan.record_bits)
+    for value in (one,difference,tail,middle_bits,after_bits,after):
+        value.close()
+    output = factory()
+    buckets = tuple(factory() for _ in range(4))
+    inverse = tuple(mapping.index(index) for index in range(4))
+    prefixes = Counter(before)
+    source.rewind()
+    try:
+        while not prefixes.finished:
+            for merging in (False,True):
+                for a in range(2):
+                    intervening = Counter(middle)
+                    try:
+                        while not intervening.finished:
+                            for b in range(2):
+                                if merging:
+                                    copy_bits(buckets[inverse[2*a+b]],output,suffix)
+                                else:
+                                    copy_bits(source,buckets[2*a+b],suffix)
+                            intervening.decrement()
+                    finally:
+                        intervening.close()
+                if not merging:
+                    for bucket in buckets:
+                        bucket.rewind()
+            for bucket in buckets:
+                need(bucket.read() == BLANK, "complete bit-gate bucket")
+                borrowed_tape(bucket).clear()
+            prefixes.decrement()
+        need(source.read() == BLANK, "complete bit-gate source")
+        source.clear()
+        output.rewind()
+        return output
+    except BaseException:
+        output.clear()
+        raise
+    finally:
+        for value in (before,middle,suffix,prefixes):
+            value.close()
+        for bucket in buckets:
+            bucket.clear()
+
+
+def flip_digit(source, plan, position, factory):
+    need(compare(position,plan.bits) < 0, "selected address bit exists")
+    one, tail = Count.literal(1),subtract(plan.bits,position)
+    after_bits = subtract(tail,one)
+    before, after = power_two(position),power_two(after_bits)
+    suffix = Count.product(after,plan.record_bits)
+    for value in (one,tail,after_bits,after):
+        value.close()
+    left,right,output = factory(),factory(),factory()
+    prefixes = Counter(before)
+    source.rewind()
+    try:
+        while not prefixes.finished:
+            copy_bits(source,left,suffix)
+            copy_bits(source,right,suffix)
+            left.rewind()
+            right.rewind()
+            copy_bits(right,output,suffix)
+            copy_bits(left,output,suffix)
+            need(left.read() == right.read() == BLANK, "complete flip pieces")
+            borrowed_tape(left).clear()
+            borrowed_tape(right).clear()
+            prefixes.decrement()
+        need(source.read() == BLANK, "complete flip source")
+        source.clear()
+        output.rewind()
+        return output
+    except BaseException:
+        output.clear()
+        raise
+    finally:
+        for value in (before,suffix,prefixes):
+            value.close()
+        left.clear()
+        right.clear()
+
+
+def stable_radix(source, key_bits, record_bits, factory):
+    """LSD partitions on an encoded pass index and two reused physical buckets."""
+    position, passes = Count.literal(0),Counter(key_bits)
+    current = source
+    try:
+        while not passes.finished:
+            buckets, output = (factory(),factory()),None
+            current.rewind()
+            try:
+                while current.read() != BLANK:
+                    key = read_fixed(current,key_bits)
+                    try:
+                        bucket = buckets[bit_at(key,position)]
+                        write_fixed(key,bucket,key_bits)
+                        copy_bits(current,bucket,record_bits)
+                    finally:
+                        key.close()
+                current.clear()
+                output = factory()
+                for bucket in buckets:
+                    append_bits(bucket,output)
+                output.rewind()
+                current,output = output,None
+            finally:
+                for bucket in buckets:
+                    bucket.clear()
+                if output is not None:
+                    output.clear()
+            position.increment()
+            passes.decrement()
+        return current
+    except BaseException:
+        current.clear()
+        raise
+    finally:
+        position.close()
+        passes.close()
+
+
+def repair(source, plan, control, factory):
+    good,bad,holes = factory(),factory(),factory()
+    output = None
+    remaining,index = Counter(plan.records),Count.literal(0)
+    source.rewind()
+    try:
+        while not remaining.finished:
+            state = plan.decode(index)
+            try:
+                exceptional = control.bad(state)
+                holes.append(int(exceptional))
+                if exceptional:
+                    control.execute_state(state,plan,True)
+                    control.ideal_state(state)
+                    destination = plan.encode(state)
+                    try:
+                        write_fixed(destination,bad,plan.bits)
+                        copy_bits(source,bad,plan.record_bits)
+                    finally:
+                        destination.close()
+                else:
+                    copy_bits(source,good,plan.record_bits)
+            finally:
+                plan.close_state(state)
+            index.increment()
+            remaining.decrement()
+        need(source.read() == BLANK, "complete repair input row")
+        source.clear()
+        remaining.close()
+        index.close()
+        remaining,index = None,None
+        bad.rewind()
+        bad = stable_radix(bad,plan.bits,plan.record_bits,factory)
+        good.rewind()
+        holes.rewind()
+        output = factory()
+        remaining,index = Counter(plan.records),Count.literal(0)
+        while not remaining.finished:
+            hole = holes.read()
+            need(hole in (0,1), "one repair hole bit per complete record")
+            holes.step(1)
+            if hole:
+                destination = read_fixed(bad,plan.bits)
+                try:
+                    need(compare(destination,index) == 0, "sorted exceptional destination fills this hole")
+                    copy_bits(bad,output,plan.record_bits)
+                finally:
+                    destination.close()
+            else:
+                copy_bits(good,output,plan.record_bits)
+            index.increment()
+            remaining.decrement()
+        need(good.read() == bad.read() == holes.read() == BLANK, "complete repair reinsertion")
+        output.rewind()
+        result,output = output,None
+        return result
+    finally:
+        good.clear()
+        bad.clear()
+        holes.clear()
+        if output is not None:
+            output.clear()
+        if remaining is not None:
+            remaining.close()
+        if index is not None:
+            index.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/native_sources.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/native_sources.py
new file mode 100644
index 0000000000..3d2834c5ff
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/compact/native_sources.py
@@ -0,0 +1,56 @@
+"""Load the completed ordinary backend and immutable compact reference."""
+from hashlib import sha256
+import importlib.util
+from pathlib import Path, PurePosixPath
+import sys
+import tarfile
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+ARCHIVES = {
+    "pr2899": "fc4a2e07423835737c8fb3872664b16ff12aa4cf83b1e26e49878debef40c531",
+    "pr2250": "f7c4412bed944228e911c370d847d057a68d27b7d80aac86964b396df6a31756",
+}
+_temporary = None
+_loaded = None
+
+
+def module(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    result = importlib.util.module_from_spec(spec)
+    sys.modules[name] = result
+    spec.loader.exec_module(result)
+    return result
+
+
+def activate():
+    global _temporary, _loaded
+    if _loaded is not None:
+        return _loaded
+    if any(name in sys.modules for name in ("source", "loader", "words", "streams")):
+        raise ValueError("cold compact/ordinary namespace")
+    _temporary = tempfile.TemporaryDirectory(prefix="physical-compact-")
+    paths = {}
+    for name, digest in ARCHIVES.items():
+        archive = HERE / "inputs" / (name + ".tar")
+        if sha256(archive.read_bytes()).hexdigest() != digest:
+            raise ValueError("immutable source archive: " + name)
+        destination = Path(_temporary.name) / name
+        with tarfile.open(archive, "r:") as contents:
+            seen = set()
+            for entry in contents.getmembers():
+                path = PurePosixPath(entry.name)
+                if path.is_absolute() or ".." in path.parts or entry.name in seen or not (entry.isfile() or entry.isdir()):
+                    raise ValueError("regular relative source archive")
+                seen.add(entry.name)
+            contents.extractall(destination, filter="data")
+        paths[name] = destination
+    source = module("source", paths["pr2899"] / "source.py")
+    source.ROOT = ROOT
+    source.activate()
+    sys.path.insert(0, str(paths["pr2899"]))
+    module("streams", paths["pr2250"] / "streams.py")
+    reference = module("compact_reference", paths["pr2250"] / "compact.py")
+    _loaded = source, reference
+    return _loaded
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/PROOF.md
new file mode 100644
index 0000000000..96b032f662
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/PROOF.md
@@ -0,0 +1,601 @@
+# Encoded whole-row dispatch for the retained occurrence compiler
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+
+## 1. Proposition, source boundary, and novelty
+
+Fix one finite uniform template produced by the retained chronological
+product, completion/splitting and integer compiler. Write its final rank,
+productive width, conservative owned inventory and ordinary paid count as
+`N >= 2`, `W >= 1`, `O >= 0`, and `P`. These are constants before the numerical
+input varies. They are not the raw P104 width or its local private peak.
+Fix its complete native services and finite list of physical field IDs.
+
+**Row/occurrence dispatch theorem.** Given an admissible encoded complete-row
+descriptor, the fixed tables in `row_programs.py` implement exact whole-row
+division and reassembly for every fixed positive divisor, physically produce
+the quotient row and stock descriptors, and update the ordinary numerical
+child geometry `e -> floor(e/N)`. They preserve complete front/back control
+fields, every spectator bit plane, the selected offset `rho`, and the parent's
+descriptor. The source binder in `compiler_routes.py` connects these services
+to the actual flat compiler event grammar: compiler-internal matched fields
+receive complete coordinate routes and inverse returns, while only final
+ordinary rank-one calls consume row stock. The local time and backing bounds
+in sections 8 and 9 hold at every input size in the stated domain. There is
+no extra row-address-width, recursion-depth, or `e` factor in the row-copy toll.
+
+This refines a specific retained boundary. The older full physical controller
+(#3385), complex compact package (#3055), literal two-role parking caller, and
+physical row padding package already provide substantial infrastructure. The
+two-role caller takes a supplied row guide. The padding package already proves
+amortized linear binary-to-unary conversion; its implementation is retained
+byte for byte. The new work is the arbitrary final divisor, encoded descriptor
+production, canonical encoded-zero padding, ordinary geometry update, and
+binding to the current source's distinct matched-occurrence and ordinary-child
+events. It is not a new generic existence proof for leaves or controllers.
+Earlier raw reservations in #5480 and generic allocation/backing work in
+#5814 are also predecessors, not new claims of this package.
+
+The occurrence package #6878 supplies the geometric extension and symbolic
+tariff. Here each added transposition becomes six charged selected-XOR records,
+three on entry and three on return. Its native, monomial, compact and all-column
+premises remain. The owned lifecycle export supplies physical initialization,
+COPY-as-ADD, suspension, output preservation and parent restoration. Its proof
+is not replaced by a row-count argument. Exact source bytes, Git object IDs
+and SHA256 values are in `DEPENDENCIES.json` and `SOURCES.json`.
+
+The selected record remains #6030 with
+`kappa = 781451/250000000 = 0.003125804`. All five selected framework assumptions
+remain recorded. This theorem supplies a narrower implementation implication
+under explicit retained interfaces. Finite execution supports the written
+proof; it is not a proof-assistant admission or a complete multiplier replay.
+
+## 2. Complete rows and the descriptor ABI
+
+A physical field has the serialization
+
+`[outer prefix c in 0..C-1][row ordinal u in 0..R-1][complete row v in 0..J-1]`.
+
+Here `C,R,J` are positive. A complete row contains `2^a` numerical records,
+each of exactly `b` physical bits, so `J=b*2^a`. It includes every front control,
+active coordinate, back control, spectator and record suffix, rather than one
+representative of a control fibre. Volume `V=CRJ` counts actual physical bits.
+The general splitter needs the complete row length. Geometry specialization
+also uses its valid factorization `a,b` and the complete numerical format.
+
+The current lifecycle alphabet is physical `0,1,LEFT=2,SEP=3,END=4,BASE=5,BLANK=6`.
+Payload bodies contain physical bits only. Numerical virtual symbols use
+three physical bits; component delimiter 2 is `010`. The row tables operate
+on physical bits through `PhysicalPort` and never treat virtual blank code
+`100` as the physical frontier. Payload origins follow `LEFT`; bridge and
+staged-header origins follow `BASE`. All exposed heads enter and return at
+their own origins. Physically distinct tapes are an ABI premise, not an
+uncharged runtime pointer comparison.
+
+For two signed components of fixed root width `w`, one Gaussian record has
+`b=6*(w+1)` physical bits, including both terminators. The common-grid supplier
+chooses `w`; it stays fixed through ordinary recursion. The ideal precision
+parameters of #6900/#6901 and their error/overflow obligations remain separate
+from this exact encoding compatibility.
+
+There are forty fixed row work ports, one row descriptor port, and the `W`
+already declared public ports. Lifecycle bridge/header ports are reused. No
+new tape is allocated at a recursive call. A finite template may have a large
+constant tape inventory, independent of input size and recursion depth.
+
+Each descriptor integer is canonical least-significant-first binary, including
+the single symbol `0` for zero. For binary length `ell`, the header writes
+`1^ell 0` followed by the `ell` digits. Its twenty-three entries are:
+
+| Entry | Meaning |
+| --- | --- |
+| `outer`, `rows`, `stock`, `row_bits` | Positive `C,R,S,J` at a row invocation |
+| `within_bits`, `record_bits` | Complete-row factorization `a,b` |
+| `p,d,K,G,H,q0,qF,qB,D` | Fixed global precision/layout/reservation parameters |
+| `f` | Width of each rank-one block of the current uniform program |
+| `rho` | Selected bit plane, `0 <= rho < K` |
+| `active_start` | Current `N*f` rectangle start, within the complete row |
+| `back_start` | Fixed complete back-control start, within the row |
+| `selected_axes` | Current ordinary input width `e` |
+| `entry_start` | Start of the ordinary input's `e` chunks, within the row |
+| `remainder` | `r=e mod N` at an internal ordinary node |
+| `cutoff` | One certified global integer phase cutoff `t >= N` |
+
+**All three starts are within-row coordinates.** The root producer converts
+the source's global offsets once: `entry_start=o-q0*K` and
+`back_start=z-q0*K`. Front fields begin at within-row coordinates 0 and `H`.
+After padding or division, `rows` need not be a power of two. Nothing subtracts
+a new `ceil(log2(rows))`, changes `q0`, or moves a control field after an imagined
+new binary row prefix. Row ordinal and within-row coordinates remain a pair.
+
+An admissible root header certifies the source's complete geometry and compact
+domain, including `H=dG`, the full two front and one back control fields,
+`entry_start >= 2H`, `entry_start+e*K <= back_start`, `back_start+H <= a`,
+the record-fibre conditions and every numerical provider's size/precision
+guards. The tables check header syntax, positive extents, exact divisibilities
+and the cutoff lower bound. They do not re-prove every mathematical precondition
+of the root parameter producer. The selected global parameters, stock law and
+phase cutoff remain an explicit caller premise. The new root table physically
+derives `J,f,r,active_start`; these are not obtained by host integer decoding.
+Those derived fields in a root preheader may be canonical placeholders;
+the root table overwrites them before that header is used for routing.
+
+Each numerical provider must return exactly the same encoded extent and
+component boundaries, with physical `BLANK` immediately after it. Temporary
+encoded virtual blanks beyond that frontier must be removed by its charged
+return routine. This is necessary for the router and current `CodedPort`
+implementation to compose.
+
+## 3. Literal split, inverse, and complete stock
+
+For a fixed divisor `g >= 1`, assume `g | S` and `S | R`. Put `Q=R/g` and
+`S'=S/g`. The child retains all fields except the row/stock quotients and, in
+numerical mode, the ordinary geometry of section 4. The literal split is
+
+`(c, u=g*q+w, v) -> role w at (c,q,v)`.
+
+This is a bijection for `w<g,q<Q,v<J`. Each role receives `CQJ` physical bits
+and the same complete within-row rectangle.
+
+`compile_prepare(g)` scans canonical encoded row and stock counts using
+finite-state binary division by constant `g`. It starts at the highest digit.
+State `h in 0..g-1` is the remainder; input bit `x` emits quotient bit
+`floor((2h+x)/g)` and enters state `(2h+x) mod g`. The quotient bit is 0 or 1.
+Exact division returns only at remainder zero, trims leading quotient zeroes,
+and requires a positive quotient. The `g` remainder states are finite control,
+not an input-dependent register.
+
+`compile_router(g)` decodes the child header, builds unary guides of lengths
+`C,Q,J,S'` with the retained decoder, and verifies `S' | Q` by traversing the
+row guide and cyclic stock guide together. Each stock rewind is charged to
+consumed stock marks. It scans in order `c,q,w,v`: the source advances through
+one complete row, role `w` receives every bit, and the `J` guide rewinds at
+the row end. Role numbers are static states. Source and header are preserved;
+all guides, decoded integers and temporary words are erased.
+
+The merger uses the same order with source and destination exchanged. It
+copies every bit of every role to a distinct return bridge and erases the
+consumed role bits. It is exactly the inverse index equation, including all
+controls and spectators. Exact physical frontier checks reject short or extra
+packets. All heads return to local origins. These are success-domain machines;
+malformed-header rejection does not promise arbitrary transactional rollback.
+
+The stock invariant is
+
+`S | R and g | S  =>  (S/g) | (R/g)`.
+
+Consequently the product of all unreleased divisors on a nested path must
+divide the original stock. Iterate in actual call order and restore parent
+descriptors on return. A maximum factor is insufficient: nine rows can be
+divided by 3 twice, but stock `max(3,3)=3` is exhausted at the first division;
+stock 9 supports both. Independent factors 2 and 3 likewise cannot be replaced
+by 3.
+
+A retained source-style sufficient reservation is
+
+`S0=[W*(O+1)]^L*S_other`, where `N^L >= 2d`.
+
+A different schedule may use a smaller justified stock, but each actual path
+product must divide it. Reserving `O+1` row labels does not initialize private
+memory, convert productive input to erased scratch, or create output credit.
+The owned lifecycle proof supplies those actions. Compiler-internal matched
+occurrences below consume no further row factor.
+
+## 4. Ordinary geometry and the actual phase leaf test
+
+At an internal node of encoded width `e` and entry `s`, write
+
+`e=N*f+r`, `0 <= r < N`, `active_start=s+r*K`.
+
+The required remainder service completes the `r` elementary selected kernels
+at chunks `[s,s+r*K)` on **every** complete public field. The uniform program
+then acts on its `N` blocks of `f` chunks, selecting the same `rho` in each.
+The remainder's numerical/physical proof and charge remain separate; an
+identity test fixture cannot admit it. Complete-row splitting commutes with
+this rowwise map, so `install` may invoke it after public splitting and
+descriptor installation.
+
+Before an ordinary rank-one call, the source-emitted axis route makes the
+requested `f`-chunk block canonical first. A recursive child has
+
+`e_child=f`, `entry_child=active_start_parent`,
+`f_child=floor(e_child/N)`, `r_child=e_child mod N`,
+`active_start_child=entry_child+r_child*K`.
+
+`derive_geometry` copies old `f` to `selected_axes` and old `active_start` to
+`entry_start`. Fixed-rank binary division emits the child quotient/remainder.
+At most `N-1` encoded additions form `r_child*K`, then one addition forms the
+active start. The work is a finite `N`-dependent constant times descriptor
+length. There is no loop over the decreasing ordinary width `e_child`.
+
+The child fits because
+
+`active_start_child+N*f_child*K = entry_child+e_child*K`,
+
+which is inside the parent's first requested block and hence its active
+rectangle. Fixed front/back geometry and `a,b,J,d,D,H,K,rho,q0,qF,qB` survive.
+Completed remainder coordinates remain arbitrary spectators. The parent's
+complete encoded descriptor is parked and restored byte for byte.
+
+At root, `compile_prepare(...,root=True)` retains `selected_axes=e` and the
+supplied within-row entry. It derives `J=b*2^a` by repeated binary doubling
+and emits the same `f,r,active_start` equations. The root width factor is
+consumed only after receiving a padded row count and stock divisible by `W`.
+The root parameter/padding producer stages that count in the header; its
+actual staging and parameter construction are separately billed.
+
+The selected deferred schedule (#6115) uses one phase cutoff
+`s_phase=max(N,h^eta)`, `eta=1/1400000000`, shared by descendants. For integer
+widths define `t=max(N,floor(h^eta))`. A requested child is elementary exactly
+when `f <= t`. `compile_leaf(N)` decodes the header, checks `t >= N`, and
+compares encoded `f,t`. Least-significant-first comparison retains the sign
+of the latest differing bit, which is the highest differing bit at the end;
+unequal canonical digit lengths determine their order. The descriptor is
+preserved and all work erased before returning a finite Boolean terminal.
+`prepare` rejects recursive descent when `f <= t`.
+
+Elementary children and the root branch `e <= t` retain the source leaf
+providers. `StockLeafFixture` is explicitly a structural integration fixture,
+not the numerical stopping condition. Root geometry, child geometry and leaf
+comparison are distinct executable tables and distinct test groups.
+
+## 5. Actual source grammar and charged occurrence routes
+
+The exact owned-lifecycle source lowerer refines #5443's unchanged compiler.
+It emits actual physical IDs, unique occurrence-owned banks, complete ordered
+matched field lists, source-complement and deepest-exit brackets, private
+lifetime actions, and explicit elementary-axis brackets. Raw unit/native
+wrapper services retain their precise identities; their endpoints are not
+replaced by a rank profile.
+
+For the selected raw source, complete ambient 145 equals maximum target rank
+145; its authenticated current lifecycle receipt binds that fact for all
+13,444 productive roles. Chronological products multiply both quantities,
+completion keeps the maximum target, and paid-job splitting changes no target.
+Thus the prepared selected unit retains equality between complete ambient and
+the compiler's maximum-target parameter. The source column fit applies to
+that actual ambient. A different unit with a larger declared ambient needs a
+separate fit check; rank equality itself is not an address adapter.
+
+There are two invocation kinds:
+
+| Kind | Physical input | Row action |
+| --- | --- | --- |
+| `MATCHED_FIELDS_OCCURRENCE` | Complete ordered list of existing distinct fields, with the actual borrowed owner for each role | Preserve fields and stock; emit full coordinate entry/return routes |
+| `SINGLE_OWNER_ROW_CHILD` | One final ordinary rank-one owner's complete field | Divide into final `W` public fields, update ordinary geometry, recurse or invoke the leaf, merge every output on return |
+
+The public `sites` map admits only the second kind to ordinary row descent.
+Compiler substitution is flattened into one fixed finite word. It creates
+no numerical runtime frame and consumes no stock. A finite program counter
+retains static compiler contexts. Only input-dependent ordinary recursion
+uses the physical continuation stack.
+The source lowerer's pending set becomes empty when its last deepest-exit
+batch is issued. Synchronous construction and the inverse-return service
+sequence, not that empty set alone, enforce completion before the parent
+fragment or owned cleanup resumes.
+
+The binder reads these source token forms without inventing owners:
+
+* `program-enter/return` carries the complete `matched-program` field list and
+  exact role index. A source complement of rank `n` in parent rank `m` uses
+  `[m-n,m)`. A deepest exit uses normalized first `n` coordinates supplied by
+  its retained paid-job normalizers.
+* `occurrence-enter/return` carries actual occurrence ID, lattice copy, point,
+  column, enclosing rank and raw role. At column `c`, target `k*c` uses the
+  first `k*c` coordinates and full unit ambient is `m*c`. The fit
+  `m*c <= enclosing_rank <= N` is checked. Retained normalizers make the
+  issuing job canonical before its child occurs.
+* `base-axis-enter/return` contains the actual terminal ordinary token,
+  physical owner, axis and enclosing rank. It routes that axis to coordinate
+  zero before the unchanged rank-one `PAID` and restores it after return.
+  Axis zero may have an empty route. A later axis is not free merely because
+  its rank is one.
+
+For a requested ordered list `A`, the complete permutation is `A` followed by
+its increasing complement in `0..N-1`, exactly #6878's construction. The first
+complete child ambient positions form its frame; the remaining positions stay
+present. If the parent chart is `B`, the child chart is `B[order[i]]`. Full
+parent charts and inverse swap words are compile-time descriptors, not an
+input-dependent Python stack. The binder verifies complete parent restoration
+on every nested return. All descriptors become fixed constants with the
+template.
+
+A block swap `(a,b)` is the selected-XOR word
+`b ^= a; a ^= b; b ^= a`, applied to all `f` selected columns at fixed `rho`.
+Three records implement the transposition. Reversed swaps supply the inverse
+with another three records. An entry/return pair with `t_occ` entry swaps
+therefore emits exactly `6*t_occ` records. Each record names two fixed block
+numbers and reads runtime `f,K,rho` and the within-row start through the
+protected encoded descriptor. It invokes the retained compact service and
+pays its tariff. It is not a host-list permutation or an all-`K` plane sweep.
+
+All matched fields are routed before a complete native class word executes,
+so scalar contacts see common canonical coordinates. Every route is undone
+before the enclosing word resumes. Whole-job binary monomial normalizers and
+quadratic phases remain separate charged native services; their prices are
+not replaced by the coordinate-permutation tariff. Product and completion/
+splitting service endpoints retain #6878's construction. The new binder
+refines the integer-compiler/elementary-axis grammar; it does not implement
+every raw monomial provider.
+
+The original source event stream remains in order, including descriptor-only
+enter/return services after their routes are lowered. The separate flat
+ownership replay can therefore check the original owners and LIFO borrows.
+Added routing changes neither paid count, rank nor owner. Rebinding an already
+routed word rejects, as do missing elementary-axis brackets.
+
+A matched occurrence must not be row split. For example, fields `00` and `11`,
+each of two one-bit rows, would be mistaken for packet `0011`. The actual
+`g=2` table returns `01` and `01`. Field count, field size, total bit count and
+nominal rank can agree while physical owners change. This is a counterexample
+to that proposed wrong composition, not an allegation about the source.
+
+## 6. Canonical zero padding and exact restriction
+
+Let the complete root divisor be `S0`. The accelerated branch requires
+`R0 >= S0`, alongside every layout/source guard. Pad once to
+`R'=S0*ceil(R0/S0)`. Then
+
+`R0 <= R' < R0+S0 <= 2R0`.
+
+If `R0 < S0`, reject this branch or invoke its declared elementary fallback.
+Padding to `S0` then does not retain the factor-below-two bound.
+The caller establishes the valid-volume fit before invoking this wrapper;
+malformed-input rejection is not assigned the successful `V0` bound.
+
+In the common numeric encoding, a zero Gaussian record retains component
+delimiters while its value bits are zero. Its physical string is not all
+zeros. Let `Z` be a complete canonical zero row of length `J`. It can be
+produced by a charged copy of one complete source row as shape and the owned
+initializer, which maps numeric symbols to zero and preserves terminators.
+Both scans have length `J`. A different producer must supply its actual cost
+`T_Z(J)` and backing `S_Z(J)`. The immutable zero row is not constant-size.
+
+`pattern_padding.py` retains the predecessor's decoder, cover test, round-up
+planner, genuine-row scans and cleanup. Only the added-row writer/restrictor
+changes. Padding traverses `Z` in lockstep with the complete `J` guide,
+appends whole patterns after each outer prefix's genuine rows, and rewinds
+both guides. Restriction requires every returned added row to equal `Z` and
+copies genuine rows to a distinct output. The complete pattern is validated
+even when no padding is needed. Extents, marker checks, writes, comparisons,
+movement, rewinds and cleanup are actual instructions.
+
+The endpoint premise is a **completed zero-preserving rowwise numerical map**,
+with identity on row ordinals, complete controls/spectators restored, valid
+extent and borrowed input/descriptor restoration. A completed linear map with
+this rowwise action supplies the zero property. Local pattern checks alone
+do not establish semantics: an incorrect callee could zero the genuine rows
+and still pass. Rounded residuals cannot be silently deleted. Exact canonical
+zero return, or a separately proved rounded restriction contract, is required.
+Each selected deferred phase restricts before inverse exposure and the next
+phase; this construction does not multiply padding factors over phases.
+The borrowed zero pattern also returns unchanged, with its head at its
+origin. Local comparisons do not prove this promise for an arbitrary callee.
+
+## 7. Physical composition with the owned lifecycle
+
+At a nonleaf ordinary `PAID`, the owned controller makes a charged
+administrative bit copy of that actual owner's field to its distinct `BASE`
+bridge. `prepare` reads the protected active descriptor and emits the child
+header on the staged `BASE` tape. The controller parks all fixed payload ports,
+including the complete parent header, using the delimited stack. Row work is
+already blank. A finite saved PC identifies the actual caller owner.
+
+`install` splits the bridge into the ordered public ports, copies the staged
+binary header to the child descriptor origin, and invokes the required
+elementary remainder service in numerical mode. The controller retires bridge
+and staged header. Native tables access the runtime descriptor through a
+counted read-only raw `BinaryContextPort`, distinct from coded numerical
+views. Every numerical and row head returns to its local origin.
+
+On return, `collect` first merges **all** child public outputs into the protected
+bridge and retires their bodies. The controller retires other child payloads,
+pops the continuation, reads its saved PC, erases the designated old owner,
+and copies the preserved bridge to it. The parent's header returns from saved
+bytes. Popping before output preservation would lose the child result and is
+not permitted by the interface.
+
+The row service does not implement private initialization, scalar COPY,
+dirty-bank erase, numerical rounding or suspension. The owned machine does
+not prove geometry merely by preserving an opaque header. Their contracts
+meet at exact physical encoding, extent, origin, public field order, protected
+metadata and invocation kind. All fixed scratch ports join the suspension
+inventory even when blank at the boundary. No hidden host address, dynamic
+saved frame object, or uncounted field-length slice is a runtime operation.
+
+## 8. All-size local time, including guide construction
+
+Count one emitted local read/branch, one-cell write, unit move, or fixed jump
+as one step. A fixed interpreter or tape encoding changes constants only.
+Let `E` be the larger of the complete incoming and produced header lengths
+(root production of the potentially longer encoded `J` is also charged to
+`J` below), and define
+
+`c(N,g)=2^16*(N+g+1)`.
+
+For row-only mode take `N=2`. A prepare/split/merge bundle and its descriptor
+copies cost at most
+
+`c(N,g)*(V+E+1)`
+
+on the admissible success domain, excluding numerical/remainder services and
+the owned bridge/continuation actions. This deliberately loose bound follows
+from table-level accounting, not fixture elapsed times:
+
+1. Fixed-schema encode, decode, copy, clear, positive validation, division and
+   comparison each make a bounded number of scans. Twenty-three fields and
+   forty work ports are fixed. `1024*(E+1)` per descriptor-only invocation
+   covers its scans, canonicality, quotient trim and origin checks.
+2. The retained converter performs `n` consecutive binary decrements. If
+   `z(t)` counts low zero digits, then
+   `sum_{t=1}^n z(t)=sum_{j>=1} floor(n/2^j)<n`. Rewind follows only the borrow
+   chain just crossed. The exact predecessor table bound is `60n+40`, including
+   copy, trim and rewind. Guides `C,Q,J,S'` cost at most `240V+160`, since
+   `S'<=Q` and every extent is at most `V`. There is no full binary `Count(J)`
+   scan per payload bit.
+3. The `Q,S'` divisibility scan is linear in `Q`: each stock rewind is charged
+   to its consumed cells. The payload loop has a fixed number of instructions
+   per bit, and its `J` rewind costs `3J+O(1)` per row. Row/prefix loops and
+   output rewinds are linear in `V`. `1024*(V+E+g+1)` for either split or merge
+   covers those loops, guide/descriptor cleanup, role checks and frontiers.
+4. Ordinary geometry performs one fixed-`N` division and at most `N-1`
+   additions of `K`, plus one entry addition, on `O(E+1)` digits. The allocation
+   `1024*(N+1)*(E+1)` covers these operations, temporary copies/erases and
+   cutoff comparison. Finite remainder states depend on `N`, not `e`.
+5. Root extent construction starts from binary `b`, doubles `a` times, and
+   pays for a unary guide for `a`. Its cost is
+   `O(a*ell(b)+a^2+a+ell(b)+1)`. Since `ell(b)<=b`, `a<=2^a`, and
+   `a^2<=2^(a+1)`, it is `O(b*2^a+1)=O(J+1)`. Deriving `J` therefore hides no
+   factor `log J` on a full-row scan, even when `log J` is polynomial in `p`.
+
+The displayed coefficient dominates the sum, including finitely many
+descriptor copies and the leaf test. Separate prepare/split/merge calls may
+instead each be billed with the same generous coefficient. Template/table
+compilation costs one fixed `F_T`. It is not charged to the historical raw
+`10^9` allowance. All count-dependent work occurs on encoded tapes. Small
+fixed `N,g` fixtures do not limit the theorem or claim a feasible materialization
+of the selected astronomical word.
+
+Pattern padding costs at most `4096V0+4096`, excluding `T_Z(J)` and the callee,
+where `V0=C*R0*J`. The predecessor bound is `2048V0+2048`. Pattern validation,
+reads/moves and its second guide rewind add a constant number of steps per
+appended/checked bit and one full `J` scan, fitting the doubled allowance.
+The hypothesis `S0<=R0` remains necessary.
+
+Coordinate routes have a separate exact finite invoice. If binding `j` uses
+`t_j` entry swaps, charge `6*t_j` selected compact-XOR services on the actual
+complete field. With retained bound `C_X*v*((f*G)^tau+1)`, added routing is
+the **sum** of these charges at actual field volume `v`. Raw native, monomial,
+phase, scalar, elementary and owned services retain their complete bills.
+Equal ranks never make value movement free.
+
+## 9. Backing, complete global invoice, and selected implication
+
+At a successful row invocation, decoded binary words occupy `O(E)` cells;
+unary guides occupy at most `C+Q+J+S'<=4V`; prepared header occupies `O(E)`;
+destination roles together occupy `V`; merger bridge occupies `V`. A generous
+fresh-interval bound `128*(V+E+g+1)` includes markers, guards and temporary
+words. Root padding uses at most `128*(V0+1)+S_Z(J)`, including zero-row backing.
+
+These are fresh active-interval bounds, not claims that erasure shrinks
+previous backing. For each reusable work port `i`, let `M_i` be the maximum
+extent ever visited. Retained backing is pre-existing backing plus `M_i` up
+to a fixed guard. Across repeated calls charge these historical maxima for
+the forty fixed work ports, not the current smaller extent. Parent payloads
+and headers are parked and charged by the owned lifecycle inventory. Blank
+row ports still acquire physical frame delimiters, included in that lifecycle
+bill. Numerical provider scratch/backing remain separate explicit terms.
+
+A complete favorable invoice before asymptotic absorption is
+
+`T_total <= F_T + G_root + T_Z(J) + 4096*(V0+1)`
+
+`            + sum_{ordinary invocations nu} c(N,W)*(V_nu+E_nu+1)`
+
+`            + T_owned + T_remainders + T_leaves + T_native_original`
+
+`            + sum_{emitted route records j} T_compact(j)`.
+
+The row-invocation sum includes the initial root split when that entry is
+used. If the retained recurrence `T(e,U)` measures the complete incoming
+ordinary packet, its `W` public fields each have volume `U/W`. Every paid
+rank-one child receives one such packet, hence the source child volume
+`U/W` is unchanged. An active header counts rows in each current public
+field; a root preheader counts the unsplit root packet. These distinct
+conventions explain the root/ordinary versions of `prepare`.
+
+`G_root` is the actual selected descriptor/stock/cutoff/padded-count producer,
+not host integer arithmetic. `T_owned` includes bridges, private lifecycles,
+suspension, protected return and header restoration. Every term is implemented
+here or names an explicit retained provider. Backing adds actual owned
+continuation backing, numerical provider backing, root padding/zero-row
+backing, and historical maxima of fixed row work. These are not all inferred
+from `V` without a contract.
+
+The frozen owned-lifecycle supplier makes `T_owned` concrete. For one ordinary
+descent/return, let `S_body` be total parent body length, `C_body` total child
+body length just before retirement, `L_in,L_out` the owner bridge lengths,
+`E_child` staged header length, `q` fixed payload ports, and `b_PC` fixed
+return-PC bits. Its exact administrative physical-action bill is
+
+`4*S_body+5*C_body+18*L_in+13*L_out+5*E_child+38*q+27*b_PC+103`.
+
+This excludes row callbacks and leaf/top tests, already separately listed.
+Add each actual INIT at `5*D_dirty+25*n_symbols+17`, COPY addition at
+`35*n_value_bits+26*n_terminators+14`, and dirty retirement at `5*L+7`.
+Native work is retired before/after each service and at root cleanup using
+those same actual-length charges. Each parent-top test costs 3. Native table
+steps cost at most thirteen physical actions each, plus explicit final port
+rewinds `2*h+3` and auxiliary retirement. Fixed control transitions add a
+template-dependent multiple of event counts. These positive summands provide
+the administrative invoice without assuming private contents numerically zero
+or treating erased backing as deallocated.
+
+For the favorable retained caller, complete record precision covers its
+short global parameter encodings, stock fits the root row range, and header
+length is `O_T(V+polylog p)`. Although `ell(J)` can be large, `ell(J)<=J<=V`.
+Fixed-root precision and the root producer must justify the other descriptor
+bounds. Under #6878's current-volume and compact contracts, the new linear
+terms and finite sum of selected-XOR charges fit its ordinary node tariff by
+enlarging a fixed coefficient. They change neither `P/W`, width recurrence,
+nor exponents.
+
+The selected deferred proof #6115 has `mu_tau<2^-94010` and
+`mu_sigma<2^-47005`. Its internal tariff already includes movement, owned
+storage, restoration and fewer than `N` elementary remainders. Substituting
+this linear physical row interface changes finite constants and the eventual
+threshold, provided the other providers meet their bills. It does not alone
+establish the full physical/precision/compiler assumption, an unconditional
+multiplier, or a new `kappa`.
+
+## 10. Executed evidence and limits
+
+The registered checker authenticates dependency bytes before import. It runs
+the row tables normally and under Python `-O`, with explicit checks rather
+than removable assertions. Coverage includes fixed divisor examples,
+translated origins, retained blank backing, genuine coded numeric records,
+non-power-of-two quotients, full output merge and role retirement. Encoded
+geometry tests cover long integers, root extent, cutoff boundaries, and an
+actual table mutant that omits the geometry update.
+
+The source-route checker uses actual outputs of the frozen source lowerer
+and a separate coordinate oracle. That oracle forms complements independently
+and applies emitted selected XORs to GF(2) coordinate masks. It checks all
+selected columns and complete controls/spectators at native boundaries.
+Deleting a nonzero-axis route, omitting an inverse XOR, or changing an actual
+owner rejects. The tested raw unit is a compiler-control fixture with private
+lifetimes, not a proposed Gaussian identity. Its native numerical endpoint is
+opaque in the placement test.
+
+The joined replay uses the exact frozen owned machine and real row service
+on two source-generated words. Its width-six structural case makes 72 ordinary
+children and 512 leaves per run through two stock divisions and includes
+compiler-private borrows. Its width-one rank-two case exercises the encoded
+width path `6 -> 3`, child remainder/start update and actual `f<=t` leaf test
+through a physical continuation. That fixture checks descriptor arithmetic,
+not the selected compact-domain parameter inequalities. Both run twice on
+retained backing and compare every productive output to a separate value
+interpreter. Native/coordinate services are identity fixtures, with a literal
+cyclic value-bit leaf and counted raw-context read in the remainder fixture.
+The join establishes physical ABI composition; the separate route oracle
+checks coordinate meaning. No Gaussian or precision admission is inferred.
+
+Counterexamples exercise the actual row table on an incorrect matched-field
+composition and exhausted repeated stock. They explain why invocation kind,
+owner identity and path-product divisibility are required; they do not refute
+a retained theorem. Independently written reviewer interpreters add nested-row
+and geometry evidence. Their exact executed scripts/logs, when included, are
+independent checks of this scoped implication, not full theorem acceptance.
+
+## Open next questions
+
+1. Bind the selected global phase descriptor/stock/cutoff producer to this
+   twenty-three-field ABI, including padded-count staging, and substitute its
+   actual all-size charge for `G_root`.
+2. Supply retained compact selected-XOR, raw monomial, native and elementary
+   remainder/leaf providers through the read-only context port, including
+   exact frontier restoration and full precision.
+3. Combine dispatcher and owned-lifecycle invoices with those providers and
+   the selected common-grid proof. This may strengthen the concrete machine
+   implication while retaining analytic recovery and every other unproved
+   selected hypothesis explicitly.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/TASK.json b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/TASK.json
new file mode 100644
index 0000000000..70bb2c54a6
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/TASK.json
@@ -0,0 +1,93 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "scope_change_reason": "Assigned seed53 compiler/physical interface scope: arbitrary final-divisor complete rows and actual occurrence/ordinary-child dispatch for #6878, preserving earlier generic controller and padding proofs.",
+  "actual_scope": "Prove and execute one current-source encoded whole-row/stock/ordinary-geometry dispatcher and its matched-occurrence route binding, under explicit root, native, precision and owned-lifecycle contracts.",
+  "bottleneck_link": "Replaces the source-compatible occurrence package supplied row-dispatch boundary by finite local tables and an exact physical ABI, without treating a census or finite replay as removal of a foundational assumption.",
+  "stop_rule": "Complete the scoped row/occurrence refinement, full favorable invoice, source pins and adverse controls; retain all numerical/root/analytic premises and stop before a new construction search.",
+  "evidence": "PROOF.md, RESULT.json, normal and optimized registered replay, independently authored nested-row/geometry/placement review where explicitly recorded.",
+  "author": "@CubeJerry",
+  "ai_assistance": "Substantial OpenAI assistance in research, proof development, implementation, tests and documentation; no independent human or proof-kernel admission claimed.",
+  "outcome": "completed",
+  "open_questions": [
+    {
+      "question": "Bind the selected root phase descriptor, stock, cutoff and padded-count producer to this encoded header.",
+      "why_it_matters": "The local dispatcher now produces child geometry, but its exact global input and G_root bill remain a caller contract.",
+      "first_step": "Start from the selected deferred phase and retained control-reservation producer; emit this twenty-three-field preheader with paid local arithmetic.",
+      "blocked_by": "Exact root producer and numerical provider binding, not finite template materialization."
+    },
+    {
+      "question": "Bind retained compact selected-XOR and elementary remainder/leaf services to coded fields and raw binary context.",
+      "why_it_matters": "Coordinate route records have explicit counts but numerical and full-format return providers remain retained premises.",
+      "first_step": "Supply one actual finite native table and prove encoding, complete spectator restoration, local frontier normalization, time and backing.",
+      "blocked_by": "Native ABI adaptation and common precision/error proof."
+    },
+    {
+      "question": "Combine the dispatcher and owned lifecycle bills with current native and precision suppliers.",
+      "why_it_matters": "A complete current-caller implication requires all positive invoice terms and exact endpoints together.",
+      "first_step": "Use the exact frozen lifecycle export and list the remaining providers without changing the selected assumptions prematurely.",
+      "blocked_by": "Independent source-bound native, root and numerical precision closure; analytic recovery remains separate."
+    }
+  ]
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/compiler_routes.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/compiler_routes.py
new file mode 100644
index 0000000000..5752189b8a
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/compiler_routes.py
@@ -0,0 +1,150 @@
+"""Bind source-generated flat compiler events to charged #6878 routes.
+
+This is finite template compilation, before runtime p, e, f and row counts.
+Actual owner IDs and source tokens are retained. Prepared for @CubeJerry with
+substantial OpenAI assistance. Apache-2.0.
+"""
+from dataclasses import dataclass
+from pathlib import Path
+import importlib.util
+import sys
+
+path=Path(__file__).resolve().parent/"row_programs.py"
+spec=importlib.util.spec_from_file_location("compiler_row_programs",path)
+r=importlib.util.module_from_spec(spec);sys.modules[spec.name]=r
+exec(compile(path.read_bytes(),str(path),"exec"),r.__dict__)
+
+
+@dataclass(frozen=True)
+class Event:
+    op: str
+    fields: tuple
+    token: tuple=()
+    rank: int=0
+
+
+def bind(unit,root_rank,raw_ambient,raw_roles):
+    """Refine the exact lower() grammar; retain original native scalar services.
+
+    Source complements target [s,n), exits canonical [0,n). Unit occurrences
+    use actual rank*column and full ambient*column. Each terminal axis receives
+    a prefix route/inverse at its explicit base-axis service boundaries. Original enter/
+    return tokens become descriptor-only identities after these XOR records.
+    They stay in the word so the independent ownership replay still applies.
+    """
+    r.need(type(root_rank) is int and root_rank>=2,"fixed uniform rank")
+    r.need(raw_ambient>=max(raw_roles.values()),"complete raw ambient")
+    fields={name for name,_ in unit.roles}|set(unit.owned)
+    identity=tuple(range(root_rank))
+    chart={field:identity for field in fields}
+    scopes={field:[] for field in fields}
+    output,bindings=[],[]
+    serial=total_swaps=paid=0
+    tags={}
+
+    def xor_events(field,swaps,which,source_token,number):
+        for a,b in swaps:
+            for x,y in ((a,b),(b,a),(a,b)):
+                output.append(Event("SERVICE",(field,),
+                    ("selected-bit-xor",number,which,x,y,source_token)))
+
+    def enter(field,positions,ambient,scope,source_token):
+        nonlocal serial,total_swaps
+        r.need(field in fields,"actual emitted physical field")
+        layout=r.occurrence(root_rank,tuple(positions),ambient)
+        before=chart[field]
+        after=tuple(before[i] for i in layout['order'])
+        number=serial;serial+=1
+        scopes[field].append((scope,before,layout,number))
+        chart[field]=after
+        total_swaps+=len(layout['entry'])
+        bindings.append(dict(id=number,field=field,source_token=source_token,
+            kind=r.MATCHED,scope=scope,parent_order=before,order=layout['order'],
+            active=tuple(positions),child_ambient=ambient,global_image=after[:ambient],
+            entry=layout['entry'],inverse=layout['return'],row_divisor=1))
+        xor_events(field,layout['entry'],"enter",source_token,number)
+
+    def leave(field,scope,source_token):
+        r.need(scopes[field] and scopes[field][-1][0]==scope,"source LIFO complete chart return")
+        _,before,layout,number=scopes[field].pop()
+        xor_events(field,layout['return'],"return",source_token,number)
+        restored=list(chart[field])
+        for a,b in layout['return']:
+            restored[a],restored[b]=restored[b],restored[a]
+        r.need(tuple(restored)==before,"actual inverse restores complete parent order")
+        chart[field]=before
+
+    for event in unit.events:
+        token=event.token
+        tag=token[0] if token else None
+        r.need(tag!="selected-bit-xor","source word must not be routed twice")
+        original=Event(event.op,event.fields,event.token,event.rank)
+        if event.op=="SERVICE" and tag in ("program-enter","program-return"):
+            r.need(len(event.fields)==1,"one actual program field")
+            field=event.fields[0]
+            binding,index=token[1:]
+            r.need(binding[0]=="matched-program" and binding[2][index]==field,
+                   "exact ordered matched-program owner")
+            kind=binding[1]
+            if kind[0]=="source-complement":
+                parent=kind[1][1];n=kind[2];start=kind[3]
+                r.need(start+n==parent<=root_rank,"source complement exact partition")
+                positions=tuple(range(start,parent))
+            else:
+                r.need(kind[0]=="deepest-exit","retained compiler program kind")
+                n=kind[3];positions=tuple(range(n))
+            r.need(1<=n<=root_rank,"positive smaller complete program")
+            scope=("program",binding,index)
+            if tag=="program-enter":
+                output.append(original);enter(field,positions,n,scope,token)
+                tags[kind[0]]=tags.get(kind[0],0)+1
+            else:
+                leave(field,scope,token);output.append(original)
+        elif event.op=="SERVICE" and tag in ("occurrence-enter","occurrence-return"):
+            r.need(len(token)==9 and token[1]=="occurrence","actual source occurrence token")
+            field,=event.fields
+            column,n,name=token[6:9]
+            r.need(name in raw_roles and type(column) is int and column>0,"source role/column")
+            ambient=raw_ambient*column;target=raw_roles[name]*column
+            r.need(target<=ambient<=n<=root_rank,"complete source unit fits program")
+            scope=("occurrence",token[1:])
+            if tag=="occurrence-enter":
+                output.append(original)
+                enter(field,tuple(range(target)),ambient,scope,token)
+                tags["unit-occurrence"]=tags.get("unit-occurrence",0)+1
+            else:
+                leave(field,scope,token);output.append(original)
+        elif event.op=="SERVICE" and tag in ("base-axis-enter","base-axis-return"):
+            field,=event.fields
+            ordinary=token[1:]
+            r.need(len(ordinary)==7 and ordinary[0]=="ordinary-rank-one",
+                   "explicit current elementary-axis source boundary")
+            axis,n=ordinary[-2:]
+            r.need(ordinary[2]==field and 0<=axis<n<=root_rank,"actual terminal axis/owner")
+            scope=("paid-axis",ordinary)
+            if tag=="base-axis-enter":
+                output.append(original);enter(field,(axis,),1,scope,token)
+                tags["terminal-rank-one"]=tags.get("terminal-rank-one",0)+1
+            else:
+                leave(field,scope,token);output.append(original)
+        elif event.op=="PAID":
+            field,=event.fields
+            r.need(event.rank==1 and len(token)==7 and token[0]=="ordinary-rank-one",
+                   "only actual terminal rank-one leaves consume rows")
+            r.need(scopes[field] and scopes[field][-1][0]==("paid-axis",token),
+                   "rank-one call occurs within its actual charged axis route")
+            output.append(original)
+            paid+=1
+        else:
+            if event.op in ("INIT","CLEAR"):
+                field,=event.fields
+                r.need(not scopes[field],"private lifetime after complete geometry return")
+            output.append(original)
+    r.need(not any(scopes.values()),"all finite compiler scopes return")
+    r.need(all(order==identity for order in chart.values()),"all complete root charts restored")
+    xor_count=sum(e.op=="SERVICE" and e.token and e.token[0]=="selected-bit-xor" for e in output)
+    r.need(xor_count==6*total_swaps,"complete literal address tariff")
+    r.need(sum(e.op=="PAID" for e in output)==paid,"paid profile unchanged")
+    return tuple(output),dict(source_events=len(unit.events),emitted_events=len(output),
+        route_pairs=serial,entry_swaps=total_swaps,selected_xor_records=xor_count,
+        paid_sites=paid,scope_kinds=dict(sorted(tags.items())),matched_row_divisors=0),tuple(bindings)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/row_programs.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/row_programs.py
new file mode 100644
index 0000000000..30ba41725f
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/row_programs.py
@@ -0,0 +1,593 @@
+"""Finite local row programs for a fixed compiled template.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+The source Builder/positive-binary decoder is retained byte for byte. Every
+runtime decision is a local-symbol branch in an emitted finite table.
+Numerical Python values occur only in template compilation or observers.
+"""
+from pathlib import Path
+import importlib.util
+import sys
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def load_source(relative, name):
+    path = Path(__file__).resolve().parent / relative
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    exec(compile(path.read_bytes(), str(path), "exec"), module.__dict__)
+    return module
+
+
+retained = load_source("vendor/row_padding.py", "row_dispatch_retained_padding")
+geometry = load_source("vendor/occurrence_geometry.py", "row_dispatch_retained_geometry")
+BLANK, LEFT, ZERO, ONE = "_", "|", "0", "1"
+
+# Inherited unary decoder uses TEMP=10. Roles are supplied, preallocated ports.
+SOURCE, OUTPUT, OUTER, ROWS, STOCK, ROWBITS = range(6)
+QUOT_ROWS, QUOT_STOCK, GUIDE_C, GUIDE_R, TEMP, GUIDE_J, GUIDE_S = range(6, 13)
+HEADER, CHILD_HEADER, LENGTH = 13, 14, 15
+SCHEMA = (
+    ("outer", OUTER), ("rows", ROWS), ("stock", STOCK), ("row_bits", ROWBITS),
+    ("within_bits", 16), ("record_bits", 17), ("p", 18), ("d", 19),
+    ("K", 20), ("G", 21), ("H", 22), ("q0", 23), ("qF", 24),
+    ("qB", 25), ("D", 26), ("f", 27), ("rho", 28),
+    ("active_start", 29), ("back_start", 30), ("selected_axes", 31),
+    ("entry_start", 32), ("remainder", 33), ("cutoff", 34),
+)
+OFFSET, CONSTANT = 35, 36
+FIRST_ROLE = 40
+ROW_CHILD = "single_owner_row_child"
+MATCHED = "matched_fields_occurrence"
+
+
+class Builder(retained.Builder):
+    def empty(self, tape):
+        ok = self.fresh("empty")
+        self.read(tape, {BLANK: ok})
+        self.mark(ok)
+
+    def seek_end(self, tape):
+        loop, step, end = (self.fresh("seek") for _ in range(3))
+        self.mark(loop)
+        self.read(tape, {ZERO: step, ONE: step, BLANK: end})
+        self.mark(step)
+        self.move(tape, 1)
+        self.go(loop)
+        self.mark(end)
+
+    def canonical(self, tape, positive=False):
+        """Canonical LSF binary; exactly '0' is the sole zero representation."""
+        first0, last0, last1, next0, next1, end = (self.fresh("canon") for _ in range(6))
+        self.read(tape, {ZERO: first0, ONE: next1})
+        self.mark(first0)
+        self.move(tape, 1)
+        branches = {ZERO: next0, ONE: next1}
+        if not positive:
+            branches[BLANK] = end
+        self.read(tape, branches)
+        self.mark(next0)
+        self.move(tape, 1)
+        self.go(last0)
+        self.mark(next1)
+        self.move(tape, 1)
+        self.go(last1)
+        self.mark(last0)
+        self.read(tape, {ZERO: next0, ONE: next1})
+        self.mark(last1)
+        self.read(tape, {ZERO: next0, ONE: next1, BLANK: end})
+        self.mark(end)
+        self.rewind(tape)
+
+    def copy(self, source, target):
+        self.empty(target)
+        loop, zero, one, end = (self.fresh("copy") for _ in range(4))
+        self.mark(loop)
+        self.read(source, {ZERO: zero, ONE: one, BLANK: end})
+        for label, bit in ((zero, ZERO), (one, ONE)):
+            self.mark(label)
+            self.write(target, bit)
+            self.move(source, 1)
+            self.move(target, 1)
+            self.go(loop)
+        self.mark(end)
+        self.rewind(source)
+        self.rewind(target)
+
+    def divide_constant(self, source, target, divisor, exact=True, remainder=None):
+        """Positive quotient; optional floor/remainder, all remainders finite."""
+        need(type(divisor) is int and divisor > 0, "fixed positive divisor")
+        self.canonical(source, positive=True)
+        self.copy(source, target)
+        self.seek_end(source)
+        self.seek_end(target)
+        self.move(source, -1)
+        self.move(target, -1)
+        state = [self.fresh("remainder") for _ in range(divisor)]
+        finishes = [self.fresh("division_done") for _ in range(divisor)]
+        common = self.fresh("division_common")
+        self.go(state[0])
+        for rem in range(divisor):
+            self.mark(state[rem])
+            branch = {bit: state[rem] + bit for bit in (ZERO, ONE)}
+            if rem == 0 or not exact:
+                branch[LEFT] = finishes[rem]
+            self.read(source, branch)
+            for value, bit in enumerate((ZERO, ONE)):
+                self.mark(state[rem] + bit)
+                quotient, following = divmod(2 * rem + value, divisor)
+                self.write(target, str(quotient))
+                self.move(source, -1)
+                self.move(target, -1)
+                self.go(state[following])
+        for rem in range(divisor):
+            self.mark(finishes[rem])
+            self.move(source, 1);self.move(target, 1)
+            if remainder is not None:
+                self.empty(remainder)
+                for bit in bin(rem)[2:][::-1]:
+                    self.write(remainder,bit);self.move(remainder,1)
+                self.rewind(remainder)
+            self.go(common)
+        self.mark(common)
+        self.seek_end(target)
+        self.move(target, -1)
+        trim, erase, done = (self.fresh("trim") for _ in range(3))
+        self.mark(trim)
+        self.read(target, {ZERO: erase, ONE: done})
+        self.mark(erase)
+        self.write(target, BLANK)
+        self.move(target, -1)
+        self.go(trim)
+        self.mark(done)
+        self.rewind(target)
+
+    def unary_zero(self, descriptor, output):
+        self.canonical(descriptor)
+        maybe,positive,zero,finish=(self.fresh("unary_zero") for _ in range(4))
+        self.read(descriptor,{ZERO:maybe,ONE:positive})
+        self.mark(maybe);self.move(descriptor,1)
+        self.read(descriptor,{BLANK:zero,ZERO:positive+"rewind",ONE:positive+"rewind"})
+        self.mark(positive+"rewind");self.rewind(descriptor);self.go(positive)
+        self.mark(zero);self.rewind(descriptor);self.go(finish)
+        self.mark(positive);self.unary(descriptor,output)
+        self.mark(finish)
+
+    def double(self, tape):
+        """Positive binary multiplication by two using one-bit pending control."""
+        states=(self.fresh("shift_zero"),self.fresh("shift_one"))
+        end=self.fresh("shift_done")
+        self.go(states[0])
+        for pending in (0,1):
+            self.mark(states[pending])
+            branches={bit:states[pending]+bit for bit in (ZERO,ONE)}
+            if pending==1:branches[BLANK]=end
+            self.read(tape,branches)
+            for value,bit in enumerate((ZERO,ONE)):
+                self.mark(states[pending]+bit)
+                self.write(tape,str(pending));self.move(tape,1);self.go(states[value])
+        self.mark(end);self.write(tape,ONE);self.rewind(tape)
+
+    def multiply_constant(self, source, target, factor):
+        need(type(factor) is int and factor>=0,"finite nonnegative multiplier")
+        self.empty(target)
+        if factor==0:
+            self.write(target,ZERO)
+            return
+        self.canonical(source,positive=True)
+        states=[self.fresh("multiply_carry") for _ in range(factor)]
+        end=self.fresh("multiply_done")
+        self.go(states[0])
+        for carry in range(factor):
+            self.mark(states[carry])
+            self.read(source,{ZERO:states[carry]+ZERO,ONE:states[carry]+ONE,BLANK:states[carry]+"end"})
+            for value,bit in enumerate((ZERO,ONE)):
+                self.mark(states[carry]+bit)
+                total=factor*value+carry
+                self.write(target,str(total%2));self.move(target,1);self.move(source,1)
+                self.go(states[total//2])
+            self.mark(states[carry]+"end")
+            if carry:
+                for bit in bin(carry)[2:][::-1]:
+                    self.write(target,bit);self.move(target,1)
+            self.go(end)
+        self.mark(end);self.rewind(source);self.rewind(target)
+
+    def add(self, left, right, target):
+        self.empty(target)
+        states=(self.fresh("add_zero"),self.fresh("add_one"))
+        end=self.fresh("add_done")
+        self.go(states[0])
+        for carry in (0,1):
+            self.mark(states[carry])
+            self.read(left,{a:states[carry]+"left"+a for a in (ZERO,ONE,BLANK)})
+            for a in (ZERO,ONE,BLANK):
+                base=states[carry]+"left"+a
+                self.mark(base)
+                self.read(right,{b:base+"right"+b for b in (ZERO,ONE,BLANK)})
+                for bit in (ZERO,ONE,BLANK):
+                    self.mark(base+"right"+bit)
+                    if a==BLANK and bit==BLANK and carry==0:
+                        self.go(end)
+                        continue
+                    total=int(a==ONE)+int(bit==ONE)+carry
+                    self.write(target,str(total%2));self.move(target,1)
+                    if a!=BLANK:self.move(left,1)
+                    if bit!=BLANK:self.move(right,1)
+                    self.go(states[total//2])
+        self.mark(end);self.rewind(left);self.rewind(right);self.rewind(target)
+
+    def compare(self, left, right, less, equal, greater):
+        """LSF comparison remembers the most recent differing (higher) bit."""
+        states={v:self.fresh("compare") for v in (-1,0,1)}
+        ends={-1:less,0:equal,1:greater}
+        self.go(states[0])
+        for previous in (-1,0,1):
+            self.mark(states[previous])
+            self.read(left,{a:states[previous]+a for a in (ZERO,ONE,BLANK)})
+            for a in (ZERO,ONE,BLANK):
+                base=states[previous]+a
+                self.mark(base)
+                self.read(right,{b:base+b for b in (ZERO,ONE,BLANK)})
+                for b in (ZERO,ONE,BLANK):
+                    self.mark(base+b)
+                    if a==BLANK or b==BLANK:
+                        result=previous if a==b else (-1 if a==BLANK else 1)
+                        self.rewind(left);self.rewind(right);self.go(ends[result])
+                    else:
+                        following=previous if a==b else (-1 if a<b else 1)
+                        self.move(left,1);self.move(right,1);self.go(states[following])
+
+    def row_extent(self):
+        within=dict(SCHEMA)["within_bits"]
+        record=dict(SCHEMA)["record_bits"]
+        guide=QUOT_ROWS
+        self.empty(guide);self.empty(TEMP)
+        self.canonical(record,positive=True)
+        self.clear(ROWBITS);self.copy(record,ROWBITS)
+        self.unary_zero(within,guide)
+        loop,more,end=(self.fresh("extent") for _ in range(3))
+        self.mark(loop);self.read(guide,{ONE:more,BLANK:end})
+        self.mark(more);self.double(ROWBITS);self.move(guide,1);self.go(loop)
+        self.mark(end);self.clear(guide);self.clear(TEMP)
+
+    def cutoff_guard(self, rank):
+        self.empty(CONSTANT)
+        for bit in bin(rank)[2:][::-1]:
+            self.write(CONSTANT,bit);self.move(CONSTANT,1)
+        self.rewind(CONSTANT)
+        cutoff=dict(SCHEMA)["cutoff"]
+        self.canonical(cutoff,positive=True)
+        good=self.fresh("valid_global_cutoff")
+        self.compare(cutoff,CONSTANT,"reject",good,good)
+        self.mark(good);self.clear(CONSTANT)
+
+    def derive_geometry(self, rank, child):
+        """Rank-one child: e'=f, s'=program_start; then f',r',s'+r'K."""
+        need(type(rank) is int and rank>=2,"fixed final-template rank")
+        ports=dict(SCHEMA)
+        f,e,entry,active,rem,k=(ports[name] for name in
+                              ("f","selected_axes","entry_start","active_start","remainder","K"))
+        if child:
+            self.clear(e);self.copy(f,e)
+            self.clear(entry);self.copy(active,entry)
+        self.clear(f);self.clear(rem);self.clear(active)
+        self.divide_constant(e,f,rank,exact=False,remainder=rem)
+        self.empty(OFFSET);self.write(OFFSET,ZERO)
+        self.empty(GUIDE_S);self.empty(TEMP);self.unary_zero(rem,GUIDE_S)
+        loop,more,end=(self.fresh("remainder_offset") for _ in range(3))
+        self.mark(loop);self.read(GUIDE_S,{ONE:more,BLANK:end})
+        self.mark(more)
+        self.add(OFFSET,k,CONSTANT)
+        self.clear(OFFSET);self.copy(CONSTANT,OFFSET);self.clear(CONSTANT)
+        self.move(GUIDE_S,1);self.go(loop)
+        self.mark(end);self.clear(GUIDE_S)
+        self.add(entry,OFFSET,active);self.clear(OFFSET)
+
+    def encode(self, fields, target):
+        """Fixed schema: length prefix 1^ell 0 followed by ell LSF digits."""
+        self.empty(target)
+        for field in fields:
+            self.canonical(field)
+            loop, unit, end = (self.fresh("length") for _ in range(3))
+            self.mark(loop)
+            self.read(field, {ZERO: unit, ONE: unit, BLANK: end})
+            self.mark(unit)
+            self.write(target, ONE)
+            self.move(target, 1)
+            self.move(field, 1)
+            self.go(loop)
+            self.mark(end)
+            self.write(target, ZERO)
+            self.move(target, 1)
+            self.rewind(field)
+            loop, zero, one, end = (self.fresh("digits") for _ in range(4))
+            self.mark(loop)
+            self.read(field, {ZERO: zero, ONE: one, BLANK: end})
+            for label, bit in ((zero, ZERO), (one, ONE)):
+                self.mark(label)
+                self.write(target, bit)
+                self.move(field, 1)
+                self.move(target, 1)
+                self.go(loop)
+            self.mark(end)
+            self.rewind(field)
+        self.rewind(target)
+
+    def decode(self, source, fields):
+        self.empty(LENGTH)
+        for field in fields:
+            self.empty(field)
+            first = self.fresh("positive_length")
+            self.read(source, {ONE: first})
+            self.mark(first)
+            loop, unit, end = (self.fresh("read_length") for _ in range(3))
+            self.mark(loop)
+            self.read(source, {ONE: unit, ZERO: end})
+            self.mark(unit)
+            self.write(LENGTH, ONE)
+            self.move(LENGTH, 1)
+            self.move(source, 1)
+            self.go(loop)
+            self.mark(end)
+            self.move(source, 1)
+            self.rewind(LENGTH)
+            loop, digit, zero, one, end = (self.fresh("read_digits") for _ in range(5))
+            self.mark(loop)
+            self.read(LENGTH, {ONE: digit, BLANK: end})
+            self.mark(digit)
+            self.read(source, {ZERO: zero, ONE: one})
+            for label, bit in ((zero, ZERO), (one, ONE)):
+                self.mark(label)
+                self.write(field, bit)
+                self.move(field, 1)
+                self.move(source, 1)
+                self.move(LENGTH, 1)
+                self.go(loop)
+            self.mark(end)
+            self.rewind(field)
+            self.canonical(field)
+            self.clear(LENGTH)
+        exact = self.fresh("exact_header")
+        self.read(source, {BLANK: exact})
+        self.mark(exact)
+        self.rewind(source)
+
+    def divisible_guides(self, rows, stock):
+        loop, r_more, s_more, restart, end = (self.fresh("stock") for _ in range(5))
+        self.mark(loop)
+        self.read(rows, {ONE: r_more, BLANK: end})
+        self.mark(r_more)
+        self.read(stock, {ONE: s_more, BLANK: restart})
+        self.mark(s_more)
+        self.move(rows, 1)
+        self.move(stock, 1)
+        self.go(loop)
+        self.mark(restart)
+        self.rewind(stock)
+        self.go(loop)
+        self.mark(end)
+        exact = self.fresh("complete_stock")
+        self.read(stock, {BLANK: exact})
+        self.mark(exact)
+        self.rewind(rows)
+        self.rewind(stock)
+
+    def close(self):
+        self.code.append(("done",))
+        self.mark("reject")
+        self.code.append(("reject",))
+        self.mark("quarantine")
+        self.code.append(("quarantine",))
+        return self.finish()
+
+
+def compile_prepare(divisor, kind=ROW_CHILD, rank=None, root=False):
+    need(kind == ROW_CHILD, "matched-fields occurrence must not split rows")
+    b = Builder()
+    fields = tuple(port for _, port in SCHEMA)
+    for port in (HEADER, CHILD_HEADER, LENGTH, QUOT_ROWS, QUOT_STOCK,
+                 TEMP, GUIDE_S, OFFSET, CONSTANT, *fields):
+        b.boundary(port)
+    b.decode(HEADER, fields)
+    if rank is not None:
+        b.cutoff_guard(rank)
+        fast=b.fresh("actual_fast_child")
+        width=dict(SCHEMA)["selected_axes" if root else "f"]
+        b.compare(width,dict(SCHEMA)["cutoff"],"reject","reject",fast)
+        b.mark(fast)
+        if root:
+            b.row_extent()
+        b.derive_geometry(rank,child=not root)
+    b.divide_constant(ROWS, QUOT_ROWS, divisor)
+    b.divide_constant(STOCK, QUOT_STOCK, divisor)
+    replacements = {ROWS: QUOT_ROWS, STOCK: QUOT_STOCK}
+    b.encode(tuple(replacements.get(port, port) for port in fields), CHILD_HEADER)
+    for port in (*fields, QUOT_ROWS, QUOT_STOCK):
+        b.clear(port)
+    return b.close()
+
+
+def compile_row_extent():
+    b=Builder()
+    for port in (16,17,ROWBITS,QUOT_ROWS,TEMP):b.boundary(port)
+    b.row_extent()
+    return b.close()
+
+
+def compile_leaf(rank):
+    """Actual requested-child test f<=t, t=max(N,floor(h^eta)) supplied globally."""
+    need(type(rank) is int and rank>=2,"fixed final-template rank")
+    b=Builder()
+    fields=tuple(port for _,port in SCHEMA)
+    for port in (HEADER,LENGTH,CONSTANT,*fields):b.boundary(port)
+    b.decode(HEADER,fields);b.cutoff_guard(rank)
+    f=dict(SCHEMA)["f"];cutoff=dict(SCHEMA)["cutoff"]
+    b.canonical(f,positive=True)
+    leaf,internal=b.fresh("elementary_child"),b.fresh("recursive_child")
+    b.compare(f,cutoff,leaf,leaf,internal)
+    for label,value in ((leaf,True),(internal,False)):
+        b.mark(label)
+        for port in fields:b.clear(port)
+        b.code.append(("result",value))
+    return b.close()
+
+
+def compile_router(divisor, merge=False):
+    """Uses CHILD header (rows=R/divisor); split and merge have inverse order."""
+    need(type(divisor) is int and divisor > 0, "fixed positive divisor")
+    b = Builder()
+    roles = tuple(range(FIRST_ROLE, FIRST_ROLE + divisor))
+    fields = tuple(port for _, port in SCHEMA)
+    for port in (SOURCE, OUTPUT, HEADER, LENGTH, TEMP, GUIDE_C, GUIDE_R,
+                 GUIDE_J, GUIDE_S, *fields, *roles):
+        b.boundary(port)
+    b.decode(HEADER, fields)
+    for descriptor, guide in ((OUTER, GUIDE_C), (ROWS, GUIDE_R),
+                              (ROWBITS, GUIDE_J), (STOCK, GUIDE_S)):
+        b.empty(guide)
+        b.unary(descriptor, guide)
+    b.divisible_guides(GUIDE_R, GUIDE_S)
+    if merge:
+        b.empty(OUTPUT)
+    else:
+        for role in roles:
+            b.empty(role)
+    prefix, group, next_prefix, finish = (b.fresh("route") for _ in range(4))
+    phases = tuple(b.fresh("role") for _ in roles)
+    b.mark(prefix)
+    b.read(GUIDE_C, {ONE: group, BLANK: finish})
+    b.mark(group)
+    b.read(GUIDE_R, {ONE: phases[0], BLANK: next_prefix})
+    for index, role in enumerate(roles):
+        b.mark(phases[index])
+        source, target = (role, OUTPUT) if merge else (SOURCE, role)
+        loop, bit, zero, one, row_done = (b.fresh("row") for _ in range(5))
+        b.mark(loop)
+        b.read(GUIDE_J, {ONE: bit, BLANK: row_done})
+        b.mark(bit)
+        b.read(source, {ZERO: zero, ONE: one})
+        for label, value in ((zero, ZERO), (one, ONE)):
+            b.mark(label)
+            b.empty(target)
+            b.write(target, value)
+            if merge:
+                b.write(source, BLANK)
+            b.move(source, 1)
+            b.move(target, 1)
+            b.move(GUIDE_J, 1)
+            b.go(loop)
+        b.mark(row_done)
+        b.rewind(GUIDE_J)
+        if index + 1 == divisor:
+            b.move(GUIDE_R, 1)
+            b.go(group)
+        else:
+            b.go(phases[index + 1])
+    b.mark(next_prefix)
+    b.rewind(GUIDE_R)
+    b.move(GUIDE_C, 1)
+    b.go(prefix)
+    b.mark(finish)
+    for port in roles if merge else (SOURCE,):
+        exact = b.fresh("exact_payload")
+        b.read(port, {BLANK: exact})
+        b.mark(exact)
+    for port in (*roles, OUTPUT) if merge else (SOURCE, *roles):
+        b.rewind(port)
+    for port in (GUIDE_C, GUIDE_R, GUIDE_J, GUIDE_S, TEMP, *fields):
+        b.clear(port)
+    return b.close()
+
+
+class PhysicalPort:
+    """Raw physical binary adapter: bypasses virtual codewords/blanks."""
+    def __init__(self, tape, marker=2):
+        self.tape = tape
+        self.marker = marker
+
+    def read(self):
+        symbol = self.tape.read()
+        need(symbol in (0, 1, 6, self.marker), "raw physical row alphabet")
+        return {0: ZERO, 1: ONE, 6: BLANK, self.marker: LEFT}[symbol]
+
+    def write(self, symbol):
+        self.tape.write({ZERO: 0, ONE: 1, BLANK: 6, LEFT: self.marker}[symbol])
+
+    def move(self, direction):
+        self.tape.move(direction)
+
+
+def run_choice(program, ports, limit=None):
+    """Return a fixed terminal label and observer count; no numeric decoding."""
+    pc = steps = 0
+    while True:
+        if limit is not None and steps >= limit:
+            raise ValueError("observer step limit")
+        row = program[pc]
+        op = row[0]
+        steps += 1
+        if op == "done":
+            return None, steps
+        if op == "result":
+            return row[1], steps
+        if op in ("reject", "quarantine"):
+            raise ValueError("row program " + op)
+        if op == "goto":
+            pc = row[1]
+            continue
+        port = ports[row[1]]
+        if op == "read":
+            symbol = port.read()
+            need(symbol in row[2], "foreign row symbol")
+            pc = row[2][symbol]
+            continue
+        if op == "write":
+            port.write(row[2])
+        elif op == "move":
+            port.move(row[2])
+        else:
+            raise ValueError("unknown local instruction")
+        pc += 1
+
+
+def run(program, ports, limit=None):
+    """Returned step count is an observer, never a control register."""
+    result, steps = run_choice(program, ports, limit)
+    need(result is None, "ordinary local table has no decision terminal")
+    return steps
+
+
+def occurrence(ambient, active, child_ambient, kind=MATCHED):
+    """Static #6878 constructor; neither payload nor numerical input is read."""
+    need(kind == MATCHED, "coordinate occurrence is a matched-field event")
+    order = geometry.stable_prefix(ambient, tuple(active))
+    need(len(active) <= child_ambient <= ambient, "complete child ambient")
+    swaps = tuple(geometry.swap_word(order))
+    return {"kind": kind, "ambient": ambient, "active": tuple(active),
+            "child_ambient": child_ambient, "order": order,
+            "entry": swaps, "return": tuple(reversed(swaps)),
+            "selected_xor_calls": 6 * len(swaps), "row_divisor": 1}
+
+
+def compile_occurrence(bindings, ambient, requests, child_ambient):
+    """Full-field #6878 conjugations surround ONE complete matched native word."""
+    need(len(bindings)==len(requests)>0,"all native matched fields")
+    need(len(set(bindings))==len(bindings),"distinct source matched bindings")
+    layouts=tuple(occurrence(ambient,active,child_ambient) for active in requests)
+    out=[]
+    for field,layout in zip(bindings,layouts):
+        for a,b in layout["entry"]:
+            out.extend(("xor",field,x,y) for x,y in ((a,b),(b,a),(a,b)))
+    out.append(("native",tuple(bindings)))
+    for field,layout in reversed(tuple(zip(bindings,layouts))):
+        for a,b in layout["return"]:
+            out.extend(("xor",field,x,y) for x,y in ((a,b),(b,a),(a,b)))
+    need(sum(row[0]=="xor" for row in out)==sum(x["selected_xor_calls"] for x in layouts),
+         "complete occurrence address invoice")
+    return tuple(out),layouts
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/vendor/occurrence_geometry.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/vendor/occurrence_geometry.py
new file mode 100644
index 0000000000..9c3c97d86a
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/vendor/occurrence_geometry.py
@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""Source-bound coordinate checks; no predecessor imports. Apache-2.0."""
+from __future__ import annotations
+import hashlib
+import itertools
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+CONTROLLER = 'research/p104-productive-controller/CONTROLLER.json'
+PHASES = ('research/p104-caller-independent-audit/capsule/outputs/'
+          'p104-caller-route-audit-v2-20261025/sources/DATA-PHASES.json')
+
+
+def need(ok: bool, message: str) -> None:
+    if not ok:
+        raise ValueError(message)
+
+
+def authenticate() -> dict[str, bytes]:
+    manifest = json.loads((HERE / 'SOURCES.json').read_text())
+    data = {}
+    for row in manifest['files']:
+        if row['usage'] == 'input':
+            raw = (ROOT / row['path']).read_bytes()
+            need(hashlib.sha256(raw).hexdigest() == row['sha256'], 'source hash: ' + row['path'])
+            data[row['path']] = raw
+    return data
+
+
+def stable_prefix(n: int, active: tuple[int, ...]) -> tuple[int, ...]:
+    need(type(n) is int and n > 0, 'positive ambient')
+    need(len(set(active)) == len(active), 'injective active list')
+    need(all(type(a) is int and 0 <= a < n for a in active), 'active range')
+    used = set(active)
+    return active + tuple(i for i in range(n) if i not in used)
+
+
+def swap_word(order: tuple[int, ...]) -> list[tuple[int, int]]:
+    need(sorted(order) == list(range(len(order))), 'complete permutation')
+    live = list(range(len(order)))
+    out = []
+    for i, target in enumerate(order):
+        if live[i] != target:
+            j = live.index(target)
+            live[i], live[j] = live[j], live[i]
+            out.append((i, j))
+    need(tuple(live) == order and len(out) <= len(order)-1, 'emitted permutation and bound')
+    return out
+
+
+def compress(value: int, kept: tuple[int, ...]) -> int:
+    mask = sum(1 << i for i in kept)
+    need(value & ~mask == 0, 'discarded coordinate used')
+    return sum(((value >> old) & 1) << new for new, old in enumerate(kept))
+
+
+def block(stage: int) -> tuple[int, ...]:
+    return tuple(range(9)) if stage == 0 else tuple(range(9+8*(stage-1), 9+8*stage))
+
+
+def canonicalizer(n: int, active: tuple[int, ...], base: tuple[int, ...]) -> tuple[int, ...]:
+    need(len(base) == 9, 'base nine')
+    need(all((a & b).bit_count() % 2 == int(i == j)
+             for i, a in enumerate(base) for j, b in enumerate(base)), 'orthogonal base')
+    return tuple(base[i] if i < 9 else 1 << i for i in stable_prefix(n, active))
+
+
+def inverse_canonicalizer(columns: tuple[int, ...], value: int) -> int:
+    # Orthogonal inverse via dot products, independent of emitted swap execution.
+    return sum(((col & value).bit_count() % 2) << i for i, col in enumerate(columns))
+
+
+def spectral_poly(axes: tuple[int, ...]):
+    linear, quadratic = {}, set()
+    for axis in axes:
+        support = [i for i in range(axis.bit_length()) if axis >> i & 1]
+        for i in support:
+            linear[i] = (linear.get(i, 0)+1) % 4
+        for pair in itertools.combinations(support, 2):
+            if pair in quadratic:
+                quadratic.remove(pair)
+            else:
+                quadratic.add(pair)
+    return tuple(sorted((i, v) for i, v in linear.items() if v)), tuple(sorted(quadratic))
+
+
+def source_checks(data: dict[str, bytes]) -> dict[str, int]:
+    word = json.loads(data[CONTROLLER])
+    phases = json.loads(data[PHASES])
+    stages = sorted({e[1] for e in word['physical_events'] if e[0] == 'LOCAL'})
+    need(stages == [0, *range(1, 32, 2), 32], 'actual eighteen stage set')
+    kept = tuple(sorted({i for stage in stages for i in block(stage)}))
+    mask = sum(1 << a for a in kept)
+    need(len(kept) == 145 and word['ambient_rank'] == 145, 'compressed ambient145')
+    position = {old: new for new, old in enumerate(kept)}
+    cases = []
+    for term in word['diagonal']:
+        selected = tuple(i for i, yes in enumerate(term[1:]) if yes)
+        need(set(selected) <= set(stages), 'main stage subset')
+        cases.append(('main', selected, term[0]))
+    for event in word['physical_events']:
+        if event[0] == 'IDLE':
+            need(set(event[2]) <= set(stages), 'idle stage subset')
+            cases.append(('idle', tuple(event[2]), 0))
+    layouts = routes = basis_checks = contacts = 0
+    restriction_witness = False
+    for recipe in phases['recipes']:
+        q = recipe['q']
+        basis = tuple(recipe['idle_children'][0]['orthogonal_axes'][:8])
+        for stage in stages:
+            vectors = () if stage == 0 else tuple(b ^ (1 << i) for b, i in zip(basis, block(stage), strict=True))
+            reduced = tuple(compress(v, kept) for v in vectors)
+            def act(axis):
+                out = axis
+                for v in vectors:
+                    if (axis & v).bit_count() % 2:
+                        out ^= v
+                return out
+            spectator = tuple(1 << i for i in range(9, 9+8*stage))
+            raw_x = (q,) if stage == 0 else tuple(1 << i for i in range(9+8*(stage-1)))
+            raw_y = () if stage == 0 else raw_x+(q, q, q)
+            entry_x, entry_y = spectator+(q,), spectator
+            exit_x = spectator+tuple(1 << i for i in range(9))
+            exit_y = exit_x+(q, q, q)
+            out_x = tuple(1 << i for i in range(9+8*stage))
+            out_y = out_x+(q, q, q)
+            for old_terms, new_terms in ((raw_x, entry_x), (raw_y, entry_y), (exit_x, out_x), (exit_y, out_y)):
+                old_l, old_q = spectral_poly(tuple(act(a) for a in old_terms))
+                new_l, new_q = spectral_poly(new_terms)
+                need(old_q == new_q, 'actual contact quadratic phase')
+                old_d, new_d = dict(old_l), dict(new_l)
+                delta = {i: (new_d.get(i, 0)-old_d.get(i, 0)) % 4 for i in old_d.keys() | new_d.keys()}
+                need(set(delta.values()) <= {0, 2}, 'actual contact is translation')
+                translation = sum(1 << i for i, value in delta.items() if value == 2)
+                need(translation & ~mask == 0 and act(translation) & ~mask == 0, 'contact and inverse stay in retained support')
+                contacts += 1
+            for i in range(265):
+                x, actual = 1 << i, 1 << i
+                for v in vectors:
+                    if (x & v).bit_count() % 2:
+                        actual ^= v
+                if i not in position:
+                    need(actual == x, 'discarded route spectator')
+                else:
+                    y = 1 << position[i]
+                    reduced_actual = y
+                    for v in reduced:
+                        if (y & v).bit_count() % 2:
+                            reduced_actual ^= v
+                    need(compress(actual, kept) == reduced_actual, 'route compression intertwiner')
+                basis_checks += 1
+            routes += 1
+        for kind, selected, qpower in cases:
+            has_zero = 0 in selected
+            base = tuple(1 << i for i in range(9)) if kind == 'main' and has_zero else (q, *basis)
+            if kind == 'main':
+                start = tuple(range(9)) if has_zero else (0,)
+            else:
+                start = tuple(range(1, 9)) if has_zero else ()
+            old_active = start + tuple(i for s in selected if s for i in block(s))
+            active = tuple(position[i] for i in old_active)
+            cols = canonicalizer(145, active, base)
+            positive = tuple(base[i] if i < 9 else 1 << position[i] for i in old_active)
+            need(cols[:len(active)] == positive, 'exact positive first columns')
+            for i in range(145):
+                need(inverse_canonicalizer(cols, cols[i]) == 1 << i, 'full inverse including complement')
+                basis_checks += 1
+            physical = tuple(1 << position[i] for stage in selected for i in block(stage))
+            if kind == 'main':
+                physical += (q,) * ((qpower-int(has_zero)) % 4)
+                corrected = positive + (q,) * (2 if qpower == -1 else 0)
+                need(spectral_poly(physical) == spectral_poly(corrected), 'actual main phase and central translation')
+            else:
+                physical += (q,) * ((-int(has_zero)) % 4)
+                lp, qp = spectral_poly(physical)
+                lc, qc = spectral_poly(positive)
+                need(qp == qc, 'idle quadratic phase')
+                dp, dc = dict(lp), dict(lc)
+                delta = {i: (dp.get(i, 0)-dc.get(i, 0)) % 4 for i in dp.keys() | dc.keys()}
+                need(set(delta.values()) <= {0, 2}, 'idle correction is translation')
+            # Parity kernels and linear permutations have absolute phase one at zero.
+            need(all(axis > 0 for axis in positive), 'nonzero Gaussian axes')
+            old = canonicalizer(265, old_active, base)
+            if any(old[i] & ~mask for i in kept):
+                restriction_witness = True
+            layouts += 1
+    need(restriction_witness, 'naive restriction must actually fail')
+    need(len(phases['recipes']) == 112, 'all retained ports')
+    return {'ports': 112, 'routes': routes, 'contacts': contacts, 'layouts': layouts, 'basis_checks': basis_checks,
+            'retained_axes': 145, 'discarded_axes': 120, 'naive_restriction_witness': 1}
+
+
+def permutation_checks() -> dict[str, int]:
+    cases = tensor_checks = 0
+    for n in range(1, 8):
+        for r in range(n+1):
+            lists = itertools.permutations(range(n), r) if n <= 5 else [tuple(reversed(range(r))), tuple(range(n-r, n))]
+            for active in lists:
+                order, swaps = stable_prefix(n, active), swap_word(stable_prefix(n, active))
+                for f in (1, 2, 4):
+                    # Each chunk has three bits; only rho=1 moves.
+                    k, rho = 3, 1
+                    labels = list(range(n*f*k))
+                    original = labels[:]
+                    for a, b in swaps:
+                        for j in range(f):
+                            ai, bi = (a*f+j)*k+rho, (b*f+j)*k+rho
+                            x, y = 1 << ai, 1 << bi
+                            x ^= y; y ^= x; x ^= y
+                            need((x, y) == (1 << bi, 1 << ai), 'three-add swap')
+                            labels[ai], labels[bi] = labels[bi], labels[ai]
+                    expected = original[:]
+                    for a in range(n):
+                        for j in range(f):
+                            expected[(a*f+j)*k+rho] = (order[a]*f+j)*k+rho
+                    need(labels == expected, 'fixed-rho route and unselected spectators')
+                    for a, b in reversed(swaps):
+                        for j in range(f):
+                            ai, bi = (a*f+j)*k+rho, (b*f+j)*k+rho
+                            labels[ai], labels[bi] = labels[bi], labels[ai]
+                    need(labels == original, 'literal inverse return')
+                    tensor_checks += 1
+                cases += 1
+    return {'ordered_active_lists': cases, 'tensor_routes': tensor_checks}
+
+
+def layout_domain(n, width, owned, d, f, k, g, other=1, lead=0, materialize_rows=True, active_extent=None):
+    need(n >= 2 and width >= 1 and owned >= 0 and d >= 1 and f >= 1 and k >= 1 and g >= 1 and other >= 1, 'layout positive domain')
+    extent = d if active_extent is None else active_extent
+    need(1 <= extent <= d, 'active extent domain')
+    power, levels = 1, 0
+    while power < 2*d:
+        power *= n; levels += 1
+    stock = (width*(owned+1))**levels * other
+    q0 = max(1, ((stock-1).bit_length()+k-1)//k)
+    h = d*g
+    qf, qb = (2*h+k-1)//k, (h+k-1)//k
+    start, end = (q0+qf+lead)*k, (extent-qb)*k
+    need(start+n*f*k <= end, 'active interval fit')
+    need(q0*k+2*h <= start and end+h <= extent*k, 'complete controls')
+    need((n*f-1)*g <= h, 'all occurrence column controls')
+    need(q0*k >= (stock-1).bit_length(), 'logarithmic row-stock fit')
+    if not materialize_rows:
+        return stock, q0*k, None, start, end
+    rows = 1 << (q0*k)
+    padded = ((rows+stock-1)//stock)*stock
+    need(rows <= padded < 2*rows and padded % stock == 0, 'one complete row pad')
+    return stock, rows, padded, start, end
+
+
+def domain_checks() -> dict[str, int]:
+    total = 0
+    for n, width, owned, f in itertools.product((2, 3, 7), (1, 3, 11), (0, 2, 6), (1, 2, 7)):
+        stock, rows, padded, start, end = layout_domain(n, width, owned, 1024, f, 256, 5, 6)
+        need(padded % (width*(owned+1)*6) == 0, 'simultaneous divisors')
+        for u in (0, 1, padded//2, padded-1):
+            digits, current = [], u
+            for divisor in (width, owned+1, 2, 3):
+                current, digit = divmod(current, divisor)
+                digits.append((divisor, digit))
+            for divisor, digit in reversed(digits):
+                current = divisor*current+digit
+            need(current == u, 'whole-row nested return')
+        total += 1
+    for extent in (512, 640):
+        layout_domain(7, 11, 6, 1024, 7, 256, 5, 6, active_extent=extent)
+        total += 1
+    layout_domain(7, 11, 6, 10**32, 10**30, 10**10, 5, 6, materialize_rows=False)
+    return {'reservation_cases': total+1}
+
+
+def negative_controls() -> list[str]:
+    controls = []
+    def rejects(name, call):
+        try:
+            call()
+        except (ValueError, IndexError):
+            controls.append(name)
+        else:
+            raise ValueError('negative control accepted: '+name)
+    rejects('aliased-active-coordinate', lambda: stable_prefix(5, (1, 1)))
+    rejects('missing-coordinate-range', lambda: stable_prefix(5, (5,)))
+    rejects('dropped-complement', lambda: swap_word((0, 2)))
+    rejects('discarded-live-route-axis', lambda: compress(1 << 12, (0, 1, 2)))
+    rejects('nonorthogonal-canonicalizer', lambda: canonicalizer(9, (0,), (1,)*9))
+    rejects('front-back-overlap', lambda: layout_domain(7, 11, 6, 64, 7, 1, 5))
+    rejects('too-large-occurrence', lambda: layout_domain(7, 11, 6, 64, 100, 256, 5))
+    need(3 % 2 != 0, 'max stock rejected'); controls.append('max-instead-of-product-stock')
+    order = stable_prefix(5, (3, 1))
+    labels = list(range(5))
+    for a, b in swap_word(order):
+        labels[a], labels[b] = labels[b], labels[a]
+    need(labels != list(range(5)), 'omitted return witness'); controls.append('omitted-inverse-return')
+    x, y = list(range(5)), [10+i for i in range(5)]
+    wrong = [x[i]+y[order[i]] for i in range(5)]
+    right = [x[i]+y[i] for i in range(5)]
+    need(wrong != right, 'scalar alignment witness'); controls.append('rolewise-route-without-whole-conjugation')
+    return controls
+
+
+def main() -> None:
+    data = authenticate()
+    report = {'source': source_checks(data), 'permutations': permutation_checks(),
+              'domains': domain_checks(), 'negative_controls': negative_controls()}
+    print(json.dumps(report, sort_keys=True, separators=(',', ':')))
+    print('PASS_SELECTED_COMPILER_OCCURRENCE_LAYOUT')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/vendor/row_padding.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/vendor/row_padding.py
new file mode 100644
index 0000000000..1e3533efa9
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/dispatch/vendor/row_padding.py
@@ -0,0 +1,321 @@
+"""Finite local control for full-fibre compatible ROW padding.
+
+JoyboyBrian, with substantial OpenAI Codex assistance. Apache-2.0.
+Semantics follow Jose Manuel PR2786 and Nick Petalas PR3503; neither frozen
+implementation is changed. Each executed instruction observes one local cell.
+"""
+from dataclasses import dataclass
+
+BLANK = "_"
+LEFT = "|"
+SOURCE, PD, RD, SD, BD, P, R, S, B, D, TEMP, ROWS, PAD, RETURN, OUTPUT = range(15)
+TAPES = 15
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+class Builder:
+    def __init__(self):
+        self.code = []
+        self.labels = {}
+        self.serial = 0
+        self.rejection = "reject"
+
+    def fresh(self, prefix):
+        self.serial += 1
+        return prefix + str(self.serial)
+
+    def mark(self, name):
+        need(name not in self.labels, "unique control label")
+        self.labels[name] = len(self.code)
+
+    def read(self, tape, branches):
+        complete = {symbol: ("quarantine" if symbol == LEFT else self.rejection)
+                    for symbol in ("0", "1", BLANK, LEFT)}
+        complete.update(branches)
+        self.code.append(("read", tape, complete))
+
+    def write(self, tape, symbol):
+        self.code.append(("write", tape, symbol))
+
+    def move(self, tape, direction):
+        self.code.append(("move", tape, direction))
+
+    def go(self, label):
+        self.code.append(("goto", label))
+
+    def rewind(self, tape):
+        loop, done = self.fresh("rewind"), self.fresh("rewound")
+        self.mark(loop)
+        self.read(tape, {LEFT: done, "0": loop + "step", "1": loop + "step", BLANK: loop + "step"})
+        self.mark(loop + "step")
+        self.move(tape, -1)
+        self.go(loop)
+        self.mark(done)
+        self.move(tape, 1)
+
+    def clear(self, tape):
+        self.rewind(tape)
+        loop, erase, done = self.fresh("clear"), self.fresh("erase"), self.fresh("cleared")
+        self.mark(loop)
+        self.read(tape, {"0": erase, "1": erase, BLANK: done})
+        self.mark(erase)
+        self.write(tape, BLANK)
+        self.move(tape, 1)
+        self.go(loop)
+        self.mark(done)
+        self.rewind(tape)
+
+    def boundary(self, tape):
+        good = self.fresh("boundary")
+        previous = self.rejection
+        self.rejection = "quarantine"
+        self.move(tape, -1)
+        self.read(tape, {LEFT: good})
+        self.mark(good)
+        self.move(tape, 1)
+        self.rejection = previous
+
+    def unary(self, descriptor, output):
+        # Canonical LSF positive binary input; last digit must be one.
+        zero, one, done = self.fresh("lastzero"), self.fresh("lastone"), self.fresh("copied")
+        self.mark(zero)
+        self.read(descriptor, {"0": zero + "bit", "1": one + "bit"})
+        self.mark(one)
+        self.read(descriptor, {"0": zero + "bit", "1": one + "bit", BLANK: done})
+        for state, bit in ((zero, "0"), (one, "1")):
+            self.mark(state + "bit")
+            self.write(TEMP, bit)
+            self.move(TEMP, 1)
+            self.move(descriptor, 1)
+            self.go(state)
+        self.mark(done)
+        self.rewind(descriptor)
+        self.rewind(TEMP)
+        loop, borrow, unit, tail, trim, append, end = [self.fresh("decode") for _ in range(7)]
+        self.mark(loop)
+        self.read(TEMP, {BLANK: end, "0": borrow, "1": unit})
+        self.mark(borrow)
+        self.write(TEMP, "1")
+        self.move(TEMP, 1)
+        self.read(TEMP, {"0": borrow, "1": unit})
+        self.mark(unit)
+        self.write(TEMP, "0")
+        self.move(TEMP, 1)
+        self.read(TEMP, {BLANK: trim, "0": tail, "1": tail})
+        self.mark(trim)
+        self.move(TEMP, -1)
+        self.write(TEMP, BLANK)
+        self.mark(tail)
+        self.rewind(TEMP)
+        self.mark(append)
+        self.write(output, "1")
+        self.move(output, 1)
+        self.go(loop)
+        self.mark(end)
+        self.rewind(output)
+
+    def increment(self, tape):
+        loop, carry, setone, done = [self.fresh("increment") for _ in range(4)]
+        self.mark(loop)
+        self.read(tape, {"1": carry, "0": setone, BLANK: setone})
+        self.mark(carry)
+        self.write(tape, "0")
+        self.move(tape, 1)
+        self.go(loop)
+        self.mark(setone)
+        self.write(tape, "1")
+        self.mark(done)
+        self.rewind(tape)
+
+    def plan(self):
+        compare, more, fits = [self.fresh("cover") for _ in range(3)]
+        self.mark(compare)
+        self.read(S, {BLANK: fits, "1": more})
+        self.mark(more)
+        good = self.fresh("covered")
+        self.read(R, {"1": good})
+        self.mark(good)
+        self.move(S, 1)
+        self.move(R, 1)
+        self.go(compare)
+        self.mark(fits)
+        self.rewind(R)
+        self.rewind(S)
+        row, group, exact, partial, drain, padding, finish = [self.fresh("plan") for _ in range(7)]
+        self.mark(row)
+        self.increment(ROWS)
+        self.move(R, 1)
+        self.move(S, 1)
+        self.read(S, {BLANK: exact, "1": partial})
+        self.mark(exact)
+        self.rewind(S)
+        self.read(R, {BLANK: finish, "1": row})
+        self.mark(partial)
+        self.read(R, {BLANK: drain, "1": row})
+        self.mark(drain)
+        self.read(S, {BLANK: finish, "1": padding})
+        self.mark(padding)
+        self.write(D, "1")
+        self.move(D, 1)
+        self.increment(ROWS)
+        self.move(S, 1)
+        self.go(drain)
+        self.mark(finish)
+        for tape in (R, S, D):
+            self.rewind(tape)
+
+    def rows(self, source, output, count, mode):
+        rows, row, body, bit, zero, one, endbody, end = [self.fresh("scan") for _ in range(8)]
+        self.mark(rows)
+        self.read(count, {"1": row, BLANK: end})
+        self.mark(row)
+        self.mark(body)
+        self.read(B, {"1": bit, BLANK: endbody})
+        self.mark(bit)
+        if mode == "zero":
+            self.write(output, "0")
+            self.move(output, 1)
+        else:
+            self.read(source, {"0": zero, **({"1": one} if mode == "copy" else {})})
+            self.mark(zero)
+            if mode == "copy":
+                self.write(output, "0")
+                self.go(one + "copied")
+                self.mark(one)
+                self.write(output, "1")
+                self.mark(one + "copied")
+                self.move(output, 1)
+            self.move(source, 1)
+        self.move(B, 1)
+        self.go(body)
+        self.mark(endbody)
+        self.rewind(B)
+        self.move(count, 1)
+        self.go(rows)
+        self.mark(end)
+        self.rewind(count)
+
+    def transform(self, source, output, restricting):
+        prefix, run, end, exact = [self.fresh("transform") for _ in range(4)]
+        self.mark(prefix)
+        self.read(P, {"1": run, BLANK: end})
+        self.mark(run)
+        self.rows(source, output, R, "copy")
+        self.rows(source, output, D, "discard" if restricting else "zero")
+        self.move(P, 1)
+        self.go(prefix)
+        self.mark(end)
+        self.read(source, {BLANK: exact})
+        self.mark(exact)
+        for tape in (P, source, output):
+            self.rewind(tape)
+
+    def finish(self):
+        result = []
+        for instruction in self.code:
+            if instruction[0] == "goto":
+                result.append(("goto", self.labels[instruction[1]]))
+            elif instruction[0] == "read":
+                result.append(("read", instruction[1],
+                               {k: self.labels[v] for k, v in instruction[2].items()}))
+            else:
+                result.append(instruction)
+        return tuple(result)
+
+
+def program():
+    b = Builder()
+    for descriptor, output in ((PD, P), (RD, R), (SD, S), (BD, B)):
+        b.unary(descriptor, output)
+    b.plan()
+    b.transform(SOURCE, PAD, False)
+    b.code.append(("call",))
+    # Borrowed contents are a semantic callee premise. These local checks
+    # enforce only the returned boundary-marker positions, not that premise.
+    for tape in (SOURCE, PD, RD, SD, BD, ROWS, PAD, RETURN):
+        b.boundary(tape)
+    b.transform(RETURN, OUTPUT, True)
+    for tape in (P, R, S, B, D, TEMP, ROWS, PAD, RETURN):
+        b.clear(tape)
+    b.code.append(("done",))
+    # Well-formed-tape data errors retain reliable left markers. Recover
+    # borrowed heads and erase owned work using the same local scans.
+    b.mark("reject")
+    b.rejection = "quarantine"
+    for tape in (P, R, S, B, D, TEMP, ROWS, PAD, RETURN, OUTPUT):
+        b.clear(tape)
+    for tape in (SOURCE, PD, RD, SD, BD):
+        b.rewind(tape)
+    b.code.append(("rejected",))
+    b.mark("quarantine")
+    b.code.append(("quarantined",))
+    return b.finish()
+
+
+PROGRAM = program()
+
+
+@dataclass
+class Tape:
+    cells: dict
+    head: int = 1
+    low: int = 0
+    high: int = 0
+
+    @classmethod
+    def fixture(cls, text="", origin=0):
+        return cls({origin: LEFT, **{origin + i + 1: c for i, c in enumerate(text)}},
+                   origin + 1, origin, origin + len(text))
+
+    def read(self):
+        self.low = min(self.low, self.head)
+        self.high = max(self.high, self.head)
+        return self.cells.get(self.head, BLANK)
+
+
+class Machine:
+    """A table interpreter, not a host implementation of padding/counting."""
+    def __init__(self, tapes):
+        need(len(tapes) == TAPES, "fixed fifteen tapes")
+        need(len({id(tape) for tape in tapes}) == TAPES, "distinct physical tape ports")
+        self.tapes = tapes
+        self.pc = 0
+        self.steps = 0
+        self.calls = 0
+
+    def run(self, budget=10000000):
+        need(len({id(tape) for tape in self.tapes}) == TAPES, "distinct physical tape ports")
+        while self.steps < budget:
+            instruction = PROGRAM[self.pc]
+            op = instruction[0]
+            self.steps += 1
+            if op in ("rejected", "quarantined"):
+                raise ValueError(op)
+            if op in ("done", "call"):
+                if op == "call":
+                    self.pc += 1
+                    self.calls += 1
+                return op
+            if op == "goto":
+                self.pc = instruction[1]
+                continue
+            tape = self.tapes[instruction[1]]
+            if op == "read":
+                symbol = tape.read()
+                need(symbol in instruction[2], "local guard rejected at state " + str(self.pc))
+                self.pc = instruction[2][symbol]
+                continue
+            if op == "write":
+                tape.read()
+                tape.cells[tape.head] = instruction[2]
+            elif op == "move":
+                tape.head += instruction[2]
+                tape.read()
+            else:
+                raise ValueError("unknown local opcode")
+            self.pc += 1
+        raise ValueError("test execution budget exhausted")
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/PROOF.md
new file mode 100644
index 0000000000..605981247e
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/PROOF.md
@@ -0,0 +1,591 @@
+# Source-bound physical lifecycle for the retained complex compiler
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+
+## 1. Claim, prior coverage and exact boundary
+
+This package constructs a physical lifecycle refinement of the **current
+selected raw word and the complete finite compiler grammar**. Its new content
+is the binding between actual source events and an executable sequential-tape
+controller: current private lifetimes, chronological product substitutions,
+compiler matches on borrowed private fields, complete smaller-program batches,
+initialization, arithmetic COPY, dirty retirement, suspended parent contents,
+saved finite return state, and output installation before parent resumption.
+The proof is quantified over all legal runtime sizes for every fixed finite
+template produced by that construction. Its force is the induction below;
+the executed small instances are discriminating implementation evidence.
+
+The generic allocation argument already exists in
+[#5814](https://github.com/CrocSwap/integer-mult-bounds/pull/5814), especially
+`selected-owned-dispatch/ALLOCATION-THEOREM.md`, `FRESH-NAMES.md` and
+`BINDING-STATUS.md`. That work includes coded logical blanks, the output bridge,
+COPY as addition, and the distinction between current volume and retained
+backing. Those ideas are credited dependencies, not new discoveries here.
+The present contribution instantiates them with the current source word and a
+literal controller, and supplies a source-driven lowerer which executes the
+complete lockstep compiler rather than replacing large subprograms by an
+interface check.
+
+All five assumptions in selected #6030 remain in the selected record. A native
+Gaussian implementation and its numerical error bound are not supplied here.
+A physical lifecycle theorem relative to explicit native and row services is
+different from a complete multiplication theorem.
+
+`SOURCES.json` pins canonical inputs at
+`7c49fe32c55de02c2c873655c804b16e4c3fef0a` by Git blob and SHA256:
+
+| Source | Use in this result |
+| --- | --- |
+| #6030 `p104-helper470-twin-rung-removal/WORD.json.gz` | Every current local operand, chart, INIT, COPY, MOVE and CLEAR |
+| `p104-productive-controller/CONTROLLER.json` | Actual 18 LOCAL sites, 15 copied queries, boundaries, IDLE jobs and productive roles |
+| #5443 `lockstep-completion-pass/executor.py` | Unchanged Pascal matching, replication, complete source/complement batches, exits and ownership stack |
+| `p7-TENSOR.md` and `FINITE-PRECOMPILATION.md` | Chronological product, completion/splitting and finite compiler semantics |
+| #5356 `delimited-continuation-stack/stack.py` | Unchanged local-read/write/unit-move continuation implementation |
+| #5814 allocation, fresh-name and binding proofs | Prior allocator and historical source-boundary analysis |
+
+Byte-identical proof exports in `vendor/` have public commit and Git/SHA256
+pins in `DEPENDENCIES.json`: #6878 at
+`41febf890fbbb852c6059d4c0cc8c593ae9dfa5c` supplies occurrence geometry,
+complements, inverse routes and the complete-row ABI; #6900 at
+`c46339035fccd571effb48434d80f572e20f1092` supplies the current ideal caller
+grid; #6901 at `4c7a4f00f09665276e145ac2cc1d12f8b8f9a7ac` supplies
+compiler-wide ideal dyadic precision and headroom under its endpoint premises.
+The verifier authenticates these proof bytes, without rerunning their whole
+dependency suites. The all-column selected algebra of #6890 and the newer
+#6902/#6914 owned-rise audit are not repeated or claimed as new results.
+
+### Relative theorem
+
+Fix the current raw unit and a finite sequence of the specified products,
+completion and splitting operations which produces a separated rule: maximum
+paid rank is smaller than minimum target rank. Fix a legal finite integer
+compiler rank N. Run `source_ir.lower` on authenticated #5443, without partial
+copies or non-base blackbox fallback. Let the resulting fixed template have
+productive width w, private inventory o and finite program P. All construction
+work precedes varying runtime input size.
+
+Assume these service conditions, which do **not** assume private initialization,
+arithmetic COPY, dirty erasure, or preservation of suspended parent banks:
+
+1. **Full-field and arithmetic ABI.** Numerical fields are complete common-format
+   arrays, with common fixed-point scale and signed component width. Native and
+   geometry services return the exact declared array extent, including arbitrary
+   spectators, at the origin. Actual additions fit the signed width. The frontier
+   is exactly the declared number of complete records: no trailing coded logical
+   blanks or native scratch remain in a numerical field. Descriptors are separate
+   contiguous raw binary payloads. The ideal format of #6900/#6901 is compatible
+   when their premises hold; it does not certify an approximate native service.
+2. **Fixed native tables.** Each SERVICE and elementary PAID leaf has a fixed
+   finite transition table with its source endpoint, time and local backing
+   bound. Its accessible ports are exactly its event fields, fixed auxiliary
+   ports and explicitly borrowed binary context ports. Tables cannot access
+   another field or an ancestor segment. The full-field conjugations of #6878
+   are charged services, not free relabelings.
+3. **Ordinary child services.** A terminating encoded stopping test and
+   `prepare/install/collect` implement actual ordinary recursion at the
+   supplied ordered PAID site. `prepare` preserves parent payloads and stages
+   a complete child descriptor; `install` distributes a complete owner bridge
+   into all w productive fields and installs that descriptor; `collect`
+   reconstructs the owner from **all** returned productive fields. They use
+   fixed supplied ports, return canonical heads and format, and have explicit
+   time/backing bounds. Rank reduction, elementary remainders, placement,
+   whole-row stock and numerical leaf cutoff belong to this interface.
+   A stock-depth fixture is not their proof.
+4. **Imported finite source theorem.** The named compiler has its stated
+   ordered matching, integral complete batches, strict smaller-rank substitutions
+   and semantic endpoints. This is an imported theorem, not an assertion that
+   finite testing proves it. The added lifecycle annotation is proved below
+   by structural induction over that exact construction.
+
+Then `machine.Controller` refines the emitted program on every legal runtime
+input and every finite current dirty private body. INIT produces canonical
+zero; COPY adds into the actual destination; CLEAR erases the complete physical
+body. A child cannot change a parked parent field, descriptor or continuation.
+Every output is captured before retirement; the correct occupied parent owner
+is replaced; all other parent words and heads return unchanged. The number of
+physical tapes is fixed by P and its service inventories, independently of
+runtime size and recursion depth.
+
+Sections 6–7 give a positive action invoice and a coordinatewise retained
+backing bound, including dirty contents and auxiliary high-water marks. Under
+the stated current-volume bounds and whole-row contraction
+`V_child=V_parent/w`, w>=2, they imply `K0+C_P V_root` retained backing and
+linear lifecycle work per ordinary node, with finite template-dependent
+constants. Arbitrarily occupied dirty input is not silently absorbed into K0.
+
+## 2. Actual raw lifetimes and the finite wrapper grammar
+
+`current_local` reads every instruction of the authenticated word. It checks
+the chart of every accessed field, exact Boolean ownership flags on MOVE,
+equal charts at scalar contacts, positive MOVE rank from the source chart
+dimension difference, and complete final charts. Every private access lies
+between the actual INIT and CLEAR. Each current COPY has coefficient one and
+an INIT destination unchanged by intervening operations. The machine still
+implements it by actual addition; this check does not license an overwrite.
+
+The exact local word has 770 public fields, 29 private names, 31 private
+lifetimes, peak logical ownership 13, and 23 COPY sites. The lowering uses a
+separate conservative 29-name inventory at each actual LOCAL occurrence; it
+does not reuse an ancestor's live bank because the local peak is smaller.
+
+`current_caller` maps the selected 104 local ports and their partners to the
+32 main factors. It allocates distinct sets of 562 local helpers and 29 private
+names for each of 18 LOCAL sites, retaining every caller boundary and physical
+event. Each QUERY_SHEAR gets the literal sequence
+
+`INIT z; COPY(z,x); query-in; PAID(z); query-out; query-add(y,z); CLEAR z`.
+
+Its 104 query banks are reused only after CLEAR. There are 15 query sites.
+Actual field maps are injective; productive inputs are not copied to satisfy
+another productive role. Normalizers are explicit SERVICE events, including
+the re-emitted whole-job canonicalizers of #6878.
+
+The derived caller has 13,444 productive fields, 626 private names, 2,118
+private lifetimes, 1,974 arithmetic COPYs and 66,834 paid jobs. Its annotated
+raw word has 642,410 events: 569,366 SERVICE, 66,834 PAID, 2,118 INIT,
+2,118 CLEAR and 1,974 COPY. Both complete paid and target histograms are
+compared with selected `RESULT.json`, rather than inferred from these totals.
+Added services incur positive ordinary work; this package does not claim
+that they fit the historical numerical raw `10^9` allowance.
+
+For a chronological product U*V, each V role j has a separate U copy. Its
+private names are `('left',j,name)`. At U's chronological paid position ell,
+the distinct current owners, in V-role order, become V's productive fields;
+V's private names are `('right',ell,name)`. A V input can be a live private
+field of U: it is borrowed, not allocated, copied or cleared by V. All V events
+and inverse normalizers finish before U resumes. Left and right path tags are
+disjoint. Induction on event position preserves each INIT/use/CLEAR lifetime,
+including later reuse of a private label in a disjoint lifetime.
+
+Let B_U,O_U,P_U count productive fields, private names and paid events, and
+I_U,C_U,A_U,S_U count INIT, CLEAR, COPY and SERVICE. The actual loops give
+
+\[
+B_{UV}=B_UB_V,\quad P_{UV}=P_UP_V,\quad O_{UV}=B_VO_U+P_UO_V,
+\]
+
+\[
+X_{UV}=B_VX_U+P_UX_V\quad(X=I,C,A),
+\]
+
+\[
+S_{UV}=B_VS_U+P_US_V+2B_UB_V+2P_UB_V.
+\]
+
+The final terms count charged complete-field entry/return services. The
+verifier checks this full bill on a product with private owners on both sides.
+These equalities define every fixed finite product power without requiring
+materialization of the selected 1,024-fold product.
+
+Completion appends the source job on [K,L) to a field with target K<L,
+retaining whole-job canonicalizers around the complete old word. Splitting
+replaces rank R by consecutive pieces of size at most J, with entry and inverse
+return around every piece. Original normalizers remain outside the replacement.
+No new private bank appears. If c fields are completed and p' is the sum of
+the ceiling counts of pieces, INIT/CLEAR/COPY counts stay fixed and SERVICE
+increases by 2c+2p'. Every piece keeps its actual owner. The executed fixture
+contains a nonleading split piece and a genuine completion job.
+
+## 3. Refinement of the actual integer compiler
+
+`lower` supplies the exact roles and ordered (rank,owner) rounds to the
+authenticated `Rule`. It reuses `Compiler.plan`, `compile`, `uniform`,
+`run_class`, Pascal buckets and source order unchanged. With the source's
+`owned_policy='unit'`, every static owned field is `('own',g,name)`, where g
+is the fresh source unit identifier. It gets one fixed physical port. Distinct
+unit occurrences never share a private bank just because their depths agree.
+
+| Source boundary | Added event and invariant |
+| --- | --- |
+| `push(field,(g,role),expected)` | Complete-field occurrence entry on that exact field; retain g, role, copy, Pascal point, column and program rank |
+| Before the next child/exit round | Emit the entire preceding nonpaid fragment for every unit, with its full field map |
+| `sub(n,fields,tops)` | Entry for the exact ordered distinct fields, complete smaller program, inverse returns |
+| Elementary n<m | `base-axis-enter`, rank-one PAID, `base-axis-return` for each actual axis and field |
+| After all deepest exit batches return | Final nonpaid fragment before releasing private names |
+| `pop(field,(g,role))` | Matching full-field inverse return before the source permission pop |
+
+The predecessor executor can replace large subprograms by an interface check
+for an audit budget, or execute only some replicas. This lowerer removes those
+shortcuts: `copies` must be `None`; every non-base `sub` has its exact compiled
+width and expands recursively. Only the elementary rank base makes rank-one
+leaves. The source budget does not gate this override. Python recursion and
+construction records are finite template construction, not runtime storage.
+
+Each scalar fragment is emitted only after all productive and private fields
+of the class are matched. Every ADD therefore receives its actual two complete
+fields in the common occurrence order. Replication can split a deepest exit
+round into several complete batches. A static pending set groups the batches; synchronous source construction
+calls prevent advancing the parent fragment or releasing its banks until the
+last batch and its inverse services have returned. The set becomes empty when
+the last batch is issued, before that synchronous call returns.
+That construction record becomes a fixed sequence of program counters.
+
+For the proof, induct on the source's strict smaller-rank calls, then on the
+finite class tree and chronological rounds. A fresh class receives injective
+source fields or the exact live fields handed by issuers; its private ports
+are fresh. The nonpaid fragment uses only these bindings, with every private
+access in a lifetime checked by `Unit.check`. While a child runs, the parent
+fragment is not emitted. A live private owner can thus be borrowed without
+being reinitialized or cleared. The child induction restores full fields and
+orders. The next parent fragment has its previous permission and shape. The
+final fragment closes all actual lifetimes before source release. The source
+LIFO returns give each actual field back to the issuer named by the matching.
+
+This proves the annotation property for every finite source instance, under
+the imported matching/termination theorem. `check_flat_ownership` separately
+replays the emitted word without calling the Compiler, tracking lifetime owners
+and nested occurrence, program and base-axis scopes. A parent cannot resume
+through an outstanding borrow; only the actual owner clears an unborrowed
+private field. This checker is extra evidence, not the universal argument.
+
+Only a rank-one PAID site makes an ordinary runtime recursive call on one
+owner. A compiler `sub` already has its complete ordered matched-field list.
+It consumes neither another row divisor nor another runtime bank frame.
+Products, completions and compiler substitutions are inside the fixed program.
+Their private names increase the template constant o; they allocate no new
+physical tapes at runtime.
+
+## 4. Geometry is an explicit service obligation
+
+Changing supports inside an unchanged scalar word would not be justified.
+The #6878 construction instead conjugates each **complete field** into the
+common occurrence order and inverse-routes it on return. For ordered support
+A its extension lists A followed by the increasing ambient complement. Every
+spectator remains present, without a zero assumption. An entry/return pair
+costs at most 6(N-1) selected-block movement records at that occurrence scale,
+besides native monomial, scalar, descriptor and row work. Movements act at
+the chosen bit plane rho; applying every bit plane requires its actual calls.
+
+The IR retains the needed source information at each boundary:
+
+* `occurrence-enter/return` identifies the actual field, unit, role, Pascal
+  point, column c and containing program. Full unit ambient satisfies
+  m*c<=n, and the matched target has its source rank k*c.
+* `program-enter/return` retains the ordered actual field list, source
+  complement or deepest-exit tag, and exact rank. A source complement uses
+  [s,n_parent), before the source job on [0,s). An exit uses its actual ordered
+  request, the smaller uniform program and the full complement. Return
+  services are emitted in reverse field order.
+* `base-axis-enter/return` retains the axis and base rank around every
+  elementary rank-one PAID. Ordinary row installation may use a canonical
+  prefix only after the requested axis is placed there and restored afterward.
+* Raw MOVE, LOCAL, QUERY, IDLE and whole-job normalizers, product transposes,
+  completed targets and split pieces remain explicit source-tagged services.
+  None is an additional row split.
+
+The finite source path determines the fixed movement recipe. Runtime scale,
+rank/placement values and rho are read from explicit binary context ports,
+not a hidden Python closure. Context is read-only and its head is normalized
+on return. Additional mutable scratch uses fixed `primitive_work` ports,
+included in the physical inventory and each continuation, and retired before
+and after the table.
+
+This package binds the positions and operands of these services and proves
+their lifecycle. It does not implement the charged compact selected-bit
+movement primitives or numerical native endpoints. Their table supplier must
+still meet the declared geometry, full-format return and tariff. A codec or
+head convention of an older native implementation is not automatically this
+ABI; an adapter and its cost must be supplied if they differ.
+
+## 5. Literal initialization, addition and physical continuation
+
+### Encoded fields and native ports
+
+The physical alphabet is 0,1,LEFT=2,SEP=3,END=4,BASE=5,BLANK=6.
+Every occupied payload body is a contiguous string of physical 0/1 cells,
+preceded by its current LEFT marker. Physical BLANK terminates that body.
+A logical symbol in 0..6 is coded by three physical bits; the logical blank
+is 4, encoded 100. It therefore cannot terminate a physical body. Native
+rightward motion at an unwritten frontier first materializes code 100, so it
+cannot jump over an unrepresented hole. Left motion rejects at the current
+origin and cannot access the parked parent. Code alignment is invariant.
+
+A signed component is a little-endian two's-complement word followed by logical
+COMPONENT=2, encoded 010. A complex record has two components. A numerical
+zero row consequently contains separator codes; it is **not** a string of
+physical zero bits. At a fixed fractional scale this representation is a
+common dyadic grid. #6901's ideal choice F=p+D and signed width
+p+h+2D+3 can be encoded this way under its assumptions. This package additionally
+requires actual arithmetic headroom and a provider's canonical return format.
+
+`CodedPort` is used for numerical fields and native auxiliaries. A separate
+`BinaryContextPort` exposes a raw binary descriptor: its frontier read returns
+physical BLANK=6, not logical blank4. Writes and movement beyond either its
+origin or frontier reject. The table's port order is event fields, then
+`primitive_work`, then `primitive_context`. The last group must be protected
+descriptor ports disjoint from event and scratch ports. They are included
+in the payload inventory, so a single physical stack preserves them too.
+
+`execute_table` accepts only finite branch/write/move/goto/halt/reject rows.
+It cannot call a Python numerical function or inspect a tape address. After
+the table it rewinds every bound port. Each table must return numerical fields
+to the declared full-record extent; trimming an extended numerical tail is
+part of that table's separately charged return contract. Native scratch is
+retired by the controller even when nonzero. Two-sided native machines need
+an explicit translation to one-sided ports, with its inventory and tariff;
+the present code does not silently assume that adaptation.
+
+### INIT, COPY and CLEAR
+
+`initialize(target,shape)` first retires every old byte of target, including
+coded logical blanks, then scans the complete format of productive field0.
+It writes zero for each value bit and preserves every component separator.
+All numerical fields have that same complete shape at a program boundary;
+native services do not change the guide's declared format. The guide's data
+and head are preserved. Every private name is initialized before access.
+
+`copy_as_add(target,source)` scans equal complete component boundaries and
+does finite carry addition into the **actual destination**. It retains only
+carry and previous sign bits. At a terminator it resets carry and rejects
+equal-sign overflow. It thus computes exact signed addition whenever the
+result fits. Existing destination residue is included, even if the ideal
+source word called that destination zero. It does not assign a host copy.
+
+`retire` scans to the physical frontier, writes BLANK on every occupied cell,
+and returns to the local origin. It is independent of the numerical value.
+Numerical zeroing does not substitute for retirement. Old high-water backing
+remains reserved after retirement; no space claim treats it as deallocated.
+
+### One physical stack, output before pop
+
+There are q fixed payload tapes: all productive and static private fields,
+row descriptors, and every row/native auxiliary. Four additional tapes hold
+the stack control, the active finite-PC descriptor, the owner bridge and the
+staged child header. The last two are reused at every depth. The bridge and
+header are not unrecorded per-depth arrays.
+
+At a non-leaf PAID site the controller performs this sequence:
+
+1. Copy the actual complete owner bytes into the empty bridge, without changing
+   the owner. Run `prepare` to stage the child's complete binary descriptor.
+2. Write the fixed-width binary PC of the following instruction. The source
+   site and its actual owner are recoverable from this finite PC.
+3. Run the inherited `Stack.push` on **all** q payload ports. It scans their
+   current bodies, leaves them intact, and installs a child LEFT delimiter at
+   each actual frontier. Every child head is at a new empty local origin.
+4. Run `install` into all productive ports and the new descriptor. Retire the
+   bridge and staged header. Begin the same fixed program at PC0.
+
+At child RET, `collect` first builds the complete returned owner in the bridge.
+The controller then retires all q child bodies, including every private bank,
+descriptor and dirty auxiliary. Only now does it call `Stack.pop`, which removes
+the child delimiters and restores every parent payload head and the saved PC.
+It consumes that PC, locates the exact parent owner from its preceding PAID
+instruction, retires the owner's old body, installs the bridge output, and
+retires the bridge. The next fixed instruction is the matching source
+continuation, including its inverse coordinate route where applicable.
+
+The stack does not save host pointers or origins. It finds current delimiters
+and the previous control top by local scans. The source implementation's
+returned sizes/heads and hardware counters are observers; the controller
+ignores them. Removing these observations changes no branch or tape action.
+The runtime PC and its bit loop have bounds fixed by the template and can be
+expanded into finite control. There is no host recursion in `Controller.run`.
+An observation callback used by the verifier is absent from the machine claim.
+
+Induct on the terminating ordinary recursion tree. At a leaf, the supplied
+finite table has its stated endpoint; INIT/COPY/CLEAR have the proved meanings.
+At an internal call, the delimiter isolates every child from all parent
+segments. The row service and induction hypothesis provide all child outputs.
+Capturing them before retirement preserves them independently of pop. Pop
+restores all parents, then only the actual issuing owner is replaced. Thus the
+next source instruction receives exactly the required data and descriptor.
+At the root, unprotected private and auxiliary payloads are retired; productive
+outputs and protected borrowed descriptors remain. This proves the physical
+part of the relative theorem without assuming erased intermediate values.
+
+## 6. Complete positive time invoice
+
+Count one local physical read, write or unit move as one action. The following
+are exact for `machine.py` and the pinned Stack, with canonical entry heads.
+Lengths refer to physical occupied binary bytes, not ideal nonzero values.
+
+| Routine | Exact actions |
+| --- | --- |
+| Rewind a head at offset h to its local origin | 2h+3 |
+| Transfer L bytes into an empty marked target | 8L+14 |
+| Retire L bytes | 5L+7 |
+| INIT, old dirty length D and n logical format symbols | 5D+25n+17 |
+| COPY addition with B value bits and C component terminators | 35B+26C+14 |
+| Stack.push, total parent length S, q ports, fixed PC width b | 2S+10q+7b+11 |
+| Stack.pop under the same conditions | 2S+21q+11b+28 |
+| Write / consume the active saved PC | 4b+4 / 5b+4 |
+| Test for a parent at a canonical control top | 3 |
+
+For example, the signed-addition bit scan performs its source and target
+three-bit reads and target rewrite; delimiter processing checks/reset carry.
+Rewinds give the final affine terms. These counts are derived from literal
+loops, not timing extrapolations. The verifier measures translated-origin
+cases, and the root reviewer separately derived the scan and stack bills.
+
+Let S be the sum of parent body lengths, C the sum of child body lengths just
+before their retirement, L_in and L_out the input/output owner lengths, and H
+the staged child header length. Here H is a header byte count, not the paper's
+control-field parameter dG. Descend plus ascend, excluding the three row
+service calls and separate leaf/top tests, has exact administrative cost
+
+\[
+\boxed{4S+5C+18L_{in}+13L_{out}+5H+38q+27b+103.}
+\]
+
+This includes both bridge copies, bridge/header retirement, all child
+retirement, parent-owner replacement, PC production/consumption and both
+stack operations. It allows unequal input/output physical lengths for the
+administrative identity, although the numerical row ABI returns the same
+complete declared shape. The nine boundary fixtures subtract measured row
+service actions and recover this exact bill, independently of ancestor prefix
+length. No child-time, numerical-value or source-error term is used to pay it.
+
+The total execution invoice is the sum of these administrative costs over
+ordinary calls; every actual INIT, COPY and CLEAR scan; every `prepare`,
+`install`, `collect` and encoded leaf test; every native/geometry/elementary
+kernel table; every primitive auxiliary pre/post retirement; root cleanup;
+and initial/final conversion or loading. All source adapters remain SERVICE
+costs. Fixed finite-control transitions contribute an additional fixed
+constant per emitted instruction and table transition in a standard TM model.
+
+A coded native read costs at most 10 physical actions, write 9, and unit
+movement at most 13, including materialized logical blanks. Read-only binary
+context reads cost 1 and legal unit moves at most 2. Thus a finite table using
+t such primitive steps costs at most 13t, plus each bound port's final rewind
+2h+3 and the explicit auxiliary retirements. This constant-factor simulation
+does not establish that a particular native table has the required tariff.
+
+If each current body, descriptor and service local peak is at most a fixed
+template constant times current complete-field volume V, then each lifecycle
+and boundary charge is O_P(V). A fixed program has finitely many events, so
+its total nonrecursive lifecycle charge at one ordinary node is O_P(V), in
+addition to its explicit primitive tariff. This is absorbable only where the
+retained node tariff already pays a full scan. We do not certify a new raw
+numerical allowance or silently discard geometry constants.
+
+Occupied dirty input of length D costs its actual 5D term. A very large warm
+blank capacity costs no traversal merely because it exists. Conversely, K0
+alone cannot justify an O(V) time bound for arbitrarily large **occupied**
+private bodies. The exact invoice applies without a small-D assumption; the
+linear-time corollary requires the stated current-volume entry bound.
+
+## 7. Retained backing, including erased and visited cells
+
+Use absolute physical extents, including every previously reserved or visited
+cell. Let K_i be entry backing of physical tape i, and b_i its current root
+payload origin. For a payload port at ordinary node v, let e_{v,i} bound the
+largest locally visited offset, expressed as a length from that node's origin.
+This includes native work, descriptor scratch, blanks subsequently erased and
+the first visited frontier cell. At a call boundary let s_{v,i} be its actual
+current parent-body length. The child origin on that same tape is exactly
+
+\[
+b_{child,i}=b_{v,i}+s_{v,i}+1,
+\]
+
+because push writes one LEFT delimiter at the actual parent frontier. Define
+the prospective extent recursively by
+
+\[
+E_{v,i}=\max\bigl(e_{v,i},
+ \max_{v\to u}(s_{v,i}+1+E_{u,i})\bigr).
+\]
+
+This is a resource proof, not a runtime address computation. A sequential
+child reuses the same suffix, so siblings enter a maximum rather than a sum.
+On every payload tape final retained backing is bounded coordinatewise by
+`max(K_i,b_i+E_root,i)`. Even if e and s bounds are conservative, this remains
+valid. Using `max(sum K_i, sum E_i)` instead is generally false: one tape can
+retain warm capacity while another extends cold backing.
+
+Control frames have length exactly 2q+b+3 when all payload heads are normalized.
+Thus control backing is bounded by the maximum live depth times that length,
+plus its entry prefix and visited frontier. The active PC tape needs b bits
+and its frontier. The shared bridge needs the largest complete owner or output
+encountered; the shared staged-header tape needs the largest staged descriptor.
+Their capacities are maxima across the execution, not per-depth allocations.
+Include their coordinatewise maxima with K_i too. Parent descriptors and
+all fixed row/native work tapes are already among the q payload ports.
+
+Suppose each node's local peaks, its current cut bodies, descriptor/auxiliary
+sizes, and the finitely many marker/PC costs are bounded by C_P V_v, with
+V_v>=1. Suppose each actual ordinary whole-row child satisfies
+V_u=V_v/w and w>=2, using the complete unchanged within-row format. Along any
+active path,
+
+\[
+\sum_j V_j\leq V_{root}\sum_{j\geq0}w^{-j}
+=\frac{V_{root}}{1-1/w}.
+\]
+
+Summing the coordinatewise inequalities and adding the fixed shared ports
+gives `K0+C'_P V_root`, where K0=sum_i K_i. Deleted dirty values and cleared
+native work remain included through their local peaks. There is no sum over
+all completed siblings, no depth-dependent tape inventory, and no separate
+unpriced descriptor stack. Without the local service bound, or without volume
+contraction, retain the explicit path/coordinate formula; do not assert the
+linear corollary. In particular, w=1 requires its own argument.
+
+The checker computes per-port prospective extents from the fixed source word,
+canonical field lengths and legal call cuts **before** execution. It then
+compares every individual physical tape's retained capacity. A separate
+observer tracks all reads, writes and unit moves, adding the visited frontier
+even where the inherited simulator has not extended its written-cell list.
+Both written backing and visited backing are recorded. Repeated invocations
+must reuse their retained suffixes exactly, and translated protected prefixes
+must be preserved. These are finite resource tests of the formula, not a
+replacement for the path induction.
+
+## 8. What is closed, what remains, and how to check it
+
+The proved implication replaces an abstract compiler-owned allocation step
+with a source-bound executable implementation: every current private lifetime
+and borrowed owner has an actual port; every source occurrence has explicit
+entry/return; initialization and COPY use the full numerical format; dirty
+contents are physically retired; complete ordinary child outputs survive pop;
+and all continuation, descriptor, scratch and historical backing is charged.
+There is no remaining allocator oracle inside this implementation.
+
+The result remains relative to the finite compiler source theorem and to the
+explicit native/geometry/ordinary-row services. It does not provide the compact
+movement tables, exact or rounded Gaussian tables, source-specific numerical
+stopping/stock producer, global numerical error analysis, BIT admission, or
+analytic recovery. A row implementation must treat the numerical zero-row
+pattern canonically, preserve complete within-row fields and spectators,
+divide only at actual ordinary children, handle decreasing rank and remainders,
+and charge its padding and descriptor arithmetic. Those are concrete interface
+obligations, rather than silently successful callbacks in the theorem.
+
+The current selected constants remain power1024, cutoff16, floor17, ambient145,
+and compiler N=2^65807000000000. The final template is defined constructively
+but is not materialized here. Its nonmaterialization is not itself a gap in
+an existence proof. Conversely, no finite fixture is described as executing
+that template or removing one of the five selected assumptions.
+
+Run the package verifier in normal and optimized Python. It authenticates all
+source bytes before parsing or executing and uses captured-source `compile`,
+not a stale bytecode cache. It checks current complete profiles, raw lifetimes,
+product and completion/splitting invoices, complete small compiler expansions,
+independent flat ownership, literal physical replays, exact boundary action
+bills, signed arithmetic, raw context access and retained backing. The current
+raw word is executed twice with distinguishing synthetic native tables; all
+2,118 private lifetimes are physically cleared on each invocation. That fixture
+is not a numerical Gaussian replay. An independent value-level oracle uses
+host recursion only in the checker, never in the controller.
+
+Adverse controls include borrowed CLEAR, a changed COPY coefficient, mistyped
+ownership flag, omitted INIT, early parent CLEAR, one bank per depth, missing
+occurrence/program/base-axis returns, an ancestor probe, COPY overwrite losing
+actual residue, numerical zero substituted for physical retirement, child
+output discarded before collection, wrong return PC, a logical blank collapsed
+to physical blank, source drift, and illegal binary context operations. Tests
+are rejection evidence for these specific faults. No proof-kernel acceptance
+or independent human approval is claimed.
+
+Credit the predecessor authors: Ali Romman's continuation and P104 work;
+JoyboyBrian's query/owned-interface work; Mason Hale's #5814 allocation binding;
+zxv's backing and chronological-product analysis; Jacob Alan Sussman's integer
+compiler; Mark / Matarener's lockstep implementation; Douglas Colkitt's compact
+layout and retained framework; DreamingOfClouds and the selected local-word
+lineage; Chris R / Clear1nsight's whole-job/contact audit; and the precision
+contributors including Ross Richardson. The #6878/#6900/#6901 source exports
+retain their original notices. This new source refinement, implementation,
+proof and checks were prepared for @CubeJerry with substantial OpenAI
+assistance. Concurrent root review is separate AI-assisted review, not a human
+or formal theorem certification.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/machine.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/machine.py
new file mode 100644
index 0000000000..acf475e4fc
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/machine.py
@@ -0,0 +1,406 @@
+"""Literal lifecycle control on fixed sequential tapes.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+Stack is the authenticated #5356 implementation supplied by the loader.
+Algorithms never read tape addresses, extents, hardware arrays or a host stack.
+Instruction and primitive tables are fixed before runtime inputs vary.
+"""
+from dataclasses import dataclass
+
+ZERO, ONE, LEFT, SEP, END, BASE, BLANK = range(7)
+COMPONENT = 2
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def emit(tape, symbol):
+    tape.write(symbol)
+    tape.move(1)
+
+
+def origin(tape, marker=LEFT):
+    tape.move(-1)
+    while tape.read() != marker:
+        tape.move(-1)
+    tape.move(1)
+
+
+def retire(tape, marker=LEFT):
+    """Erase all coded bytes, including encoded logical blanks."""
+    origin(tape, marker)
+    while (symbol := tape.read()) != BLANK:
+        need(symbol in (ZERO, ONE), "contiguous binary body")
+        emit(tape, BLANK)
+    origin(tape, marker)
+
+
+def transfer(source, target, source_marker=LEFT, target_marker=LEFT):
+    """Administrative actual-byte copy; never an arithmetic COPY."""
+    origin(source, source_marker)
+    origin(target, target_marker)
+    need(target.read() == BLANK, "administrative transfer needs empty target")
+    while (symbol := source.read()) != BLANK:
+        need(symbol in (ZERO, ONE), "binary transfer")
+        emit(target, symbol)
+        source.move(1)
+    origin(source, source_marker)
+    origin(target, target_marker)
+
+
+class CodedPort:
+    """Seven virtual symbols encoded as three nonblank physical bits.
+
+    The physical LEFT before the current body is never exposed as data.
+    A left step at its local origin rejects. Two-sided routines first use
+    the standard translation to two one-sided ports.
+    """
+    __slots__ = ("tape",)
+
+    def __init__(self, tape):
+        self.tape = tape
+
+    def read(self):
+        t = self.tape
+        if t.read() == BLANK:
+            return 4
+        value = 0
+        for _ in range(3):
+            bit = t.read()
+            need(bit in (ZERO, ONE), "whole virtual codeword")
+            value = 2 * value + bit
+            t.move(1)
+        for _ in range(3):
+            t.move(-1)
+        need(value < 7, "unused virtual codeword")
+        return value
+
+    def write(self, value):
+        need(type(value) is int and 0 <= value < 7, "virtual alphabet")
+        for shift in (2, 1, 0):
+            emit(self.tape, (value >> shift) & 1)
+        for _ in range(3):
+            self.tape.move(-1)
+
+    def move(self, direction):
+        need(direction in (-1, 1), "virtual unit move")
+        t = self.tape
+        if direction == 1:
+            if t.read() == BLANK:
+                self.write(4)
+            for _ in range(3):
+                t.move(1)
+        else:
+            t.move(-1)
+            if t.read() == LEFT:
+                t.move(1)
+                raise ValueError("native routine crossed its local origin")
+            t.move(-1)
+            t.move(-1)
+
+
+class BinaryContextPort:
+    """Read-only raw binary descriptor, with its own physical alphabet.
+
+    Unlike CodedPort, read returns physical BLANK=6 at the frontier. A table
+    may inspect that frontier but cannot pass it or the current LEFT marker.
+    This supplies runtime e/f/K/rho data through counted local operations.
+    """
+    __slots__ = ("tape",)
+
+    def __init__(self, tape):
+        self.tape = tape
+
+    def read(self):
+        symbol = self.tape.read()
+        need(symbol in (ZERO, ONE, BLANK), "binary context alphabet")
+        return symbol
+
+    def write(self, value):
+        raise ValueError("native context is read-only")
+
+    def move(self, direction):
+        need(direction in (-1, 1), "binary context unit move")
+        t = self.tape
+        if direction == 1:
+            need(t.read() in (ZERO, ONE), "context frontier cannot be crossed")
+            t.move(1)
+        else:
+            t.move(-1)
+            if t.read() == LEFT:
+                t.move(1)
+                raise ValueError("native context crossed its local origin")
+
+
+def read_code(tape):
+    """Consume a numeric-format code; physical frontier returns None."""
+    if tape.read() == BLANK:
+        return None
+    value = 0
+    for _ in range(3):
+        bit = tape.read()
+        need(bit in (ZERO, ONE), "numeric codeword")
+        value = 2 * value + bit
+        tape.move(1)
+    need(value < 7, "unused numeric codeword")
+    return value
+
+
+def write_code(tape, value):
+    for shift in (2, 1, 0):
+        emit(tape, (value >> shift) & 1)
+
+
+def initialize(target, shape):
+    """Dispose of arbitrary old bytes, then zero the complete common format."""
+    need(target is not shape, "private initialization cannot destroy its guide")
+    retire(target)
+    origin(shape)
+    in_component = False
+    while (symbol := read_code(shape)) is not None:
+        need(symbol in (ZERO, ONE, COMPONENT), "canonical signed components")
+        if symbol == COMPONENT:
+            need(in_component, "positive component width")
+            write_code(target, COMPONENT)
+            in_component = False
+        else:
+            write_code(target, ZERO)
+            in_component = True
+    need(not in_component, "component terminator")
+    origin(shape)
+    origin(target)
+
+
+def copy_as_add(target, source):
+    """Signed addition into the actual destination, including any residue.
+
+    Components are little-endian two's complement followed by COMPONENT.
+    Carries reset at delimiters; equal-sign signed overflow rejects.
+    No ideal-zero test or exact-value overwrite substitutes for addition.
+    """
+    need(target is not source, "distinct COPY/ADD ports")
+    origin(source)
+    origin(target)
+    carry = 0
+    last_a = last_b = last_out = 0
+    in_component = False
+    while True:
+        a = read_code(source)
+        b = read_code(target)
+        need((a is None) == (b is None), "same complete numerical extent")
+        if a is None:
+            need(not in_component, "complete signed component")
+            break
+        need(a in (ZERO, ONE, COMPONENT) and b in (ZERO, ONE, COMPONENT),
+             "canonical signed addition operands")
+        need((a == COMPONENT) == (b == COMPONENT), "same component boundaries")
+        if a == COMPONENT:
+            need(in_component, "positive signed component width")
+            need(last_a != last_b or last_out == last_a, "signed addition overflow")
+            carry = 0
+            in_component = False
+            continue
+        value = a + b + carry
+        last_a, last_b, last_out = a, b, value & 1
+        carry = value >> 1
+        for _ in range(3):
+            target.move(-1)
+        write_code(target, last_out)
+        in_component = True
+    origin(source)
+    origin(target)
+
+
+def execute_table(table, ports, readonly_context=()):
+    """Run a supplied finite native table with every port confined.
+
+    These tables retain explicit semantics/time/space premises. Fixture
+    tables are not advertised as Gaussian implementations.
+    """
+    views = (tuple(CodedPort(t) for t in ports)
+             + tuple(BinaryContextPort(t) for t in readonly_context))
+    pc = 0
+    while True:
+        row = table[pc]
+        op = row[0]
+        if op == "halt":
+            break
+        if op == "reject":
+            raise ValueError(row[1])
+        if op == "goto":
+            pc = row[1]
+            continue
+        view = views[row[1]]
+        if op == "branch":
+            pc = dict(row[2]).get(view.read(), row[3])
+            continue
+        if op == "write":
+            view.write(row[2])
+        elif op == "move":
+            view.move(row[2])
+        else:
+            raise ValueError("native table opcode")
+        pc += 1
+    for tape in tuple(ports)+tuple(readonly_context):
+        origin(tape)
+
+
+@dataclass(frozen=True)
+class Instruction:
+    op: str
+    ports: tuple = ()
+    token: tuple = ()
+
+
+class Controller:
+    """Fixed finite controller of a fixed flat compiled template.
+
+    rows implements the separately priced row/shape interface; all its
+    dynamic state belongs on the supplied tapes. services contains fixed
+    finite transition tables. Payload ports include metadata and all scratch.
+    The only runtime continuation is the physical Stack.
+    """
+    def __init__(self, program, public_count, payloads, control, descriptor,
+                 bridge, child_header, rows, services, stack_class, protected_ports=(),
+                 primitive_work=(), primitive_context=()):
+        self.program = tuple(program)
+        self.public_count = public_count
+        self.payloads = tuple(payloads)
+        self.control = control
+        self.descriptor = descriptor
+        self.bridge = bridge
+        self.child_header = child_header
+        self.rows = rows
+        self.services = services
+        need(len({id(t) for t in self.payloads+(control,descriptor,bridge,child_header)})
+             == len(self.payloads)+4, "all physical ports distinct")
+        self.stack = stack_class(self.payloads, control, descriptor)
+        self.protected_ports = tuple(protected_ports)
+        owned = {e.ports[0] for e in self.program if e.op == "INIT"}
+        need(all(public_count <= i < len(self.payloads) for i in owned), "INIT only private physical slots")
+        need(owned.isdisjoint(self.protected_ports), "owned fields cannot be borrowed descriptors")
+        self.root_cleanup = tuple(i for i in range(public_count,len(self.payloads))
+                                  if i not in self.protected_ports)
+        self.primitive_work = tuple(primitive_work)
+        self.primitive_context = tuple(primitive_context)
+        data_ports = {i for e in self.program for i in e.ports}
+        need(all(0 <= i < len(self.payloads) for i in data_ports), "compiled port range")
+        need(all(i >= public_count and i < len(self.payloads) and i not in data_ports
+                 and i not in self.protected_ports for i in self.primitive_work), "separate primitive scratch")
+        need(len(set(self.primitive_work)) == len(self.primitive_work), "distinct primitive work ports")
+        need(len(set(self.primitive_context)) == len(self.primitive_context)
+             and all(i in self.protected_ports and 0 <= i < len(self.payloads)
+                     and i not in data_ports for i in self.primitive_context), "borrowed binary context ports")
+        self.pc_bits = max(1, (len(self.program) - 1).bit_length())
+        self.pc_words = tuple(tuple((pc >> j) & 1 for j in range(self.pc_bits))
+                              for pc in range(len(self.program)))
+        need(self.program and self.program[-1].op == "RET", "finite completed program")
+
+    def save_pc(self, pc):
+        need(self.descriptor.read() == BLANK, "empty active PC descriptor")
+        for bit in self.pc_words[pc]:
+            emit(self.descriptor, bit)
+        origin(self.descriptor, BASE)
+
+    def consume_pc(self):
+        pc = 0
+        for shift in range(self.pc_bits):
+            bit = self.descriptor.read()
+            need(bit in (ZERO, ONE), "binary return PC")
+            pc |= bit << shift
+            emit(self.descriptor, BLANK)
+        need(self.descriptor.read() == BLANK, "exact fixed return PC width")
+        origin(self.descriptor, BASE)
+        need(pc < len(self.program) and pc > 0 and self.program[pc-1].op == "PAID",
+             "return PC designates a paid continuation")
+        return pc
+
+    def has_parent(self):
+        self.control.move(-1)
+        symbol = self.control.read()
+        self.control.move(1)
+        need(symbol in (BASE, END), "complete continuation top")
+        return symbol == END
+
+    def descend(self, pc):
+        event = self.program[pc]
+        source = self.payloads[event.ports[0]]
+        transfer(source, self.bridge, target_marker=BASE)
+        self.rows.prepare(event.token, self.child_header)
+        self.save_pc(pc + 1)
+        self.stack.push((True,) * len(self.payloads))
+        self.rows.install(self.bridge, self.child_header,
+                          self.payloads[:self.public_count])
+        retire(self.bridge, BASE)
+        retire(self.child_header, BASE)
+
+    def primitive(self, token, fields):
+        for i in self.primitive_work:
+            retire(self.payloads[i])
+        execute_table(self.services[token],
+                      tuple(self.payloads[i] for i in fields+self.primitive_work),
+                      tuple(self.payloads[i] for i in self.primitive_context))
+        for i in self.primitive_work:
+            retire(self.payloads[i])
+
+    def ascend(self):
+        self.rows.collect(self.payloads[:self.public_count], self.bridge)
+        for tape in self.payloads:
+            retire(tape)
+        self.stack.pop()                   # ignore observer sizes and heads
+        pc = self.consume_pc()
+        target = self.payloads[self.program[pc-1].ports[0]]
+        retire(target)
+        transfer(self.bridge, target, source_marker=BASE)
+        retire(self.bridge, BASE)
+        return pc
+
+    def run(self, observe=None):
+        pc = 0
+        while True:
+            event = self.program[pc]
+            if observe is not None:
+                observe("before", pc, event)  # checker only; ignores return value
+            if event.op == "INIT":
+                initialize(self.payloads[event.ports[0]], self.payloads[0])
+                pc += 1
+            elif event.op == "CLEAR":
+                retire(self.payloads[event.ports[0]])
+                pc += 1
+            elif event.op == "COPY":
+                copy_as_add(self.payloads[event.ports[0]], self.payloads[event.ports[1]])
+                pc += 1
+            elif event.op == "SERVICE":
+                self.primitive(event.token,event.ports)
+                pc += 1
+            elif event.op == "PAID":
+                if self.rows.is_leaf(event.token):
+                    self.primitive(("leaf",)+event.token,event.ports)
+                    pc += 1
+                else:
+                    self.descend(pc)
+                    pc = 0
+            elif event.op == "RET":
+                if not self.has_parent():
+                    for i in self.root_cleanup:
+                        retire(self.payloads[i])
+                    break
+                pc = self.ascend()
+            else:
+                raise ValueError("compiled opcode")
+            if observe is not None:
+                observe("after", pc, event)
+
+
+def boundary_actions(q, b, parent_total, child_total, input_length,
+                     output_length, staged_header_length):
+    """Exact descend+ascend actions, excluding the three row-service calls.
+
+    Also excludes caller leaf/top tests. All heads are at local origins.
+    Includes PC, all retirement, occupied-target replacement and both relays.
+    """
+    return (4 * parent_total + 5 * child_total + 18 * input_length
+            + 13 * output_length + 5 * staged_header_length
+            + 38 * q + 27 * b + 103)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/source_ir.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/source_ir.py
new file mode 100644
index 0000000000..79c95fa794
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lifecycle/source_ir.py
@@ -0,0 +1,522 @@
+"""Source-driven lifecycle IR and finite compiler lowering.
+
+All recursion/dictionaries here belong to template construction, before runtime
+input size varies. machine.py executes the resulting fixed finite program.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from collections import Counter
+from dataclasses import dataclass
+from fractions import Fraction
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+@dataclass(frozen=True)
+class Event:
+    op: str
+    fields: tuple
+    token: tuple = ()
+    rank: int = 0
+
+
+@dataclass(frozen=True)
+class Unit:
+    name: str
+    roles: tuple
+    owned: tuple
+    events: tuple
+
+    def check(self):
+        public = {name for name, rank in self.roles}
+        private = set(self.owned)
+        need(len(public) == len(self.roles) and len(private) == len(self.owned), "unique unit names")
+        need(public.isdisjoint(private), "public/private name separation")
+        need(all(type(r) is int and r >= 1 for _, r in self.roles), "positive target ranks")
+        live = set()
+        for e in self.events:
+            need(e.op in ("INIT", "CLEAR", "COPY", "SERVICE", "PAID"), "unit opcode")
+            if e.op == "INIT":
+                need(len(e.fields) == 1 and e.fields[0] in private and e.fields[0] not in live, "fresh private INIT")
+                live.add(e.fields[0])
+            elif e.op == "CLEAR":
+                need(len(e.fields) == 1 and e.fields[0] in live, "CLEAR only own live bank")
+                live.remove(e.fields[0])
+            else:
+                need(e.fields and all(f in public or f in live for f in e.fields), "use outside private lifetime")
+                if e.op == "COPY":
+                    need(len(e.fields) == 2 and e.fields[0] in live
+                         and e.fields[0] != e.fields[1], "private COPY ports")
+                if e.op == "PAID":
+                    need(len(e.fields) == 1 and type(e.rank) is int and e.rank > 0, "positive whole paid job")
+        need(not live, "all private lifetimes end")
+        return self
+
+    def pieces(self):
+        fragments, rounds = [[]], []
+        for e in self.events:
+            if e.op == "PAID":
+                rounds.append(e)
+                fragments.append([])
+            else:
+                fragments[-1].append(e)
+        return tuple(tuple(f) for f in fragments), tuple(rounds)
+
+
+def remap(event, names, context=(), rank_factor=1):
+    return Event(event.op, tuple(names[f] for f in event.fields),
+                 context + (event.token,), event.rank * rank_factor)
+
+
+def product(left, right):
+    """p7-TENSOR chronological substitution; never tensor an operator sum."""
+    left.check(); right.check()
+    lf, lr = left.pieces()
+    roles = tuple(((i,j),k*h) for i,k in left.roles for j,h in right.roles)
+    owned, maps, events = [], {}, []
+    for j,h in right.roles:
+        maps[j] = {i:(i,j) for i,_ in left.roles}
+        for o in left.owned:
+            fresh = ("left",j,o)
+            owned.append(fresh); maps[j][o] = fresh
+    for j,h in right.roles:
+        for i,_ in left.roles:
+            events.append(Event("SERVICE",((i,j),),("product-left-enter",j,h,i)))
+    for ell in range(len(lr)+1):
+        for j,h in right.roles:
+            events += [remap(e,maps[j],("product-left",j,h)) for e in lf[ell]]
+        if ell == len(lr):
+            break
+        issuing = lr[ell]
+        names = {j:maps[j][issuing.fields[0]] for j,_ in right.roles}
+        need(len(set(names.values())) == len(names), "distinct product request owners")
+        for o in right.owned:
+            fresh = ("right",ell,o)
+            owned.append(fresh); names[o] = fresh
+        events += [Event("SERVICE",(names[j],),("product-enter",ell,j,issuing.token)) for j,_ in right.roles]
+        events += [remap(e,names,("product-right",ell,issuing.rank,issuing.token),issuing.rank) for e in right.events]
+        events += [Event("SERVICE",(names[j],),("product-return",ell,j,issuing.token)) for j,_ in right.roles]
+    for j,h in right.roles:
+        for i,_ in left.roles:
+            events.append(Event("SERVICE",((i,j),),("product-left-return",j,h,i)))
+    return Unit(left.name+"*"+right.name,roles,tuple(owned),tuple(events)).check()
+
+
+def completion_split(unit, cutoff, floor):
+    unit.check()
+    need(0 < cutoff < floor <= max(k for _,k in unit.roles), "completion/splitting domain")
+    completed = [(name,k) for name,k in unit.roles if k < floor]
+    events = [Event("SERVICE",(name,),("whole-job-in",k,floor)) for name,k in completed]
+    extended = list(unit.events)
+    for name,k in completed:
+        extended.append(Event("PAID",(name,),("completion",k,floor),floor-k))
+    for e in extended:
+        if e.op != "PAID":
+            events.append(e); continue
+        start = 0
+        while start < e.rank:
+            size = min(cutoff,e.rank-start)
+            token = ("piece",start,size,e.rank,e.token)
+            events += [Event("SERVICE",e.fields,("piece-enter",)+token),
+                       Event("PAID",e.fields,token,size),
+                       Event("SERVICE",e.fields,("piece-return",)+token)]
+            start += size
+    events += [Event("SERVICE",(name,),("whole-job-out",k,floor)) for name,k in completed]
+    return Unit(unit.name+"/pass",tuple((name,max(k,floor)) for name,k in unit.roles),
+                unit.owned,tuple(events)).check()
+
+
+def current_local(word):
+    """Retain every current #6030 operand, chart, lifetime and paid position.
+
+    No all-column algebra is redone. MOVE ranks are the dimension differences
+    in the authenticated source rule, with their native meaning retained.
+    """
+    p,o = word["public"],word["owned_fields"]
+    frames = word["frames"]
+    current = list(word["initial"])+[None]*o
+    live,untouched,starts,episodes = set(),set(),{},[]
+    events,moves,peak = [],Counter(),0
+    for pc,raw in enumerate(word["program"]):
+        op,r = raw[:2]
+        need(type(r) is int and 0 <= r < p+o,"current local role")
+        token = ("local",pc,tuple(raw))
+        if op == "INIT":
+            need(p <= r and r not in live,"current fresh private INIT")
+            live.add(r); untouched.add(r); starts[r] = pc
+            current[r] = raw[2]; peak = max(peak,len(live))
+            events.append(Event("INIT",(r,),token))
+        elif op == "CLEAR":
+            need(r in live and current[r] == raw[2],"current owned CLEAR chart")
+            live.remove(r); untouched.discard(r)
+            episodes.append((r,starts.pop(r),pc)); current[r] = None
+            events.append(Event("CLEAR",(r,),token))
+        elif op == "MOVE":
+            need(len(raw) == 5 and type(raw[4]) is bool,"typed private MOVE flag")
+            need(current[r] == raw[2] and (r in live) == raw[4],"current MOVE owner and chart")
+            need(r < p or r in live,"live MOVE source")
+            rank = abs(len(frames[raw[3]])-len(frames[raw[2]]))
+            need(rank > 0,"current positive MOVE rank")
+            current[r] = raw[3]; moves[rank] += 1
+            untouched.discard(r)
+            events += [Event("SERVICE",(r,),("move-in",)+token),
+                       Event("PAID",(r,),token,rank),
+                       Event("SERVICE",(r,),("move-out",)+token)]
+        else:
+            need(op in ("COPY","ADD","SCALE") and current[r] == raw[-1],"current scalar destination chart")
+            need(r < p or r in live,"live scalar destination")
+            coefficient = Fraction(raw[-2])
+            need(coefficient != 0,"nonzero source coefficient")
+            if op == "SCALE":
+                fields = (r,)
+            else:
+                src = raw[2]
+                need(type(src) is int and 0 <= src < p+o and src != r,"current distinct scalar source")
+                need((src < p or src in live) and current[src] == raw[-1],"current common scalar chart")
+                fields = (r,src)
+            if op == "COPY":
+                need(r in untouched and coefficient == 1,"current COPY follows untouched INIT with coefficient one")
+                events.append(Event("COPY",fields,token))
+            else:
+                events.append(Event("SERVICE",fields,token))
+            untouched.discard(r)
+    need(not live and current[:p] == word["final"],"current complete local exit")
+    return tuple(events),dict(events=len(word["program"]),owned_labels=o,
+                              owned_lifetimes=len(episodes),peak_live=peak,
+                              episodes=episodes,paid=dict(sorted(moves.items())))
+
+
+def current_caller(word,caller):
+    """Exact outer/local field maps and explicit copied-query lifetimes.
+
+    Named contact/normalizer/query services retain source endpoint meanings.
+    Every original scalar/MOVE token and its chronology are preserved.
+    """
+    local_events,report = current_local(word)
+    ports = tuple(word["live"])
+    need(len(ports) == len(set(ports)) == 104,"current 104 ports")
+    need((caller["kind"],caller["pairs"],caller["prefix_pairs"],caller["ambient_rank"])
+         == ("complex",16,7,145),"current physical caller family")
+    main_local = set(ports)|{x+112 for x in ports}
+    helpers = sorted(set(range(word["public"]))-main_local)
+    locals_ = [e for e in caller["physical_events"] if e[0] == "LOCAL"]
+    need(len(locals_) == 18 and all(not e[3] for e in locals_),"current forward local sites")
+    public = 32*104+18*len(helpers)
+    own_first,query_first = public,public+18*word["owned_fields"]
+    owned = tuple(range(public,query_first+104))
+    roles = []
+    for i,term in enumerate(caller["diagonal"]):
+        stages = term[1:]
+        rank = (9 if stages[0] else 1)+8*sum(stages[1:])
+        roles += [(i*104+j,rank) for j in range(104)]
+    events,local_sites,query_sites = [],[],[]
+    def scalar(raw,context):
+        for j in range(104):
+            fields = (raw[1]*104+j,) if raw[0] == "SCALE" else (raw[1]*104+j,raw[2]*104+j)
+            events.append(Event("SERVICE",fields,context+(j,tuple(raw))))
+    for raw in caller["boundaries"]["right_program"]:
+        scalar(raw,("boundary-right",))
+    local_number = 0
+    for site,raw in enumerate(caller["physical_events"]):
+        op = raw[0]
+        if op == "LOCAL":
+            _,stage,pair,reverse = raw
+            need(not reverse,"all-forward local occurrence")
+            names = {}
+            for j,r in enumerate(ports):
+                names[r] = 2*pair*104+j; names[r+112] = (2*pair+1)*104+j
+            for j,r in enumerate(helpers):
+                field = 32*104+local_number*len(helpers)+j
+                names[r] = field
+                rank = len(word["frames"][word["final"][r]])-len(word["frames"][word["initial"][r]])
+                roles.append((field,rank))
+            for j in range(word["owned_fields"]):
+                names[word["public"]+j] = own_first+local_number*word["owned_fields"]+j
+            need(len(names) == len(set(names.values())) == word["public"]+word["owned_fields"],
+                 "injective complete current local grant")
+            for r in range(word["public"]):
+                events.append(Event("SERVICE",(names[r],),("local-entry",site,stage,r)))
+            events += [remap(e,names,("caller-local",site,stage)) for e in local_events]
+            for r in range(word["public"]):
+                events.append(Event("SERVICE",(names[r],),("local-return",site,stage,r)))
+            local_sites.append((site,stage,tuple(sorted(names.items())))); local_number += 1
+        elif op == "QUERY_SHEAR":
+            _,stage,pair,reverse = raw
+            need(not reverse,"current forward query")
+            for j in range(104):
+                x,y,z = 2*pair*104+j,(2*pair+1)*104+j,query_first+j
+                token = ("query",site,stage,j)
+                events += [Event("INIT",(z,),token),Event("COPY",(z,x),token),
+                           Event("SERVICE",(z,),("query-in",)+token),Event("PAID",(z,),token,1),
+                           Event("SERVICE",(z,),("query-out",)+token),
+                           Event("SERVICE",(y,z),("query-add",)+token),Event("CLEAR",(z,),token)]
+                query_sites.append((site,j,x,y,z))
+        elif op == "IDLE":
+            for side in (0,1):
+                for j in range(104):
+                    field = (2*raw[1]+side)*104+j
+                    token = ("idle",site,tuple(raw[2]),side,j)
+                    events += [Event("SERVICE",(field,),("idle-in",)+token),
+                               Event("PAID",(field,),token,8*len(raw[2])),
+                               Event("SERVICE",(field,),("idle-out",)+token)]
+        elif op == "Q_POWER":
+            for j in range(104):
+                events.append(Event("SERVICE",(raw[1]*104+j,),("central-square",site,j,raw[2])))
+        else:
+            need(op in ("ADD","SWAP","SIGNED_SWAP"),"current outer scalar opcode")
+            scalar(raw,("outer",site))
+    for raw in caller["boundaries"]["left_program"]:
+        scalar(raw,("boundary-left",))
+    roles = tuple(sorted(roles))
+    need([r for r,_ in roles] == list(range(public)),"every productive field supplied once")
+    # The pinned occurrence theorem supplies the complete 145-coordinate
+    # whole-job canonicalizers. Each is a charged service, never a free name.
+    events = ([Event("SERVICE",(r,),("raw-whole-job-enter",r,k)) for r,k in roles]
+              +events+[Event("SERVICE",(r,),("raw-whole-job-return",r,k)) for r,k in roles])
+    unit = Unit("selected6030",roles,owned,tuple(events)).check()
+    report.update(public_count=public,raw_owned=len(owned),local_sites=len(local_sites),
+                  query_lifetimes=len(query_sites),total_lifetimes=18*report["owned_lifetimes"]+len(query_sites),
+                  raw_paid=dict(sorted(Counter(e.rank for e in events if e.op=="PAID").items())),
+                  raw_targets=dict(sorted(Counter(k for _,k in roles).items())),raw_events=len(events))
+    return unit,report
+
+
+def lower(unit,rank,source):
+    """Refine #5443's unchanged matching, with no partial/interface fallback.
+
+    Insert all inter-round fragments before a class is suspended. Flatten
+    finite compiler substitutions; only rank-one leaves make runtime children.
+    """
+    unit.check()
+    fragments,rounds = unit.pieces()
+    need(rounds,"nonempty paid word")
+    need(max(e.rank for e in rounds)<min(k for _,k in unit.roles),"strict separated compiler rule")
+    R = source.Rule(unit.name,unit.roles,tuple((e.rank,e.fields[0]) for e in rounds),unit.owned)
+    public_names = {name for name,_ in unit.roles}
+
+    class Lowerer(source.Compiler):
+        def __init__(self):
+            super().__init__(R,owned_policy="unit")
+            self.code,self.indices,self.contexts = [],{},[]
+            self.unit_context,self.unit_fields,self.occurrences = {},{},[]
+            self.borrowed_private = 0
+            self.program_frames,self.program_count = [],0
+
+        def number(self,field):
+            need(field in self.indices,"field has a static allocation")
+            return self.indices[field]
+
+        def append(self,event,names,context):
+            self.code.append(remap(event,{key:self.number(value) for key,value in names.items()},context))
+
+        def push(self,field,entry,expect_top):
+            super().push(field,entry,expect_top)
+            if isinstance(entry,tuple) and len(entry)==2 and type(entry[0]) is int:
+                g,name = entry
+                ctx = self.contexts[-1]
+                if g not in self.unit_fields:
+                    pos = len(ctx["gids"])
+                    need(pos<len(ctx["metadata"]),"source class unit enumeration")
+                    ctx["gids"].append(g)
+                    self.unit_context[g],self.unit_fields[g] = ctx,{}
+                self.unit_fields[g][name] = field
+                if name in public_names:
+                    pos = ctx["gids"].index(g)
+                    copy,point,column = ctx["metadata"][pos]
+                    context = ("occurrence",ctx["serial"],g,copy,point,column,ctx["n"],name)
+                    self.code.append(Event("SERVICE",(self.number(field),),("occurrence-enter",)+context))
+                    self.occurrences.append((context,self.number(field),expect_top))
+                    if isinstance(field,tuple) and field and field[0]=="own":
+                        self.borrowed_private += 1
+
+        def pop(self,field,entry):
+            if isinstance(entry,tuple) and len(entry)==2 and type(entry[0]) is int and entry[1] in public_names:
+                g,name = entry
+                ctx = self.unit_context[g]
+                pos = ctx["gids"].index(g)
+                copy,point,column = ctx["metadata"][pos]
+                context = ("occurrence",ctx["serial"],g,copy,point,column,ctx["n"],name)
+                self.code.append(Event("SERVICE",(self.number(field),),("occurrence-return",)+context))
+            super().pop(field,entry)
+
+        def alloc_bank(self,g,oname,frame,d):
+            field = super().alloc_bank(g,oname,frame,d)
+            need(field not in self.indices,"fresh occurrence bank identity")
+            self.indices[field] = len(self.indices)
+            return field
+
+        def begin_round(self,ctx):
+            j = ctx["round"]
+            need(j<len(rounds),"source cannot advance beyond final round")
+            need(len(ctx["gids"])==len(ctx["metadata"]),"complete class match before scalar contacts")
+            for g,meta in zip(ctx["gids"],ctx["metadata"]):
+                names = self.unit_fields[g]
+                need(set(names)==public_names|set(unit.owned),"complete field map")
+                for e in fragments[j]:
+                    self.append(e,names,("unit-fragment",ctx["serial"],g,meta[2],j))
+            ctx["round"] += 1
+            return j
+
+        def run_class(self,frame,n,a,G,d,dil,incoming,exits_iter):
+            if incoming:
+                parent = self.unit_context[incoming[0]["issuer"][0]]
+                j = self.begin_round(parent)
+                need(len(incoming)==len(parent["gids"]),"one request per parent unit")
+                for job,g,meta in zip(incoming,parent["gids"],parent["metadata"]):
+                    need(job["issuer"]==(g,rounds[j].fields[0]) and job["rank"]==rounds[j].rank*meta[2],
+                         "literal incoming owner and rank")
+            metadata = [(copy,point,dil*R.c(point)) for copy in range(a)
+                        for point in R.lattice(n,dil) if sum(point)==G-d for _ in range(R.u(point))]
+            ctx = dict(n=n,metadata=metadata,gids=[],round=0,pending=None,serial=len(self.occurrences))
+            self.contexts.append(ctx)
+            super().run_class(frame,n,a,G,d,dil,incoming,exits_iter)
+            need(ctx["round"]==len(rounds) or not metadata,"complete source class chronology")
+            need(self.contexts.pop() is ctx,"static compiler stack order")
+
+        def free_class_banks(self,units):
+            if units:
+                ctx = self.unit_context[units[0][1]]
+                need(ctx["round"]==len(rounds) and ctx["pending"] is None,"all exits returned before cleanup")
+                for U in units:
+                    _,g,_,column,_,_,_ = U
+                    for e in fragments[-1]:
+                        self.append(e,self.unit_fields[g],("unit-fragment",ctx["serial"],g,column,len(rounds)))
+            super().free_class_banks(units)
+
+        def sub(self,n,fields,tops):
+            kind = ("source-complement",self.program_frames[-1],n,
+                    self.program_frames[-1][1]-n)
+            if tops and isinstance(tops[0],tuple) and len(tops[0])==2 and type(tops[0][0]) is int:
+                ctx = self.unit_context[tops[0][0]]
+                if ctx["pending"] is None:
+                    j = self.begin_round(ctx)
+                    ctx["pending"] = set(ctx["gids"])
+                else:
+                    j = ctx["round"]-1
+                for field,top in zip(fields,tops):
+                    g,name = top
+                    need(self.unit_context[g] is ctx and g in ctx["pending"],"unique exit batch owner")
+                    need(name==rounds[j].fields[0] and field==self.unit_fields[g][name],"exact exit binding")
+                    ctx["pending"].remove(g)
+                if not ctx["pending"]:
+                    ctx["pending"] = None
+                kind = ("deepest-exit",ctx["serial"],j,n,tuple(tops))
+            ordered_fields = tuple(self.number(field) for field in fields)
+            need(len(set(ordered_fields))==len(ordered_fields),"whole smaller-program distinct field binding")
+            binding = ("matched-program",kind,ordered_fields)
+            for index,field in enumerate(ordered_fields):
+                self.code.append(Event("SERVICE",(field,),("program-enter",binding,index)))
+            if n<R.m:
+                self.blackbox(n,fields,tops)
+                self.stats["base_rank_lt_m_fields"] += len(fields)
+            else:
+                need(len(fields)==self.compile(n)[0],"complete smaller-rank program; no interface-only fallback")
+                self.uniform(n,fields,tops)
+            for index in reversed(range(len(ordered_fields))):
+                self.code.append(Event("SERVICE",(ordered_fields[index],),("program-return",binding,index)))
+
+        def blackbox(self,n,fields,tops):
+            need(n<R.m,"only elementary rank base may be opaque")
+            super().blackbox(n,fields,tops)
+            for field in fields:
+                for axis in range(n):
+                    token=("ordinary-rank-one",len(self.code),self.number(field),
+                           tuple(self.program_frames),
+                           tuple((c["serial"],c["round"]) for c in self.contexts),axis,n)
+                    self.code.append(Event("SERVICE",(self.number(field),),("base-axis-enter",)+token))
+                    self.code.append(Event("PAID",(self.number(field),),token,1))
+                    self.code.append(Event("SERVICE",(self.number(field),),("base-axis-return",)+token))
+
+        def uniform(self,n,fields,tops,top_level=False,copies=None):
+            need(copies is None,"partial compiler execution forbidden")
+            self.program_count += 1
+            self.program_frames.append((self.program_count,n))
+            super().uniform(n,fields,tops,top_level=top_level,copies=None)
+            self.program_frames.pop()
+
+    compiler = Lowerer()
+    B,a,P,cost = compiler.compile(rank)
+    fields = [("array",i) for i in range(B)]
+    compiler.indices.update({field:i for i,field in enumerate(fields)})
+    if rank<R.m:
+        compiler.blackbox(rank,fields,[None]*B)
+    else:
+        compiler.uniform(rank,fields,[None]*B,top_level=True)
+        need(all(compiler.received[f]==2 for f in fields),"every source plus complement occurs exactly once")
+    need(all(not entries for entries in compiler.stack.values()),"source ownership stacks restored")
+    need(sum(e.op=="PAID" for e in compiler.code)==P,"literal paid leaf count")
+    result = Unit(unit.name+"/uniform",tuple((i,rank) for i in range(B)),
+                  tuple(range(B,len(compiler.indices))),tuple(compiler.code)).check()
+    summary = dict(rank=rank,width=B,replication=a,paid=P,source_cost=cost,
+                   events=len(result.events),owned=len(result.owned),
+                   occurrences=len(compiler.occurrences),borrowed_private=compiler.borrowed_private,
+                   source_stats=dict(sorted(compiler.stats.items())))
+    return result,summary,tuple(compiler.occurrences)
+
+
+def check_flat_ownership(unit):
+    """Independent flat-word permission replay; does not call the compiler."""
+    public={i for i,_ in unit.roles};private=set(unit.owned)
+    scopes={i:[] for i in public|private}
+    owners={};max_depth=0;counts=Counter()
+    for e in unit.events:
+        token=e.token
+        if e.op=="SERVICE" and token and token[0] in ("occurrence-enter","occurrence-return"):
+            field,=e.fields;scope=("occurrence",token[1:])
+            if token[0].endswith("enter"):
+                need(field in public or field in owners,"borrow initialized actual private field")
+                scopes[field].append(scope);counts["occurrence_entries"]+=1
+                counts["private_occurrence_entries"]+=int(field in private)
+            else:
+                need(scopes[field] and scopes[field][-1]==scope,"exact occurrence inverse return")
+                scopes[field].pop()
+        elif e.op=="SERVICE" and token and token[0] in ("program-enter","program-return"):
+            field,=e.fields;binding,index=token[1:]
+            need(binding[0]=="matched-program" and binding[2][index]==field,"ordered complete subprogram field")
+            scope=("program",binding,index)
+            if token[0].endswith("enter"):
+                need(field in public or field in owners,"subprogram borrows initialized field")
+                scopes[field].append(scope);counts[binding[1][0]+"_fields"]+=1
+            else:
+                need(scopes[field] and scopes[field][-1]==scope,"exact whole-program inverse return")
+                scopes[field].pop()
+        elif e.op=="SERVICE" and token and token[0] in ("base-axis-enter","base-axis-return"):
+            field,=e.fields;scope=("base-axis",token[1:])
+            need(token[1]=="ordinary-rank-one" and token[3]==field,"actual elementary axis owner")
+            if token[0].endswith("enter"):
+                need(field in public or field in owners,"base axis borrows initialized field")
+                scopes[field].append(scope);counts["base_axis_entries"]+=1
+            else:
+                need(scopes[field] and scopes[field][-1]==scope,"exact elementary axis inverse return")
+                scopes[field].pop()
+        else:
+            actor=token[2] if token and token[0]=="unit-fragment" else None
+            if e.op=="INIT":
+                field,=e.fields
+                need(actor is not None and field in private and field not in owners and not scopes[field],
+                     "fresh unborrowed static private bank")
+                owners[field]=actor;counts["physical_init_sites"]+=1
+            elif e.op=="CLEAR":
+                field,=e.fields
+                need(field in owners and owners[field]==actor and not scopes[field],
+                     "only actual owner clears after all child returns")
+                del owners[field];counts["physical_clear_sites"]+=1
+            else:
+                for field in e.fields:
+                    need(field in public or field in owners,"initialized emitted operand")
+                    if actor is not None:
+                        if scopes[field]:
+                            top=scopes[field][-1]
+                            need(top[0]=="occurrence" and top[1][2]==actor,
+                                 "parent cannot resume through a pending borrow")
+                        else:
+                            need(owners.get(field)==actor,"unborrowed private actor")
+                if e.op=="PAID":
+                    need(e.rank==1,"only ordinary rank-one calls remain")
+                    counts["ordinary_paid_sites"]+=1
+                    counts["ordinary_private_paid_sites"]+=int(e.fields[0] in private)
+        max_depth=max(max_depth,max((len(scopes[f]) for f in e.fields),default=0))
+    need(not owners and not any(scopes.values()),"all static scopes and physical lifetimes close")
+    return dict(max_borrow_depth=max_depth,counts=dict(sorted(counts.items())))
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lockstep_executor.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lockstep_executor.py
new file mode 100644
index 0000000000..9469443a3d
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/lockstep_executor.py
@@ -0,0 +1,558 @@
+"""Event-level executor of the FINITE-PRECOMPILATION lockstep compiler, extended with
+(a) tagged rounds produced by the completion/splitting pass and (b) a LIFO owned-bank
+allocator ("stack" policy) whose peak occupancy is measured.
+
+Derived from research/lockstep-live-role-audit/live_roles.py (our #4691), which keeps,
+for every physical field, the stack of live roles and checks the ownership invariants
+I1-I6 at every event.  Everything from that file is retained; the additions are:
+
+  * Rule.kinds   one tag per chronological round: "orig" (an original paid job),
+                 "piece" (a non-leading piece of a split job) or "completion"
+                 (a piece of the paid completion of a small target on its own owner);
+  * Rule.completed  role -> (K, L) for every role completed from rank K to rank L;
+  * owned_policy="stack": owned banks are taken from one LIFO stack of bank slots.
+    A unit allocates its banks when its class starts and frees them when its class
+    ends; the executor requires the freed banks to be exactly the top of the stack
+    (nested lifetimes, invariant I7) and records the peak number of live slots;
+  * owned_policy="release_early": a deliberately wrong allocator that frees the
+    class's banks before its rounds run (must be rejected);
+  * per-execution counters for pieces, completions, adapters and bank scans.
+
+Imported by counts.py, verify.py and test_verify.py.
+"""
+from collections import Counter, defaultdict
+from fractions import Fraction
+from functools import lru_cache
+from math import factorial, gcd, lcm, prod
+from pathlib import Path
+import random
+
+HERE = Path(__file__).resolve().parent
+REPO = HERE.parents[1]
+
+
+class Violation(Exception):
+    pass
+
+
+def need(ok, msg):
+    if not ok:
+        raise Violation(msg)
+
+
+# ------------------------------------------------------------------ rules
+class Rule:
+    def __init__(self, name, roles, rounds, owned=("C0",), kinds=None, completed=None):
+        self.name, self.roles, self.rounds, self.owned = name, tuple(roles), tuple(rounds), tuple(owned)
+        self.kinds = tuple(kinds) if kinds is not None else tuple("orig" for _ in self.rounds)
+        self.completed = dict(completed or {})
+        assert len(self.kinds) == len(self.rounds)
+        assert all(k in ("orig", "piece", "completion") for k in self.kinds)
+        names = [n for n, _ in self.roles]
+        assert len(set(names)) == len(names)
+        assert all(o in set(names) | set(self.owned) for _, o in self.rounds)
+        self.targets = Counter(k for _, k in self.roles)
+        self.types = tuple(sorted(self.targets))
+        self.W = tuple(self.targets[k] for k in self.types)
+        self.m = max(self.types)
+        assert max(r for r, _ in self.rounds) < min(self.types), "strict hierarchy"
+
+    def c(self, a):
+        return prod(k ** e for k, e in zip(self.types, a))
+
+    def u(self, a):
+        return factorial(sum(a)) // prod(factorial(e) for e in a) * prod(w ** e for w, e in zip(self.W, a))
+
+    def lattice(self, n, dil):
+        bound = n // (self.m * dil)
+        out = []
+
+        def rec(i, a, val):
+            if i == len(self.types):
+                out.append(tuple(a))
+                return
+            e = 0
+            while val <= bound:
+                rec(i + 1, a + [e], val)
+                e += 1
+                val *= self.types[i]
+        if bound:
+            rec(0, [], 1)
+        return out
+
+    # per-unit record counts of the pass (see PROOF.md, Lemma A)
+    def pass_counts(self):
+        kinds = Counter(self.kinds)
+        return {"rounds": len(self.rounds), "orig_rounds": kinds["orig"], "piece_rounds": kinds["piece"],
+                "completion_rounds": kinds["completion"], "completed_roles": len(self.completed),
+                "adapters": 2 * len(self.completed),
+                "relocations": kinds["piece"] + kinds["completion"],
+                "owned_banks": len(self.owned)}
+
+
+# ------------------------------------------------------------------ executor
+class Compiler:
+    """Counting pass (widths, source order) and event-level execution."""
+
+    def __init__(self, rule, owned_policy="unit", eager=False, bad_exit=False, budget=3_000_000):
+        self.R = rule
+        self.policy, self.eager, self.bad_exit = owned_policy, eager, bad_exit
+        self.budget = budget
+        self.stack = defaultdict(list)       # field -> list of entries (guid, role)
+        self.guid = 0
+        self.fresh = 0
+        self.events = 0
+        self.stats = Counter()
+        self.received = Counter()            # top-level field -> number of full-rank completions
+        self.max_live_depth = 0
+        self.partial = False
+        self.bank_stack = []                 # LIFO allocator of owned-bank slots ("stack" policy)
+        self.peak_banks = 0
+        self.total_bank_allocations = 0
+
+    # ---------------- counting
+    @lru_cache(None)
+    def plan(self, n):
+        """Ordered source ranks of one tree copy and ordered exit batches (rank, t)."""
+        R = self.R
+        pts = R.lattice(n, 1)
+        G = max(map(sum, pts))
+        sources, exits, units = [], [], [0]
+
+        def cls(d, dil, incoming):
+            us = [(a, dil * R.c(a)) for a in R.lattice(n, dil) if sum(a) == G - d for _ in range(R.u(a))]
+            units[0] += len(us)
+            demand = defaultdict(int)
+            for a, col in us:
+                for _, k in R.roles:
+                    i = R.types.index(k)
+                    demand[tuple(x + (j == i) for j, x in enumerate(a))] += 1
+            supply = Counter(p for p, _ in incoming)
+            assert set(supply) <= set(demand) and all(supply[p] <= demand[p] for p in supply)
+            used = Counter()
+            for a, col in us:
+                for _, k in R.roles:
+                    i = R.types.index(k)
+                    p = tuple(x + (j == i) for j, x in enumerate(a))
+                    if used[p] < supply[p]:
+                        used[p] += 1
+                    else:
+                        sources.append(k * col)
+            for j, (r, _) in enumerate(R.rounds):
+                out = [(a, r * col) for a, col in us]
+                if d < G:
+                    cls(d + 1, dil * r, out)
+                else:
+                    ranks = {rk for _, rk in out}
+                    assert len(ranks) == 1
+                    exits.append((ranks.pop(), len(out)))
+        cls(0, 1, [])
+        return tuple(sources), tuple(exits), units[0], G
+
+    @lru_cache(None)
+    def compile(self, n):
+        """(width B_n, replication a, leaves P_n, roles_executed) ; base: ordinary rank-one program."""
+        if n < self.R.m:
+            return (1, 1, n, 0)
+        sources, exits, units, G = self.plan(n)
+        S = len(sources)
+        a = 1
+        for e, t in exits:
+            B = self.compile(e)[0]
+            a = lcm(a, B // gcd(B, t))
+        for s, cnt in Counter(sources).items():
+            if n - s:
+                B = self.compile(n - s)[0]
+                a = lcm(a, B // gcd(B, cnt))
+        width = a * S
+        leaves = Fraction(0)
+        cost = a * units * len(self.R.roles)
+        for e, t in exits:
+            B, _, P, c = self.compile(e)
+            leaves += Fraction(a * t * P, B)
+            cost += a * t // B * c
+        for s in sources:
+            if n - s:
+                B, _, P, c = self.compile(n - s)
+                leaves += Fraction(a * P, B)
+        for s, cnt in Counter(sources).items():
+            if n - s:
+                B, _, P, c = self.compile(n - s)
+                cost += a * cnt // B * c
+        assert leaves.denominator == 1
+        return (width, a, leaves.numerator, cost)
+
+    # ---------------- execution helpers
+    def new_field(self, tag):
+        self.fresh += 1
+        return (tag, self.fresh)
+
+    def push(self, f, entry, expect_top):
+        st = self.stack[f]
+        top = st[-1] if st else None
+        need(top == expect_top, f"I2 nesting: field {f} top {top} != expected {expect_top}")
+        st.append(entry)
+        self.max_live_depth = max(self.max_live_depth, len(st))
+        self.events += 1
+
+    def pop(self, f, entry):
+        st = self.stack[f]
+        need(st and st[-1] == entry, f"I4 LIFO: field {f} top {st[-1] if st else None} != {entry}")
+        st.pop()
+        self.events += 1
+
+    # ---------------- owned banks
+    def alloc_bank(self, g, oname, frame, d):
+        """Return the physical field of one owned bank of unit g under the current policy."""
+        if self.policy in ("unit",):
+            of = ("own", g, oname)
+        elif self.policy == "depth":
+            of = ("own-depth", id(frame), d, oname)
+        elif self.policy in ("stack", "release_early"):
+            slot = len(self.bank_stack)
+            self.bank_stack.append((g, oname))
+            self.peak_banks = max(self.peak_banks, len(self.bank_stack))
+            of = ("bank", slot)
+        else:
+            raise ValueError(self.policy)
+        self.total_bank_allocations += 1
+        self.stats["bank_init_scans"] += 1
+        return of
+
+    def free_class_banks(self, units):
+        """Invariant I7 (nested lifetimes): the banks of a finishing class are exactly the
+        top of the LIFO allocator.  Banks are then released for reuse by sibling classes."""
+        if self.policy not in ("stack", "release_early"):
+            return
+        mine = [(g, oname) for _, g, _, _, _, omap, _ in units for oname in omap]
+        top = self.bank_stack[len(self.bank_stack) - len(mine):]
+        need(len(self.bank_stack) >= len(mine) and Counter(top) == Counter(mine),
+             "I7 nested bank lifetimes: a finishing class's banks are not the top of the allocator")
+        del self.bank_stack[len(self.bank_stack) - len(mine):]
+        self.stats["bank_erase_scans"] += len(mine)
+
+    # ---------------- execution
+    def blackbox(self, n, fields, tops):
+        need(len(set(fields)) == len(fields), "I5 distinct fields handed to a smaller program")
+        for f, t in zip(fields, tops):
+            st = self.stack[f]
+            need((st[-1] if st else None) == t, "I5 handed field is owned by its issuer")
+        g = ("sub", self.next_guid())
+        for f, t in zip(fields, tops):
+            self.push(f, g, t)
+        for f in fields:
+            self.pop(f, g)
+        self.stats["interface_checked_subprogram_fields"] += len(fields)
+
+    def sub(self, n, fields, tops):
+        if n < self.R.m:
+            self.blackbox(n, fields, tops)
+            self.stats["base_rank_lt_m_fields"] += len(fields)
+            return
+        B, a, P, cost = self.compile(n)
+        if len(fields) == B and cost <= self.budget and not self.partial:
+            self.uniform(n, fields, tops)
+        else:
+            self.blackbox(n, fields, tops)
+
+    def uniform(self, n, fields, tops, top_level=False, copies=None):
+        B, a, P, cost = self.compile(n)
+        sources, exits, units, G = self.plan(n)
+        S = len(sources)
+        if copies is not None and copies < a:
+            a = copies
+            self.partial = True
+        need(len(fields) == a * S, "I5 width")
+        need(len(set(fields)) == len(fields), "I5 distinct fields handed to a program")
+        for f, t in zip(fields, tops):
+            st = self.stack[f]
+            need((st[-1] if st else None) == t, "I5 handed field is owned by its issuer")
+        self.stats["executed_programs"] += 1
+        snapshot = {f: list(self.stack[f]) for f in fields}
+        prog = ("prog", self.next_guid())
+        for f, t in zip(fields, tops):
+            self.push(f, prog, t)
+        by_rank = defaultdict(list)
+        for c in range(a):
+            for i, s in enumerate(sources):
+                by_rank[s].append(fields[c * S + i])
+        for s in sorted(by_rank):
+            grp = by_rank[s]
+            if top_level:
+                for f in grp:
+                    self.received[f] += 1
+            if n - s:
+                Bc = self.compile(n - s)[0]
+                if self.partial:
+                    self.sub(n - s, grp, [prog] * len(grp))
+                else:
+                    need(len(grp) % Bc == 0, "complement batch integral")
+                    for i in range(0, len(grp), Bc):
+                        self.sub(n - s, grp[i:i + Bc], [prog] * Bc)
+        if top_level:
+            self.top_prog = prog
+        frame = (fields, S, prog, [0] * a)
+        self.run_class(frame, n, a, G, 0, 1, None, iter(exits))
+        need(all(p == S for p in frame[3]), "every source slot used exactly once")
+        for f in fields:
+            self.pop(f, prog)
+        need(all(self.stack[f] == snapshot[f] for f in fields), "I4 program restores all stacks")
+
+    def next_guid(self):
+        self.guid += 1
+        return self.guid
+
+    def run_class(self, frame, n, a, G, d, dil, incoming, exits_iter):
+        R = self.R
+        fields, S, prog, ptr = frame
+        units = []      # (copy, guid, point, column, {role: field}, owned {name: field}, issuing)
+        for c in range(a):
+            for pt in R.lattice(n, dil):
+                if sum(pt) != G - d:
+                    continue
+                for _ in range(R.u(pt)):
+                    units.append([c, self.next_guid(), pt, dil * R.c(pt), {}, {}, None])
+        supply = defaultdict(list)
+        if incoming:
+            for job in incoming:
+                supply[(job["copy"], job["point"])].append(job)
+        used = Counter()
+        live = []
+        for U in units:
+            c, g, pt, col, fmap, omap, _ = U
+            for name, k in R.roles:
+                i = R.types.index(k)
+                p = tuple(x + (j == i) for j, x in enumerate(pt))
+                lst = supply.get((c, p), [])
+                if used[(c, p)] < len(lst):
+                    job = lst[used[(c, p)]]
+                    used[(c, p)] += 1
+                    need(job["rank"] == k * col, "I2 whole job: child role rank == parent job rank")
+                    self.push(job["field"], (g, name), job["issuer"])
+                    fmap[name] = job["field"]
+                    self.stats["nested_role_entries"] += 1
+                else:
+                    f = fields[c * S + ptr[c]]
+                    ptr[c] += 1
+                    need(n < R.m * k * col <= R.m * n, "source band")
+                    self.push(f, (g, name), prog)
+                    if prog == getattr(self, "top_prog", None):
+                        self.received[f] += 1
+                    fmap[name] = f
+                    self.stats["source_role_entries"] += 1
+                live.append(fmap[name])
+            for oname in R.owned:
+                of = self.alloc_bank(g, oname, frame, d)
+                self.push(of, (g, oname), None)    # owned bank must be free when allocated
+                omap[oname] = of
+                live.append(of)
+        need(all(used[k] == len(v) for k, v in supply.items()), "every parent job consumed")
+        need(len(live) == len(set(live)), "I1 simultaneously live roles of a class are distinct arrays")
+        self.stats["classes"] += 1
+        self.stats["units"] += len(units)
+        self.stats["max_class_live_roles"] = max(self.stats["max_class_live_roles"], len(live))
+        pc = R.pass_counts()
+        self.stats["adapter_records"] += pc["adapters"] * len(units)
+        self.stats["relocation_records"] += pc["relocations"] * len(units)
+        if self.policy == "release_early":
+            # wrong allocator: give the slots back before the rounds (children may alias them)
+            mine = [(g, oname) for _, g, _, _, _, omap, _ in units for oname in omap]
+            del self.bank_stack[len(self.bank_stack) - len(mine):]
+            for U in units:
+                for oname, of in U[5].items():
+                    self.pop(of, (U[1], oname))
+        pending = []
+        for j, ((r, owner), kind) in enumerate(zip(R.rounds, R.kinds)):
+            out = []
+            for U in units:
+                c, g, pt, col, fmap, omap, issuing = U
+                need(issuing is None, "I3 lockstep: parent suspended until its child finished")
+                f = fmap.get(owner, omap.get(owner))
+                st = self.stack[f]
+                need(st and st[-1] == (g, owner), "I3 paid job issued on a field the unit currently owns")
+                U[6] = f
+                out.append({"copy": c, "point": pt, "rank": r * col, "field": f, "issuer": (g, owner)})
+            need(len({o["field"] for o in out}) == len(out), "I3 ordered round has no field alias")
+            self.stats[f"{kind}_jobs"] += len(out)
+            if d < G:
+                if self.eager:
+                    pending.append((r, out))
+                    if len(pending) == 2 or j == len(R.rounds) - 1:
+                        for U in units:
+                            U[6] = None
+                        for rr, oo in pending:
+                            self.run_class(frame, n, a, G, d + 1, dil * rr, oo, exits_iter)
+                        pending = []
+                    continue
+                self.run_class(frame, n, a, G, d + 1, dil * r, out, exits_iter)
+            else:
+                e, t = next(exits_iter)
+                need(all(o["rank"] == e for o in out) and len(out) == a * t, "exit batch shape")
+                Be = self.compile(e)[0]
+                flds = [o["field"] for o in out]
+                tps = [o["issuer"] for o in out]
+                if self.bad_exit and len(flds) >= 2:
+                    flds[1] = flds[0]
+                if self.partial:
+                    self.sub(e, flds, tps)
+                else:
+                    need(len(out) % Be == 0, "I5 exit batch integral")
+                    for i in range(0, len(flds), Be):
+                        self.sub(e, flds[i:i + Be], tps[i:i + Be])
+                self.stats["exit_jobs"] += len(out)
+            for U in units:
+                f = U[6]
+                if f is not None:
+                    st = self.stack[f]
+                    need(st[-1] == (U[1], owner), "I4 field returned to the parent after the child class")
+                U[6] = None
+        if self.policy != "release_early":
+            self.free_class_banks(units)
+            for U in units:
+                c, g, pt, col, fmap, omap, _ = U
+                for oname, of in omap.items():
+                    self.pop(of, (g, oname))
+        for U in units:
+            c, g, pt, col, fmap, omap, _ = U
+            for name, _ in reversed(R.roles):
+                self.pop(fmap[name], (g, name))
+
+
+def audit(rule, n, copies_if_large=2, **kw):
+    C = Compiler(rule, **kw)
+    B, a, P, cost = C.compile(n)
+    sources = C.plan(n)[0]
+    G = C.plan(n)[3]
+    copies = None if cost <= C.budget else min(a, copies_if_large)
+    k = a if copies is None else copies
+    fields = [("array", i) for i in range(k * len(sources))]
+    C.uniform(n, fields, [None] * len(fields), top_level=True, copies=copies)
+    need(all(not C.stack[f] for f in C.stack), "I4 all stacks empty at the end")
+    need(all(C.received[f] == 2 for f in fields), "I6 every array: complement + source job exactly once")
+    need(not C.bank_stack, "I7 allocator empty at the end")
+    return {"rank": n, "generations": G, "width_B_log10": len(str(B)) - 1, "replication_a_log10": len(str(a)) - 1,
+            "P_over_B": float(Fraction(P, B)), "executed_tree_copies": k, "full_width_executed": copies is None,
+            "events": C.events, "max_live_stack_on_one_array": C.max_live_depth,
+            "peak_banks": C.peak_banks, "total_bank_allocations": C.total_bank_allocations, **dict(C.stats)}
+
+
+def negative(rule, n, **kw):
+    try:
+        audit(rule, n, **kw)
+        return None
+    except Violation as e:
+        return str(e)
+
+
+# ------------------------------------------------------------------ the pass (Lemma A)
+class RawRule:
+    """Input of the pass: a native unit whose paid ranks may overlap its target ranks, so the
+    lockstep hierarchy r_max < k_min is not asserted (it holds only after the pass)."""
+
+    def __init__(self, name, roles, rounds, owned=("C0",)):
+        self.name, self.roles, self.rounds, self.owned = name, tuple(roles), tuple(rounds), tuple(owned)
+        self.kinds = tuple("orig" for _ in self.rounds)
+        self.completed = {}
+        self.targets = Counter(k for _, k in self.roles)
+
+    @property
+    def separated(self):
+        return max(r for r, _ in self.rounds) < min(self.targets)
+
+
+def pieces(rank, J):
+    """Consecutive disjoint-axis pieces of a job of the given rank at cutoff J."""
+    q, r = divmod(rank, J)
+    return [J] * q + ([r] if r else [])
+
+
+def complete_and_split(rule, J, L, name=None, completion_owner="self", drop_remainder=False,
+                       completion_rank_shift=0):
+    """Completion of every role of rank K<L to rank L by a paid job of rank L-K on disjoint
+    axes of that same owner (after every original round), then splitting of every paid job,
+    original or completion, into consecutive pieces of rank <= J.  Returns the new Rule.
+    The keyword mutations are rejecting controls, never used for a result."""
+    assert 0 < J < L, "cutoff must be below the completion floor"
+    roles = tuple((nm, max(k, L)) for nm, k in rule.roles)
+    rounds, kinds = [], []
+    for (r, owner), kind in zip(rule.rounds, rule.kinds):
+        ps = pieces(r, J)
+        if drop_remainder and len(ps) > 1 and ps[-1] != J:
+            ps = ps[:-1]
+        for i, p in enumerate(ps):
+            rounds.append((p, owner))
+            kinds.append(kind if i == 0 else "piece")
+    completed = dict(rule.completed)
+    for nm, k in rule.roles:
+        if k < L:
+            D = L - k + completion_rank_shift
+            owner = nm if completion_owner == "self" else completion_owner
+            for p in pieces(D, J):
+                rounds.append((p, owner))
+                kinds.append("completion")
+            completed[nm] = (k, L)
+    return Rule(name or f"{rule.name} | completed L={L}, split J={J}", roles, rounds, rule.owned, kinds, completed)
+
+
+# ------------------------------------------------------------------ rule zoo
+def toy():
+    return Rule("toy (finite_dag_audit synthetic)", (("a", 3), ("b", 3), ("c", 4)),
+                ((1, "a"), (1, "C0"), (1, "b"), (1, "a"), (2, "c"), (2, "C0")))
+
+
+def overlapping_toy():
+    """Paid ranks reach the smallest target: the lockstep hierarchy fails before the pass."""
+    roles = (("a", 3), ("b", 5), ("c", 8))
+    rounds = ((1, "a"), (4, "C0"), (7, "b"), (2, "a"), (5, "c"), (3, "C0"), (6, "b"))
+    return roles, rounds
+
+
+def shaped(name, target_ranks, role_counts, paid_ranks, n_rounds, seed, owned=("C0",), adversarial=None):
+    rng = random.Random(seed)
+    roles = [(f"t{k}_{i}", k) for k, cnt in zip(target_ranks, role_counts) for i in range(cnt)]
+    names = [nm for nm, _ in roles] + list(owned)
+    rounds = []
+    for _ in range(n_rounds):
+        r = rng.choice(paid_ranks)
+        if adversarial == "one_owner":
+            o = names[0]
+        elif adversarial == "centre":
+            o = owned[0]
+        else:
+            o = rng.choice(names)
+        rounds.append((r, o))
+    return roles, rounds
+
+
+P7_TARGET_RANKS = (5, 6, 7, 8, 9, 25, 41, 57, 121)
+P7_PAID_RANKS = (1, 2, 3, 4, 5, 8, 16, 32, 48)
+SELECTED_TARGET_RANKS = (4, 7, 8, 9, 17, 25, 33, 41, 49, 57, 65, 73, 145)
+SELECTED_PAID_RANKS = (1, 2, 3, 4, 5, 8, 16, 24, 32, 40, 48, 56, 64, 72)
+
+
+def p7_shaped(seed, role_counts=(2, 1, 1, 1, 2, 1, 1, 1, 1), n_rounds=20, adversarial=None):
+    roles, rounds = shaped("p7", P7_TARGET_RANKS, role_counts, P7_PAID_RANKS, n_rounds, seed, adversarial=adversarial)
+    return roles, rounds, f"p7-shaped seed={seed} {adversarial or 'random'}"
+
+
+def selected_shaped(seed, n_local=3, adversarial=None):
+    """Rank sets of the selected #5413 caller with reduced multiplicities and the caller's
+    chronology shape: LOCAL blocks of small-rank jobs on helper roles and the owned centre,
+    IDLE jobs of rank 16..72 on main roles, rank-one QUERY jobs on the owned query bank."""
+    rng = random.Random(seed)
+    helpers = [(f"h{k}_{i}", k) for k, cnt in zip((4, 7, 8, 9), (1, 1, 1, 2)) for i in range(cnt)]
+    mains = [(f"m{k}", k) for k in (17, 25, 33, 41, 49, 57, 65, 73, 145)]
+    roles = helpers + mains
+    owned = ("C0", "Q")
+    hnames = [nm for nm, _ in helpers] + ["C0"]
+    mnames = [nm for nm, _ in mains]
+    rounds = []
+    idle = iter((16, 24, 32, 40, 48, 56, 64, 72) * 2)
+    for _ in range(n_local):
+        for _ in range(4):
+            r = rng.choice((1, 2, 3, 4, 5, 8))
+            o = hnames[0] if adversarial == "one_owner" else "C0" if adversarial == "centre" else rng.choice(hnames)
+            rounds.append((r, o))
+        rounds.append((next(idle), "C0" if adversarial == "centre" else rng.choice(mnames)))
+        rounds.append((1, "Q"))
+    return roles, rounds, owned, f"selected-shaped seed={seed} {adversarial or 'random'}"
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/PROOF.md
new file mode 100644
index 0000000000..12be1f0606
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/PROOF.md
@@ -0,0 +1,260 @@
+# Physical completion of the ordinary wrapper
+
+Jose Manuel (`jmbarrancoml`), with substantial OpenAI Codex assistance.
+
+I compose the fixed-role reversed caller from PR2809 with Nick Petalas's
+PR2808 wrapper. I retain David Arias's PR2753 endpoint and p=1 cost argument,
+the selected source vocabulary, and the earlier ordinary borrowing proof.
+I add encoded setup, numerical-template initialization, two-call ownership
+and physical erasure. I do not claim a new borrowing identity or exponent.
+
+## Statement and source boundary
+
+Fix a source-admissible prime q>2^80 and the pinned selected vocabulary. Put
+c=17/10000 and a=c(1-c)=169711/10^8. I use the completed p=1 caller C0 from
+PR2753/2809, with its written endpoint, chronology, source-refinement and
+uniform charge arguments. These are explicit mathematical dependencies,
+not consequences of this package's small tests.
+
+On a complete stream `[P][q^e][G][q^e][S]`, e>=1 and P,G,S>=1, I construct
+the ordinary interchange with unchanged borrowed input, a distinct owned
+output, pointwise spectator restoration and empty owned work at return.
+I obtain O_q(V e^(1-a)) time and O_q(V)+F_q space on a fixed tape inventory,
+where V=P G S q^(2e). I include the source's finite compilation charge F_q.
+The binary completion has O_q(V E^(1-a)) time at positive binary width E.
+
+I prove successful execution on admitted canonical inputs. I do not promise
+transactional recovery after an interruption or a failing internal macro.
+The wrapper's stronger arbitrary-exception API therefore remains outside
+this composition statement. I retain the selected GL64 compilation argument;
+I have not materialized its entire finite instruction word or a microtransition
+table. I make no supplier-admission or multiplication-exponent claim.
+
+I receive the borrowed payload and canonical parameter tapes on external ports,
+outside the owned work inventory. The caller consumes each returned output
+before reusing that output port. I preserve the caller's other state on disjoint
+roles; I require no external fresh-row factor.
+
+## 1. Keep the recursion levels separate
+
+I retain the elementary digit interchange A0 inside C0. I define B1 by applying
+the ordinary wrapper to that sealed C0. C0 never calls B1. A later caller C1
+may use the completed B1 only after this construction; I do not implement C1
+here. This order avoids assuming the faster ordinary primitive during its own
+construction.
+
+I use C0's unweighted endpoint
+
+    F_I(H,D) = (C_n D,C_n H),
+
+where C_n reverses the n atom positions. An arbitrary weighted involution
+does not satisfy the same two-call wrapper identity. I encode unit weight 1
+in the initial ROOT record, with depth 0 and no STEP records.
+
+## 2. Compute the parameters on tapes
+
+I keep e on its original canonical Count tape and compute
+
+    w = min { j>=1 : j^10000 >= e^17 },
+    D(e) = 0 for e<64; D(e)=1+D(42 floor(e/64)) otherwise,
+    K(w) = 269241600 |GL_64(F_q)| q^(4096(w-1)),
+    stock = K(w)^D(e),
+    k = min { j>=0 : q^j >= stock }, R=q^k.
+
+I find w by binary bisection using Count comparison, addition and division by
+two. Fixed-power multiplication may saturate at e^17: min(xy,T) preserves the
+predicate needed for each comparison. I store no numerical result in finite
+control. The exponents 17 and 10000, q and the finite source dimensions are
+compiled constants. I compute D by its encoded contraction loop and form
+stock through encoded multiplication and a countdown of D levels.
+
+I use the elementary branch if 2k>=e. Otherwise I compute
+
+    (n,ell) = divmod(e-k,w),
+
+and also use the elementary branch when n<64. The fitted branch therefore
+satisfies e=k+nw+ell, 0<=ell<w, n>=64 and stock<=R. I choose w and stock from
+the original e before removing any borrowed digits. I never substitute D(n)
+for D(e) in setup.
+
+The retained sharp-fit proof in `research/bit2234-stock-threshold` gives
+2k<e for e>=311311 for this exact K and every permitted prime. Since
+w<=2e^c, I also have n>e^(1-c)/4-1. At that cutoff this exceeds 64, using
+c<1/2 and 311311>260^2. Thus only finitely many widths use the elementary
+branch. I reuse this predecessor theorem; I do not claim its cutoff or stock
+coefficient as a new result.
+
+All new setup integers have O_q(e+log(PGS)+1) bits. In particular,
+log_q(stock)=O(w log e)=O(e). Schoolbook binary Count arithmetic, fixed-power
+bisection, and the encoded loops take a fixed polynomial in 1+log V; a fourth
+power suffices for this implementation. I absorb that polynomial into O_q(V),
+since its ratio to V has a finite supremum for V>=1. I retain a fixed number
+of integer tapes rather than a tape per loop iteration.
+
+## 3. Initialize the actual numerical contexts
+
+I allocate fixed register roles before reading numerical widths. PhysicalArena
+has no `bits` attribute. It supplies the retained Arena operations with a
+preallocated free map and sequential PhysicalWord views.
+
+For a positive canonical maximum M, I scan its binary digits and write one
+zero per digit, one additional zero margin and RIGHT to the permanent template.
+I copy values into slots through that template. For the internal body I use
+M=q^w; for its index bank I use n. The resulting extents are
+
+    L=bitlength(q^w)+1, I=bitlength(n)+1.
+
+I keep these templates throughout the coarse recursion, including unit
+resets. I use separate fixed banks for q^k and, when ell>0, q^ell. I omit the
+remainder Ring when ell=0. The elementary branch instead initializes its
+modulus from q^e. No decoded length enters Arena construction.
+
+I emit the ROOT record with append_word(n), append_word(1), append_word(0)
+and RECORD_END. I do not use Program.fixture or Arena.input at runtime.
+The small dimension-2 fixture needs an explicit index floor for the retained
+Geometry constructor's literal 64. I exclude that fixture exception from the
+selected statement: in production n>=64 already supplies the required extent.
+
+## 4. Bind the exact wrapper order
+
+Write J=q^ell. I use PR2808's input order
+
+    [P][H_hi:R][H_body:(q^w)^n][H_rem:J][G]
+       [D_hi:R][D_body:(q^w)^n][D_rem:J][S].
+
+I preserve the predecessor's remainder exchange and chronological body word:
+
+    D-=H; F_I; D+=H; F_I; D=-D; D+=H.
+
+The body states are (H,D-H), (C(D-H),CH), (C(D-H),CD), (D,D-H),
+(D,H-D), (D,H). I then exchange the two original high fields. This proves
+the complete ordinary endpoint with each original spectator fixed.
+
+For each F_I, I pass the following actual C0 arguments:
+
+    old_count=P, depth=0, old_directory=empty,
+    fresh_rows=ceil(R/stock)*stock, before=1,
+    gap=J*G*R, suffix=J*S, body_size=n.
+
+The R in the gap is the genuine D_hi extent. I do not replace it by the padded
+row count. The empty directory represents P distinct empty frozen tuples;
+old_count retains their multiplicity. I do not collapse P to one.
+
+I preserve PR2786's literal row padding and restriction. From stock<=R I get
+R<=R'<2R. Since n<=e, D(n)<=D(e), so R' is a compatible positive multiple of
+K(w)^D(n). C0 restores each row ordinal. I restrict after each completed F_I,
+before the next arithmetic step on the original ring. Both calls reuse the
+same row stock; I do not multiply sequential reserves.
+
+## 5. Preserve ownership across the physical calls
+
+I keep the outer Counts, rings and payloads outside the C0 banks and pool.
+At the callee boundary I expose a borrowed physical view of each outer lease.
+This is necessary because Machine.commit consumes Lease results; passing the
+outer Lease object as a root input would transfer ownership incorrectly.
+
+The outer invocation owns the initialized C0 markers and templates. After
+each successful F_I I require empty canonical bodies, empty numerical live
+sets, no scratch leases and the initial parking state. I retain the templates
+as borrowed session workspace. Padding consumes and clears the protected
+output before the second call. At the end I erase the session markers,
+templates, parking port and the now-consumed protected output marker.
+
+I suspend the outer allocation-site specialization while C0 runs, preserving
+the outer leases and the prohibition on new physical Tape/Arena construction.
+The inner pool then specializes the authenticated source sites for its own
+roles. I restore the outer factories on return. I specialize only padding's
+allocation function, retaining its nominal Tape checks for returned outputs.
+
+At final transfer I erase the source cells and release the emptied lease.
+I reinitialize erased markers by explicit local writes before a later call.
+The output must have been consumed before reuse. I retain slot identities,
+and I may rebuild different template extents on the same physical roles.
+
+## 6. Charge the complete ordinary invocation
+
+PR2808 charges 3n ADDs, n sign passes, k+ell elementary digit passes, two
+complete F_I calls and two padding/restriction bills. I retain its intermediate
+output-disposal scans. Unit ordered ADD costs O_q(V): I charge its polynomial
+coefficient arithmetic against the complete q^w target fibre. Sign has the
+retained linear scan bound. Thus the added body arithmetic costs O_q(nV).
+
+The padding planner costs O(R+stock), including its countdown resets; R and
+stock are at most V on the fitted domain. Padding, restriction, output copies,
+lease disposal and initialization/erasure contribute O_q(V) in total. The
+complete C0 bound from the retained moment argument is
+
+    T_C0(n,w)/V <= C_q (n+n^(1-c)w).
+
+After the below-two padding factor and two calls, I obtain
+
+    T_B1(e)/V = O_q(n+n^(1-c)w+k+w).
+
+Now n<=e/w, e^c<=w<=2e^c, and k=O(w log e). Therefore
+
+    n <= e^(1-c),
+    n^(1-c)w <= 2^c e^(1-c+c^2),
+    k+w = O(e^c(1+log e)) = O(e^(1-c+c^2)).
+
+I get the retained saving a=c(1-c). The finite elementary fallback widths fit
+the same bound after increasing C_q. I do not use timings as evidence for it.
+
+Outside C0, I retain only a fixed number of input-sized payloads, padded
+payloads of volume below 2V, and O_q(log V) setup/template cells. During C0 I
+add its O_q(V')+F_q reserve to the retained outer data. I therefore obtain
+O_q(V)+F_q space. Register counts, stream roles and the instruction vocabulary
+depend on q and the selected source, not on e or recursion depth.
+
+For the explicit outer pool, I bound setup by 64 simultaneous Count/Counter
+roles: fixed_power retains two accumulators, Count.product adds three roles
+and one addition copy, and bisection/select retain fewer than twenty other
+operands. Iterations release their predecessors before advancing. During the
+wrapper I retain fewer than 64 outer roles, including the seven plan Counts,
+prepared extents/program, PR2808's thirteen Counts at a call, and payloads.
+The reached nonrecursive primitives are a subset of PR2809's completed blocks,
+whose conservative bound is q^2+128 scratch roles. Thus q^2+256 outer roles
+suffice. C0 uses its separate unchanged pool. Binary padding retains fewer
+than 32 Count/Counter/payload roles, within its fixed allowance of 96.
+
+I exclude the explicit observer counters, provenance maps and test callbacks
+from machine state and cost. Production uses no observer callback; those
+observations neither select instructions nor supply numerical operands.
+
+## 7. Complete the binary interface
+
+For E>=1, I construct B=2^E and the least e with Q=q^e>=B by encoded loops.
+Then B<=Q<qB and e<=E. I pad the first field with prefix P and body G*B*S;
+I pad the second with prefix P*Q*G and body S. This gives `[P][Q][G][Q][S]`
+with volume below q^2 V, without padding any spectator region.
+
+I invoke the completed radix-q B1 once, then restrict the second field and
+the first field in reverse order. The genuine B-by-B rectangle is invariant
+under the ordinary interchange. At the completed endpoint the dummy cells
+again contain zero, so restriction loses no input. I close padding before
+return and erase the consumed native output marker.
+
+The four scans and encoded setup cost O_q(V); the native call costs
+O_q(V E^(1-a)). I preserve the fixed inventory, arbitrary complete spectators
+and O_q(V)+F_q space. At E=0 I return an owned identity copy and erase unused
+workspace. This is a completion of the retained rectangular-padding method,
+not a new reduction.
+
+## 8. Evidence and remaining successor obligation
+
+The finite engine checks use a dimension-2, q=2 grammar and explicit interface
+parameters. They do not execute the selected GL64 payload or the fitted
+large-prime domain. I check a separate affine provenance mask for every input
+column while physical payload cells remain Boolean. These masks are checker
+state, not machine workspace or an enlarged runtime alphabet.
+
+The binary rectangle checks use completed elementary native backends at
+q=2,3,5; they test the adapter, not the faster all-size rate. The written
+composition above supplies the quantified statement subject to its named
+source arguments. I claim no independent human or proof-assistant review.
+
+commdata2338's PR2399 still requires source binding for the successor's header
+route. PR2753's current route decorates and sorts high keys; it does not call
+the older ordinary_fields hook. A leaf-only substitution leaves O(wV) routing.
+The completed B1 is a predecessor for that work, not its replacement. The
+complex supplier, selected bootstrap-stage adoption and analytic transfer
+remain separate.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/binary.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/binary.py
new file mode 100644
index 0000000000..651185a9ee
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/binary.py
@@ -0,0 +1,99 @@
+"""Complete binary fields by two sequential rectangle-padding passes."""
+from contextlib import ExitStack
+
+import source
+_loader, padding, _outer = source.activate()
+from cardinal_counts import Count, positive
+from directory import append_tape
+from encoded import compare, subtract
+from ordinary import radix_power
+from records import Tape
+from role_parking import transfer
+from scratch_pool import ScratchPool
+from session import (OuterScope, borrowed_count, borrowed_tape, erase_marker,
+                     initialize_marker, sealed_constructors)
+from words import BLANK, LEFT, need
+
+
+class Binary:
+    """Borrow one completed radix-q engine; preserve arbitrary spectators."""
+    def __init__(self, native):
+        self.native = native
+        self.pool = ScratchPool(96)
+        self.scope = OuterScope(self.pool)
+        self.output = Tape()
+        self.closed = False
+
+    def run(self, payload, width, prefixes, gap, suffix):
+        need(self.output.read() == BLANK and borrowed_tape(payload) is not self.output,
+             "distinct empty binary output")
+        if self.closed:
+            self.output.step(-1)
+            marker = self.output.read()
+            need(marker in (LEFT, BLANK), "consumed binary output origin")
+            if marker == BLANK:
+                self.output.write(LEFT)
+            self.output.step(1)
+            for tape in self.pool.tapes:
+                initialize_marker(tape)
+            self.closed = False
+        for value in (prefixes, gap, suffix):
+            positive(value)
+        with sealed_constructors(), self.scope.installed(), ExitStack() as cleanup:
+            owns_return_marker = False
+            if width.zero():
+                append_tape(borrowed_tape(payload), self.output)
+                self.output.rewind()
+                if not self.native.closed:
+                    self.native.finish(False)
+                    owns_return_marker = True
+            else:
+                binary = radix_power(width, 2)
+                radix, digits = Count.literal(1), Count.literal(0)
+                for value in (binary, radix, digits):
+                    cleanup.callback(value.close)
+                while compare(radix, binary) < 0:
+                    radix.multiply_small(self.native.q)
+                    digits.increment()
+                added = subtract(radix, binary)
+                middle = Count.product(gap, binary)
+                first_body = Count.product(middle, suffix)
+                middle.close()
+                middle = Count.product(prefixes, radix)
+                second_prefixes = Count.product(middle, gap)
+                middle.close()
+                for value in (added, first_body, second_prefixes):
+                    cleanup.callback(value.close)
+                first = padding.transform(borrowed_tape(payload), prefixes, binary, added, first_body)
+                try:
+                    padded = padding.transform(first, second_prefixes, binary, added, suffix)
+                finally:
+                    first.clear()
+                try:
+                    with self.scope.suspended():
+                        returned = self.native.run(borrowed_tape(padded), borrowed_count(digits),
+                                                   borrowed_count(prefixes), borrowed_count(gap),
+                                                   borrowed_count(suffix))
+                    owns_return_marker = True
+                finally:
+                    padded.clear()
+                try:
+                    first = padding.transform(returned, second_prefixes, binary, added, suffix,
+                                              restricting=True)
+                finally:
+                    returned.clear()
+                try:
+                    result = padding.transform(first, prefixes, binary, added, first_body,
+                                               restricting=True)
+                finally:
+                    first.clear()
+                transfer(result, self.output)
+                result.clear()
+            # A consumed child output is now owned scratch of the binary caller.
+            if owns_return_marker:
+                erase_marker(self.native.output)
+        self.pool.empty()
+        for tape in self.pool.tapes:
+            erase_marker(tape)
+        self.closed = True
+        return self.output
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/encoded.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/encoded.py
new file mode 100644
index 0000000000..2280fa98ff
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/encoded.py
@@ -0,0 +1,224 @@
+"""Unbounded setup integers on canonical binary Count tapes."""
+from dataclasses import dataclass
+
+import source
+source.activate()
+from cardinal_counts import Count, positive
+from stream import Counter
+from words import LEFT, ONE, RIGHT, ZERO, need
+
+
+def compare(left, right):
+    if left is right or left.tape is right.tape:
+        return 0
+    left.rewind()
+    right.rewind()
+    order = 0
+    try:
+        while left.read() != RIGHT and right.read() != RIGHT:
+            a, b = left.read(), right.read()
+            need(a in (ZERO, ONE) and b in (ZERO, ONE), "binary comparison digits")
+            if a != b:
+                order = 1 if a == ONE else -1
+            left.step(1)
+            right.step(1)
+        if left.read() != RIGHT:
+            return 1
+        if right.read() != RIGHT:
+            return -1
+        return order
+    finally:
+        left.rewind()
+        right.rewind()
+
+
+def subtract(left, right):
+    need(compare(left, right) >= 0, "nonnegative setup difference")
+    result = Count(left)
+    right.rewind()
+    borrow = 0
+    try:
+        while result.read() != RIGHT:
+            done = right.read() == RIGHT
+            difference = result.read() - (ZERO if done else right.read()) - borrow
+            borrow = int(difference < 0)
+            result.tape.write(difference + 2 * borrow)
+            result.step(1)
+            if not done:
+                right.step(1)
+        need(not borrow and right.read() == RIGHT, "complete setup subtraction")
+        result.normalize()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        right.rewind()
+
+
+def divide(numerator, denominator):
+    positive(denominator)
+    divisor = Count(denominator)
+    quotient, remainder = Count.literal(0), Count.literal(0)
+    numerator.msb()
+    try:
+        while numerator.read() != LEFT:
+            bit = numerator.read()
+            need(bit in (ZERO, ONE), "division numerator digit")
+            quotient.multiply_small(2)
+            remainder.multiply_small(2)
+            if bit == ONE:
+                remainder.increment()
+            if compare(remainder, divisor) >= 0:
+                following = subtract(remainder, divisor)
+                remainder.close()
+                remainder = following
+                quotient.increment()
+            numerator.step(-1)
+        numerator.step(1)
+        return quotient, remainder
+    except BaseException:
+        quotient.close()
+        remainder.close()
+        raise
+    finally:
+        numerator.rewind()
+        divisor.close()
+
+
+def product(left, right, cap=None):
+    if cap is not None:
+        if (compare(left, cap) >= 0 and not right.zero()
+                or compare(right, cap) >= 0 and not left.zero()):
+            return Count(cap)
+    value = Count.product(left, right)
+    if cap is not None and compare(value, cap) > 0:
+        value.close()
+        return Count(cap)
+    return value
+
+
+def fixed_power(value, exponent, cap=None):
+    """Exponent is a compiled source constant; optional saturation is exact."""
+    need(type(exponent) is int and exponent >= 0, "fixed source exponent")
+    result, factor = Count.literal(1), Count(value)
+    try:
+        while exponent:
+            if exponent & 1:
+                following = product(result, factor, cap)
+                result.close()
+                result = following
+            exponent >>= 1
+            if exponent:
+                following = product(factor, factor, cap)
+                factor.close()
+                factor = following
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        factor.close()
+
+
+def atom_width(original, numerator=17, denominator=10000):
+    """Least w with w^denominator >= e^numerator, by encoded bisection."""
+    positive(original)
+    target = fixed_power(original, numerator)
+    low, high = Count.literal(1), Count(original)
+    try:
+        while compare(low, high) < 0:
+            middle = Count(low)
+            middle.add(high)
+            middle.divide_small(2)
+            power = fixed_power(middle, denominator, target)
+            above = compare(power, target) >= 0
+            power.close()
+            if above:
+                high.close()
+                high = middle
+            else:
+                low.close()
+                middle.increment()
+                low = middle
+        result, low = low, None
+        return result
+    finally:
+        if low is not None:
+            low.close()
+        high.close()
+        target.close()
+
+
+@dataclass(frozen=True)
+class Profile:
+    numerator: int = 17
+    denominator: int = 10000
+    dimension: int = 64
+    child_rank: int = 42
+    row_factor: int = 269241600
+
+
+def select(original, q, profile=Profile()):
+    """Return owned encoded parameters; q/profile are compile-time constants."""
+    width = atom_width(original, profile.numerator, profile.denominator)
+    dimension, one = Count.literal(profile.dimension), Count.literal(1)
+    cursor, depth = Count(original), Count.literal(0)
+    stock, rows, borrowed = Count.literal(1), Count.literal(1), Count.literal(0)
+    body, remainder = Count.literal(0), Count.literal(0)
+    try:
+        while compare(cursor, dimension) >= 0:
+            cursor.divide_small(profile.dimension)
+            if profile.child_rank != 1:
+                cursor.multiply_small(profile.child_rank)
+            depth.increment()
+        if not depth.zero():
+            order = 1
+            for position in range(profile.dimension):
+                order *= q ** profile.dimension - q ** position
+            level = Count.literal(profile.row_factor * order)
+            digits = subtract(width, one)
+            repeats = Counter(digits)
+            digits.close()
+            try:
+                while not repeats.finished:
+                    level.multiply_small(q ** (profile.dimension ** 2))
+                    repeats.decrement()
+                levels = Counter(depth)
+                try:
+                    while not levels.finished:
+                        following = Count.product(stock, level)
+                        stock.close()
+                        stock = following
+                        levels.decrement()
+                finally:
+                    levels.close()
+            finally:
+                level.close()
+                repeats.close()
+        while compare(rows, stock) < 0:
+            rows.multiply_small(q)
+            borrowed.increment()
+        twice = Count(borrowed)
+        twice.multiply_small(2)
+        fits = compare(twice, original) < 0
+        twice.close()
+        if fits:
+            remaining = subtract(original, borrowed)
+            body.close()
+            remainder.close()
+            try:
+                body, remainder = divide(remaining, width)
+            finally:
+                remaining.close()
+            fits = compare(body, dimension) >= 0
+        return dict(fits=fits, width=width, depth=depth, stock=stock,
+                    rows=rows, borrowed=borrowed, body=body, remainder=remainder)
+    except BaseException:
+        for value in (width, depth, stock, rows, borrowed, body, remainder):
+            value.close()
+        raise
+    finally:
+        dimension.close()
+        one.close()
+        cursor.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/ordinary.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/ordinary.py
new file mode 100644
index 0000000000..81b330a4b8
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/ordinary.py
@@ -0,0 +1,193 @@
+"""Encoded ordinary interchange around the sealed p=1 reversed caller."""
+from contextlib import ExitStack
+
+import source
+_loader, _padding, outer = source.activate()
+from bitstream import atom_swap
+from cardinal_counts import Count, positive
+from directory import append_tape
+from encoded import Profile, compare, select
+from physical_words import PhysicalArena
+from records import Program, RECORD_END, ROOT, Tape, append_word
+from role_parking import transfer
+from scratch_pool import ScratchPool
+from session import (OuterScope, RootSession, borrowed_count, borrowed_tape,
+                     erase_marker, initialize_marker, sealed_constructors)
+from stream import Counter
+from words import BLANK, LEFT, Ring, need
+
+
+def radix_power(exponent, q):
+    result, remaining = Count.literal(1), Counter(exponent)
+    try:
+        while not remaining.finished:
+            result.multiply_small(q)
+            remaining.decrement()
+        return result
+    except BaseException:
+        result.close()
+        raise
+    finally:
+        remaining.close()
+
+
+def ring_from_count(bank, maximum, cleanup):
+    bank.prepare(maximum)
+    modulus = bank.load(maximum)
+    cleanup.callback(bank.free, modulus)
+    ring = Ring(modulus)
+    cleanup.callback(ring.close)
+    return ring
+
+
+def unit_program(indices, ring, size, depth, code_bits):
+    program = Program(indices, ring.arena, code_bits)
+    program.tape.append(ROOT)
+    for word in (size, ring.one, depth):
+        append_word(program.tape, word)
+    program.tape.append(RECORD_END)
+    program.tape.rewind()
+    return program
+
+
+class Ordinary:
+    """One fixed inventory, reusable after the caller consumes each output.
+
+    q, profile, source code and register capacities are compiled constants.
+    run() selects the body from the encoded original width. execute_plan() is
+    an interface hook for declared small grammars; production uses run().
+    Successful admitted execution closes its owned state. No interrupted-macro
+    recovery guarantee is part of this mathematical interface.
+    """
+    def __init__(self, q, binding, topology, programs, capacity=1 << 24,
+                 profile=Profile(), fixture_index_floor=0, observe=None):
+        need(type(q) is int and q >= 2 and binding.codes.q == q, "one compiled radix")
+        need(1 <= profile.child_rank < profile.dimension and profile.row_factor >= 1,
+             "contracting compiled stock profile")
+        if fixture_index_floor:
+            need(binding.cutoff == 2, "index-floor exception belongs only to the reduced fixture")
+        self.q, self.binding, self.profile = q, binding, profile
+        self.fixture_index_floor = fixture_index_floor
+        self.banks = tuple(PhysicalArena(capacity) for _ in range(4))
+        self.runtime = RootSession(binding, topology, programs,
+                                   PhysicalArena(capacity), PhysicalArena(capacity))
+        self.pool = ScratchPool(q*q+256)
+        self.scope = OuterScope(self.pool)
+        self.output = Tape()
+        self.closed = False
+        self.last_fitted = None  # Observer only.
+        self.observe = observe  # Checker-only; its return value never controls execution.
+
+    def rearm(self):
+        need(self.closed and self.output.read() == BLANK, "consume previous ordinary output")
+        self.output.step(-1)
+        marker = self.output.read()
+        need(marker in (LEFT, BLANK), "consumed ordinary output origin")
+        if marker == BLANK:
+            self.output.write(LEFT)
+        self.output.step(1)
+        for tape in self.pool.tapes:
+            initialize_marker(tape)
+        for bank in self.banks:
+            for word in (*bank.words, bank.template):
+                initialize_marker(word.tape)
+        self.runtime.rearm()
+        self.closed = False
+
+    def finish(self, fitted):
+        self.pool.empty()
+        self.runtime.finish(2 if fitted else 0)
+        for bank in self.banks:
+            bank.erase_owned()
+        for tape in self.pool.tapes:
+            erase_marker(tape)
+        self.closed, self.last_fitted = True, fitted
+
+    def fallback(self, payload, original, prefixes, gap, suffix):
+        with ExitStack() as cleanup:
+            modulus = radix_power(original, self.q)
+            cleanup.callback(modulus.close)
+            ring = ring_from_count(self.banks[0], modulus, cleanup)
+            extents = [value.marginal() for value in (prefixes, gap, suffix)]
+            for value in extents:
+                cleanup.callback(value.close)
+            return atom_swap(payload, ring, self.q, *extents)
+
+    def fitted(self, payload, plan, prefixes, gap, suffix):
+        with ExitStack() as cleanup:
+            modulus = radix_power(plan["width"], self.q)
+            remainder = radix_power(plan["remainder"], self.q)
+            one = Count.literal(1)
+            for value in (modulus, remainder, one):
+                cleanup.callback(value.close)
+            ring = ring_from_count(self.banks[0], modulus, cleanup)
+            high = ring_from_count(self.banks[1], plan["rows"], cleanup)
+            tail = (None if plan["remainder"].zero() else
+                    ring_from_count(self.banks[2], remainder, cleanup))
+            index_maximum = Count(plan["body"])
+            cleanup.callback(index_maximum.close)
+            if self.fixture_index_floor:
+                floor = Count.literal(self.fixture_index_floor)
+                if compare(index_maximum, floor) < 0:
+                    index_maximum.close()
+                    index_maximum = Count(floor)
+                    cleanup.callback(index_maximum.close)
+                floor.close()
+            indices = self.banks[3]
+            indices.prepare(index_maximum)
+            size, depth = indices.load(plan["body"]), indices.zero()
+            cleanup.callback(indices.free_many, size, depth)
+            self.runtime.arena.prepare(modulus)
+            self.runtime.indices.prepare(index_maximum)
+            program = unit_program(indices, ring, size, depth, self.binding.codes.bits)
+            directory = self.pool.acquire()
+            cleanup.callback(program.tape.clear)
+            cleanup.callback(directory.clear)
+            actual_gap = Count.product(remainder, gap)
+            following = Count.product(actual_gap, plan["rows"])
+            actual_gap.close()
+            actual_gap = following
+            actual_suffix = Count.product(remainder, suffix)
+            cleanup.callback(actual_gap.close)
+            cleanup.callback(actual_suffix.close)
+
+            def callee(padded, rows):
+                if self.observe is not None:
+                    self.observe("before", borrowed_tape(padded), None)
+                with self.scope.suspended():
+                    returned = self.runtime.run(
+                        borrowed_tape(padded), borrowed_tape(directory), borrowed_tape(program.tape),
+                        ring.modulus, size, depth, borrowed_count(prefixes), borrowed_count(rows),
+                        borrowed_count(one), borrowed_count(actual_gap), borrowed_count(actual_suffix))
+                if self.observe is not None:
+                    self.observe("after", borrowed_tape(padded), returned)
+                return returned
+
+            return outer.interchange(payload, size, ring, high, self.q, prefixes, gap, suffix,
+                                     plan["stock"], callee, remainder_ring=tail)
+
+    def execute_plan(self, payload, original, prefixes, gap, suffix, plan_factory):
+        if self.closed:
+            self.rearm()
+        need(self.output.read() == BLANK and borrowed_tape(payload) is not self.output,
+             "distinct empty ordinary output port")
+        for value in (original, prefixes, gap, suffix):
+            positive(value)
+        with sealed_constructors(), self.scope.installed():
+            plan = plan_factory()
+            try:
+                result = (self.fitted(borrowed_tape(payload), plan, prefixes, gap, suffix)
+                          if plan["fits"] else
+                          self.fallback(borrowed_tape(payload), original, prefixes, gap, suffix))
+                transfer(result, self.output)
+                result.clear()  # The literal transfer erases cells but does not end a lease.
+            finally:
+                for name, value in plan.items():
+                    if name != "fits":
+                        value.close()
+            self.finish(plan["fits"])
+        return self.output
+
+    def run(self, payload, original, prefixes, gap, suffix):
+        return self.execute_plan(payload, original, prefixes, gap, suffix,
+                                 lambda: select(original, self.q, self.profile))
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/physical_words.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/physical_words.py
new file mode 100644
index 0000000000..44b4647142
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/physical_words.py
@@ -0,0 +1,106 @@
+"""Fixed register roles whose word templates come from encoded input scans."""
+import source
+source.activate()
+from records import Tape
+from words import Arena, BLANK, LEFT, ONE, RIGHT, ZERO, Meter, Word, need
+
+
+class PhysicalWord:
+    def __init__(self, arena, slot):
+        self.arena, self.slot, self.tape = arena, slot, Tape()
+
+    @property
+    def head(self):
+        return self.tape.head
+
+    @property
+    def cells(self):
+        return self.tape.cells  # Checker observation; arithmetic uses cell methods.
+
+    def read(self):
+        self.arena.meter.reads += 1
+        return self.tape.read()
+
+    def write(self, symbol):
+        need(symbol in (ZERO, ONE, RIGHT, BLANK), "word tape alphabet")
+        self.arena.meter.writes += 1
+        self.tape.write(symbol)
+
+    def step(self, direction):
+        self.arena.meter.moves += 1
+        self.tape.step(direction)
+
+    rewind, msb, zero, erase = Word.rewind, Word.msb, Word.zero, Word.erase
+    inspect = Word.inspect  # Fixture-only, forbidden by the execution checks.
+
+
+class PhysicalArena(Arena):
+    """Allocate a fixed number of roles before reading any numerical width.
+
+    No bits attribute exists. Arena.zero always takes a preallocated slot and
+    copies the encoded template through the retained sequential word methods.
+    """
+    def __init__(self, capacity):
+        need(type(capacity) is int and capacity > 0, "compiled register capacity")
+        self.capacity, self.meter = capacity, Meter()
+        self.words = [PhysicalWord(self, slot) for slot in range(capacity)]
+        self.available = list(reversed(range(capacity)))
+        self.live = set()
+        self.template = PhysicalWord(self, -1)
+        self.initialized = False
+
+    def prepare(self, maximum):
+        """Use bitlength(maximum)+1 zero cells, with no decoded bit length."""
+        need(not self.live and not self.initialized and self.template.read() == BLANK,
+             "fresh word template")
+        maximum.rewind()
+        positive = False
+        while maximum.read() != RIGHT:
+            bit = maximum.read()
+            need(bit in (ZERO, ONE), "encoded maximum digits")
+            positive = positive or bit == ONE
+            self.template.write(ZERO)
+            self.template.step(1)
+            maximum.step(1)
+        need(positive, "positive template maximum")
+        self.template.write(ZERO)
+        self.template.step(1)
+        self.template.write(RIGHT)
+        self.template.rewind()
+        maximum.rewind()
+        self.initialized = True
+
+    def load(self, value):
+        """Copy a canonical Count into an initialized Word, retaining its margin."""
+        result = self.zero()
+        value.rewind()
+        try:
+            while value.read() != RIGHT:
+                need(result.read() != RIGHT, "input fits encoded template")
+                result.write(value.read())
+                result.step(1)
+                value.step(1)
+            need(result.read() != RIGHT, "input retains a high zero margin")
+            result.rewind()
+            return result
+        except BaseException:
+            self.free(result)
+            raise
+        finally:
+            value.rewind()
+
+    def erase_owned(self):
+        need(not self.live, "empty numerical roles before final erasure")
+        for word in self.words:
+            need(word.read() == BLANK, "erased numerical body")
+            word.step(-1)
+            need(word.read() == LEFT, "owned numerical origin")
+            word.write(BLANK)
+            word.step(1)
+        if self.initialized:
+            self.template.erase()
+        self.template.step(-1)
+        need(self.template.read() == LEFT, "owned template origin")
+        self.template.write(BLANK)
+        self.template.step(1)
+        self.initialized = False
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/session.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/session.py
new file mode 100644
index 0000000000..09f645bbf0
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/session.py
@@ -0,0 +1,156 @@
+"""Reuse a completed physical root while its outer owner retains templates."""
+from contextlib import contextmanager
+from types import FunctionType
+
+import source
+_loader, padding, outer = source.activate()
+from macro_machine import Machine
+from records import Tape
+from scratch_pool import Lease
+from cardinal_counts import Count
+from words import Arena, BLANK, LEFT, need
+
+
+def erase_marker(tape):
+    need(tape.read() == BLANK, "empty body before owned marker erasure")
+    tape.step(-1)
+    need(tape.read() == LEFT, "owned marker at the local origin")
+    tape.write(BLANK)
+    tape.step(1)
+
+
+def initialize_marker(tape):
+    need(tape.read() == BLANK, "empty body before marker initialization")
+    tape.step(-1)
+    need(tape.read() == BLANK, "blank owned origin")
+    tape.write(LEFT)
+    tape.step(1)
+
+
+def borrowed_tape(tape):
+    """Expose the physical input without transferring an outer lease's ownership.
+
+    Machine.commit consumes Lease results. Root input ports are borrowed, so
+    they must carry physical views even when the outer owner uses a lease.
+    """
+    return tape.owned() if isinstance(tape, Lease) else tape
+
+
+def borrowed_count(count):
+    view = object.__new__(Count)
+    view.tape = borrowed_tape(count.tape)
+    return view
+
+
+@contextmanager
+def sealed_constructors():
+    original_tape, original_arena = Tape.__init__, Arena.__init__
+    def forbidden(*_args, **_kwargs):
+        raise ValueError("physical allocation inside the ordinary invocation")
+    Tape.__init__ = Arena.__init__ = forbidden
+    try:
+        yield
+    finally:
+        Tape.__init__, Arena.__init__ = original_tape, original_arena
+
+
+class OuterScope:
+    """Suspend allocation-site specialization without ending any live lease."""
+    def __init__(self, pool):
+        self.pool = pool
+        self.manager = self.transform = None
+
+    def enable(self):
+        need(self.manager is None, "one active outer factory scope")
+        self.manager = self.pool.install()
+        self.manager.__enter__()
+        self.transform = padding.transform
+        namespace = dict(self.transform.__globals__)
+        namespace["Tape"] = self.pool.acquire
+        # Preserve complete()'s nominal Tape ownership checks. Only transform's
+        # immutable constructor site receives the fixed-role factory.
+        padding.transform = FunctionType(self.transform.__code__, namespace,
+                                         self.transform.__name__, self.transform.__defaults__,
+                                         self.transform.__closure__)
+
+    def disable(self):
+        need(self.manager is not None, "active outer factory scope")
+        padding.transform = self.transform
+        manager, self.manager = self.manager, None
+        manager.__exit__(None, None, None)
+
+    @contextmanager
+    def installed(self):
+        self.enable()
+        try:
+            yield self
+        finally:
+            self.disable()
+
+    @contextmanager
+    def suspended(self):
+        self.disable()
+        try:
+            yield
+        finally:
+            self.enable()
+
+
+class RootSession(Machine):
+    """Borrow initialized role/bank templates for two completed root calls.
+
+    The outer invocation owns these markers and erases them once at its end.
+    A successful F return restores the supplied initialized workspace state.
+    This does not provide recovery from an interrupted or failing inner macro.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.completed_roots = 0
+
+    def erase_work(self):
+        need(not self.arena.live and not self.indices.live and not self.pool.live,
+             "completed root returns empty banks and scratch leases")
+        need(self.numerical.machine.tapes == [{}, {0: "^"}], "completed root returns parking baseline")
+        for tape in (*self.roles.values(), *self.handoff.values()):
+            need(tape.read() == BLANK, "completed root returns empty role bodies")
+            tape.step(-1)
+            need(tape.read() == LEFT, "session retains its initialized role marker")
+            tape.step(1)
+        self.completed_roots += 1
+
+    def run(self, *args, **kwargs):
+        need(self.output.read() == BLANK, "consume prior root output before reuse")
+        return super().run(*args, **kwargs)
+
+    def finish(self, expected=2):
+        need(self.completed_roots == expected and self.output.read() == BLANK,
+             "expected completed and consumed ordinary-wrapper calls")
+        need(not self.arena.live and not self.indices.live and not self.pool.live,
+             "empty numerical and scratch roles at session end")
+        if hasattr(self.arena, "erase_owned"):
+            for tape in (*self.roles.values(), *self.handoff.values(), *self.pool.tapes):
+                erase_marker(tape)
+            self.arena.erase_owned()
+            self.indices.erase_owned()
+            self.numerical._empty_port()
+            self.numerical._move(1, -1)
+            self.numerical._write(1, "_")
+            self.numerical._move(1, 1)
+            self.closed = True
+        else:
+            Machine.erase_work(self)
+        erase_marker(self.output)
+
+    def rearm(self):
+        need(self.closed and hasattr(self.arena, "erase_owned"), "closed physical session")
+        for tape in (*self.roles.values(), *self.handoff.values(), *self.pool.tapes, self.output):
+            initialize_marker(tape)
+        for bank in (self.arena, self.indices):
+            need(not bank.live and not bank.initialized, "blank numerical session")
+            for word in (*bank.words, bank.template):
+                initialize_marker(word.tape)
+        self.numerical._move(1, -1)
+        need(self.numerical._read(1) == "_", "blank owned parking origin")
+        self.numerical._write(1, "^")
+        self.numerical._move(1, 1)
+        self.closed, self.completed_roots = False, 0
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/source.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/source.py
new file mode 100644
index 0000000000..8594fc62ce
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/ordinary/source.py
@@ -0,0 +1,62 @@
+"""Authenticate unchanged source archives and load one shared tape vocabulary."""
+from hashlib import sha256
+from pathlib import Path, PurePosixPath
+import importlib.util
+import sys
+import tarfile
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+ARCHIVES = {
+    "pr2809": "ee1d4ec05e3c872d264be3b38f71a8c153acf37427f5d3ba87f8e15440c9ccf0",
+    "pr2808": "2ab59c6d0ad00c001ecbe44090b66871ec3d2c1fdc51daa503109e56f3285cab",
+}
+_temporary = None
+_loaded = None
+PROOF_INPUTS = {
+    "research/bit2234-stock-threshold/README.md":
+        "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7",
+}
+
+
+def extract(name, destination):
+    archive = HERE / "inputs" / (name + ".tar")
+    if sha256(archive.read_bytes()).hexdigest() != ARCHIVES[name]:
+        raise ValueError("unchanged source archive: " + name)
+    with tarfile.open(archive, "r:") as source:
+        names = set()
+        for member in source.getmembers():
+            path = PurePosixPath(member.name)
+            if (path.is_absolute() or ".." in path.parts or member.name in names
+                    or not (member.isfile() or member.isdir())):
+                raise ValueError("regular relative source inventory")
+            names.add(member.name)
+        source.extractall(destination, filter="data")
+
+
+def activate():
+    global _temporary, _loaded
+    if _loaded is not None:
+        return _loaded
+    names = ("loader", "words", "records", "catalogue", "controller", "numeric",
+             "macro_machine", "macro_code", "scheduler", "cardinal_counts", "padding", "outer")
+    if any(name in sys.modules for name in names):
+        raise ValueError("cold shared predecessor namespace")
+    for name, digest in PROOF_INPUTS.items():
+        if sha256((ROOT / name).read_bytes()).hexdigest() != digest:
+            raise ValueError("pinned stock proof changed: " + name)
+    _temporary = tempfile.TemporaryDirectory(prefix="ordinary-physical-")
+    root = Path(_temporary.name)
+    for name in ARCHIVES:
+        extract(name, root / name)
+    specification = importlib.util.spec_from_file_location("loader", root / "pr2809/loader.py")
+    loader = importlib.util.module_from_spec(specification)
+    sys.modules["loader"] = loader
+    specification.loader.exec_module(loader)
+    loader.REPOSITORY = ROOT
+    loader.activate()
+    padding = loader.module("padding", root / "pr2808/vendor/pr2786/padding.py")
+    outer = loader.module("outer", root / "pr2808/outer.py")
+    _loaded = loader, padding, outer
+    return _loaded
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/record_lift/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/record_lift/PROOF.md
new file mode 100644
index 0000000000..69e07e58c5
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/record_lift/PROOF.md
@@ -0,0 +1,101 @@
+# The f-column lift of the selected caller's monomials as a fixed record list
+
+Scope: the physical half of `native_all_columns` for the selected #5413 caller, at the level
+of records. PR #5442 closes the algebraic half (every identity of the caller lifts to every
+column width `f`) and leaves open the tape realization of `g^(tensor f)` with spectators and
+adapters at the retained tariff. `SPECIALIZATION.md` §2–§3 (the P1 specialization of #4610)
+states the realization in writing: any nine-axis monomial has a recipe of at most 171
+retained elementary movement/phase records, each a compact-control selected-bit addition or
+a per-record phase, acting on all `f` columns with one fixed list of primitive types. This
+package executes that recipe for the caller's actual monomials and routes.
+
+## Setting
+
+A field with `f` columns on `n` logical axes has addresses `X = (x_1, ..., x_f)`, `x_j` in
+`F_2^n`, next to arbitrary spectator bits. The retained monomial convention
+(`prune_native.monomial`) is `m = (G, b, Q, alpha, a)` acting on one column as
+
+```
+|x> -> i^(a + q(x)) |G x xor b>,   q(x) = sum_i alpha_i x_i + 2 sum_(i<j) Q_ij x_i x_j  (mod 4),
+```
+
+and its lift (SPECIALIZATION §3) as `|X> -> i^(a f + sum_j q(x_j)) |(G x_1 xor b, ..., G x_f xor b)>`.
+
+Five record types, each acting on all `f` columns at once and on no spectator bit:
+
+| record | action | retained primitive |
+|---|---|---|
+| `XROW(i,k)` | `x_{j,i} ^= x_{j,k}` for every column `j` | compact-control selected-bit addition, slots `k -> i` (movement-paid) |
+| `NOT(i)` | `x_{j,i} ^= 1` for every column `j` | selected-bit translation (movement-paid) |
+| `S(i)` | phase `i^(sum_j x_{j,i})` | unit-S phase record |
+| `CZ(i,k)` | phase `(-1)^(sum_j x_{j,i} x_{j,k})` | controlled-sign phase record |
+| `I` | phase `i^f` | global `i` record, lifted to `i^f` |
+
+A row swap is three `XROW` records. `SWAP_BITS(i,k)` of the plan is a row swap.
+
+## Lemma (record realization, uniform in f)
+
+For every monomial `m` the list `R(m)` = [`alpha_i` copies of `S(i)` for each `i`; `CZ(i,k)` for
+each `i<k` with `Q_ik = 1`; the reversed Gaussian-elimination list of `G` with swaps expanded
+to three `XROW`; `NOT(i)` for each set bit of `b`; `a` copies of `I`] does not depend on `f`,
+contains at most `96 + 9 + 27 + 36 + 3 = 171` records, and executes the lift of `m` exactly on
+every address and every `f >= 1`, leaving every spectator bit unchanged.
+
+*Proof.* Each record is the `f`-fold product of the same one-column operation, applied to
+the columns independently (`XROW`, `NOT` act column by column; `S`, `CZ`, `I` add a phase that
+is a sum over columns, with the global record contributing `f`). So the composition of the
+list on `X` is the `f`-fold product of its composition on one column, and the phase is the
+sum of the one-column phases plus `a f`. On one column: the phase records applied first on the
+input address give `i^(q(x))` (the diagonal `Q` is carried by `alpha`, exactly as in the
+convention); Gaussian elimination gives elementary matrices `E_1, ..., E_r` with
+`E_r ... E_1 G = I`, hence `G = E_1 ... E_r` (each elementary matrix is an involution), and
+applying `E_r` first and `E_1` last maps `x` to `G x`; the translations give `xor b`; the
+global records give `i^a`. The bounds are those of SPECIALIZATION §2: at most 72 additions
+and 8 swaps (24 records), 9 translations, 27 unit-S, 36 controlled-sign and 3 global
+records. No record reads or writes a spectator bit. ∎
+
+Cost. Each `XROW` or `NOT` record is one compact-control selected-bit addition on the ordered
+pair of slots (`compact-control-movement.tex`, Proposition), costing `O(V((f log p)^tau + 1))`
+on a fixed number of tapes in the domain `f <= p`, `A = O(p)`, `K / log p -> infinity`, with
+the front/back control fields reserved as in `compact-control-layout.tex` ("the proposition
+applies to every ordered pair of slots"). A phase record computes a fixed degree-two residue
+from `O(f)` selected address bits per complete record and applies one of `{1, i, -1, -i}`
+(SPECIALIZATION §2); it is absorbed by the record fiber. The domain `f <= p` is the actual
+layer's own domain: `f <= e <= floor(b_in^epsilon)` and `p = 6 b_in` (SPECIALIZATION §3). The
+tariff per record is inherited from the Proposition, not re-derived here.
+
+## What is executed (`verify.py`)
+
+- The 896 compiled port wrappers of `NORMALIZERS.json` (112 ports x 8 orientations/paths):
+  the record list is executed on all 512 addresses at `f = 1` (and compared with the exact
+  Clifford engine's basis action on one wrapper per path), on all 262,144 addresses at `f = 2`
+  for two wrappers, and on 48 random addresses at `f = 2, 3, 4` for every wrapper, with random
+  spectator bits. Every wrapper is within the §2 bound; the largest list has 107 records
+  (69 movement, 38 phase).
+- The body's own monomials, which are not port wrappers: all 1,072 `MONOMIAL` operations of
+  `NEUTRAL-BACKWARD-v16c` (800 whole-job helper normalizers, 240 Z-map block maps, 16 paid C8 axis
+  routes and 16 mode aliases) and the 8 `output_N` words of the #5402 provider's mode boundaries,
+  which #5442's mode-output certificate binds (the 8 `input_K` words coincide with alias words).
+  These are 283 distinct words. Each is read off the exact engine as a monomial `(G, b, Q, alpha, a)`
+  on 46 basis states and certified to be the same group element (Pauli tableau and image of `|0>`);
+  its record list is then executed on all 512 addresses at `f = 1` and on 48 random addresses at
+  `f = 2, 3, 4`. The largest list has 76 records (60 movement), within the §2 bound.
+- The central translation `X0` is one `NOT(0)` record. `C0` (cgate on axis 0) and `D`
+  (Fourier on axes 1..8) are positive-rank Gaussians: in the retained framework they are paid
+  children of the recursion (`FINITE-PRECOMPILATION.md` §1, "one ordinary positive rank-r f
+  child on the actual owner's full stream"), not adapters, and no record list is claimed for them.
+- The literal `pre_word` and `post_word` of all 119 targets of `WHOLECALLER-PLAN-v1`
+  (32 main, 72 helper, 15 idle), 16,748 `SWAP_BITS` events in all, are executed as `XROW`
+  records on 145-axis addresses at `f = 2`; each word realizes the declared `permutation` or
+  `inverse_permutation` of its target with phase zero and spectators untouched. The 16
+  central `X` corrections of negative `Q` powers are `NOT(0)` records.
+
+## What is not claimed
+
+The Proposition's proof (the four-update rotation scheme with dirty compact fields, its
+overflow repair and the chunk-swap primitive) is not executed; the reservations of the control
+fields for the 145-axis layout are taken from `compact-control-layout.tex` as written. No
+numerical tariff, no new κ, no change to the selected record. The body monomials, including the
+400 helper alias pairs of #5442, are executed separately above (an earlier version said they
+were covered by the port-wrapper lists; none of them is a port wrapper). The forward body is not
+replayed.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/record_lift/lift.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/record_lift/lift.py
new file mode 100644
index 0000000000..167d085a91
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/record_lift/lift.py
@@ -0,0 +1,377 @@
+"""Record-level realization of the f-column lift of the selected caller's monomials.
+
+Model (SPECIALIZATION.md s2-s3, compact-control-movement.tex).  An address of a field with
+f columns on n logical axes is X = (x_1, ..., x_f), x_j in F_2^n, plus arbitrary spectator
+bits.  A monomial m = (G, b, Q, alpha, a) acts on one column as
+    |x> -> i^(a + q(x)) |G x xor b>,    q(x) = sum_i alpha_i x_i + 2 sum_{i<j} Q_ij x_i x_j  (mod 4),
+in the order diag(Q, alpha), perm(G), xgate(b), phase(a) of prune_native.monomial, and its
+lift m^(tensor f) acts as
+    |X> -> i^(a f + sum_j q(x_j)) |(G x_1 xor b, ..., G x_f xor b)>.
+
+Tape records.  Every record acts on all f columns at once and never reads or writes a
+spectator bit; each is one retained primitive type:
+    XROW(i, k)   x_{j,i} ^= x_{j,k} for every column j      (compact-control selected-bit addition,
+                                                               slots k -> i; movement-paid)
+    NOT(i)       x_{j,i} ^= 1 for every column j             (selected-bit translation; movement-paid)
+    S(i)         phase i^(sum_j x_{j,i})                       (unit-S phase record)
+    CZ(i, k)     phase (-1)^(sum_j x_{j,i} x_{j,k})            (controlled-sign phase record)
+    I            phase i^f                                     (global i record, lifted to i^f)
+A row swap is three XROW records.  The record list of a monomial is independent of f.
+
+This module builds the record list of a monomial by Gaussian elimination (the grammar of
+SPECIALIZATION.md s2), executes it on explicit addresses with the phase accumulated modulo 4,
+and compares with the lift formula; it also realizes 145-axis axis permutations (the plan's
+J routes) as transposition chains of XROW records.  Standard library only.
+"""
+import importlib.util
+import json
+import random
+from collections import Counter
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+CAP = ROOT / "research/coupled-helper-neutral-completion/capsule/workspace"
+NORM = CAP / "swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json"
+PLAN = CAP / "swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json"
+CLIFFORD = ROOT / "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py"
+BODY = CAP / "swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json"
+PROVIDER = CAP / "swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json"
+N9 = 9
+N145 = 145
+
+
+def load_clifford():
+    spec = importlib.util.spec_from_file_location("tape_lift_clifford_exact", CLIFFORD)
+    ce = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(ce)
+    return ce
+
+
+# ------------------------------------------------------------------ monomials
+def parity(x):
+    return x.bit_count() & 1
+
+
+def mv(rows, x):
+    return sum(parity(r & x) << i for i, r in enumerate(rows))
+
+
+def qvalue(Q, alpha, x, n):
+    return (sum(alpha[i] for i in range(n) if x >> i & 1)
+            + 2 * sum(parity((Q[i] >> (i + 1)) & (x >> (i + 1))) for i in range(n) if x >> i & 1)) % 4
+
+
+class Monomial:
+    def __init__(self, n, matrix_rows, offset, quadratic_rows, linear_Z4, phase):
+        self.n = n
+        self.G = tuple(matrix_rows)
+        self.b = offset
+        self.Q = tuple(quadratic_rows)
+        self.alpha = tuple(linear_Z4)
+        self.a = phase % 4
+        assert len(self.G) == len(self.Q) == len(self.alpha) == n
+        for i in range(n):
+            assert self.alpha[i] % 2 == (self.Q[i] >> i) & 1, "Z4 linear parity equals the Q diagonal"
+            for j in range(n):
+                assert (self.Q[i] >> j) & 1 == (self.Q[j] >> i) & 1, "symmetric Q"
+
+    @classmethod
+    def from_recipe(cls, r, n=N9):
+        return cls(n, r["matrix_rows"], r["offset"], r["quadratic_rows"], r["linear_Z4"], r["phase"])
+
+    @classmethod
+    def from_axis_permutation(cls, perm, n):
+        """x -> x' with x'_{perm[i]} = x_i, i.e. axis i moves to axis perm[i] (a J route)."""
+        rows = [0] * n
+        for i, t in enumerate(perm):
+            rows[t] |= 1 << i
+        return cls(n, rows, 0, [0] * n, [0] * n, 0)
+
+    def one_column(self, x):
+        """(image address, phase mod 4) of one column."""
+        return mv(self.G, x) ^ self.b, qvalue(self.Q, self.alpha, x, self.n)
+
+    def lift(self, X, f):
+        """(image, phase) of the lifted monomial on X = list of f column addresses."""
+        img, ph = [], (self.a * f) % 4
+        for x in X:
+            y, p = self.one_column(x)
+            img.append(y)
+            ph = (ph + p) % 4
+        return img, ph
+
+    # -------------------------------------------------------------- the record grammar
+    def records(self):
+        """Record list realizing the monomial (f-independent).  Order of application:
+        phase records on the input address, then the row operations of G, then translations,
+        then the global i records."""
+        n = self.n
+        out = []
+        for i in range(n):
+            out += [("S", i)] * self.alpha[i]
+        for i in range(n):
+            for k in range(i + 1, n):
+                if (self.Q[i] >> k) & 1:
+                    out.append(("CZ", i, k))
+        # Gaussian elimination of G to the identity; the reversed op list realizes G
+        M = list(self.G)
+        ops = []
+        for col in range(n):
+            piv = next(r for r in range(col, n) if (M[r] >> col) & 1)
+            if piv != col:
+                M[piv], M[col] = M[col], M[piv]
+                ops.append(("SWAP", piv, col))
+            for r in range(n):
+                if r != col and (M[r] >> col) & 1:
+                    M[r] ^= M[col]
+                    ops.append(("XROW", r, col))        # row r ^= row col
+        assert M == [1 << i for i in range(n)]
+        for op in reversed(ops):
+            if op[0] == "SWAP":
+                _, i, k = op
+                out += [("XROW", i, k), ("XROW", k, i), ("XROW", i, k)]
+            else:
+                out.append(op)
+        for i in range(n):
+            if (self.b >> i) & 1:
+                out.append(("NOT", i))
+        out += [("I",)] * self.a
+        return out
+
+
+def record_counts(recs):
+    c = Counter(r[0] for r in recs)
+    return {"XROW": c["XROW"], "NOT": c["NOT"], "S": c["S"], "CZ": c["CZ"], "I": c["I"],
+            "movement_records": c["XROW"] + c["NOT"], "phase_records": c["S"] + c["CZ"] + c["I"], "total": len(recs)}
+
+
+# ------------------------------------------------------------------ tape execution on addresses
+def execute(recs, X, f, spectators):
+    """Apply the record list to the f column addresses X (list of ints) with spectator bits.
+    Returns (new X, phase mod 4, spectators) -- spectators are carried, never touched."""
+    X = list(X)
+    ph = 0
+    for r in recs:
+        t = r[0]
+        if t == "XROW":
+            _, i, k = r
+            for j in range(f):
+                X[j] ^= ((X[j] >> k) & 1) << i
+        elif t == "NOT":
+            i = r[1]
+            for j in range(f):
+                X[j] ^= 1 << i
+        elif t == "S":
+            i = r[1]
+            ph = (ph + sum((X[j] >> i) & 1 for j in range(f))) % 4
+        elif t == "CZ":
+            _, i, k = r
+            ph = (ph + 2 * sum(((X[j] >> i) & 1) & ((X[j] >> k) & 1) for j in range(f))) % 4
+        elif t == "I":
+            ph = (ph + f) % 4
+        else:
+            raise ValueError(r)
+    return X, ph, spectators
+
+
+def check_monomial(m, f, addresses, spectator_bits=3, rng=None):
+    """Execute the record list on the given column-address tuples and compare with the lift."""
+    recs = m.records()
+    rng = rng or random.Random(0)
+    for X in addresses:
+        spec = rng.getrandbits(spectator_bits)
+        got_X, got_ph, got_spec = execute(recs, X, f, spec)
+        want_X, want_ph = m.lift(X, f)
+        if got_X != want_X or got_ph != want_ph or got_spec != spec:
+            return False, {"X": X, "got": (got_X, got_ph), "want": (want_X, want_ph)}
+    return True, record_counts(recs)
+
+
+def all_addresses(n, f):
+    N = 1 << n
+    if f == 1:
+        return [[x] for x in range(N)]
+    if f == 2:
+        return [[x, y] for x in range(N) for y in range(N)]
+    raise ValueError("exhaustive only for f <= 2")
+
+
+def random_addresses(n, f, count, seed):
+    rng = random.Random(seed)
+    return [[rng.getrandbits(n) for _ in range(f)] for _ in range(count)]
+
+
+# ------------------------------------------------------------------ inventory of the selected caller
+def wrappers():
+    nz = json.loads(NORM.read_text(encoding="utf-8"))
+    out = []
+    for p, port in enumerate(nz["ports"]):
+        for name, w in sorted(port["compiled_wrappers"].items()):
+            out.append((f"port{p}:{name}", Monomial.from_recipe(w["recipe"])))
+    return out
+
+
+def literal_op(ce, word):
+    """Exact engine operator of a literal monomial word (primitives D, P, X, phase, applied in order)."""
+    op = ce.ident(N9)
+    for e in word:
+        if e[0] == "D":
+            op = op.then(ce.diag(N9, e[1], e[2]))
+        elif e[0] == "P":
+            op = op.then(ce.perm(N9, e[1]))
+        elif e[0] == "X":
+            op = op.then(ce.xgate(N9, e[1]))
+        elif e[0] == "phase":
+            op = op.then(ce.Op(N9, ce.identity(N9), [("phase", e[1])]))
+        else:
+            raise ValueError("unknown monomial primitive " + repr(e[0]))
+    return op
+
+
+def from_engine(ce, op):
+    """The monomial (G, b, Q, alpha, a) of an exact engine operator, read off its action on the 46 basis states
+    0, e_i, e_i + e_j, then certified as the same exact group element (Pauli tableau and image of |0>, which fixes
+    the absolute phase) as the engine operator of the read-off monomial.  Raises if op is not that monomial."""
+    units = {(1, 0): 0, (0, 1): 1, (-1, 0): 2, (0, -1): 3}
+
+    def act(x):
+        vec, den = op.zero_state(x)
+        nz = [(y, v) for y, v in enumerate(vec) if v != (0, 0)]
+        if den != 0 or len(nz) != 1 or nz[0][1] not in units:
+            raise ValueError("not a dyadic-free monomial")
+        return nz[0][0], units[nz[0][1]]
+    b, a = act(0)
+    single = [act(1 << i) for i in range(N9)]
+    cols = [single[i][0] ^ b for i in range(N9)]
+    rows = [sum(((cols[i] >> r) & 1) << i for i in range(N9)) for r in range(N9)]
+    alpha = [(single[i][1] - a) % 4 for i in range(N9)]
+    Q = [0] * N9
+    for i in range(N9):
+        Q[i] |= (alpha[i] & 1) << i
+        for j in range(i + 1, N9):
+            d = (act((1 << i) | (1 << j))[1] - single[i][1] - single[j][1] + a) % 4
+            if d % 2:
+                raise ValueError("odd quadratic phase")
+            if d == 2:
+                Q[i] |= 1 << j
+                Q[j] |= 1 << i
+    m = Monomial(N9, rows, b, Q, alpha, a)
+    mine = ce.diag(N9, m.Q, m.alpha).then(ce.perm(N9, m.G)).then(ce.xgate(N9, m.b)).then(ce.Op(N9, ce.identity(N9), [("phase", m.a)]))
+    if mine.tab != op.tab or mine.zero_state() != op.zero_state():
+        raise ValueError("read-off monomial is a different group element")
+    return m
+
+
+def body_monomials(ce):
+    """Every literal monomial word the selected caller's body applies besides the port wrappers: the 1,072
+    MONOMIAL operations of NEUTRAL-BACKWARD-v16c (800 whole-job helper normalizers, 240 Z-map block maps,
+    16 paid C8 axis routes, 16 mode aliases) and the 16 mode words input_K / output_N of the #5402 provider,
+    which #5442's mode-output certificate binds.  Returns (name, Monomial, occurrences) per distinct word."""
+    body = json.loads(BODY.read_text(encoding="utf-8"))
+    prov = json.loads(PROVIDER.read_text(encoding="utf-8"))
+    words = {}
+    for i, o in enumerate(body["operations"]):
+        if o["op"] == "MONOMIAL":
+            kind = o.get("purpose") or ("whole_job" if "whole_job_boundary" in o else "block")
+            words.setdefault(json.dumps(o["word"]), [kind, 0])[1] += 1
+    for m in prov["mode_boundaries"]:
+        for key in ("input_K", "output_N"):
+            words.setdefault(json.dumps(m[key]["literal_word"]), ["mode_" + key, 0])[1] += 1
+    out = []
+    for k, (kind, n) in words.items():
+        out.append((kind, from_engine(ce, literal_op(ce, json.loads(k))), n))
+    return out
+
+
+def central_elements(ce):
+    """C0 = cgate on axis 0 and X0 = xgate on axis 0 are not monomials in prune_native's sense
+    (cgate is a rank-one Gaussian); only X0 is a translation record.  We return X0 and the
+    diagonal unit-S / Z elements used by the plan (phase records)."""
+    return [("X0", Monomial(N9, [1 << i for i in range(N9)], 1, [0] * N9, [0] * N9, 0))]
+
+
+def plan_words():
+    """The 145-axis J routes of WHOLECALLER-PLAN-v1: for every main/helper/idle target its literal
+    pre_word and post_word (lists of SWAP_BITS events), the declared permutation and inverse,
+    and whether a central X follows the LEFT boundary (the correction of a negative Q power)."""
+    plan = json.loads(PLAN.read_text(encoding="utf-8"))
+    out = []
+    for kind in ("main_targets", "helper_targets", "idle_jobs"):
+        for idx, t in enumerate(plan[kind]):
+            for key in ("pre_word", "post_word"):
+                assert all(ev[0] == "SWAP_BITS" and len(ev) == 3 for ev in t[key]), (kind, idx, key)
+            assert t["affine_translation"] == [] and t["absolute_phase"] == 0, "J routes are plain permutations"
+            out.append({"name": f"{kind}[{idx}] rank {t['rank']}", "kind": kind, "pre": t["pre_word"], "post": t["post_word"],
+                        "perm": tuple(t["permutation"]), "inv": tuple(t["inverse_permutation"]),
+                        "central_X": bool(t.get("central_X_after_LEFT", False))})
+    return out
+
+
+def swap_records(word):
+    """SWAP_BITS(i, k) is the row swap of axes i and k: three XROW records."""
+    recs = []
+    for _, i, k in word:
+        recs += [("XROW", i, k), ("XROW", k, i), ("XROW", i, k)]
+    return recs
+
+
+def check_word(word, perm, inv, f, count, seed, n=N145):
+    """Execute the literal SWAP_BITS word as XROW records and identify which declared axis
+    permutation it realizes (the plan's `permutation` or `inverse_permutation`).
+    Returns (ok, convention, record counts)."""
+    recs = swap_records(word)
+    cands = {"permutation": Monomial.from_axis_permutation(perm, n), "inverse_permutation": Monomial.from_axis_permutation(inv, n)}
+    rng = random.Random(seed)
+    alive = set(cands)
+    for X in random_addresses(n, f, count, seed):
+        spec = rng.getrandbits(3)
+        got_X, got_ph, got_spec = execute(recs, X, f, spec)
+        if got_spec != spec or got_ph != 0:
+            return False, None, None
+        for c in list(alive):
+            if cands[c].lift(X, f) != (got_X, 0):
+                alive.discard(c)
+        if not alive:
+            return False, None, None
+    conv = sorted(alive)
+    return True, conv, record_counts(recs)
+
+
+def transposition_chain(perm):
+    """Transpositions (i, k) whose product (applied left to right as axis swaps) is perm."""
+    n = len(perm)
+    content = list(range(n))      # content[pos] = original axis whose bit now sits at pos
+    where = list(range(n))        # where[axis] = its current position
+    out = []
+    for t in range(n):
+        s_axis = perm.index(t)    # output position t must hold original axis s_axis
+        s = where[s_axis]
+        if s != t:
+            a, b = content[s], content[t]
+            content[s], content[t] = b, a
+            where[a], where[b] = t, s
+            out.append((s, t))
+    assert all(where[i] == perm[i] for i in range(n))
+    return out
+
+
+def permutation_records(perm):
+    recs = []
+    for i, k in transposition_chain(perm):
+        recs += [("XROW", i, k), ("XROW", k, i), ("XROW", i, k)]
+    return recs
+
+
+def check_permutation(perm, f, count, seed):
+    n = len(perm)
+    m = Monomial.from_axis_permutation(perm, n)
+    recs = permutation_records(perm)
+    rng = random.Random(seed)
+    for X in random_addresses(n, f, count, seed):
+        spec = rng.getrandbits(3)
+        got_X, got_ph, got_spec = execute(recs, X, f, spec)
+        want_X, want_ph = m.lift(X, f)
+        if got_X != want_X or got_ph != want_ph or got_spec != spec:
+            return False, None
+    return True, record_counts(recs)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/NOTICE.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/NOTICE.md
new file mode 100644
index 0000000000..e82bfef530
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/NOTICE.md
@@ -0,0 +1,38 @@
+# Attribution
+
+Jose Manuel (`jmbarrancoml`) prepared the new sequential interpreter,
+selected monomial compiler, checks and written composition with substantial
+OpenAI Codex assistance. We use the repository's Apache-2.0 license.
+
+Douglas Colkitt's compact-control movement/layout construction and the
+retained OpenAI framework supply the dirty-control identity, original
+guard, exceptional repair method, record-paid arithmetic and asymptotic
+domain. We implement that method; we claim no new generic guard or sorting
+algorithm. The source-authenticated address audit remains a separate oracle.
+
+The existing carry and guard audits retain their credit: John-Michael
+Smith's PR763, bbMisk's PR1219 and later-source audit, Hanson Sun's PR1247,
+Sagar Thakrar's PR1475, and the PR1603 lineage. Our new path uses the original
+predicate and does not replace their refinements.
+
+The selected scalar word, native Clifford compilation, frame recipes,
+owner maps and T16 packing retain the contributors and disclosures in
+`research/complex-sw4-frame8/NOTICE.md` and the gauge44/T16 notices linked
+from `research/joint-query/NOTICE.md`. We reuse Ali Romman's retained source
+loader to read the frozen local archive. It authenticates the five source
+members and does not run the exploratory producer.
+
+The unchanged selected `clifford_exact.py` interpreter supplies the exact
+single-column comparison. The new compiler independently lowers its
+serialized affine matrices and follows its strict-upper quadratic convention.
+We compare both selected literal programs and their source hashes, rather
+than substituting the nearby R492 predecessor.
+
+PR2234 by Jose Manuel, head `d047ef86fbc5b1614d3d8e2b8d3441413beab73f`, supplies
+a pending written completed ordinary-interchange construction. We import
+none of its code. The physical tests use the elementary completed supplier;
+the faster complexity statement names the ordinary contract as a premise.
+
+`SOURCES.json` pins retained code, proof notes and archives. We have not
+merged or closed predecessor work, changed the selected frontier, or obtained
+independent human or proof-assistant verification.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/compact.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/compact.py
new file mode 100644
index 0000000000..60bc206c78
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/compact.py
@@ -0,0 +1,203 @@
+"""Retained dirty compact-control word with a sequential repair interpreter.
+
+The algebra and original guard are Douglas Colkitt's retained construction.
+This interpreter supplies payload movement, keyed repair and scratch closure.
+"""
+from dataclasses import dataclass
+from math import prod
+
+from streams import (Tape,need,copy,bit_key,key_value,stable_radix,
+                     digit_permutation,flip_digit)
+
+
+@dataclass(frozen=True)
+class Layout:
+    fields: tuple
+    record_bits: int
+
+    @property
+    def bits(self):return sum(width for _,width in self.fields)
+    @property
+    def records(self):return 1<<self.bits
+    @property
+    def names(self):return tuple(name for name,_ in self.fields)
+
+    def width(self,name):return dict(self.fields)[name]
+
+    def position(self,name,low_bit=0):
+        before=0
+        for field,width in self.fields:
+            if field==name:
+                need(0<=low_bit<width,"field bit extent")
+                return before+width-1-low_bit
+            before+=width
+        raise ValueError("unknown field")
+
+    def decode(self,index):
+        need(0<=index<self.records,"full record address")
+        out={}
+        for name,width in reversed(self.fields):
+            out[name]=index% (1<<width);index>>=width
+        return out
+
+    def encode(self,state):
+        out=0
+        for name,width in self.fields:
+            need(0<=state[name]<1<<width,"encoded field extent")
+            out=(out<<width)+state[name]
+        return out
+
+
+@dataclass(frozen=True)
+class Compact:
+    n: int
+    K: int
+    G: int
+    rho: int
+    source: str | None
+    target: str
+    late: bool=False
+
+    def validate(self,layout):
+        need(self.n>=1 and self.K>=1 and self.G>=1 and 0<=self.rho<self.K,"compact domain")
+        need(layout.width(self.target)==(self.n+1)*self.K,"wide target extent")
+        need(all(layout.width(name)==self.n*self.G for name in ("u","t","b")),
+             "complete equal compact fields")
+        need(layout.names.index("u")<layout.names.index(self.target) and
+             layout.names.index("t")<layout.names.index(self.target)<layout.names.index("b"),
+             "front and back compact placement")
+        if self.source is not None:
+            need(layout.width(self.source)==(self.n+1)*self.K,"wide source extent")
+            need((layout.names.index(self.source)>layout.names.index(self.target))==self.late,
+                 "declared source order")
+        else:need(not self.late,"constant toggle uses early routine")
+
+    def select(self,value):
+        return sum(((value>>(self.rho+i*self.K))&1)<<(i*self.G) for i in range(self.n))
+
+    def mask(self,value,compact=False):
+        return sum(((value>>(i*self.G if compact else self.rho+i*self.K))&1)
+                   <<(self.rho+i*self.K) for i in range(self.n))
+
+    def operations(self):
+        ops=[]
+        def rot(target,controls,kind,sign=1):ops.append(("rotate",target,controls,kind,sign))
+        def load(front,controls,kind,sign=1):
+            ops.append(("swap",front,"b"));rot("b",controls,kind,sign);ops.append(("swap",front,"b"))
+        def flip(control,is_compact=False):
+            tag="compact" if is_compact else "wide"
+            controls=(() if control is None else (control,))+("t",)
+            rot(self.target,controls,"first_"+tag)
+            load("t",(self.target,),"selected_y")
+            rot(self.target,controls,"second_"+tag)
+            controls=(() if control is None else (control,))+(self.target,)
+            load("t",controls,"original_"+tag,-1)
+        if self.late:
+            flip("u",True);load("u",(self.source,),"selected_x")
+            flip("u",True);load("u",(self.source,),"selected_x",-1)
+        else:flip(self.source)
+        return tuple(ops)
+
+    def offset(self,state,operation):
+        _,target,controls,kind,sign=operation
+        if kind=="selected_y":return sign*self.select(state[self.target])
+        if kind=="selected_x":return sign*self.select(state[self.source])
+        compact=kind.endswith("compact")
+        control="u" if compact else self.source
+        bits=[1 if control is None else (state[control]>>(i*self.G if compact else self.rho+i*self.K))&1
+              for i in range(self.n)]
+        if kind.startswith("original"):
+            value=state[self.target]^sum(b<<(self.rho+i*self.K) for i,b in enumerate(bits))
+            return sign*self.select(value)
+        B=1<<self.G
+        return sign*sum(bits[i]*(2*((state["t"]>>(i*self.G))&(B-1)) if kind.startswith("first")
+                               else 1-2*((state["t"]>>(i*self.G))&(B-1)))
+                       <<(self.rho+i*self.K) for i in range(self.n))
+
+    def execute(self,state,layout,inverse=False):
+        out=dict(state)
+        for op in reversed(self.operations()) if inverse else self.operations():
+            if op[0]=="swap":out[op[1]],out[op[2]]=out[op[2]],out[op[1]]
+            else:out[op[1]]=(out[op[1]]+(-1 if inverse else 1)*self.offset(out,op))%(1<<layout.width(op[1]))
+        return out
+
+    def ideal(self,state,highest=False):
+        out=dict(state);n=self.n+int(highest)
+        value=(sum(1<<(self.rho+i*self.K) for i in range(n)) if self.source is None else
+               sum(((state[self.source]>>(self.rho+i*self.K))&1)<<(self.rho+i*self.K) for i in range(n)))
+        out[self.target]^=value
+        return out
+
+    def bad(self,state):
+        B=1<<self.G;upper=(1<<(self.K-1))-2*B;mask=(1<<(self.K-1))-1
+        return any(((state["t"]>>(i*self.G))&(B-1))==B-1 or
+                   not 2*B<=((state[self.target]>>(self.rho+i*self.K+1))&mask)<upper or
+                   (self.late and ((state["u"]>>(i*self.G))&(B-1))==B-1)
+                   for i in range(self.n))
+
+
+def ordinary(source,layout,first,second):
+    """Completed elementary supplier used in tests; retain the abstract call bill."""
+    width=layout.width(first);need(width==layout.width(second),"equal ordinary chunks")
+    source.meter.ordinary_calls.append({"width":width,"volume":len(source.data)})
+    for bit in range(width):
+        a,b=sorted((layout.position(first,bit),layout.position(second,bit)))
+        source=digit_permutation(source,layout.bits,a,b,layout.record_bits,(0,2,1,3))
+    return source
+
+
+def rotate(source,layout,word,op):
+    _,target,controls,_,_=op;at=layout.names.index(target)
+    need(all(layout.names.index(name)<at for name in controls),"all rotation controls precede target")
+    before=sum(width for _,width in layout.fields[:at]);after=sum(width for _,width in layout.fields[at+1:])
+    width=layout.width(target);radix=1<<width;suffix=(1<<after)*layout.record_bits
+    source.rewind();left=Tape(source.meter);right=Tape(source.meter);out=Tape(source.meter)
+    for prefix in range(1<<before):
+        state=layout.decode(prefix<<(width+after));cut=word.offset(state,op)%radix
+        source.meter.control_evaluations+=1
+        copy(source,left,(radix-cut)*suffix);copy(source,right,cut*suffix)
+    source.finish();left.rewind();right.rewind()
+    for prefix in range(1<<before):
+        state=layout.decode(prefix<<(width+after));cut=word.offset(state,op)%radix
+        source.meter.control_evaluations+=1
+        copy(right,out,cut*suffix);copy(left,out,(radix-cut)*suffix)
+    left.finish();right.finish();left.erase();right.erase();source.erase();out.rewind()
+    source.meter.rotation_passes+=1
+    return out
+
+
+def repair(source,layout,word,wrong_inverse=False):
+    source.rewind();good=Tape(source.meter);bad=Tape(source.meter);holes=Tape(source.meter)
+    for index in range(layout.records):
+        state=layout.decode(index);exception=word.bad(state);holes.write(bytes((int(exception),)))
+        if exception:
+            old=state if wrong_inverse else word.execute(state,layout,True)
+            destination=layout.encode(word.ideal(old))
+            bad.write(bit_key(destination,layout.bits));copy(source,bad,layout.record_bits)
+            source.meter.repair_records+=1;source.meter.control_evaluations+=1
+        else:copy(source,good,layout.record_bits)
+    source.finish();source.erase();bad.rewind();good.rewind();holes.rewind()
+    bad=stable_radix(bad,layout.bits,layout.record_bits);out=Tape(source.meter)
+    for index in range(layout.records):
+        if holes.read(1)[0]:
+            destination=key_value(bad.read(layout.bits))
+            need(destination==index,"sorted exceptional keys fill precisely the marked holes")
+            copy(bad,out,layout.record_bits)
+        else:copy(good,out,layout.record_bits)
+    for tape in (bad,good,holes):tape.finish();tape.erase()
+    out.rewind();return out
+
+
+def execute(source,layout,word,omit_repair=False,wrong_inverse=False):
+    word.validate(layout);need(len(source.data)==layout.records*layout.record_bits,"complete record rectangle")
+    for op in word.operations():
+        source=ordinary(source,layout,op[1],op[2]) if op[0]=="swap" else rotate(source,layout,word,op)
+    if not omit_repair:source=repair(source,layout,word,wrong_inverse)
+    y=layout.position(word.target,word.rho+word.n*word.K)
+    if word.source is None:source=flip_digit(source,layout.bits,y,layout.record_bits)
+    else:
+        x=layout.position(word.source,word.rho+word.n*word.K);a,b=sorted((x,y))
+        mapping=(0,1,3,2) if x<y else (0,3,2,1)
+        source=digit_permutation(source,layout.bits,a,b,layout.record_bits,mapping)
+    need(source.head==0,"completed compact output origin")
+    return source
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/streams.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/streams.py
new file mode 100644
index 0000000000..61542ce4c9
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/reference/streams.py
@@ -0,0 +1,115 @@
+"""Sequential bit-stream simulator with charged contiguous transfers.
+
+Bulk methods abbreviate consecutive tape transitions; they charge each bit.
+Payload destinations are append-only. Random lookup is confined to controls.
+"""
+from dataclasses import dataclass,field
+
+
+def need(condition,message):
+    if not condition:
+        raise ValueError(message)
+
+
+@dataclass
+class Meter:
+    reads: int=0
+    writes: int=0
+    moves: int=0
+    erases: int=0
+    control_evaluations: int=0
+    digit_passes: int=0
+    rotation_passes: int=0
+    radix_passes: int=0
+    repair_records: int=0
+    ordinary_calls: list=field(default_factory=list)
+
+
+class Tape:
+    def __init__(self,meter,data=b""):
+        self.meter=meter;self.data=bytearray(data);self.head=0
+
+    def read(self,size):
+        need(0<=size<=len(self.data)-self.head,"sequential read boundary")
+        value=self.data[self.head:self.head+size];self.head+=size
+        self.meter.reads+=size;self.meter.moves+=size
+        return value
+
+    def write(self,value):
+        need(self.head==len(self.data),"append-only output")
+        self.data.extend(value);self.head+=len(value)
+        self.meter.writes+=len(value);self.meter.moves+=len(value)
+
+    def rewind(self):
+        self.meter.moves+=self.head;self.head=0
+
+    def finish(self):
+        need(self.head==len(self.data),"complete sequential consumption")
+
+    def erase(self):
+        self.rewind();size=len(self.data)
+        self.meter.erases+=size;self.meter.moves+=2*size
+        self.data.clear();self.head=0
+
+
+def copy(source,target,size):
+    target.write(source.read(size))
+
+
+def bit_key(value,width):
+    need(0<=value<1<<width,"binary control key extent")
+    return bytes((value>>i)&1 for i in range(width))
+
+
+def key_value(bits):
+    need(all(b in (0,1) for b in bits),"binary control encoding")
+    return sum(b<<i for i,b in enumerate(bits))
+
+
+def digit_permutation(source,total_bits,first,second,record_bits,mapping):
+    """Two physical address-bit positions, numbered from the left."""
+    need(0<=first<second<total_bits,"two ordered bit fields")
+    need(sorted(mapping)==list(range(4)),"four-state permutation")
+    middle=1<<(second-first-1);suffix=(1<<(total_bits-second-1))*record_bits
+    slab=4*middle*suffix;need(len(source.data)%slab==0,"complete digit slabs")
+    source.rewind();out=Tape(source.meter);buckets=[Tape(source.meter) for _ in range(4)]
+    inverse=[mapping.index(i) for i in range(4)]
+    for _prefix in range(len(source.data)//slab):
+        for a in range(2):
+            for _mid in range(middle):
+                for b in range(2):copy(source,buckets[2*a+b],suffix)
+        for bucket in buckets:bucket.rewind()
+        for a in range(2):
+            for _mid in range(middle):
+                for b in range(2):copy(buckets[inverse[2*a+b]],out,suffix)
+        for bucket in buckets:bucket.finish();bucket.erase()
+    source.finish();source.erase();out.rewind();source.meter.digit_passes+=1
+    return out
+
+
+def flip_digit(source,total_bits,position,record_bits):
+    suffix=(1<<(total_bits-position-1))*record_bits;slab=2*suffix
+    need(len(source.data)%slab==0,"complete bit-flip slabs")
+    source.rewind();out=Tape(source.meter);left=Tape(source.meter);right=Tape(source.meter)
+    for _ in range(len(source.data)//slab):
+        copy(source,left,suffix);copy(source,right,suffix)
+        left.rewind();right.rewind();copy(right,out,suffix);copy(left,out,suffix)
+        left.finish();right.finish();left.erase();right.erase()
+    source.finish();source.erase();out.rewind();source.meter.digit_passes+=1
+    return out
+
+
+def stable_radix(source,key_bits,payload_bits):
+    """LSD binary partition and concatenation; no sorting or seek oracle."""
+    width=key_bits+payload_bits;need(len(source.data)%width==0,"complete keyed records")
+    for position in range(key_bits):
+        source.rewind();buckets=[Tape(source.meter),Tape(source.meter)]
+        for _ in range(len(source.data)//width):
+            key=source.read(key_bits)
+            bucket=buckets[key[position]]
+            bucket.write(key);copy(source,bucket,payload_bits)
+        source.finish();source.erase();out=Tape(source.meter)
+        for bucket in buckets:
+            bucket.rewind();copy(bucket,out,len(bucket.data));bucket.finish();bucket.erase()
+        out.rewind();source=out;source.meter.radix_passes+=1
+    return source
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2808/outer.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2808/outer.py
new file mode 100644
index 0000000000..1341d39448
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2808/outer.py
@@ -0,0 +1,233 @@
+"""Fresh-output ordinary borrowing wrapper over authenticated binary tapes.
+
+Runtime extents and atom counts stay encoded. The completed F callback is the
+only new indirect semantic boundary. It must satisfy the README contract.
+"""
+
+from contextlib import ExitStack, contextmanager
+from dataclasses import dataclass
+
+import padding
+from bitstream import atom_swap
+from cardinal_counts import Count, positive
+from cardinality import multiply_atom_power, radix_power
+from linear_sign import sign_address
+from stream import Counter, add_pass
+from words import need
+
+
+def replace(current, following, borrowed):
+    need(
+        following is not current and following is not borrowed,
+        "distinct owned pass output",
+    )
+    if current is not borrowed:
+        current.clear()
+    return following
+
+
+def body_pass(
+    source, atoms, ring, q, before, gap, suffix, *, negative=False, sign=False
+):
+    """One vector ADD or target negation, in at most n complete atom passes."""
+    need(not atoms.zero(), "positive whole-atom body")
+    for extent in (before, gap, suffix):
+        positive(extent)
+    current = source
+    coefficient = ring.negate if negative else ring.arena.copy
+    with ExitStack() as work:
+        remaining = Counter(atoms)
+        work.callback(remaining.close)
+        remaining.decrement()
+        pre = Count.product(before, gap) if sign else Count(before)
+        tail = Count(suffix)
+        work.callback(pre.close)
+        work.callback(tail.close)
+        multiply_atom_power(tail, remaining.tape, ring, q)
+        middle = Count(gap)
+        work.callback(middle.close)
+        multiply_atom_power(middle, remaining.tape, ring, q)
+        if sign:
+            multiply_atom_power(pre, atoms, ring, q)
+        try:
+            for_more = True
+            while for_more:
+                extents = [value.marginal() for value in (pre, middle, tail)]
+                try:
+                    if sign:
+                        following = sign_address(
+                            current, ring, q, extents[0], extents[2]
+                        )
+                    else:
+                        following, _meter = add_pass(
+                            current, ring, *extents, lambda: coefficient(ring.one)
+                        )
+                    current = replace(current, following, source)
+                finally:
+                    for extent in extents:
+                        extent.close()
+                for_more = not remaining.finished
+                if for_more:
+                    remaining.decrement()
+                    for _ in radix_power(ring, q):
+                        pre.multiply_small(q)
+                        need(tail.divide_small(q) == 0, "exact next atom suffix")
+            result, current = current, None
+            return result
+        finally:
+            if current is not None and current is not source:
+                current.clear()
+
+
+def swap_chunks(source, ring, q, before, middle, suffix):
+    extents = [value.marginal() for value in (before, middle, suffix)]
+    try:
+        return atom_swap(source, ring, q, *extents)
+    finally:
+        for extent in extents:
+            extent.close()
+
+
+def body_ordinary(source, atoms, ring, q, prefixes, rows, stock, gap, suffix, callee):
+    """D-=H; padded F; D+=H; padded F; D=-D; D+=H, with fresh rows per F."""
+    before = Count.product(prefixes, rows)
+    body = Count.product(gap, suffix)
+    multiply_atom_power(body, atoms, ring, q)
+    multiply_atom_power(body, atoms, ring, q)
+    current = source
+    try:
+        current = body_pass(current, atoms, ring, q, before, gap, suffix, negative=True)
+        for second in (False, True):
+            following = padding.complete(current, prefixes, rows, stock, body, callee)
+            current = replace(current, following, source)
+            if not second:
+                following = body_pass(current, atoms, ring, q, before, gap, suffix)
+                current = replace(current, following, source)
+        following = body_pass(current, atoms, ring, q, before, gap, suffix, sign=True)
+        current = replace(current, following, source)
+        following = body_pass(current, atoms, ring, q, before, gap, suffix)
+        current = replace(current, following, source)
+        result, current = current, None
+        return result
+    finally:
+        if current is not None and current is not source:
+            current.clear()
+        before.close()
+        body.close()
+
+
+@dataclass(frozen=True)
+class Shape:
+    rows: Count
+    body_width: Count
+    gap: Count
+    actual_gap: Count
+    actual_suffix: Count
+    high_gap: Count
+    high_suffix: Count
+
+
+@contextmanager
+def borrowing_shape(
+    atoms, ring, high_ring, q, prefixes, spectators, suffix, stock, remainder_ring
+):
+    need(type(q) is int and q >= 2, "fixed radix at least two")
+    for extent in (prefixes, spectators, suffix, stock):
+        positive(extent)
+    need(not atoms.zero(), "positive whole-atom body")
+    need(ring.raw.compare(ring.modulus, ring.one) > 0, "nonempty atom field")
+    need(
+        high_ring.raw.compare(high_ring.modulus, high_ring.one) > 0,
+        "nonempty high field",
+    )
+    if remainder_ring is not None:
+        need(
+            remainder_ring.raw.compare(remainder_ring.modulus, remainder_ring.one) > 0,
+            "use absent remainder for zero residual digits",
+        )
+    with ExitStack() as work:
+        rows = Count(high_ring.modulus)
+        remainder = (
+            Count.literal(1)
+            if remainder_ring is None
+            else Count(remainder_ring.modulus)
+        )
+        body_width = Count.literal(1)
+        for value in (rows, remainder, body_width):
+            work.callback(value.close)
+        multiply_atom_power(body_width, atoms, ring, q)
+        chunk = Count.product(body_width, remainder)
+        gap = Count.product(spectators, rows)
+        actual_gap = Count.product(remainder, gap)
+        actual_suffix = Count.product(remainder, suffix)
+        high_gap = Count.product(chunk, spectators)
+        high_suffix = Count.product(chunk, suffix)
+        for value in (chunk, gap, actual_gap, actual_suffix, high_gap, high_suffix):
+            work.callback(value.close)
+        yield Shape(
+            rows, body_width, gap, actual_gap, actual_suffix, high_gap, high_suffix
+        )
+
+
+def swap_remainder(source, ring, q, prefixes, shape, suffix):
+    pre = Count.product(prefixes, shape.rows)
+    rem_pre = Count.product(pre, shape.body_width)
+    rem_gap = Count.product(shape.gap, shape.body_width)
+    try:
+        return swap_chunks(source, ring, q, rem_pre, rem_gap, suffix)
+    finally:
+        pre.close()
+        rem_pre.close()
+        rem_gap.close()
+
+
+def interchange(
+    source,
+    atoms,
+    ring,
+    high_ring,
+    q,
+    prefixes,
+    spectators,
+    suffix,
+    stock,
+    callee,
+    remainder_ring=None,
+):
+    """[P][Hhi][Hbody][Hrem][Z][Dhi][Dbody][Drem][T] -> full chunk swap.
+
+    high_ring.modulus is R=q^k, ring.modulus is M=q^w; n=atoms>0.
+    remainder_ring is absent for zero remaining digits, otherwise q^ell.
+    All input heads enter at one. The callee preserves its input and heads.
+    """
+    current = source
+    with borrowing_shape(
+        atoms, ring, high_ring, q, prefixes, spectators, suffix, stock, remainder_ring
+    ) as shape:
+        try:
+            if remainder_ring is not None:
+                current = swap_remainder(
+                    current, remainder_ring, q, prefixes, shape, suffix
+                )
+            following = body_ordinary(
+                current,
+                atoms,
+                ring,
+                q,
+                prefixes,
+                shape.rows,
+                stock,
+                shape.actual_gap,
+                shape.actual_suffix,
+                callee,
+            )
+            current = replace(current, following, source)
+            following = swap_chunks(
+                current, high_ring, q, prefixes, shape.high_gap, shape.high_suffix
+            )
+            current = replace(current, following, source)
+            result, current = current, None
+            return result
+        finally:
+            if current is not None and current is not source:
+                current.clear()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2808/vendor/pr2786/padding.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2808/vendor/pr2786/padding.py
new file mode 100644
index 0000000000..0229304638
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2808/vendor/pr2786/padding.py
@@ -0,0 +1,135 @@
+"""Compatible fresh-row padding on the retained sequential binary tapes.
+
+The caller supplies canonical positive Count operands and a completed callee.
+Only finite flags, not decoded cardinalities or payloads, control these scans.
+"""
+
+from cardinal_counts import Count, positive
+from records import Tape
+from stream import Counter
+from words import BLANK, ONE, ZERO, need
+
+
+def plan_rows(rows, stock):
+    """Return owned Counts (ceil(rows/stock)*stock, added), requiring rows>=stock.
+
+    Each main iteration consumes one of rows. Each final iteration consumes
+    one of fewer than stock unused group positions. No payload is accessed.
+    """
+    positive(rows)
+    positive(stock)
+    remaining, group = Counter(rows), Counter(stock)
+    padded, added = Count.literal(0), Count.literal(0)
+    completed_group = False
+    try:
+        while not remaining.finished:
+            remaining.decrement()
+            group.decrement()
+            padded.increment()
+            if group.finished:
+                completed_group = True
+                if not remaining.finished:
+                    group.close()
+                    group = Counter(stock)
+        need(completed_group, "row capacity must cover at least one stock group")
+        while not group.finished:
+            group.decrement()
+            padded.increment()
+            added.increment()
+        return padded, added
+    except BaseException:
+        padded.close()
+        added.close()
+        raise
+    finally:
+        remaining.close()
+        group.close()
+
+
+def scan_rows(source, output, rows, body, mode):
+    """Process exactly rows*body cells at the current prefix, using three modes."""
+    need(mode in ("copy", "zero", "discard"), "finite row-scan mode")
+    outer = Counter(rows)
+    try:
+        while not outer.finished:
+            inner = Counter(body)
+            try:
+                while not inner.finished:
+                    if mode == "zero":
+                        output.append(ZERO)
+                    else:
+                        bit = source.read()
+                        need(bit in (ZERO, ONE), "complete binary row payload")
+                        if mode == "copy":
+                            output.append(bit)
+                        else:
+                            need(bit == ZERO, "callee must leave added rows zero")
+                        source.step(1)
+                    inner.decrement()
+            finally:
+                inner.close()
+            outer.decrement()
+    finally:
+        outer.close()
+
+
+def transform(source, prefixes, rows, added, body, restricting=False):
+    """Pad or restrict [prefixes][rows][body], returning a fresh owned tape.
+
+    Source enters at its first cell. Every count loop has its encoded finite
+    bound. For restriction the source instead has rows+added rows per prefix.
+    """
+    for count in (prefixes, rows, body):
+        positive(count)
+    need(isinstance(added, Count), "encoded padding count")
+    need(source.head == 1, "row scan enters at its local left boundary")
+    output, outer = Tape(), Counter(prefixes)
+    try:
+        while not outer.finished:
+            scan_rows(source, output, rows, body, "copy")
+            scan_rows(source, output, added, body, "discard" if restricting else "zero")
+            outer.decrement()
+        need(source.read() == BLANK, "exact complete row extent")
+        output.rewind()
+        return output
+    except BaseException:
+        output.clear()
+        raise
+    finally:
+        outer.close()
+        source.rewind()
+
+
+def complete(source, prefixes, rows, stock, body, callee):
+    """Invoke a source-preserving, row-pointwise callee on compatible fresh rows.
+
+    The callee borrows the padded input and row count, returns a DISTINCT owned
+    output, restores all heads, and closes its own work even on failure. Its
+    endpoint must preserve genuine row ordinals and permute within each row.
+    Runtime zero checks do not establish that semantic callee premise.
+    """
+    padded_rows, added = plan_rows(rows, stock)
+    padded = returned = None
+    try:
+        padded = transform(source, prefixes, rows, added, body)
+        candidate = callee(padded, padded_rows)
+        need(
+            candidate is not padded and candidate is not source,
+            "callee returns distinct owned output, never a borrowed input",
+        )
+        returned = candidate
+        need(isinstance(returned, Tape), "callee returns a payload tape")
+        need(
+            padded.head == returned.head == padded_rows.tape.head == 1,
+            "completed callee restores borrowed and output heads",
+        )
+        padded.clear()
+        padded = None
+        return transform(returned, prefixes, rows, added, body, restricting=True)
+    finally:
+        if returned is not None and isinstance(returned, Tape):
+            returned.clear()
+        if padded is not None:
+            padded.clear()
+        padded_rows.close()
+        added.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/consumer.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/consumer.py
new file mode 100644
index 0000000000..a66d9276f8
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/consumer.py
@@ -0,0 +1,85 @@
+"""Catalogue-bound common local and native idle consumers of actual leaf traces."""
+from controller import Callback
+from directory import produce
+from layout import Layout
+from numeric import Geometry, selected_coefficient
+from packet import read_prefix
+import packet_engine
+from records import Fields
+from trace import execute
+from words import Unsigned, need
+
+
+class Consumer:
+    recursive=True
+    def __init__(self,context,indices,program,specifications,parent_size,depth):
+        self.context,self.indices,self.program=context,indices,program
+        self.specifications,self.parent_size,self.depth=specifications,parent_size,depth
+        need(program.code_bits==context.codes.bits,"one full selected source vocabulary")
+
+    def apply(self,source,request_id,common,low,old_directory,old_count,before,gap,suffix,observe=None,child_stock=None,child_before=None):
+        context,indices=self.context,self.indices
+        request=self.specifications.catalogue.requests[request_id]
+        need(common==(request.kind!="IDLE"),"common local versus native idle source view")
+        spec=self.specifications.bind(request_id,common,low)
+        plan=self.specifications.plan(spec.code)
+        directory,prefixes=produce(old_directory,self.depth,old_count,spec.code,context)
+        raw=Unsigned(indices)
+        divisor,one=indices.literal(64),indices.literal(1)
+        columns,remainder=raw.divmod(self.parent_size,divisor)
+        need(not columns.zero(),"positive selected internal quotient")
+        indices.free_many(divisor,remainder)
+        fields,carry=raw.add(self.depth,one);indices.free(one)
+        need(not carry,"current field depth margin")
+        geometry=Geometry(plan,indices,columns,self.depth,spec.code,self.program)
+        layout=Layout(geometry,self.parent_size,context.ring,context.q,before,gap,suffix)
+        try:
+            directory.rewind();first=read_prefix(directory,fields);directory.rewind()
+            prefix=Fields(indices,context.arena,context.codes.bits);prefix.tape=first
+            frame=Callback(context.ring,indices,self.program,prefix,self.specifications,spec.code,allow_fallback=True)
+            valid=raw.compare(frame.final_size,self.parent_size)==0 and raw.compare(frame.depth,self.depth)==0
+            frame.close();first.clear()
+            need(valid,"selected node and encoded incoming frame agree")
+            def coefficient(prefix,reference):
+                values=Fields(indices,context.arena,context.codes.bits);values.tape=prefix
+                return selected_coefficient(plan,context.ring,indices,self.program,values,
+                                            self.specifications,spec.code,reference)
+            def invoke(current,event):
+                from recursive_call import child_call
+                return child_call(self,current,event,layout,directory,prefixes,fields,
+                                  child_stock,child_before)
+            return (yield from packet_engine.run_generator(source,execute(geometry),layout,directory,
+                                  prefixes,fields,coefficient,observe=observe,invoke=invoke))
+        finally:
+            layout.close();geometry.close();indices.free_many(columns,fields)
+            directory.clear();prefixes.close();old_directory.rewind()
+
+
+class IncomingWeights:
+    """Read the unchanged parent program with exactly its frozen field prefix."""
+    def __init__(self,context,indices,program,specifications,parent_size,depth):
+        import oracle
+        self.context,self.indices,self.program=context,indices,program
+        self.specifications,self.parent_size,self.depth=specifications,parent_size,depth
+        self.ambient=specifications.bind(0,True,tuple(map(tuple,oracle.eye(64)))).code
+
+    def coefficient(self,prefix,request):
+        need(request.kind=="incoming","original parent weight request")
+        context,indices=self.context,self.indices
+        fields=Fields(indices,context.arena,context.codes.bits);fields.tape=prefix
+        frame=Callback(context.ring,indices,self.program,fields,self.specifications,self.ambient,
+                       allow_fallback=True,leaf=True)
+        try:
+            need(frame.raw.compare(frame.final_size,self.parent_size)==0 and
+                 frame.raw.compare(frame.depth,self.depth)==0,"frozen-only incoming parent frame")
+            value=frame.weight(request.coordinate)
+            if request.negative_inverse:
+                inverse=context.ring.inverse(value)
+                need(inverse is not None,"incoming remainder weight is a unit")
+                opposite=context.ring.negate(inverse)
+                context.arena.free_many(value,inverse);value=opposite
+            frame.close()
+            return value
+        except ValueError:
+            frame.abort()
+            raise
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/driver.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/driver.py
new file mode 100644
index 0000000000..5b7846a70a
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/driver.py
@@ -0,0 +1,197 @@
+"""Physical whole-word staging and chronological native global operations."""
+from functools import lru_cache
+from types import GeneratorType
+
+from bitstream import copy_bits
+from cardinal_counts import Count
+from control import LocalState
+from episode import xor_packet
+from fresh_rows import family_rows
+import oracle
+from records import Tape
+from routes import compile_route, copy_rows, inverse_rational, route_packet
+from selection import gather, scatter
+from sources import identity, product
+from stream import Counter
+from words import BLANK, ONE, ZERO, need
+
+
+@lru_cache(None)
+def inverse_chart(matrix):
+    transposed=tuple(zip(*matrix))
+    if product(matrix,transposed)==identity(len(matrix)):return transposed
+    return inverse_rational(matrix)
+
+
+@lru_cache(None)
+def compile_owner(chart,common_low,codes):
+    """Fixed-q source labels; no high matrix or precision reaches this stage."""
+    inverse=inverse_chart(chart)
+    native=tuple(map(tuple,oracle.multiply(common_low,oracle.reduce_rational(inverse,codes.q),codes.q)))
+    forward=compile_route(native,chart,codes)
+    backward=compile_route(common_low,inverse,codes)
+    need(forward.target_low==common_low and backward.target_low==native,"exact owner/common inverse binding")
+    return native,forward,backward
+
+
+def clone_packet(source,context,old_count,fibre):
+    result,outer=Tape(),Counter(old_count)
+    source.rewind()
+    try:
+        while not outer.finished:
+            copy_rows(source,result,context.highs,fibre);outer.decrement()
+        need(source.read()==BLANK,"complete cloned packet")
+        result.rewind()
+        return result
+    except ValueError:
+        result.clear()
+        raise
+    finally:outer.close();source.rewind()
+
+
+def xor_family(source,target,old_count,rows,fibre):
+    result,outer=Tape(),Counter(old_count)
+    source.rewind();target.rewind()
+    try:
+        while not outer.finished:
+            records=Counter(rows)
+            while not records.finished:
+                bits=Counter(fibre)
+                while not bits.finished:
+                    a,b=source.read(),target.read()
+                    need(a in (ZERO,ONE) and b in (ZERO,ONE),"aligned native Boolean family")
+                    result.append(a^b);source.step(1);target.step(1);bits.decrement()
+                bits.close();records.decrement()
+            records.close();outer.decrement()
+        need(source.read()==target.read()==BLANK,"complete native family XOR")
+        result.rewind()
+        return result
+    except ValueError:
+        result.clear()
+        raise
+    finally:outer.close();source.rewind();target.rewind()
+
+
+class Driver:
+    def __init__(self,context,topology,consumer,old_directory,old_count,before,gap,suffix,fibre,observe=None,child_stock=None,child_before=None):
+        self.child_stock,self.child_before=child_stock,child_before
+        self.context,self.topology,self.consumer=context,topology,consumer
+        self.old_directory,self.old_count=old_directory,old_count
+        self.before,self.gap,self.suffix,self.fibre=before,gap,suffix,fibre
+        self.observe=observe
+
+    def event(self,kind,*labels):
+        if self.observe is not None:self.observe(kind,*labels)
+
+    def residual(self,source,identifier,common,low):
+        self.event("residual",identifier,common)
+        if getattr(self.consumer,"recursive",False):
+            result=self.consumer.apply(source,identifier,common,low,self.old_directory,self.old_count,
+                                       self.before,self.gap,self.suffix,child_stock=self.child_stock,
+                                       child_before=self.child_before)
+        else:
+            result=self.consumer.apply(source,identifier,common,low,self.old_directory,self.old_count,
+                                       self.before,self.gap,self.suffix)
+        if isinstance(result,GeneratorType):return (yield from result)
+        return result
+
+    def commit(self,families,family,low,packet):
+        """Merge into the latest family state, including earlier role returns."""
+        previous=families[family]
+        families[family]=scatter(previous,packet,self.context,self.old_count,low,self.fibre)
+        previous.clear()
+
+    def local(self,families,call,common_low):
+        context=self.context
+        slots,buffers={},{}
+        state=LocalState(call);private=state.private
+        try:
+            seen=set()
+            for role,owner in enumerate(call.owners):
+                chart=self.topology.matrix(owner.chart)
+                native,forward,backward=compile_owner(chart,common_low,context.codes)
+                key=(owner.family,native)
+                need(key not in seen,"disjoint complete owned low packets")
+                seen.add(key)
+                local=gather(families[owner.family],context,self.old_count,native,self.fibre)
+                try:buffers[role]=route_packet(local,forward,context,self.old_count,self.fibre)
+                finally:local.clear()
+                slots[role]=(owner.family,native,backward)
+            for position,event in enumerate(call.events):
+                op,role=state.accept(position)
+                self.event("literal",call.stage,call.replica,position,op)
+                if op==0:
+                    changed=yield from self.residual(buffers[role],call.requests[position],True,common_low)
+                    buffers[role].clear();buffers[role]=changed
+                elif op==1:
+                    source=event[2]
+                    need(source in buffers,"live XOR payload role")
+                    changed=xor_packet(buffers[source],buffers[role],context,self.old_count,self.fibre)
+                    buffers[role].clear();buffers[role]=changed
+                elif op==2:
+                    need(private not in buffers,"fresh private payload role")
+                    copied=clone_packet(buffers[role],context,self.old_count,self.fibre)
+                    try:buffers[private]=yield from self.residual(copied,call.requests[position],True,common_low)
+                    finally:copied.clear()
+                else:
+                    need(op==3 and private in buffers,"live transported private payload")
+                    buffers.pop(private).clear()
+            state.finish()
+            # Every role returns, including helpers with a changed physical frame.
+            for role in range(private):
+                family,native,backward=slots[role]
+                returned=route_packet(buffers[role],backward,context,self.old_count,self.fibre)
+                try:self.commit(families,family,native,returned)
+                finally:returned.clear()
+        finally:
+            for tape in buffers.values():tape.clear()
+            self.old_directory.rewind()
+
+    def idle(self,families,identifier,replica):
+        family=self.topology.idle_family(identifier,replica)
+        for low in self.topology.catalogue.low_classes():
+            selected=gather(families[family],self.context,self.old_count,low,self.fibre)
+            changed=None
+            try:
+                changed=yield from self.residual(selected,identifier,False,low)
+                self.commit(families,family,low,changed)
+            finally:
+                if changed is not None:changed.clear()
+                selected.clear()
+
+    def global_word(self,families):
+        topology=self.topology
+        rows=family_rows(self.context)
+        try:
+            for event in topology.schedule:
+                kind=event["kind"]
+                self.event("global",kind)
+                if kind=="local_cover_sweep":
+                    for replica in range(topology.replicas):
+                        call=topology.call(event["stage"],replica)
+                        for low in topology.catalogue.low_classes():
+                            yield from self.local(families,call,low)
+                elif kind=="idle":
+                    for replica in range(topology.replicas):
+                        for identifier in topology.idles[event["idx"]]:yield from self.idle(families,identifier,replica)
+                elif kind=="bridge":
+                    need(event["coefficient"] in (-1,1) and event["dst"]!=event["src"],"native bridge scalar")
+                    for replica in range(topology.replicas):
+                        for port in range(topology.ports):
+                            for target,source,side in ((event["dst"],event["src"],0),
+                                                       (event["src"],event["dst"],1)):
+                                a=topology.family(replica,target,side,port)
+                                b=topology.family(replica,source,side,port)
+                                changed=xor_family(families[b],families[a],self.old_count,rows,self.fibre)
+                                families[a].clear();families[a]=changed
+                                self.event("bridge",a,b,event["coefficient"])
+                else:
+                    need(kind=="exchange","closed global opcode")
+                    for replica in range(topology.replicas):
+                        for pair in range(topology.pairs):
+                            for port in range(topology.ports):
+                                a=topology.family(replica,pair,0,port);b=topology.family(replica,pair,1,port)
+                                families[a],families[b]=families[b],families[a]
+                                self.event("exchange",a,b)
+                self.event("global_return",kind,event.get("stage",event.get("idx",-1)))
+        finally:rows.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md
new file mode 100644
index 0000000000..d0318d43ed
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/NOTICE.md
@@ -0,0 +1,9 @@
+# Frozen proof evidence
+
+These files are byte-exact proof exports, authenticated by [EVIDENCE.json](../EVIDENCE.json). They are evidence dependencies, not new results of this package. Their internal relative links refer to their original package at the manifest commit.
+
+- `pr2731-README.md`: starship-s, sharp residual storage and retained-role proof, PR2731; retains its credit to Jose Manuel/jmbarrancoml and earlier source authors.
+- `pr2708-README.md`: Nick Petalas, route/key storage and caller-phase proof, PR2708; retains its source credit and Apache-2.0 statement.
+- `pr2688-PROOF.md` and `pr2688-NOTICE.md`: ywz65, canonical-directory storage proof, PR2688; the original notice preserves source attribution.
+
+The inherited numerical/source implementation itself is separately frozen in `../predecessor/`. The local reserve uses these proofs only within their stated contracts and explicitly accounts for the new recursive frames. No component proof is silently promoted to a complete caller or a physical fixed-tape theorem.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md
new file mode 100644
index 0000000000..f2b49cdef8
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/evidence/pr2688-NOTICE.md
@@ -0,0 +1,22 @@
+# Attribution
+
+New numerical storage theorem and verifier: ywz65, assisted substantially by
+OpenAI Codex, 2026. New material is Apache-2.0 under the repository license.
+
+The unchanged canonical-directory implementation and its source contract are
+from CrocSwap/integer-mult-bounds PR2569, head
+898ff36fe2cd05f733de6b26c88a4c4741b06237, by Jose Manuel (jmbarrancoml) with
+OpenAI Codex assistance. The exact serialized field formula and
+cubic setup-cost correction are from PR2590, head
+8803e0ced7d5cc8a6db1b11157742f70981f4f42, by ywz65 with OpenAI Codex assistance.
+The current PR2569 has incorporated that correction. This package does not
+claim either predecessor result anew.
+
+The unchanged [PR2569 notice](vendor/NOTICE-2569.md) retains its detailed
+predecessor and concurrent attribution. The source commit, original path,
+Git blob and SHA-256 of every vendored file appear in VENDOR.json.
+
+The numerical q threshold is taken from the main three-stage note. Its
+historical exponent is not silently substituted for PR2569's explicit
+root coupling. The new contribution is the uniform numerical directory
+allowance under the named contract, not a new producer or complete caller.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/layout.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/layout.py
new file mode 100644
index 0000000000..aa554b14fe
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/layout.py
@@ -0,0 +1,123 @@
+"""Binary two-bank layout with an independent complete intervening gap."""
+from cardinal_counts import Count, positive
+from cardinality import multiply_atom_power
+from words import need
+
+
+class Layout:
+    def __init__(self,geometry,parent_size,ring,q,before,gap,suffix,embedded=True):
+        for value in (before,gap,suffix):positive(value)
+        self.geometry,self.ring,self.q=geometry,ring,q
+        self.before,self.gap,self.suffix=before,gap,suffix
+        self.parent_size,self.embedded=parent_size,embedded
+        self.core=geometry.raw.times_small(geometry.columns,geometry.plan.dimension)
+        remaining=geometry.raw.subtract_exact(parent_size,self.core)
+        self.extra=geometry.raw.times_small(remaining,2)
+        geometry.index.free(remaining)
+        self.total=geometry.raw.times_small(parent_size,2)
+
+    def physical(self,position):
+        if not self.embedded or self.geometry.raw.compare(position,self.core)<0:
+            return self.geometry.index.copy(position)
+        return self.geometry.plus(position,self.extra)
+
+    def extents(self,first,second=None):
+        g=self.geometry
+        a=self.physical(first)
+        b=self.physical(second) if second is not None else None
+        if b is not None:need(g.raw.compare(a,b)<0,"ordered physical body atoms")
+        last=a if b is None else b
+        pre,tail=Count(self.before),Count(self.suffix)
+        multiply_atom_power(pre,a,self.ring,self.q)
+        after=g.raw.subtract_exact(self.total,last)
+        count=g.raw.subtract_exact(after,g.one)
+        multiply_atom_power(tail,count,self.ring,self.q)
+        g.index.free_many(after,count)
+        if g.raw.compare(a,self.parent_size)>=0:
+            enlarged=Count.product(pre,self.gap);pre.close();pre=enlarged
+        if g.raw.compare(last,self.parent_size)<0:
+            enlarged=Count.product(tail,self.gap);tail.close();tail=enlarged
+        values=[pre]
+        if b is not None:
+            distance=g.raw.subtract_exact(b,a)
+            count=g.raw.subtract_exact(distance,g.one)
+            middle=Count.literal(1)
+            multiply_atom_power(middle,count,self.ring,self.q)
+            if g.raw.compare(a,self.parent_size)<0 and g.raw.compare(b,self.parent_size)>=0:
+                enlarged=Count.product(middle,self.gap);middle.close();middle=enlarged
+            values.append(middle)
+            g.index.free_many(distance,count,b)
+        values.append(tail);g.index.free(a)
+        result=[value.marginal() for value in values]
+        for value in values:value.close()
+        return result
+
+    def fibre(self):
+        value=Count.product(self.before,self.gap)
+        multiply_atom_power(value,self.total,self.ring,self.q)
+        result=Count.product(value,self.suffix)
+        value.close()
+        return result
+
+    def close(self):
+        self.geometry.index.free_many(self.core,self.extra,self.total)
+
+    def child_extents(self, first, second, width, *, before):
+        """Return B', G', S' for two complete, disjoint child chunks.
+
+        Source order is [U][B][head M^n][G][tail M^n][S]. U is returned
+        separately to the caller and must not be absorbed in `before`.
+        The projected order is [U][B'][chunk M^c][G'][chunk M^c][S'].
+        """
+        positive(before)
+        g = self.geometry
+        need(not width.zero(), "positive recursive child width")
+        a, b = self.physical(first), self.physical(second)
+        a_end, b_end = g.plus(a, width), g.plus(b, width)
+        last_offset = g.raw.subtract_exact(width, g.one)
+        first_last = g.plus(first, last_offset)
+        second_last = g.plus(second, last_offset)
+        mapped_first_last = self.physical(first_last)
+        mapped_second_last = self.physical(second_last)
+        expected_first_last = g.raw.subtract_exact(a_end, g.one)
+        expected_second_last = g.raw.subtract_exact(b_end, g.one)
+        words = (a,b,a_end,b_end,last_offset,first_last,second_last,
+                 mapped_first_last,mapped_second_last,
+                 expected_first_last,expected_second_last)
+        values = []
+        try:
+            need(g.raw.compare(a,b)<0 and g.raw.compare(a_end,b)<=0,
+                 "ordered disjoint recursive child chunks")
+            need(g.raw.compare(b_end,self.total)<=0,
+                 "recursive child lies in the complete body")
+            need(g.raw.compare(mapped_first_last,expected_first_last)==0
+                 and g.raw.compare(mapped_second_last,expected_second_last)==0,
+                 "each recursive child chunk is physically contiguous")
+            for start,end in ((a,a_end),(b,b_end)):
+                need(g.raw.compare(start,self.parent_size)>=0
+                     or g.raw.compare(end,self.parent_size)<=0,
+                     "recursive chunk does not cross the original gap")
+
+            pre, middle, tail = Count(before), Count.literal(1), Count(self.suffix)
+            values = [pre,middle,tail]
+            multiply_atom_power(pre,a,self.ring,self.q)
+            between = g.raw.subtract_exact(b,a_end)
+            after = g.raw.subtract_exact(self.total,b_end)
+            try:
+                multiply_atom_power(middle,between,self.ring,self.q)
+                multiply_atom_power(tail,after,self.ring,self.q)
+            finally:
+                g.index.free_many(between,after)
+
+            # Exactly one of these three complete spectator regions contains
+            # the parent's external gap; it is multiplied in exactly once.
+            gap_region = (0 if g.raw.compare(a,self.parent_size)>=0 else
+                          2 if g.raw.compare(b_end,self.parent_size)<=0 else 1)
+            enlarged = Count.product(values[gap_region],self.gap)
+            values[gap_region].close()
+            values[gap_region] = enlarged
+            return [value.marginal() for value in values]
+        finally:
+            for value in values:
+                value.close()
+            g.index.free_many(*words)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/linear_sign.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/linear_sign.py
new file mode 100644
index 0000000000..6a6e5c02f2
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/linear_sign.py
@@ -0,0 +1,82 @@
+"""Linear-traffic address negation on complete atom fibres.
+
+The source shape is [before][M][suffix], M = ring.modulus.  No atom value
+or spectator cardinality is decoded into host control.  Each nonzero atom
+slice is copied forwards, while slice starts are visited in reverse order.
+"""
+from bitstream import copy_bits
+from records import Tape
+from stream import Counter, positive_extent
+from words import BLANK, need
+
+
+def move_slices(source, count, suffix, direction):
+    """Move count complete slices by charged unit head movements."""
+    blocks = Counter(count)
+    try:
+        while not blocks.finished:
+            bits = Counter(suffix)
+            try:
+                while not bits.finished:
+                    source.step(direction)
+                    bits.decrement()
+            finally:
+                bits.close()
+            blocks.decrement()
+    finally:
+        blocks.close()
+
+
+def sign_address(source, ring, q, before, suffix):
+    """Pull back x -> -x mod M, preserving source and resetting both heads.
+
+    q is retained for the old public signature; the permutation needs only
+    M >= 2. Source-head moves, including the final rewind, are at most 6V,
+    where V = before*M*suffix. Numerical counter setup has its usual
+    amortized binary-counting charge and is not hidden in this move bound.
+    """
+    del q
+    positive_extent(before)
+    positive_extent(suffix)
+    two = ring.arena.literal(2)
+    leading = ring.raw.subtract_exact(ring.modulus, two)
+    nonzero = ring.raw.subtract_exact(ring.modulus, ring.one)
+    output = Tape()
+    outer = Counter(before)
+    try:
+        while not outer.finished:
+            # Preserve the zero slice, then reach the final nonzero slice.
+            copy_bits(source, output, suffix)
+            move_slices(source, leading, suffix, 1)
+            remaining = Counter(nonzero)
+            try:
+                while not remaining.finished:
+                    copy_bits(source, output, suffix)
+                    remaining.decrement()
+                    if not remaining.finished:
+                        # Two is finite control. Copying a padded residue word
+                        # for this count once per atom would cost O(V log M)
+                        # when suffix=1.
+                        for _ in range(2):
+                            backwards=Counter(suffix)
+                            try:
+                                while not backwards.finished:
+                                    source.step(-1)
+                                    backwards.decrement()
+                            finally:backwards.close()
+            finally:
+                remaining.close()
+            # We finished just after slice 1; advance to the next outer row.
+            move_slices(source, leading, suffix, 1)
+            outer.decrement()
+        need(source.read() == BLANK, "complete linear sign input")
+        source.rewind()
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        source.rewind()
+        outer.close()
+        ring.arena.free_many(two, leading, nonzero)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/node.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/node.py
new file mode 100644
index 0000000000..28c98a3573
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/node.py
@@ -0,0 +1,88 @@
+"""Complete internal node: peel, fresh rows, recursive caller and return."""
+from cardinal_counts import Count, positive
+from cardinality import multiply_atom_power
+from consumer import Consumer, IncomingWeights
+from driver import Driver
+import fresh_rows
+from packet import read_prefix
+import peel
+from plan import Request
+from topology import SelectedTopology
+from words import Unsigned, need
+from scheduler import complete
+
+
+def selected_topology(catalogue):
+    """One immutable source table per catalogue, shared by every frame.
+
+    The retained topology's recipe/call caches include its identity in their
+    keys. Recreating that identity per child would retain source-table copies
+    after those children returned. Keep the single owner on the fixed-q
+    catalogue instead of introducing another global frame-keyed cache.
+    """
+    result=getattr(catalogue,"_recursive_caller_topology",None)
+    if result is None:
+        result=SelectedTopology(catalogue)
+        catalogue._recursive_caller_topology=result
+    need(result.catalogue is catalogue,"selected topology belongs to its fixed source")
+    return result
+
+
+class Node:
+    def __init__(self,context,indices,program,parent_size,depth,topology,consumer,incoming,stock_multiple=1):
+        self.context,self.indices,self.program=context,indices,program
+        self.parent_size,self.depth=parent_size,depth
+        self.topology,self.consumer,self.incoming=topology,consumer,incoming
+        self.stock_multiple=stock_multiple
+        raw=Unsigned(indices);dimension,one=indices.literal(context.dimension),indices.literal(1)
+        columns,remainder=raw.divmod(parent_size,dimension)
+        valid=not columns.zero()
+        indices.free_many(dimension,one,columns,remainder)
+        need(valid,"complete internal node width")
+
+    def run(self,*args,**kwargs):
+        return complete(self.run_generator(*args,**kwargs))
+
+    def run_generator(self,source,old_directory,old_count,row_count,before,gap,suffix,observe=None):
+        old_count,row_count,before,gap,suffix=(Count(value) for value in (old_count,row_count,before,gap,suffix))
+        for value in (old_count,row_count,before,gap,suffix):positive(value)
+        context,indices=self.context,self.indices
+        unused=leading=fibre=None;peeled=None;families={}
+        try:
+            old_directory.rewind();first=read_prefix(old_directory,self.depth);old_directory.rewind()
+            zero=indices.zero()
+            try:
+                value=self.incoming.coefficient(first,Request("incoming",zero))
+                context.arena.free(value)
+            finally:first.clear();indices.free(zero)
+            unused=fresh_rows.quotient(row_count,context,self.topology.families)
+            stock=Count(unused)
+            try:need(stock.divide_small(self.stock_multiple)==0,"selected compatible unused stock factor")
+            finally:stock.close()
+            leading=Count.product(unused,before)
+            fibre=Count.product(leading,gap)
+            total=Unsigned(indices).times_small(self.parent_size,2)
+            multiply_atom_power(fibre,total,context.ring,context.q);indices.free(total)
+            following=Count.product(fibre,suffix);fibre.close();fibre=following
+            peeled=peel.run(source,context,indices,self.parent_size,self.depth,self.program,
+                            old_directory,old_count,row_count,before,gap,suffix,self.incoming)
+            families=fresh_rows.split(peeled,context,self.topology.families,old_count,fibre)
+            driver=Driver(context,self.topology,self.consumer,old_directory,old_count,leading,gap,suffix,fibre,observe,child_stock=unused,child_before=before)
+            yield from driver.global_word(families)
+            return fresh_rows.merge(families,context,self.topology.families,old_count,fibre)
+        finally:
+            for tape in families.values():tape.clear()
+            if peeled is not None and peeled is not source:peeled.clear()
+            for value in (unused,leading,fibre,old_count,row_count,before,gap,suffix):
+                if value is not None:value.close()
+            source.rewind();old_directory.rewind()
+
+
+class SelectedNode(Node):
+    def __init__(self,context,indices,program,parent_size,depth,catalogue,specifications):
+        need(context.dimension==64 and context.codes is catalogue.codes and
+             specifications.catalogue is catalogue,"one source-bound selected node")
+        topology=selected_topology(catalogue)
+        consumer=Consumer(context,indices,program,specifications,parent_size,depth)
+        incoming=IncomingWeights(context,indices,program,specifications,parent_size,depth)
+        super().__init__(context,indices,program,parent_size,depth,topology,consumer,incoming,9475)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/packet_engine.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/packet_engine.py
new file mode 100644
index 0000000000..72543f684f
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/packet_engine.py
@@ -0,0 +1,98 @@
+"""Shared trace on complete prefixes, with the caller's full two-bank layout."""
+from bitstream import copy_bits
+from packet import read_prefix
+from records import Tape
+from stream import Counter
+from stream_runner import action
+from words import BLANK, need
+from scheduler import Invocation, complete
+
+
+def run_generator(source,events,layout,directory,prefix_count,field_count,coefficient,factory=Tape,observe=None,invoke=None):
+    fibre=layout.fibre()
+    current,active=source,None
+    boundary_words=[]
+    boundary_labels=None
+    returned=False
+    internal=invoked=False
+    try:
+        for event in events:
+            if event.kind=="enter":
+                need(active is None and event.parent_identity is layout.geometry.parent_identity,
+                     "one whole-packet completed child")
+                active=event
+                boundary_labels=(event.child_kind,event.field,event.reverse,event.half,
+                                 event.source_code,event.parent_identity)
+                boundary_words=[layout.geometry.index.copy(getattr(event,name))
+                                for name in ("first","second","width","depth")]
+                internal=layout.geometry.raw.compare(event.width,layout.geometry.leaf_cutoff)>=0
+                invoked=False
+                if observe is not None:observe("enter")
+                continue
+            if event.kind=="return":
+                need(active is not None and boundary_labels==
+                     (event.child_kind,event.field,event.reverse,event.half,
+                      event.source_code,event.parent_identity),
+                     "same completed child returns")
+                for saved,name in zip(boundary_words,("first","second","width","depth")):
+                    need(layout.geometry.raw.compare(saved,getattr(event,name))==0,"restored child geometry")
+                need(invoked==internal,"exactly one internal invocation before return")
+                layout.geometry.index.free_many(*boundary_words);boundary_words=[]
+                active=None
+                boundary_labels=None
+                if observe is not None:observe("return")
+                continue
+            if event.kind=="invoke":
+                need(active is not None and internal and not invoked and invoke is not None,
+                     "exactly one bound recursive child consumer")
+                need(boundary_labels==(event.child_kind,event.field,event.reverse,event.half,
+                                       event.source_code,event.parent_identity),
+                     "invoke matches entered child")
+                for saved,name in zip(boundary_words,("first","second","width","depth")):
+                    need(layout.geometry.raw.compare(saved,getattr(event,name))==0,
+                         "invoke has the entered child geometry")
+                following=yield Invocation(invoke(current,event))
+                need(following is not current,"recursive child returns its owned output")
+                if current is not source:current.clear()
+                current=following
+                invoked=True
+                continue
+            need(active is None or not internal,"internal body is exclusively a whole-packet invocation")
+            output,prefixes=factory(),Counter(prefix_count)
+            directory.rewind()
+            try:
+                need(not prefixes.finished,"nonempty complete prefix packet")
+                while not prefixes.finished:
+                    fields=read_prefix(directory,field_count)
+                    local,changed=factory(),None
+                    try:
+                        copy_bits(current,local,fibre);local.rewind()
+                        changed=action(local,event,layout,lambda request:coefficient(fields,request),factory)
+                        copy_bits(changed,output,fibre)
+                        need(changed.read()==BLANK,"complete changed prefix fibre")
+                    finally:
+                        if changed is not None and changed is not local:changed.clear()
+                        local.clear();fields.clear()
+                    prefixes.decrement()
+                need(current.read()==directory.read()==BLANK,"complete shared packet and directory")
+                current.rewind();directory.rewind()
+                if current is not source:current.clear()
+                output.rewind();current=output
+            except ValueError:
+                output.clear()
+                raise
+            finally:prefixes.close()
+        need(active is None,"complete child lifetime")
+        returned=True
+        return current
+    finally:
+        # A deeper failure closes suspended parents with GeneratorExit. Owned
+        # output must be erased on that path as well as ordinary ValueError.
+        if not returned and current is not source:current.clear()
+        fibre.close();directory.rewind();source.rewind()
+        if boundary_words:layout.geometry.index.free_many(*boundary_words)
+        events.close()
+
+
+def run(*args,**kwargs):
+    return complete(run_generator(*args,**kwargs))
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/peel.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/peel.py
new file mode 100644
index 0000000000..38502515af
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/peel.py
@@ -0,0 +1,46 @@
+"""Peel the last n-m head atoms using original incoming weight offsets."""
+from cardinal_counts import Count
+from layout import Layout
+from numeric import Geometry
+import packet_engine
+from plan import Plan, Request
+from trace import primitive
+from words import Unsigned, need
+
+
+def events(geometry,parent_size):
+    raw,index=geometry.raw,geometry.index
+    coordinate=raw.times_small(geometry.columns,geometry.plan.dimension)
+    total=raw.times_small(parent_size,2)
+    last=raw.subtract_exact(total,geometry.one)
+    index.free(total)
+    try:
+        while raw.compare(coordinate,parent_size)<0:
+            right=raw.subtract_exact(last,coordinate)
+            try:
+                for stage in range(8):
+                    a,b=index.copy(coordinate),index.copy(right)
+                    if stage in (0,2,4,6):yield from primitive("atom_swap",a,b,None,geometry)
+                    elif stage==7:
+                        index.free(a);yield from primitive("sign",b,None,None,geometry)
+                    else:
+                        request=Request("incoming",index.copy(coordinate),negative_inverse=stage==3)
+                        yield from primitive("add",b,a,request,geometry)
+            finally:index.free(right)
+            raw.increment_in_place(coordinate)
+    finally:index.free_many(coordinate,last)
+
+
+def run(source,context,indices,parent_size,depth,program,old_directory,old_count,
+        fresh_rows,before,gap,suffix,incoming):
+    divisor=indices.literal(context.dimension)
+    columns,remainder=Unsigned(indices).divmod(parent_size,divisor)
+    indices.free_many(divisor,remainder)
+    geometry=Geometry(Plan(context.dimension,1,True,()),indices,columns,depth,0,program)
+    leading=Count.product(fresh_rows,before)
+    layout=Layout(geometry,parent_size,context.ring,context.q,leading,gap,suffix,embedded=False)
+    try:
+        return packet_engine.run(source,events(geometry,parent_size),layout,old_directory,
+                                 old_count,depth,incoming.coefficient)
+    finally:
+        layout.close();leading.close();geometry.close();indices.free(columns)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md
new file mode 100644
index 0000000000..ef9f81510d
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/NOTICE.md
@@ -0,0 +1,49 @@
+# Attribution
+
+Jose Manuel (`jmbarrancoml`) prepared the full first-range caller, gap/peel
+integration, source catalogue binding and checks with substantial OpenAI Codex
+assistance. New work uses Apache-2.0. We claim no independent human review
+or new formal-kernel verification of this package.
+
+We credit OpenAI's retained framework and Douglas Colkitt for the stream,
+interchange and tape contracts. The selected word/hosting lineage includes
+DreamingOfClouds' PR589 tuning on eumemic's PR555 word, Dugongue's PR541/548,
+rohanarun's PR542, eumemic's PR490 whole-owner argument and alephnan's PR1627
+literal reader and chronological hosting proof.
+
+The source527 contributors supplied the normal forms and weighted leaf
+factorization. commdata2338 supplied PR2160's selected good form, PR2188's
+mixed descriptor grammar, PR1379's parking boundary and PR2332's selected
+table/global-slot binding. Ross Richardson supplied PR2159's full-ring fallback
+topology and covariance. Jose Manuel's PR2157/2171/2195/2207/2234 and
+PR2310/2364/2405/2449/2501/2569 supply the selected chart, controlled stream,
+generated grammar, canonical-prefix, completed residual and source-route
+predecessors. PR2195 supplies the ring/GL hosting lift and terminal gauge
+calculation recalled in our proof. We do not claim new versions of those
+algebraic identities.
+
+We retain 25 files from PR2569 at
+`0b116cb34f27a4b064f0d8dd65549ea5705cf9c0`, including its 16 unchanged PR2501
+runtime/compiler dependencies. SOURCES.json lists their original paths,
+Git blobs and SHA256 hashes. We retain their bytes and source comments.
+We adapt PR2234's provider enumeration in catalogue.py and preserve its
+ordered request digest. Our test-only model and observers adapt predecessor
+finite expectation and origin-column patterns. The oracle module serves
+fixed-q source compilation and finite expectations; we do not use it to
+decode runtime high fields or execute payload permutations.
+
+We credit ywz65's PR2475 for conditional whole-call staging and PR2545 for its
+separate buffer-residency completion. Ross Richardson's PR2519 gives a
+separate one-buffer R439 adapter and relative-chart packet identity. We do
+not adopt those numerical workspace constants. commdata2338's PR2386/2399
+sharpen request counts and completed leaf/header substitution.
+
+We credit ywz65's completed PR2566 audit of AtomSwap/Sign cost and ownership,
+and PR2590 for the cubic radix-reconstruction term in directory setup. We
+use PR2569's corrected proof at
+`898ff36fe2cd05f733de6b26c88a4c4741b06237`; its runtime bytes match our earlier
+pin. We preserve the canonical-input hypothesis and charge returned directory
+and Count disposal outside the audited producer interval.
+
+We leave larger recursive return, numerical reserve admission and full
+multiplication transfer open. We retain the selected frontier.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py
new file mode 100644
index 0000000000..6a14feac45
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/cardinal_counts.py
@@ -0,0 +1,55 @@
+"""Separate unbounded tapes for products of arbitrary spectator cardinalities."""
+from counts import Count as RetainedCount
+from words import LEFT, ONE, RIGHT, ZERO, need
+
+
+class Count(RetainedCount):
+    def zero(self):
+        self.rewind()
+        result=self.read()==ZERO
+        self.step(1)
+        result=result and self.read()==RIGHT
+        self.rewind()
+        return result
+
+    def add(self,other):
+        source=Count(other)
+        self.rewind();source.rewind()
+        carry=0;left_done=False
+        try:
+            while True:
+                if not left_done and self.read()==RIGHT:left_done=True
+                right_done=source.read()==RIGHT
+                if left_done and right_done and not carry:break
+                a=ZERO if left_done else self.read()
+                b=ZERO if right_done else source.read()
+                need(a in (ZERO,ONE) and b in (ZERO,ONE),"binary cardinality sum")
+                total=a+b+carry
+                self.tape.write(total&1);carry=total>>1
+                self.step(1)
+                if not right_done:source.step(1)
+            self.tape.write(RIGHT)
+            self.normalize()
+        finally:source.close()
+
+    @classmethod
+    def product(cls,left,right):
+        factor,scan,result=cls(left),cls(right),cls.literal(0)
+        scan.msb()
+        try:
+            while scan.read()!=LEFT:
+                result.multiply_small(2)
+                if scan.read()==ONE:result.add(factor)
+                else:need(scan.read()==ZERO,"binary multiplier digit")
+                scan.step(-1)
+            scan.step(1)
+            return result
+        except ValueError:
+            result.close()
+            raise
+        finally:
+            factor.close();scan.close()
+
+
+def positive(value):
+    need(isinstance(value,Count) and not value.zero(),"independent positive cardinality tape")
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py
new file mode 100644
index 0000000000..0efc0575a7
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/catalogue.py
@@ -0,0 +1,268 @@
+"""Fixed selected request compilation, adapted from pinned PR2234 provider.py.
+
+Only q, rational labels and low classes enter these compilation routines.
+Runtime precision, high matrices, widths and coefficients remain on tapes.
+"""
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from fractions import Fraction as F
+from functools import cached_property, lru_cache
+from hashlib import sha256
+import importlib.util
+import json
+
+from binding import split_basis
+from low_codes import LowCodes
+import oracle
+from plan import compile_plan
+from sources import ROOT, Template, compile_specification, identity, product
+from words import need
+
+
+def canonical(value):
+    return json.dumps(value,sort_keys=True,separators=(",",":"))
+
+
+@dataclass(frozen=True)
+class Base:
+    kind: str
+    data: tuple
+    rank: int
+
+    @cached_property
+    def key(self):
+        values=[[str(x) for x in row] for row in self.data] if self.kind=="local" else self.data
+        return sha256(canonical([self.kind,self.rank,values]).encode()).hexdigest()
+
+    @lru_cache(None)
+    def matrix(self):
+        out=[[F(0)]*64 for _ in range(64)]
+        if self.kind=="local":
+            for i,row in enumerate(self.data):out[i][:8]=row
+        else:
+            need(self.kind=="idle" and len(set(self.data))==self.rank,"fixed idle base")
+            for i in self.data:out[i][i]=F(1)
+        return tuple(map(tuple,out))
+
+    @lru_cache(None)
+    def basis(self,q):
+        return split_basis(self.matrix(),self.rank,q)
+
+
+@dataclass(frozen=True)
+class Chart:
+    kind: str
+    port: int = -1
+    stage: int = -1
+    axes: tuple = ()
+
+    @property
+    def key(self):return (self.kind,self.port,self.stage,self.axes)
+
+
+@dataclass(frozen=True)
+class Request:
+    kind: str
+    stage: int
+    position: int
+    role: int
+    family: int
+    old_frame: int
+    new_frame: int
+    base: Base
+    chart: Chart
+    header_space: str
+    source_chart: object = None
+
+    def record(self):
+        return [self.kind,self.stage,self.position,self.role,self.family,
+                self.old_frame,self.new_frame,self.base.key,self.base.rank,
+                self.chart.key,self.header_space,self.source_chart.key if self.source_chart else None]
+
+
+class Catalogue:
+    dimension=64
+    replicas=32
+    families=28416
+    private=661
+    replica_stride=888
+
+    def __init__(self,q):
+        self.q=q
+        path=ROOT/"research/pr589-five-helper-hosting/verify.py"
+        spec=importlib.util.spec_from_file_location("retained_selected_node_source",path)
+        self.old=importlib.util.module_from_spec(spec);spec.loader.exec_module(self.old)
+        self.word,self.template,self.geometry=(self.old.read(p) for p in
+                                               (self.old.WORD,self.old.HOST,self.old.GEO))
+        rows=[self.old.projection([self.word["lines"][i] for i in frame]) for frame in self.word["frames"]]
+        self.projectors=[p for p,_ in rows];self.dimensions=[r for _,r in rows]
+        self.idles={event["idx"]:event for event in self.template["schedule"] if event["kind"]=="idle"}
+        self.requests=[];self.bases={};self.charts=set();self.erase_guards=[]
+        self._bind()
+        self.codes=LowCodes(q,64,len(self.requests))
+        self.identifiers={self.semantic_key(request):i for i,request in enumerate(self.requests)}
+        need(len(self.identifiers)==len(self.requests),"unique full catalogue request identifiers")
+
+    @staticmethod
+    def semantic_key(request):
+        return (request.kind,request.stage,request.role if request.kind=="IDLE" else request.position)
+
+    def base(self,a,b):
+        lo,hi=(a,b) if self.dimensions[a]<=self.dimensions[b] else (b,a)
+        value=Base("local",self.old.sub(self.projectors[hi],self.projectors[lo]),
+                   self.dimensions[hi]-self.dimensions[lo])
+        return self.bases.setdefault(value.key,value)
+
+    def pending(self,child):return tuple(self.old.pending_axes(self.idles[child]))
+
+    def owner_chart(self,call,role):
+        family,route=call["owners"][role]
+        if route[0]=="data":return Chart("data",route[2],route[1])
+        need(route[0]=="hosted","selected owner route kind")
+        _,child,offset,width=route
+        axes=self.pending(child)[offset:offset+width]
+        need(len(axes)==8,"complete selected helper support")
+        return Chart("host",family%111 if min(axes)<8 else -1,axes=axes)
+
+    @lru_cache(None)
+    def chart_matrix(self,chart):
+        out=identity(64)
+        if chart.kind=="identity":return tuple(map(tuple,out))
+        if chart.kind=="data":
+            if chart.stage==0:return tuple(map(tuple,out))
+            axes=list(range(8))+list(range(8+7*(chart.stage-1),8+7*chart.stage))
+            rho=self.geometry["ports"][chart.port]["rho15"]
+            for i,a in enumerate(axes):
+                for j,b in enumerate(axes):out[a][b]=F(rho[i][j])
+            return tuple(map(tuple,out))
+        if chart.kind=="family" or (chart.kind=="host" and chart.port>=0):
+            port=self.geometry["ports"][chart.port]
+            for i in range(8):out[i][:8]=[F(port["q"][i],2)]+list(map(F,port["complement_columns"][i]))
+        if chart.kind=="host":
+            domain,support=set(range(8)),set(chart.axes);permutation=list(range(64))
+            for a,b in zip(sorted(domain-support),sorted(support-domain)):
+                permutation[a],permutation[b]=b,a
+            need(set(permutation[:8])==support,"selected owner support completion")
+            out=[[row[permutation[j]] for j in range(64)] for row in out]
+        else:need(chart.kind=="family","known fixed chart")
+        return tuple(map(tuple,out))
+
+    def _append(self,request):
+        need(0<request.base.rank<=42,"positive selected paid residual")
+        self.requests.append(request);self.charts.add(request.chart)
+        if request.source_chart:self.charts.add(request.source_chart)
+
+    def _bind(self):
+        t=self.template
+        need((t["m"],t["stages"],t["replicas"],t["live"])==(64,9,32,28416),"selected node dimensions")
+        for stage in range(9):
+            call=t["calls"][32*stage]
+            for replica in range(32):
+                other=t["calls"][32*stage+replica]
+                need((other["stage"],other["replica"],other["orientation"],other["local_hash"])
+                     ==(stage,replica,call["orientation"],call["local_hash"]),"replica literal binding")
+                need(len(other["owners"])==len(call["owners"])==661 and
+                     all(route==r0 and family==f0+888*replica
+                         for (family,route),(f0,r0) in zip(other["owners"],call["owners"])),
+                     "replica owner symmetry")
+            opened=None
+            for position,event in enumerate(t["local_programs"][call["orientation"]]):
+                op,role=event[:2]
+                if op==0:
+                    _,_,a,b,rank,_=event;base=self.base(a,b)
+                    need(base.rank==rank and opened is None,"positive MOVE outside private lifetime")
+                    self._append(Request("MOVE",stage,position,role,call["owners"][role][0],a,b,
+                                         base,self.owner_chart(call,role),"owner"))
+                elif op==2:
+                    _,_,temporary,a,b,rank,_=event;base=self.base(a,b)
+                    need(temporary==661 and opened is None and base.rank==rank==7,"fresh selected COPY")
+                    opened=Request("COPY",stage,position,role,t["live"],a,b,base,Chart("identity"),
+                                   "common",self.owner_chart(call,role))
+                    self._append(opened)
+                elif op==3:
+                    _,_,temporary,a,b,_,_=event
+                    need(opened is not None and opened.role==role and temporary==661 and
+                         opened.base==self.base(a,b),"transported ERASE source binding")
+                    self.erase_guards.append((stage,position,opened.position,role,opened.base.key));opened=None
+                else:need(op==1,"selected local opcode")
+            need(opened is None,"closed local private lifetime")
+        occupied=defaultdict(set)
+        for child,copy,offset,width,_stage,_helper in t["hosting"]["slots"]:
+            axes=self.pending(child)[offset:offset+width]
+            need(not occupied[child,copy].intersection(axes),"disjoint selected hosted slots")
+            occupied[child,copy].update(axes)
+        for child,event in self.idles.items():
+            pending=set(self.pending(child));histogram=Counter()
+            for copy in range(222):
+                axes=tuple(sorted(pending-occupied[child,copy]));rank=len(axes);histogram[rank]+=1
+                if not rank:continue
+                base=Base("idle",axes,rank);self.bases.setdefault(base.key,base)
+                self._append(Request("IDLE",child,child,copy,event["pair"]*222+copy,
+                                     event["source_level"],event["target_level"],base,
+                                     Chart("family",copy%111),"owner"))
+            if str(child) in t["hosting"]["remainders"]:
+                need({str(rank):count for rank,count in histogram.items()}==t["hosting"]["remainders"][str(child)],
+                     "actual idle remainder histogram")
+            else:need(histogram==Counter({0:222}),"zero idle emits no residual")
+        self.profile=Counter()
+        for request in self.requests:self.profile[request.base.rank]+=32
+        expected={int(k):v for k,v in self.old.read("research/e8-bit-p111-tuned/tune/EXPECTED.json")["nine"]["profile"].items()}
+        need(dict(self.profile)==expected and sum(self.profile.values())==904896,"complete selected paid catalogue")
+        need(self.receipt()["binding_sha256"]=="f5a4fb124709adc4b56376a3146e3609e91c0f4d3ed1931a61785a5d99bf8ee7",
+             "exact ordered PR2234 request records")
+
+    def receipt(self):
+        digest=sha256()
+        for request in self.requests:digest.update((canonical(request.record())+"\n").encode())
+        return {"canonical_requests":len(self.requests),"replicas":32,"full_paid_requests":sum(self.profile.values()),
+                "request_kinds":dict(Counter(request.kind for request in self.requests)),
+                "base_labels":len(self.bases),"chart_labels":len(self.charts),
+                "rank_histogram":dict(sorted(self.profile.items())),"canonical_ERASE_guards":len(self.erase_guards),
+                "binding_sha256":digest.hexdigest()}
+
+    @lru_cache(None)
+    def template_for(self,request_id,common):
+        request=self.requests[request_id]
+        need(common or request.kind!="COPY","COPY uses a common header")
+        chart=tuple(map(tuple,identity(64))) if common else self.chart_matrix(request.chart)
+        basis=request.base.basis(self.q)
+        preparation=basis if common else tuple(map(tuple,product(chart,basis)))
+        record=tuple(request.record())+("common-after-route" if common else "native-owner",)
+        return Template(self.q,request.base.rank,record,request.base.matrix(),chart,preparation)
+
+    def identifier(self,kind,stage,position):return self.identifiers[kind,stage,position]
+
+    def low_classes(self):
+        for ordinal in range(self.codes.size):yield self.codes.unrank(ordinal)
+
+
+class Specifications(dict):
+    """Lazy fixed-q table, shared by current and frozen field codes."""
+    def __init__(self,catalogue):
+        super().__init__();self.catalogue=catalogue;self.plans={}
+
+    def __contains__(self,code):
+        codes=self.catalogue.codes
+        if not isinstance(code,int) or not 0<=code<codes.limit:return False
+        tag=code//codes.size
+        return bool(tag&1) or self.catalogue.requests[tag//2].kind!="COPY"
+
+    def __missing__(self,code):
+        need(code in self,"admitted fixed source code")
+        request,common,low=self.catalogue.codes.decode(code)
+        result=compile_specification(code,self.catalogue.template_for(request,common),low)
+        self[code]=result
+        return result
+
+    def bind(self,request_id,common,low):
+        return self[self.catalogue.codes.encode(request_id,common,low)]
+
+    def plan(self,code):
+        if code in self.plans:return self.plans[code]
+        spec=self[code];q=self.catalogue.q
+        header=oracle.multiply(spec.low,oracle.reduce_rational(spec.template.preparation,q),q)
+        projector=oracle.multiply([row[:spec.template.rank] for row in header],
+                                  oracle.inverse(header,q)[:spec.template.rank],q)
+        result=compile_plan(projector,spec.template.rank,q,spec.good)
+        self.plans[code]=result
+        return result
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py
new file mode 100644
index 0000000000..4f6ac09bff
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/control.py
@@ -0,0 +1,50 @@
+"""Finite literal-frame controller shared by execution and full-source checks."""
+from words import need
+
+
+class LocalState:
+    def __init__(self,call):
+        self.call=call
+        self.private=len(call.owners)
+        self.frames=list(call.start)+[-1]
+        self.versions=[0]*(self.private+1)
+        self.opened=None
+
+    def accept(self,position):
+        event=self.call.events[position]
+        op,role=event[:2]
+        private,frames,versions=self.private,self.frames,self.versions
+        need(0<=role<private,"live local destination/source role")
+        if op==0:
+            _,_,old,new,_rank,flag=event
+            need(self.opened is None and frames[role]==old and flag==int(self.call.reverse),
+                 "MOVE frame and lifetime")
+            need(self.call.requests[position] is not None,"source-bound MOVE request")
+            frames[role]=new;versions[role]+=1
+        elif op==1:
+            _,_,source,coefficient,frame,flag=event
+            need(coefficient in (-1,1) and flag==int(self.call.reverse) and role!=source and
+                 0<=source<=private and frames[role]==frames[source]==frame and
+                 (source!=private or self.opened is not None),"aligned framed local XOR")
+            need(self.opened is None or role!=self.opened[0],"copied source remains unchanged")
+            versions[role]+=1
+        elif op==2:
+            _,_,temporary,old,new,_rank,flag=event
+            need(temporary==private and self.opened is None and frames[role]==old and
+                 frames[private]==-1 and flag==int(self.call.reverse),"fresh transported COPY interval")
+            need(self.call.requests[position] is not None,"source-bound COPY request")
+            frames[private]=new;versions[private]+=1
+            self.opened=(role,versions[role],versions[private],old,new,position)
+        else:
+            need(op==3 and self.opened is not None,"matching private ERASE")
+            _,_,temporary,old,new,rank_field,flag=event
+            need(temporary==private and flag==int(self.call.reverse) and
+                 rank_field==(7 if self.call.reverse else 0) and
+                 self.opened[:5]==(role,versions[role],versions[private],old,new) and
+                 frames[role]==old and frames[private]==new,"transported source lifetime guard")
+            frames[private]=-1;self.opened=None
+        return op,role
+
+    def finish(self):
+        need(self.opened is None and tuple(self.frames[:-1])==self.call.end and self.frames[-1]==-1,
+             "complete local endpoint and private closure")
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py
new file mode 100644
index 0000000000..aa3a327604
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/fresh_rows.py
@@ -0,0 +1,68 @@
+"""Decode the caller's actual fresh row range and restore its original order."""
+from cardinal_counts import Count, positive
+from cardinality import radix_power
+from records import Tape
+from routes import copy_rows
+from stream import Counter
+from words import BLANK, need
+
+
+def quotient(fresh,context,families):
+    positive(fresh)
+    unused=Count(fresh)
+    try:
+        need(unused.divide_small(families)==0,"complete fresh family factor")
+        need(unused.divide_small(context.codes.size)==0,"complete fresh GL low factor")
+        for _ in range(context.dimension*context.dimension):
+            first=True
+            for _ in radix_power(context.ring,context.q):
+                if first:first=False
+                else:need(unused.divide_small(context.q)==0,"complete fresh high factor")
+        need(not unused.zero(),"nonempty unused row quotient")
+        return unused
+    except ValueError:
+        unused.close()
+        raise
+
+
+def family_rows(context):
+    result=Count(context.highs)
+    result.multiply_small(context.codes.size)
+    return result
+
+
+def split(source,context,families,old_count,fibre):
+    packets={family:Tape() for family in range(families)}
+    rows,outer=family_rows(context),Counter(old_count)
+    source.rewind()
+    try:
+        need(not outer.finished,"positive old physical prefix range")
+        while not outer.finished:
+            for family in range(families):copy_rows(source,packets[family],rows,fibre)
+            outer.decrement()
+        need(source.read()==BLANK,"complete row split")
+        for tape in packets.values():tape.rewind()
+        return packets
+    except ValueError:
+        for tape in packets.values():tape.clear()
+        raise
+    finally:rows.close();outer.close();source.rewind()
+
+
+def merge(packets,context,families,old_count,fibre):
+    need(set(packets)==set(range(families)),"complete live family inventory")
+    rows,outer,output=family_rows(context),Counter(old_count),Tape()
+    for tape in packets.values():tape.rewind()
+    try:
+        while not outer.finished:
+            for family in range(families):copy_rows(packets[family],output,rows,fibre)
+            outer.decrement()
+        need(all(tape.read()==BLANK for tape in packets.values()),"complete restored family rows")
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        rows.close();outer.close()
+        for tape in packets.values():tape.rewind()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py
new file mode 100644
index 0000000000..39a2916c20
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/topology.py
@@ -0,0 +1,91 @@
+"""Fixed chronological selected calls, owners and global frame boundaries."""
+from dataclasses import dataclass
+from functools import lru_cache
+from hashlib import sha256
+
+from catalogue import canonical
+from words import need
+
+
+@dataclass(frozen=True)
+class Owner:
+    family: int
+    chart: object
+
+
+@dataclass(frozen=True)
+class Call:
+    stage: int
+    replica: int
+    owners: tuple
+    start: tuple
+    end: tuple
+    events: tuple
+    requests: tuple
+    reverse: bool
+
+
+class SelectedTopology:
+    replicas=32
+    pairs=4
+    ports=111
+    families=28416
+    stride=888
+
+    def __init__(self,catalogue):
+        self.catalogue=catalogue
+        self.schedule=tuple(catalogue.template["schedule"])
+        self.idles={i:tuple(j for j,r in enumerate(catalogue.requests) if r.kind=="IDLE" and r.stage==i)
+                    for i in range(10)}
+        expected="Each recipe phase: replicas then all cover classes; finish every local invocation before the next."
+        need(catalogue.template["loop_order"]==expected,"source-selected loop order")
+        self._validate_global()
+
+    def _validate_global(self):
+        levels=[-1]*4
+        for position,event in enumerate(self.schedule):
+            kind=event["kind"]
+            if kind=="local_cover_sweep":
+                need(levels[event["pair"]]==event["stage"]-1,"local call enters its data level")
+                levels[event["pair"]]=event["stage"]
+            elif kind=="idle":
+                need(levels[event["pair"]]==event["source_level"],"idle enters its native level")
+                levels[event["pair"]]=event["target_level"]
+                need(bool(self.idles[event["idx"]])==(event["rank"]>0),"zero idle source boundary")
+            elif kind=="bridge":
+                need(event["coefficient"] in (-1,1) and event["dst"]!=event["src"] and
+                     levels[event["dst"]]==levels[event["src"]],"native bridge frame alignment")
+            else:
+                need(kind=="exchange" and position==len(self.schedule)-1 and levels==[8]*4,
+                     "terminal exchange frame boundary")
+
+    @lru_cache(None)
+    def recipe(self,stage):
+        source=self.catalogue.template["calls"][32*stage]
+        reverse=source["orientation"]=="reverse"
+        events=tuple(map(tuple,self.catalogue.template["local_programs"][source["orientation"]]))
+        identifiers=tuple(self.catalogue.identifier("MOVE" if event[0]==0 else "COPY",stage,position)
+                          if event[0] in (0,2) else None for position,event in enumerate(events))
+        word=self.catalogue.word
+        start=tuple(word["final"] if reverse else word["start"])
+        end=tuple(word["start"] if reverse else word["final"])
+        return events,identifiers,start,end,reverse
+
+    @lru_cache(None)
+    def call(self,stage,replica):
+        source=self.catalogue.template["calls"][32*stage+replica]
+        events,identifiers,start,end,reverse=self.recipe(stage)
+        owners=tuple(Owner(family,self.catalogue.owner_chart(source,role))
+                     for role,(family,_route) in enumerate(source["owners"]))
+        need(len(owners)==len(start)==len(end)==661,"complete selected staged roles")
+        return Call(stage,replica,owners,start,end,events,identifiers,reverse)
+
+    def matrix(self,chart):return self.catalogue.chart_matrix(chart)
+
+    def idle_family(self,request_id,replica):
+        request=self.catalogue.requests[request_id]
+        need(request.kind=="IDLE","native idle family")
+        return request.family+self.stride*replica
+
+    def family(self,replica,pair,side,port):
+        return self.stride*replica+(2*pair+side)*self.ports+port
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py
new file mode 100644
index 0000000000..21a5a21220
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/binding.py
@@ -0,0 +1,102 @@
+"""Fixed selected labels and explicit owner-to-common numerical specifications."""
+from dataclasses import dataclass, replace
+from fractions import Fraction as F
+from hashlib import sha256
+import importlib.util
+import json
+
+from routes import compile_route
+from sources import ROOT, Template, compile_specification, identity, independent_columns, product
+from words import need
+
+
+def split_basis(base, rank, q):
+    size = len(base)
+    complement = [[F(i == j)-base[i][j] for j in range(size)] for i in range(size)]
+    image, kernel = independent_columns(base, q), independent_columns(complement, q)
+    need((len(image), len(kernel)) == (rank, size-rank), "source projector rank")
+    basis = [[base[i][j] for j in image]+[complement[i][j] for j in kernel] for i in range(size)]
+    projected = [[basis[i][j] if j < rank else F(0) for j in range(size)] for i in range(size)]
+    need(product(base, basis) == projected and len(independent_columns(basis, q)) == size,
+         "fixed source split basis")
+    return tuple(map(tuple, basis))
+
+
+def common_template(template):
+    basis = split_basis(template.base, template.rank, template.q)
+    need(tuple(map(tuple, product(template.chart, basis))) == template.preparation,
+         "original owner preparation provenance")
+    return replace(template, chart=tuple(map(tuple, identity(len(template.base)))), preparation=basis,
+                   record=template.record+("common-after-owner-route",))
+
+
+def owner_common(template, owner_low, request, vocabulary):
+    route = compile_route(owner_low, template.chart, vocabulary)
+    owner_code = vocabulary.encode(request, False, route.low)
+    common_code = vocabulary.encode(request, True, route.target_low)
+    owner = compile_specification(owner_code, template, route.low)
+    common = compile_specification(common_code, common_template(template), route.target_low)
+    need(owner.good == common.good, "same physical low projector branch")
+    return owner, common, route
+
+
+@dataclass(frozen=True)
+class Episode:
+    source: int
+    targets: tuple
+    private: int
+    records: tuple
+    sha256: str
+    source_family: int
+    target_families: tuple
+    chart: tuple
+    template: object
+    request: int = 1
+
+
+def selected_episode(q=3):
+    path = ROOT / "research/pr589-five-helper-hosting/verify.py"
+    spec = importlib.util.spec_from_file_location("selected_source_packet_labels", path)
+    old = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(old)
+    word, host = old.read(old.WORD), old.read(old.HOST)
+    call = host["calls"][0]
+    need(call["orientation"] == "forward", "selected episode orientation")
+    records = host["local_programs"]["forward"][21881:21938]
+    digest = sha256(json.dumps(records, separators=(",", ":")).encode()).hexdigest()
+    need(digest == "e622fdcb880ed9e39962929f64272937cc4ccdd6bafd7def1dc1d7a68512b35e",
+         "selected literal COPY511 episode")
+    need(records[0] == [2,473,661,511,0,7,0] and records[-1] == [3,473,661,511,0,0,0],
+         "exact transported COPY and ERASE")
+    targets = tuple(record[1] for record in records[1:-1])
+    need(len(targets) == len(set(targets)) == 55 and
+         all(record == [1, target, 661, 1, 0, 0] and target not in (473,661)
+             for target, record in zip(targets, records[1:-1])), "immutable COPY source and private value")
+    family, route = call["owners"][473]
+    need(family == 527 and route == ["hosted",2,16,8], "selected COPY source owner")
+    idle = next(event for event in host["schedule"] if event["kind"] == "idle" and event["idx"] == 2)
+    support = old.pending_axes(idle)[16:24]
+    need(support == list(range(17,25)), "selected source support")
+    permutation = list(range(64))
+    for i, j in enumerate(support):
+        permutation[i], permutation[j] = j, i
+    chart = tuple(tuple(F(permutation[j] == i) for j in range(64)) for i in range(64))
+    target_families = tuple(call["owners"][target][0] for target in targets)
+    need(target_families == targets and family not in target_families and
+         all(call["owners"][target][1] == ["data",0,target % 111] for target in targets),
+         "disjoint stage-zero target families")
+    local, rank = old.projection([word["lines"][i] for i in word["frames"][511]])
+    need(rank == 7, "selected COPY511 rank")
+    key = sha256(json.dumps(["local", rank, [[str(x) for x in row] for row in local]],
+                            sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    need(key == "f256295f6139080a4b55eeb08cd459385c08060fbee5b1cf318379d6ee9b5cbf",
+         "selected COPY511 projector label")
+    base = [[F(0) for _ in range(64)] for _ in range(64)]
+    for i in range(8):
+        base[i][:8] = local[i]
+    basis = split_basis(base, rank, q)
+    record = ("COPY",0,21881,473,28416,511,0,key,7,"common",tuple(support),-1)
+    template = Template(q, rank, record, tuple(map(tuple, base)),
+                        tuple(map(tuple, identity(64))), basis)
+    return Episode(473, targets, 661, tuple(map(tuple, records)), digest, family,
+                   target_families, chart, template)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py
new file mode 100644
index 0000000000..4d1fd4abb0
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/bitstream.py
@@ -0,0 +1,160 @@
+"""Complete atom swaps and address signs, using fixed-radix digit passes."""
+from cardinality import Natural, digit_suffix, radix_power
+from records import Tape
+from stream import Counter, copy_blocks, one_bit_suffix, positive_extent
+from words import BLANK, ONE, ZERO, need
+
+
+def unobserved(_counter):
+    pass
+
+
+def copy_bits(source, target, length):
+    if one_bit_suffix(length):
+        bit = source.read()
+        need(bit in (ZERO, ONE), "opaque single payload bit")
+        target.append(bit)
+        source.step(1)
+        return
+    count = Counter(length)
+    while not count.finished:
+        bit = source.read()
+        need(bit in (ZERO, ONE), "opaque stream bit")
+        target.append(bit)
+        source.step(1)
+        count.decrement()
+    count.close()
+
+
+def digit_swap(source, q, before, middle, suffix):
+    buckets = [[Tape() for _ in range(q)] for _ in range(q)]
+    outer = Counter(before)
+    while not outer.finished:
+        for a in range(q):
+            between = Counter(middle)
+            while not between.finished:
+                for b in range(q):
+                    copy_bits(source, buckets[a][b], suffix)
+                between.decrement()
+            between.close()
+        outer.decrement()
+    outer.close()
+    need(source.read() == BLANK, "complete digit-swap input")
+    source.rewind()
+    for row in buckets:
+        for tape in row:
+            tape.rewind()
+    out, outer = Tape(), Counter(before)
+    while not outer.finished:
+        for a in range(q):
+            between = Counter(middle)
+            while not between.finished:
+                for b in range(q):
+                    copy_bits(buckets[b][a], out, suffix)
+                between.decrement()
+            between.close()
+        outer.decrement()
+    outer.close()
+    for row in buckets:
+        for tape in row:
+            need(tape.read() == BLANK, "complete transposed digit bucket")
+            tape.clear()
+    out.rewind()
+    return out
+
+
+def digit_complement(source, q, before, suffix):
+    buckets, outer = [Tape() for _ in range(q)], Counter(before)
+    while not outer.finished:
+        for digit in range(q):
+            copy_bits(source, buckets[digit], suffix)
+        outer.decrement()
+    outer.close()
+    need(source.read() == BLANK, "complete digit-complement input")
+    source.rewind()
+    for tape in buckets:
+        tape.rewind()
+    out, outer = Tape(), Counter(before)
+    while not outer.finished:
+        for digit in range(q):
+            copy_bits(buckets[q-1-digit], out, suffix)
+        outer.decrement()
+    outer.close()
+    for tape in buckets:
+        need(tape.read() == BLANK, "complete complemented digit bucket")
+        tape.clear()
+    out.rewind()
+    return out
+
+
+def atom_swap(source, ring, q, before, middle, suffix):
+    for value in (before, middle, suffix):
+        positive_extent(value)
+    pre, gap, tail = Natural(before), Natural(middle), Natural(suffix)
+    digit_suffix(gap, ring, q)
+    digit_suffix(tail, ring, q)
+    current, first = source, True
+    try:
+        for _ in radix_power(ring, q):
+            if not first:
+                pre.multiply_small(q)
+                need(tail.divide_small(q) == 0, "exact next digit suffix")
+            following = digit_swap(current, q, pre, gap, tail)
+            if current is not source:
+                current.clear()
+            current, first = following, False
+        return current
+    finally:
+        pre.close()
+        gap.close()
+        tail.close()
+
+
+def translate_one(source, ring, before, suffix):
+    leading = ring.raw.subtract_exact(ring.modulus, ring.one)
+    left, right, output = Tape(), Tape(), Tape()
+    outer = Counter(before)
+    while not outer.finished:
+        copy_blocks(source, left, leading, suffix, unobserved)
+        copy_blocks(source, right, ring.one, suffix, unobserved)
+        outer.decrement()
+    outer.close()
+    need(source.read() == BLANK, "complete translation input")
+    source.rewind()
+    left.rewind()
+    right.rewind()
+    outer = Counter(before)
+    while not outer.finished:
+        copy_blocks(right, output, ring.one, suffix, unobserved)
+        copy_blocks(left, output, leading, suffix, unobserved)
+        outer.decrement()
+    outer.close()
+    need(left.read() == right.read() == BLANK, "complete translation buckets")
+    left.clear()
+    right.clear()
+    ring.arena.free(leading)
+    output.rewind()
+    return output
+
+
+def sign_address(source, ring, q, before, suffix):
+    for value in (before, suffix):
+        positive_extent(value)
+    pre, tail = Natural(before), Natural(suffix)
+    digit_suffix(tail, ring, q)
+    current, first = source, True
+    try:
+        for _ in radix_power(ring, q):
+            if not first:
+                pre.multiply_small(q)
+                need(tail.divide_small(q) == 0, "exact complemented suffix")
+            following = digit_complement(current, q, pre, tail)
+            if current is not source:
+                current.clear()
+            current, first = following, False
+        result = translate_one(current, ring, before, suffix)
+        current.clear()
+        return result
+    finally:
+        pre.close()
+        tail.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py
new file mode 100644
index 0000000000..b8ba857e32
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/cardinality.py
@@ -0,0 +1,136 @@
+"""Canonical unbounded binary cardinalities on one sequential tape each."""
+from records import Tape
+from stream import Counter
+from words import BLANK, LEFT, ONE, RIGHT, ZERO, need
+
+
+class Natural:
+    def __init__(self, source=None):
+        self.tape = Tape()
+        if source is None:
+            self.tape.append(ONE)
+        else:
+            source.rewind()
+            while source.read() != RIGHT:
+                bit = source.read()
+                need(bit in (ZERO, ONE), "binary cardinality input")
+                self.tape.append(bit)
+                source.step(1)
+            source.rewind()
+        self.tape.append(RIGHT)
+        self.normalize()
+
+    def read(self):
+        return self.tape.read()
+
+    def step(self, direction):
+        self.tape.step(direction)
+
+    def rewind(self):
+        self.tape.rewind()
+
+    def msb(self):
+        self.rewind()
+        while self.read() != RIGHT:
+            self.step(1)
+        self.step(-1)
+
+    def normalize(self):
+        self.rewind()
+        while self.read() != RIGHT:
+            self.step(1)
+        self.step(-1)
+        while self.read() == ZERO:
+            self.tape.write(RIGHT)
+            self.step(1)
+            self.tape.write(BLANK)
+            self.step(-1)
+            self.step(-1)
+        if self.read() == LEFT:
+            self.step(1)
+            self.tape.write(ZERO)
+            self.step(1)
+            self.tape.write(RIGHT)
+        self.rewind()
+
+    def multiply_small(self, constant):
+        """The multiplier and bounded carry belong to fixed finite control."""
+        need(constant >= 2, "fixed cardinality multiplier")
+        carry = 0
+        while self.read() != RIGHT:
+            total = constant*self.read()+carry
+            self.tape.write(total & 1)
+            carry = total >> 1
+            self.step(1)
+        while carry:
+            self.tape.write(carry & 1)
+            carry >>= 1
+            self.step(1)
+        self.tape.write(RIGHT)
+        self.rewind()
+
+    def divide_small(self, constant):
+        self.msb()
+        remainder = 0
+        while self.read() != LEFT:
+            remainder = 2*remainder+self.read()
+            if remainder >= constant:
+                self.tape.write(ONE)
+                remainder -= constant
+            else:
+                self.tape.write(ZERO)
+            self.step(-1)
+        self.step(1)
+        self.normalize()
+        return remainder
+
+    def marginal(self):
+        """Copy with one high zero bit for the retained ADD input contract."""
+        result = Natural(self)
+        result.msb()
+        result.step(1)
+        result.tape.write(ZERO)
+        result.step(1)
+        result.tape.write(RIGHT)
+        result.rewind()
+        return result
+
+    def close(self):
+        self.tape.clear()
+
+
+def radix_power(ring, q):
+    """Yield once per radix-q digit of M=q^w, without decoding w."""
+    arena = ring.arena
+    divisor, power = arena.literal(q), arena.copy(ring.modulus)
+    try:
+        while ring.raw.compare(power, ring.one) > 0:
+            quotient, remainder = ring.raw.divmod(power, divisor)
+            need(remainder.zero() and not quotient.zero(), "cardinality prime-power context")
+            arena.free_many(power, remainder)
+            power = quotient
+            yield
+        need(ring.raw.compare(power, ring.one) == 0, "complete radix exponent")
+    finally:
+        arena.free_many(divisor, power)
+
+
+def multiply_atom_power(value, exponent, ring, q):
+    count = Counter(exponent)
+    try:
+        while not count.finished:
+            for _ in radix_power(ring, q):
+                value.multiply_small(q)
+            count.decrement()
+    finally:
+        count.close()
+
+
+def digit_suffix(value, ring, q):
+    """Multiply by q^(w-1), preserving an arbitrary spectator factor."""
+    first = True
+    for _ in radix_power(ring, q):
+        if first:
+            first = False
+        else:
+            value.multiply_small(q)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py
new file mode 100644
index 0000000000..ce4935f838
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/children.py
@@ -0,0 +1,84 @@
+"""Serialized child extensions on the same raw-prefix field band."""
+from controller import Callback
+from records import BLANK, FINITE_BITS, RECORD_END, ROOT, STEP, Program, append_finite, append_word
+from words import need
+
+
+def extend(incoming, request):
+    parent = incoming.program
+    index, residue = incoming.index, incoming.residue
+    need(request.child_kind in ("good", "pair", "unit"), "serialized child kind")
+    kind = {"good": 0, "pair": 1, "unit": 2}[request.child_kind]
+    specification = incoming.specifications[incoming.current_code]
+    rank = specification.template.rank
+    f, remainder = incoming.raw.divmod(incoming.final_size, incoming.sixty_four)
+    index.free(remainder)
+    if kind == 0:
+        size = incoming.raw.times_small(f, rank)
+    elif request.half:
+        need(kind == 2, "only orientation unit children halve")
+        size, remainder = incoming.raw.divmod(f, incoming.two_index)
+        index.free(remainder)
+    else:
+        size = index.copy(f)
+    index.free(f)
+    need(not size.zero() and incoming.raw.compare(request.coordinate, size) < 0,
+         "requested completed-child coordinate")
+    new_depth = incoming.plus(incoming.depth, incoming.one_index)
+    out = Program(index, residue, parent.code_bits)
+    out.tape.append(ROOT)
+    for word in (incoming.root_size, incoming.root_unit, new_depth):
+        append_word(out.tape, word)
+    out.tape.append(RECORD_END)
+    parent.tape.rewind()
+    while parent.tape.read() != RECORD_END:
+        parent.tape.step(1)
+    parent.tape.step(1)
+    while parent.tape.read() != BLANK:
+        out.tape.append(parent.tape.read())
+        parent.tape.step(1)
+    parent.tape.rewind()
+    out.tape.append(STEP)
+    metadata = (kind, incoming.current_code, rank, request.field, int(request.reverse), int(request.half))
+    for position, value in enumerate(metadata):
+        append_finite(out.tape, value, parent.code_bits if position == 1 else FINITE_BITS)
+    append_word(out.tape, incoming.final_size)
+    append_word(out.tape, size)
+    out.tape.append(RECORD_END)
+    out.tape.rewind()
+    index.free_many(size, new_depth)
+    return out
+
+
+def coefficient(ring, index, program, fields, specifications, current_code, request):
+    """Evaluate an actual appended leaf program; no fresh current field exists."""
+    parent, leaf, extended = None, None, None
+    protected_residues, protected_indices = frozenset(ring.arena.live), frozenset(index.live)
+    try:
+        parent = Callback(ring, index, program, fields, specifications, current_code, allow_fallback=True)
+        extended = extend(parent, request)
+        leaf = Callback(ring, index, extended, fields, specifications, current_code,
+                        allow_fallback=True, leaf=True)
+        value = leaf.weight(request.coordinate)
+        if request.negative_inverse:
+            inverse = ring.inverse(value)
+            need(inverse is not None, "serialized child weight unit")
+            opposite = ring.negate(inverse)
+            ring.arena.free_many(value, inverse)
+            value = opposite
+        leaf.close()
+        parent.close()
+        extended.tape.clear()
+        return value
+    except ValueError:
+        if leaf is not None:
+            leaf.abort()
+        if parent is not None:
+            parent.abort()
+        if extended is not None:
+            extended.tape.clear()
+        ring.arena.rollback(protected_residues)
+        index.rollback(protected_indices)
+        program.tape.rewind()
+        fields.tape.rewind()
+        raise
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py
new file mode 100644
index 0000000000..c631a9e77f
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/controller.py
@@ -0,0 +1,305 @@
+"""Encoded selected coefficient/offset callback, including descriptor indices.
+
+Runtime residues, extents, coordinates and generation levels remain words.
+Only finite operation/source/rank/row labels enter native control. The loop
+refines the retained PR2310/2332 grammar and PR2405 raw-prefix interface.
+"""
+from matrices import Matrices
+from records import BLANK, CONSTANT, MULTIPLY, PAIR, RETURN, VALUE, Stack, seek_record
+from words import LEFT, ONE, RIGHT, ZERO, Unsigned, need
+
+GOOD_KIND, PAIR_KIND, UNIT_KIND = range(3)
+
+
+def finite_word(word, limit):
+    """Decode only a provably finite row/pivot label, not a variable index."""
+    need(0 < limit <= 128, "finite row-label range")
+    word.msb()
+    state = 0
+    while word.read() != LEFT:
+        bit = word.read()
+        need(bit in (ZERO, ONE), "finite-selector bit")
+        state = (state << 1) | bit
+        need(state < limit, "finite-selector extent")
+        word.step(-1)
+    word.step(1)
+    return state
+
+
+class Callback:
+    def __init__(self, ring, index_arena, program, fields, specifications, current_code,
+                 allow_fallback=False, leaf=False):
+        self.ring, self.residue = ring, ring.arena
+        self.index, self.raw = index_arena, Unsigned(index_arena)
+        self.program, self.fields, self.specifications = program, fields, specifications
+        self.current_code = current_code
+        self.leaf = leaf
+        self.protected_residues, self.protected_indices = frozenset(self.residue.live), frozenset(self.index.live)
+        need(current_code in specifications and (allow_fallback or specifications[current_code].good),
+             "selected good current site")
+        need(program.code_bits == fields.code_bits and
+             all(code == spec.code and 0 <= code < 1 << program.code_bits for code, spec in specifications.items()),
+             "one compiled source-code vocabulary")
+        self.q = specifications[current_code].template.q
+        need(all(spec.template.q == self.q for spec in specifications.values()), "one fixed source prime")
+        self.index.template.rewind()
+        large_enough = True
+        for _ in range(8):
+            if self.index.template.read() == RIGHT:
+                large_enough = False
+                break
+            self.index.template.step(1)
+        self.index.template.rewind()
+        need(large_enough, "internal-site index context has eight bits")
+        self.one_index, self.sixty_four = self.index.literal(1), self.index.literal(64)
+        self.two_index = self.index.literal(2)
+        self.matrices = Matrices(ring)
+        self.pending, self.values = Stack(index_arena, self.residue), Stack(index_arena, self.residue)
+        self.prepared_codes = set()  # Bounded finite-vocabulary checker observation.
+        try:
+            self._prime_power_context()
+            self._validate_program()
+        except ValueError:
+            self.abort()
+            raise
+
+    def plus(self, a, b):
+        value, carry = self.raw.add(a, b)
+        need(not carry, "binary index margin")
+        return value
+
+    def _prime_power_context(self):
+        qword = self.residue.literal(self.q)  # Fixed machine prime, not a runtime residue.
+        self.high_cap, remainder = self.ring.raw.divmod(self.ring.modulus, qword)
+        need(remainder.zero() and not self.high_cap.zero(), "positive prime-power field cap")
+        self.residue.free(remainder)
+        test = self.residue.copy(self.high_cap)
+        while self.ring.raw.compare(test, self.ring.one) > 0:
+            quotient, remainder = self.ring.raw.divmod(test, qword)
+            need(remainder.zero(), "modulus is a power of the fixed prime")
+            self.residue.free_many(test, remainder)
+            test = quotient
+        need(self.ring.raw.compare(test, self.ring.one) == 0, "complete prime-power reduction")
+        self.residue.free_many(test, qword)
+
+    def step(self, level):
+        metadata, parent, child = self.program.step(level)
+        kind, code, rank, field, reverse, half = metadata
+        need(kind in (GOOD_KIND, PAIR_KIND, UNIT_KIND) and code in self.specifications,
+             "selected finite step/source")
+        spec = self.specifications[code]
+        need(rank == spec.template.rank and 1 <= rank <= 42, "actual selected rank")
+        need((kind == GOOD_KIND) == spec.good, "actual low-class branch")
+        need(reverse in (0, 1) and half in (0, 1), "finite step flags")
+        need(kind == UNIT_KIND or not half, "halving only at unit reset")
+        need((kind == PAIR_KIND and field < 127 and reverse == (field >= 64)) or
+             (kind != PAIR_KIND and field == 0 and reverse == 0), "physical pair field and reversal")
+        f, remainder = self.raw.divmod(parent, self.sixty_four)
+        self.index.free(remainder)
+        need(not f.zero(), "internal parent extent")
+        if kind == GOOD_KIND:
+            expected = self.raw.times_small(f, rank)
+        elif half:
+            expected, remainder = self.raw.divmod(f, self.two_index)
+            self.index.free(remainder)
+        else:
+            expected = self.index.copy(f)
+        need(not child.zero() and self.raw.compare(child, expected) == 0 and self.raw.compare(child, parent) < 0,
+             "exact proper generated child extent")
+        self.index.free(expected)
+        return metadata, parent, child, f
+
+    def _validate_program(self):
+        self.root_size, self.root_unit, self.depth = self.program.root()
+        self.root_size.msb()
+        top = self.root_size.read()
+        self.root_size.step(-1)
+        significant = self.root_size.read()
+        self.root_size.rewind()
+        need(top == ZERO and significant == ONE, "canonical root-index word extent")
+        need(self.raw.compare(self.root_size, self.sixty_four) >= 0, "selected internal root")
+        need(self.ring.raw.compare(self.root_unit, self.ring.modulus) < 0, "canonical root unit")
+        inv = self.ring.inverse(self.root_unit)
+        need(inv is not None, "root coefficient unit")
+        self.residue.free(inv)
+        current, count = self.index.copy(self.root_size), self.index.zero()
+        while self.raw.compare(count, self.depth) < 0:
+            level = self.plus(count, self.one_index)
+            metadata, parent, child, f = self.step(level)
+            need(self.raw.compare(parent, current) == 0, "chronological program extents")
+            self.fields.check_code(count, metadata[1])
+            self.index.free_many(parent, f, current, count)
+            current, count = child, level
+        self.index.free(count)
+        self.final_size = current
+        after = self.plus(self.depth, self.one_index)
+        seek_record(self.program.tape, after)
+        need(self.program.tape.read() == BLANK, "exact program depth")
+        self.program.tape.rewind()
+        if self.leaf:
+            self.fields.end(self.depth)
+        else:
+            self.fields.check_code(self.depth, self.current_code)
+            self.fields.end(after)
+        self.index.free(after)
+
+    def prepare(self, slot, code, scope):
+        high = self.fields.read(slot, code, scope)
+        for row in high:
+            for digit in row:
+                need(self.ring.raw.compare(digit, self.high_cap) < 0, "canonical high digit")
+        spec = self.specifications[code]
+        p = self.matrices.prepare(spec.low, high, self.q, spec.template.preparation, spec.template.rank)
+        self.matrices.free(high)
+        # Only the checker consumes this finite source-code trace.
+        self.prepared_codes.add(code)
+        return p
+
+    def weight(self, index):
+        need(self.raw.compare(index, self.final_size) < 0, "requested generated coordinate")
+        need(self.pending.empty() and self.values.empty(), "empty binary continuation roles")
+        self.pending.push(VALUE, self.depth, index)
+        while not self.pending.empty():
+            tag, operands = self.pending.pop()
+            if tag == CONSTANT:
+                coefficient, = operands
+                self.values.push(RETURN, coefficient)
+                self.residue.free(coefficient)
+            elif tag == MULTIPLY:
+                coefficient, = operands
+                value_tag, values = self.values.pop()
+                need(value_tag == RETURN, "value-stack tag")
+                value, = values
+                result = self.ring.multiply(value, coefficient)
+                self.values.push(RETURN, result)
+                self.residue.free_many(coefficient, value, result)
+            elif tag == PAIR:
+                coefficient, = operands
+                den_tag, den_values = self.values.pop()
+                num_tag, num_values = self.values.pop()
+                need(den_tag == num_tag == RETURN, "ordered pair value tags")
+                denominator, = den_values
+                numerator, = num_values
+                inv = self.ring.inverse(denominator)
+                need(inv is not None, "generated pair denominator unit")
+                product = self.ring.multiply(coefficient, numerator)
+                result = self.ring.multiply(product, inv)
+                self.values.push(RETURN, result)
+                self.residue.free_many(coefficient, denominator, numerator, inv, product, result)
+            else:
+                need(tag == VALUE, "pending value request")
+                level, coordinate = operands
+                if level.zero():
+                    need(self.raw.compare(coordinate, self.root_size) < 0, "root coordinate extent")
+                    self.values.push(RETURN, self.root_unit)
+                    self.index.free_many(level, coordinate)
+                    continue
+                metadata, parent, child, f = self.step(level)
+                kind, code, rank, field, reverse, _half = metadata
+                need(self.raw.compare(coordinate, child) < 0, "recursive coordinate extent")
+                if kind == UNIT_KIND:
+                    self.values.push(RETURN, self.ring.one)
+                else:
+                    slot = self.raw.subtract_exact(level, self.one_index)
+                    p = self.prepare(slot, code, self.depth)
+                    if kind == GOOD_KIND:
+                        pivots = self.matrices.good_pivots(p, rank)
+                        self.matrices.free(p)
+                        quotient, remainder = self.raw.divmod(coordinate, f)
+                        pivot = finite_word(quotient, rank)
+                        self.pending.push(MULTIPLY, pivots[pivot])
+                        self.pending.push(VALUE, slot, coordinate)
+                        self.residue.free_many(*pivots)
+                        self.index.free_many(quotient, remainder)
+                    else:
+                        diagonal, permutation = self.matrices.fallback(p)
+                        self.matrices.free(p)
+                        self.pending.push(PAIR, diagonal[field])
+                        if reverse:
+                            last = self.raw.subtract_exact(f, self.one_index)
+                            column = self.raw.subtract_exact(last, coordinate)
+                            self.index.free(last)
+                        else:
+                            column = self.index.copy(coordinate)
+                        for row in (field, permutation[field]):
+                            if row < 64:
+                                first = self.raw.times_small(f, row)
+                                position = self.plus(first, column)
+                                self.pending.push(VALUE, slot, position)
+                                self.index.free_many(first, position)
+                            else:
+                                self.pending.push(CONSTANT, self.ring.one)
+                        self.residue.free_many(*diagonal)
+                        self.index.free(column)
+                    self.index.free(slot)
+                self.index.free_many(level, coordinate, parent, child, f)
+        tag, values = self.values.pop()
+        need(tag == RETURN and self.pending.empty() and self.values.empty(), "closed generated evaluation")
+        result, = values
+        return result
+
+    def coefficient(self, target_row, column, inverse=False):
+        need(not self.leaf, "internal coefficient requires a current field")
+        need(0 < target_row < 64 and isinstance(target_row, int), "fixed head target row")
+        f, remainder = self.raw.divmod(self.final_size, self.sixty_four)
+        self.index.free(remainder)
+        need(not f.zero() and self.raw.compare(column, f) < 0, "current selected column")
+        scope = self.plus(self.depth, self.one_index)
+        p = self.prepare(self.depth, self.current_code, scope)
+        self.index.free(scope)
+        pinv = self.ring.inverse(p[0][0])
+        need(pinv is not None, "selected good head pivot")
+        ratio = self.ring.multiply(p[target_row][0], pinv)
+        ell = self.ring.negate(ratio)
+        self.residue.free_many(pinv, ratio)
+        self.matrices.free(p)
+        base = self.raw.times_small(f, target_row)
+        index = self.plus(base, column)
+        self.index.free_many(base, f)
+        numerator, denominator = self.weight(index), self.weight(column)
+        self.index.free(index)
+        ainv = self.ring.inverse(denominator)
+        need(ainv is not None, "incoming head coefficient unit")
+        product = self.ring.multiply(ell, numerator)
+        coefficient = self.ring.multiply(product, ainv)
+        self.residue.free_many(ell, numerator, denominator, ainv, product)
+        if inverse:
+            opposite = self.ring.negate(coefficient)
+            self.residue.free(coefficient)
+            coefficient = opposite
+        return coefficient
+
+    def offset(self, target_row, column, source, inverse=False):
+        need(self.ring.raw.compare(source, self.ring.modulus) < 0, "canonical source atom")
+        coefficient = self.coefficient(target_row, column, inverse)
+        result = self.ring.multiply(coefficient, source)
+        self.residue.free(coefficient)
+        return result
+
+    def close(self):
+        need(self.pending.empty() and self.values.empty(), "closed continuation interface")
+        self.index.free_many(self.root_size, self.depth, self.final_size,
+                             self.one_index, self.sixty_four, self.two_index)
+        self.residue.free_many(self.root_unit, self.high_cap)
+
+    def abort(self):
+        self.residue.rollback(self.protected_residues)
+        self.index.rollback(self.protected_indices)
+        self.program.tape.rewind()
+        self.fields.tape.rewind()
+        for stack in (self.pending, self.values):
+            stack.tape.clear()
+            stack.reverse.clear()
+
+
+def selected_offset(ring, index_arena, program, fields, specifications, current_code,
+                    target_row, column, source, inverse=False):
+    callback = Callback(ring, index_arena, program, fields, specifications, current_code)
+    try:
+        result = callback.offset(target_row, column, source, inverse)
+        prepared = tuple(sorted(callback.prepared_codes))
+        callback.close()
+        return result, prepared
+    except ValueError:
+        callback.abort()
+        raise
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py
new file mode 100644
index 0000000000..81b48940ce
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/counts.py
@@ -0,0 +1,57 @@
+"""Unbounded cardinalities; only compiled finite constants enter host control."""
+from cardinality import Natural, digit_suffix
+from records import Tape
+from words import ONE, RIGHT, ZERO, need
+
+
+class Count(Natural):
+    @classmethod
+    def literal(cls, value):
+        """Compile a fixed cardinality, never decode a runtime operand."""
+        need(isinstance(value, int) and value >= 0, "compiled cardinality")
+        tape = Tape()
+        for bit in range(max(1, value.bit_length())):
+            tape.append((value >> bit) & 1)
+        tape.append(RIGHT)
+        tape.rewind()
+        result = cls(tape)
+        tape.clear()
+        return result
+
+    def increment(self):
+        self.rewind()
+        while self.read() == ONE:
+            self.tape.write(ZERO)
+            self.step(1)
+        if self.read() == RIGHT:
+            self.tape.write(ONE)
+            self.step(1)
+            self.tape.write(RIGHT)
+        else:
+            need(self.read() == ZERO, "canonical count digit")
+            self.tape.write(ONE)
+        self.rewind()
+
+    def equals(self, other):
+        self.rewind()
+        other.rewind()
+        same = True
+        while self.read() != RIGHT and other.read() != RIGHT:
+            same = same and self.read() == other.read()
+            self.step(1)
+            other.step(1)
+        same = same and self.read() == other.read() == RIGHT
+        self.rewind()
+        other.rewind()
+        return same
+
+
+def high_power(value, ring, q, dimension):
+    for _ in range(dimension*dimension):
+        digit_suffix(value, ring, q)
+
+
+def high_count(ring, q, dimension):
+    result = Count.literal(1)
+    high_power(result, ring, q, dimension)
+    return result
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py
new file mode 100644
index 0000000000..c74cacf5ce
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/directory.py
@@ -0,0 +1,126 @@
+"""Produce all high fields while preserving physical old-prefix multiplicity."""
+from cardinality import radix_power
+from counts import Count, high_count, high_power
+from records import RECORD_END, Tape, append_finite, append_word, read_finite, read_word
+from stream import Counter
+from words import BLANK, RIGHT, ZERO, need
+
+
+class Context:
+    def __init__(self, ring, vocabulary):
+        self.ring, self.arena, self.raw = ring, ring.arena, ring.raw
+        self.codes = vocabulary
+        self.q, self.dimension = vocabulary.q, vocabulary.dimension
+        for _ in radix_power(ring, self.q):
+            pass
+        divisor = self.arena.literal(self.q)
+        self.cap, remainder = self.raw.divmod(ring.modulus, divisor)
+        need(remainder.zero() and not self.cap.zero(), "positive high-field radix")
+        self.arena.free_many(divisor, remainder)
+        self.highs = high_count(ring, self.q, self.dimension)
+
+    def close(self):
+        self.arena.free(self.cap)
+        self.highs.close()
+
+
+class Odometer:
+    def __init__(self, context):
+        self.context = context
+        self.digits = [[context.arena.zero() for _ in range(context.dimension)]
+                       for _ in range(context.dimension)]
+        self.finished = False
+
+    def advance(self):
+        need(not self.finished, "live high odometer")
+        context = self.context
+        for row in reversed(self.digits):
+            for digit in reversed(row):
+                context.raw.increment_in_place(digit)
+                if context.raw.compare(digit, context.cap) < 0:
+                    return
+                need(context.raw.compare(digit, context.cap) == 0, "high digit carry")
+                while digit.read() != RIGHT:
+                    digit.write(ZERO)
+                    digit.step(1)
+                digit.rewind()
+        self.finished = True
+
+    def close(self):
+        for row in self.digits:
+            self.context.arena.free_many(*row)
+
+
+def append_tape(source, destination):
+    source.rewind()
+    while source.read() != BLANK:
+        destination.append(source.read())
+        source.step(1)
+    source.rewind()
+
+
+def old_prefix(source, field_count, context):
+    """Retain one serialized prefix; decode at most one old numerical word."""
+    output, remaining = Tape(), Counter(field_count)
+    try:
+        while not remaining.finished:
+            code = read_finite(source, context.codes.bits)
+            need(code < context.codes.limit, "old compiled source code")
+            append_finite(output, code, context.codes.bits)
+            for _ in range(context.dimension*context.dimension):
+                word = read_word(source, context.arena)
+                try:
+                    need(context.raw.compare(word, context.cap) < 0, "old high digit range")
+                    append_word(output, word)
+                finally:
+                    context.arena.free(word)
+            need(source.read() == RECORD_END, "old field boundary")
+            source.step(1)
+            output.append(RECORD_END)
+            remaining.decrement()
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        remaining.close()
+
+
+def produce(old, old_fields, old_count, code, context):
+    need(0 <= code < context.codes.limit, "new compiled source code")
+    expected, emitted = Count(old_count), Count.literal(0)
+    high_power(expected, context.ring, context.q, context.dimension)
+    outer, output = Counter(old_count), Tape()
+    old.rewind()
+    try:
+        need(not outer.finished, "nonempty old physical prefix domain")
+        while not outer.finished:
+            saved = old_prefix(old, old_fields, context)
+            high = Odometer(context)
+            try:
+                while not high.finished:
+                    append_tape(saved, output)
+                    append_finite(output, code, context.codes.bits)
+                    for row in high.digits:
+                        for digit in row:
+                            append_word(output, digit)
+                    output.append(RECORD_END)
+                    emitted.increment()
+                    high.advance()
+            finally:
+                saved.clear()
+                high.close()
+            outer.decrement()
+        need(old.read() == BLANK and emitted.equals(expected), "complete canonical raw directory")
+        old.rewind()
+        output.rewind()
+        return output, expected
+    except ValueError:
+        output.clear()
+        expected.close()
+        old.rewind()
+        raise
+    finally:
+        emitted.close()
+        outer.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py
new file mode 100644
index 0000000000..30d11ff4f3
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/episode.py
@@ -0,0 +1,124 @@
+"""Transported COPY/XOR/ERASE on staged complete packets and physical families."""
+from counts import Count
+from directory import produce
+from records import Tape
+from routes import copy_rows, route_packet
+from selection import gather, scatter
+from stream import Counter
+from words import BLANK, ONE, ZERO, need
+
+
+def xor_packet(source, target, context, old_count, fibre, factory=Tape):
+    output, outer = factory(), Counter(old_count)
+    source.rewind()
+    target.rewind()
+    try:
+        while not outer.finished:
+            highs = Counter(context.highs)
+            while not highs.finished:
+                bits = Counter(fibre)
+                while not bits.finished:
+                    left, right = source.read(), target.read()
+                    need(left in (ZERO, ONE) and right in (ZERO, ONE), "aligned Boolean operands")
+                    output.append(left ^ right)
+                    source.step(1)
+                    target.step(1)
+                    bits.decrement()
+                bits.close()
+                highs.decrement()
+            highs.close()
+            outer.decrement()
+        need(source.read() == target.read() == BLANK, "complete aligned XOR")
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        outer.close()
+        source.rewind()
+        target.rewind()
+
+
+def staged(source, targets, episode, context, old_count, fibre, residual, factory=Tape):
+    """Call the concrete residual once, then retain its transported ERASE guard."""
+    need(tuple(targets) == episode.targets and len({id(tape) for tape in targets.values()}) == len(targets)
+         and all(tape is not source for tape in targets.values()), "distinct staged live roles")
+    need(len(episode.records) == len(episode.targets)+2 and
+         episode.records[0][:3] == (2,episode.source,episode.private) and
+         episode.records[-1][:3] == (3,episode.source,episode.private) and
+         episode.records[0][3:5] == episode.records[-1][3:5] and
+         all(record[0] == 1 and record[1] == target and record[2] == episode.private
+             and record[3] in (-1,1) and target != episode.source
+             for target, record in zip(episode.targets, episode.records[1:-1])),
+         "closed source-preserving COPY interval")
+    initial, outer = factory(), Counter(old_count)
+    source.rewind()
+    while not outer.finished:
+        copy_rows(source, initial, context.highs, fibre)
+        outer.decrement()
+    outer.close()
+    need(source.read() == BLANK, "complete staged COPY source")
+    source.rewind()
+    initial.rewind()
+    private, result = None, {}
+    try:
+        private = residual(initial)
+        need(private is not initial and private is not source and
+             all(private is not value for value in targets.values()), "owned transported private result")
+        for target in episode.targets:
+            result[target] = xor_packet(private, targets[target], context, old_count, fibre, factory)
+        # Only reads of private and source occur after the completed transport.
+        # The authenticated literal word therefore supplies the transported
+        # equality guard; comparison with untransported source would be wrong.
+        need(source.head == private.head == 1, "transported source lifetime closes at ERASE")
+        return result
+    except ValueError:
+        for value in result.values():
+            value.clear()
+        raise
+    finally:
+        if private is not None and private is not initial and private is not source:
+            private.clear()
+        initial.clear()
+
+
+def physical(families, episode, source_route, common_code, context, old_directory,
+             old_fields, old_count, fibre, residual, factory=Tape):
+    """Gather, route, produce fields, execute, scatter and erase local work.
+
+    residual(source, directory, prefix_count) must execute the completed
+    common-view residual and preserve its inputs. The verifier supplies the
+    actual PR2501 packet interpreter, including its leaf expansion.
+    """
+    request, common, low = context.codes.decode(common_code)
+    need(common and request == episode.request and low == source_route.target_low
+         and source_route.chart == episode.chart, "current common-view source binding")
+    source = gather(families[episode.source_family], context, old_count, source_route.low, fibre, factory)
+    common_source = directory = prefixes = changed = None
+    targets, result = {}, {}
+    try:
+        common_source = route_packet(source, source_route, context, old_count, fibre, factory)
+        for role, family in zip(episode.targets, episode.target_families):
+            targets[role] = gather(families[family], context, old_count, low, fibre, factory)
+        directory, prefixes = produce(old_directory, old_fields, old_count, common_code, context)
+        changed = staged(common_source, targets, episode, context, old_count, fibre,
+                         lambda value: residual(value, directory, prefixes), factory)
+        for role, family in zip(episode.targets, episode.target_families):
+            result[family] = scatter(families[family], changed[role], context, old_count, low, fibre, factory)
+        return result
+    except ValueError:
+        for value in result.values():
+            value.clear()
+        raise
+    finally:
+        source.clear()
+        if common_source is not None:
+            common_source.clear()
+        for collection in (targets, changed or {}):
+            for value in collection.values():
+                value.clear()
+        if directory is not None:
+            directory.clear()
+        if prefixes is not None:
+            prefixes.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py
new file mode 100644
index 0000000000..6667c0b772
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/forms.py
@@ -0,0 +1,182 @@
+"""Complete selected adapter preparations with binary scalar operands.
+
+The fixed matrix and reduction indices are finite control. All coefficients
+remain Word objects. Algebra follows source527 and PR2159/2160/2188/2234.
+"""
+from dataclasses import dataclass
+
+from matrices import Matrices
+from words import need
+
+
+@dataclass
+class GoodForm:
+    dimension: int
+    rank: int
+    pivots: tuple
+    rows: tuple
+    columns: tuple
+    cross: list
+
+    def close(self, ring):
+        ring.arena.free_many(*self.pivots)
+        for _, _, value in self.rows + self.columns:
+            ring.arena.free(value)
+        Matrices(ring).free(self.cross)
+
+
+@dataclass
+class Reduction:
+    kind: str
+    target: int
+    source: int
+    scalar: object
+    permutation: tuple
+
+
+@dataclass
+class FallbackForm:
+    dimension: int
+    diagonal: tuple
+    permutation: tuple
+    reductions: tuple
+    negative_sign: bool
+
+    def close(self, ring):
+        ring.arena.free_many(*self.diagonal)
+        for reduction in self.reductions:
+            if reduction.scalar is not None:
+                ring.arena.free(reduction.scalar)
+
+
+def row_add(matrix, target, source, coefficient, ring):
+    if coefficient.zero():
+        return
+    for j in range(len(matrix[0])):
+        product = ring.multiply(coefficient, matrix[source][j])
+        result = ring.add(matrix[target][j], product)
+        ring.arena.free_many(matrix[target][j], product)
+        matrix[target][j] = result
+
+
+def column_add(matrix, target, source, coefficient, ring):
+    if coefficient.zero():
+        return
+    for row in matrix:
+        product = ring.multiply(coefficient, row[source])
+        result = ring.add(row[target], product)
+        ring.arena.free_many(row[target], product)
+        row[target] = result
+
+
+def negative_product(a, b, ring):
+    value = ring.multiply(a, b)
+    result = ring.negate(value)
+    ring.arena.free(value)
+    return result
+
+
+def good_form(projector, rank, ring):
+    """Keep chronological row/column scalars and the full cross block."""
+    m = len(projector)
+    need(1 <= rank < m <= 64, "fixed good preparation dimension")
+    matrices, arena = Matrices(ring), ring.arena
+    a = [[arena.copy(value) for value in reversed(row)] for row in projector]
+    left, right = matrices.identity(m), matrices.identity(m)
+    pivots, rows, columns = [], [], []
+    for k in range(rank):
+        column = m-1-k
+        pivot = arena.copy(a[k][column])
+        inverse = ring.inverse(pivot)
+        need(inverse is not None, "complete good class")
+        pivots.append(pivot)
+        for i in range(k+1, m):
+            coefficient = negative_product(a[i][column], inverse, ring)
+            rows.append((i, k, coefficient))
+            row_add(a, i, k, coefficient, ring)
+            row_add(left, i, k, coefficient, ring)
+        for j in range(column):
+            coefficient = negative_product(a[k][j], inverse, ring)
+            columns.append((column, j, coefficient))
+            column_add(a, j, column, coefficient, ring)
+            column_add(right, j, column, coefficient, ring)
+        arena.free(inverse)
+    for i in range(m):
+        for j in range(m):
+            need(ring.raw.compare(a[i][j], pivots[i]) == 0 if i < rank and j == m-1-i
+                 else a[i][j].zero(), "complete northeast diagonal endpoint")
+    matrices.free(a)
+    li, ri = matrices.inverse(left), matrices.inverse(right)
+    lp = matrices.multiply(left, projector)
+    a0 = matrices.multiply(lp[:rank], li)
+    b = matrices.multiply(ri, [row[:rank] for row in reversed(li)])
+    for matrix in (a0, b):
+        for row in matrix:
+            for j, value in enumerate(row):
+                row[j] = ring.negate(value)
+                arena.free(value)
+    cross = matrices.zero(m, m)
+    for k, pivot in enumerate(pivots):
+        inverse = ring.inverse(pivot)
+        need(inverse is not None, "good pivot remains a unit")
+        for i in range(m):
+            value = ring.negate(b[i][k])
+            if i == m-1-k:
+                adjusted = ring.subtract(value, inverse)
+                arena.free(value)
+                value = adjusted
+            arena.free(cross[i][k])
+            cross[i][k] = value
+        for j in range(rank, m):
+            value = ring.multiply(inverse, a0[k][j])
+            arena.free(cross[m-1-k][j])
+            cross[m-1-k][j] = value
+        arena.free(inverse)
+    for matrix in (left, right, li, ri, lp, a0, b):
+        matrices.free(matrix)
+    return GoodForm(m, rank, tuple(pivots), tuple(rows), tuple(columns), cross)
+
+
+def fallback_form(projector, ring):
+    """Retain each shear's original pair and pre-operation permutation."""
+    matrices, arena = Matrices(ring), ring.arena
+    rows = matrices.residual(projector)
+    size = len(rows)
+    permutation, reductions = list(range(size)), []
+    for j in range(size):
+        inverse = None
+        for pivot in range(j, size):
+            inverse = ring.inverse(rows[pivot][j])
+            if inverse is not None:
+                break
+        need(inverse is not None, "complete fallback unit pivot")
+        if pivot != j:
+            reductions.append(Reduction("swap", j, pivot, None, tuple(permutation)))
+            rows[j], rows[pivot] = rows[pivot], rows[j]
+            permutation[j], permutation[pivot] = permutation[pivot], permutation[j]
+        for i in range(size):
+            if i == j:
+                continue
+            coefficient = negative_product(rows[i][j], inverse, ring)
+            reductions.append(Reduction("shear", i, j, coefficient, tuple(permutation)))
+            row_add(rows, i, j, coefficient, ring)
+        arena.free(inverse)
+    diagonal = []
+    determinant = arena.copy(ring.one)
+    for i in range(size):
+        for j in range(size):
+            if i == j:
+                diagonal.append(rows[i][j])
+                value = ring.multiply(determinant, rows[i][j])
+                arena.free(determinant)
+                determinant = value
+            else:
+                need(rows[i][j].zero(), "complete fallback diagonal endpoint")
+                arena.free(rows[i][j])
+    negative_one = ring.negate(ring.one)
+    positive = ring.raw.compare(determinant, ring.one) == 0
+    negative = ring.raw.compare(determinant, negative_one) == 0
+    need(positive or negative, "fallback terminal determinant sign")
+    arena.free_many(determinant, negative_one)
+    return FallbackForm(len(projector), tuple(diagonal), tuple(permutation),
+                        tuple(reductions), not positive)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py
new file mode 100644
index 0000000000..737edfc4a1
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/low_codes.py
@@ -0,0 +1,109 @@
+"""Fixed-q compilation of lexicographic GL codes, independent of input width."""
+from math import prod
+from words import need
+
+
+class Constraints:
+    def __init__(self, rows, q):
+        self.rows, self.q = rows, q
+        self.basis, self.inconsistent = [], False
+
+    def next(self, column):
+        coefficients = [row[column] for row in self.rows]
+        rhs = 0
+        for pivot, row, value in self.basis:
+            factor = coefficients[pivot]
+            coefficients = [(a-factor*b) % self.q for a, b in zip(coefficients, row)]
+            rhs = (rhs+factor*value) % self.q
+        pivot = next((i for i, x in enumerate(coefficients) if x), None)
+        return coefficients, rhs, pivot
+
+    def excluded(self, reduced, value):
+        if self.inconsistent:
+            return 0
+        _row, rhs, pivot = reduced
+        if pivot is not None:
+            return self.q**(len(self.rows)-len(self.basis)-1)
+        return self.q**(len(self.rows)-len(self.basis)) if value == rhs else 0
+
+    def choose(self, reduced, value):
+        if self.inconsistent:
+            return
+        row, rhs, pivot = reduced
+        if pivot is None:
+            self.inconsistent = value != rhs
+            return
+        inverse = pow(row[pivot], -1, self.q)
+        normalized = tuple(x*inverse % self.q for x in row)
+        self.basis.append((pivot, normalized, (value-rhs)*inverse % self.q))
+        self.basis.sort(key=lambda item: item[0])
+
+
+class LowCodes:
+    def __init__(self, q, dimension, requests=1):
+        need(q >= 3 and all(q % p for p in range(2, q)) and
+             1 <= dimension <= 64 and requests > 0, "fixed prime and source vocabulary")
+        self.q, self.dimension, self.requests = q, dimension, requests
+        self.radices = tuple(q**dimension-q**k for k in range(dimension))
+        self.size = prod(self.radices)
+        self.limit = 2*requests*self.size
+        self.bits = max(1, (self.limit-1).bit_length())
+
+    def vector_rank(self, rows, vector):
+        constraints, rank = Constraints(rows, self.q), 0
+        for column, value in enumerate(vector):
+            reduced = constraints.next(column)
+            total = self.q**(self.dimension-column-1)
+            for smaller in range(value):
+                rank += total-constraints.excluded(reduced, smaller)
+            constraints.choose(reduced, value)
+        need(constraints.inconsistent, "independent low row")
+        return rank
+
+    def vector_unrank(self, rows, rank):
+        constraints, vector = Constraints(rows, self.q), []
+        for column in range(self.dimension):
+            reduced = constraints.next(column)
+            total = self.q**(self.dimension-column-1)
+            for value in range(self.q):
+                count = total-constraints.excluded(reduced, value)
+                if rank < count:
+                    vector.append(value)
+                    constraints.choose(reduced, value)
+                    break
+                rank -= count
+            else:
+                raise ValueError("low-row rank range")
+        need(rank == 0 and constraints.inconsistent, "complete independent low row")
+        return tuple(vector)
+
+    def rank(self, matrix):
+        need(len(matrix) == self.dimension and
+             all(len(row) == self.dimension and all(isinstance(x, int) and 0 <= x < self.q
+                                                     for x in row) for row in matrix),
+             "fixed low matrix shape and residues")
+        rank, previous = 0, []
+        for row, radix in zip(matrix, self.radices):
+            rank = rank*radix+self.vector_rank(previous, row)
+            previous.append(tuple(row))
+        return rank
+
+    def unrank(self, rank):
+        need(isinstance(rank, int) and 0 <= rank < self.size, "GL low ordinal")
+        digits = []
+        for radix in reversed(self.radices):
+            rank, digit = divmod(rank, radix)
+            digits.append(digit)
+        rows = []
+        for digit in reversed(digits):
+            rows.append(self.vector_unrank(rows, digit))
+        return tuple(rows)
+
+    def encode(self, request, common, matrix):
+        need(0 <= request < self.requests and common in (False, True), "fixed request/view tag")
+        return (2*request+int(common))*self.size+self.rank(matrix)
+
+    def decode(self, code):
+        need(isinstance(code, int) and 0 <= code < self.limit, "complete compiled source code")
+        tag, ordinal = divmod(code, self.size)
+        return tag//2, bool(tag & 1), self.unrank(ordinal)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py
new file mode 100644
index 0000000000..5d497353ef
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/matrices.py
@@ -0,0 +1,217 @@
+"""Fixed-dimensional preparations whose entries are binary word tapes.
+
+Matrix positions and row permutations range over the fixed 64/128-dimensional
+control alphabet. Runtime entries never become Python integers. The algebra
+adapts the retained source527/PR2160/2159/2234 normal forms.
+"""
+from words import need
+
+
+class Matrices:
+    def __init__(self, ring):
+        self.ring, self.arena = ring, ring.arena
+
+    def zero(self, rows, columns):
+        need(0 < rows <= 128 and 0 < columns <= 256, "fixed matrix dimensions")
+        return [[self.arena.zero() for _ in range(columns)] for _ in range(rows)]
+
+    def free(self, matrix):
+        for row in matrix:
+            for value in row:
+                self.arena.free(value)
+
+    def copy(self, matrix):
+        return [[self.arena.copy(value) for value in row] for row in matrix]
+
+    def identity(self, size):
+        out = self.zero(size, size)
+        for i in range(size):
+            self.arena.free(out[i][i])
+            out[i][i] = self.arena.copy(self.ring.one)
+        return out
+
+    def constants(self, matrix):
+        """Compile a fixed rational source matrix; inverses use the word machine."""
+        palette = {}
+        for row in matrix:
+            for constant in row:
+                if constant in palette:
+                    continue
+                numerator = self.ring.literal(constant.numerator)
+                denominator = self.ring.literal(constant.denominator)
+                inv = self.ring.inverse(denominator)
+                need(inv is not None, "source denominator is a unit")
+                palette[constant] = self.ring.multiply(numerator, inv)
+                self.arena.free_many(numerator, denominator, inv)
+        out = [[self.arena.copy(palette[constant]) for constant in row] for row in matrix]
+        for value in palette.values():
+            self.arena.free(value)
+        return out
+
+    def multiply(self, a, b):
+        rows, inner, columns = len(a), len(b), len(b[0])
+        need(all(len(row) == inner for row in a) and all(len(row) == columns for row in b),
+             "matrix product shape")
+        out = self.zero(rows, columns)
+        for i in range(rows):
+            for k in range(inner):
+                if a[i][k].zero():
+                    continue
+                for j in range(columns):
+                    if b[k][j].zero():
+                        continue
+                    product = self.ring.multiply(a[i][k], b[k][j])
+                    total = self.ring.add(out[i][j], product)
+                    self.arena.free_many(out[i][j], product)
+                    out[i][j] = total
+        return out
+
+    def inverse(self, matrix):
+        size = len(matrix)
+        need(size <= 128 and all(len(row) == size for row in matrix), "fixed square matrix")
+        identity = self.identity(size)
+        rows = [[self.arena.copy(value) for value in row] + unit
+                for row, unit in zip(matrix, identity)]
+        for j in range(size):
+            pinv = None
+            for pivot in range(j, size):
+                pinv = self.ring.inverse(rows[pivot][j])
+                if pinv is not None:
+                    break
+            need(pinv is not None, "matrix unit pivot")
+            rows[j], rows[pivot] = rows[pivot], rows[j]
+            for k in range(2*size):
+                value = self.ring.multiply(pinv, rows[j][k])
+                self.arena.free(rows[j][k])
+                rows[j][k] = value
+            self.arena.free(pinv)
+            for i in range(size):
+                if i == j or rows[i][j].zero():
+                    continue
+                coefficient = self.arena.copy(rows[i][j])
+                for k in range(2*size):
+                    product = self.ring.multiply(coefficient, rows[j][k])
+                    value = self.ring.subtract(rows[i][k], product)
+                    self.arena.free_many(rows[i][k], product)
+                    rows[i][k] = value
+                self.arena.free(coefficient)
+        for i in range(size):
+            for j in range(size):
+                need(self.ring.raw.compare(rows[i][j], self.ring.one) == 0 if i == j else rows[i][j].zero(),
+                     "binary matrix inverse endpoint")
+                self.arena.free(rows[i][j])
+        return [row[size:] for row in rows]
+
+    def projector(self, header, rank):
+        need(0 < rank < len(header), "proper projector rank")
+        inv = self.inverse(header)
+        out = self.multiply([row[:rank] for row in header], inv[:rank])
+        self.free(inv)
+        return out
+
+    def good_pivots(self, projector, rank):
+        rows = self.copy(projector)
+        size, pivots = len(rows), []
+        for k in range(rank):
+            inv = self.ring.inverse(rows[k][k])
+            need(inv is not None, "binary nongeneric good class")
+            pivots.append(self.arena.copy(rows[k][k]))
+            for i in range(k+1, size):
+                if rows[i][k].zero():
+                    continue
+                coefficient = self.ring.multiply(rows[i][k], inv)
+                for j in range(size):
+                    product = self.ring.multiply(coefficient, rows[k][j])
+                    value = self.ring.subtract(rows[i][j], product)
+                    self.arena.free_many(rows[i][j], product)
+                    rows[i][j] = value
+                self.arena.free(coefficient)
+            self.arena.free(inv)
+        # Rank-r split projectors with these pivots have zero residual block.
+        for i in range(rank, size):
+            for j in range(rank, size):
+                need(rows[i][j].zero(), "binary full-ring Schur block")
+        self.free(rows)
+        return pivots
+
+    def residual(self, p):
+        size = len(p)
+        need(size <= 64, "selected residual dimension")
+        out = self.zero(2*size, 2*size)
+        for i in range(size):
+            for j in range(size):
+                if i == j:
+                    complement = self.ring.subtract(self.ring.one, p[i][j])
+                else:
+                    complement = self.ring.negate(p[i][j])
+                for row, column, value in (
+                    (i, j, complement),
+                    (2*size-1-i, 2*size-1-j, self.arena.copy(complement)),
+                    (i, 2*size-1-j, self.arena.copy(p[i][j])),
+                    (2*size-1-i, j, self.arena.copy(p[i][j])),
+                ):
+                    self.arena.free(out[row][column])
+                    out[row][column] = value
+        return out
+
+    def fallback(self, projector):
+        rows = self.residual(projector)
+        size = len(rows)
+        permutation = list(range(size))  # Fixed finite row-label control.
+        for j in range(size):
+            inv = None
+            for pivot in range(j, size):
+                inv = self.ring.inverse(rows[pivot][j])
+                if inv is not None:
+                    break
+            need(inv is not None, "binary fallback unit pivot")
+            rows[j], rows[pivot] = rows[pivot], rows[j]
+            permutation[j], permutation[pivot] = permutation[pivot], permutation[j]
+            for i in range(size):
+                if i == j or rows[i][j].zero():
+                    continue
+                coefficient = self.ring.multiply(rows[i][j], inv)
+                for k in range(size):
+                    product = self.ring.multiply(coefficient, rows[j][k])
+                    value = self.ring.subtract(rows[i][k], product)
+                    self.arena.free_many(rows[i][k], product)
+                    rows[i][k] = value
+                self.arena.free(coefficient)
+            self.arena.free(inv)
+        diagonal = []
+        for i in range(size):
+            for j in range(size):
+                if i == j:
+                    diagonal.append(rows[i][j])
+                else:
+                    need(rows[i][j].zero(), "binary fallback diagonal endpoint")
+                    self.arena.free(rows[i][j])
+        return diagonal, tuple(permutation)
+
+    def raw_header(self, low, high, q):
+        """Compile-time low class plus encoded runtime high digits."""
+        qword = self.ring.literal(q)
+        constants = {constant for row in low for constant in row}
+        palette = {constant: self.ring.literal(constant) for constant in constants}
+        out = []
+        for lo, hi in zip(low, high):
+            row = []
+            for constant, digit in zip(lo, hi):
+                term = self.ring.multiply(qword, digit)
+                row.append(self.ring.add(term, palette[constant]))
+                self.arena.free(term)
+            out.append(row)
+        self.arena.free(qword)
+        for value in palette.values():
+            self.arena.free(value)
+        return out
+
+    def prepare(self, low, high, q, fixed_preparation, rank):
+        raw = self.raw_header(low, high, q)
+        basis_chart = self.constants(fixed_preparation)
+        header = self.multiply(raw, basis_chart)
+        self.free(raw)
+        self.free(basis_chart)
+        p = self.projector(header, rank)
+        self.free(header)
+        return p
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py
new file mode 100644
index 0000000000..6d4ebca839
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/numeric.py
@@ -0,0 +1,189 @@
+"""One numeric page for one exact raw prefix; never a packet-wide constant."""
+from controller import Callback, finite_word
+from forms import fallback_form, good_form
+from matrices import Matrices
+from words import Unsigned, need
+
+
+class Geometry:
+    def __init__(self, plan, index_arena, columns, depth, source_code, parent_identity):
+        self.plan = plan
+        self.index, self.raw = index_arena, Unsigned(index_arena)
+        self.columns = columns
+        self.depth, self.source_code, self.parent_identity = depth, source_code, parent_identity
+        self.one, self.two = self.index.literal(1), self.index.literal(2)
+        self.leaf_cutoff = self.index.literal(64)
+        need(not columns.zero(), "positive residual columns")
+
+    def plus(self, a, b):
+        out, carry = self.raw.add(a, b)
+        need(not carry, "residual address margin")
+        return out
+
+    def point(self, field, column):
+        base = self.raw.times_small(self.columns, field)
+        if field < self.plan.dimension:
+            result = self.plus(base, column)
+        else:
+            last = self.raw.subtract_exact(self.columns, self.one)
+            reverse = self.raw.subtract_exact(last, column)
+            result = self.plus(base, reverse)
+            self.index.free_many(last, reverse)
+        self.index.free(base)
+        return result
+
+    def close(self):
+        self.index.free_many(self.one, self.two, self.leaf_cutoff)
+
+
+class Page(Geometry):
+    def __init__(self, plan, form, ring, index_arena, columns, weight,
+                 depth, source_code, parent_identity):
+        super().__init__(plan, index_arena, columns, depth, source_code, parent_identity)
+        self.form, self.ring, self.weight = form, ring, weight
+        if plan.good:
+            need((form.dimension, form.rank) == (plan.dimension, plan.rank), "good plan binding")
+        else:
+            signature = tuple((r.kind, r.target, r.source, r.permutation) for r in form.reductions)
+            need(signature == plan.reductions and form.permutation == plan.permutation
+                 and form.negative_sign == plan.negative_sign, "full/low fallback itinerary binding")
+
+    def bank(self, row, column):
+        if row >= self.plan.dimension:
+            return self.ring.arena.copy(self.ring.one)
+        base = self.raw.times_small(self.columns, row)
+        position = self.plus(base, column)
+        result = self.weight(position)
+        self.index.free_many(base, position)
+        return result
+
+    def ratio(self, scalar, numerator, denominator):
+        ring, arena = self.ring, self.ring.arena
+        inverse = ring.inverse(denominator)
+        need(inverse is not None, "generated adapter denominator unit")
+        product = ring.multiply(scalar, numerator)
+        result = ring.multiply(product, inverse)
+        arena.free_many(numerator, denominator, inverse, product)
+        return result
+
+    def coefficient(self, reference, column, reverse=False):
+        ring, arena, form = self.ring, self.ring.arena, self.form
+        if reference.kind == "head":
+            scalar = form.rows[reference.index][2]
+        elif reference.kind == "tail":
+            scalar = form.columns[reference.index][2]
+        elif reference.kind == "cross":
+            scalar = form.cross[reference.first][reference.second]
+        else:
+            need(reference.kind == "shear", "adapter coefficient reference")
+            reduction = form.reductions[reference.index]
+            need((reduction.target, reduction.source, reduction.permutation) ==
+                 (reference.first, reference.second, reference.permutation), "original shear reference")
+            scalar = reduction.scalar
+        if scalar.zero():
+            result = arena.zero()
+        elif reference.kind == "tail":
+            result = arena.copy(scalar)
+        else:
+            if reference.kind == "head":
+                numerator, denominator = self.bank(reference.first, column), self.bank(reference.second, column)
+            elif reference.kind == "cross":
+                numerator, denominator = arena.copy(ring.one), self.bank(reference.second, column)
+            else:
+                numerator = self.bank(reference.permutation[reference.first], column)
+                denominator = self.bank(reference.permutation[reference.second], column)
+            result = self.ratio(scalar, numerator, denominator)
+        if (reference.sign < 0) != reverse:
+            opposite = ring.negate(result)
+            arena.free(result)
+            result = opposite
+        return result
+
+    def child_weight(self, kind, field, reverse, index):
+        ring, arena = self.ring, self.ring.arena
+        if kind == "unit":
+            return arena.copy(ring.one)
+        if kind == "good":
+            quotient, remainder = self.raw.divmod(index, self.columns)
+            k = finite_word(quotient, self.plan.rank)
+            parent = self.weight(index)
+            result = ring.multiply(parent, self.form.pivots[k])
+            arena.free(parent)
+            self.index.free_many(quotient, remainder)
+            return result
+        need(kind == "pair" and 0 <= field < 2*self.plan.dimension-1, "pair child field")
+        if self.form.permutation[field] == field:
+            return arena.copy(self.form.diagonal[field])
+        if reverse:
+            last = self.raw.subtract_exact(self.columns, self.one)
+            column = self.raw.subtract_exact(last, index)
+            self.index.free(last)
+        else:
+            column = self.index.copy(index)
+        numerator = self.bank(self.form.permutation[field], column)
+        denominator = self.bank(field, column)
+        result = self.ratio(self.form.diagonal[field], numerator, denominator)
+        self.index.free(column)
+        return result
+
+    def close(self):
+        self.form.close(self.ring)
+        super().close()
+
+    def evaluate(self, request):
+        if request.kind == "adapter":
+            return self.coefficient(request.reference, request.coordinate, request.reverse_adapter)
+        need(request.kind == "child", "symbolic coefficient request")
+        value = self.child_weight(request.child_kind, request.field, request.reverse, request.coordinate)
+        if request.negative_inverse:
+            inverse = self.ring.inverse(value)
+            need(inverse is not None, "completed leaf weight unit")
+            result = self.ring.negate(inverse)
+            self.ring.arena.free_many(value, inverse)
+            return result
+        return value
+
+
+def selected_page(plan, ring, index_arena, program, fields, specifications, current_code):
+    """Caller closes the returned page and incoming frame at the same prefix."""
+    incoming = Callback(ring, index_arena, program, fields, specifications, current_code,
+                        allow_fallback=True)
+    columns, remainder = incoming.raw.divmod(incoming.final_size, incoming.sixty_four)
+    index_arena.free(remainder)
+    scope = incoming.plus(incoming.depth, incoming.one_index)
+    projector = incoming.prepare(incoming.depth, current_code, scope)
+    index_arena.free(scope)
+    need(plan.good == specifications[current_code].good, "fixed selected branch")
+    form = good_form(projector, plan.rank, ring) if plan.good else fallback_form(projector, ring)
+    Matrices(ring).free(projector)
+    page = Page(plan, form, ring, index_arena, columns, incoming.weight,
+                incoming.depth, current_code, program)
+    return page, incoming
+
+
+def selected_coefficient(plan, ring, index_arena, program, fields, specifications,
+                         current_code, request):
+    """Closed per-prefix callback for a symbolic trace event, on each pass."""
+    need(current_code in specifications and plan.dimension == 64 and
+         plan.rank == specifications[current_code].template.rank and
+         plan.good == specifications[current_code].good, "selected trace/source binding")
+    if request.kind == "child":
+        from children import coefficient
+        return coefficient(ring, index_arena, program, fields, specifications, current_code, request)
+    protected_residues, protected_indices = frozenset(ring.arena.live), frozenset(index_arena.live)
+    incoming = None
+    try:
+        page, incoming = selected_page(plan, ring, index_arena, program, fields, specifications, current_code)
+        result = page.evaluate(request)
+        page.close()
+        index_arena.free(page.columns)
+        incoming.close()
+        return result
+    except ValueError:
+        if incoming is not None:
+            incoming.abort()
+        ring.arena.rollback(protected_residues)
+        index_arena.rollback(protected_indices)
+        program.tape.rewind()
+        fields.tape.rewind()
+        raise
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py
new file mode 100644
index 0000000000..244f131466
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/oracle.py
@@ -0,0 +1,94 @@
+"""Host arithmetic for fixture construction and expected values only."""
+from math import gcd
+
+from words import need
+
+
+def eye(n):
+    return [[int(i == j) for j in range(n)] for i in range(n)]
+
+
+def multiply(a, b, modulus):
+    out = [[0]*len(b[0]) for _ in a]
+    for i, row in enumerate(a):
+        for k, x in enumerate(row):
+            if x:
+                for j, y in enumerate(b[k]):
+                    if y:
+                        out[i][j] = (out[i][j]+x*y) % modulus
+    return out
+
+
+def inverse(a, modulus):
+    n = len(a)
+    rows = [list(row)+unit for row, unit in zip(a, eye(n))]
+    for j in range(n):
+        k = next((i for i in range(j, n) if gcd(rows[i][j], modulus) == 1), None)
+        need(k is not None, "oracle unit pivot")
+        rows[j], rows[k] = rows[k], rows[j]
+        inv = pow(rows[j][j], -1, modulus)
+        rows[j] = [x*inv % modulus for x in rows[j]]
+        for i in range(n):
+            if i != j and rows[i][j]:
+                c = rows[i][j]
+                rows[i] = [(x-c*y) % modulus for x, y in zip(rows[i], rows[j])]
+    return [row[n:] for row in rows]
+
+
+def reduce_rational(a, modulus):
+    return [[x.numerator*pow(x.denominator, -1, modulus) % modulus for x in row] for row in a]
+
+
+def fixture(template, width, high=1, bad=False, unit_low=False, row=None):
+    q, modulus = template.q, template.q**width
+    row = template.rank if row is None else row
+    h = eye(64)
+    if bad:
+        h[0][0], h[0][row], h[row][0], h[row][row] = q, q-1, 1, 1+q*high
+    elif unit_low:
+        h[0][0], h[0][row], h[row][0], h[row][row] = 1+q*high, 1, 1, 2
+    else:
+        h[0][row], h[row][0], h[row][row] = 1, q*high, 1+q*high
+    raw = multiply(h, inverse(reduce_rational(template.preparation, modulus), modulus), modulus)
+    low = tuple(tuple(x % q for x in row) for row in raw)
+    digits = tuple(tuple(x//q for x in row) for row in raw)
+    return low, digits
+
+
+def projector(template, low, high, width):
+    q, modulus = template.q, template.q**width
+    raw = [[a+q*b for a, b in zip(lo, hi)] for lo, hi in zip(low, high)]
+    common = multiply(raw, reduce_rational(template.chart, modulus), modulus)
+    return multiply(multiply(common, reduce_rational(template.base, modulus), modulus),
+                    inverse(common, modulus), modulus)
+
+
+def good_pivots(p, rank, modulus):
+    rows, pivots = [list(row) for row in p], []
+    for k in range(rank):
+        inv = pow(rows[k][k], -1, modulus)
+        pivots.append(rows[k][k])
+        for i in range(k+1, len(rows)):
+            coefficient = rows[i][k]*inv % modulus
+            rows[i] = [(x-coefficient*y) % modulus for x, y in zip(rows[i], rows[k])]
+    return pivots
+
+
+def fallback(p, modulus):
+    n = len(p)
+    rows = [[0]*(2*n) for _ in range(2*n)]
+    for i in range(n):
+        for j in range(n):
+            rows[i][j] = rows[2*n-1-i][2*n-1-j] = (int(i == j)-p[i][j]) % modulus
+            rows[i][2*n-1-j] = rows[2*n-1-i][j] = p[i][j]
+    permutation = list(range(2*n))
+    for j in range(2*n):
+        pivot = next(i for i in range(j, 2*n) if gcd(rows[i][j], modulus) == 1)
+        rows[j], rows[pivot] = rows[pivot], rows[j]
+        permutation[j], permutation[pivot] = permutation[pivot], permutation[j]
+        inv = pow(rows[j][j], -1, modulus)
+        for i in range(2*n):
+            if i != j and rows[i][j]:
+                coefficient = rows[i][j]*inv % modulus
+                rows[i] = [(x-coefficient*y) % modulus for x, y in zip(rows[i], rows[j])]
+    return [rows[i][i] for i in range(2*n)], tuple(permutation)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py
new file mode 100644
index 0000000000..ebc9b61651
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/packet.py
@@ -0,0 +1,97 @@
+"""One shared trace across a sequential directory of complete raw prefixes.
+
+Each primitive traverses the whole packet before the next trace event. Child
+entry/return occur once for the packet, never once per sampled high header.
+"""
+from bitstream import copy_bits
+from cardinality import Natural, multiply_atom_power
+from records import RECORD_END, Tape
+from stream import Counter, positive_extent
+from stream_runner import Layout, action
+from trace import execute
+from words import BLANK, need
+
+
+def read_prefix(directory, field_count):
+    out, remaining = Tape(), Counter(field_count)
+    while not remaining.finished:
+        while directory.read() != RECORD_END:
+            symbol = directory.read()
+            need(symbol != BLANK, "complete raw-prefix directory")
+            out.append(symbol)
+            directory.step(1)
+        out.append(RECORD_END)
+        directory.step(1)
+        remaining.decrement()
+    remaining.close()
+    out.rewind()
+    return out
+
+
+def copy_prefix(source, output, before, body):
+    count = Counter(before)
+    while not count.finished:
+        copy_bits(source, output, body)
+        count.decrement()
+    count.close()
+
+
+def run(source, geometry, parent_size, ring, q, before, suffix, prefix_count,
+        field_count, directory, coefficient, payload_factory=Tape, boundary_observer=None):
+    positive_extent(prefix_count)
+    expected_fields = geometry.plus(geometry.depth, geometry.one)
+    matches = geometry.raw.compare(field_count, expected_fields) == 0
+    geometry.index.free(expected_fields)
+    need(matches, "original frozen/current field count")
+    layout = Layout(geometry, parent_size, ring, q, before, suffix)
+    body = Natural(suffix)
+    multiply_atom_power(body, layout.total, ring, q)
+    current, active = source, None
+    try:
+        for event in execute(geometry):
+            if event.kind == "enter":
+                need(active is None and event.parent_identity is geometry.parent_identity,
+                     "one whole-packet child invocation")
+                active = event
+                if boundary_observer is not None:
+                    boundary_observer(event.kind)
+                continue
+            if event.kind == "return":
+                need(active is not None and active.parent_identity is event.parent_identity and
+                     (active.child_kind, active.field, active.reverse, active.half, active.source_code) ==
+                     (event.child_kind, event.field, event.reverse, event.half, event.source_code),
+                     "whole-packet symbolic return")
+                for a, b in ((active.first, event.first), (active.second, event.second),
+                             (active.width, event.width), (active.depth, event.depth)):
+                    need(geometry.raw.compare(a, b) == 0, "whole-packet encoded child return")
+                active = None
+                if boundary_observer is not None:
+                    boundary_observer(event.kind)
+                continue
+            output, prefixes = payload_factory(), Counter(prefix_count)
+            directory.rewind()
+            while not prefixes.finished:
+                fields = read_prefix(directory, field_count)
+                local = payload_factory()
+                copy_prefix(current, local, before, body)
+                local.rewind()
+                changed = action(local, event, layout, lambda request: coefficient(fields, request), payload_factory)
+                copy_prefix(changed, output, before, body)
+                need(changed.read() == BLANK, "complete returned prefix fibre")
+                changed.clear()
+                local.clear()
+                fields.clear()
+                prefixes.decrement()
+            prefixes.close()
+            need(current.read() == directory.read() == BLANK, "complete shared high packet")
+            current.rewind()
+            directory.rewind()
+            if current is not source:
+                current.clear()
+            output.rewind()
+            current = output
+        need(active is None, "whole-packet child return")
+        return current
+    finally:
+        layout.close()
+        body.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py
new file mode 100644
index 0000000000..48255d5454
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/plan.py
@@ -0,0 +1,112 @@
+"""Compile fixed-low symbolic itineraries, without width or high fields."""
+from dataclasses import dataclass
+from math import prod
+
+from words import need
+
+
+@dataclass(frozen=True)
+class Reference:
+    kind: str
+    index: int = 0
+    first: int = 0
+    second: int = 0
+    permutation: tuple = ()
+    sign: int = 1
+
+
+@dataclass(frozen=True)
+class Command:
+    kind: str
+    target: int
+    source: int
+    reference: Reference
+
+
+@dataclass
+class Request:
+    kind: str
+    coordinate: object
+    reference: object = None
+    reverse_adapter: bool = False
+    child_kind: str = ""
+    field: int = 0
+    reverse: bool = False
+    negative_inverse: bool = False
+    half: bool = False
+
+
+@dataclass(frozen=True)
+class Plan:
+    dimension: int
+    rank: int
+    good: bool
+    commands: tuple
+    reductions: tuple = ()
+    permutation: tuple = ()
+    negative_sign: bool = False
+
+
+def compile_plan(low_projector, rank, q, good):
+    """Host arithmetic here depends only on the fixed prime/low vocabulary."""
+    m = len(low_projector)
+    need(1 <= rank < m <= 64, "compiled residual dimension")
+    if good:
+        commands = []
+        index = 0
+        for k in range(rank):
+            for i in range(k+1, m):
+                commands.append(Command("add", i, k, Reference("head", index, i, k)))
+                index += 1
+        index = 0
+        for k in range(rank):
+            column = m-1-k
+            for source in range(column):
+                commands.append(Command("add", m+column, m+source,
+                                        Reference("tail", index, sign=-1)))
+                index += 1
+        for i in range(m):
+            for k in range(m):
+                commands.append(Command("add", m+i, k, Reference("cross", i*m+k, i, k)))
+        return Plan(m, rank, True, tuple(commands))
+    size = 2*m
+    rows = [[0]*size for _ in range(size)]
+    for i in range(m):
+        for j in range(m):
+            rows[i][j] = rows[size-1-i][size-1-j] = (int(i == j)-low_projector[i][j]) % q
+            rows[i][size-1-j] = rows[size-1-i][j] = low_projector[i][j] % q
+    permutation, reductions = list(range(size)), []
+    for j in range(size):
+        pivot = next(i for i in range(j, size) if rows[i][j] % q)
+        if pivot != j:
+            reductions.append(("swap", j, pivot, tuple(permutation)))
+            rows[j], rows[pivot] = rows[pivot], rows[j]
+            permutation[j], permutation[pivot] = permutation[pivot], permutation[j]
+        inverse = pow(rows[j][j], -1, q)
+        for i in range(size):
+            if i != j:
+                coefficient = -rows[i][j]*inverse % q
+                reductions.append(("shear", i, j, tuple(permutation)))
+                rows[i] = [(x+coefficient*y) % q for x, y in zip(rows[i], rows[j])]
+    sign = prod(rows[i][i] for i in range(size)) % q
+    need(sign in (1, q-1), "compiled terminal sign")
+    commands = []
+    unit = Reference("unit")
+    for i in range(size-1):
+        commands.append(Command("child", i, size-1, unit))
+        commands.append(Command("child", i, size-1, Reference("pair", i, i, size-1,
+                                                              tuple(permutation))))
+    if sign != 1:
+        commands.append(Command("sign", size-1, -1, Reference("fixed", sign=-1)))
+    for index in range(len(reductions)-1, -1, -1):
+        kind, i, k, snapshot = reductions[index]
+        if kind == "swap":
+            commands.append(Command("child", i, k, unit))
+        else:
+            reference = Reference("shear", index, i, k, snapshot, -1)
+            if i > k:
+                commands.append(Command("add", i, k, reference))
+            else:
+                commands.extend((Command("child", i, k, unit), Command("add", k, i, reference),
+                                 Command("child", i, k, unit)))
+    return Plan(m, rank, False, tuple(commands), tuple(reductions), tuple(permutation), sign != 1)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py
new file mode 100644
index 0000000000..4f00467a0f
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/records.py
@@ -0,0 +1,271 @@
+"""Sequential binary program/field records and typed continuation stacks.
+
+Runtime numerical words copy between tapes. Only tags, source codes, ranks
+and row labels enter fixed finite control. Fixture encoding is separate.
+"""
+from words import BLANK, LEFT, ONE, RIGHT, ZERO, Meter, Unsigned, need
+
+WORD_END, RECORD_END = 5, 6
+ROOT, STEP, VALUE, CONSTANT, MULTIPLY, PAIR, RETURN = range(7, 14)
+FINITE_BITS = 16  # Fixed vocabulary width for this compiled source instance.
+
+
+class Tape:
+    def __init__(self):
+        self.cells = bytearray([LEFT])
+        self.head = 1
+        self.meter = Meter()
+
+    def read(self):
+        self.meter.reads += 1
+        return self.cells[self.head] if self.head < len(self.cells) else BLANK
+
+    def write(self, symbol):
+        need(ZERO <= symbol <= RETURN, "fixed record alphabet")
+        self.meter.writes += 1
+        if self.head >= len(self.cells):
+            self.cells.extend([BLANK]*(self.head+1-len(self.cells)))
+        self.cells[self.head] = symbol
+
+    def step(self, direction):
+        need(direction in (-1, 1), "unit record-head move")
+        self.head += direction
+        need(self.head >= 0, "local record boundary")
+        self.meter.moves += 1
+
+    def append(self, symbol):
+        need(self.read() == BLANK, "append at record blank")
+        self.write(symbol)
+        self.step(1)
+
+    def rewind(self):
+        self.step(-1)
+        while self.read() != LEFT:
+            self.step(-1)
+        self.step(1)
+
+    def clear(self):
+        self.rewind()
+        while self.read() != BLANK:
+            self.write(BLANK)
+            self.step(1)
+        self.rewind()
+
+
+def append_word(tape, word):
+    word.rewind()
+    while word.read() != RIGHT:
+        tape.append(word.read())
+        word.step(1)
+    tape.append(WORD_END)
+    word.rewind()
+
+
+def read_word(tape, arena):
+    out = arena.zero()
+    while tape.read() != WORD_END:
+        bit = tape.read()
+        need(bit in (ZERO, ONE) and out.read() != RIGHT, "encoded word extent")
+        out.write(bit)
+        out.step(1)
+        tape.step(1)
+    need(out.read() == RIGHT, "complete encoded word")
+    tape.step(1)
+    out.rewind()
+    return out
+
+
+def append_finite(tape, value, bits=FINITE_BITS):
+    """Compile-time finite source/operation tag encoding."""
+    need(0 <= value < 1 << bits, "compiled finite vocabulary")
+    for bit in range(bits):
+        tape.append((value >> bit) & 1)
+    tape.append(WORD_END)
+
+
+def read_finite(tape, bits=FINITE_BITS):
+    # The accumulator ranges over a fixed finite set, independent of e/w/h.
+    state = 0
+    for bit in range(bits):
+        value = tape.read()
+        need(value in (ZERO, ONE), "finite label bit")
+        state |= value << bit
+        tape.step(1)
+    need(tape.read() == WORD_END, "finite label delimiter")
+    tape.step(1)
+    return state
+
+
+def seek_record(tape, index):
+    machine, arena = Unsigned(index.arena), index.arena
+    remaining, one = arena.copy(index), arena.literal(1)
+    tape.rewind()
+    while not remaining.zero():
+        while tape.read() != RECORD_END:
+            need(tape.read() != BLANK, "record exists at global slot")
+            tape.step(1)
+        tape.step(1)
+        after = machine.subtract_exact(remaining, one)
+        arena.free(remaining)
+        remaining = after
+    arena.free_many(remaining, one)
+
+
+class Stack:
+    def __init__(self, index_arena, residue_arena):
+        self.index_arena, self.residue_arena = index_arena, residue_arena
+        self.tape, self.reverse = Tape(), Tape()
+
+    def empty(self):
+        self.tape.step(-1)
+        result = self.tape.read() == LEFT
+        self.tape.step(1)
+        return result
+
+    def push(self, tag, *words):
+        need(tag in (VALUE, CONSTANT, MULTIPLY, PAIR, RETURN), "continuation kind")
+        need(len(words) == (2 if tag == VALUE else 1), "continuation arity")
+        self.tape.append(tag)
+        for word in words:
+            append_word(self.tape, word)
+        self.tape.append(RECORD_END)
+
+    def pop(self):
+        need(not self.empty(), "nonempty continuation stack")
+        tape, reverse = self.tape, self.reverse
+        tape.step(-1)
+        need(tape.read() == RECORD_END, "continuation top delimiter")
+        tape.write(BLANK)
+        tape.step(-1)
+        while tape.read() not in (LEFT, RECORD_END):
+            reverse.append(tape.read())
+            tape.write(BLANK)
+            tape.step(-1)
+        tape.step(1)
+        reverse.step(-1)
+        tag = reverse.read()
+        need(tag in (VALUE, CONSTANT, MULTIPLY, PAIR, RETURN), "encoded continuation kind")
+        reverse.write(BLANK)
+        reverse.step(-1)
+        arenas = (self.index_arena, self.index_arena) if tag == VALUE else (self.residue_arena,)
+        words = []
+        for arena in arenas:
+            out = arena.zero()
+            while reverse.read() != WORD_END:
+                bit = reverse.read()
+                need(bit in (ZERO, ONE) and out.read() != RIGHT, "continuation binary word")
+                out.write(bit)
+                out.step(1)
+                reverse.write(BLANK)
+                reverse.step(-1)
+            need(out.read() == RIGHT, "complete continuation operand")
+            reverse.write(BLANK)
+            reverse.step(-1)
+            out.rewind()
+            words.append(out)
+        need(reverse.read() == LEFT, "complete continuation record")
+        reverse.step(1)
+        return tag, tuple(words)
+
+
+class Program:
+    """Encoded root and admitted chronological steps; numerical fields are words."""
+    def __init__(self, index_arena, residue_arena, code_bits=FINITE_BITS):
+        self.index_arena, self.residue_arena = index_arena, residue_arena
+        self.code_bits = code_bits
+        self.tape = Tape()
+
+    def root(self):
+        self.tape.rewind()
+        need(self.tape.read() == ROOT, "root record")
+        self.tape.step(1)
+        size = read_word(self.tape, self.index_arena)
+        unit = read_word(self.tape, self.residue_arena)
+        depth = read_word(self.tape, self.index_arena)
+        need(self.tape.read() == RECORD_END, "root record end")
+        self.tape.rewind()
+        return size, unit, depth
+
+    def step(self, level):
+        need(not level.zero(), "positive step level")
+        seek_record(self.tape, level)
+        need(self.tape.read() == STEP, "step record")
+        self.tape.step(1)
+        metadata = tuple(read_finite(self.tape, self.code_bits if field == 1 else FINITE_BITS)
+                         for field in range(6))
+        parent = read_word(self.tape, self.index_arena)
+        child = read_word(self.tape, self.index_arena)
+        need(self.tape.read() == RECORD_END, "step record end")
+        self.tape.rewind()
+        return metadata, parent, child
+
+    @classmethod
+    def fixture(cls, index_arena, residue_arena, root_size, root_unit, events, code_bits=FINITE_BITS):
+        """Fixture-only serialization; runtime computes and validates extents."""
+        out = cls(index_arena, residue_arena, code_bits)
+        out.tape.append(ROOT)
+        for arena, value in ((index_arena, root_size), (residue_arena, root_unit), (index_arena, len(events))):
+            word = arena.input(value)
+            append_word(out.tape, word)
+            arena.free(word)
+        out.tape.append(RECORD_END)
+        size = root_size
+        for kind, code, rank, field, reverse, half in events:
+            f = size//64
+            child = rank*f if kind == 0 else f//2 if half else f
+            out.tape.append(STEP)
+            for field_index, label in enumerate((kind, code, rank, field, int(reverse), int(half))):
+                append_finite(out.tape, label, code_bits if field_index == 1 else FINITE_BITS)
+            for value in (size, child):
+                word = index_arena.input(value)
+                append_word(out.tape, word)
+                index_arena.free(word)
+            out.tape.append(RECORD_END)
+            size = child
+        out.tape.rewind()
+        return out
+
+
+class Fields:
+    def __init__(self, index_arena, residue_arena, code_bits=FINITE_BITS):
+        self.index_arena, self.residue_arena = index_arena, residue_arena
+        self.code_bits = code_bits
+        self.tape = Tape()
+
+    def check_code(self, slot, code):
+        seek_record(self.tape, slot)
+        observed = read_finite(self.tape, self.code_bits)
+        self.tape.rewind()
+        need(observed == code, "original global raw-field code")
+
+    def end(self, after):
+        seek_record(self.tape, after)
+        complete = self.tape.read() == BLANK
+        self.tape.rewind()
+        need(complete, "exact frozen/current field prefix")
+
+    def read(self, slot, code, depth):
+        need(Unsigned(self.index_arena).compare(slot, depth) < 0, "frozen field excludes current/future slot")
+        seek_record(self.tape, slot)
+        observed = read_finite(self.tape, self.code_bits)
+        need(observed == code, "exact encoded raw-field specification")
+        out = [[read_word(self.tape, self.residue_arena) for _ in range(64)] for _ in range(64)]
+        need(self.tape.read() == RECORD_END, "complete 64-dimensional raw high field")
+        self.tape.rewind()
+        return out
+
+    @classmethod
+    def fixture(cls, index_arena, residue_arena, fields, code_bits=FINITE_BITS):
+        """Load canonical raw-field fixture data before measured execution."""
+        out = cls(index_arena, residue_arena, code_bits)
+        for code, high in fields:
+            append_finite(out.tape, code, code_bits)
+            need(len(high) == 64 and all(len(row) == 64 for row in high), "field fixture shape")
+            for row in high:
+                for value in row:
+                    word = residue_arena.input(value)
+                    append_word(out.tape, word)
+                    residue_arena.free(word)
+            out.tape.append(RECORD_END)
+        out.tape.rewind()
+        return out
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py
new file mode 100644
index 0000000000..35531201dc
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/routes.py
@@ -0,0 +1,249 @@
+"""Owner/common high-cube routes by binary keys and sequential stable passes."""
+from dataclasses import dataclass
+from fractions import Fraction
+
+from bitstream import copy_bits
+from counts import Count
+from directory import Odometer, append_tape
+from matrices import Matrices
+from records import WORD_END, Tape, append_word, read_word
+from stream import Counter
+from words import BLANK, ONE, RIGHT, ZERO, need
+
+
+@dataclass(frozen=True)
+class Route:
+    q: int
+    dimension: int
+    low: tuple
+    target_low: tuple
+    chart: tuple
+
+
+def compile_route(low, chart, vocabulary):
+    """Compile fixed labels only; no input modulus or high digit is available."""
+    import oracle
+    q, dimension = vocabulary.q, vocabulary.dimension
+    vocabulary.rank(low)
+    need(len(chart) == dimension and all(len(row) == dimension for row in chart), "fixed chart shape")
+    chart = tuple(tuple(Fraction(x) for x in row) for row in chart)
+    reduced = oracle.reduce_rational(chart, q)
+    oracle.inverse(reduced, q)
+    target = tuple(map(tuple, oracle.multiply(low, reduced, q)))
+    vocabulary.rank(target)
+    return Route(q, dimension, tuple(map(tuple, low)), target, chart)
+
+
+def inverse_rational(matrix):
+    """Fixed source compilation; fractions never enter measured payload loops."""
+    size = len(matrix)
+    rows = [[Fraction(x) for x in row]+[Fraction(i == j) for j in range(size)]
+            for i, row in enumerate(matrix)]
+    for column in range(size):
+        pivot = next((i for i in range(column, size) if rows[i][column]), None)
+        need(pivot is not None, "invertible fixed rational chart")
+        rows[column], rows[pivot] = rows[pivot], rows[column]
+        scale = rows[column][column]
+        rows[column] = [x/scale for x in rows[column]]
+        for i in range(size):
+            if i != column:
+                factor = rows[i][column]
+                rows[i] = [x-factor*y for x, y in zip(rows[i], rows[column])]
+    return tuple(tuple(row[size:]) for row in rows)
+
+
+def high_key(high, route, chart, context):
+    matrices, arena = Matrices(context.ring), context.arena
+    raw = matrices.raw_header(route.low, high, context.q)
+    common = matrices.multiply(raw, chart)
+    matrices.free(raw)
+    divisor = arena.literal(context.q)
+    keys = []
+    try:
+        for i in range(context.dimension):
+            row = []
+            keys.append(row)
+            for j in range(context.dimension):
+                low = arena.literal(route.target_low[i][j])
+                difference = context.raw.subtract_exact(common[i][j], low)
+                quotient, remainder = context.raw.divmod(difference, divisor)
+                arena.free_many(low, difference)
+                valid = remainder.zero() and context.raw.compare(quotient, context.cap) < 0
+                arena.free(remainder)
+                row.append(quotient)
+                need(valid, "exact routed low class and high carry")
+        return keys
+    except ValueError:
+        matrices.free(keys)
+        raise
+    finally:
+        matrices.free(common)
+        arena.free(divisor)
+
+
+def copy_key(source, output, context, selected=None, cursor=None):
+    bit = ZERO
+    template = context.arena.template
+    for coordinate in range(context.dimension*context.dimension):
+        template.rewind()
+        if coordinate == selected:
+            cursor.rewind()
+        while template.read() != RIGHT:
+            value = source.read()
+            need(value in (ZERO, ONE), "complete binary route key")
+            if coordinate == selected:
+                if cursor.read() == ONE:
+                    bit = value
+                cursor.step(1)
+            output.append(value)
+            source.step(1)
+            template.step(1)
+        need(source.read() == WORD_END, "route key word extent")
+        output.append(WORD_END)
+        source.step(1)
+        template.rewind()
+        if coordinate == selected:
+            cursor.rewind()
+    return bit
+
+
+def copy_rows(source, output, count, fibre):
+    remaining = Counter(count)
+    try:
+        while not remaining.finished:
+            copy_bits(source, output, fibre)
+            remaining.decrement()
+    finally:
+        remaining.close()
+
+
+def partition(source, coordinate, cursor, context, fibre, factory):
+    buckets = (factory(), factory())
+    counts = (Count.literal(0), Count.literal(0))
+    records = Counter(context.highs)
+    output = factory()
+    try:
+        while not records.finished:
+            key = Tape()
+            try:
+                bit = copy_key(source, key, context, coordinate, cursor)
+                append_tape(key, buckets[bit])
+                copy_bits(source, buckets[bit], fibre)
+                counts[bit].increment()
+            finally:
+                key.clear()
+            records.decrement()
+        need(source.read() == BLANK, "complete route partition")
+        source.rewind()
+        for bucket, count in zip(buckets, counts):
+            bucket.rewind()
+            remaining = Counter(count)
+            while not remaining.finished:
+                copy_key(bucket, output, context)
+                copy_bits(bucket, output, fibre)
+                remaining.decrement()
+            remaining.close()
+            need(bucket.read() == BLANK, "complete stable route bucket")
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        records.close()
+        for bucket, count in zip(buckets, counts):
+            bucket.clear()
+            count.close()
+
+
+def route_cube(source, route, context, fibre, factory=Tape):
+    need((route.q, route.dimension) == (context.q, context.dimension), "route/context binding")
+    matrices, arena = Matrices(context.ring), context.arena
+    chart = matrices.constants(route.chart)
+    high, decorated = Odometer(context), factory()
+    source.rewind()
+    current, output = decorated, None
+    try:
+        while not high.finished:
+            key = high_key(high.digits, route, chart, context)
+            for row in key:
+                for digit in row:
+                    append_word(decorated, digit)
+            matrices.free(key)
+            copy_bits(source, decorated, fibre)
+            high.advance()
+        need(source.read() == BLANK, "complete source high cube")
+        source.rewind()
+        decorated.rewind()
+        if context.raw.compare(context.cap, context.ring.one) > 0:
+            for coordinate in reversed(range(context.dimension*context.dimension)):
+                cursor = arena.copy(context.ring.one)
+                try:
+                    while True:
+                        following = partition(current, coordinate, cursor, context, fibre, factory)
+                        current.clear()
+                        current = following
+                        cursor.msb()
+                        final = cursor.read() == ONE
+                        cursor.rewind()
+                        if final:
+                            break
+                        shifted = context.raw.shift_add_bit(cursor, ZERO)
+                        arena.free(cursor)
+                        cursor = shifted
+                finally:
+                    arena.free(cursor)
+        high.close()
+        high = Odometer(context)
+        output = factory()
+        while not high.finished:
+            for row in high.digits:
+                for expected in row:
+                    actual = read_word(current, arena)
+                    valid = context.raw.compare(actual, expected) == 0
+                    arena.free(actual)
+                    need(valid, "complete bijective routed high order")
+            copy_bits(current, output, fibre)
+            high.advance()
+        need(current.read() == BLANK, "complete routed key removal")
+        output.rewind()
+        return output
+    except ValueError:
+        if output is not None:
+            output.clear()
+        raise
+    finally:
+        current.clear()
+        high.close()
+        matrices.free(chart)
+        source.rewind()
+
+
+def route_packet(source, route, context, old_count, fibre, factory=Tape):
+    outer, output = Counter(old_count), factory()
+    source.rewind()
+    try:
+        need(not outer.finished, "positive route prefix count")
+        while not outer.finished:
+            local = factory()
+            try:
+                copy_rows(source, local, context.highs, fibre)
+                local.rewind()
+                changed = route_cube(local, route, context, fibre, factory)
+                try:
+                    copy_rows(changed, output, context.highs, fibre)
+                    need(changed.read() == BLANK, "closed routed prefix")
+                finally:
+                    changed.clear()
+            finally:
+                local.clear()
+            outer.decrement()
+        need(source.read() == BLANK, "complete old-prefix route")
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        outer.close()
+        source.rewind()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py
new file mode 100644
index 0000000000..2c28f1aaec
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/selection.py
@@ -0,0 +1,71 @@
+"""Gather/scatter one low class at its original positions in a complete family."""
+from bitstream import copy_bits
+from counts import Count, high_power
+from records import Tape
+from routes import copy_rows
+from stream import Counter
+from words import BLANK, ONE, ZERO, need
+
+
+def discard_rows(source, count, fibre):
+    rows = Counter(count)
+    try:
+        while not rows.finished:
+            bits = Counter(fibre)
+            while not bits.finished:
+                need(source.read() in (ZERO, ONE), "complete skipped payload")
+                source.step(1)
+                bits.decrement()
+            bits.close()
+            rows.decrement()
+    finally:
+        rows.close()
+
+
+def packet_operation(source, context, old_count, low, fibre, replacement=None, factory=Tape):
+    # The ordinal and vocabulary cardinality belong to fixed-q compilation.
+    ordinal = context.codes.rank(low)
+    before = Count.literal(ordinal)
+    after = Count.literal(context.codes.size-ordinal-1)
+    high_power(before, context.ring, context.q, context.dimension)
+    high_power(after, context.ring, context.q, context.dimension)
+    outer, output = Counter(old_count), factory()
+    source.rewind()
+    if replacement is not None:
+        replacement.rewind()
+    try:
+        need(not outer.finished, "positive physical old-prefix count")
+        while not outer.finished:
+            if replacement is None:
+                discard_rows(source, before, fibre)
+                copy_rows(source, output, context.highs, fibre)
+                discard_rows(source, after, fibre)
+            else:
+                copy_rows(source, output, before, fibre)
+                discard_rows(source, context.highs, fibre)
+                copy_rows(replacement, output, context.highs, fibre)
+                copy_rows(source, output, after, fibre)
+            outer.decrement()
+        need(source.read() == BLANK, "complete selected family")
+        if replacement is not None:
+            need(replacement.read() == BLANK, "complete packet replacement")
+        output.rewind()
+        return output
+    except ValueError:
+        output.clear()
+        raise
+    finally:
+        before.close()
+        after.close()
+        outer.close()
+        source.rewind()
+        if replacement is not None:
+            replacement.rewind()
+
+
+def gather(source, context, old_count, low, fibre, factory=Tape):
+    return packet_operation(source, context, old_count, low, fibre, factory=factory)
+
+
+def scatter(source, replacement, context, old_count, low, fibre, factory=Tape):
+    return packet_operation(source, context, old_count, low, fibre, replacement, factory)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py
new file mode 100644
index 0000000000..16d5e7e6a2
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/sources.py
@@ -0,0 +1,148 @@
+"""Compile fixed selected rational labels and low classes.
+
+This stage depends on q and the fixed selected catalogue, never on the input
+width or high digits. Runtime inverses and coefficients come from words.py.
+The selection/chart conventions adapt PR2234 and PR2405 with attribution.
+"""
+from dataclasses import dataclass
+from fractions import Fraction as F
+from hashlib import sha256
+import importlib.util
+import json
+from pathlib import Path
+
+from words import need
+
+
+ROOT = Path(__file__).resolve().parents[3]
+
+
+def identity(n):
+    return [[F(i == j) for j in range(n)] for i in range(n)]
+
+
+def product(a, b):
+    out = [[F(0) for _ in b[0]] for _ in a]
+    for i, row in enumerate(a):
+        for k, x in enumerate(row):
+            if x:
+                for j, y in enumerate(b[k]):
+                    if y:
+                        out[i][j] += x*y
+    return out
+
+
+def independent_columns(matrix, q):
+    # q is fixed when compiling the finite source vocabulary.
+    rows = [[x.numerator*pow(x.denominator, -1, q) % q for x in row] for row in matrix]
+    rank, chosen = 0, []
+    for j in range(len(matrix[0])):
+        pivot = next((i for i in range(rank, len(rows)) if rows[i][j]), None)
+        if pivot is None:
+            continue
+        rows[rank], rows[pivot] = rows[pivot], rows[rank]
+        inv = pow(rows[rank][j], -1, q)
+        rows[rank] = [x*inv % q for x in rows[rank]]
+        for i in range(len(rows)):
+            if i != rank and rows[i][j]:
+                c = rows[i][j]
+                rows[i] = [(x-c*y) % q for x, y in zip(rows[i], rows[rank])]
+        chosen.append(j)
+        rank += 1
+        if rank == len(rows):
+            break
+    return chosen
+
+
+@dataclass(frozen=True)
+class Template:
+    q: int
+    rank: int
+    record: tuple
+    base: tuple
+    chart: tuple
+    preparation: tuple
+
+
+@dataclass(frozen=True)
+class Specification:
+    code: int
+    template: Template
+    low: tuple
+    good: bool
+
+
+def compile_specification(code, template, low):
+    """Compile the finite low-class branch, with no width/high input."""
+    import oracle
+    q = template.q
+    need(len(low) == 64 and all(len(row) == 64 and all(0 <= x < q for x in row) for row in low),
+         "fixed raw low class")
+    h = oracle.multiply(low, oracle.reduce_rational(template.preparation, q), q)
+    inv = oracle.inverse(h, q)
+    p = oracle.multiply([row[:template.rank] for row in h], inv[:template.rank], q)
+    try:
+        oracle.good_pivots(p, template.rank, q)
+        good = True
+    except ValueError:
+        good = False
+    return Specification(code, template, tuple(map(tuple, low)), good)
+
+
+def compile_templates(q=3):
+    path = ROOT / "research/pr589-five-helper-hosting/verify.py"
+    spec = importlib.util.spec_from_file_location("retained_binary_control_source", path)
+    old = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(old)
+    word, host, geometry = (old.read(p) for p in (old.WORD, old.HOST, old.GEO))
+    call = host["calls"][0]
+    program = host["local_programs"][call["orientation"]]
+    idles = {event["idx"]: event for event in host["schedule"] if event["kind"] == "idle"}
+    templates = []
+    for position, op, role, key in (
+        (21816, 2, 472, "c097fc120eea0e30ceaae6f2f6bad489ec86945dfecb852fb50c2d46d64185cd"),
+        (18085, 0, 222, "5a7dce9c52ac8c9c23fa89766439abfc412b5242b444945289a83828ffa9ae6d"),
+    ):
+        event = program[position]
+        need(event[:2] == [op, role], "exact selected literal")
+        a, b, rank = event[3:6] if op == 2 else event[2:5]
+        pa, ra = old.projection([word["lines"][i] for i in word["frames"][a]])
+        pb, rb = old.projection([word["lines"][i] for i in word["frames"][b]])
+        lo, hi = (pa, pb) if ra <= rb else (pb, pa)
+        local = old.sub(hi, lo)
+        observed = sha256(json.dumps(["local", rank, [[str(x) for x in row] for row in local]],
+                                    sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+        need(observed == key and abs(ra-rb) == rank, "selected projector identity")
+        base = [[F(0) for _ in range(64)] for _ in range(64)]
+        for i in range(8):
+            base[i][:8] = local[i]
+        family, route = call["owners"][role]
+        need(route[0] == "hosted", "selected hosted source")
+        _, child, offset, width = route
+        axes = old.pending_axes(idles[child])[offset:offset+width]
+        port = family % 111 if min(axes) < 8 else -1
+        chart = identity(64)
+        if op != 2:
+            if port >= 0:
+                entry = geometry["ports"][port]
+                for i in range(8):
+                    chart[i][:8] = [F(entry["q"][i], 2)] + list(map(F, entry["complement_columns"][i]))
+            pi = list(range(64))
+            for i, j in zip(sorted(set(range(8))-set(axes)), sorted(set(axes)-set(range(8)))):
+                pi[i], pi[j] = j, i
+            chart = [[row[pi[j]] for j in range(64)] for row in chart]
+        complement = [[F(i == j)-base[i][j] for j in range(64)] for i in range(64)]
+        image, kernel = independent_columns(base, q), independent_columns(complement, q)
+        need((len(image), len(kernel)) == (rank, 64-rank), "fixed low-field split basis")
+        basis = [[base[i][j] for j in image] + [complement[i][j] for j in kernel] for i in range(64)]
+        # PB=BE over the rationals, before any input-width modulus exists.
+        projected_basis = [[basis[i][j] if j < rank else F(0) for j in range(64)] for i in range(64)]
+        need(product(base, basis) == projected_basis and len(independent_columns(basis, q)) == 64,
+             "rational split basis with unit determinant modulo fixed q")
+        preparation = product(chart, basis)
+        record = ("COPY" if op == 2 else "MOVE", 0, position, role,
+                  host["live"] if op == 2 else family, a, b, key, rank,
+                  "common" if op == 2 else "owner", tuple(axes), port)
+        templates.append(Template(q, rank, record, tuple(map(tuple, base)), tuple(map(tuple, chart)),
+                                  tuple(map(tuple, preparation))))
+    return tuple(templates)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py
new file mode 100644
index 0000000000..5e5a4bb0f9
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/predecessor/vendor/stream.py
@@ -0,0 +1,163 @@
+"""Binary-counted complete-fibre ADD using an encoded coefficient callback.
+
+Each arbitrary spectator extent has its own canonical word length. None
+enters the coefficient context. Payload bits remain opaque to the arithmetic.
+"""
+from records import Tape
+from words import BLANK, LEFT, ONE, RIGHT, ZERO, need
+
+
+class Counter:
+    """Canonical variable-length countdown with amortized ripple movement."""
+    def __init__(self, word):
+        self.tape = Tape()
+        word.rewind()
+        while word.read() != RIGHT:
+            self.tape.append(word.read())
+            word.step(1)
+        word.rewind()
+        self.tape.append(RIGHT)
+        self.tape.step(-1)
+        self.tape.step(-1)
+        while self.tape.read() == ZERO:
+            self.tape.write(RIGHT)
+            self.tape.step(1)
+            self.tape.write(BLANK)
+            self.tape.step(-1)
+            self.tape.step(-1)
+        self.finished = self.tape.read() == LEFT
+        if self.finished:
+            self.tape.step(1)
+            self.tape.write(ZERO)
+            self.tape.step(1)
+            self.tape.write(RIGHT)
+        self.tape.rewind()
+
+    def decrement(self):
+        need(not self.finished, "positive countdown")
+        tape = self.tape
+        while tape.read() == ZERO:
+            tape.write(ONE)
+            tape.step(1)
+        need(tape.read() == ONE, "canonical positive counter")
+        tape.write(ZERO)
+        tape.step(1)
+        if tape.read() == RIGHT:
+            tape.write(BLANK)
+            tape.step(-1)
+            tape.step(-1)
+            if tape.read() == LEFT:
+                tape.step(1)
+                tape.write(ZERO)
+                tape.step(1)
+                tape.write(RIGHT)
+                self.finished = True
+            else:
+                tape.step(1)
+                tape.write(RIGHT)
+        tape.rewind()
+
+    def close(self):
+        self.tape.clear()
+
+
+def positive_extent(word):
+    """Reject padding inherited from a different, larger spectator extent."""
+    word.msb()
+    margin = word.read()
+    word.step(-1)
+    significant = word.read()
+    word.rewind()
+    need(margin == ZERO and significant == ONE, "separately canonical positive spectator extent")
+
+
+def one_bit_suffix(word):
+    """Recognize the fixed encodings of one, without decoding a cardinality."""
+    word.rewind()
+    if word.read() != ONE:
+        return False
+    word.step(1)
+    if word.read() == ZERO:
+        word.step(1)
+    result = word.read() == RIGHT
+    word.rewind()
+    return result
+
+
+def copy_blocks(source, target, count, suffix, observe):
+    blocks = Counter(count)
+    single = one_bit_suffix(suffix)
+    while not blocks.finished:
+        if single:
+            bit = source.read()
+            need(bit in (ZERO, ONE), "opaque payload bit")
+            target.append(bit)
+            source.step(1)
+        else:
+            bits = Counter(suffix)
+            while not bits.finished:
+                bit = source.read()
+                need(bit in (ZERO, ONE), "opaque payload bit")
+                target.append(bit)
+                source.step(1)
+                bits.decrement()
+            bits.close()
+            observe(bits)
+        blocks.decrement()
+    blocks.close()
+    observe(blocks)
+
+
+def add_pass(source, ring, before, middle, suffix, prepare_coefficient, payload_factory=Tape):
+    for extent in (before, middle, suffix):
+        positive_extent(extent)
+    left, right, out = payload_factory(), payload_factory(), payload_factory()
+    totals = {"reads": 0, "writes": 0, "moves": 0}
+    def observe(counter):
+        # External meter only; no count controls execution.
+        for key in totals:
+            totals[key] += getattr(counter.tape.meter, key)
+    def traverse(merge):
+        coefficient = prepare_coefficient()
+        need(ring.raw.compare(coefficient, ring.modulus) < 0, "canonical encoded coefficient")
+        outer = Counter(before)
+        while not outer.finished:
+            x = ring.arena.zero()
+            sources = Counter(ring.modulus)
+            while not sources.finished:
+                offset = ring.multiply(coefficient, x)
+                leading = ring.raw.subtract_exact(ring.modulus, offset)
+                mid = Counter(middle)
+                while not mid.finished:
+                    if merge:
+                        copy_blocks(right, out, offset, suffix, observe)
+                        copy_blocks(left, out, leading, suffix, observe)
+                    else:
+                        copy_blocks(source, left, leading, suffix, observe)
+                        copy_blocks(source, right, offset, suffix, observe)
+                    mid.decrement()
+                mid.close()
+                observe(mid)
+                ring.arena.free_many(offset, leading)
+                sources.decrement()
+                if not sources.finished:
+                    ring.raw.increment_in_place(x)
+            sources.close()
+            observe(sources)
+            ring.arena.free(x)
+            outer.decrement()
+        outer.close()
+        observe(outer)
+        ring.arena.free(coefficient)
+    traverse(False)
+    need(source.read() == BLANK, "complete input extent")
+    source.rewind()
+    left.rewind()
+    right.rewind()
+    traverse(True)
+    need(left.read() == right.read() == BLANK, "complete split consumption")
+    left.clear()
+    right.clear()
+    out.rewind()
+    return out, {"counters": totals, "left": left.meter.record(), "right": right.meter.record(),
+                 "output": out.meter.record()}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/recursive_call.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/recursive_call.py
new file mode 100644
index 0000000000..6d33224145
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/recursive_call.py
@@ -0,0 +1,110 @@
+"""Complete generated child on one packet, with separately charged frame work.
+
+The parent's frozen fields are the child's old directory. The unused U
+coordinate alone supplies fresh rows; address spectators are never borrowed.
+"""
+from cardinal_counts import Count
+from children import extend
+from controller import Callback
+from directory import Context, append_tape
+from packet import read_prefix
+from plan import Request
+from records import Fields, Program
+from words import Arena, RIGHT, Ring, Unsigned, need
+
+REGISTER_CAPACITY=1 << 24
+
+
+def copy_word(source,arena):
+    """Copy an encoded value to a separate frame bank without decoding it."""
+    out=arena.zero()
+    source.rewind()
+    try:
+        while source.read()!=RIGHT:
+            need(out.read()!=RIGHT,"equal frame word extents")
+            out.write(source.read());source.step(1);out.step(1)
+        need(out.read()==RIGHT,"complete frame word copy")
+        out.rewind();return out
+    except ValueError:
+        arena.free(out);raise
+    finally:source.rewind()
+
+
+class Frame:
+    def __init__(self,parent,program,event):
+        # bits describes the existing physical word template, not a decoded
+        # width, residue or address. Both frames have identical templates.
+        self.arena=Arena(parent.context.arena.bits,REGISTER_CAPACITY)
+        self.indices=Arena(parent.indices.bits,REGISTER_CAPACITY)
+        self.modulus=self.ring=self.context=self.program=self.size=self.depth=self.node=None
+        try:
+            self.modulus=copy_word(parent.context.ring.modulus,self.arena)
+            self.ring=Ring(self.modulus)
+            self.context=Context(self.ring,parent.context.codes)
+            self.program=Program(self.indices,self.arena,program.code_bits)
+            append_tape(program.tape,self.program.tape);self.program.tape.rewind()
+            self.size=copy_word(event.width,self.indices)
+            self.depth=copy_word(event.depth,self.indices)
+            from node import SelectedNode
+            self.node=SelectedNode(self.context,self.indices,self.program,self.size,self.depth,
+                                   parent.specifications.catalogue,parent.specifications)
+        except BaseException:
+            # The caller cannot close a constructor that never returned.
+            # These are fresh, separate banks, so every remaining word belongs
+            # to this failed frame, including partial child initialization.
+            if self.program is not None:self.program.tape.clear()
+            if self.context is not None:self.context.close()
+            if self.ring is not None:self.ring.close()
+            self.indices.rollback(frozenset())
+            self.arena.rollback(frozenset())
+            raise
+
+    def close(self):
+        self.program.tape.clear()
+        self.indices.free_many(self.size,self.depth)
+        self.context.close();self.ring.close();self.arena.free(self.modulus)
+        need(not self.indices.live and not self.arena.live,"recursive frame numerical restoration")
+
+
+def child_call(parent,source,event,layout,directory,prefixes,fields,stock,before):
+    need(stock is not None and before is not None,"independent child row-stock and spectators")
+    context,indices=parent.context,parent.indices
+    need(event.parent_identity is parent.program and event.source_code==layout.geometry.source_code,
+         "recursive call belongs to the frozen parent")
+    raw=Unsigned(indices)
+    need(raw.compare(event.width,parent.parent_size)<0,"strict recursive contraction")
+    extents=layout.child_extents(event.first,event.second,event.width,before=before)
+    extended=frame=callback=result=None
+    returned=False
+    first=None
+    try:
+        directory.rewind();first=read_prefix(directory,fields);directory.rewind()
+        prefix=Fields(indices,context.arena,context.codes.bits);prefix.tape=first
+        callback=Callback(context.ring,indices,parent.program,prefix,parent.specifications,
+                          event.source_code,allow_fallback=True)
+        zero=indices.zero()
+        try:
+            request=Request("child",zero,child_kind=event.child_kind,field=event.field,
+                            reverse=event.reverse,half=event.half)
+            extended=extend(callback,request)
+        finally:indices.free(zero)
+        callback.close();callback=None
+        # Descriptor depends only on ancestor program and the finite branch;
+        # the representative high prefix is not used to pick children.
+        frame=Frame(parent,extended,event)
+        extended.tape.clear();extended=None
+        first.clear();first=None
+        from scheduler import Invocation
+        result=yield Invocation(frame.node.run_generator(source,directory,prefixes,stock,*extents))
+        need(source.head==result.head==directory.head==parent.program.tape.head==1,
+             "completed recursive return restores caller heads")
+        returned=True
+        return result
+    finally:
+        if result is not None and result is not source and not returned:result.clear()
+        if callback is not None:callback.abort()
+        if frame is not None:frame.close()
+        if extended is not None:extended.tape.clear()
+        if first is not None:first.clear()
+        for extent in extents:extent.close()
+        directory.rewind();source.rewind();parent.program.tape.rewind()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/scheduler.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/scheduler.py
new file mode 100644
index 0000000000..60c2b6d065
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/scheduler.py
@@ -0,0 +1,28 @@
+"""Iterative evaluator: child depth does not consume the Python call stack."""
+from dataclasses import dataclass
+from types import GeneratorType
+from words import need
+
+@dataclass
+class Invocation:
+    body: object
+
+def complete(body):
+    need(isinstance(body,GeneratorType),"a suspended stream program")
+    stack=[body]
+    value=None
+    try:
+        while stack:
+            try:
+                request=stack[-1].send(value)
+            except StopIteration as done:
+                stack.pop()
+                value=done.value
+                continue
+            need(isinstance(request,Invocation) and isinstance(request.body,GeneratorType),
+                 "only a complete child invocation may suspend the caller")
+            stack.append(request.body)
+            value=None
+        return value
+    finally:
+        for pending in reversed(stack): pending.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/stream_runner.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/stream_runner.py
new file mode 100644
index 0000000000..6ba5df130b
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/stream_runner.py
@@ -0,0 +1,113 @@
+"""Interpret the shared trace on a complete Boolean fibre for one prefix.
+
+Coefficient requests remain symbolic until a pass reads its exact raw prefix.
+All physical atom positions and spectator cardinalities remain binary.
+"""
+from bitstream import atom_swap
+from linear_sign import sign_address
+from cardinality import Natural, multiply_atom_power
+from stream import add_pass, positive_extent
+from trace import execute
+from words import need
+
+
+class Layout:
+    def __init__(self, geometry, parent_size, ring, q, before, suffix):
+        positive_extent(before)
+        positive_extent(suffix)
+        self.geometry, self.ring, self.q = geometry, ring, q
+        self.before, self.suffix = before, suffix
+        self.core = geometry.raw.times_small(geometry.columns, geometry.plan.dimension)
+        unused = geometry.raw.subtract_exact(parent_size, self.core)
+        self.extra = geometry.raw.times_small(unused, 2)
+        geometry.index.free(unused)
+        self.total = geometry.raw.times_small(parent_size, 2)
+
+    def physical(self, position):
+        if self.geometry.raw.compare(position, self.core) < 0:
+            return self.geometry.index.copy(position)
+        return self.geometry.plus(position, self.extra)
+
+    def extents(self, first, second=None):
+        g = self.geometry
+        a = self.physical(first)
+        b = self.physical(second) if second is not None else None
+        if b is not None:
+            need(g.raw.compare(a, b) < 0, "ordered stream atoms")
+        pre, tail = Natural(self.before), Natural(self.suffix)
+        multiply_atom_power(pre, a, self.ring, self.q)
+        after = g.raw.subtract_exact(self.total, a if b is None else b)
+        count = g.raw.subtract_exact(after, g.one)
+        multiply_atom_power(tail, count, self.ring, self.q)
+        g.index.free_many(after, count)
+        values = [pre]
+        if b is not None:
+            distance = g.raw.subtract_exact(b, a)
+            gap = g.raw.subtract_exact(distance, g.one)
+            middle = Natural()
+            multiply_atom_power(middle, gap, self.ring, self.q)
+            values.append(middle)
+            g.index.free_many(distance, gap, b)
+        values.append(tail)
+        g.index.free(a)
+        result = [value.marginal() for value in values]
+        for value in values:
+            value.close()
+        return result
+
+    def close(self):
+        self.geometry.index.free_many(self.core, self.extra, self.total)
+
+
+def action(source, event, layout, coefficient, payload_factory=None):
+    """One full primitive pass; split and merge each request a coefficient."""
+    if event.kind == "add":
+        extents = layout.extents(event.second, event.first)
+    elif event.kind == "atom_swap":
+        extents = layout.extents(event.first, event.second)
+    else:
+        need(event.kind == "sign", "stream primitive tag")
+        extents = layout.extents(event.first)
+    try:
+        if event.kind == "add":
+            kwargs = {} if payload_factory is None else {"payload_factory": payload_factory}
+            output, _traffic = add_pass(source, layout.ring, *extents,
+                                       lambda: coefficient(event.request), **kwargs)
+            return output
+        if event.kind == "atom_swap":
+            return atom_swap(source, layout.ring, layout.q, *extents)
+        return sign_address(source, layout.ring, layout.q, *extents)
+    finally:
+        for extent in extents:
+            extent.close()
+
+
+def run(source, geometry, parent_size, ring, q, before, suffix, coefficient,
+        payload_factory=None):
+    layout = Layout(geometry, parent_size, ring, q, before, suffix)
+    current, active = source, None
+    try:
+        for event in execute(geometry):
+            if event.kind == "enter":
+                need(active is None and event.parent_identity is geometry.parent_identity,
+                     "one complete child invocation")
+                active = event
+                continue
+            if event.kind == "return":
+                need(active is not None and active.parent_identity is event.parent_identity
+                     and active.source_code == event.source_code and active.child_kind == event.child_kind
+                     and active.half == event.half,
+                     "same symbolic child return")
+                for a, b in ((active.first, event.first), (active.second, event.second),
+                             (active.width, event.width), (active.depth, event.depth)):
+                    need(geometry.raw.compare(a, b) == 0, "restored encoded child context")
+                active = None
+                continue
+            following = action(current, event, layout, coefficient, payload_factory)
+            if current is not source:
+                current.clear()
+            current = following
+        need(active is None, "closed stream child invocation")
+        return current
+    finally:
+        layout.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/trace.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/trace.py
new file mode 100644
index 0000000000..4b002201ce
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2753/trace.py
@@ -0,0 +1,184 @@
+"""One encoded-index trace for algebra observation and stream interpretation.
+
+The iterator lends each emitted word until the next iteration. A child
+extension always refers to the unchanged parent program and current raw slot.
+"""
+from dataclasses import dataclass, replace
+
+from plan import Request
+from words import need
+
+
+@dataclass
+class Event:
+    kind: str
+    first: object
+    second: object = None
+    request: object = None
+    width: object = None
+    depth: object = None
+    child_kind: str = ""
+    field: int = 0
+    reverse: bool = False
+    source_code: int = 0
+    parent_identity: object = None
+    half: bool = False
+
+
+def columns(page, reverse=False):
+    j = page.raw.subtract_exact(page.columns, page.one) if reverse else page.index.zero()
+    try:
+        while page.raw.compare(j, page.columns) < 0:
+            yield j
+            if reverse:
+                if j.zero():
+                    break
+                previous = page.raw.subtract_exact(j, page.one)
+                page.index.free(j)
+                j = previous
+            else:
+                page.raw.increment_in_place(j)
+    finally:
+        page.index.free(j)
+
+
+def primitive(kind, first, second, request, page):
+    try:
+        yield Event(kind, first, second, request)
+    finally:
+        page.index.free(first)
+        if second is not None:
+            page.index.free(second)
+        if request is not None:
+            page.index.free(request.coordinate)
+
+
+def leaf(page, first, second, width, kind, field=0, reverse=False, half=False):
+    need(not width.zero() and page.raw.compare(width, page.leaf_cutoff) < 0,
+         "completed leaf child below selected cutoff")
+    depth = page.plus(page.depth, page.one)
+    boundary = Event("enter", first, second, width=width, depth=depth,
+                     child_kind=kind, field=field, reverse=reverse,
+                     source_code=page.source_code, parent_identity=page.parent_identity, half=half)
+    try:
+        yield boundary
+        i = page.index.zero()
+        try:
+            while page.raw.compare(i, width) < 0:
+                left = page.plus(first, i)
+                last = page.raw.subtract_exact(width, page.one)
+                tail = page.raw.subtract_exact(last, i)
+                right = page.plus(second, tail)
+                page.index.free_many(last, tail)
+                try:
+                    # A weighted leaf uses only complete atom swaps, later
+                    # ADDs and one sign. No weighted-swap oracle appears.
+                    for stage in range(8):
+                        a, b = page.index.copy(left), page.index.copy(right)
+                        if stage in (0, 2, 4, 6):
+                            yield from primitive("atom_swap", a, b, None, page)
+                        elif stage == 7:
+                            page.index.free(a)
+                            yield from primitive("sign", b, None, None, page)
+                        else:
+                            request = Request("child", page.index.copy(i), child_kind=kind,
+                                              field=field, reverse=reverse, negative_inverse=stage == 3, half=half)
+                            yield from primitive("add", b, a, request, page)
+                finally:
+                    page.index.free_many(left, right)
+                page.raw.increment_in_place(i)
+        finally:
+            page.index.free(i)
+        yield replace(boundary, kind="return")
+    finally:
+        page.index.free(depth)
+
+
+def child(page, first, second, width, kind, field=0, reverse=False, half=False):
+    try:
+        need(page.raw.compare(first, second) < 0, "ordered child chunks")
+        end = page.plus(first, width)
+        need(page.raw.compare(end, second) <= 0, "disjoint child chunks")
+        page.index.free(end)
+        need(not width.zero(), "positive complete child invocation")
+        if page.raw.compare(width, page.leaf_cutoff) < 0:
+            yield from leaf(page, first, second, width, kind, field, reverse, half)
+        else:
+            # Borrow the same encoded boundary until the caller resumes this
+            # generator after one whole-packet recursive return.  Never loop
+            # over exposed high-prefix values to invoke separate children.
+            depth = page.plus(page.depth, page.one)
+            boundary = Event("enter", first, second, width=width, depth=depth,
+                             child_kind=kind, field=field, reverse=reverse,
+                             source_code=page.source_code,
+                             parent_identity=page.parent_identity, half=half)
+            try:
+                yield boundary
+                yield replace(boundary, kind="invoke")
+                yield replace(boundary, kind="return")
+            finally:
+                page.index.free(depth)
+    finally:
+        page.index.free_many(first, second, width)
+
+
+def pair_command(page, command):
+    i, k, m = command.target, command.source, page.plan.dimension
+    need(i < k, "ordered fallback child fields")
+    same = (i < m) == (k < m)
+    half, remainder = page.raw.divmod(page.columns, page.two)
+    page.index.free(remainder)
+    try:
+        for stage in range(3):
+            if stage != 1:
+                if not same or half.zero():
+                    continue
+                first = page.raw.times_small(page.columns, k)
+                after = page.raw.times_small(page.columns, k+1)
+                second = page.raw.subtract_exact(after, half)
+                page.index.free(after)
+                yield from child(page, first, second, page.index.copy(half), "unit", half=True)
+            else:
+                first = page.raw.times_small(page.columns, i)
+                second = page.raw.times_small(page.columns, k)
+                kind = command.reference.kind
+                need(kind in ("unit", "pair"), "selected fallback child kind")
+                yield from child(page, first, second, page.index.copy(page.columns),
+                                 kind, i if kind == "pair" else 0,
+                                 i >= m if kind == "pair" else False)
+    finally:
+        page.index.free(half)
+
+
+def adapters(page, reverse=False):
+    # Recreate the finite command iterator for each encoded column.
+    for j in columns(page, reverse):
+        commands = reversed(page.plan.commands) if reverse else page.plan.commands
+        for command in commands:
+            target, source = page.point(command.target, j), page.point(command.source, j)
+            request = Request("adapter", page.index.copy(j), command.reference, reverse)
+            yield from primitive("add", target, source, request, page)
+
+
+def execute(page):
+    """Expand a residual and yield opaque complete internal child calls."""
+    if page.plan.good:
+        yield from adapters(page)
+        first = page.index.zero()
+        second = page.raw.times_small(page.columns, 2*page.plan.dimension-page.plan.rank)
+        width = page.raw.times_small(page.columns, page.plan.rank)
+        yield from child(page, first, second, width, "good")
+        yield from adapters(page, True)
+    else:
+        for command in page.plan.commands:
+            if command.kind == "child":
+                yield from pair_command(page, command)
+            else:
+                for j in columns(page):
+                    target = page.point(command.target, j)
+                    if command.kind == "sign":
+                        yield from primitive("sign", target, None, None, page)
+                    else:
+                        source = page.point(command.source, j)
+                        request = Request("adapter", page.index.copy(j), command.reference)
+                        yield from primitive("add", target, source, request, page)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/NOTICE.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/NOTICE.md
new file mode 100644
index 0000000000..307c2da733
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/NOTICE.md
@@ -0,0 +1,30 @@
+# Attribution
+
+Jose Manuel (`jmbarrancoml`) wrote the numerical-bank codec, its composition
+proof, exact sequential invoice and tests with substantial OpenAI Codex
+assistance. Apache-2.0. We claim no independent human or formal-kernel review.
+
+We retain these source files without byte changes:
+
+- `vendor/words.py`: Jose Manuel's PR2697, commit
+  `a53fdf4bcbe33c6732f0bec1badc8c023380f9d1`, originally
+  `research/selected-bit-node/vendor/words.py`. The retained selected
+  coefficient/stream lineage includes PR2332/2364/2405/2449/2501/2569,
+  the PR2234 recursive specification, and the source527/PR589 construction.
+- `vendor/parking_machine.py`: ywz65's PR2635, commit
+  `1662dda699d9ea57b3fb13a23873b087d765149f`, originally
+  `research/finite-parking-frames/machine.py`. ywz65 supplied the two-tape
+  finite table, matched-frame proof and exact table invoice with OpenAI
+  Codex assistance. Its PR2574/2534/2483/2250/2287 lineage retains credit.
+- `vendor/pr2753_recursive_call.py`: David Arias's PR2753, commit
+  `7dba5452a4071a856a0b11cebdcd2d3b6bcd7659`, originally
+  `research/selected-bit-recursive-caller/recursive_call.py`. We retain it
+  as reference text only. David Arias supplied the concurrent all-size
+  logical caller, iterative scheduler and joined logical reserve with
+  substantial OpenAI Codex assistance.
+
+The source creators retain their original credit. This contribution does
+not claim a new generic stack construction or first logical recursive caller.
+The new boundary is the literal bank/slot/word serialization into the existing
+parking table, same-slot restoration, fixed physical inventory and complete
+sequential-operation invoice.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/codec.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/codec.py
new file mode 100644
index 0000000000..9cd54d9417
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/codec.py
@@ -0,0 +1,151 @@
+"""Two fixed tapes park and restore two finite numerical register banks.
+
+Word values and parking depth stay on tapes. Bank/slot labels and the live
+maps range over fixed finite inventories. Counters below are observations.
+"""
+from parking_machine import HALTS, Machine
+from words import LEFT, ONE, RIGHT, ZERO, need
+
+
+class BankParking:
+    def __init__(self, residue_arena, index_arena, machine=None):
+        self.arenas = (residue_arena, index_arena)
+        need(residue_arena is not index_arena, "two distinct fixed numerical banks")
+        self.capacities = tuple(arena.capacity for arena in self.arenas)
+        self.slot_bits = tuple(max(1, (capacity-1).bit_length()) for capacity in self.capacities)
+        self.machine = Machine(packet={0: "^"}, heads=(0, 1)) if machine is None else machine
+        self.codec_counts = dict(reads=0, writes=0, moves=0, slot_tests=0, commands=0)
+
+    def _read(self, tape):
+        self.codec_counts["reads"] += 1
+        return self.machine.tapes[tape].get(self.machine.heads[tape], "_")
+
+    def _write(self, tape, symbol):
+        self.codec_counts["writes"] += 1
+        position = self.machine.heads[tape]
+        if symbol == "_":
+            self.machine.tapes[tape].pop(position, None)
+        else:
+            self.machine.tapes[tape][position] = symbol
+
+    def _move(self, tape, direction):
+        need(direction in (-1, 1), "unit codec head movement")
+        self.codec_counts["moves"] += 1
+        self.machine.heads[tape] += direction
+
+    def _command(self, command):
+        need(self.machine.state == "done", "parking controller is at a completed boundary")
+        self.codec_counts["commands"] += 1
+        self.machine.state = command
+        while self.machine.state not in HALTS:
+            self.machine.step()
+        need(self.machine.state == "done", "matched parking command completes")
+
+    def _empty_port(self):
+        need(self._read(1) == "_", "empty packet port before bank operation")
+        self._move(1, -1)
+        try:
+            need(self._read(1) == "^", "packet port starts after its left marker")
+        finally:
+            self._move(1, 1)
+
+    def _put_bit(self, bit):
+        need(bit in (ZERO, ONE) and self._read(1) == "_", "append a bit to an empty port cell")
+        self._write(1, "1" if bit else "0")
+        self._move(1, 1)
+
+    def _take_bit(self):
+        symbol = self._read(1)
+        need(symbol in ("0", "1"), "complete binary register record")
+        self._write(1, "_")
+        self._move(1, 1)
+        return int(symbol == "1")
+
+    def _rewind_port(self):
+        self._move(1, -1)
+        while self._read(1) != "^":
+            self._move(1, -1)
+        self._move(1, 1)
+
+    def _supply(self, bank, slot, word):
+        self._put_bit(bank)
+        for bit in range(self.slot_bits[bank]):
+            self._put_bit((slot >> bit) & 1)
+        word.rewind()
+        while True:
+            bit = word.read()
+            if bit == RIGHT:
+                break
+            need(bit in (ZERO, ONE), "live numerical word has a complete binary extent")
+            self._put_bit(bit)
+            word.step(1)
+        word.rewind()
+        need(self._read(1) == "_", "empty packet terminator cell")
+        self._write(1, "$")
+        self._rewind_port()
+
+    def park(self, keep=(frozenset(), frozenset())):
+        """Park all parent slots except separately owned child input grants.
+
+        A caller can copy modulus/width/depth into fresh slots and grant those
+        copies to the child. It must close the grants before restore().
+        """
+        need(len(keep) == 2 and all(arena.capacity == capacity
+             for arena, capacity in zip(self.arenas, self.capacities)), "fixed bank inventory")
+        for bank, arena in enumerate(self.arenas):
+            need(all(type(slot) is int and slot in arena.live for slot in keep[bank]),
+                 "child grants are live fixed slot labels")
+        self._empty_port()
+        self._command("begin")
+        for bank, arena in enumerate(self.arenas):
+            for slot in range(self.capacities[bank]):
+                self.codec_counts["slot_tests"] += 1
+                if slot in arena.live and slot not in keep[bank]:
+                    word = arena.words[slot]
+                    need(word.slot == slot and word.arena is arena, "stable physical numerical role")
+                    self._supply(bank, slot, word)
+                    self._command("push")
+                    arena.free(word)
+            need(arena.live == set(keep[bank]), "only declared child grants remain in the bank")
+        self._empty_port()
+
+    def _restore_word(self):
+        bank = self._take_bit()
+        slot = 0
+        for bit in range(self.slot_bits[bank]):
+            slot |= self._take_bit() << bit
+        arena = self.arenas[bank]
+        need(slot < self.capacities[bank] and slot < len(arena.words) and
+             slot not in arena.live and slot in arena.available, "original parent slot is free")
+        # The allocator's finite free map may change order. The original
+        # Word object/slot must survive; relabelling another object is invalid.
+        arena.available.remove(slot)
+        arena.available.append(slot)
+        word = arena.zero()
+        need(word is arena.words[slot] and word.slot == slot, "restore the original slot object")
+        while word.read() != RIGHT:
+            word.write(self._take_bit())
+            word.step(1)
+        need(self._read(1) == "$", "stored numerical word matches the fixed template extent")
+        self._write(1, "_")
+        self._rewind_port()
+        word.rewind()
+
+    def restore(self):
+        """Restore the latest owned frame in a well-bracketed command stream."""
+        need(all(arena.capacity == capacity for arena, capacity in zip(self.arenas, self.capacities)),
+             "restore uses the same fixed numerical bank inventory")
+        need(all(not arena.live for arena in self.arenas),
+             "child clears its grants and numerical work before parent restoration")
+        self._empty_port()
+        while True:
+            self._move(0, -1)
+            symbol = self._read(0)
+            self._move(0, 1)
+            if symbol == "F":
+                self._command("end")
+                self._empty_port()
+                return
+            need(symbol in ("0", "1", "R"), "owned frame or matched register record")
+            self._command("pop")
+            self._restore_word()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py
new file mode 100644
index 0000000000..cafd614a3b
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/parking_machine.py
@@ -0,0 +1,108 @@
+"""Two-tape parking controller. Apache-2.0; ywz65 with OpenAI Codex.
+
+Only (finite state, two scanned symbols) selects a transition. Coordinates,
+step limits and counters belong to the simulator, not the controller.
+"""
+from itertools import product
+
+ALPHABET = tuple('_01^$FR')
+STATES = ('begin', 'end', 'end_check', 'push', 'push_copy', 'push_rewind',
+          'pop', 'pop_measure', 'pop_return', 'pop_copy')
+HALTS = ('done', 'reject')
+
+def transition_table():
+    table = {(s, a, b): ('reject', (None, None), (0, 0))
+             for s, a, b in product(STATES, ALPHABET, ALPHABET)}
+    def put(s, a, b, nxt, writes=(None, None), moves=(0, 0)):
+        table[s, a, b] = nxt, writes, moves
+    for b in ALPHABET:
+        put('begin', '_', b, 'done', ('F', None), (1, 0))
+        put('end', '_', b, 'end_check', moves=(-1, 0))
+        for a in ALPHABET:
+            put('end_check', a, b, 'reject', moves=(1, 0))
+        put('end_check', 'F', b, 'done', ('_', None))
+    for b in '01$':
+        put('push', '_', b, 'push_copy', ('R', None), (1, 0))
+    for b in '01':
+        put('push_copy', '_', b, 'push_copy', (b, '_'), (1, 1))
+    put('push_copy', '_', '$', 'push_rewind', (None, '_'), (0, -1))
+    put('push_rewind', '_', '_', 'push_rewind', moves=(0, -1))
+    put('push_rewind', '_', '^', 'done', moves=(0, 1))
+    put('pop', '_', '_', 'pop_measure', moves=(-1, 0))
+    for a in '01':
+        put('pop_measure', a, '_', 'pop_measure', moves=(-1, 1))
+        put('pop_return', a, '_', 'pop_return', moves=(1, 0))
+        put('pop_copy', a, '_', 'pop_copy', ('_', a), (-1, -1))
+    put('pop_measure', 'R', '_', 'pop_return', moves=(1, 0))
+    put('pop_measure', 'F', '_', 'reject', moves=(1, 0))
+    put('pop_return', '_', '_', 'pop_copy', (None, '$'), (-1, -1))
+    put('pop_copy', 'R', '^', 'done', ('_', None), (0, 1))
+    return table
+
+TABLE = transition_table()
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+def certify(table):
+    need(set(table) == set(product(STATES, ALPHABET, ALPHABET)), 'complete finite table')
+    for key, (nxt, writes, moves) in table.items():
+        need(nxt in STATES + HALTS, 'finite next state')
+        need(len(writes) == len(moves) == 2, 'exactly two tapes')
+        need(all(x is None or x in ALPHABET for x in writes), 'finite writes')
+        need(all(type(x) is int and x in (-1, 0, 1) for x in moves), 'unit head moves')
+    return len(table)
+
+class Machine:
+    def __init__(self, parking=None, packet=None, heads=(0, 0), table=None):
+        self.tapes = [dict(parking or {}), dict(packet or {})]
+        self.heads = list(heads)
+        self.table = TABLE if table is None else table
+        self.state = 'done'
+        self.counts = dict(steps=0, reads=0, writes=0, moves=0)
+        self.visited = [set(), set()]
+        self.transitions = set()
+
+    def step(self):
+        pair = tuple(t.get(h, '_') for t, h in zip(self.tapes, self.heads))
+        key = (self.state, *pair)
+        nxt, writes, moves = self.table[key]
+        self.transitions.add(key)
+        self.counts['steps'] += 1
+        self.counts['reads'] += 2
+        for k in (0, 1):
+            h = self.heads[k]
+            self.visited[k].add(h)
+            if writes[k] is not None:
+                self.counts['writes'] += 1
+                if writes[k] == '_':
+                    self.tapes[k].pop(h, None)
+                else:
+                    self.tapes[k][h] = writes[k]
+            self.heads[k] += moves[k]
+            self.counts['moves'] += abs(moves[k])
+        self.state = nxt
+
+    def run(self, entry, limit=1000000):
+        need(entry in ('begin', 'end', 'push', 'pop'), 'public entry')
+        before = dict(self.counts)
+        self.state = entry
+        for _ in range(limit):
+            self.step()
+            if self.state in HALTS:
+                return {k: self.counts[k] - before[k] for k in before}
+        raise ValueError('test execution budget; not a controller counter')
+
+def tariff(operation, n=0):
+    if operation == 'begin':
+        steps, writes, moves = 1, 1, 1
+    elif operation == 'end':
+        steps, writes, moves = 2, 1, 1
+    elif operation == 'push':
+        steps, writes, moves = 2*n+3, 2*n+2, 3*n+3
+    elif operation == 'pop':
+        steps, writes, moves = 3*n+4, 2*n+2, 5*n+5
+    else:
+        raise ValueError(operation)
+    return dict(steps=steps, reads=2*steps, writes=writes, moves=moves)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/words.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/words.py
new file mode 100644
index 0000000000..8d4ba37e27
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/inputs/pr2769/vendor/words.py
@@ -0,0 +1,415 @@
+"""Binary word tapes; unbounded numerical values stay in tape cells.
+
+Only zero/one carry states and fixed register/operation tags enter Python
+control. Fixture loading/inspection methods are outside measured execution.
+The arena bounds the tape inventory by a compile-time register capacity.
+"""
+ZERO, ONE, LEFT, RIGHT, BLANK = range(5)
+
+
+def need(test, message):
+    if not test:
+        raise ValueError(message)
+
+
+class Meter:
+    __slots__ = ("reads", "writes", "moves", "peak_live", "allocations")
+
+    def __init__(self):
+        self.reads = self.writes = self.moves = self.peak_live = self.allocations = 0
+
+    def record(self):
+        return {name: getattr(self, name) for name in self.__slots__}
+
+
+class Word:
+    __slots__ = ("arena", "slot", "cells", "head")
+
+    def __init__(self, arena, slot):
+        self.arena, self.slot = arena, slot
+        self.cells = bytearray([LEFT] + [BLANK]*(arena.bits+1))
+        self.head = 1
+
+    def read(self):
+        self.arena.meter.reads += 1
+        return self.cells[self.head]
+
+    def write(self, symbol):
+        need(symbol in (ZERO, ONE, RIGHT, BLANK), "word tape alphabet")
+        self.arena.meter.writes += 1
+        self.cells[self.head] = symbol
+
+    def step(self, direction):
+        need(direction in (-1, 1), "unit word-head movement")
+        self.head += direction
+        need(0 <= self.head < len(self.cells), "local word boundary")
+        self.arena.meter.moves += 1
+
+    def rewind(self):
+        self.step(-1)
+        while self.read() != LEFT:
+            self.step(-1)
+        self.step(1)
+
+    def msb(self):
+        self.rewind()
+        while self.read() != RIGHT:
+            self.step(1)
+        self.step(-1)
+
+    def zero(self):
+        self.rewind()
+        nonzero = False
+        while True:
+            bit = self.read()
+            if bit == RIGHT:
+                break
+            need(bit in (ZERO, ONE), "complete binary word")
+            nonzero = nonzero or bit == ONE
+            self.step(1)
+        self.rewind()
+        return not nonzero
+
+    def erase(self):
+        self.rewind()
+        while self.read() != RIGHT:
+            self.write(BLANK)
+            self.step(1)
+        self.write(BLANK)
+        self.rewind()
+
+    def inspect(self):
+        """Checker-only decoding; arithmetic code must not call this."""
+        need(self.head == 1 and self.cells[-1] == RIGHT, "inspect a restored word")
+        return sum(bit << i for i, bit in enumerate(self.cells[1:-1]))
+
+
+class Arena:
+    def __init__(self, bits, capacity=65536):
+        need(bits >= 2 and capacity > 0, "fixed word context")
+        self.bits, self.capacity = bits, capacity
+        self.meter = Meter()
+        self.words, self.available, self.live = [], [], set()
+        self.template = Word(self, -1)
+        self.template.cells[1:-1] = bytes([ZERO])*bits
+        self.template.cells[-1] = RIGHT
+
+    def zero(self):
+        if self.available:
+            slot = self.available.pop()
+            out = self.words[slot]
+        else:
+            slot = len(self.words)
+            need(slot < self.capacity, "fixed register inventory")
+            out = Word(self, slot)
+            self.words.append(out)
+        need(slot not in self.live, "fresh numerical register")
+        self.live.add(slot)
+        self.meter.allocations += 1
+        self.meter.peak_live = max(self.meter.peak_live, len(self.live))
+        source = self.template
+        source.rewind()
+        while source.read() != RIGHT:
+            need(out.read() == BLANK, "erased register before reuse")
+            out.write(ZERO)
+            out.step(1)
+            source.step(1)
+        need(out.read() == BLANK, "erased right delimiter cell")
+        out.write(RIGHT)
+        out.rewind()
+        source.rewind()
+        return out
+
+    def literal(self, value):
+        """Compile-time literal only; never decode a runtime word here."""
+        need(isinstance(value, int) and value >= 0, "unsigned literal")
+        out = self.zero()
+        for bit in tuple((value >> i) & 1 for i in range(value.bit_length())):
+            need(out.read() != RIGHT, "literal fits the fixed word")
+            out.write(bit)
+            out.step(1)
+        out.rewind()
+        return out
+
+    def input(self, value):
+        """Fixture-only loading of an encoded input word."""
+        return self.literal(value)
+
+    def copy(self, source):
+        need(source.arena is self, "one word extent")
+        out = self.zero()
+        source.rewind()
+        while source.read() != RIGHT:
+            out.write(source.read())
+            source.step(1)
+            out.step(1)
+        out.rewind()
+        source.rewind()
+        return out
+
+    def free(self, word):
+        need(word.arena is self and word.slot in self.live, "owned numerical register")
+        word.erase()
+        self.live.remove(word.slot)
+        self.available.append(word.slot)
+
+    def free_many(self, *words):
+        for word in words:
+            self.free(word)
+
+    def rollback(self, protected):
+        """Erase owned temporary roles on a rejecting path; capacity is fixed."""
+        for slot in tuple(self.live):
+            if slot not in protected:
+                self.free(self.words[slot])
+        for slot in protected:
+            self.words[slot].rewind()
+
+
+class Unsigned:
+    def __init__(self, arena):
+        self.arena = arena
+
+    def compare(self, a, b):
+        need(a.arena is b.arena is self.arena, "comparison word context")
+        if a is b:
+            return 0
+        a.rewind()
+        b.rewind()
+        state = 0
+        while a.read() != RIGHT:
+            x, y = a.read(), b.read()
+            need(x in (ZERO, ONE) and y in (ZERO, ONE), "comparison binary digits")
+            if x != y:
+                state = 1 if x == ONE else -1
+            a.step(1)
+            b.step(1)
+        need(b.read() == RIGHT, "equal comparison extents")
+        a.rewind()
+        b.rewind()
+        return state
+
+    def add(self, a, b):
+        out = self.arena.zero()
+        a.rewind()
+        b.rewind()
+        carry = 0
+        while a.read() != RIGHT:
+            x, y = a.read(), b.read()
+            total = x+y+carry  # Four finite carry states, not word arithmetic.
+            out.write(total & 1)
+            carry = total >> 1
+            a.step(1)
+            if b is not a:
+                b.step(1)
+            out.step(1)
+        need(b.read() == RIGHT, "equal addition extents")
+        a.rewind()
+        b.rewind()
+        out.rewind()
+        return out, carry
+
+    def subtract(self, a, b):
+        out = self.arena.zero()
+        a.rewind()
+        b.rewind()
+        borrow = 0
+        while a.read() != RIGHT:
+            x, y = a.read(), b.read()
+            digit = x-y-borrow  # One finite borrow bit.
+            out.write(digit & 1)
+            borrow = int(digit < 0)
+            a.step(1)
+            if b is not a:
+                b.step(1)
+            out.step(1)
+        need(b.read() == RIGHT, "equal subtraction extents")
+        a.rewind()
+        b.rewind()
+        out.rewind()
+        return out, borrow
+
+    def subtract_exact(self, a, b):
+        out, borrow = self.subtract(a, b)
+        need(not borrow, "unsigned subtraction precondition")
+        return out
+
+    def shift_add_bit(self, a, bit):
+        need(bit in (ZERO, ONE), "one incoming bit")
+        out = self.arena.zero()
+        a.rewind()
+        carry = bit
+        while a.read() != RIGHT:
+            previous = a.read()
+            out.write(carry)
+            carry = previous
+            a.step(1)
+            out.step(1)
+        a.rewind()
+        out.rewind()
+        need(not carry, "reserved high-bit margin")
+        return out
+
+    def divmod(self, numerator, denominator):
+        need(not denominator.zero(), "nonzero binary divisor")
+        # A zero high bit leaves room for 2*remainder+bit.
+        denominator.msb()
+        margin = denominator.read()
+        denominator.rewind()
+        need(margin == ZERO, "binary divisor has the high-bit margin")
+        scan = self.arena.copy(numerator)
+        quotient, remainder = self.arena.zero(), self.arena.zero()
+        scan.msb()
+        quotient.msb()
+        while scan.read() != LEFT:
+            shifted = self.shift_add_bit(remainder, scan.read())
+            self.arena.free(remainder)
+            if self.compare(shifted, denominator) >= 0:
+                remainder = self.subtract_exact(shifted, denominator)
+                self.arena.free(shifted)
+                quotient.write(ONE)
+            else:
+                remainder = shifted
+                quotient.write(ZERO)
+            scan.step(-1)
+            quotient.step(-1)
+        scan.step(1)
+        quotient.step(1)
+        self.arena.free(scan)
+        return quotient, remainder
+
+    def times_small(self, a, constant):
+        """Multiply by a fixed finite matrix/rank label; preserve the word margin."""
+        need(0 <= constant <= 128, "finite index multiplier")
+        result = self.arena.zero()
+        for bit in tuple((constant >> i) & 1 for i in range(constant.bit_length()-1, -1, -1)):
+            doubled, carry = self.add(result, result)
+            need(not carry, "index multiplication margin")
+            self.arena.free(result)
+            if bit:
+                result, carry = self.add(doubled, a)
+                need(not carry, "index multiplication extent")
+                self.arena.free(doubled)
+            else:
+                result = doubled
+        return result
+
+    def increment_in_place(self, word):
+        """Ripple increment for a bounded address counter; restore its head."""
+        word.rewind()
+        while word.read() == ONE:
+            word.write(ZERO)
+            word.step(1)
+        need(word.read() == ZERO, "ripple increment has space")
+        word.write(ONE)
+        word.rewind()
+
+
+class Ring:
+    """Canonical residues modulo an encoded M>1 with one leading zero bit."""
+    def __init__(self, modulus):
+        self.modulus, self.arena = modulus, modulus.arena
+        self.raw = Unsigned(self.arena)
+        self.one = self.arena.literal(1)
+        try:
+            need(self.raw.compare(modulus, self.one) > 0, "modulus exceeds one")
+            modulus.msb()
+            margin = modulus.read()
+            modulus.step(-1)
+            significant = modulus.read()
+            modulus.rewind()
+            need(margin == ZERO and significant == ONE, "canonical modulus word with one high-bit margin")
+        except ValueError:
+            self.arena.free(self.one)
+            raise
+
+    def close(self):
+        self.arena.free(self.one)
+
+    def add(self, a, b):
+        total, carry = self.raw.add(a, b)
+        need(not carry, "canonical modular addition margin")
+        if self.raw.compare(total, self.modulus) >= 0:
+            out = self.raw.subtract_exact(total, self.modulus)
+            self.arena.free(total)
+            return out
+        return total
+
+    def subtract(self, a, b):
+        if self.raw.compare(a, b) >= 0:
+            return self.raw.subtract_exact(a, b)
+        larger, carry = self.raw.add(a, self.modulus)
+        need(not carry, "canonical modular subtraction margin")
+        out = self.raw.subtract_exact(larger, b)
+        self.arena.free(larger)
+        return out
+
+    def negate(self, a):
+        zero = self.arena.zero()
+        out = self.subtract(zero, a)
+        self.arena.free(zero)
+        return out
+
+    def multiply(self, a, b):
+        if a.zero() or b.zero():
+            return self.arena.zero()
+        if self.raw.compare(a, self.one) == 0:
+            return self.arena.copy(b)
+        if self.raw.compare(b, self.one) == 0:
+            return self.arena.copy(a)
+        scan = self.arena.copy(b)
+        result = self.arena.zero()
+        scan.msb()
+        while scan.read() != LEFT:
+            doubled = self.add(result, result)
+            self.arena.free(result)
+            if scan.read() == ONE:
+                result = self.add(doubled, a)
+                self.arena.free(doubled)
+            else:
+                result = doubled
+            scan.step(-1)
+        scan.step(1)
+        self.arena.free(scan)
+        return result
+
+    def inverse(self, a):
+        """Euclid, with Bezout coefficients reduced modulo M; None for nonunits."""
+        r0, r1 = self.arena.copy(self.modulus), self.arena.copy(a)
+        t0, t1 = self.arena.zero(), self.arena.copy(self.one)
+        while not r1.zero():
+            quotient, r2 = self.raw.divmod(r0, r1)
+            if self.raw.compare(quotient, self.modulus) >= 0:
+                reduced = self.raw.subtract_exact(quotient, self.modulus)
+                self.arena.free(quotient)
+                quotient = reduced
+            product = self.multiply(quotient, t1)
+            t2 = self.subtract(t0, product)
+            self.arena.free_many(quotient, product, r0, t0)
+            r0, r1, t0, t1 = r1, r2, t1, t2
+        unit = self.raw.compare(r0, self.one) == 0
+        self.arena.free_many(r0, r1, t1)
+        if unit:
+            return t0
+        self.arena.free(t0)
+        return None
+
+    def literal(self, constant):
+        """Compile a fixed signed integer through binary modular operations."""
+        negative = constant < 0
+        magnitude = abs(constant)
+        result = self.arena.zero()
+        instructions = tuple((magnitude >> i) & 1 for i in range(magnitude.bit_length()-1, -1, -1))
+        for bit in instructions:
+            doubled = self.add(result, result)
+            self.arena.free(result)
+            if bit:
+                result = self.add(doubled, self.one)
+                self.arena.free(doubled)
+            else:
+                result = doubled
+        if negative:
+            out = self.negate(result)
+            self.arena.free(result)
+            result = out
+        return result
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_binding.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_binding.py
new file mode 100644
index 0000000000..c197eb6458
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_binding.py
@@ -0,0 +1,145 @@
+"""Separate selected generated coefficients from the reduced GL2 fixture."""
+from types import SimpleNamespace
+
+import loader
+loader.activate()
+from children import extend
+from controller import Callback
+from macro_code import Residual
+from numeric import selected_coefficient
+import oracle
+from plan import Plan, Request
+from records import Fields, Program, append_finite
+from words import need
+
+
+def view(cls, runtime, tape):
+    result = object.__new__(cls)
+    result.index_arena, result.residue_arena = runtime.indices, runtime.arena
+    result.code_bits = runtime.binding.codes.bits
+    result.tape = tape
+    return result
+
+
+class SelectedBinding:
+    cutoff, stock_multiple, child_mode = 64, 9475, 0
+
+    def __init__(self, specifications):
+        self.specifications = specifications
+        self.catalogue = specifications.catalogue
+        self.codes = self.catalogue.codes
+        self.ambient = specifications.bind(0, True, tuple(map(tuple, oracle.eye(64)))).code
+
+    def residual(self, identifier, common, low, mode):
+        need(mode == 0, "one selected source program")
+        request = self.catalogue.requests[identifier]
+        need(common == (request.kind != "IDLE"), "selected common/native source view")
+        spec = self.specifications.bind(identifier, common, low)
+        return Residual(spec.code, self.specifications.plan(spec.code), identifier, common, low)
+
+    def incoming(self, runtime):
+        def coefficient(prefix, request):
+            need(request.kind == "incoming", "incoming coefficient grammar")
+            fields = view(Fields, runtime, prefix)
+            frame = Callback(runtime.context.ring, runtime.indices, runtime.program, fields,
+                             self.specifications, self.ambient, allow_fallback=True, leaf=True)
+            try:
+                raw = frame.raw
+                need(raw.compare(frame.final_size, runtime.size) == 0 and
+                     raw.compare(frame.depth, runtime.depth) == 0, "incoming frame width and depth")
+                value = frame.weight(request.coordinate)
+                if request.negative_inverse:
+                    inverse = runtime.context.ring.inverse(value)
+                    need(inverse is not None, "incoming unit inverse")
+                    following = runtime.context.ring.negate(inverse)
+                    runtime.arena.free_many(value, inverse)
+                    value = following
+                frame.close()
+                return value
+            except BaseException:
+                frame.abort()
+                raise
+        return SimpleNamespace(coefficient=coefficient)
+
+    def validate_residual(self, runtime, definition, first):
+        frame = Callback(runtime.context.ring, runtime.indices, runtime.program,
+                         view(Fields, runtime, first), self.specifications,
+                         definition.code, allow_fallback=True)
+        try:
+            need(frame.raw.compare(frame.final_size, runtime.size) == 0 and
+                 frame.raw.compare(frame.depth, runtime.depth) == 0, "current residual frame binding")
+            frame.close()
+        except BaseException:
+            frame.abort()
+            raise
+
+    def coefficient(self, runtime, definition, prefix, request):
+        return selected_coefficient(definition.plan, runtime.context.ring, runtime.indices,
+                                    runtime.program, view(Fields, runtime, prefix),
+                                    self.specifications, definition.code, request)
+
+    def child_program(self, runtime, definition, event, first):
+        callback = Callback(runtime.context.ring, runtime.indices, runtime.program,
+                            view(Fields, runtime, first), self.specifications,
+                            definition.code, allow_fallback=True)
+        zero = runtime.indices.zero()
+        try:
+            result = extend(callback, Request("child", zero, child_kind=event.child_kind,
+                                             field=event.field, reverse=event.reverse, half=event.half))
+            callback.close()
+            return result.tape
+        except BaseException:
+            callback.abort()
+            raise
+        finally:
+            runtime.indices.free(zero)
+
+    def check_stock(self, runtime):
+        pass
+
+
+class ToyBinding:
+    """Fixture-only q2/dimension2 grammar; production uses SelectedBinding."""
+    cutoff, stock_multiple, child_mode = 2, 1, 0
+
+    def __init__(self, catalogue, plans):
+        self.catalogue, self.codes, self.plans = catalogue, catalogue.codes, plans
+
+    def residual(self, identifier, common, low, mode):
+        need(common and identifier in (0, 1) and mode in (0, 1), "toy MOVE binding")
+        plan, constants = self.plans[(identifier, low)]
+        code = self.codes.encode(identifier, common, low)
+        if mode:
+            return Residual(code, Plan(2, 1, True, ()), identifier, common, low,
+                            axis=identifier, constants=constants)
+        return Residual(code, plan, identifier, common, low, constants=constants)
+
+    def incoming(self, runtime):
+        return SimpleNamespace(coefficient=lambda _prefix, _request:
+                               runtime.arena.copy(runtime.context.ring.one))
+
+    def validate_residual(self, runtime, definition, first):
+        pass
+
+    def coefficient(self, runtime, definition, prefix, request):
+        if request.kind == "child":
+            return runtime.arena.copy(runtime.context.ring.one)
+        return runtime.arena.literal(definition.constants[(request.reference, request.reverse_adapter)])
+
+    def child_program(self, runtime, definition, event, first):
+        # The retained toy grammar uses only Program identity. Carry a finite
+        # source-label record as extra inert data to exercise descriptor parking.
+        result = runtime.pool.acquire()
+        from directory import append_tape
+        append_tape(runtime.program.tape, result)
+        append_finite(result, definition.code, self.codes.bits)
+        result.rewind()
+        return result
+
+    def check_stock(self, runtime):
+        from cardinal_counts import Count
+        expected = Count.literal(6 if runtime.root else 1)
+        try:
+            need(expected.equals(runtime.count("unused")), "toy exact independent fresh stock")
+        finally:
+            expected.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_code.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_code.py
new file mode 100644
index 0000000000..2f5f8ecfac
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_code.py
@@ -0,0 +1,107 @@
+"""Compile fixed source schedules; numerical dimensions never enter this pass."""
+from dataclasses import dataclass
+
+import loader
+loader.activate()
+from control import LocalState
+from driver import compile_owner
+from residual_blocks import Cursor
+from words import need
+
+
+@dataclass(frozen=True)
+class Residual:
+    code: int
+    plan: object
+    identifier: int
+    common: bool
+    low: tuple
+    axis: object = None
+    constants: object = None
+
+
+@dataclass(frozen=True)
+class Code:
+    operations: tuple
+    staged_roles: int
+
+
+def compile_node(topology, binding, mode=0):
+    """Finite offline expansion of the source's q-dependent instruction word.
+
+    The selected GL64 expansion can be enormous. This routine proves an
+    effective finite emitter; practical selected runs may compile regions with
+    the same finite labels. The small model uses the complete emitted tuple.
+    """
+    operations = [("node",)]
+    staged = 0
+    def residual(role, identifier, common, low):
+        definition = binding.residual(identifier, common, low, mode)
+        operations.append(("residual_begin", role, definition))
+        if definition.axis is not None:
+            operations.append(("block", definition, ("axis", definition.axis, 0)))
+        else:
+            cursor = Cursor(definition.plan)
+            while not cursor.done:
+                operations.append(("block", definition, cursor.take()))
+        operations.append(("residual_end", role, definition))
+    for event in topology.schedule:
+        kind = event["kind"]
+        if kind == "local_cover_sweep":
+            for replica in range(topology.replicas):
+                call = topology.call(event["stage"], replica)
+                staged = max(staged, len(call.owners) + 1)
+                for low in topology.catalogue.low_classes():
+                    slots = []
+                    for role, owner in enumerate(call.owners):
+                        native, forward, backward = compile_owner(
+                            topology.matrix(owner.chart), low, topology.catalogue.codes)
+                        slots.append((owner.family, native, backward))
+                        operations.append(("gather_route", ("stage", role), owner.family, native, forward))
+                    state = LocalState(call)
+                    for position, item in enumerate(call.events):
+                        op, role = state.accept(position)
+                        target = ("stage", role)
+                        if op == 0:
+                            residual(target, call.requests[position], True, low)
+                        elif op == 1:
+                            operations.append(("xor", target, ("stage", item[2])))
+                        elif op == 2:
+                            operations.append(("copy", target, "copy_source"))
+                            residual("copy_source", call.requests[position], True, low)
+                            operations.append(("move", "copy_source", ("stage", state.private)))
+                        else:
+                            need(op == 3, "closed local opcode")
+                            operations.append(("clear", ("stage", state.private)))
+                    state.finish()
+                    for role, (family, native, backward) in enumerate(slots):
+                        operations.append(("route_scatter", ("stage", role), family, native, backward))
+                    for role in range(len(call.owners) + 1):
+                        operations.append(("clear", ("stage", role)))
+        elif kind == "idle":
+            for replica in range(topology.replicas):
+                for identifier in topology.idles[event["idx"]]:
+                    family = topology.idle_family(identifier, replica)
+                    for low in topology.catalogue.low_classes():
+                        operations.append(("gather", "idle", family, low))
+                        residual("idle", identifier, False, low)
+                        operations.append(("scatter", "idle", family, low))
+                        operations.append(("clear", "idle"))
+        elif kind == "bridge":
+            need(event["coefficient"] in (-1, 1), "native Boolean bridge coefficient")
+            for replica in range(topology.replicas):
+                for port in range(topology.ports):
+                    for target, source, side in ((event["dst"], event["src"], 0),
+                                                 (event["src"], event["dst"], 1)):
+                        operations.append(("family_xor", topology.family(replica, target, side, port),
+                                           topology.family(replica, source, side, port)))
+        else:
+            need(kind == "exchange", "closed global opcode")
+            for replica in range(topology.replicas):
+                for pair in range(topology.pairs):
+                    for port in range(topology.ports):
+                        operations.append(("exchange", topology.family(replica, pair, 0, port),
+                                           topology.family(replica, pair, 1, port)))
+        operations.append(("checkpoint", kind, event.get("stage", event.get("idx", -1))))
+    operations.append(("return",))
+    return Code(tuple(operations), staged)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_machine.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_machine.py
new file mode 100644
index 0000000000..5a032e8923
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/macro_machine.py
@@ -0,0 +1,453 @@
+"""One active frame, fixed stream roles and an encoded parent continuation."""
+from contextlib import contextmanager
+
+import loader
+codec = loader.activate()
+from cardinal_counts import Count, positive
+from cardinality import multiply_atom_power
+from directory import Context, append_tape, produce
+from driver import xor_family
+from episode import xor_packet
+import fresh_rows
+from layout import Layout
+from macro_binding import view
+from numeric import Geometry
+from packet import read_prefix
+import packet_engine
+import peel
+from plan import Request
+from records import Program, Tape
+from recursive_call import copy_word
+from residual_blocks import events as block_events
+from role_parking import FiniteFields, RoleParking, transfer
+from routes import copy_rows, route_packet
+from scratch_pool import Lease, ScratchPool
+from selection import gather, scatter
+from stream import Counter
+from trace import child
+from words import BLANK, LEFT, Ring, Unsigned, need
+
+
+NAMES = ("source", "peeled", "old_directory", "program", "old_count", "rows",
+         "before", "gap", "suffix", "unused", "leading", "fibre", "highs",
+         "family_rows", "directory", "prefixes", "current", "copy_source", "idle", "swap", "header")
+CAPSULE = ("source", "old_directory", "program", "old_count", "rows", "before", "gap", "suffix")
+
+
+class Machine:
+    def __init__(self, binding, topology, programs, arena, indices, observe=None):
+        self.binding, self.topology, self.programs = binding, topology, tuple(programs)
+        self.arena, self.indices = arena, indices
+        staged = max(program.staged_roles for program in programs)
+        labels = (*NAMES, *(("family", i) for i in range(topology.families)),
+                  *(("stage", i) for i in range(staged)))
+        self.roles = {label: Tape() for label in labels}
+        self.handoff = {label: Tape() for label in CAPSULE}
+        self.output = Tape()
+        self.pool = ScratchPool(binding.codes.q ** 2 + 128)
+        self.numerical = codec.BankParking(arena, indices)
+        self.streams = RoleParking(self.numerical, self.roles.values())
+        self.header = FiniteFields((2, len(programs), max(len(p.operations) for p in programs),
+                                   arena.capacity, arena.capacity, arena.capacity,
+                                   indices.capacity, indices.capacity))
+        self.context = self.program = self.size = self.depth = None
+        self.geometry_state = None
+        self.pc = self.mode = 0
+        self.root = True
+        self.closed = False
+        self.observe = observe  # Checker-only; the controller never reads its result.
+        self.counts = dict(macros=0, residuals=0, calls=0, returns=0)  # Observers only.
+
+    def tape(self, label):
+        return self.roles[label]
+
+    def count(self, label):
+        result = object.__new__(Count)
+        result.tape = self.tape(label)
+        return result
+
+    def commit(self, result, label):
+        target = self.tape(label)
+        if result is target:
+            return
+        target.clear()
+        append_tape(result, target)
+        target.rewind()
+        if isinstance(result, Lease):
+            result.clear()
+
+    def save_count(self, value, label):
+        self.commit(value.tape, label)
+        value.close()
+
+    def new_context(self, modulus, size, depth):
+        ring = Ring(modulus)
+        context = Context(ring, self.binding.codes)
+        self.save_count(context.highs, "highs")
+        context.highs = self.count("highs")
+        self.context, self.size, self.depth = context, size, depth
+        self.program = view(Program, self, self.tape("program"))
+
+    def restore_context(self, labels):
+        modulus, one, cap, size, depth = labels
+        ring = object.__new__(Ring)
+        ring.arena, ring.raw = self.arena, Unsigned(self.arena)
+        ring.modulus, ring.one = self.arena.words[modulus], self.arena.words[one]
+        context = object.__new__(Context)
+        context.ring, context.arena, context.raw = ring, self.arena, ring.raw
+        context.codes = self.binding.codes
+        context.q, context.dimension = context.codes.q, context.codes.dimension
+        context.cap, context.highs = self.arena.words[cap], self.count("highs")
+        self.context = context
+        self.size, self.depth = self.indices.words[size], self.indices.words[depth]
+        self.program = view(Program, self, self.tape("program"))
+
+    def boundary(self):
+        self.pool.empty()
+        for tape in self.roles.values():
+            tape.step(-1)
+            need(tape.read() == LEFT, "completed canonical head stands after LEFT")
+            tape.step(1)
+        ring = self.context.ring
+        expected_indices = {self.size.slot, self.depth.slot}
+        if self.geometry_state is not None:
+            _definition, page, layout, fields, columns = self.geometry_state
+            expected_indices.update(word.slot for word in
+                                    (columns, page.one, page.two, page.leaf_cutoff, fields,
+                                     layout.core, layout.extra, layout.total))
+        need(self.arena.live == {ring.modulus.slot, ring.one.slot, self.context.cap.slot} and
+             self.indices.live == expected_indices,
+             "only declared persistent and active geometry words at a completed macro")
+
+    @contextmanager
+    def geometry(self, definition):
+        if self.geometry_state is not None:
+            owner, page, layout, fields, _columns = self.geometry_state
+            need(owner is definition, "one active residual geometry")
+            yield page, layout, fields
+            return
+        divisor = self.indices.literal(self.context.dimension)
+        columns, remainder = Unsigned(self.indices).divmod(self.size, divisor)
+        self.indices.free_many(divisor, remainder)
+        page = Geometry(definition.plan, self.indices, columns, self.depth, definition.code, self.program)
+        if self.binding.cutoff != 64:
+            self.indices.free(page.leaf_cutoff)
+            page.leaf_cutoff = self.indices.literal(self.binding.cutoff)
+        layout = Layout(page, self.size, self.context.ring, self.context.q,
+                        self.count("leading"), self.count("gap"), self.count("suffix"))
+        fields = page.plus(self.depth, page.one)
+        self.geometry_state = definition, page, layout, fields, columns
+        yield page, layout, fields
+
+    def close_geometry(self):
+        if self.geometry_state is None:
+            return
+        _definition, page, layout, fields, columns = self.geometry_state
+        self.geometry_state = None
+        self.indices.free(fields)
+        layout.close()
+        page.close()
+        self.indices.free(columns)
+
+    def node(self):
+        divisor = self.indices.literal(self.context.dimension)
+        columns, remainder = Unsigned(self.indices).divmod(self.size, divisor)
+        valid = not columns.zero()
+        self.indices.free_many(divisor, columns, remainder)
+        need(valid, "complete internal node width")
+        for label in ("old_count", "rows", "before", "gap", "suffix"):
+            self.count(label).normalize()
+            positive(self.count(label))
+        # Preserve source ingress validation before the first payload operation.
+        first = read_prefix(self.tape("old_directory"), self.depth)
+        self.tape("old_directory").rewind()
+        zero = self.indices.zero()
+        incoming = self.binding.incoming(self)
+        try:
+            value = incoming.coefficient(first, Request("incoming", zero))
+            self.arena.free(value)
+        finally:
+            first.clear()
+            self.indices.free(zero)
+        unused = fresh_rows.quotient(self.count("rows"), self.context, self.topology.families)
+        self.save_count(unused, "unused")
+        stock = Count(self.count("unused"))
+        try:
+            need(stock.divide_small(self.binding.stock_multiple) == 0, "compatible fresh stock factor")
+        finally:
+            stock.close()
+        self.save_count(Count.product(self.count("unused"), self.count("before")), "leading")
+        fibre = Count.product(self.count("leading"), self.count("gap"))
+        total = Unsigned(self.indices).times_small(self.size, 2)
+        multiply_atom_power(fibre, total, self.context.ring, self.context.q)
+        self.indices.free(total)
+        complete = Count.product(fibre, self.count("suffix"))
+        fibre.close()
+        self.save_count(complete, "fibre")
+        peeled = peel.run(self.tape("source"), self.context, self.indices, self.size, self.depth,
+                          self.program, self.tape("old_directory"), self.count("old_count"),
+                          self.count("rows"), self.count("before"), self.count("gap"),
+                          self.count("suffix"), incoming)
+        self.commit(peeled, "peeled")
+        self.save_count(fresh_rows.family_rows(self.context), "family_rows")
+        source = self.tape("peeled")
+        outer = Counter(self.count("old_count"))
+        try:
+            while not outer.finished:
+                for family in range(self.topology.families):
+                    copy_rows(source, self.tape(("family", family)), self.count("family_rows"), self.count("fibre"))
+                outer.decrement()
+            need(source.read() == BLANK, "complete canonical fresh-row split")
+        finally:
+            outer.close()
+            source.rewind()
+            for family in range(self.topology.families):
+                self.tape(("family", family)).rewind()
+
+    def residual_begin(self, role, definition):
+        self.binding.check_stock(self)
+        directory, prefixes = produce(self.tape("old_directory"), self.depth, self.count("old_count"),
+                                      definition.code, self.context)
+        self.commit(directory, "directory")
+        self.save_count(prefixes, "prefixes")
+        with self.geometry(definition) as (_page, _layout, fields):
+            first = read_prefix(self.tape("directory"), fields)
+            self.tape("directory").rewind()
+            try:
+                self.binding.validate_residual(self, definition, first)
+            finally:
+                first.clear()
+        self.commit(self.tape(role), "current")
+        self.counts["residuals"] += 1
+        if self.observe is not None:
+            self.observe(self, "residual_begin", definition, role)
+
+    def prepare_child(self, definition, event, layout, fields):
+        need(event.parent_identity is self.program and
+             event.source_code == definition.code == layout.geometry.source_code,
+             "recursive gate belongs to the current program and source")
+        raw = Unsigned(self.indices)
+        need(raw.compare(event.width, self.size) < 0, "strict child contraction")
+        extents = layout.child_extents(event.first, event.second, event.width, before=self.count("before"))
+        first = read_prefix(self.tape("directory"), fields)
+        self.tape("directory").rewind()
+        program = None
+        try:
+            program = self.binding.child_program(self, definition, event, first)
+            inputs = (self.tape("current"), self.tape("directory"), program,
+                      self.tape("prefixes"), self.tape("unused"), *(extent.tape for extent in extents))
+            for label, source in zip(CAPSULE, inputs):
+                target = self.handoff[label]
+                need(target.read() == BLANK, "empty fixed child handoff port")
+                append_tape(source, target)
+                target.rewind()
+            return (self.arena.copy(self.context.ring.modulus),
+                    self.indices.copy(event.width), self.indices.copy(event.depth))
+        finally:
+            if program is not None:
+                program.clear()
+            first.clear()
+            for extent in extents:
+                extent.close()
+
+    def block(self, definition, block):
+        grants = None
+        with self.geometry(definition) as (page, layout, fields):
+            if block[0] == "axis":
+                axis = block[1]
+                trace = child(page, page.raw.times_small(page.columns, axis),
+                              page.raw.times_small(page.columns, 3 - axis),
+                              self.indices.copy(page.columns), "good")
+            else:
+                trace = block_events(page, block)
+            try:
+                first = next(trace, None)
+                if first is not None and first.kind == "enter" and page.raw.compare(first.width, page.leaf_cutoff) >= 0:
+                    grants = self.prepare_child(definition, first, layout, fields)
+                else:
+                    def complete_events():
+                        if first is not None:
+                            yield first
+                        yield from trace
+                    result = packet_engine.run(self.tape("current"), complete_events(), layout,
+                                               self.tape("directory"), self.count("prefixes"), fields,
+                                               lambda prefix, request: self.binding.coefficient(self, definition, prefix, request))
+                    self.commit(result, "current")
+            finally:
+                trace.close()
+        if grants is not None:
+            self.close_geometry()
+            self.call(grants)
+            return True
+        return False
+
+    def call(self, grants):
+        self.pool.empty()
+        need(self.geometry_state is None, "close derived geometry before the recursive cut")
+        ring = self.context.ring
+        self.header.write(self.tape("header"), (int(self.root), self.mode, self.pc + 1,
+                          ring.modulus.slot, ring.one.slot, self.context.cap.slot,
+                          self.size.slot, self.depth.slot))
+        self.streams.park()
+        modulus, size, depth = grants
+        self.numerical.park(({modulus.slot}, {size.slot, depth.slot}))
+        for label in CAPSULE:
+            transfer(self.handoff[label], self.tape(label))
+        self.new_context(modulus, size, depth)
+        self.root, self.mode, self.pc = False, self.binding.child_mode, 0
+        self.counts["calls"] += 1
+
+    def close_frame(self):
+        self.close_geometry()
+        ring = self.context.ring
+        self.context.close()
+        ring.close()
+        self.arena.free(ring.modulus)
+        self.indices.free_many(self.size, self.depth)
+        for tape in self.roles.values():
+            tape.clear()
+        self.pool.empty()
+        need(not self.arena.live and not self.indices.live, "child numerical cleanup before restoration")
+
+    def returned(self):
+        families = {i: self.tape(("family", i)) for i in range(self.topology.families)}
+        result = fresh_rows.merge(families, self.context, self.topology.families,
+                                 self.count("old_count"), self.count("fibre"))
+        need(self.output.read() == BLANK, "empty protected return port")
+        append_tape(result, self.output)
+        self.output.rewind()
+        result.clear()
+        return self.complete_return()
+
+    def complete_return(self):
+        """Return the already completed protected output through one frame."""
+        self.close_frame()
+        if self.root:
+            return True
+        self.numerical.restore()
+        self.streams.restore()
+        root, self.mode, self.pc, *labels = self.header.read(self.tape("header"))
+        self.root = bool(root)
+        self.tape("header").clear()
+        self.restore_context(labels)
+        transfer(self.output, self.tape("current"))
+        self.counts["returns"] += 1
+        return False
+
+    def dispatch(self, operation):
+        kind, *args = operation
+        context, old_count, fibre = self.context, self.count("old_count"), self.count("fibre")
+        if kind == "node":
+            self.node()
+        elif kind == "residual_begin":
+            self.residual_begin(*args)
+        elif kind == "block":
+            if self.block(*args):
+                return "jump"
+        elif kind == "residual_end":
+            self.close_geometry()
+            transfer(self.tape("current"), self.tape(args[0]))
+            self.tape("directory").clear()
+            self.tape("prefixes").clear()
+            if self.observe is not None:
+                self.observe(self, "residual_end", args[1], args[0])
+        elif kind == "gather_route":
+            role, family, low, route = args
+            selected = gather(self.tape(("family", family)), context, old_count, low, fibre)
+            try:
+                self.commit(route_packet(selected, route, context, old_count, fibre), role)
+            finally:
+                selected.clear()
+        elif kind == "route_scatter":
+            role, family, low, route = args
+            result = route_packet(self.tape(role), route, context, old_count, fibre)
+            try:
+                changed = scatter(self.tape(("family", family)), result, context, old_count, low, fibre)
+                self.commit(changed, ("family", family))
+            finally:
+                result.clear()
+        elif kind == "gather":
+            role, family, low = args
+            self.commit(gather(self.tape(("family", family)), context, old_count, low, fibre), role)
+        elif kind == "scatter":
+            role, family, low = args
+            self.commit(scatter(self.tape(("family", family)), self.tape(role), context, old_count, low, fibre), ("family", family))
+        elif kind == "xor":
+            target, source = args
+            self.commit(xor_packet(self.tape(source), self.tape(target), context, old_count, fibre), target)
+        elif kind == "family_xor":
+            target, source = args
+            self.commit(xor_family(self.tape(("family", source)), self.tape(("family", target)),
+                                   old_count, self.count("family_rows"), fibre), ("family", target))
+        elif kind == "exchange":
+            first, second = (("family", index) for index in args)
+            transfer(self.tape(first), self.tape("swap"))
+            transfer(self.tape(second), self.tape(first))
+            transfer(self.tape("swap"), self.tape(second))
+        elif kind == "copy":
+            self.commit(self.tape(args[0]), args[1])
+            if self.observe is not None:
+                self.observe(self, "copy_source", *args)
+        elif kind == "move":
+            transfer(self.tape(args[0]), self.tape(args[1]))
+        elif kind == "clear":
+            self.tape(args[0]).clear()
+        elif kind == "checkpoint":
+            if self.observe is not None:
+                self.observe(self, *args)
+        else:
+            need(kind == "return", "closed finite macro alphabet")
+            return "done" if self.returned() else "jump"
+        return "next"
+
+    def load_root(self, source, directory, program, modulus, size, depth, old_count, rows, before, gap, suffix, mode=0):
+        need(not self.arena.live and not self.indices.live, "empty supplied working banks")
+        inputs = (source, directory, program, old_count.tape, rows.tape, before.tape, gap.tape, suffix.tape)
+        owned = (*self.roles.values(), *self.handoff.values(), self.output, *self.pool.tapes)
+        need(all(input_tape is not work_tape for input_tape in inputs for work_tape in owned),
+             "borrowed root input ports are outside the reusable working bank")
+        for label, tape in zip(CAPSULE, inputs):
+            self.commit(tape, label)
+        self.new_context(copy_word(modulus, self.arena), copy_word(size, self.indices), copy_word(depth, self.indices))
+        self.mode, self.pc, self.root = mode, 0, True
+
+    def run(self, source, directory, program, modulus, size, depth, old_count, rows, before, gap, suffix, mode=0):
+        need(not self.closed, "one owned root invocation per machine initialization")
+        with self.pool.install():
+            self.load_root(source, directory, program, modulus, size, depth, old_count, rows, before, gap, suffix, mode)
+            while True:
+                self.boundary()
+                operation = self.programs[self.mode].operations[self.pc]
+                action = self.dispatch(operation)
+                self.counts["macros"] += 1
+                if action == "done":
+                    break
+                if action == "next":
+                    self.pc += 1
+            self.pool.empty()
+            need(self.numerical.machine.tapes == [{}, {0: "^"}], "complete physical stack return")
+            self.erase_work()
+        return self.output
+
+    def erase_work(self):
+        """Erase permanent owned markers/templates at the final root return."""
+        need(not self.arena.live and not self.indices.live and not self.pool.live,
+             "root cleanup follows complete frame and scratch cleanup")
+        def marker(tape):
+            tape.step(-1)
+            need(tape.read() == LEFT, "owned work marker at the known origin")
+            tape.write(BLANK)
+            tape.step(1)
+        for tape in (*self.roles.values(), *self.handoff.values(), *self.pool.tapes):
+            need(tape.read() == BLANK, "empty body before owned marker erasure")
+            marker(tape)
+        for arena in (self.arena, self.indices):
+            for word in arena.words:
+                marker(word)
+            arena.template.erase()
+            marker(arena.template)
+        self.numerical._empty_port()
+        self.numerical._move(1, -1)
+        self.numerical._write(1, "_")
+        self.numerical._move(1, 1)
+        self.closed = True
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/residual_blocks.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/residual_blocks.py
new file mode 100644
index 0000000000..fba75e7649
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/residual_blocks.py
@@ -0,0 +1,106 @@
+"""Defunctionalized residual itinerary at complete column-sweep boundaries.
+
+The cursor contains only a fixed-source command label and a three-way stage.
+Variable column loops finish inside a block; an internal child can suspend
+only its finite return label. This module does not interpret payload blocks.
+"""
+import loader
+loader.activate()
+from plan import Request
+from role_parking import FiniteFields
+from trace import adapters, child, columns, primitive
+from words import need
+
+
+class Cursor:
+    def __init__(self, plan, position=0, stage=0):
+        self.plan, self.position, self.stage = plan, position, stage
+        self.bound = 3 if plan.good else len(plan.commands)
+        self.schema = FiniteFields((self.bound + 1, 3))
+        need(0 <= position <= self.bound and 0 <= stage < 3,
+             "finite residual cursor")
+        need(stage == 0 or (not plan.good and position < self.bound and
+                           plan.commands[position].kind == "child"),
+             "pair stages belong to fallback child commands")
+
+    @property
+    def done(self):
+        return self.position == self.bound
+
+    def save(self, tape):
+        self.schema.write(tape, (self.position, self.stage))
+
+    @classmethod
+    def restore(cls, plan, tape):
+        schema = FiniteFields(((3 if plan.good else len(plan.commands)) + 1, 3))
+        return cls(plan, *schema.read(tape))
+
+    def take(self):
+        """Advance before execution; the new cursor is the return continuation."""
+        need(not self.done, "unfinished residual block")
+        position, stage = self.position, self.stage
+        if self.plan.good:
+            self.position += 1
+            return ("forward", "good", "backward")[position], position, 0
+        command = self.plan.commands[position]
+        if command.kind == "child":
+            if stage < 2:
+                self.stage += 1
+            else:
+                self.position += 1
+                self.stage = 0
+            return "pair", position, stage
+        self.position += 1
+        return "sweep", position, 0
+
+
+def events(page, block):
+    """Reference expansion of one block, using the pinned primitive events.
+
+    A physical interpreter runs forward/backward/sweep and below-cutoff leaves
+    to completion. For an internal good/pair child it prepares the capsule and
+    parks the finite return cursor; this reference generator is not that stack.
+    """
+    kind, position, stage = block
+    if kind in ("forward", "backward"):
+        yield from adapters(page, kind == "backward")
+    elif kind == "good":
+        yield from child(page, page.index.zero(),
+                         page.raw.times_small(page.columns, 2 * page.plan.dimension - page.plan.rank),
+                         page.raw.times_small(page.columns, page.plan.rank), "good")
+    elif kind == "sweep":
+        command = page.plan.commands[position]
+        need(command.kind in ("add", "sign"), "complete nonrecursive column sweep")
+        for column in columns(page):
+            target = page.point(command.target, column)
+            if command.kind == "sign":
+                yield from primitive("sign", target, None, None, page)
+            else:
+                source = page.point(command.source, column)
+                request = Request("adapter", page.index.copy(column), command.reference)
+                yield from primitive("add", target, source, request, page)
+    else:
+        need(kind == "pair", "closed residual block alphabet")
+        command = page.plan.commands[position]
+        i, k, dimension = command.target, command.source, page.plan.dimension
+        need(i < k, "ordered fallback child fields")
+        if stage != 1:
+            if (i < dimension) != (k < dimension):
+                return
+            half, remainder = page.raw.divmod(page.columns, page.two)
+            page.index.free(remainder)
+            if half.zero():
+                page.index.free(half)
+                return
+            after = page.raw.times_small(page.columns, k + 1)
+            second = page.raw.subtract_exact(after, half)
+            page.index.free(after)
+            yield from child(page, page.raw.times_small(page.columns, k), second,
+                             half, "unit", half=True)
+        else:
+            child_kind = command.reference.kind
+            need(child_kind in ("unit", "pair"), "selected fallback child kind")
+            yield from child(page, page.raw.times_small(page.columns, i),
+                             page.raw.times_small(page.columns, k), page.index.copy(page.columns),
+                             child_kind, i if child_kind == "pair" else 0,
+                             i >= dimension if child_kind == "pair" else False)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/role_parking.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/role_parking.py
new file mode 100644
index 0000000000..fc48c244ee
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/role_parking.py
@@ -0,0 +1,116 @@
+"""Fixed canonical stream roles and finite control on the shared parking tape.
+
+The caller supplies dense role bodies over the retained record alphabet and
+finishes numerical restoration before restoring this enclosing stream frame.
+The codec reads no payload length or physical head coordinate into control.
+"""
+import loader
+loader.activate()
+from records import Tape
+from words import BLANK, LEFT, ONE, ZERO, need
+
+BODY = (0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+
+
+class RoleParking:
+    def __init__(self, numerical_codec, roles):
+        self.port = numerical_codec
+        self.roles = tuple(roles)
+        need(len({id(tape) for tape in self.roles}) == len(self.roles),
+             "distinct permanent stream roles")
+
+    def park(self):
+        port = self.port
+        port._empty_port()
+        port._command("begin")
+        for tape in self.roles:
+            tape.rewind()
+            while True:
+                symbol = tape.read()
+                if symbol == BLANK:
+                    break
+                need(symbol in BODY, "dense fixed-alphabet role body")
+                for shift in range(4):
+                    port._put_bit((symbol >> shift) & 1)
+                tape.write(BLANK)
+                tape.step(1)
+            tape.rewind()
+            port._write(1, "$")
+            port._rewind_port()
+            port._command("push")
+        port._empty_port()
+
+    def restore(self):
+        port = self.port
+        port._empty_port()
+        # The record count and order are fixed at compilation, including empty
+        # roles. No unbounded handle or record-count decoder is necessary.
+        for tape in reversed(self.roles):
+            tape.rewind()
+            need(tape.read() == BLANK, "child clears canonical roles before return")
+            port._command("pop")
+            while port._read(1) != "$":
+                symbol = 0
+                for shift in range(4):
+                    symbol |= port._take_bit() << shift
+                need(symbol in BODY, "restored fixed-alphabet role symbol")
+                tape.append(symbol)
+            port._write(1, "_")
+            port._rewind_port()
+            tape.rewind()
+        port._command("end")
+        port._empty_port()
+
+
+class FiniteFields:
+    """A fixed schema for source labels, slot labels and continuation states.
+
+    Bounds belong to the compiled fixed-q source. Runtime dimensions, residue
+    values, tape extents and recursion depth must use encoded data roles.
+    """
+    def __init__(self, bounds):
+        self.bounds = tuple(bounds)
+        need(all(type(bound) is int and bound > 0 for bound in self.bounds),
+             "positive compile-time finite-field bounds")
+        self.widths = tuple(max(1, (bound - 1).bit_length()) for bound in self.bounds)
+
+    def write(self, tape, values):
+        need(len(values) == len(self.bounds), "finite continuation arity")
+        tape.rewind()
+        need(tape.read() == BLANK, "empty finite-control destination")
+        for value, bound, width in zip(values, self.bounds, self.widths):
+            need(type(value) is int and 0 <= value < bound, "finite continuation label")
+            for shift in range(width):
+                tape.append((value >> shift) & 1)
+        tape.rewind()
+
+    def read(self, tape):
+        tape.rewind()
+        values = []
+        for bound, width in zip(self.bounds, self.widths):
+            value = 0
+            for shift in range(width):
+                bit = tape.read()
+                need(bit in (ZERO, ONE), "complete finite-control bit field")
+                value |= bit << shift
+                tape.step(1)
+            need(value < bound, "admitted finite continuation label")
+            values.append(value)
+        need(tape.read() == BLANK, "exact finite-control record extent")
+        tape.rewind()
+        return tuple(values)
+
+
+def transfer(source, target):
+    """Move a complete owned result to its permanent canonical destination."""
+    need(source is not target, "distinct result and canonical destination")
+    target.clear()
+    source.rewind()
+    while source.read() != BLANK:
+        symbol = source.read()
+        need(symbol in BODY, "dense transferred body")
+        target.append(symbol)
+        source.write(BLANK)
+        source.step(1)
+    source.rewind()
+    target.rewind()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/scratch_pool.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/scratch_pool.py
new file mode 100644
index 0000000000..0f22807c65
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/binding/vendor/runtime/pr2809/scratch_pool.py
@@ -0,0 +1,151 @@
+"""Reusable physical stream tapes for completed, nonrecursive source blocks.
+
+Each lease has an explicit end. A repeated cleanup of an ended lease cannot
+erase a later borrower of the same physical role. No lease crosses CALL.
+"""
+from contextlib import contextmanager
+import sys
+from types import FunctionType
+
+import loader
+loader.activate()
+from records import Tape
+from words import Arena, BLANK, LEFT, Meter, need
+
+
+class Lease:
+    def __init__(self, pool, slot):
+        self.pool, self.slot, self.active = pool, slot, True
+        self.physical = pool.tapes[slot]
+        self.meter = Meter()
+
+    def owned(self):
+        need(self.active and self.pool.live.get(self.slot) is self, "live scratch lease")
+        return self.physical
+
+    @property
+    def head(self):
+        return self.owned().head
+
+    def read(self):
+        if not self.active:
+            raise ValueError("live scratch lease")
+        self.meter.reads += 1
+        return self.physical.read()
+
+    def write(self, symbol):
+        if not self.active:
+            raise ValueError("live scratch lease")
+        self.meter.writes += 1
+        self.physical.write(symbol)
+
+    def step(self, direction):
+        if not self.active:
+            raise ValueError("live scratch lease")
+        self.meter.moves += 1
+        self.physical.step(direction)
+
+    def append(self, symbol):
+        self.operation(self.physical.append, symbol)
+
+    def rewind(self):
+        self.operation(self.physical.rewind)
+
+    def operation(self, method, *args):
+        """Run the same literal tape loop without a lease wrapper at each cell.
+
+        Counter differences update only the observer's lease meter; the method
+        still performs its real reads, writes and unit moves on the physical tape.
+        """
+        if not self.active:
+            raise ValueError("live scratch lease")
+        meter = self.physical.meter
+        before = meter.reads, meter.writes, meter.moves
+        try:
+            return method(*args)
+        finally:
+            self.meter.reads += meter.reads - before[0]
+            self.meter.writes += meter.writes - before[1]
+            self.meter.moves += meter.moves - before[2]
+
+    def clear(self):
+        if not self.active:
+            return
+        self.operation(self.physical.clear)
+        self.active = False
+        del self.pool.live[self.slot]
+
+
+class ScratchPool:
+    def __init__(self, capacity):
+        need(type(capacity) is int and capacity > 0, "fixed scratch capacity")
+        self.tapes = tuple(Tape() for _ in range(capacity))
+        self.live = {}
+        self.peak = self.allocations = 0  # Checker observations, never selectors.
+
+    def acquire(self):
+        for slot, tape in enumerate(self.tapes):
+            if slot not in self.live:
+                # clear()'s rewind supplies the origin invariant. No physical
+                # head coordinate enters the allocator's finite slot choice.
+                need(tape.read() == BLANK, "empty scratch role before reuse")
+                lease = Lease(self, slot)
+                self.live[slot] = lease
+                self.peak = max(self.peak, len(self.live))
+                self.allocations += 1
+                return lease
+        raise ValueError("fixed scratch role inventory exhausted")
+
+    def empty(self):
+        need(not self.live, "completed macro closes all scratch leases")
+        for tape in self.tapes:
+            need(tape.read() == BLANK, "completed macro leaves scratch bodies empty")
+            tape.step(-1)
+            need(tape.read() == LEFT, "completed scratch head stands after LEFT")
+            tape.step(1)
+
+    @contextmanager
+    def install(self):
+        """Specialize only the authenticated source's Tape allocation sites.
+
+        Defaults retain the original Tape class object after imports; specialize
+        those defaults as well as module globals. Restore the process namespace
+        on exit. This adapter never changes a frozen file.
+        """
+        import controller
+        saved = []
+        for module in tuple(sys.modules.values()):
+            path = getattr(module, "__file__", None)
+            if path is None or not str(path).startswith(str(loader.CALLER)):
+                continue
+            for name, value in tuple(vars(module).items()):
+                if value is Tape:
+                    saved.append((module, name, value))
+                    setattr(module, name, self.acquire)
+                elif isinstance(value, FunctionType) and value.__defaults__:
+                    old = value.__defaults__
+                    if any(item is Tape for item in old):
+                        saved.append((value, "__defaults__", old))
+                        value.__defaults__ = tuple(self.acquire if item is Tape else item for item in old)
+        original_close = controller.Callback.close
+        original_tape_init, original_arena_init = Tape.__init__, Arena.__init__
+        def close(callback):
+            original_close(callback)
+            # The source's close ends these borrows but leaves their empty Tape
+            # objects to the host allocator. End the four physical leases here.
+            for stack in (callback.pending, callback.values):
+                stack.tape.clear()
+                stack.reverse.clear()
+        controller.Callback.close = close
+        def forbid_tape(_self, *_args, **_kwargs):
+            raise ValueError("physical Tape allocation inside a completed macro")
+        def forbid_arena(_self, *_args, **_kwargs):
+            raise ValueError("numerical Arena allocation inside a completed macro")
+        Tape.__init__, Arena.__init__ = forbid_tape, forbid_arena
+        try:
+            yield self
+        finally:
+            Tape.__init__, Arena.__init__ = original_tape_init, original_arena_init
+            controller.Callback.close = original_close
+            for owner, name, value in reversed(saved):
+                setattr(owner, name, value)
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/PROOF.md b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/PROOF.md
new file mode 100644
index 0000000000..82e9a8b0b5
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/PROOF.md
@@ -0,0 +1,242 @@
+# Physical Gaussian monomial on complete record packets
+
+Jose Manuel (`jmbarrancoml`), with substantial OpenAI Codex assistance.
+
+I implement the Gaussian phase boundary left open by PR3055. I retain
+PR2250's affine word, PR2378's coordinate and signed-word identities,
+PR2422's coefficient-field composition, and PR3055's physical Compact
+argument. I give a structured tape-program refinement under those source
+contracts. I have not proved this Python program in Lean or expanded it into
+a complete transition table.
+
+## Quantified interface
+
+Fix a field schema with ell fields, m distinct vector coordinates, and
+`1 <= m <= 73`. Fix an invertible binary m-by-m matrix L, an offset v,
+a constant c in Z/4, linear coefficients l_i in Z/4, and strict-upper
+quadratic coefficients q_ij in {0,1}. I compile these finite data before
+reading the input. I use the source convention: diagonal phase terms already
+belong to l_i; I do not reinterpret lower or diagonal matrix entries.
+
+Supply canonical encoded Counts for positive f,K,G,h,r,C and `0 <= rho < K`,
+with h>=2. Each vector field has width fK; u,t,b each have width `(f-1)G`.
+Place u,t before the vector fields and b after them. Other complete spectator
+fields may have width zero. Supply the complete C-row payload at its local
+origin, with
+
+    R = 2hr, a = sum(field widths), M0 = 2^a, v0 = M0*R,
+    M = C*M0, V = C*v0, A = 2+a+ceil(log2(R+1)).
+
+Within each record, concatenate r coefficient fields. Within each field,
+store the h real bits followed by the h imaginary bits, each least significant
+bit first in two's-complement notation. Interpret these integers on one common
+caller-supplied grid. I neither change that grid nor round coefficients.
+
+For record address x, let x_j contain the m selected coordinate bits at low-bit
+position `rho+jK`. Define
+
+    P(x) = f*c + sum_(j=0)^(f-1) [sum_i l_i*x_(j,i)
+                              + 2*sum_(i<k) q_(i,k)*x_(j,i)*x_(j,k)] mod 4.
+
+Let F apply `x_j -> L*x_j+v` independently at each selected position, fixing
+the other address bits and the outer-row label. The forward endpoint sends
+each Gaussian coefficient z at x to `i^P(x)*z` at F(x). The inverse takes
+the coefficient at y, recovers `x=F^-1(y)`, and sends `i^-P(x)*z` to x.
+
+I require representability of each component that the requested unit phase
+negates. A most-negative h-bit component may remain or move without negation.
+The exact guards are:
+
+| Phase | Components that must exceed -2^(h-1) |
+|---|---|
+| 0 | none |
+| 1 | imaginary |
+| 2 | real and imaginary |
+| 3 | real |
+
+On admitted input, I preserve the borrowed payload and descriptors, return a
+distinct protected output at its origin, and erase owned scratch contents and
+markers. The caller consumes that output before reuse. For the named signed
+headroom rejection on otherwise admitted input, I also erase owned work and
+allow a valid retry. I make no rollback claim for arbitrary malformed input,
+internal failures or interruption.
+
+## Encoded phase accumulation
+
+In `Recipe.phase`, I copy f, divide by the literal four, and retain only its
+remainder in the finite control. I initialize the phase with `(f mod 4)*c`.
+I traverse f columns using an encoded ripple counter and advance a Count
+position by K after each column. I read one selected bit per compiled vector
+coordinate. The fixed linear and strict-upper quadratic loops update a
+four-state accumulator.
+
+By induction over the column counter, after j columns I hold
+`f*c + sum_(k<j) column_phase(x_k)` modulo four. The returned state therefore
+equals P(x). For inverse mode I negate that state modulo four. I never decode
+the varying f,K,rho or record address into a host integer. I use a fixed tuple
+of m bits, with m part of the compiled schema.
+
+In `scan`, I enumerate each complete row's addresses with an encoded Count.
+I decode that address through the inherited encoded Layout, compute P once,
+then traverse its r coefficient fields. I reset the local address at each
+outer row. The outer row ordinal never enters phase arithmetic.
+
+## Signed component traversal
+
+In `read_component`, I consume exactly h binary cells. Before the final bit
+I retain a Boolean recording whether the lower bits were zero. At the final
+bit I retain the sign. Their conjunction detects precisely the most-negative
+two's-complement word. I read both components and check the phase-specific
+guards before writing either output component of that pair.
+
+For negation, `emit_component` complements each bit and adds one using a
+one-bit carry. Induction over the bit position gives the residue of -z modulo
+2^h. The guard excludes the sole signed value whose negative cannot fit, so
+this residue represents the exact integer -z. For copying, I consume and emit
+exactly h bits, including leading zero bits. I do not normalize components as
+unsigned Counts.
+
+I implement the four unit phases as `(x,y)`, `(-y,x)`, `(-x,-y)` and `(y,-x)`.
+I clear the two component bodies through borrowed physical views after each
+pair, retaining their active leases until the complete scan ends. Thus I use
+two reusable component buffers rather than one buffer per coefficient.
+
+For each address the phase remains fixed throughout its r fields. By induction
+over the field, record and row counters, I obtain the stated phase endpoint
+on the whole packet. I check exhaustion before disposing of the owned input.
+
+## Affine composition and returned ports
+
+I use the authenticated `binary_word` compiler from PR2250 once, before input.
+It decomposes the invertible affine map into XOR and toggle gates. Each gate
+acts on the selected bits in parallel. For f>1, I execute the corresponding
+physical Compact gate from PR3055 with n=f-1. I retain its dirty-field repair,
+highest-bit step, complete-row scope, binary B1 calls and source hypotheses.
+
+`PairDispatch` owns one Compact inventory. I select only an action in the
+compiled word and require a closed callee, empty leases and consumed protected
+output before changing its finite source, target and order. I suspend the
+parent allocation scope during the call. After return I copy the callee's
+protected output to one parent lease, clear the callee return and its marker,
+and consume the previous parent stream. I keep the constructor seal active
+through this exchange.
+
+For f=1, the compact fields have zero width. I use the inherited complete-row
+digit permutation or toggle, preserving spectator bits and concatenating rows
+in their original order. I make no Compact/B1 call in that branch. I construct
+the compact width as literal zero instead of multiplying zero by G: the
+caller may supply an arbitrarily long unused G descriptor.
+
+Forward execution phases the original record before applying the affine word.
+Inverse execution reverses the involutive gates before evaluating the negative
+phase at the recovered address. These compositions give the quantified
+endpoint. A phase evaluated at the destination address would in general give
+a different inverse; the failure suite injects that error.
+
+## Complete time charge
+
+For each record, the encoded Layout decodes at cost O_ell(a^2). A selected
+bit lookup uses a scan of O(a) cells, and fK<=a with K>=1. I therefore charge
+O_m(a^2) for the column loop and its position/counter maintenance. I charge
+O(h) for each signed pair, including reads, emissions, rewinds and erasure.
+The coefficient and component counters add no larger term: the subsequent
+complete traversals pay their initialization. One phase pass costs
+
+    O_(ell,m)(V + M*A^2).
+
+I perform the whole-packet extent multiplication once. Its cost
+`O((A+log(C+1))^2)` fits `O(V+M*A^6)`, using `log^2(C+1)=O(C)` and M>=C.
+I keep C out of the per-record arithmetic. Initial cloning, final output
+copying, complete rewinds and returned-port disposal cost O(V).
+
+Let g_E count early XOR gates and toggles, g_L count late XOR gates, and
+`g=g_E+g_L`, `S=4g_E+12g_L`. These constants depend only on the fixed recipe;
+the source elimination gives the coarse bound `g<=m^2+3m`. For f>1 set
+
+    delta = min(1,(f-1)*(2*2^(-G)+8*2^(G-K))).
+
+Assume the pinned completed binary ordinary contract
+`T_B1(v,b)<=K_q*v*(1+b^tau)` from PR3055, with its eligible fixed prime q,
+source preservation, completed spectators and restored owned work. I obtain
+
+    S*sum_(j=1)^C T_B1(v0,(f-1)G)
+      + O_(ell,m)((g+1)*(V+M*A^6) + g*delta*M*A*(R+A)).
+
+I count SC binary calls. The binary padding below q^2, native restoration and
+disposal already belong to the inherited B1 bound. I retain that factor there.
+At f=1 I obtain `O_(ell,m)(gV+M*A^6)` without B1. The positive-G check reads
+only a constant-size prefix under the canonical-Count premise.
+
+In the retained long-record domain `f<=p`, `A=O(p)`,
+`G=4*ceil(log2 p)+6`, `K/log p -> infinity`, with R exceeding each fixed power
+of p, PR3055 gives `delta=O(p^-3)`. I absorb the displayed preparation and
+repair terms and obtain `O_(q,ell,m)(V*(1+((f-1)G)^tau))`. I retain the
+unabsorbed invoice at independent finite sizes. I do not infer these universal
+charges from the fixture timings.
+
+## Inventory, space and rejection
+
+I allocate `8*ell+256` parent scratch roles, one protected output, and one
+Compact/Binary/native inventory before numerical input. A conservative parent
+census is `2*ell+96` live roles: ell+3 Layout Counts, at most ell decoded
+fields, seven persistent setup Counts, current/output/component streams,
+counters and nested encoded arithmetic temporaries. I close a predecessor
+before replacing its role. I allocate no physical inventory per gate, column,
+record or coefficient field.
+
+Including borrowed payload, a conservative occupied-content bound is
+
+    6V + 2*delta*M*a + M + O_ell(A+log(C+1))
+       + W_B1(v0,(f-1)G) + F_q.
+
+I omit B1 and exceptional terms at f=1. I add D_in, the total borrowed
+descriptor storage, when counting parameter input tapes. At f=1, an untouched
+G tape can exceed V; I exclude it only from owned workspace and execution time.
+The common-grid denominator is a caller convention, not another scanned
+parameter in this interface.
+
+For fresh backing storage, each parent role reaches at most
+`O(V+A+log(C+1))` cells. Each Compact role has the PR3055 allowance
+`O(v0+delta*M0*a+A+log(C+1))`; I retain separate protected-output and B1
+allowances. Multiplication by the fixed role capacities preserves the stated
+asymptotic bound. For a reused engine I take each role's maximum extent over
+prior invocations: the simulator blanks cells without shrinking its backing
+bytearray. I do not charge the fixed word as separate persistent inventories.
+
+For `SignedHeadroomError`, I clear both component bodies, then the partial
+phase output and its counter/buffer leases. The parent clears its current
+owned packet, including an inverse call's permuted packet, closes Layout and
+setup Counts, checks the empty pool, erases markers and closes the invocation.
+I remove the empty protected-output marker before rethrowing. No Compact call
+remains active during a phase rejection. I preserve the borrowed input and
+descriptors; cleanup costs O(V) plus the charged descriptor scans.
+
+## Evidence and scope
+
+I exhaust the signed-pair domain at h=2,3,4, including 109 rejected pairs.
+I compare encoded phases with a separate integer polynomial, including all
+512 selected one-column addresses and wider repeated tensors. I compare
+complete physical packets against integer Gaussian/address oracles using
+orientation anchors and distinct Gaussian record labels. I test both
+directions, multiple coefficient fields, dirty spectators and outer rows.
+
+Gaussian negation carries depend on payload bits. I therefore use exact
+Gaussian value oracles and the signed-pair argument above; I do not apply the
+predecessor's linear bit-provenance technique through negation. During physical
+execution I disable the indexed monomial and Compact reference methods.
+The small complete fixtures use the ordinary elementary branch. I retain the
+faster B1 contract as a source obligation, with PR3055's separate fitted-handoff
+evidence, rather than a conclusion from these fixtures.
+
+I test later-field rejection and a valid retry on the same inventory, and an
+unused 4097-digit G at f=1. I inject missing repeated constants, destination
+inverse phases, skipped coefficient phases, omitted signed guards, uncompiled
+actions, unconsumed returns and source-binding failures.
+
+PR2534 already supplied a selected-child fixture with the earlier indexed
+Compact. PR2378/2422 already established the phase/record algebra. I contribute
+the encoded fixed-inventory phase implementation and its joined physical
+monomial endpoint. A caller still needs a common grid and adequate signed
+headroom, coefficient arithmetic, proper-width recursive dispatch, private
+lifetimes and a complete physical cost argument. I leave the selected result
+and the higher PR2979 candidate outside this contribution.
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/SOURCES.json b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/SOURCES.json
new file mode 100644
index 0000000000..e040a55880
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/SOURCES.json
@@ -0,0 +1,41 @@
+{
+  "schema_version":1,
+  "base_commit":"d8e0f83f00191df62174b641e9fff055c357f641",
+  "files":[
+    {"path":"docs/research/agent-task-catalog.json","usage":"provenance","git_blob":"67f085acd86acd7d4e03922d9cf4b26bca66fed5","sha256":"47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"},
+    {"path":"certificates/selected-result.json","usage":"input","git_blob":"b1fea0c94436b236cc2b7d41a7be032811b94c81","sha256":"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"},
+    {"path":"notes/compact-control-layout.tex","usage":"input","git_blob":"16f4d233471a7d189163ae7e7902becadecbba64","sha256":"2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87"},
+    {"path":"notes/compact-control-movement.tex","usage":"input","git_blob":"06b6a9ef24245ac7b724c53a204635415b402357","sha256":"b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6"},
+    {"path":"research/bit2234-stock-threshold/README.md","usage":"input","git_blob":"ede0d322c477af91d4c2cc33db0fd10958f45eab","sha256":"1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7"},
+    {"path":"research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz","usage":"input","git_blob":"9eafb8776cbf78c72124f833534469ddfa5e98ec","sha256":"0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f"},
+    {"path":"research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json","usage":"input","git_blob":"44006542202ca6037533a754f0bcd00549d7e088","sha256":"0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734"},
+    {"path":"research/e8-bit-p111-tuned/tune/EXPECTED.json","usage":"input","git_blob":"e293ddc557742637f9f679f083a1a282d87b1b13","sha256":"b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4"},
+    {"path":"research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz","usage":"input","git_blob":"85a4499bf9e4911a705d50567a2c2ef6cf23739a","sha256":"e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f"},
+    {"path":"research/pr589-five-helper-hosting/PROOF.md","usage":"input","git_blob":"bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02","sha256":"59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647"},
+    {"path":"research/pr589-five-helper-hosting/verify.py","usage":"input","git_blob":"dbc71f56bb4205ebe378ada1f9f4ea88630d1d39","sha256":"cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367"},
+    {"path":"research/recursive-parking-boundary/README.md","usage":"input","git_blob":"251f335ebaccc11d69393ee7aeb5a2e84526d0bb","sha256":"491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18"},
+    {"path":"research/selected-bit-local-ring-sweeps/PROOF.md","usage":"input","git_blob":"4330de85dd9862ed15d84ab917887d249753df99","sha256":"846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7"},
+    {"path":"research/selected-bit-recursive-closure/PROOF.md","usage":"input","git_blob":"6c410cab5713979214a45835091fbeb9ee9b8531","sha256":"74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344"},
+    {"path":"research/selected-complex-layer-closure/PROOF.md","usage":"input","git_blob":"d7ec0d101405a5f099f55f6a73e9791731737fd0","sha256":"43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265"},
+    {"path":"upstream/build/sections/02-streams.tex","usage":"input","git_blob":"088fceea1867abc76271d7efe7532b779fee9039","sha256":"606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab"},
+    {"path":"research/selected-monomial-coordinate-refinement/RECIPE.json","usage":"input","git_blob":"86f38710f388764659411f865fc1640dabc90586","sha256":"b3f5d3d5b6ab1a42b1eb7ed00d850a327f3652a9a498f0a239d0e606e0c3f272"},
+    {"path":"research/selected-monomial-coordinate-refinement/sources/RESIDUAL-ADAPTERS.json","usage":"input","git_blob":"ed43ed7d505b88afb51fc33d205710f806fe5d2f","sha256":"383f40aadd00a4ac700dfd0d4c22d6c6c0be9a9863116e4d69c7acd23bafae0c"},
+    {"path":"research/selected-complex-layer-closure/arithmetic.py","usage":"input","git_blob":"009d7b7166718832ebbf11893cb1ef258184a4f9","sha256":"31e4b21bb64924d723d1248a7eccf4e9c80d323ba8784804af79a75da18c346a"},
+    {"path":"research/selected-monomial-coordinate-refinement/lean/PhaseWords.lean","usage":"input","git_blob":"f463cb2ddccc4aeaf4d7e2e1fbe358ef374c14c9","sha256":"8574b3b3febf18e012976986147075730c6903c3f349c78d51cde444dcfeff79"},
+    {"path":"research/lean-record-phase-bridge/lean/RecordBridge.lean","usage":"input","git_blob":"790d84239cfdb85d0a6167ce0ae6587bdc843a48","sha256":"b9d648d50f620ebd92cc7065330a20371bd8445a01f671a6d572c3a501f9da32"}
+  ],
+  "archives":[
+    {"path":"inputs/pr3055.tar","head":"9dc841c9a101435fdd15e0f7623bf16b6d0363e9","source_path":"research/physical-complex-compact","git_tree":"e9acbd7053e6b065ad783aa29bf29489866fc634","sha256":"c76e11cce0696db643715a362631b60fb14f26ba66c1e3bb5b5b0389eb52e95d"}
+  ],
+  "predecessors":[
+    {"pr":3055,"head":"9dc841c9a101435fdd15e0f7623bf16b6d0363e9","credit":"Jose Manuel: encoded physical Compact, B1 handoff, exceptional repair, outer rows and fixed ownership."},
+    {"pr":2250,"head":"d404b48a1e7b147556b309497d55089c837dddb2","credit":"Original sequential Compact and monomial implementation; Douglas Colkitt's compact algebra, guard and repair method."},
+    {"pr":2287,"head":"8c60765b5dea9d862b3b190d55da102a576031bf","credit":"Gaussian arithmetic and complex-layer grid proof; retain the package's complete contributor attribution."},
+    {"pr":2378,"head":"5816f94741709e8082e06a2cc9a114ff87411f3d","credit":"AAAmirinu: signed carry/headroom and conditional coordinate refinement."},
+    {"pr":2422,"head":"0df268def5a3ce9e7e077ed8166eec545c3b8c25","credit":"Gareth Davidson/bitplane: all-field record composition, common-scale theorem and guarded inverse."},
+    {"pr":2534,"head":"f961dcb12061c3959058aed883f48b55f365eb80","credit":"ywz65: selected child-7 two-column Compact/monomial/leaf/caller-return composition, dirty helpers, three rows and K2 omission witness."},
+    {"pr":2899,"head":"2f0911ad735643a069b9790302fbf179e49f74f8","credit":"Physical ordinary interchange and its retained C0/BIT predecessors; full notices remain inside the frozen archive."}
+  ],
+  "authentication":"I authenticate 20 live proof/runtime inputs in verify.py before importing checks, then the unchanged PR3055 export in phase_sources.py and its nested PR2899/2250 sources and transitive C0 chain. I use the original monomial implementation for finite affine compilation and checker reference access.",
+  "attribution":"Jose Manuel (jmbarrancoml), with substantial OpenAI Codex assistance including analysis subagents. Apache-2.0, retaining source-specific notices in immutable archives. I preserve prior phase algebra, selected fixtures and physical ordinary/Compact credit. I claim no independent human or proof-assistant verification."
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/monomial_engine.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/monomial_engine.py
new file mode 100644
index 0000000000..2251fd98ba
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/monomial_engine.py
@@ -0,0 +1,184 @@
+"""Physical Gaussian phases joined to one reusable Compact inventory."""
+import phase_sources
+phase_sources.activate()
+from cardinal_counts import Count,positive
+from compact_counts import append_bits,copy_bits
+from compact_layout import Layout
+from compact_streams import digit_permutation,flip_digit
+from encoded import compare,subtract
+from pair_dispatch import PairDispatch
+from phase_recipe import Recipe
+from records import Tape
+from scratch_pool import ScratchPool
+from session import (OuterScope,borrowed_count,borrowed_tape,erase_marker,
+                     initialize_marker,sealed_constructors)
+from signed_phase import SignedHeadroomError,scan
+from words import BLANK,LEFT,need
+
+
+class MonomialEngine:
+    def __init__(self,names,vectors,literal,native):
+        need(type(names) is tuple and len(names) == len(set(names)), "fixed monomial field schema")
+        self.names = names
+        self.recipe = Recipe(literal,vectors)
+        positions = tuple(names.index(name) for name in self.recipe.vectors)
+        need(not set(self.recipe.vectors)&{"u","t","b"} and
+             names.index("u") < min(positions) and names.index("t") < min(positions) and
+             names.index("b") > max(positions), "complete front/back compact placement")
+        actions = tuple(self.action(gate) for gate in self.recipe.word)
+        self.compact = PairDispatch(names,actions,self.recipe.vectors[0],native)
+        self.pool = ScratchPool(8*len(names)+256)
+        self.scope = OuterScope(self.pool)
+        self.output = Tape()
+        for tape in (*self.pool.tapes,self.output):
+            erase_marker(tape)
+        self.closed = True
+
+    def action(self,gate):
+        kind,target,source = gate
+        target_name = self.recipe.vectors[target]
+        source_name = None if kind == "flip" else self.recipe.vectors[source]
+        late = False if source_name is None else self.names.index(source_name) > self.names.index(target_name)
+        return source_name,target_name,late
+
+    def rearm(self):
+        need(self.closed and self.output.read() == BLANK, "consume previous monomial output")
+        self.output.step(-1)
+        marker = self.output.read()
+        need(marker in (LEFT,BLANK), "monomial output origin")
+        if marker == BLANK:
+            self.output.write(LEFT)
+        self.output.step(1)
+        for tape in self.pool.tapes:
+            initialize_marker(tape)
+        self.closed = False
+
+    def compact_gate(self,current,gate,widths,n,K,G,rho,record_bits,rows):
+        self.compact.select(self.action(gate))
+        with self.scope.suspended():
+            returned = self.compact.run(borrowed_tape(current),tuple(borrowed_count(value) for value in widths),
+                                        *(borrowed_count(value) for value in (n,K,G,rho,record_bits,rows)))
+        following = None
+        try:
+            following = self.pool.acquire()
+            append_bits(returned,following)
+            following.rewind()
+            current.clear()
+            result,following = following,None
+            return result
+        finally:
+            returned.clear()
+            erase_marker(returned)
+            if following is not None:
+                following.clear()
+
+    def single_column_gate(self,current,gate,plan,rho):
+        source,target,_late = self.action(gate)
+        target_bit = plan.bit_position(target,rho)
+        source_bit = None
+        try:
+            if source is None:
+                return flip_digit(current,plan,target_bit,self.pool.acquire)
+            source_bit = plan.bit_position(source,rho)
+            early = compare(source_bit,target_bit) < 0
+            first,second = (source_bit,target_bit) if early else (target_bit,source_bit)
+            return digit_permutation(current,plan,first,second,
+                                     (0,1,3,2) if early else (0,3,2,1),self.pool.acquire)
+        finally:
+            target_bit.close()
+            if source_bit is not None:
+                source_bit.close()
+
+    def run(self,payload,widths,f,K,G,rho,component_bits,coefficients,outer_rows,inverse=False):
+        need(type(inverse) is bool and len(widths) == len(self.names) and
+             all(isinstance(value,Count) for value in widths), "compiled mode and encoded field inventory")
+        for value in (f,K,G,component_bits,coefficients,outer_rows):
+            positive(value)
+        source = borrowed_tape(payload)
+        need(source is not self.output, "distinct borrowed monomial input")
+        self.rearm()
+        plan = current = n = record_bits = wide = compact_width = total = one = two = None
+        guard_error = None
+        with sealed_constructors(),self.scope.installed():
+            try:
+                one,two = Count.literal(1),Count.literal(2)
+                need(compare(component_bits,two) >= 0 and compare(rho,K) < 0, "signed width and selected residue")
+                n = subtract(f,one)
+                wide = Count.product(f,K)
+                # G is unused at f=1 and need not fit the address extent.
+                compact_width = Count.literal(0) if n.zero() else Count.product(n,G)
+                need(all(compare(widths[self.names.index(name)],wide) == 0 for name in self.recipe.vectors),
+                     "complete wide monomial slots")
+                need(all(compare(widths[self.names.index(name)],compact_width) == 0 for name in ("u","t","b")),
+                     "complete used compact slots")
+                record_bits = Count.product(component_bits,coefficients)
+                record_bits.multiply_small(2)
+                plan = Layout(self.names,widths,record_bits)
+                total = Count.product(plan.row_bits,outer_rows)
+                current = self.pool.acquire()
+                source.rewind()
+                copy_bits(source,current,total)
+                need(source.read() == BLANK, "complete Gaussian monomial packet")
+                source.rewind()
+                current.rewind()
+                if not inverse:
+                    current = scan(current,plan,self.recipe,f,K,rho,component_bits,coefficients,outer_rows,self.pool.acquire)
+                for gate in reversed(self.recipe.word) if inverse else self.recipe.word:
+                    if n.zero():
+                        # Finish each complete outer row before concatenation.
+                        current = self.single_column_rows(current,gate,plan,rho,outer_rows)
+                    else:
+                        current = self.compact_gate(current,gate,widths,n,K,G,rho,record_bits,outer_rows)
+                if inverse:
+                    current = scan(current,plan,self.recipe,f,K,rho,component_bits,coefficients,outer_rows,self.pool.acquire,True)
+                append_bits(current,self.output)
+                current.clear()
+                current = None
+            except SignedHeadroomError as error:
+                guard_error = error
+            finally:
+                source.rewind()
+                if current is not None:
+                    current.clear()
+                if plan is not None:
+                    plan.close()
+                for value in (n,record_bits,wide,compact_width,total,one,two):
+                    if value is not None:
+                        value.close()
+                self.pool.empty()
+        for tape in self.pool.tapes:
+            erase_marker(tape)
+        self.output.rewind()
+        self.closed = True
+        if guard_error is not None:
+            erase_marker(self.output)
+            raise guard_error
+        return self.output
+
+    def single_column_rows(self,current,gate,plan,rho,outer_rows):
+        """Reuse complete-row gates without folding the row label into a key."""
+        from stream import Counter
+        remaining = Counter(outer_rows)
+        output,row = self.pool.acquire(),None
+        current.rewind()
+        try:
+            while not remaining.finished:
+                row = self.pool.acquire()
+                copy_bits(current,row,plan.row_bits)
+                row.rewind()
+                row = self.single_column_gate(row,gate,plan,rho)
+                append_bits(row,output)
+                row.clear()
+                row = None
+                remaining.decrement()
+            need(current.read() == BLANK, "complete one-column row packet")
+            current.clear()
+            output.rewind()
+            result,output = output,None
+            return result
+        finally:
+            remaining.close()
+            if row is not None:
+                row.clear()
+            if output is not None:
+                output.clear()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/pair_dispatch.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/pair_dispatch.py
new file mode 100644
index 0000000000..0e467bdb37
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/pair_dispatch.py
@@ -0,0 +1,19 @@
+"""Select a compiled Compact action only at a consumed, closed boundary."""
+import phase_sources
+phase_sources.activate()
+from compact_engine import CompactEngine
+from words import BLANK,need
+
+
+class PairDispatch(CompactEngine):
+    def __init__(self,names,actions,default_target,native):
+        actions = tuple(actions)
+        self.actions = frozenset(actions)
+        initial = actions[0] if actions else (None,default_target,False)
+        super().__init__(names,*initial,native)
+
+    def select(self,action):
+        need(action in self.actions, "action belongs to the compiled monomial word")
+        need(self.closed and self.output.read() == BLANK and not self.pool.live and
+             self.binary.closed and self.binary.native.closed, "closed consumed Compact action boundary")
+        self.source,self.target,self.late = action
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/phase_recipe.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/phase_recipe.py
new file mode 100644
index 0000000000..a2f684fb58
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/phase_recipe.py
@@ -0,0 +1,46 @@
+"""Finite monomial compilation and encoded tensor-phase accumulation."""
+import phase_sources
+_native,_compact,reference = phase_sources.activate()
+from cardinal_counts import Count
+from compact_counts import bit_at
+from stream import Counter
+from words import need
+
+
+class Recipe:
+    def __init__(self,literal,vectors):
+        self.vectors = tuple(vectors)
+        m = len(self.vectors)
+        need(0 < m <= 73 and len(set(self.vectors)) == m, "fixed monomial coordinate vocabulary")
+        self.matrix = tuple(literal["matrix_rows"])
+        self.linear = tuple(literal["linear_Z4"])
+        rows = tuple(literal["quadratic_rows"])
+        self.offset,self.constant = literal["offset"],literal["phase"]
+        need(len(self.matrix) == len(self.linear) == len(rows) == m, "complete fixed recipe")
+        need(all(type(row) is int and 0 <= row < 1<<m for row in (*self.matrix,*rows)),
+             "fixed binary recipe rows")
+        need(type(self.offset) is int and 0 <= self.offset < 1<<m and
+             type(self.constant) is int and 0 <= self.constant < 4 and
+             all(type(value) is int and 0 <= value < 4 for value in self.linear), "fixed affine and phase constants")
+        self.quadratic = tuple((i,j) for i in range(m) for j in range(i+1,m) if rows[i]>>j&1)
+        self.word = reference.binary_word(dict(matrix_rows=self.matrix,offset=self.offset))
+
+    def phase(self,state,columns,spacing,residue,inverse=False):
+        remaining = Counter(columns)
+        repetition,position = Count(columns),Count(residue)
+        value = self.constant*repetition.divide_small(4) % 4
+        repetition.close()
+        try:
+            while not remaining.finished:
+                # One bit per compiled coordinate is a fixed finite state.
+                bits = tuple(bit_at(state[name],position) for name in self.vectors)
+                for coefficient,bit in zip(self.linear,bits):
+                    value = (value+coefficient*bit) % 4
+                for i,j in self.quadratic:
+                    value = (value+2*bits[i]*bits[j]) % 4
+                position.add(spacing)
+                remaining.decrement()
+            return (-value)%4 if inverse else value
+        finally:
+            position.close()
+            remaining.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/phase_sources.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/phase_sources.py
new file mode 100644
index 0000000000..aaa5c663a4
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/phase_sources.py
@@ -0,0 +1,53 @@
+"""Authenticate the physical Compact predecessor and its monomial source."""
+from hashlib import sha256
+import importlib.util
+from pathlib import Path, PurePosixPath
+import sys
+import tarfile
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+ARCHIVE_SHA256 = "c76e11cce0696db643715a362631b60fb14f26ba66c1e3bb5b5b0389eb52e95d"
+_temporary = None
+_loaded = None
+
+
+def module(name,path):
+    spec = importlib.util.spec_from_file_location(name,path)
+    result = importlib.util.module_from_spec(spec)
+    sys.modules[name] = result
+    spec.loader.exec_module(result)
+    return result
+
+
+def activate():
+    global _temporary,_loaded
+    if _loaded is not None:
+        return _loaded
+    names = ("native_sources","source","loader","words","compact","compact_engine","streams")
+    if any(name in sys.modules for name in names):
+        raise ValueError("cold shared physical monomial namespace")
+    archive = HERE/"inputs/pr3055.tar"
+    if sha256(archive.read_bytes()).hexdigest() != ARCHIVE_SHA256:
+        raise ValueError("immutable physical Compact source archive")
+    _temporary = tempfile.TemporaryDirectory(prefix="physical-monomial-")
+    destination = Path(_temporary.name)
+    with tarfile.open(archive,"r:") as contents:
+        seen = set()
+        for entry in contents.getmembers():
+            path = PurePosixPath(entry.name)
+            if path.is_absolute() or ".." in path.parts or entry.name in seen or not (entry.isfile() or entry.isdir()):
+                raise ValueError("regular relative source archive")
+            seen.add(entry.name)
+        contents.extractall(destination,filter="data")
+    native = module("native_sources",destination/"native_sources.py")
+    native.ROOT = ROOT
+    _source,reference = native.activate()
+    sys.path.insert(0,str(destination))
+    if "compact" in sys.modules:
+        raise ValueError("one authenticated compact reference")
+    sys.modules["compact"] = reference
+    monomial = module("monomial_reference",Path(reference.__file__).with_name("monomial.py"))
+    _loaded = native,reference,monomial
+    return _loaded
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/reference.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/reference.py
new file mode 100644
index 0000000000..5fa4494167
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/reference.py
@@ -0,0 +1,102 @@
+"""Columnwise lift of fixed binary affine maps and Gaussian unit phases."""
+from streams import Tape,need,copy,digit_permutation,flip_digit
+from compact import Compact,execute
+
+
+def binary_word(recipe):
+    rows=list(recipe["matrix_rows"]);m=len(rows);reduction=[]
+    need(0<m<=73 and all(0<=row<1<<m for row in rows),"fixed binary matrix extent")
+    for j in range(m):
+        p=next((i for i in range(j,m) if rows[i]>>j&1),None)
+        need(p is not None,"invertible monomial linear map")
+        if p!=j:
+            for target,source in ((j,p),(p,j),(j,p)):
+                rows[target]^=rows[source];reduction.append(("add",target,source))
+        for i in range(m):
+            if i!=j and rows[i]>>j&1:
+                rows[i]^=rows[j];reduction.append(("add",i,j))
+    need(rows==[1<<i for i in range(m)],"complete binary elimination")
+    return tuple(reversed(reduction))+tuple(("flip",i,-1) for i in range(m) if recipe["offset"]>>i&1)
+
+
+def column_phase(recipe,x):
+    m=len(recipe["matrix_rows"])
+    # Raw retained recipes can store symmetric/diagonal entries. The source
+    # qvalue convention uses only the strict upper part; alpha holds diagonals.
+    value=sum(recipe["linear_Z4"][i] for i in range(m) if x>>i&1)
+    value+=2*sum(((recipe["quadratic_rows"][i]>>(i+1))&(x>>(i+1))).bit_count()
+                 for i in range(m) if x>>i&1)
+    return value%4
+
+
+def column_map(recipe,x):
+    return recipe["offset"]^sum(((row&x).bit_count()%2)<<i
+                                for i,row in enumerate(recipe["matrix_rows"]))
+
+
+def columns(state,m,f,K,rho):
+    return tuple(sum(((state["v"+str(i)]>>(rho+j*K))&1)<<i for i in range(m)) for j in range(f))
+
+
+def tensor_phase(recipe,state,f,K,rho,omit_tensor_constant=False):
+    constant=recipe["phase"]*(1 if omit_tensor_constant else f)
+    return (constant+sum(column_phase(recipe,x)
+                        for x in columns(state,len(recipe["matrix_rows"]),f,K,rho)))%4
+
+
+def negate(bits):
+    """Two's-complement negation in least-significant-bit stream order."""
+    carry=1;out=bytearray()
+    for bit in bits:
+        value=(1-bit)+carry;out.append(value&1);carry=value>>1
+    return out
+
+
+def phase_pass(source,layout,recipe,f,K,rho,coefficient_bits,inverse=False,
+               omit_tensor_constant=False):
+    need(coefficient_bits>=2 and layout.record_bits%(2*coefficient_bits)==0,"Gaussian record extent")
+    source.rewind();out=Tape(source.meter);real=Tape(source.meter);imag=Tape(source.meter)
+    def emit(tape,negative):
+        if negative:
+            carry=1
+            for _ in range(coefficient_bits):
+                value=(1-tape.read(1)[0])+carry
+                out.write(bytes((value&1,)));carry=value>>1
+        else:copy(tape,out,coefficient_bits)
+        tape.finish()
+    for index in range(layout.records):
+        phase=tensor_phase(recipe,layout.decode(index),f,K,rho,omit_tensor_constant)
+        if inverse:phase=-phase%4
+        source.meter.control_evaluations+=1
+        for _ in range(layout.record_bits//(2*coefficient_bits)):
+            copy(source,real,coefficient_bits);copy(source,imag,coefficient_bits)
+            real.rewind();imag.rewind()
+            if phase==0:emit(real,False);emit(imag,False)
+            elif phase==1:emit(imag,True);emit(real,False)
+            elif phase==2:emit(real,True);emit(imag,True)
+            else:emit(imag,False);emit(real,True)
+            real.erase();imag.erase()
+    source.finish();source.erase();out.rewind();return out
+
+
+def execute_monomial(source,layout,recipe,f,K,G,rho,coefficient_bits,inverse=False,
+                     omit_tensor_constant=False):
+    need(f>=1,"positive tensor width");word=binary_word(recipe)
+    if not inverse:
+        source=phase_pass(source,layout,recipe,f,K,rho,coefficient_bits,
+                          omit_tensor_constant=omit_tensor_constant)
+    for kind,i,k in reversed(word) if inverse else word:
+        target="v"+str(i);control=None if kind=="flip" else "v"+str(k)
+        if f>1:
+            source=execute(source,layout,Compact(f-1,K,G,rho,control,target,
+                           False if control is None else k>i))
+        elif control is None:
+            source=flip_digit(source,layout.bits,layout.position(target,rho),layout.record_bits)
+        else:
+            a,b=layout.position(control,rho),layout.position(target,rho)
+            mapping=(0,1,3,2) if a<b else (0,3,2,1)
+            source=digit_permutation(source,layout.bits,min(a,b),max(a,b),layout.record_bits,mapping)
+    if inverse:
+        source=phase_pass(source,layout,recipe,f,K,rho,coefficient_bits,True,
+                          omit_tensor_constant)
+    return source
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/signed_phase.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/signed_phase.py
new file mode 100644
index 0000000000..bab32b0c5d
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/monomial/signed_phase.py
@@ -0,0 +1,112 @@
+"""Fixed-width signed Gaussian phases on literal sequential tapes."""
+import phase_sources
+phase_sources.activate()
+from cardinal_counts import Count
+from compact_counts import copy_bits
+from session import borrowed_tape
+from stream import Counter
+from words import BLANK,need
+
+
+class SignedHeadroomError(ValueError):
+    pass
+
+
+MOVES = (((0,False),(1,False)),((1,True),(0,False)),
+         ((0,True),(1,True)),((1,False),(0,True)))
+
+
+def read_component(source,target,width):
+    """Copy the exact width; report the most-negative signed bit pattern."""
+    remaining = Counter(width)
+    lower_zero,sign = True,0
+    try:
+        while not remaining.finished:
+            bit = source.read()
+            need(bit in (0,1), "complete signed binary component")
+            target.append(bit)
+            source.step(1)
+            remaining.decrement()
+            if remaining.finished:
+                sign = bit
+            else:
+                lower_zero = lower_zero and bit == 0
+        target.rewind()
+        return bool(sign and lower_zero)
+    finally:
+        remaining.close()
+
+
+def emit_component(source,target,width,negative):
+    source.rewind()
+    if not negative:
+        copy_bits(source,target,width)
+    else:
+        remaining,carry = Counter(width),1
+        try:
+            while not remaining.finished:
+                bit = source.read()
+                need(bit in (0,1), "signed component digit")
+                value = (1-bit)+carry
+                target.append(value&1)
+                carry = value>>1
+                source.step(1)
+                remaining.decrement()
+        finally:
+            remaining.close()
+    need(source.read() == BLANK, "complete fixed-width component emission")
+
+
+def pair(source,target,width,phase,real,imag):
+    need(type(phase) is int and 0 <= phase < 4, "finite Gaussian unit phase")
+    try:
+        minima = (read_component(source,real,width),read_component(source,imag,width))
+        if any(negative and minima[which] for which,negative in MOVES[phase]):
+            raise SignedHeadroomError("signed Gaussian phase headroom")
+        buffers = (real,imag)
+        for which,negative in MOVES[phase]:
+            emit_component(buffers[which],target,width,negative)
+    finally:
+        # Retain the two active leases across coefficient fields.
+        borrowed_tape(real).clear()
+        borrowed_tape(imag).clear()
+
+
+def scan(source,plan,recipe,columns,spacing,residue,width,coefficients,outer_rows,factory,inverse=False):
+    output,real,imag = factory(),factory(),factory()
+    rows = Counter(outer_rows)
+    source.rewind()
+    try:
+        while not rows.finished:
+            records,index = Counter(plan.records),Count.literal(0)
+            try:
+                while not records.finished:
+                    state = plan.decode(index)
+                    try:
+                        phase = recipe.phase(state,columns,spacing,residue,inverse)
+                    finally:
+                        plan.close_state(state)
+                    fields = Counter(coefficients)
+                    try:
+                        while not fields.finished:
+                            pair(source,output,width,phase,real,imag)
+                            fields.decrement()
+                    finally:
+                        fields.close()
+                    index.increment()
+                    records.decrement()
+            finally:
+                records.close()
+                index.close()
+            rows.decrement()
+        need(source.read() == BLANK, "complete Gaussian phase packet")
+        source.clear()
+        output.rewind()
+        return output
+    except BaseException:
+        output.clear()
+        raise
+    finally:
+        real.clear()
+        imag.clear()
+        rows.close()
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/RESULT.json b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/RESULT.json
new file mode 100644
index 0000000000..e4a03118d5
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/RESULT.json
@@ -0,0 +1,396 @@
+{
+  "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810",
+  "base_margin_upper_at_new_claim": "-390359343452242794286352754590140865431940508358395458455/3138550867693340381917894711603833208051177722232017256448",
+  "complete_cost": {
+    "compiler": {
+      "H": 65807000000000,
+      "N": "2^65807000000000",
+      "eta": {
+        "lower": "0.000000120357243671228711011443",
+        "upper": "0.000000120357243671228711011444"
+      },
+      "gap": "1/1400000000",
+      "integer_test_exponent": 47005,
+      "logarithm_power": 1024,
+      "theta": "63/64",
+      "uniform_saving": "10940329/3500000000",
+      "word_materialized": false
+    },
+    "full_forward_calls": 18,
+    "gain": "261/500000000",
+    "kappa": "781451/250000000",
+    "kappa_decimal": "0.003125804",
+    "margin_at_previous": {
+      "lower": "0.127894719171880023552284133066",
+      "upper": "0.127894719171880023552284133067"
+    },
+    "negative_controls": {
+      "old_BIT": "Rejected by outer inequalities",
+      "old_cutoff": "Rejected by completion-tail ratio greater than one",
+      "source_completion": "Rejected at cutoff17, floor18 and decay39/40",
+      "source_offset": "Rejected at cutoff16 with tail offset1/5"
+    },
+    "nonrecursive": {
+      "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+      "local_paid_rank_mass": 5952,
+      "local_routes": 5325000,
+      "local_scalar": 189428,
+      "peak_owned_fields": 13,
+      "raw_budget": 1000000000,
+      "raw_scalar_upper": 184647552,
+      "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word."
+    },
+    "ordinary_BIT": {
+      "admitted": "17/5000",
+      "after_cover": "69/20000",
+      "atom": "1/250",
+      "before_cover": "3459/1000000",
+      "ordinary_saving": "8590884599/2500000000000",
+      "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+    },
+    "outer": {
+      "functional_checks": {
+        "actual_new_BIT_stock_sublinear": "348599999253/350000000000",
+        "fixed_halo_explicit_metadata_branch": "26950000001/350000000",
+        "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000",
+        "new_semantic_group_guard": "3/1400000000"
+      },
+      "margins": {
+        "boundary_algebraic_matrix": "30632907178119357/9800000000000000000",
+        "fused_gaussian": "30632907134358071/9800000000000000000",
+        "global_coordinate_router": "2735081/875000000",
+        "group_bit_router": "3829114266794757/1225000000000000000",
+        "group_scans": "699999999/700000000",
+        "main_transform": "30632900178119357/9800000000000000000",
+        "microbox_face_corrections": "26950000001/350000000",
+        "polynomial_products": "1399999999/1400000000",
+        "sparse_union_movement": "4011882907178119357/9800000000000000000"
+      },
+      "parameters": {
+        "a": "2735081/875000000",
+        "b": "21880653/7000000000",
+        "beta": "1399999997/1400000000",
+        "bit_saving": "17/5000",
+        "cap_xi": "8911882900178119357/9800000000000000000",
+        "complex_uniform_saving": "10940329/3500000000",
+        "d": "1/1400000000",
+        "epsilon": "1399999999/1400000000",
+        "kappa": "781451/250000000",
+        "lambda_": "1993748387/2000000000",
+        "lambda_prime": "6978119357/7000000000",
+        "layout": "1/1400000000",
+        "q": "21880643/7000000000",
+        "r0": "1/14000000000",
+        "stop": "1/1400000000",
+        "tested_saving": "3125809/1000000000"
+      },
+      "strict_checks": {
+        "actual_bit_above_effective": "239919/875000000",
+        "actual_logarithmic_gamma_guard": "1/1400000000",
+        "actual_logarithmic_group_guard": "888117110321880643/4900000000000000000",
+        "alpha_logarithm_absorption": "1/14000000000",
+        "boundary_algebraic_matrix_above_kappa": "27978119357/9800000000000000000",
+        "cap_above_band": "4011882900178119357/9800000000000000000",
+        "cap_below_cell": "888117092821880643/9800000000000000000",
+        "cap_below_phase_cell_power": "10688117099821880643/9800000000000000000",
+        "complex_above_effective": "1/1400000000",
+        "complex_below_one_over_32": "196869347/7000000000",
+        "complex_endpoint": "1/700000000",
+        "epsilon_below_one": "1/1400000000",
+        "epsilon_positive": "1399999999/1400000000",
+        "fine_prime_halo_umbrella": "7/2",
+        "fused_gaussian_above_kappa": "27934358071/9800000000000000000",
+        "gaussian_above_main": "3478119357/4900000000000000000",
+        "global_coordinate_router_above_kappa": "1/350000000",
+        "global_gamma_power_slack": "9/14000000000",
+        "group_below_dimension": "1/700000000",
+        "group_bit_router_above_kappa": "4366794757/1225000000000000000",
+        "group_gauge_power_slack": "888117109971880643/4900000000000000000",
+        "group_key_fits_record": "1/700000000",
+        "group_positive": "1399999997/1400000000",
+        "group_scans_above_kappa": "3489059681/3500000000",
+        "halo_covers_generic_inverse_radius": "5",
+        "improvement_over_user_baseline": "697416790400418148631/500000000000000000000000",
+        "lambda_above_internal": "1/2800000000",
+        "lambda_above_sigma": "3/2800000000",
+        "lambda_above_tau": "1/2800000000",
+        "lambda_prime_above_lambda": "1/2800000000",
+        "lambda_prime_above_leaf": "13978119347/9800000000000000000",
+        "leaf_saving_above_effective": "6978119347/9800000000000000000",
+        "main_transform_above_kappa": "20978119357/9800000000000000000",
+        "membership_arithmetic_fits_record": "1/1400000000",
+        "microbox_face_corrections_above_kappa": "16843066231/218750000",
+        "microbox_halo_volume": "110600000003/1400000000",
+        "new_complex_uniform_saving_above_b": "1/1400000000",
+        "new_semantic_guard_with_C1_one": "1/1400000000",
+        "polynomial_products_above_kappa": "6978119367/7000000000",
+        "positive_layout_slack": "1/1400000000",
+        "q_below_effective": "1/1400000000",
+        "q_below_internal": "1/1400000000",
+        "q_below_leaf": "13978119347/9800000000000000000",
+        "q_positive": "21880643/7000000000",
+        "short_record_fallback": "6978119347/7000000000",
+        "source_axis_superpolynomial": "1/1400000000",
+        "sparse_union_movement_above_kappa": "3981250027978119357/9800000000000000000",
+        "stop_below_one": "1399999999/1400000000",
+        "stop_positive": "1/1400000000",
+        "strassen_integer_power_gap": "1951441519231",
+        "support_router_span": "3/1400000000",
+        "theta_positive_polynomial_power": "2",
+        "union_header_fits_record": "3/1400000000",
+        "union_tag_work_per_visit_fits_record": "3/1400000000"
+      }
+    },
+    "paid": {
+      "1": 41502,
+      "16": 416,
+      "2": 8226,
+      "24": 416,
+      "3": 8928,
+      "32": 416,
+      "4": 1800,
+      "40": 416,
+      "48": 416,
+      "5": 2934,
+      "56": 416,
+      "6": 198,
+      "64": 416,
+      "7": 108,
+      "72": 208,
+      "8": 18
+    },
+    "paid_calls": 66834,
+    "previous_pr5907": "1562641/500000000",
+    "productive_fields": 13444,
+    "query_shears": 15,
+    "rank_mass_surplus": 760,
+    "raw_ceiling": {
+      "derivative_upper": "-367807535420800867201733748003152468614163818931415672397258381/1569275433846670190958947355801916604025588861116008628224",
+      "interval": [
+        "0",
+        "17/5000"
+      ]
+    },
+    "raw_headroom": [
+      "755791/100000000000000",
+      "47237/6250000000000"
+    ],
+    "raw_root_interval": [
+      "312581155791/100000000000000",
+      "19536322237/6250000000000"
+    ],
+    "relative_gain_percent": "26100/1562641",
+    "strictification": {
+      "alpha": {
+        "lower": "0.999999997408080181764198797100",
+        "upper": "0.999999997408080181764198797101"
+      },
+      "cutoff": 16,
+      "delta": {
+        "lower": "0.950628642242169524414131100979",
+        "upper": "0.950628642242169524414131100980"
+      },
+      "floor": 17,
+      "gamma": {
+        "lower": "0.975562351047467297857948799346",
+        "upper": "0.975562351047467297857948799347"
+      },
+      "normalized_paid_upper": "1048576000976562501/1048576001073741824",
+      "power": 1024,
+      "reserve": "1/1000000000000",
+      "tail_block": 128,
+      "tail_decay": "125/128",
+      "tail_offset": "1/7",
+      "tested": "3125809/1000000000"
+    },
+    "targets": {
+      "1": 252,
+      "145": 208,
+      "17": 416,
+      "2": 144,
+      "25": 416,
+      "3": 72,
+      "33": 416,
+      "4": 1926,
+      "41": 416,
+      "49": 416,
+      "5": 252,
+      "57": 416,
+      "6": 36,
+      "65": 416,
+      "7": 162,
+      "73": 208,
+      "8": 342,
+      "9": 6930
+    },
+    "whole_idle_jobs": 3120
+  },
+  "controls": {
+    "damaged_base_word": "Exact source SHA256: research/p104-helper468-rung-removal/WORD.json.gz",
+    "damaged_source_LOCAL-EDITS.json": "Exact source SHA256: research/p104-unread-path-resynthesis/LOCAL-EDITS.json",
+    "damaged_source_NOTICE": "Exact source SHA256: research/p104-unread-path-resynthesis/NOTICE",
+    "damaged_source_PLAN.json": "Exact source SHA256: research/p104-unread-path-resynthesis/PLAN.json",
+    "extra_target_credit": "Every productive helper has a native target",
+    "missing_add1": "All public and owned rows",
+    "missing_add5": "All public and owned rows",
+    "missing_central_translation": "Rejected by the complete Laurent endpoint",
+    "unpaid_query": "Complete field and call counts",
+    "wrong_sign_add1": "All public and owned rows",
+    "wrong_sign_add5": "All public and owned rows"
+  },
+  "limits": [
+    "All five inherited framework assumptions remain.",
+    "The large uniform word and rounded multiplier are not materialized.",
+    "Author checks do not establish independent acceptance.",
+    "The selected frontier is unchanged."
+  ],
+  "local": {
+    "endpoint_coefficients": 638401,
+    "helpers": {
+      "1": 14,
+      "2": 8,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "6": 2,
+      "7": 9,
+      "8": 19,
+      "9": 385
+    },
+    "owned_fields": 29,
+    "owned_lifetimes": 31,
+    "paid": {
+      "1": 2219,
+      "2": 457,
+      "3": 496,
+      "4": 100,
+      "5": 163,
+      "6": 11,
+      "7": 6,
+      "8": 1
+    },
+    "paid_rank_mass": 5952,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 189428
+  },
+  "native": {
+    "distinct_maps": 2922,
+    "helper_normalizers": 1124,
+    "helpers": {
+      "1": 14,
+      "2": 8,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "6": 2,
+      "7": 9,
+      "8": 19,
+      "9": 385
+    },
+    "main_adapters": 208,
+    "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width",
+    "recipe_payload_sha256": "e22642923d5437c49e2d1dc79dd6b795503499d6f33615a1df3568f0b96164c1",
+    "wrong_phase_rejected": true
+  },
+  "paid_delta": {
+    "1": -2,
+    "2": 1,
+    "3": -2,
+    "4": 1,
+    "6": 1,
+    "7": -1,
+    "8": 1
+  },
+  "physical_caller": {
+    "central_square_columns": 53248,
+    "full_calls": 18,
+    "main_targets": {
+      "145": 208,
+      "17": 416,
+      "25": 416,
+      "33": 416,
+      "41": 416,
+      "49": 416,
+      "57": 416,
+      "65": 416,
+      "73": 208
+    },
+    "new_paid_jobs": 0,
+    "physical_contacts": 7488,
+    "ports": 104,
+    "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142",
+    "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.",
+    "whole_idle_jobs": {
+      "16": 416,
+      "24": 416,
+      "32": 416,
+      "40": 416,
+      "48": 416,
+      "56": 416,
+      "64": 416,
+      "72": 208
+    },
+    "wrapper_sites": [
+      1,
+      3,
+      5,
+      7,
+      9,
+      11,
+      13,
+      15,
+      17,
+      19,
+      21,
+      23,
+      25,
+      27,
+      29,
+      31
+    ]
+  },
+  "separate_columns": {
+    "arithmetic": "Dense integer rows with binary denominators; reverse chronology",
+    "coefficients": 638401,
+    "columns": 799
+  },
+  "source_local": {
+    "endpoint_coefficients": 638401,
+    "helpers": {
+      "1": 15,
+      "2": 7,
+      "3": 5,
+      "4": 107,
+      "5": 14,
+      "6": 1,
+      "7": 10,
+      "8": 18,
+      "9": 385
+    },
+    "owned_fields": 29,
+    "owned_lifetimes": 31,
+    "paid": {
+      "1": 2221,
+      "2": 456,
+      "3": 498,
+      "4": 99,
+      "5": 163,
+      "6": 10,
+      "7": 7
+    },
+    "paid_rank_mass": 5947,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 228664
+  },
+  "status": "PASS_P104_BASE5907_EDIT_KAPPA_312580400",
+  "target_delta": {
+    "1": -1,
+    "2": 1,
+    "3": -1,
+    "6": 1,
+    "7": -1,
+    "8": 1
+  }
+}
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/WORD.json.gz b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/WORD.json.gz
new file mode 100644
index 0000000000..22f9ab02d1
Binary files /dev/null and b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/WORD.json.gz differ
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/clifford_exact.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/clifford_exact.py
new file mode 100644
index 0000000000..166841a037
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/clifford_exact.py
@@ -0,0 +1,149 @@
+"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals.
+Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d.
+The tableau is supplemented by a literal circuit, so global phases are kept.
+"""
+from dataclasses import dataclass
+
+def parity(x):return x.bit_count()&1
+def rank(rows):
+ p={}
+ for x in rows:
+  while x:
+   b=x.bit_length()-1
+   if b not in p:p[b]=x;break
+   x^=p[b]
+ return len(p)
+def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<<j for j in range(n)) for i in range(n))
+def mv(rows,x):return sum(parity(r&x)<<i for i,r in enumerate(rows))
+def inv(rows,n):
+ a=[r|(1<<(n+i)) for i,r in enumerate(rows)]
+ for j in range(n):
+  k=next(i for i in range(j,n) if a[i]>>j&1);a[j],a[k]=a[k],a[j]
+  for i in range(n):
+   if i!=j and a[i]>>j&1:a[i]^=a[j]
+ assert [r&((1<<n)-1) for r in a]==[1<<i for i in range(n)]
+ return tuple(r>>n for r in a)
+def basis_extend(cols,n):
+ out=[]
+ for x in list(cols)+[1<<i for i in range(n)]:
+  if rank(out+[x])>len(out):out.append(x)
+ assert len(out)==n
+ return tuple(out)
+def nullspace(rows,n):
+ a=list(rows);p=[];k=0
+ for j in range(n):
+  t=next((i for i in range(k,len(a)) if a[i]>>j&1),None)
+  if t is None:continue
+  a[t],a[k]=a[k],a[t]
+  for i in range(len(a)):
+   if i!=k and a[i]>>j&1:a[i]^=a[k]
+  p.append(j);k+=1
+ return tuple((1<<j)|sum(((a[i]>>j)&1)<<v for i,v in enumerate(p)) for j in range(n) if j not in p)
+def pmul(a,b):
+ x,z,p=a;y,w,q=b
+ return x^y,z^w,(p+q+2*parity(z&y))%4
+def identity(n):return tuple([(1<<i,0,0) for i in range(n)]+[(0,1<<i,0) for i in range(n)])
+def apply(T,p):
+ n=len(T)//2;x,z,ph=p;out=(0,0,ph)
+ for i in range(n):
+  if x>>i&1:out=pmul(out,T[i])
+ for i in range(n):
+  if z>>i&1:out=pmul(out,T[n+i])
+ return out
+def compose(A,B):return tuple(apply(A,p) for p in B)
+def inverse(T):
+ n=len(T)//2;cols=[x|(z<<n) for x,z,p in T];rows=transpose(cols,2*n);cols_inv=transpose(inv(rows,2*n),2*n);out=[]
+ for j,w in enumerate(cols_inv):
+  x=w&((1<<n)-1);z=w>>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4))
+ return tuple(out)
+def qvalue(Q,alpha,x,n):
+ return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4
+def mul_i(a,p):
+ x,y=a;p%=4
+ return [(x,y),(-y,x),(-x,-y),(y,-x)][p]
+@dataclass
+class Op:
+ n:int
+ tab:tuple
+ circuit:list
+ def then(self,b):
+  assert self.n==b.n
+  return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit)
+ def adjoint(self):
+  circ=[]
+  for e in reversed(self.circuit):
+   if e[0]=='P':circ.append(('P',inv(e[1],self.n)))
+   elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2])))
+   elif e[0]=='C':circ.append(('C',e[1],-e[2]))
+   elif e[0]=='phase':circ.append(('phase',(-e[1])%4))
+   else:circ.append(e)
+  return Op(self.n,inverse(self.tab),circ)
+ def zero_state(self,basis=0):
+  N=1<<self.n;vec=[(0,0)]*N;vec[basis]=(1,0);den=0
+  for e in self.circuit:
+   if e[0]=='P':
+    v=[(0,0)]*N
+    for x,a in enumerate(vec):v[mv(e[1],x)]=a
+    vec=v
+   elif e[0]=='X':vec=[vec[x^e[1]] for x in range(N)]
+   elif e[0]=='D':vec=[mul_i(a,qvalue(e[1],e[2],x,self.n)) for x,a in enumerate(vec)]
+   elif e[0]=='phase':vec=[mul_i(a,e[1]) for a in vec]
+   elif e[0]=='C':
+    q,sgn=e[1:];v=[]
+    for x,(a,b) in enumerate(vec):
+     c,d=vec[x^q]
+     # C=(1+i)I/2+(1-i)X/2; inverse conjugates both coefficients.
+     v.append((a-sgn*b+c+sgn*d,b+sgn*a+d-sgn*c))
+    vec=v;den+=1
+   else:raise AssertionError(e)
+   while den and all((a&1)==(b&1)==0 for a,b in vec):vec=[(a//2,b//2) for a,b in vec];den-=1
+  return vec,den
+def ident(n):return Op(n,identity(n),[])
+def perm(n,G):
+ cols=transpose(G,n);gi=inv(G,n)
+ return Op(n,tuple([(a,0,0) for a in cols]+[(0,a,0) for a in gi]),[('P',tuple(G))])
+def diag(n,Q,alpha=None):
+ Q=tuple(Q);assert transpose(Q,n)==Q
+ alpha=tuple(alpha) if alpha is not None else tuple((Q[i]>>i)&1 for i in range(n))
+ assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n))
+ return Op(n,tuple([(1<<i,Q[i],alpha[i]) for i in range(n)]+[(0,1<<i,0) for i in range(n)]),[('D',Q,alpha)])
+def cgate(n,q,sgn=1):
+ return Op(n,tuple([(1<<i,0,0) for i in range(n)]+[(q if q>>i&1 else 0,1<<i,(3*sgn)%4 if q>>i&1 else 0) for i in range(n)]),[('C',q,sgn)])
+def xgate(n,b):return Op(n,tuple([(1<<i,0,0) for i in range(n)]+[(0,1<<i,2*((b>>i)&1)) for i in range(n)]),[('X',b)])
+def fourier(n,axes=None):
+ out=ident(n)
+ for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<<i))
+ return out
+def hadamard(n,axes):
+ axes=list(axes);Q=tuple(1<<i if i in axes else 0 for i in range(n));S=diag(n,Q)
+ return S.then(fourier(n,axes)).then(S)
+def canonical_frame(n,U):
+ r=len(U)
+ if r==0:return ident(n)
+ if r==n:return fourier(n)
+ G=transpose(basis_extend(U,n),n);gi=inv(G,n);Q=tuple((1<<i)^sum(parity(gi_i&gi_j)<<j for j,gi_j in enumerate(transpose(gi,n))) for i,gi_i in enumerate(transpose(gi,n)))
+ K=perm(n,G).then(diag(n,Q))
+ return K.adjoint().then(fourier(n,range(r))).then(K)
+def monomial(op):
+ n=op.n;T=op.tab;assert all(x==0 and p%2==0 for x,z,p in T[n:]);G=transpose([x for x,z,p in T[:n]],n);b=mv(G,sum((p//2)<<i for i,(x,z,p) in enumerate(T[n:])))
+ gt=transpose(G,n);cols=[mv(gt,z) for x,z,p in T[:n]];Q=transpose(cols,n);alpha=[(p-2*parity(b&z))%4 for x,z,p in T[:n]]
+ out=diag(n,Q,alpha).then(perm(n,G)).then(xgate(n,b));assert out.tab==T
+ vec,den=op.zero_state();assert den==0 and all(a==(0,0) for i,a in enumerate(vec) if i!=b);phase=[(1,0),(0,1),(-1,0),(0,-1)].index(vec[b]);out=out.then(Op(n,identity(n),[('phase',phase)]));assert out.zero_state()==op.zero_state()
+ return out,dict(matrix_rows=G,offset=b,quadratic_rows=Q,linear_Z4=alpha,phase=phase)
+def lower_child(op):
+ n=op.n;Bcols=[x for x,z,p in op.tab[n:]];r=rank(Bcols)
+ if not r:
+  mon,rec=monomial(op);return dict(rank=0,left=rec,right=None),mon
+ G=transpose(basis_extend(Bcols,n),n);A=inv(G,n);PA=perm(n,A);part=op.then(PA);Bcols=[x for x,z,p in part.tab[n:]];Dcols=[z for x,z,p in part.tab[n:]]
+ picks=[];selected=[]
+ for j,x in enumerate(Bcols):
+  if rank(selected+[x])>len(selected):picks.append(j);selected.append(x)
+ assert len(picks)==r and all(x>>r==0 for x in Bcols)
+ Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<<r)-1) for j in picks],r)
+ Qsmall=tuple(sum(parity(row&col)<<j for j,col in enumerate(transpose(Bi,r))) for row in Dr);Q=Qsmall+(0,)*(n-r);DQ=diag(n,Q)
+ V=part.then(DQ).then(hadamard(n,range(r)));assert all(x==0 for x,z,p in V.tab[n:]);Vmon,Vrec=monomial(V)
+ S=diag(n,tuple(1<<i if i<r else 0 for i in range(n)))
+ left=S.adjoint().then(DQ.adjoint()).then(PA.adjoint());right=Vmon.then(S.adjoint()).then(xgate(n,(1<<r)-1))
+ lmon,lrec=monomial(left);rmon,rrec=monomial(right);compiled=rmon.then(fourier(n,range(r))).then(lmon)
+ assert compiled.tab==op.tab and compiled.zero_state()==op.zero_state()
+ return dict(rank=r,left=lrec,right=rrec),compiled
diff --git a/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/native_verify.py b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/native_verify.py
new file mode 100644
index 0000000000..2c209dfa9c
--- /dev/null
+++ b/research/current-serial-monomial-leaf/vendor/monomial/vendor/selected/native_verify.py
@@ -0,0 +1,277 @@
+"""Check native operators with exact Gaussian dyadic arithmetic.
+
+The interpreter is adapted from the independent campaign native review.
+It does not import the source-code producer or the Clifford compiler.
+Research used OpenAI Codex under the user's direction.
+"""
+
+from functools import lru_cache
+
+
+def require(condition, label):
+    if not condition:
+        raise ValueError(label)
+
+
+def parity(value):
+    return value.bit_count() % 2
+
+
+def mul(matrix, vector):
+    return sum(parity(row & vector) << i for i, row in enumerate(matrix))
+
+
+def transpose(matrix):
+    return tuple(sum(((row >> j) & 1) << i for i, row in enumerate(matrix)) for j in range(len(matrix)))
+
+
+def inverse(matrix):
+    n = len(matrix)
+    rows = [row | (1 << (n+i)) for i, row in enumerate(matrix)]
+    for j in range(n):
+        pivot = next((i for i in range(j, n) if rows[i] >> j & 1), None)
+        require(pivot is not None, 'singular binary chart')
+        rows[j], rows[pivot] = rows[pivot], rows[j]
+        for i in range(n):
+            if i != j and rows[i] >> j & 1:
+                rows[i] ^= rows[j]
+    require([row & ((1 << n)-1) for row in rows] == [1 << i for i in range(n)], 'binary inverse')
+    return tuple(row >> n for row in rows)
+
+
+def extend(vectors, n):
+    columns, pivots = [], {}
+    for value in tuple(vectors) + tuple(1 << i for i in range(n)):
+        reduced = value
+        while reduced:
+            j = reduced.bit_length()-1
+            if j not in pivots:
+                pivots[j] = reduced
+                columns.append(value)
+                break
+            reduced ^= pivots[j]
+    require(len(columns) == n, 'frame basis extension')
+    return tuple(columns)
+
+
+def adjoint(circuit):
+    out = []
+    for gate in reversed(circuit):
+        if gate[0] == 'P':
+            out.append(('P', inverse(gate[1])))
+        elif gate[0] == 'D':
+            out.append(('D', gate[1], tuple(-a % 4 for a in gate[2])))
+        elif gate[0] == 'C':
+            out.append(('C', gate[1], -gate[2]))
+        elif gate[0] == 'phase':
+            out.append(('phase', -gate[1] % 4))
+        else:
+            require(gate[0] == 'X', 'adjoint gate type')
+            out.append(gate)
+    return tuple(out)
+
+
+def fourier(rank):
+    return tuple(('C', 1 << i, 1) for i in range(rank))
+
+
+def frame(vectors, n):
+    rank = len(vectors)
+    if rank == 0:
+        return ()
+    if rank == n:
+        return fourier(n)
+    matrix = transpose(extend(vectors, n))
+    columns = transpose(inverse(matrix))
+    quadratic = tuple((1 << i) ^ sum(parity(a & b) << j for j, b in enumerate(columns)) for i, a in enumerate(columns))
+    diagonal = tuple((row >> i) & 1 for i, row in enumerate(quadratic))
+    chart = (('P', matrix), ('D', quadratic, diagonal))
+    return adjoint(chart) + fourier(rank) + chart
+
+
+def monomial(record):
+    matrix = tuple(record['matrix_rows'])
+    quadratic = tuple(record['quadratic_rows'])
+    linear = tuple(record['linear_Z4'])
+    require(transpose(quadratic) == quadratic, 'quadratic symmetry')
+    require(len(matrix) == len(quadratic) == len(linear) == 9, 'monomial dimension')
+    require(all(a % 2 == (quadratic[i] >> i) & 1 for i, a in enumerate(linear)), 'diagonal parity')
+    inverse(matrix)
+    return (('D', quadratic, linear), ('P', matrix), ('X', record['offset']), ('phase', record['phase']))
+
+
+def recipe(record):
+    rank = record['rank']
+    require(isinstance(rank, int) and 0 <= rank <= 9, 'child rank')
+    if rank == 0:
+        require(record['right'] is None, 'rank zero right factor')
+        return monomial(record['left'])
+    return monomial(record['right']) + fourier(rank) + monomial(record['left'])
+
+
+def tableau(circuit, n=9):
+    rows = [(1 << i, 0, 0) for i in range(n)] + [(0, 1 << i, 0) for i in range(n)]
+    for gate in circuit:
+        tag = gate[0]
+        out = []
+        inverse_transpose = transpose(inverse(gate[1])) if tag == 'P' else None
+        for x, z, phase in rows:
+            if tag == 'P':
+                x, z = mul(gate[1], x), mul(inverse_transpose, z)
+            elif tag == 'X':
+                phase += 2 * parity(z & gate[1])
+            elif tag == 'C':
+                if parity(z & gate[1]):
+                    x ^= gate[1]
+                    phase += 3 * gate[2]
+            elif tag == 'D':
+                quadratic, linear = gate[1:]
+                phase += sum(linear[i] for i in range(n) if x >> i & 1)
+                phase += 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(n) if x >> i & 1)
+                z ^= mul(quadratic, x)
+            else:
+                require(tag == 'phase', 'tableau gate type')
+            out.append((x, z, phase % 4))
+        rows = out
+    return tuple(rows)
+
+
+@lru_cache(maxsize=512)
+def action(gate):
+    if gate[0] == 'P':
+        return tuple(mul(gate[1], x) for x in range(512))
+    require(gate[0] == 'D', 'state action type')
+    quadratic, linear = gate[1:]
+    return tuple((sum(linear[i] for i in range(9) if x >> i & 1)
+                  + 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(9) if x >> i & 1)) % 4 for x in range(512))
+
+
+def rotate(pair, power):
+    a, b = pair
+    return ((a, b), (-b, a), (-a, -b), (b, -a))[power % 4]
+
+
+def state(circuit, basis=0):
+    value, denominator = {basis: (1, 0)}, 0
+    for gate in circuit:
+        tag = gate[0]
+        result = {}
+        if tag == "C":
+            direction, sign = gate[1:]
+            for address, (a, b) in value.items():
+                for target, pair in ((address, (a - sign*b, b + sign*a)),
+                                     (address ^ direction, (a + sign*b, b - sign*a))):
+                    old = result.get(target, (0, 0))
+                    result[target] = (old[0] + pair[0], old[1] + pair[1])
+            denominator += 1
+        else:
+            for address, pair in value.items():
+                if tag == "P":
+                    target = mul(gate[1], address)
+                elif tag == "X":
+                    target = address ^ gate[1]
+                else:
+                    target = address
+                    if tag == "D":
+                        pair = rotate(pair, action(gate)[address])
+                    else:
+                        require(tag == "phase", "Unknown Gaussian state gate")
+                        pair = rotate(pair, gate[1])
+                require(target not in result, "A monomial address map is not injective")
+                result[target] = pair
+        value = {address: pair for address, pair in result.items() if pair != (0, 0)}
+    while denominator and all((a | b) % 2 == 0 for a, b in value.values()):
+        denominator -= 1
+        value = {address: (a//2, b//2) for address, (a, b) in value.items()}
+    return value, denominator
+
+
+def equal(actual, expected, label):
+    require(tableau(actual) == tableau(expected), label + ": signed Pauli action")
+    require(state(actual) == state(expected), label + ": exact global phase")
+
+
+def verify(data, certificate):
+    word = data["word"]
+    original, clean = data["programs"], data["clean_programs"]
+    source_recipes = data["recipes"]
+    residuals = data["residuals"]["recipes"]
+    native_tags = {"climb", "adapter", "residual_adapter"}
+    for orientation in ("forward", "backward"):
+        native = [event for event in clean[orientation] if event[0] in native_tags]
+        require(native == [event for event in original[orientation] if event[0] in native_tags],
+                "A retained native event changed")
+        require(len(native) == 5056, "The retained native event count changed")
+    frames = [frame(tuple(vectors), 9) for vectors in word["frames"]]
+    used = {(event[3], event[4]) for program in clean.values()
+            for event in program if event[0] == "climb"}
+    children = {(record["old"], record["new"]): record for record in source_recipes["children"]}
+    require(len(children) == len(source_recipes["children"]) and used <= set(children),
+            "The retained child recipe coverage is incomplete")
+    for old, new in sorted(used):
+        record = children[old, new]
+        require(record["rank"] == len(word["frames"][new]) - len(word["frames"][old]),
+                "A retained child has the wrong rank")
+        equal(recipe(record), adjoint(frames[old]) + frames[new], "Retained child")
+    endpoints = {(record["role"], record["port"]): record
+                 for record in source_recipes["endpoint_adapters"]}
+    require(len(endpoints) == len(source_recipes["endpoint_adapters"])
+            and set(endpoints) == {(role, p) for role in ("source", "target") for p in range(112)},
+            "The endpoint adapter coverage is incomplete")
+    for (role, port), record in endpoints.items():
+        direction = word["ports"][port]
+        conventional = (("C", direction, 1),) if role == "source" else (
+            ("C", direction, -1),) + fourier(9)
+        index = word["start"][port] if role == "source" else word["final"][112 + port]
+        require(record["frame"] == index and record["rank"] == 0, "An endpoint frame changed")
+        equal(recipe(record), adjoint(conventional) + frames[index], "Endpoint adapter")
+    used_residuals = set()
+    for program in clean.values():
+        for event in program:
+            if event[0] != "residual_adapter":
+                continue
+            _, position, register, entry, *tail = event
+            terminal = tail[0] if tail else 1
+            key = str(entry) if terminal == 1 else str(entry) + ":" + str(terminal)
+            require(key in residuals and position in ("pre", "post"), "A residual binding changed")
+            require(entry == word["start"][register] and terminal == word["final"][register],
+                    "A residual endpoint changed")
+            used_residuals.add(key)
+    for key in sorted(used_residuals):
+        record = residuals[key]
+        equal(recipe(record), adjoint(frames[record["frame"]]) + frames[record.get("terminal", 1)],
+              "Residual adapter")
+    records = certificate["input_recipes"]
+    ports = certificate["compensation_ports"]
+    require([record["port"] for record in records] == ports and len(records) == 8,
+            "The eight input recipes changed")
+    columns = 0
+    for item in records:
+        port, label = item["port"], item["label"]
+        require(label == word["ports"][port] and item["canonical_start_frame_id"] == word["start"][port],
+                "An input recipe has the wrong supplier label")
+        record = item["recipe"]
+        require(record["rank"] == 1, "An input copy has the wrong child rank")
+        for side in ("left", "right"):
+            factor = record[side]
+            require(factor["quadratic_rows"] == [0] * 9 and factor["linear_Z4"] == [0] * 9
+                    and factor["offset"] == factor["phase"] == 0,
+                    "An input factor is not an address permutation")
+        actual, expected = recipe(record), (("C", label, 1),)
+        equal(actual, expected, "Positive inherited input line")
+        for basis in range(512):
+            require(state(actual, basis) == state(expected, basis), "A complete input Gaussian column differs")
+            columns += 1
+        negative = monomial(record["right"]) + (("C", 1, -1),) + monomial(record["left"])
+        require(tableau(negative) != tableau(expected) or state(negative) != state(expected),
+                "An inverse input child was not detected")
+        phased = actual + (("phase", 1),)
+        require(tableau(phased) == tableau(actual) and state(phased) != state(expected),
+                "An input phase-only error was not detected")
+    return {"status": "PASS_EXACT_INPUT_NATIVE_FRAMES", "retained_native_events_per_orientation": 5056,
+            "retained_child_recipes": len(used), "endpoint_adapter_recipes": len(endpoints),
+            "residual_adapter_recipes": len(used_residuals), "new_input_recipes": len(records),
+            "new_exact_gaussian_columns": columns, "inverse_input_child_controls": len(records),
+            "phase_only_controls": len(records), "address_permutation_factors": 2 * len(records),
+            "method": "Independent signed Pauli and exact Gaussian interpretation; no compiler import",
+            "scope": "Positive inherited input frames before every retained adapter. No recursive hosting claim."}
diff --git a/research/current-serial-monomial-leaf/verify.py b/research/current-serial-monomial-leaf/verify.py
new file mode 100644
index 0000000000..c636243c69
--- /dev/null
+++ b/research/current-serial-monomial-leaf/verify.py
@@ -0,0 +1,44 @@
+"""Bounded replays with source and exact-result authentication.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from argparse import ArgumentParser
+from pathlib import Path
+import json
+import sys
+ROOT=Path(__file__).resolve().parent
+sys.path.insert(0,str(ROOT))
+from serial_sources import authenticate, need
+
+
+def stable(value):
+    if isinstance(value,dict):
+        return {k:stable(v) for k,v in value.items() if k!='elapsed_seconds'}
+    if isinstance(value,(list,tuple)):
+        return [stable(v) for v in value]
+    return value
+
+
+def main():
+    parser=ArgumentParser()
+    parser.add_argument('--suite',required=True,choices=('metadata','domain-history','descriptor','algebra','forward','inverse','phase-domain','history'))
+    args=parser.parse_args(); sources=authenticate()
+    suites={'metadata':('descriptor','algebra'),'domain-history':('phase-domain','history')}.get(args.suite,(args.suite,))
+    expected=json.loads((ROOT/'RESULT.json').read_text());results={}
+    for suite in suites:
+        if suite=='descriptor':
+            import check_descriptor
+            result=check_descriptor.run()
+        elif suite=='algebra':
+            import check_algebra
+            result=check_algebra.run()
+        else:
+            import check_numeric
+            result=check_numeric.run(suite)
+        need(stable(result)==expected[suite],'exact committed suite receipt')
+        results[suite]=stable(result)
+    print(json.dumps(dict(status='PASS_CURRENT_SERIAL_MONOMIAL_'+args.suite.upper(),
+                         authenticated_source_files=sources,result=results),sort_keys=True))
+
+
+if __name__=='__main__':main()