From dbb9fb1c8fbf2dc0ee1cc3c28abfc9d2a834305e Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Fri, 23 Oct 2026 09:37:06 -0400
Subject: [PATCH 1/4] Add exact Gaussian cache reuse and sharp fixed-contact
 center bound

---
 research/gaussian-cache-reuse/PLAN.json     |   13 +
 research/gaussian-cache-reuse/PROOF.md      |  204 ++++
 research/gaussian-cache-reuse/README.md     |  198 ++++
 research/gaussian-cache-reuse/RESULT.json   | 1003 +++++++++++++++++++
 research/gaussian-cache-reuse/SOURCES.json  |  134 +++
 research/gaussian-cache-reuse/TASK.json     |  113 +++
 research/gaussian-cache-reuse/VALIDATION.md |   63 ++
 research/gaussian-cache-reuse/VERIFY.json   |   47 +
 research/gaussian-cache-reuse/center.py     |   58 ++
 research/gaussian-cache-reuse/geometry.py   |  128 +++
 research/gaussian-cache-reuse/primitive.py  |  155 +++
 research/gaussian-cache-reuse/verify.py     |  110 ++
 12 files changed, 2226 insertions(+)
 create mode 100644 research/gaussian-cache-reuse/PLAN.json
 create mode 100644 research/gaussian-cache-reuse/PROOF.md
 create mode 100644 research/gaussian-cache-reuse/README.md
 create mode 100644 research/gaussian-cache-reuse/RESULT.json
 create mode 100644 research/gaussian-cache-reuse/SOURCES.json
 create mode 100644 research/gaussian-cache-reuse/TASK.json
 create mode 100644 research/gaussian-cache-reuse/VALIDATION.md
 create mode 100644 research/gaussian-cache-reuse/VERIFY.json
 create mode 100644 research/gaussian-cache-reuse/center.py
 create mode 100644 research/gaussian-cache-reuse/geometry.py
 create mode 100644 research/gaussian-cache-reuse/primitive.py
 create mode 100644 research/gaussian-cache-reuse/verify.py

diff --git a/research/gaussian-cache-reuse/PLAN.json b/research/gaussian-cache-reuse/PLAN.json
new file mode 100644
index 0000000000..42ce094942
--- /dev/null
+++ b/research/gaussian-cache-reuse/PLAN.json
@@ -0,0 +1,13 @@
+{
+  "at_UTC": "2026-10-23T13:12:01.622494+00:00",
+  "base_commit": "8544ddf488e4ecd2f8c85f79a5b2277d1380aee0",
+  "canonical_main": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+  "scope": "Exact cache primitive and source-bound generalized center floor, not a complete supplier search or new kappa.",
+  "candidate": "One stable arbitrary source at zero frame; two arbitrary targets in planes <1,2> and <1,4>. Retain a line-<1> owned cache and reuse a second owned field for both output updates.",
+  "predicted_recursive_change": "2 H2 -> 3 H1, with zero new productive credit and two owned cache fields.",
+  "predicted_gain_at_selected_exponent": "0.991635124775620904301391563105821801159734270612346654",
+  "center_question": "Does the owned-center intersection floor extend to non-nested or arbitrary Clifford transport paths and typed-copy branching trees while persistent common-chart contact caps remain fixed?",
+  "claimed_new_application": "Constructive exponent-aware cache sharing plus its source-bound applicability limit. Metric, memoization and subadditivity are classical, not inventions claimed here.",
+  "stop": "Verify literal arbitrary-input fanout and raw dual, phases, invalidation controls and complete module tariff. Reconstruct all16 center blocks before asserting an 8-rank bound. Do not substitute the toy saving into the selected supplier without an actual changed caller.",
+  "geometry_sha256": "20c217d44893d2cc3b517af826936fc8a4c58f498f5bf76b833e5599a25d9084"
+}
diff --git a/research/gaussian-cache-reuse/PROOF.md b/research/gaussian-cache-reuse/PROOF.md
new file mode 100644
index 0000000000..a38015d2cb
--- /dev/null
+++ b/research/gaussian-cache-reuse/PROOF.md
@@ -0,0 +1,204 @@
+# Cache tree identities and the selected center intersection bound
+
+## Frames and actual paid ranks
+
+Let a field have \(2^n\) binary-address positions. A Clifford frame F has
+exact unitary operator \(G_F\). Set
+\(L_0=\{(0,z):z\in\mathbb F_2^n\}\) and
+\(\Lambda_F=F^{-1}L_0\), using the induced binary symplectic action.
+For the actual transport \(G_B G_A^{-1}\), its Fourier rank is
+
+\[
+r(A,B)=n-\dim(\Lambda_A\cap\Lambda_B).
+\tag{1}
+\]
+
+Indeed its B block measures the dimension outside \(L_0\) of
+\(BA^{-1}L_0\). Its kernel is the intersection of \(L_0\) with that
+image. Pulling the intersection back through B gives (1).
+Phases and monomial factors do not change this rank, but must still be
+implemented. This rank is an integer metric on Lagrangian charts; different
+Cliffords with the same chart can have distance zero and nontrivial paid
+ordinary monomial work.
+
+For the repository's canonical subspace frame \(C_U\), direct substitution
+gives
+
+\[
+\Lambda(U)=\{(x,x+z):x\in U,\ z\in U^\perp\}.
+\]
+
+Consequently
+\(r(U,V)=\dim U+\dim V-2\dim(U\cap V)\), including non-nested pairs.
+`primitive.py` independently checks this against exact lowered Clifford
+operators for every pair of the 16 subspaces of \(\mathbb F_2^3\), including
+all input columns and absolute phase. The binary chart formula is the
+algebraic statement; these finite tests check its convention in the retained
+implementation.
+
+## A cache is a snapshot with a representation
+
+Fix a logical column x. At each cache node v maintain physical value
+\(z_v=G_vx\). An owned child w is created by copying \(z_v\), then applying
+the fully paid transport \(G_wG_v^{-1}\). Thus
+
+\[
+G_wG_v^{-1}z_v=G_wx.
+\tag{2}
+\]
+
+Induction proves the invariant on any typed-copy tree. At a terminal,
+\(y_i\leftarrow y_i+\alpha_i z_i\) supplies precisely the requested
+contribution. Internal caches carry no productive-owner credit. Leaves can
+be processed in their original order using a reusable owned field if the
+retained parent cache remains unchanged.
+
+The logical snapshot is an operator row on the independent caller inputs.
+For a cached row R, a later required row S may use the cache when
+\(S=qR\) for an explicitly known scalar q, by changing the ADD coefficient.
+Writes to the original owner are harmless only when this row relation still
+holds. The invariant concerns expressions, not register identifiers. In a
+longer caller the row algebra must include all address operators, coefficients
+and phases; the small scalar-row control here is not such a caller analysis.
+
+Let the desired main endpoint be
+\((x,y_1,y_2)\mapsto(x,y_1+A_1x,y_2+A_2x)\).
+Its raw inverse transpose is
+
+\[
+(x,y_1,y_2)\mapsto
+(x-A_1^Ty_1-A_2^Ty_2,y_1,y_2).
+\tag{3}
+\]
+
+Since G is unitary, \(G^T=\overline G^{-1}\). Reversing the fanout into a
+gather therefore uses conjugate transports in the reversed directions.
+`dual_program` implements (3), not a forward move with a reversed name.
+The inverse transpose is of the main endpoint; owned CLEARs make the full
+scratch-inclusive map noninvertible. Arbitrary owned entries are erased under
+the retained owned-erasure contract and both owned fields leave zero.
+
+Equations (2) and (3) hold for arbitrary field columns. Lifting each block by
+\(I_b\otimes G\) proves the same identities with b idle positions, and block
+composition proves arbitrary repetitions. Tensoring address operators does
+not merge owner roles or turn their sum into independent output credit.
+This is an all-width algebraic identity under the retained Gaussian and
+owned-erasure primitives. A bit-cost implementation still needs those
+primitives' precision, storage, normalizer and tape contracts.
+
+## A sharp three terminal example
+
+Take \(U=0\), \(V_1=\langle1,2\rangle\),
+\(V_2=\langle1,4\rangle\). The three terminals have pairwise distance 2.
+Their shared line \(M=\langle1\rangle\) has distance 1 to each.
+Copy x to owned Z and move U to M; copy Z to owned W, move M to V1,
+ADD to Y1 and clear W; repeat for V2; clear Z. The program has three
+rank-1 moves and the ordinary passes recorded in RESULT.json.
+
+For \(0<s\leq1\), the minimum recursive moment over typed-copy cache trees
+connecting these terminals is exactly
+
+\[
+\min\{2\,2^s,3\}.
+\tag{4}
+\]
+
+To prove the lower bound, remove nonterminal leaves and suppress degree-two
+vertices. Suppression does not increase moment: the metric triangle
+inequality and \((a+b)^s\leq a^s+b^s\) allow replacement of a path by
+one direct edge. Contract zero-rank edges for this rank-only argument.
+A reduced tree connecting three terminals is either a path through one
+terminal or a three-edge tree with one nonterminal junction. The former
+costs \(2\,2^s\). In the latter all three positive integer edge ranks are
+at least 1, hence the cost is at least 3. These bounds apply to arbitrary
+Clifford intermediate charts. The separate transfers and the shared line
+attain them. Ordinary monomial costs are outside this rank-only optimum.
+
+At \(s=1-0.00302015\), the frozen gain is
+\(2\,2^s-3=0.9916351247756209043\ldots\).
+The exact rational interval engine certifies its positive sign and the
+negative sign after charging one more H1. At \(s=1/2\) the separate
+transfers win. This sign reversal is a useful control on treating rank mass
+as a sufficient cost statistic.
+
+If Z is already a caller-supplied observation \(C_Mx\), omit its creation
+and final erasure. One owned W then suffices for two marginal H1 moves.
+Z is returned unchanged. Its relation to x and all costs outside the module
+are preconditions; the module does not manufacture that observation.
+
+## Intersection loss bounds any typed tree
+
+For a rooted tree of n-dimensional charts, in parent-before-child order let
+\(I_k=\bigcap_{v\leq k}\Lambda_v\). When child w of p is added,
+\(I_{k-1}\subseteq\Lambda_p\), so the quotient map injects
+
+\[
+I_{k-1}/(I_{k-1}\cap\Lambda_w)
+\hookrightarrow
+\Lambda_p/(\Lambda_p\cap\Lambda_w).
+\]
+
+The lost dimension is at most \(r(p,w)\). Summing proves
+
+\[
+\sum_e r_e\geq n-\dim\!\bigcap_v\Lambda_v.
+\tag{5}
+\]
+
+Matarener's nested path argument is the predecessor of this proof. The
+extension uses the actual inverse-image Clifford chart and permits branching
+and arbitrary intermediate Lagrangians. For \(0<s\leq1\), subadditivity gives
+\(\sum_e r_e^s\geq(\sum_e r_e)^s\).
+
+For canonical terminal frames \(U_i\), set \(I=\bigcap_iU_i\) and
+\(J=\sum_iU_i\). The explicit chart formula gives
+
+\[
+\dim\bigcap_i\Lambda(U_i)=\dim I+n-\dim J.
+\tag{6}
+\]
+
+Adding arbitrary intermediate vertices can only shrink that intersection.
+
+## Application to all selected center blocks
+
+Keep #4470's chronological scalar demand, coefficients, fixed warps and helper
+boundaries. Persistent L roles retain the original monotone subspace-frame
+rules. Every source/target scalar contact is in a common canonical frame.
+The predecessor's interval propagation forces a source frame R to contain
+\(A=\operatorname{Low}(\mathrm{source})\), and every target frame Fi to
+lie in \(B_i=\operatorname{Up}(\mathrm{target}_i)\).
+
+Allow the owned payload to travel along arbitrary Clifford intermediates and
+to branch by typed copies. It carries the same specified snapshot; combining
+independent payloads is outside this contract. From (5) and (6), its rank mass
+is at least
+
+\[
+\begin{aligned}
+\dim(R+\sum_iF_i)-\dim(R\cap\bigcap_iF_i)
+&\geq\dim R-\dim(R\cap\bigcap_iB_i)\\
+&\geq\dim A-\dim(A\cap\bigcap_iB_i).
+\end{aligned}
+\tag{7}
+\]
+
+The last inequality is the injection
+\(A/(A\cap X)\hookrightarrow R/(R\cap X)\).
+For a dual gather, apply the same argument to the transposed typed-copy tree
+with conjugate charts; intersection dimensions and edge ranks are preserved.
+
+`center.py` rebuilds the selected local word, recovers paid profile
+`{1:2237,2:388,3:494,4:147,5:36,8:8}` in both orientations, and propagates
+all original contact intervals. For all eight blocks in each orientation,
+it finds \(\dim A=8\) and \(A\cap\bigcap_{i=1}^{22}B_i=0\).
+Thus every such tree pays rank mass at least 8 and moment at least \(8^s\).
+The existing single H8 attains the bound. The actual terminal-chart
+intersection independently gives the same loss eight.
+
+This closes the predecessor's stated non-nested-C question under unchanged
+persistent/contact constraints. It does not cover changed cross-frame contact
+interfaces, changed scalar graphs or helper boundaries, new observations, or
+general circuits mixing independent payloads. Such changes alter the premises
+of (7). In particular the bound must not be transferred unchanged to the
+split-contact or paid-history continuations.
diff --git a/research/gaussian-cache-reuse/README.md b/research/gaussian-cache-reuse/README.md
new file mode 100644
index 0000000000..771bd2994a
--- /dev/null
+++ b/research/gaussian-cache-reuse/README.md
@@ -0,0 +1,198 @@
+# Gaussian Cache Reuse for Cross Frame ADDs and Paid History
+
+Several required reads of the same logical snapshot can share a transformed
+owned copy. A small exact example replaces **two rank-2 Gaussian jobs by three
+rank-1 jobs**, with no new productive-output credit. Its predicted moment saving
+was frozen before construction and then verified. The same geometry extends
+Matarener's selected-center lower bound to non-nested Clifford transports and
+typed-copy trees: **each of the 16 block-orientations still costs at least one
+rank-8 job** under the original common-contact constraints.
+
+These are a reusable construction and a scoped lower-bound proof, with exact
+finite checks. They do not install a changed selected caller or establish a new
+κ. Canonical source baseline: `ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c`,
+selected conditional κ `0.00302015` from #4470.
+
+## The small geometric law
+
+A frame describes how a field is represented. Changing frames mixes some
+number of independent binary directions; call that number the edge's rank.
+A cache tree pays for each shared prefix once. The useful equations are
+
+\[
+\text{cache price at exponent }s=\sum_{e}r_e^s,\qquad s=1-\kappa,
+\]
+
+\[
+\sum_e r_e\;\geq\;n-\dim\!\left(\bigcap_v\Lambda_v\right).
+\]
+
+Here each \(\Lambda_v\) is an n-dimensional Clifford chart. The second equation
+says that the directions lost from the joint intersection must be paid for
+somewhere in the tree. [PROOF.md](PROOF.md) gives the argument and the exact
+chart convention. This is classical intersection geometry applied to the
+repository's owned-copy and Gaussian-job contracts.
+
+The simplest useful example has source frame 0 and two target planes
+\(\langle1,2\rangle,\langle1,4\rangle\). Going separately costs \(2\,2^s\).
+Sharing their line \(\langle1\rangle\) costs three rank-1 edges, hence 3.
+The exact optimum over typed cache trees, even with arbitrary intermediate
+Clifford charts, is
+
+\[
+\boxed{\min\{2\,2^s,3\}}.
+\]
+
+The preferred network changes at \(s=\log_2(3/2)\). Thus the geometry alone
+does not predict the winner: the recursive exponent chooses the network.
+At the selected exponent the shared tree saves
+`0.9916351247756209043` moment units. **One additional rank-1 repair job
+exhausts that saving.** [PLAN.json](PLAN.json) fixes the prediction and geometry
+hash; [RESULT.json](RESULT.json) contains outward rational sign certificates.
+This is a prospective module-cost prediction, not a held-out κ improvement.
+
+## Exact ownership and lifetime contract
+
+Every cache in frame F contains \(C_F x\) for one specified logical snapshot x.
+A COPY followed by the fully paid transport \(C_G C_F^{-1}\) creates a child
+cache in G. Scalar ADDs consume it while leaving that cache unchanged. Its
+productive-owner credit is zero.
+
+| Module | Paid jobs | Ordinary whole-field passes | Extra fields |
+| --- | --- | --- | --- |
+| Two separate forward transfers | 2 H2 | 2 COPY, 2 ADD, 3 CLEAR | 1 owned |
+| Shared forward fanout | 3 H1 | 3 COPY, 2 ADD, 5 CLEAR | 2 owned |
+| Raw inverse-transpose gather | 3 H1 | 2 COPY, 3 ADD, 5 CLEAR | 2 owned |
+| Caller supplies the line observation | 2 H1 marginal | 2 COPY, 2 ADD, 3 CLEAR | 1 owned, 1 borrowed observation |
+
+Every paid move also retains its exact left and right monomial normalizers,
+including phases; at most six such maps occur in each three-move module.
+The table counts the explicit ordinary passes, not a complete bit, tape or
+precision tariff. Those maps and passes remain implementation costs. Owned
+fields may enter arbitrarily and are explicitly cleared; they leave zero.
+Dirty borrowed workspace must be returned and cannot use this erasure rule.
+Relative to separate transfers, sharing uses one more owned field, three more
+explicit passes and one more pair of normalizers. A caller must price that
+tradeoff before interpreting the recursive-moment gain as an algorithmic gain.
+
+Reuse is valid when the required logical operator row equals the saved row,
+or is a proved scalar multiple absorbed into the ADD coefficient. Matching
+owner names or frame tags is insufficient. Intervening writes can invalidate
+the snapshot; a later exact restoration can make it usable again. The checker
+rejects a stale read and accepts restored and specified proportional rows.
+
+The already-paid observation variant requires the caller to supply
+\(Z=C_{\langle1\rangle}x\) for that exact snapshot. Z is returned unchanged.
+Its creation, lifetime, hosting and eventual cleanup remain caller obligations.
+This variant is derived after the frozen main prediction. It does not give an
+independent observation for free.
+
+## Where this changes the next research experiment
+
+These are source-specific handoffs, not a new task allocation or priority revision.
+
+1. **Batch cross-frame ADDs by exact snapshot.**
+   [Discussion #5125](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125)
+   already implements a separate owned COPY, paid transport, ADD and CLEAR per
+   split contact. That primitive is predecessor work. The changed experiment
+   is to find several required reads of the *same operator row*, share their
+   transformed prefix, and compare the complete changed invoice. Freeze the
+   candidate tree, cache lifetime, normalizers and repair allowance before
+   native lowering. Another frame seed does not test this premise.
+2. **Use an actual paid-history observation as the root.**
+   The paid-history continuation in
+   [Discussion #4930](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930)
+   is already claimed. Supply this primitive to that question: first identify
+   the exact saved helper/center expression and its later demand. Prove the
+   row relation and return contract before claiming the marginal two-H1 bill.
+   Retaining an observation can change the root geometry; a count of saved
+   coordinates alone does not prove an independent Gaussian output block.
+3. **Require a changed contact or payload before another center-only scan.**
+   The new bound closes the non-nested-transport question explicitly left in
+   [owned-centre-wire-floor](../owned-centre-wire-floor/README.md), and also
+   covers typed-copy branching under those fixed caps. Arbitrary exact
+   Clifford intermediate charts do not lower its eight-rank charge. Changed
+   cross-frame contacts, helper boundaries, scalar graphs, or combinations of
+   independent payloads require a new bound and remain outside this result.
+
+The physical binding is the bottleneck: a candidate must supply the required
+rows with a winning complete bill. The existing
+[coded compiler reserve](../coded-compiler-closure/README.md) already supplies
+conditional arithmetic for its declared model. More compiler digits do not
+prove the missing physical caller. Likewise, the
+[active-query bound](../coded-active-query-bound/README.md) and
+[two-stage terminal result](../two-stage-coded-terminal/README.md) explain why
+static mode counts and a free endpoint decoder are insufficient; neither is a
+universal exclusion of paid-history or changed-contact constructions.
+
+The submission refresh adds a concrete warning from
+[active query feedback](../coded-active-feedback/README.md): its recovered
+missing coefficient is accompanied by a nonzero second-input coefficient
+whose rank fraction tends to 3/4. That scoped result does not reject other
+feedback grammars, but makes the full row relation the first test for a
+paid-history cache root. Recovering one desired coefficient is insufficient.
+
+## Verification
+
+From the repository root, with Python 3.12 and the standard library:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse
+```
+
+Both registered commands are read-only and compare every saved mathematical
+field. They run normally and with `-O`; explicit failure checks remain active
+with assertions disabled. The launcher supplies a fresh bytecode-cache namespace.
+
+The exact dyadic-complex checker tests all 40 independent input columns in
+each orientation, including arbitrary owned entry values; all 256 canonical
+three-axis frame pairs, 140 non-nested; and wrong-phase, wrong-dual and stale
+snapshot controls. It tests 6,750 two-qubit Lagrangian paths/trees and rebuilds
+the original selected word's complete local paid profile and all 16 center
+contact blocks. The general proofs are written, not proof-kernel checked.
+The unchanged selected supplier's native, compiler and multiplication-theorem
+obligations are not re-established by this module replay.
+
+## Open next questions
+
+- Which *actual* split-contact word contains a profitable repeated-snapshot
+  cache tree? Start with one source row and its first two required cross-frame
+  reads, including all intervening writes. The blockers are the exact row
+  match, legal lifetime and complete bill; [TASK.json](TASK.json) records a
+  bounded test.
+- Can the claimed paid-history caller provide a retained observation with the
+  required row relation and unchanged return? Start at its already claimed
+  source helper prefix. The blocker is caller binding, rather than the local
+  transport identity.
+- Does changing a helper boundary or splitting a contact reduce the new joint
+  intersection loss? Derive fresh Low/Up or replacement constraints for one
+  changed block before extending a construction. The original caps cannot be
+  reused after changing the graph.
+
+## Provenance and credit
+
+Copied-center reuse predates this package; see
+[copied-reversed](../copied-reversed/README.md). Matarener supplies the
+owned-center intersection argument and fixed-word interval engine. Dugongue
+supplies the owned-C retiming contract. Cinna Davis supplies #4470's selected
+word, retaining zxv's native supplier, Jacob Alan Sussman's Clifford work and
+the complete credited source chain. The live split-contact and paid-history
+discussions supply the application context, not mathematical inputs to the
+verifier. Metric geometry, memoization, Steiner trees and subadditivity are
+classical; this package claims their explicit costed application and scoped
+extension here.
+
+Overlap checks on 2026-10-23 covered 347 PR records, 4,456 Discussion records
+and 6,999 local package notes in the second bounded search. They do not cover
+every diff, every comment or unpublished work. Live claims are provisional.
+No external claim or publication was made in this session; this is local
+evidence until shared. Exact canonical source pins are in
+[SOURCES.json](SOURCES.json). Prepared for the repository user with substantial
+OpenAI Codex assistance. Apache-2.0.
+
+The final upstream checkpoint is `ff3cc58e370d0f678e529246f8c73e8094e18fcf`.
+Selection, catalogue, family guidance and every existing declared source pin
+are unchanged. Newly archived two-axis and owned-kernel results concern
+different contact alphabets; their source-only intake is not scientific
+acceptance. The new active-feedback context above is pinned separately.
diff --git a/research/gaussian-cache-reuse/RESULT.json b/research/gaussian-cache-reuse/RESULT.json
new file mode 100644
index 0000000000..82ffee525c
--- /dev/null
+++ b/research/gaussian-cache-reuse/RESULT.json
@@ -0,0 +1,1003 @@
+{
+  "status": "PASS_GAUSSIAN_CACHE_REUSE_AND_SHARP_CENTER_BOUND_NO_NEW_KAPPA",
+  "plan_sha256": "9d914483465b5da9952a8c2ad3c1017ad231ffa6b1c2681eb846d4b98b6fd649",
+  "primitive": {
+    "exact_frame_pairs": 256,
+    "non_nested_pairs": 140,
+    "address_dimension": 3,
+    "addresses_per_field": 8,
+    "independent_original_fields": 3,
+    "arbitrary_owned_entry_fields_cleared": 2,
+    "all_input_columns_per_orientation": 40,
+    "forward": {
+      "paid": {
+        "1": 3
+      },
+      "ordinary_field_passes": {
+        "ADD": 2,
+        "CLEAR": 5,
+        "COPY": 3
+      },
+      "owned_fields": 2,
+      "new_productive_owners": 0
+    },
+    "raw_inverse_transpose": {
+      "paid": {
+        "1": 3
+      },
+      "ordinary_field_passes": {
+        "ADD": 3,
+        "CLEAR": 5,
+        "COPY": 2
+      },
+      "owned_fields": 2,
+      "new_productive_owners": 0
+    },
+    "existing_paid_observation_variant": {
+      "tariff": {
+        "paid": {
+          "1": 2
+        },
+        "ordinary_field_passes": {
+          "ADD": 2,
+          "CLEAR": 3,
+          "COPY": 2
+        },
+        "owned_fields": 1,
+        "new_productive_owners": 0,
+        "borrowed_observation_fields": 1
+      },
+      "all_input_columns": 40,
+      "precondition": "Z=C_line X for the exact required logical snapshot; caller supplies and already pays that observation. Z is returned unchanged. Its creation, retention and eventual cleanup remain caller costs."
+    },
+    "negative_controls": [
+      "wrong forward phase",
+      "wrong dual orientation",
+      "stale snapshot"
+    ],
+    "lifetime_controls": [
+      "restored source",
+      "specified proportional source"
+    ],
+    "primitive_scope": "Exact finite module plus written block/tensor lift; no installed selected-caller improvement."
+  },
+  "geometry": {
+    "all_two_qubit_lagrangians": 15,
+    "arbitrary_chart_path_and_tree_checks": 6750,
+    "canonical_three_axis_meetings": [
+      {
+        "meeting_basis": [],
+        "edge_grades": [
+          0,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1
+        ],
+        "edge_grades": [
+          1,
+          1,
+          1
+        ]
+      },
+      {
+        "meeting_basis": [
+          2
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          3
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          4
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          5
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          6
+        ],
+        "edge_grades": [
+          1,
+          3,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          7
+        ],
+        "edge_grades": [
+          1,
+          3,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          2
+        ],
+        "edge_grades": [
+          0,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          4
+        ],
+        "edge_grades": [
+          0,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          6
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          2,
+          4
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          2,
+          5
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          3,
+          4
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          3,
+          5
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          2,
+          4
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      }
+    ],
+    "cache_tree_mass": {
+      "edge_rank_mass": 3,
+      "intersection_floor": 3,
+      "steps": [
+        {
+          "node": 1,
+          "parent": 0,
+          "grade": 1,
+          "intersection_loss": 1
+        },
+        {
+          "node": 2,
+          "parent": 1,
+          "grade": 1,
+          "intersection_loss": 1
+        },
+        {
+          "node": 3,
+          "parent": 1,
+          "grade": 1,
+          "intersection_loss": 1
+        }
+      ]
+    },
+    "transition_s": "0.584962500721156181453738943947816508759814407692481060455752",
+    "scope": "General proof is written; these finite checks corroborate its ranks and transcription."
+  },
+  "price": {
+    "baseline_paid": {
+      "2": 2
+    },
+    "cache_paid": {
+      "1": 3
+    },
+    "productive_owner_delta": 0,
+    "outward_moment_gains": {
+      ".00302015": {
+        "saving": [
+          "778074320324929711448396173466075825095034793744123736337/784637716923335095479473677900958302012794430558004314112",
+          "3112297281299718845793584693864303300380139174976494945539/3138550867693340381917894711603833208051177722232017256448"
+        ],
+        "after_one_extra_H1": [
+          "-6563396598405384031077504434882476917759636813880577775/784637716923335095479473677900958302012794430558004314112",
+          "-26253586393621536124310017739529907671038547255522310909/3138550867693340381917894711603833208051177722232017256448"
+        ]
+      },
+      ".004": {
+        "saving": [
+          "193986964612987004559506547625256900050002729830442564423/196159429230833773869868419475239575503198607639501078528",
+          "1551895716903896036476052381002055200400021838643540515479/1569275433846670190958947355801916604025588861116008628224"
+        ],
+        "after_one_extra_H1": [
+          "-2172464617846769310361871849982675453195877809058514105/196159429230833773869868419475239575503198607639501078528",
+          "-17379716942774154482894974799861403625567022472468112745/1569275433846670190958947355801916604025588861116008628224"
+        ]
+      },
+      ".005": {
+        "saving": [
+          "3095116623278995131471986088129486700423211664193186845345/3138550867693340381917894711603833208051177722232017256448",
+          "3095116623278995131471986088129486700423211664193186845541/3138550867693340381917894711603833208051177722232017256448"
+        ],
+        "after_one_extra_H1": [
+          "-43434244414345250445908623474346507627966058038830411103/3138550867693340381917894711603833208051177722232017256448",
+          "-43434244414345250445908623474346507627966058038830410907/3138550867693340381917894711603833208051177722232017256448"
+        ]
+      },
+      ".01": {
+        "saving": [
+          "3051832649934593665179488419917092609221248706206130443413/3138550867693340381917894711603833208051177722232017256448",
+          "3051832649934593665179488419917092609221248706206130443609/3138550867693340381917894711603833208051177722232017256448"
+        ],
+        "after_one_extra_H1": [
+          "-86718217758746716738406291686740598829929016025886813035/3138550867693340381917894711603833208051177722232017256448",
+          "-86718217758746716738406291686740598829929016025886812839/3138550867693340381917894711603833208051177722232017256448"
+        ]
+      }
+    },
+    "repair_budget": "Strictly less than one extra H1 per module at every tested positive saving.",
+    "selected_installation": false,
+    "new_kappa": null
+  },
+  "selected_centers": {
+    "blocks": {
+      "backward": [
+        {
+          "source_event": 11333,
+          "targets": [
+            11310,
+            11311,
+            11312,
+            11313,
+            11314,
+            11315,
+            11316,
+            11317,
+            11318,
+            11319,
+            11320,
+            11321,
+            11322,
+            11323,
+            11324,
+            11325,
+            11326,
+            11327,
+            11328,
+            11329,
+            11330,
+            11331
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            10,
+            16,
+            34,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11359,
+          "targets": [
+            11336,
+            11337,
+            11338,
+            11339,
+            11340,
+            11341,
+            11342,
+            11343,
+            11344,
+            11345,
+            11346,
+            11347,
+            11348,
+            11349,
+            11350,
+            11351,
+            11352,
+            11353,
+            11354,
+            11355,
+            11356,
+            11357
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            8,
+            16,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11385,
+          "targets": [
+            11362,
+            11363,
+            11364,
+            11365,
+            11366,
+            11367,
+            11368,
+            11369,
+            11370,
+            11371,
+            11372,
+            11373,
+            11374,
+            11375,
+            11376,
+            11377,
+            11378,
+            11379,
+            11380,
+            11381,
+            11382,
+            11383
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            9,
+            17,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11411,
+          "targets": [
+            11388,
+            11389,
+            11390,
+            11391,
+            11392,
+            11393,
+            11394,
+            11395,
+            11396,
+            11397,
+            11398,
+            11399,
+            11400,
+            11401,
+            11402,
+            11403,
+            11404,
+            11405,
+            11406,
+            11407,
+            11408,
+            11409
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            8,
+            20,
+            36,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11437,
+          "targets": [
+            11414,
+            11415,
+            11416,
+            11417,
+            11418,
+            11419,
+            11420,
+            11421,
+            11422,
+            11423,
+            11424,
+            11425,
+            11426,
+            11427,
+            11428,
+            11429,
+            11430,
+            11431,
+            11432,
+            11433,
+            11434,
+            11435
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            8,
+            18,
+            32,
+            66,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11463,
+          "targets": [
+            11440,
+            11441,
+            11442,
+            11443,
+            11444,
+            11445,
+            11446,
+            11447,
+            11448,
+            11449,
+            11450,
+            11451,
+            11452,
+            11453,
+            11454,
+            11455,
+            11456,
+            11457,
+            11458,
+            11459,
+            11460,
+            11461
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            9,
+            17,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11489,
+          "targets": [
+            11466,
+            11467,
+            11468,
+            11469,
+            11470,
+            11471,
+            11472,
+            11473,
+            11474,
+            11475,
+            11476,
+            11477,
+            11478,
+            11479,
+            11480,
+            11481,
+            11482,
+            11483,
+            11484,
+            11485,
+            11486,
+            11487
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            8,
+            16,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11515,
+          "targets": [
+            11492,
+            11493,
+            11494,
+            11495,
+            11496,
+            11497,
+            11498,
+            11499,
+            11500,
+            11501,
+            11502,
+            11503,
+            11504,
+            11505,
+            11506,
+            11507,
+            11508,
+            11509,
+            11510,
+            11511,
+            11512,
+            11513
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            12,
+            16,
+            32,
+            68,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        }
+      ],
+      "forward": [
+        {
+          "source_event": 11310,
+          "targets": [
+            11312,
+            11313,
+            11314,
+            11315,
+            11316,
+            11317,
+            11318,
+            11319,
+            11320,
+            11321,
+            11322,
+            11323,
+            11324,
+            11325,
+            11326,
+            11327,
+            11328,
+            11329,
+            11330,
+            11331,
+            11332,
+            11333
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            10,
+            16,
+            34,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11336,
+          "targets": [
+            11338,
+            11339,
+            11340,
+            11341,
+            11342,
+            11343,
+            11344,
+            11345,
+            11346,
+            11347,
+            11348,
+            11349,
+            11350,
+            11351,
+            11352,
+            11353,
+            11354,
+            11355,
+            11356,
+            11357,
+            11358,
+            11359
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            8,
+            16,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11362,
+          "targets": [
+            11364,
+            11365,
+            11366,
+            11367,
+            11368,
+            11369,
+            11370,
+            11371,
+            11372,
+            11373,
+            11374,
+            11375,
+            11376,
+            11377,
+            11378,
+            11379,
+            11380,
+            11381,
+            11382,
+            11383,
+            11384,
+            11385
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            9,
+            17,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11388,
+          "targets": [
+            11390,
+            11391,
+            11392,
+            11393,
+            11394,
+            11395,
+            11396,
+            11397,
+            11398,
+            11399,
+            11400,
+            11401,
+            11402,
+            11403,
+            11404,
+            11405,
+            11406,
+            11407,
+            11408,
+            11409,
+            11410,
+            11411
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            8,
+            20,
+            36,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11414,
+          "targets": [
+            11416,
+            11417,
+            11418,
+            11419,
+            11420,
+            11421,
+            11422,
+            11423,
+            11424,
+            11425,
+            11426,
+            11427,
+            11428,
+            11429,
+            11430,
+            11431,
+            11432,
+            11433,
+            11434,
+            11435,
+            11436,
+            11437
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            8,
+            18,
+            32,
+            66,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11440,
+          "targets": [
+            11442,
+            11443,
+            11444,
+            11445,
+            11446,
+            11447,
+            11448,
+            11449,
+            11450,
+            11451,
+            11452,
+            11453,
+            11454,
+            11455,
+            11456,
+            11457,
+            11458,
+            11459,
+            11460,
+            11461,
+            11462,
+            11463
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            9,
+            17,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11466,
+          "targets": [
+            11468,
+            11469,
+            11470,
+            11471,
+            11472,
+            11473,
+            11474,
+            11475,
+            11476,
+            11477,
+            11478,
+            11479,
+            11480,
+            11481,
+            11482,
+            11483,
+            11484,
+            11485,
+            11486,
+            11487,
+            11488,
+            11489
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            8,
+            16,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11492,
+          "targets": [
+            11494,
+            11495,
+            11496,
+            11497,
+            11498,
+            11499,
+            11500,
+            11501,
+            11502,
+            11503,
+            11504,
+            11505,
+            11506,
+            11507,
+            11508,
+            11509,
+            11510,
+            11511,
+            11512,
+            11513,
+            11514,
+            11515
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            12,
+            16,
+            32,
+            68,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        }
+      ]
+    },
+    "orientations": 2,
+    "total_blocks": 16,
+    "new_scope": "Arbitrary exact Clifford transports between canonical common-chart contacts, and typed-copy branching trees or their dual gathers. Persistent contact intervals and the scalar demand stay fixed.",
+    "excluded": "Changed cross-frame contact ABI, changed L paths/warps/coefficients, new observations or combinations of independent payloads outside the typed tree, other source words.",
+    "claim_type": "Written general lower-bound proof plus exact source-incidence checks, not an exhaustive circuit or proof-kernel verification."
+  },
+  "claims": "Constructive all-width block identity under retained Gaussian/owned-erasure contracts; written sharp bound for typed-copy trees with fixed canonical contact caps. Finite exact corroboration, no formal kernel or full supplier admission."
+}
diff --git a/research/gaussian-cache-reuse/SOURCES.json b/research/gaussian-cache-reuse/SOURCES.json
new file mode 100644
index 0000000000..ab223a12ae
--- /dev/null
+++ b/research/gaussian-cache-reuse/SOURCES.json
@@ -0,0 +1,134 @@
+{
+  "schema_version": 1,
+  "base_commit": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+  "files": [
+    {
+      "path": "research/fresh-helper-boundary/CHANGES.json",
+      "usage": "input",
+      "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624",
+      "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9"
+    },
+    {
+      "path": "research/fresh-helper-boundary/native.py",
+      "usage": "input",
+      "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29",
+      "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154"
+    },
+    {
+      "path": "research/higher-moment-strictification/verify.py",
+      "usage": "input",
+      "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326",
+      "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699"
+    },
+    {
+      "path": "research/joint-helper-lattice/PATCH.json",
+      "usage": "input",
+      "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727",
+      "git_blob": "51304a6601061ed4e698f910b09135ef109555e3"
+    },
+    {
+      "path": "research/joint-helper-lattice/RESULT.json",
+      "usage": "input",
+      "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21",
+      "git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596"
+    },
+    {
+      "path": "research/joint-helper-lattice/native_joint.py",
+      "usage": "input",
+      "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46",
+      "git_blob": "0315f80e2fdef5e0eef13e3e9b8f72066238164d"
+    },
+    {
+      "path": "research/kappa-rebuild/architecture/mixed_target_probe.py",
+      "usage": "input",
+      "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a",
+      "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e"
+    },
+    {
+      "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz",
+      "usage": "input",
+      "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61",
+      "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784"
+    },
+    {
+      "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz",
+      "usage": "input",
+      "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39",
+      "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c"
+    },
+    {
+      "path": "research/missing-join-frame/PATCH.json",
+      "usage": "input",
+      "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e",
+      "git_blob": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101"
+    },
+    {
+      "path": "research/owned-centre-wire-floor/verify.py",
+      "usage": "input",
+      "sha256": "46e4e242cc336adea56138117404c9b9e499747f7e8181d93e59608a4308026d",
+      "git_blob": "49053e0d6785c26e22c2e02db9d6699aa323a487"
+    },
+    {
+      "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py",
+      "usage": "input",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962",
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375",
+      "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395"
+    },
+    {
+      "path": "research/owned-centre-wire-floor/PROOF.md",
+      "usage": "provenance",
+      "sha256": "4fddcb9d3595870dd6ba9a0819e19ba50d9748b3cd643b978f43aef8750dcaf5",
+      "git_blob": "e6033ac5ddedc4152c2553499021b262f81f75bd"
+    },
+    {
+      "path": "research/owned-centre-wire-floor/README.md",
+      "usage": "provenance",
+      "sha256": "f2fdd6c91d98b692dac91e7a6cd6c8f09094cd2259ed3737ec429b147499c0a3",
+      "git_blob": "ffd10d3c4314d3bdc80aad56d606b73e1bb4d820"
+    },
+    {
+      "path": "research/coded-active-query-bound/README.md",
+      "usage": "provenance",
+      "sha256": "95269b047c19069caeb11edd36a485a0a86275b329aa44da90c8c08403e09178",
+      "git_blob": "f8858cea6b9ff5018ac3eee71bebcde9696e595d"
+    },
+    {
+      "path": "research/two-stage-coded-terminal/README.md",
+      "usage": "provenance",
+      "sha256": "1547a1b5fbb4b919fa90c6b2c3e476e51e52ca8f99c39a5f6a268757eced1365",
+      "git_blob": "86e7af1c02878abd03e2287fa6c87f94d3371ef1"
+    },
+    {
+      "path": "research/coded-compiler-closure/README.md",
+      "usage": "provenance",
+      "sha256": "3ee6da00bdee9f1607e9725f0b9853355c7f3c60b701bae479e86fccc602a7a1",
+      "git_blob": "8f14ae9c3a4d01097375be28ae3c7886f3eb44d5"
+    },
+    {
+      "path": "research/copied-reversed/README.md",
+      "usage": "provenance",
+      "sha256": "d23336ad86ffeb10755088ff9aaf8dada3791a6399c2891a07cb34436870f5f5",
+      "git_blob": "aaf71dc7fe72a936f64c6dfc75e8bee99c1ec472"
+    },
+    {
+      "path": "research/coded-active-feedback/README.md",
+      "usage": "provenance",
+      "pin": "head:ff3cc58e370d0f678e529246f8c73e8094e18fcf:research/coded-active-feedback/README.md",
+      "sha256": "a5db3dc44c87f5469d2eee6251010862dca49e92bf418297b8e3d92e813daa7b",
+      "git_blob": "bdd22ccce3d96bb1fa7c3e6f40862df54609dec1"
+    }
+  ],
+  "source_credit": "Matarener, Dugongue, Cinna Davis, zxv, Jacob Alan Sussman and the full retained native/Clifford/compiler lineage. New work with substantial OpenAI Codex assistance."
+}
diff --git a/research/gaussian-cache-reuse/TASK.json b/research/gaussian-cache-reuse/TASK.json
new file mode 100644
index 0000000000..3ea54ac66a
--- /dev/null
+++ b/research/gaussian-cache-reuse/TASK.json
@@ -0,0 +1,113 @@
+{
+  "schema_version": 1,
+  "task_id": "centre-path-sharing",
+  "priority_revision": 7,
+  "base_commit": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+  "original_card": {
+    "id": "centre-path-sharing",
+    "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.",
+      "Prove a lower bound on copied information per call for the selected decoder contract."
+    ],
+    "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).",
+    "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.",
+    "allowed_variations": [
+      "One sharing pattern across a fixed number of calls.",
+      "One reduced copied-total contract for the existing decoder.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Removing copies without a replacement contract for the decoder's copied totals.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "overlap_terms": [
+      "centre path",
+      "copied totals",
+      "private temporary",
+      "shared centre",
+      "batching"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Explicit user assignment: turn geometric laws into useful research findings. Supply an exact exponent-aware owned-cache sharing primitive, and extend the selected fixed-common-contact center bound to arbitrary Clifford paths and typed-copy trees.",
+  "scope_change_reason": "The historical card requests cross-call center savings and its historical packing screen. This package installs no supplier and uses the refreshed selected source. It supplies a local reusable contract and closes the predecessor non-nested-center gap instead; no old packing ceiling or complete card acceptance is asserted.",
+  "bottleneck_link": "Physical row/caller binding and complete repair costs distinguish usable sharing from geometric rank savings. The sharp selected-center bound prevents another transport-only scan under unchanged caps; changed split contacts or paid-history roots need separate contracts.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop at exact primitive and dual checks, complete module ownership/pass counts, outward moment signs and all16 source-bound center blocks. No duplicate active native synthesis campaign or new supplier-admission claim.",
+  "outcome": "partial",
+  "evidence": "PROOF.md, frozen PLAN.json and geometry.py hash, RESULT.json reproduced by normal and optimized registered verify.py commands. README links the three bounded next questions.",
+  "author": "Prepared for the repository user with OpenAI Codex research assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in analysis, code and writing; exact finite checks and written proofs; no independent human or proof-kernel review.",
+  "open_questions": [
+    {
+      "question": "Can a required split-contact word share one transformed snapshot across two or more cross-frame ADDs with a winning complete bill?",
+      "why_it_matters": "The exact primitive removes duplicated rank work only when the same operator row is required; this changes the per-ADD ownership premise already explored in Discussion 5125.",
+      "first_step": "In the current claimed split-contact source, symbolically track one source row through its first two cross-frame reads. Freeze their frames, candidate cache tree, write interval and all incremental costs, then compare and lower exactly. Coordinate with the existing claim before expanding the campaign.",
+      "blocked_by": "An actual repeated-row witness and source-bound native/precision/tape invoice; one extra H1 already loses the toy gain."
+    },
+    {
+      "question": "Can the existing paid-history continuation supply an observation with the required exact row relation and unchanged return?",
+      "why_it_matters": "An already-paid observation changes the cache root and can reduce marginal work without pretending a new independent Gaussian output was supplied.",
+      "first_step": "Use the source helper prefix already claimed in Discussion 4930; identify the saved expression, later required expression and lifetime. Prove proportionality as operator rows before applying the two-H1 observation variant.",
+      "blocked_by": "Caller-bound expression equality, return/cleanup and complete storage/precision costs. The local variant cannot establish these."
+    },
+    {
+      "question": "Can a changed helper boundary or independent source/destination contact reduce the selected block joint-intersection floor?",
+      "why_it_matters": "Arbitrary owned transport and typed-copy branching alone cannot improve the fixed-cap center charge; a changed cap or payload is needed to escape this scoped bound.",
+      "first_step": "For one changed block, derive new interval or replacement constraints and exact terminal charts. Compute its new joint intersection loss, then price a completed candidate under that new contract.",
+      "blocked_by": "Valid replacement constraints after graph/contact changes; the old Low/Up propagation is not automatically applicable."
+    }
+  ],
+  "entry_checkpoint": {
+    "canonical_main": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+    "selected_conditional_kappa": "0.00302015",
+    "selected_binding_command": [
+      "python3",
+      "-B",
+      "scripts/research_selected_baseline.py"
+    ],
+    "task_assignment": "Explicit user geometric/predictive research assignment; no task-picker reroll.",
+    "live_overlap_date": "2026-10-23",
+    "second_overlap_coverage": {
+      "pr_records": 347,
+      "discussion_records": 4456,
+      "local_notes": 6999
+    },
+    "overlap_limits": "Bounded cached text search plus selected live discussion and open-PR reads, not exhaustive diffs/comments/unpublished work. Existing claims advisory. No external post authorized or made.",
+    "relevant_active_context": [
+      "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125",
+      "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930",
+      "https://github.com/CrocSwap/integer-mult-bounds/pull/5200"
+    ],
+    "scope_separation": "Single per-ADD cross-frame lowering is prior work. Paid-history native closure is already claimed. This package supplies a shared-cache module and fixed-cap theorem, not a duplicate construction campaign."
+  },
+  "final_upstream_checkpoint": {
+    "canonical_main": "ff3cc58e370d0f678e529246f8c73e8094e18fcf",
+    "guidance_catalog_and_selection_changed": false,
+    "existing_declared_source_pins_changed": false,
+    "new_context_read": [
+      "research/coded-active-feedback/README.md",
+      "research/two-axis-owned-contacts/README.md",
+      "research/owned-kernel-weak-duality/README.md"
+    ],
+    "replay_runner_change": "New POSIX Git-blob descendant cleanup; no mathematical semantics change. Recheck package with the refreshed runner after integrating upstream."
+  }
+}
diff --git a/research/gaussian-cache-reuse/VALIDATION.md b/research/gaussian-cache-reuse/VALIDATION.md
new file mode 100644
index 0000000000..af0ee9c6d0
--- /dev/null
+++ b/research/gaussian-cache-reuse/VALIDATION.md
@@ -0,0 +1,63 @@
+# Local validation
+
+Checked on 2026-10-23 on Darwin arm64 with CPython 3.12.14, standard library
+only. The bundled interpreter was
+`/Users/temp/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3`.
+No new dependency installation was required.
+
+## Commands and outcomes
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse
+python3 -B scripts/research_selected_baseline.py
+```
+
+The metadata/source-pin check passed. The registered replay passed both
+`-I -W error -B verify.py` and `-I -O -W error -B verify.py`, each in its
+launcher-supplied private bytecode-cache namespace. They reproduced all saved
+mathematical fields read-only and ended with
+`PASS_REGISTERED_RESEARCH_PACKAGE research/gaussian-cache-reuse outcome=partial`.
+Explicit guards and all-column comparisons remain active under optimization.
+Result comparison uses the JSON representation, including string rank keys.
+
+Coverage: 256 exact canonical frame pairs including 140 non-nested pairs;
+40 independent input columns in each main orientation and in the supplied
+observation module; eight correlated observation fixtures; wrong phase,
+wrong raw-dual orientation and stale-snapshot controls; restored/proportional
+row controls; all 15 two-qubit Lagrangians and 6,750 paths/trees; all 16
+selected center block-orientations with 22 targets each; complete local paid
+profile reconstruction; outward rational moment signs at four exponents
+and a losing half-exponent control.
+
+The selected-baseline command passed source/metadata orientation only. It is
+not the full selected replay. No new selected supplier was installed, so
+native, Lean, Docker, full compiler/precision/tape and multiplication-theorem
+replays were not run. The all-width identities and lower bound are written
+proofs, not kernel-checked theorems or an independently reviewed admission.
+
+## Frozen evidence
+
+The plan was frozen at `2026-10-23T13:12:01.622494+00:00` before the literal
+construction/checker. Its prediction is a module moment saving, not a new
+kappa. The observation variant and final proof are subsequent derivations.
+
+| File | SHA256 |
+| --- | --- |
+| `PLAN.json` | `9d914483465b5da9952a8c2ad3c1017ad231ffa6b1c2681eb846d4b98b6fd649` |
+| `geometry.py` | `20c217d44893d2cc3b517af826936fc8a4c58f498f5bf76b833e5599a25d9084` |
+| `RESULT.json` | `127aaacd8c24043129f224f56f14f436826c218091c82bde647ef9f46fe9c3c5` |
+
+## Upstream checkpoint and scope
+
+The investigation started at canonical main
+`ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c` and refreshed to
+`ff3cc58e370d0f678e529246f8c73e8094e18fcf`. Selection, catalogue,
+family guidance and every pre-existing declared source pin were unchanged.
+Upstream was merged without modifying frozen evidence, and the package was
+replayed with its updated Git-reader cleanup. The newly archived
+active-feedback README is a separately pinned provenance source.
+
+The overlap search and relevant live claims are recorded in TASK.json.
+No external post, PR, selected-frontier update or maintainer queue action was
+performed. This package is local author-checked evidence.
diff --git a/research/gaussian-cache-reuse/VERIFY.json b/research/gaussian-cache-reuse/VERIFY.json
new file mode 100644
index 0000000000..d457be3f60
--- /dev/null
+++ b/research/gaussian-cache-reuse/VERIFY.json
@@ -0,0 +1,47 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/fresh-helper-boundary/CHANGES.json",
+    "research/fresh-helper-boundary/native.py",
+    "research/higher-moment-strictification/verify.py",
+    "research/joint-helper-lattice/PATCH.json",
+    "research/joint-helper-lattice/RESULT.json",
+    "research/joint-helper-lattice/native_joint.py",
+    "research/kappa-rebuild/architecture/mixed_target_probe.py",
+    "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz",
+    "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz",
+    "research/missing-join-frame/PATCH.json",
+    "research/owned-centre-wire-floor/verify.py",
+    "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Authenticate live sources and frozen geometry; exact all-column primitive/dual/observation, 256 frame pairs with absolute phases, stale and incorrect orientation controls, 6750 Lagrangian tree/path checks, all16 reconstructed selected center blocks and outward rational price signs; reproduce RESULT.json read-only."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Repeat all explicit identity, source, geometry and price checks with assertions disabled; reproduce every mathematical field read-only. Retained Clifford internal assertions are supplemented by explicit all-column comparisons."
+    }
+  ]
+}
diff --git a/research/gaussian-cache-reuse/center.py b/research/gaussian-cache-reuse/center.py
new file mode 100644
index 0000000000..08883af45d
--- /dev/null
+++ b/research/gaussian-cache-reuse/center.py
@@ -0,0 +1,58 @@
+"""Source-bound extension of Matarener's owned-center intersection bound.
+
+Only the original geometry helpers are loaded; its root computation is not
+executed. New conclusion allows arbitrary Clifford path intermediates and
+typed-copy trees under the unchanged canonical contact caps.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from collections import Counter
+from pathlib import Path
+from hashlib import sha256
+import ast
+import importlib.util
+import sys
+from geometry import need,span,dim,canonical_chart
+
+
+def run(root):
+    path=root/'research/owned-centre-wire-floor/verify.py'
+    names={'points','dim','join','c_contact','l_roles','blocks','paid_profile','propagate'}
+    parsed=ast.parse(path.read_text());functions=[x for x in parsed.body if isinstance(x,ast.FunctionDef) and x.name in names]
+    need({x.name for x in functions}==names,'Exact predecessor helper inventory')
+    ctx={'Counter':Counter,'need':need,'ALL':frozenset(range(512))}
+    exec(compile(ast.Module(body=functions,type_ignores=[]),str(path),'exec'),ctx)
+    sys.path.insert(0,str(root/'research/joint-helper-lattice'))
+    import native_joint as J
+    c,programs,_,_,_=J.construct();spaces=[span(b) for b in c['frames']]
+    records={};expected=Counter({1:2237,2:388,3:494,4:147,5:36,8:8})
+    for direction,program in programs.items():
+        need(ctx['paid_profile'](c,program,spaces)==expected,'Reconstructed complete selected local bill')
+        low,up=ctx['propagate'](c,program,spaces)
+        need(all(low[i]<=up[i] for i in low),'Every fixed-word scalar contact interval')
+        rows=[]
+        for block in ctx['blocks'](program):
+            need(block['src'] is not None and len(block['t'])==22,'One source and 22 target contacts')
+            a=low[block['src']];common=a
+            for t in block['t']:common &= up[t]
+            need(dim(a)==8 and dim(common)==0,'Source-bound eight-rank intersection loss')
+            # At the actual current contact charts, Lagrangian intersection
+            # gives the same sharp floor, with arbitrary intermediate charts.
+            actual=canonical_chart(spaces[program[block['src']][2]],9)
+            for t in block['t']:actual &= canonical_chart(spaces[program[t][2]],9)
+            need(9-dim(actual)==8,'Actual Clifford-chart intersection attains rank-eight lower bound')
+            rows.append({'source_event':block['src'],'targets':block['t'],
+                         'source_lower_basis':list_basis(a),
+                         'source_lower_dimension':8,'source_and_target_caps_intersection_dimension':0,
+                         'rank_mass_lower_bound':8,'moment_lower_bound':'8^s',
+                         'baseline_paid_job':8})
+        need(len(rows)==8,'All eight blocks per orientation')
+        records[direction]=rows
+    return {'blocks':records,'orientations':2,'total_blocks':16,
+            'new_scope':'Arbitrary exact Clifford transports between canonical common-chart contacts, and typed-copy branching trees or their dual gathers. Persistent contact intervals and the scalar demand stay fixed.',
+            'excluded':'Changed cross-frame contact ABI, changed L paths/warps/coefficients, new observations or combinations of independent payloads outside the typed tree, other source words.',
+            'claim_type':'Written general lower-bound proof plus exact source-incidence checks, not an exhaustive circuit or proof-kernel verification.'}
+
+
+def list_basis(s):
+    from geometry import basis
+    return basis(s)
diff --git a/research/gaussian-cache-reuse/geometry.py b/research/gaussian-cache-reuse/geometry.py
new file mode 100644
index 0000000000..600e4350c2
--- /dev/null
+++ b/research/gaussian-cache-reuse/geometry.py
@@ -0,0 +1,128 @@
+"""Finite binary frame geometry and rooted cache-tree certificates.
+
+Metric/Clifford principles are classical. Retain Dugongue's chart grammar,
+Matarener's owned-center intersection proof, and the local geometry lineage.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from collections import Counter
+
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def span(basis):
+    s={0}
+    for x in basis:
+        s |= {v^x for v in tuple(s)}
+    return frozenset(s)
+
+
+def dim(s):
+    need(len(s)>0 and len(s)&(len(s)-1)==0,'binary subspace cardinality')
+    return len(s).bit_length()-1
+
+
+def distance(a,b):
+    return dim(a)+dim(b)-2*dim(a&b)
+
+
+def basis(s):
+    rows={}
+    for v in sorted(s):
+        for p in sorted(rows,reverse=True):
+            if v>>p&1:
+                v^=rows[p]
+        if v:
+            rows[v.bit_length()-1]=v
+    return list(rows.values())
+
+
+def subspaces(n):
+    seen={frozenset({0})}; todo=list(seen)
+    while todo:
+        s=todo.pop()
+        for v in set(range(1<<n))-s:
+            t=frozenset(s|{x^v for x in s})
+            if t not in seen:
+                seen.add(t);todo.append(t)
+    return sorted(seen,key=lambda s:(len(s),sorted(s)))
+
+
+def gf2_rank(rows):
+    basis_={}
+    for x in rows:
+        while x:
+            p=x.bit_length()-1
+            if p not in basis_:
+                basis_[p]=x;break
+            x^=basis_[p]
+    return len(basis_)
+
+
+def canonical_chart(u,n):
+    """Inverse-image Lagrangian L_U={(x,x+z):x in U,z in U-perp}."""
+    perp=[z for z in range(1<<n) if all((x&z).bit_count()%2==0 for x in u)]
+    return span([x|((x^z)<<n) for x in u for z in perp])
+
+
+def lagrangians(n):
+    """All isotropic n-spaces, used only in the bounded n<=2 control."""
+    out=[]
+    for s in subspaces(2*n):
+        if dim(s)!=n:
+            continue
+        b=basis(s); mask=(1<<n)-1
+        if all((((a&mask)&(v>>n)).bit_count()+((v&mask)&(a>>n)).bit_count())%2==0
+               for a in b for v in b):
+            out.append(s)
+    return out
+
+
+def tree_bound(charts,parents):
+    """Exact intersection-loss certificate for any equal-dimensional charts."""
+    need(len(charts)==len(parents)>0 and parents[0] is None,'rooted tree')
+    n=dim(charts[0]); common=charts[0]; mass=0; steps=[]
+    for i in range(1,len(charts)):
+        p=parents[i]
+        need(type(p) is int and 0<=p<i,'parent precedes child')
+        need(dim(charts[i])==n,'equal-dimensional Lagrangian charts')
+        edge=n-dim(charts[p]&charts[i]);drop=dim(common)-dim(common&charts[i])
+        need(drop<=edge,'intersection loss fits actual edge grade')
+        common &= charts[i]; mass+=edge
+        steps.append({'node':i,'parent':p,'grade':edge,'intersection_loss':drop})
+    need(mass>=n-dim(common),'tree rank-mass floor')
+    return {'edge_rank_mass':mass,'intersection_floor':n-dim(common),'steps':steps}
+
+
+def fanout_program(n=3):
+    """Two owned fields; original target updates remain in their given order."""
+    z=[];line=[1];ab=[1,2];ac=[1,4]
+    return [
+        ['CLEAR','Z'],['CLEAR','W'],
+        ['COPY','Z','X'],['MOVE','Z',z,line],
+        ['COPY','W','Z'],['MOVE','W',line,ab],['ADD','Y1','W',1],['CLEAR','W'],
+        ['COPY','W','Z'],['MOVE','W',line,ac],['ADD','Y2','W',1],['CLEAR','W'],
+        ['CLEAR','Z']]
+
+
+def dual_program():
+    """Inverse-transpose main endpoint; reversed gather, same three grades."""
+    z=[];line=[1];ab=[1,2];ac=[1,4]
+    return [
+        ['CLEAR','Z'],['CLEAR','W'],
+        ['COPY','W','Y1'],['DUAL_MOVE','W',ab,line],['ADD','Z','W',1],['CLEAR','W'],
+        ['COPY','W','Y2'],['DUAL_MOVE','W',ac,line],['ADD','Z','W',1],['CLEAR','W'],
+        ['DUAL_MOVE','Z',line,z],['ADD','X','Z',-1],['CLEAR','Z']]
+
+
+def tariffs(program):
+    paid=Counter();ordinary=Counter()
+    for e in program:
+        if e[0] in ('MOVE','DUAL_MOVE'):
+            r=distance(span(e[2]),span(e[3]))
+            if r:paid[r]+=1
+        else:ordinary[e[0]]+=1
+    return {'paid':dict(sorted(paid.items())),'ordinary_field_passes':dict(sorted(ordinary.items())),
+            'owned_fields':2,'new_productive_owners':0}
diff --git a/research/gaussian-cache-reuse/primitive.py b/research/gaussian-cache-reuse/primitive.py
new file mode 100644
index 0000000000..38e95b750b
--- /dev/null
+++ b/research/gaussian-cache-reuse/primitive.py
@@ -0,0 +1,155 @@
+"""Literal owned-cache primitives with exact dyadic-complex column checks.
+
+Classical copy/transport sharing; repository Clifford implementation retained
+unchanged and authenticated by the caller. Apache-2.0; Codex assistance.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+from functools import lru_cache
+from geometry import need, distance, span, fanout_program, dual_program, tariffs
+
+ZERO=(Q(0),Q(0));ONE=(Q(1),Q(0))
+
+
+def add(a,b):
+    return a[0]+b[0],a[1]+b[1]
+
+
+def mul(a,b):
+    return a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]
+
+
+def conjugate(ce,op):
+    out=ce.ident(op.n)
+    for e in op.circuit:
+        if e[0]=='P':part=ce.perm(op.n,e[1])
+        elif e[0]=='D':part=ce.diag(op.n,e[1],tuple(-a%4 for a in e[2]))
+        elif e[0]=='C':part=ce.cgate(op.n,e[1],-e[2])
+        elif e[0]=='X':part=ce.xgate(op.n,e[1])
+        elif e[0]=='phase':part=ce.Op(op.n,ce.identity(op.n),[('phase',-e[1]%4)])
+        else:raise ValueError('Unrecognized exact circuit primitive')
+        out=out.then(part)
+    return out
+
+
+def matrix(op):
+    cols=[]
+    for j in range(1<<op.n):
+        vec,den=op.zero_state(j)
+        cols.append([(Q(a,1<<den),Q(b,1<<den)) for a,b in vec])
+    return [list(row) for row in zip(*cols)]
+
+
+def mv(a,x):
+    return [sum_pairs(mul(v,w) for v,w in zip(row,x)) for row in a]
+
+
+def sum_pairs(values):
+    z=ZERO
+    for v in values:z=add(z,v)
+    return z
+
+
+def proportion(snapshot,current):
+    """Exact logical operator rows, not owner names or frame labels."""
+    if not snapshot:return Q(0) if not current else None
+    k=next(iter(snapshot));q=current.get(k,Q(0))/snapshot[k]
+    return q if {k:v*q for k,v in snapshot.items() if v*q}==current else None
+
+
+def run(ce,spaces):
+    n=3;frames=[ce.canonical_frame(n,list_basis(s)) for s in spaces]
+    edge_checks=0;non_nested=0
+    for i,a in enumerate(spaces):
+      for j,b in enumerate(spaces):
+        op=frames[i].adjoint().then(frames[j]);recipe,compiled=ce.lower_child(op)
+        need(recipe['rank']==distance(a,b),'Actual Clifford edge grade, including nonnested frames')
+        need(compiled.tab==op.tab and matrix(compiled)==matrix(op),'All-column normal form and absolute phase')
+        edge_checks+=1;non_nested+=int(not(a<=b or b<=a))
+    roles=['X','Y1','Y2','Z','W'];size=1<<n
+    forward=fanout_program();backward=dual_program()
+
+    @lru_cache(None)
+    def transition(kind,a,b):
+        op=ce.canonical_frame(n,list(a)).adjoint().then(ce.canonical_frame(n,list(b)))
+        return matrix(conjugate(ce,op) if kind=='DUAL_MOVE' else op)
+
+    def execute(program,column,wrong_phase=False,changed_source=False,supplied=None):
+        state={r:[ZERO]*size for r in roles} if supplied is None else {r:v[:] for r,v in supplied.items()}
+        if supplied is None:state[roles[column//size]][column%size]=ONE
+        mutated=False
+        for e in program:
+            kind,r=e[:2]
+            if kind=='CLEAR':state[r]=[ZERO]*size
+            elif kind=='COPY':state[r]=state[e[2]][:]
+            elif kind=='ADD':
+                state[r]=[add(x,(e[3]*y[0],e[3]*y[1])) for x,y in zip(state[r],state[e[2]])]
+                if changed_source and r=='Y1':
+                    state['X']=[(2*x,2*y) for x,y in state['X']]
+            else:
+                a,b=tuple(e[2]),tuple(e[3])
+                if wrong_phase and not mutated:
+                    kind='DUAL_MOVE' if kind=='MOVE' else 'MOVE';mutated=True
+                state[r]=mv(transition(kind,a,b),state[r])
+        return state
+
+    a1=matrix(ce.canonical_frame(n,[1,2]));a2=matrix(ce.canonical_frame(n,[1,4]))
+    transpose=lambda a:[list(row) for row in zip(*a)]
+    def expected(column,back=False,source_changed=False):
+        initial={r:[ZERO]*size for r in roles};initial[roles[column//size]][column%size]=ONE
+        out={r:initial[r][:] for r in roles}
+        out['Z']=out['W']=[ZERO]*size
+        if back:
+            delta1=mv(transpose(a1),initial['Y1']);delta2=mv(transpose(a2),initial['Y2'])
+            out['X']=[(x[0]-y[0]-z[0],x[1]-y[1]-z[1]) for x,y,z in zip(initial['X'],delta1,delta2)]
+        else:
+            out['Y1']=[add(x,y) for x,y in zip(initial['Y1'],mv(a1,initial['X']))]
+            source=[(2*x,2*y) for x,y in initial['X']] if source_changed else initial['X']
+            if source_changed:out['X']=source
+            out['Y2']=[add(x,y) for x,y in zip(initial['Y2'],mv(a2,source))]
+        return out
+    for column in range(len(roles)*size):
+        need(execute(forward,column)==expected(column),'Forward: all arbitrary persistent and owned entry columns')
+        need(execute(backward,column)==expected(column,True),'Raw inverse transpose: all arbitrary columns')
+    need(any(execute(forward,j,True)!=expected(j) for j in range(size)),'Wrong forward phase rejected')
+    need(any(execute(backward,j,True)!=expected(j,True) for j in range(size,3*size)),'Wrong raw-dual orientation rejected')
+    need(any(execute(forward,j,changed_source=True)!=expected(j,source_changed=True) for j in range(size)),
+         'Reusing a stale snapshot after a source change is rejected')
+    row={('X',()):Q(1)};changed={('X',()):Q(1),('Y',()):Q(1)}
+    need(proportion(row,changed) is None,'Changed source expression invalidates cache')
+    restored=dict(changed);restored.pop(('Y',()))
+    need(proportion(row,restored)==1,'A restored source is safe despite intervening writes')
+    need(proportion(row,{('X',()):Q(3,2)})==Q(3,2),'Specified scalar change can be absorbed in the ADD coefficient')
+    # Derived variant for an actual already-paid observation. Its correlation
+    # with X is an explicit caller precondition, never independent input credit.
+    existing=[['CLEAR','W']]+forward[4:-1]
+    for column in range(len(roles)*size):
+        initial={r:[ZERO]*size for r in roles};initial[roles[column//size]][column%size]=ONE
+        wanted={r:v[:] for r,v in initial.items()};wanted['W']=[ZERO]*size
+        for r,frame in [('Y1',(1,2)),('Y2',(1,4))]:
+            delta=mv(transition('MOVE',(1,),frame),initial['Z'])
+            wanted[r]=[add(x,y) for x,y in zip(initial[r],delta)]
+        need(execute(existing,column)==wanted,'Existing observation: every independent column; cache returned unchanged')
+    line=matrix(ce.canonical_frame(n,[1]))
+    for j in range(size):
+        supplied={r:[ZERO]*size for r in roles};supplied['X'][j]=ONE
+        supplied['Z']=mv(line,supplied['X'])
+        actual=execute(existing,0,supplied=supplied);wanted=expected(j)
+        need(all(actual[r]==wanted[r] for r in ('X','Y1','Y2','W')) and actual['Z']==supplied['Z'],
+             'Caller-proved observation Z=C_line X gives the intended target updates')
+    existing_tariff=tariffs(existing);existing_tariff['owned_fields']=1
+    existing_tariff['borrowed_observation_fields']=1
+    return {'exact_frame_pairs':edge_checks,'non_nested_pairs':non_nested,
+            'address_dimension':3,'addresses_per_field':size,'independent_original_fields':3,
+            'arbitrary_owned_entry_fields_cleared':2,'all_input_columns_per_orientation':len(roles)*size,
+            'forward':tariffs(forward),'raw_inverse_transpose':tariffs(backward),
+            'existing_paid_observation_variant':{'tariff':existing_tariff,'all_input_columns':len(roles)*size,
+                'precondition':'Z=C_line X for the exact required logical snapshot; caller supplies and already pays that observation. Z is returned unchanged. Its creation, retention and eventual cleanup remain caller costs.'},
+            'negative_controls':['wrong forward phase','wrong dual orientation','stale snapshot'],
+            'lifetime_controls':['restored source','specified proportional source'],
+            'primitive_scope':'Exact finite module plus written block/tensor lift; no installed selected-caller improvement.'}
+
+
+def list_basis(s):
+    from geometry import basis
+    return basis(s)
diff --git a/research/gaussian-cache-reuse/verify.py b/research/gaussian-cache-reuse/verify.py
new file mode 100644
index 0000000000..e1c2b0019b
--- /dev/null
+++ b/research/gaussian-cache-reuse/verify.py
@@ -0,0 +1,110 @@
+"""Exact cache construction, geometric bound and source application.
+
+Standard library only. Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from decimal import Decimal as D,localcontext
+from fractions import Fraction as Q
+from hashlib import sha256
+from itertools import product
+from pathlib import Path
+import argparse
+import importlib.util
+import json
+import sys
+
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1]
+sys.path.insert(0,str(HERE))
+import geometry as G
+import primitive as P
+import center
+
+
+def authenticate():
+    manifest=json.loads((HERE/'SOURCES.json').read_text())
+    for row in manifest['files']:
+        if row.get('usage')!='input':
+            continue
+        G.need(sha256((ROOT/row['path']).read_bytes()).hexdigest()==row['sha256'],'Changed source '+row['path'])
+    plan=json.loads((HERE/'PLAN.json').read_text())
+    G.need(sha256((HERE/'geometry.py').read_bytes()).hexdigest()==plan['geometry_sha256'],'Unchanged prospective geometry')
+    return plan
+
+
+def load(path,name):
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec);sys.modules[name]=module;spec.loader.exec_module(module)
+    return module
+
+
+def geometry_checks():
+    ls=G.lagrangians(2);G.need(len(ls)==15,'All two-qubit Lagrangians including noncanonical phase charts')
+    checks=0
+    for a,b,c in product(ls,repeat=3):
+        for parents in ([None,0,0],[None,0,1]):
+            G.tree_bound([a,b,c],parents);checks+=1
+    spaces=G.subspaces(3)
+    G.need(len(spaces)==16,'All canonical three-axis frames')
+    terminals=[G.span([]),G.span([1,2]),G.span([1,4])]
+    choices=[]
+    for f in spaces:
+        ranks=sorted(G.distance(t,f) for t in terminals)
+        choices.append({'meeting_basis':G.basis(f),'edge_grades':ranks})
+    with localcontext() as ctx:
+        ctx.prec=60
+        for s in [D(1)-D('.00302015'),D('.5')]:
+            power=lambda r:D(0) if not r else (D(r).ln()*s).exp()
+            scores=[sum(power(r) for r in x['edge_grades']) for x in choices]
+            G.need(abs(min(scores)-min(D(3),2*power(2)))<D('1e-55'),'Exact-profile three-terminal minimum')
+        transition=(D(3)/2).ln()/D(2).ln()
+    tree=[G.canonical_chart(G.span(b),3) for b in [[],[1],[1,2],[1,4]]]
+    sharp=G.tree_bound(tree,[None,0,1,1])
+    G.need(sharp['edge_rank_mass']==sharp['intersection_floor']==3,'Branching example attains intersection bound')
+    return {'all_two_qubit_lagrangians':len(ls),'arbitrary_chart_path_and_tree_checks':checks,
+            'canonical_three_axis_meetings':choices,'cache_tree_mass':sharp,
+            'transition_s':str(transition),'scope':'General proof is written; these finite checks corroborate its ranks and transcription.'}
+
+
+def price_checks(plan):
+    m=load(ROOT/'research/higher-moment-strictification/verify.py','cache_exact_moments')
+    def margin(targets,paid,c):
+        a=m.moment(targets,1-c);b=m.moment(paid,1-c)
+        return a[0]-b[1],a[1]-b[0]
+    gains={}
+    for c in ['.00302015','.004','.005','.01']:
+        gain=margin({2:2},{1:3},Q(c));debt=margin({2:2},{1:4},Q(c))
+        G.need(gain[0]>0 and debt[1]<0,'Positive reuse gain; one extra H1 destroys it')
+        gains[c]={'saving':[str(v) for v in gain],'after_one_extra_H1':[str(v) for v in debt]}
+    G.need(margin({2:2},{1:3},Q('.5'))[1]<0,'At exponent one-half separate copies beat the three-H1 tree')
+    with localcontext() as ctx:
+        ctx.prec=55
+        predicted=D(plan['predicted_gain_at_selected_exponent'])
+        lo,hi=margin({2:2},{1:3},Q('.00302015'))
+        to_dec=lambda q:D(q.numerator)/q.denominator
+        G.need(to_dec(lo)-D('1e-52')<predicted<to_dec(hi)+D('1e-52'),'Frozen preconstruction gain agrees with exact bounds')
+    return {'baseline_paid':{'2':2},'cache_paid':{'1':3},'productive_owner_delta':0,
+            'outward_moment_gains':gains,'repair_budget':'Strictly less than one extra H1 per module at every tested positive saving.',
+            'selected_installation':False,'new_kappa':None}
+
+
+def run():
+    plan=authenticate()
+    ce=load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py','cache_pinned_clifford')
+    primitive=P.run(ce,G.subspaces(3));print('PASS_EXACT_CACHE_PRIMITIVE',flush=True)
+    geo=geometry_checks();print('PASS_GENERAL_CHART_TREE_CONTROLS',flush=True)
+    source=center.run(ROOT);print('PASS_ALL_16_SELECTED_CENTER_BLOCKS',flush=True)
+    return {'status':'PASS_GAUSSIAN_CACHE_REUSE_AND_SHARP_CENTER_BOUND_NO_NEW_KAPPA',
+            'plan_sha256':sha256((HERE/'PLAN.json').read_bytes()).hexdigest(),
+            'primitive':primitive,'geometry':geo,'price':price_checks(plan),'selected_centers':source,
+            'claims':'Constructive all-width block identity under retained Gaussian/owned-erasure contracts; written sharp bound for typed-copy trees with fixed canonical contact caps. Finite exact corroboration, no formal kernel or full supplier admission.'}
+
+
+if __name__=='__main__':
+    ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');args=ap.parse_args()
+    # JSON object keys are strings. Compare the serialized schema so an exact
+    # integer rank key from the frozen geometry helper is not a false mismatch.
+    result=json.loads(json.dumps(run()))
+    if args.write:
+        (HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n')
+    else:G.need(result==json.loads((HERE/'RESULT.json').read_text()),'Every saved mathematical field reproduced')
+    print(json.dumps({'status':result['status'],'new_kappa':None,'module_gain':json.loads((HERE/'PLAN.json').read_text())['predicted_gain_at_selected_exponent']},sort_keys=True))

From ae7bb4851b0e171bc1b5f6b345f0906a5dbb00a6 Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Fri, 23 Oct 2026 09:41:48 -0400
Subject: [PATCH 2/4] Record isolated cache replay and clarify forecast scope

---
 research/gaussian-cache-reuse/PROOF.md      |  4 ++-
 research/gaussian-cache-reuse/README.md     | 18 +++++++++--
 research/gaussian-cache-reuse/VALIDATION.md | 33 +++++++++++++++++++--
 3 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/research/gaussian-cache-reuse/PROOF.md b/research/gaussian-cache-reuse/PROOF.md
index a38015d2cb..f6eb9fbc48 100644
--- a/research/gaussian-cache-reuse/PROOF.md
+++ b/research/gaussian-cache-reuse/PROOF.md
@@ -117,7 +117,9 @@ attain them. Ordinary monomial costs are outside this rank-only optimum.
 At \(s=1-0.00302015\), the frozen gain is
 \(2\,2^s-3=0.9916351247756209043\ldots\).
 The exact rational interval engine certifies its positive sign and the
-negative sign after charging one more H1. At \(s=1/2\) the separate
+negative sign after charging one more H1. In fact the repaired saving is
+\(4(2^{-\kappa}-1)<0\) for every \(\kappa>0\).
+At \(s=1/2\) the separate
 transfers win. This sign reversal is a useful control on treating rank mass
 as a sufficient cost statistic.
 
diff --git a/research/gaussian-cache-reuse/README.md b/research/gaussian-cache-reuse/README.md
index 771bd2994a..e5a7228abb 100644
--- a/research/gaussian-cache-reuse/README.md
+++ b/research/gaussian-cache-reuse/README.md
@@ -2,8 +2,9 @@
 
 Several required reads of the same logical snapshot can share a transformed
 owned copy. A small exact example replaces **two rank-2 Gaussian jobs by three
-rank-1 jobs**, with no new productive-output credit. Its predicted moment saving
-was frozen before construction and then verified. The same geometry extends
+rank-1 jobs**, with no new productive-output credit. The tree, word skeleton
+and moment prediction were frozen before exact Clifford realization and
+all-column verification. The same geometry extends
 Matarener's selected-center lower bound to non-nested Clifford transports and
 typed-copy trees: **each of the 16 block-orientations still costs at least one
 rank-8 job** under the original common-contact constraints.
@@ -36,6 +37,15 @@ repository's owned-copy and Gaussian-job contracts.
 The simplest useful example has source frame 0 and two target planes
 \(\langle1,2\rangle,\langle1,4\rangle\). Going separately costs \(2\,2^s\).
 Sharing their line \(\langle1\rangle\) costs three rank-1 edges, hence 3.
+The shared paid-transfer graph is:
+
+```mermaid
+flowchart LR
+  S["Source frame 0"] -->|"rank 1"| M["Retained line cache"]
+  M -->|"rank 1"| A["First target plane"]
+  M -->|"rank 1"| B["Second target plane"]
+```
+
 The exact optimum over typed cache trees, even with arbitrary intermediate
 Clifford charts, is
 
@@ -49,7 +59,9 @@ At the selected exponent the shared tree saves
 `0.9916351247756209043` moment units. **One additional rank-1 repair job
 exhausts that saving.** [PLAN.json](PLAN.json) fixes the prediction and geometry
 hash; [RESULT.json](RESULT.json) contains outward rational sign certificates.
-This is a prospective module-cost prediction, not a held-out κ improvement.
+This tests a predeclared module-cost prediction. The word skeleton was already
+specified at the freeze; it is not a blind structural discovery or a held-out
+κ improvement.
 
 ## Exact ownership and lifetime contract
 
diff --git a/research/gaussian-cache-reuse/VALIDATION.md b/research/gaussian-cache-reuse/VALIDATION.md
index af0ee9c6d0..e71999d9ef 100644
--- a/research/gaussian-cache-reuse/VALIDATION.md
+++ b/research/gaussian-cache-reuse/VALIDATION.md
@@ -38,9 +38,11 @@ proofs, not kernel-checked theorems or an independently reviewed admission.
 
 ## Frozen evidence
 
-The plan was frozen at `2026-10-23T13:12:01.622494+00:00` before the literal
-construction/checker. Its prediction is a module moment saving, not a new
-kappa. The observation variant and final proof are subsequent derivations.
+The plan was frozen at `2026-10-23T13:12:01.622494+00:00` before exact Clifford
+realization and the all-column checker. The frozen geometry file already
+contains the word skeleton. Its prediction is a module moment saving, not
+a blind design forecast or a new kappa. The observation variant and final
+proof are subsequent derivations.
 
 | File | SHA256 |
 | --- | --- |
@@ -61,3 +63,28 @@ active-feedback README is a separately pinned provenance source.
 The overlap search and relevant live claims are recorded in TASK.json.
 No external post, PR, selected-frontier update or maintainer queue action was
 performed. This package is local author-checked evidence.
+
+## Committed bytes and Git free replay
+
+The byte preflight passed for all 24 package/input files at
+`40eeaa2a363ec8f9bc420b3bb6e337234949b308`:
+
+```sh
+python3 -B scripts/check_research_commit.py --package research/gaussian-cache-reuse
+python3 -B scripts/export_research_package.py export --package research/gaussian-cache-reuse --ref 40eeaa2a363ec8f9bc420b3bb6e337234949b308 --output /tmp/gaussian-cache-reuse-40eeaa2a36.tar
+python3 -B scripts/export_research_package.py check /tmp/gaussian-cache-reuse-40eeaa2a36.tar
+```
+
+The 580 KiB export passed its exact inventory/hash check. It was extracted
+into a fresh temporary directory with no Git checkout and replayed normally
+and with `-O`, using the same Python 3.12 interpreter, `PATH=/nonexistent`,
+`-I -W error -B` and fresh `-X pycache_prefix` directories. Both mathematical
+replays passed and the temporary extracted files were removed. Subsequent
+documentation refinements leave the verifier, plan and result bytes unchanged.
+This is evidence for the declared mathematical replay inputs, not hosted CI.
+
+The additional `--check-source-history` preflight did not pass: this checkout
+is shallow and the tool requires full Git history. It reported
+`source-history check requires full Git history`. No full-history download
+or weaker replacement check was used. The successful byte/export checks do
+not substitute for that separate publication-history requirement.

From 5a40115affefff6a6811996e7c175a4e4ab10a40 Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Fri, 23 Oct 2026 11:27:32 -0400
Subject: [PATCH 3/4] Identify zxv and link contribution-specific research
 credits

---
 research/gaussian-cache-reuse/README.md    | 51 +++++++++++++++++-----
 research/gaussian-cache-reuse/SOURCES.json |  2 +-
 research/gaussian-cache-reuse/TASK.json    |  2 +-
 3 files changed, 41 insertions(+), 14 deletions(-)

diff --git a/research/gaussian-cache-reuse/README.md b/research/gaussian-cache-reuse/README.md
index e5a7228abb..5b4ad7f690 100644
--- a/research/gaussian-cache-reuse/README.md
+++ b/research/gaussian-cache-reuse/README.md
@@ -184,24 +184,51 @@ obligations are not re-established by this module replay.
 
 ## Provenance and credit
 
-Copied-center reuse predates this package; see
-[copied-reversed](../copied-reversed/README.md). Matarener supplies the
-owned-center intersection argument and fixed-word interval engine. Dugongue
-supplies the owned-C retiming contract. Cinna Davis supplies #4470's selected
-word, retaining zxv's native supplier, Jacob Alan Sussman's Clifford work and
-the complete credited source chain. The live split-contact and paid-history
-discussions supply the application context, not mathematical inputs to the
-verifier. Metric geometry, memoization, Steiner trees and subadditivity are
-classical; this package claims their explicit costed application and scoped
-extension here.
+Prepared by zxv with substantial OpenAI Codex assistance. The predecessor
+contributions used here are:
+
+- **zxv:** the native and uniform supplier in
+  [PR #4359](https://github.com/CrocSwap/integer-mult-bounds/pull/4359),
+  logarithmic compiler in
+  [PR #4411](https://github.com/CrocSwap/integer-mult-bounds/pull/4411), and
+  higher-moment strictification and rational interval engine in
+  [PR #4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433).
+- **Matarener:** the owned-center intersection argument and fixed-word
+  interval engine in
+  [PR #5060](https://github.com/CrocSwap/integer-mult-bounds/pull/5060).
+- **Dugongue:** the owned-C retiming contract in
+  [PR #4534](https://github.com/CrocSwap/integer-mult-bounds/pull/4534).
+- **Cinna Davis:** the selected word in
+  [PR #4470](https://github.com/CrocSwap/integer-mult-bounds/pull/4470), building
+  on [PR #4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440),
+  [PR #4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441) and
+  [PR #4447](https://github.com/CrocSwap/integer-mult-bounds/pull/4447).
+  [PR #5220](https://github.com/CrocSwap/integer-mult-bounds/pull/5220)
+  supplies the active-feedback application context and coupling warning.
+- **Jacob Alan Sussman:** the mixed-target recursion in
+  [PR #4268](https://github.com/CrocSwap/integer-mult-bounds/pull/4268).
+- **icekylinx:** copied-center reuse in
+  [PR #36](https://github.com/CrocSwap/integer-mult-bounds/pull/36) and the
+  exact Clifford compiler lineage retained from
+  [PR #531](https://github.com/CrocSwap/integer-mult-bounds/pull/531).
+  See also the retained [copied-reversed attribution](../copied-reversed/README.md).
+- **Tekalign:** the source-pinned T74 package in
+  [PR #2768](https://github.com/CrocSwap/integer-mult-bounds/pull/2768), from
+  which the unchanged exact Clifford kernel is loaded. Its retained notices
+  preserve the complete native, phase and compiler contributor chain.
+
+The live split-contact and paid-history discussions supply application context,
+not mathematical inputs to the verifier. Metric geometry, memoization, Steiner
+trees and subadditivity are classical; this package claims their explicit
+costed application and scoped extension here. All retained source notices
+and predecessor attribution remain in force.
 
 Overlap checks on 2026-10-23 covered 347 PR records, 4,456 Discussion records
 and 6,999 local package notes in the second bounded search. They do not cover
 every diff, every comment or unpublished work. Live claims are provisional.
 No external claim or publication was made in this session; this is local
 evidence until shared. Exact canonical source pins are in
-[SOURCES.json](SOURCES.json). Prepared for the repository user with substantial
-OpenAI Codex assistance. Apache-2.0.
+[SOURCES.json](SOURCES.json). Apache-2.0.
 
 The final upstream checkpoint is `ff3cc58e370d0f678e529246f8c73e8094e18fcf`.
 Selection, catalogue, family guidance and every existing declared source pin
diff --git a/research/gaussian-cache-reuse/SOURCES.json b/research/gaussian-cache-reuse/SOURCES.json
index ab223a12ae..3fb706bd41 100644
--- a/research/gaussian-cache-reuse/SOURCES.json
+++ b/research/gaussian-cache-reuse/SOURCES.json
@@ -130,5 +130,5 @@
       "git_blob": "bdd22ccce3d96bb1fa7c3e6f40862df54609dec1"
     }
   ],
-  "source_credit": "Matarener, Dugongue, Cinna Davis, zxv, Jacob Alan Sussman and the full retained native/Clifford/compiler lineage. New work with substantial OpenAI Codex assistance."
+  "source_credit": "zxv, Matarener, Dugongue, Cinna Davis, Jacob Alan Sussman, icekylinx, Tekalign and the full retained native/Clifford/compiler lineage; contribution-specific PR links are in README.md#provenance-and-credit. New work by zxv with substantial OpenAI Codex assistance."
 }
diff --git a/research/gaussian-cache-reuse/TASK.json b/research/gaussian-cache-reuse/TASK.json
index 3ea54ac66a..cfa14d141b 100644
--- a/research/gaussian-cache-reuse/TASK.json
+++ b/research/gaussian-cache-reuse/TASK.json
@@ -54,7 +54,7 @@
   "stop_rule": "Stop at exact primitive and dual checks, complete module ownership/pass counts, outward moment signs and all16 source-bound center blocks. No duplicate active native synthesis campaign or new supplier-admission claim.",
   "outcome": "partial",
   "evidence": "PROOF.md, frozen PLAN.json and geometry.py hash, RESULT.json reproduced by normal and optimized registered verify.py commands. README links the three bounded next questions.",
-  "author": "Prepared for the repository user with OpenAI Codex research assistance",
+  "author": "zxv, with substantial OpenAI Codex research assistance",
   "ai_assistance": "Substantial OpenAI Codex assistance in analysis, code and writing; exact finite checks and written proofs; no independent human or proof-kernel review.",
   "open_questions": [
     {

From 879ba16ce8b55093969f2ddf18a0d862dce03a6d Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Fri, 23 Oct 2026 11:32:58 -0400
Subject: [PATCH 4/4] Prepare focused cache contribution and record publication
 replay

---
 research/gaussian-cache-reuse/README.md     |  4 +--
 research/gaussian-cache-reuse/TASK.json     |  2 +-
 research/gaussian-cache-reuse/VALIDATION.md | 34 +++++++++++++++++++--
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/research/gaussian-cache-reuse/README.md b/research/gaussian-cache-reuse/README.md
index 5b4ad7f690..2c5449434b 100644
--- a/research/gaussian-cache-reuse/README.md
+++ b/research/gaussian-cache-reuse/README.md
@@ -226,8 +226,8 @@ and predecessor attribution remain in force.
 Overlap checks on 2026-10-23 covered 347 PR records, 4,456 Discussion records
 and 6,999 local package notes in the second bounded search. They do not cover
 every diff, every comment or unpublished work. Live claims are provisional.
-No external claim or publication was made in this session; this is local
-evidence until shared. Exact canonical source pins are in
+This contribution publishes author-checked evidence with its remaining
+obligations explicit. Exact canonical source pins are in
 [SOURCES.json](SOURCES.json). Apache-2.0.
 
 The final upstream checkpoint is `ff3cc58e370d0f678e529246f8c73e8094e18fcf`.
diff --git a/research/gaussian-cache-reuse/TASK.json b/research/gaussian-cache-reuse/TASK.json
index cfa14d141b..df3bb06fa4 100644
--- a/research/gaussian-cache-reuse/TASK.json
+++ b/research/gaussian-cache-reuse/TASK.json
@@ -91,7 +91,7 @@
       "discussion_records": 4456,
       "local_notes": 6999
     },
-    "overlap_limits": "Bounded cached text search plus selected live discussion and open-PR reads, not exhaustive diffs/comments/unpublished work. Existing claims advisory. No external post authorized or made.",
+    "overlap_limits": "Bounded cached text search plus selected live discussion and open-PR reads, not exhaustive diffs/comments/unpublished work. Existing claims advisory. The initial investigation was local; zxv subsequently authorized submitting this focused package as a PR.",
     "relevant_active_context": [
       "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125",
       "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930",
diff --git a/research/gaussian-cache-reuse/VALIDATION.md b/research/gaussian-cache-reuse/VALIDATION.md
index e71999d9ef..fb8f851847 100644
--- a/research/gaussian-cache-reuse/VALIDATION.md
+++ b/research/gaussian-cache-reuse/VALIDATION.md
@@ -61,8 +61,9 @@ replayed with its updated Git-reader cleanup. The newly archived
 active-feedback README is a separately pinned provenance source.
 
 The overlap search and relevant live claims are recorded in TASK.json.
-No external post, PR, selected-frontier update or maintainer queue action was
-performed. This package is local author-checked evidence.
+At the initial validation checkpoint no external post or PR had been made.
+zxv subsequently authorized this focused contribution PR. No selected-frontier
+update or maintainer queue action is included.
 
 ## Committed bytes and Git free replay
 
@@ -87,4 +88,31 @@ The additional `--check-source-history` preflight did not pass: this checkout
 is shallow and the tool requires full Git history. It reported
 `source-history check requires full Git history`. No full-history download
 or weaker replacement check was used. The successful byte/export checks do
-not substitute for that separate publication-history requirement.
+not substitute for that separate optional publication-history preflight.
+
+## Focused publication replay
+
+The publication branch starts at canonical main
+`ff3cc58e370d0f678e529246f8c73e8094e18fcf` and contains only this package.
+Earlier exploratory packages stay on the development branch. Frozen PLAN,
+geometry and RESULT bytes are unchanged. PLAN's `base_commit` records that
+local development checkpoint; it is not a replay dependency. The consumed
+source pins are the canonical commits declared in SOURCES.json.
+
+The registered normal and optimized commands above passed again from the
+focused branch. A fresh committed export at its reachable commit
+`5a40115affefff6a6811996e7c175a4e4ab10a40` passed inventory/hash checks and
+both Git-free mathematical replays, using the same isolated Python flags,
+fresh bytecode directories and `PATH=/nonexistent` described above.
+
+For publication, this reachable snapshot replaces the development-only
+`40eeaa2a36` reference in the historical export example:
+
+```sh
+python3 -B scripts/export_research_package.py export --package research/gaussian-cache-reuse --ref 5a40115affefff6a6811996e7c175a4e4ab10a40 --output /tmp/gaussian-cache-reuse-publication-5a40115aff.tar
+python3 -B scripts/export_research_package.py check /tmp/gaussian-cache-reuse-publication-5a40115aff.tar
+```
+
+Publication status and credit refinements after that snapshot change no
+scientific input, verifier, frozen plan or result. Metadata and committed-byte
+checks cover the final publication commit separately.