From ad6a7bf2213130719e9bf2022d01a30c79638f17 Mon Sep 17 00:00:00 2001
From: CubeJerry <80299683+CubeJerry@users.noreply.github.com>
Date: Mon, 9 Nov 2026 06:51:38 +0800
Subject: [PATCH] research: execute source-bound banded forward actions

Implement the fixed-tape nilpotent forward caller with actual broad-reference pages, complete rounding and storage bounds, and independent source/output checks.

No new kappa. Prepared for @CubeJerry with substantial OpenAI Codex assistance and separate source-aware AI verification.
---
 .../INDEPENDENT-PHYSICAL.json                 |  39 ++
 .../INDEPENDENT-PROOF.md                      | 178 +++++++
 .../physical-banded-forward-action/PROOF.md   | 344 +++++++++++++
 .../physical-banded-forward-action/README.md  | 109 ++++
 .../RESULT.json                               | 476 ++++++++++++++++++
 .../SOURCES.json                              | 106 ++++
 .../physical-banded-forward-action/TASK.json  |  84 ++++
 .../VERIFY.json                               |  64 +++
 .../physical-banded-forward-action/action.py  | 149 ++++++
 .../check_independent.py                      |  13 +
 .../physical-banded-forward-action/fixture.py | 205 ++++++++
 .../independent_forward.py                    | 240 +++++++++
 .../oracle_checks.py                          |  44 ++
 .../physical-banded-forward-action/pages.py   | 172 +++++++
 .../reference_source.py                       | 114 +++++
 .../retained/fast_boundary.py                 |  79 +++
 .../retained/seven_product.py                 | 286 +++++++++++
 .../physical-banded-forward-action/sources.py |  47 ++
 .../physical-banded-forward-action/verify.py  |  93 ++++
 19 files changed, 2842 insertions(+)
 create mode 100644 research/physical-banded-forward-action/INDEPENDENT-PHYSICAL.json
 create mode 100644 research/physical-banded-forward-action/INDEPENDENT-PROOF.md
 create mode 100644 research/physical-banded-forward-action/PROOF.md
 create mode 100644 research/physical-banded-forward-action/README.md
 create mode 100644 research/physical-banded-forward-action/RESULT.json
 create mode 100644 research/physical-banded-forward-action/SOURCES.json
 create mode 100644 research/physical-banded-forward-action/TASK.json
 create mode 100644 research/physical-banded-forward-action/VERIFY.json
 create mode 100644 research/physical-banded-forward-action/action.py
 create mode 100644 research/physical-banded-forward-action/check_independent.py
 create mode 100644 research/physical-banded-forward-action/fixture.py
 create mode 100644 research/physical-banded-forward-action/independent_forward.py
 create mode 100644 research/physical-banded-forward-action/oracle_checks.py
 create mode 100644 research/physical-banded-forward-action/pages.py
 create mode 100644 research/physical-banded-forward-action/reference_source.py
 create mode 100644 research/physical-banded-forward-action/retained/fast_boundary.py
 create mode 100644 research/physical-banded-forward-action/retained/seven_product.py
 create mode 100644 research/physical-banded-forward-action/sources.py
 create mode 100644 research/physical-banded-forward-action/verify.py

diff --git a/research/physical-banded-forward-action/INDEPENDENT-PHYSICAL.json b/research/physical-banded-forward-action/INDEPENDENT-PHYSICAL.json
new file mode 100644
index 0000000000..a3b4bddf53
--- /dev/null
+++ b/research/physical-banded-forward-action/INDEPENDENT-PHYSICAL.json
@@ -0,0 +1,39 @@
+{
+  "source": {
+    "kind": "broad",
+    "original_inverse_identity_entries": 32,
+    "schur_inverse_identity_entries": 8,
+    "narrow_substitution_distinguished": true,
+    "reference_sha256": "156be0b0199657b95b636597b332b378a1fe82d1a80e8b9cc84eaf90425694c5"
+  },
+  "cases": {
+    "broad": {
+      "complex_error": "346358033082657087202940729/318985786077664953201356615712768",
+      "complex_error_decimal": 1.0858102404548134e-06,
+      "rounding_error": "15/16777216",
+      "matrix_calls": 2,
+      "scalar_products": 98,
+      "output_sha256": "1ddd68794b1acd24f39601bb4d462bdac8cfa9f6a409fb153022557f9ad167b5"
+    },
+    "singular": {
+      "complex_error": "1/128",
+      "complex_error_decimal": 0.0078125,
+      "rounding_error": "29/4096",
+      "matrix_calls": 6,
+      "scalar_products": 294,
+      "output_sha256": "67baafe96a83c187b4a19c46bf1289053373836eb08616b9744b126951af9ad5"
+    },
+    "long_to_short": {
+      "complex_error": "0",
+      "complex_error_decimal": 0.0,
+      "rounding_error": "0",
+      "matrix_calls": 6,
+      "scalar_products": 6,
+      "output_sha256": "af5570f5a1810b7af78caf4bc70a660f0df51e42baf91d4de5b2328de0e83dfc"
+    }
+  },
+  "owned_roles": 2788,
+  "action_sha256": "c10d2daa72446d02326bf1f368f10fd1e6bb27c60477ccc16a288d1fb3d59688",
+  "pages_sha256": "80d53c429af883507f817ec467f09de1a57ede342e244afbf83b753b31196a2c",
+  "oracle_sha256": "77b926bfdabcaac64516b13e50842958cc6db17f4a8ceae9b6879a9131548334"
+}
diff --git a/research/physical-banded-forward-action/INDEPENDENT-PROOF.md b/research/physical-banded-forward-action/INDEPENDENT-PROOF.md
new file mode 100644
index 0000000000..2c4b84e3bd
--- /dev/null
+++ b/research/physical-banded-forward-action/INDEPENDENT-PROOF.md
@@ -0,0 +1,178 @@
+# Independent nilpotent forward-action review
+
+Prepared for **@CubeJerry** with separate source-aware OpenAI AI verification.
+This is independent source/page and arithmetic reasoning, not human or
+proof-assistant review. The algebraic lift and retained solver are inherited;
+the reviewed contribution is their concrete fixed-tape forward composition.
+**No new κ or discharged global multiplication assumption is asserted.**
+
+## 1. Exact page commutation
+
+Let F be a real rational n-by-n matrix, n≥1. Put target t_i=2i and source
+s_j=2j+1, and define N[t_i,s_j]=−F_ij, with all other entries zero. The two
+sets are disjoint. Every product of two entrywise-masked pieces of N vanishes.
+Split N into strictly lower, diagonal and strictly upper block pieces
+N_L,N_D,N_U. Assume the **exact source before rounding** satisfies
+`|t_i−s_j|≤b` for nonzero F_ij, with dyadic block b. Then
+
+\[
+ L=I+N_L,\quad U=I+N_D+N_U,\quad LU=I+N.
+\]
+
+The factors have the adjacent-block support admitted by the retained
+preparer. Lower inverse diagonal pages are I; upper ones are I−N_D.
+This holds for singular, nonsymmetric or signed F: F is never inverted.
+
+Let τ be truncation toward zero to h=2^−P and Fhat=τ(F). An N entry never lies
+on the scalar diagonal, since an even target differs from an odd source.
+The inverse-page formula is therefore affine on disjoint entries: exact scalar
+ones stay ones, and each other nonzero coefficient is a signed F_ij. The
+identities `τ(−x)=−τ(x)` and `τ(τ(x))=τ(x)` prove that pre-rounding F before
+exact factor serialization produces **identical four rounded page banks**
+to exact F followed by the preparer's rounding.
+
+Identity padding adds no coupling. Simultaneously reversing rows and columns
+is a permutation, commutes with τ, and preserves disjoint support even if it
+exchanges parity labels. Thus the statement includes the retained **padded
+upper reversal**, coupling banks, incomplete blocks and exact signed bits,
+provided the common scalar width suffices.
+
+Exact support must be checked first: a tiny off-band entry could round away
+and make only the shortened path admissible. The producer rejects this case.
+Floor rounding on negative coefficients would also break the equality.
+
+## 2. Independent no-feedback semantics
+
+Lift input x by y[t_i]=0 and y[s_i]=x_i. Every source row remains bit-exact:
+coupling rows there vanish and diagonal rows are identity. A rounded target
+value never enters any subsequent coupling source.
+
+Partition row i's Fhat dot sum by whether its source block is lower than,
+higher than, or equal to the target block. Call the three sums a_i,c_i,d_i.
+The projected target is exactly
+
+\[
+ \tau\bigl(\tau(\tau(a_i)+c_i)+d_i\bigr).                 \tag{1}
+\]
+
+Absent updates truncate an already-grid value and do nothing. Equation(1)
+is the independent oracle: **three disjoint complete dot sums**, rather than
+a second implementation copied from the author's block-solver recurrence.
+
+Let each logical complex input satisfy `|Re x_j|+|Im x_j|≤R`. Its components
+are supplied as separate real columns; an unpaired final real column has
+imaginary part zero. If s_i counts the nonzero exact F coefficients in row i,
+source quantization contributes at most s_i R h. Three effective roundings
+contribute at most 3h to each real component. Consequently
+
+\[
+ |\Re(\widehat{Fx}-Fx)_i|+|\Im(\widehat{Fx}-Fx)_i|
+       \le (s_iR+6)2^{-P}.                                \tag{2}
+\]
+
+No number of blocks or inverse norm multiplies this bound. The exact target
+is the original F product, not Fhat alone or F inverse. A separate finite
+three-block example gives staged numerator 0 whereas one completed-dot
+rounding gives 2, so the rounding semantics cannot be interchanged.
+
+## 3. Range
+
+Set ρ=||F||∞. Inward coefficient quantization cannot increase absolute entry
+values. At every partial target stage, each coefficient has been used at most
+once. Triangle inequality and the magnitude-decreasing property of truncation
+bound each target state and completed target residual by ρR in component-l1
+norm; source states stay bounded by R. No accumulated-rounding allowance is
+needed for this **range** argument.
+
+A common scalar carrier must cover `max(1,R,ρR,max_ij |Fhat_ij|)` strictly
+below its positive signed limit. If this maximum is C≥1, the conservative
+choice `w=P+2+ceil(log2 C)` suffices. Descriptor widths are separate. Exact
+matrix returns still use `2w+log2 b+2` bits and SevenProduct's independently
+proved internal U/V guards. The scalar-state bound cannot replace them.
+
+## 4. Complete ceilings and retained history
+
+Write c for the number of **real columns**, distinct from the radius R. Let
+
+\[
+ K_0=\lceil n/b\rceil,\quad K=\lceil2n/b\rceil,
+ J=\lceil c/b\rceil.
+\]
+
+The input and projected output each contain J K_0 b² scalar words in the
+retained batch-major ABI, including row and inactive-column padding. The
+interleaved input and child output each contain J K b² words. Every child
+batch uses K diagonal and K−1 coupling products in each of its two passes.
+Thus the exact matrix-call count is
+
+\[
+ Q_b=2(2K-1)J,                                            \tag{3}
+\]
+
+with exactly `Q_b 7^log2 b` scalar leaves. No n/b or c/b approximation is
+substituted for these ceilings. b=1 and partial rows/columns remain covered.
+The four page banks themselves contain `2(2K−1)b²` scalar words.
+
+The parent fills its entire interleaved stream, calls the retained child once
+on all batches, then projects. Its live/backing space must therefore include
+the **whole** J K b²w-bit interleaved input and child protected return, plus
+the whole J K_0 b²w-bit parent output. This is not a per-batch O(nb w) bound
+independent of c. Borrowed input/pages and preparation storage are additional.
+
+Parent interleaving/projection scans and restoration are linear in these
+stream extents, with encoded local counters charged. The unchanged child
+receives the global column count c: its padding validation copies/compares
+encoded column offsets, so generic accounting must retain their log c work
+or an explicit caller premise absorbing it. B7's local-column-only invoice
+does not transfer automatically to this different single-child interface.
+
+Across repeated calls, sum the maximum visited extent of **each fixed role**
+over its entire history, including erased parent buffers and inactive
+arithmetic descendants. Source cache/rational preparation height and page
+serialization stay in the separately paid setup bill. Clearing does not
+deallocate historical tape backing.
+
+## 5. Independent original source and completed finite review
+
+For the current `Reference(61,3,2,1,3,32)`, the source checker reads **broad**
+entries of the full original `[16,20)` window Q and inverts Q by pivoted
+triangular elimination/back-substitution. Both inverse identities are checked.
+It obtains F by inverting `(Q^-1)_{J,J}` for J=(0,3), independently of the
+producer's A-inverse Schur calculation. Replacing broad Q with narrow Q gives
+a different matrix and is explicitly distinguished. This is a finite exact
+rational Reference claim, not an arbitrary-cap or ideal-Gaussian statement.
+
+The independent observer matches actual physical packed outputs, zero
+padding, hashes, matrix counts and scalar counts for all three retained runs:
+
+| Case | Shape / grid | Matrix products | Scalar leaves | Original complex-l1 error |
+|---|---|---:|---:|---:|
+| Actual broad Schur | n=2, c=3, b=4, P=20, w=28 | 2 | 98 | approximately 1.08581024e−6 |
+| Signed nongrid singular | n=3, c=3, b=4, P=8, w=16 | 6 | 294 | 1/128 |
+| Same-owner short zero | n=1, c=1, b=1, P=4, w=8 | 6 | 6 | 0 |
+
+The signed source is one third of the three-vertex path Laplacian. Its exact
+rational rank is two. At the **chosen P=8**, truncation gives 85/256 times the
+integer Laplacian and still has rank two; a nonzero two-by-two minor and its
+constant nullvector certify this. This is not a general preservation claim:
+at P=7 the rounded matrix has nonzero determinant and rank three. The primitive
+needs neither exact nor rounded F to be invertible.
+
+Separate finite controls distinguish negative floor rounding, the wrong
+lift sign, nonzero target initialization, an exact tiny off-band entry that
+would disappear on the grid, and one-shot instead of three-stage rounding.
+These are external oracle controls; the physical fixture separately executes
+alias, padding, pending-return and after-child truncation rejection controls.
+All 2,788 owned roles are erased after the actual physical sequence, including
+the larger-to-smaller reuse. This is not an independent implementation of
+the scalar multiplier.
+
+Reviewed source hashes:
+
+* `action.py`: `c10d2daa72446d02326bf1f368f10fd1e6bb27c60477ccc16a288d1fb3d59688`.
+* `pages.py`: `80d53c429af883507f817ec467f09de1a57ede342e244afbf83b753b31196a2c`.
+* Independent oracle: `77b926bfdabcaac64516b13e50842958cc6db17f4a8ceae9b6879a9131548334`.
+
+The package's final paper retains global-r buffers, global column-control
+cost, full ceilings and separately paid source preparation. No blocking
+mathematical or interface discrepancy remains in these reviewed versions.
diff --git a/research/physical-banded-forward-action/PROOF.md b/research/physical-banded-forward-action/PROOF.md
new file mode 100644
index 0000000000..fc484cbfbf
--- /dev/null
+++ b/research/physical-banded-forward-action/PROOF.md
@@ -0,0 +1,344 @@
+# A literal banded forward action through a nilpotent lift
+
+This package implements one supplied real band-matrix action on encoded RHS
+columns. Its finite source is a Schur matrix of the **broad** current rational
+Reference. It does not implement a whole broad Gaussian word, a union router,
+an outer multiplication algorithm, or a new selected exponent. **No new κ.**
+
+The elementary lift, Strassen identity and generic Gaussian conditioning are
+not new claims. The contribution is the complete fixed-role zero/interleave,
+existing physical inverse-page call, projection and restoration transaction;
+its source-bound dyadic page preparation; and its explicit full bill.
+
+## 1. Exact function and input contract
+
+Let F be an n-by-n real rational matrix, n>0, with half-band v and at most s
+nonzero coefficients per row. Let Γ≥||F||∞. In particular s≤2v+1. F may be
+singular. Let b be dyadic with b≥2v+1. The producer checks the exact interleaved
+support **before** coefficient rounding: a tiny out-of-band coefficient cannot
+silently turn an invalid source into a valid one by disappearing on the grid.
+
+For r>0 real RHS columns, put
+
+    J = ceil(r/b), K0 = ceil(n/b), K = ceil(2n/b),
+    N0 = K0 b, N1 = K b.
+
+The source has J batches, each N0 rows by b columns in row-major order. A word
+is the retained width-w two's-complement, least-significant-bit-first encoding
+of its numerator on the 2^-P grid. P<w. Rows at least n and columns at least r
+are zero. The output has exactly this same padded layout. Pairing real columns
+as real and imaginary components gives the complex-l1 contract below; an odd
+last real column is also permitted.
+
+All five source tapes (input and four coefficient banks) are distinct and
+outside the complete owned closure. Metadata ports may alias each other, but
+not data ports or owned tapes. Every port begins at its left-marker origin.
+`run` returns one protected output; `consume` must erase it before the next
+call. Moving the returned head does not remove this obligation.
+
+The four coefficient banks having the prescribed source/lift semantics is an
+**admission premise**, established by the authenticated preparer and its source
+receipt. The online caller checks port ownership, encoded geometry, binary
+extents and padding; it does not authenticate the mathematical values of
+arbitrary supplied coefficient banks.
+
+## 2. Interleaving and exact prepared-page equality
+
+For each i interleave a fresh zero target at position 2i and the source value
+at 2i+1. Define
+
+\[
+ N_{2i,2j+1}=-F_{ij},\qquad N_{kl}=0\text{ otherwise}.
+\]
+
+Its half-band is at most 2v+1. Target rows and source columns are disjoint, so
+any product of two matrices with this mask vanishes. Split N into strictly
+lower, diagonal and strictly upper **blocks** N_L,N_D,N_U. Then
+
+\[
+ L=I+N_L,\quad U=I+N_D+N_U,\quad
+ LU=I+N,\quad (LU)^{-1}=I-N.                                \tag{1}
+\]
+
+In particular `(I+N)^-1(0,x)=(Fx,x)`. At b covering the band, L and U are block
+bidiagonal. L's diagonal inverse blocks are I, while U's are I−N_D. These
+blocks have positive unit no-pivot elimination pivots: every nonidentity
+entry goes from a source column to a target row, and no second such entry can
+follow it. Inverting these blocks never requires F to be invertible.
+
+Let τ be componentwise real truncation toward zero at P fractional bits.
+Setup first computes `Fhat=τ(F)` exactly, constructs the corresponding dyadic
+factors, serializes them as exact retained Matrix objects, and **executes
+unchanged physical `prepare_pages`**. This produces exactly the same bytes as
+preparing the unrounded exact-F factors and rounding their final pages:
+
+* Preceding-block pages contain only signed entries of F, and τ(−x)=−τ(x).
+* Every inverse diagonal block is I minus its masked block. The mask has zero
+  scalar diagonal, so no truncation of `1+x` occurs. Identity and zero entries
+  remain exact, and off-diagonal entries again commute with τ and sign.
+* Padding by identity and reversal are permutations of this same identity.
+
+Thus pre-rounding changes the setup height without changing the inherited
+online rounded function. The source's `expected_pages` is an observer only;
+its values are never supplied to the physical consumer. The independent
+checker instead inverts exact diagonal blocks, computes both page routes and
+compares each to the actual physical page words.
+
+## 3. Literal transaction, restoration and fixed owners
+
+`action.py` uses one BandedAction owner, a fixed pool of 128 local roles, a
+dilated tape, an output tape and the unchanged FastBoundaryPages child. Its
+complete constructor closure is 2,788 physical roles. Tape constructors are
+sealed throughout online execution. Count values, loop indices and record
+dimensions remain encoded; the online program never decodes a matrix size,
+payload word, coefficient or numerical answer into a host integer.
+
+The wrapper scans each input batch. For each real row it writes b zero words
+and copies the b source words. It validates and discards the input's row pad,
+then writes only the necessary N1−2n lifted row pad. It does not double N0
+blindly: when n is ragged, `ceil(2n/b)` and `2 ceil(n/b)` can differ.
+
+It suspends its local scratch scope around **one complete** child call with
+dimensions `(2n,r,b,w,P)`. The child retains its full batch/row ceiling invoice
+and unchanged exact-product-then-rounding ABI. The wrapper projects each even
+row and compares every recovered odd-row bit with the original borrowed source
+row. It checks all lifted padding, restores the original row padding, consumes
+the child, and rewinds every input/page/metadata port.
+
+Successful return protects the complete output until consume. All other owned
+roles are erased, with left markers released; consume also erases output.
+Exception cleanup consumes any child return, clears partial dilation/output,
+closes the pool, releases markers and restores every borrowed port. Tests
+include a truncated coupling after a completed matrix child, so this assertion
+is not based only on preflight failures.
+
+The largest local live set has eleven persistent Count descriptors, at most
+three nested iterator/copy activations, and bounded arithmetic temporaries.
+The same fixed helper implementations used by the retained wrapper fit a
+conservative 64-local-role envelope, below the 128 available roles. Child
+execution suspends that local pool rather than borrowing its remaining roles.
+No dimension-dependent Python stack, list of tapes or recursively live owner
+is created by `run`.
+
+The underlying Tape clear scans the **live prefix to the first blank**. Every
+call clears that prefix before shorter reuse, leaving its already blank
+historical suffix intact. Retained backing remains part of space; it is not
+rescanned merely because a later call is short. The same owner executes a
+larger singular case followed by a one-row/one-column call, and every retained
+cell is checked blank afterward. Copying, comparison, zero creation, rewind,
+projection and erasure are all charged.
+
+## 4. Error and scalar range
+
+Assume the actual input maximum complex-l1 norm is at most R≥1 and the input is
+already on the common grid. This is a mathematical admission promise, not an
+unimplemented modulus-check claim. Earlier grid conversion belongs to the
+caller. Put h=2^-P. The quantized source satisfies
+
+\[
+ \|\widehat F-F\|_\infty\le sh,\qquad
+ \|\widehat F\|_\infty\le\Gamma.
+\]
+
+Throughout both physical passes, source rows stay exact. Target errors are
+never read as sources of a nonidentity coefficient. Each target is assembled
+from three disjoint sets of original source columns: lower-block, upper-block
+and same-block contributions. The lower inverse page is identity and adds no
+effective rounding. There are at most three effective scalar truncations, or
+six ulps for a complex pair. Therefore
+
+\[
+ \|\widehat y-Fx\|_*\le(sR+6)2^{-P}.                       \tag{2}
+\]
+
+This need not equal a single completed-dot truncation of Fx. The independent
+oracle forms those three disjoint dot sums directly rather than copying the
+block-solver recurrence. It also compares the returned values with the original
+unrounded F.
+
+Inward rounding cannot increase a partial absolute row-sum budget. Since each
+coefficient appears in exactly one of the three sets, stored targets have
+magnitude at most ΓR and sources at most R. This includes complete residuals
+and solved states; it avoids multiplying a `(1+Γ)` factor once per block.
+A sufficient target-q allocation is
+
+\[
+ P\ge\max(P_{\rm in},q+\lceil\log_2(sR+6)\rceil+1),\qquad
+ w\ge P+2+\lceil\log_2(\max(1,\Gamma)(R+1))\rceil,           \tag{3}
+\]
+
+with metadata widths separately charged. Exact root products and recursive
+Strassen scratch do not remain masked. They use the retained general guards
+`U=w+ell+2`, `V=2w+4ell+4`, and exact returned width `2w+ell+2`, where
+`ell=log₂b`. These are not replaced by the smaller stored-state bound.
+
+For the actual broad source `F=D-C A^-1 B`, the source's retained admission
+`E_M Qideal≤1/2` and row/column bounds give `||A^-1||≤2Qideal` and
+`Γ=3+18Qideal`. No broad F inverse or broad row gap is needed. The finite fixture
+instead computes and reports the exact inverse norm of its small A and exact
+norm of F. It makes no arbitrary-cap or ideal-Gaussian claim.
+
+Only with `q,P_in,log R,log Γ=O(p)` do scalar widths become O(p). Tensor use
+also needs the accumulated `g log(1+Γ)` guard funded. Under the particular
+capped broad source conditioning in GAUSSIAN.md, Γ is polynomial in p and
+`g=p^beta`, beta<1, gives an o(p) guard. An arbitrary fixed Reference does not
+automatically satisfy those premises. Neither the other broad shears nor that
+whole-source composition is implemented here.
+
+## 5. Complete online ceiling and space invoice
+
+With K,J from section 1, exactly
+
+\[
+ Q_{\rm prod}=2(2K-1)J
+\]
+
+matrix products occur, each with `7^ell` actual scalar children. Write
+`omega=log₂7`, `Lambda=1+ell+ceil(log₂(w+2))`, and let M(u) be the complete bit
+cost of the inherited independent scalar-word product at width u. Retain
+
+\[
+ Q_{\rm prod}\,O\!\left(b^\omega[
+ M(w+\ell+2)+(2w+4\ell+4)\Lambda^3]\right)                  \tag{4}
+\]
+
+for all matrix arithmetic and its quadrant/parked-frame movement. The inherited
+caller adds
+
+\[
+ O\!\left(KJb^2[w+\log(2n+r+2)+\ell+1]\Lambda^3\right).    \tag{5}
+\]
+
+Here `h=ceil(log₂(2n+r+2))` is retained explicitly. This wrapper calls the child
+once with the **global r**, so exponentially many lines do not give
+`h=O(log p)` merely because n and b are polynomial in p. The primitive claims
+no production boundary margin obtained by dropping h. A later streaming wrapper
+could call local b-column transactions, or a complete outer proof could fund
+the displayed global-column overhead; neither substitution is made here.
+
+The wrapper's input/output extent is `I=J K0 b²w`; the dilation extent is
+`D=J K b²w≤2I`. All copying, inserted zeros, source-row comparisons, projection,
+clears and rewinds cost O(I+D), plus `O(J N0 log(n+2))` for the explicit row
+comparisons and a fixed polynomial in the encoded startup dimensions. The
+encoded outer `indices(J)` loop uses amortized binary increment/decrement;
+there is no repeated scan of a log r counter for every payload bit. Keeping
+the startup polynomial separately is safe, and these terms are absorbed by
+(5) in the usual sufficiently large admitted regime.
+
+The output and dilated buffers store **all r columns**, not merely one b-column
+batch. Current storage is their complete I+D bits, the inherited child storage,
+input/page banks, descriptors and all previously retained backing extents.
+Live-prefix erasure prevents an extra old-high-water rescan tariff, but does
+not remove historical extents from the space count. The long-to-short receipt
+records that those extents remain allocated and erased. The physical role
+count is constant, while the number of occupied/retained cells is not.
+
+When both `2n≥b` and `r≥b`, the product count in (4) simplifies to
+`O(nr b^(omega−2))`. In general retain
+
+\[
+ O(nr b^{\omega-2}+(n+r)b^{\omega-1}+b^\omega).
+\]
+
+With b=O(W), this has the desired band exponent; it is not by itself a global
+supplier or multiplication bound. Headers, field exposure and page-key grouping
+are outside this already-packed input ABI. There is no hidden tensor-sized
+integer argument charged at a scalar width.
+
+## 6. Separately paid source and page setup
+
+The setup is independent of online payloads. The finite source takes entries
+of the authenticated current **broad** Reference on `[16,20)`, validates the
+original phase-pure interior `{1,2}`, and computes its exact rational Schur F
+on `{0,3}`. This is an explicit admitted partition, not a claim that the
+production carve selects that interior. The independent source oracle obtains
+F by inverting the J-principal block of the full original Q inverse, using
+pivoted triangular elimination/back-substitution instead of the producer's
+interior inverse. It explicitly distinguishes substitution of the narrow Q.
+
+For a general supplied rational F let H_F bound its input numerator/denominator
+heights. Pre-rounding costs `O(n²(H_F+P)^3)` by conservative elementary rational
+division, including complete input reads. After that, the factor coefficients
+have height `H=O(P+log(Γ+1)+log(n+b+2)+1)`. Unit-pivot nilpotent block elimination
+has no products of two nonidentity coefficients; its reduced intermediate
+entries and inverse pages remain in the same height envelope. All physical
+Matrix get/set scans, support checks, counter arithmetic, serialization and
+exact block inversions are paid by, for example,
+
+\[
+ C_{\rm setup}\le C_F+O(n^2(H_F+P)^3+(n+b+2)^6H^4).          \tag{6}
+\]
+
+Here C_F is the complete cost of producing the exact source F, not a free entry
+oracle. Host setup indexing can be simulated by full sequential scans of its
+finite matrices within this deliberately loose polynomial. The actual dyadic
+physical `prepare_pages` actions are separately metered in the receipt.
+
+For the current source, C_F includes canonical interval generation, exact
+coordinate arithmetic, original reference weights/cuts, and rational Schur
+formation. Those algorithms have polynomial bit cost in their numerical
+precision, period and coefficient-height parameters. In the intended
+`period=2^O(ell)` and polynomial-p setup regime this permits
+`C_F=2^O(ell)poly(p)`; the generic theorem always retains C_F explicitly.
+Any numerical admission radius supplied as a rational requires its full
+numerator/denominator description charge, not only log of its value.
+
+Fresh setup storage includes dense serialized factors of O(n²H) bits, source
+matrices of O(n²H_F), interval caches and page banks of
+`2(2K−1)b²w` bits. Historical source caches and physical tape backing remain
+charged unless a fresh/cleared namespace is used. Across repeated calls the
+same pages can be reused without recomputing F or its coefficients per RHS.
+No global catalogue amortization is asserted by this component.
+
+## 7. Evidence, provenance and limits
+
+The registered normal/optimized verifier executes three cases on one owner:
+the actual broad-reference Schur, a signed nongrid singular tridiagonal matrix,
+and a smaller one-row zero matrix. The singular matrix is
+
+\[
+ \tfrac13\begin{pmatrix}1&-1&0\\-1&2&-1\\0&-1&1\end{pmatrix}.
+\]
+
+Its constant vector is in the kernel and a 2-by-2 minor is nonzero, so its rank
+is exactly two. It has both lower and upper lifted block couplings at b4. The
+tests include partial input rows/RHS columns, exact page commutation, a tiny
+out-of-band coefficient before rounding, source/page and inactive-owned aliases,
+pending returns and failure after a completed matrix child. Every data/page/
+descriptor head, dirty spectator and owned backing cell is checked. The
+independent output oracle uses three disjoint integer dot sums; it also checks
+the exact original-F error and every padded output bit.
+
+Each receipt's `transaction_actions` includes `run`, the subsequent physical
+scan moving the returned head to its end, the attempted rejected pending
+reentry, and `consume`. It is not a claimed count of core `run` alone. Host
+fixture construction and external exact observers are separate; actual factor
+serialization/page preparation and initial payload packing have their own
+metered fields.
+
+Canonical base is `7c49fe32c55de02c2c873655c804b16e4c3fef0a`. Retained
+`seven_product.py` and `fast_boundary.py` are unchanged bytes from public fork
+commit `f821cba68f44048e70e78afb75603ed4dde99f11`, with source paths/hashes in
+SOURCES.json. The canonical actual page/Matrix runtime is from
+CrocSwap/integer-mult-bounds#5059 and its pinned physical scalar-word cohort.
+CrocSwap/integer-mult-bounds#481 already proposed batched Gaussian arithmetic
+and a written conditional tape tariff; it is closed/unmerged. Merged
+CrocSwap/integer-mult-bounds#4205 already proves the shared finite-core broad
+word/error interface at its host arithmetic boundary. We do not republish
+either generic theorem. This package supplies the specified physical forward
+primitive and preserves their remaining outer obligations.
+
+Credit the retained construction authors, Jose Manuel's shared reference/core
+integration, Mason Hale's interval arithmetic, Vlado Vojdanovski's Gaussian
+and block work, the physical scalar-word contributors, and the independently
+credited exact seven-product package. Prepared for `@CubeJerry` with substantial
+OpenAI Codex assistance. A separate source-aware AI researcher supplied the
+independent original-matrix/page/three-sum oracle. Apache-2.0. No human or proof
+assistant acceptance is claimed by the finite checks.
+
+Open next question: can the actual broad union-window caller pay its original
+coupling shear, header transport, source catalogue and current-grid conversion
+around this primitive? A first step is one frozen page key and complete
+rounded chronological transaction. No such full caller, complete Gaussian
+word, outer CRT/FFT assembly or discharge of the selected five assumptions is
+part of this result.
diff --git a/research/physical-banded-forward-action/README.md b/research/physical-banded-forward-action/README.md
new file mode 100644
index 0000000000..e3cb7fd20a
--- /dev/null
+++ b/research/physical-banded-forward-action/README.md
@@ -0,0 +1,109 @@
+# Physical banded forward action
+
+This package executes a supplied real band-matrix action on packed RHS columns
+using fixed physical tape roles. It writes fresh zero target rows, interleaves
+the borrowed sources, calls the unchanged seven-product inverse-page service
+once, projects the targets, checks source preservation bit for bit, and erases
+all owned work. It returns a protected output in the original padded layout.
+
+The construction lifts F to a square-zero matrix N with
+`N[2i,2j+1]=-F[i,j]`. Solving `(I+N)y=(0,x)` returns `(Fx,x)`, even when F is
+singular. Preparing the factors from F rounded once to the P grid yields
+exactly the same final page bytes as preparing exact F then rounding the pages.
+The verifier actually runs the unchanged physical `prepare_pages`; it does not
+feed expected page values to the consumer.
+
+**No new κ.** This is one literal forward primitive with a finite actual broad
+Reference binding. It does not implement the whole broad Gaussian word, global
+union routing, FFT/CRT recovery or any discharge of the selected five assumptions.
+
+## Exact scope and complete cost
+
+`BandedAction.run(source,pages,n,r,b,w,P)` accepts batch-major real RHS columns,
+with row and final-column padding zero. The dyadic block b covers the doubled
+interleaved band. All external ports and heads are restored. Metadata may alias
+other metadata; data ports are distinct and outside the complete owned closure.
+Call `consume()` after using the protected output.
+
+With `K=ceil(2n/b)` and `J=ceil(r/b)`, the transaction makes exactly
+`2(2K-1)J` b-by-b products, each with `7^log2(b)` actual scalar children.
+[PROOF.md](PROOF.md) retains the full scalar-word price, parked-frame movement,
+all ceiling terms, encoded counters, inserted zeros, projection, erasure,
+complete-r backing and separately paid setup. For row sparsity s and current
+complex-l1 input radius R, the error relative to original F is at most
+`(sR+6)2^-P`. Stored sources/targets stay within `max(1,||F||∞)R`; exact kernel
+scratch uses its larger inherited guards.
+
+## Reproduce
+
+From the repository root with CPython 3.12 and the standard library:
+
+```sh
+python3 -B scripts/research_package.py --package research/physical-banded-forward-action
+```
+
+Expected: all four registered normal and optimized commands pass. The physical
+commands match the exact `RESULT.json` receipt and marker
+`PASS_PHYSICAL_BANDED_FORWARD_ACTION`; the independent controls report
+`PASS_INDEPENDENT_FORWARD_CONTROLS`.
+For a direct replay:
+
+```sh
+python3 -I -B research/physical-banded-forward-action/verify.py
+```
+
+The checks execute an actual **broad** `Reference(61,3,2,1,3,32)` Schur matrix
+from window `[16,20)` with explicit interior `{1,2}`; a signed nongrid singular
+tridiagonal matrix; and a shorter one-row zero matrix on the same owner. They
+check partial rows/RHS, original source/page bindings, exact pre-round page
+equivalence, protected output, all 2,788 owned roles, aliases, corrupt padding,
+tiny out-of-band source coefficients and failure after a completed matrix child.
+
+The independent source oracle derives the Schur matrix through the full
+original broad matrix inverse and explicitly rejects narrow substitution.
+The independent output oracle forms three disjoint integer dot sums instead
+of replaying the author's block recurrence. It compares every actual returned
+bit, source preservation, original-matrix error and the complete product count.
+
+## Provenance and limits
+
+Canonical base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+The unchanged actual `seven_product.py` and `fast_boundary.py` come from public
+fork commit `f821cba68f44048e70e78afb75603ed4dde99f11`; their source paths and
+hashes are in [SOURCES.json](SOURCES.json). Canonical page preparation and the
+physical scalar-word cohort are retained from
+CrocSwap/integer-mult-bounds#5059. The same-reference broad finite-core program
+and numerical prerequisites are inherited from merged
+CrocSwap/integer-mult-bounds#4205. Closed/unmerged
+CrocSwap/integer-mult-bounds#481 already proposes batched Gaussian arithmetic;
+the generic identity and arithmetic exponent are not claimed anew here.
+
+The unchanged `reference_source.py` adapter is retained from
+[`research/shrinking-reference-halo/source.py`](https://github.com/CubeJerry/integer-mult-bounds/blob/a99c4dce9f6bf1972b13f0f239e082ac70a9e5e8/research/shrinking-reference-halo/source.py)
+at published fork commit `a99c4dce9f6bf1972b13f0f239e082ac70a9e5e8`.
+Its SHA-256 is
+`20c0fb2e4aa95de976ef6ce74ded4bf1cb9073732eca7eda8f61e45d239afa2c`.
+The source authentication and isolated Reference-loading adapter are credited
+to that predecessor package; they are not new implementation in this result.
+
+The explicit finite interior is not asserted to be the production carve's
+choice. The source target is its exact rational broad Schur, without an ideal
+Gaussian approximation claim. Input and coefficient preparation, and any
+earlier grid conversion, are separate charged work. No finite-size speedup over
+a direct matvec or competing physical implementation is claimed.
+
+## Open next questions
+
+Can one complete broad union-window caller bind its original coupling shear,
+source page key, current-grid conversion and header routing around this
+primitive? The first step is one frozen source and a full chronological physical
+transaction, with setup and partial-batch ceilings retained. The current
+already-packed ABI does not supply that caller.
+
+Prepared for `@CubeJerry` with substantial OpenAI Codex assistance. A separate
+source-aware AI reviewer supplied the independent original-matrix, page and
+three-sum oracle. Credit the original construction authors, Jose Manuel's common
+Reference/core integration, Mason Hale's interval arithmetic, the retained
+physical scalar-word and exact seven-product contributors, and the named
+predecessors above. Apache-2.0; source notices are retained. Finite checks are
+not human approval or a formal proof-assistant certification.
diff --git a/research/physical-banded-forward-action/RESULT.json b/research/physical-banded-forward-action/RESULT.json
new file mode 100644
index 0000000000..0bae4be1d7
--- /dev/null
+++ b/research/physical-banded-forward-action/RESULT.json
@@ -0,0 +1,476 @@
+{
+  "broad": {
+    "block": 4,
+    "columns": 3,
+    "controls": [
+      "pending output",
+      "source/page alias",
+      "inactive deep-owned alias",
+      "non-dyadic block",
+      "nonzero padded input row",
+      "nonzero inactive RHS column"
+    ],
+    "error_allowance": "1/131072",
+    "independent_review": {
+      "complex_error": "346358033082657087202940729/318985786077664953201356615712768",
+      "incoming_radius": "5/16",
+      "matrix_calls": 2,
+      "page_words": [
+        [
+          1048576,
+          0,
+          0,
+          0,
+          0,
+          1048576,
+          0,
+          0,
+          0,
+          0,
+          1048576,
+          0,
+          0,
+          0,
+          0,
+          1048576
+        ],
+        [],
+        [
+          1048576,
+          0,
+          0,
+          0,
+          382979,
+          1048576,
+          17382,
+          0,
+          0,
+          0,
+          1048576,
+          0,
+          90858,
+          0,
+          368075,
+          1048576
+        ],
+        []
+      ],
+      "rounding_error": "15/16777216",
+      "row_sparsity": 2,
+      "scalar_products": 98,
+      "words": [
+        [
+          -40330,
+          51978,
+          -11647
+        ],
+        [
+          21763,
+          -68549,
+          46786
+        ]
+      ]
+    },
+    "initial_payload_packing_actions": [
+      25725,
+      6985,
+      23886
+    ],
+    "original_error": "31600757135864775892707073/39873223259708119150169576964096",
+    "output": [
+      "-20165/524288",
+      "25989/524288",
+      "-11647/1048576",
+      "0",
+      "21763/1048576",
+      "-68549/1048576",
+      "23393/524288",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0"
+    ],
+    "output_sha256": "1ddd68794b1acd24f39601bb4d462bdac8cfa9f6a409fb153022557f9ad167b5",
+    "page_bits": [
+      448,
+      0,
+      448,
+      0
+    ],
+    "physical_setup_actions": [
+      1164007,
+      220604,
+      1003858
+    ],
+    "precision": 20,
+    "products": 2,
+    "retained_owner_cells": 21559,
+    "rows": 2,
+    "scalar_products": 98,
+    "transaction_actions": [
+      11932590,
+      3682892,
+      11030818
+    ],
+    "width": 28
+  },
+  "long_to_short": {
+    "block": 1,
+    "columns": 1,
+    "controls": [
+      "pending output"
+    ],
+    "error_allowance": "3/8",
+    "independent_review": {
+      "complex_error": "0",
+      "incoming_radius": "1/8",
+      "matrix_calls": 6,
+      "page_words": [
+        [
+          16,
+          16
+        ],
+        [
+          0
+        ],
+        [
+          16,
+          16
+        ],
+        [
+          0
+        ]
+      ],
+      "rounding_error": "0",
+      "row_sparsity": 0,
+      "scalar_products": 6,
+      "words": [
+        [
+          0
+        ]
+      ]
+    },
+    "initial_payload_packing_actions": [
+      1138,
+      297,
+      1132
+    ],
+    "original_error": "0",
+    "output": [
+      "0"
+    ],
+    "output_sha256": "af5570f5a1810b7af78caf4bc70a660f0df51e42baf91d4de5b2328de0e83dfc",
+    "page_bits": [
+      16,
+      8,
+      16,
+      8
+    ],
+    "physical_setup_actions": [
+      51978,
+      12243,
+      54560
+    ],
+    "precision": 4,
+    "products": 6,
+    "retained_owner_cells": 22373,
+    "rows": 1,
+    "scalar_products": 6,
+    "transaction_actions": [
+      139851,
+      37567,
+      134610
+    ],
+    "width": 8
+  },
+  "marker": "PASS_PHYSICAL_BANDED_FORWARD_ACTION",
+  "no_new_kappa": true,
+  "owned_roles": 2788,
+  "scope": "literal supplied band action; exact finite broad Reference Schur; no full broad window",
+  "singular": {
+    "block": 4,
+    "columns": 3,
+    "controls": [
+      "pending output",
+      "source/page alias",
+      "inactive deep-owned alias",
+      "non-dyadic block",
+      "nonzero padded input row",
+      "nonzero inactive RHS column",
+      "short coupling after completed child"
+    ],
+    "error_allowance": "9/256",
+    "independent_review": {
+      "complex_error": "1/128",
+      "incoming_radius": "5/16",
+      "matrix_calls": 6,
+      "page_words": [
+        [
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          0,
+          0,
+          0,
+          0,
+          256
+        ],
+        [
+          0,
+          0,
+          0,
+          85,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          0,
+          0,
+          0,
+          0,
+          256,
+          0,
+          0,
+          0,
+          85,
+          256,
+          256,
+          0,
+          0,
+          0,
+          170,
+          256,
+          -85,
+          0,
+          0,
+          0,
+          256,
+          0,
+          -85,
+          0,
+          85,
+          256
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          85,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ],
+      "rounding_error": "29/4096",
+      "row_sparsity": 3,
+      "scalar_products": 294,
+      "words": [
+        [
+          -15,
+          31,
+          -15
+        ],
+        [
+          0,
+          -47,
+          47
+        ],
+        [
+          16,
+          15,
+          -31
+        ]
+      ]
+    },
+    "initial_payload_packing_actions": [
+      17953,
+      4876,
+      17234
+    ],
+    "original_error": "1/256",
+    "output": [
+      "-15/256",
+      "31/256",
+      "-15/256",
+      "0",
+      "0",
+      "-47/256",
+      "47/256",
+      "0",
+      "1/16",
+      "15/256",
+      "-31/256",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0"
+    ],
+    "output_sha256": "67baafe96a83c187b4a19c46bf1289053373836eb08616b9744b126951af9ad5",
+    "page_bits": [
+      512,
+      256,
+      512,
+      256
+    ],
+    "physical_setup_actions": [
+      1128574,
+      238864,
+      1065482
+    ],
+    "precision": 8,
+    "products": 6,
+    "retained_owner_cells": 22373,
+    "rows": 3,
+    "scalar_products": 294,
+    "transaction_actions": [
+      24402042,
+      7728622,
+      23049150
+    ],
+    "width": 16
+  },
+  "source": {
+    "F": [
+      [
+        "777581682259149196747604614949/2215179069983784397231643164672",
+        "863743296690897832566265363529/9968305814927029787542394241024"
+      ],
+      [
+        "18360984398696939395693947801/1107589534991892198615821582336",
+        "7281593658223054052137217599003/19936611629854059575084788482048"
+      ]
+    ],
+    "H": [
+      [
+        "32713835665/68719476736",
+        "11044712815/34359738368",
+        "3100624699/68719476736",
+        "90474419/68719476736"
+      ],
+      [
+        "11023330389/68719476736",
+        "33264146607/68719476736",
+        "2608325481/8589934592",
+        "1360532697/34359738368"
+      ],
+      [
+        "891583857/68719476736",
+        "12023651079/68719476736",
+        "33707175003/68719476736",
+        "19643558747/68719476736"
+      ],
+      [
+        "17309303/68719476736",
+        "1043192267/68719476736",
+        "3267389923/17179869184",
+        "34038418763/68719476736"
+      ]
+    ],
+    "I": [
+      1,
+      2
+    ],
+    "J": [
+      0,
+      3
+    ],
+    "independent_review": {
+      "kind": "broad",
+      "narrow_substitution_distinguished": true,
+      "original_inverse_identity_entries": 32,
+      "reference_sha256": "156be0b0199657b95b636597b332b378a1fe82d1a80e8b9cc84eaf90425694c5",
+      "schur_inverse_identity_entries": 8
+    },
+    "interior_inverse_norm": "1250093842048967770112/290115882378508970943",
+    "kind": "broad",
+    "length": 4,
+    "origin": 16,
+    "parameters": [
+      61,
+      3,
+      2,
+      1,
+      3,
+      32
+    ],
+    "reference_sha256": "156be0b0199657b95b636597b332b378a1fe82d1a80e8b9cc84eaf90425694c5",
+    "schur_norm": "8725721733714138435860972261599/19936611629854059575084788482048",
+    "scope": "exact finite rational source; no whole broad word or ideal comparison"
+  },
+  "source_controls": [
+    "exact rank-two null vector",
+    "nongrid signed coefficient pre-round equivalence",
+    "tiny off-band before rounding"
+  ],
+  "source_pins": {
+    "research/certified-gaussian-recovery/NOTICE.md": "10acae9e78402ca70c6afd0e8d6da8fefc0da519c646cf43d93f923aba85b86d",
+    "research/certified-gaussian-recovery/intervals.py": "159d2a7d32a8cc7c8f56632a8ef127308b984a0a6753c9d6bdccacc6e7d6d4df",
+    "research/physical-boundary-pages/boundary_pages.py": "35fc82a8c30661fece362cee2d60951e1bee3e0348acaa622b2c3b052d9381ff",
+    "research/physical-gaussian-core/gaussian_matrix.py": "5bb982c6f36083b646bd5a5ab2ea4059c203fa0cc824e9f28132c0f323824bac",
+    "research/physical-gaussian-core/gaussian_rationals.py": "6f9a380c8c7b4233c3bc338a6206d65cc85bee2e4f5625c2a212065f04f4b73d",
+    "research/physical-gaussian-core/gaussian_rows.py": "821fd15a9b82f182f28055d4b83340e697906203f0728a36dc03196eca13c535",
+    "research/physical-gaussian-core/gaussian_sources.py": "c5889a97a11a9c6c6c44deb8a2042498ddc3f55703de15269132b8f198e24b15",
+    "research/physical-gaussian-core/inputs/branchfree-source.tar": "e6cdacd59a067189a99bfe03f4448913bb8d518ed4a9b1d981a68c5c666529c7",
+    "research/physical-gaussian-core/inputs/word-export.tar": "d428e8b6aef4d348fa2e922ca64c4cfd634bbb2f0c150033273e65fcf4600b49",
+    "research/rational-unitary-fft/exact.py": "c9b89d7357210af69865690ba12e695366961f8b501a8fab9d0fefe3fb30c479",
+    "research/rational-unitary-fft/gaussian.py": "08155357fd39b5fd7959f51f1d205b6511b8577b51520d793c89f92368b399ab",
+    "research/rational-unitary-fft/gaussian_reference.py": "ed4d0908646e391d4a0ea32c988a0301a1793a72294ac7058a664ed3283ca3c3",
+    "retained/fast_boundary.py": "4400cee53dcd24e7ee210121479340306623e32b94948ad026a8cce6d59d91c9",
+    "retained/seven_product.py": "3e6639aca88822e879abd563b427eb499e1b7650c3d209ad51587ac8756da401"
+  }
+}
diff --git a/research/physical-banded-forward-action/SOURCES.json b/research/physical-banded-forward-action/SOURCES.json
new file mode 100644
index 0000000000..1a95c0a175
--- /dev/null
+++ b/research/physical-banded-forward-action/SOURCES.json
@@ -0,0 +1,106 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "research/physical-gaussian-core/gaussian_sources.py",
+      "usage": "input",
+      "git_blob": "ce521f91997775e189f984ba7dd68a15bf9ecd9b",
+      "sha256": "c5889a97a11a9c6c6c44deb8a2042498ddc3f55703de15269132b8f198e24b15"
+    },
+    {
+      "path": "research/physical-gaussian-core/inputs/word-export.tar",
+      "usage": "input",
+      "git_blob": "885794cf3328941209034ee2d946ed76dbea8ce3",
+      "sha256": "d428e8b6aef4d348fa2e922ca64c4cfd634bbb2f0c150033273e65fcf4600b49"
+    },
+    {
+      "path": "research/physical-gaussian-core/inputs/branchfree-source.tar",
+      "usage": "input",
+      "git_blob": "48dc77f5145d649bfed6745e38ab18b11772d597",
+      "sha256": "e6cdacd59a067189a99bfe03f4448913bb8d518ed4a9b1d981a68c5c666529c7"
+    },
+    {
+      "path": "research/physical-boundary-pages/boundary_pages.py",
+      "usage": "input",
+      "git_blob": "13323e77903ef7d55b142a6e9c669dafa5cc7799",
+      "sha256": "35fc82a8c30661fece362cee2d60951e1bee3e0348acaa622b2c3b052d9381ff"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_matrix.py",
+      "usage": "input",
+      "git_blob": "fc41183a42f5e1af5ea2294c295a0519abbcdb6c",
+      "sha256": "5bb982c6f36083b646bd5a5ab2ea4059c203fa0cc824e9f28132c0f323824bac"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_rationals.py",
+      "usage": "input",
+      "git_blob": "053404d91c1bef0d4bb0f6647491847bf5879aaf",
+      "sha256": "6f9a380c8c7b4233c3bc338a6206d65cc85bee2e4f5625c2a212065f04f4b73d"
+    },
+    {
+      "path": "research/physical-gaussian-core/gaussian_rows.py",
+      "usage": "input",
+      "git_blob": "4b786bf2774fb317762b6148864f5192292da8e7",
+      "sha256": "821fd15a9b82f182f28055d4b83340e697906203f0728a36dc03196eca13c535"
+    },
+    {
+      "path": "research/rational-unitary-fft/exact.py",
+      "usage": "input",
+      "git_blob": "aae41e6acfb2e5a4fafdd85727891eb746b57b42",
+      "sha256": "c9b89d7357210af69865690ba12e695366961f8b501a8fab9d0fefe3fb30c479"
+    },
+    {
+      "path": "research/rational-unitary-fft/gaussian.py",
+      "usage": "input",
+      "git_blob": "52ad2e1d605f5f7d669234567c25bc087306dd44",
+      "sha256": "08155357fd39b5fd7959f51f1d205b6511b8577b51520d793c89f92368b399ab"
+    },
+    {
+      "path": "research/rational-unitary-fft/gaussian_reference.py",
+      "usage": "input",
+      "git_blob": "92addfabde50655cea7ad5a84cca9cff5457adee",
+      "sha256": "ed4d0908646e391d4a0ea32c988a0301a1793a72294ac7058a664ed3283ca3c3"
+    },
+    {
+      "path": "research/certified-gaussian-recovery/intervals.py",
+      "usage": "input",
+      "git_blob": "91d458865aa026bdf0d59653a4ecbfe3a178ecbc",
+      "sha256": "159d2a7d32a8cc7c8f56632a8ef127308b984a0a6753c9d6bdccacc6e7d6d4df"
+    },
+    {
+      "path": "research/certified-gaussian-recovery/NOTICE.md",
+      "usage": "input",
+      "git_blob": "5e3269b5afe5e11f044ffae45216c4731b42c7af",
+      "sha256": "10acae9e78402ca70c6afd0e8d6da8fefc0da519c646cf43d93f923aba85b86d"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    }
+  ],
+  "retained_files": [
+    {
+      "path": "retained/seven_product.py",
+      "source_repository": "CubeJerry/integer-mult-bounds",
+      "source_commit": "f821cba68f44048e70e78afb75603ed4dde99f11",
+      "source_path": "research/physical-seven-product-matrix/seven_product.py",
+      "sha256": "3e6639aca88822e879abd563b427eb499e1b7650c3d209ad51587ac8756da401"
+    },
+    {
+      "path": "retained/fast_boundary.py",
+      "source_repository": "CubeJerry/integer-mult-bounds",
+      "source_commit": "f821cba68f44048e70e78afb75603ed4dde99f11",
+      "source_path": "research/physical-seven-product-matrix/fast_boundary.py",
+      "sha256": "4400cee53dcd24e7ee210121479340306623e32b94948ad026a8cce6d59d91c9"
+    }
+  ]
+}
diff --git a/research/physical-banded-forward-action/TASK.json b/research/physical-banded-forward-action/TASK.json
new file mode 100644
index 0000000000..76067825ca
--- /dev/null
+++ b/research/physical-banded-forward-action/TASK.json
@@ -0,0 +1,84 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 8,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "scope_status": "refined",
+  "track_seed": 27,
+  "actual_scope": "Implement literal fixed-role banded forward action by zero-row interleaving, the unchanged exact seven-product inverse-page caller, and target projection. Bind one exact current broad Reference Schur and retain all setup, rounding, movement and storage costs.",
+  "scope_change_reason": "The generic batched arithmetic is already CrocSwap/integer-mult-bounds#481 and the same-reference broad word/error is CrocSwap/integer-mult-bounds#4205. The exact seven-product kernel is now physically available; this missing supplied forward caller is distinct from the concurrently developed narrow union transaction.",
+  "bottleneck_link": "A complete broad supplier needs an actual paid banded forward service before host arithmetic can be transferred into a physical caller. This does not discharge any global assumption.",
+  "budget_minutes": 39,
+  "stop_rule": "Freeze a bounded supplied forward primitive by 22:35 UTC; no speculative code after 22:39. Stop before broad union/header routing or a complete Gaussian/FFT/CRT assertion.",
+  "outcome": "completed",
+  "evidence": "PROOF.md and actual normal/optimized verifier, including a separately authored source and three-disjoint-sum oracle. Source pages are actually prepared on the retained tapes. No new kappa.",
+  "author": "Prepared for @CubeJerry",
+  "ai_assistance": "Substantial OpenAI Codex assistance in source research, implementation, proof and tests; an independent source-aware AI worker supplied original-matrix, page and direct disjoint-sum verification. No human or formal proof-kernel acceptance claimed.",
+  "open_questions": [
+    {
+      "question": "Can the complete broad union window pay its source coupling shear, field/header transport, common-grid conversion and page catalogue around this primitive?",
+      "why_it_matters": "An already-packed supplied matrix action is not the full current broad caller or outer multiplication proof.",
+      "first_step": "Freeze one actual coarse-source page key and implement a full chronological rounded transaction with every partial-batch and setup cost retained.",
+      "blocked_by": "No complete broad union or outer assembly is supplied in this package."
+    }
+  ],
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  }
+}
diff --git a/research/physical-banded-forward-action/VERIFY.json b/research/physical-banded-forward-action/VERIFY.json
new file mode 100644
index 0000000000..ff8283854d
--- /dev/null
+++ b/research/physical-banded-forward-action/VERIFY.json
@@ -0,0 +1,64 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "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-boundary-pages/boundary_pages.py",
+    "research/physical-gaussian-core/gaussian_matrix.py",
+    "research/physical-gaussian-core/gaussian_rationals.py",
+    "research/physical-gaussian-core/gaussian_rows.py",
+    "research/rational-unitary-fft/exact.py",
+    "research/rational-unitary-fft/gaussian.py",
+    "research/rational-unitary-fft/gaussian_reference.py",
+    "research/certified-gaussian-recovery/intervals.py",
+    "research/certified-gaussian-recovery/NOTICE.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Actual broad-source and signed singular physical band actions; unchanged physical pre-rounded page preparation; independent original-matrix and three-sum oracle; full ceilings, padding, aliases, protected returns, failure cleanup and long-to-short owner history."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Actual broad-source and signed singular physical band actions; unchanged physical pre-rounded page preparation; independent original-matrix and three-sum oracle; full ceilings, padding, aliases, protected returns, failure cleanup and long-to-short owner history. Assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/check_independent.py"
+      ],
+      "timeout_seconds": 30,
+      "checks": "Separately authored direct oracle: singular nullvector, negative-floor page mutant, opposite lift sign, nonzero targets, tiny off-band coefficient before rounding, and three-stage versus one-shot rounding."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/check_independent.py"
+      ],
+      "timeout_seconds": 30,
+      "checks": "Separately authored direct oracle: singular nullvector, negative-floor page mutant, opposite lift sign, nonzero targets, tiny off-band coefficient before rounding, and three-stage versus one-shot rounding."
+    }
+  ]
+}
diff --git a/research/physical-banded-forward-action/action.py b/research/physical-banded-forward-action/action.py
new file mode 100644
index 0000000000..ed08b3c757
--- /dev/null
+++ b/research/physical-banded-forward-action/action.py
@@ -0,0 +1,149 @@
+"""Literal interleaved nilpotent lift for an encoded banded forward action.
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from gaussian_sources import active
+active()
+from cardinal_counts import Count, positive
+from compact_counts import copy_bits
+from encoded import compare, subtract
+from records import Tape
+from router_metadata import indices, owned
+from scratch_pool import ScratchPool
+from session import (OuterScope, borrowed_count, borrowed_tape, erase_marker,
+                     initialize_marker, sealed_constructors)
+from words import BLANK, need
+from boundary_pages import ceiling_division
+from fast_boundary import FastBoundaryPages, origin, dyadic
+
+
+def bit(tape):
+    value = tape.read()
+    need(value in (0, 1), 'complete band-action binary field')
+    tape.step(1)
+    return value
+
+
+def zeroes(tape, length):
+    for _ in indices(length):
+        tape.append(0)
+
+
+def zero_field(tape, length):
+    for _ in indices(length):
+        need(bit(tape) == 0, 'zero band-action padding')
+
+
+class BandedAction:
+    def __init__(self):
+        self.child = FastBoundaryPages()
+        self.pool = ScratchPool(128)
+        self.scope = OuterScope(self.pool)
+        self.dilated, self.output = Tape(), Tape()
+        self.closed, self.pending = True, False
+        self.calls = 0
+        for tape in (*self.pool.tapes, self.dilated, self.output):
+            erase_marker(tape)
+
+    def forbidden(self):
+        return (*self.pool.tapes, self.dilated, self.output, *self.child.forbidden())
+
+    def idle(self):
+        need(self.closed and not self.pending and not self.pool.live
+             and self.output.read() == BLANK, 'consume prior band-action return')
+        self.child.idle()
+        need(self.child.closed and not self.child.pending and not self.child.pool.live,
+             'consumed band-action child')
+
+    def consume(self):
+        need(self.closed and self.pending, 'one pending band-action return')
+        self.output.clear()
+        erase_marker(self.output)
+        self.pending = False
+        self.idle()
+
+    def run(self, source, pages, length, columns, block, width, precision):
+        need(len(pages) == 4, 'four nilpotent action page banks')
+        source = borrowed_tape(source)
+        pages = tuple(borrowed_tape(tape) for tape in pages)
+        metadata = tuple(borrowed_count(value) for value in
+                         (length, columns, block, width, precision))
+        length, columns, block, width, precision = metadata
+        sources = (source, *pages)
+        forbidden = self.forbidden()
+        need(len(set(sources)) == len(sources)
+             and all(tape not in forbidden for tape in sources)
+             and all(value.tape not in forbidden and value.tape not in sources
+                     for value in metadata), 'external distinct band-action ports')
+        self.idle()
+        ports = (*sources, *(value.tape for value in metadata))
+        for tape in ports:
+            origin(tape)
+        for value in (length, columns, block, width):
+            positive(value)
+        dyadic(block)
+        need(compare(precision, width) < 0, 'band-action fractional width')
+        for tape in (*self.pool.tapes, self.dilated, self.output):
+            initialize_marker(tape)
+        self.closed = False
+        succeeded = False
+        try:
+            with sealed_constructors(), self.scope.installed():
+                with owned(Count(length), ceiling_division(length, block),
+                           ceiling_division(columns, block),
+                           Count.product(block, width)) as (twice, row_blocks, batches, row_bits):
+                    twice.multiply_small(2)
+                    with owned(ceiling_division(twice, block),
+                               Count.product(row_blocks, block)) as (lift_blocks, padded):
+                        with owned(Count.product(lift_blocks, block)) as (lift_padded,):
+                            with owned(subtract(lift_padded, twice),
+                                       subtract(padded, length)) as (lift_tail, tail):
+                                with owned(Count.product(lift_tail, row_bits),
+                                           Count.product(tail, row_bits)) as (lift_bits, tail_bits):
+                                    for _ in indices(batches):
+                                        for row in indices(padded):
+                                            if compare(row, length) < 0:
+                                                zeroes(self.dilated, row_bits)
+                                                copy_bits(source, self.dilated, row_bits)
+                                            else:
+                                                zero_field(source, row_bits)
+                                        zeroes(self.dilated, lift_bits)
+                                    need(source.read() == BLANK, 'complete band-action source batches')
+                                    source.rewind()
+                                    self.dilated.rewind()
+                                    with self.scope.suspended():
+                                        returned = self.child.run(*pages, self.dilated, twice,
+                                                                  columns, block, width, precision)
+                                    try:
+                                        for _ in indices(batches):
+                                            for _ in indices(length):
+                                                copy_bits(returned, self.output, row_bits)
+                                                for _ in indices(row_bits):
+                                                    need(bit(returned) == bit(source),
+                                                         'nilpotent source rows preserved exactly')
+                                            zero_field(source, tail_bits)
+                                            zero_field(returned, lift_bits)
+                                            zeroes(self.output, tail_bits)
+                                        need(source.read() == returned.read() == BLANK,
+                                             'complete projected band-action return')
+                                    finally:
+                                        if self.child.pending:
+                                            self.child.consume()
+                    self.child.idle()
+                    self.calls += 1
+                    succeeded = self.pending = True
+        finally:
+            if self.child.pending:
+                self.child.consume()
+            for tape in ports:
+                tape.rewind()
+            self.dilated.clear()
+            self.pool.empty()
+            for tape in (*self.pool.tapes, self.dilated):
+                erase_marker(tape)
+            self.output.rewind()
+            if not succeeded:
+                self.output.clear()
+                erase_marker(self.output)
+                self.pending = False
+            self.closed = True
+        return self.output
diff --git a/research/physical-banded-forward-action/check_independent.py b/research/physical-banded-forward-action/check_independent.py
new file mode 100644
index 0000000000..c303f11fc1
--- /dev/null
+++ b/research/physical-banded-forward-action/check_independent.py
@@ -0,0 +1,13 @@
+"""Run the separately authored finite forward-oracle negative controls."""
+from pathlib import Path
+import json
+import sys
+PACKAGE = Path(__file__).resolve().parent
+sys.path.insert(0, str(PACKAGE))
+import independent_forward
+import oracle_checks
+
+if __name__ == '__main__':
+    result = oracle_checks.run(independent_forward)
+    independent_forward.need(len(result['controls']) == 6, 'six independent decisive controls')
+    print(json.dumps(dict(marker='PASS_INDEPENDENT_FORWARD_CONTROLS', **result), sort_keys=True))
diff --git a/research/physical-banded-forward-action/fixture.py b/research/physical-banded-forward-action/fixture.py
new file mode 100644
index 0000000000..692a090e1a
--- /dev/null
+++ b/research/physical-banded-forward-action/fixture.py
@@ -0,0 +1,205 @@
+"""Finite fixture preparation and observations, separate from literal action."""
+from fractions import Fraction as Q
+from hashlib import sha256
+import time
+import pages as preparation
+import independent_forward
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def body(tape):
+    from session import borrowed_tape
+    raw = bytes(borrowed_tape(tape).cells)
+    end = raw.find(bytes((4,)), 1)
+    if end < 0:
+        end = len(raw)
+    need(all(x == 4 for x in raw[end:]), 'blank observer backing suffix')
+    return raw[1:end]
+
+
+def snapshots(tapes):
+    from session import borrowed_tape
+    return tuple((bytes(borrowed_tape(t).cells), borrowed_tape(t).head) for t in tapes)
+
+
+def decoded(raw, width, precision):
+    need(len(raw) % width == 0, 'complete observer words')
+    return [Q(sum(v << i for i, v in enumerate(raw[k:k+width]))
+              -(raw[k+width-1] << width), 1 << precision)
+            for k in range(0, len(raw), width)]
+
+
+def erased(owner):
+    need(all(t.head == 1 and all(x == 4 for x in t.cells) for t in owner.forbidden()),
+         'all forward-action owned roles and retained extents erased')
+
+
+def case(owner, all_tapes, matrix, *, block=4, precision=20, width=28, columns=3, controls=True):
+    from cardinal_counts import Count
+    from check_support import no_decode
+    from records import Tape
+    from ring_words import Signed, write_signed
+    from router_metadata import owned
+    from scratch_pool import ScratchPool
+    from session import OuterScope, initialize_marker, erase_marker, sealed_constructors
+    from boundary_pages import prepare_pages
+    from words import BLANK
+    n = len(matrix)
+    rhs = tuple(tuple(Q(((3*i+5*j+2) % 9)-4, 16) for j in range(columns)) for i in range(n))
+    pool = ScratchPool(96)
+    scope = OuterScope(pool)
+    for tape in pool.tapes:
+        erase_marker(tape)
+        initialize_marker(tape)
+    source, spectator = Tape(), Tape()
+    spectator.append(1); spectator.append(0); spectator.append(1); spectator.rewind()
+    metadata = tuple(Count.literal(x) for x in (n, columns, block, width, precision))
+    pages = (); matrices = ()
+    def meter():
+        return tuple(sum(getattr(t.meter, key) for t in all_tapes) for key in ('reads', 'writes', 'moves'))
+    def delta(before):
+        return tuple(x-y for x, y in zip(meter(), before))
+    start = time.monotonic()
+    try:
+        before = meter()
+        with sealed_constructors(), scope.installed():
+            matrices = preparation.physical_factors(matrix, block, precision, pool)
+            with no_decode():
+                pages = prepare_pages(*matrices, *metadata[2:], pool)
+            for owner_matrix in matrices:
+                owner_matrix.close()
+            matrices = ()
+        setup_bill = delta(before)
+        expected = preparation.expected_pages(matrix, block, precision)
+        need(expected == preparation.expected_pages(matrix, block, precision, pre_round=False),
+             'pre-rounding exact page equality')
+        need(tuple(tuple(decoded(body(t), width, precision)) for t in pages) == expected,
+             'actual physical prepare_pages bytes')
+        independent_pages = independent_forward.check_pages(matrix, block, precision)
+        need(tuple(tuple(int(x*(1 << precision)) for x in bank) for bank in expected)
+             == independent_pages, 'independent inverse-block and pre-round page oracle')
+        padded = ((n+block-1)//block)*block
+        packing_before = meter()
+        for start_column in range(0, columns, block):
+            for row in range(padded):
+                for column in range(start_column, start_column+block):
+                    value = rhs[row][column] if row < n and column < columns else Q()
+                    integer = int(value*(1 << precision))
+                    with owned(Signed(Count.literal(abs(integer)), integer < 0)) as encoded:
+                        write_signed(encoded[0], source, metadata[3])
+        source.rewind()
+        packing_bill = delta(packing_before)
+        ports = (source, *pages, *(value.tape for value in metadata), spectator)
+        saved = snapshots(ports)
+        before = meter(); leaves = owner.child.kernel.leaves; products = owner.child.products
+        with no_decode():
+            output = owner.run(source, pages, *metadata)
+        raw = body(output)
+        while output.read() != BLANK:
+            output.step(1)
+        pending = snapshots((output,))
+        try:
+            with no_decode():
+                owner.run(source, pages, *metadata)
+        except ValueError as error:
+            need(str(error) == 'consume prior band-action return', 'specific protected-return guard')
+        else:
+            raise ValueError('pending action output overwritten')
+        need(snapshots((output,)) == pending, 'pending output and moved head unchanged')
+        with no_decode():
+            owner.consume()
+        bill = delta(before)
+        need(snapshots(ports) == saved, 'all borrowed source, pages, descriptors and spectator preserved')
+        erased(owner)
+        value_rows = preparation.rounded_oracle(matrix, rhs, block, precision)
+        packed_expected = []
+        for start_column in range(0, columns, block):
+            for row in range(padded):
+                packed_expected.extend(value_rows[row][column] if row < n and column < columns else Q()
+                                       for column in range(start_column, start_column+block))
+        need(decoded(raw, width, precision) == packed_expected, 'completed rounded forward action')
+        exact = preparation.multiply(matrix, rhs)
+        error = max(abs(x-y) for row, ideal in zip(value_rows, exact) for x, y in zip(row, ideal))
+        sparsity = max(sum(bool(x) for x in row) for row in matrix)
+        radius = max(sum(map(abs, row), Q()) for row in zip(*rhs))
+        admitted = max(Q(1), radius)
+        allowance = Q(sparsity*admitted+6, 1 << precision)
+        need(error <= allowance, 'exact original forward error allowance')
+        independent = independent_forward.check_return(matrix,
+            tuple(tuple(int(value*(1 << precision)) for value in row) for row in rhs),
+            raw, block, precision, width, admitted)
+        expected_products = 2*(2*((2*n+block-1)//block)-1)*((columns+block-1)//block)
+        used_products = owner.child.products-products
+        used_leaves = owner.child.kernel.leaves-leaves
+        need(used_products == expected_products and used_leaves == expected_products*7**(block.bit_length()-1),
+             'complete ceiling and actual leaf invoice')
+        rejected = ['pending output']
+        if controls:
+            def reject(src, bank, meta, message):
+                current = snapshots(ports)
+                try:
+                    with no_decode():
+                        owner.run(src, bank, *meta)
+                except ValueError as problem:
+                    need(str(problem) == message, 'specific action guard: '+str(problem))
+                else:
+                    raise ValueError('accepted malformed forward call')
+                need(snapshots(ports) == current, 'rejection preserves borrowed inputs')
+                owner.idle(); erased(owner)
+            reject(pages[0], pages, metadata, 'external distinct band-action ports')
+            reject(owner.child.kernel.word.product.word.pool.tapes[-1], pages, metadata,
+                   'external distinct band-action ports')
+            rejected.extend(('source/page alias', 'inactive deep-owned alias'))
+            with owned(Count.literal(3)) as (three,):
+                reject(source, pages, (*metadata[:2], three, *metadata[3:]), 'dyadic fast-boundary block size')
+            rejected.append('non-dyadic block')
+            if n % block:
+                location = n*block*width
+                source.rewind()
+                for _ in range(location): source.step(1)
+                need(source.read() == 0, 'known input row pad')
+                source.write(1); source.rewind()
+                reject(source, pages, metadata, 'zero band-action padding')
+                for _ in range(location): source.step(1)
+                source.write(0); source.rewind()
+                rejected.append('nonzero padded input row')
+            if columns % block:
+                location = columns*width
+                source.rewind()
+                for _ in range(location): source.step(1)
+                need(source.read() == 0, 'known inactive column pad')
+                source.write(1); source.rewind()
+                reject(source, pages, metadata, 'zero incomplete row/RHS padding')
+                for _ in range(location): source.step(1)
+                source.write(0); source.rewind()
+                rejected.append('nonzero inactive RHS column')
+            if body(pages[1]):
+                coupling = pages[1]; location = len(body(coupling))-1
+                for _ in range(location): coupling.step(1)
+                old = coupling.read(); coupling.write(BLANK); coupling.rewind()
+                completed = owner.child.kernel.calls
+                reject(source, pages, metadata, 'complete opaque binary payload')
+                need(owner.child.kernel.calls == completed+1, 'failure occurs after one completed matrix child')
+                for _ in range(location): coupling.step(1)
+                coupling.write(old); coupling.rewind()
+                rejected.append('short coupling after completed child')
+            need(snapshots(ports) == saved, 'all control mutations restored')
+        return dict(rows=n, columns=columns, block=block, precision=precision, width=width,
+                    physical_setup_actions=setup_bill, initial_payload_packing_actions=packing_bill,
+                    transaction_actions=bill, products=used_products, scalar_products=used_leaves,
+                    page_bits=[len(body(t)) for t in pages], output_sha256=sha256(raw).hexdigest(),
+                    output=[str(x) for x in decoded(raw, width, precision)],
+                    original_error=str(error), error_allowance=str(allowance), controls=rejected,
+                    independent_review=independent,
+                    retained_owner_cells=sum(len(t.cells) for t in owner.forbidden()),
+                    seconds=time.monotonic()-start)
+    finally:
+        if owner.pending: owner.consume()
+        for matrix_owner in matrices: matrix_owner.close()
+        for page in pages: page.clear()
+        for value in metadata: value.close()
+        source.clear(); spectator.clear(); pool.empty()
diff --git a/research/physical-banded-forward-action/independent_forward.py b/research/physical-banded-forward-action/independent_forward.py
new file mode 100644
index 0000000000..f9f58ae592
--- /dev/null
+++ b/research/physical-banded-forward-action/independent_forward.py
@@ -0,0 +1,240 @@
+"""Independent exact observer for the nilpotent banded-forward wrapper.
+
+Prepared for @CubeJerry with separate source-aware OpenAI AI verification.
+Rational elimination and page arithmetic reuse the A8 independent observer;
+no author forward producer/consumer is imported. Apache-2.0.
+"""
+from fractions import Fraction as Q
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+def identity(n):
+    return tuple(tuple(Q(i == j) for j in range(n)) for i in range(n))
+
+def product_matrix(a, b):
+    need(bool(b) and all(len(row) == len(b) for row in a), "observer matrix dimensions")
+    return tuple(tuple(sum((a[i][k]*b[k][j] for k in range(len(b))), Q())
+                       for j in range(len(b[0]))) for i in range(len(a)))
+
+def inverse(a):
+    """Pivoted triangular elimination plus back-substitution, not producer GJ."""
+    n = len(a)
+    need(n > 0 and all(len(row) == n for row in a), "observer square inverse")
+    upper = [list(map(Q, row)) for row in a]
+    right = [list(row) for row in identity(n)]
+    for k in range(n):
+        pivot = next((i for i in range(k, n) if upper[i][k]), None)
+        need(pivot is not None, "observer nonsingular original matrix")
+        upper[k], upper[pivot] = upper[pivot], upper[k]
+        right[k], right[pivot] = right[pivot], right[k]
+        for i in range(k+1, n):
+            ratio = upper[i][k]/upper[k][k]
+            upper[i][k] = Q()
+            for j in range(k+1, n):
+                upper[i][j] -= ratio*upper[k][j]
+            for j in range(n):
+                right[i][j] -= ratio*right[k][j]
+    answer = [[Q()]*n for _ in range(n)]
+    for i in reversed(range(n)):
+        for j in range(n):
+            answer[i][j] = (right[i][j]-sum((upper[i][k]*answer[k][j]
+                                            for k in range(i+1, n)), Q()))/upper[i][i]
+    answer = tuple(map(tuple, answer))
+    need(product_matrix(a, answer) == identity(n)
+         and product_matrix(answer, a) == identity(n), "both original inverse identities")
+    return answer
+
+def sub(a, rows, columns):
+    return tuple(tuple(a[i][j] for j in columns) for i in rows)
+
+def toward_zero_integer(numerator, denominator):
+    need(denominator > 0, "positive rounding denominator")
+    return (1 if numerator >= 0 else -1)*(abs(numerator)//denominator)
+
+def grid_integer(value, p):
+    value = Q(value)
+    return toward_zero_integer(value.numerator << p, value.denominator)
+
+def padded(a, block):
+    n = len(a)
+    size = ((n+block-1)//block)*block
+    return tuple(tuple(a[i][j] if i < n and j < n else Q(i == j)
+                       for j in range(size)) for i in range(size))
+
+def page_words(lower, upper, block, precision):
+    """Derive all four page banks independently, including padded reversal."""
+    banks = []
+    for direction, raw in enumerate((lower, upper)):
+        a = padded(raw, block)
+        if direction:
+            a = tuple(tuple(a[-i-1][-j-1] for j in range(len(a))) for i in range(len(a)))
+        diagonals, couplings = [], []
+        for start in range(0, len(a), block):
+            rows = tuple(range(start, start+block))
+            diagonal = inverse(sub(a, rows, rows))
+            diagonals.extend(grid_integer(x, precision) for row in diagonal for x in row)
+            if start:
+                couplings.extend(grid_integer(a[i][j], precision)
+                                 for i in rows for j in range(start-block, start))
+        banks.extend((tuple(diagonals), tuple(couplings)))
+    return tuple(banks)
+
+def solve_pages(banks, rhs, block, p):
+    """Pure integer completed-dot recurrence, returning original row order."""
+    rows = len(rhs)
+    need(rows > 0 and bool(rhs[0]), "nonempty oracle RHS")
+    columns, scale = len(rhs[0]), 1 << p
+    size = ((rows+block-1)//block)*block
+    current = [list(row) for row in rhs]+[[0]*columns for _ in range(size-rows)]
+    need(all(len(row) == columns for row in current), "rectangular oracle RHS")
+    for direction in range(2):
+        if direction:
+            current = current[::-1]
+        diagonal_bank, coupling_bank = banks[2*direction:2*direction+2]
+        need(len(diagonal_bank) == size*block and len(coupling_bank) == (size-block)*block,
+             "oracle complete page extents")
+        output = []
+        for start in range(0, size, block):
+            residual = [list(row) for row in current[start:start+block]]
+            if start:
+                at = (start-block)*block
+                for i in range(block):
+                    for c in range(columns):
+                        dot = sum(coupling_bank[at+i*block+j]*output[start-block+j][c]
+                                  for j in range(block))
+                        residual[i][c] = toward_zero_integer(scale*residual[i][c]-dot, scale)
+            at = start*block
+            for i in range(block):
+                output.append([toward_zero_integer(sum(diagonal_bank[at+i*block+j]*residual[j][c]
+                                                       for j in range(block)), scale)
+                               for c in range(columns)])
+        current = output
+    return tuple(tuple(row) for row in current[::-1][:rows])
+
+
+def lifted_factors(matrix, block, precision=None):
+    n = len(matrix)
+    need(n > 0 and all(len(row) == n for row in matrix), 'square forward source')
+    need(block > 0 and block & (block-1) == 0, 'dyadic forward block')
+    data = tuple(tuple(Q(x) if precision is None else Q(grid_integer(x,precision),1 << precision)
+                       for x in row) for row in matrix)
+    lift = tuple(tuple(-data[i//2][j//2] if i%2 == 0 and j%2 == 1 else Q()
+                       for j in range(2*n)) for i in range(2*n))
+    need(all(not value or abs(i-j) <= block for i,row in enumerate(lift)
+             for j,value in enumerate(row)), 'admitted interleaved scalar band')
+    lower = tuple(tuple(Q(i == j)+(lift[i][j] if i//block > j//block else 0)
+                        for j in range(2*n)) for i in range(2*n))
+    upper = tuple(tuple(Q(i == j)+(lift[i][j] if i//block <= j//block else 0)
+                        for j in range(2*n)) for i in range(2*n))
+    return lower, upper, lift
+
+
+def check_pages(matrix, block, precision):
+    exact = lifted_factors(matrix,block)
+    pre = lifted_factors(matrix,block,precision)
+    n = 2*len(matrix)
+    need(product_matrix(exact[2],exact[2]) == tuple(tuple(Q() for _ in range(n)) for _ in range(n)),
+         'interleaved lift is square zero')
+    need(product_matrix(exact[0],exact[1]) == tuple(tuple(Q(i == j)+exact[2][i][j]
+         for j in range(n)) for i in range(n)), 'exact interleaved factor product')
+    exact_pages = page_words(*exact[:2],block,precision)
+    short_pages = page_words(*pre[:2],block,precision)
+    need(exact_pages == short_pages, 'prerounded and exact-source physical page words coincide')
+    return exact_pages
+
+
+def action(matrix, rhs, block, precision):
+    """Direct three disjoint dot sums; no inverse/block-solver recurrence."""
+    n = len(matrix)
+    need(len(rhs) == n and bool(rhs[0]), 'nonempty forward observer RHS')
+    columns = len(rhs[0]);scale = 1 << precision
+    need(all(len(row) == columns for row in rhs), 'rectangular forward RHS')
+    lifted_factors(matrix,block)  # independently enforce the stated band domain
+    integers = tuple(tuple(grid_integer(value,precision) for value in row) for row in matrix)
+    result = []
+    for i in range(n):
+        target_block = (2*i)//block
+        parts = (tuple(j for j in range(n) if (2*j+1)//block < target_block),
+                 tuple(j for j in range(n) if (2*j+1)//block > target_block),
+                 tuple(j for j in range(n) if (2*j+1)//block == target_block))
+        row = []
+        for column in range(columns):
+            current = 0
+            for part in parts:
+                dot = sum(integers[i][j]*rhs[j][column] for j in part)
+                current = toward_zero_integer(current*scale+dot,scale)
+            row.append(current)
+        result.append(tuple(row))
+    return tuple(result)
+
+
+def check_action(matrix, rhs, block, precision, radius):
+    radius = Q(radius); scale = 1 << precision
+    n, columns = len(matrix), len(rhs[0])
+    observed_radius = max(sum((abs(Q(rhs[i][j],scale)) for j in range(c,min(c+2,columns))),Q())
+                          for i in range(n) for c in range(0,columns,2))
+    need(observed_radius <= radius, 'actual incoming complex radius')
+    words = action(matrix,rhs,block,precision)
+    exact = product_matrix(matrix,tuple(tuple(Q(v,scale) for v in row) for row in rhs))
+    short = tuple(tuple(Q(grid_integer(v,precision),scale) for v in row) for row in matrix)
+    quantized = product_matrix(short,tuple(tuple(Q(v,scale) for v in row) for row in rhs))
+    total_error = Q(); rounding_error = Q()
+    for i in range(n):
+        sparse = sum(value != 0 for value in matrix[i])
+        for c in range(0,columns,2):
+            error = sum((abs(Q(words[i][j],scale)-exact[i][j]) for j in range(c,min(c+2,columns))),Q())
+            rounding = sum((abs(Q(words[i][j],scale)-quantized[i][j]) for j in range(c,min(c+2,columns))),Q())
+            need(error <= (sparse*radius+6)/scale, 'original forward no-feedback error')
+            need(rounding <= Q(6,scale), 'six-ulp complex completed-rounding error')
+            total_error = max(total_error,error);rounding_error = max(rounding_error,rounding)
+    banks = check_pages(matrix,block,precision)
+    lifted_rhs = tuple(row for source in rhs for row in (tuple(0 for _ in source),tuple(source)))
+    lifted_result = solve_pages(banks,lifted_rhs,block,precision)
+    need(lifted_result[::2] == words and lifted_result[1::2] == tuple(map(tuple,rhs)),
+         'direct three-sum oracle agrees with all lifted pages and source preservation')
+    return dict(words=words, complex_error=total_error, rounding_error=rounding_error,
+                row_sparsity=max(sum(value != 0 for value in row) for row in matrix),
+                incoming_radius=observed_radius, page_words=banks)
+
+
+def original_schur(reference, origin, length, boundary, kind='broad'):
+    original = tuple(tuple(Q(reference.entry(kind,origin+i,origin+j).value)
+                           for j in range(length)) for i in range(length))
+    complete_inverse = inverse(original)
+    return inverse(sub(complete_inverse,boundary,boundary))
+
+
+def check_source(reference, matrix):
+    expected = original_schur(reference,16,4,(0,3),'broad')
+    need(tuple(map(tuple,matrix)) == expected, 'actual broad original-matrix Schur identity')
+    narrow = original_schur(reference,16,4,(0,3),'narrow')
+    need(expected != narrow, 'broad source is distinguished from the narrow matrix')
+    return dict(kind='broad', original_inverse_identity_entries=32,
+                schur_inverse_identity_entries=8, narrow_substitution_distinguished=True,
+                reference_sha256=reference.description_hash)
+
+
+def packed_bits(values, block, width):
+    n, columns = len(values), len(values[0])
+    rows = ((n+block-1)//block)*block
+    result = []
+    for first in range(0,columns,block):
+        for i in range(rows):
+            for c in range(first,first+block):
+                value = values[i][c] if i < n and c < columns else 0
+                need(-(1 << (width-1)) <= value < 1 << (width-1), 'forward observer carrier')
+                result.extend((value >> bit)&1 for bit in range(width))
+    return tuple(result)
+
+
+def check_return(matrix, rhs, returned_bits, block, precision, width, radius):
+    receipt = check_action(matrix,rhs,block,precision,radius)
+    need(tuple(returned_bits) == packed_bits(receipt['words'],block,width),
+         'complete projected forward output and zero padding')
+    n, columns = len(matrix), len(rhs[0])
+    k = (2*n+block-1)//block;j = (columns+block-1)//block
+    receipt['matrix_calls'] = 2*(2*k-1)*j
+    receipt['scalar_products'] = receipt['matrix_calls']*7**(block.bit_length()-1)
+    return receipt
diff --git a/research/physical-banded-forward-action/oracle_checks.py b/research/physical-banded-forward-action/oracle_checks.py
new file mode 100644
index 0000000000..66a4fffe5f
--- /dev/null
+++ b/research/physical-banded-forward-action/oracle_checks.py
@@ -0,0 +1,44 @@
+"""Portable finite controls for the independent forward observer.
+Prepared for @CubeJerry with separate OpenAI AI verification. Apache-2.0.
+"""
+from fractions import Fraction as Q
+
+
+def run(oracle):
+    matrix=tuple(tuple(Q(x,3) for x in row) for row in ((1,-1,0),(-1,2,-1),(0,-1,1)))
+    rhs=((91,-73,61),(-117,83,-41),(51,-31,101))
+    expected=oracle.check_action(matrix,rhs,4,8,Q(1))
+    oracle.need(oracle.product_matrix(matrix,((Q(1),),(Q(1),),(Q(1),)))==((Q(),),)*3,
+                'nonzero source nullvector without an inverse-F premise')
+    short=tuple(tuple(Q(oracle.grid_integer(x,8),256) for x in row) for row in matrix)
+    oracle.need(all(sum(row,Q())==0 for row in short)
+                and short[0][0]*short[1][1]-short[0][1]*short[1][0] != 0,
+                'this P8 rounded fixture also has exact rank two')
+    other_grid=tuple(tuple(Q(oracle.grid_integer(x,7),128) for x in row) for row in matrix)
+    det=(other_grid[0][0]*(other_grid[1][1]*other_grid[2][2]-other_grid[1][2]*other_grid[2][1])
+         -other_grid[0][1]*(other_grid[1][0]*other_grid[2][2]-other_grid[1][2]*other_grid[2][0]))
+    oracle.need(det != 0,'singularity is not preserved by arbitrary source rounding')
+    floored=tuple(tuple(Q((x.numerator<<8)//x.denominator,256) for x in row) for row in matrix)
+    oracle.need(oracle.check_pages(matrix,4,8)!=oracle.check_pages(floored,4,8),
+                'negative floor is not source truncation toward zero')
+    opposite=tuple(tuple(-x for x in row) for row in matrix)
+    oracle.need(oracle.action(matrix,rhs,4,8)!=oracle.action(opposite,rhs,4,8),
+                'sign of the lifted coupling is essential')
+    bad_lift=tuple(row for source in rhs for row in (source,source))
+    bad=oracle.solve_pages(expected['page_words'],bad_lift,4,8)
+    oracle.need(bad[::2]!=expected['words'],'nonzero target initialization is not a forward action')
+    tiny=((Q(1),Q(),Q(1,1<<80)),(Q(),Q(1),Q()),(Q(),Q(),Q(1)))
+    try:
+        oracle.check_pages(tiny,4,8)
+    except ValueError as error:
+        oracle.need('admitted interleaved scalar band' in str(error),'exact-source band control')
+    else:raise ValueError('tiny exact off-band entry admitted after rounding')
+    three=tuple(tuple(Q(1,4) if i==6 and j in (3,6,9) else Q() for j in range(10)) for i in range(10))
+    incoming=tuple((3 if j in (3,6,9) else 0,) for j in range(10))
+    separate=oracle.check_action(three,incoming,8,2,Q(1))
+    oracle.need(separate['words'][6]==(0,) and oracle.grid_integer(Q(9,16),2)==2,
+                'three staged rounds differ from a single completed-dot rounding')
+    return dict(exact_source_rank=2,p8_rounded_rank=2,p7_rounded_rank=3,
+                controls=('singular nullvector','negative floor pages','opposite lift sign',
+                'nonzero target initialization','tiny exact off-band coefficient','three separate rounding sites'),
+                scope='finite external observer controls; actual physical cases are registered separately')
diff --git a/research/physical-banded-forward-action/pages.py b/research/physical-banded-forward-action/pages.py
new file mode 100644
index 0000000000..aa72dbe2b2
--- /dev/null
+++ b/research/physical-banded-forward-action/pages.py
@@ -0,0 +1,172 @@
+"""Input-independent exact source preparation and dyadic nilpotent pages.
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from fractions import Fraction as Q
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def multiply(a, b):
+    return tuple(tuple(sum((x*y for x, y in zip(row, col)), Q())
+                       for col in zip(*b)) for row in a)
+
+
+def inverse(a):
+    n = len(a)
+    rows = [list(row)+[Q(i == j) for j in range(n)] for i, row in enumerate(a)]
+    for k in range(n):
+        at = next((i for i in range(k, n) if rows[i][k]), None)
+        need(at is not None, 'invertible admitted broad interior')
+        rows[k], rows[at] = rows[at], rows[k]
+        pivot = rows[k][k]
+        rows[k] = [x/pivot for x in rows[k]]
+        for i in range(n):
+            if i != k:
+                ratio = rows[i][k]
+                rows[i] = [x-ratio*y for x, y in zip(rows[i], rows[k])]
+    return tuple(tuple(row[n:]) for row in rows)
+
+
+def sub(a, rows, columns):
+    return tuple(tuple(a[i][j] for j in columns) for i in rows)
+
+
+def norm(a):
+    return max(sum(map(abs, row), Q()) for row in a)
+
+
+def rounded(value, precision):
+    value = Q(value)
+    integer = (abs(value.numerator) << precision)//value.denominator
+    return Q(-integer if value < 0 else integer, 1 << precision)
+
+
+def broad_source(reference):
+    """Small actual broad Reference Schur, not a relabelled narrow matrix."""
+    origin, length, interior = 16, 4, (1, 2)
+    boundary = (0, 3)
+    source = reference.source_at.get(origin+interior[0])
+    need(source is not None, 'selected broad interior start')
+    coordinates, _, _ = reference.interior(source, len(interior))
+    need(tuple(coordinates) == tuple(origin+i for i in interior),
+         'original phase-pure broad interior')
+    h = tuple(tuple(reference.entry('broad', origin+i, origin+j).value
+                    for j in range(length)) for i in range(length))
+    a, b, c, d = (sub(h, interior, interior), sub(h, interior, boundary),
+                   sub(h, boundary, interior), sub(h, boundary, boundary))
+    ai = inverse(a)
+    correction = multiply(multiply(c, ai), b)
+    f = tuple(tuple(x-y for x, y in zip(row, term)) for row, term in zip(d, correction))
+    return f, dict(kind='broad', reference_sha256=reference.description_hash,
+                   parameters=list(reference.spec.__dict__.values()), origin=origin,
+                   length=length, I=list(interior), J=list(boundary),
+                   H=[[str(x) for x in row] for row in h],
+                   F=[[str(x) for x in row] for row in f],
+                   interior_inverse_norm=str(norm(ai)), schur_norm=str(norm(f)),
+                   scope='exact finite rational source; no whole broad word or ideal comparison')
+
+
+def factors(matrix, block, precision, *, pre_round=True):
+    n = len(matrix)
+    need(n > 0 and all(len(row) == n for row in matrix), 'square forward matrix')
+    need(type(block) is int and block > 0 and block & (block-1) == 0
+         and type(precision) is int and precision >= 0, 'dyadic lift and integer grid')
+    need(all(not Q(x) or abs(2*i-(2*j+1)) <= block
+             for i, row in enumerate(matrix) for j, x in enumerate(row)),
+         'funded exact forward bandwidth before rounding')
+    data = tuple(tuple(rounded(x, precision) if pre_round else Q(x) for x in row)
+                 for row in matrix)
+    extent = 2*n
+    nilpotent = tuple(tuple(-data[i//2][j//2] if i % 2 == 0 and j % 2 == 1 else Q()
+                            for j in range(extent)) for i in range(extent))
+    need(all(not x or abs(i-j) <= block for i, row in enumerate(nilpotent)
+             for j, x in enumerate(row)), 'funded original interleaved bandwidth')
+    lower = tuple(tuple(Q(i == j)+(nilpotent[i][j] if i//block > j//block else 0)
+                         for j in range(extent)) for i in range(extent))
+    upper = tuple(tuple(Q(i == j)+(nilpotent[i][j] if i//block <= j//block else 0)
+                         for j in range(extent)) for i in range(extent))
+    return lower, upper
+
+
+def expected_pages(matrix, block, precision, *, pre_round=True):
+    """External direct mask observer; not used to supply physical page data."""
+    lower, upper = factors(matrix, block, precision, pre_round=pre_round)
+    n = len(lower)
+    size = ((n+block-1)//block)*block
+    def padded(a):
+        return tuple(tuple(a[i][j] if i < n and j < n else Q(i == j)
+                           for j in range(size)) for i in range(size))
+    out = []
+    for direction, a in enumerate((padded(lower), padded(upper))):
+        if direction:
+            a = tuple(tuple(reversed(row)) for row in reversed(a))
+        diagonals, coupling = [], []
+        for start in range(0, size, block):
+            diagonals.extend(rounded(2*Q(i == j)-a[start+i][start+j], precision)
+                             for i in range(block) for j in range(block))
+            if start:
+                coupling.extend(rounded(a[i][j], precision)
+                                for i in range(start, start+block)
+                                for j in range(start-block, start))
+        out.extend((tuple(diagonals), tuple(coupling)))
+    return tuple(out)
+
+
+def physical_factors(matrix, block, precision, pool):
+    """Serialize pre-rounded exact factors, then caller runs prepare_pages."""
+    from cardinal_counts import Count
+    from gaussian_matrix import Matrix
+    from gaussian_rationals import Rational
+    from ring_check_words import decode
+    from ring_words import Signed
+    from router_metadata import owned
+    data = factors(matrix, block, precision)
+    owners = []
+    def make(value):
+        return Rational(Signed(Count.literal(abs(value.numerator)), value < 0),
+                        Count.literal(value.denominator))
+    try:
+        for a in data:
+            with owned(Count.literal(len(a))) as (size,):
+                owners.append(Matrix(size, size, pool,
+                    lambda i, j, a=a: make(a[decode(i)][decode(j)])))
+        return tuple(owners)
+    except BaseException:
+        for owner in owners:
+            owner.close()
+        raise
+
+
+def rounded_oracle(matrix, rhs, block, precision):
+    """Finite rational recurrence observer, independent of physical movement."""
+    n, columns = len(matrix), len(rhs[0])
+    banks = expected_pages(matrix, block, precision)
+    size = ((2*n+block-1)//block)*block
+    current = []
+    for row in rhs:
+        current.extend(([Q()]*columns, list(row)))
+    current.extend([[Q()]*columns for _ in range(size-2*n)])
+    for direction in range(2):
+        if direction:
+            current.reverse()
+        output = []
+        diagonal, coupling = banks[2*direction:2*direction+2]
+        for start in range(0, size, block):
+            residual = current[start:start+block]
+            if start:
+                offset = (start-block)*block
+                c = tuple(coupling[offset+i*block:offset+(i+1)*block] for i in range(block))
+                term = multiply(c, output[-block:])
+                residual = [[rounded(x-y, precision) for x, y in zip(row, part)]
+                            for row, part in zip(residual, term)]
+            offset = start*block
+            d = tuple(diagonal[offset+i*block:offset+(i+1)*block] for i in range(block))
+            output.extend([rounded(x, precision) for x in row] for row in multiply(d, residual))
+        current = output
+    current.reverse()
+    need(tuple(tuple(current[2*i+1]) for i in range(n)) == tuple(tuple(row) for row in rhs),
+         'oracle preserved sources')
+    return tuple(tuple(current[2*i]) for i in range(n))
diff --git a/research/physical-banded-forward-action/reference_source.py b/research/physical-banded-forward-action/reference_source.py
new file mode 100644
index 0000000000..b78551e461
--- /dev/null
+++ b/research/physical-banded-forward-action/reference_source.py
@@ -0,0 +1,114 @@
+"""Authenticated binding to the retained global Gaussian Reference.
+
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+The executed Reference/interval algorithms belong to Jose Manuel and Mason
+Hale, with the original geometry and mathematical lineage credited in README.
+"""
+import ast
+from fractions import Fraction as Q
+from hashlib import sha256
+import json
+from pathlib import Path
+import sys
+from types import ModuleType
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+REFERENCE = "research/rational-unitary-fft/gaussian_reference.py"
+EXACT = "research/rational-unitary-fft/exact.py"
+GAUSSIAN = "research/rational-unitary-fft/gaussian.py"
+INTERVALS = "research/certified-gaussian-recovery/intervals.py"
+
+
+def authenticated_inputs(package):
+    root = package.parent.parent
+    manifest = json.loads((package / "SOURCES.json").read_text())
+    raw = {}
+    for item in manifest["files"]:
+        if item["usage"] == "input":
+            content = (root / item["path"]).read_bytes()
+            need(sha256(content).hexdigest() == item["sha256"],
+                 "changed pinned input: " + item["path"])
+            raw[item["path"]] = content
+    need(all(path in raw for path in (REFERENCE, EXACT, GAUSSIAN, INTERVALS)),
+         "complete source dependency manifest")
+    return raw
+
+
+def _module(name, statements, namespace=None):
+    module = ModuleType(name)
+    if namespace:
+        module.__dict__.update(namespace)
+    sys.modules[name] = module
+    tree = ast.Module(body=statements, type_ignores=[])
+    exec(compile(ast.fix_missing_locations(tree), "<authenticated source adapter>",
+                 "exec", optimize=0), module.__dict__)
+    return module
+
+
+def reference_class(raw):
+    """Rebind only imports, leaving every executed numerical body unchanged.
+
+    gaussian.py also imports a full circuit compiler unused by Reference's
+    explicit constructor/entry interface. Extract exactly its three named
+    helpers; no numerical source expression or loop is changed. for_cap is
+    outside this adapter's domain and is not invoked.
+    """
+    exact_tree = ast.parse(raw[EXACT])
+    exact = _module("_shrinking_source_exact", exact_tree.body)
+    gaussian_tree = ast.parse(raw[GAUSSIAN])
+    wanted = {"rational", "load_intervals"}
+    helpers = [node for node in gaussian_tree.body
+               if isinstance(node, ast.FunctionDef) and node.name in wanted]
+    need({node.name for node in helpers} == wanted, "retained Gaussian helper shape")
+    gaussian = _module("_shrinking_source_gaussian", helpers,
+                       {"Q": Q, "need": need, "sha256": sha256, "sys": sys,
+                        "ModuleType": ModuleType})
+    tree = ast.parse(raw[REFERENCE])
+    body = [node for node in tree.body if not (
+        isinstance(node, ast.ImportFrom) and node.module in ("exact", "gaussian"))]
+    reference = _module("_shrinking_source_reference", body,
+                        {"Mat": exact.Mat, "ceil_log2": exact.ceil_log2,
+                         "need": exact.need, "INTERVALS": INTERVALS,
+                         "load_intervals": gaussian.load_intervals,
+                         "rational": gaussian.rational})
+    return reference.Reference
+
+
+def make_reference(raw, parameters):
+    return reference_class(raw)(raw, *parameters)
+
+
+def source_entry(reference, row, column):
+    return Q(int(row == column)) - reference.entry("narrow", row, column).value
+
+
+def source_receipt(reference):
+    """Diagnostic setup inventory; not an asserted exact Python heap count."""
+    values = [entry.value for entry in reference.entries.values()]
+    weight_values = [value for receipt in reference.weights.values()
+                     for value in receipt.values() if type(value) is Q]
+    height = max([1] + [max(abs(x.numerator).bit_length(), x.denominator.bit_length())
+                        for x in values + weight_values])
+    return dict(reference_sha256=reference.description_hash,
+                parameters=list(reference.spec.__dict__.values()),
+                stored_entries=len(reference.entries), stored_weights=len(reference.weights),
+                stored_kernels=len(reference.kernel), maximum_rational_height=height,
+                weight_precision=reference.weight_precision,
+                kernel_error_bits=reference.kernel_error_bits)
+
+
+def clear_reference(reference):
+    """Release setup caches; physical erasure is separately charged in proof.
+
+    This does not claim secure zeroization of Python immutable integers.
+    """
+    reference.entries.clear(); reference.weights.clear(); reference.kernel.clear()
+    for name in ("pi_interval", "root_of_unity"):
+        function = getattr(reference.exp.oracle, name, None)
+        if function is not None and hasattr(function, "cache_clear"):
+            function.cache_clear()
diff --git a/research/physical-banded-forward-action/retained/fast_boundary.py b/research/physical-banded-forward-action/retained/fast_boundary.py
new file mode 100644
index 0000000000..aedc06b495
--- /dev/null
+++ b/research/physical-banded-forward-action/retained/fast_boundary.py
@@ -0,0 +1,79 @@
+"""Seven-product replacement for the unchanged #5059 completed-product ABI.
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from boundary_pages import BoundaryPages
+from cardinal_counts import Count
+from compact_counts import copy_bits
+from router_metadata import owned
+from session import borrowed_count, borrowed_tape, erase_marker
+from words import BLANK, LEFT, RIGHT, need
+from seven_product import SevenProduct
+
+
+def origin(tape):
+    need(tape.read()!=LEFT,'canonical fast-boundary borrowed origin')
+    tape.step(-1);correct=tape.read()==LEFT;tape.step(1)
+    need(correct,'canonical fast-boundary borrowed origin')
+
+
+def dyadic(count):
+    """One literal count scan; no decoded logarithm or host dimension."""
+    source=count.tape;seen=False
+    try:
+        while source.read() in (0,1):
+            if source.read()==1:
+                need(not seen,'dyadic fast-boundary block size');seen=True
+            source.step(1)
+        need(source.read()==RIGHT and seen,'dyadic fast-boundary block size')
+    finally:source.rewind()
+
+
+class FastBoundaryPages(BoundaryPages):
+    def __init__(self):
+        super().__init__();self.kernel=SevenProduct();self.pending=False
+
+    def forbidden(self):
+        w=self.word
+        return (*self.pool.tapes,self.output,*w.pool.tapes,w.output,*w.canonical,
+                *w.base.pool.tapes,*w.product.pool.tapes,
+                *w.product.word.pool.tapes,*w.product.twiddles.pool.tapes,
+                *self.kernel.forbidden())
+
+    def idle(self):
+        super().idle();self.kernel.idle()
+        need(self.kernel.closed and not self.kernel.pending,
+             'consumed fast-boundary matrix child')
+
+    def consume(self):
+        need(self.closed and self.pending,'one pending fast-boundary return')
+        self.output.clear();erase_marker(self.output);self.pending=False
+        self.idle()
+
+    def product(self,first,second,destination,block,width,wide):
+        """Copy the complete exact wide product; no P-grid rounding here."""
+        try:
+            with self.scope.suspended():
+                returned=self.kernel.run(first,second,block,width,wide)
+            with owned(Count.product(block,block)) as (entries,):
+                with owned(Count.product(entries,wide)) as (bits,):
+                    copy_bits(returned,destination,bits)
+            need(returned.read()==BLANK,'complete fast-boundary matrix result')
+            self.products+=1
+        finally:
+            if self.kernel.pending:self.kernel.consume()
+            first.rewind();second.rewind();destination.rewind()
+
+    def run(self,lower_d,lower_b,upper_d,upper_b,rhs,length,columns,block,width,precision):
+        sources=tuple(borrowed_tape(t) for t in (lower_d,lower_b,upper_d,upper_b,rhs))
+        metadata=tuple(borrowed_count(c) for c in (length,columns,block,width,precision))
+        forbidden=self.forbidden()
+        need(len(set(sources))==5 and all(t not in forbidden for t in sources)
+             and all(c.tape not in forbidden and c.tape not in sources for c in metadata),
+             'external distinct fast-boundary ports')
+        need(self.closed and not self.pending and not self.pool.live
+             and self.output.read()==BLANK,'consume prior fast-boundary output')
+        for tape in (*sources,*(c.tape for c in metadata)):origin(tape)
+        self.idle();dyadic(metadata[2])
+        result=super().run(*sources,*metadata)
+        self.pending=True
+        return result
diff --git a/research/physical-banded-forward-action/retained/seven_product.py b/research/physical-banded-forward-action/retained/seven_product.py
new file mode 100644
index 0000000000..1c4d48c6d1
--- /dev/null
+++ b/research/physical-banded-forward-action/retained/seven_product.py
@@ -0,0 +1,286 @@
+"""Exact seven-product matrix multiplication on a fixed physical tape inventory.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+The Strassen identity is inherited. This file supplies its encoded, flat
+seven-stage depth-first execution, tip-only frame parking and exact ABI.
+"""
+from gaussian_sources import active
+active()
+from cardinal_counts import Count,positive
+from compact_counts import copy_bits
+from encoded import compare,divide
+from fft_arithmetic import Arithmetic
+from fft_word_engine import FftWord
+from records import Tape
+from ring_words import Signed,add,difference,read_signed,write_signed
+from router_metadata import indices,owned
+from scratch_pool import ScratchPool
+from session import (OuterScope,borrowed_count,borrowed_tape,erase_marker,
+                     initialize_marker,sealed_constructors)
+from words import BLANK,LEFT,need
+
+FRAME_BASE=5
+LEFT_TERMS=((0,3,1),(2,3,1),(0,0,0),(3,3,0),(0,1,1),(2,0,-1),(1,3,-1))
+RIGHT_TERMS=((0,3,1),(0,0,0),(1,3,-1),(2,0,-1),(3,3,0),(0,1,1),(2,3,1))
+UPDATES=(((0,False),(3,False)),((2,False),(3,True)),
+         ((1,False),(3,False)),((0,False),(2,False)),
+         ((0,True),(1,False)),((3,False),),((0,False),))
+
+
+def origin(tape):
+    need(tape.read()!=LEFT,'canonical seven-product borrowed origin')
+    tape.step(-1);correct=tape.read()==LEFT;tape.step(1)
+    need(correct,'canonical seven-product borrowed origin')
+
+
+def dyadic_log(value,one,two):
+    positive(value);current=Count(value);logarithm=Count.literal(0)
+    try:
+        while compare(current,one)>0:
+            quotient,remainder=divide(current,two)
+            try:need(remainder.zero(),'seven-product block is a power of two')
+            except BaseException:quotient.close();raise
+            finally:remainder.close()
+            current.close();current=quotient;logarithm.increment()
+        need(compare(current,one)==0,'seven-product terminal dimension one')
+        result,logarithm=logarithm,None;return result
+    finally:
+        current.close()
+        if logarithm is not None:logarithm.close()
+
+
+class SevenProduct:
+    def __init__(self):
+        self.word=FftWord(base_bits=4096)
+        self.pool=ScratchPool(256);self.scope=OuterScope(self.pool)
+        self.arithmetic=Arithmetic(self.word,self.scope)
+        self.left,self.right=Tape(),Tape()
+        self.qa=tuple(Tape() for _ in range(4));self.qb=tuple(Tape() for _ in range(4))
+        self.acc=tuple(Tape() for _ in range(4))
+        self.result,self.combine,self.parked,self.reverse,self.output=(Tape() for _ in range(5))
+        self.closed=True;self.pending=False
+        self.calls=self.nodes=self.leaves=self.pushes=self.pops=0
+        for tape in (*self.pool.tapes,*self.buffers()):erase_marker(tape)
+
+    def buffers(self):
+        return (self.left,self.right,*self.qa,*self.qb,*self.acc,self.result,
+                self.combine,self.parked,self.reverse,self.output)
+
+    def forbidden(self):
+        word=self.word
+        return (*self.pool.tapes,*self.buffers(),*word.pool.tapes,word.output,
+                *word.canonical,*word.base.pool.tapes,*word.product.pool.tapes,
+                *word.product.word.pool.tapes,*word.product.twiddles.pool.tapes)
+
+    def word_idle(self):
+        self.word.idle()
+        need(self.word.closed and not self.word.pool.live and self.word.output.read()==BLANK,
+             'consumed seven-product scalar owner')
+
+    def idle(self):
+        need(self.closed and not self.pending and not self.pool.live and self.output.read()==BLANK,
+             'consumed seven-product owner')
+        self.word_idle()
+
+    def consume(self):
+        need(self.closed and self.pending,'one pending seven-product return')
+        self.output.clear();erase_marker(self.output);self.pending=False
+        self.idle()
+
+    def promote(self,source,destination,entries,width,widened):
+        source.rewind()
+        try:
+            for _ in indices(entries):
+                with owned(read_signed(source,width)) as (value,):
+                    write_signed(value,destination,widened)
+            need(source.read()==BLANK,'complete seven-product input matrix')
+        finally:source.rewind();destination.rewind()
+
+    def split(self,source,quadrants,half,width):
+        source.rewind()
+        with owned(Count.product(half,width)) as (row_bits,):
+            for left,right in ((quadrants[0],quadrants[1]),(quadrants[2],quadrants[3])):
+                for _ in indices(half):
+                    copy_bits(source,left,row_bits);copy_bits(source,right,row_bits)
+        need(source.read()==BLANK,'complete streamed matrix quadrant split')
+        for tape in quadrants:tape.rewind()
+        source.clear()
+
+    def zero_accumulators(self,entries,width):
+        with owned(Count.product(entries,width)) as (bits,):
+            for tape in self.acc:
+                for _ in indices(bits):tape.append(0)
+                tape.rewind()
+
+    def operand(self,quadrants,term,destination,entries,width):
+        first,second,sign=term;a=quadrants[first];b=quadrants[second]
+        a.rewind();b.rewind()
+        try:
+            if sign==0:
+                with owned(Count.product(entries,width)) as (bits,):copy_bits(a,destination,bits)
+            else:
+                for _ in indices(entries):
+                    with owned(read_signed(a,width),read_signed(b,width)) as (x,y):
+                        with owned(add(x,y) if sign==1 else difference(x,y)) as (value,):
+                            write_signed(value,destination,width)
+                need(b.read()==BLANK,'complete second quadrant operand')
+            need(a.read()==BLANK,'complete first quadrant operand')
+        finally:a.rewind();b.rewind();destination.rewind()
+
+    def push(self,stage,entries,u,v):
+        """Append one parent to the current parked tip; no ancestor rewind."""
+        need(self.parked.read()==BLANK,'parked frame tip')
+        for tapes,width in ((self.qa+self.qb,u),(self.acc,v)):
+            with owned(Count.product(entries,width)) as (bits,):
+                for tape in tapes:
+                    tape.rewind();copy_bits(tape,self.parked,bits)
+                    need(tape.read()==BLANK,'complete parked matrix')
+                    tape.clear()
+        self.parked.append(FRAME_BASE+stage);self.pushes+=1
+
+    def pop(self,entries,u,v):
+        """Read the finite continuation, then delete only the final frame."""
+        need(self.parked.read()==BLANK,'parked return tip')
+        self.parked.step(-1);symbol=self.parked.read()
+        if symbol==LEFT:
+            self.parked.step(1);return None
+        need(FRAME_BASE<=symbol<FRAME_BASE+7,'seven-product finite continuation')
+        stage=symbol-FRAME_BASE;self.parked.write(BLANK);self.parked.step(-1)
+        with owned(Count(u),Count(v)) as (extent,part):
+            extent.multiply_small(8);part.multiply_small(4);extent.add(part)
+            with owned(Count.product(entries,extent)) as (bits,):
+                for _ in indices(bits):
+                    bit=self.parked.read();need(bit in(0,1),'complete parked frame body')
+                    self.reverse.append(bit);self.parked.write(BLANK);self.parked.step(-1)
+        self.parked.step(1);self.reverse.step(-1)
+        for tapes,width in ((self.qa+self.qb,u),(self.acc,v)):
+            with owned(Count.product(entries,width)) as (bits,):
+                for tape in tapes:
+                    for _ in indices(bits):
+                        bit=self.reverse.read();need(bit in(0,1),'complete reversed frame body')
+                        tape.append(bit);self.reverse.write(BLANK);self.reverse.step(-1)
+                    tape.rewind()
+        need(self.reverse.read()==LEFT,'exact reversed frame extent');self.reverse.step(1)
+        self.pops+=1;return stage
+
+    def dispatch(self,stage,n,two,u,v):
+        half,remainder=divide(n,two)
+        try:
+            need(remainder.zero() and not half.zero(),'exact nonleaf dyadic split')
+            with owned(Count.product(half,half)) as (entries,):
+                self.operand(self.qa,LEFT_TERMS[stage],self.left,entries,u)
+                self.operand(self.qb,RIGHT_TERMS[stage],self.right,entries,u)
+                self.push(stage,entries,u,v)
+            result,half=half,None;return result
+        finally:
+            remainder.close()
+            if half is not None:half.close()
+
+    def add_return(self,slot,negative,entries,v):
+        accumulator=self.acc[slot];accumulator.rewind();self.result.rewind()
+        try:
+            for _ in indices(entries):
+                with owned(read_signed(accumulator,v),read_signed(self.result,v)) as (old,value):
+                    with owned(difference(old,value) if negative else add(old,value)) as (updated,):
+                        write_signed(updated,self.combine,v)
+            need(accumulator.read()==self.result.read()==BLANK,'complete returned product update')
+            accumulator.clear();self.combine.rewind()
+            with owned(Count.product(entries,v)) as (bits,):copy_bits(self.combine,accumulator,bits)
+            need(self.combine.read()==BLANK,'complete accumulator replacement')
+        finally:
+            self.combine.clear();accumulator.rewind();self.result.rewind()
+
+    def join(self,half,v):
+        with owned(Count.product(half,v)) as (row_bits,):
+            for left,right in ((self.acc[0],self.acc[1]),(self.acc[2],self.acc[3])):
+                for _ in indices(half):
+                    copy_bits(left,self.result,row_bits);copy_bits(right,self.result,row_bits)
+                need(left.read()==right.read()==BLANK,'complete returned quadrant join')
+        for tape in (*self.qa,*self.qb,*self.acc):tape.clear()
+        self.result.rewind()
+
+    def compute(self,block,one,two,u,v):
+        """Flat finite-state DFS; only the current dimension remains live."""
+        n=Count(block);returning=False
+        try:
+            while True:
+                if not returning:
+                    self.nodes+=1
+                    if compare(n,one)==0:
+                        with owned(read_signed(self.left,u),read_signed(self.right,u)) as (a,b):
+                            with owned(self.arithmetic.multiply(a,b,u)) as (value,):
+                                write_signed(value,self.result,v)
+                        need(self.left.read()==self.right.read()==BLANK,'complete scalar leaf matrices')
+                        self.left.clear();self.right.clear();self.result.rewind()
+                        self.leaves+=1;returning=True
+                    else:
+                        half,remainder=divide(n,two)
+                        try:
+                            need(remainder.zero(),'internal dyadic quadrant split')
+                            self.split(self.left,self.qa,half,u)
+                            self.split(self.right,self.qb,half,u)
+                            with owned(Count.product(half,half)) as (entries,):
+                                self.zero_accumulators(entries,v)
+                        finally:half.close();remainder.close()
+                        child=self.dispatch(0,n,two,u,v);n.close();n=child
+                        continue
+                with owned(Count.product(n,n)) as (entries,):
+                    stage=self.pop(entries,u,v)
+                    if stage is None:break
+                    for slot,negative in UPDATES[stage]:self.add_return(slot,negative,entries,v)
+                self.result.clear()
+                if stage==6:
+                    self.join(n,v);n.multiply_small(2)
+                    returning=True
+                else:
+                    n.multiply_small(2)
+                    child=self.dispatch(stage+1,n,two,u,v);n.close();n=child
+                    returning=False
+            need(compare(n,block)==0,'root returned dimension')
+        finally:n.close()
+
+    def run(self,first,second,block,width,wide):
+        first,second=borrowed_tape(first),borrowed_tape(second)
+        block,width,wide=(borrowed_count(c) for c in (block,width,wide))
+        sources=(first,second);metadata=(block,width,wide)
+        forbidden=self.forbidden()
+        need(first is not second and all(t not in forbidden for t in sources)
+             and all(c.tape not in forbidden and c.tape not in sources for c in metadata),
+             'external seven-product operands and metadata')
+        ports=(*sources,*(c.tape for c in metadata))
+        for tape in ports:origin(tape)
+        self.idle();positive(width)
+        for tape in (*self.pool.tapes,*self.buffers()):initialize_marker(tape)
+        self.closed=False;succeeded=False
+        try:
+            with sealed_constructors(),self.scope.installed():
+                with owned(Count.literal(1),Count.literal(2)) as (one,two):
+                    with owned(dyadic_log(block,one,two),Count(width),Count(width),Count(width)) as (ell,u,v,expected):
+                        u.add(ell);u.add(two)
+                        v.multiply_small(2)
+                        with owned(Count(ell)) as (four_ell,):
+                            four_ell.multiply_small(4);v.add(four_ell)
+                        v.add(two);v.add(two)
+                        expected.multiply_small(2);expected.add(ell);expected.add(two)
+                        need(compare(wide,expected)==0,'exact inherited matrix return width')
+                        with owned(Count.product(block,block)) as (entries,):
+                            self.promote(first,self.left,entries,width,u)
+                            self.promote(second,self.right,entries,width,u)
+                            self.compute(block,one,two,u,v)
+                            for _ in indices(entries):
+                                with owned(read_signed(self.result,v)) as (value,):
+                                    write_signed(value,self.output,wide)
+                            need(self.result.read()==BLANK,'complete exact root matrix')
+                        self.result.clear();self.word_idle();self.calls+=1
+                        succeeded=self.pending=True
+        finally:
+            for tape in ports:tape.rewind()
+            for tape in self.buffers():
+                if tape is not self.output:tape.clear()
+            self.pool.empty()
+            for tape in (*self.pool.tapes,*(t for t in self.buffers() if t is not self.output)):
+                erase_marker(tape)
+            self.output.rewind()
+            if not succeeded:self.output.clear();erase_marker(self.output);self.pending=False
+            self.closed=True
+        return self.output
diff --git a/research/physical-banded-forward-action/sources.py b/research/physical-banded-forward-action/sources.py
new file mode 100644
index 0000000000..f0c8106f8e
--- /dev/null
+++ b/research/physical-banded-forward-action/sources.py
@@ -0,0 +1,47 @@
+"""Use the unchanged authenticated physical scalar-word cohort.
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from contextlib import contextmanager
+import importlib.util
+from hashlib import file_digest
+import json
+from pathlib import Path
+import sys
+PACKAGE=Path(__file__).resolve().parent
+ROOT=PACKAGE.parent.parent
+PHYSICAL=PACKAGE.parent/'physical-gaussian-core'
+@contextmanager
+def physical_runtime():
+    if 'gaussian_sources' in sys.modules:raise ValueError('cold banded-action namespace')
+    old=sys.path[:];sys.path[:0]=[str(PHYSICAL),str(PACKAGE),str(PACKAGE/"retained"),str(PACKAGE.parent/"physical-boundary-pages")]
+    spec=importlib.util.spec_from_file_location('gaussian_sources',PHYSICAL/'gaussian_sources.py')
+    source=importlib.util.module_from_spec(spec);sys.modules['gaussian_sources']=source
+    try:
+        spec.loader.exec_module(source)
+        with source.opened() as state:yield state
+    finally:sys.path[:]=old
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+def authenticated_inputs():
+    manifest=json.loads((PACKAGE/'SOURCES.json').read_text());result={}
+    for row in manifest['files']:
+        if row['usage']!='input':continue
+        path=ROOT/row['path']
+        need(path.is_file() and not path.is_symlink(),'regular seven-product source: '+row['path'])
+        with path.open('rb') as stream:digest=file_digest(stream,'sha256').hexdigest()
+        need(digest==row['sha256'],'pinned seven-product source: '+row['path'])
+        result[row['path']]=digest
+    for row in manifest['retained_files']:
+        path=PACKAGE/row['path']
+        need(path.is_file() and not path.is_symlink(),'regular retained source: '+row['path'])
+        with path.open('rb') as stream:digest=file_digest(stream,'sha256').hexdigest()
+        need(digest==row['sha256'],'pinned retained source: '+row['path'])
+        result[row['path']]=digest
+    return result
+
+def load(name,path):
+    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
diff --git a/research/physical-banded-forward-action/verify.py b/research/physical-banded-forward-action/verify.py
new file mode 100644
index 0000000000..d363a363a3
--- /dev/null
+++ b/research/physical-banded-forward-action/verify.py
@@ -0,0 +1,93 @@
+"""Reproduce the actual broad-source and singular physical forward cases."""
+from pathlib import Path
+import argparse
+from fractions import Fraction as Q
+import importlib.util
+import json
+import sys
+
+PACKAGE = Path(__file__).resolve().parent
+sys.path.insert(0, str(PACKAGE))
+_spec = importlib.util.spec_from_file_location('banded_action_sources', PACKAGE/'sources.py')
+sources = importlib.util.module_from_spec(_spec)
+sys.modules[_spec.name] = sources
+_spec.loader.exec_module(sources)
+import pages
+import reference_source
+import independent_forward
+
+
+def stable(value):
+    if isinstance(value, Q):
+        return str(value)
+    if isinstance(value, dict):
+        return {key: stable(item) for key, item in value.items() if key != 'seconds'}
+    if isinstance(value, (tuple, list)):
+        return [stable(item) for item in value]
+    return value
+
+
+def run():
+    source_pins = sources.authenticated_inputs()
+    raw = reference_source.authenticated_inputs(PACKAGE)
+    reference = reference_source.make_reference(raw, (61, 3, 2, 1, 3, 32))
+    broad, source = pages.broad_source(reference)
+    source['independent_review'] = independent_forward.check_source(reference, broad)
+    singular = tuple(tuple(Q(x, 3) for x in row) for row in ((1, -1, 0), (-1, 2, -1), (0, -1, 1)))
+    pages.need(all(sum(row, Q()) == 0 for row in singular)
+               and singular[0][0]*singular[1][1] != singular[0][1]*singular[1][0],
+               'exact rank-two singular control')
+    try:
+        pages.factors(((Q(1), Q(), Q(1, 1 << 80)), (Q(), Q(1), Q()), (Q(), Q(), Q(1))), 4, 8)
+    except ValueError as error:
+        pages.need(str(error) == 'funded exact forward bandwidth before rounding', 'exact support control')
+    else:
+        raise ValueError('small off-band source coefficient hidden by rounding')
+    print('SOURCE_VALIDATED', file=sys.stderr, flush=True)
+    with sources.physical_runtime():
+        from records import Tape
+        from action import BandedAction
+        from fixture import case, erased
+        all_tapes = []
+        original_init = Tape.__init__
+        def tracked(tape):
+            original_init(tape)
+            all_tapes.append(tape)
+        Tape.__init__ = tracked
+        try:
+            owner = BandedAction()
+            pages.need({id(t) for t in all_tapes} == {id(t) for t in owner.forbidden()},
+                       'complete constructor ownership census')
+            first = case(owner, all_tapes, broad)
+            print('BROAD_PASSED', file=sys.stderr, flush=True)
+            second = case(owner, all_tapes, singular, precision=8, width=16)
+            print('SINGULAR_PASSED', file=sys.stderr, flush=True)
+            third = case(owner, all_tapes, ((Q(),),), block=1, precision=4, width=8,
+                         columns=1, controls=False)
+            erased(owner)
+            print('HISTORY_PASSED', file=sys.stderr, flush=True)
+            return dict(marker='PASS_PHYSICAL_BANDED_FORWARD_ACTION', source_pins=source_pins,
+                        source=source, broad=first, singular=second, long_to_short=third,
+                        owned_roles=len(owner.forbidden()), source_controls=['exact rank-two null vector',
+                        'nongrid signed coefficient pre-round equivalence', 'tiny off-band before rounding'],
+                        no_new_kappa=True,
+                        scope='literal supplied band action; exact finite broad Reference Schur; no full broad window')
+        finally:
+            Tape.__init__ = original_init
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--write-result', action='store_true')
+    parser.add_argument('--emit', action='store_true')
+    args = parser.parse_args()
+    result = stable(run())
+    if args.write_result:
+        (PACKAGE/'RESULT.json').write_text(json.dumps(result, indent=2, sort_keys=True)+'\n')
+    elif not args.emit:
+        pages.need(result == json.loads((PACKAGE/'RESULT.json').read_text()), 'stable exact forward receipt')
+    print(json.dumps(result, indent=2, sort_keys=True))
+
+
+if __name__ == '__main__':
+    main()