diff --git a/research/native-kappa-30201655/.gitattributes b/research/native-kappa-30201655/.gitattributes
new file mode 100644
index 0000000000..fa1385d99a
--- /dev/null
+++ b/research/native-kappa-30201655/.gitattributes
@@ -0,0 +1 @@
+* -text
diff --git a/research/native-kappa-30201655/4535-BRIDGE-PINS.json b/research/native-kappa-30201655/4535-BRIDGE-PINS.json
new file mode 100644
index 0000000000..93467db60e
--- /dev/null
+++ b/research/native-kappa-30201655/4535-BRIDGE-PINS.json
@@ -0,0 +1,40 @@
+{
+  "files": [
+    {
+      "pr": 4483,
+      "head": "fb0c208864e6b24e3473318a058aa5b2dbd5764b",
+      "path": "research/compact-joint-compiler/PROOF.md",
+      "sha256": "3f337fba12288d3b5e51af9541e2a645f79c8668fabf48b212672285fe6150b4"
+    },
+    {
+      "pr": 4532,
+      "head": "644607ba59ebe401ac7ecd627ae7f331f924d1b0",
+      "path": "research/adaptive-gate-existence/PROOF.md",
+      "sha256": "340d637feef40f44a808c718207c0fede12cc483e2c979b86c56bb736b9c1ef5"
+    },
+    {
+      "pr": 4483,
+      "head": "fb0c208864e6b24e3473318a058aa5b2dbd5764b",
+      "path": "research/direct-mixed-flow/README.md",
+      "sha256": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8"
+    },
+    {
+      "pr": 4483,
+      "head": "fb0c208864e6b24e3473318a058aa5b2dbd5764b",
+      "path": "research/compact-joint-compiler/arithmetic/PROOF.txt",
+      "sha256": "273598588316e29a45e3940c6f5070d973b1998fe5b9c582b23bfe87502724cc"
+    },
+    {
+      "pr": 4535,
+      "head": "a6d7237f697185e857090e174c23c1cb22c6563c",
+      "path": "research/critical-root-multiplication/PROOF.md",
+      "sha256": "870cc213c847175f3717db057539686de638594e8c509b2a2daf8d8e72497102"
+    },
+    {
+      "pr": 4535,
+      "head": "a6d7237f697185e857090e174c23c1cb22c6563c",
+      "path": "research/critical-root-multiplication/RESULT.json",
+      "sha256": "e830f4cab30e70ab02d2ecca283969bd97f3a6925948b61d0eb15df3be831b14"
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/BATCHED-INVERSE.md b/research/native-kappa-30201655/BATCHED-INVERSE.md
new file mode 100644
index 0000000000..80dfbba996
--- /dev/null
+++ b/research/native-kappa-30201655/BATCHED-INVERSE.md
@@ -0,0 +1,94 @@
+# Batched native solves for one shared Gaussian band inverse
+
+Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0.
+
+This is a constructive sufficient native Word RAM algorithm, with no Turing-machine primitive. It improves the inverse adapter when the retained bandwidth grows. It does not establish a larger complete multiplication κ: in modern outer regimes the bandwidth may already be bounded, and the Fourier-kernel exponent is a separate constraint.
+
+## Theorem
+
+Put ω = log₂ 7. Let A be a shared s by s triangular matrix of bandwidth at most h, and let R right-hand sides be supplied. Let H be a power of two with h ≤ H < 2(h+1). Pad s to a multiple of H with independent unit diagonal coordinates. Suppose the absolute row sums of A, of its contiguous H by H diagonal blocks, and of their inverses, as well as ||A⁻¹||∞, are bounded by a known polynomial in n. The input norm means the maximum infinity norm of an INDIVIDUAL right-hand-side column, equivalently the maximum absolute input entry. It is not the induced row-sum norm of the entire R-column matrix; no factor R enters the precision bound. This norm and requested precision have O(log n) bits. Every entry is a supplied bounded-word dyadic number; no matrix or inverse oracle is supplied.
+
+There is an explicit native algorithm with preparation O(s H²), application
+
+    O(s (R+H) H^(ω−2)),
+
+and O(s R+s H) stored words, at any requested absolute accuracy 2⁻ᴾ. A sufficiently large fixed constant times log n bits per physical word suffices. For R ≥ H, application is O(s R H^(ω−2)), strictly improving the scalar O(s R H) count when H grows.
+
+## Constructive organization
+
+Number diagonal blocks in substitution order. Because the bandwidth is at most H, only the immediately preceding block can couple to a block. Write its equation
+
+    Dᵢ Xᵢ + Eᵢ Xᵢ₋₁ = Bᵢ.
+
+Prepare Gᵢ ≈ Dᵢ⁻¹ by ordinary triangular substitution on H unit columns. This costs O(H³) per block, or O(s H²) in all. This is an actual bounded-word computation, not an assumed inverse. Partition the right-hand sides into batches of H and pad the final batch with zero columns. In substitution order compute
+
+    Xᵢ = Gᵢ (Bᵢ − Eᵢ Xᵢ₋₁).
+
+Both products are H by H products. Use Strassen's seven-product recursion, with exact-grid additions/subtractions and signed fixed-point scalar multiplication only at its leaves. Each product costs O(H^ω) word operations. Thus each batch costs O((s/H) H^ω), proving the count. An upper triangular solve uses the reversed row and column ordering. Gathering and scattering cost O(s R).
+
+No growing-input integer multiplication is hidden: each leaf multiplies two explicitly bounded machine-word magnitudes. Signed values are sign plus magnitude; natural truncated SUB can implement a signed subtraction by comparing magnitudes first.
+
+## Explicit stability and finite words
+
+Let u be the fixed-point grid spacing. Set B ≥ 2 to bound H, the row norms of A and its blocks and coupling blocks, the inverse row norms of A and its diagonal blocks, and every right-hand-side norm. All these bounds are polynomial by hypothesis.
+
+A Strassen multiplication of exact supplied grid matrices has entrywise rounding error at most H²u. To see this, input-side sums are exact. Only scalar leaf products round, each by at most u. Each output quadrant combines at most four child outputs, so the error recurrence is e(H) ≤ 4 e(H/2), with e(1) ≤ u. This proves e(H) ≤ H²u. Input-side magnitudes grow by at most H; product and output recombination magnitudes are at most H⁴ times the square of the maximum input magnitude. They are polynomially bounded. This argument covers negative values and cancellation.
+
+In preparation, rounded triangular substitution for each inverse column has residual at most (H+M)u in each row, where M bounds the diagonal-block row norm. Each row contains at most H rounded products, and final division contributes at most M u to its equation. Hence the prepared inverse has row-norm error
+
+    εG ≤ H ||D⁻¹||∞ (H+M)u ≤ 2 B³u.
+
+For u ≤ 1/(12 B⁶), this is below 1, so its row norm is at most B+1. The same residual argument bounds every prepared inverse entry and all its substitution prefixes by a polynomial in B; no repeated-error exponential is assumed.
+
+For the application, denote the full computed solution norm by x. A block's first matrix-product error is at most B²u. The approximate-inverse error and second product give, after multiplying its equation by Dᵢ, a block residual bounded by
+
+    6 B⁵u (1+x).
+
+For completeness, use εG ≤ 2 B³u and B²u ≤ 1 in
+
+    M [ εG (X + Mx + B²u) + (K+1) B²u + B²u ],
+
+where M,K,X ≤ B. This is at most the displayed bound. The residual is a rowwise equation error, so combining all blocks takes its maximum; it is not multiplied by the number of blocks. If r is the full residual norm, the actual inverse bound gives x ≤ B²+B r. Therefore
+
+    r ≤ 6 B⁵u (1+B²+B r) ≤ 24 B⁷u,
+    ||Xcomputed − A⁻¹Binput||∞ ≤ 24 B⁸u.
+
+The assumption 6 B⁶u ≤ 1/2 closes the rearrangement. Taking
+
+    u ≤ min(1/(12 B⁶), 2⁻ᴾ/(24 B⁸))
+
+suffices. Only P+O(log B) fractional bits are needed. The computed solution norm is at most 3 B². The explicit Strassen and preparation magnitude bounds require only O(log B) additional integral bits and a fixed number of product limbs. Thus all arithmetic fits one sufficiently large common O(log n)-bit word budget, including raw products and division numerators. No floating-point instruction is assumed.
+
+## Actual Gaussian inverse caller
+
+PR #4554 supplies an explicitly formed near-identity periodic Gaussian matrix, its ordinary-band factors and its rank-at-most-2h Woodbury correction. Its proof gives polynomial inverse bounds for both triangular factors: ||L⁻¹||∞ ≤ 8 and ||U⁻¹||∞ ≤ 36(h+1), with uniformly bounded pivots and polynomial factor norms. Contiguous diagonal-block inverses are the corresponding principal blocks of the triangular inverse, so the theorem's hypotheses follow. Factor errors are separately charged by that predecessor's residual estimate.
+
+For one axis, batch its R parallel fibers rather than solving them individually. Apply the theorem to both ordinary-band triangular factors. The small Woodbury Schur inverse is prepared by the predecessor's explicit elimination and unit-column solves. Its action on batches is another bounded matrix product. The recovery Xz has dimensions s by 2h times 2h by R; split its rows, columns and inner dimension into H-sized blocks. It has the same O(s (R+H) H^(ω−2)) count. All small Schur products are covered because s ≥ H. Every new approximation gets a polynomially smaller local grid budget, preserving O(log n) word precision.
+
+Preparation remains O(s H²), including the ordinary factors, inverse diagonal blocks and the Woodbury data. For the intended tensor axes, s = n^o(1), the number of fibers is at least H eventually, and this preparation is n^o(1). Across d axes with T total entries, h = O(1+sqrt(p)/α), α² = Θ(d sqrt(p)), and d = Θ(p^ε), the inverse work becomes
+
+    O(T d (1+h)^(ω−2) + n^o(1)).
+
+For 0 < ε < 1/2, this is
+
+    O(T p^[ε+(ω−2)(1/4−ε/2)] + n^o(1)),
+
+instead of the previous O(T p^[1/4+ε/2]). The forward chirp cost is unchanged: O(T p^ε log p). Shared exp/root setup is still paid by #4554. For ε ≥ 1/2, h = O(1), so the new batching has no exponent gain; this is why the theorem does not imply a modern best κ by itself.
+
+## Executable evidence
+
+    python3.12 -I -O -B batched_band.py
+
+The portable standard-library replay implements bounded signed dyadic arithmetic, all seven Strassen products, explicit inverse-block preparation and batched band substitution. It checks 36 systems and 1,785 individual residual entries against an independent Fraction oracle, including a non-full last batch. All residuals are below 2⁻⁷⁰; 172,305 arithmetic operations were charged, and the largest raw magnitude used 205 bits under a 384-bit cap. A deliberately undersized word fails. The fixture uses real unit-diagonal lower bands; general complex data follow by four real matrix products, and upper solves follow by reversal. These extensions are covered by the proof rather than those fixtures. It is not an emitted RamStd program or a complete asymptotic multiplier replay.
+
+## Credit, overlap and open next questions
+
+Strassen's seven-product identity is classical (V. Strassen, Numerische Mathematik 13 (1969), 354–356, DOI 10.1007/BF02165411). Shared band factors, Gaussian tails, explicit conditioning and Woodbury preparation here are predecessor results from Dugongue's PR #4554, with its Harvey–van der Hoeven/OpenAI Gaussian-resampling lineage. Problem 1.8's bounded-word/frame discipline motivates explicit word checks; no fresh Lean verification is claimed. The new contribution is this sufficient batched inverse organization, its residual proof and executable native fixture. We do not claim that batching triangular solves or fast matrix multiplication is historically new.
+
+The useful next check is whether any admissible complete native outer parameter regime has growing h and is actually limited by this inverse cost. Freeze that caller and compare its full profile before claiming a new κ. A separate task is to replace Strassen by a faster constructive bounded-word matrix algorithm with an equally explicit stability bound; its exponent would enter the same formula.
+
+## Frozen source bindings and search coverage
+
+The inspected predecessor NATIVE-BANDED-INVERSE.md has SHA-256 1259b4242ebf6ac7f14bfe72e371afb8dc530b2755d1fd82228d9dc6f01634ba; NATIVE-RECOUNT.md has SHA-256 fc14d31113ef3abd597e654e0aec35ef7972d014268e4b8b7624f202f9ff79db. Both are from the PR #4554 local source package. The primary [Strassen paper](https://link.springer.com/article/10.1007/BF02165411) identifies the classical seven-product exponent; its identity is implemented explicitly here.
+
+A scoped search of current-main research/ and notes/ found existing Strassen integer-power certificates in the helper/compiler family. Those precedents retain their credit; this package does not claim first use of Strassen in the repository. The new scoped application is the shared Gaussian inverse and its finite-word residual bound. A federated DAG query for Kronecker returned representation-theory results, not an applicable arithmetic convolution theorem. This is limited search evidence, not an exhaustive novelty assertion. Current-main AGENTS.md, autoresearch.md and CONTRIBUTING.md were read before construction; the task was explicitly assigned, so it was not rerolled.
diff --git a/research/native-kappa-30201655/CODE-SOURCE-PINS.json b/research/native-kappa-30201655/CODE-SOURCE-PINS.json
new file mode 100644
index 0000000000..2db32160b9
--- /dev/null
+++ b/research/native-kappa-30201655/CODE-SOURCE-PINS.json
@@ -0,0 +1,62 @@
+[
+  {
+    "local_file": "sources/4554-FFT-ERROR.md",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/FFT-ERROR.md",
+    "sha256": "ca426930df5c449ca8ce432360ba3ac80f12377bcd9a058ad16387d8ad87bef5"
+  },
+  {
+    "local_file": "sources/4554-ROOTS-RECOVERY.md",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/ROOTS-RECOVERY.md",
+    "sha256": "5e115c3ded1734dbcb119c889755a13ce9e9357598ec20a3eb1d3cdd727638f4"
+  },
+  {
+    "local_file": "sources/4554-NATIVE-STABILITY.md",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/NATIVE-STABILITY.md",
+    "sha256": "260e78bf8f88667a637b804d013d1e7c6dfdf1e23ae35ffdc64a4366c7321221"
+  },
+  {
+    "local_file": "root_seed.py",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/root_seed.py",
+    "sha256": "9b323f84ade7decfa6152dd4385e90ec43b56087927ac23ad4ef73ae4d5d3042"
+  },
+  {
+    "local_file": "native_convolution.py",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/native_convolution.py",
+    "sha256": "a62a4cb5a1da458e31c90ea881a1146b59e9fd7ccbf317c1c9836c19bc7fa2c6"
+  },
+  {
+    "local_file": "phase_tables.py",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/phase_tables.py",
+    "sha256": "4d70323775a8efc3af82eff7ee567482bfa5d14d8c86289fe21c29c0d37422e1"
+  },
+  {
+    "local_file": "exp_table.py",
+    "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+    "repository_path": "research/native-word-fft/exp_table.py",
+    "sha256": "e617b40d499f423a7861b4483bdacdb7db28232fadf7468efe871adae557fa35"
+  },
+  {
+    "local_file": "critical_engine.py",
+    "commit": "a6d7237f697185e857090e174c23c1cb22c6563c",
+    "repository_path": "research/adaptive-gate-existence/root_application.py",
+    "sha256": "e656ef12f73a8dd3bdb256eca95a712de1269facb18a652fc4068ba718619b4d"
+  },
+  {
+    "local_file": "raw-profile.json",
+    "commit": "f626db5c3a3d781d8f7695038776c621651f75e1",
+    "repository_path": "research/joint-helper-lattice/RESULT.json",
+    "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21"
+  },
+  {
+    "local_file": "majorant-benchmarks.json",
+    "commit": "f626db5c3a3d781d8f7695038776c621651f75e1",
+    "repository_path": "research/rank-convergence/BENCHMARKS.json",
+    "sha256": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850"
+  }
+]
diff --git a/research/native-kappa-30201655/CONTENT-HASHES.json b/research/native-kappa-30201655/CONTENT-HASHES.json
new file mode 100644
index 0000000000..58845b1edb
--- /dev/null
+++ b/research/native-kappa-30201655/CONTENT-HASHES.json
@@ -0,0 +1,61 @@
+{
+  ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da",
+  "4535-BRIDGE-PINS.json": "82b86fbc8a09bb7c72044bdfda1f7b45d694ef47f0bcbb4c4f5b38fc4134f248",
+  "BATCHED-INVERSE.md": "de76a7585551bedc239ba55d45fb097b97168c8287fe3c50101944af403307d2",
+  "CODE-SOURCE-PINS.json": "40d160b96402054c7cac05d21e383eda449445eceba2520a2a6a90c17b117c55",
+  "FINAL-ASSEMBLY-REVIEW-HASHES.json": "c509adf3960ff56441899618a3f3304664c11f635c9eb218574ad0dd941a9ad1",
+  "FUSED-NATIVE-REVIEW.md": "b9cde61cebab3d1b9e34c7099e4cd52b8ba880cf021f235a9508cd34813fff61",
+  "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+  "MODERN-SOURCE-MAP.json": "cc48b51a9b2ae46cef437e0a56c4e68b613f8c3bd8b03c3386bc6cf4745c6c57",
+  "NATIVE-ASSEMBLY.md": "a1f200292ea13d72bd64cb91a4daa28261bc220a80fe9c94983f3b9a1dffaa42",
+  "NATIVE-PROVIDER-4535.md": "242af59962fe466dc0bfe5826bd33da1b9b7d2430a2f8dfceb71e4282ecc410c",
+  "OFFLINE-SETUP.md": "cb9becabc6102270e93f83dfe808f367771a0f1f4eff729ff01b998fb91f85dc",
+  "PHASE-CELL-BATCHED.md": "e259f7ccea5c0bdbe2be7cf516eac802d9ee31e2af8509105e51e40e387b9748",
+  "PROVIDER-INDEPENDENT-REVIEW.md": "ba79234a9a66e5503b5e4a9f4014890802c15cd82094a71a4b73dcb7fb0377dc",
+  "README.md": "14da3076b3fc6d03cf9e44c2427280486df412c6cb91f235e81e1fd6149e0ba7",
+  "RECORD-INDEPENDENT-REVIEW.md": "cdb938a63796999ae71a906251cccc40936ae7127727549a174b99e647cd6f48",
+  "RECORD-PRODUCT.md": "a141fe4ebb35aea44b1f006217841d40f57ca2112df6de6944a8507905e1ec57",
+  "SOURCES.json": "c7050d7b52c6c262c6172dc1f01e9a249a4d104ca84c1c2bf780fa1cbb080630",
+  "TASK.json": "6bab26b71de806e15801a6416f7da883380249a52f1c2b41aeb95b9052d0903d",
+  "VERIFY.json": "c7a2acef526dbc37ff402ffcd0a6c8b7d0950f4ef1902305b5e07df3cdafc6f3",
+  "batched_band.py": "9268a9cf15e75abe2410baafca262e41c7b6f482d7805de6d7aa1e9dcef40264",
+  "critical_check.py": "41fa69948c5e20faa7245f441c7487e0a7f89ccaffc778849d80187ba012eb28",
+  "critical_engine.py": "e656ef12f73a8dd3bdb256eca95a712de1269facb18a652fc4068ba718619b4d",
+  "exp_table.py": "e617b40d499f423a7861b4483bdacdb7db28232fadf7468efe871adae557fa35",
+  "limb_setup.py": "953fcf90f371f7f184e8492506ee56aedd017ca98f2227c5d7f0cf7024f0e362",
+  "majorant-benchmarks.json": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850",
+  "modern-sources/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77",
+  "modern-sources/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba",
+  "modern-sources/FINE-PADDING-COMPOSITION.md": "331189874c79c2fbfb839838ec8ea61c09a7f0769098af88716ad6e7c54c0b5a",
+  "modern-sources/FINE-PRIME-PADDING.md": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce",
+  "modern-sources/FIXED-A-PERIODIC-NORM-AUDIT.md": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb",
+  "modern-sources/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0",
+  "modern-sources/GAUGEFREE-INTERIORS.md": "a7fc34302a70f8453f877a6433ffe2776457bf37b5d8bb262afcb6b198a935fc",
+  "modern-sources/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272",
+  "modern-sources/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc",
+  "modern-sources/PARTIAL-FUSION.md": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5",
+  "modern-sources/README.md": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e",
+  "modern-sources/REFINED-PHASE-FUSION.md": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5",
+  "modern-sources/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310",
+  "modern-sources/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6",
+  "modern-sources/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15",
+  "native_convolution.py": "a62a4cb5a1da458e31c90ea881a1146b59e9fd7ccbf317c1c9836c19bc7fa2c6",
+  "native_ledger.py": "cf3ededf5c980e272deb4647bdae76b1132aa1aa164c89af92eb58ac2597f3c2",
+  "native_metadata.py": "aab42cc2cd3787775274a822186f547708e9713fb2c9bbe0d7340cecd32a4b8b",
+  "phase_tables.py": "4d70323775a8efc3af82eff7ee567482bfa5d14d8c86289fe21c29c0d37422e1",
+  "raw-profile.json": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21",
+  "record_product.py": "6967feb00fbcb13640504f26c5e20bcea249e1dc89c41713aa8e8f161def873e",
+  "root_seed.py": "9b323f84ade7decfa6152dd4385e90ec43b56087927ac23ad4ef73ae4d5d3042",
+  "sources/4535-PROOF.md": "870cc213c847175f3717db057539686de638594e8c509b2a2daf8d8e72497102",
+  "sources/4535-README.md": "954a905f2b38cf1d0e039b9c2beebcf99a9e6009c2d2fb834e668ca74b911523",
+  "sources/4535-RESULT.json": "e830f4cab30e70ab02d2ecca283969bd97f3a6925948b61d0eb15df3be831b14",
+  "sources/4554-FFT-ERROR.md": "ca426930df5c449ca8ce432360ba3ac80f12377bcd9a058ad16387d8ad87bef5",
+  "sources/4554-NATIVE-STABILITY.md": "260e78bf8f88667a637b804d013d1e7c6dfdf1e23ae35ffdc64a4366c7321221",
+  "sources/4554-ROOTS-RECOVERY.md": "5e115c3ded1734dbcb119c889755a13ce9e9357598ec20a3eb1d3cdd727638f4",
+  "sources/PR4483-ARITHMETIC-PROOF.txt": "273598588316e29a45e3940c6f5070d973b1998fe5b9c582b23bfe87502724cc",
+  "sources/PR4483-DIRECT-MIXED-FLOW.md": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8",
+  "sources/PR4483-SOURCE-PROOF.md": "3f337fba12288d3b5e51af9541e2a645f79c8668fabf48b212672285fe6150b4",
+  "sources/PR4532-SOURCE-PROOF.md": "340d637feef40f44a808c718207c0fede12cc483e2c979b86c56bb736b9c1ef5",
+  "sparse_membership.py": "0e6e9bf0ecd890f38ae4268f2384a200b22b06a3ef9b46cd389fdd1a7842fc73",
+  "verify.py": "1cc2fe8b850d19ea852800fb3cc6b15d89554a6f7bc794db8785462ed4676dbf"
+}
diff --git a/research/native-kappa-30201655/FINAL-ASSEMBLY-REVIEW-HASHES.json b/research/native-kappa-30201655/FINAL-ASSEMBLY-REVIEW-HASHES.json
new file mode 100644
index 0000000000..130d26c81d
--- /dev/null
+++ b/research/native-kappa-30201655/FINAL-ASSEMBLY-REVIEW-HASHES.json
@@ -0,0 +1,45 @@
+{
+  "scope": "reviewed source bytes; not proof certificates",
+  "files": [
+    {
+      "path": "assembly/NATIVE-ASSEMBLY.md",
+      "sha256": "a1f200292ea13d72bd64cb91a4daa28261bc220a80fe9c94983f3b9a1dffaa42"
+    },
+    {
+      "path": "provider/NATIVE-PROVIDER-4535.md",
+      "sha256": "242af59962fe466dc0bfe5826bd33da1b9b7d2430a2f8dfceb71e4282ecc410c"
+    },
+    {
+      "path": "provider/PR4483-DIRECT-MIXED-FLOW.md",
+      "sha256": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8"
+    },
+    {
+      "path": "provider/PR4532-SOURCE-PROOF.md",
+      "sha256": "340d637feef40f44a808c718207c0fede12cc483e2c979b86c56bb736b9c1ef5"
+    },
+    {
+      "path": "sources/4535-PROOF.md",
+      "sha256": "870cc213c847175f3717db057539686de638594e8c509b2a2daf8d8e72497102"
+    },
+    {
+      "path": "analytic/BATCHED-INVERSE.md",
+      "sha256": "de76a7585551bedc239ba55d45fb097b97168c8287fe3c50101944af403307d2"
+    },
+    {
+      "path": "analytic/PHASE-CELL-BATCHED.md",
+      "sha256": "e259f7ccea5c0bdbe2be7cf516eac802d9ee31e2af8509105e51e40e387b9748"
+    },
+    {
+      "path": "assembly/modern-sources/GAUGEFREE-INTERIORS.md",
+      "sha256": "a7fc34302a70f8453f877a6433ffe2776457bf37b5d8bb262afcb6b198a935fc"
+    },
+    {
+      "path": "assembly/modern-sources/FINE-PADDING-COMPOSITION.md",
+      "sha256": "331189874c79c2fbfb839838ec8ea61c09a7f0769098af88716ad6e7c54c0b5a"
+    },
+    {
+      "path": "assembly/modern-sources/TENSOR-COMPILER.md",
+      "sha256": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15"
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/FUSED-NATIVE-REVIEW.md b/research/native-kappa-30201655/FUSED-NATIVE-REVIEW.md
new file mode 100644
index 0000000000..56cab0ffca
--- /dev/null
+++ b/research/native-kappa-30201655/FUSED-NATIVE-REVIEW.md
@@ -0,0 +1,65 @@
+# Independent review of the fused native Gaussian route
+
+Prepared for Dugongue with substantial OpenAI Codex assistance. This is an informal mathematical/code-design review, not a new formal or external human audit.
+
+## Sources actually read
+
+Read in full: research/capped-fusion-t74-k554/outer/GAUGEFREE-INTERIORS.md; outer/FINE-PADDING-COMPOSITION.md; outer/UNION-SCHEDULE.md; vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md; and vendor/pr1673/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md. The parameter/boundary alternatives in outer/STRUCTURED-BOUNDARY.md were inspected; its stronger unproved structured-stability premise is not required. Sources are bound to canonical commit f626db5c3a3d781d8f7695038776c621651f75e1. Raw copies were fetched at that exact commit when the partial Git clone could not retrieve missing blobs. Their raw Git object hashes, independently computed from byte lengths and blob headers, equal the commit's tree entries. Git hash-object applies the local CRLF filter to some of these files and is therefore not the raw-byte comparison.
+
+SHA-256 bindings:
+
+- FINE-PADDING-COMPOSITION.md: 331189874c79c2fbfb839838ec8ea61c09a7f0769098af88716ad6e7c54c0b5a.
+- SHALLOW-TOEPLITZ.md: b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310.
+- UNION-SCHEDULE.md: b1e6237655616a9d779f69915eb05a78e001d52150c168588426a5208e3d85a6.
+
+## Precision finding, and its existing resolution
+
+The old capped-gauge audit converts absolute full-cell weight error to relative error using exp(a/(4θ)). Its claim that this is absorbed by C p precision uses θ⁻¹ = O(d) and a d = o(p). That argument alone is invalid after fine padding makes θ⁻¹ = Θ(p²). This is not an outstanding gap in the composed route: FINE-PADDING-COMPOSITION explicitly imports PR #1786's setup precision C p + 64 p² ceil(log₂ p). The larger precision is OFFLINE ONLY and must be included explicitly in any native lowering.
+
+A native implementation computes those setup-only scalars by signed multiword grade-school arithmetic, Machin pi and rational Taylor/series methods at polynomial(p) precision. It costs polynomial(p) per local coefficient, and polynomial(s,p) in total, hence n^o(1) once per axis. It must not claim O(1) bounded-word exp-table queries for these wider setup values. The data circuit applies only locally anchored shifted kernels with O(p)-bit online coefficients; applying the full-cell diagonal to data and hoping it later cancels would be invalid.
+
+For g = p^β simultaneous axes, fine padding gives chirp guard exponent β+2ξ−2, and the accretive shallow circuit adds g polylog(p) bits. Thus β+2ξ−2 < 1 and β < 1 suffice for O(p) total online precision. The source's offline-only override is essential to this conclusion.
+
+## Shallow circuit check
+
+The shifted Gaussian identities are exact expansions. The symbol argument keeps |s| < 1/2, with polynomial lower gap in θ. The Jacobi-product factors interlace, giving argument bounded in absolute value by the first-factor argument, hence an accretive real-part bound. At fine θ⁻¹ = O(p²), both broad and narrow inverse bounds remain polynomial in p.
+
+The full Toeplitz construction actually supplies a finite circuit on the existing wires, rather than an unspecified fast transform. Its principal-section Schur recursion has logarithmic depth; displacement ranks grow additively; the Stein generator representation follows by finite telescoping; the four-update generator shear restores its source; triangular parity children run in parallel. The resulting circuit has O(log⁴ N) matching rounds and O(N log⁴ N) gates. Coefficient setup uses rational minors and exact independent-column/orthogonalization calculations at polynomial local precision. The prefix/inverse-prefix bounds extend from near-identity to accretive principal sections via their inverse norm and Schur bounds.
+
+The accretive proof's shear norm may be conservatively bounded using Λ' rather than the original Λ for descendants; both remain polynomial and this changes only fixed constants/guard logarithms. No exponent changes.
+
+The scalar application of every individual axis would cost T d and would lose the proposed saving. The full theorem must retain the inherited tensor-to-kernel fusion identity and its provider, applying matching rounds on groups of axes. The native Gaussian row is the FUSED tariff, not that scalar fallback. This review validates the cited shallow construction and precision; it does not independently emit a complete fused multiplier program.
+
+## Native union metadata and wrap gathers
+
+The union source's O(g) bit scan for an r-th set bit is paid there by a p-bit tape move. One cannot silently reuse that as O(1) Word RAM work. A constructive native replacement is available: the header contains k = O(g log L) = p^β polylog(p) = o(p) bits, where L is the polynomial microbox side. Enumerate all 2^k headers and all r ≤ g during setup, storing their membership masks and r-th-set-bit tags. The work and space are 2^k polynomial(p) = n^o(1); each key and result fits a machine word. Each online visit then computes its tag in O(1) indexed operations.
+
+For consecutive mixed-radix axis groups, extract the group coordinate by division by its stride followed by reduction modulo its group radix; both fit the declared word. The group local header is then a table key. If a fused circuit uses arbitrary selected binary positions, prepare the full 2^k deposited-submask table. Enumerate complementary masks in increasing order by next = (current−M) AND M, combining each base with every prepared deposited submask. This enumerates each gathered record once, so no per-record k-step extraction is required. The tables are generated explicitly; no PEXT/PDEP or nonuniform advice is assumed. Coarse labels and per-axis factor pages are input-independent local setup. Reuse is paid once per axis/microbox as in the source and amortized by the superpolynomial spectator payload.
+
+Radix distribution, its reverse, transpose/untranspose, splitting and LIFO restoration use O(1) word instructions per moved bounded-word record. The source's complete-line lemma remains exact: membership flags depend only on the chosen-axis membership and the other coordinates. Total visits equal sum_x |F(x)| ≤ g μ V. Thus the native union cost is O(V g μ polylog p) per group, not O(V g² μ). It is unnecessary to retain the source's tape-head API. Periodic indices are reduced modulo their known line lengths using bounded-word arithmetic; gathers/scatters enumerate the explicit physical selected positions and their inverses, including both endpoint groups. No native sorting oracle is assumed.
+
+## Capped boundary cost
+
+Fine cells may have Θ(p²) entries, but capped interiors have length at most B = p^ξ. The boundary density remains O((W/B) polylog p), since cap B < p² and clipped endpoint cells are separately retained. With W = O(sqrt(p/u)), the explicit inverse-block and right-hand-side Strassen batching of BATCHED-INVERSE.md applies to the ordinary factors and the small periodic Woodbury closure. BOTH coupling matrices are evaluated by the same batches. The per-axis cost is O(T W^(ω−1)/B), up to polylogarithms, and summing axes gives O(T d W^(ω−1)/B).
+
+Since 7^16 < 2^45, take ω < 45/16. With T p = Θ(n), this allows native boundary saving
+
+    c + ξ − ε,       c = 3/32.
+
+The weaker explicit Strassen construction is enough; no unproved near-quadratic structured-boundary stability theorem is required. Periodic correction and both endpoint groups remain charged. All matrix inverse/preparation steps are explicit polynomial local calculations, with setup-only multiword scalars separated from the O(p)-bit data path.
+
+## Candidate parameter arithmetic
+
+Let q = 0.0030201656 be an ACTUALLY supplied uniform native kernel exponent, and choose
+
+    δ = 10⁻⁸, ε = 1−δ, β = 1−3δ, r₀ = 10⁻⁹,
+    ξ = ε(1+q) − 3/32 + 10⁻¹⁰,
+    κ = 0.0030201655.
+
+The modern fused rows are main εq; Gaussian 1−ε+qβ; boundary 3/32+ξ−ε; union ξ+1/2−ε. Every one strictly exceeds κ. The main surplus is about 6.98×10⁻¹¹, so it is essential to keep exact rationals and not replace q by a downward display that erases that gap. Membership 1−β−2(1−ε) = δ > 0; γ spare power 1−ε−r₀ = 9×10⁻⁹ > 0; group size ε−β = 2δ > 0; β < 1; cap 1/2 < ξ < ε; and fine chirp guard 1−β−(2ξ−2)−r₀ > 0. Polynomial setup and all polylogarithmic factors can be absorbed into the corresponding strict margins above a finite eventual cutoff. These are asymptotic mathematical bounds, with no practical cutoff or speedup claim.
+
+This verifies that the fused analytic/native adapter stack has no exponent obstruction at the candidate point. It remains essential that the full submission separately supplies and credits the exact uniform native kernel provider, its all-input operator identity, arbitrary phases, normalization, complete cyclic/convolution embedding and exact recovery. Those are the full assembly worker's obligations, not consequences of this parameter table or finite circuit fixtures.
+
+## Credit
+
+Retain PR #1673 (Vlado Vojdanovski: capped phase-cell fusion/shallow circuits), PR #1758 (fractional-shift accretive interiors and per-visit accounting), PR #1786 (Chafik Boukhalfa: fine primes and offline precision), Tim Trudgian's prime estimate, Jeremy Kothe's ledger lineage, the retained supplier authors and the Harvey–van der Hoeven/OpenAI analytic lineage. Native arithmetic primitives retain PR #4554 and its complete contributor notices. The new review and primitive-specific batching/metadata lowering do not replace predecessor credit.
diff --git a/research/native-kappa-30201655/LICENSE b/research/native-kappa-30201655/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/research/native-kappa-30201655/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/research/native-kappa-30201655/MODERN-SOURCE-MAP.json b/research/native-kappa-30201655/MODERN-SOURCE-MAP.json
new file mode 100644
index 0000000000..1ade8c7499
--- /dev/null
+++ b/research/native-kappa-30201655/MODERN-SOURCE-MAP.json
@@ -0,0 +1,124 @@
+{
+  "sources": [
+    {
+      "local_file": "modern-sources/BILATERAL-LDU.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/BILATERAL-LDU.md",
+      "sha256": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77",
+      "bytes": 6305
+    },
+    {
+      "local_file": "modern-sources/CAPPED-INTERIORS.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/CAPPED-INTERIORS.md",
+      "sha256": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba",
+      "bytes": 7284
+    },
+    {
+      "local_file": "modern-sources/FINE-PADDING-COMPOSITION.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+      "repository_path": "research/capped-fusion-t74-k554/outer/FINE-PADDING-COMPOSITION.md",
+      "sha256": "331189874c79c2fbfb839838ec8ea61c09a7f0769098af88716ad6e7c54c0b5a",
+      "bytes": 7442
+    },
+    {
+      "local_file": "modern-sources/FINE-PRIME-PADDING.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+      "repository_path": "research/capped-fusion-t74-k554/vendor/pr1786/FINE-PRIME-PADDING.md",
+      "sha256": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce",
+      "bytes": 18927
+    },
+    {
+      "local_file": "modern-sources/FIXED-A-PERIODIC-NORM-AUDIT.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-PERIODIC-NORM-AUDIT.md",
+      "sha256": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb",
+      "bytes": 3422
+    },
+    {
+      "local_file": "modern-sources/FORWARD-SMALL-A-AUDIT.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/FORWARD-SMALL-A-AUDIT.md",
+      "sha256": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0",
+      "bytes": 6689
+    },
+    {
+      "local_file": "modern-sources/GAUGEFREE-INTERIORS.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9",
+      "repository_path": "research/capped-fusion-t74-k554/outer/GAUGEFREE-INTERIORS.md",
+      "sha256": "a7fc34302a70f8453f877a6433ffe2776457bf37b5d8bb262afcb6b198a935fc",
+      "bytes": 19045
+    },
+    {
+      "local_file": "modern-sources/LOG-A-PHASE-SCHUR-AUDIT.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md",
+      "sha256": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272",
+      "bytes": 10642
+    },
+    {
+      "local_file": "modern-sources/OUTER-AUDIT.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/OUTER-AUDIT.md",
+      "sha256": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc",
+      "bytes": 13831
+    },
+    {
+      "local_file": "modern-sources/PARTIAL-FUSION.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/PARTIAL-FUSION.md",
+      "sha256": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5",
+      "bytes": 4169
+    },
+    {
+      "local_file": "modern-sources/README.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/README.md",
+      "sha256": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e",
+      "bytes": 18502
+    },
+    {
+      "local_file": "modern-sources/REFINED-PHASE-FUSION.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/REFINED-PHASE-FUSION.md",
+      "sha256": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5",
+      "bytes": 7276
+    },
+    {
+      "local_file": "modern-sources/SHALLOW-TOEPLITZ.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md",
+      "sha256": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310",
+      "bytes": 15480
+    },
+    {
+      "local_file": "modern-sources/SUPPLIER-SUPPORT-AUDIT.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md",
+      "sha256": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6",
+      "bytes": 16557
+    },
+    {
+      "local_file": "modern-sources/TENSOR-COMPILER.md",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed",
+      "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/TENSOR-COMPILER.md",
+      "sha256": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15",
+      "bytes": 13430
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/NATIVE-ASSEMBLY.md b/research/native-kappa-30201655/NATIVE-ASSEMBLY.md
new file mode 100644
index 0000000000..93116735b7
--- /dev/null
+++ b/research/native-kappa-30201655/NATIVE-ASSEMBLY.md
@@ -0,0 +1,145 @@
+# Source-bound native Word RAM multiplication with saving 0.0030201655
+
+## Precise claim and retained mathematical inputs
+
+On the standard finite-word random-access model with indexed memory, add/subtract, shifts, Boolean operations, comparison and multiplication/division of O(log n)-bit words, the constructions below give packed n-bit integer multiplication in
+
+    O(n/(log n)^kappa),  kappa=0.0030201655.
+
+The word-width coefficient is a sufficiently large fixed constant. This is a Word RAM claim, not a stronger multitape-TM exponent. It is conditional on the correctness of the specifically retained algebraic and analytic predecessor proofs listed next. It imports no TM algorithm or TM complexity theorem. No new unknown compiler, stability oracle, fast multiplier or unpriced coefficient instruction is a premise.
+
+Retain these mathematical source results:
+
+1. The literal all-input dyadic native identity and chronological finite compiler of PR #4470/#4483/#4532/#4535, including distinct productive fields, all paid jobs, owned scratch restoration, exact endpoint phase normalizers and the finite compiler majorant. The pinned #4535 certificate funds a fixed uniform provider saving q_C=0.0030201656 at N=2^(10^12). In particular P_leaf/W<N^(1-q_C), with every complement, leaf, copied query and owned job counted. The enormous finite program is algorithmically specified, not materialized here.
+2. The actual Gaussian/Poisson identities, prime-grid cyclic embedding, rounding/recovery theorem, and coefficient error formulas of the retained analytic reduction. Fine prime padding is specifically PR #1786, as bound in FINE-PADDING-COMPOSITION.md; fractional-shift accretive Toeplitz circuits are PR #1758's GAUGEFREE-INTERIORS.md, using the constructive SHALLOW-TOEPLITZ and TENSOR-COMPILER recipes. These are mathematical identities, circuit constructions and error bounds, not their tape tariffs.
+3. The exact dyadic core/halo and sparse-axis decomposition: full complete-tensor H calls preserve coarse labels, and each sparse axis operator acts only on its own explicitly generated boundary slabs. This is the actual decomposition in the cited capped/fine-padding construction, including original physical period cuts and original-input halo repairs.
+
+The new contribution is a concrete finite-word execution and cost assembly for those actual recipes: native short products and FFTs, paid sublinear coefficient/index tables, constant-word scalar evaluation, direct indexed sparse visits, batched boundary arithmetic and explicit nine-row native accounting. The statement remains source-bound while the predecessor algebraic/analytic proofs retain their stated status. Finite replay checks cannot independently establish their universal correctness.
+
+## Parameters and model
+
+Write p=Theta(log n), d=Theta(p^epsilon), g=Theta(p^beta), choose alpha^2=Theta(log p), and use its spare bound alpha^2<=p^r eventually. Fix
+
+    q_C     = 0.0030201656,
+    q       = 0.00302016555,
+    stop    = 10^-9,
+    kappa   = 0.0030201655,
+    epsilon = 1-10^-8,
+    beta    = 1-3*10^-8,
+    r       = 10^-9,
+    c       = 3/32,
+    layout  = 10^-10,
+    xi      = epsilon*(1+q)-c+layout.
+
+Every constant is fixed before n varies. Working scalar components have C p bits for a sufficiently large fixed C. Their exact raw products, sums and divisions use a fixed number of machine words. Multiplication is used only on these bounded words; no whole n-bit product is a unit-cost instruction. Signed complex scalars are represented by two signed dyadic components.
+
+The input and output are ordinary packed words. Digitization, final carry propagation and packing cost O(n/log n) operations. All target-box coefficient counts T satisfy T p=Theta(n). Original axes have bit length ell=Theta(p/d), and actual axis lengths 2^Theta(p/d)=n^{o(1)}. In every growing range, all fixed finite-template constants and every fixed polynomial descriptor preparation are absorbed by one explicitly enlarged eventual cutoff. No practical cutoff or implementation size is asserted.
+
+## 1. The actual finite provider becomes a native bounded-word kernel
+
+Execute the fixed expanded provider word from retained input 1, with each bank an indexed array and every owned allocation distinct. Scalar dyadic ADD/SCALE/COPY/CLEAR instructions use direct bounded-word arithmetic. Completed child endpoints are exact unitary Gaussian operators on arbitrary bank contents; source coefficient/denominator and restoration bounds give a fixed linear guard C0 e at rank e, or the stronger fixed-template depth guard when applicable. Since e<=d or g and epsilon,beta<1, C0 e=o(p). No data-dependent test changes the linear identity.
+
+Its rank recurrence is the actual whole-program leaf recurrence, with strict moment P_leaf/W<N^(1-q_C), ordinary base costs and rank remainders paid. The ordinary induction gives O(2^e e^(1-q)) word operations up to fixed logarithmic factors and fixed-template constants. On T records, applying the kernel as a direct sum over selected-bit fibers costs
+
+    O(T e^(1-q) polylog p).
+
+The endpoint is the canonical selected-axis Gaussian kernel with all distinct independent productive inputs and all owned scratch restored. Phase frames convert it to the actual simultaneous normalized H calls in TENSOR-COMPILER.md. Owned banks are memory banks with fixed multiplicity; they receive no productive credit.
+
+A finite rank-N compiler is fixed independently of n, despite its extreme size. Its enumeration, scalar coefficients and matrix/phase recipes are actual finite algorithms. Runtime preparation is not permitted to query an unspecified optimal circuit. One may conservatively allocate a distinct owner for every expanded allocation, exactly as #4535 specifies.
+
+## 2. Native metadata and coefficient tables are explicitly paid
+
+One fused Gaussian group uses g original axes. All their complete physical coordinate bits occupy
+
+    K=O(g ell+g log p)=O(p^(beta+1-epsilon)+p^beta log p)=o(p).
+
+For each of the polynomially many group/stage types, enumerate every K-bit key and run the actual local coefficient/address/predicate recipe. This includes phase-cell classification, holes, capped boundaries, anchored fractional shifts, the prescribed matching/Benes controls and separable diagonal values. The remaining axes are spectators, so no other coordinate is needed to determine these functions. Tables store O(p)-bit output values or addresses. Their total time and space are
+
+    poly(p)*2^O(K)+poly(r,p)=n^{o(1)}.
+
+Here r=max(s_i,t_i)=n^{o(1)}. First prepare each one-axis coefficient/factor/page catalogue by its actual polynomial(r,p) constructor, once per axis. Each group-key evaluation then combines/lookups those stored one-axis recipes with polynomial(p) work. This pays global axis preparation separately from the thin group tables.
+
+Coefficient construction starts at precision Cp+O(p^2 log p) and is performed with explicitly implemented multi-limb integer/rational arithmetic. Global one-axis Schur, factor and generator construction may have dimensions and exact rational numerator/denominator bit heights polynomial in r and p, rather than polynomial in p alone. Grade-school limb addition, multiplication, long division and exact finite rational elimination therefore take polynomial(r,p) native word operations in total for each such constructor. Gaussian exp/root coefficients use convergent rational series and certified remainders at that paid precision. Local polynomial-size circuit generation and group-table evaluation are charged separately as above. No polynomial(r,p)-bit scalar is treated as one machine word. Only source-conditioned O(p)-bit guarded coefficients are retained online: polynomial(r,p) error/count factors add O(log r+log p)=o(p) guard bits, while the actual conditioning and normalization bounds supply the remaining Cp allowance.
+
+Project a group key from the complete O(p)-bit address by a precomputed Benes permutation of word bits, implemented with O(log p) masked shifts; mask away spectators. Its control masks are generated in polynomial(p) preprocessing. Lookup is one indexed word operation. Hence classification and diagonal/coefficient access take polylog(p) native work per visited record, without a hidden factor g. Unlike TM transition batching, these tables encode explicit algebraic coefficient and coordinate functions; no TM occurs in their definition or evaluation.
+
+For the main simultaneous selected-bit kernels, deposit maps on 2^e local bit indices and every fixed-template basis/quarter-phase map are also explicitly tabulated. They require poly(p)*2^O(d+g)=n^{o(1)} preparation. Enumerating complementary submasks by next=(current-mask)&mask visits all selected fibers without PEXT/PDEP or one extraction per axis. Fixed-dimension binary column lifts use a fixed number of whole-block XORs. Arbitrary physical bit permutations use the paid word-level Benes recipe above.
+
+The global FFT twiddle product and global separable normalizations may instead use the mixed-radix prefix-product scan: suffix products are recomputed only on odometer carries, yielding O(1) amortized scalar work per record, with no division by possibly zero entries. No g-fold product is silently charged as a unit scalar instruction.
+
+## 3. Main simultaneous transform
+
+The exact common-level tensor FFT decomposition has ell=Theta(p/d) rounds. Its local H calls are precisely the native selected-bit kernel of section 1, with separate charged recordwise twiddles. Therefore
+
+    main = O(T ell d^(1-q) polylog p)
+         = O(T p^(1-epsilon*q) polylog p).
+
+All addressing, fixed-template normalizers, owned scratch and base exits are included in the native call bill. Direct word-addressed permutations replace tape routing; a separate fast BIT supplier is unnecessary.
+
+## 4. Fused actual Gaussian adapters
+
+Fine source primes have theta=Theta(p^-2). The shifted Gaussian symbol and its accretive section/Schur bounds are the actual GAUGEFREE-INTERIORS theorem. A dyadic interior of cap B=p^xi has only the quadratic chirp range O(alpha^2 theta B^2); the linear Gaussian drift has been absorbed exactly into its shifted Toeplitz kernel, not erased. The shallow in-place Toeplitz circuit has polylog(p) rounds and polynomially bounded local coefficients/prefixes. Its common local wire order is the retained DYADIC CORE/MICROBOX of side L=p^128, not the full original axis of length r. Thus the Benes circuit width has log2(L)=O(log p) local bits and contributes only polylog(p) stages; using log2(r) as the local routing depth here would be incorrect. Coarse axis labels remain spectator coordinates. All completed simultaneous H calls are nevertheless executed globally across the whole complete tensor and all coarse labels, with the prescribed selected local bits and restored spectator order; they are not separate isolated suppliers per coarse box. TENSOR-COMPILER gives a common sequence of these H calls and diagonals on the same data coordinates, with identity operations on inactive axes. The group-key table may include full coarse coordinates to choose local coefficient/control pages, but this does not enlarge the local circuit wire width or stage count. There is no constant-factor data padding on each of g axes.
+
+The per-group precision guard is
+
+    O(p^(beta+2xi-2) polylog p + p^beta polylog p)=o(p).
+
+Global normalization costs O(d log p)=o(p), since epsilon<1. Offline raw weights may require the larger setup precision already charged in section 2; the online shifted/anchored coefficients still use O(p) bits. The completed narrow inverse, broad identity-hole completion, local Schur complements and physical-prefix inverses have the cited polynomial bounds. Their errors are allocated at completed-map boundaries rather than multiplying large internal gauges across successive completed maps.
+
+Apply the compiled g-axis circuits using section 1. There are d/g groups and polylog(p) calls per group, so
+
+    fused Gaussian = O(T d g^(-q) polylog p)
+                   = O(T p^(epsilon-q*beta) polylog p).
+
+This is the actual tensor-fused algorithm. Merely applying g separate O(t log p) line FFTs would reintroduce T d work and would not prove the claimed saving.
+
+## 5. Boundary and sparse recovery
+
+Each original axis has O(s W/B polylog p) boundary coordinates, with W=O(sqrt(p) polylog p). Exact setup forms the correct rounded principal matrix and its Schur complement, preserving physical cuts and the actual fine-prime polynomial conditioning. Precompute its whole-boundary-block factors and periodic closure once. On a batch of W independent spectator right-hand sides, every dense W by W block update, block-pivot inverse, periodic correction, and both original coupling directions uses Strassen's explicit seven-product recursion. Its O(log W) depth and polynomial intermediate growth require O(log^2 p) extra guard bits. Global residual/condition bounds control final error, not a product of per-cell amplification bounds.
+
+This is the constructive batched inverse in the companion analytic proof. There are O(s/B) boundary groups per axis. Per right-hand side the cost is O((s/B) W^(omega-1) polylog p), including all couplings. Summing all d axes and all fibers gives
+
+    boundary = O(T (d/B) W^(omega-1) polylog p)
+             = O(T p^(epsilon-xi+29/32) polylog p),
+
+using 7^16<2^45, hence omega<45/16. Any final incomplete batch is padded with zero right-hand sides once, by less than a factor two; it does not add a coordinate on each tensor axis. All required same-axis factors are reused, never refactored per fiber.
+
+Every sparse axis operation is supported only on its own listed endpoint slabs. Enumerate those slabs by indexed coordinates and visit only that axis's records. Operators on distinct axes commute at a fixed tensor stage, and processing an axis preserves the other axes' slab flags. Total visits are the sum of slab sizes, not g times their union size. Therefore sparse metadata/movement costs
+
+    O(T d W/B polylog p)=O(T p^(epsilon+1/2-xi) polylog p).
+
+The dense arithmetic on these slabs is already charged in the boundary row. Group construction adds O(T(d/g) polylog p) scans. Direct random access avoids sorting complete records by growing group keys.
+
+The core/halo decomposition uses halo A=p^48 and dyadic core L=p^128. Its exceptional copied volume is O(T g A/L) per group. The original group inputs supply all halos; inaccurate core edges are discarded. Even retaining the predecessor's deliberately loose p^2 arithmetic allowance gives total core-face work bounded by O(T p^(epsilon+beta+48-128+2) polylog p), negligible here. No halo volume is padded by 2^g.
+
+## 6. Native elementary and record products; exact recovery
+
+All O(p)-bit scalar/short products are direct bounded-word operations. Long polynomial records have r coefficients of O(p) bits. Use the direct native FFT on those records with digit width Theta(p) and GLOBAL word precision Theta(p), not a fresh local Theta(log(rp))-bit machine. With explicitly generated roots and the fixed-point error theorem, a product costs O(r log r) word operations. It uses word products, not a TM multiplier. Here log r=Theta(p/d), so the complete retained record-product bill is O(T p/d polylog p), saving epsilon. This includes the constant number of signed/complex encodings and normalizations of the actual retained ring product.
+
+The convolution/recovery caller's explicit error target is met by the chosen C p precision, including Gaussian gamma, supplier semantic guards, circuit prefix/suffix bounds and polynomially many local errors. The retained integer-recovery inequalities then give coefficient error strictly below 1/4; nearest-integer rounding recovers the exact coefficients. The standard bounded-word radix carry pass and packed output cost O(T polylog p). No external theorem of fast integer multiplication is used at any point of this native algorithm.
+
+## 7. Nine paid native rows and exact strict margins
+
+Every work term is O(T p^e polylog p) plus n^{o(1)} setup, and T=Theta(n/p). Thus its saving is 1-e. The nine retained rows have these native savings:
+
+| Actual operation | Native saving |
+|---|---:|
+| main simultaneous transform | epsilon*q |
+| initial/final standalone complete-address routing | 1 |
+| fused Gaussian circuits | 1-epsilon+q*beta |
+| additional standalone addressing passes | 1 (native masked shifts/table queries) |
+| group scans and table lookup passes | 1-epsilon+beta |
+| boundary algebra, both couplings, closure | 3/32+xi-epsilon |
+| indexed sparse-axis visits | 1/2+xi-epsilon |
+| global-precision polynomial record products | epsilon |
+| core-face recovery | 1-(epsilon+beta+48-128+2) |
+
+Per-call selected-bit gather, restore and address evaluation are already included inside the main-transform and fused-Gaussian call bounds. Extra per-group whole-array scans are included in the 1-epsilon+beta row. The two standalone addressing rows refer only to a fixed number of additional global passes; they do not classify all ell transform calls or all d/g group calls as one pass. Thus no T*ell or T*d/g toll is left uncounted. Native routing rows include their fixed logarithmic costs and are not assigned zero work. The smallest strict saving is epsilon*q=0.0030201655197983445, exceeding kappa by exactly 0.0000000000197983445. The fused Gaussian saving is 0.0030201754593950335. The boundary saving is epsilon*q+10^-10. Every other row has a fixed positive excess over kappa. Therefore all fixed polylog(p) factors can be absorbed into those strict margins; n^{o(1)} setup is smaller than n/p^kappa. This proves the claimed source-bound native asymptotic bound.
+
+All essential interface inequalities are strict: beta<epsilon<1, xi>1/2, xi<epsilon, epsilon+r<1, beta+2xi-2+r<1, beta+1-epsilon<1, and beta+2(1-epsilon)<1. They respectively pay grouping, cap geometry, normalization, chirp precision, thin tables and the retained membership bound. The companion exact rational ledger should verify these rather than rely on decimal displays.
+
+## Evidence, limitations and credit
+
+This is an informal asymptotic assembly proof using actual predecessor recipes. It does not claim a materialized astronomical native supplier, an independently kernel-checked mathematical theorem, practical constants, a new TM bound or worldwide priority for FFT, Strassen, Toeplitz, word lookup, diagonal dominance or Woodbury. Executable component replays must be reported separately from universal source proofs. In particular a finite agreement with classical multiplication cannot verify the enormous fixed provider identity or the entire asymptotic caller.
+
+Credit includes Jacob Alan Sussman's matching/Pascal construction; zxv's flow/majorant; Ryanson Jonathan's mirror-window method; Cinna Davis and the joint-helper lineage; Dillon's #4532 critical-root theorem; Vlado Vojdanovski's #1673 circuit tensorization and phase-cell fusion; PR #1758's shifted/accretive gauge-free interiors; Chafik Boukhalfa's #1786 fine padding and Tim Trudgian's prime estimate; Jeremy Kothe's ledger lineage; eumemic and icekylinx's Gaussian chirp/error work; Harvey and van der Hoeven's analytic multiplication/Poisson groundwork; and PR #4554's native arithmetic/adapters with their notices. Preserve exact source notices and commit/hash pins in the integrated package. Prepared for Dugongue with substantial OpenAI Codex assistance.
diff --git a/research/native-kappa-30201655/NATIVE-PROVIDER-4535.md b/research/native-kappa-30201655/NATIVE-PROVIDER-4535.md
new file mode 100644
index 0000000000..a9c069f5bf
--- /dev/null
+++ b/research/native-kappa-30201655/NATIVE-PROVIDER-4535.md
@@ -0,0 +1,86 @@
+# Native Word RAM closure of the actual critical-root finite word
+
+## Result
+
+Put q_C=0.0030201656 and N=2^1000000000000. Under the pinned predecessor's **algebraic finite-word theorem** described below, its actual fixed uniform word yields a native bounded-word Gaussian kernel with work
+
+    O(2^e (e+1)^(1-q_C))
+
+on 2^e entries. For input component magnitude at most 2^b and requested absolute error 2^-B, where e,b,B=O(log n), a sufficiently large fixed constant times log n bits per word suffices. Preparation, address/phase metadata, integer batch widths, all complete paid children, owned allocation/initialization/erasure and fixed rational arithmetic are included. This closure does not assume a Turing-machine execution theorem, a unit-cost transform oracle, an unproved stability gadget, or a new scalar circuit supplied by a moment inequality alone.
+
+The fixed finite word and its exact all-input correctness are predecessor mathematics. This result independently supplies its native random-access implementation, precision and asymptotic cost. It remains an informal proof, as do those predecessors. No practical cutoff, materialized giant word, Lean audit, new raw profile or new TM kappa is claimed.
+
+## Exactly which algebraic predecessor facts are retained
+
+PR #4535, head a6d7237f697185e857090e174c23c1cb22c6563c, `research/critical-root-multiplication/PROOF.md`, sections 2 and 3, applies the critical-root majorant of PR #4532 at 644607ba59ebe401ac7ecd627ae7f331f924d1b0 to the actual joint-helper word of PR #4470 at b9a13c1673e0e9697de410de16e8bbf3207a7363. It fixes N above and obtains
+
+    P_leaf/W = L(N) < N^(1-q_C).
+
+Here W is the actual independent productive width after integer denominator clearing and P_leaf counts every rank-one paid child. The ordinary base, source complements, unmatched premature exits and compiler-boundary jobs are charged. Each source input is distinct, even when a class has no incoming parent. This is a strict uniform moment for an algorithmically specified finite word, rather than an unnormalized raw-profile comparison.
+
+The actual finite construction is given in the source at PR #4483 head fb0c208864e6b24e3473318a058aa5b2dbd5764b, **`research/direct-mixed-flow/README.md`, sections 2 and 3**. This is the relevant detailed construction; the short `research/compact-joint-compiler/PROOF.md` is a parameter consequence and is not itself that construction. The retained source defines the capped multinomial classes, matches the first D(b) whole issued jobs to child target slots and completes every remaining job as an exit. A paid round and its child finish before the next parent round resumes. Rank descent is strict. Nested widths B_n=B_(n-1)*S_n make every earlier complement/exit batch integral. Every original field receives its disjoint complement transform and its source transform; no productive input is copied or identified. This proves the all-input algebraic assembly by strong induction, using the source's whole-job Gaussian conjugacy identities and monomial normalizer recipes.
+
+Those algebraic identities, the exact all-column joint-helper endpoint and the uniform majorant are retained credited results. The retained algebraic identity is its actual column/fiber lift for every positive f, including the literal lifted Clifford normalizers and phases f*gamma modulo 4; a finite replay at f=1 alone would not prove that fact. They are not re-inferred from histograms. The fixed normalizers are explicit binary affine matrices and quadratic fourth-root phase descriptors, as supplied by the source's Gaussian/Clifford reduction. There is no assumption here that an unspecified dense change of basis is cheaply evaluable. If the source's exact all-input word or stated monomial identities are wrong, this conditional native consequence fails; the native proof does not conceal that ordinary mathematical dependency as a cost oracle.
+
+The strict leaf inequality is the numerical/mathematical premise used below. This document does not reuse PR #4535 section 4's TM movement, tape, precision, or finite-template execution contract. Word RAM closure is proved directly.
+
+## Uniform finite setup and complete instruction inventory
+
+Expand the effective construction at the single fixed N. Its recursion and width products terminate by strict rank descent. Enumerate every raw unit, all integer routing matches, each scalar ADD/SCALE, each child, each whole-job monomial adapter, and each owned buffer. Assign different storage to simultaneously live fields; a safe simpler construction gives a separate bank to every owned allocation. Count the actually emitted records and their coefficients. This computes finite integers W, P_leaf, O, R and a coefficient bound G. No assertion is made that these enormous integers or records have been physically produced here.
+
+The expansion is one fixed finite algorithm independent of the eventual n and e. Run it as charged initialization, taking a fixed finite C_setup operations and space. It can be retained between calls within a multiplication run. Its binary integer arithmetic is performed in fixed finitely many limbs. Increase the global fixed word-width coefficient and eventual cutoff until its fixed literals fit. Alternatively expand each fixed coefficient into finitely many word limbs. This is uniform finite preprocessing, not advice depending on n and not free input-dependent arithmetic. C_setup is included in the asymptotic constant; finite small inputs use direct butterflies.
+
+No normalized source-count division is introduced as a scalar gate: integer replication clears the batch widths. All literal scalar coefficients are dyadic (and the same proof permits any fixed nonzero rational denominators). Their numerator and denominator heights are fixed and explicitly enumerable. Normalizers and private allocation are included even when their scalar coefficient-height contribution is zero.
+
+## Direct word implementation and paid address metadata
+
+Use indexed arrays for the independent live roles and owned scratch. A scalar gate acts coordinatewise, with O(1) bounded-word numerator products, additions and divisions per coordinate; the fixed number of limbs can depend on the frozen finite word. COPY and CLEAR perform explicit passes. Do not clear dirty borrowed fields. Parked suspended callers retain their own storage until their return.
+
+Every e-bit affine/quadratic monomial lift is implemented by the explicit table construction in NATIVE-PROVIDER.md: prepare parity and least-set-bit tables on mu=max(1,floor(e/16)) bits, then use a fixed number of chunk lookups per e-bit address. Increasing-index recurrences compute its affine image and quadratic phase in O(1) word instructions per entry. Their O(e^2+2^(e/16)) setup is absorbed by O(2^e); each application and owned scratch pass also costs O(2^e). Common live coordinate maps are bijections by the retained exact normalizer identities, so indexed gather/scatter preserves every input value and caller-live field. No popcount, ctz, PEXT or PDEP instruction is required.
+
+For a rank-r child lifted to r*f active bits inside N*f bits, enumerate complementary fiber bases and selected-bit deposits. Explicit table construction and the chunk/parity method charge O(2^e) total gather/scatter work. Each fiber is passed to the child once; it is not reexecuted per output element. Disjoint fibers preserve arbitrary independent data. Child responses finish before a suspended caller continues. Metadata, full fiber descriptors, zero initialization and final flattening/clearing are included in the fixed count of array passes.
+
+After N is frozen, all local record counts are fixed constants. Therefore the complete nonchild execution of one volume-V batch costs at most C*V, with a newly computed fixed C including setup and all role/owner passes. No tape-movement implementation is called.
+
+## Rank recurrence and one-time stock reserve
+
+Let z=1-q_C, f(e) be the active chunk size in the ordinary uniform recursion and t(e)=T(e)/2^e. The credited finite word has only rank-one paid leaves at rank N. Group only complete sets of W fibers, retain every leftover on its distinct original input, and run their direct completed butterflies. Reserve the actual preceding row stock at all nested levels; its width is O(log(e+2)) because W is fixed and the child rank contracts by N. Computing the high directions once, plus paying those leftovers, gives the direct native recurrence
+
+    t(e) <= (P_leaf/W)*t(f(e)) + C*(1+log(e+2)),
+    f(e) <= e/N,
+
+above a fixed finite base cutoff. This is the same algebraic complete-batch decomposition; its nonchild word-time bound is proved above rather than obtained from a tape tariff. The fixed stock, complete batches, leftover direct transforms and high-direction transforms are actual operations. Any implementation must preserve their full field identities; replacing the stock by one reusable dirty field is not this construction.
+
+An explicit conservative split is available. Put a=ceil(log2 W), lambda=ceil(log2(e+2)), and D_upper=1+ceil(log_N(e+1)); choose the fixed-cutoff branch until e exceeds a*D_upper+2*lambda+2*N. Above it take f=floor((e-a*D_upper-2*lambda-N)/N) and ell=e-N*f. Then ell=O(log(e+2)), ell>=a+2*lambda and f>=1. There are 2^ell complete fibers. Fewer than W leftovers occupy fraction at most W/2^ell<=(e+2)^(-2), so their O(e) direct cost contributes O(1) normalized work. The ell high directions cost O(ell) normalized operations. The a*D_upper stock reserve covers one actual W-role chunk at every possible nested depth; every role remains on its own indexed coordinates. Thus the displayed recurrence has an explicit direct native batch implementation, with no input-size-dependent padding factor hidden in its constant.
+
+Put mu=(P_leaf/W)*N^(-z)<1. Since (e+1)^z dominates log(e+2), choose a fixed base cutoff and constant A so C*(1+log(e+2)) <= (1-mu')*A*(e+1)^z for some mu<mu'<1. Increasing the cutoff absorbs the harmless +1 in the child argument. Strong induction, with all finite base costs included, proves T(e)<=A*2^e*(e+1)^z. Since f(e)<=e/N, recursion depth D(e)=O(log(e+2)).
+
+## Precision: literal coefficients and depth, not total word length
+
+Consider the expanded finite template acting on all live and owned coordinate banks. For ADD x<-x+a*y use the exact operator-norm bound 1+|Re a|+|Im a|; for SCALE use max(1,|Re a|+|Im a|); COPY has bound 2 and CLEAR bound 1. Monomial permutations and quarter phases have norm 1. Their finite product gives a computable fixed integer K>=2 covering every local prefix and suffix, with completed recursive children treated as exact unitary Gaussian maps on their live fields and zero on freshly cleared owned storage.
+
+An expanded prefix or suffix is inside at most one unfinished child per depth. Every other completed child acts unitarily on its disjoint live coordinates. Hence the complete exact prefix/suffix norm is at most K^(D(e)+1). This is proved from the actual finite inventory and all-input endpoint; no semantic-precision oracle is assumed. The constant log K may be enormous but is fixed. In particular, multiplying a varying depth by log K gives O(log(e+2)) guard bits, not an input-dependent unbounded coefficient.
+
+With M(e)<=A*2^e*(e+1)^z scalar operations, exact rational local evaluation followed by rounding to P fractional bits injects complex error at most sqrt(2)*2^-P. Transporting every local error through the exact suffix and summing yields
+
+    ||computed-exact||_infinity
+      <= sqrt(2)*A*2^e*(e+1)^z*K^(D(e)+1)*2^-P.
+
+Thus it suffices to set
+
+    P=B+e+ceil(log2 A)+ceil(z*log2(e+1))
+        +(D(e)+1)*ceil(log2 K)+3.
+
+The exact input Euclidean norm is at most sqrt(Z_e*2^e)*2^b. A safe sequential allocation has Z_e bounded by a fixed polynomial in e (even allocating a fresh bank at every recursion depth contributes only a depth factor at equal total volume). The prefix estimate and the same transported-error sum therefore give integral width
+
+    I=b+e/2+(D(e)+1)*ceil(log2 K)+O(log(e+2))+O(1).
+
+If a chosen stock layout uses a larger fixed polynomial space envelope, include its logarithm instead. Consequently I+P=O(log n) whenever e,b,B=O(log n). Products and exact fixed-limb rational divisions add only a constant factor to the common word width. Fixed dyadic denominators contribute their literal finite height; they are not mistakenly charged as O(log e) when their constants are huge. Negative operands use signed magnitudes or two's-complement arithmetic with explicit guard bits. No intermediate is a unit-cost n-bit product.
+
+The same local-error argument controls arbitrary approximate inputs to inverse calls and sums over independent fibers. The unnormalized Walsh conversion multiplies accuracy by 2^(e/2), so requesting B+ceil(e/2)+1 bits from the Gaussian kernel suffices. Its exact Gaussian-integer normalization is constructed in O(e) bounded-word steps and remains within O(log n) bits.
+
+## Scope and credit
+
+This proves the native execution/precision closure of the pinned actual algebraic finite word at q_C. It does not independently reprove the critical mirror/majorant or the source's all-column identities, and does not turn a numerical receipt into those proofs. The entire cyclic/tensor caller, precision propagation, paid Gaussian/phase preparation and packed integer recovery must be connected by the complete outer assembly before a multiplication exponent follows. A native target of 0.0030201655 requires that complete assembly with strict slack; it is not a new multitape-TM result and is not a better value obtained by printing more root digits.
+
+Credit: Cinna Davis and the joint-helper/native contributors; Jacob Alan Sussman for integer matching; zxv for direct flow, nested widths and logarithmic majorants; Ryanson Jonathan for mirror windows; Dillon for the critical-root criterion; all retained Clifford and Gaussian sources; and the earlier #956 native provider lineage. This document adds direct indexed-RAM metadata, exact rational bounded-word lowering and quantitative depth stability for that actual larger finite word. Prepared for Dugongue with substantial OpenAI Codex assistance, Apache-2.0. No independent human or formal-kernel acceptance claim.
diff --git a/research/native-kappa-30201655/OFFLINE-SETUP.md b/research/native-kappa-30201655/OFFLINE-SETUP.md
new file mode 100644
index 0000000000..5966cb9366
--- /dev/null
+++ b/research/native-kappa-30201655/OFFLINE-SETUP.md
@@ -0,0 +1,9 @@
+# Paid offline arithmetic and explicit thin metadata
+
+For each fixed input length parameter p, one original axis has r = 2^O(p^(1−epsilon)) positions. A complete group key has K = O(p^(beta+1−epsilon) + p^beta log p) = o(p). Enumerating the actual coefficient, phase, membership and address functions over their local keys costs poly(p) 2^O(K), after the one-axis catalogues have been built in poly(r,p) operations. Both are n^o(1). These are explicit algebraic functions, not TM transition tables.
+
+Original global Gaussian coefficients may require Cp + O(p² log p) offline precision. No such number is a unit-cost scalar. limb_setup.py supplies signed arithmetic with 15-bit limbs, schoolbook multiplication and binary long division; elementary raw products stay below 32 bits. Polynomial-sized rational coefficient preparation and exact elimination therefore have polynomial native cost. Rational exp/root series at specified precision also have polynomial construction time with certified remainder formulas retained from the sources. This is a sufficient asymptotic construction, not a claim that the full source coefficient constructor was emitted in this packet.
+
+Online only the source-conditioned O(p)-bit coefficients are retained, with guards for polynomial error amplification and the actual circuit suffix norms. Complete word-key projection is a Benes masked-shift network of O(log p) depth. Local tensor-circuit route width is the dyadic microbox L = p^128, so local routing also costs O(log p) stages; full original-axis width must not replace that local width. Coarse labels are spectators in those local routes while complete H calls still cover all coarse labels.
+
+sparse_membership.py checks an explicit table-driven set-bit scatter on finite examples. Its width cap is a test limit, not the asymptotic theorem: enumeration over all K-bit keys is paid as above. No Python dictionary lookup, arbitrary-width arithmetic or oracle is silently designated as one native instruction in the proof.
diff --git a/research/native-kappa-30201655/PHASE-CELL-BATCHED.md b/research/native-kappa-30201655/PHASE-CELL-BATCHED.md
new file mode 100644
index 0000000000..4679ae70fb
--- /dev/null
+++ b/research/native-kappa-30201655/PHASE-CELL-BATCHED.md
@@ -0,0 +1,70 @@
+# Native batched phase-cell boundary inverse
+
+Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0.
+
+This theorem instantiates BATCHED-INVERSE.md at the actual phase-cell Gaussian inverse in the retained RaD report, rather than the stronger near-identity subclass of PR #4554. It changes the arithmetic algorithm; no Turing-machine implementation or execution tariff is used.
+
+## Exact source and scope
+
+The source is references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md, sections “The Schur boundary remains small” and “Two interior passes and one boundary solve”, together with its cited review-phase-cell-inverse.md. Its actual rational rounded matrix H has diagonal-dominance gap at least 1/(8p), row norm below 2 and ||H⁻¹||∞ ≤ 8p. The Gaussian tail, similarity construction, phase cells, Schur formula and their error estimates are predecessor mathematics. We retain their exact algebra and replace the online arithmetic below. This is a sufficient complete algorithm for that inverse map on arbitrary bounded complex data, not by itself a multiplication theorem.
+
+Let p > 100, u = α² = Θ(p^r), d = Θ(p^ε), and w = ceil(sqrt(16p/u))+2. Assume the source's actual parameter restrictions, including ε+r < 1 and ε > (1−r)/2. Every physical phase cell then eventually has more than 4w entries, and each cell has Θ(d) entries, including the two distinct endpoint cells. Put T for the full tensor volume and Rᵢ = T/sᵢ for the parallel fibers of axis i. All sᵢ and p have the source's polynomial numeric bounds in n, sᵢ = n^o(1), and eventually Rᵢ exceeds every fixed power of p.
+
+## Constructive native algorithm and cost
+
+In each cell, keep the first and last w entries as boundary vertices. The interior matrix is exactly diagonal-similar to the source's explicitly rounded symmetric banded Toeplitz matrix. Its inverse is evaluated by the stated Gohberg–Semencul formula: four triangular Toeplitz products, each an ordinary convolution, plus explicit diagonal scaling. Use the direct bounded-word radix-two FFT and paid root/exp routines from PR #4554 for these length-O(d) convolutions, at the guard precision below. This takes O(d log(d+2)) native instructions per cell. Both interior passes are charged. Across all fibers and axes their total cost is O(T d log(p+2)). No packed large-input multiplier is a subroutine.
+
+The boundary Schur complement S has bᵢ = O(sᵢ w/d) vertices in inherited physical order, cyclic half-bandwidth at most 2w and row norm below 2. Its rounded dyadic form has gap at least 1/(16p). Prepare its ordinary-band LU factors and periodic Woodbury data by the source's explicit finite algorithms, once per axis. They are shared data, not advice or inverse oracles. The source gives
+
+    ||U||∞ < 2,       ||L||∞ ≤ 65p²,
+    ||L⁻¹||∞ < 32p,   ||U⁻¹||∞ ≤ 1040p³.
+
+The periodic correction has rank at most 4w and explicitly prepared matrices Z,V,K⁻¹ with
+
+    ||V||∞ < 2,       ||Z||∞ ≤ 16p,       ||K⁻¹||∞ ≤ 33p.
+
+Choose a power-of-two block size H with 4w ≤ H < 8w. Pad the ordinary triangular systems with independent unit diagonal coordinates if necessary. Their contiguous diagonal-block inverses are the corresponding principal blocks of the triangular inverse, so all hypotheses of BATCHED-INVERSE.md hold with polynomial bounds in p. Prepare those inverse blocks by ordinary triangular substitution on unit columns. Apply both triangular solves to batches of H independent right-hand sides using the explicit seven-product Strassen routine. Since Rᵢ ≥ H eventually, this costs
+
+    O(bᵢ Rᵢ H^(ω−2)),       ω = log₂ 7.
+
+Apply the periodic closure as y − Z K⁻¹ V y. The selector/corner map V has support in O(w) coordinates and is explicitly stored. Its products, the O(w) by O(w) K⁻¹ product, and the bᵢ by O(w) Z product are partitioned into H-sized matrix blocks and the same right-hand-side batches. Their cost is covered by the same bound, because bᵢ ≥ H eventually. Do not apply Z separately to each right-hand side; that would repay the bandwidth factor.
+
+Both off-diagonal couplings H_BI and H_IB are charged. Each cell has O(w²) coupling entries, supported only on its two boundary strips and the adjoining interior strips of length O(w). Express them as a fixed number of O(w) by O(w) dense block products against the same batches of fiber columns. The work per axis is O((sᵢ/d) Rᵢ w^(ω−1)), identical to the Schur solve bound. The O(sᵢ Rᵢ) gathers, scatters and splits are also included. Two endpoint cells and periodic corrections remain separate explicit blocks; no undeclared cyclic merge is used.
+
+Therefore the complete online inverse per axis costs
+
+    O(T log(p+2) + (T/d) w^(ω−1)).
+
+Summing d axes gives the sufficient native bound
+
+    O(T [d log(p+2) + w^(ω−1)] + n^o(1)).                 (1)
+
+The n^o(1) term pays the complete axis preparation, including phase generation, Gaussian coefficients, GS generators, Schur entries, ordinary factors, inverse diagonal blocks and all Woodbury data. Exact rational preparation is implementable using signed multiword grade-school arithmetic and Gaussian elimination on explicitly stored finite matrices. Its dimensions and rational numerator/denominator lengths are polynomial in sᵢ and p, so it costs poly(sᵢ,p) = n^o(1), with each elementary word operation charged. Only guarded O(p)-bit coefficients are retained online. The shared native exp/phase construction additionally costs O(n^η polylog n) for any fixed η > 0 selected by the outer caller. It is paid once and is not subsumed into n^o(1).
+
+## Stability, word width and exact periodic closure
+
+The source already proves all polynomial inverse and intermediate bounds of the completed interior–boundary–interior composition. No stage is replaced by an assumed unknown transformation. For the new batched triangular solve, BATCHED-INVERSE.md gives error ≤ 24 B⁸ v for scalar grid spacing v, provided v ≤ 1/(12 B⁶). Here B is polynomial in p for the boundary factors and their right-hand sides: the source bounds the first interior output by 8p, boundary right-hand side by 17p, and later completed values by O(p²), on unit-norm input.
+
+For a block matrix product the grid error is ≤ H²v per entry. Any prepared matrix coefficient errors are bounded in induced row norm by the sum over its O(w) columns, so a polynomially smaller coefficient budget covers them. The source's Z, V and K⁻¹ operator norms are polynomial, and the periodic closure has a fixed number of completed products. Thus its total new error is poly(p) v, with no exponential dependence on bᵢ, the number of cells or fibers. The arbitrary-input bound follows by homogeneous norm scaling; a log(max(1,||input||∞)) precision guard is explicitly paid.
+
+The unchanged local GS maps may amplify internally by 2^(8p+O(1)); their four native FFT convolutions require only O(p) fractional and integral bits because d is polynomial in p. Allocate enough of the source's 2^(-32768p) grid budget to every new FFT, preparation rounding, Strassen and closure product. Equivalently choose a larger fixed constant times p if a particular FFT implementation uses a larger fixed error constant. The source's completed-map perturbation argument then preserves its final 2^(-p-10) inverse error and normalization N⁻¹/2^ceil(log₂(32p)). Every intermediate, exact product, division numerator, address and counter fits a single sufficiently large common Θ(log n)-bit physical word budget; the fixed constant must cover the FFT root-generator's private working precision too. Complex arithmetic uses four real matrix products and a fixed number of real sums.
+
+This explicitly handles the periodic Schur closure and both coupling directions. A necessary condition, failed search or unknown inverse oracle is not being offered as the result.
+
+## Exponent consequence for an actual outer caller
+
+Since w² = O(p^(1−r)), formula (1) becomes
+
+    O(T [p^ε log(p+2) + p^((ω−1)(1−r)/2)] + setup).
+
+The exact integer inequality 7^16 < 2^45 gives ω < 45/16, so the boundary exponent is strictly below 29(1−r)/32. With Tp = Θ(n), the inverse map itself consequently admits any normalized saving strictly below
+
+    min(1−ε, (3+29r)/32),
+
+with its own logarithm absorbed by strict slack. Thus for small positive r its boundary component allows a fixed saving greater than 3/32. This is much larger than the approximately 0.003020165 Fourier-kernel saving under discussion and removes the old requirement that the final saving be below r. It does not by itself assert that the complete multiplication caller has that saving: root generation, forward maps, kernel, twiddles, input/output, products and recovery must be present in the full outer assembly. In particular, use the actual provider tariff T p^τ if supplied; do not substitute an unrelated εq kernel formula merely from a rank-saving name.
+
+## Evidence and provenance
+
+The new executable leaf batched_band.py checks the actual fixed-grid Strassen and inverse-block substitution machinery: 36 systems, 1,785 independent residual entries below 2⁻⁷⁰, including partial batches, signed inputs and an overflow rejection control. It does not replay the entire asymptotic phase-cell caller. Existing phase-cell finite prototypes and source reviews retain their original scope and credit. This corollary supplies a new informal universal assembly of those exact algebraic maps with the checked native batching primitive.
+
+The retained phase-cell construction and reviews credit the RaD campaign, Gohberg–Semencul (1972), Feng–Wu–Wei's primary formula exposition, Harvey–van der Hoeven Gaussian resampling, and the upstream integer-multiplication manuscript. Strassen's seven-product identity is classical. PR #4554 contributes the paid native finite-word exp/phase/root/FFT routines and their Gaussian lineage. Our contribution is batched native boundary and coupling evaluation with polynomial residual control. No fresh Lean verification, new TM κ, practical speedup or worldwide novelty is claimed.
diff --git a/research/native-kappa-30201655/PROVIDER-INDEPENDENT-REVIEW.md b/research/native-kappa-30201655/PROVIDER-INDEPENDENT-REVIEW.md
new file mode 100644
index 0000000000..57120dde78
--- /dev/null
+++ b/research/native-kappa-30201655/PROVIDER-INDEPENDENT-REVIEW.md
@@ -0,0 +1,29 @@
+# Independent final provider/assembly review
+
+Reviewed the current assembly/NATIVE-ASSEMBLY.md, provider/NATIVE-PROVIDER-4535.md, the predecessor algebraic compiler proofs and the relevant modern gauge-free/fine-padding and batched inverse documents. No decisive error was found in the **stated source-bound informal claim** at native Word RAM kappa=0.0030201655. This is not independent verification of every inherited analytic theorem, an emitted end-to-end multiplier, a Lean result or a practical performance claim.
+
+## Provider dependency audit
+
+The relevant effective chronological construction is PR4483's research/direct-mixed-flow/README.md sections 2 and 3, not merely the short compact-joint-compiler parameter proof. Its actual rules supply matched whole jobs from the present paid round, complete unmatched exits, introduce distinct sources when parent slots are absent, and return completed children before the parent continues. Nested divisible widths make smaller program batches integral. Strict rank descent proves finite construction. Its all-input correctness uses explicit source Gaussian/monomial matching identities. PR4532's majorant and PR4535's absorption then fund the actual fixed rank N=2^(10^12), with P_leaf/W<N^(1-0.0030201656).
+
+The native closure's exact asymptotic premise is this algebraic all-fiber identity for every positive lift f, including absolute phase normalizers. An f=1 replay or favorable histogram alone would not supply it. Within that retained mathematical premise, the indexed array compiler, fixed rational operation lowering, paid affine/quadratic metadata tables, complete batches, leftovers and depth-prefix roundoff argument do provide native execution and O(log n)-bit words without a TM complexity or precision theorem. The fixed constants may be astronomical; treating them as fixed is valid only after freezing the supplier before n varies.
+
+## Outer cost and precision audit
+
+The main native row is T*p^(1-epsilon*q), and the actual tensor-fused Gaussian row is T*p^(epsilon-q*beta), up to fixed polylogarithms. The latter is essential: substituting separate line transforms with T*d work would not establish the claimed exponent at epsilon near 1. The assembly explicitly retains the constructive shallow shifted/accretive Toeplitz circuit and its simultaneous selected-bit H/diagonal compiler, so it does not make that substitution.
+
+The group coordinate-key width K=O(p^(beta+1-epsilon)+p^beta log p) is o(p) under the stated strict parameter inequalities. Enumerating the explicitly defined coefficient/address functions therefore costs n^o(1), including any fixed polynomial number of group types. Paid word-bit Benes routing gives logarithmic, rather than g-linear, work per query. The coefficient/root preparation uses multi-limb arithmetic on its polynomial-size offline operands. If an axis-sized constructor has dimensions s_i=n^o(1), its exact bit lengths/time should be described as polynomial(s_i,p), not uniformly polynomial(p); this still contributes n^o(1) setup. Online data and rounded coefficient words remain C*p bits under the retained conditioning and explicit new rounding estimates.
+
+The supplied batched triangular residual theorem controls the full solution using the actual global inverse norm rather than multiplying errors along the block chain. Periodic low-rank correction, inverse diagonal-block preparation, both original boundary couplings, incomplete batches and indexed sparse visits are charged. Fast multiplication is Strassen on bounded signed scalar words; no n-bit input product is an elementary operation. The native full-global-precision record FFT uses the same word model as the outer caller, which is necessary when log(record length) is much smaller than p.
+
+For the stated rational parameters, q_C-q=5e-11, epsilon*q-kappa=1.97983445e-11 and the fused Gaussian margin is positive. These strict constants absorb all fixed polylog(p) factors eventually. The claim needs the complete source-bound nine-row and interface ledger, not only these three comparisons. The root's component finite tests retain their separate scope: record-product fixtures do not replay the gigantic provider or full asymptotic caller.
+
+## Scope and retained obligations
+
+The assembly is a new native execution/cost theorem conditional on specifically credited algebraic/analytic predecessor proofs. Its missing formalization and missing materialized full program are disclosed rather than treated as hidden fast-algorithm oracles. The claim must remain qualified this way in README, title/body and handoff; a finite arithmetic certificate does not independently certify universal source mathematics or worldwide best-known priority. The source's analytic Gaussian identities, phase-cell/coarse-label decomposition, prime padding, tensor-circuit correctness, matching normalizers and exact recovery retain their full predecessor attribution.
+
+Reviewed bytes are hash-bound in FINAL-ASSEMBLY-REVIEW-HASHES.json. Later edits require a targeted reread; these hashes do not themselves validate mathematics.
+
+## Targeted final revision review
+
+Reread assembly revision SHA-256 a1f200292ea13d72bd64cb91a4daa28261bc220a80fe9c94983f3b9a1dffaa42. It now explicitly limits the common circuit wire width to the retained dyadic core L=p^128, preserves coarse labels while making the completed H calls globally, and charges global polynomial(r,p) preparation separately from polynomial(p) group-key evaluation. The nine rows now expressly include per-call selected-bit addressing within the main/fused costs and per-group scans within the group row; the standalone routing rows cover only additional global passes. These clarifications address the review notes without changing the claimed exponent. No new decisive gap was found in that targeted reread.
diff --git a/research/native-kappa-30201655/README.md b/research/native-kappa-30201655/README.md
new file mode 100644
index 0000000000..dbd147dbac
--- /dev/null
+++ b/research/native-kappa-30201655/README.md
@@ -0,0 +1,29 @@
+# Conditional native Word RAM multiplication: κ = 0.0030201655
+
+The informal sufficient assembly in [NATIVE-ASSEMBLY.md](NATIVE-ASSEMBLY.md), together with the explicitly retained predecessor algebraic and analytic proofs, gives packed n-bit multiplication in O(n / (log n)^κ) on a standard Word RAM with w = Θ(log n) and bounded-word MUL/DIV, for κ = 0.0030201655. It uses neither a TM simulator nor a TM multiplication subroutine. The word-width constant and eventual cutoff may be enormous.
+
+This exceeds the displayed conditional Word RAM target 0.003020165 in PR #4541 by 0.0000000005. It does **not** improve the underlying p16 paid profile or critical root, establish a new TM bound, or claim that no previous cofinal family implies this numerical value. The contribution is a direct finite-word realization and complete cost assembly with weaker machine premises. The selected upstream frontier is unchanged.
+
+Two essential mechanisms are combined here: (1) fused gauge-free Gaussian circuits with paid sublinear full-group metadata tables, bounded local microbox routing, and multi-limb offline coefficient construction; (2) global-precision native FFT record products and an explicit batched boundary solver, including both coupling directions and periodic closure. Direct native execution of the actual retained finite provider supplies the transform exponent. An unfused Gaussian loop or a local-log(record-size) word model would not establish this bound.
+
+## Read and replay
+
+Start with NATIVE-ASSEMBLY.md, NATIVE-PROVIDER-4535.md and RECORD-PRODUCT.md. The exact nine-row ledger has a minimum excess of 0.0000000000197983445 above κ. Run `python3 -I -O -B verify.py` from this directory, or `python3 -B scripts/research_package.py --package research/native-kappa-30201655` from the repository root. Python 3.12 and its standard library suffice; Windows, Linux and macOS use the same source. No GPU or Lean environment is required.
+
+The verifier authenticates the complete package before loading component code. It checks the source critical majorant and finite absorption, all strict native cost inequalities, actual fixed-word arithmetic components and rejecting controls. These are finite component and rational-arithmetic checks, **not** a replay of the all-input asymptotic multiplication algorithm or a formal proof certificate.
+
+## Retained proof boundary
+
+The finite provider has fixed rank N = 2^(10^12), encoded symbolically and never materialized. Its actual all-column/all-fiber algebraic identity and critical majorant are retained source proofs, not inferred from sampled matrix entries. The analytic Gaussian/Poisson, fine-padding, accretive Toeplitz and integer recovery proofs are also retained. MODERN-SOURCE-MAP.json and 4535-BRIDGE-PINS.json bind the exact public source snapshots. Source snapshots preserve their notices. This package adds an informal native assembly and executable components; independent acceptance of the inherited mathematics remains a review obligation. No unknown gadget or fast-multiplication oracle is assumed.
+
+## Overlap, precedents and credit
+
+The final checkpoint fetched canonical main f626db5c3a3d781d8f7695038776c621651f75e1 and inspected the 30 most recently updated PRs through #4562. In particular #4535 supplies the critical-root input; #4538/#4541 supply earlier native components and packed TM transfer; #4554 supplies native Gaussian/FFT primitives. Newly visible #4556–#4562 are independent component audits, not a new exponent. Their existence is acknowledged; this package does not claim to have replayed all those submissions. #4540/#4549's controller results do not change the paid p16 profile used here. No exhaustive historical-priority claim is made.
+
+The shared DAG/Lean tree was searched for Word RAM, sparse limbs and convolution. Problem 1.8/MpLimbs and sparse-axis precedents informed the representation, but no newly kernel-checked Lean theorem is claimed or required. Source-only catalog entries are not treated as proofs. The canonical DAG and active Lean sources are untouched.
+
+Credit includes Cinna Davis and joint-helper contributors; Jacob Alan Sussman; zxv; Ryanson Jonathan; Dillon (#4532/#4535); Vlado Vojdanovski (#1673); the #1758 gauge-free authors; Chafik Boukhalfa (#1786) and Tim Trudgian; Jeremy Kothe; eumemic and icekylinx; Harvey and van der Hoeven; and all retained source owners. See the original notices and assembly credit for specific contributions. Prepared for Dugongue with substantial OpenAI Codex assistance from one lead and three reviewing/research agents. Apache-2.0 for new code; inherited notices remain applicable.
+
+## Open next questions
+
+Independent review should check the retained all-fiber compiler and analytic proofs at their actual caller. A practical full native multiplier and a useful cutoff remain unimplemented; see TASK.json for concrete review and engineering steps. These limitations do not convert finite checks into universal evidence.
diff --git a/research/native-kappa-30201655/RECORD-INDEPENDENT-REVIEW.md b/research/native-kappa-30201655/RECORD-INDEPENDENT-REVIEW.md
new file mode 100644
index 0000000000..73a0ed9ed2
--- /dev/null
+++ b/research/native-kappa-30201655/RECORD-INDEPENDENT-REVIEW.md
@@ -0,0 +1,38 @@
+# Independent final native-assembly and record-product review
+
+Prepared for Dugongue with substantial OpenAI Codex assistance. This review is independent within the four-worker AI team; it is not external human review or a kernel audit.
+
+Reviewed assembly/NATIVE-ASSEMBLY.md at SHA-256 187fcf18a8177976ef238e97ff69ee2a2c81a9148b21147c1083ccc13288438c and record_product.py at SHA-256 6967feb00fbcb13640504f26c5e20bcea249e1dc89c41713aa8e8f161def873e. Read the actual native_convolution.py path and its root-seed call. The retained analytical sources and their exact-byte bindings were separately reviewed in FUSED-NATIVE-REVIEW.md. Later prose clarifications should be rehashed by the integrator.
+
+No new substantive mathematical defect was found in the stated source-bound conditional assembly. This conclusion retains the explicitly identified all-input finite supplier, analytic reduction, tensor-compiler identities, fine-prime and exact-recovery source premises. It does not independently replay or establish the enormous finite supplier or a complete asymptotic native execution.
+
+The native provider gap is strict: q = 0.00302016555 < q_C = 0.0030201656, and q_C is below the source critical saving. The chosen ε gives εq = 0.0030201655197983445 > κ = 0.0030201655. The Gaussian row is the actual fused g-axis circuit cost T d g^(-q), not the scalar T d fallback. The capped boundary uses explicit Strassen and charges both couplings and periodic closure. The fine-prime wider offline precision is paid with polynomial-size multi-limb setup; it is not mislabeled one-word arithmetic.
+
+Native per-visit metadata is justified by sublinear-bit group keys and explicit n^o(1) tables, with word-level Benes extraction or mixed-radix/indexed gathering. Sparse-axis enumeration visits the sum of individual slab volumes, not every axis on every record of their union. These are actual random-access recipes and import no TM algorithm or tariff.
+
+The routing rows require the following accounting interpretation: call-specific gather/restore and phase normalizers are already inside the main/fused call bills; group-specific extra passes are in the group-scan bill. Only a fixed number of additional global passes have standalone saving 1. There must not be an additional uncharged full-array scan per axis. The source assembly's intended interpretation was confirmed with the root worker.
+
+For batched inverse stability, the right-hand-side size is the maximum infinity norm of INDIVIDUAL columns, equivalently entrywise maximum. It is never the induced row-sum norm across all R columns; R can be enormous and must not enter the precision guard. The owned BATCHED-INVERSE.md now states this explicitly. Fine-prime conditioning is polynomial in p; old special-case constants such as 8p are not asserted for the capped fine-prime matrix.
+
+## Actual record-product check
+
+For a record of length r = 2^j and signed Gaussian-integer components smaller than 2^p, each input complex modulus is below β = 2^(p+1). The code pads to N = 2r, uses F = 16p+16 bitlength(r)+64 fractional bits and S = 2^F, computes the two forward transforms and one inverse, and retains the 2r−1 linear-convolution coefficients. Its guarded fixed-point operations are those of native_convolution.py.
+
+The prior FFT estimate bounds coefficient error by 216 N^6 β²/S. With bitlength(r) = j+1,
+
+    216 N^6 β²/S
+    ≤ 216 * 2^(6j+6+2p+2−16p−16j−16−64)
+    = 216 * 2^(-14p−10j−72)
+    < 1/4.
+
+Thus rounding floor((x+S/2)/S) recovers the correct signed integer, including negative coordinates. The runtime separation check is an additional control; the mathematical bound supplies its sufficiency. Folding coefficient j+r with a minus sign implements reduction modulo X^r+1; the nonexistent highest term at degree 2r−1 is correctly treated as zero. Real and imaginary components are both retained.
+
+The supplied width 16(F+16)+20 covers the root seed's private precision P = 8(F+16) and raw-product requirement 2P+20 exactly. FFT data/products need much less: F and log r are O(global p), so the declared sufficiently large fixed common word coefficient covers them. It is essential that the outer proof uses GLOBAL p-sized words, not a fresh local log(record bitlength)-sized machine.
+
+Each product performs O(r log r) native operations after the root table has been prepared and paid. Root preparation is shared or counted in the explicit sublinear setup. The code recomputes each input kernel transform, correctly charging it to that product. Full-variable-input multiplication appears only in the independent schoolbook reference oracle, not the algorithm.
+
+## Remaining scope
+
+The final result should remain described as source-bound conditional native Word RAM multiplication, with no new TM exponent, no independently formalized full theorem, no practical-speed assertion and no claim of worldwide novelty. Preserve the predecessor credits already listed in NATIVE-ASSEMBLY.md and the complete source notices. A minor setup wording should allow polynomial(s_i,p), not merely polynomial(p), whenever full-axis exact rational preparations are discussed; both are n^o(1) in the stated regime.
+
+Independent executable replay: python -I -O -B record_product.py passed 36 signed complex record products and 378 ring coefficients, with maximum raw magnitude width 51,965 bits under each explicitly computed word cap, and the overflow rejection control passed. TM_calls = 0. This is finite operational-model evidence, separate from the universal source-bound proof.
diff --git a/research/native-kappa-30201655/RECORD-PRODUCT.md b/research/native-kappa-30201655/RECORD-PRODUCT.md
new file mode 100644
index 0000000000..e4fc1395ec
--- /dev/null
+++ b/research/native-kappa-30201655/RECORD-PRODUCT.md
@@ -0,0 +1,9 @@
+# Native global-precision polynomial records
+
+For power-of-two r and signed complex integer coefficients of magnitude below 2^p, record_product.py computes the product modulo y^r + 1. Pad to N = max(2, 2r), perform two forward and one inverse direct radix-2 FFTs, round the ordinary coefficients, and fold coefficient j+r negatively into coefficient j. The schoolbook oracle occurs only in the verifier.
+
+The fixed-point fractional width is F = 16p + 16 bit_length(r) + 64. Each raw intermediate is checked against the chosen fixed word-width bound, including root generation. The retained native convolution error inequality is at most 216 N^6 β² / 2^F with β = 2^(p+1); substitution makes this strictly below 1/4 for all p ≥ 1 and r ≥ 1. To see the margin, N ≤ 2r except the identical r = 1 case N = 2, and bit_length(r) > log2 r. The numerator is below 2^(2p+16) r^6, whereas the denominator exceeds 2^(16p+64) r^16. Nearest integer rounding is therefore exact. Negative coefficients use the same absolute error bound. Folding is exact bounded-word subtraction.
+
+In the actual caller p = Θ(log n), log r = O(p/d), and F = O(p). Thus every checked arithmetic operation uses a fixed number of GLOBAL machine words. The FFT takes O(r log r) operations; its O(p+r) reusable root setup is charged offline (or absorbed when r grows). It would be incorrect to charge the same scalar as constant time on a fresh Θ(log(rp))-bit machine. All-input error and cost statements here are informal proofs using the retained root/FFT error theorem; 36 products and 378 ring coefficients provide independent finite replay only.
+
+The record_product implementation and its fixed-word convolver are distinct from a TM multiplier. Native root generation uses bounded-word rational series. The original #4554 source notices and root code are retained.
diff --git a/research/native-kappa-30201655/SOURCES.json b/research/native-kappa-30201655/SOURCES.json
new file mode 100644
index 0000000000..a2a5ea8bbd
--- /dev/null
+++ b/research/native-kappa-30201655/SOURCES.json
@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "f626db5c3a3d781d8f7695038776c621651f75e1",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40",
+      "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65",
+      "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96"
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/TASK.json b/research/native-kappa-30201655/TASK.json
new file mode 100644
index 0000000000..13dfd95248
--- /dev/null
+++ b/research/native-kappa-30201655/TASK.json
@@ -0,0 +1,80 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 7,
+  "base_commit": "f626db5c3a3d781d8f7695038776c621651f75e1",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/unconditional-batched-crt/README.md"
+    ],
+    "methods": [
+      "Prove one missing implication with explicit quantified hypotheses.",
+      "Find an exact counterexample at the claimed interface boundary."
+    ],
+    "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_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.",
+    "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.",
+    "allowed_variations": [
+      "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller."
+    ],
+    "scope_change_triggers": [
+      "Replacing a quantified obligation with another finite smoke test.",
+      "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses."
+    ],
+    "overlap_terms": [
+      "uniform transfer",
+      "all-size",
+      "precision",
+      "4100",
+      "unconditional-batched-crt"
+    ],
+    "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_status": "changed",
+  "actual_scope": "Direct native Word RAM realization and nine-row sufficient assembly at conditional kappa 0.0030201655.",
+  "scope_change_reason": "User explicitly assigned the native Word RAM alternative and a higher conditional kappa, rather than the default catalogue audit.",
+  "bottleneck_link": "Replaces TM transfer with a fully paid native fused Gaussian, finite-provider and record-product assembly.",
+  "budget_minutes": 60,
+  "stop_rule": "Freeze strict target and inherited proof inputs; independently review assembly; finish finite checks and a portable source-bound handoff within the session.",
+  "outcome": "completed",
+  "evidence": "NATIVE-ASSEMBLY.md; NATIVE-PROVIDER-4535.md; exact critical and native ledgers; two independent agent reviews; component replay.",
+  "author": "Dugongue",
+  "ai_assistance": "Substantial OpenAI Codex assistance: lead plus three research/review agents; no Lean formalization, no Jev.",
+  "open_questions": [
+    {
+      "question": "Will independent reviewers accept the retained all-fiber algebraic and analytic predecessor proofs and their assembly?",
+      "why_it_matters": "The theorem is explicitly conditional on those source proofs; finite checks cannot establish them.",
+      "first_step": "Review the pinned compiler, fine-padding and shallow-circuit sources against NATIVE-ASSEMBLY.md.",
+      "blocked_by": "Independent mathematical review."
+    },
+    {
+      "question": "Can one emit a practical full native multiplication caller?",
+      "why_it_matters": "The enormous fixed supplier establishes no practical cutoff.",
+      "first_step": "Materialize a smaller complete caller with the same interfaces and independently compare all outputs.",
+      "blocked_by": "Engineering and useful finite constants."
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/VERIFY.json b/research/native-kappa-30201655/VERIFY.json
new file mode 100644
index 0000000000..0d84fb7a35
--- /dev/null
+++ b/research/native-kappa-30201655/VERIFY.json
@@ -0,0 +1,20 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Authenticate all sources; exact critical absorption and native margins; bounded-word record, boundary, metadata and limb components; rejecting controls."
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/batched_band.py b/research/native-kappa-30201655/batched_band.py
new file mode 100644
index 0000000000..395eea28c7
--- /dev/null
+++ b/research/native-kappa-30201655/batched_band.py
@@ -0,0 +1,115 @@
+"""Native fixed-grid Strassen batches for a shared triangular band solve.
+Python integers emulate checked finite words. Fraction is external oracle only.
+"""
+from __future__ import annotations
+import json, random
+from fractions import Fraction
+
+class Word:
+    def __init__(self, precision=100, width=384):
+        self.p, self.S, self.width, self.ops, self.bits = precision, 1 << precision, width, 0, 0
+    def val(self, x):
+        self.ops += 1
+        self.bits = max(self.bits, abs(x).bit_length())
+        if abs(x).bit_length() >= self.width:
+            raise OverflowError('finite-word magnitude overflow')
+        return x
+    def add(self,a,b): return self.val(a+b)
+    def sub(self,a,b): return self.val(a-b)
+    def mul(self,a,b):
+        t=self.val(a*b)
+        return self.val((abs(t)//self.S)*(-1 if t<0 else 1))
+    def div(self,a,b):
+        if not b: raise ZeroDivisionError
+        t=self.val(a*self.S)
+        return self.val((abs(t)//abs(b))*(-1 if (a<0)!=(b<0) else 1))
+
+def zero(n): return [[0]*n for _ in range(n)]
+def combine(a,b,w,sign=1):
+    return [[w.add(x,y) if sign==1 else w.sub(x,y) for x,y in zip(r,s)] for r,s in zip(a,b)]
+def multiply(a,b,w):
+    n=len(a)
+    if n==1: return [[w.mul(a[0][0],b[0][0])]]
+    h=n//2
+    def split(x):
+        return ( [r[:h] for r in x[:h]], [r[h:] for r in x[:h]],
+                 [r[:h] for r in x[h:]], [r[h:] for r in x[h:]] )
+    A,B,C,D=split(a); E,F,G,H=split(b)
+    add=lambda x,y:combine(x,y,w)
+    sub=lambda x,y:combine(x,y,w,-1)
+    M1=multiply(add(A,D),add(E,H),w)
+    M2=multiply(add(C,D),E,w)
+    M3=multiply(A,sub(F,H),w)
+    M4=multiply(D,sub(G,E),w)
+    M5=multiply(add(A,B),H,w)
+    M6=multiply(sub(C,A),add(E,F),w)
+    M7=multiply(sub(B,D),add(G,H),w)
+    R=add(sub(add(M1,M4),M5),M7)
+    S=add(M3,M5)
+    T=add(M2,M4)
+    U=add(sub(add(M1,M3),M2),M6)
+    return [r+s for r,s in zip(R,S)]+[r+s for r,s in zip(T,U)]
+
+def inverse_lower(a,w):
+    n=len(a); out=zero(n)
+    for col in range(n):
+        for row in range(n):
+            t=w.S if row==col else 0
+            for j in range(row): t=w.sub(t,w.mul(a[row][j],out[j][col]))
+            out[row][col]=w.div(t,a[row][row])
+    return out
+
+def prepare(a,block,w):
+    """Input lower triangular with bandwidth <= block, side divisible by block."""
+    n=len(a)
+    if block<1 or block&(block-1) or n%block: raise ValueError('block shape')
+    for i in range(n):
+        if a[i][i]==0: raise ValueError('zero pivot')
+        for j in range(n):
+            if (j>i or i-j>block) and a[i][j]: raise ValueError('outside band')
+    result=[]
+    for start in range(0,n,block):
+        diag=[r[start:start+block] for r in a[start:start+block]]
+        prev=zero(block) if not start else [r[start-block:start] for r in a[start:start+block]]
+        result.append((inverse_lower(diag,w),prev))
+    return result
+
+def solve(prepared,b,block,w):
+    n=len(b); q=len(b[0]); result=[[0]*q for _ in range(n)]
+    for col in range(0,q,block):
+        previous=zero(block)
+        for i,(inverse,edge) in enumerate(prepared):
+            start=i*block
+            rhs=[r[col:col+block]+[0]*max(0,col+block-q) for r in b[start:start+block]]
+            current=multiply(inverse,combine(rhs,multiply(edge,previous,w),w,-1),w)
+            for j in range(block): result[start+j][col:min(col+block,q)]=current[j][:min(block,q-col)]
+            previous=current
+    return result
+
+def check():
+    rng=random.Random(4554); cases=entries=ops=peak=0; max_error=Fraction(0)
+    for block in (1,2,4,8):
+        for count in (1,2,4):
+            n=block*count
+            for q in (1,block,max(1,2*block-1)):
+                w=Word(); a=zero(n)
+                for i in range(n):
+                    a[i][i]=w.S
+                    for j in range(max(0,i-block),i): a[i][j]=rng.randrange(-3,4)*w.S//(16*block)
+                b=[[rng.randrange(-8,9)*w.S//8 for _ in range(q)] for _ in range(n)]
+                prepared=prepare(a,block,w); x=solve(prepared,b,block,w)
+                for i in range(n):
+                    for col in range(q):
+                        residual=sum(Fraction(a[i][j]*x[j][col],w.S*w.S) for j in range(n))-Fraction(b[i][col],w.S)
+                        max_error=max(max_error,abs(residual)); entries+=1
+                        if abs(residual)>=Fraction(1,1<<70): raise AssertionError('residual')
+                cases+=1; ops+=w.ops; peak=max(peak,w.bits)
+    # Scalar multiplication work scales as exactly 7^log2(side), not side^3.
+    for side in (1,2,4,8):
+        w=Word(); a=[[w.S if i==j else 0 for j in range(side)] for i in range(side)]
+        if multiply(a,a,w)!=a: raise AssertionError('identity')
+    try: Word(width=4).val(16)
+    except OverflowError: pass
+    else: raise AssertionError('overflow control')
+    return {'systems':cases,'residual_entries':entries,'charged_operations':ops,'max_raw_bits':peak,'residual_below_2^-70':True,'overflow_control':True}
+if __name__=='__main__': print(json.dumps(check(),sort_keys=True))
diff --git a/research/native-kappa-30201655/critical_check.py b/research/native-kappa-30201655/critical_check.py
new file mode 100644
index 0000000000..fe6cb22e2f
--- /dev/null
+++ b/research/native-kappa-30201655/critical_check.py
@@ -0,0 +1,49 @@
+"""Exact p16 critical majorant and finite native-provider absorption replay.
+Apache-2.0; Dugongue with substantial OpenAI Codex assistance.
+Credits: Dillon's retained critical engine, zxv/Sussman/compiler lineage.
+"""
+from pathlib import Path
+from fractions import Fraction as F
+import json
+
+HERE=Path(__file__).resolve().parent
+
+
+def need(ok,why):
+    if not ok:raise ValueError(why)
+
+
+def check():
+    path=HERE/'critical_engine.py';E={'__name__':'frozen_critical_engine','__file__':str(path)}
+    exec(compile(path.read_bytes(),str(path),'exec'),E)
+    profile=json.loads((HERE/'raw-profile.json').read_text())
+    benchmarks=json.loads((HERE/'majorant-benchmarks.json').read_text())
+    old=next(row['witness'] for row in benchmarks['cases'] if row['name']=='p16')
+    witness={key:old[key] for key in ('a','b','height_base','ell0','s','lambda','p','c')}
+    witness['guards']={key:old['guards'][key] for key in ('U','V','Q','d','beta')}
+    witness['upper_exponent']='.997067'
+    lo,hi=F('.9969798340229'),F('.9969798340230')
+    root=E['certify'](profile,lo,hi,F('.564'),F(1))
+    majorant=E['critical_guards'](profile,lo,hi,witness)
+    need(witness['height_base']==1024 and witness['ell0']==650 and F(witness['c'])==133 and F(witness['p'])==F(2,5),'exact retained majorant parameters')
+    log=lambda n:tuple(F(x,E['GRID']) for x in E['logarithm'](n))
+    need(log(2)[0]>F(2,3) and log(2)[1]<1,'log2 bracket')
+    need(log(145)[1]<8,'log145 bracket')
+    log_A_upper=F('.003021')*(8+6500)
+    need(log_A_upper<20 and 133+10**12<2**40,'normalization/logarithmic overhead below36')
+    uniform=F('.0030201656');gap=(1-hi)-uniform;H=10**12
+    margin=gap*H*F(2,3)-36
+    need(margin==F(646,3) and margin>0,'finite word absorption')
+    need(gap-F(2,5)/(133+F(2,3)*H)>0,'all-larger-rank absorption monotonicity')
+    rejected=False
+    try:E['certify'](profile,lo,hi,F(0),F(1))
+    except ValueError:rejected=True
+    need(rejected,'unfunded mirror control')
+    return dict(status='PASS',critical_root=root,critical_majorant=majorant,
+                fixed_rank_encoding='2^1000000000000',fixed_rank_materialized=False,
+                native_provider_saving=str(uniform),finite_absorption_log_margin=str(margin),
+                unfunded_mirror_rejected=True,
+                scope='Exact source critical-majorant arithmetic and finite absorption; all-column algebraic word identity remains a cited mathematical proof, not this replay')
+
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/critical_engine.py b/research/native-kappa-30201655/critical_engine.py
new file mode 100644
index 0000000000..89d6139b63
--- /dev/null
+++ b/research/native-kappa-30201655/critical_engine.py
@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+"""Critical-root hypotheses for the retained p7 and p16 rank inventories.
+
+Separate exact arithmetic and mirror enumeration; no predecessor evaluator is
+imported. The inventories and native contracts remain credited source inputs.
+Dillon with substantial OpenAI Codex assistance; Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as F
+from functools import lru_cache
+from hashlib import sha256
+import json
+from pathlib import Path
+
+
+GRID = 1 << 128
+PINS = {
+    'research/higher-moment-strictification/RESULT.json':
+        'ad79e3c0459e7b495a0ca34010553b12147779a007389e1695cc1336f123c156',
+    'research/compact-joint-compiler/arithmetic/RESULT.json':
+        'a6caaa2a6d6460a8c1ef7e48c4853bb27976be33a52b96a4216dfa90d96c9091',
+    'research/joint-helper-lattice/RESULT.json':
+        'c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21',
+    'research/rank-convergence/BENCHMARKS.json':
+        '513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850',
+}
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def floorq(x):
+    return x.numerator // x.denominator
+
+
+def ceilq(x):
+    return -((-x.numerator) // x.denominator)
+
+
+def outward(lo, hi):
+    return floorq(lo * GRID), ceilq(hi * GRID)
+
+
+@lru_cache(None)
+def logarithm(n):
+    """Integer endpoints in units 2^-128, using an exact atanh tail."""
+    require(type(n) is int and n >= 1, 'positive integer logarithm')
+
+    def series(y):
+        z = (y - 1) / (y + 1)
+        require(0 <= z <= F(1, 3), 'logarithm range reduction')
+        # log(y)=2 sum z^(2j+1)/(2j+1). Every omitted denominator
+        # is at least 121, so the geometric tail bounds all omitted terms.
+        term, total = z, F(0)
+        for j in range(60):
+            total += 2 * term / (2*j + 1)
+            term *= z*z
+        return total, total + 2*term / (121*(1-z*z))
+
+    exponent = n.bit_length() - 1
+    a, b = series(F(n, 1 << exponent))
+    c, d = series(F(2))
+    return outward(a + exponent*c, b + exponent*d)
+
+
+def exponential(x):
+    """Outward integer endpoints for exp(exact rational x)."""
+    x = F(x)
+    if x == 0:
+        return GRID, GRID
+    if x < 0:
+        lo, hi = exponential(-x)
+        return GRID*GRID // hi, -((-GRID*GRID) // lo)
+    squarings = 0
+    while x > F(1, 2):
+        x /= 2
+        squarings += 1
+    term_lo = term_hi = total_lo = total_hi = GRID
+    for j in range(1, 65):
+        term_lo = floorq(term_lo*x/j)
+        term_hi = ceilq(term_hi*x/j)
+        total_lo += term_lo
+        total_hi += term_hi
+    # The next term is x^65/65!. Subsequent ratios are <=1/132;
+    # twice an upper enclosure of that term bounds the entire tail.
+    total_hi += 2*ceilq(term_hi*x/65)
+    for _ in range(squarings):
+        total_lo = total_lo*total_lo // GRID
+        total_hi = -((-total_hi*total_hi) // GRID)
+    return total_lo, total_hi
+
+
+@lru_cache(None)
+def power(n, t):
+    t = F(t)
+    lo, hi = logarithm(n)
+    endpoints = [F(lo, GRID)*t, F(hi, GRID)*t]
+    lower = exponential(min(endpoints))[0]
+    upper = exponential(max(endpoints))[1]
+    return F(lower, GRID), F(upper, GRID)
+
+
+def moment(histogram, t):
+    lo = hi = F(0)
+    for rank, count in histogram.items():
+        a, b = power(rank, t)
+        lo += count*a
+        hi += count*b
+    return lo, hi
+
+
+def mean(histogram, t):
+    lo = hi = F(0)
+    for rank, count in histogram.items():
+        a, b = power(rank, t)
+        c, d = logarithm(rank)
+        lo += count*a*F(c, GRID)
+        hi += count*b*F(d, GRID)
+    total_lo, total_hi = moment(histogram, t)
+    require(total_lo > 0, 'positive tilted total')
+    return lo/total_hi, hi/total_lo
+
+
+def display(interval):
+    # These short rational bounds are rounded outward, never floating point.
+    unit = 10**6
+    return [str(F(floorq(interval[0]*unit), unit)),
+            str(F(ceilq(interval[1]*unit), unit))]
+
+
+def histogram(raw):
+    require(isinstance(raw, dict) and raw, 'nonempty histogram')
+    result = {}
+    for key, count in raw.items():
+        rank = int(key)
+        require(str(rank) == str(key) and rank >= 1,
+                'canonical positive integer rank')
+        require(type(count) is int and count > 0, 'positive multiplicity')
+        result[rank] = count
+    return result
+
+
+def mirror_sides(targets, paid, x):
+    sources, exits = Counter(), Counter()
+    for k, w in targets.items():
+        for r, count in paid.items():
+            if k > r and F(1, k) < x <= F(1, r):
+                sources[k*r] += w*count
+            if r > k and F(1, r) < x <= F(1, k):
+                exits[k*r] += w*count
+    return sources, exits
+
+
+def certify(profile, lo, hi, beta, derivative_floor):
+    targets, paid = (histogram(profile[key]) for key in ('targets', 'paid'))
+    m = max(targets)
+    require(min(targets) >= 2 and max(paid) < m and paid.get(1, 0) > 0,
+            'native rank interface and nonempty forests')
+    require(0 < lo < hi < 1, 'critical exponent interval')
+    require(sum(k*q for k, q in targets.items()) >
+            sum(k*q for k, q in paid.items()), 'positive rank-one surplus')
+    first_t, first_p = moment(targets, lo), moment(paid, lo)
+    last_t, last_p = moment(targets, hi), moment(paid, hi)
+    first = first_t[0]-first_p[1], first_t[1]-first_p[0]
+    last = last_t[0]-last_p[1], last_t[1]-last_p[0]
+    require(first[1] < 0 < last[0], 'root sign crossing')
+    # Each tilted mean is nondecreasing: its derivative is the variance
+    # of log(rank). Thus this bounds their difference on the whole interval.
+    gap = mean(targets, lo)[0] - mean(paid, hi)[1]
+    require(gap > derivative_floor > 0, 'positive crossing derivative')
+    # t*m^(t-1) increases for t>0, since its derivative has the sign
+    # of 1+t*log(m). This lower bound therefore applies at the unknown root.
+    eta = lo*power(m, lo-1)[0]
+    require(0 <= beta < eta, 'strict mirror capacity')
+    points = sorted({F(0), *(F(1, k) for k in targets),
+                     *(F(1, r) for r in paid)})
+    cells, worst, worst_cell = [], F(0), None
+    for left, right in zip(points, points[1:]):
+        source, exit_ = mirror_sides(targets, paid, (left+right)/2)
+        require((source, exit_) == mirror_sides(targets, paid, right),
+                'right-closed mirror endpoint')
+        ehi = moment(exit_, hi)[1]
+        slo = moment(source, lo)[0]
+        require(ehi <= beta*slo, 'uniform mirror inequality')
+        if exit_:
+            ratio = ehi/slo
+            cells.append({'left': str(left), 'right': str(right),
+                          'upper_ratio': display((ratio, ratio))[1]})
+            if ratio > worst:
+                worst, worst_cell = ratio, [str(left), str(right)]
+    require(mirror_sides(targets, paid, F(0)) == (Counter(), Counter()),
+            'zero mirror endpoint')
+    require(mirror_sides(targets, paid, 2*points[-1]) == (Counter(), Counter()),
+            'empty mirror tail')
+    return {'critical_root_interval': [str(lo), str(hi)],
+            'endpoint_target_minus_paid': [display(first), display(last)],
+            'uniform_mean_gap_lower': display((gap, gap))[0],
+            'derivative_floor': str(derivative_floor),
+            'beta': str(beta), 'source_capacity_lower': display((eta, eta))[0],
+            'mirror_upper': display((worst, worst))[1],
+            'maximizing_cell': worst_cell, 'funded_mirror_cells': cells,
+            'conclusion': 'Unique crossing on this bracket; critical-root hypotheses hold.',
+            'scope': 'Rank-inventory admission criterion; native and outer obligations inherited.'}
+
+
+def arithmetic_controls():
+    count = 0
+    for base in (1, 2, 3, 5, 16, 121, 145, 10440):
+        for exponent in (F(-1, 2), F(0), F(1, 4), F(1, 2), F(1), F(2)):
+            lo, hi = power(base, exponent)
+            require(lo > 0 and lo**exponent.denominator <= F(base)**exponent.numerator
+                    <= hi**exponent.denominator, 'exact power enclosure control')
+            count += 1
+    return count
+
+
+def critical_guards(profile, root_lo, root_hi, witness):
+    """Fund a shifted-logarithmic majorant at the isolated critical root.
+
+    Uniform inequalities cover [root_lo, upper_exponent], a superset of
+    every unknown-root interval needed in the written endpoint theorem.
+    Parameters are inherited from #4483 except the explicit cover and beta.
+    """
+    targets, paid = (histogram(profile[key]) for key in ('targets', 'paid'))
+    m = max(targets)
+    top = F(witness['upper_exponent'])
+    a, b, M, ell = (witness[key] for key in ('a', 'b', 'height_base', 'ell0'))
+    require(all(type(v) is int and v >= 1 for v in (a, b, ell)) and
+            type(M) is int and M >= 2, 'critical integer geometry')
+    s, lam, p, c = (F(witness[key]) for key in ('s', 'lambda', 'p', 'c'))
+    require(0 < root_lo < root_hi < top < 1 and min(s, lam, p, c) > 0,
+            'critical parameter domain')
+    U, V, Q, d, beta = (F(witness['guards'][key])
+                       for key in ('U', 'V', 'Q', 'd', 'beta'))
+    require(0 < U < 1 and 0 < V < 1 and Q >= 1 and d > 0,
+            'critical uniform guard domain')
+    require(c >= p/(1-root_hi), 'critical concavity')
+    mean_gap = mean(targets, root_lo)[0] - mean(paid, top)[1]
+    require(mean_gap >= d, 'critical mean gap')
+
+    def forward(h, t):
+        x, y = moment(h, t+s), moment(h, t)
+        return x[0]/y[1], x[1]/y[0]
+
+    # The derivative of log(M_h(t+s)/M_h(t)) is mu_h(t+s)-mu_h(t)
+    # and is nonnegative, because a tilted mean has variance derivative.
+    ordering = forward(targets, root_lo)[0] - forward(paid, top)[1]
+    require(ordering >= 0, 'critical forward ordering')
+    actual_u = power(M, -s)[1]*forward(targets, top)[1]**a*forward(paid, top)[1]**b
+    actual_v = power(M, lam)[1]*(moment(targets, top-lam)[1]/moment(paid, root_lo)[0])**(a+b)
+    actual_q = moment(targets, top)[1]/moment(paid, root_lo)[0]
+    require(actual_u <= U, 'critical mixed tail')
+    require(actual_v <= V, 'critical root tail')
+    require(actual_q <= Q, 'critical moment ratio')
+    eta = root_lo*power(m, root_lo-1)[0]
+    require(0 <= beta < eta < 1, 'critical mirror capacity')
+    points = sorted({F(0), *(F(1, k) for k in targets),
+                     *(F(1, r) for r in paid)})
+    mirror_upper = F(0)
+    for left, right in zip(points, points[1:]):
+        sources, exits = mirror_sides(targets, paid, (left+right)/2)
+        numerator, denominator = moment(exits, top)[1], moment(sources, root_lo)[0]
+        require(numerator <= beta*denominator, 'critical mirror window')
+        if exits:
+            mirror_upper = max(mirror_upper, numerator/denominator)
+
+    def log(n):
+        return tuple(F(x, GRID) for x in logarithm(n))
+
+    logn0_lo = log(m)[0] + ell*log(M)[0]
+    tau_upper = root_hi + p/(c+logn0_lo)
+    require(tau_upper <= top, 'critical tangent cover')
+    denominator = c + log(m)[1] + (ell+1)*log(M)[1] + log(2)[1]
+    K = d*p*(a*ell+1)/denominator
+    lower = (1-U**ell)*(F(exponential(K)[0], GRID)-1)-Q*power(M, lam)[1]*V**ell
+    required = (1-eta)/(eta-beta)
+    require(lower >= required, 'critical recurrence funding')
+    return {'parameters': witness,
+            'uniform_interval': [str(root_lo), str(top)],
+            'uniform_mean_gap_lower': display((mean_gap, mean_gap))[0],
+            'forward_ordering_margin_lower': display((ordering, ordering))[0],
+            'mixed_tail_upper': display((actual_u, actual_u))[1],
+            'root_tail_upper': display((actual_v, actual_v))[1],
+            'moment_ratio_upper': display((actual_q, actual_q))[1],
+            'mirror_upper': display((mirror_upper, mirror_upper))[1],
+            'source_capacity_lower': display((eta, eta))[0],
+            'tangent_exponent_upper': display((tau_upper, tau_upper))[1],
+            'funding_lower': display((lower, lower))[0],
+            'required_funding_upper': display((required, required))[1],
+            'ordinary_base_cutoff': str(m)+'*'+str(M)+'^'+str(ell),
+            'normalization': 'A=n0^(1-theta)/(c+log(n0))^p, where theta is the isolated root',
+            'conclusion': 'L(n)<=A*n^theta*(c+log(n))^p for every integer n>=1, under the stated contracts.',
+            'scope': 'Critical-exponent leaf-count majorant; no new outer endpoint or physical admission.'}
+
+
+def run(root):
+    root = Path(root)
+    sources = {}
+    for path, digest in PINS.items():
+        raw = (root/path).read_bytes()
+        require(sha256(raw).hexdigest() == digest, 'source bytes: '+path)
+        sources[path] = json.loads(raw)
+    p7 = sources['research/higher-moment-strictification/RESULT.json']['invoice_oracle']
+    p16 = sources['research/compact-joint-compiler/arithmetic/RESULT.json']
+    native = sources['research/joint-helper-lattice/RESULT.json']
+    require(all(p16[k] == native[k] for k in ('targets', 'paid')),
+            'p16 consumer/native inventory equality')
+    cases = [('p7', p7, F('0.997313'), F('0.997314'), F('0.321'), F(1)),
+             ('p16', p16, F('0.996979'), F('0.996980'), F('0.564'), F(1))]
+    results, rejected = {}, {}
+    original = {row['name']: row['witness'] for row in
+                sources['research/rank-convergence/BENCHMARKS.json']['cases']}
+    for name, profile, lo, hi, beta, gap in cases:
+        results[name] = certify(profile, lo, hi, beta, gap)
+        mutations = {
+            'no crossing': (F('0.998'), F('0.999'), beta, gap),
+            'unfunded mirror': (lo, hi, F(0), gap),
+            'false derivative': (lo, hi, beta, F(100)),
+        }
+        for label, args in mutations.items():
+            try:
+                certify(profile, *args)
+            except ValueError as error:
+                expected = {'no crossing': 'root sign crossing',
+                            'unfunded mirror': 'uniform mirror inequality',
+                            'false derivative': 'positive crossing derivative'}[label]
+                require(str(error) == expected, 'unexpected control rejection')
+                rejected[name+': '+label] = str(error)
+            else:
+                raise ValueError('accepted root-application mutation: '+label)
+        # Retain the predecessor's actual geometry, tails, logarithmic power,
+        # concavity constant, cutoff, and U/V/Q/d guards. The root replaces its
+        # strict base exponent; cover endpoints and the p7 beta are explicit.
+        previous = original[name]
+        witness = {key: previous[key] for key in
+                   ('a', 'b', 'height_base', 'ell0', 's', 'lambda', 'p', 'c')}
+        witness['guards'] = {key: previous['guards'][key]
+                             for key in ('U', 'V', 'Q', 'd', 'beta')}
+        witness['upper_exponent'] = '.997483' if name == 'p7' else '.997067'
+        if name == 'p7':
+            witness['guards']['beta'] = '.322'
+        results[name]['critical_majorant'] = critical_guards(profile, lo, hi, witness)
+        defects = {
+            'concavity': ('c', '1', 'critical concavity'),
+            'tangent cover': ('ell0', 1, 'critical tangent cover'),
+            'underfunded logarithm': ('p', str(F(witness['p'])/100), 'critical recurrence funding'),
+        }
+        for label, (key, value, expected) in defects.items():
+            bad = dict(witness, **{key: value})
+            try:
+                critical_guards(profile, lo, hi, bad)
+            except ValueError as error:
+                require(str(error) == expected, 'unexpected critical-guard rejection')
+                rejected[name+': '+label] = str(error)
+            else:
+                raise ValueError('accepted critical-guard mutation: '+label)
+    return {'source_sha256': PINS, 'applications': results,
+            'arithmetic_controls': arithmetic_controls(), 'rejected_controls': rejected,
+            'arithmetic': 'Separate exact 128-bit outward log/exp intervals; no producer execution.'}
+
+
+if __name__ == '__main__':
+    print(json.dumps(run(Path(__file__).resolve().parents[2]), sort_keys=True, indent=2))
diff --git a/research/native-kappa-30201655/exp_table.py b/research/native-kappa-30201655/exp_table.py
new file mode 100644
index 0000000000..f4207d62c1
--- /dev/null
+++ b/research/native-kappa-30201655/exp_table.py
@@ -0,0 +1,80 @@
+"""Paid signed exponential tables: bounded-word executable model, Apache-2.0.
+Dugongue with substantial OpenAI Codex assistance.
+Decimal is used only by check() as an independent reference.
+"""
+from decimal import Decimal,localcontext
+from math import factorial
+import json
+
+
+def need(ok,why):
+    if not ok:raise ValueError(why)
+
+
+class ExpTable:
+    def __init__(self,n,c=2,C=2):
+        need(n>=1 and 1<=c<=8 and 1<=C<=8,'fixed template domain')
+        self.ell=(n+2).bit_length();self.p=c*self.ell;self.C=C
+        self.hbits=self.ell//4
+        self.J=C*self.ell*(1<<self.hbits)
+        self.degree=8*(c+4*C+64)+1
+        self.P=self.p+4*C*self.ell+(self.J+1).bit_length()+self.degree.bit_length()+32
+        self.S=1<<self.P;self.width=2*self.P+32
+        self.limit=1<<self.width;self.operations=0;self.maximum_bits=0
+        h=self.S>>self.hbits
+        self.q=max(0,self.poly(h)-self.degree-2)
+        self.rows=[self.S]
+        for _ in range(self.J):
+            self.rows.append(self.val(self.val(self.rows[-1]*self.q)//self.S))
+        self.setup_operations=self.operations
+
+    def val(self,x):
+        need(abs(x)<self.limit,'word overflow')
+        self.operations+=1;self.maximum_bits=max(self.maximum_bits,abs(x).bit_length());return x
+
+    def poly(self,x):
+        term=self.S;out=self.S
+        for k in range(1,self.degree+1):
+            term=self.val(self.val(term*x)//self.val(self.S*k))
+            out=self.val(out-term if k&1 else out+term)
+        return out
+
+    def query(self,argument,fraction_bits):
+        need(0<=fraction_bits<=self.P,'argument precision')
+        x=self.val(abs(argument)<<(self.P-fraction_bits))
+        need(x<=self.C*self.ell*self.S,'argument range')
+        index=x>>(self.P-self.hbits)
+        residual=self.val(x-(index<<(self.P-self.hbits)))
+        value=self.val(self.val(self.rows[index]*self.poly(residual))//self.S)
+        if argument>0:
+            need(value>0,'reciprocal positivity')
+            value=self.val(self.val(self.S*self.S)//value)
+        shift=self.P-self.p
+        return self.val((value+(1<<(shift-1)))>>shift)
+
+
+def check():
+    cases=queries=0;peak=0
+    for n in (1,15,255,4095):
+        for c,C in ((1,1),(2,2),(4,1)):
+            tab=ExpTable(n,c,C)
+            need((1<<tab.P)<=factorial(tab.degree+1)*(1<<(tab.hbits*(tab.degree+1))),
+                 'independent symbolic Taylor tail control')
+            bound=tab.C*tab.ell
+            for num in (-16*bound,-13,0,7,16*bound):
+                got=tab.query(num,4)
+                with localcontext() as ctx:
+                    ctx.prec=100
+                    exact=(Decimal(num)/16).exp()
+                    need(abs(Decimal(got)/(Decimal(2)**tab.p)-exact)<Decimal(2)**(-tab.p),'signed exponential error')
+                queries+=1
+            peak=max(peak,tab.maximum_bits);cases+=1
+    try:ExpTable(15).query(10000,0)
+    except ValueError:pass
+    else:raise ValueError('out-of-range argument accepted')
+    return dict(status='PASS',prepared_tables=cases,signed_queries=queries,
+                maximum_bits=peak,out_of_range_control=True,
+                scope='bounded-word signed exp tables; Decimal reference is check-only')
+
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/limb_setup.py b/research/native-kappa-30201655/limb_setup.py
new file mode 100644
index 0000000000..aba309c941
--- /dev/null
+++ b/research/native-kappa-30201655/limb_setup.py
@@ -0,0 +1,113 @@
+"""Native limb arithmetic for paid offline setup; Apache-2.0.
+Dugongue with substantial OpenAI Codex assistance.
+Runtime routines use bounded 15-bit limbs and <=32-bit arithmetic only.
+Python whole integers appear only in conversions and independent check().
+"""
+from random import Random
+import json
+
+BITS=15;BASE=1<<BITS;MASK=BASE-1
+
+
+def need(ok,why):
+    if not ok:raise ValueError(why)
+
+
+def norm(a):
+    a=list(a)
+    need(all(type(x) is int and 0<=x<BASE for x in a),'limb range')
+    while a and a[-1]==0:a.pop()
+    return a
+
+
+def compare(a,b):
+    a=norm(a);b=norm(b)
+    if len(a)!=len(b):return 1 if len(a)>len(b) else -1
+    for x,y in zip(reversed(a),reversed(b)):
+        if x!=y:return 1 if x>y else -1
+    return 0
+
+
+def add(a,b):
+    a=norm(a);b=norm(b);out=[];carry=0
+    for i in range(max(len(a),len(b))):
+        t=(a[i] if i<len(a) else 0)+(b[i] if i<len(b) else 0)+carry
+        need(t<1<<32,'word bound');out.append(t&MASK);carry=t>>BITS
+    if carry:out.append(carry)
+    return norm(out)
+
+
+def subtract(a,b):
+    need(compare(a,b)>=0,'negative limb subtraction');out=[];borrow=0
+    for i,x in enumerate(a):
+        t=x-(b[i] if i<len(b) else 0)-borrow
+        borrow=1 if t<0 else 0;out.append(t+BASE if borrow else t)
+    need(borrow==0,'undrained borrow');return norm(out)
+
+
+def multiply(a,b):
+    a=norm(a);b=norm(b);out=[0]*(len(a)+len(b)+1)
+    for i,x in enumerate(a):
+        carry=0
+        for j,y in enumerate(b):
+            t=out[i+j]+x*y+carry
+            need(t<1<<32,'raw limb product bound')
+            out[i+j]=t&MASK;carry=t>>BITS
+        k=i+len(b)
+        while carry:
+            t=out[k]+carry;need(t<1<<32,'limb carry bound')
+            out[k]=t&MASK;carry=t>>BITS;k+=1
+    return norm(out)
+
+
+def shift_bit(a,bit):
+    need(bit in (0,1),'bit input');out=[];carry=bit
+    for x in a:
+        t=(x<<1)+carry;need(t<1<<32,'shift bound')
+        out.append(t&MASK);carry=t>>BITS
+    if carry:out.append(carry)
+    return norm(out)
+
+
+def divide(a,b):
+    a=norm(a);b=norm(b);need(b,'zero divisor')
+    q=[];r=[]
+    for limb in reversed(a):
+        for bit in range(BITS-1,-1,-1):
+            r=shift_bit(r,(limb>>bit)&1);q=shift_bit(q,0)
+            if compare(r,b)>=0:
+                r=subtract(r,b)
+                if q:q[0]|=1
+                else:q=[1]
+    return norm(q),norm(r)
+
+
+def encode(x):
+    need(x>=0,'nonnegative test integer');out=[]
+    while x:out.append(x&MASK);x>>=BITS
+    return out
+
+
+def decode(a):
+    return sum(x<<(BITS*i) for i,x in enumerate(a))
+
+
+def check():
+    rng=Random(20261022);cases=0
+    for size in (1,15,31,64,129,257,513):
+        for _ in range(6):
+            x=rng.getrandbits(size);y=rng.getrandbits(max(1,size-3)) or 1
+            a=encode(x);b=encode(y)
+            need(decode(add(a,b))==x+y,'limb addition reference')
+            need(decode(multiply(a,b))==x*y,'limb multiplication reference')
+            q,r=divide(a,b);need((decode(q),decode(r))==divmod(x,y),'long-division reference')
+            if x>=y:need(decode(subtract(a,b))==x-y,'limb subtraction reference')
+            cases+=1
+    try:divide([1],[])
+    except ValueError:pass
+    else:raise ValueError('zero denominator accepted')
+    return dict(status='PASS',arithmetic_cases=cases,limb_bits=BITS,maximum_allowed_raw_bits=32,
+                zero_denominator_control=True,scope='explicit polynomial-cost multiword setup arithmetic, not unit-cost unbounded integers')
+
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/majorant-benchmarks.json b/research/native-kappa-30201655/majorant-benchmarks.json
new file mode 100644
index 0000000000..bc58c96abd
--- /dev/null
+++ b/research/native-kappa-30201655/majorant-benchmarks.json
@@ -0,0 +1,164 @@
+{
+  "schema_version": 1,
+  "cases": [
+    {
+      "name": "p7",
+      "source": "research/higher-moment-strictification/RESULT.json",
+      "profile_key": "invoice_oracle",
+      "consumer_key": [
+        "outer",
+        "ledger"
+      ],
+      "witness": {
+        "a": 1,
+        "b": 1,
+        "lambda": "1/10",
+        "mirror_slices": 20,
+        "t0": ".99731352",
+        "t_upper": ".997481",
+        "p": "1/10",
+        "c": "38",
+        "s": "1/10",
+        "height_base": 256,
+        "ell0": 100,
+        "guards": {
+          "U": ".961",
+          "V": ".903",
+          "Q": "1.001",
+          "d": "1.72",
+          "beta": ".321",
+          "eta": ".9845"
+        },
+        "uniform_saving": "376107/140000000",
+        "kappa": ".00268647",
+        "H": 3040000000
+      },
+      "baseline": {
+        "source": "research/net-tax-rank-compiler/RESULT.json",
+        "path": [
+          "examples",
+          "p7-net-shift-same-C",
+          "uniform"
+        ]
+      }
+    },
+    {
+      "name": "native4453",
+      "source": "research/native-lattice-retiming/RESULT.json",
+      "profile_key": null,
+      "consumer_key": [
+        "outer"
+      ],
+      "witness": {
+        "a": 1,
+        "b": 1,
+        "lambda": "1/10",
+        "mirror_slices": 20,
+        "t0": "29909963/30000000",
+        "t_upper": ".9971362",
+        "p": "2/5",
+        "c": "134",
+        "s": "1/20",
+        "height_base": 1024,
+        "ell0": 400,
+        "guards": {
+          "U": ".968",
+          "V": ".984",
+          "Q": "1.001",
+          "d": "1.02",
+          "beta": ".575",
+          "eta": ".982"
+        },
+        "uniform_saving": "525213/175000000",
+        "kappa": ".00300120",
+        "H": 1300000000
+      },
+      "baseline": {
+        "source": "research/net-tax-rank-compiler/RESULT.json",
+        "path": [
+          "examples",
+          "native-concentrated-balanced",
+          "uniform"
+        ]
+      }
+    },
+    {
+      "name": "native4453-matched-uniform",
+      "source": "research/native-lattice-retiming/RESULT.json",
+      "profile_key": null,
+      "consumer_key": [
+        "outer"
+      ],
+      "witness": {
+        "a": 1,
+        "b": 1,
+        "lambda": "1/10",
+        "mirror_slices": 20,
+        "t0": "29909963/30000000",
+        "t_upper": ".9971362",
+        "p": "2/5",
+        "c": "134",
+        "s": "1/20",
+        "height_base": 1024,
+        "ell0": 400,
+        "guards": {
+          "U": ".968",
+          "V": ".984",
+          "Q": "1.001",
+          "d": "1.02",
+          "beta": ".575",
+          "eta": ".982"
+        },
+        "uniform_saving": "105043/35000000",
+        "kappa": ".00300120",
+        "H": 4300000000
+      },
+      "baseline": {
+        "source": "research/net-tax-rank-compiler/RESULT.json",
+        "path": [
+          "examples",
+          "native-concentrated-balanced",
+          "uniform"
+        ]
+      }
+    },
+    {
+      "name": "p16",
+      "source": "research/compact-joint-compiler/arithmetic/RESULT.json",
+      "profile_key": null,
+      "consumer_key": [
+        "outer"
+      ],
+      "witness": {
+        "a": 1,
+        "b": 1,
+        "lambda": "1/10",
+        "mirror_slices": 20,
+        "t0": ".99697984",
+        "t_upper": ".997066",
+        "p": "2/5",
+        "c": "133",
+        "s": "1/20",
+        "height_base": 1024,
+        "ell0": 650,
+        "guards": {
+          "U": ".963",
+          "V": ".992",
+          "Q": "1.001",
+          "d": "1.03",
+          "beta": ".564",
+          "eta": ".982"
+        },
+        "uniform_saving": "471898442219/156250001562500",
+        "kappa": ".00302015",
+        "H": 2800000000
+      },
+      "baseline": {
+        "source": "research/compact-joint-compiler/arithmetic/RESULT.json",
+        "path": [
+          "compiler"
+        ]
+      }
+    }
+  ]
+}
diff --git a/research/native-kappa-30201655/modern-sources/BILATERAL-LDU.md b/research/native-kappa-30201655/modern-sources/BILATERAL-LDU.md
new file mode 100644
index 0000000000..5cad6ee19f
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/BILATERAL-LDU.md
@@ -0,0 +1,131 @@
+# Bilateral Gaussian LDU and a fixed-width periodic inverse bound
+
+Independent audit of the parent's infinite-LDU observation. This is an analytic norm theorem. It does **not** assert that the bilateral factors already have a fully priced fast implementation.
+
+## Statement
+
+Let `1<rho=t/s<=2`, `theta=rho-1`, `q_i=floor(rho*i+1/2)` for all integers i, and `beta_i=rho*i-q_i`. For any `a>=1`, define on Z
+
+`G_ij=exp(-a[(rho*j-q_i)^2-beta_j^2])`.
+
+Let `r=exp(2a rho)` and `c=prod_(m>=1)(1-r^-m)>0`. Then G has an exact factorization on bounded bilateral sequences
+
+`G=L C U`,
+
+where L is unit lower triangular, U is unit upper triangular, C is diagonal, and all factors and their inverses are bounded. Moreover all six factors are invariant under simultaneous index translation by s. Their periodizations therefore factor the periodic Gaussian matrix N, and
+
+`||N^-1||_infinity <= c^-4 exp(a/2)/(1-exp(-a rho theta))^2`.
+
+In particular, at the fixed choice `a=1`,
+
+`||N^-1||_infinity < 16 theta^-2`.
+
+Any fixed a>=1, including a=4pi if an integer alpha>=2 is retained, gives a constant times theta^-2. No lower bound proportional to log(1/theta) on a is needed for this norm theorem.
+
+## 1. Finite-origin factorization and the shift correction
+
+Write `x_i=r^q_i`, `d_i=exp(-a q_i^2)`, and `e_i=exp(-a rho^2 i^2+a beta_i^2)`. Then `G_ij=d_i x_i^j e_j`, including negative indices, and `d_i x_i^i e_i=1`.
+
+For a finite square principal interval `[l,r0]`, the Vandermonde powers must begin at zero. The correct shifted row diagonal is **d_i x_i^l**, and the power is `j-l`. This removes a possible erroneous origin-dependent diagonal from the upper factor.
+
+Put
+
+`C_i(l)=prod_(l<=k<i)(1-x_k/x_i)`.
+
+Finite Newton elimination gives the pivot `C_i(l)` and
+
+`L^l_ij=G_ij prod_(l<=k<j)(1-x_k/x_i)/C_j(l)`, `i>=j`,
+
+`U^l_ij=(e_j/e_i) h_(j-i)(x_l,...,x_i)`, `j>=i`.
+
+Here h is the complete symmetric polynomial, h_0=1. Upper and lower inverses are
+
+`(U^l)^-1_ij=(-1)^(j-i)(e_j/e_i) e_(j-i)(x_l,...,x_(j-1))`,
+
+`(L^l)^-1_ij=(-1)^(i-j) exp(E_ij) C_i(l)/(C_j(l) D_ij)`,
+
+where
+
+`D_ij=prod_(j<k<=i)(1-x_j/x_k)`,
+
+`E_ij=a[-beta_i^2+beta_j^2-rho^2(i-j)+2rho sum_(j<k<=i)beta_k]`.
+
+These formulas are independent of the right endpoint whenever their indices exist.
+
+## 2. Uniform bounds before taking limits
+
+Because each q-gap is at least 1,
+
+`c<=C_i(l),D_ij<=1`.
+
+The normalized complete symmetric polynomial satisfies
+
+`h_h(x_l,...,x_i)/x_i^h <= c^-1`.
+
+Indeed, its generating function after division by x_i^h has variables 1 and a subset bounded by r^-1,r^-2,...; coefficient h is bounded by the sum of all coefficients of the remaining product, which is at most c^-1. Consequently
+
+`0<=L^l_ij<=c^-1 G_ij`, `0<=U^l_ij<=c^-1 G_ij`.
+
+For the elementary polynomial, compare each h-subset of the prefix with its h largest nodes. The deficits form a partition and give
+
+`e_h(x_l,...,x_(j-1))/prod_(j-h<=k<j)x_k <= c^-1`.
+
+The two inverse bounds are therefore
+
+`|(L^l)^-1_ij|<=c^-2 exp(a/4) exp(-a rho theta(i-j))`, `i>=j`,
+
+`|(U^l)^-1_ij|<=c^-1 exp(a/4) exp(-a rho theta(j-i))`, `j>=i`.
+
+Both use only `-1/2<=beta_k<1/2`. Thus their row norms are at most the corresponding constants divided by `1-exp(-a rho theta)`, uniformly in l and the finite size.
+
+The row sum of G is uniformly finite, since
+
+`G_i,i+h <= exp(a/4) exp(-a(rho*|h|-1/2)^2)`.
+
+The same positive Gaussian bound controls all finite-origin L and U factors.
+
+## 3. Letting the left origin tend to minus infinity
+
+For fixed i,j, C_i(l) converges to
+
+`C_i=prod_(k<i)(1-x_k/x_i)` in `[c,1]`.
+
+The lower products converge absolutely. The upper homogeneous and elementary polynomials converge because `sum_(k<=i)x_k` is finite; the estimates above remain valid. Define L,U,Linv,Uinv by these limits.
+
+For each fixed i,j, the finite-origin identity for G is a sum over `l<=k<=min(i,j)`. Every summand is bounded by `c^-2 G_ik G_kj`. That bilateral Gaussian product is summable in k, so dominated convergence gives `G=L C U` entrywise.
+
+For two lower triangular matrices, a fixed product entry has only the finitely many intermediate indices between its column and row. Therefore the finite-origin identities `(L^l)^-1 L^l=L^l(L^l)^-1=I` pass directly to the limit. The upper-triangular identities work the same way. All four matrices have uniformly bounded row sums, so these entrywise products are also bounded-operator identities on l-infinity; absolute convergence justifies applying them to every bounded input.
+
+This argument does not require operator-norm convergence of the finite sections. Such convergence is not asserted.
+
+## 4. Periodization is a bounded algebra homomorphism
+
+Since `q_(i+s)=q_i+t` and `beta_(i+s)=beta_i`, G is invariant under simultaneous translation `(i,j)->(i+s,j+s)`. Every displayed factor has the same invariance: ratios `x_k/x_i` are preserved, and the Gaussian/prefix expressions shift together. C_i is s-periodic.
+
+For an invariant matrix A with bounded absolute row sums, set
+
+`Pi(A)_ij=sum_(n in Z) A_(i,j+ns)`, `0<=i,j<s`.
+
+Then `||Pi(A)||<=||A||`. If A and B are two such matrices, absolute row summability permits rearrangement after writing each intermediate index as `k=l+ms`. Simultaneous invariance yields
+
+`Pi(AB)=Pi(A) Pi(B)`.
+
+Thus `N=Pi(G)=Pi(L) Pi(C) Pi(U)`, and its inverse is
+
+`N^-1=Pi(Uinv) Pi(C^-1) Pi(Linv)`.
+
+The diagonal periodization Pi(C) is simply diag(C_0,...,C_(s-1)). Multiplying the established norm bounds proves
+
+`||N^-1||<=c^-4 exp(a/2)/(1-exp(-a rho theta))^2`.
+
+For a=1, r>=e^2>7, and the elementary product bound gives `c>=1-sum_(m>=1)r^-m>5/6`. Also `1-exp(-rho theta)>=theta/2` for 0<theta<=1. Hence the displayed bound is below `4(6/5)^4 exp(1/2) theta^-2<16 theta^-2`.
+
+## Algorithmic boundary
+
+This removes Woodbury from the *analytic factorization*. A direct implementation could still choose Woodbury for convenience. The identity for a Woodbury audit is: if `N=N0+UV`, then with `S=I+V N0^-1 U`,
+
+`S^-1=I-V N^-1 U`.
+
+The inverse on the right is that of the updated N, not the base N0. The fixed-a bound above may be used analytically to bound that right-hand side even before an algorithm for N inverse is available.
+
+A fast upper-factor algorithm and the precision/layout needed to tensorize it remain separate obligations. No multiplication exponent follows just from this theorem.
diff --git a/research/native-kappa-30201655/modern-sources/CAPPED-INTERIORS.md b/research/native-kappa-30201655/modern-sources/CAPPED-INTERIORS.md
new file mode 100644
index 0000000000..62c3fa27b6
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/CAPPED-INTERIORS.md
@@ -0,0 +1,72 @@
+# Conditional refinement: cap interior length independently of d
+
+This is a separate follow-up to the uncapped proof audit. Its current status is **PASS_CONDITIONAL_PHASE_FUSION_REVIEW**, following the independent capped-gauge and capped-layout audits and an integrated root review. It preserves the weaker `OUTER-ARITHMETIC.json` as history. Under the retained supplier assumptions and the reviewed interfaces, the capped construction below gives `kappa=0.001672922349588871`. The only new analytic change is the anchored O(aB) local gauge; all altered operation counts are derived explicitly here. No upstream selected certificate is changed.
+
+Let the original phase-cell scale remain `d=p^epsilon`, and cap dyadic interior lengths at `B=2^floor(b log2 p)`, where `1/2<b<epsilon`. Continue to use the actual logarithmic alpha and maximum physical bandwidth `W=O(sqrt(p) polylog p)`.
+
+Inside a phase cell of length O(d), reserve W endpoints. Repeatedly take a B-point interior followed by a W-point separator while this fits. Apply the already proved dyadic-tail carving to the remaining interval. There are O(d/B) full interiors, at most O(log B) tail interiors, and at most
+
+`O(W(d/B+log B))`
+
+boundary coordinates per original cell. Every interior is separated from the next by at least W coordinates. Thus the boundary density is `O((W/B) polylog p)`, the inherited Schur half-bandwidth stays O(W), and all blocks remain principal restrictions of the same globally rounded matrix. The original physical period cut remains a boundary.
+
+The larger gauge in the uncapped proof can be replaced by a gauge local to each **capped block**. For the narrow matrix, use the exact diagonal ratios `ahat_j/ahat_m` with m an interior anchor. This does not change `diag(ahat) Ghat diag(ahat)^-1`. Within one original phase cell,
+
+`log a_j=-a(1/4-beta_j^2)/theta`, `beta_(j+1)-beta_j=theta`,
+
+so successive logarithmic differences have magnitude at most O(a). Therefore the range on a B-point block is O(aB). The global downward rounding changes this by O(1) once its retained Cp-bit precision dominates the original O(ad)=o(p) absolute logarithmic range. One must form the anchored ratio, not numerically multiply by the old full-cell gauge and later cancel it.
+
+For the broad forward block, choose the anchor m within that capped block in the exact formula of `FORWARD-SMALL-A-AUDIT.md`. Then `|delta|<=1/2`, and its diagonal logarithms vary by
+
+`O((B+B^2/d)/alpha^2)=O(B/alpha^2)`
+
+because B<=d. Its Toeplitz SPD condition and completed finite-block inverse bound are unchanged. Thus O(aB) is a common conservative gauge bound for both directions.
+
+All capped block circuits in one L-point local axis run as a direct sum, so their count does not multiply the polylogarithmic depth. Coefficient tables remain polynomial in p per local group/coarse block. The tensor compiler now permits
+
+`g=p^beta`, `beta=1-b-r-zeta`.
+
+The guard `g*a*B=o(p)` follows from r+zeta>0. The supplier support proof needs each individual K-neighborhood to fit its original axis and total moved support o(p); it does **not** require all g controls to fit within one original axis. The sufficient auxiliary inequality `beta<1-epsilon` in the uncapped ledger must therefore be removed in this follow-up.
+
+The changed principal exponents, normalized by V, are
+
+| Component | exponent |
+|---|---:|
+| main transform | `1-epsilon*q` |
+| fused Gaussian circuits | `epsilon-q*beta` |
+| boundary algebra | `epsilon-b+(omega-1)/2` |
+| sparse union movement | `epsilon+beta+1/2-b` |
+| grouped scans | `epsilon-beta` |
+
+For the boundary row, one axis has O(V W/B) boundary records. A band solve or coupling product on W simultaneous right-hand sides costs O(W^(omega-2)) per boundary record, so all d axes cost `O(V (d/B) W^(omega-1) polylog p)`. The new factor d/B must not be omitted. For the sparse union, its fraction within a group is O(gW/B polylog p); g sequential axis operations and d/g groups give `O(V (dg/B) W polylog p)`. These are precisely the third and fourth changed rows.
+
+All other costs in `OUTER-AUDIT.md` remain paid. Global routing has saving a_eff; packed polynomial products have saving epsilon. Even a conservative full active-group key surcharge adds only `beta+1-epsilon` to the union exponent. Sparse core-face corrections have exponent at most `epsilon+beta-3`, using the former p² per-record allowance on their O(gA/L) copied volume.
+
+With the rational bound omega<45/16, put c=(3-omega_upper)/2=3/32 and take a positive boundary slack s_boundary=10^-5. Balancing the two dominant rows while leaving that boundary slack gives
+
+```
+epsilon=(1+q+q*(c-s_boundary-r-zeta))/(1+q)^2,
+b=epsilon*(1+q)-c+s_boundary,
+beta=1-b-r-zeta,
+kappa_limit=epsilon*q.
+```
+
+Using the same q, r and zeta as the uncapped candidate yields approximately
+
+```
+epsilon = 0.9984838711085557536432677624420451614...
+b       = 0.9064167934681446247757331487619919695...
+beta    = 0.0935821965318553752242668512380080305...
+kappa_limit = 0.0016729223595888711324653863199468081...
+kappa       = 0.001672922349588871
+```
+
+The boundary saving equals `kappa_limit+10^-5`. The union movement exponent is below 0.686, and even its optional full-key surcharge leaves it below 0.781. The per-record phase metadata exponent `beta+2(1-epsilon)` is below 0.097, so calculating all g membership predicates remains cheaper than scanning one p-bit record. Core-face repair costs remain negligible at L=p^8.
+
+The common compiled H calls are still made globally across complete coarse-label ranges. Each selected bit needs only its own K=128G neighborhood to fit its original axis. Since `1-epsilon>0`, this holds eventually even though gK is larger than one axis width. The total support is O(g polylog p)=o(p), because beta<1. All support-router reservoirs, product row stock and exact endpoint restoration are those of the independently audited supplier.
+
+At the displayed parameters, `b>1/2`, `epsilon>b`, `beta>0`, `epsilon>beta`, `1-b-r-beta=zeta>0`, and `1-epsilon-r>0`. These respectively pay the wide-band separation, cap below original cell scale, growing group payload, number of groups, compiled local-gauge precision, and global gamma/rounding range. The raw global rounded weights may still have O(ad) logarithmic range during offline generation. The **data** only sees exact anchored ratios of range O(aB); approximating those ratios to the retained precision introduces `exp(o(p))` error amplification, already paid by the strict group guard.
+
+The assembled group endpoints are the same full normalized Haug inverse or Saug/4 operators as in the uncapped proof. Changing the interior partition changes only their factorization. It does not change their completed contraction bounds, intended zero-hole semantics, principal-core locality, or the final `2^D` scale compensation. Consequently the uncapped precision and error argument applies with the improved group gauge budget.
+
+`check_capped_outer.py` computes 44 exact positive slacks, every displayed cost margin, and five rejecting controls. The full-cell-gauge control is especially relevant: it fails, so the stronger result depends on the independently reviewed anchored-gauge proof. The local review retains the original supplier and all-size conditional assumptions.
diff --git a/research/native-kappa-30201655/modern-sources/FINE-PADDING-COMPOSITION.md b/research/native-kappa-30201655/modern-sources/FINE-PADDING-COMPOSITION.md
new file mode 100644
index 0000000000..41efb17c1e
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/FINE-PADDING-COMPOSITION.md
@@ -0,0 +1,51 @@
+# Fine source-prime padding on this package's stack, and epsilon -> 1
+
+**Credit first.** The mechanism of this note is **PR1786 (chafreaky, Chafik Boukhalfa)**: source primes at relative gap Theta(p^-2) from their dyadic targets, which exist by **Tim Trudgian's** effective prime number theorem (arXiv:1401.2689v2, theorem 2), the resulting setup precision `Cp + 64 p^2 ceil(log2 p)`, the theta-dependent conditioning, the polynomial halo p^48 / core p^128 and the dyadic normalizers. Its full text is vendored verbatim in `vendor/pr1786/FINE-PRIME-PADDING.md` and is the proof of every statement about primes, precision, locality and normalization used here. It builds on Vlado Vojdanovski's PR1673 (capped phase-cell fusion), the fractional-shift interiors and per-visit tag accounting of PR1758 (`outer/GAUGEFREE-INTERIORS.md`), the radix-distributed union schedule (`outer/UNION-SCHEDULE.md`), Jeremy Kothe's PR1731 ledger lineage and the PR1699/PR1672 supplier. **New in this package** (only): (a) the observation that epsilon is a free parameter and the resulting exact point epsilon = 1 - 1.0009765625e-60080; (b) the composition analysis below; (c) the exact ledger and independent derivation at that point.
+
+## 1. What is used from where
+
+| ingredient | source | role at epsilon -> 1 |
+|---|---|---|
+| fine primes, theta in (1/(4p^2), 1/(2p^2-1)] | PR1786 sec. 1-2 | chirp range a theta B^2 = O(a B^2/p^2): guard beta + 2 xi - 2 < 1 |
+| setup precision, locality, normalizers | PR1786 sec. 3-5 | halo 48 / core 128; online precision stays O(p) |
+| fractional-shift interiors, accretive circuit lemma | PR1758 (outer/GAUGEFREE-INTERIORS.md) | removes the linear gauge; **still required**: the old linear guard beta + xi <= 1 is violated at beta ~ 1, xi = 0.908 (ledger control `old_linear_guard`) |
+| radix-distributed union schedule, per-visit tag work | outer/UNION-SCHEDULE.md | **still required**: the old g-factor union row 1 - eps - beta - 1/2 + xi is negative (control `old_g_factor_union_row`) and 2 beta < 1 fails (control `old_union_tag_2beta`) |
+| boundary | explicit Strassen, tau = 45/16 (7^16 < 2^45), c = 3/32 | **not** the structured boundary of this package series: at xi = 0.908 < eps the boundary row is not binding, so the unproved stability claim of STRUCTURED-BOUNDARY.md is dispensable. Its file is retained as an alternative; it does not enter kappa. |
+
+## 2. epsilon is a free parameter (answer to "what sets epsilon = 0.9999999 in PR1786")
+
+Write delta = 1 - epsilon, beta = 1 - 3 delta, xi = epsilon(1+q) - c + s (boundary saving = main + s), c = 3/32. Every constraint of the ledger that involves epsilon or beta:
+
+* main = epsilon q is the binding saving, kappa = floor(epsilon q) - 1e-60022;
+* Gaussian row: 1 - epsilon + q beta >= epsilon q iff **beta >= 1 - delta(1 + 1/q)** (a window of width ~ 594 delta below 1);
+* membership: 1 - beta - 2(1-epsilon) > 0 iff **beta < 1 - 2 delta**; header / tag per visit: 1 - beta > 0; group below dimension: epsilon - beta > 0;
+* **1 - epsilon - r0 > 0** (`global_gamma_power_slack`, r0 = 1e-60080: the spare power for u <= p^r0) and `source_axis_superpolynomial` 1 - epsilon > 0;
+* boundary / union rows: xi = 0.9079 < epsilon (cap_below_cell), xi - 1/2 > 0, guard 1 - (2 xi - 2) - r0 - beta = 0.184 > 0: independent of delta;
+* core-face corrections epsilon + beta + 48 - 128 + 2 < 0: independent of delta.
+
+The window for beta is non-empty for every delta > 0, and beta = 1 - 3 delta lies in it (the Gaussian row exceeds main by delta(1 - 2q)). The only lower bound on delta is **delta > r0 = 1e-60080**, a free strict slack of the proof. So PR1786's 1e-7 is an explicit interior point, not a limit; its kappa is q - 1.68e-10 only because delta = 1e-7. In this package delta = 1.0009765625e-60080 = (1025/1024) 1e-60080 (the smallest ratio that keeps the gamma spare power 1 - epsilon - r0 = r0/1024 > 0 and puts C - epsilon q below 1/F):
+
+    epsilon = 1 - 1.0009765625e-60080, beta = 1 - 3.0029296875e-60080, xi = 0.90792965478815...,
+    kappa = 0.0016797549561255445213356709939207025769983114385025802954603275201628645...
+
+which is q - 1.68e-60083 (q = b - 1e-60080 = 0.00167975495612554452133567099392070257699831143850258029546032752016286...). Exact sweep (`outer/independent_check.py`): delta in {1e-7, 1e-12, 1e-30, 1e-60, 1.0009765625e-60080, 1.1e-60080 ... } all satisfy every row; delta = r0 is rejected by `global_gamma_power_slack`; beta below the Gaussian window or at the membership edge is rejected (ledger controls `beta_below_gaussian_window`, `beta_above_membership_window`, `epsilon_equals_one`, `epsilon_not_above_r0_slack`).
+
+**Maximum epsilon.** Within this construction epsilon < 1 strictly (epsilon = 1 would mean d = p axes: source axes of O(1) size, `epsilon_equals_one` control; also kappa = epsilon q <= q), and 1 - epsilon > r0. The hard cap on any outer of this form is kappa < q (the supplier's complex saving); the remaining distance is q delta = 1.68e-60083.
+
+## 3. Does composing with the rest of the stack relax anything further? (answer: no, nothing is left to relax)
+
+* The binding rows at this point are main = epsilon q; boundary = main + s and union = main + s + 13/32, all other rows have positive margins >= 1e-60080. Nothing but delta moves kappa.
+* Structured boundary / k5 boundary: boundary row non-binding, no effect on kappa (only on xi, which is free in (1/2, epsilon)). Using c = 1/2 would give xi = 0.5 and the same kappa; it would add the unproved structured-stability claim for nothing.
+* The router row a_eff = (q+b)/2 > epsilon q by 5e-65 + q delta; using the true bit endpoint there would not change kappa (main binds).
+* Therefore kappa = epsilon q - 1e-60022 with epsilon the only free quantity, and it is already within q delta = 1.68e-60083 of the ceiling q.
+
+## 4. Obligations (same as PR1786 sec. 8, with sharper asymptotics)
+
+1. Every "eventually" in vendor/pr1786/FINE-PRIME-PADDING.md is now needed with exponent margin delta = 1.0009765625e-60080 instead of 1e-7: e.g. log x = Theta(p^(1-epsilon)) = p^(1.0009765625e-60080) must dominate log p in the prime-count estimate (true for p beyond an astronomically large cutoff), source axes 2^(p^delta) must exceed every fixed polynomial of p, and the polylog factors of every row are absorbed by p^delta-type slack. This is the same logical status as the 1e-60080 slacks of every row of this package (and of PR1786's 1e-7 version with a smaller cutoff); no practical cutoff is claimed.
+2. Trudgian's theorem is a cited mathematical input (vendor/pr1786); the prime and precision lemmas are PR1786's and need their review (PR1786 is a draft).
+3. The composition with PR1758's accretive circuit lemma uses theta^-1 = O(p^2) in the symbol bound (PR1786 sec. 3); the Gauge-free note's guard is superseded by `beta + 2 xi - 2 < 1` at fine theta.
+4. Fresh native admission of the unchanged supplier: `verify_release.py`.
+
+## 5. Executable support
+
+`outer/check_ledger.py` (exact, 62 strict checks (including improvement over the exact kappas of PR1828, PR1839, PR1875, PR1876 and PR1897), 17 rejecting controls, improvement over PR1786's exact kappa and PR1758), `outer/independent_check.py` (independent balance derivation, the epsilon-free sweep), `outer/check_fine_padding.py` (PR1786's finite prime witnesses, underflow control, power relations), `outer/check_gaugefree.py` (PR1758 identities).
diff --git a/research/native-kappa-30201655/modern-sources/FINE-PRIME-PADDING.md b/research/native-kappa-30201655/modern-sources/FINE-PRIME-PADDING.md
new file mode 100644
index 0000000000..bf9899ee21
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/FINE-PRIME-PADDING.md
@@ -0,0 +1,355 @@
+# Fine prime padding with separate setup and online precision
+
+This extends the capped phase-cell construction of PR1673 and the
+fractional-shift interiors and radix-union schedule of PR1758. The finite
+supplier is the unchanged signed-554 T74 supplier admitted in PR1699.
+The new mechanism is a finer choice of source primes. Its smaller phase
+increment changes the chirp budget, provided coefficient setup is allowed
+more precision than the online records. The boundary uses the retained
+explicit Strassen format; no structured-solver stability claim is needed.
+
+The exact ledger gives conditional
+`kappa=0.001679754788150048`, rounded strictly below the derived saving.
+The conclusion retains the all-size hypotheses listed in section 8 below.
+Finite checks do not prove those hypotheses, the cited prime theorem or the
+complete multiplication theorem. No practical cutoff is claimed.
+
+## 1. A source-prime interval finer than 1/d
+
+Retain the dyadic target box of the assembly construction. Its dimension is
+`d=Theta(p^epsilon)`, `0<epsilon<1`, its target side lengths are r or r/2,
+and `log r=Theta(p/d)=Theta(p^(1-epsilon))`. For integer p set
+
+    eta_p = 1/(4p^2).
+
+Choose distinct primes s_i in
+
+    (1-2 eta_p) t_i < s_i <= (1-eta_p) t_i.
+
+Here is an unconditional replacement for the old source-prime interval
+lemma; it does not require a new prime-gap conjecture. Trudgian, *Updating
+the error term in the prime number theorem*, arXiv:1401.2689v2, theorem 2,
+proves for x>=229 that
+
+    |pi(x)-li(x)| <= 0.2795 x (log x)^(-3/4)
+                         exp(-sqrt(log x/6.455)).
+
+[Primary source, theorem 2](https://arxiv.org/html/1401.2689v2#S2).
+This theorem is a cited mathematical input, not re-proved by the verifier.
+
+Apply it at the two endpoints of the requested interval about x=t_i.
+The logarithmic-integral difference is at least `eta_p x/log x`. The sum
+of the two errors divided by this main term is bounded, for a fixed C, by
+
+    C p^2 (log x)^(1/4) exp(-c sqrt(log x)) -> 0.
+
+Indeed `log x=Theta(p^(1-epsilon))` and epsilon<1 is fixed, so its positive
+power dominates log p. Consequently the interval contains eventually at
+least `x/(8p^2 log x)` primes. This exceeds d, since x is exponential in
+`p^(1-epsilon)` and the denominator and d are polynomial in p. Both target
+sizes satisfy the estimate. Their intervals are disjoint, so all d source
+primes can be made distinct, odd and coprime to their dyadic targets.
+
+The deterministic search used by the assembly still works: scan the
+intervals and test candidates by trial division. Even scanning all O(r)
+candidates with O(sqrt r) divisors and polynomial bit overhead costs
+`O(d r^(3/2) poly(p))`. Its logarithm is `O(log p+p/d)=o(p)`, hence setup
+is `n^o(1)=o(n)`. No unknown threshold is used as a claim of practicality.
+The algorithm can fall back on the retained multiplier for smaller inputs.
+
+Let `rho_i=t_i/s_i=1+theta_i`. The interval gives
+
+    1/(4p^2) < theta_i <= 1/(2p^2-1) <= 1/p^2.
+
+Also `S/T > (1-1/(2p^2))^d >= 1-d/(2p^2) > 1/2` eventually, since
+d<=p. Thus the same capacity bound `T/2<S<T`, permutations, distinct-prime
+packing and source/target side sizes are preserved. The changed lower
+bound on theta is explicit; we do not reuse the old `theta>=1/(4d)`.
+
+## 2. Polynomial conditioning survives the smaller increment
+
+Keep `alpha=ceil(sqrt((4/pi) log(16p)))` and `a=pi alpha^2`. Eventually
+`4 log(16p)<=a<=5 log(16p)` and alpha^2=Theta(log p). The sharp row estimate
+of PR1673, LOG-A-PHASE-SCHUR-AUDIT section 1, is valid for every theta>0:
+
+    ||N-I||_infinity <= exp(-2 a theta)+5 exp(-2a).
+
+For theta>=1/(4p^2), its row gap is at least `1/(8p^2)` eventually; for
+example `1-exp(-2a theta)>=1/(4p^2)` while the second term is O(p^-8).
+Omitting the exponentially small nonzero diagonal aliases and setting the
+diagonal exactly to one preserves a polynomial gap. Exponentially accurate
+band truncation and coefficient rounding preserve half of it. Every principal
+narrow block has the same row gap, and its Schur complements retain that gap.
+
+The broad bound in FORWARD-SMALL-A-AUDIT sections 1-3 already states its
+dependence on theta explicitly:
+
+    ||K^-1|| <= O(alpha^5 rho^2 theta^-2 exp(a rho/3)).
+
+This is polynomial for the new theta. Since rho=1+O(p^-2), the exponential
+factor is at most p^2 eventually, theta^-2<=16p^4, and alpha^5 is
+polylogarithmic. The finite and bilateral LDU entry bounds are geometric
+in index distance and bound both row and column sums. The same estimates
+apply to the finite contiguous sections used by elimination. The augmented
+forward matrix adds identity hole columns and a Gaussian coupling of bounded
+row and column sums. Thus a conservative common eventual bound p^10 covers
+the relevant matrices and their inverse norms, in both induced row/column
+norms and spectral norm. Polynomially small perturbations preserve it with
+slightly larger constants. This bound is independent of the number of cells.
+
+Physical-prefix elimination still consists of one contiguous prefix and
+disjoint future interiors separated by at least the bandwidth. The eliminated
+matrix is a direct sum of such sections. A Schur inverse is a principal block
+of the corresponding full inverse; its norm is therefore polynomial too.
+Schur norms follow from `D-C A^-1 B`. These are the same prefix geometries
+used in the retained dense no-pivot boundary argument, with new polynomial
+constants. No general stability assertion for structured generators is used.
+
+## 3. Setup precision must increase; online precision need not
+
+The old absolute weight precision cannot be retained. For the narrow weights
+
+    w_i=exp(-a(1/4-beta_i^2)/theta),
+
+the negative logarithm can now be as large as `a/(4 theta)=O(p^2 log p)`.
+Rounding these weights absolutely to Cp bits can produce zero. The finite
+checker includes a concrete underflow witness; this is a required change.
+
+Let `L_p=ceil(log2 p)` and let C be a sufficiently large fixed constant.
+Use setup precision
+
+    P_setup = C p + 64 p^2 L_p.
+
+Eventually `a<=16 L_p`, so `a/(4 theta)<=16 p^2 L_p`. Since log 2>1/2,
+rounding a weight downward with absolute error at most `2^-P_setup` gives
+
+    |w_hat_i-w_i|/w_i
+      <= 2^-P_setup exp(a/(4 theta))
+      < 2^(-C p).
+
+The weights remain positive. Increasing C by a fixed amount supplies any
+additional polynomial slack needed below. Computing these polynomially many
+bits, exponentials, exact anchored ratios and local inverse/factor pages takes
+polynomial time in p. Schoolbook arithmetic and ordinary convergent series
+already suffice; no use of the improved multiplier at a larger precision is
+required for this setup bound.
+
+Define one globally fixed rounded reference matrix H as in the retained
+audit: within each original phase cell use positive rounded weights and a
+single rounded, truncated Toeplitz kernel, and across cells use rounded
+Gaussian entries, with diagonal exactly one. The weights use P_setup, while
+the kernel and the actual online pages need only a sufficiently large
+constant times p bits. For distances at most W, weight ratios have logarithmic
+range O(aW)=o(p). The truncation tail is bounded directly in the Gaussian
+entries, independently of the full-cell weight range. Hence H differs from
+the exact Gaussian matrix by `poly(p) 2^(-(C-o(1))p)` in row and column norm.
+This preserves the polynomial conditioning in section 2. All actual Schur
+and inverse tables are computed for this H, with the same perturbation budget.
+
+The data circuit never multiplies by the full-cell weights. Use PR1758's
+exact fractional-shift identities, whose algebra holds for every theta>0.
+On a capped block of length at most B, the narrow remaining chirp has
+logarithmic range O(a theta B^2); the broad chirp and its leftover linear
+term have range O(b0 theta B^2+b0 theta B), where b0=pi/alpha^2. Each is at
+most O(a B^2/p^2). The shifted Toeplitz kernels remain accretive: their shift
+gap is at least theta/2, and the explicit symbol bound of PR1758 gives
+polynomial inverse norms when theta^-1=O(p^2). Its accretive shallow-circuit
+theorem therefore has polylog(p) guard bits per axis, as before.
+
+The ideal shifted representation and H need not have identical stored
+coefficients. Their difference has the bound just established: replace the
+old raw `Cp` weight precision by P_setup in the comparison in PR1758 section
+2. Local shifted kernels and anchored chirps are generated directly, then
+rounded at online precision. Across g axes the uncompleted amplification is
+
+    exp(O(g a B^2/p^2 + g polylog p)).
+
+Thus O(p)-bit records suffice whenever
+
+    beta + 2 xi - 2 < 1,    beta < 1.
+
+The inverse comparison also stays within the error budget. If an ideal
+interior A and the rounded reference H_II differ by Delta, then
+`H_II^-1-A^-1=-H_II^-1 Delta A^-1`. Both inverse norms are polynomial;
+the error changes only by a polynomial factor. Telescoping through the
+constant number of completed factor stages, and through g tensor axes,
+uses the stated chirp/prefix guard. Exact identity of their rounded
+coefficient lists is neither assumed nor needed.
+
+Setup arithmetic at P_setup is separate from these records. It is not placed
+inside an online motif call or multiplied into the per-record data cost.
+PHASE-LAYOUT-AUDIT already permits polynomial coefficient/page generation
+per complete microbox and axis, amortized by the superpolynomial inner and
+spectator payload. Replacing its polynomial by another fixed polynomial
+preserves that argument: `L^g` and every full unused source-axis range exceed
+every fixed polynomial in p. The number of pages, capped pieces, axes and
+required bits is polynomial. This is an asymptotic amortization, not a claim
+that P_setup or the eventual cutoff is practical.
+
+## 4. Normalize completed maps with powers of two
+
+The exact Gaussian resampling identity and the coprime source/target
+permutations do not require theta to be of order 1/d. They require the
+positive separation and invertibility established above. The completed
+forward, inverse and diagonal factors can have larger polynomial norms
+than in the old parameter family. Divide each such completed map by an
+additional dyadic factor of at most `2^ceil(100 log2 p)`. The conservative
+p^10 bounds above are then below one. Restore the product of these exact
+normalizers at the final scalar shift, together with the retained Gaussian
+normalization. This preserves the exact transform identity.
+
+There are O(d) factors; the added shift has O(d log p)=o(p) bits because
+epsilon<1. This also bounds the extra accuracy needed before exact recovery.
+At a sufficiently large fixed C, data precision is `C p+o(p)=O(p)`.
+Completed groups can be treated as contractions, while their uncompleted
+prefixes/suffixes use the chirp and circuit guards of section 3. None of
+these changes increases the semantic online dimension exponent C1=1.
+Offline arithmetic is paid through the setup amortization, not that interface.
+The normalizer is scalar: combine its powers into the group coefficients or
+apply one scalar per completed group, rather than introducing a full scan per
+axis. A constant number of these operations per group is absorbed by the
+retained group-scan row. Global restoration is one already-paid exact shift.
+
+## 5. A larger but still polynomial locality window
+
+The old literal row-gap and locality constants must not be reused. A
+conservative generic locality argument suffices. For a banded reference
+matrix with `||H||_2,||H^-1||_2<=p^10`, put
+
+    Q=I-p^-20 H* H.
+
+Its eigenvalues lie in `[0,1-p^-40]`. With `J=ceil(p^42)`, the polynomial
+inverse `p^-20 sum_(j<J) Q^j H*` has error at most `p^10 exp(-p^2)`, below
+`2^-Cp` for every fixed C eventually. The bandwidth is at most `2WJ+W`.
+Since W=O(sqrt(p) polylog p)<p eventually, a halo `A=C_A p^48` covers it.
+The same statement holds for the relevant periodic matrices and finite
+sections: the norm bounds are uniform in their length. Polynomial factors
+from changing induced norms on a polynomial-size halo are absorbed by
+exp(-p^2). This proves a usable replacement for the old Cp^3 locality scale.
+
+Choose dyadic core length `L=2^ceil(128 log2 p)`. Then gA/L tends to zero.
+The retained single-face/core correction layout has the same formula with
+halo exponent 48 and core exponent 128. Its paid cost power is
+`epsilon+beta+48-128+2`; its halo-volume margin is `128-48-beta>0`.
+The locality polynomial is used in the proof and coefficient setup. The
+online algorithm still uses the capped factorization and compiled circuits;
+it does not perform J Neumann iterations on each data record.
+
+An original phase cell now has length Theta(p^2). Capped dyadic carving still
+has boundary density `O((W/B) polylog p)`: the additional end-cell contribution
+is `O(W log B/p^2)`, dominated when B<=p^2. Clipped physical period cuts and
+holes remain boundary. Scalar Schur bandwidth stays O(W), since an eliminated
+interior joins only its two neighboring O(W)-size separators. Larger cores
+and halos change only fixed powers in offline setup and O(log p) address
+fields. Their source axes are still superpolynomial in p.
+
+## 6. Retained Strassen boundary, circuit and union costs
+
+Use the explicit Strassen circuit, with `7^16<2^45`, so choose fixed matrix
+target exponent `tau=45/16` and `c=(3-tau)/2=3/32`. PR1673's dense boundary
+proof and fixed-format absolute-precision argument apply to the new polynomially
+conditioned pages. Block scans, permutations, rewinds and linear combinations
+remain charged. Boundary density is still W/B, so its cost power remains
+`epsilon-xi+(tau-1)/2` and its saving is `c+xi-epsilon`. This applies to general
+rounded blocks and needs no structured inverse algorithm.
+
+The interiors use PR1758's shifted Toeplitz representation and accretive
+shallow-circuit theorem, with the smaller theta substituted in the explicit
+symbol bound and with section 3's setup precision. Circuit algebra and depth
+are unchanged; the condition guard remains polylog(p) per axis because all
+inverse norms and theta^-1 are polynomial.
+
+Retain PR1758's radix-distributed union schedule. Complete lines stay in one
+flag class and axis operators commute on distinct tensor factors. Its incidence
+identity is `sum_r |S_r|=sum_x |F(x)|=sum_i |U_i|<=g mu V`. Each visit already
+moves an O(p)-bit record; flag extraction and O(g log L)-bit headers are absorbed
+when beta<1. We use PR1758's per-visit argument, not the obsolete 2 beta<1.
+Union cost power remains `epsilon+1/2-xi`. No per-axis scan of the whole union
+is added, and no vanishing-union fraction is assumed. Support routing,
+whole-neighborhood reservation and interchange retain their stated interfaces.
+
+## 7. Explicit parameters and every paid row
+
+Use PR1699's certified endpoint
+`b_cert=335950991225108904267/200000000000000000000000`.
+Set `b=b_cert-10^-64`, `q=b-10^-64`, `a_eff=(q+b)/2`,
+`r0=10^-64`, `zeta=10^-66`, layout slack `s=10^-64`, and stopped-recursion
+parameter `stop=10^-70`. The bit endpoint is 0.001733427039589844234749.
+Choose
+
+    epsilon=9999999/10000000,
+    beta=9999997/10000000,
+    xi=epsilon(1+q)-3/32+s.
+
+Thus xi=0.90792965478815... . This is an explicit interior point; it does not
+assert an attained limiting rate. Since beta<epsilon<1, source axes and unused
+spectators remain superpolynomial and the number of groups is polynomial.
+
+| Operation | Cost power | Saving |
+|---|---|---|
+| Main transforms | 1-epsilon q | epsilon q |
+| Global coordinate router | 1-a_eff | a_eff |
+| Fused Gaussian groups | epsilon-q beta | 1-epsilon+q beta |
+| Group bit router | epsilon-a_eff beta | 1-epsilon+a_eff beta |
+| Group scans, including normalization | epsilon-beta | 1-epsilon+beta |
+| Strassen boundary | epsilon-xi+(tau-1)/2 | c+xi-epsilon |
+| Radix union movement | epsilon+1/2-xi | xi+1/2-epsilon |
+| Polynomial products | 1-epsilon | epsilon |
+| Core-face corrections | epsilon+beta+48-128+2 | 1-(epsilon+beta+48-128+2) |
+
+Boundary saving equals main saving plus s. With delta=10^-7 and beta=1-3 delta,
+Gaussian saving minus main saving is `delta(1-2q)>0`. The global router also
+exceeds the main saving. Every other row has larger slack. The minimum is
+`epsilon q`, strictly above the rounded headline.
+
+Key side conditions are
+
+    1-beta=3 delta>0,
+    1-beta-2(1-epsilon)=delta>0,
+    epsilon-beta=2 delta>0,
+    1-epsilon-r0>0,
+    1-(2xi-2)-r0-beta=0.184140990423...>0,
+    1/2<xi<epsilon, xi<2,
+    128-48-beta>0, 48>43.
+
+The ledger regenerates the remaining stopped-supplier, endpoint, logarithm
+and layout conditions. A separate implementation reconstructs the point and
+all nine powers. Fourteen rejected variants include the old theta guard,
+old union scan, group=dimension, epsilon=1, an unsupported Strassen exponent
+and halo/core choices outside the stated locality witness. These failures
+are scoped to this proof and point, not universal lower bounds.
+
+## 8. Scope, sources and open obligations
+
+Newly supplied here: the effective fine-prime interval and capacity/search
+argument; the polynomial setup-precision replacement; the theta-dependent
+conditioning substitution; conservative locality/core choices; scalar
+normalization accounting; and the exact parameter composition.
+
+Retained or cited mathematical inputs are Trudgian's prime theorem; PR1673's
+Gaussian identities, bilateral/finite LDU, capped factorization, dense boundary
+and layout arguments; PR1758's fractional-shift identities, accretive circuit
+theorem and per-visit union schedule; and the admitted finite supplier.
+Arithmetic and finite simulations do not prove these general statements.
+
+The multiplication conclusion remains conditional on the all-size compiler,
+common labels, mutable sources, whole-call hosting, semantic online precision
+C1=1, fixed tapes, prime-packing implementation, arbitrary-width equal-chunk
+interchange, exact recovery and analytic transfer. The changed prime interval,
+setup precision and locality scales are proved above rather than silently
+substituted into old numeric hypotheses. No independent human review,
+proof-assistant verification, practical cutoff or physical multiplication
+implementation is claimed.
+
+Credit Vlado Vojdanovski for PR1673; IdeaOuter, as credited by PR1758, for
+fractional-shift interiors and per-visit tag accounting; Jeremy Kothe and
+contributors for the package series; and LeverRank for the second schedule
+simulation. PR1699's notices retain the complete supplier lineage. PR1672
+published the signed-554 kernel first. New material here was prepared by
+Chafik Boukhalfa with substantial OpenAI Codex assistance, under Apache-2.0.
+
+Open next questions: independently review setup versus online precision,
+uniform prefix conditioning and the enlarged halo; formalize the fine-prime
+transfer lemma; improve the finite supplier endpoint. Every new endpoint
+still requires a complete paid native word and admission. The extreme
+eventual threshold is intentionally not presented as a practical algorithm.
diff --git a/research/native-kappa-30201655/modern-sources/FIXED-A-PERIODIC-NORM-AUDIT.md b/research/native-kappa-30201655/modern-sources/FIXED-A-PERIODIC-NORM-AUDIT.md
new file mode 100644
index 0000000000..ad029e08f1
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/FIXED-A-PERIODIC-NORM-AUDIT.md
@@ -0,0 +1,82 @@
+# Independent audit: fixed-width Gaussian inverse is polynomially bounded
+
+This independently checks the stronger bilateral-LDU proof proposed by the parent and Gaussian-factor agent. It supersedes the need for `a=Theta(log(1/theta))` in the earlier nearest-neighbor norm argument. It does **not** assert a new fast data algorithm or a final exponent.
+
+Let rho=t/s>1, theta=rho-1, q_i=floor(rho i+1/2), beta_i=rho i-q_i for all integer i. Define
+
+```
+x_i=exp(2a rho q_i), e_i=exp(-a rho^2 i^2+a beta_i^2),
+G_ij=exp(-a q_i^2) x_i^j e_j,
+r=exp(2a rho), c=product_(m>=1)(1-r^-m)>0.
+```
+
+The sequence x_i increases at least by a factor r at every step and tends geometrically to zero toward minus infinity.
+
+## Finite-origin identities
+
+For an integer origin l, Newton interpolation of columns j>=l gives, on every finite principal interval starting at l,
+
+```
+C_i(l)=product_(l<=k<i)(1-x_k/x_i),
+L_ij(l)=G_ij product_(l<=k<j)(1-x_k/x_i)/C_j(l), i>=j,
+U_ij(l)=(e_j/e_i) h_(j-i)(x_l,...,x_i), j>=i,
+G=L(l) diag(C_i(l)) U(l).
+```
+
+Here h denotes complete homogeneous symmetric polynomials, and both triangular factors have diagonal one. The powers arising from moving the monomial origin from zero to l cancel exactly: the pivot is C_i(l), not a residual power of x_i.
+
+Since C_i(l)>=c and the normalized complete-homogeneous coefficient is at most c^-1,
+
+```
+|L_ij(l)| <= c^-1 G_ij,
+|U_ij(l)| <= c^-1 G_ij.
+```
+
+All limits as l tends to minus infinity exist, including fixed-degree h over the infinite summable past. The displayed Gaussian domination permits passing the factorization to the bilateral limit.
+
+## Inverse factors
+
+For i>=j and h=i-j,
+
+```
+(L(l)^-1)_ij=(-1)^h C_i(l)/C_j(l)
+ * exp(a[-beta_i^2+beta_j^2-rho^2 h+2rho sum_(j<k<=i)beta_k])
+ / product_(j<k<=i)(1-x_j/x_k).
+```
+
+For j>=i and h=j-i,
+
+```
+(U(l)^-1)_ij=(-1)^h (e_j/e_i) e_h(x_l,...,x_(j-1)).
+```
+
+The latter e_h is elementary symmetric, distinct from the scalar normalization e_j. Its dominant product consists of x_i,...,x_(j-1), so its normalized value is at most c^-1.
+
+Using |beta_i|<=1/2 in the two exact exponents gives uniform estimates
+
+```
+|(L(l)^-1)_ij| <= c^-2 exp(a/4-a rho theta h),
+|(U(l)^-1)_ij| <= c^-1 exp(a/4-a rho theta h).
+```
+
+These pass to the bilateral limits. Products of triangular factors and their inverse factors have only finitely many terms for each supported matrix entry, so both inverse identities survive directly. All four factors define bounded absolutely row-summable operators.
+
+## Periodization
+
+Every limiting factor is simultaneously s-periodic in its row and column indices. For a bounded absolutely row-summable periodic array A, define
+
+```
+Pi(A)_ij=sum_(n in Z) A_(i,j+ns), 0<=i,j<s.
+```
+
+Absolute summability and periodicity give `Pi(AB)=Pi(A)Pi(B)` by reindexing
+`B_(k,j+ns)=B_(k+ms,j+(n+m)s)`. Also `||Pi(A)||_infinity<=||A||_infinity` and Pi(I)=I_s. The retained periodic Gaussian matrix is exactly N=Pi(G). Therefore
+
+```
+N^-1=Pi(U^-1 diag(C)^-1 L^-1),
+||N^-1||_infinity <= c^-4 exp(a/2)/(1-exp(-a rho theta))^2.
+```
+
+For **any fixed a>=1**, this is O(theta^-2), with a constant depending only on a. Thus a fixed admissible integer Gaussian width alpha suffices for the norm and perturbation estimates. No logarithmic growth of alpha is needed for conditioning.
+
+The theorem changes an analytic parameter constraint. Applying these factors quickly on the tape remains a separate constructive obligation.
diff --git a/research/native-kappa-30201655/modern-sources/FORWARD-SMALL-A-AUDIT.md b/research/native-kappa-30201655/modern-sources/FORWARD-SMALL-A-AUDIT.md
new file mode 100644
index 0000000000..0f7f80b3f7
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/FORWARD-SMALL-A-AUDIT.md
@@ -0,0 +1,109 @@
+# Broad forward Gaussian: finite-block and completed-matrix conditioning
+
+This note supports the phase-assembly branch. It distinguishes the broad forward map S from the narrow T used in N=C T D. Its conclusions concern conditioning and local circuit guards; the final simultaneous tensor layout remains that branch's obligation.
+
+Let the narrow parameter be `a=pi alpha^2=Theta(log p)`, `rho=t/s=1+theta`, and `lambda=1/rho`. The forward map is
+
+`S_(k,j)=alpha^-1 exp[-b0(j-lambda*k)^2]`, `b0=pi/alpha^2`.
+
+Equivalently it uses the small resampling parameter
+
+`b=b0 lambda^2=pi/(alpha^2 rho^2)`.
+
+## 1. The bilateral bound works at every positive parameter
+
+The finite and bilateral LDU arguments in BILATERAL-LDU.md use a>=1 only for their final numerical simplification of the product c. For any b>0, define
+
+`c_b=prod_(m>=1)(1-exp(-2b rho m))`.
+
+The same proof gives, for the periodic normalized matrix and for every finite contiguous principal block with q-gaps at least 1 and |beta_i|<=1/2,
+
+`||N_b^-1|| <= c_b^-4 exp(b/2)/(1-exp(-b rho theta))^2`.
+
+There is an explicit useful product bound. Expand the logarithm and sum nonnegative terms:
+
+`log(c_b^-1)=sum_(k>=1) 1/[k(exp(2b rho k)-1)]`
+
+` <=(1/(2b rho)) sum_(k>=1)1/k^2=pi^2/(12b rho)`.
+
+At `b=pi/(alpha^2 rho^2)`, this implies
+
+`c_b^-4 <= exp(pi alpha^2 rho/3)=exp(a rho/3)`.
+
+Since b*rho*theta=pi*theta/(alpha^2 rho)<1 for alpha>=2 and theta<=1, its reciprocal gap is at most `2alpha^2 rho/(pi theta)`. Thus every such normalized block inverse has norm polynomial in p when alpha^2=O(log p) and theta^-1 is polynomial in p.
+
+## 2. Actual target-grid phase-cell block
+
+Embed source j at target coordinate i=q_j. On an original phase cell q_j=j+c, every selected target coordinate i in that cell corresponds to j=i-c. A square interior of the forward target-grid matrix is therefore
+
+`K_(k,i)=alpha^-1 exp[-b0(i-lambda*k-c)^2]`.
+
+Here both i and k run over one contiguous selected-target interval inside that cell. Put
+
+`q'_k=k+rho*c`, `beta'_k=rho*k-q'_k=theta*k-rho*c`.
+
+At a selected coordinate k=q_j, beta'_k is exactly the original beta_j, hence lies in [-1/2,1/2). Also q' has consecutive gap 1. Integrality of q' was never needed in the finite LDU proof; monotone separation and the beta bound suffice. Consequently
+
+`K=alpha^-1 N_b diag(exp(-b*(beta'_i)^2))`,
+
+and
+
+`||K^-1|| <= alpha exp(3b/4) c_b^-4/(1-exp(-b rho theta))^2`
+
+` =O(alpha^5 rho^2 theta^-2 exp(pi alpha^2 rho/3))=poly(p)`.
+
+This controls the **completed** interior inverse. It avoids multiplying the large individual diagonal-gauge norms to estimate K inverse. Target holes should be retained as boundary vertices, so every interior coordinate has the asserted original beta bound.
+
+## 3. Square completion of the global forward map
+
+Add one identity column e_h for every target hole h, and feed zero into these extra columns. This makes an invertible square t-by-t matrix H_aug without changing the desired forward result. Permute selected q_j rows/columns first and holes second. In that order,
+
+`H_aug = [ alpha^-1 N_b D_b^-1   0 ; R   I ]`,
+
+where `D_b=diag(exp(b beta_j^2))` and R consists of broad Gaussian rows at holes. A Gaussian lattice-sum bound gives `||R||=O(1)` after the alpha^-1 factor. Thus
+
+`H_aug^-1=[ alpha D_b N_b^-1   0 ; -R alpha D_b N_b^-1   I ]`
+
+has polynomial row norm. The matrix itself also has O(1) row norm. Gaussian truncation and sufficiently accurate structure-preserving coefficient rounding perturb both it and all required interior blocks by exponentially small amounts, preserving these polynomial bounds.
+
+If A is the block-diagonal interior matrix and S is the completed boundary Schur complement, then S inverse is the boundary principal block of H_aug inverse; hence its norm is polynomial. Also
+
+`||S||<=||H_BB||+||H_BI|| ||A^-1|| ||H_IB||=poly(p)`.
+
+This is enough for the completed Schur map. To justify a particular sequential block-LU implementation, its prefix factor norms still need to be checked. The natural physical-prefix elimination sets consist of one contiguous selected-source prefix plus disjoint future interiors, with identity hole columns. That geometry offers the same uniform contiguous-block inverse bound; it should be made explicit in the assembly proof.
+
+## 4. Exact local Toeplitz split and guard range
+
+Choose an anchor m inside the target cell, and write x=i-m, y=k-m,
+
+`delta=(1-lambda)m-c`, with |delta|<=1/2.
+
+Then the exact factorization is
+
+`K_(k,i)=Drow(y) G(y,x) Dcol(x)`,
+
+`G(y,x)=exp[-b0 lambda(x-y)^2]`,
+
+`Dcol(x)=exp[-b0((1-lambda)x^2+2delta*x)]`,
+
+`Drow(y)=alpha^-1 exp[b0 lambda(1-lambda)y^2+2b0 delta lambda*y-b0 delta^2]`.
+
+Expansion gives exactly `-b0(delta+x-lambda*y)^2`; no approximate recentering is involved. On a phase cell of O(d) coordinates, the two diagonal logarithmic ranges are O(d/alpha^2). These are smaller than the O(alpha^2 d) narrow inverse gauges already paid by the proposed group size.
+
+## 5. SPD Toeplitz conditioning for the shallow circuit
+
+Let `gamma=b0 lambda=pi/(alpha^2 rho)`. The full Gaussian Toeplitz symbol has, by the Gaussian Poisson identity,
+
+`f(omega)=sqrt(pi/gamma) sum_(k in Z) exp[-(omega+2pi*k)^2/(4gamma)]`.
+
+For -pi<=omega<=pi,
+
+`sqrt(pi/gamma) exp[-pi^2/(4gamma)] <= f(omega) <= 1+sqrt(pi/gamma)`.
+
+Every finite principal Gaussian Toeplitz matrix has eigenvalues between these same bounds, by integrating the squared modulus of its coefficient polynomial against f. At alpha^2=O(log p), its condition number is polynomial in p. Truncation width O(sqrt(p/gamma)) and Cp-bit rounding perturb the matrix far less than its lower eigenvalue, so the actual symmetric rounded Toeplitz Ghat remains SPD with polynomial condition number.
+
+The low-displacement block-LU circuit of SHALLOW-TOEPLITZ.md extends from near identity to this SPD setting: every principal Schur complement has norm at most lambda_max and inverse norm at most lambda_min^-1, and ranks grow by the same additive displacement recurrence. Shear coefficients are polynomial in p; multiplying these bounds along O(log d) recursive levels gives exp(O(log^2 p)) partial-prefix growth. This calls for O(log^2 p) internal circuit guard bits per axis, rather than claiming the near-identity theorem's O(log p) unchanged. It is still below the group budget dominated by the local Gaussian diagonals.
+
+Dyadic interior subdivision from LOG-A-PHASE-SCHUR-AUDIT.md applies here too, using the broader width O(sqrt(p alpha^2)). It keeps target holes and separators as boundary, adds only polylogarithmic boundary volume, and lets every interior use a dyadic shallow circuit without 2^g padding.
+
+No numerical final exponent follows from these conditioning statements alone.
diff --git a/research/native-kappa-30201655/modern-sources/GAUGEFREE-INTERIORS.md b/research/native-kappa-30201655/modern-sources/GAUGEFREE-INTERIORS.md
new file mode 100644
index 0000000000..0f9e75ee7b
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/GAUGEFREE-INTERIORS.md
@@ -0,0 +1,119 @@
+> **Package note (fine primes).** In this package the source primes are chosen at relative gap Theta(p^-2) (PR1786, `vendor/pr1786`); theta >= 1/(4p^2) replaces theta >= 1/(4d) in every bound below, the chirp range becomes O(a B^2/p^2) and the guard of Section 5 becomes beta + 2 xi - 2 < 1 (see `outer/FINE-PADDING-COMPOSITION.md`). The accretive lemma and the shift identities hold for every theta > 0; the symbol bound mu >= (1 - e^{-gamma theta/2}) e^{-pi^2/(3 gamma)} is polynomial for theta^-1 = O(p^2).
+
+# Gauge-free interiors: fractional-shift Toeplitz kernels, accretive shallow circuits, and the chirp-only guard
+
+**Status.** New in this package series (not in PR1673 by Vlado Vojdanovski, whose capped phase-cell fusion, SHALLOW-TOEPLITZ.md, CAPPED-GAUGE-AUDIT.md and LOG-A-PHASE-SCHUR-AUDIT.md this note modifies and relies on). Conditional on every hypothesis of PR1673 except the three statements replaced below. Independent review required before release. Executable support: `outer/check_gaugefree.py` (exact identities, 50-digit symbol checks, section/Schur bounds, circuit replay) and `outer/check_ledger.py` / `outer/independent_check.py` (the ledger).
+
+## 0. Result and what changes
+
+kappa (this package = structured boundary + this note) = **0.0016797455088022990515465336851999736723...** (exact, 58 strict checks positive, all rejecting controls fire; previous package (structured boundary, linear guard) 0.0016783441717365..., gain +1.4013e-6; rectangular k=5 package 0.0016781238306335..., gain +1.6217e-6). Parameters: eps = 0.9999943758, xi = 0.5016741213, beta = 0.9966461332.
+
+Three statements of #1673 are replaced (everything else is unchanged):
+
+| # | #1673 / earlier packages | this note |
+|---|---|---|
+| R1 | local gauge of a capped interior: diagonals of range O(aB) (narrow), O(b0 B) (broad) | the linear part of the gauge is exactly a fractional centre shift of the Toeplitz kernel; only the quadratic chirp remains, range O(a theta B^2) = O(a B^2/d). (Section 2) |
+| R2 | SHALLOW-TOEPLITZ sec. 9 needs mu I <= H <= M I (SPD) or ||H-I||<1/4 | accretive: (H+H^*)/2 >= mu I and ||H|| <= Lambda. The shifted Gaussian symbol is accretive with explicit mu. (Sections 3, 4) |
+| R3 | ledger guard beta + xi <= 1-r-zeta; union tag check 1-2 beta > 0 | guard beta + 2 xi - eps <= 1-r-zeta; tag check 1-beta > 0 (Sections 5, 6) |
+
+## 1. Setting
+
+Phase cell: beta_i = theta i - c in [-1/2,1/2), rho = 1+theta, lambda = 1/rho, 1/(4d) <= theta <= 1/(2d-1). An interior is a contiguous block of selected target coordinates (unit q-gaps), length n <= B (dyadic), anchor m at its centre; x = i-m, y = k-m, t = i-m for the narrow operator. B = p^xi, d = p^eps, xi < eps.
+
+* Broad forward block (FORWARD-SMALL-A-AUDIT, CAPPED-GAUGE-AUDIT sec. 3): K_{ki} = alpha^-1 exp(-b0 (x - lambda y + delta)^2), delta = (1-lambda) m - c, |delta| <= 1/2, b0 = pi/alpha^2.
+* Narrow inverse block (LOG-A-PHASE-SCHUR-AUDIT sec. 1): N_{i,i+h} = exp(-a[(rho h + beta_i)^2 - beta_{i+h}^2]), a = pi alpha^2, beta_i = beta0 + theta t_i.
+
+## 2. Exact gauge <-> shift identities
+
+**Lemma 2.1 (broad).** For every real s,
+(x - lambda y + delta)^2 - lambda (x - y - s)^2 = (1-lambda) x^2 - lambda(1-lambda) y^2 + delta^2 - lambda s^2 + 2(delta + lambda s) x - 2 lambda (delta + s) y.
+Hence K = Drow G_s Dcol exactly, with the Toeplitz kernel G_s(y,x) = exp(-b0 lambda (x-y-s)^2) and diagonals separable in (y,x) (proved by expansion; sympy and 600 exact rational mixed-difference checks in `check_gaugefree.py` stage A/B).
+Choose **s = -delta (1-theta)**. Then the x-linear coefficient is 2 b0 (delta + lambda s) = 2 b0 delta (1 - lambda(1-theta)) = 2 b0 delta * 2 theta/(1+theta), |.| <= 2 b0 theta, and the y-linear coefficient is -2 b0 lambda (delta + s) = -2 b0 lambda theta delta, |.| <= b0 theta. Over a block with |x|,|y| <= B/2 the linear leftover has logarithmic range <= 2 b0 theta B (total), and the quadratic parts b0 (1-lambda) x^2, b0 lambda (1-lambda) y^2 have range <= b0 theta B^2/4 each. Also |s| <= (1-theta)/2, i.e. 1 - 2|s| >= theta.
+(With s = -delta/lambda the linear terms vanish in x and are 2 b0 delta (1-lambda) in y, but |s| can exceed 1/2 by theta/2, which changes the winding number of the symbol; so the shift is shrunk by (1-theta). The price is the O(b0 theta B) linear leftover, dominated by the chirp.)
+
+**Lemma 2.2 (narrow).** With beta_{i+h} = beta_i + theta h, rho = 1+theta:
+(rho h + beta_i)^2 - beta_{i+h}^2 = (1+2theta) h^2 + 2 beta_i h. Writing beta_i = beta0 + theta t_i, j = i+h, t_j = t_i + h, and 2 t_i h = t_j^2 - t_i^2 - h^2:
+log N_{ij} = -a rho h^2 - 2 a beta0 h + a theta (t_i^2 - t_j^2) (exact; sympy check, stage A).
+So N = D' k D'^{-1}-type: N_{ij} = e^{a theta t_i^2} k(j-i) e^{-a theta t_j^2} with the Toeplitz kernel k(h) = exp(-a rho h^2 - 2 a beta0 h) = exp(a beta0^2/rho) exp(-gamma (h-s)^2), **gamma = a rho, s = -beta0/rho**. Here |s| <= 1/(2 rho) so **1 - 2|s| >= 1 - 1/rho = theta/rho >= theta/2**: no shrinking is needed, and the gauge is the chirp D' = exp(a theta t^2) of logarithmic range a theta B^2/4 (centred). The old weights are the same objects: log w_i = const + a theta (i - c/theta)^2 (the old linear slope 2 a beta0 is exactly the term moved into k).
+
+**Normalisation.** G'_s(u) := e^{gamma s^2} e^{-gamma (u-s)^2} = exp(-gamma u^2 + 2 gamma s u) has G'_s(0) = 1 (unit diagonal, as the audited N). The scalars e^{gamma s^2} are exact constants (stored in the anchor ratios).
+
+**Rounding.** The circuit applies the ideal truncated kernel (band W) rounded to Cp bits; the audited global rounded matrix differs from it by <= poly(p) 2^{-Cp} times the diagonal range e^{O(g (a theta B^2 + polylog))}, which is covered by the same precision guard (Section 5). **Restated comparison (audited rounded matrix vs ideal shifted kernel).** The audits (BILATERAL-LDU, FORWARD-SMALL-A, CAPPED-GAUGE-AUDIT sec. 2-3) bound the unshifted globally rounded matrix H^. Let K be the ideal block (exact Gaussian entries) and K~ = Drow' G^_s Dcol' the matrix the circuit applies (truncated at W, G^_s rounded to Cp bits, anchored diagonals). Entrywise |H^ - K| <= 4 * 2^{-P} e^{a/(4 theta)} relative to the weights (audit sec. 2), and |K~ - K| <= 2^{-Cp} W-banded; the diagonal conversions contribute the factor e^{O(a theta B^2)} per axis (chirp range of Section 5; the linear leftover is smaller). Hence ||K~ - H^|| <= poly(p) 2^{-Cp} e^{O(g a theta B^2 + g polylog p)} (g axes tensored), and the exponent is o(p) bits by the precision guard beta + 2 xi - eps < 1 of Section 5. For C > 1 the perturbation is <= 2^{-(C-o(1))p} <= 2^{-p}/poly, and since ||K^-1||, ||H^-1|| <= p^{O(1)} (Section 3; audits) every audited uniform bound (row gap, inverse norms, Neumann tail J = Cp^2, halo radius A) holds for K~ with polynomially perturbed constants. No structural change.
+
+## 3. The shifted Gaussian symbol is accretive
+
+Let q = e^{-gamma}, 0 <= s' = |s| < 1/2, phi(w) = sum_u e^{-gamma(u-s)^2} e^{-iuw}.
+
+**Lemma 3.1 (product form).** Jacobi triple product with Z = q^{-2s} e^{-iw}:
+phi(w) = e^{-gamma s^2} prod_{m>=1}(1-q^{2m}) (1 + a_m e^{-iw})(1 + b_m e^{iw}), a_m = q^{2m-1-2s}, b_m = q^{2m-1+2s}.
+For s < 0 the symbol is the complex conjugate (swap a, b). All a_m, b_m in (0,1) iff |s|<1/2; a_1 = q^{1-2|s|} is the unique factor near 1. At |s| = 1/2: a_1 = 1 and phi(pi) = 0. (Verified at 50 digits, relative error 2.5e-42 on 1025 points.)
+
+**Lemma 3.2 (phase).** For w in [0,pi] and s >= 0, f(x) := arg(1 + x e^{iw}) = atan(x sin w/(1 + x cos w)) is increasing in x in [0,1) (f'(x) = sin w/|1+x e^{iw}|^2 > 0). arg phi = sum_m [f(b_m) - f(a_m)]. Since 2m+1-2s >= 2m-1+2s iff s <= 1/2, a_{m+1} <= b_m, so f(b_m) >= f(a_{m+1}) and
+0 <= -arg phi = sum_m [f(a_m)-f(b_m)] <= sum_m [f(a_m) - f(a_{m+1})] = f(a_1) < w/2 <= pi/2.
+For w in [-pi,0] use phi(-w) = conj(phi(w)).
+
+**Lemma 3.3 (real part).** cos(f(a_1)) = (1 + a_1 cos w)/|1 + a_1 e^{iw}|, so
+Re phi(w) >= |phi(w)| cos f(a_1) >= e^{-gamma s^2} prod_{m>=1}(1-q^{2m}) * (1 - a_1) prod_{m>=2}(1-a_m) prod_{m>=1}(1 - b_m) =: m_s(gamma).
+(The bound is attained at w = pi up to the other factors: stage C finds min Re phi / m_s = 1.0.) Normalising by e^{gamma s^2}:
+
+mu(gamma, s) := m_s e^{gamma s^2} >= (1 - e^{-gamma(1-2|s|)}) exp(-pi^2/(3 gamma)).
+
+Proof of the closed form: -ln prod_k (1 - e^{-k gamma x}) = sum_h (1/h)/(e^{h x gamma}-1) <= pi^2/(6 x gamma); the three infinite products are bounded by prod_{k>=1}(1-q^{2k}) >= e^{-pi^2/(12 gamma)} (twice, the second for m >= 2 since a_m <= q^{2m-2}) and prod_{k>=1}(1-q^{2k-1}) >= prod(1-q^k) >= e^{-pi^2/(6 gamma)}; total e^{-pi^2/(3 gamma)}.
+Norm: Lambda := ||G'_s||_2 <= ||symbol||_{l1} = sum_u e^{-gamma(u^2 - 2su)} <= 3 + sqrt(2 pi/gamma) (u^2 - 2su >= u^2 - |u| >= 0 and >= u^2/2 for |u| >= 2).
+
+Parameter values. Broad: gamma = b0 lambda = pi/(alpha^2 rho) = Theta(1/log p), 1-2|s| >= theta >= 1/(4d): mu >= (gamma theta/2) e^{-pi alpha^2 rho /3} = p^{-O(1)}. Narrow: gamma = a rho >= 4 log(16 p), 1 - 2|s| >= theta/2: mu >= (1 - e^{-a theta/2}) e^{-pi^2/(3 gamma)} >= a theta/3 = p^{-O(1)} (this is the audited row gap).
+
+## 4. The accretive Toeplitz circuit (replaces SHALLOW-TOEPLITZ sec. 9)
+
+**Theorem 4.1.** Let N be a power of two and H an N x N complex Toeplitz matrix with ||H||_2 <= Lambda and (H + H^*)/2 >= mu I, mu > 0. There is an N-wire circuit of disjoint invertible 1x1/2x2 gates applying H, with O(log^4 N) rounds, O(N log^4 N) gates, no ancilla, and
+log(max prefix / suffix / inverse-prefix operator norm) = O(log N * log(2 + Lambda/mu) + log N).
+Rounding every coefficient to p + O(log N * log(2+Lambda/mu)) bits gives operator error 2^-p. If Lambda/mu = p^{O(1)} the guard is O(log N log p) bits per axis.
+
+*Proof.* Identical to SHALLOW-TOEPLITZ sec. 4, 5, 6, 9 except for the single place where the hypothesis is used, the uniform control of every recursive matrix, which we prove now.
+
+(a) *Descendants are Schur complements of sections.* Let T_b be the leading b x b section of H. The recursion of sec. 4 acts on index intervals J = [a,b); the matrix at J is S(a,b) = T_b / T_a (Schur complement of the leading a x a block of T_b, as an (b-a) x (b-a) matrix). Indeed the root is S(0,N); the children of S(a,b) with midpoint m are S(a,m) = T_m/T_a (leading block of S(a,b)) and S(a,b)/S(a,m) = T_b/T_m by the quotient property (T_b/T_a)/(T_m/T_a) = T_b/T_m. All of these are contiguous leading-type sections of the same Toeplitz H.
+
+(b) *Accretive matrices.* If Re <Tx,x> >= mu ||x||^2 then ||Tx|| >= mu||x||, so ||T^-1|| <= mu^-1; every principal submatrix has the same property. Hence ||T_b^-1|| <= 1/mu for all b and ||S(a,b)^-1|| = ||(T_b^-1)[a,b)|| <= 1/mu. Also ||S(a,b)|| <= ||T_b[a,b)|| + ||T[a,b); [0,a)|| ||T_a^-1|| ||T[0,a); [a,b)|| <= Lambda + Lambda^2/mu =: Lambda'. The shear matrices K = A^-1 B, L = C A^-1 have norm <= Lambda/mu. (No Hermitian structure was used.)
+
+(c) *Displacement rank, generators, compiler.* Sec. 4's rank identities (Delta = ZM - MZ, rank Delta(H) <= 2, ranks of A,S <= 2 + depth) and the sec. 5 bounded-generator compiler use only that each node's A, S, K, L are bounded matrices with the displayed ranks; the Stein generators g_j (orthonormal), h_j (norm <= ||E_T|| <= 2 Lambda'') have polynomial norm, and gamma_P = 64 N Lambda'' suffices. The recursion D_full(N) <= D_full(N/2) + O(log^3 N) is unchanged.
+
+(d) *Prefix norms.* With each completed node factor of norm and inverse norm <= poly(N) (Lambda'/mu)^{O(1)}, B(N) <= max(C B(N/2), N^C (Lambda'/mu)^C), so log B(N) = O(log N log(2+Lambda'/mu)) as in sec. 9 with kappa replaced by Lambda'/mu. QED.
+
+**Corollary 4.2 (perturbation, truncation, rounding).** If the symbol is perturbed in l1 by eps' <= mu/2 (band truncation at W, rounding to Cp bits), the Hermitian part stays >= mu/2 and Theorem 4.1 applies to the perturbed matrix. For the broad kernel the truncation tail is <= 2^{-p}, and mu >= p^{-O(1)}.
+
+**Corollary 4.3 (boundary pivots for the structured boundary).** The boundary LU pivot P_j of STRUCTURED-BOUNDARY (Schur complement of T[J] onto segment j after eliminating all indices left of it and the interval I_j to its right, J = [0, end of I_j)) satisfies ||P_j^-1|| <= 1/mu, ||P_j|| <= Lambda + Lambda^2/mu, because P_j^-1 is the principal block of (T[J])^-1 and T[J∖seg_j] is a principal submatrix of T[J], both accretive. The couplings are band entries of G_s. The statement holds per constant-offset stretch: each stretch of a cell (maximal run with constant phase offset c, i.e. one Toeplitz matrix T, one shift s) is handled with its own anchor at the segment centre, so that the chirp D' = exp(a theta t^2) (broad: b0 theta t^2) has range a theta B'^2/4 for boundary segments of physical length B' <= B + 2W (and the linear leftover is <= 2 b0 theta B'); a pivot chain crossing a cell cut restarts, since cell cuts are boundary coordinates. Rank-2 Stein/Sylvester displacement for P_j, P_j^-1 holds for every Toeplitz T (Kailath), shifted or not; screened in `check_gaugefree.py` D/E and in the earlier IdeaOuter screen (displacement rank 2 along the whole chain at s = 0.5). Thus the structured-boundary pivot bounds (which used BILATERAL-LDU for the unshifted gauge) transfer without change of statement.
+
+## 5. Assembly and the guard
+
+For every capped interior (dyadic length n <= B, with its own anchor and shift s):
+ broad: Drow' (circuit of G'_s, Theorem 4.1 with mu = mu(b0 lambda, s)) Dcol';
+ narrow: D' (circuit of G'_s, gamma = a rho) D'^-1 (inverse circuit = reversed gate sequence).
+The diagonal factors Dcol', Drow', D' are anchored ratios with logarithmic range
+ narrow: a theta B^2/4; broad: <= b0 theta B^2/4 (x^2 and y^2 terms) + 4 b0 theta B (linear leftover) .
+Per axis the range is O(a B^2/d); direct sums over blocks run in parallel as before. For g simultaneous axes the precision requirement of CAPPED-GAUGE-AUDIT sec. 4 becomes
+ P >= p + O(a d) + O(g a theta B^2) + O(g log N log p) + ... , i.e. g B^2/d * polylog <= p^{1-r-zeta}:
+ **beta + 2 xi - eps <= 1 - r - zeta**.
+The offline accuracy term a d = o(p) is unchanged. The leftover linear term (exponent beta + xi - eps) is dominated by the chirp (exponent beta + 2 xi - eps) since xi > 0. The circuit norms add g * O(log N log p) bits (Theorem 4.1), polylog per axis, as before.
+(Why this does not collide with locality: the audited locality/halo constructions use the global rounded matrix only through uniform norms and the row gap, which are properties of the same Toeplitz-similar matrices; the shift is an exact similarity-to-Toeplitz representation of the same blocks, Lemmas 2.1-2.2.)
+
+## 6. Ledger changes (exact)
+
+1. `group_gauge_power_slack`: 1 - xi - r - beta -> **1 - (2 xi - eps) - r - beta**; `actual_logarithmic_group_guard`: 1 - xi - beta -> **1 - (2 xi - eps) - beta**. Add `shift_leftover_linear_dominated_by_chirp`: xi > 0, `shift_gap_theta_polynomial`: eps > 0.
+2. Parameters: eps = (1 + q beta)/(1 + q) (main = Gaussian), xi = eps(1+q) - c + slack (boundary = main + slack), beta = 1 - 2 xi + eps - r - zeta. Closed form beta = (-1 + 2c - 2 slack + 1/(1+q) - r - zeta)/(1 + 2q - q/(1+q)), c = (3 - tau_eff)/2.
+3. `union_tag_work_fits_record` (1 - 2 beta) -> **`union_tag_work_per_visit_fits_record`: 1 - beta** (Section 7). `union_header_fits_record` (1-beta) and `membership_arithmetic_fits_record` (1 - beta - 2(1-eps)) stay: pkg8 values 3.354e-3 and 3.343e-3.
+4. Controls added: `old_linear_gauge_guard` (1 - xi - beta < 0), `old_union_tag_2beta` (1 - 2beta < 0) must fire as rejecting controls (they do).
+5. Numbers (pkg8-era package, superseded by outer/FINE-PADDING-COMPOSITION.md for the current epsilon = 1 - 2e-100 point): eps = 0.99999437577296, xi = 0.50167412128176, beta = 0.99664613320944; margins above kappa: main = Gaussian = bit router = boundary = union ~ 1e-64; global router 9.4e-9; cap xi - 1/2 = 1.674e-3; group_below_dimension 3.35e-3; epsilon_below_one 5.6e-6; improvement over pkg7 1.4013e-6.
+`outer/check_ledger.py` carries exactly these edits relative to the previous (structured-boundary, linear-guard) package; `outer/independent_check.py` re-derives (E,X,B) from the three linear equations by exact elimination.
+
+## 7. Union tag work: g polylog <= p suffices
+
+The previous version of UNION-SCHEDULE.md (steps 1 tag and section 3 header paragraph) argued "tag work per record <= O(g^2) in total, o(p) because 2 beta < 1". The cost accounting of Section 2.3-2.4 of that note is per visit: round r touches only records of S_r; each visit costs O(p log g + p log a + 1) head travel (radix passes, transposition) plus the tag extraction O(g) bit operations (scan of the g-bit flag header for the r-th set bit) plus O(g log L) header travel (the header is carried with the record). Sum over rounds = sum_r |S_r| = sum_x |F(x)| <= g mu V (Section 2.4). Total = O(g mu V (p polylog p + g log L)) = O(g mu V p polylog p) as soon as g log L = o(p polylog p), i.e. beta < 1 (and this is already the header check `union_header_fits_record`). The O(g^2) per-record total is a pessimistic restatement: each of the |F| <= g visits of a record is paid for by its own Theta(p) move. UNION-SCHEDULE.md now carries this wording. A reviewer should confirm no other place charges g^2 per record.
+
+## 8. Obligations / risks (review checklist)
+
+1. Theorem 4.1 relies on SHALLOW-TOEPLITZ sec. 4-6 (not re-derived); only the descendant bound (Section 4(a)-(b)) is new. The finite replay (`check_gaugefree.py` stage E: the vendored compiler on shifted Gaussian tiles n = 8, 16, 32, gamma in {0.5, 2, 20}, s up to 0.499: max error 1.8e-12, displacement rank <= 3, peak prefix norm <= 91 for n = 8, 16, max generator entry <= 11.4) supports it. The peak prefix norm is tracked only for n <= 16; for n = 32 it is not computed (reported as null).
+2. The tile is a contiguous section of the *banded, truncated, rounded* shifted kernel; Corollary 4.2 covers it. The audited global rounded matrix remains the reference for the locality/Neumann/halo arguments; its comparison with the ideal kernel is stated in Section 2 (error poly(p) 2^{-Cp} e^{O(g a theta B^2)} = 2^{-(C-o(1))p}, C > 1).
+3. Narrow N formula taken from LOG-A-PHASE-SCHUR-AUDIT (`n_{i,h}`), verified symbolically against the quoted weights of CAPPED-GAUGE-AUDIT sec. 2 (stage A). Broad block formula from CAPPED-GAUGE-AUDIT sec. 3.
+4. (pkg8-era, superseded by the fine-padding point beta = 1 - 6e-100) The parameter point sat at beta = 0.9966, 1 - beta = 3.35e-3: header (g log L bits) and membership (g (log s)^2) rows hold only "eventually", with exponent margins 3.3e-3; the claim is an asymptotic statement with the same status as the other margins (1e-64 slacks).
+5. Not changed: supplier, bit/complex rows, union schedule beyond Section 7, cap xi > 1/2 (still binding at 1.67e-3).
+6. STRUCTURED-BOUNDARY.md now states the chirp range O(aB^2/d) for consecutive boundary segments (physical length <= B + 2W) and cites Corollary 4.3 for the pivot bounds.
diff --git a/research/native-kappa-30201655/modern-sources/LOG-A-PHASE-SCHUR-AUDIT.md b/research/native-kappa-30201655/modern-sources/LOG-A-PHASE-SCHUR-AUDIT.md
new file mode 100644
index 0000000000..3bcf490a8c
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/LOG-A-PHASE-SCHUR-AUDIT.md
@@ -0,0 +1,140 @@
+# Audit: logarithmic Gaussian width retains the phase-cell Schur solver
+
+This audit checks the analytic hypotheses of the retained rad20 phase-cell solver at `a=pi alpha^2=Theta(log p)`, `theta=Theta(1/d)`, even though `a theta` tends to zero. It also audits the shallow Toeplitz circuit algebra and identifies the actual matrix that must be precomputed. It does not certify the final tensor layout or multiplication exponent.
+
+Read inputs: `references/semantic-bulk/rad20/reports/review-bulk-resampling.md`, `review-phase-cell-inverse.md`, `downstream-phase-cell-inverse.md`, and `work/inplace_algebra_ultra/SHALLOW-TOEPLITZ.md`.
+
+## 1. The sharp elementary diagonal-dominance estimate
+
+Let `rho=1+theta`, `beta_i=rho*i-q_i`, and let the Gaussian row coefficient at integer offset h be
+
+`n_i,h=exp(-a[(rho*h+beta_i)^2-beta_(i+h)^2])`.
+
+The h=0 coefficient is 1. Set `g_i=q_i-q_(i-1)` and `g_(i+1)=q_(i+1)-q_i`, each in {1,2}. For the nearest coefficients,
+
+`n_i,-1=exp(-a*g_i*(2rho-2beta_i-g_i))`,
+
+`n_i,+1=exp(-a*g_(i+1)*(2rho+2beta_i-g_(i+1)))`.
+
+If g_i=1, the first exponent is exactly `1+2theta-2beta_i`; if g_i=2, that gap forces `beta_i<theta-1/2`, and the exponent is at least the same expression. Similarly g_(i+1)=2 forces `beta_i>=1/2-theta`, so the upper exponent is at least `1+2theta+2beta_i`. Consequently
+
+`n_i,-1+n_i,+1`
+
+` <=exp(-a(1+2theta-2beta_i))+exp(-a(1+2theta+2beta_i))`
+
+` <=exp(-2a theta)+exp(-2a(1+theta))`.
+
+The last step is convexity in beta on [-1/2,1/2]. The two nearest directions cannot both be charged as exp(-2a theta).
+
+For |h|>=2,
+
+`(rho*h+beta_i)^2-beta_(i+h)^2 >= h^2-|h|`,
+
+so their entire two-sided tail is below `4 exp(-2a)` for a>=1. Therefore
+
+`||N-I||_infinity <= exp(-2a theta)+5 exp(-2a)`.
+
+This includes nonzero periodic diagonal aliases in the tail; no alias is silently omitted from this bound.
+
+For p>=101, theta>=1/(4p), and `a>=4 log(16p)`,
+
+`1-exp(-2a theta) >= 1-exp(-1/(2p)) >=1/(4p)`,
+
+`5exp(-2a)<=5/(16p)^8<1/(8p)`.
+
+Hence N has row diagonal-dominance margin at least `1/(8p)` in the following robust sense: after deleting its tiny nonzero diagonal aliases, its diagonal is 1 and its off-diagonal row sum is at most `1-1/(8p)`. In particular the fixed-width inverse theorem is not needed to supply the retained strict row dominance.
+
+Choose the legal integer alpha by
+
+`alpha=ceil(sqrt((4/pi)log(16p)))`.
+
+Then a has the required lower bound and is O(log p). The old sufficient condition `u>=ceil(log2(8p))` need not be reused: the direct estimate above replaces that prerequisite.
+
+## 2. Actual rounded H, interior matrices, and guard range
+
+Use exactly the retained structure:
+
+- `w=ceil(sqrt(16p/u))+2`, u=alpha^2=a/pi;
+- cell weights `a_j=exp(-a(1/4-beta_j^2)/theta)`;
+- one globally fixed downward dyadic Toeplitz kernel `Ghat_delta` for |delta|<=w, zero outside, with Ghat_0=1;
+- positive downward dyadic weights ahat_j;
+- within a physical cell, define H_jk **exactly** as `ahat_j Ghat_(j-k)/ahat_k`;
+- across cells, use the retained downward Gaussian entries; set H_jj=1.
+
+Thus the actual interior block being inverted is
+
+`A_cell=diag(ahat) Ghat_cell diag(ahat)^-1`.
+
+It is not the unrounded Gaussian matrix, and its retained truncated Ghat is not silently replaced by the infinite Gaussian kernel.
+
+The weight range is
+
+`0<=-log a_j<=a/(4theta)=O(a d)`
+
+under theta between 1/(4d) and 1/(2d-1). The old eventual condition u*d<=p holds whenever d=p^epsilon, epsilon<1, and u=O(log p). It bounds the old rational perturbation calculation by the same `2^(O(p)) eta` allowance. The stronger range `O(a d)` should be used for grouped tensor precision, rather than charging O(p) independently for every axis.
+
+Choose the coefficient precision high enough that `||H-N||<1/(16p)`, including the Gaussian truncation, omitted diagonal aliases and weight-ratio rounding. The retained bound `p*2^(16p+7)*eta+2^(-46p)` at eta=2^(-32768p) is more than sufficient. Then H has diagonal 1, row gap at least `1/(16p)`, row norm below 2, and inverse norm at most 16p. All clipped principal windows inherit the same row gap. The physical period cut must remain a cell boundary, as in the retained bulk review.
+
+## 3. Schur complement bounds without an a*theta>1 assumption
+
+A scalar elimination step on a strictly row-diagonally-dominant matrix cannot decrease its minimum absolute row gap. For pivot k,
+
+`gap_i(new) >= gap_i(old)+(|a_ik|/|a_kk|) gap_k(old)`.
+
+The full absolute row sum also cannot increase, since the added update row has off-pivot sum less than |a_kk|. Induction applies regardless of the signs of filled entries. Since the diagonal begins real positive and the correction magnitude is below it, the surviving diagonal remains positive.
+
+Consequently the exact Schur complement
+
+`S=H_BB-H_BI H_II^-1 H_IB`
+
+has row gap at least `1/(16p)`, row norm below 2, positive diagonal, and
+
+`||S^-1||_infinity<=16p`.
+
+Principal interior inverses also have norm at most 16p. Rounding S by a row perturbation below 1/(32p) preserves gap at least 1/(32p) and inverse norm at most 32p. A row has O(w) nonzeros; the retained P-grid readily meets this target. These are polynomial bounds on arbitrary signed inputs, with no factor equal to the number of cells.
+
+The boundary geometry is unchanged: keep first/last w vertices of each physical cell, yielding O(s*w/d) boundary vertices and circular half-bandwidth at most 2w. Schur fill only joins the two end groups of one cell, while original cross-cell entries join neighboring end groups. Actual inverse and LU coefficient tables must be precomputed for this H/S, not imported from the old parameter values.
+
+Thus the retained banded/cyclic boundary solver's gap-dependent proof remains applicable with fixed constants enlarged. The proposed batched boundary arithmetic still needs its own data-layout and Strassen error audit, but there is no analytic conditioning obstruction at logarithmic a.
+
+## 4. Apply the shallow circuit directly to Ghat inverse
+
+Because a is eventually larger than 4pi, the symmetric Toeplitz matrix Ghat_cell satisfies
+
+`max(||Ghat_cell-I||_1,||Ghat_cell-I||_infinity)<1/8`.
+
+Downward rounding only decreases this off-diagonal sum. The shallow full-Toeplitz theorem therefore applies directly to Ghat_cell. Reverse the resulting invertible circuit and invert its gates to obtain Ghat_cell inverse. This avoids the two-branch Gohberg-Semencul difference entirely. The interior inverse is:
+
+1. multiply by diag(ahat)^-1;
+2. apply the reversed shallow circuit for Ghat_cell;
+3. multiply by diag(ahat).
+
+Its only superpolynomial individual scale comes from the **local** weight range O(a d). Completed A_cell inverse has polynomial norm by the strict row gap. Across g axes, the uncompleted local weight contribution is at most exp(O(g*a*d)); choosing `g<=p/(d polylog p)` with sufficient logarithmic slack keeps the total data precision O(p). The shallow circuit contributes polynomial-in-d amplification per axis, hence only O(g log d) additional logarithmic range. This is a guard calculation, not a complete simultaneous-layer routing proof.
+
+## 5. Independent shallow-Toeplitz algebra audit and a length caveat
+
+The parity-split triangular identity, block Schur displacement formulas, Stein-generator telescoping identity, and bounded-prefix induction in SHALLOW-TOEPLITZ.md check algebraically. In particular the parity children run in parallel, avoiding the earlier erroneous sequential-depth recurrence. The full block-LU recursion also runs its two children in parallel, with O(log N) displacement rank after O(log N) levels.
+
+That document currently states its circuit theorem for dyadic N. Actual cell interiors are not generally dyadic. Padding every tensor axis to its next power of two would be invalid. A plausible exact extension has been communicated to its author: split an arbitrary N into balanced sizes differing by at most one; a near-square rectangular Toeplitz dirty shear is a square Toeplitz shear plus one extra row/column rank-one shear. The latter can be implemented by a binary tree of unitary 2-coordinate reductions and its inverse, without clean ancilla. The rectangular Stein identity telescopes as before. This extension needs its own written proof/controls before it is used as an established interface.
+
+No new final kappa is asserted by this audit.
+
+## 6. Dyadic interior subdivision resolves the length caveat
+
+No arbitrary-length shallow FFT theorem is actually needed. Refine the interior/boundary partition inside each original physical phase cell of length L as follows. Keep its first and last w vertices as boundary. Starting with the remaining interval of length R=L-2w:
+
+- while R>4w, choose the largest power of two B<=R-w;
+- mark the next B vertices as one interior, the following w vertices as boundary, and replace R by R-B-w;
+- once R<=4w, mark all remaining vertices as boundary.
+
+Every interior now has exactly dyadic length. If R>4w, then `B>(R-w)/2`, so the next remainder is less than R/2. There are `O(1+log(L/w))` interiors and the total boundary count in the cell is `O(w(1+log(L/w)))`. The final boundary group, including the initially reserved last w vertices, has size at most 5w; all inserted separators have size w.
+
+The width-w matrix H cannot connect two different new interiors: their separating boundary gap has w vertices, so their nearest physical coordinates differ by w+1. Each new interior is still a principal block of the SAME globally fixed Toeplitz-similar cell matrix. Its weights retain the original cell gauge; there is no new rescaling or rerounding at a subdivision boundary.
+
+Eliminating one dyadic interior fills only between its immediately neighboring boundary groups. Each such group has O(w) vertices. Original H edges also connect only the same group or neighboring groups; an interior has length greater than w in the loop above. Thus, in inherited physical boundary order, the new Schur complement has half-bandwidth O(w), not O(w log d). Only its number of rows grows by O(log d):
+
+`n_boundary=O((s/d) w log d)`.
+
+Clipped endpoint cells of size O(w) may be declared wholly boundary, adding only O(w) rows; preserve the original physical period cut. This is the same endpoint convention as the retained bulk review.
+
+The boundary solve and coupling work therefore gain only polylogarithmic factors. All dyadic interior blocks use the established SHALLOW-TOEPLITZ theorem directly, without padding any tensor axis and without requiring a non-dyadic Fourier circuit. This resolves the length caveat in section 5 for the intended phase-cell application; it does not prove the separate simultaneous tensor-layer routing claim.
diff --git a/research/native-kappa-30201655/modern-sources/OUTER-AUDIT.md b/research/native-kappa-30201655/modern-sources/OUTER-AUDIT.md
new file mode 100644
index 0000000000..974b8db67f
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/OUTER-AUDIT.md
@@ -0,0 +1,93 @@
+# Phase-cell fusion: outer assembly audit
+
+Status: assembly audit in progress. The exact arithmetic in this directory is a **conditional target**, not a replacement of the selected certificate. The remaining proof interfaces are recorded explicitly below.
+
+## Conditional transfer statement
+
+Assume the same finite bit/complex suppliers, common-label arithmetic compiler, semantic guard and all-size fixed-tape interfaces as the selected conditional PR1094 result. Also assume the new deferred-reservation, support-limited H supplier, shallow-circuit tensorization, and grouped sparse/core-halo lemmas below have their stated uniform implementations. Then the retained integer-multiplication reduction runs in
+
+`O(n (log n)^(1-kappa))`,  `kappa=0.001672664764353193`.
+
+Here p=Theta(log n) and the live scalar bit volume V=Theta(n). Global one-axis preprocessing is polynomial in the original axis sizes and p, hence `n^o(1)`. Table construction or page loading repeated per coarse block is charged to its superpolynomial `L^g` payload by the tensor/scan lemmas; it is included in the displayed V costs, rather than called one global preprocessing operation. Every cost row below is `O(V p^e polylog p)` with `1-e>kappa`. The minimum excess is greater than `10^-11`. Consequently every fixed logarithmic factor and each use of the unconditional quasi-linear short arithmetic kernel can be absorbed in a single positive fraction of that excess. Floors, rounded alpha, and dyadic L alter constants or logarithmic factors. All claims are eventual in p; one fixed finite prefix of inputs can use the retained elementary fallback. This statement becomes an admitted theorem only when the named implementation hypotheses receive the intended full review.
+
+## Parameter convention
+
+Let `a_bit=0.001733427039589844234749` and `b=0.001675462676808103522925` be the retained lower bounds certified by the selected PR1094 replay. For applying the older compact recurrence, lower the usable bit saving to `a_eff=(b+q)/2`; this keeps its historical convention `a_eff<b` while retaining a strict supplier margin. It does not claim a stronger bit supplier.
+
+Use actual `alpha^2=O(log p)` as in the logarithmic diagonal-dominance audit. The symbol `r=10^-6` is only a spare upper-bound exponent: eventually `alpha^2<=p^r`. The narrow and broad Gaussian bandwidths are both `O(sqrt(p) polylog p)`. The group guard is conservatively bounded by `g p^r d`, although the actual logarithmic choice is better.
+
+Write `d=p^epsilon`, `g=p^beta` (integer parts change constants), `L=Theta(p^8)` dyadic microbox side, and `A=Theta(p^3)` locality halo. The retained target axis lengths exceed every polynomial in p, and their logarithms are `Theta(p/d)`. Keep the retained near-one prime/dyadic capacity bound `T/S<2`.
+
+## The exact dense-path objects
+
+The inverse path must use the actual globally fixed rounded narrow matrix H from the retained phase-cell proof. Let C select the increasing nearest positions q_j and let E be its injection into the target grid. Define
+
+`H_aug = E H C + (I-E C)`.
+
+After simultaneously ordering selected positions first, this is exactly `H direct_sum I`. Thus its row gap, row norm, inverse bound and principal-window locality follow from those of H. Because q increments are one or two, its physical target-grid bandwidth is at most `2w+2`. A principal target-grid window contains a contiguous source interval plus identity hole coordinates. The inverse on the selected rows is exactly `E H^-1 C`. Multiplying its selected outputs by the retained `D_normalized/2^j` and setting its hole outputs to zero realizes compression, followed by an increasing q-image extraction.
+
+The expansion path uses the square target-grid completion in `../gaussian_fast_ultra/FORWARD-SMALL-A-AUDIT.md`. The input is the one-pass q-image embedding with zero hole entries. Identity columns at holes make the completion invertible but contribute zero to the desired expansion. The principal non-hole phase blocks are two diagonal factors around a symmetric broad Gaussian Toeplitz matrix. Their finite inverses are polynomially bounded at `alpha^2=O(log p)` by the small-parameter bilateral LDU argument; their raw diagonal range is `O(d/alpha^2)`, below the common `O(alpha^2 d)` guard allowance. This is a different Gaussian matrix from the narrow H, and cannot be replaced by H without proof.
+
+Normalize the completed augmented forward matrix by 4. The retained broad map has row norm below 2, so the identity-hole augmentation has row norm below 3; division by 4 is therefore a contraction on arbitrary inputs, including numerical error in hole coordinates. On the intended zero-hole subspace this introduces an additional factor 1/2 per axis relative to the former S/2 convention. Compensate by a single exact `2^D` output scale for D resampled axes, increasing the retained gamma by D. Since D=O(d)=o(p), this costs only O(d) extra bits and one O(V) shift scan. The exact Fourier/resampling identity is retained after that stated scale adjustment.
+
+In both paths refine physical phase cells into dyadic interiors separated by O(wide-bandwidth) boundary groups. Preserve the original physical period cut. The refinement increases the boundary count by only `O(log d)` and keeps scalar Schur bandwidth O(wide-bandwidth). It uses exactly the original rounded coefficients and weights, with no local rerounding.
+
+All target holes belong to the boundary: inside one original phase cell `q_j-j` is constant, so its selected target positions are consecutive. Hence each dyadic interior is an ordinary contiguous selected interval, not a masked Toeplitz matrix. Use the maximum broad/narrow physical bandwidth W in both directions and every separator. Using only the smaller narrow bandwidth for the forward partition would leave forbidden interior-to-interior edges.
+
+## Five factors and the scope of the sparse union
+
+For an interior/boundary partition M=[A B; C D], put `S=D-C A^-1 B`. The inverse and forward identities are respectively
+
+```
+M^-1 = diag(A^-1,I) E_-B diag(A,S^-1) E_-C diag(A^-1,I),
+M    = diag(A,I) E_C diag(A^-1,S) E_B diag(A,I).
+```
+
+Here the two off-diagonal shears use **original** B and C, which are banded. Each sparse factor acts inside the union of the boundary slabs and the O(wide-bandwidth) neighboring interior slabs. That union is invariant during that sparse factor. A dense A or A^-1 stage can spread its support throughout an interior; the implementation gathers the sparse union afresh after each dense stage. It never assumes the union remains invariant across a dense stage.
+
+There are a fixed number of dense tensor stages and sparse union stages per group. At a dense stage the generic circuit tensorizer supplies all g local circuits together, with cost `O(V g^(1-q) polylog p)`, plus its paid bit routing. Distinct cell origins and dyadic size classes change coefficient tables and switch controls but not the common routing schedule. Identity blocks use identity stages. No data-axis padding by a constant factor is permitted.
+
+Each compiled H stage is invoked on the **whole complete tensor stream across all coarse labels**. It is not separately invoked inside one fixed coarse-label microbox. The H schedule selects the same local bit positions for every label and its completed operator preserves all coarse coordinates. The coefficient-dependent diagonal stages run between completed H calls and may scan one coarse block at a time. Thus a supplier may temporarily borrow complete high/coarse bits from the selected original dyadic axes and restore them before a diagonal is evaluated. This distinction is necessary: `log2 L` local bits alone are shorter than a `K=128G` compact neighborhood.
+
+Every selected bit can have a complete K-bit neighborhood from its original axis, because the true axis bitlength is `Theta(p/d)` and eventually exceeds every fixed multiple of log p. The supplier's internal coordinate frames must be implemented by support-limited permutations involving only those g neighborhoods, its O(gG) reserved controls and O(log g) row roles. The union of these positions is O(g log p); the endpoint routing therefore costs `O(V g^(1-a_eff) polylog p)`, not a fresh `O(V p^(1-a_eff))` at every H call. The independent support audit must verify the actual compact frames, rather than inferring this charge solely from the final selected-bit support. The initial global microbox gather and final inverse gather may still use the separately paid full-address router.
+
+## Target-grid cores avoid non-dyadic dense halo fields
+
+The dense path uses only the dyadic L-sized target cores. It does not pad the retained `(L+2A)` target halo length to 2L on every axis. For compression, the row-Neumann locality proof is applied to `H_aug` (bandwidth at most `2w+2`); enlarging A by a fixed factor covers that bandwidth and the q-image conversion. Core outputs within a fixed multiple of A of any microbox boundary are repaired by separately gathered sparse halo rectangles. Outside those strips the principal-core inverse has the retained exponentially small row error. Expansion is banded after Gaussian truncation and has the same simpler core/halo split.
+
+Partition exceptional outputs by the first exceptional axis and side. For halo thickness a fixed multiple of A, the exact rectangular-copy count is `O(V g A/L)` per group. Process only those copied rectangles by the retained sequential g-axis local algorithm, with temporary padding of its **current single field** removed after each operation. Its cost is bounded by
+
+`O(V (g A/L) g [1+w^2/d] polylog p)` per group,
+
+plus sparse sorting and metadata. This is negligible at L=Theta(p^8), even if the group-key length `K=O(g p/d)` and another fixed polynomial factor are charged. The original local contraction and tensor error argument applies to each rectangle, because all its inputs are original group inputs and unprocessed axes retain their supplied halos. Erroneous principal-core edge outputs are discarded, never recycled as purported global halo values.
+
+The full source-to-q-image embedding and its inverse extraction preserve lexicographic order in each coordinate. Enumerating the target rectangle and testing all q-image predicates costs O(p) per p-bit coefficient record. They therefore take one O(V) pass, using the retained near-one volume bound. The same record accounting permits membership tests for the sparse union in one pass. Multiplication by a separable diagonal uses the tensorizer's nested prefix-product scan; it does not multiply g coefficients afresh for every scalar record.
+
+## Remaining old outer rows
+
+The main synthetic transform must use the deferred-reservation layer from `../radical_reduction_ultra/README.md`, including the support-limited global layout replacement. Its total cost is `O(V[p^(1-a_eff)+p*d^-q] polylog p)`. In particular, retaining the old per-top-axis bit moves or power-width reservation condition would reintroduce an invalid row. The common-layer recurrence may use any fixed stopping exponent `t_stop>0` with `(1-t_stop)b>a_eff` and `q<(1-t_stop)b`.
+
+For each visited coarse block and group, all required local coefficient pages can instead be regenerated in polynomial time in p: there are g local windows of size at most L=Theta(p^8), their rational origins have O(p/d) bits, and the published local coefficient/Schur/circuit constructors are polynomial in that size and requested precision. Recover local phases and anchor gauges from these origins; do not form a raw uncentered global q² exponential on the data. The page contains O(p)-bit online coefficients. Its polynomial setup and sequential loading are amortized by the complete `L^g` payload, which eventually dominates every fixed power of p. This gives an explicit access method even when the coarse labels are permuted; no random global coefficient-table lookup is assumed.
+
+Global chirps, twists, positive diagonal normalizations and exact scale factors are separable products. The prefix-product scan supplies their products in O(V polylog p), with completed scalar range `O(d alpha^2)=o(p)`. Packed polynomial products retain their saving epsilon. The finite supplier, exact common-label frame, whole-call hosting, semantic depth bound with C1=1, phase precision, prime packing and fixed-tape input/output assumptions are inherited unchanged. They are still conditional interfaces, as in the selected result.
+
+## Cost ledger, with conservative wide bandwidth
+
+Let `h_w=1/2` and `h_K=beta+1-epsilon`. Normalize all costs by V. Fixed logarithmic factors are absorbed by strict gaps.
+
+| Component | power of p | reason |
+|---|---:|---|
+| main transform | `1-epsilon*q` | deferred reservations |
+| constant global coordinate routing | `1-a_eff` | paid support/full router |
+| dense Gaussian groups | `epsilon-q*beta` | `(d/g) g^(1-q)` |
+| grouped bit routing | `epsilon-a_eff*beta` | same grouping, bit supplier |
+| one/fixed group scans | `epsilon-beta` | d/g groups |
+| boundary algebra | `(omega-1)*h_w` | batched w-column Strassen |
+| sparse union, basic movement | `beta+h_w` | V g w overall |
+| sparse union, conservative key surcharge | `beta+h_w+h_K` | full active-group keys |
+| polynomial products | `1-epsilon` | retained short polynomial products |
+| core-face corrections | `epsilon+beta+3-8+2` | old local maps on sparse copies, with a loose p² allowance |
+
+Use the rational upper bound `omega<45/16`, checked by `7^16<2^45`. The target balances the first and third rows exactly before a fixed 10^-11 absorption backoff.
+
+This ledger is accepted only after its circuit tensorizer, grouped sparse route, target-grid core/halo adapter, forward small-a inverse bound, and deferred-reservation interfaces have written proofs. Exact positive inequalities alone do not discharge those interfaces.
diff --git a/research/native-kappa-30201655/modern-sources/PARTIAL-FUSION.md b/research/native-kappa-30201655/modern-sources/PARTIAL-FUSION.md
new file mode 100644
index 0000000000..876f44a23e
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/PARTIAL-FUSION.md
@@ -0,0 +1,60 @@
+# Partial tensor fusion: a strictly better prospective outer balance
+
+This is a prospective cost theorem, not an implemented resampler. It changes the full-fusion target to a smaller interface whose precision is payable.
+
+Suppose the normalized holes construction is completed so that a g-axis Gaussian group is a fixed number of tensor geometric/Toeplitz convolutions, diagonal factors, and corrections supported on the hole rows, and suppose its halo gather/scatter has the same asymptotic cost. Let d=p^epsilon and a=Theta(log d), theta=Theta(1/d).
+
+The exact normalizations developed in HOLES-AND-Q-LDU.md have local logarithmic range O(a/theta)=O(a d) per axis. Therefore g axes can be fused with O(p) guard bits if
+
+```
+g*a*d = O(p).
+```
+
+Taking `g=p^(1-epsilon-zeta)` for fixed zeta>0 pays the logarithm and leaves strict slack. There are d/g groups. A group convolution using the retained supplier with saving q costs, after division by full volume,
+
+```
+g^(1-q) polylog p.
+```
+
+Thus all Gaussian groups cost
+
+```
+(d/g)*g^(1-q) = d/g^q
+             = p^[epsilon-q*(1-epsilon-zeta)].
+```
+
+Its saving is `(1+q)*(1-epsilon)-q*zeta`. The main synthetic transform, using deferred reservations, retains saving epsilon*q. Ignoring the arbitrarily small fixed zeta and strict absorption gaps, balancing yields
+
+```
+epsilon=(1+q)/(1+2q),
+kappa=q*(1+q)/(1+2q).
+```
+
+This exceeds the old `q/(1+q)` by exactly
+
+```
+q^3 / ((1+q)*(1+2q)).
+```
+
+That is a new outer balance, rather than tighter rational margins in the old family. At the selected complex endpoint the difference is about 4.7e-9. For example take q equal to the selected complex saving minus 10^-10, zeta=10^-8, the displayed epsilon, and kappa ten^-11 below the smaller main/Gaussian margin. The resulting exact arithmetic target is approximately
+
+```
+0.00167266475042434534254271472,
+```
+
+about 4.55335e-9 above the selected 0.001672660197076918. This is only a prospective target until both missing interfaces below are established.
+
+## Other paid terms
+
+The bit routing saving is larger than q at the selected pair. Moving a group of O(g log p) small coordinate bits across spectator fields costs O(V g^(1-a_bit) polylog p) per group, hence O(V d/g^a_bit polylog p), below the convolution cost since a_bit>q. A superpolynomial untouched spectator suffix remains available while processing a group, so the compact supplier's descriptor work can still be paid; pointwise small-polynomial products require a separately paid small-field transpose but only logarithmic-width fields.
+
+The g-axis scalar normalization costs O(g a), and the stronger local weights cost O(g a d); both fit O(p) by construction. For local convolution window L=O(p/a+d), take a dyadic microtile N≫gL. The total halo volume is bounded by `(1+O(L/N))^g=O(1)`. The gauge increment bound implies total logarithmic variation O(g[a theta N+a/theta]); with N=Theta(gL), the extra condition is g^2<=O(d). It holds at the proposed epsilon near one, since 2(1-epsilon)<epsilon.
+
+The hole system has only theta times the rows. The favorable complementary Gaussian width is O(sqrt(p theta/a)); even a classical banded application has regular cost O(V d theta*(p theta/a)), which at theta≈1/d is O(V p/(a d)). This is far below the proposed main exponent. This cost statement still requires the symbolic-normalization adapters to preserve that sparsity.
+
+## Precisely unproved steps
+
+1. Complete normalized holes factorization into a fixed number of grouped convolutions and a genuinely hole-supported correction, with O(p) records after all diagonal cancellations. The weighted full-geometric component is proved in the companion note; the Toeplitz/complement adapters are not.
+2. Implement g-axis near-one halos/gathers in the proposed group cost, instead of silently using g full scans. A dyadic boundary-subset decomposition has total volume `(N+O(L))^g=O(N^g)`, but this does not itself prove fast movement of the nonlinear boundary signature. Padding all axes to 2N would be invalid.
+
+The unchanged paid resampler retains Vd work and rejects this target. These are explicit positive next lemmas, not conditions erased from a certificate.
diff --git a/research/native-kappa-30201655/modern-sources/README.md b/research/native-kappa-30201655/modern-sources/README.md
new file mode 100644
index 0000000000..7d0b3a41bf
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/README.md
@@ -0,0 +1,210 @@
+# Outer reduction: deferred reservations and batched Gaussian solves
+
+**Status: two scoped construction refinements, one explicit conjectural route; no new final multiplication exponent.** The selected conditional exponent remains `0.001672660197076918`. The proposed target `0.00167498` below depends on a tensor-resampling lemma that is not proved here. This package does not change a selected certificate.
+
+Base checkout: `work/integer-mult-current`, commit `e6f9716621f4e01fc190617934cdfaf072bd976f`. Prepared with substantial AI assistance. Apache-2.0; original sources and contributor credit are retained by reference.
+
+## 1. Where the present loss occurs
+
+Write `a` for the effective bit saving, `b` for the complex saving, `q` for the strict implemented complex-layer saving, `d=p^epsilon`, and `u=alpha^2=p^r`. The selected endpoint data are
+
+```
+b = 0.001675462676808103522925
+a = 0.001733427039589844234749
+kappa = 0.001672660197076918.
+```
+
+The current balanced outer construction has, up to strict backoffs, the two costs `V p^(1-epsilon*q)` and `V p^epsilon`; the second comes both from reserved/extra axes and from scalar/bulk-resampling passes. In addition, its reserved-axis treatment uses `K=d^c`, requires `c>q`, and requires `dK=o(p)`. Thus even if all Gaussian work disappeared, retaining that reservation argument would still force `epsilon<1/(1+q)`. It is insufficient to erase just the Gaussian row from a ledger.
+
+The selected outer logic was read in `research/complex-pr615-ceiling/vendor/multicold/engines/outer.py`; its seven margins and 47 slacks match the current 1094 assembly. The underlying detailed interfaces are in upstream sections 02, 04, 05, 06, 07, 08, 09, 10 and the cited `references/semantic-bulk/rad20/reports/` transfer notes. In particular, the current bulk Gaussian proof already uses local principal windows and short fields; proposing that same improvement again would not change the selected result.
+
+## 2. Deferred reservations: removing the power-width reservation condition
+
+This is an all-size **conditional transfer argument**, assuming the retained complete rectangular compact gadget, exact common-frame circuit, arbitrary coordinate router, and linear semantic guard. It does not require a new finite supplier identity.
+
+Let `G=4 ceil(log2 p)+6`, and choose `K=128G`. At a layer on `h` still-unprocessed selected bits, reserve enough complete K-bit chunks to provide the two front H-bit fields, one back H-bit field, and row bits, where `H=hG`. The number of reserved chunks is
+
+```
+R(h) = ceil(3hG/K) + O(log h).
+```
+
+For `h` above a fixed polynomial in `log p`, `R(h) <= h/16`. Select those chunks from the still-unprocessed axes. Apply the retained compact circuit to the other `h-R(h)` bits, borrowing all three dirty fields from the reserved subset. At the completed-call boundary it is exactly `C` on the active bits and identity on every reserved or spectator bit, for arbitrary initial coefficients and arbitrary dirty addresses. Therefore all reserved bits retain their original complete ranges and can be processed next.
+
+Repeat on the reserved subset. The processed subsets are disjoint. Stop once `h=polylog(p)` and apply those remaining kernels individually. This is **not** a recursive call on a truncated record or a clean-scratch claim: the entire original stream is still present, with the same full polynomial suffix, and every previously processed coordinate is an untouched spectator. Completed kernels on disjoint selected bits commute. All row padding is removed before moving to the next phase, so temporary factor-two padding never multiplies across phases.
+
+To establish the time bound, retain the original `m,W,s` recurrence and stop its internal recursion at `d^beta`. With `sigma=1-b`, any `lambda>max(1-a,sigma)` gives, with logarithmic factors suppressed,
+
+```
+F(h) <= O(h^lambda + h^sigma d^(beta*(1-sigma)) + 1).
+```
+
+This follows because a packed local basis change has width `O(hG)` and hence cost `O(V h^(1-a) polylog p)`. The term formerly written `(h d^c)^(1-a)` is now `h^(1-a) polylog p`. All compact-gadget exceptional fractions remain polynomially small with K=128G; the retained repair proof uses the current call's O(p)-bit address and is not replaced by a global exception count.
+
+Since `h_j <= d/16^j` above the polylogarithmic tail,
+
+```
+sum_j F(h_j)
+  = O((d^lambda + d^(sigma+beta*(1-sigma))) polylog p).
+```
+
+The extra physical rearrangements of complete existing fields cost
+`O(V p^(1-a) polylog p)` by the retained arbitrary coordinate router, over O(log d) phases. Its polynomial descriptor work is paid by the unchanged superpolynomial polynomial-record suffix, at every internal call. This is additive, not free routing.
+
+Consequently, for every fixed `q < min(a,(1-beta)*b)`, the whole layer has
+
+```
+O(V [d^(1-q) + p^(1-a)] polylog p).
+```
+
+The common guard remains O(d): each completed phase changes semantic numerator/denominator bounds by O(h_j), and `sum h_j=O(d)`. Only the currently active phase contributes its internal excess. There is still exactly one truncation after the entire normalized layer. No power K=d^c and no condition c>q remains. K=o(ell) now follows from `ell=p^(1-epsilon)` for every fixed epsilon<1.
+
+The extra top round on the long axes can use the same layer after a paid coordinate rearrangement collecting its selected bits and K-bit complete neighborhoods. The common rounds use a single paid global layout router, rather than `p/K` separate K-swaps. Thus the transformed version of the synthetic cost is
+
+```
+O(V [p^(1-a) + ell*d^(1-q)] polylog p).
+```
+
+This is the strongest positive transfer established by the present note. It removes the geometric source of `q/(1+q)` in the compact compiler. It does not remove the independent O(Vd) Gaussian and scalar costs.
+
+### Checks
+
+`check_constructions.py` checks 1,000 exact reservation schedules and 5,460 entries of actual Gaussian-rational `C` tensor matrices. Every axis is processed once; the phasewise output equals the independently calculated closed tensor matrix. Omitting the deferred subset is a retained failing control. These checks support the written argument; they are not an all-size compiler implementation.
+
+## 3. Batched right-hand sides for the Gaussian boundary inverse
+
+This refinement applies to the precomputed noncyclic banded L/U factors in the retained principal-window solver. It uses the many spectator lines carrying the same axis matrix.
+
+For a triangular matrix with scalar bandwidth w, group consecutive rows into blocks of a power-of-two width `B in [w,2w)`. There is only one preceding block in a lower solve (one following block for an upper solve). Precompute each diagonal-block inverse. For B simultaneous right-hand sides, the update is
+
+```
+X_j = L_jj^-1 * (Y_j - L_j,j-1 * X_j-1).
+```
+
+Two B-by-B products implement each update. The seven-product identity gives `O(B^omega)` scalar operations, `omega=log_2(7)`. For z boundary rows and R>=B right-hand sides, splitting the columns into B-column batches gives
+
+```
+O(z R B^(omega-2))
+```
+
+scalar work. Incomplete edge blocks and the last RHS batch are zero-padded only for the current product; this is a constant temporary volume increase, not a tensor-axis padding factor. The matrices may vary from row block to row block. No Toeplitz assumption is made.
+
+The original boundary has `z=O(M w/d + w)` rows in a length-M local window. Summed over axes and lines, the old regular contribution `V w^2` becomes
+
+```
+O(V w^(omega-1) polylog p).
+```
+
+The artificial-end contribution is handled by a polynomial-size microbox L; it is
+`O(V d w^(omega-1)/L polylog p)`. The O(Vd polylog p) local field motion and interior-convolution cost is still paid and is still present.
+
+### Tape layout
+
+Expose the same axis and factor page used by the retained solver. Gather B adjacent RHS indices with a B-valued local field, moving that O(log p)-bit field across the current row field by the retained small-field transposition. It costs O(V log p) per axis. This charge belongs to the existing d-pass term. Read factor pages and RHS row blocks sequentially. Keep the immediately preceding solved B-by-B block on a fixed work tape. Products use a depth-first seven-product recursion, parking/restoring the other finitely many matrices at each node; scanning and quadrant rearrangement is O(B^2) per level and is dominated by B^omega. There is no random factor lookup and no separate tape for every RHS.
+
+### Precision
+
+Keep the retained O(p)-bit rounded factor entries and compute each B-by-B product exactly as a dyadic matrix product before one component rounding. An individual seven-product recursion has depth log B. Additions grow integers by only O(log B) bits at every product boundary, so exact products and their sums have O(p+log B)=O(p) bits. A block inverse is precomputed at the retained high precision, with its row-norm perturbation charged explicitly.
+
+Round after a completed block update, not between scalar products. The residual of the completed triangular system is bounded rowwise by `poly(p)*2^-P*(1+||X||)`, with P the retained large constant multiple of p. The retained inverse-norm bounds then give a uniform global solution error after absorption, independent of the number of row blocks. This is the same residual closure used by the original banded solver; it must be instantiated with new block-factor rounding constants in any adoption. An unproved claim of numerical stability of fast floating-point multiplication is unnecessary.
+
+For `u=p^r`, `w^2=O(p^(1-r))`. The revised regular boundary exponent is
+
+```
+((omega-1)/2)*(1-r),
+```
+
+whose saving at r=0 is `(3-log_2 7)/2 > 0.096`. Thus an implemented version could remove the old requirement r>kappa while keeping `epsilon+r<1`. It cannot remove the separate O(Vd) scan term by itself.
+
+### Exact checks and remaining check
+
+The script independently compares seven-product multiplication against classical multiplication, then compares 60 varied-size blocked triangular solves against exact Gaussian-elimination inverses (1,976 output entries). A dropped-predecessor-block control fails. This establishes finite algebraic orientation, padding and dependencies. A complete adaptation of the original numerical residual constants is still required before adopting the changed analytic interface.
+
+## 4. A concrete route toward tensor Gaussian fusion
+
+This section is **conjectural construction work**, not an established algorithm. The missing step is stated so it can be attacked.
+
+A possible way to avoid d separate Gaussian passes is to compute the tensor Gaussian on a microbox through one tensor convolution. For `rho=s/t`, a real Gaussian row has the exact scalar identity
+
+```
+exp[-a(j-rho*k)^2]
+ = exp[-a(1-rho)j^2]
+   exp[+a*rho(1-rho)k^2]
+   exp[-a*rho(j-k)^2].
+```
+
+Integer translations of j and k add only linear factors, so each local rectangle is a diagonal, Toeplitz convolution, diagonal. Across axes, the diagonal factors fuse into one per-record multiplication. The central convolution is a tensor cyclic convolution after sufficient halos.
+
+With the current theta≈1/d, a local Gaussian halo has radius
+`A=O(alpha*sqrt(p))`. To keep product halo volume constant, the core needs length `L=Omega(dA)`. But the fused diagonal logarithmic range is then
+`O(d*theta*L^2/alpha^2)=O(d^2 p)`, not O(p). Thus the most obvious tensor-chirp fusion fails its precision ledger. This explicit failure should prevent a false positive.
+
+One changed hypothesis makes that favorable: choose source primes much closer to t, with `theta=Theta(d^-3)`. Then at `L=Theta(dA)`, that logarithmic range is O(p), and the product halo overhead is still constant. Such prime lengths are available eventually for every fixed epsilon<1: the explicit prime-counting error from Fiori–Kadiri–Swidinsky, Corollary 22, is `O(x sqrt(log x) exp(-c sqrt(log x)))`; on an interval of width `x/d^3`, with `log x=Theta(p^(1-epsilon))`, its error is o(x/(d^3 log x)). The interval contains far more than d primes, so distinct choices and `S/T=1-o(1)` follow. Trial division setup remains `n^o(1)`. This is an asymptotic existence argument with an enormous cutoff, not a practical prime-search claim.
+
+However two serious costs remain unproved:
+
+1. A power-of-two convolution window N has a useful core N-2A. Reinterpreting an axis by these variable non-dyadic cores is not the known binary-coordinate router. Padding every N-2A field to the next power of two costs 2^d. Performing the known small-field reshape one axis at a time costs Vd. A new simultaneous variable-core gather/scatter is needed, with full payload movement charged.
+2. The inverse Gaussian correction is not itself one convolution. With theta=d^-3, the current phase-cell similarity weights range like `exp(O(u/theta))`, too large for its old O(p)-bit proof. The generic banded solve can avoid those enormous weights, but the present batched bound still has a d factor outside its favorable structured regime. The tensor inverse needs a different stable factorization or a sparse-boundary construction with a fully paid ledger.
+
+Therefore “choose closer primes” plus “use a multidimensional FFT” is not a proved bypass. It is an explicit construction program with two specified lemmas.
+
+## 5. Exact optimistic target and fully paid comparison
+
+Assume a new tensor-resampling interface gives
+
+```
+O(V [p^(1-a) + d^(1-q) + w^(omega-1)] polylog p)
+```
+
+for the complete expansion and inverse, including variable-core layout, coefficient factors, stable inverse, all restoration and only O(p)-bit records. Combine it with Section 2. The complete normalized saving is at least
+
+```
+min(a, epsilon*q, 1-epsilon*(1-q),
+    1-((omega-1)/2)*(1-r), epsilon),
+```
+
+with strict `epsilon+r<1`, `q<min(a,(1-beta)b)`, and sufficiently small fixed logarithmic absorption margins. The selected endpoints admit the exact sample
+
+```
+q       = 67/40000       = 0.001675
+epsilon = 99999/100000   = 0.99999
+r       = 1/200000       = 0.000005
+beta    = 1/100000
+kappa   = 83749/50000000 = 0.00167498.
+```
+
+Here `epsilon*q-kappa = 13/4000000000 > 0`, the complex endpoint exceeds q by `0.000000462676808103522925`, and the gamma gap is `0.000005`. The target exceeds the selected kappa by `0.000002319802923082` (about 0.1386894%). Letting epsilon approach one and q approach b would recover the complex saving itself, up to arbitrary strict slack.
+
+**Fully paid ledger today:** without the unproved tensor-resampling interface, the unchanged Vd term remains. It imposes `kappa<1-epsilon`, so maximizing the proven/reused terms still gives at most `b/(1+b)`. Sections 2 and 3 alone do not improve final kappa. Under the displayed sample, the paid Gaussian margin is only `0.00001`, so that sample FAILS the current interface. It is deliberately not emitted as a passing outer certificate.
+
+## 6. Reproduction and evidence
+
+Run from the parent workspace:
+
+```
+python3 work/radical_reduction_ultra/check_constructions.py
+python3 work/radical_reduction_ultra/check_ledger.py
+```
+
+`CONTROLS.json` contains exact finite controls. `LEDGER.json` contains the optimistic row and the correctly rejected fully paid row. Neither imports a producer or mutates the source checkout.
+
+## Open next questions
+
+- Instantiate Section 2 against the exact current compact field-layout code and reject malformed reservoir choices. This is a bounded integration task; it could remove a real interface restriction even before a new final exponent is obtained.
+- Carry the block residual argument in Section 3 through the retained P=32768p constants and factor-page format. The algebraic and layout reductions are explicit; numerical certification is the remaining bounded task.
+- For the fusion program, first prove or disprove a simultaneous variable-core gather/scatter with O(V p^(1-a) polylog p) cost and no 2^d padding. This isolates the data-layout bottleneck before more analytic effort.
+- Seek a stable tensor inverse for near-identity Gaussian resampling with theta≈d^-3 that avoids both enormous diagonal similarities and d sequential full scans. A finite small-d result is not enough; require the exact operator, record width and mass recurrence.
+
+## Primary sources and attribution
+
+- CrocSwap/integer-mult-bounds pinned upstream and transfer reports, in particular 02-streams, 04-swap, 05-layers, 06-transforms, 07-resampling, 08-assembly, 09-exact-arithmetic, 10-transposition; reviewed contributions by Douglas Colkitt and the cited independent contributors are retained unchanged.
+- Harvey and van der Hoeven's original Gaussian resampling and multiplication interfaces are inherited through those source proofs.
+- V. Strassen, *Gaussian Elimination is Not Optimal*, Numerische Mathematik 13 (1969), 354–356, DOI `10.1007/BF02165411`. The seven-product identity is reproduced and independently checked here; no modern matrix multiplication exponent is needed.
+- A. Fiori, H. Kadiri, J. Swidinsky, *Sharper bounds for the error term in the prime number theorem*, arXiv:2206.12557v2, Corollary 22: https://arxiv.org/pdf/2206.12557 . Used only for the clearly marked close-prime construction program.
+
+## Later constructive developments
+
+The positive interpolation-tree and global two-tail results are in `STABLE-POSITIVE-TREE.md`, with exact controls in `POSITIVE-TREE-CONTROLS.json`. They provide bounded gauges for every signed-data intermediate and show that all high-level rank-one contributions collapse to two global running sums. Its Section 6 gives a normalized Sylvester factorization into a dirty Toeplitz shear, one well-conditioned full Toeplitz map, and one triangular Toeplitz map; `SYLVESTER-CONTROLS.json` checks that identity.
+
+The stronger fixed-width Gaussian norm theorem is independently audited in `FIXED-A-PERIODIC-NORM-AUDIT.md`, with `FIXED-A-LDU-CONTROLS.json`. It replaces the earlier sufficient logarithmic-width condition: for any fixed admissible a>=1, the periodic inverse has norm O(theta^-2). This is an analytic parameter improvement, not a completed fast inverse.
+
+The outer partial-fusion candidate in `PARTIAL-FUSION.md` remains prospective. Neither the stable, shallow in-place algebra for plain Toeplitz matrices nor bounded final Gaussian conditioning alone proves that the curved Gaussian coefficient gauges can be processed with only O(p) total guard bits when many axes are fused. That interface, and the actual halo movement cost, must be resolved before claiming a new kappa.
diff --git a/research/native-kappa-30201655/modern-sources/REFINED-PHASE-FUSION.md b/research/native-kappa-30201655/modern-sources/REFINED-PHASE-FUSION.md
new file mode 100644
index 0000000000..51920b3b76
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/REFINED-PHASE-FUSION.md
@@ -0,0 +1,125 @@
+# A narrower positive route: fuse retained phase-cell interiors
+
+Status: a complete parameter ledger for a concrete conditional transfer. It avoids the unresolved normalized-erasure adapter. It still requires the new shallow in-place structured-matrix circuit to be integrated with the retained fast tensor supplier and a grouped sparse boundary gather. No new selected certificate is asserted.
+
+## Construction
+
+Keep the already reviewed phase-cell Schur decomposition, with
+
+```
+d=p^epsilon, u=alpha^2=Theta(p^r), w=Theta(p^((1-r)/2)),
+0<r, epsilon+r<1, epsilon>(1-r)/2.
+```
+
+The positive r may be arbitrarily small; it eventually dominates the old logarithmic lower bound on u. Thus this route can retain the established diagonal-dominance, rounded H, local inverse, and Schur residual proofs. The stronger fixed-a theorem is not needed here.
+
+Within each no-gap phase cell, the interior matrix is exactly
+
+```
+A=diag(a_j) G diag(a_j)^-1,
+G_ij=G_(i-j), log(max a_j/min a_j)=O(u d).
+```
+
+The retained G is a symmetric truncated Gaussian Toeplitz matrix with `||G-I||<1/8`; hence G and G^-1 are uniformly conditioned. Apply its inverse by the new shallow in-place low-displacement circuit, rather than summing the two Gohberg-Semencul branches. The circuit's Toeplitz coefficients and Schur generators are precomputed. This is the algebraic connection to the new in-place work; the old source proof did not provide such a tensor-fusible circuit.
+
+Fuse
+
+```
+g=p^beta, beta=1-epsilon-r-zeta,
+```
+
+axes at a time, with fixed zeta>0. The total diagonal similarity guard is
+`O(g u d)=O(p^(1-zeta))=o(p)`. Polylogarithmic circuit depth and bounded polynomial factor growth add only `O(g polylog p)=o(p)` bits. Every completed group has polynomial norm; error is allocated at the completed-group boundaries, preserving the retained O(p)-bit record model.
+
+### Dyadic interiors without exponential padding
+
+Inside a phase cell, repeatedly choose the largest power of two K such that `K+2w` fits the remaining interval, while its remaining length exceeds 4w. Make a piece of length K+2w, designate w endpoints on each side as boundary, and use its K remaining indices as the interior. The leftover interval of length at most 4w is all boundary.
+
+The remaining length at least halves on each step. Thus there are O(log d) pieces per original cell, every interior has dyadic length, and the total boundary size grows by only O(log d). No padding by a factor two per tensor axis is used. Schur fill still joins only the two w-sized endpoint groups of a piece, so its scalar bandwidth remains O(w). Distinct dyadic size classes require only O(log p) circuit schedules; inactive axes use identity stages.
+
+### Boundary arithmetic
+
+Let R denote the number of spectator right-hand sides, which eventually exceeds every polynomial in p. Batch them in groups of w. Every dense w-by-w block multiplication in the banded forward/backward solve, the border correction, and the boundary/interior couplings then costs O(w^omega) scalar products for w right-hand sides, omega=log_2(7)<2.8081. The retained no-pivot factors are precomputed; Strassen creates only polynomial intermediate growth in w, hence O(log p) extra guard bits. Use the existing global residual argument to bound the completed solve error.
+
+There are O(s*w*log(d)/d) boundary rows per axis. Consequently the total boundary arithmetic over all d axes is
+
+```
+O(V * w^(omega-1) * polylog(p)),
+```
+
+where V counts p-bit data volume. This includes H_BI and H_IB couplings; doing those couplings scalarly would incorrectly reintroduce V*w^2.
+
+### Five stages separate fused interiors from sparse corrections
+
+For the interior/boundary order write H=[A B; C D] and S=D-C A^-1 B. The exact identity
+
+```
+H^-1 = diag(A^-1,I) [I -B;0 I] diag(A,S^-1)
+       [I 0;-C I] diag(A^-1,I)
+```
+
+is verified by multiplication. Thus the only full-interior stages are A and A^-1. The two shears use original banded B and C, whose support is within O(w) of each artificial cell boundary. The middle factor splits into the commuting interior A and boundary S^-1.
+
+For a g-axis group, collect the union U of the O(w log d)-wide endpoint slabs. Its volume is O(V*g*w*log(d)/d). All sparse shear and boundary stages preserve this union; outside it they are identity. Process the g axis operators sequentially on U, without g scans of the full V data. Even a deliberately loose movement cost is
+
+```
+O(V*g^2*w*polylog(p)/d) per group,
+O(V*g*w*polylog(p)) over all d/g groups.
+```
+
+Add one full scan per group to gather/scatter U, for O(V*d/g). This is below the proposed fused interior cost at the displayed parameters. Dense boundary arithmetic is still batched as above and costs O(V*w^(omega-1)*polylog p); scanning inactive entries in U is included in the movement bound.
+
+The union-slab gather/scatter and the evaluation of its piece catalogues must be implemented in the retained macro-routing model. The address fields have polynomial length and g*polylog(p)=o(p), but that observation alone is not a tape routing proof. Importantly, the cost budget now tolerates a sequential factor g on the **sparse union**, so the required route is weaker than a fully fused boundary solver.
+
+## Paid exponents
+
+Let q be strictly below the supplied complex saving and below the bit saving. The proposed dominant costs, normalized by V, are
+
+| Component | Power of p | Saving |
+|---|---:|---:|
+| Main transform with deferred reservations | 1-epsilon*q | epsilon*q |
+| Fused Gaussian interior / convolution groups | epsilon-q*beta | 1-epsilon+q*beta |
+| Group bit routing | epsilon-a_bit*beta | 1-epsilon+a_bit*beta |
+| Sparse group scans | epsilon-beta | 1-epsilon+beta |
+| Boundary algebra | (omega-1)*(1-r)/2 | 1-(omega-1)*(1-r)/2 |
+| Sequential operations on sparse union | beta+(1-r)/2 | (1+r)/2-beta |
+
+Every entry has an explicit cost source above. The similarity/normalization condition is `epsilon+r+beta<1`. The old full-axis scan Vd is not part of the claimed implementation; until its replacement is proved, this remains conditional.
+
+Ignoring arbitrarily small zeta and strict absorption margins, balancing the first two rows gives
+
+```
+epsilon=(1+q-q*r)/(1+2q),
+beta=(q-(1+q)*r)/(1+2q),
+kappa=q*(1+q-q*r)/(1+2q).
+```
+
+This is feasible for `0<r<q/(1+q)`. Its improvement over the old same-q balance is
+
+```
+kappa-q/(1+q)
+ = q^3/((1+q)*(1+2q)) - q^2*r/(1+2q) > 0.
+```
+
+Thus positive r is compatible with a strictly larger exponent, while retaining the old phase-cell analytic hypotheses.
+
+One explicit arithmetic target uses
+
+```
+q=0.001675462576808103522925,
+r=0.000001,
+zeta=0.00000001,
+epsilon=(1+q-q*(r+zeta))/(1+2q),
+beta=1-epsilon-r-zeta,
+kappa=epsilon*q-0.00000000001.
+```
+
+It yields
+
+```
+epsilon = 0.9983301313358845139763404147924773...
+beta    = 0.0016688586641154860236595852075227...
+kappa   = 0.0016726647643531934852000135266363...
+```
+
+The proposed kappa exceeds the selected 0.001672660197076918 by about 4.5672763e-9. Its boundary saving is greater than 0.09595, its sparse-scan saving is greater than 0.0033387, its sparse-union saving exceeds 0.49833, and the bit saving is strictly larger than q. This target is deliberately **not** promoted: the new circuit/supplier integration and grouped sparse tape route must first be proved.
diff --git a/research/native-kappa-30201655/modern-sources/SHALLOW-TOEPLITZ.md b/research/native-kappa-30201655/modern-sources/SHALLOW-TOEPLITZ.md
new file mode 100644
index 0000000000..bc4349b2da
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/SHALLOW-TOEPLITZ.md
@@ -0,0 +1,197 @@
+# Shallow, stable, dimension-preserving Toeplitz circuits
+
+Status: a positive algebraic circuit construction for **dyadic local tiles**. It gives the missing full-Toeplitz primitive in the normalized Sylvester merge. It does not reconcile the anchor coordinates with the original Gaussian gauges; that remains a separate obligation. The construction uses no data ancilla, no zero-initialized coordinate and no fan-out. Fixed coefficient generation is allowed polynomial time in the local tile size and precision.
+
+## 1. Result
+
+Let N be a power of two, and let H be an N by N real or complex Toeplitz matrix with
+
+    max(||H-I||_1, ||H-I||_infinity) <= delta < 1/4.
+
+There is an N-wire linear circuit applying H, with O(log^4 N) rounds of disjoint invertible 2 by 2 gates and diagonal gates, O(N log^4 N) gates, and polynomial-in-N bounds for all coefficients and all partial circuit operator norms and inverse operator norms. Constants depend only on delta.
+
+For any requested output accuracy 2^-p, rounding the coefficients to p+O(log N) bits gives operator error at most 2^-p; arithmetic at that precision also gives uniform forward error 2^-p on bounded inputs, after allowing the same O(log N) guard bits. A rational approximation to the input Toeplitz coefficients and all required gate coefficients can be generated using poly(N,p) bit operations. This coefficient preprocessing may use polynomial extra memory; the **data circuit** still has exactly N live coordinates.
+
+The same result applies to upper or lower triangular Toeplitz matrices with max(||T-I||_1,||T-I||_infinity)<=eta for **any fixed eta<1**, with only O(log^2 N) rounds and constants depending on eta. In particular eta=1/2 is permitted for the generator-normalization step below, even though the full-Toeplitz statement uses delta<1/4. Descendants need bounded norm and inverse, not continued distance below 1/4. This independent triangular construction is important: a contiguous bottom-recursion / shear / top-recursion has linear depth even though its work is quasi-linear.
+
+## 2. Dirty Toeplitz shear is a shallow circuit
+
+For disjoint m-coordinate vectors x and y, implement
+
+    (x,y) -> (x,y+Tx),
+
+where T is Toeplitz, in O(log m) rounds when m is dyadic. It is an invertible square map on the existing 2m wires.
+
+Write the first column and row of T as c_0,...,c_(m-1) and c_0,r_1,...,r_(m-1). Set
+
+    g_0=h_0=c_0/2,
+    g_j=(c_j+r_(m-j))/2,
+    h_j=(c_j-r_(m-j))/2,              1 <= j < m.
+
+Then T=C(g)+C_-(h), where C is a circulant and C_- is a negacyclic circulant. For a unitary m-point FFT F, C(g)=F^* diag(DFT(g)) F. A circulant shear therefore consists of F on x and y in parallel, the disjoint pairwise shears y_j+=DFT(g)_j x_j, and F^* on x and y. Every FFT stage consists of disjoint unitary 2 by 2 butterflies; bit reversal is a disjoint swap stage.
+
+For gamma=exp(pi i/m), D=diag(1,gamma,...,gamma^(m-1)),
+
+    C_-(h)=D^-1 C(Dh) D.
+
+Use diagonal twists before and after the same circulant-shear circuit. The two completed shears commute. Source x is restored after each. No circulant inverse is needed, so zero Fourier multipliers cause no problem. Every gate is invertible even when T itself is singular.
+
+All intermediate norms are polynomial in m and the l1 norm of the Toeplitz symbol. In the 2-norm, FFT and twist stages are unitary, and the spectral diagonal has norm at most the symbol l1 norm.
+
+## 3. Independent triangular primitive: parity splitting
+
+Let T_N(f) be lower triangular Toeplitz multiplication by f modulo z^N. Write
+
+    f(z)=e(z^2)+z o(z^2).
+
+Reorder the existing coordinates into even and odd powers, N=2m. Then
+
+    T_N(f) = [ E  ZO ; O E ],
+
+where E=T_m(e), O=T_m(o), and Z=T_m(z). All these m by m triangular Toeplitz matrices commute. Set
+
+    k=o/e mod z^m,
+    s=e-z o^2/e mod z^m.
+
+The exact factorization is
+
+    [ E ZO ; O E ]
+      = [ I 0 ; T_m(k) I ]
+        diag(T_m(e),T_m(s))
+        [ I T_m(zk) ; 0 I ].
+
+Thus apply the right Toeplitz shear, the two child triangular circuits **in parallel**, and the left Toeplitz shear. The recurrence for rounds is
+
+    D_tri(N) <= D_tri(N/2)+O(log N),
+
+giving D_tri(N)=O(log^2 N). The two recursions act on disjoint coordinates. Inverses are obtained by reversing the gate sequence and inverting every gate, at the same depth.
+
+Stability is not proved by multiplying coefficient l1 bounds afresh at each depth. Each child is a principal submatrix or principal Schur complement of the original triangular matrix, after a coordinate permutation. If the initial T_N(f) differs from I in both 1- and infinity-norm by at most eta<1, every descendant M satisfies
+
+    ||M-I|| <= eta+eta^2/(1-eta)=eta/(1-eta)
+
+in both norms, and ||M^-1||_2 <= 1/(1-eta). This follows directly by expressing the descendant as a Schur complement of a principal block of the original matrix; nested elimination and restriction preserve that description. Hence all local diagonal blocks and local Schur multipliers have constant 2-norms. Their triangular Toeplitz coefficient l1 norms are at most sqrt(N) times these constant bounds. The dirty shear circuits from section 2 therefore remain polynomially bounded.
+
+## 4. Full Toeplitz recursion: displacement rank grows additively
+
+Use the Sylvester shift displacement
+
+    Delta_m(M)=Z_m M-M Z_m.
+
+A Toeplitz H has rank Delta_N(H)<=2. At a node of size 2m, partition
+
+    M=[ A B ; C D ],
+    Z_(2m)=[ Z 0 ; E Z ],       E=e_0 e_(m-1)^T,
+    K=A^-1 B, L=C A^-1, S=D-C A^-1 B.
+
+The usual block factorization is
+
+    M=[ I 0 ; L I ] diag(A,S) [ I K ; 0 I ].
+
+Again A and S run in parallel. To bound ranks, let U=[-C A^-1,I] and V=[-A^-1 B;I]. Then M V=[0;S], U M=[0,S], and direct block multiplication gives
+
+    Delta_m(S)=U Delta_(2m)(M) V-S E A^-1 B.
+
+Therefore rank Delta(S)<=rank Delta(M)+1. Also, the upper-left block of Delta_(2m)(M) is Delta_m(A)-B E, so rank Delta(A)<=rank Delta(M)+1. At depth d, both children thus have displacement rank at most 2+d.
+
+The top-right block of Delta(M) equals Delta(B), while its bottom-left equals E A+Delta(C)-D E. Consequently
+
+    rank Delta(B)<=r,
+    rank Delta(C)<=r+2,
+    rank Delta(K)<=rank Delta(A)+rank Delta(B)<=2r+1,
+    rank Delta(L)<=rank Delta(C)+rank Delta(A)<=2r+3.
+
+All shear matrices have displacement rank O(log N).
+
+Every recursive M is a principal Schur complement of the original H. Since H=I+R and both ||R||_1 and ||R||_infinity are at most delta,
+
+    max(||M-I||_1,||M-I||_infinity) <= delta/(1-delta),
+    ||M^-1||_2 <= 1/(1-delta).
+
+The inverse assertion also follows because M^-1 is a principal submatrix of the inverse of a principal submatrix of H. Thus A,S,K,L are uniformly bounded in 2-norm independently of recursion depth.
+
+## 5. Bounded-generator shear compiler
+
+For an m by m matrix T define its Stein displacement
+
+    E_T=T-Z T Z^T=-Delta_m(T) Z^T+T e_0 e_0^T.
+
+Its rank is at most rank Delta(T)+1. Choose an orthonormal basis g_1,...,g_r for the column space of E_T, and put h_j=E_T^* g_j. With conjugates interpreted appropriately,
+
+    E_T=sum_j g_j h_j^*,
+    T=sum_j L(g_j) U(conj(h_j)).
+
+Here L(g) is lower triangular Toeplitz with first column g, and U(h) is upper triangular Toeplitz with first row h. The second identity is the finite telescoping sum T=sum_(k=0)^(m-1) Z^k E_T (Z^T)^k. All g_j have 2-norm 1, and all h_j have 2-norm at most ||E_T||_2=O(1). Their coefficient l1 norms are O(sqrt(m)).
+
+A zero or tiny first coefficient of h is harmless. Choose an integer gamma >= 2||h||_1 (a fixed conservative gamma=64N suffices under the stated bounds), and set
+
+    P=I+U(h)/gamma.
+
+P and P^-1 have constant norm, and P is upper triangular Toeplitz. On the same two existing vectors, one generator term is implemented by
+
+    x <- P x,
+    y <- y+gamma L(g) x,
+    x <- P^-1 x,
+    y <- y-gamma L(g) x.
+
+The result is y<-y+L(g)U(h)x and x is restored. Source transforms use section 3; the other two operations use section 2. Each term costs O(log^2 m) rounds. There are O(log N) terms, hence O(log^3 N) rounds for a full low-displacement-rank shear.
+
+Although the partial generator sum can be larger than its final T, its norm is at most the sum of O(log N) products of O(sqrt N)-norm factors, hence O(N log N). Within a term the source norm remains constant times its entry norm and the target norm is polynomially bounded. Terms are completed as shears with one common source, so their partial sums add; one must not charge a product of polynomial factors for every generator.
+
+The full recurrence is therefore
+
+    D_full(N) <= D_full(N/2)+O(log^3 N)=O(log^4 N).
+
+## 6. Global prefixes, rounding and preprocessing
+
+At each block-LU node the completed right shear, completed middle block, and completed left shear have constant norm and constant inverse norm. At an intermediate time there is at most one unfinished generator compiler or one unfinished triangular compiler along each recursive path; disjoint paths form a direct sum. If B(N) bounds a full circuit prefix and inverse prefix, this gives B(N)<=max(C B(N/2),N^C), hence B(N)=N^O(1). The same argument applies to suffixes and to the triangular compiler.
+
+There are N polylog(N) arithmetic gates. Perturbation of one bounded gate by epsilon contributes at most N^C epsilon to the whole operator, by the prefix/suffix bounds. The sum over all gates remains N^O(1) epsilon. Therefore p+O(log N) coefficient/arithmetic bits suffice; there is no N or N^2 precision term on the data.
+
+The coefficients are fixed before seeing the data. One concrete polynomial-time generation route is:
+
+1. Approximate the original Toeplitz symbol by dyadic rationals at p+O(log N) bits, preserving Toeplitz structure. The operator perturbation is at most N times the entry perturbation.
+2. Compute every recursive Schur matrix as a principal Schur complement of this original rational matrix. Its entries are ratios of minors of that original matrix, so numerator and denominator bitlengths are polynomial in N and p. Avoid an unnecessarily expanded recursive rational expression.
+3. For each Stein displacement, use exact rational elimination to select independent columns and rational, unnormalized Gram-Schmidt to obtain orthogonal vectors v_j. Then g_j=v_j/sqrt(v_j^*v_j) and h_j=E_T^*v_j/sqrt(v_j^*v_j). The resulting generators have the bounded norms proved above. Nonzero rational residual norms are at least 2^-poly(N,p), so poly(N,p) offline precision suffices for their normalization. Equivalently a high-accuracy SVD may be used.
+4. Compute the finite series divisions and FFT roots to p+O(log N) final bits. All final data-gate coefficients are polynomially bounded. Offline intermediate rational numerators may be longer; they never become data wires.
+
+This separates polynomial-time coefficient setup from bounded-precision data application. Applying an algebraic-RAM theorem directly to arbitrarily large integers would not provide this separation.
+
+## 7. Normalized Sylvester merge
+
+For two b-point children, N=2b, the normalized map supplied by the radical-reduction branch is
+
+    S(B,A)=f(z)B(z)+z^b g(z^-1)A(z),
+    f(z)=product_lower(1+(x/zeta)z),
+    g(z^-1)=product_upper(1+(zeta/x)z^-1).
+
+Let h=g(z^-1)/f(z), K_ij=h_(i-b-j), H_ij=h_(i-j), 0<=i,j<b. The exact identity is
+
+    S=T_f [ I K ; 0 H ].
+
+Thus on exactly 2b data coordinates apply the K dirty Toeplitz shear, the b-wire full Toeplitz H circuit, and the 2b-wire triangular Toeplitz T_f circuit. At sufficiently separated geometric nodes, ||H-I||_1 and ||H-I||_infinity are below 1/4; the f symbol also differs from 1 by a fixed number below 1. This gives O(log^4 b) rounds, bounded intermediate amplification and p+O(log b) data bits in the normalized anchor coordinates. The whole map is square and invertible.
+
+Dyadic child sizes are explicit in this construction. Local tiles may be selected dyadic without padding every tensor axis; arbitrary-length global boundaries still need a layout treatment. Also, converting raw Gaussian coefficient arrays into the common anchor may have exp(O(a b^2)) range. This theorem does not authorize that conversion at bounded precision. The Gaussian gauge/localization branch must establish compatible input/output gauges.
+
+## 8. Relation to the papers and controls
+
+The following primary sources were read end-to-end, including appendices:
+
+- Giorgi, Grenet and Roche, *Fast In-place Algorithms for Polynomial Operations: Division, Evaluation, Interpolation*, arXiv:2002.10304v3. Its RAM model has read-only inputs plus distinct output storage, and its unwritten output is used as temporary memory. This does not establish an N-wire reversible interpolation circuit.
+- Dumas and Grenet, *In-place fast polynomial modular remainder*, arXiv:2302.13600v6. Its accumulated convolution/Toeplitz routines and reversible quotient/remainder transform are directly relevant. Its triangular Toeplitz recursion is work-efficient but the two recursive data calls are sequential.
+- The same arXiv's expanded v7, *Fast in-place accumulation*. Sections 2, 6 and 7 provide the accumulated linear compiler, Toeplitz-like sum-LU formula, and reversible remainder routines. The final paragraph explicitly leaves floating-point behavior of undoing operations for future study. The present prefix/suffix proof supplies an analysis for this restricted near-identity use.
+
+The parity split and the bounded-generator low-displacement LU combination above are new derivations in this work, not assertions copied from these sources.
+
+`check_circuits.py` compiles actual no-ancilla 1x1/2x2 gate layers, checks pairwise disjointness and invertibility, and replays all input columns. `CIRCUIT-REPLAY.json` records dyadic sizes 2,4,8,16. Current full-Toeplitz endpoint errors are at most 4.5e-15 in double precision. It also replays the normalized Sylvester merge for b=1,2,4,8, with maximum error 1.7e-15; at b=8 the circuit has 16 wires, 608 rounds and 2,464 gates. Omitting the compensating generator subtraction yields error 1.0. `check_exact_algebra.py` verifies 340 parity-factor matrix entries and 26 Schur displacement/rank nodes using exact rational arithmetic. These controls support the algebra but are not substitutes for it.
+
+## 9. Extension to positive-definite Toeplitz matrices
+
+The near-I hypothesis of the full-Toeplitz theorem is sufficient, not necessary. Suppose H is Hermitian positive definite and mu I <= H <= M I, with mu>0. Every principal submatrix has spectrum in [mu,M]. Every principal Schur complement S also does: S^-1 is a principal block of the inverse of a principal submatrix, whose spectrum is in [1/M,1/mu]. Thus every recursive A,S has norm at most M and inverse norm at most 1/mu. The shears K,L have norm at most kappa=M/mu. The displacement-rank formulas are unchanged.
+
+Use orthonormal g generators and h of norm O(kappa), and choose gamma>=2||h||_1. The triangular source transform P is still near I, so the depth O(log^4 N) is unchanged. Generator-stage amplitudes and coefficients are poly(N,kappa). Across the O(log N) completed ancestor factors, the bound becomes
+
+    log(max prefix/inverse-prefix norm)
+       = O(log N * log(2+M+1/mu) + log N).
+
+If M and 1/mu are exp(O(u)), this is O((u+1)log N). The corresponding data precision is p+O((u+1)log N), and g-axis tensorization adds O(g(u+1)log N) guard bits. This is a usable broad-Gaussian extension once a separate spectral argument supplies the stated eigenvalue interval. Reversing the circuit applies H^-1; the inverse itself need not be Toeplitz.
diff --git a/research/native-kappa-30201655/modern-sources/SUPPLIER-SUPPORT-AUDIT.md b/research/native-kappa-30201655/modern-sources/SUPPLIER-SUPPORT-AUDIT.md
new file mode 100644
index 0000000000..72404c42d7
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/SUPPLIER-SUPPORT-AUDIT.md
@@ -0,0 +1,139 @@
+# Independent audit: support-local simultaneous-H supplier
+
+Conclusion: the retained compact phase supplier can be used at width g with cost
+
+    O(V g^(1-q) polylog(p))
+
+without the previously charged additive V p^(1-a), **provided the call is made globally on the complete dyadic tensor, not separately on one fixed coarse-label microbox**. This is conditional on the same accepted finite complex circuit and arbitrary-width equal-chunk interchange as the retained supplier, and on the support-router transfer proved in `work/halo_layout_ultra/SUPPORT-ROUTER.md`. The new support-router's unequal-spacing algebra and its use here have been checked below.
+
+The full address still has O(p) bits. That quantity remains in descriptor arithmetic, keys and error precision; it no longer determines the width of any newly required fast coordinate interchange.
+
+## 1. What the actual phase frames touch
+
+The primary source is `work/integer-mult-current/upstream/build/sections/05-layers.tex`.
+
+At lines 86–139, a residual basis is a matrix M in GL(m,F_2), extended **inside F_2^m**. At width e=mf it is applied separately to the column
+
+    (x_(1,j),...,x_(m,j)), 0<=j<f,
+
+where x_(h,j) is the one selected bit in the jth K-bit chunk of slot h. A frame adapter therefore changes only e selected bits. It is not an arbitrary basis of the full O(p)-bit ambient address. Gaussian elimination gives a fixed number of simultaneous row additions because the finite network's m is fixed.
+
+The compact replacement in `notes/compact-control-movement.tex` lines 38–44 and 143–166 implements each row addition using two front and one back dirty fields of at most (f-1)G bits, G=4 ceil(log2 p)+6. Its at most twelve fast interchanges have width (f-1)G, **not** the full distance between slots and not p. Long intervening fields are spectators. The modular rotations scan them, with polynomial descriptor arithmetic paid separately by complete records.
+
+Residual children in `whole-complex-concatenation.md` use the first r complete fK slots after the same adapter. Their union is already one complete rfK field. The grouped child changes a descriptor; it does not gather a new p-dimensional frame. All remaining slots and the trailing tK field stay complete spectators. `whole-complex-prefix-and-wrapper-qualification.md` supplies a leading row prefix, not an unpriced suffix-to-front transpose.
+
+The source/sink Z masks and inverse-child wrappers in source05 lines 123–175 depend only on selected bits. They are coefficientwise signs/fourth-root phases. Scalar network gates act between fixed role streams at aligned addresses; they do not change the address support.
+
+## 2. Global selected-bit exposure
+
+For one tensor-compiler H call, the selected position in each of the g original long axes lies among its O(log p) local low bits. Choose a K-bit neighborhood starting at that selected position, with common selected offset rho=0. More generally one may retain a common rho after shifting all neighborhood starts accordingly. Because the original axis length ell grows faster than log p, K+O(log p)<ell eventually. The g neighborhoods lie in different original axes and are disjoint.
+
+Let S be these gK actual bit positions. Send them, preserving chunk order and each chunk's internal order, to a consecutive destination set T of gK slots. The explicit extension
+
+    S -> T as prescribed,
+    T\S -> S\T bijectively,
+    identity outside S union T
+
+is a coordinate permutation supported on at most 2gK positions. Its inverse restores the original coarse-coordinate interpretation. The target can be chosen before the payload and a reserved untouched suffix. No stable reordering of every coarse field is required.
+
+Apply the H supplier to this full global stream, whose complete coarse-coordinate ranges remain present. A fixed coarse-label microbox alone does **not** contain enough complete K-bit fields: its high coarse bits are fixed. Borrowing those fixed labels inside such a microbox would violate the supplier's complete-field hypothesis. This audit approves the global call only.
+
+The tensor compiler's H schedule is independent of all coarse labels. Those labels affect only diagonal coefficients between complete H calls. The diagonal scan can still be organized by coarse-label microboxes after undoing the global exposure permutation. Coarse-dependent coefficients therefore do not require separate supplier invocations.
+
+## 3. Deferred reservoirs and the row prefix
+
+At a phase with h unprocessed selected bits, reserve whole K-bit chunks for two front hG fields, one back hG field, and a leading row prefix. With K=128G, the field reservation is at most 3h/128+O(1) chunks. Row preparation needs O(log h) further chunks, including the product stock for nested bit and complex calls. For h above a fixed polylog(p) threshold the total R(h) is at most h/16. The remaining bounded/polylogarithmic h can be processed individually.
+
+Every such chunk is one of the current selected chunks. The phase applies C only to the other h-R(h) selected bits and identity to the reserved chunks; the latter are deferred to the next phase.
+
+This requires one explicit modification to the original exposition: **do not first apply C to the reserved row/front/back selected bits**. That preliminary work in the old all-axis construction only ensured those selected bits were eventually covered. It is not needed to create rows or complete temporary fields. Source `compact-control-layout.tex` lines 30–62 proves that the active invocation is the required C tensor separately on every row and identity on all reserved/spectator coordinates, for arbitrary incoming payloads. Hence dirty, unprocessed reserved selected bits are valid.
+
+The leading q0 complete chunks have cardinality 2^(q0 K). Choose q0 from the actual product row stock Q_rows=W_complex^D_complex W_bit^D_bit. This preserves the accepted nesting contract; replacing the product by a maximum would be incorrect. Pad the leading row count to a multiple of Q_rows once for this phase, by adding whole rows. The factor is below two. All descendants inherit the same complete within-row fields and the same row stock; no new independent bit coordinates are allocated.
+
+A completed active invocation is identity on the row label and every temporary coordinate. Each padded zero row is therefore zero at completion and can be deleted. Delete padding and restore the exposure layout **before the next deferred phase**. Consequently row padding does not multiply by 2 at every phase or tensor axis.
+
+The next deferred phase gathers only its h'=R(h) remaining neighborhoods. A gather/restore can again be extended with support at most 2h'K; it may move previously processed coordinates temporarily but fixes them after the inverse placement. Their values need not be recomputed. There is no need to move all p coordinates back into a stable global axis order.
+
+## 4. The logarithmic K choice is legal after tightening the statement
+
+The original compact-control proposition states the sufficient asymptotic condition K/log p -> infinity. K=128G does not satisfy that literal condition. The source proof, however, uses it only at lines 149–154 to obtain
+
+    K >= G+4 ceil(log2 p)+10,
+    delta_bad <= 5/(128p^3).
+
+K=128G satisfies the displayed finite inequality directly. The earlier/later-source guard proof, complete-field layout, row stock, scalar gates and semantic guard have no other use of K/log p -> infinity. Thus the transfer must cite the tightened finite guard hypothesis; it must not claim that the new K satisfies the old stronger asymptotic wording.
+
+With this change, all compact interchanges retain width O(h log p), and the per-node movement overhead is O(V_node h^(1-a) polylog(p)). Here h is the current selected width, not the ambient number d of original Gaussian axes. The supplier's stopping threshold and branching analysis likewise use its own top width g; global p remains only in logarithmic guards and O(p)-bit descriptors.
+
+## 5. Check of the support-router extension
+
+The original arbitrary-source router colors active targets by their current location modulo K. Targets in one color have disjoint K-bit guards. The new router stores only the r active control digits, H=rG, even when the target spacings are unequal multiples of K.
+
+The four-update proof depends solely on disjointness of the guard intervals: on a good address the first y update adds 2zt within a guard, the t update adds its old low bit e without carry, and the second y update adds z(1-2(t+e)). Their net is z(1-2e), changing exactly the selected low bit. The final t update restores t. Nothing uses equality between successive target gaps. A complete F therefore fixes every nontarget source bit, even inside another guard. F; load u from the sources; F; unload implements the desired simultaneous XOR for sources outside the target set.
+
+All rotations remain globally bijective, because their controls precede the target after the prescribed back-field shuttle. Their current-control inverse is used on bad addresses. The ideal selected-bit XOR preserves the guard/control bad predicate, so the old sparse repair applies unchanged. Its O(p)-bit keys and polynomial per-record arithmetic remain explicit; they are not replaced by a unit-cost sort.
+
+For a permutation moving k positions, factor it into two involutions and three XOR stages per matching. Three disjoint 3kG-bit reservoirs can be chosen when n>=9kG; the three matching cohorts avoid the respective reservoirs. Each target residue class then uses width at most kG in each control field, rather than ceil(n/K)G. Original equal-width interchanges place and restore the fields. This gives O(V k^(1-a) polylog p), plus descriptor setup.
+
+When records are short, choose only ell_s=ceil(log2 p)^2 untouched binary bits, not a whole long original axis. Here is explicit noncircular suffix bookkeeping. For a requested permutation pi with moved support at most k, if n>2(k+1)ell_s, a gap in its support contains a consecutive ell_s-bit field S disjoint from the actual last ell_s bits. Use one original equal-ell_s interchange A to move S to the actual suffix. Route the conjugate A pi A^-1 on the n-ell_s prefix only, then undo A. The conjugate fixes that suffix pointwise because pi fixed S. Choose all control reservoirs inside the prefix, after this interchange, and recompute positions and residue classes after their placements. Thus no control operation touches the grouped suffix. Grouping its 2^ell_s complete values into a record preserves the data volume and gives a superpolynomial record length. If n<=2(k+1)ell_s, the retained full-span bound is already O(V(k+1)^(1-a) polylog p), so no suffix grouping is needed for this support bound. The placement costs O(V polylog p), not V ell^(1-a) for the original long axis length ell.
+
+For the calls here, k=O(hK)=O(h log p), and n/(k log p) tends to infinity because g=p^beta with beta<1 while n is of order p in the retained full tensor. If this inequality fails in a small regime, n=O(k polylog p), so the retained full-span bound is already O(V k^(1-a) polylog p). The support theorem's own temporary reservoirs may have O(kG) bits; this is a polylogarithmic enlargement of support, already priced in the same bound.
+
+## 6. Complete charge table
+
+| Operation | Active coordinate/data support | Charge |
+| --- | --- | --- |
+| Initial and inverse neighborhood exposure | At most 2gK moved bit positions | O(V g^(1-a) polylog p) |
+| Deferred phase exposure at width h | At most 2hK positions | O(V h^(1-a) polylog p) |
+| Fixed binary residual adapter | h selected bits; compact controls O(hG) | O(V_node h^(1-a) polylog p) |
+| Control-field shuttle | At most O(hG)-bit chunks | Original O(V_node(hG)^(1-a)) |
+| Modular rotations and exceptional repair | Full scan; O(p)-bit descriptors/keys | O(V_node) after record grouping |
+| Residual child concatenation | Existing contiguous first-r slots | Descriptor change only |
+| Source/sink/inverse phases | Selected-bit masks and coefficients | O(V_node) |
+| Scalar role gates, parking and restoration | Fixed role streams at aligned addresses | O(V_node) |
+| Whole-row padding and deletion | One current-phase row prefix | O(V), factor below two, removed before next phase |
+
+No row in this table requires an interchange of width p.
+
+Let tau=1-a. The retained stopped branching argument gives O(V h^(1-q) polylog p) for each phase, with q<a and the same strict complex/leaf margin as the retained supplier. Since h_(j+1)<=h_j/16 above the polylogarithmic tail,
+
+    sum_j h_j^(1-q)=O(g^(1-q)),
+    sum_j h_j^tau=O(g^tau)<=O(g^(1-q)).
+
+Therefore the entire selected-bit call, including support-local exposure/restoration, costs O(V g^(1-q) polylog p). The old V p^(1-a) term was the full-span exposure estimate. It is not needed for this support-local call family.
+
+## 7. Precision, normalization and validity boundary
+
+The compact address operations only permute coefficient encodings. Their temporary binary combinations are address-control arithmetic, not coefficient values. The accepted whole-child semantic guard remains linear in selected width. Completed deferred phases act on disjoint selected bits, and the sum of their widths is g; only one current phase contributes unfinished internal excess. Thus its arithmetic guard is O(g), independently of the total address width and of the number of coarse labels.
+
+The retained target is H0=(1/2)[[1,1],[1,-1]], while `TENSOR-COMPILER.md` uses the raw matrix H. Follow a supplied H0 tensor by the scalar 2^g. This is an O(V) binary shift/diagonal, with O(g) extra magnitude and error allowance. Repeated compiler calls and local/coarse-dependent diagonal factors retain the already proved total guard O(g ad+g polylog p), which is O(p) at the proposed strict parameters.
+
+The positive conclusion is restricted to a globally complete dyadic stream, selected positions admitting the complete K neighborhoods, the retained exact common-frame/whole-child contract, and support-router calls using the original paid equal-chunk primitive. It does not approve per-coarse-microbox borrowing, stable compaction of every coarse axis, arbitrary computed-key full sorting, a maximum-only row stock, or reuse of the unmodified K/log p hypothesis.
+
+## 8. Large groups do not have to fit inside one original axis
+
+Let the ambient axis count be d=Theta(p^epsilon), with any fixed epsilon<1, and let each original binary axis have length ell=Theta(p^(1-epsilon)). The support argument permits
+
+    g=Theta(p^beta),        0<beta<epsilon, beta<1.
+
+It does **not** require beta<1-epsilon, g<ell, or gG<=ell.
+
+Only one K-bit neighborhood per selected original axis must fit inside that axis. This is K+O(log p)<ell, true eventually because K=Theta(log p) and epsilon<1. The total neighborhoods have gK=O(p^beta log p) bit positions. The support router's temporary reservoirs have O(gKG)=O(p^beta log^2 p) positions, which fit the full Theta(p)-bit binary tensor whenever beta<1. An untouched log^2 p-bit suffix reservoir can be chosen outside this support.
+
+The compact front/back controls are made by concatenating **multiple complete neighborhoods**. This is explicit in the primary layout: q_F=ceil(2H/K) and q_B=ceil(H/K) entire chunks supply the two front H-bit fields and one back H-bit field, respectively. With H=hG and K=128G, the complete-chunk cost is at most ceil(3h/128)+O(1). The row stock adds O(log(hG)) chunks. Consequently
+
+    R(h) <= 3h/128 + O(log(hG)+1) <= h/16
+
+above a polylogarithmic threshold. No step asks a single original axis to contain H=hG controls. Grouping these chunks changes their placement, not the number of full binary coordinates available. This removes the former beta<1-epsilon reservation restriction from the H supplier interface; independent Gaussian-gauge constraints may still impose their own relation between beta and an interior-length exponent.
+
+
+## 9. Independent bookkeeping audit
+
+`SUPPORT-ADVERSARIAL-AUDIT.md` independently checks the pre-reserved uniform
+control width, post-placement target coloring, global complete-field use,
+row restoration, and suffix conjugation above. Its suffix clarification
+makes the existing short-record argument explicit without changing the
+cost or imposing any new relation between g and one original axis length.
+The primary/source coverage and hashes are recorded in
+`SUPPLIER-AUDIT-SOURCES.json`; `SUPPLIER-CAPACITY-CONTROLS.json` is an exact
+integer control in a regime where gG exceeds the entire single-axis width.
diff --git a/research/native-kappa-30201655/modern-sources/TENSOR-COMPILER.md b/research/native-kappa-30201655/modern-sources/TENSOR-COMPILER.md
new file mode 100644
index 0000000000..19efb9cb1c
--- /dev/null
+++ b/research/native-kappa-30201655/modern-sources/TENSOR-COMPILER.md
@@ -0,0 +1,160 @@
+# Tensorizing local circuits without dimension padding
+
+Status: an algebraic compiler and scan-cost lemma. It reduces a tensor product of different bounded-depth local circuits to a bounded sequence of simultaneous binary Hadamard calls and diagonal scans on the **same** data volume. The retained supplier must support the stated Hadamard call on selected local bits and restore the agreed endpoint record order. No new fast-transform supplier is asserted here.
+
+## 1. Interface and conclusion
+
+Let N=2^m and let g axes each have N local coordinates. A coarse-label block contains V=N^g data records in lexicographic local-coordinate order. On axis a let C_a be an N-wire linear circuit of depth D; every layer consists of disjoint invertible two-coordinate gates and one-coordinate diagonals. The permitted gates are bounded shears, swaps, FFT butterflies, and diagonals. Circuits, pair matchings, coefficients and depths can differ by axis and by coarse label. Their tables are fixed independently of data values.
+
+Write H=[[1,1],[1,-1]]. A simultaneous Hadamard call means the tensor product of one H acting on one selected bit in each axis, with all remaining local and coarse coordinates as spectators. It acts on existing 2^g-coordinate fibers inside the N^g records; it allocates no new coordinate. The bit selected in an axis may be prescribed by the compiler.
+
+After padding shorter circuits by identity **operations**, the tensor product C_1 tensor ... tensor C_g is a sequence of
+
+    at most (8m+2)D simultaneous H calls
+
+and O(Dm) tensor-diagonal scans. A tensor diagonal has the form
+
+    d(i_1,...,i_g;c)=product_(a=1)^g d_a(i_a;c),
+
+where c is the fixed coarse label. Each diagonal scan uses O(1) amortized coefficient multiplications and O(1) amortized coefficient-table record movements per data record, after loading gN local values. The number of arithmetic-data coordinates remains exactly N^g throughout.
+
+If all local gate coefficients and inverses are bounded by B and all original prefix and inverse-prefix norms by Lambda, the compiler's local prefix bounds are Lambda times poly(B), up to absolute constants. For polynomial B and Lambda this is N^O(1). The tensor-prefix logarithmic bound is O(g log N). More generally depth D=polylog(p), B=poly(p), N=poly(p) gives an O(g polylog(p)) guard even without a stronger prefix theorem.
+
+An outer similarity whose logarithmic range is Q_a on axis a adds only sum_a Q_a. Therefore the retained phase-cell case Q_a=O(a d) uses
+
+    p + O(g a d + g polylog(p))
+
+working bits. The condition g a d+g polylog(p)=O(p) is sufficient for O(p)-bit records.
+
+## 2. Fixed Hadamard words, including zero shears
+
+All formulas below are matrix-product order; execution reads right to left. Let U(t)=[[1,t],[0,1]]. Direct multiplication gives
+
+    H diag(2,1) H diag(-3,1) H = [[-8,-10],[0,-6]],
+    diag(-1/8,-1/6) H diag(2,1) H diag(-3,1) H = U(5/4).
+
+For q nonzero, conjugate by A_q=diag(4q/5,1):
+
+    U(q)=A_q diag(-1/8,-1/6) H diag(2,1) H diag(-3,1) H A_q^-1.
+
+This has three H factors. To include t=0 with uniformly invertible diagonals, choose a known B>=|t| and c=2B+1. Then
+
+    U(t)=U(t+c) U(-c).
+
+Both parameters have magnitude at least B+1 and at most 3B+1. This is a **six-H word for every t**, with all scalar coefficients and inverses bounded by poly(B). There is no division by t and no case split at t=0. Transpose the word to obtain the same six-H count for lower shears.
+
+There are two bounded identity words:
+
+    I = (1/2) H H,
+    I = diag((1-i)/4,(1+i)/4) H diag(1,i) H diag(1,i) H.
+
+The second identity uses three H factors. Its middle product before the leading diagonal equals diag(2+2i,2-2i). Complex coefficients are permitted by the retained complex H interface.
+
+Consequently every gate type can be given **exactly six H factors**, separated by diagonal matrices:
+
+- Upper/lower shear: the six-H word above.
+- Diagonal, including I: append three two-H identity words.
+- Swap J: use J=(1/2)H diag(1,-1)H, then append two two-H identity words.
+- FFT butterfly H diag(1,w), optionally scaled by 1/sqrt(2): append a two-H identity and a three-H identity. Here |w|=1.
+
+Combining neighboring diagonal matrices puts every word in one common alternating shape with six H factors and seven diagonals. Thus different gate types, zero parameters and inactive pairs can coexist in one simultaneous schedule without branches or padded data coordinates.
+
+## 3. Every matching can be routed to adjacent pairs
+
+For one local layer, assign its oriented pairs (i,j) to positions (2k,2k+1). Unpaired coordinates are assigned arbitrarily to the remaining positions, in pairs carrying diagonal or identity gates. This defines a permutation pi on exactly N coordinates. The layer equals
+
+    P_pi^-1 (direct sum of adjacent-pair gates) P_pi.
+
+We use a Beneš network of 2m-1 switch layers. At each layer all switches join indices differing in one fixed bit; the bit sequence is
+
+    0,1,...,m-1,m-2,...,1,0.
+
+Here is a constructive proof of rearrangeability. Form a bipartite multigraph whose left vertices are input pairs {2j,2j+1} and whose right vertices are output pairs {2k,2k+1}. Input i supplies an edge to output-pair floor(pi(i)/2). Every vertex has degree two, so each component is an even cycle (parallel edges are allowed). Alternately color each cycle's edges 0 and 1. The first switch sends an input edge into the subnetwork of its color; the last switch sends that color to the required output parity. Each color class induces a permutation on N/2 pair indices. Recursively route both color subnetworks in parallel. This gives exactly the displayed bit sequence and uses no storage coordinates.
+
+The switch is either I or J. Both are obtained from the common two-H word
+
+    S_epsilon=(1/2) H diag(1,epsilon) H,
+    epsilon=+1 for I, epsilon=-1 for J.
+
+Thus all axis-dependent switch controls are diagonal entries. A physical switch on bit k simply uses a simultaneous H call selecting bit k in each axis. No interstage wire shuffle is needed. If a supplier accepts only a contiguous selected-bit field, the existing paid bit router must gather that field and undo the gather; that is a supplier-interface cost, not an uncharged permutation.
+
+Each forward or inverse Beneš route uses 2(2m-1) H calls. The adjacent gates use six. Hence one original matching layer uses
+
+    2[2(2m-1)]+6 = 8m+2
+
+H calls. The schedule is identical on every axis and every coarse-label block; only diagonal tables change.
+
+## 4. Tensor fusion is literal multiplication, not a sum expansion
+
+Let the compiled axis-a circuit be D_(a,L) H_(a,L) ... H_(a,1) D_(a,0), with the same number and arrangement of H factors. Kronecker multiplication gives
+
+    tensor_a C_a
+      = (tensor_a D_(a,L)) (tensor_a H_(a,L)) ...
+        (tensor_a H_(a,1)) (tensor_a D_(a,0)).
+
+Every tensor of diagonals is a single diagonal scan. Every tensor of binary H factors is one simultaneous H call. This introduces neither a sum of 2^g branches nor a 2^g padding factor. The 2^g-dimensional Hadamard fibers are subsets of the N^g existing coordinates.
+
+An axis with no work at a particular original depth receives an identity layer, routed and compiled with the same fixed shape. Its intermediate H operations are still present, but the complete local word is I. Coarse-label variation is equally harmless: for each fixed label the identity above holds separately, and the whole data operator is a direct sum over labels.
+
+## 5. Uniform intermediate bounds and precision
+
+A completed switch route is a permutation and has norm one. Each partial switch word has absolute constant norm and inverse norm. Between original local circuit boundaries, at most one original gate word is partially executed. Its length is constant, and its scalar coefficients and inverses are poly(B); all different pairs act as a direct sum. Therefore
+
+    max_prefix ||C_compiled,prefix||,
+    max_prefix ||C_compiled,prefix^-1|| <= poly(B) Lambda.
+
+The length O(D log N) does not require multiplying this polynomial bound afresh at every stage: completed original prefixes already have bound Lambda; completed route and padding words have their exact intended endpoints. The corresponding suffix bound is also polynomial when the original endpoint and inverse-prefix bounds are.
+
+For g tensor factors, the operator norms multiply, so their logarithms add. A microbox coarse-label direct sum takes the maximum over labels, not a product over labels. Hence polynomial local bounds give exp(O(g log N)); using only the rough original bound Lambda<=(2B)^D gives exp(O(gD log B)). Adding the original cell similarity contributes exp(sum Q_a).
+
+The number of compiled stages is polylog(p). Allocate each rounding or supplied-transform error below the final tolerance divided by this stage count and the prefix/suffix amplification. This costs O(g polylog(p)+sum Q_a) guard bits. Supplier-internal precision charges still must be those already guaranteed for the simultaneous H call; this compiler does not erase them.
+
+## 6. Product diagonals with constant amortized scan cost
+
+Fix one diagonal stage and one coarse label. Load the gN coefficients d_a(i) on a coefficient tape in axis order. Use base-N lexicographic enumeration with axis 0 fastest. Store suffix products
+
+    P_j=product_(a=j)^(g-1) d_a(i_a),       1<=j<g,
+
+and P_g=1. A normal record uses d_0(i_0) P_1, one coefficient multiplication. If the odometer carries through axes 0,...,k-1 and increments axis k, recompute only P_k,P_(k-1),...,P_1. A carry of depth at least k occurs at most V/N^k times. Therefore the total extra products are bounded by
+
+    V sum_(k>=1) k/N^k = O(V),
+
+plus O(g) initialization. No division by d_a(i) is used, so this method also permits zero diagonal entries when an external application permits them. Every cached product is recomputed from current factors, never updated by a long chain of multiplicative ratios, so numerical drift does not depend on the number of records scanned.
+
+The same accounting works on a fixed number of tapes. Keep the coefficient-tape head normally in axis-0's N-record table. Rewinding that table costs O(N) once per N records. A depth-k carry visits the needed tables up to axis k and returns, moving O(kN) coefficient records. Summing over carries gives
+
+    O(V sum_(k>=1) kN/N^k)=O(V)
+
+record moves. The suffix-product tape is accessed near its front except on carries, with the same geometric bound. Counter/address arithmetic costs only polylog(p) per record. This does not require g work tapes or a random-access lookup every record.
+
+The table loading cost is O(gN) records per coarse block and stage. For N>=2 it is O(N^g), including small g, and polynomial-time table construction is negligible per N^g block in the retained asymptotic regime g=p^beta tending to infinity. If tables are supplied rather than constructed locally, no additional assumption is needed. Both generation and loading costs must be charged once per visited coarse block, not silently once for the entire input.
+
+At O(p) working precision, O(1) amortized scalar multiplications per record and O(1) record movements cost O(V_bits polylog(p)) under the retained pointwise-arithmetic kernel, where V_bits counts bit volume. There is no g V_bits coefficient-generation term.
+
+## 7. Exact controls
+
+`check_tensor_compiler.py` constructs the network controls and all fixed words. `TENSOR-COMPILER-CONTROLS.json` records:
+
+- every permutation for N=2,4,8, including all 40,320 permutations at N=8;
+- 100 random permutations each at N=16,32,64;
+- exact symbolic checks of upper/lower zero and nonzero shears, diagonal, Swap and FFT words;
+- an exact two-axis N=4 replay with different axis matchings and gate types: 16 data coordinates, all 256 input-output matrix entries, 18 simultaneous H calls, no dimension expansion.
+
+The finite controls support the constructive proofs; the cycle coloring, word identities, Kronecker identity and geometric scan sums establish the asymptotic statements.
+
+## 8. Cost substitution into the retained supplier
+
+Suppose a simultaneous H call on g selected bits, across V_bits bits of data and spectators, has paid cost O(V_bits g^(1-q) polylog(p)). Suppose also that any required bit-field gather/restore has cost O(V_bits g^(1-a_bit) polylog(p)). For D=polylog(p), N=poly(p), the compiler uses only polylog(p) such calls, and its diagonal scans cost O(V_bits polylog(p)). Thus the grouped local circuit costs
+
+    O(V_bits [g^(1-q)+g^(1-a_bit)+1] polylog(p)).
+
+When a_bit>q and 0<q<1, this is O(V_bits g^(1-q) polylog(p)). The compiler therefore preserves the supplier saving q. The substitution is valid with different local circuits and control masks per axis/coarse label, provided their uniformly bounded tables are generated within the separately charged polynomial preprocessing budget. It introduces neither a g V_bits full-scan term nor a 2^g volume multiplier.
+
+
+The retained supplier returns the normalized butterfly H0=H/2. After one
+simultaneous H0 call, multiply all coefficients by 2^g to obtain the raw H
+used by these identities. This is one binary-shift diagonal scan and adds
+O(g) precision guard. The support audit in `SUPPLIER-SUPPORT-AUDIT.md`
+justifies the stated call cost globally on the complete dyadic tensor,
+using only O(g log p) selected-neighborhood positions plus support-local
+helper reservoirs. It does not require g log p bits inside any one axis.
diff --git a/research/native-kappa-30201655/native_convolution.py b/research/native-kappa-30201655/native_convolution.py
new file mode 100644
index 0000000000..ba6e408158
--- /dev/null
+++ b/research/native-kappa-30201655/native_convolution.py
@@ -0,0 +1,73 @@
+"""Direct bounded-word complex convolution; Apache-2.0.
+Dugongue with substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+
+
+def need(ok,why):
+    if not ok:raise ValueError(why)
+
+
+def source_module(name):
+    p=Path(__file__).with_name(name)
+    scope={'__name__':'native_component','__file__':str(p)}
+    exec(compile(p.read_bytes(),str(p),'exec'),scope)
+    return scope
+
+
+class Convolver:
+    def __init__(self,size,p,width):
+        need(size>=2 and size&(size-1)==0 and p>=1,'transform shape')
+        self.N=size;self.p=p;self.S=1<<p;self.width=width
+        self.limit=1<<width;self.operations=0;self.maximum_bits=0
+        root=source_module('root_seed.py')['root_seed'](size,p,width)
+        self.operations=root['charged_word_operations'];self.maximum_bits=root['largest_intermediate_bits']
+        self.roots=[(self.S,0)]
+        for _ in range(1,size//2):
+            self.roots.append(self.cmul(self.roots[-1],(root['real'],root['imag'])))
+        self.setup_operations=self.operations
+
+    def val(self,x):
+        need(abs(x)<self.limit,'word overflow')
+        self.operations+=1;self.maximum_bits=max(self.maximum_bits,abs(x).bit_length());return x
+
+    def cmul(self,a,b):
+        ac=self.val(a[0]*b[0]);bd=self.val(a[1]*b[1])
+        ad=self.val(a[0]*b[1]);bc=self.val(a[1]*b[0])
+        return self.val(self.val(ac-bd)//self.S),self.val(self.val(ad+bc)//self.S)
+
+    def fft(self,data,inverse=False):
+        need(len(data)==self.N,'transform array length')
+        data=list(data)
+        for z in data:self.val(z[0]);self.val(z[1])
+        j=0
+        for i in range(1,self.N):
+            mask=self.N>>1
+            while j&mask:j^=mask;mask>>=1;self.operations+=4
+            j^=mask
+            if i<j:data[i],data[j]=data[j],data[i]
+            self.operations+=9
+        step=2
+        while step<=self.N:
+            half=step>>1;stride=self.N//step
+            for start in range(0,self.N,step):
+                for k in range(half):
+                    tw=self.roots[k*stride]
+                    if not inverse:tw=(tw[0],-tw[1])
+                    u=data[start+k];v=self.cmul(data[start+k+half],tw)
+                    data[start+k]=(self.val(u[0]+v[0]),self.val(u[1]+v[1]))
+                    data[start+k+half]=(self.val(u[0]-v[0]),self.val(u[1]-v[1]))
+                    self.operations+=18
+            step<<=1
+        if inverse:data=[(self.val(a//self.N),self.val(b//self.N)) for a,b in data]
+        return data
+
+    def prepare(self,kernel):
+        need(1<=len(kernel)<=self.N,'kernel size')
+        return self.fft(list(kernel)+[(0,0)]*(self.N-len(kernel)))
+
+    def apply(self,data,prepared,output_length):
+        need(1<=len(data)<=self.N and 1<=output_length<=self.N,'convolution size')
+        d=self.fft(list(data)+[(0,0)]*(self.N-len(data)))
+        result=self.fft([self.cmul(x,y) for x,y in zip(d,prepared)],True)
+        return result[:output_length]
diff --git a/research/native-kappa-30201655/native_ledger.py b/research/native-kappa-30201655/native_ledger.py
new file mode 100644
index 0000000000..e1faa0cf22
--- /dev/null
+++ b/research/native-kappa-30201655/native_ledger.py
@@ -0,0 +1,63 @@
+"""Exact native Word RAM assembly ledger; Apache-2.0.
+Dugongue with substantial OpenAI Codex assistance.
+Arithmetic checks support the separate source-bound proof; they do not prove its identities.
+"""
+from fractions import Fraction as F
+import json
+
+PROVIDER=F('0.0030201656')
+Q=F('0.00302016555')
+STOP=F(1,10**9)
+TARGET=F('0.0030201655')
+
+def check(epsilon=1-F(1,10**8), beta=1-F(3,10**8), target=TARGET, r=F(1,10**9)):
+    q=Q
+    xi=epsilon*(1+q)-F(3,32)+F(1,10**10)
+    savings={
+      'main_transform':epsilon*q,
+      'complete_address_routing':F(1),
+      'fused_gaussian':1-epsilon+q*beta,
+      'selected_bit_gather_restore':F(1),
+      'group_scans_and_lookup':1-epsilon+beta,
+      'boundary_algebra_and_couplings':F(3,32)+xi-epsilon,
+      'indexed_sparse_axis_visits':F(1,2)+xi-epsilon,
+      'global_precision_record_products':epsilon,
+      'core_face_recovery':1-(epsilon+beta+48-128+2)}
+    guards={
+      'positive_saving':target,
+      'source_provider_stopped_margin':PROVIDER*(1-STOP)-q,
+      'below_packed_output_limit':1-target,
+      'epsilon_below_one':1-epsilon,
+      'beta_positive':beta,
+      'beta_below_epsilon':epsilon-beta,
+      'cap_above_band':xi-F(1,2),
+      'cap_below_dimension':epsilon-xi,
+      'global_gamma_guard':1-epsilon-r,
+      'shifted_group_chirp_guard':1-(beta+2*xi-2+r),
+      'group_support_and_key_guard':1-(beta+1-epsilon),
+      'membership_guard':1-(beta+2*(1-epsilon)),
+      'positive_spare_alpha_exponent':r,
+      'strassen_integer_certificate':F(2**45-7**16)}
+    guards.update({name+'_excess':value-target for name,value in savings.items()})
+    if not all(v>0 for v in guards.values()):
+        raise ValueError('failed strict guards: '+','.join(k for k,v in guards.items() if v<=0))
+    return {'kappa':str(target),'effective_provider_saving':str(q),'source_provider_saving':str(PROVIDER),'stop':str(STOP),'epsilon':str(epsilon),'beta':str(beta),'r':str(r),'xi':str(xi),
+            'nine_native_savings':{k:str(v) for k,v in savings.items()},
+            'strict_guards':{k:str(v) for k,v in guards.items()},
+            'minimum_excess':str(min(v-target for v in savings.values()))}
+
+def main():
+    result=check()
+    controls={}
+    for name,kwargs in [('epsilon_one',{'epsilon':F(1)}),('unfunded_outer_target',{'target':Q}),
+                        ('key_fills_whole_word_power',{'beta':1-F(1,10**8)}),
+                        ('membership_at_edge',{'beta':1-F(2,10**8)}),
+                        ('normalization_at_edge',{'r':F(1,10**8)})]:
+        try:check(**kwargs)
+        except ValueError:controls[name]='REJECTED'
+        else:raise AssertionError('control accepted: '+name)
+    result.update(status='PASS',rejecting_controls=controls,
+       scope='Exact native exponent/guard arithmetic only; retained algebraic/analytic identities and full implementation are separate evidence.')
+    print(json.dumps(result,indent=2))
+
+if __name__=='__main__':main()
diff --git a/research/native-kappa-30201655/native_metadata.py b/research/native-kappa-30201655/native_metadata.py
new file mode 100644
index 0000000000..dba7ce2fc7
--- /dev/null
+++ b/research/native-kappa-30201655/native_metadata.py
@@ -0,0 +1,65 @@
+"""Paid affine/quadratic address metadata; independent exact finite reference."""
+from random import Random
+import json
+
+
+def require(x,m):
+    if not x:raise ValueError(m)
+
+
+def metadata(e,columns,offset,linear,upper):
+    require(e>=1 and len(columns)==len(linear)==len(upper)==e,'shape')
+    size=1<<e;mask=size-1
+    require(0<=offset<size and all(0<=x<size for x in columns+upper),'address bound')
+    require(all(0<=x<4 for x in linear),'linear phase bound')
+    require(all((upper[j]&((1<<(j+1))-1))==0 for j in range(e)),'upper phase form')
+    mu=max(1,e//16);small=1<<mu;lowmask=small-1
+    parity=[0]*small;lowbit=[0]*small
+    for x in range(1,small):
+        parity[x]=parity[x>>1]^(x&1)
+        lowbit[x]=0 if x&1 else 1+lowbit[x>>1]
+    def par(x):
+        result=0
+        for _ in range((e+mu-1)//mu):result^=parity[x&lowmask];x>>=mu
+        return result
+    def first(x):
+        for pos in range(0,e,mu):
+            chunk=x&lowmask
+            if chunk:return pos+lowbit[chunk]
+            x>>=mu
+        raise ValueError('zero has no least set bit')
+    image=[0]*size;phase=[0]*size
+    for x in range(1,size):
+        j=first(x);y=x-(1<<j)
+        image[x]=image[y]^columns[j]
+        phase[x]=(phase[y]+linear[j]+2*par(upper[j]&y))&3
+    return [x^offset for x in image],phase
+
+
+def check():
+    rng=Random(20261022);cases=points=0
+    for e in range(1,13):
+        columns=[1<<j for j in range(e)]
+        if e>1:
+            for _ in range(4*e):
+                a,b=rng.sample(range(e),2)
+                columns=[x^((1<<a) if x&(1<<b) else 0) for x in columns]
+        offset=rng.randrange(1<<e);linear=[rng.randrange(4) for _ in range(e)]
+        upper=[sum(rng.randrange(2)<<k for k in range(j+1,e)) for j in range(e)]
+        images,phases=metadata(e,columns,offset,linear,upper)
+        require(len(set(images))==1<<e,'affine permutation collision')
+        for x in range(1<<e):
+            image=offset;phase=0
+            for j in range(e):
+                if (x>>j)&1:
+                    image^=columns[j];phase+=linear[j]
+                    for k in range(j+1,e):phase+=2*((upper[j]>>k)&1)*((x>>k)&1)
+            require(images[x]==image and phases[x]==phase%4,'independent coordinate/phase mismatch')
+            points+=1
+        cases+=1
+    try:metadata(1,[1],0,[0],[1])
+    except ValueError:pass
+    else:raise ValueError('non-upper phase accepted')
+    return {'status':'PASS_EXACT_METADATA','affine_quadratic_maps':cases,'all_input_addresses_checked':points,'invalid_phase_control':True,'scope':'Finite exact semantics; universal paid O(volume) proof is separate.'}
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/phase_tables.py b/research/native-kappa-30201655/phase_tables.py
new file mode 100644
index 0000000000..b153a93047
--- /dev/null
+++ b/research/native-kappa-30201655/phase_tables.py
@@ -0,0 +1,121 @@
+"""Native radix phase tables over signed Gaussian dyadics.
+All arithmetic is bounded by the caller's logarithmic-word contract; no TM,
+transition table, transcendental oracle, or recursive integer multiplier appears.
+The caller supplies a certified seed with coordinate error < 2^-p.
+"""
+from fractions import Fraction
+from random import Random
+import json
+
+
+def need(ok,msg):
+    if not ok: raise ValueError(msg)
+
+
+def round_scaled(v,p):
+    """Nearest integer to v/2^p, ties away from zero; shifts and sign only."""
+    a=abs(v)
+    q=(a+(1<<(p-1)))>>p
+    return -q if v<0 else q
+
+
+class PhaseTable:
+    def __init__(self,D,p,radix_bits,seed,word_width=None):
+        need(D>=2 and p>=2 and radix_bits>=1,'shape')
+        self.D,self.p,self.t=D,p,radix_bits
+        self.Q=1<<p;self.R=1<<radix_bits
+        self.d=((D-1).bit_length()+radix_bits-1)//radix_bits
+        self.E=1<<(radix_bits*self.d)
+        need(self.Q>=64*(self.E+self.d),'precision guard')
+        self.w=2*p+8 if word_width is None else word_width
+        need(self.w>=2*p+8 and D<(1<<self.w),'bounded word guard')
+        need(len(seed)==2 and all(abs(x)<=2*self.Q for x in seed),'seed representation')
+        self.operations=0;self.tables=[]
+        base=tuple(seed)
+        for j in range(self.d):
+            row=[(self.Q,0)]
+            for a in range(1,self.R): row.append(self.multiply(row[-1],base))
+            self.tables.append(row)
+            self.operations+=4*self.R # writes and bounded counters
+            if j+1<self.d:
+                for _ in range(self.t): base=self.multiply(base,base)
+        self.setup_operations=self.operations
+
+    def multiply(self,a,b):
+        ar,ai=a;br,bi=b
+        need(all(abs(x)<=2*self.Q for x in (*a,*b)),'intermediate component guard')
+        products=(ar*br,ai*bi,ar*bi,ai*br)
+        need(all(abs(x)<(1<<(self.w-2)) for x in products),'word product guard')
+        real=products[0]-products[1];imag=products[2]+products[3]
+        need(max(abs(real),abs(imag))<(1<<(self.w-1)),'signed word sum guard')
+        self.operations+=48 # four word MULs, signs, adds, shifts, bounded control
+        out=(round_scaled(real,self.p),round_scaled(imag,self.p))
+        need(all(abs(x)<=2*self.Q for x in out),'rounded magnitude guard')
+        return out
+
+    def power(self,e):
+        need(0<=e<self.D,'exponent outside certified domain')
+        out=(self.Q,0)
+        for row in self.tables:
+            digit=e&(self.R-1);e>>=self.t
+            self.operations+=6 # digit extraction, table addresses, loads, loop
+            out=self.multiply(out,row[digit])
+        need(e==0,'exponent digit exhaustion')
+        return out
+
+    def coordinate_error_bound(self):
+        return Fraction(16*(self.E+self.d),self.Q)
+
+
+def cmul(a,b):
+    return a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]
+
+
+def cpow(z,e):
+    result=(Fraction(1),Fraction(0))
+    while e:
+        if e&1: result=cmul(result,z)
+        z=cmul(z,z);e>>=1
+    return result
+
+
+def nearest_fraction(x,Q):
+    v=x*Q
+    sign=-1 if v<0 else 1;v=abs(v)
+    return sign*((2*v.numerator+v.denominator)//(2*v.denominator))
+
+
+def check():
+    rng=Random(20261022);cases=queries=0;maximum_setup=0;maximum_query=0
+    # Rational exact unit-circle points make the error oracle algebraic and exact.
+    # The phase-table proof applies to every unit complex z, including roots.
+    units=[(Fraction(0),Fraction(1)),(Fraction(3,5),Fraction(4,5)),
+           (Fraction(-5,13),Fraction(12,13))]
+    for D in (3,7,17,41,129):
+      for t in (1,2,3):
+       for z in units:
+        p=24
+        seed=tuple(nearest_fraction(x,1<<p) for x in z)
+        tab=PhaseTable(D,p,t,seed)
+        exponents=range(D) if D<=41 else [0,1,D-1,*[rng.randrange(D) for _ in range(15)]]
+        for e in exponents:
+            before=tab.operations;got=tab.power(e);used=tab.operations-before
+            want=cpow(z,e);bound=tab.coordinate_error_bound()
+            need(all(abs(Fraction(g,tab.Q)-v)<=bound for g,v in zip(got,want)),'exact phase error bound')
+            need(used<=54*tab.d,'constant digit operation envelope')
+            maximum_query=max(maximum_query,used);queries+=1
+        need(tab.setup_operations<=60*tab.d*(tab.R+tab.t),'setup envelope')
+        maximum_setup=max(maximum_setup,tab.setup_operations);cases+=1
+    # An actual altered table entry must change an exponent that uses it.
+    tab=PhaseTable(17,24,2,(0,1<<24));tab.tables[0][1]=(0,0)
+    need(tab.power(1)!=(0,1<<24),'mutated phase table escaped')
+    try:PhaseTable(129,8,3,(0,256))
+    except ValueError:pass
+    else:raise ValueError('undersized precision accepted')
+    return dict(status='PASS',table_cases=cases,power_queries=queries,
+                maximum_setup_operations=maximum_setup,maximum_query_operations=maximum_query,
+                mutated_table_control=True,undersized_precision_control=True,
+                scope='native bounded-word phase-table component; not a complete multiplication theorem')
+
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/raw-profile.json b/research/native-kappa-30201655/raw-profile.json
new file mode 100644
index 0000000000..edf41a49a0
--- /dev/null
+++ b/research/native-kappa-30201655/raw-profile.json
@@ -0,0 +1,274 @@
+{
+  "compiler": {
+    "H": 64215200000000,
+    "N": "2^64215200000000",
+    "eta": {
+      "lower": "0.000000206231977820868640096499",
+      "upper": "0.000000206231977820868640096500"
+    },
+    "gap": "1/1400000000",
+    "integer_test_exponent": 45868,
+    "logarithm_power": 1000,
+    "theta": "63/64",
+    "uniform_saving": "528527/175000000",
+    "word_materialized": false
+  },
+  "fixed_profile_ceiling": {
+    "decreasing_through_C": "1/20",
+    "headroom": [
+      "15977/1000000000000",
+      "159771/10000000000000"
+    ],
+    "negative_derivative_upper": {
+      "lower": "-195970.145588045890401261885812812963",
+      "upper": "-195970.145588045890401261885812812962"
+    },
+    "remaining_interval_moment_upper": {
+      "lower": "-6847.019825166589746262304732988153",
+      "upper": "-6847.019825166589746262304732988152"
+    },
+    "root": [
+      "3020165977/1000000000000",
+      "30201659771/10000000000000"
+    ]
+  },
+  "full_calls": 18,
+  "gain_over_PR4416": "4171/12500000",
+  "gain_over_PR4440": "1203/20000000",
+  "gain_over_PR4441": "191/10000000",
+  "gain_over_PR4447": "473/25000000",
+  "kappa": "60403/20000000",
+  "kappa_decimal": "0.00302015",
+  "local_helpers": {
+    "4": 28,
+    "7": 7,
+    "8": 47,
+    "9": 326
+  },
+  "local_paid": {
+    "1": 2237,
+    "2": 388,
+    "3": 494,
+    "4": 147,
+    "5": 36,
+    "8": 8
+  },
+  "negative_controls": {
+    "closed_epsilon": [
+      "epsilon_below_one",
+      "global_gamma_power_slack",
+      "actual_logarithmic_gamma_guard",
+      "source_axis_superpolynomial",
+      "gaussian_above_main",
+      "new_semantic_guard_with_C1_one"
+    ],
+    "closed_uniform": [
+      "new_complex_uniform_saving_above_b"
+    ],
+    "old_BIT": [
+      "actual_bit_above_effective"
+    ],
+    "unfunded_endpoint": [
+      "main_transform_above_kappa",
+      "global_coordinate_router_above_kappa",
+      "fused_gaussian_above_kappa",
+      "group_bit_router_above_kappa",
+      "boundary_algebraic_matrix_above_kappa"
+    ]
+  },
+  "nonrecursive": {
+    "local_route_bound": 4814000,
+    "local_scalar_allowance": 158168,
+    "raw_budget": 1000000000,
+    "raw_upper": 181098496
+  },
+  "ordinary_BIT": {
+    "admitted": "17/5000",
+    "after_cover": "69/20000",
+    "atom": "1/250",
+    "before_cover": "3459/1000000",
+    "ordinary_saving": "8590884599/2500000000000",
+    "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+  },
+  "outer": {
+    "functional_checks": {
+      "actual_new_BIT_stock_sublinear": "348599999253/350000000000",
+      "fixed_halo_explicit_metadata_branch": "26950000001/350000000",
+      "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000",
+      "new_semantic_group_guard": "3/1400000000"
+    },
+    "margins": {
+      "boundary_algebraic_matrix": "5919499595771787/1960000000000000000",
+      "fused_gaussian": "5919499587315361/1960000000000000000",
+      "global_coordinate_router": "2114107/700000000",
+      "group_bit_router": "2959750493657679/980000000000000000",
+      "group_scans": "699999999/700000000",
+      "main_transform": "5919498195771787/1960000000000000000",
+      "microbox_face_corrections": "26950000001/350000000",
+      "polynomial_products": "1399999999/1400000000",
+      "sparse_union_movement": "802169499595771787/1960000000000000000"
+    },
+    "parameters": {
+      "a": "2114107/700000000",
+      "b": "845643/280000000",
+      "beta": "1399999997/1400000000",
+      "bit_saving": "17/5000",
+      "cap_xi": "1782169498195771787/1960000000000000000",
+      "complex_uniform_saving": "528527/175000000",
+      "d": "1/1400000000",
+      "epsilon": "1399999999/1400000000",
+      "kappa": "60403/20000000",
+      "lambda_": "398791939/400000000",
+      "lambda_prime": "1395771787/1400000000",
+      "layout": "1/1400000000",
+      "q": "4228213/1400000000",
+      "r0": "1/14000000000",
+      "stop": "1/1400000000",
+      "tested_saving": "604031/200000000"
+    },
+    "strict_checks": {
+      "actual_bit_above_effective": "265893/700000000",
+      "actual_logarithmic_gamma_guard": "1/1400000000",
+      "actual_logarithmic_group_guard": "177830503904228213/980000000000000000",
+      "alpha_logarithm_absorption": "1/14000000000",
+      "boundary_algebraic_matrix_above_kappa": "5595771787/1960000000000000000",
+      "cap_above_band": "802169498195771787/1960000000000000000",
+      "cap_below_cell": "177830500404228213/1960000000000000000",
+      "cap_below_phase_cell_power": "2137830501804228213/1960000000000000000",
+      "complex_above_effective": "1/1400000000",
+      "complex_below_one_over_32": "7904357/280000000",
+      "complex_endpoint": "1/700000000",
+      "epsilon_below_one": "1/1400000000",
+      "epsilon_positive": "1399999999/1400000000",
+      "fine_prime_halo_umbrella": "7/2",
+      "fused_gaussian_above_kappa": "5587315361/1960000000000000000",
+      "gaussian_above_main": "695771787/980000000000000000",
+      "global_coordinate_router_above_kappa": "1/350000000",
+      "global_gamma_power_slack": "9/14000000000",
+      "group_below_dimension": "1/700000000",
+      "group_bit_router_above_kappa": "3493657679/980000000000000000",
+      "group_gauge_power_slack": "177830503834228213/980000000000000000",
+      "group_key_fits_record": "1/700000000",
+      "group_positive": "1399999997/1400000000",
+      "group_scans_above_kappa": "348942947/350000000",
+      "halo_covers_generic_inverse_radius": "5",
+      "improvement_over_user_baseline": "644589790400418148631/500000000000000000000000",
+      "lambda_above_internal": "1/2800000000",
+      "lambda_above_sigma": "3/2800000000",
+      "lambda_above_tau": "1/2800000000",
+      "lambda_prime_above_lambda": "1/2800000000",
+      "lambda_prime_above_leaf": "559154357/392000000000000000",
+      "leaf_saving_above_effective": "279154357/392000000000000000",
+      "main_transform_above_kappa": "4195771787/1960000000000000000",
+      "membership_arithmetic_fits_record": "1/1400000000",
+      "microbox_face_corrections_above_kappa": "53897885897/700000000",
+      "microbox_halo_volume": "110600000003/1400000000",
+      "new_complex_uniform_saving_above_b": "1/1400000000",
+      "new_semantic_guard_with_C1_one": "1/1400000000",
+      "polynomial_products_above_kappa": "1395771789/1400000000",
+      "positive_layout_slack": "1/1400000000",
+      "q_below_effective": "1/1400000000",
+      "q_below_internal": "1/1400000000",
+      "q_below_leaf": "559154357/392000000000000000",
+      "q_positive": "4228213/1400000000",
+      "short_record_fallback": "279154357/280000000",
+      "source_axis_superpolynomial": "1/1400000000",
+      "sparse_union_movement_above_kappa": "796250005595771787/1960000000000000000",
+      "stop_below_one": "1399999999/1400000000",
+      "stop_positive": "1/1400000000",
+      "strassen_integer_power_gap": "1951441519231",
+      "support_router_span": "3/1400000000",
+      "theta_positive_polynomial_power": "2",
+      "union_header_fits_record": "3/1400000000",
+      "union_tag_work_per_visit_fits_record": "3/1400000000"
+    }
+  },
+  "paid": {
+    "1": 41946,
+    "16": 448,
+    "2": 6984,
+    "24": 448,
+    "3": 8892,
+    "32": 448,
+    "4": 2646,
+    "40": 448,
+    "48": 448,
+    "5": 648,
+    "56": 448,
+    "64": 448,
+    "72": 224,
+    "8": 144
+  },
+  "paid_calls": 64620,
+  "pairs": 16,
+  "prefix_pairs": 7,
+  "productive_fields": 10928,
+  "query_shears": 15,
+  "scope": "Author-checked conditional construction; retained native/all-column, owned-erasure, whole-job, analytic, precision, tape, prime and recovery contracts. No selected promotion or formal/human acceptance.",
+  "source_heads": {
+    "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51",
+    "PR4441_combination": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39",
+    "PR4447": "322e0ec764aa7ef7801383feb1f656e460dd8bed",
+    "helper_retiming": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9"
+  },
+  "source_inputs": 51,
+  "status": "PASS_CONDITIONAL_JOINT_HELPER_KAPPA_00302015",
+  "strictification": {
+    "alpha": {
+      "lower": "0.999999988558808354139963023136",
+      "upper": "0.999999988558808354139963023137"
+    },
+    "cutoff": 20,
+    "delta": {
+      "lower": "0.958284435309221389866479909583",
+      "upper": "0.958284435309221389866479909584"
+    },
+    "floor": 21,
+    "gamma": {
+      "lower": "0.956176646497545264598139374323",
+      "upper": "0.956176646497545264598139374324"
+    },
+    "limits": [
+      "999999999/1000000000",
+      "97/100",
+      "97/100"
+    ],
+    "normalized_paid_upper": "2097152001953127/2097154147483648",
+    "power": 1024,
+    "tail_offset": "1/5",
+    "tested": "604031/200000000"
+  },
+  "targets": {
+    "145": 224,
+    "17": 448,
+    "25": 448,
+    "33": 448,
+    "4": 504,
+    "41": 448,
+    "49": 448,
+    "57": 448,
+    "65": 448,
+    "7": 126,
+    "73": 224,
+    "8": 846,
+    "9": 5868
+  },
+  "uniform_local_gain": {
+    "coefficients": {
+      "1": 17,
+      "2": 126,
+      "3": -50,
+      "4": -42,
+      "5": 2,
+      "7": -22,
+      "8": 5,
+      "9": 17
+    },
+    "derivative_upper": {
+      "lower": "-16.327581880492435373215953558618",
+      "upper": "-16.327581880492435373215953558617"
+    },
+    "intervals": 128,
+    "vanishes_at_one": true
+  }
+}
diff --git a/research/native-kappa-30201655/record_product.py b/research/native-kappa-30201655/record_product.py
new file mode 100644
index 0000000000..fe528ae356
--- /dev/null
+++ b/research/native-kappa-30201655/record_product.py
@@ -0,0 +1,75 @@
+"""Global-precision native negacyclic record products, Apache-2.0.
+Dugongue with substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+from random import Random
+import json
+
+
+def need(ok,why):
+    if not ok:raise ValueError(why)
+
+
+def module(name):
+    p=Path(__file__).with_name(name);ns={'__name__':'record_component','__file__':str(p)}
+    exec(compile(p.read_bytes(),str(p),'exec'),ns);return ns
+
+
+class RecordProduct:
+    def __init__(self,r,p):
+        need(r>=1 and r&(r-1)==0 and p>=1,'record shape')
+        self.r=r;self.p=p;N=max(2,2*r)
+        self.F=16*p+16*r.bit_length()+64;self.S=1<<self.F
+        Convolver=module('native_convolution.py')['Convolver']
+        self.cv=Convolver(N,self.F,16*(self.F+16)+20)
+
+    def product(self,a,b):
+        r=self.r;p=self.p;S=self.S;v=self.cv.val
+        need(len(a)==len(b)==r,'record coefficient length')
+        need(all(abs(x)<1<<p for z in a+b for x in z),'record coefficient range')
+        aa=[(v(z[0]*S),v(z[1]*S)) for z in a]
+        bb=[(v(z[0]*S),v(z[1]*S)) for z in b]
+        kernel=self.cv.prepare(bb)
+        got=self.cv.apply(aa,kernel,2*r-1)
+        integers=[]
+        for z in got:
+            out=[]
+            for x in z:
+                value=v(v(x+S//2)//S)
+                need(abs(x-value*S)<S//4,'integer recovery separation')
+                out.append(value)
+            integers.append(tuple(out))
+        result=[]
+        for j in range(r):
+            high=integers[j+r] if j+r<len(integers) else (0,0)
+            result.append((v(integers[j][0]-high[0]),v(integers[j][1]-high[1])))
+        return result
+
+
+def check():
+    rng=Random(20261022);cases=points=0;peak=0
+    for r in (1,2,4,8,16,32):
+        for p in (8,48,192):
+            engine=RecordProduct(r,p)
+            for _ in range(2):
+                a=[(rng.randrange(-(1<<p)+1,1<<p),rng.randrange(-(1<<p)+1,1<<p)) for _ in range(r)]
+                b=[(rng.randrange(-(1<<p)+1,1<<p),rng.randrange(-(1<<p)+1,1<<p)) for _ in range(r)]
+                actual=engine.product(a,b);expected=[[0,0] for _ in range(r)]
+                # Independent exact schoolbook ring oracle; validation only.
+                for i,(ar,ai) in enumerate(a):
+                    for j,(br,bi) in enumerate(b):
+                        sign=1 if i+j<r else -1;k=(i+j)%r
+                        expected[k][0]+=sign*(ar*br-ai*bi)
+                        expected[k][1]+=sign*(ar*bi+ai*br)
+                need(actual==list(map(tuple,expected)),'negacyclic polynomial reference')
+                points+=r;cases+=1
+            peak=max(peak,engine.cv.maximum_bits)
+    try:RecordProduct(2,8).product([(256,0)]*2,[(1,0)]*2)
+    except ValueError:pass
+    else:raise ValueError('record overflow accepted')
+    return dict(status='PASS',signed_complex_record_products=cases,ring_coefficients=points,
+                maximum_bits=peak,overflow_control=True,TM_calls=0,
+                scope='direct global-word FFT record product; no local-log(record bitlength) word model')
+
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/root_seed.py b/research/native-kappa-30201655/root_seed.py
new file mode 100644
index 0000000000..549344f7e3
--- /dev/null
+++ b/research/native-kappa-30201655/root_seed.py
@@ -0,0 +1,107 @@
+"""Native bounded-word Gaussian root seeds; no TM, FFT or root oracle.
+Apache-2.0. Dugongue with substantial OpenAI Codex assistance.
+Signed values below are represented by a sign bit and a bounded magnitude.
+"""
+import json
+from decimal import Decimal,localcontext
+
+
+def need(p,msg):
+    if not p:raise ValueError(msg)
+
+class Bound:
+    def __init__(self,w):self.limit=1<<w;self.ops=0;self.high_bits=0
+    def value(self,x,cost=1):
+        self.ops+=cost;self.high_bits=max(self.high_bits,abs(x).bit_length())
+        need(abs(x)<self.limit,'finite-word overflow');return x
+
+
+def trunc_div(x,d):
+    return x//d if x>=0 else -((-x)//d)
+
+
+def root_seed(order,p,word_width=None):
+    need(order>=1 and p>=1,'root seed shape')
+    P=8*(p+16);S=1<<P;K=128*(p+1)
+    w=max(2*P+20,order.bit_length()+1) if word_width is None else word_width
+    need(w>=2*P+20 and order<(1<<w),'word-width contract')
+    v=Bound(w);v.value(order);v.value(S)
+    def atan_inverse(q):
+        power=q;j=0;acc=0
+        while power<=S:
+            den=v.value(power*(2*j+1),4)
+            term=v.value(S//den,1)
+            acc=v.value(acc+term if j%2==0 else acc-term,5)
+            power=v.value(power*q*q,2);j=v.value(j+1,2)
+        return acc
+    a5=atan_inverse(5);a239=atan_inverse(239)
+    pi=v.value((a5<<4)-(a239<<2),5)
+    theta=v.value((pi<<1)//order,3)
+    need(0<=theta<=8*S,'angle enclosure')
+    ar=S;ai=0;sr=S;si=0
+    for k in range(1,K+1):
+        den=v.value(S*k,2)
+        nr=v.value(trunc_div(v.value(-ai*theta,2),den),4)
+        ni=v.value(trunc_div(v.value(ar*theta,2),den),4)
+        ar,ai=nr,ni
+        sr=v.value(sr+ar,6);si=v.value(si+ai,6)
+    shift=P-p;half=1<<(shift-1)
+    def nearest(x):
+        z=v.value((abs(x)+half)>>shift,5)
+        return z if x>=0 else -z
+    real,imag=nearest(sr),nearest(si)
+    error_numerator=40*(P+2)+1+4096*K+32
+    # Seed internal error <= error_numerator/2^P; nearest rounding adds 2^(-p-1).
+    need((error_numerator<<(p+1))<(1<<P),'root error proof inequality')
+    need(v.ops<=100*(P+1)+40*(K+1),'root operation envelope')
+    return dict(real=real,imag=imag,fraction_bits=p,working_bits=P,order=order,
+                internal_error_numerator=error_numerator,internal_error_scale_bits=P,
+                max_coordinate_error_power=-p,word_width=w,largest_intermediate_bits=v.high_bits,
+                charged_word_operations=v.ops)
+
+
+def decimal_reference(order,p):
+    # Independent high-precision validation only; never part of the native runtime.
+    digits=int(p*.302)+60
+    with localcontext() as ctx:
+        ctx.prec=digits
+        tol=Decimal(10)**(-(digits-10))
+        def atan(q):
+            q=Decimal(q);power=q;j=0;s=Decimal(0)
+            while True:
+                t=1/(power*(2*j+1));s+=t if j%2==0 else -t
+                if t<tol:break
+                power*=q*q;j+=1
+            return s
+        pi=16*atan(5)-4*atan(239);t=2*pi/Decimal(order)
+        tr=sr=Decimal(1);ti=si=Decimal(0)
+        for k in range(1,10000):
+            tr,ti=-ti*t/k,tr*t/k;sr+=tr;si+=ti
+            if abs(tr)+abs(ti)<tol:break
+        return +sr,+si
+
+
+def check():
+    cases=0;ops=0;peak=0
+    for p in (1,2,4,8,16,32,64,128):
+        for order in (1,2,3,4,5,8,16,97,1009,(1<<40)+87):
+            out=root_seed(order,p)
+            x,y=decimal_reference(order,p)
+            with localcontext() as ctx:
+                ctx.prec=max(90,int(p*.302)+50)
+                scale=Decimal(2)**p;err=Decimal(2)**(-p)
+                need(abs(Decimal(out['real'])/scale-x)<err,'real root error')
+                need(abs(Decimal(out['imag'])/scale-y)<err,'imaginary root error')
+            need(out['largest_intermediate_bits']<out['word_width'],'bounded native intermediate')
+            cases+=1;ops+=out['charged_word_operations'];peak=max(peak,out['largest_intermediate_bits'])
+    try:root_seed(17,8,32)
+    except ValueError:pass
+    else:raise ValueError('undersized word accepted')
+    r=root_seed(4,16)
+    need((r['real'],r['imag'])==(0,1<<16),'exact quarter root')
+    return dict(status='PASS',root_seed_cases=cases,charged_native_word_operations=ops,
+                maximum_intermediate_bits=peak,undersized_word_rejected=True,
+                no_root_or_TM_oracle=True,uses_only_bounded_word_products=True,
+                emitted_RamStd_program=False,Lean_proof=False)
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/sources/4535-PROOF.md b/research/native-kappa-30201655/sources/4535-PROOF.md
new file mode 100644
index 0000000000..717065d140
--- /dev/null
+++ b/research/native-kappa-30201655/sources/4535-PROOF.md
@@ -0,0 +1,118 @@
+# Critical-root compilation of the joint-helper supplier
+
+This is a conditional consequence of the pinned source contracts, not a materialized algorithm or a claim of independent human acceptance. The companion verifier binds the numerical root, mirror, majorant, final-rank and outer certificates. Apache-2.0; substantial OpenAI Codex assistance.
+
+## 1. Statement and credited inputs
+
+Assume the all-column native, productive-owner, chronological whole-job, compact movement, semantic precision, fixed-tape, stock, analytic transfer, prime-avoidance and exact-recovery contracts retained by PR4470 and PR4483. Apply the critical-root compiler theorem of PR4532 to the unchanged PR4470 mixed profile. With the finite arithmetic certificates specified below, the retained integer-multiplication reduction admits the conditional saving
+
+\[
+\kappa=0.003020165.
+\]
+
+This exceeds PR4470's declared `0.00302015` by `0.000000015`. It neither changes the raw native supplier nor strengthens its physical premises. It does not identify the critical root itself as an attainable outer exponent.
+
+The native supplier is PR4470 at `b9a13c1673e0e9697de410de16e8bbf3207a7363`; the arbitrary-height finite compiler is PR4483 at `fb0c208864e6b24e3473318a058aa5b2dbd5764b`; the critical-root theorem is PR4532 at `644607ba59ebe401ac7ecd627ae7f331f924d1b0`. The integer/Pascal matching construction is Jacob Alan Sussman's; the overlapping flow and logarithmic majorant are zxv's; the mirror-window method is Ryanson Jonathan's; the joint-helper native lineage retains Cinna Davis and its earlier contributors; PR4532's new critical-root argument is credited to Dillon with Codex assistance. New material here is the application and the explicit conditional bridge below. Preserve the upstream licenses and attribution.
+
+## 2. What remains paid and productive
+
+Use the exact paid and target histograms authenticated against PR4470 and the compact consumer receipt. The raw unit has ambient rank145, 10,928 productive fields, all18 full supplier calls, all15 copied-query shears, the eight owned centre jobs within every full call, and all3,360 idle jobs. The updated joint-helper histogram, not an earlier controller histogram, is authoritative.
+
+Each productive field has an arbitrary independent input. Each paid occurrence remains a distinct chronological request even when another request has the same rank. Owned centres and query scratch are not productive fields. No input is cloned, no scratch is reclassified as a target, no field is identified with another field, and no scalar correction or idle job is dropped.
+
+Write
+\[
+T(t)=\sum_k W_k k^t,\qquad P(t)=\sum_r P_r r^t.
+\]
+The companion exact interval certificate isolates a simple crossing
+\[
+ 0.9969798340229<t_*<0.9969798340230
+\]
+and certifies the strict pointwise mirror inequality at that crossing. A favorable moment alone is insufficient: the mirror cells, endpoint conventions and zero-source cells are checked as in PR4532. Root isolation and this mirror certificate are inputs to the theorem, not consequences of rounded numerical root finding.
+
+## 3. A funded finite uniform rank
+
+PR4532 supplies a majorant
+\[
+ L(n)\le A n^{t_*}(c+\log n)^p
+\]
+with the ordinary base range and its normalization fully funded. Here `L` counts normalized rank-one paid leaves, including source complements and boundary and leaf exits. At every positive integer rank the finite compiler clears its actual integer batch denominators. Recursive exit and complement ranks are strictly smaller than their parent rank; the elementary base construction is `L(n)=n` and is charged.
+
+Set
+\[
+ s_C=0.0030201656,\qquad z=1-s_C=0.9969798344.
+\]
+The root bracket gives `z-t_* > 377/10^12 > 0`. The companion exact compiler certificate verifies the full logarithmic inequality, including `log A` and the base cutoff, at
+\[
+ N=2^{10^{12}}.
+\]
+The certificate uses `M=1024`, height multiplier `g=2`, `p=2/5`, `c=133`, and `n0=145*1024^650`, with `A=n0^(1-t_*)/(133+log n0)^(2/5)`. The exact tail/mirror certificate funds this majorant; final absorption is checked separately. It bounds `log A<20`, `(2/5)log(133+log N)<16`, and `(z-t_*)log N>754/3`. Therefore the strict logarithmic margin exceeds `646/3`, proving `L(N)<N^z`. This includes the normalization and ordinary base cost. It is not merely an appeal to eventual absorption.
+
+Freeze this `N` before the eventual multiplication input varies. PR4483 section1 constructs a finite chronological program at this fixed rank. Empty-root classes, when present, receive their own distinct top inputs; they do not share an earlier input. All unmatched paid requests and source-completion requests remain in the word. Whole jobs finish before their suspended caller resumes.
+
+Expand the finite rank recursion and clear integer widths. Let `W` be the resulting number of independent productive arrays, all with the full rank-`N` endpoint, and let `P_leaf` be its number of rank-one paid children, counting multiplicity. Then
+\[
+ P_{leaf}/W=L(N)<N^z.
+\]
+Thus the complete uniform moment is strictly below1. The word is algorithmically specified and finite; it is not materialized. No bound on its practical size follows from the displayed rank. The finite counting bound can nevertheless be made explicit: with raw counts `W0=10928`, `P0=64620` and rank surplus752, the companion finite-word ledger bounds the adaptive height by `2*10^11`, a class-count envelope by `C_N<2^3400000000031`, and a divisible-width envelope by `B_N<C_N^N`. For the class-count bound, `W0<2^14` and `W0+P0<2^17`; summing capped target/paid paths is bounded by the corresponding uncapped binomial expansion. Including endpoint jobs is bounded conservatively by `W0*(W0+P0)^(G_depth+1)<2^(17*G_depth+31)`. Capping deletes instances and does not increase this count. If `B_0=1`, the divisible-width rule `B_n=B_(n-1)*S_n`, where `S_n` is the positive source count at rank `n`, makes every earlier width divide the new batch and gives `B_N<C_N^N`. Elementary base ranks use width1. These are conservative fixed integer bounds, not materialized counts. Exact rank-mass telescoping gives `B_N*N-P_leaf=752*Q_col`, where `Q_col` is total raw-unit column multiplicity; each occurrence has positive integer multiplicity, so `U<=Q_col<=B_N*N/752`. Actual allocated ownership and record counts, rather than only the 144 full-call centre episodes per mixed-unit occurrence, are used below.
+
+## 4. Fresh constants for this word
+
+This step invokes the same general fixed-template closure contracts as the predecessors. It is not a deduction of physical cost from a leaf histogram alone.
+
+Use an exact expansion of the chosen finite compiler as the definition of the following integers. Computing these integers is a finite algorithm; this claim does not assert that their enormous numerical values have been computed.
+
+* `U`: number of occurrences of the raw mixed native unit in the completely expanded word.
+* `W,P_leaf`: the actual productive width and rank-one paid count after all batch widths are cleared.
+* `O`: a safe maximum number of simultaneously live owned field banks, including raw centres, thin-query fields, compiler adapter temporaries, suspended jobs, and any additional parking field required by the chosen implementation. Assigning a separate bank to every owned allocation in the entire expanded word is a valid conservative choice. If parking retains an existing role stream without a new field, count that stream in the live-role inventory instead; do not count the same physical field twice. `144U=18*8*U` bounds only the full-call centre episodes and is not used as a bound for all scratch. The15 thin stages also have112 port-query episodes each; assigning a separate owned field to every such episode gives the further conservative bound `1680U`. Reuse within a stage may reduce this, but is not assumed. One bank per recursion depth is not sufficient in general.
+* `G`: an integer envelope for the actual expanded coefficient-height and unit-phase charge. For an ADD of dyadic coefficient `a`, include at least `ceil(log2(1+|a|))+log2 denominator(a)`; for a dyadic SCALE include `ceil(log2(max(1,|a|)))+log2 denominator(a)` instead. Include every scalar macro, elementary normalization and fixed phase correction with a conservative elementary allowance. Include all compiler-boundary records in the inventory. A larger computable envelope is permitted.
+* `R_phys,R_match`: counts of the actual physical records and whole-job matching/normalizer records, together with explicit fixed binary matrices, phase descriptors and their native row-addition/swap decompositions. These are counted separately from coefficient height; a zero-height permutation is not a zero-cost tape operation. The companion ledger provides a conservative elementary normalizer count `F_N=16(N+1)^2` from binary Gaussian elimination and quadratic fourth-root phase terms; this is an operation/descriptor bound, not an independent packed execution theorem. Alternatively, count the actual finite recipes directly. Their implementation still uses the retained whole-job and compact movement tariffs.
+
+For clarity, the height bound above is `G_depth<=2*10^11`; the coefficient envelope is `G_coeff=G`, a different integer. The exact width-clearing prescription may choose final `W=B_N<C_N^N`. The bound `U<=W*N/752` follows from the retained positive rank surplus, with elementary completions and leaves still charged. A conservative physical-record envelope is
+
+`R_phys <= [A_raw + 32*(W0+P0)*F_N + 1]*W*N`,
+
+where `A_raw` is a freshly counted upper bound for all raw physical records. Any implementation allocating additional parking or routing instructions enlarges this envelope and its exact allocation count; it is not silently covered by the `144U` full-call centre bound. Both the conservative envelope and direct counting are fixed finite procedures at the chosen `N`.
+
+All coefficients remain dyadic: the raw native word has dyadic scalar coefficients; the compiler uses whole-job coordinate matching and integer replication, not divisions by the normalized source count. Clearing integer widths implements that normalization combinatorially. Elementary leaves and complete source normalizers remain actual instructions. This point must be checked against the emitted construction, not inferred by treating the rational recurrence as a physical instruction.
+
+Under the retained completed-child semantic precision lemma, instantiate fresh constants, for example
+\[
+ Z=W+O,\quad E=64(Z+N+P_{leaf}+G+1)^3,\quad B=P_{leaf}+E,
+ \quad C_0=32NB^2,\quad C_1=1.
+\]
+These are the general finite-template formulas from the credited closure argument, applied to the new word and its own envelope. Their applicability assumes the same complete-field normalizers and completed-child semantics. They are **not** asserted for an arbitrary circuit solely because its scalar coefficients are dyadic. If additional records require a larger envelope or a larger fixed constant in that lemma, enlarge it before fixing the eventual threshold. No old p3, PR4470 or PR4479 numerical scalar, stock or precision cap is reused.
+
+For ordinary recursion let `D(e)=0` below `N` and `D(e)=1+D(floor(e/N))` otherwise. Reserve
+\[
+ q_0=\lceil\log_2 W\rceil D(e)
+\]
+complete preceding chunks for the row stock, with actual one-time whole-row padding and all active/control/spectator coordinates. This is `O(log e)` with a fixed, possibly enormous coefficient. Retain the independent BIT stock when both are needed; replacing their product by a maximum is invalid.
+
+Owned buffers remain separate from productive credit. Every suspended allocation keeps its own live bank until its specified restoration or erasure. Parking, copying, initialization and clearing are paid fixed-volume operations under the inherited owned-erasure and movement contracts; their coefficient and physical-record constants are newly counted. No dirty-borrowed buffer may be cleared as if owned.
+
+Every binary matrix now has fixed finite dimension. Its actual row-addition and coordinate-swap recipe is a fixed template; its column lift uses the inherited compact movement implementation rather than an unpriced RAM gather. The numbers of role streams, tapes, instruction types and descriptor recipes are fixed after `N` is frozen. Any descriptor setup polynomial has a fixed degree. These statements rely on the retained native/movement and fixed-tape contracts; the arithmetic verifier does not establish them anew.
+
+## 5. Outer transfer and absorption
+
+Choose `d=10^-10` and the exact parameters
+\[
+ b=\kappa+5d,\quad a=\kappa+4d,\quad q=\kappa+3d,
+ \quad\epsilon=1-d,\quad\beta=1-3d,
+ \quad r_0=d/10,\quad stop=layout=d.
+\]
+Use complex uniform saving `kappa+6d=s_C` and the retained BIT saving `.0034` with atom exponent `.004`. The source outer ledger recomputed at these values passes all54 strict predicates, the nine outer cost rows and all4 functional guards. Its minimum cost-row saving minus `kappa` is
+\[
+ 29969798347/10^{20}>0.
+\]
+The finite-word constants above are fixed before the outer input grows. The positive power gaps therefore absorb fixed multiplicative constants and the retained logarithmic row-stock/descriptor factors by increasing the eventual input cutoff. The superpolynomial record-fiber argument absorbs fixed-degree descriptor preparation under its existing hypothesis. Neither assertion absorbs an omitted variable-cost operation or an unpriced change of computational model.
+
+The actual numerical cutoff must depend on the newly instantiated constants. No explicit overall multiplication input threshold, improvement of that threshold, practical runtime gain or materialized word is claimed.
+
+## 6. Admission boundary
+
+The conditional exponent consequence follows if the generic finite-template closure contracts retained in PR4470/PR4483 apply to the fixed compiler word just described, and the companion finite root/mirror/compiler/outer certificates pass. This is the intended inherited premise, now made explicit for the changed compiler.
+
+PR4532 alone proves a normalized leaf majorant. It does not supply native tensor realization, physical movement, precision, stock, prime exclusions or analytic recovery. If the generic fixed-template closure premise is not established or accepted for this algorithmically expanded word, the conclusion remains a conditional parameter consequence pending that physical bridge; it cannot be promoted to an unconditional multiplication theorem. Likewise, the absence of computed gigantic constants cannot be described as a complete numerical physical audit.
+
+This construction preserves all source obligations and improves only the conditional exponent consequence. It does not establish global optimality, change the selected frontier automatically, or claim independent human or formal-kernel verification.
diff --git a/research/native-kappa-30201655/sources/4535-README.md b/research/native-kappa-30201655/sources/4535-README.md
new file mode 100644
index 0000000000..3e50c34d27
--- /dev/null
+++ b/research/native-kappa-30201655/sources/4535-README.md
@@ -0,0 +1,34 @@
+# Conditional multiplication κ = 0.003020165
+
+Combining PR4532's critical-root compiler with PR4470's unchanged native supplier gives the conditional multiplication saving **κ = 0.003020165**, an absolute gain of **0.000000015** over PR4470's 0.00302015. This is a small compiler-and-transfer improvement, not a new geometry or a lower native paid invoice.
+
+The complete p16 profile remains 10,928 productive fields and 64,620 paid jobs, including all owned centres, idle jobs, copied-query shears and independent helper outputs. Its raw moment crossing is unchanged, near 0.003020165977. The new construction certifies uniform complex saving 0.0030201656 at sufficient fixed local rank `N = 2^1000000000000`, then uses a new exact outer parameter point with all 54 strict predicates and four functional guards positive. Ordinary BIT saving remains 0.0034.
+
+The argument first freezes a finite integer-compiled word and replaces its precision, stock, owned-space, movement and fixed-tape constants using the general finite-template closure. It does not copy the old expanded-word constants. These constants are algorithmically specified; the enormous word is not materialized. The stated local rank is not an overall multiplication input threshold or a practical speedup.
+
+## Evidence and reproduction
+
+Run Python 3.12 from the repository root:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/critical-root-multiplication --check-only
+python3.12 -B scripts/research_package.py --package research/critical-root-multiplication
+```
+
+The registered commands replay PR4470's unchanged dependency and native gates, then check the new exact arithmetic. The native gate covers 632 arbitrary input columns in both orientations and 423 physical frame pairs, including absolute phase. The new checker authenticates sources, reruns the PR4532 arithmetic, binds its profile to PR4470, proves finite logarithmic absorption, and checks the complete outer ledger. Mutations reject a changed paid profile, a closed root gap, an unfunded logarithmic bound and κ without uniform-supplier slack.
+
+`PROOF.md` supplies the mathematical combination and finite physical closure argument. `RESULT.json` is a finite arithmetic certificate, not a formal proof of that argument or of the inherited hypotheses. `VALIDATION.md` records actual commands and limitations.
+
+Reporting clarification following Ryanson Jonathan's independent arithmetic check in PR4536: `absorption.margin_lower` is evaluated at `log(N)=10^12`, whereas `absorption.cost_margin_lower=646/3` is the conservative bound at the stated `N=2^(10^12)`. The certificate now labels both evaluation points explicitly. Neither the cutoffs, margins nor κ changed. PR4536 checks arithmetic, not the compiler theorem or physical premises.
+
+## Scope and attribution
+
+This branch is stacked on PR4532 at `644607ba59ebe401ac7ecd627ae7f331f924d1b0`. Its predecessor files are unchanged and are not new work here. Canonical main at preparation was `f9f85c1e4fa1e955ff39f10fca447e3e2a4e4adc`. The selected record is untouched.
+
+Credit Dillon's PR4532 critical-root theorem; zxv's PR4483 adaptive compiler and earlier flow/majorant work; Jacob Alan Sussman's integer compiler; Ryanson Jonathan's corrected mirror method; Cinna Davis and the credited PR4470 native lineage; Dugongue's PR4479 compact-consumer analysis; and all retained BIT, physical, precision, tape and outer-ledger authors. New combination prepared for hexapode with substantial OpenAI Codex assistance. Apache-2.0.
+
+The native all-column lift, whole-job implementation and movement tariffs, permitted owned erasure, semantic precision, fixed-tape execution, stock, analytic decomposition, prime avoidance and exact recovery remain explicit conditional premises. No independent human review, proof-assistant acceptance, unconditional theorem or selected-frontier promotion is claimed. PR4532's own unmerged status and proof scope remain relevant.
+
+## Open next questions
+
+The fixed-profile headroom is now small. A larger improvement needs a changed native supplier or recursive interface with a complete paid/output invoice and both operator replays. Separately, the conservative finite-word bounds could be sharpened by emitting a small adaptive forest and auditing its actual widths and routes. Neither task is solved by the present exponent certificate; see `TASK.json` for their first steps and blockers.
diff --git a/research/native-kappa-30201655/sources/4535-RESULT.json b/research/native-kappa-30201655/sources/4535-RESULT.json
new file mode 100644
index 0000000000..1c7af6e350
--- /dev/null
+++ b/research/native-kappa-30201655/sources/4535-RESULT.json
@@ -0,0 +1,268 @@
+{
+  "BIT_admission": {
+    "admitted": "17/5000",
+    "after_cover": "69/20000",
+    "atom": "1/250",
+    "before_cover": "3459/1000000",
+    "ordinary_saving": "8590884599/2500000000000",
+    "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+  },
+  "absorption": {
+    "conclusion": "A*N^theta*(133+logN)^(2/5)<=N^t above this finite cutoff; physical implementation overhead not inferred",
+    "cost_all_larger_N_monotonicity": true,
+    "cost_margin_evaluation_N": "2^1000000000000",
+    "cost_margin_lower": "646/3",
+    "logA_upper": "11588535078387598648766751054204368156120388952774219/850705917302346158658436518579420528640000000000000",
+    "log_threshold": 1000000000000,
+    "margin_evaluation_log_N": 1000000000000,
+    "margin_lower": "299725246478781048809002279469549139266283611047225781/850705917302346158658436518579420528640000000000000",
+    "margin_scope": "margin_lower is evaluated at log(N)=log_threshold; cost_margin_lower is the conservative certified margin at primary_certified_N. The two margins use different cutoffs.",
+    "positive_gap": "377/1000000000000",
+    "primary_certified_N": "2^1000000000000",
+    "secondary_conservative_N_cutoff": "2^2000000000000"
+  },
+  "critical_root": {
+    "beta": "141/250",
+    "conclusion": "Unique crossing on this bracket; critical-root hypotheses hold.",
+    "critical_root_interval": [
+      "9969798340229/10000000000000",
+      "996979834023/1000000000000"
+    ],
+    "derivative_floor": "1",
+    "endpoint_target_minus_paid": [
+      [
+        "-1/1000000",
+        "0"
+      ],
+      [
+        "0",
+        "1/1000000"
+      ]
+    ],
+    "funded_mirror_cells": [
+      {
+        "left": "1/72",
+        "right": "1/65",
+        "upper_ratio": "141309/500000"
+      },
+      {
+        "left": "1/65",
+        "right": "1/64",
+        "upper_ratio": "37509/250000"
+      },
+      {
+        "left": "1/64",
+        "right": "1/57",
+        "upper_ratio": "477989/1000000"
+      },
+      {
+        "left": "1/57",
+        "right": "1/56",
+        "upper_ratio": "303319/1000000"
+      },
+      {
+        "left": "1/56",
+        "right": "1/49",
+        "upper_ratio": "135741/250000"
+      },
+      {
+        "left": "1/49",
+        "right": "1/48",
+        "upper_ratio": "187981/500000"
+      },
+      {
+        "left": "1/48",
+        "right": "1/41",
+        "upper_ratio": "562811/1000000"
+      },
+      {
+        "left": "1/41",
+        "right": "1/40",
+        "upper_ratio": "25767/62500"
+      },
+      {
+        "left": "1/40",
+        "right": "1/33",
+        "upper_ratio": "140197/250000"
+      },
+      {
+        "left": "1/33",
+        "right": "1/32",
+        "upper_ratio": "430399/1000000"
+      },
+      {
+        "left": "1/32",
+        "right": "1/25",
+        "upper_ratio": "68367/125000"
+      },
+      {
+        "left": "1/25",
+        "right": "1/24",
+        "upper_ratio": "220287/500000"
+      },
+      {
+        "left": "1/24",
+        "right": "1/17",
+        "upper_ratio": "52779/100000"
+      },
+      {
+        "left": "1/17",
+        "right": "1/16",
+        "upper_ratio": "450273/1000000"
+      },
+      {
+        "left": "1/16",
+        "right": "1/9",
+        "upper_ratio": "101799/200000"
+      },
+      {
+        "left": "1/9",
+        "right": "1/8",
+        "upper_ratio": "60647/1000000"
+      },
+      {
+        "left": "1/8",
+        "right": "1/7",
+        "upper_ratio": "9019/500000"
+      },
+      {
+        "left": "1/7",
+        "right": "1/5",
+        "upper_ratio": "3127/250000"
+      },
+      {
+        "left": "1/5",
+        "right": "1/4",
+        "upper_ratio": "13237/1000000"
+      }
+    ],
+    "maximizing_cell": [
+      "1/48",
+      "1/41"
+    ],
+    "mirror_upper": "562811/1000000",
+    "scope": "Rank-inventory admission criterion; native and outer obligations inherited.",
+    "source_capacity_lower": "491053/500000",
+    "uniform_mean_gap_lower": "521143/500000"
+  },
+  "finite_envelope": {
+    "G_depth_upper": 200000000000,
+    "class_envelope": "C_N <= W0*(W0+P0+1)^(G_depth+1) < 2^3400000000031",
+    "divisible_width_bound": "B_N < C_N^N",
+    "full_call_centre_episodes_per_raw_unit": 144,
+    "height_base": 1024,
+    "height_multiplier": 2,
+    "log2_C_N_strict_upper": 3400000000031,
+    "owned_space_scope": "144U and1680U bound separate raw episodes, not total live scratch. Actual compiler/parking allocations require their own O ledger.",
+    "primary_N": "2^1000000000000",
+    "proof_scope": "Height/class recurrence, denominator clearing and positive-surplus occurrence inequalities are inherited proof premises. Only their displayed integer arithmetic is checked; no gigantic word or B_N is materialized.",
+    "raw_occurrence_bound": "U <= B_N*N/752",
+    "raw_paid_jobs": 64620,
+    "raw_productive_fields": 10928,
+    "raw_rank_surplus": 752,
+    "thin_query_episodes_per_raw_unit": 1680
+  },
+  "functional_checks": 4,
+  "kappa": "604033/200000000",
+  "minimum_outer_margin_above_kappa": "29969798347/100000000000000000000",
+  "outer_checks": 54,
+  "outer_parameters": {
+    "a": "15100827/5000000000",
+    "b": "6040331/2000000000",
+    "beta": "9999999997/10000000000",
+    "bit_saving": "17/5000",
+    "complex_uniform_saving": "3775207/1250000000",
+    "d": "1/10000000000",
+    "epsilon": "9999999999/10000000000",
+    "kappa": "604033/200000000",
+    "layout": "1/10000000000",
+    "q": "30201653/10000000000",
+    "r0": "1/100000000000",
+    "stop": "1/10000000000",
+    "tested_saving": "30201657/10000000000"
+  },
+  "physical_bridge": "Conditional proof premise: retained native, movement, precision, stock and fixed-tape closure must apply to the fixed expanded word; this arithmetic check does not establish physical admission.",
+  "rejected_mutations": {
+    "closedrootgap": "closed root gap",
+    "kappa_equals_uniform": "raw kappa lacks uniform slack",
+    "log_absorption_failure": "log absorption derivative",
+    "nativeprofile": "native profile altered"
+  },
+  "retained_root_applications_replayed": [
+    "p7",
+    "p16"
+  ],
+  "source_sha256": {
+    "research/adaptive-gate-existence/PROOF.md": "340d637feef40f44a808c718207c0fede12cc483e2c979b86c56bb736b9c1ef5",
+    "research/adaptive-gate-existence/SOURCES.json": "ca5f833fd92acd6fac36fef73692550f4250b39f24760840e72b5868884048d9",
+    "research/adaptive-gate-existence/WITNESS.json": "f1fa3d91efe8fb32e038941776f9db54a6d935eeb2b28bd2b3168aa8f70251e4",
+    "research/adaptive-gate-existence/root_application.py": "e656ef12f73a8dd3bdb256eca95a712de1269facb18a652fc4068ba718619b4d",
+    "research/adaptive-gate-existence/verify.py": "9f0c0fbddbba2d9c38a73097db911fc5cdacf8ea1d182e037f4779577dca253a",
+    "research/compact-joint-compiler/PROOF.md": "3f337fba12288d3b5e51af9541e2a645f79c8668fabf48b212672285fe6150b4",
+    "research/compact-joint-compiler/arithmetic/RESULT.json": "a6caaa2a6d6460a8c1ef7e48c4853bb27976be33a52b96a4216dfa90d96c9091",
+    "research/direct-mixed-flow/README.md": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8",
+    "research/fresh-helper-boundary/ARITHMETIC-RESULT.json": "5d25fec9ac4b036c93846a50dccfa4af030e2982f5cec02e28702193bf157cf7",
+    "research/fresh-helper-boundary/CHANGES.json": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624",
+    "research/fresh-helper-boundary/NATIVE-RESULT.json.gz": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839",
+    "research/fresh-helper-boundary/RESULT.json": "34163eeeef1cd712de457d7fd3b0435f98a12ac456b82256b078f33225456fbd",
+    "research/fresh-helper-boundary/SOURCES.json": "01998e9b86222d10811fc0114dcd5c946ff9e95025a7cacd00e67a3eefe543d0",
+    "research/fresh-helper-boundary/arithmetic.py": "212bae96d0ddcbc25076afe2589a47736c66b77420057f28c44c937ad087fc07",
+    "research/fresh-helper-boundary/native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29",
+    "research/fresh-helper-boundary/verify.py": "4c18851214400cf955e10565d89357029d9e765140233831472ce23f0c3ee7bf",
+    "research/fresh-helper-thinned/PROOF.md": "9883b3329fef7624d3471e27bb55258cd9dc18bb6d37779a3939de99add87347",
+    "research/fresh-helper-thinned/README.md": "70c1c872c2327c3f71918e218d5f1ecb7a00037771a5dd1b8ae415b84cc90dc2",
+    "research/fresh-helper-thinned/RESULT.json": "8e7db2fed5f4be6a7f944bc59e7942ccbcc3e6c36130b5671331540c183ada21",
+    "research/fresh-helper-thinned/SOURCES.json": "5aec5df5096ee8a3e90618d311640b4bdfba42be5bc4bc5fab55e8be858ab2cb",
+    "research/fresh-helper-thinned/verify.py": "c841265ccee9b6f79045ad818ce9d27cfd7ee1f60047525a75d491f0dd8b997a",
+    "research/higher-moment-strictification/README.md": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d",
+    "research/higher-moment-strictification/RESULT.json": "ad79e3c0459e7b495a0ca34010553b12147779a007389e1695cc1336f123c156",
+    "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326",
+    "research/joint-helper-lattice/RESULT.json": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21",
+    "research/joint-helper-lattice/SOURCES.json": "4045942a3b3516380c980b547e80ac254bc22e4c21c74ac16e48d3f0e46955f6",
+    "research/joint-helper-lattice/VERIFY.json": "1d004a782ff9d8264e4f3f6e6fbee729047ec7a24874fb03728695ef527786a8",
+    "research/joint-helper-lattice/native_joint.py": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46",
+    "research/joint-helper-lattice/verify.py": "8eb13f77a94315f811612cb557a17edeecb6b9d9a75dfa238b112dd6520c336f",
+    "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85",
+    "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa",
+    "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7",
+    "research/kappa-function-composition/complex/prune_native.py": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257",
+    "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a",
+    "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef",
+    "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json": "9ece46fdfda6182e757e9a3b1f513fb3d029d730f3bafdcd6ed59180a14175b0",
+    "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443",
+    "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf",
+    "research/kappa-rebuild/bit/bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7",
+    "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497",
+    "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e",
+    "research/kappa-rebuild/complex/FULL-IDENTITY.md": "c4aa88c4943ef041e9542c519b7600ecf26ed6caff92558fdb07ac88ace64c17",
+    "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6",
+    "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61",
+    "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39",
+    "research/kappa-rebuild/complex/native_extensions.py": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3",
+    "research/kappa-rebuild/complex/power_two_balance.py": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424",
+    "research/kappa-rebuild/complex/rebuild_native.py": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5",
+    "research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9",
+    "research/kappa-rebuild/transfer-audit/p3_native_audit.py": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902",
+    "research/missing-join-frame/NATIVE.json.gz": "96718b257db24f4f62d3b86b36cdd514e67d2cb99947ddd7bdcb9b55a2c17841",
+    "research/missing-join-frame/PATCH.json": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e",
+    "research/missing-join-frame/PROOF.md": "50061c25d379ff5733135dbed53e8721bbd4dbee6766d1609d8a2ecdebb7dc06",
+    "research/missing-join-frame/RESULT.json": "25f2cbcde988847ff86f44e804982069863ec99ff68097f16e9bb7a1a17c4cd0",
+    "research/missing-join-frame/verify.py": "21429dd9c1b9c93ebb57e5fbb8ef674d0e4146ac8c25cc7c097c3352c02366a4",
+    "research/pr4359-p7-padding/P7-FACTOR.json": "6f96f6be5d8441f71cbe6ebb1657c69b543eb085b848b92b591b7ac01d6e6598",
+    "research/pr4359-p7-padding/TENSOR.md": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3",
+    "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15",
+    "research/pr4359-p7-padding/native_inventory.py": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32",
+    "research/query-thinned-controllers/BIT-CONTROLLER.json": "39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d",
+    "research/query-thinned-controllers/COMPLEX-CONTROLLER.json": "bf1143325d8380fab40cd5a85449f9a5412f0340deba7f4693714c92ae320088",
+    "research/query-thinned-controllers/RESULT.json": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f",
+    "research/query-thinned-controllers/SOURCES.json": "74b73563d9f78a4562d376b6f33528d652e41097f65747667f112a3e1fa81d29",
+    "research/query-thinned-controllers/controller.py": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2",
+    "research/query-thinned-controllers/verify.py": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950",
+    "research/rank-convergence/BENCHMARKS.json": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850",
+    "research/rank-convergence/PROOF.md": "3c971c5670669cb36312815b111e64c83e1490a10ee82f5412bd9aee01e9c376",
+    "research/rank-convergence/README.md": "e77af882d3f02a9d3f2dd19dce889052f63892a1c8f39fdbe0813ff5fab5e8c1",
+    "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+  },
+  "status": "PASS_EXACT_CONDITIONAL_PARAMETER_CERTIFICATE",
+  "uniform_saving": "3775207/1250000000"
+}
diff --git a/research/native-kappa-30201655/sources/4554-FFT-ERROR.md b/research/native-kappa-30201655/sources/4554-FFT-ERROR.md
new file mode 100644
index 0000000000..53691b10de
--- /dev/null
+++ b/research/native-kappa-30201655/sources/4554-FFT-ERROR.md
@@ -0,0 +1,159 @@
+# Independent numerical error bound for the native radix-two FFT
+
+Prepared by Dugongue with substantial OpenAI Codex assistance. Apache-2.0.
+This argument is independent of the transform's arithmetic implementation.
+It uses no TM computation or simulation.
+
+## Assumptions and norms
+
+Let N=2^h>=2 and let each input coefficient have complex modulus at most beta,
+beta>=1. The exact forward and inverse butterflies are unnormalized, with
+true twiddles of modulus one. The inverse is divided by N once at the end.
+Let S=2^F. Suppose every supplied approximate twiddle differs from its true
+value by at most rho=16N/S in each real/imaginary coordinate. Suppose each
+complex multiplication's local fixed-grid rounding contributes at most 2/S
+in each coordinate. Addition/subtraction at the common grid is exact, and
+all actual word operations satisfy their no-overflow bounds.
+
+Use complex modulus for this proof, and the maximum such modulus over an array.
+The twiddle error is then at most delta=32N/S; every local multiplication or
+final normalization rounding can be bounded by eta=4/S. Assume delta<=1 and
+eta<=1; the final parameters below easily imply both. Conjugation of twiddles
+for the inverse preserves these error bounds.
+
+## One forward transform
+
+If A_j bounds the approximate data modulus after j stages, then
+
+    A_(j+1) <= (2+delta) A_j + eta <= 4 A_j + eta.
+
+Since A_0<=beta, induction gives
+
+    A_j <= 4^j(beta+eta/3) <= 2*4^j beta,
+    A_h <= 2N^2 beta.
+
+Let E_j be the error from the exact partial FFT. Subtract exact and approximate
+butterflies, assigning the twiddle discrepancy to the approximate second input:
+
+    E_(j+1) <= 2 E_j + delta A_j + eta,    E_0=0.
+
+The elementary sum
+
+    sum_(j=0)^(h-1) 2^(h-1-j) 4^j = N(N-1)/2
+
+therefore gives
+
+    E_h <= delta beta N(N-1) + eta(N-1)
+        <= 36N^3 beta/S.                                      (1)
+
+The exact forward data modulus is at most N beta. The same bounds hold for the
+other operand's independent forward transform.
+
+## Pointwise product
+
+Let A,B be the exact forward arrays and Ahat,Bhat the computed arrays. A rounded
+pointwise product has error
+
+    |round(Ahat*Bhat)-A*B|
+      <= |Ahat-A| |Bhat| + |A| |Bhat-B| + eta
+      <= (36N^3 beta/S)(2N^2 beta + N beta) + eta
+      <= 112N^5 beta^2/S.                                    (2)
+
+The computed product modulus is at most
+
+    (2N^2 beta)^2 + eta <= 5N^4 beta^2.                        (3)
+
+No independence, random error cancellation or favorable data signs are used.
+
+## Inverse transform and normalization
+
+Applying the same amplitude recurrence to the approximate product input gives
+an inverse-stage amplitude bound
+
+    A'_j <= 6*4^j N^4 beta^2.
+
+The inverse error recurrence now starts with (2), rather than zero. Thus
+
+    E'_h <= N*(112N^5 beta^2/S)
+            + delta*6N^4 beta^2*N(N-1)/2 + eta(N-1)
+          <= 212N^7 beta^2/S.
+
+Division by the exact integer N scales this preexisting error by 1/N. Its own
+fixed-grid coordinate rounding contributes at most eta in complex modulus.
+Consequently every normalized output coefficient has error at most
+
+    216N^6 beta^2/S.                                         (4)
+
+In particular, the more conservative requested envelope is valid:
+
+    error <= 2^28 N^8 (F+1)^2 beta^4/S.                       (5)
+
+Indeed N>=1, beta>=1 and F+1>=1, while 216<2^28. The factors (F+1)^2 are not
+needed for this independent estimate; retaining them safely accommodates the
+stated caller ledger. They must not stand in for an unproved twiddle or local
+rounding premise.
+
+## Parameters imply strict recovery error below 1/4
+
+Let n>=1,
+
+    ell = bitlength(n+2),
+    b = max(1,floor(ell/8)),
+    beta = 2^b,
+    N = least power of two >= 2ceil(n/b),
+    F = 24ell+64,  S=2^F.
+
+Then ell>=2, b<=ell, and
+
+    N < 4ceil(n/b) <= 4n < 2^(ell+2),
+    beta^4 <= 2^(4ell).
+
+The first inequality is the ordinary bound on rounding a positive integer up
+to a power of two. Also
+
+    F+1=24ell+65 <= 2^(ell+7).
+
+For ell=2 the inequality is immediate; increasing ell by one adds only 24 to
+the left while doubling the right, and the previous left side is already at
+least 24. Substitute these bounds in (5):
+
+    2^28 N^8(F+1)^2 beta^4/S
+      < 2^[28+8(ell+2)+2(ell+7)+4ell-(24ell+64)]
+      = 2^(-10ell-6)
+      <= 2^-26 < 1/4.
+
+The same parameter inequalities imply delta=32N/S<1 and eta=4/S<1, discharging
+the earlier stability conditions. The empty-input case n=0 should be returned
+as zero directly, rather than introducing an unnecessary FFT convention.
+
+For zero-padded nonnegative digit arrays, N>=2ceil(n/b) prevents cyclic wrap
+in the linear convolution. The exact normalized inverse coefficients are real
+integers. Equation (5) therefore places each computed real coordinate strictly
+within 1/4 of the right integer, and nearest-integer recovery is exact. The
+linear carry theorem in ROOTS-RECOVERY.md then produces the exact product.
+
+## Word-size sanity bound
+
+The approximate inverse data modulus before normalization is at most
+6N^6 beta^2. On the F-bit grid its signed integer coordinates have magnitude
+at most 6S N^6 beta^2. Twiddle coordinates have magnitude at most 2S. A raw
+real multiplication used in a complex multiply is consequently bounded by
+12S^2 N^6 beta^2, and a constant additional factor covers combining two such
+products. Thus a sufficient magnitude width is
+
+    2F + 6ceil(log2 N) + 2b + 8,
+
+plus caller addresses and a sign representation. This is O(log n) for the
+chosen F. The independently generated root seed uses an even larger fixed
+constant times F for its internal precision; one common global word width
+must cover both stages. Allowing each subroutine an unaccounted private wider
+word would not establish a single Word RAM implementation.
+
+## Scope
+
+This establishes numerical sufficiency for an actually implemented iterative
+FFT whose twiddles, local rounding and word bounds meet the hypotheses. It does
+not verify an arbitrary FFT routine by observing good samples, or prove that
+an unrelated power-saving transform inherits these polynomial prefix norms.
+The native implementation and its exact operation ledger remain separately
+reviewable. No improved TM exponent or formal Lean proof is claimed.
diff --git a/research/native-kappa-30201655/sources/4554-NATIVE-STABILITY.md b/research/native-kappa-30201655/sources/4554-NATIVE-STABILITY.md
new file mode 100644
index 0000000000..86f984363c
--- /dev/null
+++ b/research/native-kappa-30201655/sources/4554-NATIVE-STABILITY.md
@@ -0,0 +1,118 @@
+# Direct bounded-word lowering of the closed rational Gaussian kernel
+
+This is a native arithmetic construction. It neither calls a Turing machine nor imports a TM simulation or multiplication routine. Its purpose is to turn an existing exact-scalar Gaussian/Walsh provider into a bounded-word algorithm with an explicit accuracy guarantee.
+
+## A literal sufficient class
+
+Consider a fixed finite provider template with:
+- arbitrary independent live arrays and explicitly cleared owned scratch;
+- fixed rational complex scalar ADD/SCALE operations, COPY, CLEAR, and exact monomial coordinate/quarter-phase operations;
+- recursive children that are exact unitary Gaussian kernels, possibly on disjoint fibers and conjugated by monomial operators;
+- a complete exact endpoint equal to the desired unitary kernel on every live input, with owned scratch erased.
+
+Read every coefficient from the literal finite template. Replace each rational scalar operation by its signed integer numerator/denominator calculation followed by rounding to a fixed binary grid. Multiplication/division here is on a fixed number of O(log n)-bit words, not on the full input. Nonzero fixed denominators are explicit integers. Metadata, address calculations and phase choices are integer computations.
+
+This class includes the rational Gaussian kernel in PR #956, whose nonchild coefficients are fixed with denominators supported on 2 and 3 and whose monomial phases are fourth roots of unity. It does not automatically include that PR's separate all-length cyclic Fourier compiler, which prepares additional input-length-dependent scalars through Newton/Toeplitz constructions.
+
+## Prefix norms are derived, not assumed
+
+For one scalar gate x<-x+a*y, the Euclidean operator norm is at most 1+|a|. For x<-a*x it is at most max(1,|a|), including the untouched coordinates. COPY has norm at most sqrt(2), CLEAR has norm 1, and coordinate/quarter-phase monomials have norm 1. These statements hold on all arbitrary inputs, not only on a chosen test vector.
+
+Replace |a| by the explicit rational upper bound |Re(a)|+|Im(a)|. Multiply these elementary bounds over the finite template; enlarge the result to an integer K>=2. This is an effective finite calculation from actual coefficient bytes. It bounds every prefix and suffix of that template when recursive children are treated as their exact unitary operators.
+
+A coefficientwise pass acts as a direct sum of the same fixed bank operation, so its norm bound does not grow with array length. Disjoint completed fiber calls form a direct sum of unitary maps. Completed owned-scratch macros have the extended map U_live direct-sum 0_owned after their initial clearing, hence norm at most 1. A primitive prefix inside one such macro is covered by the same fixed template bound.
+
+Classical base butterflies are grouped into completed unitary two-point kernels. Thus an arbitrarily long sequence of completed classical rounds does not multiply their prefix bounds: a partial primitive prefix lies inside only one current butterfly, while all completed rounds are unitary.
+
+Let D(e) be the maximum recursive call depth at rank e. An expanded prefix or suffix is inside at most one unfinished child at each depth. All its other completed children are unitary. Induction therefore gives the actual bound
+$$
+\|\text{expanded prefix}\|_2,\;\|\text{expanded suffix}\|_2
+\le K^{D(e)+1}.
+$$
+The exponent is depth, not total work. It does not hide an unproved stability oracle.
+
+## Explicit roundoff theorem
+
+Suppose the exact scalar count is at most
+$$
+M(e)\le A\,2^e(e+1)^\theta
+$$
+for fixed A>=1 and 0<theta<=1, and the input entries have absolute value at most 2^b. Use enough integral bits to cover the bound below. At each scalar update, compute the exact rational value from the stored approximants and round its two components toward zero at P fractional bits. Its local complex error is at most sqrt(2)*2^-P.
+
+By linearity, the total output error is the sum of these local errors transported through the exact remaining suffixes. Hence
+$$
+\|\widehat y-y\|_\infty
+\le \|\widehat y-y\|_2
+\le \sqrt2\,A\,2^e(e+1)^\theta K^{D(e)+1}\,2^{-P}.
+$$
+For requested error 2^-B it suffices to choose
+$$
+P=B+e+\lceil\log_2 A\rceil+
+  \lceil\theta\log_2(e+1)\rceil+
+  (D(e)+1)\lceil\log_2 K\rceil+3.
+$$
+
+Exact prefixes have magnitude at most K^(D+1)*sqrt(Z*2^e)*2^b, where fixed Z counts the simultaneously live array banks in the template. The same sum-of-local-errors argument bounds the approximate prefixes by this quantity plus the displayed error envelope. Thus an explicit integral width is
+$$
+I=b+\lceil e/2\rceil+
+ (D(e)+1)\lceil\log_2K\rceil+
+ \lceil\log_2(Z+1)\rceil+3.
+$$
+Increase it by a constant if output accuracy B is allowed to be negative; the intended use has B>=0. Every stored signed fixed-point numerator uses at most I+P+O(1) bits. Fixed rational numerators/denominators add only a template-dependent constant. Choose the physical word-width coefficient large enough for the exact intermediate numerator products, sums and divisions, or use a fixed number of limbs. This yields O(1) word instructions per scalar update.
+
+When e,b,B=O(log n), D(e)=O(log(e+2)), and A,K,Z are fixed before n, I+P=O(log n). Thus the finite-word program has the same asymptotic arithmetic operation count as the exact-scalar provider, with a computable constant and no TM or bit-cost-machine call. The cutoff can be enlarged until fixed template constants fit; below it the program uses direct unitary butterflies.
+
+## Instantiation of the actual closed provider
+
+PR #956 is pinned at fa4df77c9dfdbac93368d95dcb361e69b3b65464. Its optimized source uses m=73, largest child rank 48, productive stock W=58,899, and a complete exact profile. Its own all-input recurrence is
+$$
+t(e)\le\sum_r(H_r/W)t(rf(e))
++A\,[a+m+2\lceil\log_2(e+2)\rceil+1],
+$$
+where t(e)=T(e)/2^e, f(e)<=e/73 and the explicit integer-root certificate funds theta=1023/1024.
+
+The actual contraction gives
+$$
+D(e)\le 1+
+\left\lceil \frac{\log(e+1)}{\log(73/48)}\right\rceil.
+$$
+All source bank/owner constants are fixed before e. The elementary template bill supplies a finite upper bound for the number and coefficient sizes of its nonchild passes, from which K above is computable. In particular this does not replace a varying exact scalar of unknown condition by a word operation.
+
+Therefore this pinned rational native Gaussian/Walsh provider admits a bounded-word approximation program of work
+$$
+O\bigl(2^e(e+1)^{1023/1024}\bigr)
+$$
+and arbitrary requested error 2^-B with the explicit precision formula above. For the unnormalized Walsh conversion H_e=(1-i)^e D_e C_e D_e, first request kernel error 2^{-(B+ceil(e/2)+1)} and add ceil(e/2)+1 integral bits for the final scaling. Since |(1-i)^e|=2^{e/2}, the final error is at most 2^-B. These additions remain O(e). Quarter-phase D_e is exact. The power (1-i)^e is an exactly representable Gaussian integer and can be prepared by O(e) bounded-word updates, absorbed by the displayed work bound. No integer-multiplication theorem follows merely from this kernel statement.
+
+The same argument applies to a different *actually constructed* fixed rational provider and its proved recurrence; it does not assert a better profile or select unknown scalar coefficients. In particular, a critical-root compiler word must first have an actual admitted algebraic finite-word construction. Removing tape tariffs alone is not that construction.
+
+## Boundary for cyclic transforms and multiplication
+
+A separate cyclic transform requires explicit algorithms for roots, scalar preparation, conditioning, numerical errors, and convolution/recovery. Nonzero prepared denominators alone do not imply polynomially bounded inverse magnitudes. The exact-scalar PR #956 cyclic section does not supply the quantitative bounds needed here merely by proving nonzeroness.
+
+Root/phase tables and ordinary bounded-word FFT base multiplication can instead be constructed directly, but their complete caller and accuracy costs must be provided. No base multiplication TM is permitted in such an assembly. The nine/54-row TM outer ledger cannot simply have all costs divided by word width: each retained operation must be rebuilt as array/word arithmetic and re-invoiced.
+
+This is a positive finite-word native kernel theorem and a concrete assembly interface. It does not establish a new integer-multiplication exponent or worldwide priority for standard roundoff analysis.
+
+
+## A quantitative bound for the actual shear preparation
+
+One denominator family in the actual cyclic compiler is already quantitatively safe. Write mu=a+ib with a,b real, and put t1=1+mu*conjugate(mu), t2=mu-t1. Then
+$$
+t_1=1+a^2+b^2\ge1,\qquad
+\operatorname{Re}(t_2)=-[(a-1/2)^2+b^2+3/4]\le-3/4.
+$$
+Consequently |1/t1|<=1 and |1/t2|<=4/3, uniformly in mu. This is stronger than nonzeroness and is a direct sufficient stability bound for these two divisions. If mu is approximated within delta<=1 and |mu|<=U, then the induced t1 perturbation is at most (2U+1)delta; t2 adds another delta. Provided the t2 perturbation is at most 3/8, its reciprocal perturbation is at most (32/9) times that perturbation, by the identity 1/z-1/z'=(z'-z)/(zz'). Thus this shear preparation is polynomially conditioned whenever U is polynomially bounded. The Newton c-inverses and complete cyclic circuit still require their own quantitative analysis. Credit: ram_cost identified the completion-of-squares argument during this session.
+
+## Polyloglog overhead still retains a strict saving
+
+For completeness, a direct finite-word compiler need not retain a constant number of words to preserve an exponent saving. Suppose an actually constructed native transform on N data words has exact arithmetic work O(N (log N)^{1-kappa}) with fixed kappa>0, and an explicit numerical analysis and implementation bound every scalar update, preparation and packing overhead together by (loglog(N+4))^C for a fixed C. Then the finite-word cost is
+$$
+O\bigl(N(\log N)^{1-\kappa}(\log\log(N+4))^C\bigr)
+=O\bigl(N(\log N)^{1-\kappa'}\bigr)
+$$
+for every fixed 0<kappa'<kappa. Indeed, setting x=loglog(N+4), the ratio is at most a constant times x^C exp(-(kappa-kappa')x), which is bounded for x>=0. This is a positive absorption theorem; it does not assert that the unresolved Newton/Toeplitz preparation meets its explicit hypothesis. It is useful when a separately derived precision budget is O(log N (loglog N)^c): elementary schoolbook limb multiplication and long division on (loglog N)^c limbs have polynomially many limb operations, and therefore satisfy this overhead condition. No unbounded exact-scalar instruction or TM multiplication routine is invoked.
+
+## Credit and evidence
+
+The closed exact provider, arbitrary-input identity, ownership, recurrence, finite-profile certificate and explicit pass constants are predecessor results from #956 and its #390/Sussman/P193, native, frame/bank, bridge and normalization lineage. Prepared for Dugongue with substantial OpenAI Codex assistance. The roundoff proof above is informal; no new Lean or GPU process was run. Source inspection is not independent acceptance of the predecessor's complete theorem.
diff --git a/research/native-kappa-30201655/sources/4554-ROOTS-RECOVERY.md b/research/native-kappa-30201655/sources/4554-ROOTS-RECOVERY.md
new file mode 100644
index 0000000000..5791526c61
--- /dev/null
+++ b/research/native-kappa-30201655/sources/4554-ROOTS-RECOVERY.md
@@ -0,0 +1,223 @@
+# Native root seeds and exact product recovery
+
+Prepared by Dugongue with substantial OpenAI Codex assistance. Apache-2.0.
+Every algorithm here acts directly on bounded words, arrays and arithmetic.
+There is no Turing-machine primitive, simulator, conversion or multiplication
+black box on an entire variable-length input. Ordinary MUL/DIV on word-sized
+operands are allowed, with explicit sufficient width below.
+
+## 1. A generated primitive-root seed with certified precision
+
+For every integer D>=1 and requested p>=1, root_seed.py constructs Gaussian
+dyadic coordinates x/2^p,y/2^p satisfying
+
+    max(|x/2^p - cos(2pi/D)|, |y/2^p - sin(2pi/D)|) < 2^-p.
+
+Take P=8(p+16), S=2^P, K=128(p+1). It suffices that every word has at least
+2P+20 bits and that D and all array/control addresses fit in one word. Signed
+integers are a sign bit and an unsigned magnitude; signed arithmetic expands
+to bounded comparisons, ordinary ADD/SUB and word MUL/DIV. This is a uniform
+finite loop algorithm, not a stored transcendental constant or root oracle.
+For p=Theta(log N) and D<=N^C with fixed C, the sufficient word width remains
+Theta(log N). Constants are deliberately conservative.
+
+### Construct pi rather than assuming it
+
+Use Machin's identity pi=16 arctan(1/5)-4 arctan(1/239). Its identity can be
+verified without a numerical pi supplier: tan(2 arctan(1/5))=5/12 and
+ tan(4 arctan(1/5))=120/119. The tangent subtraction formula then gives
+ tan(4 arctan(1/5)-arctan(1/239))=1; the angle is in (0,pi/2), so it is pi/4.
+
+For q=5 and 239, sum the alternating terms
+
+    (-1)^j floor(S / ((2j+1) q^(2j+1)))
+
+while q^(2j+1)<=S. Generate successive powers by multiplication by the fixed
+integer q^2. There are at most P+1 terms. Each floored term differs from its
+exact scaled term by less than 1, and the alternating remainder after stopping
+is at most 1/S. Consequently the constructed integer A obeys
+
+    |A/S - pi| <= 20(P+2)/S.
+
+Every denominator is at most S(2P+3); the next q-power is at most 239^2 S.
+These are bounded O(P)-bit integers. Compute the integer angle t=floor(2A/D).
+Then 0<=t<=8S and
+
+    |t/S - 2pi/D| <= [40(P+2)+1]/S.
+
+No search for a prime or primitive root is involved.
+
+### Fixed-point complex Taylor evaluation
+
+Start the Taylor term and sum at (S,0). For k=1,...,K, replace the current
+term (a,b) by
+
+    (trunc(-b*t/(S*k)), trunc(a*t/(S*k))),
+
+and add it to the sum. Truncation is toward zero, implemented on sign/magnitude
+words. Let theta=t/S. Each coordinate's rounding error in term k satisfies
+E_k <= (8/k) E_(k-1)+1/S. Expanding this recurrence and using
+j!/k!<=1/(k-j)! yields E_k<exp(8)/S<4096/S. Thus the summed rounding error in
+each coordinate is at most 4096K/S.
+
+For completeness, exp(8)<4096 follows from the elementary estimate
+exp(1)<11/4 and (11/4)^8<4096. The first estimate follows by summing through
+1/3! and bounding the tail from 1/4! by (1/24)sum_j 5^-j.
+
+The omitted Taylor tail is at most 2*8^(K+1)/(K+1)!, since the subsequent ratio
+is below 1/2. The last K/2+1 factorial factors are each at least 128, so this
+is at most 2^(-K/2-3), which is <=32/S for all p>=1. The cosine and sine
+functions are 1-Lipschitz on the real line. Combining the angle, rounding and
+tail errors gives the explicit coordinate bound
+
+    E_internal <= [40(P+2)+1+4096K+32]/S.
+
+The displayed numerator times 2^(p+1) is strictly less than S. Finally round
+the two fixed-point sums to nearest at p fractional bits. This adds at most
+2^(-p-1), proving the stated strict 2^-p error.
+
+Term and partial-sum magnitudes are below 2^14 S: the exact absolute Taylor
+mass is below exp(8), and the accumulated rounding envelope is smaller than S.
+Products with t are below 2^(2P+17), denominators and all Machin intermediates
+are smaller still. Thus 2P+20 bits is a sufficient native arithmetic bound.
+The implementation charges a conservative
+
+    100(P+1)+40(K+1)
+
+word-operation envelope. Both P and K are O(p), so setup is O(p) word
+operations and O(1) live arithmetic words, besides caller storage. It is not
+necessary to form factorials or unbounded exact rational denominators.
+
+## 2. Rounding and CRT recover exact convolution coefficients
+
+Let two nonnegative base-beta digit arrays have lengths a,b, beta=2^h>=2.
+Every digit is below beta. Their ordinary linear convolution has length
+a+b-1 and coefficients
+
+    c_j = sum_(i+k=j) u_i v_k,
+    0 <= c_j <= C=min(a,b)(beta-1)^2.
+
+**Rounded numerical route.** If a computed dyadic real value Y_j/2^P satisfies
+|Y_j/2^P-c_j|<1/2 for every j, nearest-integer rounding recovers every c_j
+exactly. Range-checking 0<=c_j<=C is useful, but does not itself prove the
+error premise. The numerical transform must establish that premise from its
+actual precision and prefix-norm bounds; it cannot be inferred from good
+sample outputs. The recovery loop costs O(a+b) word operations. Its input
+integers fit when 2^P(C+1), plus fixed rounding slack, fits in a word.
+
+**Exact modular route.** For distinct certified primes p_1,...,p_s, let
+Q=product p_i. If Q>C, the canonical residue in [0,Q) is c_j itself. For
+signed coefficients |c_j|<=C, use Q>2C and the representative in (-Q/2,Q/2).
+
+The supplied CRT constructor checks each prime by literal trial division and
+constructs inverses of preceding products by modular repeated squaring with
+exponent p_i-2. Primality and inverse work is charged setup. Trial division
+costs O(sum sqrt(p_i)) word operations; modular inversion costs
+O(sum log p_i). This is a constructive positive algorithm, but these setup
+costs are not asserted to fit a fast FFT bound. A fast application must provide
+its own fully costed modulus construction or choose the numerical route above.
+
+For each coefficient maintain its reconstructed x in [0,M), initially x=0,
+M=1. The precomputed next modulus data give
+
+    t = ((r_i - (x mod p_i)) mod p_i) * inv(M mod p_i) mod p_i,
+    x <- x + M*t,   M <- M*p_i.
+
+Compute the subtraction as r_i+p_i-(x mod p_i), then reduce; it is nonnegative.
+Induction proves all processed congruences and 0<=x<M. At the end uniqueness
+proves exact recovery. The cost is O(s) native word operations per coefficient,
+with no per-coefficient root/inverse search. It suffices that Q, 2Q, every
+p_i^2 and all actual buffer indices, with constant arithmetic slack, fit in
+a word. If Q is polynomial in input length and s is fixed, this is a genuine
+logarithmic-word O(a+b) recovery stage. No such conclusion is made if Q grows
+beyond the declared word width.
+
+## 3. Linear native carry propagation and exact product
+
+Append c_(a+b-1)=0. Set carry=0. For j=0,...,a+b-1 perform
+
+    t = c_j + carry;
+    digit_j = t AND (beta-1);
+    carry = t >> h.
+
+If carry<=min(a,b)(beta-1), then
+
+    t <= min(a,b) beta(beta-1),
+
+and the next carry obeys the same bound. Thus this quantity, together with
+buffer addresses, is a sufficient word bound. No large input-sized integer
+is ever multiplied by the algorithm.
+
+The induction invariant is
+
+    sum_(j<i) digit_j beta^j + beta^i carry_i
+      = sum_(j<i) c_j beta^j.
+
+At completion the right side is the exact product of the two original digit
+arrays. That product is below beta^(a+b), so after a+b emitted digits the carry
+is zero. The output digits therefore represent the exact integer product.
+Each iteration takes a constant number of native operations, for O(a+b) time
+and O(1) arithmetic scratch. Separate source/result arrays give an immediate
+frame/preservation property; ordinary streaming array stores are sufficient.
+
+If the original inputs had exactly n bits and their limb arrays are padded to
+ceil(n/h) words, the output may contain high zero limbs. The bound product<2^(2n)
+justifies removing them and masking any partial top output limb in O(a+b)
+time; adding zeros to an MSB-first representation would be a different action.
+
+## 4. Direct native multiplication assembly
+
+Take h=Theta(log n), so each input has L=Theta(n/log n) digits. A directly
+implemented approximate DFT/NTT convolution on N=Theta(L) entries, with its
+own paid roots, normalization, bounded-word arithmetic and error<1/2, combines
+with the recovery above in O(L) additional word operations. The numerical
+root seed costs O(log n) when its requested precision is Theta(log n).
+
+Thus a direct O(N log N) word-operation convolution gives a direct O(n)
+Word RAM integer multiplication algorithm. If a fully implemented stronger
+native convolution has cost O(N log^(1-kappa) N), then the same explicit
+assembly gives O(n/log^kappa n) word operations. The latter sentence is a
+sufficient composition theorem, not an assertion that this packet supplies
+that stronger convolution. It does not use a TM black box anywhere.
+
+## 5. Evidence, library reuse and next questions
+
+`root_seed.py` checks 80 seeds, p=1,...,128 and orders through 2^40+87, against
+a separate high-precision Decimal implementation. Its transcendental reference
+is validation-only and is not called by the native constructor. An undersized
+word rejects; the exact order-four result is checked.
+
+`recover.py` checks 960 products, 10,752 CRT coefficients and 10,752 rounded
+coefficients, including extremal digit arrays, unequal lengths, signed CRT,
+composite/duplicate moduli, an invalid carry input and an actual half-unit
+rounding corruption. These are finite tests, not universal proof certificates.
+
+The existing Problem 1.8 sources provide directly relevant precedents:
+`MpLimbs20261007.lv_dig`, `dig_add_high`, `addCode` and `add_run` establish
+literal limb representation and carries in bounded IMP; `Frame` describes
+preserved arrays and IO. `Problem18IMPPrimeInverse20261001.inverseRoutine_run`
+constructs literal modular inversion from a prime/nonzero residue and charges
+84*size(p)+34 bounded instructions. Their source was inspected, not freshly
+kernel-audited here. This packet uses these as precedents, not as claims that
+the newly supplied Python/Word RAM algorithms have been formalized.
+
+The federated DAG search for Machin also found the existing source-only
+`FamousTheorems.machin_formula` public-catalog record and a Gerver-sofa
+certificate declaration; neither hit was re-elaborated or imported. Actual
+inspected project precedents include Dugongue's PR #3877,
+`research/gaussian-expansion-headroom/PROOF.md`, whose interval backend is
+credited to Mason Hale and whose retained lineage includes Jose Manuel's
+physical chirp/Gaussian work. It already uses Machin arctangent remainders and
+outward Taylor enclosures. The registered OpenAI preprint
+*The maximum number of mutually unbiased bases in dimension six*
+(2026-09-24), `build/sections/rounding.tex`, already writes the tangent proof
+and explicit alternating arctangent tail. These are method precedents, not
+freshly checked proofs or new claims of invention. Our new component is the
+explicit bounded-word seed algorithm, global precision envelope and its
+integration contract. The sources and exact inspected hashes are recorded.
+
+Concrete next tasks are to bind the recovery threshold to the actual native
+transform's row-norm/error proof, emit the signed fixed-point/root routines in
+the actual RamStd/IMP language, and audit their chosen word/arena width. A fast
+prime-based variant additionally needs a fast fully paid prime/root supplier.
+None of those requirements is hidden inside the executable root constructor.
diff --git a/research/native-kappa-30201655/sources/PR4483-ARITHMETIC-PROOF.txt b/research/native-kappa-30201655/sources/PR4483-ARITHMETIC-PROOF.txt
new file mode 100644
index 0000000000..0ad965e87f
--- /dev/null
+++ b/research/native-kappa-30201655/sources/PR4483-ARITHMETIC-PROOF.txt
@@ -0,0 +1,19 @@
+Same conditional κ, smaller finite compiler bound
+
+The native word, 408 independent helper fields, whole rank-eight center jobs and complete p16 controller are exactly PR4470's source-bound construction. The declared conditional κ remains 0.00302015. This contribution makes no improved κ claim and no change to the selected result. The bound concerns the local supplier template. The smaller outer slack may raise the eventual threshold for the full multiplication algorithm; that threshold is not bounded here. Its input profile and controller are hash-guarded; run(local) additionally checks an actual native replay's helper and paid inventories against those exact frozen inputs.
+
+Keep tested saving C = 0.00302016, so t = 1 − C. The changed paid tensor construction uses v = 682, cutoff J = 17^v, productive floor L = 21^v and higher-moment offset u = 1/8. Recompute α = P_t/T_t, γ = P_(t+u)/(17^u T_t) and δ = 10928*21/(17^C T_t). Exact rational intervals prove α < 1 − 31/(5*10^9), γ < 98102/100000 and δ < 959/1000. Both original and completion tails are charged by the retained higher-moment theorem. Their resulting conservative upper bound is
+
+  1/(1 + v*31/(5*10^9)) + 2*(98102/100000)^v + 2*(959/1000)^v < 1.
+
+The same displayed bound is greater than 1 at v = 681. This is a test of these chosen conservative ratios, not a global optimality theorem for tensor completion. Scalar words, whole-job normalizers, owned erasure, all main adapters and fixed routes remain charged by the explicit source finite allowances.
+
+Choose logarithmic contraction θ = 94/101 and logarithm power p = 143. Exact integer tests verify 17^101 < 21^94 and 2^(101−94)*(17^682)^101 ≤ (145^682)^94. For η = (1 − C)*145^(−682*C), the interval engine proves η > θ^143 and η < θ^142, and also 145^(682*C) < 2^143. These are precisely the sufficient shifted-exit, complement-capacity and initial-range hypotheses of the retained general logarithmic majorant. The smaller power is justified by these inequalities, not by changing the inductive theorem.
+
+Separate compiler slack from outer-transfer slack. Put g = 1/100000001 and d = (C − κ − g)/6 = 1/60000000600000000. Then d > 0 and the uniform saving is C − g = κ + 6d. Take b = κ + 5d, a = κ + 4d, q = κ + 3d, ε = 1 − d, β = 1 − 3d, r0 = d/10, stop = layout = d, retaining ordinary BIT admission 0.0034. All 54 strict and 4 functional predicates pass exactly, including every one of the nine outer cost rows. Four source mutation controls reject. A separate legacy check with decimal grid 10^20 passes all 63 predicates and agrees on all nine rows; the old 10^10 grid cannot resolve these smaller strict margins and is not silently reused.
+
+The integer majorant test (100000001*j + 1)^143 < 2^j passes at j = 5581 and fails at j = 5580. Thus the retained compiler theorem supplies sufficient uniform rank N = 2^558100005581. PR4470 gives 2^64215200000000, so the exponent decreases by approximately 115.06 times. This compares finite template bounds, not observed runtime, and the enormous word is algorithmically specified rather than materialized. The full integer-multiplication theorem still retains all inherited native, analytic, precision, fixed-tape, stock, prime, ownership and exact-recovery premises.
+
+Predecessor credit: PR4470's actual new native word and p16 controller; PR4447 and PR4440/4441's geometry, retiming and thinning; zxv's higher-moment and logarithmic-majorant work; Jacob Alan Sussman's mixed-target compiler; Chafik Boukhalfa, Tim Trudgian, Jeremy Kothe, Vlado Vojdanovski and the retained legacy outer-ledger contributors. New compiler choices prepared with substantial OpenAI Codex assistance. Apache-2.0 for new code; original notices retained.
+
+Open next question: replace this sufficient power majorant by a source-bound sharper recurrence while preserving both paid tails and the complete current outer ledger. A smaller template bound alone does not improve κ. The displayed N bounds the local uniform supplier template. The tiny outer d can increase the eventual input threshold of the full integer-multiplication theorem; no numerical bound on that overall threshold, nor any reduction of it, is claimed.
diff --git a/research/native-kappa-30201655/sources/PR4483-DIRECT-MIXED-FLOW.md b/research/native-kappa-30201655/sources/PR4483-DIRECT-MIXED-FLOW.md
new file mode 100644
index 0000000000..3be00f754b
--- /dev/null
+++ b/research/native-kappa-30201655/sources/PR4483-DIRECT-MIXED-FLOW.md
@@ -0,0 +1,496 @@
+# Direct mixed flow and explicit compiler size: a partial research checkpoint
+
+**Publication authorized by the user on October 21, 2026.** This is a partial
+compiler/resource checkpoint; the direct exponent gate remains open.
+
+The target is a structural successor to
+[PR4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433): remove the
+tensor/padding step needed by overlapping ranks and control the complete
+finite compiler's size. The user requested a significance target twice the
+previous contribution. That is an ambitious scope target, not a numerical
+measurement or a claim that it has been achieved.
+
+Two results are established under the source native-word hypotheses:
+
+1. A **finite chronological integer flow** works when paid ranks overlap
+   target ranks, provided `max paid < ambient`. It retains and pays every
+   unmatched job as an exit. All recursive ranks decrease. This gives a
+   finite uniform compiler, **without a proved near-root saving**.
+2. Choosing **nested divisible widths** gives `B_N <= exp(O(N log N))`.
+   Exact rank-one accounting also bounds raw instances, owned centers,
+   routing slots and the source finite-constant envelopes. This batching
+   choice preserves the normalized leaf cost and therefore applies to the
+   already supported PR4433 supplier.
+
+The main exponent target remains open. Exact compilation at rank 1,000 on
+the raw p7 profile fails the desired saving. That finite failure is not an
+asymptotic obstruction, and it does not invalidate PR4433's separated recipe.
+No new κ, selected frontier, native admission or physical runtime is claimed.
+
+## 1. Source boundary and decision
+
+The starting point is Jacob Alan Sussman's multinomial lockstep construction,
+retained by PR4359. Its separated proof requires `r_max < k_min` so every
+parent output is consumed. PR4416 and PR4433 instead repair the raw p7
+overlap by chronological products, paid completion and splitting.
+
+Retain the four native hypotheses of
+[FINITE-PRECOMPILATION.md](vendor/FINITE-PRECOMPILATION.md): a correct
+all-column arbitrary-input word, disjoint splitting with complete spectators,
+permitted and priced whole-job adapters, and finite-program closure with
+owned initialization/erasure. Equal rank alone does not supply an adapter.
+Changed finite combinatorics do not independently admit those hypotheses.
+
+**Continue, with two separate gates.** The finite-flow gate is now proved and
+checked. The exponent gate requires a new uniform estimate on the complete
+complement-plus-exit recurrence. Do not expand a search solely because a
+moment root is favorable. The size theorem is useful independently, since
+the predecessor leaves productive width and owned-instance counts implicit.
+
+| Obligation | Evidence / remaining work |
+| --- | --- |
+| Integer matching with overlapping ranks | Proved below; literal and merged replays agree |
+| Chronological return and strictly smaller exits | Proved under `r_max < m`; no cross-round matching |
+| Source complements and full uniform output | Source integer-batch induction, with nested divisible widths |
+| Direct near-root saving | **Open**; rank 1,000 fails; no global conclusion |
+| Productive width, rank-one leaves, raw instances, owned centers | Explicit bounds below, with exact finite controls |
+| Routing slots, encoded records and source finite-constant envelopes | Counted below in the stated grammar; physical implementations retain their own tariffs |
+| Native all-column, physical, analytic, precision and recovery premises | Inherited; no full replay or new admission |
+
+## 2. Partially matched integer lockstep flow
+
+Let positive integer target multiplicities be W_k, chronological paid rounds
+have ranks r_j, and let
+
+```
+2 <= k_min <= m=max(k),   1 <= r_max < m.
+```
+
+The paid word may have `r_max >= k_min`. At a fixed integer top rank n>=m,
+put
+
+```
+c(a) = product_k k^a_k,
+u(a) = multinomial(|a|;a) product_k W_k^a_k,
+R(rho) = {a : m*rho*c(a) <= n},
+G = floor(log_(k_min)(floor(n/m))).
+```
+
+For every paid-round path s of length d<=G with multiplier rho_s, instantiate
+u(a) units at column rho_s*c(a), for every point a in R(rho_s) of degree
+G−d. This is the source class construction. For a parent class with
+multiplier rho, its rank-r round supplies u(b) jobs at point b when b is
+present. The child demand at that point is
+
+```
+D(b) = sum over eligible (b−e_k) of W_k*u(b−e_k).
+```
+
+The complete Pascal sum is u(b). Therefore:
+
+- If the parent point b exists, `0 <= D(b) <= u(b)`. Route D(b) of the
+  **whole** issued jobs to the child. Complete the remaining u(b)−D(b)
+  jobs as paid exits, at their actual rank `e=r*rho*c(b)`.
+- If the parent point is absent, supply the child demand with new distinct
+  top input arrays. These are source jobs, not copies of issued data.
+- At depth G, every point has degree zero; all paid jobs are exits.
+
+No fractional jobs, cloned productive inputs or uncharged discarded requests
+are introduced. Within each point, choose a fixed enumeration of parent
+jobs and target slots and match their first D(b) elements. The rest have
+explicit endpoints and remain on their actual owners.
+
+### Sources and exits
+
+At the root, every demanded point has degree G+1, so it is outside R(1).
+Its rank s is in `(n/m,n]`. A non-root source has no parent point, hence
+`m*rho_parent*c(b)>n`; its rank is `r*rho_parent*c(b)>r*n/m>=n/m`.
+Its eligible child target ensures s<=n. Thus every source is a positive
+job in `(n/m,n]`.
+
+Every exit belongs to an actual parent unit, so
+
+```
+e <= r_max*n/m < n.
+```
+
+This holds for the new premature exits as well as leaf exits. A premature
+exit has at least one omitted Pascal term, with
+`m*r*rho*c(b)/k > n`; consequently `e > k_min*n/m`. These are large exits
+near the upper boundary. They cannot be assigned the old bound
+`r_max*(n/m)^theta` with theta<1. That lost estimate is the exponent issue.
+
+### Chronology and arbitrary inputs
+
+Run all scalar steps of a class in their specified order. At paid position
+j, issue that position for every unit, partition its whole issued jobs into
+matched and unmatched slots, finish all unmatched exits and the entire child
+class, restore adapters, and only then resume position j+1. The child takes
+incoming jobs from this one parent round plus its new top sources. It never
+waits for a later round of a suspended parent. The finite class depth is G;
+all complement and exit calls have rank below n, so their uniform programs
+are already available by strong induction.
+
+Distinct slots in one class have distinct physical fields. Routing fewer
+parent slots than the original full-Pascal construction preserves this
+property. Arbitrary-input native correctness permits correlated values,
+including current owned-center contents; it does not permit field aliasing
+or extra productive credit. Each unit has its own owned identities and
+retains them until its word clears them. These requirements are unchanged.
+
+### Exact potential and count identities
+
+Let S_s and E_e be integer source and exit inventories, U the unit count,
+and Qcol the sum of the units' positive integer column multiplicities.
+Cancellation of matched jobs gives, exactly at rank one,
+
+```
+sum_s S_s*s − sum_e E_e*e = Delta * Qcol,
+Delta = sum_k W_k*k − sum_j r_j.
+```
+
+At any real exponent t, the corresponding identity is
+
+```
+sum_s S_s*s^t − sum_e E_e*e^t
+    = (T_t−P_t) * sum_units column^t.
+```
+
+Thus a favorable raw t-moment survives as a superpotential. It does **not**
+by itself pay the source complements. Writing W=sum W_k and P=number of
+paid rounds, complete untruncated layer counts give
+
+```
+U <= sum_(d=0..G) P^d W^(G−d) <= (W+P+1)^(G+1),
+S := sum_s S_s <= W*U,
+sum_e E_e <= P*U.
+```
+
+The source package's separated case is unchanged: no premature exits occur.
+The verifier compares it with the byte-identical predecessor literal replay.
+
+## 3. Nested divisible widths and complete count bounds
+
+Use the ordinary base B_n=1, P_n=n below m, with B_0=1 and P_0=0. For n>=m
+choose the replication factor and productive width
+
+```
+a_n = B_(n−1),    B_n = a_n*S_n.
+```
+
+Every earlier width B_e divides B_(n−1), by induction. Therefore every
+source-complement batch and exit batch is an integer number of smaller
+uniform programs. This is a concrete choice within the source compiler's
+existing denominator-clearing freedom; no optimum is claimed. Its previous
+option to use an LCM is retained as predecessor context.
+
+As in the source compiler, each of the a_n*S_n original arrays first gets
+its disjoint complementary job, then its one source job through the flow.
+All exits are completed by smaller uniform programs. The result is a full
+rank-n transform on every original array. Owned storage is excluded from B_n.
+
+The normalized leaf count satisfies the **same exact recurrence** for any
+valid replication choice:
+
+```
+L(n) = (1/S_n) * [sum_s S_s L(n−s) + sum_e E_e L(e)].
+```
+
+Changing the replication factors changes width and total counts equally.
+It does not spend supplier saving or alter any outer parameter.
+
+For a fixed final N and h=G(N), all n<=N satisfy
+
+```
+S_n <= C_N := W*(W+P+1)^(h+1),
+B_N = product_(n=m..N) S_n <= C_N^N.
+```
+
+Since h=O(log N), **log B_N=O(N log N)** for a fixed mixed rule. Repeatedly
+multiplying all previous widths is unnecessary. This bounds one explicit
+realization; the original compiler did not require that inefficient choice.
+
+If Delta>0, telescope rank-one mass over the fully expanded uniform program:
+
+```
+B_N*N − P_N = Delta * Qcol_N,
+U_N <= Qcol_N <= B_N*N/Delta.
+```
+
+All raw columns are positive integers, which gives the middle inequality.
+Thus paid leaves and raw instances have the same `exp(O(N log N))` bound.
+With one owned center per raw unit, the center count is at most U_N. A rule
+with O_local distinct owned banks per invocation instead gets O_local*U_N.
+Extra router scratch must be counted separately.
+
+### Routing and word description
+
+Count one routing slot for every source, every exit, every unit target slot
+and every unit paid position. At one flow its count is at most
+`2*(W+P)*U`. The same bound telescopes over all recursive calls, because
+each call contributes its own local unit instances. Exact compilation checks
+this identity alongside widths and leaves.
+
+In the macro grammar that records a whole-job adapter, inverse adapter or
+whole-field move as one record, a slot can be handled with at most sixteen
+records: up to two whole-job conjugations and their inverses, park/load/
+return/reorder moves, and explicit scratch initialization and erasure.
+Allocate separate owned scratch for those moves when needed; no zero-cost
+routing or free copying is assumed. Let A bound the fixed unit's complete
+nonrecursive record count, owned operations and scalar coefficient heights.
+The final weighted record allowance satisfies the conservative bound
+
+```
+R_bar <= A*U_N + 32*(W+P)*U_N + P_N
+      <= (A+32*(W+P)+1)*B_N*N,  for Delta>=1.
+```
+
+R_bar bounds both the macro count and the sum of scalar-height and native
+record allowances. Every owned bank has an explicit initialization record,
+so total allocated owned banks can also be bounded by R_bar; the sharper
+raw-center bound remains separate. This is a **description/record bound**,
+not a new tariff for executing a
+general matrix or permutation. A Gaussian monomial adapter's dense binary
+address matrix and quadratic phase have O(N^2) descriptor bits. Explicit role indices add O(log B_N)
+bits. Thus an encoding of this finite word still has
+`exp(O(N log N))` bits for a fixed unit and its finite coefficient alphabet.
+If physical expansion of one adapter needs F(N) native records, multiply
+the routing term by its actual F(N). That physical implementation, coefficient
+heights and tape costs remain separately priced native obligations. They
+are not set to zero by the macro bound.
+
+## 4. Applying the size result to PR4433
+
+The new nested widths may be used in the separated compiler of PR4433.
+Its normalized L(n), ambient N, uniform saving and outer ledger remain
+unchanged. Therefore this application does not need the still-open direct
+exponent lemma.
+
+With `v=150`, `H=349300000000`, `N=2^H`, the completed mixed rule has
+
+```
+W = 7688^150 < 2^1950,
+P <= 131115^150 + 7688^150*15^150 < 2^2701,
+W+P+1 < 2^2702.
+```
+
+The bound on P counts every original and completion call by its positive
+rank mass; splitting preserves that mass. Since k_min>=2, h<=H. Set
+
+```
+D = 1950 + 2702*(H+1) = 943808600004652.
+```
+
+There is consequently a realization of the same proposed conditional
+κ=0.00268647 supplier satisfying
+
+```
+B_N < 2^(D * 2^H),
+P_N < B_N * 2^H.
+```
+
+More finely, after expanding every product, padding, split and compiler call
+back to the raw p7 word, that word has surplus 608. Product/completion/split
+boundaries cancel, so
+
+```
+B_N*N − P_N = 608 * sum_raw_p7_instances column,
+U_raw <= (B_N*N − P_N)/608.
+```
+
+This is also an explicit bound on raw p7 center banks under the safe
+one-center-per-instance allocation. These are large upper bounds, not
+emitted words, smallest widths or practical precision estimates. They replace
+one implicit part of the source finite-constant prescription. The native
+adapter bodies, analytic transfer and physical costs retain their original
+conditions; a closed bound for the source's finite-constant prescription is
+given next, without a new physical runtime or exact-recovery threshold.
+
+### A closed envelope for the source finite constants
+
+The exported THREE-base native word has exactly 22,633 records in each
+orientation. Source-bound counting retains all 15 copies, the literal p7
+controller, scalar allowance 2,490,856, every productive/paid/contact/helper/
+idle slot, and all routing and owned operations. A raw macro allowance is
+
+```
+A_raw = 15*8*(decompressed native JSON bytes)
+      + 8*(literal controller JSON bytes)
+      + 32*(2490856 + all declared slots + 15*22633) < 2^40.
+```
+
+The payload-bit terms overcount the coefficient literals and full local
+descriptors, including both orientations. The 32-per-slot term overcounts
+whole-job normalizers and inverses, field movements, initialization and
+erasure. It is a bound on the declared source word in this grammar, not
+independent verification of its functional correctness or physical tariffs.
+
+For the chronological v-fold product, its number of raw p7 invocations is
+
+```
+U_v = sum_(i=0..v−1) 7688^(v−1−i)*55998^i < 2^2392.
+```
+
+At every product level retain the whole-job matching wrappers. A conservative
+product allowance is
+
+```
+A_product <= (2^40 + 32*v*(7688+55998+1))*U_v + 32*v*55998^v.
+```
+
+Add 32 records for every final paid call, completion role and original paid
+position. Counting paid calls by their rank mass gives
+
+```
+A_completed <= A_product
+    + 32*(131115^v + 7688^v*15^v + 7688^v + 55998^v).
+```
+
+A dense local binary map/quadratic phase and role index fit in
+`64*(121^v)^2` bits per such record. The verifier checks the integer bound
+`A_completed * 64*(121^v)^2 < 2^5000`. Thus **A=2^5000** is a valid weighted
+record/description allowance for this fixed completed unit. It includes all
+source coefficients and owned operations, with a large deliberate overcount.
+No instruction list of the completed product is emitted.
+
+Since `A+32*(W+P)+1 < 2^5001`, use the envelope
+
+```
+R_bar < 2^(D*2^H + H + 5001).
+```
+
+Apply the existing source finite-constant prescription to the **newly expanded
+word**. With Z=B_N+owned banks, G its scalar coefficient envelope, and P_N
+its rank-one leaves, we have `Z<=2*R_bar`, `G<=8*R_bar`, `P_N<=R_bar` and
+`N<=R_bar`. Therefore
+
+```
+E = 64*(Z+N+P_N+G+1)^3
+  < 2^(3*D*2^H + 3*H + 15021),
+B_constant = P_N+E,
+C0 = 32*N*B_constant^2
+   < 2^(6*D*2^H + 7*H + 30049)
+   < 2^(8*D*2^H).
+```
+
+The last comparison uses `2^H>=H+1` and an exact polynomial integer check
+on D and H. These are explicit, very loose upper bounds for the inherited
+semantic precision/stock constants, conditional on that source prescription
+and its admitted native record implementations. The exact numerical outer
+input threshold, prime exclusions and physical tape costs remain separate.
+
+## 5. Exact finite checks and the open exponent gate
+
+The verifier uses no floating-point acceptance tests. It checks:
+
+- Nine literal/merged flows at ranks 20, 40 and 80: a separated control,
+  strict overlap `{2:1,5:1} <- {1:2,4:1}`, and Sussman's open equality
+  example `{2:4,3:1} <- {1:6,2:2}`. Every whole input and exit agrees.
+- The separated control agrees with the unchanged Sussman literal replay.
+- Complete nested-width compilations through rank 100 on both overlap
+  examples, checking every recursive batch, routing count and rank identity.
+- Raw p7 through rank 1,000: **880 exact nonbase compilations**. B_1000 has
+  17,504 bits; the saved receipt binds all large computed integers by their
+  unsigned big-endian hashes, avoiding enormous decimal dumps.
+- Removing premature exits violates mass conservation. Removing batch
+  replication fails integer divisibility. Allowing a paid rank equal to
+  the ambient rank is rejected because strict rank descent is unavailable.
+
+For raw p7 at rank 1,000, exact arithmetic gives
+
+```
+L(1000) > 990 > 1000^(1−0.00268647).
+```
+
+The second comparison is elementary and exact: `ln(2)>2/3` from its first
+atanh term and `1000>2^9` give `ln(1000)>6`. Then
+`1000^κ > 1+6κ > 100/99`. No log approximation is used in this rejection.
+This checks one finite failure and keeps it distinct from the infinite-rank
+question.
+
+The missing lemma is a uniform bound on the **whole** recurrence. For some
+fixed p and sufficiently large n, one would need, for example,
+
+```
+sum_e E_e e^t (1+log2(e))^p
+ + sum_s S_s (n−s)^t (1+log2(n−s))^p
+ <= S_n n^t (1+log2(n))^p,
+```
+
+with zero-rank terms defined separately and a correctly funded base range.
+The premature exits have rank proportional to n. Their logarithmic factors
+cannot use the old fixed theta<1 power contraction. A raw moment advantage
+alone does not prove this inequality.
+
+Exploratory `approximate_leaves` in flow.py evaluates the recurrence in
+floating point and is deliberately excluded from verification. A bounded
+run through 20,000 ranks found saving about 0.000827 for the default height;
+varying the height did not approach 0.00268647 there. This is local search
+evidence, not a lower bound or a reason to enlarge the same scan. A better
+boundary estimate or a changed flow is the next research obligation.
+
+## 6. Reproduction and provenance
+
+Python 3.12, standard library only:
+
+```sh
+python3.12 -B research/direct-mixed-flow/verify.py
+python3.12 -B scripts/research_package.py --package research/direct-mixed-flow --check-only
+python3.12 -B scripts/research_package.py --package research/direct-mixed-flow
+```
+
+Use `verify.py --out /absolute/new/result.json` for a fresh receipt.
+[RESULT.json](RESULT.json) contains exact flows, integer compilation hashes,
+symbolic size bounds and negative controls. `flow.py` is the new algorithm;
+the verifier independently compares its merged and literal traversal outputs.
+Those are two internal implementations, not an independent mathematical review.
+
+Canonical base is `12fa8c5c844be21bfefb38a19503fbd867a11244`, priority revision
+7. SOURCES.json pins orientation metadata. VENDOR.json separately binds eleven
+unchanged exports by commit, full path, Git blob and SHA256. Their bytes and
+notices are preserved; direct replay needs no foreign Git objects. The source
+theorem and earlier finite compiler remain attributed hypotheses, not new work.
+
+Local validation used Python 3.12.8 on macOS arm64. The registered replay,
+metadata/pin check and committed-byte preflight passed. A separate Git-free
+copy passed with `python3.12 -I -O -B verify.py`; changed-native-source and
+changed-receipt controls both rejected. Replay uses exact integer arithmetic
+and source hashes, with no network or foreign Git objects. The repository is
+shallow, so a full source-history preflight was not attempted. No Lean, Docker,
+full native/all-column admission, physical adapter expansion or historical
+suite was run. Independent mathematical acceptance remains open.
+
+The overlap refresh at 18:48 UTC covered 538 open PR bodies and 3,280
+discussion/comment records, with complete reported pagination. Specific
+searches for direct overlapping-rank compilers, Pascal matching and nested
+widths found no matching public item in that scope; this is not a novelty
+certificate. Existing PR4433 supplies the fixed-rank application, and the
+source theorem explicitly leaves the unseparated exponent open. No Discussion
+claim or PR has been posted for this partial checkpoint.
+
+## Open next questions
+
+1. **Close or refute the direct exponent gate for this capped flow.** Start
+   with a proved bound on premature-exit potential relative to the actual
+   complement capacity. This decides whether the flow can replace the
+   tensor/padding layer. A larger rank scan is not a uniform proof.
+2. **Independently admit the physical expansions and precision prescription.**
+   Audit the conservative A allowance against the actual native caller and
+   bind every adapter's physical implementation, row movements and recovery
+   exclusions. The encoded constants above use the inherited semantics;
+   description size is not a physical execution tariff.
+3. **Tighten the constructive width.** The nested product is an explicit
+   upper bound, not an optimized LCM. A useful next step would control prime
+   valuations of the actual source counts; another arbitrary batching choice
+   would not by itself establish a smaller physical supplier.
+
+Prepared by zxv with substantial OpenAI Codex assistance in research, code
+and writing. No subagents or independent human mathematical review were
+used. New material is Apache-2.0. The integer lockstep/Pascal construction
+and original open unseparated question are Jacob Alan Sussman's work, retained
+at upstream `wht-power-saving-lean` commit
+`563b4e6e913625637f36ba7869bf5fcd0dd4975a`; its LICENSE and NOTICE are included.
+PR4359 supplies the native finite-precompilation bridge and p7 predecessor
+lineage. PR4416's p7 product/padding is @1337isnot1337's work. PR4433 supplies
+the unchanged sufficient rank. Their original contributor credit remains
+in the authenticated exports.
diff --git a/research/native-kappa-30201655/sources/PR4483-SOURCE-PROOF.md b/research/native-kappa-30201655/sources/PR4483-SOURCE-PROOF.md
new file mode 100644
index 0000000000..5eccdd5924
--- /dev/null
+++ b/research/native-kappa-30201655/sources/PR4483-SOURCE-PROOF.md
@@ -0,0 +1,31 @@
+# Sufficient compact compilation at the retained saving
+
+**Proposition.** Under precisely the conditional contracts retained by PR #4470, its unchanged source-bound p16 supplier has a sufficient uniform local rank N = 2^558100005581 at declared κ = 0.00302015. This replaces the previous sufficient local rank 2^64215200000000.
+
+**Proof.** Keep C = 0.00302016 and t = 1 − C. The literal controller yields the same target and paid histograms as PR #4470; independent event counting retains all 18 full native calls, 15 copied-query shears and 3,360 whole idle jobs. All 408 helpers remain independent arbitrary fields, including nonzero dirty entry values. Native and phase replay are independent required gates, rather than being inferred from an arithmetic receipt.
+
+For the same complete histograms T and P choose v = 682, c = 17, b = 21 and u = 1/8. Exact rational intervals give
+
+α = P_t/T_t < 1 − 31/(5·10^9),
+γ = P_(t+u)/(17^u T_t) < 98102/100000,
+δ = 10928·21/(17^C T_t) < 959/1000.
+
+The retained paid-completion and splitting theorem therefore bounds the normalized final paid moment by
+
+1/(1 + 682·31/(5·10^9)) + 2(98102/100000)^682 + 2(959/1000)^682 < 1.
+
+This includes both the original paid tail and the completion tail. No new padded target has unpaid axes. The same conservative bound rejects v = 681; this is a control for the displayed choices, not a global minimum theorem.
+
+Use θ = 94/101 and logarithm power 143 in the credited general majorant. The exact checks are 17^101 < 21^94, 128(17^682)^101 ≤ (145^682)^94, and, for η = (1 − C)145^(−682C), η > θ^143 and 145^(682C) < 2^143. These supply the same shifted-exit, complement-capacity and initial-range hypotheses as in the predecessor theorem. Power 142 fails the displayed η control.
+
+Allocate compiler gap g = 1/100000001 and outer slack d = (C − κ − g)/6 = 1/60000000600000000. The elementary identity C − g = κ + 6d with d > 0 leaves the strict chain
+
+κ < q = κ + 3d < a = κ + 4d < b = κ + 5d < C − g.
+
+The exact current ledger independently checks the remaining conditions; the chain alone is not substituted for those checks. In particular, all 54 strict predicates and four functional guards pass, as do all 63 legacy predicates and equality of all nine cost rows. Ordinary BIT saving 0.0034 is retained. The legacy decimal grid is refined to 10^20 to resolve the smaller positive margins.
+
+The integer majorant test (100000001j + 1)^143 < 2^j holds at j = 5581 and fails at j = 5580. The retained sufficient logarithmic compiler theorem consequently gives N = 2^(100000001·5581) = 2^558100005581 for the uniform local supplier. Every scalar and route remains within the retained finite bound; the enormous resulting word is specified algorithmically and not materialized. This proves the conditional proposition. ∎
+
+The smaller local rank is not a higher saving exponent. Nor does it prove an improved overall multiplication threshold: the smaller outer slack may worsen that separate threshold. All inherited physical, analytic, precision, tape, stock, prime and recovery premises remain.
+
+Credit PR #4470 for the native construction and controller, PR #4447 for the missing span, PR #4440/#4441 for query thinning and helper retiming, zxv for higher-moment and logarithmic-majorant work, Jacob Alan Sussman for the mixed-target compiler, and all source scalar/Clifford/BIT/outer-ledger contributors. The legacy ledger retains Chafik Boukhalfa, Tim Trudgian, Jeremy Kothe, Vlado Vojdanovski and its full source attribution. This contribution changes the sufficient completion and compiler parameters; it does not claim these general methods were invented here.
diff --git a/research/native-kappa-30201655/sources/PR4532-SOURCE-PROOF.md b/research/native-kappa-30201655/sources/PR4532-SOURCE-PROOF.md
new file mode 100644
index 0000000000..bdf142f26d
--- /dev/null
+++ b/research/native-kappa-30201655/sources/PR4532-SOURCE-PROOF.md
@@ -0,0 +1,585 @@
+# A sufficient profile criterion for adaptive compiler gates
+
+This note proves a sufficient existence criterion for the adaptive compiler
+of zxv's [PR #4483](https://github.com/CrocSwap/integer-mult-bounds/pull/4483),
+at source head `fb0c208864e6b24e3473318a058aa5b2dbd5764b`. Its new conclusion
+is that a moment crossing and strict pointwise mirror capacity imply the
+compiler's tail gates. The mirror condition itself supplies the strict
+tilted-mean gap and makes the crossing simple. The hypotheses also imply
+a fully funded majorant at the crossing exponent, with a logarithmic factor.
+The criterion is sufficient; necessity or admission of every favorable
+moment profile is not claimed.
+
+The arbitrary-height integer flow, its cancellation identities, and its
+shifted-logarithmic majorant are predecessor results, used conditionally
+here. Their native and physical implementation premises remain premises.
+This note supplies neither a new native profile nor a new multiplication
+exponent. The accompanying finite checks illustrate the hypotheses and
+reject a tempting weaker criterion; they do not prove the theorem below.
+
+## 1. Profiles and the exact boundary hypothesis
+
+Let nonempty finite histograms `W_k` and `P_r` have positive integer coefficients,
+with target ranks `2 <= k <= m`, where `m` is their maximum, and paid ranks
+`1 <= r < m`. Define, for every real `t`,
+
+```text
+T(t) = sum_k W_k k^t,              P(t) = sum_r P_r r^t,
+mu_T(t) = T'(t)/T(t),             mu_P(t) = P'(t)/P(t),
+q(t) = T(t)/P(t),                 eta(t) = t m^(t-1).
+```
+
+All these moment functions are smooth where used. A native paid position
+is still a separate chronological position when another position has the
+same rank. The histogram specifies its multiplicity; it does not authorize
+pooling unfinished calls or aliasing owners.
+
+Use the finite mirror cells from #4483, section 2. For a pair `(r,k)`, the
+exit window is `(1/r,1/k]` when `r>k`, and the inner-source window is
+`(1/k,1/r]` when `k>r`. Its coefficient is `P_r W_k (rk)^t`.
+Partition at all endpoints, with the indicated endpoint conventions, and
+let `E_J(t)` and `S_J(t)` be the respective coefficient sums on cell `J`.
+The partition is finite and does not depend on `t`.
+
+The **strict mirror hypothesis at t_*** means there is a number `beta_*`
+such that
+
+```text
+0 <= beta_* < eta(t_*),
+E_J(t_*) <= beta_* S_J(t_*)       for every cell J.        (1)
+```
+
+In particular, a cell with zero source coefficient must have zero exit
+coefficient. Every coefficient is a positive multiple of a positive
+exponential. Thus either a cell's sum is identically zero, or it is positive
+for every real exponent. Consequently (1) persists, with a slightly larger
+factor, on a sufficiently small interval of exponents. This is a pointwise
+mirror condition, not an assertion inferred from finitely sampled flows.
+
+### 1.1 Mirror slack supplies the mean gap and rank-one surplus
+
+Write `S_t(z)` and `E_t(z)` for these piecewise constant coefficient
+functions, extended by zero outside their finitely many windows. Their
+support lies in a compact interval bounded away from zero. For `k>r`,
+the integral of `dz/z` over its source window is `log(k/r)`; for `r>k`,
+subtracting the exit window gives that same signed value. Hence
+
+```text
+integral_0^infinity [S_t(z)-E_t(z)] dz/z
+ = sum_(r,k) P_r W_k (rk)^t log(k/r)
+ = P(t) T'(t)-T(t) P'(t)
+ = P(t) T(t) [mu_T(t)-mu_P(t)].
+```
+
+Whenever `E_t<=beta S_t` pointwise with `beta<1`, the left side is
+strictly positive: every paid rank is below `m`, so a pair with target
+rank `m` supplies a source window of positive length. Therefore strict
+mirror slack implies `mu_T(t)>mu_P(t)`. In particular (1), with
+`eta(t_*)<1`, supplies the mean gap at the crossing automatically.
+
+There is also positive rank-one surplus. For `0<t<1`, integrating instead
+against `z^(t-2) dz` gives
+
+```text
+integral_0^infinity [S_t(z)-E_t(z)] z^(t-2) dz
+ = [P(t) T(1)-T(t) P(1)]/(1-t).
+```
+
+The same positivity argument applies. At `T(t_*)=P(t_*)`, this implies
+`T(1)-P(1)>0`. Thus neither the tilted-mean gap nor positive rank-one
+surplus needs an additional hypothesis. These integral identities are
+exact finite sums; they do not estimate the distribution of a flow.
+
+## 2. Existence theorem
+
+**Theorem.** Suppose the native profile and the conditional finite compiler
+contracts of #4483 apply. Suppose that for some `t_*` in `(0,1)`,
+
+```text
+T(t_*) = P(t_*),                                         (2)
+```
+
+and the strict mirror hypothesis (1) holds. Put
+`delta_* := mu_T(t_*)-mu_P(t_*)`, which is positive by section 1.1.
+Then there exist positive integers `a,b`, an integer `M>1`, positive rational
+numbers `s,lambda`,
+and a number `epsilon>0`, with `t_*+epsilon<1`, for which all of #4483's
+two-tail and ratio-ordering gates hold uniformly on
+`[t_*, t_*+epsilon]`.
+
+More precisely, with `g=a+b`, there are constants
+
+```text
+0 < U,V < 1,       Q >= 1,       d > 0,
+0 <= beta_bar < eta_* := eta(t_*),
+```
+
+such that throughout that interval,
+
+```text
+u(t) := M^(-s) [T(t+s)/T(t)]^a [P(t+s)/P(t)]^b <= U,
+v(t) := M^lambda [T(t-lambda)/P(t)]^g <= V,
+T(t+s)/T(t) >= P(t+s)/P(t),
+d/dt log q(t) >= d,              q(t) <= Q,
+E_J(t) <= beta_bar S_J(t)        for every mirror cell J,
+eta(t) >= eta_* > beta_bar.                               (3)
+```
+
+There also exist `p,c,A>0` and an integer base cutoff `n0` such that the
+normalized rank-one leaf cost of the resulting finite compiler satisfies
+
+```text
+L(0)=0,
+L(n) <= A n^t_* (c+log n)^p       for every integer n>=1.  (4)
+```
+
+The compiler uses elementary evaluation through `n0` and height
+`G=g floor(log_M(floor(n/m)))` above `n0`. In particular, for every
+`z>t_*`, it has `L(N)<=N^z` at all sufficiently large integer ranks `N`.
+This is a statement about normalized leaf counts under the inherited
+contracts; productive width and physical constants are not estimated here.
+The theorem is existential given its hypotheses. An executable application
+must certify the chosen root, or isolate its simple crossing and bound the
+needed expressions on a certified interval, before it can extract numerical
+constants. No algorithm for an unspecified real parameter is claimed.
+
+### 2.1 Integer height parameters exist
+
+Write `mu_P*=mu_P(t_*)` and `mu_T*=mu_T(t_*)`. Choose an integer `g>=2`
+large enough that
+
+```text
+(g-1) delta_* / log 2 > 1.
+```
+
+The open interval
+
+```text
+((g mu_P* + delta_*)/log 2,  g mu_T*/log 2)
+```
+
+has length greater than one, so it contains an integer `j`. Its lower
+endpoint is positive because `mu_P*>=0` and `delta_*>0`; hence `j>=1`.
+Set
+
+```text
+a=1,       b=g-1,       M=2^j,       h=(log M)/g.
+```
+
+Then both required geometric inequalities are strict:
+
+```text
+(a mu_T* + b mu_P*)/g < h < mu_T*.                       (5)
+```
+
+This proves existence within integer height parameters. No continuously
+chosen height is substituted for an integer compiler.
+
+### 2.2 The two tails and ratio ordering
+
+At the crossing exponent define
+
+```text
+phi(s) = -s log M
+         +a log[T(t_*+s)/T(t_*)]
+         +b log[P(t_*+s)/P(t_*)].
+```
+
+We have `phi(0)=0` and, by (5),
+
+```text
+phi'(0) = -log M+a mu_T*+b mu_P* < 0.
+```
+
+Also define
+
+```text
+chi(s) = log[T(t_*+s)/T(t_*)]-log[P(t_*+s)/P(t_*)].
+```
+
+Here `chi(0)=0` and `chi'(0)=delta_*>0`. Therefore every sufficiently
+small positive `s` satisfies `phi(s)<0` and `chi(s)>0`. Choose such an
+`s` rational. It supplies `u(t_*)<1` and strict ratio ordering.
+
+For the root tail, let
+
+```text
+psi(lambda) = lambda log M
+              +g log[T(t_*-lambda)/P(t_*)].
+```
+
+The equality of moments at `t_*` is essential here: it gives `psi(0)=0`.
+By (5),
+
+```text
+psi'(0) = log M-g mu_T* < 0.
+```
+
+Thus some sufficiently small positive rational `lambda` gives
+`v(t_*)=exp(psi(lambda))<1`. There is no restriction on the sign of
+`t_*-lambda`: all native ranks are positive and these finite moment sums
+exist for every real exponent.
+
+Fix these `a,b,M,s,lambda`. All the inequalities just proved are strict
+and all their expressions are continuous in `t`. The derivative of
+`log q` equals `mu_T-mu_P`, which is positive at `t_*`. There are only
+finitely many mirror cells, and their nonzero denominators stay positive.
+Choose `beta_bar` strictly between `beta_*` and `eta_*`; shrink an interval
+to the right of `t_*` until all its mirror ratios are at most `beta_bar`
+and its mean gap is at least some `d>0`. Shrink again as necessary so that
+the fixed two tails and ratio ordering remain strict, and so that its
+upper endpoint is below one. On this compact interval choose `U,V<1`
+above the two tail maxima and finite `Q` above `q`.
+
+Finally,
+
+```text
+eta'(t) = m^(t-1)(1+t log m) > 0    for t>0.
+```
+
+Hence `eta(t)>=eta_*` on the interval. This proves every assertion in (3).
+Integrating the mean-gap inequality from the exact crossing gives
+
+```text
+q(t) >= exp[d(t-t_*)]     for t in [t_*,t_*+epsilon].      (6)
+```
+
+For `t>t_*` within this interval, in particular, `T(t)>P(t)`.
+
+### 2.3 Funding the majorant at the crossing exponent
+
+This step applies #4483's shifted-log construction. It also identifies the
+precise endpoint change to that source: its displayed guard
+`T(t0)>P(t0)` can be replaced here by `T(t_*)=P(t_*)`, because the power
+used by every finite-rank induction step is strictly above `t_*`.
+Equation (6) supplies the same lower bound needed in its equation (19).
+No geometric sum is evaluated with a zero moment gap.
+
+Put
+
+```text
+R = (1-eta_*)/(eta_*-beta_bar) > 0.
+```
+
+Choose a positive rational `p` large enough that
+
+```text
+exp(d p a/log M)-1 > R,                                  (7)
+```
+
+and choose `c>0` with `c>=p/(1-t_*)`. For integer `ell>=1` define
+
+```text
+K_ell = d p (a ell+1) /
+        [c+log m+(ell+1)log M+log 2],
+
+F_ell = (1-U^ell)(exp(K_ell)-1)-Q M^lambda V^ell.
+```
+
+The fraction in `K_ell` is increasing: its derivative, apart from a
+positive denominator and the factor `d p`, is
+
+```text
+a(c+log m+log 2)+(a-1)log M > 0.
+```
+
+Both other tail factors improve as `ell` increases. Thus `F_ell` is
+nondecreasing, and
+
+```text
+lim_(ell->infinity) F_ell = exp(d p a/log M)-1 > R.
+```
+
+Choose an integer `ell0>=1` with `F_ell0>=R`, large enough also that, for
+`n0=m M^ell0`,
+
+```text
+tau(n0) := t_*+p/(c+log n0) <= t_*+epsilon.               (8)
+```
+
+Such a choice exists by the strict limit and because `tau(n0)` decreases
+to `t_*`. The cutoff is an actual positive integer. Use elementary
+evaluation at every `n<=n0`.
+
+For `n>n0`, put `C_n=floor(n/m)`, `ell=floor(log_M C_n)`, and
+`t=tau(n)=t_*+p/(c+log n)`. Then `ell>=ell0` and
+`t_*<t<=t_*+epsilon`, so all of (3) applies with `T(t)>P(t)`.
+Also
+
+```text
+n < m(M^(ell+1)+1),
+log n < log m+(ell+1)log M+log 2.
+```
+
+Consequently (6) gives `q(t)^(a ell+1)>=exp(K_ell)`. The exact source
+cancellation and the two Chernoff bounds in #4483, equations (7)--(9),
+therefore give
+
+```text
+A_t := (T(t)-P(t)) H_t - R_t
+     >= D_ell(t) P(t)^(G+1),
+
+D_ell(t) = (1-u(t)^ell)(q(t)^(a ell+1)-1)
+            -q(t) M^lambda v(t)^ell
+          >= F_ell >= F_ell0 >= R.                     (9)
+```
+
+Here `H_t` is unit column potential and `R_t` is root-source potential;
+`A_t` and `R_t` are unrelated to the normalization `A` and constant `R`.
+Write `I_t,B_t,F_t` for inner sources, boundary exits, and leaf exits.
+The same predecessor identities are
+
+```text
+I_t=B_t+F_t+A_t,      B_t<=beta_bar I_t,
+F_t<=P(t)^(G+1).
+```
+
+The function `(1-eta)/(eta-beta_bar)` decreases for
+`beta_bar<eta<1`. Since `eta(t)>=eta_*`, (9) implies
+
+```text
+(eta(t)-beta_bar) A_t >= (1-eta(t)) F_t.
+```
+
+Combining this with `(1-beta_bar)I_t<=F_t+A_t` yields
+
+```text
+B_t+F_t <= eta(t) I_t.                                  (10)
+```
+
+In particular `A_t>0`, so the inner source potential and total source
+count are positive. This supplies a nonempty flow in the certified range;
+a separate paid-rank-one assumption is unnecessary for this theorem.
+
+Set
+
+```text
+A = n0^(1-t_*)/(c+log n0)^p,
+f(0)=0,       f(x)=A x^t_* (c+log x)^p for x>=1.
+```
+
+For `x>=1`, its local tangent exponent is
+`tau(x)=t_*+p/(c+log x)<=1`, and
+
+```text
+f'(x)=f(x) tau(x)/x,
+f''(x)/f(x)=x^(-2)[tau(x)(tau(x)-1)-p/(c+log x)^2]<=0.
+```
+
+Moreover `(f(x)/x)'<=0` and `f(n0)=n0`. Thus every elementary base
+rank `1<=n<=n0` satisfies `L(n)=n<=f(n)`.
+
+For positive integer exit rank `e<=n`, `log(1+y)<=y` gives
+
+```text
+f(e)/f(n) <= (e/n)^tau(n).                               (11)
+```
+
+For an inner source rank `s>n/m`, concavity gives
+
+```text
+f(n)-f(n-s) >= tau(n) f(n) s/n
+              >= eta(tau(n)) f(n) (s/n)^tau(n).          (12)
+```
+
+When `s=n`, the first inequality follows from `tau(n)<=1` and `f(0)=0`;
+otherwise its arguments lie in `[1,n]`. Root sources may be smaller than
+`n/m`, but their complement capacities remain nonnegative because `f` is
+increasing. The zero-rank complement has zero cost.
+
+Equation (10), with (11)--(12), bounds the complete exit charge by the
+inner-source capacity. Hence `f` satisfies the complete recurrence
+
+```text
+sum_s S_s f(n-s)+sum_e E_e f(e) <= (sum_s S_s) f(n).
+```
+
+Every recursive rank is strictly below `n`, all counts are finite, and
+the source count is positive. Strong induction proves (4). Finally,
+
+```text
+log A+p log(c+log N) <= (z-t_*) log N
+```
+
+holds for every sufficiently large `N` whenever `z>t_*`; its left-hand
+growth is logarithmic in `log N`, while the right-hand growth is linear
+in `log N`. This proves the last assertion of the theorem. QED.
+
+## 3. Exact feasibility criterion for the two tail gates
+
+The following lemma characterizes just the tail and ratio-ordering gates
+at a fixed exponent. It neither supplies the mirror hypothesis nor admits
+a native implementation. It helps distinguish the root hypothesis above
+from the stronger inequality required away from a root.
+
+Fix `t` with `q(t)=T(t)/P(t)>=1`, and for `lambda>0` define
+
+```text
+H(lambda) = [log P(t)-log T(t-lambda)]/lambda.
+```
+
+**Lemma.** Positive integers `a,b`, an integer `M>1`, and positive rational
+`s,lambda` satisfying
+
+```text
+M^(-s) [T(t+s)/T(t)]^a [P(t+s)/P(t)]^b < 1,
+M^lambda [T(t-lambda)/P(t)]^(a+b) < 1,
+T(t+s)/T(t) >= P(t+s)/P(t)
+```
+
+exist if and only if there is a real `lambda>0` such that
+
+```text
+H(lambda)>mu_P(t),
+```
+
+or, equivalently,
+
+```text
+T(t-lambda) exp(lambda mu_P(t)) < P(t).                   (13)
+```
+
+**Necessity.** Put `g=a+b`, `alpha=a/g`, and `h=(log M)/g`.
+The root-tail gate gives `h<H(lambda)`. Convexity of `log T` gives
+
+```text
+H(lambda) <= mu_T(t)-log(q(t))/lambda <= mu_T(t).
+```
+
+Convexity of both logarithmic moment functions bounds the mixed-tail
+logarithm below by
+
+```text
+s g [alpha mu_T(t)+(1-alpha)mu_P(t)-h].
+```
+
+Its negativity therefore requires
+`h>alpha mu_T(t)+(1-alpha)mu_P(t)`. If `mu_T(t)<=mu_P(t)`, this would
+contradict `h<H(lambda)<=mu_T(t)`. Hence `mu_T(t)>mu_P(t)`, and the
+weighted mean is strictly above `mu_P(t)`. Thus `H(lambda)>mu_P(t)`.
+The ratio-ordering gate is not needed for this direction.
+
+**Sufficiency.** Suppose (13) holds. Strictness and continuity allow
+`lambda` to be chosen rational. The preceding convexity bound implies
+`delta:=mu_T(t)-mu_P(t)>0`. Choose an integer `g>=2` large enough that
+the interval
+
+```text
+((g mu_P(t)+delta)/log 2,  g H(lambda)/log 2)
+```
+
+has length greater than one, and choose an integer `j` strictly inside it.
+Since `mu_P(t)>=0`, its lower endpoint is positive, so `j>=1`.
+Set `a=1`, `b=g-1`, `M=2^j`. Then
+
+```text
+mu_P(t)+delta/g < h=(log M)/g < H(lambda).
+```
+
+The upper inequality gives the root-tail gate. As in section 2.2, the
+derivative at `s=0` of the mixed-tail logarithm is negative, while the
+derivative of the logarithmic forward-ratio difference is `delta>0`.
+All sufficiently small positive `s` therefore give both the mixed-tail
+gate and strict forward-ratio ordering. Choose one rational. QED.
+
+At an exact crossing `q(t)=1`, `H(lambda)` tends to `mu_T(t)` as
+`lambda` decreases to zero. A positive mean gap consequently guarantees
+(13), recovering the existence step of section 2. At `q(t)>1`, a
+positive mean gap alone does not imply (13). The strict surplus `T(t)>P(t)`
+required by a recurrence at its actual exponent remains a separate condition;
+the lemma concerns only the displayed tail and ordering inequalities.
+
+## 4. Why fixed-exponent mean separation alone does not suffice
+
+The moment equality at `t_*` cannot simply be dropped from the gate-existence
+argument. Consider the valid rank histograms
+
+```text
+targets: W_4=4, W_64=17;       paid: P_1=4, P_16=1;
+t=1/2,       m=64.
+```
+
+Then
+
+```text
+T(t)=144>P(t)=8,
+mu_T(t)=(26/9)log 4 > mu_P(t)=log 4.
+```
+
+This profile also passes strict pointwise mirror capacity. Its only exit
+window is `(1/16,1/4]`, from the pair `(r,k)=(16,4)`, with coefficient
+`4 sqrt(64)=32`. Throughout this window the pair `(1,64)` supplies inner
+coefficient `4*17*sqrt(64)=544`. The remaining cells have no exits. Hence
+the exact largest mirror ratio is `beta=32/544=1/17`, while
+`eta(t)=(1/2)/sqrt(64)=1/16`.
+
+Nevertheless no choice of positive integers `a,b`, `M>1`, and positive
+`s,lambda` satisfies both tail gates. Convexity of both logarithmic moment
+functions gives, with `g=a+b`,
+
+```text
+log u >= s[-log M+a mu_T(t)+b mu_P(t)].
+```
+
+Thus `u<1` forces `h:=(log M)/g>log 4`. The rank-4 target term alone gives
+
+```text
+T(t-lambda) >= 4*4^(1/2-lambda) = 8*4^(-lambda).
+```
+
+It follows that
+
+```text
+v^(1/g)=exp(h lambda) T(t-lambda)/P(t)
+        >=exp(lambda[h-log 4]) >1,
+```
+
+a contradiction. The obstruction concerns these simultaneous Chernoff
+gates, not existence of every possible compiler. Equivalently, the rank-4
+term ensures `T(t-lambda) exp(lambda mu_P(t))>=8=P(t)` for every
+`lambda>0`, so the exact criterion (13) fails. For every `x>=0`,
+`4*4^x>=4` and `17*64^x>16^x`, so this profile has no moment crossing in
+`(0,1)`. It is outside the theorem's hypotheses despite passing the other
+three fixed-exponent tests, and does not challenge #4483's certified
+examples. This strengthened example was supplied by the separate
+author-side proof audit for this contribution.
+
+## 5. Scope, evidence and credit
+
+The theorem inherits #4483's all-column arbitrary-input correctness,
+disjoint productive owners, literal chronological paid interface, and
+permitted and priced whole-job adapters, including input maps. Native
+centers and scratch must remain owned until their words restore and erase
+them. No input cloning, field aliasing, omitted complement, unpaid move,
+or pooling of unfinished calls is introduced here. Integer widths must
+still clear every actual chronological batch. Existence of a finite word
+and its normalized recurrence gives no numerical productive-width bound
+or physical, precision, fixed-tape, stock, analytic-transfer, or recovery
+constant. Those obligations remain inherited and unresolved by this note.
+
+The new implication is a sufficient profile criterion for the adaptive
+gates and the explicit allowance of the exact crossing as the endpoint of
+the funded majorant. The finite compiler is Jacob Alan Sussman's work;
+the overlapping integer flow and adaptive/shifted-log argument are zxv's
+#4436 and #4483; the corrected mirror-window method is Ryanson Jonathan's
+#4459. The related finite-flow, leaf, width and accounting investigations
+retain their own contributions and limitations. Their native construction
+lineage, including Cinna Davis and the original retained sources, is
+unchanged. Prepared for Dillon with substantial OpenAI Codex assistance.
+The proof is an author-side mathematical argument, not a formal-kernel
+proof or independent human review. Apache-2.0.
+
+## Open next questions
+
+1. Is a weaker, distribution-dependent boundary condition sufficient when
+   the pointwise mirror factor reaches source capacity? The first step is
+   to retain the exact capped base measure on the offending windows. That
+   requires a new bound; this proof uses strict uniform pointwise slack.
+2. Can profiles with a favorable moment but no simple crossing satisfying
+   the mirror condition use a different height or majorant? The exact
+   counterexample above shows why mean separation alone cannot establish
+   the present two-tail gates. It does not rule out another compiler.
+3. Can the resulting chronological words be emitted with complete native
+   physical and precision constants? Start with one small changed-height
+   forest and its actual batch widths. The inherited native contracts and
+   complete paid implementation remain the blocking obligations.
diff --git a/research/native-kappa-30201655/sparse_membership.py b/research/native-kappa-30201655/sparse_membership.py
new file mode 100644
index 0000000000..eeea8e76be
--- /dev/null
+++ b/research/native-kappa-30201655/sparse_membership.py
@@ -0,0 +1,53 @@
+"""Paid sparse membership tables for native fused groups, Apache-2.0.
+Dugongue with substantial OpenAI Codex assistance.
+"""
+from random import Random
+import json
+
+
+def need(ok,why):
+    if not ok:raise ValueError(why)
+
+
+def prepare(width):
+    need(1<=width<=16,'finite model width')
+    # Each row contains membership and r-th-set-bit dispatch. All rows are paid.
+    rows=[]
+    for mask in range(1<<width):
+        chosen=tuple(j for j in range(width) if (mask>>j)&1)
+        rows.append(chosen)
+    return rows
+
+
+def scatter_union(values,headers,width):
+    need(len(values)==len(headers),'stream shape')
+    table=prepare(width)
+    buckets=[[] for _ in range(width)]
+    visits=0
+    for index,(value,mask) in enumerate(zip(values,headers)):
+        need(0<=mask<1<<width,'header range')
+        dispatch=table[mask]
+        # Runtime work is proportional to actual visits, not width per record.
+        for r in range(len(dispatch)):
+            j=dispatch[r];buckets[j].append((index,value));visits+=1
+    return buckets,visits
+
+
+def check():
+    rng=Random(20261022);cases=visits=records=0
+    for width in range(1,11):
+        values=[rng.randrange(-1000,1000) for _ in range(97)]
+        headers=[rng.randrange(1<<width) for _ in values]
+        got,count=scatter_union(values,headers,width)
+        expected=[[(i,x) for i,x in enumerate(values) if (headers[i]>>j)&1] for j in range(width)]
+        need(got==expected,'independent sparse membership/scatter formula')
+        need(count==sum(mask.bit_count() for mask in headers),'actual visit accounting')
+        cases+=1;visits+=count;records+=len(values)
+    try:scatter_union([1],[4],1)
+    except ValueError:pass
+    else:raise ValueError('invalid header accepted')
+    return dict(status='PASS',group_shapes=cases,records_checked=records,actual_sparse_visits=visits,
+                invalid_header_control=True,scope='finite native membership/dispatch; full selected-bit projection theorem is separate')
+
+
+if __name__=='__main__':print(json.dumps(check(),indent=2))
diff --git a/research/native-kappa-30201655/verify.py b/research/native-kappa-30201655/verify.py
new file mode 100644
index 0000000000..a8014e9efb
--- /dev/null
+++ b/research/native-kappa-30201655/verify.py
@@ -0,0 +1,30 @@
+"""Source-bound component replay; finite evidence, not universal theorem acceptance."""
+from pathlib import Path
+import hashlib,json,io,contextlib
+HERE=Path(__file__).resolve().parent
+
+def require(ok,why):
+    if not ok:raise ValueError(why)
+
+def load(name):
+    p=HERE/(name+'.py'); ns={'__name__':'authenticated_component','__file__':str(p)}
+    exec(compile(p.read_bytes(),str(p),'exec'),ns);return ns
+
+def main():
+    pins=json.loads((HERE/'CONTENT-HASHES.json').read_text(encoding='utf-8'))
+    actual={p.relative_to(HERE).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() for p in HERE.rglob('*') if p.is_file() and p.name!='CONTENT-HASHES.json'}
+    require(actual==pins,'package inventory or source hash mismatch')
+    source_map=json.loads((HERE/'MODERN-SOURCE-MAP.json').read_text())
+    for row in source_map['sources']:
+        require(pins[row['local_file']]==row['sha256'],'frozen analytic source pin')
+    for row in json.loads((HERE/'CODE-SOURCE-PINS.json').read_text()):
+        require(pins[row['local_file']]==row['sha256'],'frozen code/source pin')
+    out={}
+    for name in ('critical_check','native_metadata','batched_band','record_product','sparse_membership','limb_setup'):
+        out[name]=load(name)['check']()
+    capture=io.StringIO()
+    with contextlib.redirect_stdout(capture):load('native_ledger')['main']()
+    out['native_ledger']=json.loads(capture.getvalue())
+    require(out['native_ledger']['kappa']=='6040331/2000000000','target drift')
+    print(json.dumps({'status':'PASS_NATIVE_ASSEMBLY_COMPONENTS','authenticated_files':len(pins),'results':out,'scope':'Finite components and exact arithmetic only; retained universal source proofs are not mechanically certified.'},indent=2))
+if __name__=='__main__':main()