diff --git a/research/fine-expansion-page-admission/CHECKPOINT.md b/research/fine-expansion-page-admission/CHECKPOINT.md
new file mode 100644
index 0000000000..d125a99d37
--- /dev/null
+++ b/research/fine-expansion-page-admission/CHECKPOINT.md
@@ -0,0 +1,74 @@
+# Recoverable wave 9 checkpoint
+
+Worker: analytic_join. Track 50/75, approved narrow source-admission pivot.
+Canonical parent: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+Worktree: `/workspace/scratch/a365d332d434/worker-analytic-wave9`.
+Branch: `research/fine-expansion-page-admission-20261109`.
+Package: `research/fine-expansion-page-admission`.
+
+## Completed findings
+
+The source-relative proof admits the actual full-period explicit expansion
+page producer for its stated finite source/precision domain. It proves the
+original-coordinate halo and all multiplicities, coefficient positivity,
+near-unit upper-endpoint acceptance and header/precision guards. It spends
+the existing forward normalizer K_f with final J=K_f-D, reaches the public
+middle's half-disk from actual quarter-disk ingress, and gives the explicit
+component-l1 prefix allowance (12*2^-J+2)2^-q. Gaussian Gamma is unchanged;
+both S factors and outer recovery remain separate.
+
+The declared direct schedule retains all costs. Mandatory per-axis Tile
+writes are Omega(DTq), and the specified full-axis FieldMove route costs
+Omega(Tq log T). This is an admitted slow reference for future grouped-map
+comparison, not a fast production prefix or a general lower bound.
+
+The dimension-changing return adapter is implemented and runs the real
+native words and public codec. It borrows/copies an encoded T Count and
+pays the T-record clock, dummy native input, protected return and cleanup.
+Its prepared q/J format boundary is explicit. No complete expansion
+controller, Tile, coefficient producer or production Fourier was executed.
+
+## Executed verification
+
+- Metadata/source pins: `PASS_PACKAGE_METADATA_AND_PINS`.
+- Registered normal and optimized replay: both
+  `PASS_FINE_EXPANSION_PAGE_ADMISSION`; identical mathematical/native
+  receipts; complete registered run 7.865 seconds on Python 3.12.14.
+- Thirty canonical files, six exact public files, 22 source clauses and
+  21 altered-clause controls authenticated.
+- Exact independent finite evidence: 4,320 headers, 7,557 blocks, 68,013
+  quadratic identities, 288,036 residue multiplicities, 16 positive-lower
+  countermodels, 16 near-unit countermodels, 768 reciprocal/unit cases,
+  240 budgets, four axis layouts and 26 stage invoices.
+- Real native T16/S9 q12/J3 output matches the independent oracle, with
+  maximum component-l1 projection error 3/8192. Protected return, short/
+  long fields, old S record clock, native/count/work aliases, borrowed
+  origins, cleanup and real coarse-grid erasure controls pass.
+
+The first native attempt correctly failed because the fixture tried to
+initialize the marker already owned by a freshly constructed Tape. The
+fixture now erases that marker before initializing; all inherited guards
+and sources are unchanged. `evidence/attempt-1.json` preserves the failure.
+The first successful adapter receipt in `evidence/normal.json` predates
+the final sixth retained public proof; the final source-bound passes are
+in `evidence/registered.json` and `evidence/REPLAY.json`.
+
+## Reproduction and next action
+
+```sh
+python3 -B scripts/research_package.py --package research/fine-expansion-page-admission
+python3 -B scripts/check_research_commit.py --package research/fine-expansion-page-admission --check-modes
+```
+
+After the staged-tree/mode gate, freeze the commit and tree for lead source
+review and publication. The lead owns remote actions; this worker creates
+no upstream PR or external post. The tested base is preserved. Exact source
+dependency commits and hashes are in `SOURCES.json`/`DEPENDENCIES.json`.
+Any final commit identifier is supplied by the containing Git commit and
+the lead's durable recovery manifest, avoiding self-referential file hashes.
+
+Outstanding: independently admitted grouped Broad source/physical cost,
+production scalar/Fourier/native contracts, the opposite transform and
+complete CRT/integer recovery. No selected certificate, full bound or
+foundational assumption is changed. The temporary local worktree is not
+durable by itself; only the lead's verified remote branch will be durable.
diff --git a/research/fine-expansion-page-admission/CLAUSES.json b/research/fine-expansion-page-admission/CLAUSES.json
new file mode 100644
index 0000000000..3ae1ad3092
--- /dev/null
+++ b/research/fine-expansion-page-admission/CLAUSES.json
@@ -0,0 +1,178 @@
+{
+  "schema_version": 1,
+  "scope": "AST source binding only; no projected execution or formal semantic acceptance.",
+  "clauses": [
+    {
+      "path": "research/physical-gaussian-expansion/expansion_geometry.py",
+      "names": [
+        "ProductionBlock",
+        "__init__"
+      ],
+      "sha256": "bc060d1d52efb44004016b7a5390552f9057f492d38304857e50f54f085523d2"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_geometry.py",
+      "names": [
+        "BlockGeometry",
+        "__init__"
+      ],
+      "sha256": "1ea95794efa09125cc12bff37d617ee0590ec7dd718da227a33ca93694e7e9ff"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_geometry.py",
+      "names": [
+        "BlockGeometry",
+        "prepare_quadratics"
+      ],
+      "sha256": "ec7f9e782818eb1dabee90e87a278a778529f696e655bb7e11e236d81e8a4225"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_geometry.py",
+      "names": [
+        "BlockGeometry",
+        "exponent"
+      ],
+      "sha256": "05877b418f6bcfc482d0f8864679cebf4573f0891653293478009e99612443f7"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_records.py",
+      "names": [
+        "compile_frame"
+      ],
+      "sha256": "55bd55077a8e80dac157c347d897ea1e87d7b390ab65e209916f78515de33536"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_geometry.py",
+      "names": [
+        "stencil_bounds"
+      ],
+      "sha256": "6d658a8850f036dbb54ebb48c3838154a9a2f153b156931804aee3bb76cfa284"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_geometry.py",
+      "names": [
+        "compile_tile"
+      ],
+      "sha256": "345fb7d48359c49c9812bea144195987a8f8eb37bd87158a1608237948b3ca4b"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_geometry.py",
+      "names": [
+        "TileGeometry",
+        "__init__"
+      ],
+      "sha256": "81984c23f7c8b129f5a16d7922b153c469311bab5e672a0132ece0222cee4566"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_geometry.py",
+      "names": [
+        "ProductionTile",
+        "__init__"
+      ],
+      "sha256": "36202b5dd3e2519ace31daa4d8476f94140be9f586c058cb66eb4db392f1cb82"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_prepare.py",
+      "names": [
+        "prepare_page"
+      ],
+      "sha256": "85d5305cbab581630de99fe35b7dcb5a2d180aa05c266136f012f0b4e9836a44"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_prepare.py",
+      "names": [
+        "TilePreparation",
+        "run_explicit"
+      ],
+      "sha256": "5650bb2cf73c7599eb2145a60f2f9fa1fac165d414d1e3bc371f17f8bfa416f6"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_prepare.py",
+      "names": [
+        "TilePreparation",
+        "run_production"
+      ],
+      "sha256": "4c0633aedfe97e444882d862edc06684e54a2f2a8c42e0b363a9f9d5994280cf"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile.py",
+      "names": [
+        "Tile",
+        "run"
+      ],
+      "sha256": "8f467f2d3bc7a1eb5be0ccd09a0dfd41dfadb9eb893ebd5b99da160095c890c5"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_block.py",
+      "names": [
+        "Block",
+        "scalar"
+      ],
+      "sha256": "20eec59f19402fa84ce02b4d8881e0a619c57f8ea4b7b844f22860a39297afef"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_block.py",
+      "names": [
+        "Block",
+        "run"
+      ],
+      "sha256": "ef6d60b4132c152b40cd9fc71592d1fc596da335fcbf082866606f200dfd536a"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_exponentials.py",
+      "names": [
+        "Exponentials",
+        "positive_interval"
+      ],
+      "sha256": "fd81d34e25b14fc62ff416d578cfbe916eadc96f292a80fae33c5c7646cfef13"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_exponentials.py",
+      "names": [
+        "Exponentials",
+        "grid_interval"
+      ],
+      "sha256": "2ecc3f807dc07dc2f7394cd87a35ecfffed11ae57af47965959108f1dd8a81d6"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_moves.py",
+      "names": [
+        "FieldMove",
+        "run"
+      ],
+      "sha256": "c05401dfbfe30d7c5d9798bdf9d88c611f48330a0b16092142f031025d873601"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_moves.py",
+      "names": [
+        "FieldMove",
+        "stage"
+      ],
+      "sha256": "4f8e859cd7c86f3660e8441af1e5b9aab47102e762a905572f4b8f45b5d6d6e3"
+    },
+    {
+      "path": "research/physical-tensor-crt-sandwich-recovery/sandwich.py",
+      "names": [
+        "Sandwich",
+        "ingress"
+      ],
+      "sha256": "032f585adc3c96ba803a7995a6aaac32670700c1c37ad8d411066ee2c9dc8841"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/boundary_codec.py",
+      "names": [
+        "Codec",
+        "prepare_return"
+      ],
+      "sha256": "f19cc2b50aa92efbf0179f5d547078e1ebfd55cf8ce650d03dc4382e793bdb22"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/boundary_codec.py",
+      "names": [
+        "Codec",
+        "return_component"
+      ],
+      "sha256": "7ead0c8ad320b7782c0fc351242b19490811d4e3003c15b60f02fdac6acfb1d4"
+    }
+  ]
+}
diff --git a/research/fine-expansion-page-admission/DEPENDENCIES.json b/research/fine-expansion-page-admission/DEPENDENCIES.json
new file mode 100644
index 0000000000..a935ea98c4
--- /dev/null
+++ b/research/fine-expansion-page-admission/DEPENDENCIES.json
@@ -0,0 +1,53 @@
+{
+  "schema_version": 1,
+  "files": [
+    {
+      "path": "research/fine-expansion-page-admission/retained/middle-PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "8db3cc1e98ba295cec4d752478431515e159c34f",
+      "source_path": "research/cached-chirp-cyclic-join/PROOF.md",
+      "git_blob": "2f434e4b55550032656d95b558563c9f5c3df839",
+      "sha256": "1119909d64ed3af1637e039ea1c60ff5457ec987828c8f2a137a93a07155cc6d"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/ledger-PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "76a84e1c4bfa4035e5ee85410dbfc4541f0da168",
+      "source_path": "research/core-group-scale-ledger/PROOF.md",
+      "git_blob": "3e580dee35c9b597d9b66932282fefa4ef92306a",
+      "sha256": "59ee004f3d69e70abf8a7fd82f99312b31d4ad32fed3d6866d61e197177599a4"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/caller-PROOF.md",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "96211247643059ae48af4c7d9dc960034798935d",
+      "source_path": "research/fine-recovery-catalogue-obstruction/PROOF.md",
+      "git_blob": "08a808b09c4a888d27f468f236ba6ca1d7881ac4",
+      "sha256": "0dde51f56eee2c711afa3b5c1e4f783ad0b057b7c206aa931b260c407236dfdd"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/boundary_codec.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "73d5adaba2b7dc662e86eb901e81369a3f73be9f",
+      "source_path": "research/core-halo-source-bridge/boundary_codec.py",
+      "git_blob": "5fdbd993cc4d9087e509fec2d9fb6e34912fa232",
+      "sha256": "e28149c32d9a53fbbe9b93c67bc0b85f1587747f74fa0452b6ff26618972eace"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/halo_tapes.py",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "73d5adaba2b7dc662e86eb901e81369a3f73be9f",
+      "source_path": "research/core-halo-source-bridge/retained/halo/sparse-halo-tape-transaction/tapes.py",
+      "git_blob": "b3dfa43ba0d08c6393731ac3cd2857a92e4c8aa2",
+      "sha256": "80b246fafae0adf53af7561e1be59f4374e6294d66bb7a12ef9524b9ef4f2a78"
+    },
+    {
+      "path": "research/fine-expansion-page-admission/retained/reference-PROOF.md",
+      "git_blob": "cabc570bb170b8cf17a34ca457b7ffa6adb17c07",
+      "sha256": "24ce857bfef43e8e104110bde5c3a702a13f6b0f021f3b2bf3e85d6c026e89b3",
+      "repository": "CubeJerry/integer-mult-bounds",
+      "commit": "4509310a9a58d4c41c74029f899cbf36be1af9a1",
+      "source_path": "research/reference-ideal-compression-join/PROOF.md"
+    }
+  ]
+}
diff --git a/research/fine-expansion-page-admission/NOTICE.md b/research/fine-expansion-page-admission/NOTICE.md
new file mode 100644
index 0000000000..86caf2993d
--- /dev/null
+++ b/research/fine-expansion-page-admission/NOTICE.md
@@ -0,0 +1,38 @@
+# Credit, license and evidence status
+
+Prepared for **@CubeJerry** with substantial OpenAI assistance in source
+audit, mathematical proof, exact independent checks, code and packaging.
+Same-team lead review is recorded separately. No independent human or
+formal proof-kernel acceptance is claimed. The repository Apache-2.0
+license applies; all retained original notices remain unchanged.
+
+- Jose Manuel (@jmbarrancoml), CrocSwap/integer-mult-bounds#3878, supplies
+  the actual explicit expansion producer, Tile and original-coordinate
+  geometry. His #3851/#3935 and their nested native/ring/Gaussian sources
+  supply the unchanged cohort, encoded words and field movement.
+- JoyboyBrian, CrocSwap/integer-mult-bounds#5056, proves the actual signed
+  internal contraction; #6085 proves the encoded coefficient enclosure.
+  Those universal results and the nested Machin/interval work are retained
+  premises and are not claimed as new here.
+- Hiroki KUMAZAKI (@kumagi), CrocSwap/integer-mult-bounds#5295, supplies the
+  actual five-residual accuracy and axis telescope. Ali Romman (@aliromman),
+  CrocSwap/integer-mult-bounds#5325, supplies the different old Tensor error
+  composition and remains credited in the overlap boundary.
+- The above original packages retain Hanson Sun, Artus Krohn-Grimberghe,
+  Chafik Boukhalfa, Mason Hale, Dugongue, Vlado, RaD/hipotures, the inherited
+  FFT/Karatsuba/q-calculus authors, Harvey–van der Hoeven, the OpenAI
+  manuscript contributors and Douglas Colkitt, together with their nested
+  archive and license notices. Their complete canonical bytes are unchanged.
+- The public @CubeJerry packages at 73d5adaba2b7dc662e86eb901e81369a3f73be9f,
+  76a84e1c4bfa4035e5ee85410dbfc4541f0da168,
+  4509310a9a58d4c41c74029f899cbf36be1af9a1,
+  96211247643059ae48af4c7d9dc960034798935d and
+  8db3cc1e98ba295cec4d752478431515e159c34f supply the exact public codec,
+  normalizer, Reference, caller and middle boundaries. Their retained files
+  are byte-exact and pinned in `DEPENDENCIES.json`.
+
+The new checker uses independently written exact integer/Fraction reasoning
+for headers, halos, exponent identities, normalization and route counts.
+It imports no predecessor numerical checker. The native witness executes
+only the real dimension-changing return adapter under the original loader,
+not coefficient production, complete expansion or production Fourier.
diff --git a/research/fine-expansion-page-admission/OVERLAP.md b/research/fine-expansion-page-admission/OVERLAP.md
new file mode 100644
index 0000000000..7c6c0ae9e9
--- /dev/null
+++ b/research/fine-expansion-page-admission/OVERLAP.md
@@ -0,0 +1,27 @@
+# Bounded overlap audit and scoped novelty
+
+Canonical base: 7c49fe32c55de02c2c873655c804b16e4c3fef0a. The lead refreshed
+canonical main and live PRs at the wave transition. This is a bounded exact
+source/PR audit, not an exhaustive absence-of-overlap claim.
+
+| Predecessor and exact head | Already established | Distinct boundary here |
+| --- | --- | --- |
+| #3878, 1a86a8fb73bb7a0982fff99852a031832c191902 | Actual explicit Tile, block geometry, coefficient factorization and local expansion, including fine theta | Complete original-period explicit-page/header and coefficient-acceptance admission; no claim to new local expansion |
+| #5056, fe624453057b7f0cb42870a594d314a148b9fb84 | Actual signed-stage inward norm and original-coordinate axis recurrence | Reused to establish the reached middle radius for the newly admitted full-period source |
+| #5295, 351975ee703ec5aa1b18f70f73700d434026199a | Five-residual local accuracy and actual-input telescope; matching producer/page admission left open | Bind all actual producer arguments and positivity/unit checks; spend the fine-family forward normalizer |
+| #6085, 9fc80f1db55d4939c7b53c0799e6840cce35fbf8 | Uniform encoded scalar enclosure and narrow-Axis argument admission | Reuse scalar theorem; independently bind expansion A/K/B families and the preparer's extra strict positivity/upper-unit checks |
+| #5325, bea42af24ee9850949a4b48d329a7dc85de72b11 | Old Tensor restored error telescope and normalization | Different fine-family Gaussian K_f/K_c policy and changing-volume common-grid return; no generic telescope novelty |
+| #3851, 7ab67b4a84d28cd562b9711aa315ca5b47822b37; #3935, f687fa171ef760fa98a4be1289717b47dd4ee0b3 | Physical Gaussian cohort and old paired production Tensor | Exact explicit expansion API only; none of the old paired guards is waived |
+| Public caller audit 96211247643059ae48af4c7d9dc960034798935d | Old catalogue cannot admit the fine family; complete integer recovery includes both S factors | Source-specific explicit-page replacement admission, not rehabilitation of the rejected old caller |
+| Public middle 8db3cc1e98ba295cec4d752478431515e159c34f | Actual cached/Cyclic/common-grid interface conditional on a half-disk supplied input | Supply a numerically admitted slow-reference prefix and pay its enlarged return; retain the middle's backend premises |
+| Public ledger 76a84e1c4bfa4035e5ee85410dbfc4541f0da168 and Reference join 4509310a9a58d4c41c74029f899cbf36be1af9a1 | Compression normalizer policy and exact H/N comparison | Preserve their existing K_c and the exact normalized compression term, without new restoration |
+| Concurrent broad Core work in another active session | Separate grouped source/implementation responsibility | Excluded; no edit, duplicate implementation or claim of its execution |
+
+The originally broad prefix question would repeat known generic error and
+norm proofs. The single approved pivot is the source-specific producer/page
+admission plus the preserved forward-normalizer and enlarged-return seam.
+The complete direct cost is checked before claiming usefulness: it fails
+the target fast bound. Its literal output/routing invoice is a scoped
+limitation, not a general Gaussian or multiplication lower bound. The
+admitted exact reference is useful for independently testing a future
+grouped source map; that future implementation needs its own proof.
diff --git a/research/fine-expansion-page-admission/PR-BODY.md b/research/fine-expansion-page-admission/PR-BODY.md
new file mode 100644
index 0000000000..c1cb17a692
--- /dev/null
+++ b/research/fine-expansion-page-admission/PR-BODY.md
@@ -0,0 +1,94 @@
+## Problem and exact result
+
+The fine-family compression ledger and cached middle still need an actual
+expansion source. The old paired production Tensor catalogue cannot admit
+that family. Existing local expansion and error theorems do not by themselves
+prove that the exact explicit coefficient/page producer accepts a complete
+original period, or that its enlarged T-record return matches the common
+codec's record clock.
+
+This source-bound enabling/audit package proves that admission for the
+unchanged explicit Tile API: q>=101, integer alpha>=2 with alpha²<q,
+0<s<t<2s and metadata fitting q bits, full target [0,t), original periodic
+halo [-b-1,s+b+2), b=alpha ceil(sqrt(q)), P=32768q and sigma=4096q.
+It binds every actual A/K/B argument to the encoded scalar enclosure and
+proves the extra strict positivity and upper-unit acceptance checks. The
+kernel's near-unit case uses its actual reciprocal lower>=unit invariant,
+not an invalid inference from interval containment alone.
+
+For the already declared forward K_f>=D, exactly J=K_f-D final shift bits
+spend the Tile sequence's built-in D bits. The admitted slow-reference
+prefix reaches the middle's half-disk from quarter-disk ingress and has
+maximum-coordinate component-l1 error below
+
+```text
+(12*2^-J+2)*2^-q <= 14*2^-q.
+```
+
+Its restored contribution is funded by q>=Gamma+tau_exp+5 when the exact
+normalized compression contracts. Gamma=K_f+K_c remains the existing
+Gaussian dyadic restoration; both S factors and other outer recovery scales
+are separate. A real native return adapter pays a new T-record clock and
+the final codec shift, with borrowed encoded T and explicit q/J templates.
+
+## Novelty and predecessor credit
+
+CrocSwap/integer-mult-bounds#3878 already covers fine theta, #5056 proves
+actual inward norm, #5295 proves the five-residual error telescope, and
+#6085 proves the encoded scalar enclosure. These are credited premises;
+the new implication is the complete expansion producer/page admission and
+its preserved-normalizer/changing-volume boundary. #5325 covers a different
+old Tensor normalization. #3851/#3935 provide the unchanged native cohort
+and source, and their old production guards remain untouched.
+
+The exact public dependencies are the @CubeJerry middle
+8db3cc1e98ba295cec4d752478431515e159c34f, ledger
+76a84e1c4bfa4035e5ee85410dbfc4541f0da168, Reference join
+4509310a9a58d4c41c74029f899cbf36be1af9a1, caller audit
+96211247643059ae48af4c7d9dc960034798935d and codec
+73d5adaba2b7dc662e86eb901e81369a3f73be9f. `DEPENDENCIES.json`
+binds their retained files; `SOURCES.json` pins 30 live canonical inputs
+at main 7c49fe32c55de02c2c873655c804b16e4c3fef0a.
+
+## Complete cost and limits
+
+This is a declared slow reference, not a fast Broad controller. Its full
+online bill is O(Tq(log T+D log²(q+2))+TJ), plus charged source preparation,
+headers, page reuse and retained historical backing. Mandatory Tile writes
+cost Omega(DTq), and the specified whole-axis FieldMove route costs
+Omega(Tq log T) under T/S<2. These literal bounds delimit this exact port;
+they are not general Gaussian lower bounds. A future grouped implementation
+may reuse its certified original-coordinate target but must prove its own
+source, radius, routing, normalizer and complete physical cost.
+
+No old catalogue guard is waived. There is no broad Core implementation,
+complete prefix physical replay, production GL64/O73 execution, full Fourier
+or integer-recovery theorem. The remaining native/scalar/Fourier and
+analytic-source obligations are explicit. **No new kappa; the selected
+conditional frontier and all five foundational assumptions are unchanged.**
+
+## Reproduction and checks
+
+```sh
+python3 -B scripts/research_package.py --package research/fine-expansion-page-admission
+python3 -B scripts/check_research_commit.py --package research/fine-expansion-page-admission --check-modes
+```
+
+Normal and optimized commands authenticate complete sources and 22 source
+clauses, then run independently derived integer/Fraction controls across
+4,320 headers, 7,557 blocks, 68,013 quadratic identities, 288,036 halo
+multiplicities, 768 reciprocal-unit cases and 240 normalization budgets.
+The actual T16/S9 q12/J3 native-word/public-codec output agrees exactly with
+the independent signed truncation oracle, with component error 3/8192.
+Short/long returns, the old S clock, borrowed metadata/work aliases,
+pending returns, wrong normalizers, lost periodic multiplicity and invalid
+near-unit reasoning are rejected or distinguished. The finite native
+witness runs only this output seam. Its single corrected initial marker
+setup failure is retained in the checkpoint; inherited guards were unchanged.
+
+Prepared for **@CubeJerry** with substantial OpenAI assistance. Credit Jose
+Manuel/@jmbarrancoml, JoyboyBrian, Hiroki KUMAZAKI/@kumagi, Ali Romman/
+@aliromman and all retained source/archive authors in `NOTICE.md`.
+Independent algorithmic checks and same-team lead review do not assert
+independent human or proof-kernel acceptance. Exact evidence, proof,
+open next questions and restart trail are in the package.
diff --git a/research/fine-expansion-page-admission/PR-TITLE.txt b/research/fine-expansion-page-admission/PR-TITLE.txt
new file mode 100644
index 0000000000..ce0063cfa2
--- /dev/null
+++ b/research/fine-expansion-page-admission/PR-TITLE.txt
@@ -0,0 +1 @@
+Admit fine-family expansion pages and delimit the direct prefix port
diff --git a/research/fine-expansion-page-admission/PROOF.md b/research/fine-expansion-page-admission/PROOF.md
new file mode 100644
index 0000000000..b97c6931da
--- /dev/null
+++ b/research/fine-expansion-page-admission/PROOF.md
@@ -0,0 +1,376 @@
+# Admit full-period fine-family expansion pages, and delimit their direct port
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+Source-bound enabling/adversarial result; no new kappa. Canonical main:
+`7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+
+## 1. What is new, and what is inherited
+
+The actual canonical expansion is #3878's `Tile`, `TilePreparation`,
+`BlockGeometry` and `ProductionBlock`. Its explicit page API is distinct
+from `ProductionTile`, which imports the old paired compression
+`ProductionPlan`. The latter's admission is incompatible with the fine
+family, as the public caller audit at 96211247643059ae48af4c7d9dc960034798935d
+proves. We change or bypass none of its guards and claim no old Tensor run.
+
+#3878 already proves local expansion at every ratio 1<t/s<2, explicitly
+including alpha^2*(t/s-1)<1. #5056 proves its actual inward norm invariant;
+#5295 derives the actual five-residual accuracy telescope; #6085 proves the
+encoded scalar exponential enclosures. Those results are reused, not new
+norm, tail, rounding or transcendental theorems here. #5325 joins a different
+old Tensor normalization and does not install a fine-family production policy.
+
+The new source interface is a complete explicit full-period page admission,
+with the original periodic halo and its multiplicities, and a declared
+normalization/output conversion to the public fine-family middle at
+8db3cc1e98ba295cec4d752478431515e159c34f. The existing forward normalization
+pays the Tile's built-in one bit per axis. The changing source/target volume
+cannot use the old input as the public codec's return clock. We give a paid
+T-record adapter and a real native-word/codec witness for that exact seam.
+
+This is an admitted **slow reference**, conditional on the credited exact
+word/convolution and source arithmetic contracts. The explicit sequential
+route below cannot meet the desired positive-kappa caller. Its literal
+writes establish that limitation; generic per-axis costs are not claimed
+as a new general lower-bound theorem. No broad Core is implemented.
+
+## 2. Source-first full-period page certificate
+
+Fix integer q>=101, integer alpha>=2 with u=alpha^2<q, and positive
+integers s<t<2s. Require s,t,alpha<2^q, the literal `fits` metadata clauses.
+Here q is the working component grid, while p0 below is the original
+fine-family parameter. They are not silently identified. Define
+
+    b=alpha*ceil(sqrt(q)), P=32768q, sigma=4096q,
+    source_start=-b-1, source_count=input_capacity=s+2b+3,
+    target_start=0, target_length=t, blocks=ceil(t/b).       (1)
+
+These are inputs to the unchanged `TilePreparation.run_explicit`. Every
+nonfinal block has m=b; the final block has 1<=m<=b. This instantiates the
+public explicit API with a proved replacement source contract, rather than
+changing `ProductionTile` or asserting its paired inverse guards.
+
+The literal `compile_tile` inequalities all hold. Since q>=101,
+ceil(sqrt(q))<sqrt(q)+1 and alpha<sqrt(q),
+
+    b<q+sqrt(q)<=11q/10,
+    3b+3<4q, 4b+2<5q.                                    (2)
+
+The strict first square-root estimate remains valid when q is a square.
+Each Block has n<=2b+m+3<=3b+3 and nc=n+m-1<=4b+2. For q>=101,
+ceil(log2(32(3b+4)))+12<=q+21, whereas
+P-2sigma-q=24575q. Thus every actual Block/Tile work-precision guard holds.
+All header fields requiring positivity are positive, the version is 2,
+source_count equals capacity, and the target origin is zero. Every later
+block origin is below t and fits its q+2-bit origin clause.
+
+For a block starting at v with length m, the exact source endpoints are
+
+    a(v)=floor(sv/t)-b-1,
+    c(v,m)=ceil(s(v+m-1)/t)+b+2.                           (3)
+
+This follows from the actual j0, gamma and h_high formulas, with
+`gamma=floor(sv/t)-sv/t`; in particular the upper endpoint uses a ceiling.
+For the full period, ceil(s(t-1)/t)=s because 0<s/t<1. Hence the union
+starts at -b-1 and ends at s+b+2, proving containment in (1).
+Endpoints are nondecreasing and consecutive windows overlap: with
+x=s(v+m-1)/t and 0<s/t<1, floor(x+s/t)<=ceil(x), leaving at least the
+stated b margins. These are exactly the monotone stream conditions used
+by `Tile.run`, including the clipped final block.
+
+Supply at halo position j the original source value x_(j mod s), for every
+integer j in [-b-1,s+b+2). Repeated residues are repeated *occurrences*,
+not a set of distinct source indices. The theorem does not require b<s.
+When b>=s, some residues appear many times; replacing this stream by one
+copy per residue changes the Gaussian sum. A target lift by c*t uses the
+source lift by c*s and leaves the residue stream and exact output unchanged.
+The optional capacity beyond source_count must be literal zero padding;
+(1) needs no such padding. Borrowed original source values are preserved.
+
+## 3. Bind the actual coefficient producer, not an arbitrary page
+
+`prepare_page` forms the actual rational A/K/B exponent families in original
+coordinates, measures the maximum ceiling of their absolute values, and
+passes that positive bound to the unchanged encoded `Exponentials` owner.
+The source quadratic identity is
+
+    U_h+V_z+K_(h-z)=(j0+h-(s/t)(v+z))^2/u.                (4)
+
+#3878's bounds, applicable under (1)-(2), give |U|<20q, |V|<3q and K<12q.
+The factor scales are exactly sigma for A and B and zero for K. Thus the
+actual arguments satisfy the all-rational sign/scale domain proved by #6085,
+without importing that audit's separate narrow-Axis geometry. The lower
+endpoints are nonnegative, no larger than the true factors, and have error
+<3*2^-P/2, which is stronger than #5295's required 4*2^-P allowance.
+
+The actual exact-unit and reflected-kernel branches preserve the same
+factors. Crucially, a true factor <=1 alone would not prove the preparer's
+*upper-endpoint* unit check. The actual production allocation supplies the
+missing admission implication. Here K_d is the exponent in (4), and k_d=exp(-pi K_d) is its kernel
+factor. Using pi<4 and e<4 in the quadratic bounds,
+
+    2^(-4256q)<A_h,B_z<2^(-3936q),
+    2^(-96q)<k_d<=1.                                    (5a)
+
+The coefficient audit's lower error <3*2^-P/2 and interval width <=2*2^-P
+therefore imply strictly positive stored A/B factors and upper endpoints
+<1, for every admitted q. These inequalities also give positive stored kernel factors.
+For the kernel upper endpoint, inspect the actual decay branch: positive_interval
+starts total_lower at its R-grid unit, only adds nonnegative terms, and each
+outward squaring preserves total_lower>=unit. Hence ceil(unit^2/total_lower)
+<=unit. The subsequent outward shift to P still gives upper<=2^P, even for
+arbitrarily tiny positive K arguments. The kernel at argument zero is exactly one.
+Thus the actual unit check passes without an unjustified separation from
+one. Reflected coefficients copy already-admitted identical K values.
+
+The normalization is exactly floor(2^P/(2alpha))/2^P. It is positive because
+2alpha<2^(q+1)<=2^P, at most 1/4, and has error <2^-P. This binds the scalar
+enclosure theorem to every actual expansion producer acceptance check,
+including positivity and the near-unit endpoint. It does not reclaim the
+predecessor general enclosure theorem. The complete ordered page headers
+agree with (1)-(3); arbitrary parsing or positivity does not certify a page.
+
+The original exact line target is
+
+    (A_i x)_v=(S_i x/2)_v
+      =(1/(2alpha_i)) sum_(j in Z)
+        exp(-pi*(j-s_i*v/t_i)^2/alpha_i^2) x_(j mod s_i). (5)
+
+All omitted integer occurrences are outside the short stencil and at
+source distance >b. The credited production tail bound therefore applies
+also when several occurrences have the same residue. It is a sum of
+positive omitted masses, not a distinct-residue count. Matching the actual
+crop, work-grid restoration 2^(2sigma), and final q-grid extraction gives
+#5295's actual-input complex-modulus defect
+
+    ||Tile_i(x)-A_i x||_abs < (sqrt(2)+2^-11)2^-q.        (6)
+
+The source coefficient/primitive and original-periodicity contracts remain
+explicit. Equations (1)-(4) discharge the particular page/frame admission
+missing when the old paired ProductionTile is unavailable; they do not
+reprove the predecessor arithmetic theorem or all-size word service.
+
+## 4. Original coordinates and the reached half-disk
+
+Start with source coordinates in order (D-1,...,0), axis zero fastest.
+For axis i, treat that original axis as the contiguous line, use the pages
+(1), and write all t_i target records for each spectator line. An exact
+cyclic axis rotation then moves that completed axis to the slowest position.
+After D steps the order is (D-1,...,0) again, with all target lengths t_i.
+No coarse tile index is substituted for a Fourier axis and no coordinate
+called a hole by the narrow map is omitted from the T-record target.
+
+A concrete unchanged rotation is `FieldMove.run` with
+C=1, A=V_(i+1)/t_i, field=t_i, R=2(q+2), right=False. Its declared map is
+[C][A][field][R bits] -> [C][field][A][R bits]. Each t_i is dyadic for the
+fine family; its padding is consequently exact with Q=t_i. This is a
+specified, expensive reference route, not a free permutation or a new
+fast Broad controller. Periodic halo creation is a sequential source-line
+scan with an encoded residue counter and paid rewinds at each wrap.
+
+The actual digit ingress in `Sandwich.ingress` scales each unsigned b_digit
+bit digit by 2^-(b_digit+2). Its plan.p is our q; the source function
+parameter named q instead counts digits. Provided our q>=b_digit+2, this is exact on the
+q grid and its complex modulus is <1/4 (imaginary part zero). CRT address
+permutation and zero padding preserve that bound. We reuse only this
+literal ingress fact; we do not invoke the rejected old Sandwich catalogue.
+
+#5056's positive-majorant argument proves the actual Tile norm bound at
+each reached input, including every signed internal truncation. A sufficient
+credited bound is 3/4 per axis. Thus an actual quarter-disk input reaches
+modulus at most (1/4)(3/4)^D before the final normalization below, and never
+leaves the unit disk during its sequence of completed axis calls. This
+hard norm conclusion uses the matching lower coefficient pages in Section 3;
+it is not inferred from an ideal-map bound while ignoring internal rounding.
+The final inward normalization/serialization cannot increase modulus.
+Consequently the public middle's actual <=1/2 guard is met with slack.
+
+## 5. Spend the existing forward normalization and pay the return clock
+
+Let k_i be the already-declared forward normalizers of the current
+fine-family source, K_f=sum k_i, and require K_f>=D. The canonical sufficient
+choice k_i=100 ceil(log2 p0) satisfies this. Let K_c be the already-declared
+compression sum used by the public group ledger, so its existing Gaussian
+restoration is Gamma=K_f+K_c. This Gamma covers only these declared
+Gaussian dyadic normalizers; the two source-size S factors and any separate
+outer Fourier/integer-recovery scales remain outside this proposition.
+Native inverse normalizers are spent *inside*
+K_c by that ledger's first policy. They are not added here.
+
+The exact normalized expansion required by the current source is
+
+    E=2^-K_f tensor_i S_i.
+
+The unchanged Tile sequence instead approximates tensor_i A_i=2^-D tensor_i S_i.
+Therefore apply exactly one final inward q-grid scale with
+
+    J=K_f-D>=0.                                         (7)
+
+Its exact unrounded target is E. Neither D nor J is a new addition to
+Gamma, and the internal 2sigma restorations are already within each Tile.
+Adding D to Gamma after (7), or using a final scale K_f instead of J, changes
+the represented source transform by 2^D or 2^-D respectively.
+
+The public Core/halo codec's `prepare_return` uses its unchanged input as
+its record clock and checks the native EOF. A compact S-record original
+source cannot clock a T-record expanded return when S<T. In particular,
+reusing it would reject extra output; it would not silently complete the
+same-volume bridge. `return_codec.py` supplies an owned T-record all-zero
+clock, prepares the codec on that clock, then converts the actual T-record
+native return with Format(q+2,q,q+2,q,J). The dummy native entrance and
+zero clock are real paid fields. A protected output copy is made before
+abort erases the helper data; the actual native return stays borrowed.
+The adapter copies a borrowed encoded positive T Count at construction;
+its small fixture supplies that Count literally. It does not implement the
+outer source of T. Format(q,J) template construction is input-independent
+and costs O(q+J); those prepared grid/normalizer scalars are declared caller
+inputs. The online clock loop uses the copied Count and costs O(Tq).
+The incoming native field is disjoint from the borrowed count, its copy,
+the codec native buffer and every owned native scratch tape. Native and
+external tape classes are distinct; all B-format clocks/work/output are
+private distinct owners. These are explicit source/ownership premises,
+not a claim that an encoded complete prefix controller was constructed. This is only the dimension-changing return adapter;
+it does not claim execution of the complete Tile sequence in the fixture.
+
+It rounds each component once, with component-l1 error <2^(1-q), except
+that J=0 is exact. Signed zero is canonicalized. Its native word count,
+external word width, grid, and normalization bits are checked explicitly.
+Short, long and old-S-clock returns are rejected, and owned helper cleanup
+and borrowed native body/origin are checked in the bounded witness.
+
+## 6. Explicit prefix error into the public middle
+
+Use ||.||_* for maximum coordinate component-l1. Because every exact A_i
+has nonnegative real coefficients and row sum at most 3/4, it contracts
+this norm by 3/4. Convert the *local final* complex error (6) once:
+
+    delta_* < (2+sqrt(2)/2048)2^-q < 3*2^-q.
+
+At the actual computed input of each axis, the credited telescope therefore
+gives e_D<3*2^-q sum_(j=0)^(D-1)(3/4)^j<12*2^-q. This is an application
+of #5295, not a new general telescope and not a Lipschitz claim for rounded
+Tiles. Exact rotations and periodic copies introduce no arithmetic error.
+After (7) and the actual return projection,
+
+    epsilon_exp = ||Ehat(x)-E(x)||_*
+      < (12*2^-J+2)2^-q <=14*2^-q.                     (8)
+
+Inward radius is retained even when a coarse grid erases values; accuracy
+still requires (8) with the later restoration paid. In the public middle's
+actual caller equation, this prefix contributes at most
+
+    2^Gamma ||C_N||_* sqrt(2) epsilon_exp,              (9)
+
+where C_N is the exact normalized ideal compression from the public
+Reference join. Under that caller's proved ||C_N||_*<=1 premise, the simple
+sufficient allocation
+
+    q>=Gamma+tau_exp+5                                 (10)
+
+makes (9) strictly less than 2^-tau_exp, since 14sqrt(2)<32. Retain the
+actual norm if that premise is absent. The middle gets its separate chi/f
+allocation; compression and all extra interfaces retain separate allowances.
+For example the completed total is bounded by 2^-tau_core +2^-tau_exp
++2^-tau_mid + e_extra when all three admitted budgets are satisfied.
+This is not complete Fourier, opposite-sign or integer-recovery admission.
+
+The original fine family has D=Theta(p0^(1-epsilon)), epsilon=10^-30,
+alpha^2=O(log p0), log2 T=Theta(p0), and Gamma=O(D log p0)=o(p0).
+Choose q to satisfy (1), metadata fits, ingress q>=b_digit+2, (10), and
+the middle/caller's other sufficient conditions. For targets O(p0), one
+q=O(p0) suffices eventually. No unquantified finite onset is inferred from
+that asymptotic statement. These exact inequalities are finite admission
+tests, including the original-period size conditions used below.
+
+## 7. Full invoice and the obstruction for this direct port
+
+Let V_i=product_(j<i)t_j product_(j>=i)s_j, so V_0=S and V_D=T.
+Axis i has V_i/s_i complete original spectator lines. Its halo has
+s_i+2b_i+3 records; one encoded periodic counter copies every occurrence,
+with initial positioning and every wrap paid. The literal Tile validation,
+all A/K/B/normalization products, prefix convolution, crop, copying,
+return consumption and cleanup have the inherited complete bound
+
+    O((V_i/s_i)(s_i+t_i+b_i) q log^2(q+2)).             (11)
+
+This includes the short-block coefficient reads for every line. Production
+pages are prepared once per original axis and reused, not regenerated per
+spectator. The actual source size is O((t_i+b_i)q); input-independent
+preparation costs sum_i polynomial(t_i,q), with every coefficient owner,
+ratio operation, reflection scan, header, page copy and retained history
+charged. #6085's explicit shifts cost their lengths; sigma=4096q is O(q),
+not merely O(log q). With fresh history the fine family pays
+D*2^O(ell)*poly(p0)=2^o(p0); retained historical backing remains additional.
+
+The specified whole-axis FieldMove rotation costs
+O(V_(i+1) q (1+ell_i)) including each split, padding/crop, full spectator
+scan, parent copy, child consumption and restoration. This is its actual
+full-field application; the old short-field O(log q) rotation bill cannot
+be substituted when the moved field is the complete original t_i.
+The final clock/codec costs O(T(q+J)+q+J), and owns a constant number of
+full T-record fields, plus encoded templates and their retained extents.
+All axis/period metadata, owned halo buffers and full original source data
+remain in the bill. Storage includes the complete O(Tq) field banks,
+O(sum_i(t_i+b_i)q) pages, short work fields and every numerical child's
+active/inactive and historical high-water backing.
+
+If each b_i<=s_i and T/S<2, (11) sums to O(DTq log^2(q+2)). The reference
+route and final conversion give the conservative online upper bound
+
+    O(Tq(log2 T + D log^2(q+2)) + T J),                 (12)
+
+plus the stated setup and metadata. The period condition b_i<=s_i holds
+eventually because ell_i=Theta(p0^epsilon) dominates log p0, but it remains
+an explicit finite test; the general bill (11) applies when it fails.
+
+There are two literal lower bills. First, `Tile.run` copies every returned
+complex word, so its outputs alone require
+
+    2(q+2) sum_(i=1)^D V_i > (q+2)D T                  (13)
+
+under T/S<2. Since digit ingress requires q>=b_digit+2=Theta(p0), this
+already costs Omega(n p0^(1-epsilon)), excluding this unchanged sequential
+port from O(n p0^(1-kappa)) for any fixed kappa>epsilon. This is a statement
+about these mandatory writes, not a general lower bound for Gaussian maps.
+
+For the particular full-axis FieldMove route specified above there is an
+even stronger bound: its loop performs ell_i complete-volume stages on
+axis i. In its actual right=False branch, stage j has 2^j prefixes,
+A=V_(i+1)/t_i spectators and suffix=(t_i/2^(j+1))*2(q+2).
+The two copies per spectator write exactly 2(q+2)V_(i+1) bits.
+The Counter loop runs ell_i times; even A=1, all-zero data or an identity
+permutation does not skip it. With Q=t_i, padding adds no coordinates.
+Thus the stage writes give
+Omega(S q sum ell_i)=Omega(n p0)=Omega(n log n). When the fine-family tests
+hold, (12) matches O(n log n) up to the stated inherited constants because
+D log^2 p0=o(p0). We do not price these rotations as the old microbox moves.
+Changing the routing could remove this latter obstruction while leaving
+(13). Avoiding (13) requires changing the one-full-field-return-per-axis
+schedule, for example a separately admitted grouped implementation.
+
+## 8. What a fast grouped Broad can reuse, and what it must still prove
+
+The reusable object is the certified original-coordinate operator E and its
+actual normalization/precision boundary: a quarter-disk source reaches the
+middle's half-disk, with error (8) and unchanged Gamma. A future group
+implementation can compare its output against the same S_i coefficients,
+including every periodic occurrence, or against their certified intervals.
+In the augmented canonical broad representation, scattering source j to
+its original q_j and filling holes with zero gives M J_source=S_gauss;
+this is the source convention already specified in GAUSSIAN.md, not a new
+identity or permission to relabel coordinates freely.
+
+Such a group implementation must prove its own prepared coefficient/source
+binding, original-q scatter and hole semantics, reached-input error/radius,
+full movement/ownership/setup bill, and actual same-map normalization. It
+cannot reuse this slow reference's favorable numerical contract as evidence
+for its missing runtime or as a free whole-field routing oracle. The public
+middle and compression still retain their scalar/Fourier/native premises;
+the five foundational assumptions and accepted bound remain unchanged.
+
+The checks combine source fingerprints with independently derived integer
+halo/header/cost and rational normalization cases. The native fixture runs
+only the new return adapter with the real public codec and real native
+Tape words, under the inherited loader; it does not execute production
+Tiles, a complete prefix, or production GL64/O73. Written universal proof,
+finite support and source-model-assisted review have distinct roles.
diff --git a/research/fine-expansion-page-admission/README.md b/research/fine-expansion-page-admission/README.md
new file mode 100644
index 0000000000..82522c543c
--- /dev/null
+++ b/research/fine-expansion-page-admission/README.md
@@ -0,0 +1,129 @@
+# Fine-family expansion page admission and a paid enlarged return
+
+**No new kappa.** This source-relative enabling result admits the actual
+explicit full-period expansion pages from CrocSwap/integer-mult-bounds#3878
+for the fine family, joins their existing one-bit-per-axis normalization to
+the declared Gaussian normalization, and provides a paid dimension-changing
+return adapter. It also proves that the unchanged sequential reference
+schedule cannot provide the desired fast prefix.
+
+For integer working precision q>=101, integer alpha>=2, alpha²<q,
+0<s<t<2s and s,t,alpha<2^q, the certified inputs are
+
+    b=alpha ceil(sqrt(q)), P=32768q, sigma=4096q,
+    source=[-b-1,s+b+2), target=[0,t).
+
+Every occurrence of original periodic source x[j mod s] is included, even
+when the halo wraps more than once. The proof binds the actual A/K/B
+arguments to #6085's scalar enclosure theorem and proves the extra actual
+producer acceptance checks: every lower coefficient is positive, every
+upper endpoint is at most one, and every page/header/window check succeeds.
+The near-unit kernel check uses the actual reciprocal producer; an interval
+enclosure by itself would not imply its upper endpoint is at most one.
+
+The resulting source operator is E=2^-K_f tensor(S_i), with the already
+declared forward normalizer K_f>=D. The Tile sequence provides D of those
+bits, so the final shift is J=K_f-D. At a true quarter-disk input, the actual
+sequence reaches the cached middle's half-disk, and its maximum-coordinate
+component-l1 error satisfies
+
+    epsilon_exp < (12*2^-J+2)2^-q <=14*2^-q.
+
+With the public middle and exact normalized compression contracts, its
+restored prefix contribution is at most
+2^Gamma ||C_N||_* sqrt(2) epsilon_exp. If ||C_N||_*<=1, the sufficient
+allocation q>=Gamma+tau_exp+5 funds an error below 2^-tau_exp. Here
+Gamma=K_f+K_c is the existing **Gaussian dyadic restoration only**. The two
+source S factors and any separate outer Fourier/recovery normalization are
+outside this proposition. No extra axis normalization is added to Gamma.
+
+## What is new and what is inherited
+
+#3878 already covers fine theta; #5056 proves the actual inward norm;
+#5295 proves the five-residual local accuracy and axis telescope; #6085
+proves the encoded exponential enclosure. We use and credit those results.
+The new work is their exact full-period producer/page admission, preserved
+forward normalizer and changed-volume output interface. The rejected old
+paired `ProductionTile`/Tensor catalogue is untouched and is not invoked.
+
+The declared direct reference retains every source coefficient, periodic
+occurrence, original axis, padded coordinate, header, source preparation,
+route and word child. It has a conservative online upper bill
+O(Tq(log T+D log²(q+2))+TJ), with separately charged setup and historical
+backing. Mandatory Tile output writes alone cost Omega(DTq); the specified
+full-axis FieldMove route additionally costs Omega(Tq log T) when T/S<2.
+This is a limitation of that explicit direct schedule. It leaves a precise
+numerical/source contract for a separately proved grouped implementation.
+
+## What actually executes
+
+`admission.py` is an exact input-independent certificate, not a native
+coefficient producer. `check_exact.py` independently checks its integer and
+rational consequences. Whole source files and 22 named source clauses are
+bound without numerical AST projection.
+
+`return_codec.py` is a real native-word/public-codec adapter. It copies a
+borrowed encoded positive T count, prepares a paid T-record zero clock and
+dummy codec input, and converts the real T-record return at shift J. The
+original compact S-record stream cannot clock an enlarged T-record return.
+The prepared q/J templates, borrowed count producer and all source/native/
+work disjointness are explicit boundaries; this is not an encoded complete
+prefix controller.
+
+The finite native fixture is T16/S9, q12 and J3. Its signed output agrees
+with an independent exact truncation oracle; component-l1 projection error
+is 3/8192, below 2^(1-q). It preserves borrowed native words/counts and
+canonical origins, protects pending output, rejects short/long/native-work
+aliases and the old S clock, erases helper state, and demonstrates actual
+coarse-grid erasure. It does **not** execute a Tile, complete prefix or
+production Fourier program. The universal claim is the explicit written
+proof under the credited source, scalar and word contracts.
+
+## Reproduce
+
+From the repository root, using only Python 3.12 and its standard library:
+
+```sh
+python3 -B scripts/research_package.py --package research/fine-expansion-page-admission
+```
+
+Both normal and optimized Python commands have a 120-second limit. Expected
+marker: `PASS_FINE_EXPANSION_PAGE_ADMISSION`. A direct bounded check is:
+
+```sh
+python3 -B research/fine-expansion-page-admission/verify.py
+```
+
+The deterministic mathematical coverage is 4,320 header tuples, 7,557
+blocks, 68,013 exact quadratic identities, 288,036 original-residue
+multiplicities, 768 reciprocal/unit cases, 240 normalization budgets, four
+axis layouts and 26 literal route-stage invoices. Negative controls detect
+short halos, deduplicated occurrences, wrong ceilings, underfunded positive
+coefficients, invalid near-unit reasoning and double normalization. There
+is no random search and no inference from this finite domain to all sizes.
+
+## Dependencies and integrity
+
+Canonical main is 7c49fe32c55de02c2c873655c804b16e4c3fef0a. `SOURCES.json`
+authenticates all 30 live canonical inputs; `DEPENDENCIES.json` binds six
+retained files from four public source/interface packages and the public
+Reference join. Those public packages are dependencies, not silently
+accepted canonical results. No source is downloaded by the checker.
+
+`PROOF.md` holds the universal source proof and full invoice. `OVERLAP.md`
+and `NOTICE.md` record predecessor scopes and credit. `CHECKPOINT.md` and
+`evidence/REPLAY.json` preserve executed checks and the single corrected
+fixture setup failure. The proposed PR description is in `PR-BODY.md`.
+
+## Open next questions
+
+A fast grouped Broad must prove its own original-q scatter/hole semantics,
+same-map source/normalizer match, reached radius/error and complete physical
+bill. This slow reference cannot serve as a free routing oracle. Native
+scalar/Fourier production admission, the opposite transform, both outer S
+factors and complete CRT/integer recovery remain separate. The selected
+certificate, complete multiplication bound and five assumptions are unchanged.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Independent
+algorithmic checks and same-team lead review are not independent human or
+formal proof-kernel acceptance.
diff --git a/research/fine-expansion-page-admission/SOURCES.json b/research/fine-expansion-page-admission/SOURCES.json
new file mode 100644
index 0000000000..faf27d73d1
--- /dev/null
+++ b/research/fine-expansion-page-admission/SOURCES.json
@@ -0,0 +1,186 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "research/physical-gaussian-expansion/PROOF.md",
+      "git_blob": "89642f4740c62460835380a3bfa00f63808009a8",
+      "sha256": "5452f3e2191824b4a8451c83fbdf58b3b2228f4e1966a6f22c3e60bd152e56b0",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_prepare.py",
+      "git_blob": "69f862e7a1853b405670397cf0a4ea184a654f50",
+      "sha256": "4cc81e92487b91875d3e4e68e4a856fef021861b879565e0f8f2c9b923b37360",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_geometry.py",
+      "git_blob": "816a371a21c4e13a6d46ef469e129b7cbef0aa1c",
+      "sha256": "59584d32b10045bb4efe1ef0b4384d15f1e045b24e4a29c38f8a9c2544c28774",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_prepare.py",
+      "git_blob": "501fca979c563e9648aa8d430cd316e9613704ca",
+      "sha256": "e925414663a4e7c152bee375137bd36ba2405b61dcc86094700852fb6fa1f867",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile.py",
+      "git_blob": "d1b4bebb2ea30ac0f334d1e2e32045a025729c34",
+      "sha256": "487b6ac17b9dfd5544148a6734d114bd83f3cf1c9475ba939e07bdb1c3ad1079",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_engine.py",
+      "git_blob": "779023d7e2c82f5dcf0d78c32ffd067e923572f7",
+      "sha256": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_prepare.py",
+      "git_blob": "32e18686b653a09804941f5fd81b715973337aeb",
+      "sha256": "38aa123f80c68f7fcb9e60acae79543cf55f6fd37e12a548cffae11a9b50c1e5",
+      "usage": "input"
+    },
+    {
+      "path": "research/gaussian-expansion-headroom/PROOF.md",
+      "git_blob": "c9844fedfb887fc546d4394aadf72aa41b2a44c7",
+      "sha256": "2af6ee0d075d7b5dbad5c58314418a84e57d54dd15fc77bf81ea016666aaa95a",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_tile_geometry.py",
+      "git_blob": "30ff87e1ffdce973f433d1e1b61956796d8209df",
+      "sha256": "c38c834264efd3be4f5de826ec9c6b7e79177c86db92b396ad0eea6beff9e532",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_records.py",
+      "git_blob": "0a90dafb5cb762bfbc78accccb847510f825ca43",
+      "sha256": "5e3a9c4bb52d2c902c4c35dfba7f33e68230adcb955a84169f30241b5cd2cca9",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_lines.py",
+      "git_blob": "c59be26feb3f9d09b6a6f9b0f00e93f223669cfa",
+      "sha256": "66bac95bdcdf788978d185e2f7508cd74152801f1513c4e5af978ff5983fc511",
+      "usage": "input"
+    },
+    {
+      "path": "research/expansion-axis-margin/README.md",
+      "git_blob": "9c02d7f00222fbfe5d1084dc2b2b6abea983baa3",
+      "sha256": "bbb87bf8b6ab69a52ed87c01827b93f323601af6cd1cb457ee42721b06346551",
+      "usage": "input"
+    },
+    {
+      "path": "research/tensor-expansion-accuracy/README.md",
+      "git_blob": "b49af1a54cb1fd06856e2cd1c8d48284c1666107",
+      "sha256": "56806adcdeb885b8b55de16c37586c15d977bda88160788ef7b4cca64e0ff6dc",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_moves.py",
+      "git_blob": "842da60d989cd3a2e3e1ca60cccde396ead0f9e0",
+      "sha256": "65fedbf5aad4922cd4ba24a6f2aef339d7428dba3f051bf8e647800ab1c1818d",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/PROOF.md",
+      "git_blob": "0f59178830599efa2c689627664245f0ac04f959",
+      "sha256": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_records.py",
+      "git_blob": "4b06c9d85165b9e7e2dce20d24527f02844ec3b4",
+      "sha256": "a450cbee0b899c0e14dbd43147e73138786846ac009c6626dbcb96292458bb6b",
+      "usage": "input"
+    },
+    {
+      "path": "research/tensor-internal-contraction/PROOF.md",
+      "git_blob": "ba524f5068052a1081c75f3d9392ff5f2d63848a",
+      "sha256": "380ceaffb70d35b4218ecf3918d30140e6c2830d07d5b8c6732ece80c5403362",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_block.py",
+      "git_blob": "be35473b70e55768ee294af8b8846f49f5bbbe8f",
+      "sha256": "e95cc3a0edd9f8a10c8bb831dae31a41bca9d7c54bc9dadf5f3ec36ebaf32011",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-expansion/expansion_sources.py",
+      "git_blob": "f8073c821494a4e57791834871ecfd3158331b9c",
+      "sha256": "a5cc56b5ad1714d21da77dcd6f938b448c215932fbdab3d7ed5613ec2c107c67",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_exponentials.py",
+      "git_blob": "8f0f32d7090554b47c112142e300c88fb8e5db4d",
+      "sha256": "f7a27cacbb27c0cfa4a63054e83feba2beae91b3fa9d3c37f903620b3899e67b",
+      "usage": "input"
+    },
+    {
+      "path": "research/encoded-gaussian-directed-coefficient-audit/PROOF.md",
+      "git_blob": "fd7f576039c8867053042d6f616441b41a4a103d",
+      "sha256": "b63efb46b31a43d6be1ba2951709e270deca3390fe9d2dd46a235f2672bfc58a",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-core/PROOF.md",
+      "git_blob": "883c8d4a6f0eead888fb3532b60db41596940889",
+      "sha256": "e909026dd3f455c35ff28210a0c4ffa232ad8d7633174e481094fd09e2469d7a",
+      "usage": "input"
+    },
+    {
+      "path": "research/unconditional-batched-crt/PROOF.md",
+      "git_blob": "406eb561cc8d6041ea3fba1a849653b654f2198c",
+      "sha256": "689fc7b01c5f04f77019ff02d1b79cb4f7020bd98e05b1052020bad295dec060",
+      "usage": "input"
+    },
+    {
+      "path": "research/unconditional-batched-crt/GAUSSIAN.md",
+      "git_blob": "adfb28c93e6b06178c901caaac39ede41a9e541b",
+      "sha256": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242",
+      "usage": "input"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81",
+      "usage": "input"
+    },
+    {
+      "path": "research/tensor-expansion-accuracy/PROOF.md",
+      "git_blob": "b439b91269154a8e31c0bc2f6ad410d1d4195d16",
+      "sha256": "659fe79662c5cfab5fd22cc937e88b849c1491bf4a66e79ee1a7558aeb090e0d",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_sources.py",
+      "git_blob": "ce521f91997775e189f984ba7dd68a15bf9ecd9b",
+      "sha256": "c5889a97a11a9c6c6c44deb8a2042498ddc3f55703de15269132b8f198e24b15",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-core/inputs/word-export.tar",
+      "git_blob": "885794cf3328941209034ee2d946ed76dbea8ce3",
+      "sha256": "d428e8b6aef4d348fa2e922ca64c4cfd634bbb2f0c150033273e65fcf4600b49",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-gaussian-core/inputs/branchfree-source.tar",
+      "git_blob": "48dc77f5145d649bfed6745e38ab18b11772d597",
+      "sha256": "e6cdacd59a067189a99bfe03f4448913bb8d518ed4a9b1d981a68c5c666529c7",
+      "usage": "input"
+    },
+    {
+      "path": "research/physical-tensor-crt-sandwich-recovery/sandwich.py",
+      "git_blob": "d1b42997b65c0405791baa79c5b470823994ced8",
+      "sha256": "1d45e8deed1b138fcd9800cc563b8cd894cbd2d072033ba23215566d299a4325",
+      "usage": "input"
+    }
+  ]
+}
diff --git a/research/fine-expansion-page-admission/TASK.json b/research/fine-expansion-page-admission/TASK.json
new file mode 100644
index 0000000000..7471e3103f
--- /dev/null
+++ b/research/fine-expansion-page-admission/TASK.json
@@ -0,0 +1,101 @@
+{
+  "actual_scope": "Bind the actual fine-family full-period explicit expansion page producer, its lower/upper coefficient admissions, original periodic halo and preserved forward normalizer; provide a paid dimension-changing return adapter and delimit the full sequential reference cost.",
+  "ai_assistance": "Substantial OpenAI assistance in source audit, proof, exact independent rational oracles, code and packaging. Independent lead review, if included, is separately recorded; no human or proof-kernel acceptance.",
+  "author": "Prepared for @CubeJerry",
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "bottleneck_link": "The analytic_recovery prefix must enter the public cached middle on its original padded field. The old paired production catalogue cannot supply that fine-family admission; generic expansion error telescopes do not establish matching producer pages or the changing-volume return.",
+  "budget_minutes": 70,
+  "evidence": "Universal producer/page/header/normalizer proof and literal complete-volume invoices; exact independent halo, exponent, reciprocal, budget and layout controls; real native-word/public-codec dimension-changing return with failure controls.",
+  "finite_domain": "4,320 admission tuples q in {101,121,256,1024}, alpha 2..9 and floor sqrt(q-1), dyadic t4..128 and all s strictly between t/2 and t; 7,557 blocks, 68,013 quadratic checks and 288,036 multiplicities. One actual native T16/S9 q12 J3 adapter fixture. No random search, complete Tile or production Fourier replay.",
+  "independent_previous_package": false,
+  "no_new_kappa": true,
+  "open_questions": [
+    {
+      "blocked_by": "This direct Tile schedule must write every axis output; the specified full-axis FieldMove route additionally costs a full log(T) field sweep.",
+      "first_step": "Pin the grouped source/caller and prove its original-q scatter, hole semantics, source/normalizer match and complete actual radius/error and physical bill.",
+      "question": "Can an actual grouped fine-family Broad implementation reuse these admitted original-coordinate pages without one complete output field per axis?",
+      "why_it_matters": "A numerically admitted slow reference does not meet the desired positive-kappa complete cost."
+    },
+    {
+      "blocked_by": "The present Gamma is only the declared Gaussian dyadic restoration; scalar/Fourier/native production premises and outer recovery are separate.",
+      "first_step": "Use the public caller audit and exact actual source scales to allocate every remaining error before final strict integer rounding.",
+      "question": "Can the cached middle, normalized compression and opposite transform meet the complete integer-recovery caller with both source S factors?",
+      "why_it_matters": "The selected conditional theorem and all five foundational assumptions remain unchanged."
+    }
+  ],
+  "original_card": {
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal 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."
+    ],
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "existing_checks": [
+      {
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "status": "author-checked"
+      },
+      {
+        "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.",
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "status": "reviewed"
+      }
+    ],
+    "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.",
+    "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."
+    },
+    "id": "uniform-transfer-audit",
+    "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."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "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."
+    ],
+    "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"
+    ]
+  },
+  "outcome": "completed",
+  "previous_public_commit": "8db3cc1e98ba295cec4d752478431515e159c34f",
+  "priority_revision": 8,
+  "schema_version": 1,
+  "scope_change_reason": "The first bounded audit found that #3878 already permits fine theta and #5056/#5295 already prove the local norm/error telescope. The approved narrow pivot proves the actual producer/header admission and unchanged-Gamma normalizer boundary, adds the changed-volume codec, and delimits the literal slow full-axis port.",
+  "scope_status": "refined",
+  "seed": 56,
+  "source_projection_scope": "Only complete source hashes and named AST fingerprints are inspected. The native fixture executes the unchanged Gaussian loader and real native-word/public-codec routines; no extracted numerical formula executes. No complete expansion controller, Tile or production Fourier replay is claimed.",
+  "stop_rule": "Freeze after source-relative producer admission, complete reference cost and bounded encoded-return checks. Do not implement broad Core, replace old catalogue guards or claim a fast prefix, full recovery or new kappa.",
+  "task_id": "uniform-transfer-audit",
+  "tracks": [
+    "50-59 recursive interface",
+    "75-84 independent verification/formalization"
+  ],
+  "wave": 9,
+  "worker": "analytic_join"
+}
diff --git a/research/fine-expansion-page-admission/VERIFY.json b/research/fine-expansion-page-admission/VERIFY.json
new file mode 100644
index 0000000000..d4a4209268
--- /dev/null
+++ b/research/fine-expansion-page-admission/VERIFY.json
@@ -0,0 +1,59 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/physical-gaussian-expansion/PROOF.md",
+    "research/physical-gaussian-expansion/expansion_prepare.py",
+    "research/physical-gaussian-expansion/expansion_geometry.py",
+    "research/physical-gaussian-expansion/expansion_tile_prepare.py",
+    "research/physical-gaussian-expansion/expansion_tile.py",
+    "research/physical-gaussian-tensor/tensor_engine.py",
+    "research/physical-gaussian-core/gaussian_prepare.py",
+    "research/gaussian-expansion-headroom/PROOF.md",
+    "research/physical-gaussian-expansion/expansion_tile_geometry.py",
+    "research/physical-gaussian-expansion/expansion_records.py",
+    "research/physical-gaussian-tensor/tensor_lines.py",
+    "research/expansion-axis-margin/README.md",
+    "research/tensor-expansion-accuracy/README.md",
+    "research/physical-gaussian-tensor/tensor_moves.py",
+    "research/physical-gaussian-tensor/PROOF.md",
+    "research/physical-gaussian-tensor/tensor_records.py",
+    "research/tensor-internal-contraction/PROOF.md",
+    "research/physical-gaussian-expansion/expansion_block.py",
+    "research/physical-gaussian-expansion/expansion_sources.py",
+    "research/physical-gaussian-core/gaussian_exponentials.py",
+    "research/encoded-gaussian-directed-coefficient-audit/PROOF.md",
+    "research/physical-gaussian-core/PROOF.md",
+    "research/unconditional-batched-crt/PROOF.md",
+    "research/unconditional-batched-crt/GAUSSIAN.md",
+    "docs/research/agent-task-catalog.json",
+    "research/tensor-expansion-accuracy/PROOF.md",
+    "research/physical-gaussian-core/gaussian_sources.py",
+    "research/physical-gaussian-core/inputs/word-export.tar",
+    "research/physical-gaussian-core/inputs/branchfree-source.tar",
+    "research/physical-tensor-crt-sandwich-recovery/sandwich.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "checks": "Whole-file/source-clause authentication; independent full-period header, halo multiplicity, actual exponent, reciprocal upper-unit, normalizer and route invoice controls; actual T16 native/public-codec return, encoded borrowed Count preservation, volume/alias/pending-return failures and coarse erasure. No complete production Tile or Fourier replay.",
+      "timeout_seconds": 120
+    },
+    {
+      "argv": [
+        "{python}",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "checks": "Whole-file/source-clause authentication; independent full-period header, halo multiplicity, actual exponent, reciprocal upper-unit, normalizer and route invoice controls; actual T16 native/public-codec return, encoded borrowed Count preservation, volume/alias/pending-return failures and coarse erasure. No complete production Tile or Fourier replay.",
+      "timeout_seconds": 120
+    }
+  ]
+}
diff --git a/research/fine-expansion-page-admission/admission.py b/research/fine-expansion-page-admission/admission.py
new file mode 100644
index 0000000000..be49c2dbb0
--- /dev/null
+++ b/research/fine-expansion-page-admission/admission.py
@@ -0,0 +1,55 @@
+"""Exact input-independent certificate, not a native Tile/page execution.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from dataclasses import dataclass
+from fractions import Fraction
+from math import isqrt
+
+def need(value,message):
+    if not value:raise ValueError(message)
+def ceil_div(a,b):return -((-a)//b)
+def ceil_log2(n):
+    need(n>0,'positive logarithm');return (n-1).bit_length()
+def trunc_div(a,b):return (-1 if a<0 else 1)*(abs(a)//b)
+
+@dataclass(frozen=True)
+class Certificate:
+    s:int;t:int;alpha:int;q:int;b:int;P:int;sigma:int
+    source_start:int;source_count:int;blocks:int
+
+    @classmethod
+    def make(cls,s,t,alpha,q):
+        need(all(type(v) is int for v in (s,t,alpha,q)),'integer source descriptors')
+        need(q>=101 and alpha>=2 and alpha*alpha<q,'production block precision/alpha')
+        need(0<s<t<2*s,'original near-one ratio')
+        need(max(s,t,alpha).bit_length()<=q,'actual fits metadata')
+        root=isqrt(q)+(isqrt(q)**2!=q);b=alpha*root
+        need(3*b+3<=4*q and 4*b+2<=5*q,'actual uniform short-block guards')
+        P=32768*q;sigma=4096*q
+        need(P>=2*sigma+q+ceil_log2(32*(3*b+4))+12,'actual complete tile precision guard')
+        need(P-4256*q>=2 and 3936*q>=2,'positive lower and strict unit upper A/B')
+        return cls(s,t,alpha,q,b,P,sigma,-b-1,s+2*b+3,ceil_div(t,b))
+
+    def block(self,v,m):
+        need(0<=v<v+m<=self.t and 1<=m<=self.b,'declared full-period block')
+        j0=(self.s*v)//self.t;gamma=Fraction(j0)-Fraction(self.s*v,self.t)
+        high=ceil_div(self.s*(v+m-1),self.t)+self.b+2
+        low=j0-self.b-1;n=high-low;nc=n+m-1
+        return dict(v=v,m=m,j0=j0,gamma=gamma,start=low,end=high,n=n,nc=nc,
+                    width=self.P+ceil_log2(n+1)+3,extract=self.P-self.q-2*self.sigma)
+
+    def block_sequence(self):
+        for v in range(0,self.t,self.b):yield self.block(v,min(self.b,self.t-v))
+
+    def exponents(self,block,h,z):
+        k=Fraction(self.s,self.t);g=block['gamma'];u=self.alpha*self.alpha
+        return (((1-k)*h*h+2*g*h+g*g)/u,
+                ((k*k-k)*z*z-2*g*k*z)/u,k*(h-z)**2/u)
+
+def final_budget(D,Kf,Kc,q,tau):
+    need(D>=1 and Kf>=D and Kc>=0,'declared normalizer shares')
+    J=Kf-D;Gamma=Kf+Kc
+    error=(Fraction(12,1<<J)+2)/(1<<q)
+    restored=Fraction(3,2)*(1<<Gamma)*error
+    return dict(J=J,Gamma=Gamma,error=error,restored=restored,
+                admitted=q>=Gamma+tau+5,threshold=Fraction(1,1<<tau))
diff --git a/research/fine-expansion-page-admission/check_exact.py b/research/fine-expansion-page-admission/check_exact.py
new file mode 100644
index 0000000000..de00360941
--- /dev/null
+++ b/research/fine-expansion-page-admission/check_exact.py
@@ -0,0 +1,124 @@
+"""Independent integer/Fraction checks of the pinned interface proposition.
+No numerical predecessor checker is imported or executed.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction
+from math import isqrt
+from admission import Certificate,final_budget,ceil_log2,need
+
+
+def checks():
+    cases=blocks=identities=wraps=0;multiple=clipped=0
+    for q in (101,121,256,1024):
+        alphas=sorted(set(range(2,10))|{isqrt(q-1)})
+        for alpha in alphas:
+            for t in (4,8,16,32,64,128):
+                for s in range(t//2+1,t):
+                    c=Certificate.make(s,t,alpha,q)
+                    # Different construction of the ceiling root: bracket its square.
+                    root=c.b//alpha
+                    need((root-1)**2<q<=root**2,'literal ceiling-root bracket')
+                    sequence=list(c.block_sequence());need(len(sequence)==c.blocks,'actual block count')
+                    end=c.source_start+c.source_count
+                    need(sequence[0]['start']==c.source_start and sequence[-1]['end']==end,'exact full-period endpoints')
+                    previous=None
+                    for block in sequence:
+                        blocks+=1;m=block['m'];v=block['v'];n=block['n']
+                        need(2*c.b+3<=n<=2*c.b+m+3 and m<=n,'actual BlockHeader span')
+                        need(block['nc']==n+m-1 and n<=4*q and block['nc']<=5*q,'actual prefix/width gates')
+                        need(c.P>=2*c.sigma+q+ceil_log2(32*(n+1))+12,'actual extraction precision gate')
+                        if previous is not None:
+                            need(previous['start']<=block['start']<=previous['end']<=block['end'],'complete monotone overlap')
+                        previous=block
+                        if m<c.b:clipped+=1
+                        for z in sorted({0,m//2,m-1}):
+                            center=Fraction(s*(v+z),t)
+                            for h in sorted({-c.b-1,0,block['end']-1-block['j0']}):
+                                A,B,K=c.exponents(block,h,z)
+                                direct=(Fraction(block['j0']+h)-center)**2/(alpha*alpha)
+                                need(A+B+K==direct,'original quadratic coefficient identity')
+                                need(abs(A)<20*q and abs(B)<3*q and 0<=K<12*q,'actual exponent ranges')
+                                identities+=1
+                            # The full needed radius is covered; ceil/floor checked without helper.
+                            first=(center.numerator//center.denominator)-c.b
+                            last=-((-center.numerator)//center.denominator)+c.b
+                            need(block['start']<=first and last<block['end'],'all center-radius integer occurrences covered')
+                    stream=Counter(j%s for j in range(c.source_start,end))
+                    need(sum(stream.values())==c.source_count,'all halo occurrences charged')
+                    for r in range(s):
+                        exact=(end-1-r)//s-(c.source_start-1-r)//s
+                        need(stream[r]==exact,'independent residue winding multiplicity');wraps+=1
+                    if max(stream.values())>1:multiple+=1
+                    for lift in (-2,1):
+                        # Shifting by one full source period preserves every multiplicity.
+                        need(Counter((j+lift*s)%s for j in range(c.source_start,end))==stream,'signed full-period lift')
+                    cases+=1
+    # These are independent proof controls, not claims of native Tile execution.
+    c=Certificate.make(61,64,3,101);seq=list(c.block_sequence())
+    need(seq[-1]['end']>c.source_start+c.source_count-1,'one-short halo fails final source containment')
+    need(c.source_count>c.s,'deduplication loses required occurrences')
+    need(any(b['end']!=((c.s*(b['v']+b['m']-1))//c.t+c.b+2) for b in seq),'floor cannot replace strict upper ceiling')
+    guards=0
+    for args in ((3,4,2,100),(3,4,11,121),(3,6,2,101),(4,4,2,101),(3,4,1,101)):
+        try:Certificate.make(*args)
+        except ValueError:guards+=1
+        else:raise ValueError('missing domain rejection')
+    # Generic interval containment does not imply the source upper<=unit guard.
+    interval_controls=reciprocal=positivity_controls=0
+    for P in range(1,17):
+        # Underfunded precision permits an exactly positive coefficient with
+        # a valid zero stored lower endpoint. This is an explicit countermodel
+        # to inferring positivity from enclosure/error alone, not a replay of
+        # the production Exponentials owner with a modified precision.
+        tiny=Fraction(1,1<<(P+1));zero=Fraction(0);one_ulp=Fraction(1,1<<P)
+        need(zero<tiny<=one_ulp and tiny-zero<Fraction(3,2)*one_ulp,
+             'underfunded enclosure allows a zero lower coefficient')
+        positivity_controls+=1
+        truth=Fraction(1)-Fraction(1,1<<(P+2));lower=Fraction((1<<P)-1,1<<P);upper=Fraction((1<<P)+1,1<<P)
+        need(lower<=truth<=upper and upper>1 and upper-lower==Fraction(2,1<<P),'near-unit enclosure countercontrol')
+        interval_controls+=1
+        for R in range(P,P+8):
+            U=1<<R
+            for added in (0,1,2,7,U//3,U):
+                lo=U+added;up=-(-(U*U)//lo)
+                final=-(-up//(1<<(R-P)))
+                need(up<=U and final<=1<<P,'actual reciprocal/ceil upper unit invariant')
+                reciprocal+=1
+    budgets=0
+    for D in (1,2,7,16):
+        for extra in (0,1,4,17,63):
+            for Kc in (0,1,8,73):
+                for tau in (0,1,13):
+                    Kf=D+extra;q=Kf+Kc+tau+5
+                    r=final_budget(D,Kf,Kc,q,tau)
+                    need(r['admitted'] and r['restored']<r['threshold'],'same-Gamma sufficient prefix allowance')
+                    exact=Fraction(1,1<<D)*Fraction(1,1<<r['J'])
+                    need(exact==Fraction(1,1<<Kf),'spend actual existing forward share')
+                    need(exact*(1<<D)!=exact and exact/Fraction(1<<D)!=exact,'double restoration and double attenuation controls')
+                    budgets+=1
+    stages=layouts=0
+    for radices in ((4,4),(8,4),(4,8,4),(8,4,8,4)):
+        # Source-valued labels verify the cyclic axis rotations, not only norms.
+        import itertools
+        initial=list(itertools.product(*(range(t) for t in reversed(radices))))
+        labels=[tuple(reversed(x)) for x in initial];order=list(reversed(range(len(radices))))
+        for i,t in enumerate(radices):
+            need(order[-1]==i,'actual original axis next contiguous')
+            V=len(labels);A=V//t
+            labels=[labels[a*t+k] for k in range(t) for a in range(A)]
+            order=[i]+order[:-1]
+            ell=t.bit_length()-1
+            for j in range(ell):
+                prefixes=1<<j;suffix=(t>>(j+1))*26
+                need(prefixes*A*2*suffix==26*V,'literal complete-volume FieldMove stage writes');stages+=1
+        need(labels==[tuple(reversed(x)) for x in initial],'full target order restored after D rotations')
+        layouts+=1
+    return dict(header_cases=cases,blocks=blocks,quadratic_identities=identities,
+                residue_multiplicities=wraps,multiple_wrap_cases=multiple,clipped_blocks=clipped,
+                certificate_domain_rejections=guards,near_unit_countercontrols=interval_controls,
+                positive_lower_countercontrols=positivity_controls,
+                reciprocal_unit_cases=reciprocal,normalization_budget_cases=budgets,
+                complete_axis_layouts=layouts,literal_move_stage_invoices=stages,
+                mathematical_controls=['short_halo','lost_alias_multiplicity','upper_floor','positivity_precision',
+                                       'near_unit_enclosure','double_forward_normalization','extra_restoration'])
diff --git a/research/fine-expansion-page-admission/evidence/REPLAY.json b/research/fine-expansion-page-admission/evidence/REPLAY.json
new file mode 100644
index 0000000000..20c0311803
--- /dev/null
+++ b/research/fine-expansion-page-admission/evidence/REPLAY.json
@@ -0,0 +1,150 @@
+{
+  "attempt_history": [
+    {
+      "file": "attempt-1.json",
+      "reason": "A fresh native Tape already owns its marker; direct initialize_marker was correctly rejected. The fixture now erases its initial marker before initializing. No inherited source or guard was changed.",
+      "status": "failed fixture setup"
+    },
+    {
+      "file": "normal.json",
+      "status": "pre-metadata successful adapter pass"
+    },
+    {
+      "file": "registered.json",
+      "status": "final registered normal and optimized pass"
+    }
+  ],
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "limitations": [
+    "No actual coefficient producer or Tile execution",
+    "No complete expansion controller",
+    "No production Fourier execution",
+    "Source-relative universal proof with finite independent support; no human or proof-kernel acceptance"
+  ],
+  "platform": "Linux-6.18.57-x86_64-with-glibc2.39",
+  "python": "3.12.14 (main, Aug 25 2026, 14:00:49) [Clang 22.1.3 ]",
+  "registered": {
+    "elapsed_seconds": 7.865,
+    "normal_and_optimized_identical": true,
+    "returncode": 0
+  },
+  "schema_version": 1,
+  "verified_result": {
+    "canonical_inputs": 30,
+    "claim": "fine-family expansion producer/page admission and declared slow-reference interface; no new kappa",
+    "mathematics": {
+      "blocks": 7557,
+      "certificate_domain_rejections": 5,
+      "clipped_blocks": 3897,
+      "complete_axis_layouts": 4,
+      "header_cases": 4320,
+      "literal_move_stage_invoices": 26,
+      "mathematical_controls": [
+        "short_halo",
+        "lost_alias_multiplicity",
+        "upper_floor",
+        "positivity_precision",
+        "near_unit_enclosure",
+        "double_forward_normalization",
+        "extra_restoration"
+      ],
+      "multiple_wrap_cases": 4320,
+      "near_unit_countercontrols": 16,
+      "normalization_budget_cases": 240,
+      "positive_lower_countercontrols": 16,
+      "quadratic_identities": 68013,
+      "reciprocal_unit_cases": 768,
+      "residue_multiplicities": 288036
+    },
+    "native_return": {
+      "J": 3,
+      "T": 16,
+      "actual_coarse_erasure": true,
+      "complete_prefix_executed": false,
+      "component_l1_projection_error": "3/8192",
+      "failures": [
+        "short_native",
+        "long_native",
+        "old_S_clock",
+        "native_metadata_or_work_alias",
+        "native_metadata_or_work_alias",
+        "native_metadata_or_work_alias",
+        "native_metadata_or_work_alias"
+      ],
+      "old_S": 9,
+      "output": [
+        [
+          15,
+          10
+        ],
+        [
+          -16,
+          11
+        ],
+        [
+          18,
+          -12
+        ],
+        [
+          -19,
+          -13
+        ],
+        [
+          20,
+          14
+        ],
+        [
+          -22,
+          15
+        ],
+        [
+          23,
+          -16
+        ],
+        [
+          -25,
+          -17
+        ],
+        [
+          26,
+          17
+        ],
+        [
+          -27,
+          18
+        ],
+        [
+          29,
+          -19
+        ],
+        [
+          -30,
+          -20
+        ],
+        [
+          31,
+          21
+        ],
+        [
+          -33,
+          22
+        ],
+        [
+          34,
+          -23
+        ],
+        [
+          -36,
+          -24
+        ]
+      ],
+      "output_sha256": "0c3403f890fafcf4599db5cf071b81eb72eebe23833bfce67ca26a6bc158675b",
+      "production_Fourier_executed": false,
+      "production_Tile_executed": false,
+      "q": 12
+    },
+    "public_files": 6,
+    "source_clause_mutations": 21,
+    "source_clauses": 22
+  }
+}
diff --git a/research/fine-expansion-page-admission/evidence/attempt-1.json b/research/fine-expansion-page-admission/evidence/attempt-1.json
new file mode 100644
index 0000000000..29d6a4ed15
--- /dev/null
+++ b/research/fine-expansion-page-admission/evidence/attempt-1.json
@@ -0,0 +1,11 @@
+{
+  "argv": [
+    "python",
+    "-B",
+    "research/fine-expansion-page-admission/verify.py"
+  ],
+  "elapsed_seconds": 4.058,
+  "returncode": 1,
+  "stdout": "",
+  "stderr": "Traceback (most recent call last):\n  File \"/workspace/scratch/a365d332d434/worker-analytic-wave9/research/fine-expansion-page-admission/verify.py\", line 125, in <module>\n    if __name__=='__main__':main()\n                            ^^^^^^\n  File \"/workspace/scratch/a365d332d434/worker-analytic-wave9/research/fine-expansion-page-admission/verify.py\", line 59, in main\n    native=native_field(values);saved=bytes(native.cells)\n           ^^^^^^^^^^^^^^^^^^^^\n  File \"/workspace/scratch/a365d332d434/worker-analytic-wave9/research/fine-expansion-page-admission/verify.py\", line 53, in native_field\n    tape=Tape();initialize_marker(tape)\n                ^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/tmp/physical-compact-anwj1wwi/pr2899/session.py\", line 25, in initialize_marker\n  File \"/tmp/ordinary-physical-gj7uryop/pr2809/inputs/pr2753/predecessor/vendor/words.py\", line 12, in need\nValueError: blank owned origin\n"
+}
diff --git a/research/fine-expansion-page-admission/evidence/normal.json b/research/fine-expansion-page-admission/evidence/normal.json
new file mode 100644
index 0000000000..6967b0a0a2
--- /dev/null
+++ b/research/fine-expansion-page-admission/evidence/normal.json
@@ -0,0 +1,12 @@
+{
+  "argv": [
+    "python",
+    "-B",
+    "research/fine-expansion-page-admission/verify.py"
+  ],
+  "elapsed_seconds": 3.874,
+  "returncode": 0,
+  "stdout": "PASS_FINE_EXPANSION_PAGE_ADMISSION\n{\n  \"canonical_inputs\": 30,\n  \"claim\": \"fine-family expansion producer/page admission and declared slow-reference interface; no new kappa\",\n  \"mathematics\": {\n    \"blocks\": 7557,\n    \"certificate_domain_rejections\": 5,\n    \"clipped_blocks\": 3897,\n    \"complete_axis_layouts\": 4,\n    \"header_cases\": 4320,\n    \"literal_move_stage_invoices\": 26,\n    \"mathematical_controls\": [\n      \"short_halo\",\n      \"lost_alias_multiplicity\",\n      \"upper_floor\",\n      \"positivity_precision\",\n      \"near_unit_enclosure\",\n      \"double_forward_normalization\",\n      \"extra_restoration\"\n    ],\n    \"multiple_wrap_cases\": 4320,\n    \"near_unit_countercontrols\": 16,\n    \"normalization_budget_cases\": 240,\n    \"quadratic_identities\": 68013,\n    \"reciprocal_unit_cases\": 768,\n    \"residue_multiplicities\": 288036\n  },\n  \"native_return\": {\n    \"J\": 3,\n    \"T\": 16,\n    \"actual_coarse_erasure\": true,\n    \"complete_prefix_executed\": false,\n    \"component_l1_projection_error\": \"3/8192\",\n    \"failures\": [\n      \"short_native\",\n      \"long_native\",\n      \"old_S_clock\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\"\n    ],\n    \"old_S\": 9,\n    \"output\": [\n      [\n        15,\n        10\n      ],\n      [\n        -16,\n        11\n      ],\n      [\n        18,\n        -12\n      ],\n      [\n        -19,\n        -13\n      ],\n      [\n        20,\n        14\n      ],\n      [\n        -22,\n        15\n      ],\n      [\n        23,\n        -16\n      ],\n      [\n        -25,\n        -17\n      ],\n      [\n        26,\n        17\n      ],\n      [\n        -27,\n        18\n      ],\n      [\n        29,\n        -19\n      ],\n      [\n        -30,\n        -20\n      ],\n      [\n        31,\n        21\n      ],\n      [\n        -33,\n        22\n      ],\n      [\n        34,\n        -23\n      ],\n      [\n        -36,\n        -24\n      ]\n    ],\n    \"output_sha256\": \"0c3403f890fafcf4599db5cf071b81eb72eebe23833bfce67ca26a6bc158675b\",\n    \"production_Fourier_executed\": false,\n    \"production_Tile_executed\": false,\n    \"q\": 12\n  },\n  \"public_files\": 5,\n  \"source_clause_mutations\": 21,\n  \"source_clauses\": 22\n}\n",
+  "stderr": "",
+  "stage": "pre-metadata adapter pass before sixth public dependency was retained"
+}
diff --git a/research/fine-expansion-page-admission/evidence/registered.json b/research/fine-expansion-page-admission/evidence/registered.json
new file mode 100644
index 0000000000..c9558d71b0
--- /dev/null
+++ b/research/fine-expansion-page-admission/evidence/registered.json
@@ -0,0 +1,14 @@
+{
+  "argv": [
+    "/opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python",
+    "-B",
+    "scripts/research_package.py",
+    "--package",
+    "research/fine-expansion-page-admission"
+  ],
+  "python": "3.12.14 (main, Aug 25 2026, 14:00:49) [Clang 22.1.3 ]",
+  "elapsed_seconds": 7.865,
+  "returncode": 0,
+  "stdout": "CHECK Whole-file/source-clause authentication; independent full-period header, halo multiplicity, actual exponent, reciprocal upper-unit, normalizer and route invoice controls; actual T16 native/public-codec return, encoded borrowed Count preservation, volume/alias/pending-return failures and coarse erasure. No complete production Tile or Fourier replay.\nPASS_FINE_EXPANSION_PAGE_ADMISSION\n{\n  \"canonical_inputs\": 30,\n  \"claim\": \"fine-family expansion producer/page admission and declared slow-reference interface; no new kappa\",\n  \"mathematics\": {\n    \"blocks\": 7557,\n    \"certificate_domain_rejections\": 5,\n    \"clipped_blocks\": 3897,\n    \"complete_axis_layouts\": 4,\n    \"header_cases\": 4320,\n    \"literal_move_stage_invoices\": 26,\n    \"mathematical_controls\": [\n      \"short_halo\",\n      \"lost_alias_multiplicity\",\n      \"upper_floor\",\n      \"positivity_precision\",\n      \"near_unit_enclosure\",\n      \"double_forward_normalization\",\n      \"extra_restoration\"\n    ],\n    \"multiple_wrap_cases\": 4320,\n    \"near_unit_countercontrols\": 16,\n    \"normalization_budget_cases\": 240,\n    \"positive_lower_countercontrols\": 16,\n    \"quadratic_identities\": 68013,\n    \"reciprocal_unit_cases\": 768,\n    \"residue_multiplicities\": 288036\n  },\n  \"native_return\": {\n    \"J\": 3,\n    \"T\": 16,\n    \"actual_coarse_erasure\": true,\n    \"complete_prefix_executed\": false,\n    \"component_l1_projection_error\": \"3/8192\",\n    \"failures\": [\n      \"short_native\",\n      \"long_native\",\n      \"old_S_clock\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\"\n    ],\n    \"old_S\": 9,\n    \"output\": [\n      [\n        15,\n        10\n      ],\n      [\n        -16,\n        11\n      ],\n      [\n        18,\n        -12\n      ],\n      [\n        -19,\n        -13\n      ],\n      [\n        20,\n        14\n      ],\n      [\n        -22,\n        15\n      ],\n      [\n        23,\n        -16\n      ],\n      [\n        -25,\n        -17\n      ],\n      [\n        26,\n        17\n      ],\n      [\n        -27,\n        18\n      ],\n      [\n        29,\n        -19\n      ],\n      [\n        -30,\n        -20\n      ],\n      [\n        31,\n        21\n      ],\n      [\n        -33,\n        22\n      ],\n      [\n        34,\n        -23\n      ],\n      [\n        -36,\n        -24\n      ]\n    ],\n    \"output_sha256\": \"0c3403f890fafcf4599db5cf071b81eb72eebe23833bfce67ca26a6bc158675b\",\n    \"production_Fourier_executed\": false,\n    \"production_Tile_executed\": false,\n    \"q\": 12\n  },\n  \"public_files\": 6,\n  \"source_clause_mutations\": 21,\n  \"source_clauses\": 22\n}\nCHECK Whole-file/source-clause authentication; independent full-period header, halo multiplicity, actual exponent, reciprocal upper-unit, normalizer and route invoice controls; actual T16 native/public-codec return, encoded borrowed Count preservation, volume/alias/pending-return failures and coarse erasure. No complete production Tile or Fourier replay.\nPASS_FINE_EXPANSION_PAGE_ADMISSION\n{\n  \"canonical_inputs\": 30,\n  \"claim\": \"fine-family expansion producer/page admission and declared slow-reference interface; no new kappa\",\n  \"mathematics\": {\n    \"blocks\": 7557,\n    \"certificate_domain_rejections\": 5,\n    \"clipped_blocks\": 3897,\n    \"complete_axis_layouts\": 4,\n    \"header_cases\": 4320,\n    \"literal_move_stage_invoices\": 26,\n    \"mathematical_controls\": [\n      \"short_halo\",\n      \"lost_alias_multiplicity\",\n      \"upper_floor\",\n      \"positivity_precision\",\n      \"near_unit_enclosure\",\n      \"double_forward_normalization\",\n      \"extra_restoration\"\n    ],\n    \"multiple_wrap_cases\": 4320,\n    \"near_unit_countercontrols\": 16,\n    \"normalization_budget_cases\": 240,\n    \"positive_lower_countercontrols\": 16,\n    \"quadratic_identities\": 68013,\n    \"reciprocal_unit_cases\": 768,\n    \"residue_multiplicities\": 288036\n  },\n  \"native_return\": {\n    \"J\": 3,\n    \"T\": 16,\n    \"actual_coarse_erasure\": true,\n    \"complete_prefix_executed\": false,\n    \"component_l1_projection_error\": \"3/8192\",\n    \"failures\": [\n      \"short_native\",\n      \"long_native\",\n      \"old_S_clock\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\",\n      \"native_metadata_or_work_alias\"\n    ],\n    \"old_S\": 9,\n    \"output\": [\n      [\n        15,\n        10\n      ],\n      [\n        -16,\n        11\n      ],\n      [\n        18,\n        -12\n      ],\n      [\n        -19,\n        -13\n      ],\n      [\n        20,\n        14\n      ],\n      [\n        -22,\n        15\n      ],\n      [\n        23,\n        -16\n      ],\n      [\n        -25,\n        -17\n      ],\n      [\n        26,\n        17\n      ],\n      [\n        -27,\n        18\n      ],\n      [\n        29,\n        -19\n      ],\n      [\n        -30,\n        -20\n      ],\n      [\n        31,\n        21\n      ],\n      [\n        -33,\n        22\n      ],\n      [\n        34,\n        -23\n      ],\n      [\n        -36,\n        -24\n      ]\n    ],\n    \"output_sha256\": \"0c3403f890fafcf4599db5cf071b81eb72eebe23833bfce67ca26a6bc158675b\",\n    \"production_Fourier_executed\": false,\n    \"production_Tile_executed\": false,\n    \"q\": 12\n  },\n  \"public_files\": 6,\n  \"source_clause_mutations\": 21,\n  \"source_clauses\": 22\n}\nPASS_REGISTERED_RESEARCH_PACKAGE research/fine-expansion-page-admission outcome=completed\n",
+  "stderr": ""
+}
diff --git a/research/fine-expansion-page-admission/retained/boundary_codec.py b/research/fine-expansion-page-admission/retained/boundary_codec.py
new file mode 100644
index 0000000000..5fdbd993cc
--- /dev/null
+++ b/research/fine-expansion-page-admission/retained/boundary_codec.py
@@ -0,0 +1,298 @@
+"""Finite-control common-grid/normalization bridge for two actual tape codecs.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+Payload routines use only one-symbol reads/writes and unit head motion. Unary
+format templates are prepared once; no payload integer or record counter is
+decoded by these routines. Native numerical work belongs to the named service.
+"""
+from dataclasses import dataclass
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+@dataclass(frozen=True)
+class Format:
+    external_bits: int       # one sign-magnitude real/imaginary component
+    external_grid: int
+    native_bits: int         # one little-endian two's-complement component
+    native_grid: int
+    normalizer_bits: int     # a_total = 2**normalizer_bits
+
+    def __post_init__(self):
+        values = tuple(self.__dict__.values())
+        require(all(type(x) is int for x in values), "integer format, not Boolean")
+        require(self.external_bits >= 2 and self.external_grid >= 0,
+                "positive external magnitude carrier")
+        require(self.native_grid >= self.external_grid and self.normalizer_bits >= 0,
+                "exact incoming grid lift and nonnegative dyadic normalizer")
+        require(self.native_bits >= self.external_bits + self.lift,
+                "complete native sign and lifted external magnitude")
+
+    @property
+    def lift(self):
+        return self.native_grid - self.external_grid
+
+    @property
+    def drop(self):
+        return self.native_grid + self.normalizer_bits - self.external_grid
+
+
+class Codec:
+    """Constant owned roles, shared immutable unary formats, protected output.
+
+    B is exactly the retained first-face transport module. Native tape methods
+    are those of the retained Core Tape class. Lifecycle marker operations are
+    the actual native session operations. These are source-model parameters,
+    never numerical callbacks. The online code has finite-valued local state.
+    """
+
+    def __init__(self, B, NativeTape, blank, initialize_marker, erase_marker, fmt):
+        self.B = B
+        self.blank = blank
+        self.initialize_marker = initialize_marker
+        self.erase_marker = erase_marker
+        # This input-independent setup is charged; no role is made per record.
+        self.magnitude_clock = B.Tape("bridge magnitude clock")
+        self.lift_clock = B.Tape("bridge lift clock")
+        self.pad_clock = B.Tape("bridge pad clock")
+        self.native_clock = B.Tape("bridge native clock")
+        self.drop_clock = B.Tape("bridge drop clock")
+        self.raw = B.Tape("bridge raw component")
+        self.absolute = B.Tape("bridge absolute component")
+        self.magnitude = B.Tape("bridge final magnitude")
+        self.output = B.Tape("bridge protected normalized field")
+        self.input = NativeTape()
+        erase_marker(self.input)
+        self.pending = False
+        self.active = False
+        self.input_armed = False
+        self.reconfigure(fmt)
+
+    @property
+    def templates(self):
+        return (self.magnitude_clock, self.lift_clock, self.pad_clock,
+                self.native_clock, self.drop_clock)
+
+    @property
+    def work(self):
+        return (self.raw, self.absolute, self.magnitude, self.output)
+
+    def reconfigure(self, fmt):
+        """Rebuild formats in the same roles; old visited blanks stay charged."""
+        require(not self.active and not self.pending and not self.input_armed,
+                "quiescent bridge format change")
+        lengths = (fmt.external_bits - 1, fmt.lift,
+                   fmt.native_bits - fmt.lift - fmt.external_bits + 1,
+                   fmt.native_bits, fmt.drop)
+        for tape, length in zip(self.templates, lengths):
+            self.B.clear(tape)
+            for _ in range(length):
+                self.B.append(tape, "1")
+            self.B.home(tape)
+        self.fmt = fmt
+
+    def bbit(self, tape):
+        bit = tape.read()
+        require(bit in ("0", "1"), "complete binary external component")
+        tape.move(1)
+        return bit == "1"
+
+    def cbit(self, tape):
+        bit = tape.read()
+        require(bit in (0, 1), "complete binary native component")
+        tape.step(1)
+        return bit == 1
+
+    def lift_component(self, source):
+        B = self.B
+        sign = self.bbit(source)
+        any_one = False
+        B.clear(self.raw)
+        B.home(self.magnitude_clock)
+        while self.magnitude_clock.read() == "1":
+            bit = self.bbit(source)
+            any_one = any_one or bit
+            B.append(self.raw, "1" if bit else "0")
+            self.magnitude_clock.move(1)
+        require(not sign or any_one, "canonical external zero sign")
+        B.home(self.lift_clock)
+        while self.lift_clock.read() == "1":
+            self.input.append(0)
+            self.lift_clock.move(1)
+        # raw is at its right terminator: read magnitude from least significant.
+        self.raw.move(-1)
+        carry = sign
+        while self.raw.read() != "^":
+            bit = self.raw.read() == "1"
+            bit = not bit if sign else bit
+            self.input.append(int(bit != carry))
+            carry = bit and carry
+            self.raw.move(-1)
+        B.home(self.pad_clock)
+        while self.pad_clock.read() == "1":
+            bit = sign
+            self.input.append(int(bit != carry))
+            carry = bit and carry
+            self.pad_clock.move(1)
+        B.clear(self.raw)
+
+    def prepare_input(self, source):
+        """Lift the complete immutable external stream, exactly and in order."""
+        B = self.B
+        require(not self.active and not self.pending, "idle source bridge")
+        require(source not in (*self.templates, *self.work), "external source owner")
+        self.active = True
+        self.initialize_marker(self.input)
+        self.input_armed = True
+        B.home(source)
+        try:
+            while source.read() != "!":
+                self.lift_component(source)
+                self.lift_component(source)
+                require(source.read() == "#", "one complete complex source record")
+                source.move(1)
+            self.input.rewind()
+        except BaseException:
+            self.abort()
+            raise
+        finally:
+            B.home(source)
+        return self.input
+
+    def return_component(self, returned):
+        B = self.B
+        B.clear(self.raw)
+        B.home(self.native_clock)
+        sign = False
+        while self.native_clock.read() == "1":
+            sign = self.cbit(returned)
+            B.append(self.raw, "1" if sign else "0")
+            self.native_clock.move(1)
+        # Last native bit is the sign. Absolute value is formed without decoding.
+        B.home(self.raw)
+        B.clear(self.absolute)
+        carry = sign
+        while self.raw.read() != "!":
+            bit = self.raw.read() == "1"
+            bit = not bit if sign else bit
+            B.append(self.absolute, "1" if bit != carry else "0")
+            carry = bit and carry
+            self.raw.move(1)
+        B.home(self.absolute)
+        B.home(self.drop_clock)
+        while self.drop_clock.read() == "1" and self.absolute.read() != "!":
+            self.drop_clock.move(1)
+            self.absolute.move(1)
+        B.clear(self.magnitude)
+        B.home(self.magnitude_clock)
+        any_one = False
+        while self.magnitude_clock.read() == "1":
+            bit = self.absolute.read() == "1"
+            any_one = any_one or bit
+            B.append(self.magnitude, "1" if bit else "0")
+            if self.absolute.read() != "!":
+                self.absolute.move(1)
+            self.magnitude_clock.move(1)
+        while self.absolute.read() != "!":
+            require(self.absolute.read() == "0", "normalized return fits external magnitude")
+            self.absolute.move(1)
+        B.append(self.output, "1" if sign and any_one else "0")
+        self.magnitude.move(-1)
+        while self.magnitude.read() != "^":
+            B.append(self.output, self.magnitude.read())
+            self.magnitude.move(-1)
+        for tape in (self.raw, self.absolute, self.magnitude):
+            B.clear(tape)
+
+    def prepare_return(self, returned, source):
+        """Normalize once, round toward zero, preserve input, check full count.
+
+        The unchanged original stream supplies the record clock. This avoids a
+        host record counter and checks that the native field has the same size.
+        """
+        B = self.B
+        require(self.active and not self.pending, "one active bridge input")
+        B.clear(self.output)
+        B.home(source)
+        returned.rewind()
+        try:
+            while source.read() != "!":
+                for _ in (0, 1):
+                    self.bbit(source)
+                    B.home(self.magnitude_clock)
+                    while self.magnitude_clock.read() == "1":
+                        self.bbit(source)
+                        self.magnitude_clock.move(1)
+                    self.return_component(returned)
+                require(source.read() == "#", "unchanged complete input record clock")
+                source.move(1)
+                B.append(self.output, "#")
+            require(returned.read() == self.blank, "no extra native output records")
+            B.home(self.output)
+            self.pending = True
+        except BaseException:
+            B.clear(self.output)
+            raise
+        finally:
+            B.home(source)
+            returned.rewind()
+        return self.output
+
+    def commit(self, transport):
+        """Commit only a complete normalized return after the saved-copy phase."""
+        B = self.B
+        require(self.active and self.pending and transport.phase == "saved",
+                "saved originals and complete protected Core return")
+        require(transport.source not in (*self.templates, *self.work),
+                "distinct destination source owner")
+        # No validation remains after this point: a whole sequential clone.
+        B.clone(self.output, transport.source)
+        B.home(transport.source)
+        transport.phase = "core"
+        self.abort()
+
+    def abort(self):
+        """Erase owned payloads; retained extent and immutable templates remain."""
+        B = self.B
+        if self.input_armed:
+            self.input.clear()
+            self.erase_marker(self.input)
+            self.input_armed = False
+        for tape in self.work:
+            B.clear(tape)
+        for tape in self.templates:
+            B.home(tape)
+        self.active = self.pending = False
+
+
+class BoundCore:
+    """The concrete Core run/consume protocol, without a payload callback.
+
+    `core` is the pinned OriginalCore (or the independently scoped CompleteCore
+    packed boundary); its prepared immutable source ports are `arguments`.
+    The all-size source theorem determines which boundary is being invoked.
+    """
+
+    def __init__(self, codec, core, arguments):
+        self.codec = codec
+        self.core = core
+        self.arguments = tuple(arguments)
+
+    def run(self, transport):
+        require(transport.phase == "saved", "halo copies precede actual Core")
+        succeeded = False
+        try:
+            payload = self.codec.prepare_input(transport.source)
+            returned = self.core.run(payload, *self.arguments)
+            self.codec.prepare_return(returned, transport.source)
+            self.core.consume()
+            self.codec.commit(transport)
+            succeeded = True
+        finally:
+            if getattr(self.core, "pending", False):
+                self.core.consume()
+            if not succeeded:
+                self.codec.abort()
diff --git a/research/fine-expansion-page-admission/retained/caller-PROOF.md b/research/fine-expansion-page-admission/retained/caller-PROOF.md
new file mode 100644
index 0000000000..08a808b09c
--- /dev/null
+++ b/research/fine-expansion-page-admission/retained/caller-PROOF.md
@@ -0,0 +1,288 @@
+# The retained recovery catalogue does not admit the fine-theta port
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+This is a source-bound obstruction and replacement-interface specification.
+It changes no implementation, selected certificate, supplier or kappa.
+
+## 1. Sources, notation and scope
+
+The canonical source pin is `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+`SOURCES.json` authenticates every live input. The public gap proof is pinned
+at `9a07c08c014259bb23c0a2b5844a1b67d91892f6`; the actual Reference-to-ideal
+compression join is pinned at `4509310a9a58d4c41c74029f899cbf36be1af9a1`.
+Their retained proofs are authenticated by `DEPENDENCIES.json`.
+
+Write **p0** for the parameter called `p` in
+`research/unconditional-batched-crt/PROOF.md` and `GAUSSIAN.md`. Its family has
+
+    p0=6b, b=ceil(log2 n), D=Theta(p0^epsilon), epsilon=1-10^-30,
+    1/(4p0^2)<=theta_i=(t_i-s_i)/s_i<=1/p0^2,
+    alpha=ceil(sqrt((4/pi)ln(16p0))), u=alpha^2,
+    T/2<S=product s_i<T, 4n/b<=T<8n/b.                  (1)
+
+Write **q** for the old Tensor's *external* precision `TensorPlan.p`.
+This is not its private working-grid field `TensorPlan.P`, nor the radix
+digit count also named `q` in `Sandwich.run`. Denote that digit count by Q.
+The old spacing variable is **d_sep**=`TensorPlan.d`; the axis count is
+**D**=`TensorPlan.dimensions`. Literal source ties d_sep=D+1.
+All logarithms marked `log2` are binary; `ln` is natural.
+
+Three increasingly permissive domains are considered separately:
+
+1. The unchanged constructor/catalogue/recovery chain at the fine family.
+2. A hypothetical relaxation allowing d_sep to vary independently of D,
+   but retaining the fine family's alpha and three necessary old guards.
+3. A further relaxation allowing alpha (hence u) to change, still retaining
+   those guards and the old external fixed-record representation.
+
+The second and third are necessary-condition superdomains, not implemented
+ports or asserted feasible production families. Rejection of the first
+does not execute its later ingress; the scan lower bound in Section 6 is
+conditional on a hypothetical successful relaxed port retaining that ABI.
+
+## 2. Exact caller binding
+
+The relevant unchanged files are:
+
+| File | Actual obligation |
+| --- | --- |
+| `physical-tensor-crt-sandwich-recovery/sandwich.py` | `run` creates `Catalogue` before numerical work; its default recovery policy calls `admit`; `admit` requires nonzero production mode |
+| `physical-gaussian-tensor/tensor_catalogue.py` | reconstructs `TensorPlan(..., production=not header.mode.zero())` from the encoded catalogue |
+| `physical-gaussian-tensor/tensor_plan.py` | loads `dimensions=axes+1`, `d=dimensions+1`, `u=alpha^2`; executes `production_axis` for each source axis and `production_common` in production mode |
+| `arbitrary-bit-sandwich/boundary.py` | calls `child.run` without disabling its default recovery policy |
+
+The necessary production inequalities are literally
+
+    4 d_sep (t_i-s_i) > s_i,                            (2)
+    u >= ceil(log2(8q)),                               (3)
+    u d_sep <= q.                                      (4)
+
+Equation (2) is `production_axis`'s strict lower ratio. Equations (3),(4)
+are `production_common`'s logarithmic concentration and similarity guards.
+The additional upper ratio `(2d_sep-1)(t_i-s_i)<s_i`, paired-halo period,
+exact common Gaussian policy, cell separation, padding, chirp and restored
+error guards all remain required. We need not weaken them or claim their
+sufficiency. In particular changing a header to diagnostic mode cannot
+meet `Sandwich.admit`'s production-mode requirement.
+
+The complete source files and required AST sites are checked; no extracted
+constructor is executed with substituted Count/Tape objects. Correctness of
+the retained Count primitives is inherited. This is a mathematical audit
+of the actual encoded contract, not a physical execution of a production
+catalogue.
+
+## 3. Literal dimension binding excludes the port
+
+At an axis from (1), (2) implies
+
+    1 < 4(D+1)theta_i <= 4(D+1)/p0^2.                  (5)
+
+Choose an eventual upper constant C_D with D<=C_D p0^epsilon. Since
+epsilon<1 and p0>=1, the last expression is at most
+`4(C_D+1)/p0`. It is <=1/2 once `p0>=8(C_D+1)` and the bound on D is in
+force. Thus every fine axis fails (2) eventually, irrespective of q or
+alpha. The literal caller has no production recovery admission on that
+eventual family.
+
+This qualitative old-band/fine-band incompatibility is prior knowledge:
+`pr1786-fine-prime-transfer-audit` already includes an old theta~1/d
+guard as a failing control, and #4029/#4142 already read d=D+1. Our new
+claim is the complete encoded recovery binding and the stronger nested
+consequences below, not discovery of that generic band mismatch.
+
+## 4. Even independent spacing cannot keep the fine alpha
+
+Now allow d_sep to be arbitrary, which strictly relaxes the literal source.
+For any fine axis (2) and theta_i<=p0^-2 imply
+
+    d_sep > p0^2/4,
+    q >= u d_sep > u p0^2/4 >= p0^2/4.                 (6)
+
+Here u is a positive integer, as in the source. On the other hand (3) gives
+
+    8q <= 2^u.                                        (7)
+
+For the actual fine alpha, the public gap proof gives
+`pi*u<=5ln(16p0)` for p0>=2^200. For completeness this loose explicit onset
+needs only elementary inequalities. Put L=ln(16p0). Since ln2>1/2,
+L>100. The ceiling definition and 3<pi<4 imply
+
+    pi*u <= 4L+4sqrt(pi L)+pi
+          < 4L+8sqrt(L)+4 <= 5L.
+
+The last inequality holds for L>=100 by putting x=sqrt(L)>=10 in
+`x^2-8x-4>=16`. Also ln2<3/4, since the positive exponential series gives
+`exp(3/4)>1+3/4+9/32+27/384>2`. Hence
+
+    2^u <= exp((5/3)ln2*ln(16p0))
+         < (16p0)^(5/4)=32 p0^(5/4),
+    q < 4 p0^(5/4).                                   (8)
+
+For p0>=64, `p0^2/4>4p0^(5/4)` (equivalently p0^3>2^16).
+Equations (6) and (8) contradict one another. Therefore:
+
+**For p0>=2^200, no external precision q and no independently chosen
+positive spacing d_sep can satisfy (2)--(4) with the actual fine alpha.**
+
+This is an all-q exclusion, not merely a failure at q=p0 or a finite search.
+Increasing the private working precision P does not change (2)--(4).
+The onset is for this alpha estimate and refusal only; it is not an onset
+for legal global periods, primes, Core geometry or the complete multiplier.
+
+## 5. Retuning alpha still forces an external precision lower bound
+
+Relax alpha as well, keeping u positive and (2)--(4). Equations (3),(6)
+give
+
+    q > (p0^2/4) log2(8q).
+
+Because q>p0^2/4, `log2(8q)>1+2log2(p0)`. Consequently every element of
+this enlarged necessary-condition domain obeys the strict bound
+
+    q > (p0^2/4)(1+2log2(p0))
+      = Omega(p0^2 log p0).                            (9)
+
+This does not assert that any point satisfying (9) meets the other old
+guards, the original dimension binding, or any source accuracy premise.
+It states what every successful relaxation retaining these three guards
+would have to pay. In particular no q=O(p0) schedule suffices there.
+The private coefficient/setup precision O(p0^2 log p0) of the *new* fine
+Reference is a different quantity; no setup bit is being mislabeled as a
+runtime record bit in (9).
+
+## 6. The external width has an actual full-volume scan bill
+
+`TensorPlan` sets `component_bits=q+2` and `record_bits=2(q+2)`.
+`Sandwich.ingress` iterates over every original coordinate in `source_product=S`.
+At each it writes a real signed component and an imaginary zero, including
+the S-Q padded zero records. `ring_words.write_signed` calls `write_fixed`
+in both sign branches; `compact_counts.write_fixed` appends exactly its
+declared width, including leading zeroes. Thus one ingress writes exactly
+
+    2S(q+2) payload cells, and the two ingresses write 4S(q+2).       (10)
+
+The full retained parent bank occupies Omega(Sq) cells. Reads, rewinds,
+return copies, erasure, metadata, source tables, CRT, scalar products and
+the three complete Tensor calls add work; none can cancel these appends.
+This lower bound does not require or discount any supplier cost.
+
+Using the fine-family volume S=Theta(n/p0) from (1), (9)--(10) imply
+
+    Omega(Sq)=Omega(n p0 log p0)
+              =Omega(n log n log log n).               (11)
+
+For any fixed kappa>=0 this exceeds the intended
+`O(n (log n)^(1-kappa))` budget. Again (11) is the consequence for a
+hypothetical successful port preserving the named necessary guards and
+literal ingress representation after relaxing d_sep and alpha. The
+unchanged literal caller already rejects; we do not charge nonexistent
+post-rejection execution. Packing, a new admission policy or a different
+caller can evade this scoped obstruction and must be analyzed separately.
+
+## 7. Numerical recovery is a separate gate, with two source S factors
+
+This section restates the retained caller's conditional recovery interface;
+it is not a new convolution theorem. Let A be its actual `outer_bits`,
+M=2^A, and let its own source gamma and E be
+
+    gamma=D(2u+ceil(log2(32q))+1),
+    E=Dq^2+6M+22+2D, epsilon=E*2^(gamma-q).
+
+`Sandwich.admit` evaluates exactly
+
+    2^(2b+5) S^2 (3E 2^gamma+2) < 2^q.                (12)
+
+It also requires production mode, so a passing (12) cannot waive
+(2)--(4). #5325 improves a conditional restored Tensor error estimate;
+its proof explicitly retains all production requirements and cannot waive
+these guards either. A small exact descriptor control in our checker passes
+(12) while failing (2); it is not an admitted production invocation.
+
+For the ideal source maps `R F_s` and `R F_s^+`, with the source's
+multiplicative-index permutation R, the opposite sandwich is
+`(u_input *cyclic v_input)/S^2`. Ingress scaled each digit by 2^-(b+2).
+The literal recovery routine therefore performs two exact multiplications
+by S and one exact shift by 2b+4, then nearest integer. Its temporary width
+is `(q+2)+4b+4`, as in #5095; S<2^b and q>=b+2 keep it O(q).
+
+More generally, a replacement complete transform service on every reached
+half-disk input with coefficient error <epsilon, including its actual final
+normalization restoration, supplies the existing sufficient condition
+
+    S^2 2^(2b+4) (3epsilon+2^(1-q)) < 1/2.             (13)
+
+Retained contraction/radius reasoning makes the rounded pointwise product
+an admitted input to the opposite service; its component truncation error
+is <sqrt(2)2^-q<2^(1-q). This explains both S factors, the strict half
+threshold, and why a per-transform gamma cannot be silently omitted or
+counted a second time after a service has already restored it. The exact
+integer/CRT controls test these algebraic mistakes without pretending to
+execute Fourier or Gaussian code.
+
+## 8. Required replacement interface and remaining obligations
+
+The public Reference/ideal join proves the source-bound *compression*
+comparison under its explicit radius, source-first target and producer
+contracts. It does not provide a new `TensorPlan`, full prefix, Fourier
+service, production catalogue or end-to-end recovery admission. In
+particular the old gamma formula above is not automatically the new
+group-normalizer ledger's gamma.
+
+A useful next join must replace the literal old policy and authenticate an
+actual fine-family catalogue. It must bind original axes/holes, encoded
+coefficient/reference delivery, original-coordinate Core/halo/diagonal
+services, and a complete expansion/chirp prefix to the new error ledger.
+Let Gamma be the *actual total existing* normalization exponent of that
+replacement and C_N its exact normalized compression on the padded field.
+If a computed prefix yhat and exact prefix y obey the public compression
+radius contracts, and the restored compression implementation has error
+<=2^-tau on yhat, then the missing source-specific prefix bound gives
+
+    ||output-2^Gamma C_N y||
+      <=2^-tau+2^Gamma ||C_N|| ||yhat-y||+e_extra.       (14)
+
+Use the public join's maximum-coordinate component-l1 norm in (14).
+A complex-modulus prefix radius or error must be multiplied by at most
+sqrt(2) before entering that norm; a resulting component-l1 error already
+bounds the complex-modulus error required by (13). Only the exact C_N is
+used as a linear operator in (14); no rounded-map contraction is assumed.
+Here e_extra explicitly covers any new entrance/output codec or restoration
+rounding; exact paid dyadic restoration contributes zero. The public policy
+can bound the normalized C_N and Gamma=O(D log p0)=o(p0), but it does not
+supply the actual prefix error in (14). Before using (13), that error,
+radius and full source/route/setup cost must be proved for all reached
+inputs, and the target must be the full `R F_s` or opposite map. A standalone
+compression bound must not be labeled a complete transform error.
+
+The desired new policy may retain external q=O(p0); Sections 3--6 show
+why doing so requires replacing an old admission clause or the caller,
+rather than merely raising its numeric precision. No claim of an
+unconditional multiplication theorem, new full kappa, general impossibility,
+or defect in the current selected conditional theorem follows.
+
+## 9. Novelty, evidence and costs
+
+`OVERLAP.md` records the bounded predecessor audit. In particular #4142
+already extracts the lower ratio and d=D+1; #3861 settles a finite old-domain
+precision gap; #5149/#6444 improve the old prime band; the pr1786 audit
+already rejects old-theta transfer; #5095 supplies this exact recovery
+caller and two-S guard; #5325 joins older Tensor errors; #6185 adds a paid
+arbitrary-bit wrapper but retains production admission. We claim the
+specific combined refusal, all-q strengthening, relaxed-width/full-ingress
+consequence and resulting replacement obligation above.
+
+The universal arguments are Sections 3--6. The replay authenticates whole
+source files, checks exact AST sites, exhausts a bounded integer necessary
+domain, checks large dyadic-parameter inequalities using integers, and
+exercises a separate rational CRT/convolution/rounding oracle. Mutation and
+boundary controls detect missing strictness, concentration, similarity,
+source-field width, gamma and either S factor. The replay performs no actual
+Tensor/CRT/Count/Tape run and imports no predecessor verifier. Counts and
+stopping bounds are reported in `evidence/REPLAY.json`; finite coverage is
+corroboration, not the all-size proof.
+
+The audit adds no runtime algorithm or amortized setup claim. The lower
+bound (10) charges only unavoidable writes; all inherited producer, private
+precision, routing, scalar arithmetic, copy, restoration and erasure costs
+remain additional. This work does not require a large native replay to
+establish failure of necessary admission conditions.
diff --git a/research/fine-expansion-page-admission/retained/halo_tapes.py b/research/fine-expansion-page-admission/retained/halo_tapes.py
new file mode 100644
index 0000000000..b3dfa43ba0
--- /dev/null
+++ b/research/fine-expansion-page-admission/retained/halo_tapes.py
@@ -0,0 +1,644 @@
+"""Sequential bit-tape halo transport; no numerical halo solver is hidden here.
+
+Only Tape's simulator backend uses positions or random-access storage.  Program
+methods observe one symbol, write one symbol, or move one cell.  Python locals
+in those methods range over finite alphabets/booleans, except fixed tape handles.
+Fixture construction, inspection, and instrumentation are outside the machine.
+"""
+
+from collections import Counter
+
+
+class Reject(ValueError):
+    pass
+
+
+class Tape:
+    """Simulator backend. Erased cells still count toward retained backing."""
+
+    def __init__(self, name, contents=""):
+        self.name = name
+        self._cells = dict(enumerate("^" + contents + "!"))
+        self._head = 0
+        self._high = len(contents) + 1
+        self.actions = Counter()
+
+    def read(self):
+        self.actions["read"] += 1
+        return self._cells.get(self._head, "_")
+
+    def write(self, symbol):
+        if len(symbol) != 1:
+            raise Reject("non-symbol write")
+        self.actions["write"] += 1
+        self._cells[self._head] = symbol
+        self._high = max(self._high, self._head)
+
+    def move(self, direction):
+        if direction not in (-1, 1):
+            raise Reject("nonunit head move")
+        self.actions["move"] += 1
+        self._head += direction
+        if self._head < 0:
+            raise Reject("crossed left sentinel")
+        self._high = max(self._high, self._head)
+
+    def inspect(self):
+        """Unmetered *test observer*: never called by Program or its helpers."""
+        chars = []
+        pos = 1
+        while self._cells.get(pos) != "!":
+            chars.append(self._cells.get(pos, "_"))
+            pos += 1
+            if pos > self._high:
+                raise Reject("observer found no terminator")
+        return "".join(chars)
+
+    def bill(self):
+        return {**self.actions, "retained_cells": self._high + 1}
+
+
+def home(t):
+    while t.read() != "^":
+        t.move(-1)
+    t.move(1)
+
+
+def end(t):
+    while t.read() != "!":
+        t.move(1)
+
+
+def append(t, ch):
+    # Caller owns the right-end head. No length or append index is available.
+    t.write(ch)
+    t.move(1)
+    t.write("!")
+
+
+def clear(t):
+    home(t)
+    while t.read() != "!":
+        t.write("_")
+        t.move(1)
+    t.write("_")
+    home(t)
+    t.write("!")
+
+
+def copy_bits(src, dst):
+    while src.read() in "01":
+        append(dst, src.read())
+        src.move(1)
+
+
+def copy_whole(src, dst):
+    home(src)
+    while src.read() != "!":
+        append(dst, src.read())
+        src.move(1)
+
+
+def clone(src, dst):
+    clear(dst)
+    copy_whole(src, dst)
+
+
+def skip_to(t, ch):
+    while t.read() != ch:
+        if t.read() == "!":
+            raise Reject("missing field delimiter")
+        t.move(1)
+
+
+def compare(a, b):
+    """Equal-width unsigned binary comparison; result is a three-state value."""
+    home(a)
+    home(b)
+    relation = "equal"
+    while a.read() != "!":
+        if b.read() not in "01" or a.read() not in "01":
+            raise Reject("unequal or malformed comparison fields")
+        if relation == "equal":
+            if a.read() == "0" and b.read() == "1":
+                relation = "less"
+            elif a.read() == "1" and b.read() == "0":
+                relation = "greater"
+        a.move(1)
+        b.move(1)
+    if b.read() != "!":
+        raise Reject("unequal comparison widths")
+    return relation
+
+
+def add_mod(a, b, subtract=False):
+    """Binary ripple addition/subtraction, truncated to the common field width."""
+    home(a)
+    end(a)
+    home(b)
+    end(b)
+    a.move(-1)
+    b.move(-1)
+    carry = subtract
+    while a.read() != "^":
+        x = a.read() == "1"
+        y = b.read() == "1"
+        if b.read() not in "01":
+            raise Reject("unequal arithmetic widths")
+        if subtract:
+            y = not y
+        a.write("1" if x ^ y ^ carry else "0")
+        carry = (x and y) or (carry and (x or y))
+        a.move(-1)
+        b.move(-1)
+    if b.read() != "^":
+        raise Reject("unequal arithmetic widths")
+
+
+def step_binary(t, down=False):
+    """Modulo 2**width increment/decrement of a plain binary field."""
+    home(t)
+    end(t)
+    t.move(-1)
+    while t.read() != "^":
+        old = t.read()
+        t.write("0" if old == "1" else "1")
+        if (old == "1") == down:
+            return
+        t.move(-1)
+
+
+def coordinate_next(t):
+    """Increment concatenated coordinate bits, skipping only schema delimiters."""
+    home(t)
+    end(t)
+    t.move(-1)
+    carrying = True
+    while t.read() != "^":
+        if t.read() in "01" and carrying:
+            if t.read() == "0":
+                t.write("1")
+                carrying = False
+            else:
+                t.write("0")
+        t.move(-1)
+    return not carrying
+
+
+def flatten(t, dst):
+    clear(dst)
+    home(t)
+    while t.read() != "!":
+        if t.read() in "01":
+            append(dst, t.read())
+        t.move(1)
+
+
+class Program:
+    """A fixed collection of tape roles, independent of dimension or volume."""
+
+    def __init__(self, source, coordinates, length, width_a, width_b, returns=""):
+        # Loading caller-supplied binary inputs is outside the program's bill;
+        # their cells are included in retained backing from the beginning.
+        self.source = Tape("source", source)
+        self.x = Tape("coordinates", coordinates)
+        self.L = Tape("L", length)
+        self.A = Tape("A", width_a)
+        self.b = Tape("b", width_b)
+        self.returns = Tape("returns", returns)
+        self.saved = Tape("saved")
+        self.final = Tape("final")
+        self.d = Tape("descriptor")
+        self.faces = Tape("faces")
+        self.unary = Tape("axis_index")
+        self.q = Tape("core_field")
+        self.r = Tape("local_field")
+        self.payload = Tape("payload")
+        self.kcore = Tape("key_core")
+        self.kface = Tape("key_face")
+        self.klocal = Tape("key_local")
+        self.ksource = Tape("key_source")
+        self.retkey = Tape("return_key")
+        self.retval = Tape("return_value")
+        self.bucket0 = Tape("radix_zero")
+        self.bucket1 = Tape("radix_one")
+        self.record = Tape("radix_record")
+        self.passes = Tape("radix_passes")
+        self.Am = Tape("A_minus_b")
+        self.Ap = Tape("A_plus_b")
+        self.LAm = Tape("L_minus_A_minus_b")
+        self.LAp = Tape("L_minus_A_plus_b")
+        self.Lb = Tape("L_minus_b")
+        self.LA = Tape("L_minus_A")
+        # This tuple is a fixed schema, never sized using input data.
+        self.roles = (
+            self.source, self.x, self.L, self.A, self.b, self.returns,
+            self.saved, self.final, self.d, self.faces, self.unary, self.q,
+            self.r, self.payload, self.kcore, self.kface, self.klocal,
+            self.ksource, self.retkey, self.retval, self.bucket0, self.bucket1,
+            self.record, self.passes, self.Am, self.Ap, self.LAm, self.LAp,
+            self.Lb, self.LA,
+        )
+        self.phase = "input"
+
+    def setup(self):
+        clone(self.A, self.Am)
+        add_mod(self.Am, self.b, subtract=True)
+        clone(self.A, self.Ap)
+        add_mod(self.Ap, self.b)
+        clone(self.L, self.LA)
+        add_mod(self.LA, self.A, subtract=True)
+        clone(self.LA, self.LAm)
+        add_mod(self.LAm, self.b, subtract=True)
+        clone(self.LA, self.LAp)
+        add_mod(self.LAp, self.b)
+        clone(self.L, self.Lb)
+        add_mod(self.Lb, self.b, subtract=True)
+
+    def load_payload(self, source, dest):
+        clear(dest)
+        copy_bits(source, dest)
+        if source.read() != "#":
+            raise Reject("bad payload delimiter")
+        source.move(1)
+
+    def face_record(self, side):
+        home(self.unary)
+        copy_bits(self.unary, self.faces)
+        append(self.faces, "0")
+        append(self.faces, side)
+        append(self.faces, "#")
+
+    def build_descriptor(self):
+        clear(self.d)
+        clear(self.faces)
+        clear(self.unary)
+        clear(self.ksource)
+        home(self.x)
+        while self.x.read() != "&":
+            append(self.d, self.x.read())
+            append(self.ksource, self.x.read())
+            self.x.move(1)
+        append(self.d, "&")
+        self.x.move(1)
+        prefix = True
+        while self.x.read() != "!":
+            if self.x.read() != "@":
+                raise Reject("bad coordinate schema")
+            append(self.d, "@")
+            self.x.move(1)
+            while self.x.read() != "#":
+                append(self.d, self.x.read())
+                append(self.ksource, self.x.read())
+                self.x.move(1)
+            append(self.d, "#")
+            self.x.move(1)
+            clear(self.r)
+            append(self.r, "0")
+            append(self.r, "0")
+            while self.x.read() != ";":
+                append(self.r, self.x.read())
+                append(self.ksource, self.x.read())
+                self.x.move(1)
+            self.x.move(1)
+            copy_whole(self.r, self.d)
+            append(self.d, "#")
+            interior = compare(self.r, self.Am) != "less"
+            interior = interior and compare(self.r, self.LAp) == "less"
+            low = compare(self.r, self.b) == "less"
+            high = compare(self.r, self.Lb) != "less"
+            lower = compare(self.r, self.Ap) == "less"
+            upper = compare(self.r, self.LAm) != "less"
+            append(self.d, "1" if interior else "0")
+            append(self.d, "1" if low else "0")
+            append(self.d, "1" if high else "0")
+            append(self.d, "1" if lower else "0")
+            append(self.d, "1" if upper else "0")
+            append(self.d, "e" if low or high else "n")
+            append(self.d, "0")
+            append(self.d, ";")
+            if prefix and (lower or high):
+                self.face_record("0")
+            if prefix and (upper or low):
+                self.face_record("1")
+            prefix = prefix and interior
+            end(self.unary)
+            append(self.unary, "1")
+
+    def prepare_face(self):
+        # Reset old face and suffix choices; all scans are through tape cells.
+        home(self.d)
+        skip_to(self.d, "&")
+        self.d.move(1)
+        while self.d.read() != "!":
+            self.d.write("@")
+            skip_to(self.d, "#")
+            self.d.move(1)
+            skip_to(self.d, "#")
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            if self.d.read() == "*":
+                self.d.write("e")
+            self.d.move(1)
+            self.d.write("0")
+            self.d.move(1)
+            self.d.move(1)
+        home(self.d)
+        skip_to(self.d, "&")
+        self.d.move(1)
+        while self.faces.read() == "1":
+            skip_to(self.d, ";")
+            self.d.move(1)
+            self.faces.move(1)
+        if self.faces.read() != "0":
+            raise Reject("bad face index")
+        self.faces.move(1)
+        self.d.write("<" if self.faces.read() == "0" else ">")
+        self.faces.move(1)
+        if self.faces.read() != "#":
+            raise Reject("bad face delimiter")
+        self.faces.move(1)
+        skip_to(self.d, ";")
+        self.d.move(1)
+        while self.d.read() != "!":
+            skip_to(self.d, ";")
+            self.d.move(-1)
+            self.d.move(-1)
+            if self.d.read() == "e":
+                self.d.write("*")
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+
+    def next_choice(self):
+        home(self.d)
+        end(self.d)
+        self.d.move(-1)
+        while self.d.read() != "^":
+            if self.d.read() == "*":
+                self.d.move(1)
+                if self.d.read() == "0":
+                    self.d.write("1")
+                    return True
+                self.d.write("0")
+                self.d.move(-1)
+            self.d.move(-1)
+        return False
+
+    def emit(self):
+        clear(self.kcore)
+        clear(self.kface)
+        clear(self.klocal)
+        home(self.d)
+        while self.d.read() != "&":
+            append(self.kcore, self.d.read())
+            self.d.move(1)
+        self.d.move(1)
+        after = False
+        side = "0"
+        while self.d.read() != "!":
+            marker = self.d.read()
+            self.d.move(1)
+            clear(self.q)
+            copy_bits(self.d, self.q)
+            self.d.move(1)
+            clear(self.r)
+            copy_bits(self.d, self.r)
+            self.d.move(1)
+            self.d.move(1)  # interior flag
+            low = self.d.read() == "1"
+            self.d.move(1)
+            high = self.d.read() == "1"
+            self.d.move(1)
+            lower = self.d.read() == "1"
+            self.d.move(1)
+            upper = self.d.read() == "1"
+            self.d.move(1)  # eligibility
+            self.d.move(1)
+            alternative = self.d.read() == "1"
+            self.d.move(1)
+            self.d.move(1)
+            if marker == "<":
+                side = "0"
+                append(self.kface, "1")
+                add_mod(self.r, self.b)
+                if not lower:
+                    if not high:
+                        raise Reject("inadmissible lower face")
+                    step_binary(self.q)
+                    add_mod(self.r, self.L, subtract=True)
+                after = True
+            elif marker == ">":
+                side = "1"
+                append(self.kface, "1")
+                add_mod(self.r, self.Ap)
+                if upper:
+                    add_mod(self.r, self.L, subtract=True)
+                else:
+                    if not low:
+                        raise Reject("inadmissible upper face")
+                    step_binary(self.q, down=True)
+                after = True
+            elif not after:
+                append(self.kface, "0")
+                add_mod(self.r, self.Am, subtract=True)
+            else:
+                append(self.kface, "0")
+                add_mod(self.r, self.b)
+                if alternative:
+                    if low:
+                        step_binary(self.q, down=True)
+                        add_mod(self.r, self.L)
+                    elif high:
+                        step_binary(self.q)
+                        add_mod(self.r, self.L, subtract=True)
+                    else:
+                        raise Reject("inadmissible suffix alternative")
+            copy_whole(self.q, self.kcore)
+            copy_whole(self.r, self.klocal)
+        append(self.kface, side)
+        copy_whole(self.kcore, self.saved)
+        copy_whole(self.kface, self.saved)
+        copy_whole(self.klocal, self.saved)
+        copy_whole(self.ksource, self.saved)
+        append(self.saved, "#")
+        copy_whole(self.payload, self.saved)
+        append(self.saved, "#")
+
+    def gather(self):
+        if self.phase != "input":
+            raise Reject("gather must precede every core mutation")
+        self.setup()
+        home(self.source)
+        end(self.saved)
+        more = True
+        while self.source.read() != "!":
+            if not more:
+                raise Reject("more payloads than coordinates")
+            self.load_payload(self.source, self.payload)
+            self.build_descriptor()
+            home(self.faces)
+            while self.faces.read() != "!":
+                self.prepare_face()
+                self.emit()
+                while self.next_choice():
+                    self.emit()
+            more = coordinate_next(self.x)
+        if more:
+            raise Reject("fewer payloads than coordinates")
+        self.phase = "saved"
+
+    def sort(self, tape, reverse_buckets=False):
+        """Stable binary LSD radix; rotate keys to expose each next digit.
+
+        A unary pass clock is copied from the first key on tape. After exactly
+        that many right rotations, the complete key is restored. No host key
+        length, pass index, record array, integer key, or comparison sort occurs.
+        """
+        clear(self.passes)
+        home(tape)
+        if tape.read() == "!":
+            return
+        while tape.read() in "01":
+            append(self.passes, "1")
+            tape.move(1)
+        if tape.read() != "#":
+            raise Reject("bad radix key")
+        home(self.passes)
+        while self.passes.read() == "1":
+            clear(self.bucket0)
+            clear(self.bucket1)
+            home(tape)
+            while tape.read() != "!":
+                clear(self.record)
+                last = "0"
+                while tape.read() in "01":
+                    last = tape.read()
+                    append(self.record, last)
+                    tape.move(1)
+                if tape.read() != "#":
+                    raise Reject("bad radix key delimiter")
+                append(self.record, "#")
+                tape.move(1)
+                copy_bits(tape, self.record)
+                if tape.read() != "#":
+                    raise Reject("bad radix payload delimiter")
+                append(self.record, "#")
+                tape.move(1)
+                target = self.bucket0 if last == "0" else self.bucket1
+                append(target, last)
+                home(self.record)
+                previous = self.record.read()
+                self.record.move(1)
+                while self.record.read() != "#":
+                    append(target, previous)
+                    previous = self.record.read()
+                    self.record.move(1)
+                append(target, "#")
+                self.record.move(1)
+                copy_bits(self.record, target)
+                append(target, "#")
+            clear(tape)
+            if reverse_buckets:
+                copy_whole(self.bucket1, tape)
+                copy_whole(self.bucket0, tape)
+            else:
+                copy_whole(self.bucket0, tape)
+                copy_whole(self.bucket1, tape)
+            self.passes.write("0")
+            self.passes.move(1)
+        clear(self.bucket0)
+        clear(self.bucket1)
+        clear(self.record)
+        clear(self.passes)
+
+    def core_complement_test_double(self):
+        """Physical mutation for chronology controls; not a Gaussian core."""
+        if self.phase != "saved":
+            raise Reject("core mutation before copies are complete")
+        home(self.source)
+        while self.source.read() != "!":
+            if self.source.read() == "0":
+                self.source.write("1")
+            elif self.source.read() == "1":
+                self.source.write("0")
+            self.source.move(1)
+        self.phase = "core"
+
+    def pending_return(self):
+        if self.returns.read() == "!":
+            clear(self.retkey)
+            clear(self.retval)
+            return False
+        self.load_payload(self.returns, self.retkey)
+        self.load_payload(self.returns, self.retval)
+        return True
+
+    def discarded(self):
+        home(self.x)
+        skip_to(self.x, "&")
+        self.x.move(1)
+        boundary = False
+        while self.x.read() != "!":
+            skip_to(self.x, "#")
+            self.x.move(1)
+            clear(self.r)
+            append(self.r, "0")
+            append(self.r, "0")
+            copy_bits(self.x, self.r)
+            if compare(self.r, self.A) == "less":
+                boundary = True
+            if compare(self.r, self.LA) != "less":
+                boundary = True
+            if self.x.read() != ";":
+                raise Reject("bad coordinate local field")
+            self.x.move(1)
+        return boundary
+
+    def merge_returns(self):
+        if self.phase != "core":
+            raise Reject("return requires completed core phase")
+        self.sort(self.returns)
+        home(self.returns)
+        pending = self.pending_return()
+        home(self.source)
+        clear(self.final)
+        more = True
+        while self.source.read() != "!":
+            if not more:
+                raise Reject("more core values than coordinates")
+            self.load_payload(self.source, self.payload)
+            flatten(self.x, self.ksource)
+            boundary = self.discarded()
+            relation = compare(self.retkey, self.ksource) if pending else "none"
+            if boundary:
+                if relation != "equal":
+                    raise Reject("missing, duplicate, or misplaced boundary return")
+                copy_whole(self.retval, self.final)
+                pending = self.pending_return()
+            else:
+                if pending and relation != "greater":
+                    raise Reject("duplicate or kept-row return")
+                copy_whole(self.payload, self.final)
+            append(self.final, "#")
+            more = coordinate_next(self.x)
+        if more or pending:
+            raise Reject("incomplete source cube or extra return")
+        self.phase = "returned"
+
+    def erase_work(self):
+        if self.phase != "returned":
+            raise Reject("erase before return completion")
+        # Roles remain allocated. The ledger deliberately does not reset peaks.
+        for tape in self.roles:
+            if tape is not self.final:
+                clear(tape)
+        self.phase = "erased"
+
+    def ledger(self):
+        """Observer, not part of the machine."""
+        return {tape.name: tape.bill() for tape in self.roles}
diff --git a/research/fine-expansion-page-admission/retained/ledger-PROOF.md b/research/fine-expansion-page-admission/retained/ledger-PROOF.md
new file mode 100644
index 0000000000..3e580dee35
--- /dev/null
+++ b/research/fine-expansion-page-admission/retained/ledger-PROOF.md
@@ -0,0 +1,321 @@
+# Spend the existing Gaussian normalizer once
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+**Conditional source-interface lemma; no new kappa.** Canonical base:
+`7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+
+## 1. Actual boundary, predecessor work and the two scale policies
+
+The current complete-Core / first-face bridge returns, on one actual original
+field, a rounded approximation to
+
+`B_j = tensor_(i in G_j) (H_i^-1 / 2^u_i)`,
+
+where the real rational H_i are the same immutable augmented narrow References
+on both sides of the splice. Put `U_j=sum_(i in G_j) u_i` and `U=sum_j U_j`.
+The admitted real row-gap bound gives `||H_i^-1||_infinity<=1/delta_i`.
+Because H_i is real, the same absolute row sums bound the component-l1
+supremum norm. Consequently
+`||B_j||_*<=product_(i in G_j)(2^-u_i/delta_i)<=1`.
+The bridge's single final truncation is on the common component grid 2^-q.
+Its exact source, whole-field radius and error contracts are retained at
+[public commit 73d5adab](https://github.com/CubeJerry/integer-mult-bounds/tree/73d5adaba2b7dc662e86eb901e81369a3f73be9f/research/core-halo-source-bridge).
+This package retains its unchanged allocation function and proof. The complete
+Core numerical contract is the cited premise at
+[6fb9ab77](https://github.com/CubeJerry/integer-mult-bounds/blob/6fb9ab776b7d0956b8bcc2d3cfde0f3034421630/research/complete-core-physical-join/NUMERICS.md).
+
+The canonical `unconditional-batched-crt/PROOF.md`, under "Exact Gaussian and
+source-transform identity", defines
+
+`(Cv)_j=v_(q_j)`, `D_jj=exp(pi alpha^2 beta_j^2)`, `N=C T_gauss D`,
+`P_s F_s = D N^-1 C P_t F_t S_gauss`.
+
+It already normalizes **completed** S_gauss and D N^-1 C maps by dyadic powers
+of p and restores their accumulated exponent gamma. The same package's
+GAUSSIAN.md specifies a sufficient dyadic p^100 bound per completed axis and
+combines normalizers within group diagonals. Its proof claims are provenance,
+not accepted here as an unconditional multiplier. In particular, we retain
+the source comparison H versus ideal N, coefficient preparation and physical
+execution as premises.
+
+Let K_j be the already-declared compression normalizer exponent for group j.
+On the padded target grid let Dtilde_i equal the actual D diagonal at selected
+addresses and equal 1 at holes. Final extraction C drops holes and has norm
+at most one. Since the actual Reference has no coupling to a hole, extraction
+of `Dtilde_i H_i^-1` is exactly the corresponding source rational compression
+map. The separate replacement of this rational map by the ideal N map is
+not proved here. The source's normalized rational target is
+
+`G_j = 2^-K_j Dtilde_(G_j) tensor_(i in G_j) H_i^-1`.       (1)
+
+This is a protocol on the complete padded target field: extraction is deferred
+until after the groups. The exact extraction on an axis commutes with every
+map acting only on another group's disjoint axes, so this preserves the
+exact source factorization. We do not commute arbitrary rounded operations;
+their actual all-input errors are controlled below. The inherited prime-product
+admission `T/S<2` in GAUSSIAN.md bounds this padding volume. Physical adaptation
+must still preserve the same original coordinates and pay the full padded
+field. Without that admission retain T explicitly rather than identifying
+its cost with the compressed source volume S.
+
+There are two valid accounting policies:
+
+* **Spend existing normalization.** Following B_j, apply
+  `A_j=2^-(K_j-U_j) Dtilde_(G_j)`. Then `A_j B_j=G_j` and the existing
+  final restoration `2^gamma` is unchanged. Require K_j>=U_j; a stronger
+  condition below makes A_j a contraction on arbitrary hole errors too.
+* **Add a new normalization.** Keep the old remaining diagonal
+  `2^-K_j Dtilde_(G_j)`. The completed group is then `G_j/2^U_j`.
+  To recover the same old target the final exponent must become `gamma+U`.
+
+Adding U to gamma in the first policy is wrong; retaining gamma in the second
+is wrong. These statements are exact identities, including all source holes.
+The policy must be bound to the actual remaining coefficients and final
+scale. Labels such as "normalized Core" cannot establish this binding.
+The written theorem below uses the first policy. The second has the same
+proof with its actual smaller remaining maps and final exponent gamma+U.
+
+#6880 already gives one-group splice bounds and warns that recovery scales
+must be paid. #5325 joins a different physical Tensor using its own 1/8
+compression and gamma. The Gaussian normalization stream concerns powers of
+(1-i)/2; the mixed-native audit concerns JSON commitments; sparse-dyadic
+normalization concerns Bezout acquisition. None supplies this particular
+source's remaining-diagonal contract or consumes its p^100 budget. We claim
+that source-specific join and its exact admission rule, not a new generic
+perturbation inequality, Gaussian identity or asymptotic p^100 argument.
+
+## 2. The actual D bound leaves room for the bridge normalizer
+
+Use the source family with p>=2 and `pi alpha^2<=5 log(16p)`; this upper bound
+is an explicitly inherited eventual Gaussian admission. Original nearest
+half-up rounding gives `|beta_j|<=1/2`. Therefore
+
+`1<=D_jj<=exp(pi alpha^2/4)<=(16p)^(5/4)<=(16p)^2`.
+
+Let `l=ceil(log2 p)`. A safe per-axis dyadic norm exponent is
+`v_i=2l+8`. It covers the value 1 assigned to holes as well as all selected
+diagonal entries. For a group put V_j=sum v_i. In the component-l1 supremum
+norm used by the bridge,
+
+`||A_j|| <= c_j := 2^(U_j+V_j-K_j)`.
+
+Thus the exact finite admission `K_j>=U_j+V_j` makes both A_j and G_j
+contractions. The bound holds on arbitrary numerical errors, including hole
+errors, rather than only on an exact source-image subspace.
+
+The source gap `delta_i>=1/(16p^2)` permits the least dyadic normalizer
+`u_i=ceil(log2(delta_i^-1))<=2l+4`. The looser `u_i<=2l+5` also suffices.
+Consequently the concrete choice `k_i=100l` has
+
+`k_i-u_i-v_i >= 96l-13 > 0`, p>=2.                      (2)
+
+This is one sufficient dyadic polynomial budget compatible with the source
+p^100 prescription. A caller's actual smaller k_i must pass the finite
+inequality; its name or asymptotic order is insufficient. A caller choosing
+oversized a_i instead of the least dyadic must fund those actual exponents.
+Equation (2) does not certify the numerical D coefficients or implement their
+physical stream.
+
+## 3. Actual rounded states, remaining error and explicit precision
+
+Let m>=1 groups partition the actual inverse axes. Each bridge is admitted on
+every incoming q-grid state of component-l1 radius at most R_b=2R_0, with
+integer R_0>=1. Its same-reference global error bound is
+
+`E_j=max( 2^(-t_j-U_j)+2^(1-q)+2 R_b Lambda_j,
+          L_j(R_b) 2^-q + R_b Lambda_j )`,              (3)
+
+where
+
+`Lambda_j=sum_(i in G_j) (1-delta_i)^J_i/(2^u_i delta_i)`,
+`L_j(R_b)=sum_(i in G_j) ((2W_i+1)R_b+2)/delta_i`.
+
+This is the retained actual bridge allocation, including complex component
+conversion, whole Core error and the final q-grid truncation. It applies at
+the actual input of each group; a rounded bridge is not assumed linear or
+Lipschitz. Its internal native radius must still include `R_b sqrt(T_j)` for
+the full field of that call. With a common upper volume `T_j<=2^n_addr`, where
+n_addr denotes the field's address width, the sufficient exponent is
+`ceil(log2 R_b)+ceil(n_addr/2)`.
+
+The actual remaining-diagonal implementation must return to the same q grid
+and satisfy, on every actual input of radius at most R_w=3R_0,
+
+`||Ahat_j(z)-A_j z||_* <= e_A,j`.                       (4)
+
+This is a paid source/compiler/rounding obligation. It includes diagonal
+coefficient error, products, copies, final grid conversion and any scale
+operation. It is not inferred from (2). If Q_q is the final componentwise
+toward-zero truncation and the preceding diagonal computation has error
+e_D,j, then `e_A,j<=e_D,j+2^(1-q)`. No precision is silently preserved after
+the remaining division.
+
+Set `w_j=c_j E_j+e_A,j`, with c_j<=1. If
+
+`sum_j w_j<=R_0`, `E_j<=R_0`,                          (5)
+
+the actual completed-group states all remain within R_b. Indeed a group
+input of radius at most `R_0+sum_(k<j) w_k` is in the bridge domain. The
+bridge output has radius at most `R_b+E_j<=R_w`, so (4) applies to its actual
+output. Compare that output first with A_j B_j applied to the same actual
+input; the local defect is at most w_j. Then use the exact contraction G_j
+to compare the actual input with the ideal predecessor. Induction gives
+
+`r_j<=R_0+sum_(k<=j) w_k`, `e_j<=sum_(k<=j) w_k`.       (6)
+
+The sharper recurrence is `e_j<=||G_j|| e_(j-1)+w_j`; (6) suffices without
+assuming linearity of either rounded routine. Final extraction cannot
+increase this norm. Exact final multiplication by 2^gamma therefore gives
+
+`final compression contribution <=2^gamma sum_j w_j`.  (7)
+
+All errors before this compression stage and after it remain separate. If
+the remaining exact suffix has complex-supremum norm L_s, its contribution
+is at most `L_s 2^gamma sum w_j` since complex modulus is bounded by the
+component-l1 norm. A complex unit phase is not assumed to contract the
+component-l1 norm. A caller returning to that norm must pay the appropriate
+conversion. Integer recovery still needs the actual CRT/Fourier and product
+scale from #6880/#2313; (7) is a substitution, not a full recovery theorem.
+
+Here is a concrete simultaneous allocation for target 2^-tau in (7).
+Require integer tau>=1 and gamma>=0; a larger exact suffix can be covered by
+adding an integer bound on log2(max(1,L_s)) to tau. Put
+
+`h=ceil(log2 m)`, `z=tau+gamma+h+1`, `eta=2^-z`.
+
+For each group require
+
+`t_j>=max(1,z+2-U_j)`,
+`q>=max_i u_i`, `q>=z+ceil(log2(max(8,2 max_j L_j(R_b))))`,
+`Lambda_j<=eta/(4R_b)`, `e_A,j<=eta`.                  (8)
+
+Then the Core term and final rounding in the kept branch of (3) are each
+at most eta/4, and its tail is at most eta/2. The halo coefficient term is
+at most eta/2 and its tail at most eta/4. Hence E_j<=eta, w_j<=2eta, and
+
+`sum w_j<=2m eta<=2^(-tau-gamma)<=1/2<=R_0`.
+
+All actual-domain guards (5) and the final tolerance follow. One sufficient
+axis-tail admission is
+`(1-delta_i)^J_i/(2^u_i delta_i)<=eta/(4R_b |G_j|)`.
+The exact rational powers give a finite acceptance check. If delta_i=1 the
+tail is zero at J_i=1, without taking a logarithm of zero. W_i=0 and holes
+remain ordinary source cases. Every inherited Core/halo geometry admission,
+original coordinate binding and production-context certificate stays required.
+
+Equation (8)'s q budget also leaves room for the final remaining-diagonal
+truncation: `2^(1-q)<=eta/4`. It therefore suffices to obtain
+`e_D,j<=3eta/4` before that truncation. This records a concrete still-open
+diagonal error target rather than setting it to zero for free.
+
+## 4. Global dimension and complete costs
+
+The public Core's conservative family uses balanced group sizes between
+g and 2g, `g=Theta(p^(39/40))`, and the actual number of axes
+`d=Theta(p^epsilon)`, `epsilon=1-10^-30`. The canonical outer source gives
+`n_addr=log2 T=Theta(p)`, `ell_original=Theta(p^(1-epsilon))`; these are explicit family
+premises, not consequences of a finite fixture.
+The source's own n denotes the integer input length, with V=Tp=Theta(n);
+it is not the address-width symbol n_addr used here.
+
+Under uniform `u_i=O(log p)`, `k_i=O(log p)`, both global totals obey
+
+`U=O(d log p)=o(p)`, `gamma=O(d log p)=o(p)`.             (9)
+
+The first-policy gamma also includes all preexisting expansion normalizers.
+The second-policy exponent gamma+U has the same eventual order. A single
+group's `U_j=o(p)` alone would not establish (9); the full d relation is
+essential. We do not claim a contradiction for the canonical near-one
+epsilon. The statement is asymptotic and can have a very large initial range.
+
+For a quantitative interpretation, suppose a combined scale bound has the
+explicit form `B p^(1-a) log2 p`, where a=1-epsilon>0 and B is a uniform
+constant after some admitted p_0. Elementary maximization gives
+`log2 p <= (2/a) p^(a/2)` for p>=1. To make this scale at most c p, it
+suffices that
+
+`p>=max(p_0,(2B/(a c))^(2/a))`.                        (10)
+
+With a=10^-30 this sufficient onset is enormous. Neither the proof nor its
+small controls claim practical production parameters at this onset.
+
+Let `tau=O(p)`, `log R_0=O(p)`, `W_i=O(sqrt(p) polylog p)` and
+`delta_i>=1/(16p^2)`. Then log L_j=O(p+log p+log g), log m=O(log p), and
+(8) gives common q and all t_j of O(p). The fixed conservative choice
+`J_i=16p^4` gives `(1-delta_i)^J_i<=exp(-p^2)` and meets the tail guards
+eventually, including the total restored scale in (9). It retains
+`b_i=(J_i-1)W_i<16p^5<p^48` once the source W_i<p admission holds.
+The earlier source geometry `L>=p^400` and first-face containment remain.
+
+The inherited Core formats then use their actual q, t_j and full radius
+R_b sqrt(T_j); their proofs give P_j,w_j=O(p) under the same uniform source
+height/prefix premises. Here the word width w_j is unrelated to the local
+error notation of (5). The bridge codec retains its complete O(T_j F_j)
+invoice, with
+
+`F_j=d_record+w_native,j+(P_j-q)+(P_j+U_j-q)+1=O(p)`,
+
+where `d_record=q+R_b.bit_length()+1` and `w_native,j` denotes the actual
+native signed-carrier width. Thus its sum is O(V m), V=Theta(Tp) for a
+common upper field volume T. A separate final exact scale or an unfused
+remaining dyadic shift costs a full O(V) pass, or O(Vm) for one per group;
+it is not free. Exact positive final shifts retain O(p) signed headroom.
+Exact downward shifts must retain the extra fractional bits or charge their
+rounding through (4). Old backing and every source/halo/callee owner remain.
+
+All **diagonal numerical products**, coefficient tables, source formation,
+validation and physical access retain their existing complete invoices. This
+proof adds no per-record free scalar multiplication and provides no new
+diagonal engine. Funding (4) at O(p) bits preserves a claimed existing tariff
+only if its actual source contract supports that precision and cost. The
+Core's full K-context setup and the halo archive bill remain; the new scale
+ledger neither drops K nor creates a cache. A fixed number of global scalar
+admission calculations per axis has polynomial descriptor cost; exact tail
+checks may have polynomial(p) rational height and are setup, not online O(1).
+
+## 5. Failure controls and exact remaining implication
+
+The actual Reference._narrow returns identity whenever either address is a
+hole. Thus a tensor coordinate consisting of holes is an exact eigenvector
+of every H_i and its inverse with eigenvalue one. This is an admitted
+all-input source direction, regardless of whether a particular outer prefix
+reaches it. Its normalized bridge action is exactly multiplication by 2^-U_j.
+
+Take two groups with U_1=U_2=8, caller K_j=U_j, remaining diagonal identity,
+and a unit value on such a coordinate. At q=15, each individual shift fits
+q>=u_i, but the sequential q-grid values are `2^-8` and then zero, because
+`2^-16<2^-15`. Restoring by 2^16 still returns zero instead of one. At q=16
+the unit survives exactly. This is a cumulative-grid erasure control for an
+ideal exact hole action followed by the actual specified truncation; it is
+not a native Gaussian execution or proof that a particular complete outer
+caller reaches that input. Final C deletes this hole-supported direction:
+the control concerns the **pre-extraction bridge interface**, and is not a
+counterexample to the completed extracted compression output. It does not
+prove a necessary q>=U condition for every final caller or reachable input.
+It exposes why individual group shifts and an ideal-state radius check do
+not certify the bridge's declared all-input global budget.
+
+Taking the actual Reference source halfwidth w=0 would make its selected
+off-diagonal entries vanish, but does not supply a stronger admitted example:
+the unchanged constructor's `narrow_tail` starts with
+`2/(1-exp(-2 pi alpha^2))>2` at w=0. Its certified `narrow_gap` is then
+negative. The actual bridge demands a positive bound no larger than that
+certificate. We therefore do not promote this structurally identity
+zero-source-halfwidth reference to an admitted selected-coordinate or
+final-output counterexample.
+
+The independent checker also distinguishes omitted compensation from double
+compensation, underfunded remaining diagonal norm, ideal-only wrapper radius,
+missing wrapper truncation, source corruption, zero tails and the full-field
+radius conversion. Exact finite recurrence cases corroborate the written
+proof and the unchanged bridge allocation; they do not establish analytic
+source or native execution premises.
+
+The new implication is now explicit: an actual remaining-diagonal service
+meeting (4), bound to the source's chosen K_j and the proper policy, plus the
+already admitted bridge at (8), yields a complete normalized compression-group
+contract on actual states and the final contribution (7). The source's
+polynomial normalizer budget passes its exact norm gate. Its source-page,
+rounded-diagonal and physical delivery obligations still need execution and
+verification; this is not a complete Gaussian/Tensor/FFT or multiplication
+theorem. All five foundational assumptions and the accepted kappa remain.
diff --git a/research/fine-expansion-page-admission/retained/middle-PROOF.md b/research/fine-expansion-page-admission/retained/middle-PROOF.md
new file mode 100644
index 0000000000..2f434e4b55
--- /dev/null
+++ b/research/fine-expansion-page-admission/retained/middle-PROOF.md
@@ -0,0 +1,285 @@
+# Cached source chirps through actual cyclic convolution and grid conversion
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+This closes one concrete prefix interface, not the complete Gaussian prefix
+or a multiplication theorem. No new kappa or selected-result change.
+
+## 1. Exact source boundary and overlap
+
+Canonical source pin: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+The unchanged cached consumer, producer and serializer are from
+CrocSwap/integer-mult-bounds#6906, public head
+`3c0443b2aa721ce692199ff31abc18e8d917596a`. That package implements certified
+chirp/conjugate payload passes and explicitly leaves full chirp convolution
+and payload-grid conversion open. We supply those connections here.
+
+The actual `Cyclic` child is canonical
+`research/physical-chirp-middle/cyclic_engine.py` (#3763). Its unchanged
+twist/ring/narrow/untwist sequence already implements normalized cyclic
+convolution. The original #3763 chirp consumer uses a different numerical
+kernel producer; we do not claim its Fourier identity or cyclic algorithm
+anew. #4325/#5987 and #6906 already prove cached phase error and movement.
+#5295/#5325 already supply the old expansion/error telescopes; they do not
+implement this cached convolution/grid seam or replace the old Tensor
+catalogue. The broad fine-family Core is outside this package and remains
+separate concurrent work.
+
+The canonical `tensor_sources.bind_chirp` function is used unchanged to bind
+the two runtime families. The Gaussian/FFT-word loader and the chirp loader
+authenticate the same corrected ring export (SHA256
+`c03d4b056ccd3db860c93579f6525e0bb1baea31cff879eb07135c99432ef159`).
+The binder compares every ring-package byte before supplying the existing
+state token. No numerical routine, scalar owner or validation is replaced.
+Actual `Tape` and `Count` identities are checked before importing the join.
+The old Tensor catalogue and its inadmissible fine-theta production guards
+are not invoked or waived.
+
+## 2. Field, source and grid contracts
+
+Let D>=2, r=2^ell>=4, t_0=r and t_i in {r/2,r}; put
+T=product t_i, M=T/r=2^A. Each original slope s_i is odd with 0<s_i<t_i.
+Axis zero is fastest, and its r adjacent coefficients form one polynomial
+record. All T original padded coordinates are processed, including every
+coordinate called a hole by the Gaussian maps. There is no Core-size phase
+period, skipped hole, extraction or transpose.
+
+The exact source chirp is
+
+    a(x)=product_i exp(-pi*i*s_i*x_i^2/t_i).
+
+The q-grid external field uses the public Core/halo bridge's signed-magnitude
+format: q+2 bits per real component, a complex record separator, and its
+fixed sentinels. Let ||z||_* = max_x(|Re z_x|+|Im z_x|); let ||z||_abs be
+maximum complex modulus. Admit an actual supplied q-grid field x with
+||x||_abs<=1/2. The join checks this condition by exact squared-radius
+products on every lifted input, not by inspecting its source history.
+
+Let h=2^-f. The certified cached producer at radius one supplies inward
+unit-disk per-axis table entries on this f grid, with each component error
+<=2h, and exact entries a_i(0)=1. Its immutable source specification binds
+each original (t_i,s_i) pair. `Prepared` emits the cached shape in fastest-first
+order and the Cyclic flags in reversed remaining-axis order, with the maximal
+axis last as required by the original Cyclic ABI. Both describe the same
+axis-zero-fastest flattened field: the inherited FourierPlan.natural_axes
+visits flags from the right at increasing low-bit offsets, while each ring
+record already contains axis zero. These source-preparation and no-concurrent-
+mutation premises are retained; structural parsing alone does not establish
+phase semantics for arbitrary tables.
+
+The cached carrier is W=f+3; the Cyclic carrier is f+2. The public codec uses
+`external_grid=q, native_grid=f, normalizer_bits=0`. Entrance is an exact
+dyadic lift. Same-grid conversions check signed representability and copy
+the exact integer; they neither discard fractional bits nor introduce a
+normalization. The final public codec truncates each component once from
+f to q, contributing <2^(1-q) in ||.||_* when f>q and zero when f=q.
+All conversions scan the complete T-record field and are paid below.
+
+## 3. The same rounded kernel at all three occurrences
+
+Let A(x) be the *fresh rounded suffix expression* defined by #6906's actual
+cache at x. It is not the exact irrational a(x). The predecessor proves
+
+    |A(x)|<=1,
+    |A(x)-a(x)| <= (3D-1)sqrt(2)h =: e_a.               (1)
+
+The same unchanged source bank and f/W fields are used for three cached
+calls. First run the forward cached pass on a literally produced all-ones
+field. Multiplication of the dyadic A(x) by exact one, followed by f-grid
+truncation, is exact, so its returned kernel is A(x), with no fourth error
+term. The second call applies the conjugate pass to the exactly lifted x.
+The third applies it to the actual Cyclic return. The cache recurrence
+depends only on original coordinates and tables, never on payload values;
+fresh initialization and completed cleanup therefore give the identical
+A(x) at every occurrence. In particular conjugating before the first
+endpoint, using A as convolution kernel, and conjugating the last endpoint
+are all necessary sign conventions.
+
+The actual computation at the f grid is thus
+
+    x0 = trunc_f(conj(A)*x),
+    z  = actual_Cyclic(A,x0),
+    yf = trunc_f(conj(A)*z),
+    yq = component_trunc_q(yf).                         (2)
+
+Kernel and endpoint calls execute real CachedChirp owners. The join copies
+and consumes every protected child return before reuse. The Cyclic child
+executes two twists, its actual ring convolution, exact signed-width
+narrowing and one untwist. Its ring consumer already performs its exact
+M restoration; the join performs no additional M, r, T or gamma scale.
+
+## 4. Actual-input defect and radius
+
+Retain #3763's exact cyclic and primitive/coefficient contracts. For
+f>=16 and f-A>=13, on disk inputs whose smaller norm is <=.7, its actual
+returned normalized cyclic convolution C obeys
+
+    ||actual_Cyclic(v,w)-C(v,w)||_abs
+      < (4sqrt(2)M+12)h,
+    ||actual_Cyclic(v,w)||_abs
+      <= min(||v||_abs,||w||_abs)+4sqrt(2)Mh.            (3)
+
+The strict numerical radius consequence is sufficient here; (3) is the
+retained written theorem, not a new proof of the Fourier backend. By
+inwardness, ||x0||_abs<=1/2. With ||A||_abs<=1, (3) is admitted at the actual
+computed x0. Since `32*1000^2<2^26`, f-A>=13 gives 4sqrt(2)Mh<.001.
+Every returned z and final yf,yq consequently has norm <.501. Cached
+endpoint truncation and the final external projection cannot increase
+complex modulus. Thus all cache payload calls are within their radius-one
+source contract. Both narrower f+2 carriers hold all converted components;
+no discarded high bit is justified by approximate cancellation.
+
+For a fixed supplied dyadic A define the exact map
+F_A x=conj(A)*C(A,conj(A)*x). Bilinear contraction of C and |A|<=1 imply
+that the two endpoint rounding errors in (2) contribute <2sqrt(2)h in
+modulus. Adding (3),
+
+    ||yf-F_A x||_abs < (4sqrt(2)M+12+2sqrt(2))h.        (4)
+
+Now replace the three A occurrences with a by a three-term telescoping
+identity at exact operands. Each term is bounded by (1)*||x||_abs, so
+`||F_A x-F_a x||_abs<=3e_a/2`. This uses exact bilinear maps only; no
+linearity or nonexpansiveness of the rounded program is assumed.
+The retained chirp identity gives F_a=Q_freq F_t, the normalized Fourier
+map with `(Q_freq v)_x=v_(-s_i x_i mod t_i)`.
+
+Convert the *one final global* modulus estimate to component-l1 using
+||.||_*<=sqrt(2)||.||_abs. There is no sqrt(2)^D factor. Since
+12sqrt(2)<17, (1),(4) and the final q projection prove
+
+    ||yq-Q_freq F_t x||_*
+      < (8M+9D+18)2^-f + 2^(1-q).                     (5)
+
+This is a bound at the actual supplied x. Its prior expansion error is
+not assumed zero and is handled separately in Section 6. The returned
+component-l1 radius is <.501sqrt(2)<1, suitable for a radius-one compression
+entrance subject to that compression's separate dense/source admissions.
+
+## 5. Explicit sufficient precision, with no new normalization
+
+For an integer target chi>=0, set C=8M+9D+18 and choose
+
+    q>=chi+2,
+    f=max(q,16,A+13,chi+1+ceil(log2 C),ceil(log2(6D))),
+    W=f+3.                                             (6)
+
+The final term permits the unchanged cached preparer's radius-one,
+target-zero allocation to keep precisely this f. Then the first term of
+(5) is <=2^(-chi-1), and the second is <=2^(-chi-1), with strict total
+error <2^-chi from the actual rounding bounds. The W value is exactly the
+unchanged producer's chosen width: A>=ell-1 and A>=D-1, so f>=A+13
+also covers its ell+2 and ceil(log2(D+1))+2 metadata-width clauses. All counts and shifts are constructed
+before online payload processing and remain encoded thereafter.
+
+For the fine family, A=O(p0), D=poly(p0), q,chi=O(p0), and ell=o(p0).
+Thus f,W=O(p0); indeed f=O(q+A+log(D+1)+1). This explicitly funds the cyclic
+M-amplification rather than assuming that a compression-only q rule already
+covers it. It is an added sufficient internal grid, not a claim that every
+previously prepared phase bank or frozen prefix already used these bits.
+Grid lifting preserves represented values. No normalizer is introduced and
+the actual existing total Gaussian gamma is unchanged.
+
+## 6. Precisely reduced prefix obligation
+
+Let e be the exact normalized broad expansion field and ehat its computed
+q-grid field in the same original padded coordinates. Assume the actual
+ehat passes the radius guard above, and ||ehat-e||_*<=epsilon_exp. The exact
+normalized Fourier map contracts maximum complex modulus, hence
+
+    ||Q_freq F_t(ehat-e)||_* <= sqrt(2) epsilon_exp.
+
+The new actual middle output yhat therefore satisfies
+
+    ||yhat-Q_freq F_t e||_*
+       < sqrt(2)epsilon_exp + delta_mid,
+    delta_mid=(8M+9D+18)2^-f+2^(1-q).                  (7)
+
+Use the public Reference/ideal join's exact normalized compression C_N,
+its actual existing total restoration exponent Gamma, and its separately
+proved restored compression error <=2^-tau on yhat. Its caller contribution
+is now explicitly
+
+    ||completed_output-2^Gamma C_N Q_freq F_t e||_*
+      < 2^-tau + 2^Gamma ||C_N||_*
+                    (sqrt(2)epsilon_exp+delta_mid) + e_extra.       (8)
+
+For example, if the actual normalized C_N contracts this norm and the
+middle's assigned restored allowance is 2^-tau_mid, choosing
+chi>=Gamma+tau_mid and (6) funds its term. A separate allowance must fund
+the expansion term and every extra interface error e_extra. No rounded-map
+contraction or automatic equality of old/new gammas is imported. No
+complete RF_s, opposite source transform, CRT or integer recovery is
+claimed: (8) leaves precisely the source-bound broad expansion, its reached
+radius/error and all remaining backend/production assumptions open.
+
+## 7. Full source, movement and arithmetic invoice
+
+All fields have full volume T. In addition to three unchanged cached calls
+and one unchanged Cyclic call, the join pays:
+
+- exact q-to-f entrance and f-to-q return in the public codec;
+- 2T exact real products for the physical input-radius checks;
+- one T-record all-ones bank, three exact W<->f+2 field conversions;
+- owned kernel/endpoint/current fields, the final external output copy,
+  every child return consumption, all rewinds and cleanup.
+
+These add O(TW+T M_word(W)) online work, including conversions whose grids
+agree but signed carrier widths differ. Use the unchanged complete scalar
+invoice M_word(W)=O(W log^2(W+2)) only under its inherited all-size contract.
+The cached update count per call is U=sum_k(T/product_{i<k}t_i-1)<2T;
+three calls cost 12(T+U) real products. The radius check adds 2T.
+These products are additional to every scalar operation inside Cyclic.
+
+Retain the complete canonical cyclic envelope, including all three full
+Fourier calls T_F, normalized ring products, twists and exact recovery.
+Here T_F means each inherited call at its actual encoded shape, row count
+and internal precision (including P=f+A), with its source and retained
+backing charges; no original-grid frontier is substituted for those calls.
+A conservative valid total is
+
+    3T_F + O(T(ell+1)f^(8/5) + r f^3 + (A+f)^3
+             + T M_word(W) + TW + D^2W + C_setup).      (9)
+
+The canonical *whole* old chirp invoice is an upper bound for its Cyclic
+subprogram, so (9) safely keeps its scalar/twiddle/setup terms without
+claiming a new optimized coefficient. No child is priced as a rank count or
+a free normalized convolution. No multiplication theorem is inferred from
+the scalar terms being nonbinding. In particular the historical T_F frontier
+has not been re-admitted for the fine-family dimensions here.
+
+`C_setup` is #6906 SOURCE.md's paid preparation and serialization: with
+m=sum_i t_i, B=O(f+ell+log(D+1)) in this source family, and historical source
+storage H_prev, let H=O(H_prev+(m+D)B+B^4). The explicit sequential simulation
+bill is O((m+D)B^12 H+Wm+sum ell_i+D). The actual serializer's integer
+unit-disk checks are also covered (or charged as O(mW^2) explicitly).
+The current flags/Counts add O(D ell+A+f) bits and polynomial preparation.
+The all-ones bank is full-volume online work, not subexponential setup.
+For fresh source history, m=2^o(p0) and these source costs are 2^o(p0);
+unbounded retained history cannot be silently discarded.
+
+Storage is a constant number of full O(TW) fields and codec buffers, the
+O(mW+DW) cached tables/state, source setup H, all active/inactive cyclic and
+scalar child backing, and encoded metadata. Every role's historical largest
+extent remains charged after erasure. Output consumption is part of the
+invoice. Structural/source preparation is not advertised as a literally
+metered elementary coefficient generator.
+
+## 8. Evidence and limits
+
+The physical witness uses T8, radices (4,2), original slopes (3,1),
+external q10, internal f16/W19 and chi7. It exercises nonzero grid lift/drop,
+both cached conjugate endpoints, kernel-on-ones, actual complete Cyclic,
+its three actual Fourier calls, exact width narrowing, the full original
+coordinate order and protected-return cleanup. It uses the predecessor's
+declared q2 finite provider and exact small metadata specialization; no
+production GL64/O73 or full fine-family invocation is claimed.
+
+The independent integer oracle imports no predecessor checker. It derives
+the eighth roots with integer square root, computes the two-point Fourier
+butterflies, signed negacyclic polynomial product, exact M restoration and
+twists, then compares against a separate exact Gaussian-rational dense
+Q_freq F_t sum. Scale/conjugation/grid controls distinguish the critical
+seams. Allocation checks are finite corroboration of (6), not a universal
+proof. Full receipts and the bounded attempt history belong in `evidence`.
+The exact source proof and inherited contracts establish the all-size
+conditional statement; model-assisted lead review is not human or
+proof-kernel acceptance.
diff --git a/research/fine-expansion-page-admission/retained/reference-PROOF.md b/research/fine-expansion-page-admission/retained/reference-PROOF.md
new file mode 100644
index 0000000000..cabc570bb1
--- /dev/null
+++ b/research/fine-expansion-page-admission/retained/reference-PROOF.md
@@ -0,0 +1,396 @@
+# The actual reference error fits the existing compression budget
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+**Source-interface theorem, conditional on the named analytic and physical
+contracts; no new kappa and no complete integer-recovery theorem.** Canonical
+source: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+
+## 1. The missing boundary and the result
+
+The public `core-group-scale-ledger` at
+`76a84e1c4bfa4035e5ee85410dbfc4541f0da168` compares the actual Core/halo and
+remaining diagonal with a tensor of inverses of fixed rational References H.
+Its section 1 explicitly leaves replacement of H by the ideal periodic narrow
+Gaussian N open. The actual remaining-diagonal service at
+`b00d64b6204e83d468dde2db7480a2822e6940aa` supplies its local error contract,
+but also leaves that comparison open. This package joins that specific
+boundary, including the original q image, holes, final extraction C and the
+already-declared restoration exponent gamma.
+
+The result is stronger than a new generic inverse-perturbation bound. The
+literal `Reference.for_cap` allocator funds the comparison at the **same**
+Core target and external q grid used in the public ledger, provided its
+declared radius covers the stated bridge input radius and the exact finite
+normalization check (13) below holds. The concrete per-axis p^100 budget
+satisfies that check. A constructor target copied from an unrelated caller,
+or a radius below the incoming-radius contract, gets no such conclusion.
+
+The proof uses existing Gaussian tail and row-norm theorems as explicit
+premises. It does not establish the exact Gaussian/Fourier identity, the
+expansion approximation, the supplier theorem, all physical context delivery,
+or the final CRT/product/carry tolerance. It supplies the previously missing
+reference-versus-ideal contribution for this compression stage.
+
+## 2. Exact same-reference operators and source premises
+
+For axis i, let S_i be its original source period, e_i its excess and
+T_i=S_i+e_i its target period. Define
+
+    theta_i=e_i/S_i, rho_i=T_i/S_i,
+    phase_i(j)=floor(theta_i*j+1/2),
+    q_i(j)=j+phase_i(j), beta_i(j)=theta_i*j-phase_i(j).
+
+All maps below use these original coordinates and the original period cut.
+The ideal source matrix is
+
+    N_i[r,s] = sum_(ell in Z)
+      exp(-pi*alpha_i^2*((rho_i*(s+ell*S_i)-q_i(r))^2-beta_i(s)^2)).  (1)
+
+In particular N_i's diagonal contains the positive nonzero-period aliases.
+The canonical Reference sets its narrow diagonal to exactly one. Deleting
+those aliases from the definition of N_i would change the target and would
+not implement the stated Gaussian source identity.
+
+Embed N_i and H_i on the selected target coordinates q_i(j). Put the identity
+on holes, with zero selected/hole couplings. This is precisely the augmented
+narrow Reference convention. Let Dtilde_i be
+`exp(pi*alpha_i^2*beta_i(j)^2)` at q_i(j) and 1 at holes. Let C select q_i(j).
+After applying all groups, C is the tensor extraction. Operators on disjoint
+axes commute with this exact extraction; no commutation of rounded routines
+is assumed. The public ledger's deferred extraction preserves the same target.
+
+Write epsilon_i for the actual rational `ref.errors["narrow"]` and delta_i
+for the actual `ref.narrow_gap`. RAW-GAUSSIAN-PROOF sections 3--5 prove
+
+    ||H_i-N_i||_infinity <= epsilon_i,
+    ||H_i^-1||_infinity <= 1/delta_i,                         (2)
+
+when delta_i>0. The first includes both omitted periodic aliases and every
+retained coefficient error. Those theorems concern the actual deterministic
+Reference rule, not a separately rounded matrix.
+
+For the fine-theta family the source parameters obey
+
+    p>=2, 1/(4p^2)<=theta_i<=1/p^2,
+    pi*alpha_i^2>=4 log(16p),
+
+and the complete unchanged `Reference.for_cap` is called with legal cuts.
+The production-gap theorem at
+`9a07c08c014259bb23c0a2b5844a1b67d91892f6` proves
+`delta_i>1/(16p^2)` from this literal constructor. Its inherited interval
+and row-gap premises are listed there; they are not discharged again.
+It also proves the source allocation lower bound used in section 5.
+
+Use the component-l1 supremum norm
+`||x||_* = max_x (|Re x_x|+|Im x_x|)` on the full padded field. Every matrix
+here is real. Its absolute row-sum bound therefore applies to this norm, and
+Kronecker row sums multiply. Complex unit phases are outside this claim;
+there is no free component-norm contraction for an unrelated suffix.
+
+## 3. The ideal inverse uses the same literal certificate
+
+The actual constructor computes rational upper endpoints a_i and b_i for
+`exp(-2*pi*alpha_i^2*theta_i)` and `exp(-2*pi*alpha_i^2)`, then sets
+
+    delta_i=1-a_i-5*b_i-epsilon_i.
+
+The credited ideal row theorem bounds `||N_i-I||_infinity` by a_i+5*b_i,
+including the aliases on the diagonal. Hence
+
+    ||N_i-I||_infinity <= 1-delta_i-epsilon_i < 1,
+    ||N_i^-1||_* <= 1/(delta_i+epsilon_i) <= 1/delta_i.      (3)
+
+All quantities refer to one actual constructor. No unknown inverse bound
+was used to construct epsilon_i or delta_i. The resolvent identity gives
+
+    H_i^-1-N_i^-1 = H_i^-1 (N_i-H_i) N_i^-1,
+
+so
+
+    ||H_i^-1-N_i^-1||_*
+      <= epsilon_i/[delta_i*(delta_i+epsilon_i)].            (4)
+
+The separately credited ideal half-gap also gives `||N_i^-1||<=8p^2`;
+therefore the simpler `128p^4 epsilon_i` is valid. We retain (4) in the
+actual group invoice because its denominator matches the constructor and
+the public normalizers. Identity holes contribute zero to (2) and (4).
+
+## 4. Actual group diagonals and the complete exact comparison
+
+Let nonempty disjoint groups G_j partition all d inverse axes. Retain the
+public ledger's actual normalizer bits u_i, group totals U_j=sum u_i and
+K_j, and bounds v_i with `||Dtilde_i||<=2^v_i`. Put V_j=sum v_i and
+
+    c_j=2^(U_j+V_j-K_j),
+    mu_j=2^(V_j-K_j) product_(i in G_j) delta_i^-1.
+
+The actual admissions are `2^u_i*delta_i>=1` and `K_j>=U_j+V_j`; thus
+`mu_j<=c_j<=1`. The exact normalized targets are
+
+    G_H,j = 2^-K_j tensor_(i in G_j) (Dtilde_i H_i^-1),
+    G_N,j = 2^-K_j tensor_(i in G_j) (Dtilde_i N_i^-1).      (5)
+
+Both have norm at most mu_j. This proves their contractions from their
+actual factors. It does not assert contraction of either numerical routine.
+Nor does it require every individual axis to contract: a group can spend
+its normalizer collectively.
+
+Telescope (5) one tensor factor at a time, use (4), and bound the other
+inverse factors by delta_i^-1. The common factors give
+
+    ||G_H,j-G_N,j||_*
+      <= xi_j := mu_j sum_(i in G_j)
+                     epsilon_i/(delta_i+epsilon_i).         (6)
+
+This is where the actual D factors and group scale are paid; dropping them
+before forming the invoice would not prove the same assertion.
+
+Let F_H=C G_H,m ... G_H,1 and F_N=C G_N,m ... G_N,1. A second telescope
+uses the proved complete-group contractions and `||C||<=1`. On an original
+input x of radius at most R_0,
+
+    ||F_H x-F_N x||_* <= R_0 sum_j xi_j.                    (7)
+
+The factor is R_0 because (7) compares two exact operators on their common
+initial input. If instead a caller inserts (6) at an actual rounded
+intermediate state, it must use that state's radius. We use the separate
+physical-versus-H argument below and do not conflate these two comparisons.
+
+## 5. The existing constructor radius pays the reference input radius
+
+For every axis in G_j, call the unchanged constructor once, before any
+numerical block request, at cap B_i and declared radius R_i. Require
+`R_i>=2R_0`, target s_i>=t_j and legal original-period cuts. Larger radii
+needed by actual dense interiors remain charged and must also be covered;
+this theorem does not weaken their radius admission.
+
+The production-gap source proof derives from the actual Gaussian.qbar
+
+    Qstar_i>=2^21 alpha_i^2 p B_i,
+    E_i=s_i+ceil(log2(8(R_i+1)Qstar_i^2)).
+
+With alpha_i,B_i>=1 and R_i>=2R_0, this implies
+
+    E_i >= s_i+46+ceil(log2(R_0 p^2)),
+    R_0 epsilon_i <= 2^(-s_i-46)/p^2.                    (8)
+
+These are inequalities for the constructor's existing allocation. We do not
+replace E_i by a separately invented reference precision. Inserting
+`delta_i>1/(16p^2)` into (6) yields
+
+    R_0 xi_j <= mu_j |G_j| 2^(-t_j-42).                   (9)
+
+The nominal radius in a source allocator is not free metadata: using R_i=1
+at an arbitrarily large R_0 removes the cancellation in (8). Such a different
+caller must retain its actual R_0/(R_i+1) factor or raise the target; it is
+not admitted by the unchanged-allocation result.
+
+## 6. The public diagonal service leaves the needed slack
+
+Retain the exact source/geometry/tail/precision admissions of the public
+group ledger. For desired final contribution 2^-tau it chooses
+
+    h=ceil(log2 m), z=tau+gamma+h+1, eta=2^-z,
+    t_j>=max(1,z+2-U_j),
+    q>=max_i u_i,
+    q>=z+ceil(log2(max(8,2 max_j L_j))),
+    L_j=sum_(i in G_j) (((2W_i+1)2R_0+2)/delta_i),
+    Lambda_j<=eta/(8R_0).                                (10)
+
+Its actual nonlinear bridge has all-input defect E_j<=eta on radius 2R_0.
+The actual source remaining-diagonal service, on radius 3R_0, proves
+
+    e_A,j <= (3R_0+2)2^-q.                               (11)
+
+This includes coefficient error, native product rounding and the proved
+zero-drop external codec. Using that actual service is essential: a merely
+postulated wrapper with allowance eta need not leave the following slack.
+
+The literal delta_i lies in (0,1), and W_i>=0. Since each group is nonempty,
+`L_j>=2R_0+2`. Equation (10) therefore gives
+
+    e_A,j <= [(3R_0+2)/(4R_0+4)] eta <= 3eta/4.
+
+The actual completed-group defect against G_H,j is consequently
+
+    w_j=c_j E_j+e_A,j <= (c_j+3/4)eta <= 7eta/4.          (12)
+
+The public actual-state induction remains valid, since this strengthens its
+old bound w_j<=2eta. Its intermediate inputs are at most 2R_0 and bridge
+outputs at most 3R_0; the new ideal comparison does not enlarge an actual
+state or invoke a routine on an idealized state.
+
+Because `2^-t_j<=eta*2^(U_j-2)`, (9) is at most eta/4 whenever
+
+    mu_j |G_j| 2^U_j <= 2^42.                            (13)
+
+This is an exact rational finite sufficient check on the actual descriptors.
+A convenient stronger check, using mu_j<=c_j, is
+
+    |G_j| 2^(2U_j+V_j-K_j) <= 2^42.                     (14)
+
+Under (13), combine the physical-versus-H error sum from (12) with (7):
+
+    ||actual extracted output-F_N x||_*
+      <= sum_j w_j+R_0 sum_j xi_j
+      <= 2m eta <= 2^(-tau-gamma).                       (15)
+
+Exact restoration by 2^gamma gives at most 2^-tau. Gamma is unchanged:
+the remaining coefficients are still `2^(U_j-K_j)Dtilde`, so each completed
+group still implements (5), rather than adding a new inverse normalization.
+No alias removal, input downcast or second restoration is hidden in (15).
+
+Thus **the old precise t_j and q allocation suffices**, with the original
+tau, when source targets s_i>=t_j, source radii R_i>=2R_0 and gate (13) are
+bound to the same References. This is an allocation binding and proof, not
+a mutation of an already frozen Reference. If a given frozen source fails
+the binding, construct its replacement before any numerical consumer and
+rebind every consumer; a source label alone does not repair it.
+
+## 7. Source-first sufficient allocation and production cost
+
+The normalizer bits u_i are determined after the actual Reference exists.
+There is no need to guess them or solve a circular fixed-point condition.
+Under the retained first scale policy, choose K_j and gamma independently
+of the new Reference normalizer bits u_i; these are the preexisting completed
+map normalizers and restoration. Choose m, tau, R_0, legal original descriptors
+and source radii R_i first, and set
+
+    s_i=max(1,z+2) for every i.                           (16)
+
+Construct the immutable References at these targets. Their positive gaps
+then determine the least dyadic u_i. The public ledger computes
+`t_j=max(1,z+2-U_j)`, automatically no larger than s_i. A tighter choice may
+exploit an independently established lower bound on U_j, but is unnecessary
+for the complete asymptotic bill. Already frozen References whose actual
+s_i cover t_j need no reconstruction.
+
+For the conservative production family let l=ceil(log2 p). The established
+eventual alpha estimate permits `v_i=2l+8`. The production-gap certificate
+permits `u_i<=2l+4`, and the source's dyadic p^100 prescription can use
+`k_i=100l`, K_j=sum k_i. Then
+
+    2U_j+V_j-K_j <= (16-94l)|G_j| <= -78|G_j|.
+
+For positive integers r, r<=2^r; hence the left side of (14) is at most
+`r 2^-78r<=2^-77r<1<2^42`. This check is uniform in group size. The actual
+remaining-diagonal coefficient guard, all native admissions and all
+Core/halo geometry constraints remain separate inherited requirements.
+
+For a finite small case without the eventual alpha upper bound, the valid
+alternative `v_i=2alpha_i^2` follows from pi<4 and exp(1)<4. Apply (13)/(14)
+with that actual bound; do not silently assign the eventual v_i to p=3.
+
+With d=Theta(p^(1-10^-30)), balanced groups of size Theta(p^(39/40)),
+gamma=O(d log p)=o(p), tau=O(p), and log R_i=O(p), (16) has s_i=O(p).
+The production-gap source upper allocation gives E_i=O(p), entry/interval
+grids O(p), w_i=O(sqrt(p/log p)) and
+W_i=O(sqrt(p log p)+log p). The original positive-weight setup precision
+remains O(p^2 log p+p); it is not an online scalar width. Actual descriptor
+heights, canonical constructor AST work, coefficient preparation, tails,
+comparisons and disposal remain charged.
+
+The comparison proof constructs or scans no dense ideal N or inverse during
+production. It adds O(d) rational descriptor checks, with polynomial bit
+heights, to the already paid source setup. The main actual payload still has
+full padded size T=product T_i. The inherited T/S<2 admission is needed to
+compare its cost with the extracted source volume; otherwise retain T.
+All full-volume Core/halo, routes, diagonal stock, coefficient scans, scalar
+leaves, restored widths and backing costs remain those of the public packages.
+None disappear when the mathematical target changes from H to N.
+
+The source-first target (16) exceeds the minimum Core target by at most U_j
+for that group. Since U_j=O(g log p)=o(p), it preserves the same O(p)
+precision envelope. It can change actual width constants and must be used
+when constructing those source objects; this is not a performance comparison
+between two finite frozen experiments. The enormous legal-period and global
+parameter onsets remain separate from the p>=2^200 sufficient alpha/precision
+estimate in the production-gap package.
+
+## 8. Prior work and the remaining ideal-analytic premise
+
+PR #3851 already proves a resolvent comparison and normalized compression
+error for its original ProductionPlan: theta about 1/d, gap 1/(8p),
+P=32768p and D/2^(2alpha^2). PR #3935 composes those physical Tensor axes,
+and #5325 gives their later recovery caller. Their comparison method is
+credited; their numerical domain and coefficient cohort do not admit the
+fine-theta Reference or the present public group normalizers. This package
+does not repackage that older complete Tensor as a new theorem.
+
+RAW-GAUSSIAN-PROOF supplies the global H-versus-N estimate and the actual
+cap allocator. PR #4648 supplies the ideal half-gap budget, and the public
+production-gap package binds positivity to that allocator. PR #6880 and
+the public Core/halo bridge compare the rounded splice with the same H.
+The public scale ledger and remaining-diagonal package supply the actual
+state and wrapper contracts used in (10)--(12). The new work is the
+source-first binding, the same-certificate ideal inverse, and the explicit
+demonstration that the existing t/q allocation funds (15).
+
+The weakest remaining analytic input at this boundary is now explicit:
+the definition (1), prior global reference-error estimate (2), ideal row
+majorant used in section 3, and interval producer theorems. Those analytic
+statements are written prior theorems,
+not independently formalized here. Outside this boundary one must still
+join this ideal compression with the actual expansion and Fourier calls,
+account for their incoming/suffix errors, and verify the exact final
+CRT/convolution/restoration tolerance. No statement here removes the full
+analytic_recovery assumption or any of the other four foundational premises.
+
+## 9. Bounded verification boundary
+
+The checker executes complete unchanged Reference.for_cap constructors;
+its independent positive-series oracle uses original source offsets and an
+infinite geometric tail. A full-period Neumann diagnostic is an exact
+rational error certificate for its named small case, not a physical native
+execution or a numerical proof of (15). The general arguments above prove
+the quantified implication. Executed counts, controls, exact source pins
+and receipts are recorded separately.
+
+In the independent oracle, the full positive Taylor argument x is enclosed
+by rational endpoints, without the canonical producer's range reduction or
+squaring. Starting with term zero equal to one, each next term is multiplied
+by the corresponding x endpoint, divided by its positive degree and rounded
+outward on a fixed dyadic working grid. Induction encloses each positive
+term and its partial sum. After degree n with x_upper<n+2, the remaining
+positive tail is at most
+
+    term_upper * x_upper/(n+1) / (1-x_upper/(n+2)).
+
+Taking reciprocal endpoints encloses exp(-x). The implementation checks its
+final interval width and stops within an explicit iteration cap; failure
+rejects. For sufficiently large f it instead uses
+`0<=exp(-pi f)<=2^-floor(3f)`, from pi>3 and exp(1)>2. No assertion of
+irrational exact rounding participates in the oracle.
+
+For every original row i, all |h|<=4 terms use j=(i+h) mod S and the original
+beta_j. For |h|>4 the narrow inequality
+`f>=alpha^2(h^2-|h|)` bounds the sum by the exact rational geometric series
+
+    2*2^(-3 alpha^2*4*5)/(1-2^(-6 alpha^2*5)).
+
+The tail includes every nonzero diagonal alias. Terms do not become zero
+merely because their original source index has wrapped. The finite lower
+matrix and its row-error bound therefore enclose the entire periodic N.
+
+The two fixed-grid Neumann diagnostics are checked by their actual final
+residuals, rather than assuming that an unrounded recurrence executed.
+For any candidate v and matrix A with `||I-A||<=rho<1`,
+`||v-A^-1 x||<=||x-Av||/(1-rho)`. For the ideal matrix, the residual also
+includes the complete oracle row error times ||v||. The exact rational
+Reference residual uses every source-produced nonzero entry. All vectors
+are complex and every residual uses the component-l1 norm.
+
+The named fixture has p=3, S=61, T=64, alpha=3, cap1, source radius2,
+R_0=1, source target35, entry bits155, source cutoff3 and target cutoff23.
+Its original holes are 11,32,53. All 4096 Reference entries and 549 independent
+finite periodic terms are checked. Both Neumann diagnostics use the one named 64-component complex input x.
+For that input, the certified difference of the two exact inverse outputs
+is at most 2^-158; after the actual D ordering, normalization by 2^20 and
+final extraction, the difference on that input is at most 2^-169. These two
+figures are input-specific bounds, not measured inverse operator norms. The unchanged public budget yields
+q41/Core target34 and a combined **conditional invoice** at most 2^-13 for
+target2^-12. It is not an executed physical output-error measurement.
+This small case uses v=2alpha^2=18 and K20. It is not the eventual p^100
+family, and it does not admit complete Core geometry or the actual dense
+native-radius contract. Its radius2 proves only the additional bridge-radius
+binding in section 5. No larger physical obligation is inferred from it.
diff --git a/research/fine-expansion-page-admission/return_codec.py b/research/fine-expansion-page-admission/return_codec.py
new file mode 100644
index 0000000000..d1114bdfaa
--- /dev/null
+++ b/research/fine-expansion-page-admission/return_codec.py
@@ -0,0 +1,73 @@
+"""Paid T-record clock for the dimension-changing native return.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from cardinal_counts import Count,positive
+from records import Tape
+from router_metadata import indices
+from scratch_pool import ScratchPool
+from session import OuterScope,initialize_marker,erase_marker,sealed_constructors,borrowed_count,borrowed_tape
+from words import BLANK,need
+
+class ExpansionReturn:
+    """Admitted return owner, not a complete encoded expansion controller.
+
+    ``records`` is a borrowed positive encoded Count prepared by the caller.
+    The host q/J scalars describe input-independent format templates whose
+    O(q+J) construction is charged separately, as is the O(log T) Count copy.
+    Source and native work owners must be distinct; run checks every native
+    alias available through this owner's ports before entering the codec.
+    """
+    def __init__(self,state,records,q,normalizer_bits):
+        records=borrowed_count(records);positive(records)
+        self.B=state.B;self.borrowed_volume_tape=records.tape;self.volume=Count(records)
+        self.codec=state.codec.Codec(state.B,Tape,BLANK,initialize_marker,erase_marker,
+                                    state.codec.Format(q+2,q,q+2,q,normalizer_bits))
+        self.clock=state.B.Tape('owned full target record clock')
+        self.output=state.B.Tape('protected expanded common-grid return')
+        self.pool=ScratchPool(32);self.scope=OuterScope(self.pool)
+        self.closed=True;self.pending=False;self.finished=False;self.calls=0
+        for tape in self.pool.tapes:erase_marker(tape)
+
+    def prepare_clock(self):
+        B=self.B;B.clear(self.clock)
+        for _ in indices(self.volume):
+            for _ in (0,1):
+                B.append(self.clock,'0');B.home(self.codec.magnitude_clock)
+                while self.codec.magnitude_clock.read()=='1':
+                    B.append(self.clock,'0');self.codec.magnitude_clock.move(1)
+            B.append(self.clock,'#')
+        B.home(self.codec.magnitude_clock);B.home(self.clock)
+
+    def run(self,native):
+        native=borrowed_tape(native)
+        need(self.closed and not self.pending and not self.finished,'consume protected expansion return')
+        forbidden=(self.codec.input,self.volume.tape,self.borrowed_volume_tape,*self.pool.tapes)
+        need(native not in forbidden and isinstance(native,Tape),'disjoint external native field and metadata')
+        self.closed=False;succeeded=False
+        for tape in self.pool.tapes:initialize_marker(tape)
+        try:
+            with sealed_constructors(),self.scope.installed():
+                try:
+                    self.prepare_clock()
+                    self.codec.prepare_input(self.clock)
+                    result=self.codec.prepare_return(native,self.clock)
+                    self.B.clone(result,self.output);self.B.home(self.output)
+                    self.pending=succeeded=True;self.calls+=1
+                finally:
+                    self.codec.abort();self.B.clear(self.clock);self.B.home(self.clock)
+                    self.pool.empty()
+        finally:
+            for tape in self.pool.tapes:erase_marker(tape)
+            if not succeeded:self.B.clear(self.output);self.B.home(self.output)
+            self.closed=True
+        return self.output
+
+    def consume(self):
+        need(self.closed and self.pending,'one protected expansion return')
+        self.B.clear(self.output);self.B.home(self.output);self.pending=False
+
+    def close(self):
+        need(self.closed and not self.pending and not self.finished,'quiescent expansion adapter')
+        self.finished=True
+        self.volume.close();self.codec.abort()
+        for tape in self.codec.templates:self.B.clear(tape);self.B.home(tape)
diff --git a/research/fine-expansion-page-admission/source_binding.py b/research/fine-expansion-page-admission/source_binding.py
new file mode 100644
index 0000000000..8cdb5820b1
--- /dev/null
+++ b/research/fine-expansion-page-admission/source_binding.py
@@ -0,0 +1,55 @@
+"""Whole-file pins and named source clauses, without projected execution.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from contextlib import contextmanager
+from hashlib import sha1,sha256
+import ast,importlib.util,json,sys
+from pathlib import Path
+HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1]
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+def authenticate():
+    counts=[]
+    for name in ('SOURCES.json','DEPENDENCIES.json'):
+        rows=json.loads((HERE/name).read_text())['files']
+        for row in rows:
+            p=ROOT/row['path'];need(p.is_file() and not p.is_symlink(),'regular pinned source')
+            raw=p.read_bytes()
+            need(sha256(raw).hexdigest()==row['sha256'] and
+                 sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==row['git_blob'],
+                 'exact source bytes '+row['path'])
+        counts.append(len(rows))
+    return counts
+
+def node_at(text,names):
+    node=ast.parse(text)
+    for name in names:
+        selected=[n for n in node.body if isinstance(n,(ast.ClassDef,ast.FunctionDef)) and n.name==name]
+        need(len(selected)==1,'one bound source clause');node=selected[0]
+    return ast.dump(node,include_attributes=False)
+
+def bind_clauses():
+    rows=json.loads((HERE/'CLAUSES.json').read_text())['clauses']
+    for row in rows:
+        node=node_at((ROOT/row['path']).read_text(),row['names'])
+        need(sha256(node.encode()).hexdigest()==row['sha256'],'bound original source clause')
+    return len(rows)
+
+def load(name,path):
+    need(name not in sys.modules,'cold source module '+name)
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec);sys.modules[name]=module;spec.loader.exec_module(module)
+    return module
+
+@contextmanager
+def opened():
+    authenticate();old=sys.path[:]
+    gaussian=load('gaussian_sources',ROOT/'research/physical-gaussian-core/gaussian_sources.py')
+    try:
+        with gaussian.opened() as state:
+            state.B=load('_expansion_return_tapes',HERE/'retained/halo_tapes.py')
+            state.codec=load('_expansion_return_codec',HERE/'retained/boundary_codec.py')
+            yield state
+    finally:sys.path[:]=old
diff --git a/research/fine-expansion-page-admission/verify.py b/research/fine-expansion-page-admission/verify.py
new file mode 100644
index 0000000000..9795570ec1
--- /dev/null
+++ b/research/fine-expansion-page-admission/verify.py
@@ -0,0 +1,128 @@
+"""Bounded source-admission mathematics and actual native-word return seam.
+No native expansion Tile, coefficient producer or complete prefix executes.
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+"""
+from fractions import Fraction
+from hashlib import sha256
+import json
+from pathlib import Path
+import sys
+HERE=Path(__file__).resolve().parent;sys.path.insert(0,str(HERE))
+from source_binding import authenticate,bind_clauses,opened,need,node_at,ROOT
+from admission import trunc_div
+from check_exact import checks
+
+def decode(text,q):
+    width=q+2;result=[]
+    for row in text.split('#')[:-1]:
+        need(len(row)==2*width,'complete external record')
+        pair=[]
+        for at in (0,width):
+            word=row[at:at+width]
+            value=int(word[1:],2)*(-1 if word[0]=='1' else 1)
+            need(value or word[0]=='0','canonical signed zero');pair.append(value)
+        result.append(tuple(pair))
+    return result
+
+def main():
+    pins=authenticate();clauses=bind_clauses();mathematics=checks()
+    # AST fingerprints bind the reviewed clauses, without projected execution.
+    mutations=0
+    import ast
+    for row in json.loads((HERE/'CLAUSES.json').read_text())['clauses']:
+        parsed=ast.parse((ROOT/row['path']).read_text());target=parsed
+        for name in row['names']:target=next(n for n in target.body if isinstance(n,(ast.ClassDef,ast.FunctionDef)) and n.name==name)
+        number=next((n for n in ast.walk(target) if isinstance(n,ast.Constant) and type(n.value) is int),None)
+        if number is None:continue
+        number.value+=1
+        need(sha256(ast.dump(target,include_attributes=False).encode()).hexdigest()!=row['sha256'],'source clause mutation detected')
+        mutations+=1
+    with opened() as state:
+        from return_codec import ExpansionReturn
+        from cardinal_counts import Count
+        from records import Tape
+        from ring_words import Signed,write_signed
+        from router_metadata import owned
+        from session import initialize_marker,erase_marker
+        from check_support import no_decode
+        from words import BLANK
+        q,J,T,S=12,3,16,9
+        values=[(((-1)**i)*(123+11*i),((-1)**(i//2))*(87+7*i)) for i in range(T)]
+        need(all(a*a+b*b<1<<(2*q-4) for a,b in values),'fixture quarter-disk words')
+        def native_field(rows):
+            tape=Tape();erase_marker(tape);initialize_marker(tape)
+            with owned(Count.literal(q+2)) as (width,):
+                for pair in rows:
+                    for value in pair:
+                        with owned(Signed(Count.literal(abs(value)),value<0)) as (word,):write_signed(word,tape,width)
+            tape.rewind();return tape
+        native=native_field(values);saved=bytes(native.cells)
+        volume=Count.literal(T);saved_volume=bytes(volume.tape.cells)
+        machine=ExpansionReturn(state,volume,q,J)
+        with no_decode():returned=machine.run(native)
+        actual=decode(returned.inspect(),q)
+        expected=[(trunc_div(a,1<<J),trunc_div(b,1<<J)) for a,b in values]
+        need(actual==expected,'actual dimension-changing codec matches independent dyadic oracle')
+        error=max(abs(Fraction(a,1<<q)-Fraction(c,1<<(q+J)))+abs(Fraction(b,1<<q)-Fraction(d,1<<(q+J)))
+                  for (a,b),(c,d) in zip(actual,values))
+        need(error<Fraction(2,1<<q),'paid final scale/drop component error')
+        need(bytes(native.cells)==saved and native.head==1,'borrowed native body and origin')
+        need(bytes(volume.tape.cells)==saved_volume and volume.tape.head==1,'borrowed encoded target Count')
+        try:machine.run(native)
+        except ValueError:pass
+        else:raise ValueError('missing protected pending return')
+        need(decode(returned.inspect(),q)==expected,'protected pending bytes')
+        output_hash=sha256(returned.inspect().encode()).hexdigest();machine.consume()
+        failures=[]
+        for label,rows in (('short_native',values[:-1]),('long_native',values+[(0,0)])):
+            bad=native_field(rows);saved_bad=bytes(bad.cells)
+            try:
+                with no_decode():machine.run(bad)
+            except ValueError:failures.append(label)
+            else:raise ValueError('missing native volume failure')
+            need(machine.closed and not machine.pending and not machine.pool.live,'failure closes adapter')
+            need(bytes(bad.cells)==saved_bad and bad.head==1,'failed borrowed volume body and origin')
+            bad.clear();erase_marker(bad)
+        # Original compact S clock is valid syntax but cannot clock a T return.
+        old_clock=state.B.Tape('old compact S source clock','0'*(2*(q+2))+'#')
+        state.B.clear(old_clock)
+        for _ in range(S):
+            for symbol in '0'*(2*(q+2))+'#':state.B.append(old_clock,symbol)
+        state.B.home(old_clock)
+        wrong=state.codec.Codec(state.B,Tape,BLANK,initialize_marker,erase_marker,state.codec.Format(q+2,q,q+2,q,J))
+        try:
+            with no_decode():
+                wrong.prepare_input(old_clock);wrong.prepare_return(native,old_clock)
+        except ValueError as error_message:
+            need('extra native output' in str(error_message),'old S-clock failure at complete native extent')
+            failures.append('old_S_clock')
+        else:raise ValueError('old source clock incorrectly admits enlarged return')
+        finally:
+            wrong.abort();state.B.clear(old_clock)
+            for template in wrong.templates:state.B.clear(template);state.B.home(template)
+        # Native input/count/work aliases are rejected before any conversion.
+        for alias in (machine.volume.tape,volume.tape,machine.codec.input,machine.pool.tapes[0]):
+            try:machine.run(alias)
+            except ValueError:failures.append('native_metadata_or_work_alias')
+            else:raise ValueError('missing native ownership rejection')
+        need(bytes(native.cells)==saved and native.head==1,'borrowed field survives all controls')
+        need(all(t.head==1 and all(v==BLANK for v in t.cells) for t in machine.pool.tapes),'native scratch erased at canonical origins')
+        need(machine.clock.inspect()==machine.output.inspect()=='' and not machine.codec.active,'external helper fields erased')
+        need([(trunc_div(a,1<<(J+2)),trunc_div(b,1<<(J+2))) for a,b in values]!=expected,'double-counted expansion bits control')
+        need(values!=expected,'omitted final scale control')
+        machine.close()
+        # Actual coarse final shift can erase a bounded field: radius is not accuracy.
+        eraser=ExpansionReturn(state,volume,q,q+1)
+        with no_decode():zero=eraser.run(native)
+        need(decode(zero.inspect(),q)==[(0,0)]*T,'actual coarse-grid erasure control')
+        eraser.consume();eraser.close();volume.close();native.clear();erase_marker(native)
+        receipt=dict(canonical_inputs=pins[0],public_files=pins[1],source_clauses=clauses,source_clause_mutations=mutations,
+                     mathematics=mathematics,native_return=dict(T=T,old_S=S,q=q,J=J,output=actual,
+                     output_sha256=output_hash,component_l1_projection_error=str(error),
+                     failures=failures,actual_coarse_erasure=True,complete_prefix_executed=False,
+                     production_Tile_executed=False,production_Fourier_executed=False),
+                     claim='fine-family expansion producer/page admission and declared slow-reference interface; no new kappa')
+    print('PASS_FINE_EXPANSION_PAGE_ADMISSION')
+    print(json.dumps(receipt,sort_keys=True,indent=2))
+
+if __name__=='__main__':main()