diff --git a/research/r437-parabolic-copy/.gitattributes b/research/r437-parabolic-copy/.gitattributes
new file mode 100644
index 0000000000..375691090e
--- /dev/null
+++ b/research/r437-parabolic-copy/.gitattributes
@@ -0,0 +1,2 @@
+* -text
+inputs/R437-UPSTREAM-NOTICE.md whitespace=cr-at-eol
diff --git a/research/r437-parabolic-copy/PROOF.md b/research/r437-parabolic-copy/PROOF.md
new file mode 100644
index 0000000000..da8c1c2bd2
--- /dev/null
+++ b/research/r437-parabolic-copy/PROOF.md
@@ -0,0 +1,275 @@
+# Parabolic COPY with batched pivot and graph routing
+
+Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0.
+
+## Result and boundary
+
+For m=64, r=7 and every split rank-seven projector over Z/q^w, the construction
+below replaces PR3950's alternate generic SL64 word by **8,036 ordered scalar
+ADD slots per column and 196 ordinary width-f interchanges**, surrounding the
+same single reversed child of width 7f. PR3950's alternate has 41,832 of each.
+All slots, including zero coefficients, are charged. This is a uniform algebraic
+construction and a **conditional relative caller/cost theorem**; an encoded
+physical compiler has not been implemented. The original R437 good/fallback
+implementation is a different construction and its tariff is not altered.
+
+The change combines the parabolic stabilizer of a projector with small fixed
+permutation networks. It removes unnecessary internal image/kernel basis work
+and shares routing across commuting graph passes and mutually exclusive pivot
+stars. Generic conjugacy, local-ring split projectors and elementary matrices
+are credited predecessor mathematics, not new claims of this package.
+
+Even the reduced positive ordinary term is not absorbable from the pinned B1/B2
+upper tariffs at the R437 target scaling. The optimistic decision is therefore:
+retain this smaller constructive relative bill, then stop supplier expansion
+until a cheaper complete ordinary adapter or a different consumer is supplied.
+This does not lower-bound actual runtime or exclude the original algorithm.
+
+## 1. Domain and a principal chart that always exists
+
+Fix an odd prime q, w>=1, R=Z/q^w, A=q^w, m>=2 and 0<r<m. For the application,
+m=64 and r=7. Let P be a split rank-r projector and g invertible over R, and
+put Q=gPg^-1. Let H=diag(h_i) consist of arbitrary units; h_i may depend on
+physical header and column, but not on body addresses or fresh unused rows.
+The requested two-bank address map, with tail coordinates reflected, is
+
+    D_H(Q)=diag(H,I) [[I-Q,Q],[Q,I-Q]] diag(H^-1,I).
+
+Every Boolean source function is allowed, including arbitrary correlated dirty
+captures. Equal field-header values at distinct physical prefix ordinals remain
+distinct. There is no SOURCE projection or clean-data assumption.
+
+A principal r-by-r minor of Q is a unit. Indeed a split idempotent is similar
+to E=diag(I_r,0), so its characteristic polynomial is t^(m-r)(t-1)^r. Its
+coefficient of t^(m-r) is (-1)^r times both 1 and the sum of all principal
+r-minors. Reducing modulo q, their sum is 1. At least one is nonzero. This
+argument also works when q divides r; trace is not used as a rank certificate.
+
+Choose a sorted subset S=(s_0,...,s_(r-1)) with unit principal minor, so
+ i<=s_i<=m-r+i. One effective deterministic rule is the first unit subset in
+lexicographic order. This fixed-m search can be very expensive: at m=64,r=7
+there are binom(64,7) subsets. It is charged in gamma below, not called free
+or a practical large-instance implementation. No enumeration of GL64 is needed.
+The same S selected modulo q works at every high lift and precision.
+
+## 2. Fixed-support pivot stars
+
+For i=0,...,r-1 and every k in i+1,...,m-r+i, let e_ik=1 if s_i=k and 0
+otherwise. Use three stars, in chronological left-action order:
+
+    all E_(i,k)(e_ik), then all E_(k,i)(-e_ik),
+    then all E_(i,k)(e_ik).
+
+At most one flag is nonzero in this entire i-stage. Consequently this is either
+identity (s_i=i) or the signed swap (x_i,x_s)->(x_s,-x_i). Grouping the triples
+into stars is legal precisely because of that mutually exclusive flag property;
+it would be false with two active candidates. Earlier stages cannot move s_i,
+which is strictly larger than every earlier s_j. The product J therefore moves
+the original S to the first r coordinates and has determinant one.
+
+The schedule has 3r(m-r) scalar factors with support independent of S, q, w,
+header and column. No conditional physical permutation or low-class regrouping
+is assumed: only scalar coefficients carry the pivot flags. All zero factors
+remain emitted and paid. This addresses a source-dependent routing issue that
+merely choosing a matrix basis would leave unresolved.
+
+## 3. Quotient out the stabilizer
+
+Write Q'=JQJ^-1 in blocks [[A0,B],[C,D]], with A0 an invertible r-by-r matrix.
+Put X=C A0^-1 and Z=-B. Define
+
+    L_X=[[I,0],[X,I]], U_Z=[[I,Z],[0,I]], T0=L_X U_Z.
+
+Then Q'=T0 E T0^-1. Here is a proof over the local ring, without a probabilistic
+chart hypothesis. The first r columns of Q' are independent modulo q; since
+im(Q') is a free direct summand of rank r, they form an R-basis of that image.
+Thus D=C A0^-1 B=XB. Idempotence gives A0^2+BC=A0, hence A0+BX=I. Multiplying
+out T0 E T0^-1 gives blocks I-BX, B, X(I-BX), XB, exactly Q'. Both L_X and
+U_Z have determinant one; each is r(m-r) commuting elementary shears.
+Set T=J^-1 T0, so Q=TET^-1 and det(T)=1.
+
+This uses only the image/kernel splitting, rather than a full arbitrary GL64
+basis. The stabilizer degrees of freedom do not need to be implemented.
+
+## 4. Ancestor units and kernel-only normalization
+
+Let H'=J H J^-1=diag(d_i). This is diagonal because J is a signed
+permutation. Define the determinant-one diagonal
+
+    D*=diag(d_0,...,d_(r-1), (product_(i<r) d_i)^-1, 1,...,1),
+    Z_h=H'^-1 D*.
+
+Z_h is identity on every image coordinate; its arbitrary unit kernel entries
+are allowed. The desired head and tail conjugators are
+
+    U_t=T=J^-1 T0,
+    U_h=H T Z_h
+       =J^-1 (H' L_X H'^-1)(H' U_Z H'^-1) D*.
+
+Both have determinant one. The conjugated graph matrices have the same supports
+and their coefficients are multiplied by d_target/d_source. Kernel ancestor
+weights remain present in these coefficients; they have not been discarded.
+The right compensation Z_h fixes every image coordinate, so diag(Z_h,I)
+commutes with D(E). Therefore
+
+    K=diag(U_h,U_t),   K D(E) K^-1=D_H(Q).
+
+Normalizing an image column independently would generally change the weighted
+swap. Here only the kernel compensation is free. This image-only diagonal
+choice emerged in the coordinating agent's cross-review of the first all-axis
+normalization; it removes unnecessary kernel diagonal factors. The result and
+all checks remain in this same assisted research session.
+
+For any unit a, diag(a,a^-1) on coordinates (i,k) is four shears:
+
+    U(1) L(a-1) U(-a^-1) L(-a(a-1)).
+
+This displayed product uses ordinary matrix multiplication; chronological left
+actions run right to left. Its off-diagonal entries vanish and its diagonal is
+(a,a^-1). Pair each image coordinate i<r with the single kernel hub k=r.
+Their pair diagonals multiply to D*, giving 4r scalar factors, with two in each
+orientation. This identity is checked separately over all units of several
+local rings. Unlike implementing an entire arbitrary SL_m diagonal, no factors
+are emitted for the other kernel coordinates.
+
+## 5. Fixed permutation networks for ordered ADD
+
+An ADD is assumed available only when the source block precedes its target
+physically. Blocks contain f atoms; the coefficient for each column comes from
+unchanged saved metadata. Ordinary block interchange is a **completed**, same-q,
+source-preserving primitive that preserves the entire intervening spectator,
+returns its heads and restores owned work. Its full cost is b(v,f).
+
+A reverse individual shear can be implemented by swapping its two whole blocks,
+performing the ordered ADD on the relabelled coordinates, and swapping back.
+This is used for the diagonal factors and costs two ordinary calls per reverse
+factor. It is never identified with the central reversed child.
+
+A whole reverse pivot star has centre i and arms in i+1,...,m-r+i. Swap i with
+its largest arm, execute the entire relabelled star, and swap back. All arms
+then precede the centre (or the opposite relation in the reflected bank).
+There are exactly two ordinary calls per reverse star, regardless of the
+number of arms. The routing permutation is fixed, even if every coefficient
+is zero. The one-hot property is needed for the algebraic regrouping, not
+for the routing operation itself.
+
+For a reverse graph pass, put t=min(r,m-r). Swap i with m-t+i for i=0,...,t-1,
+execute its relabelled shears, then undo these t swaps. The images now lie
+entirely after the kernels (or entirely before them in reflected order), so
+every ADD is ordered. This costs 2t ordinary calls per reverse graph pass.
+It preserves the original layout at the pass boundary and acts pointwise on
+all external spectators, fresh rows and physical prefix ordinals.
+
+Within this permutation-only route-and-return model, t swaps per direction
+are optimal for reversing the complete image/kernel order: the smaller group
+must all leave its original side and a transposition moves at most one of its
+members to the other side. This narrow claim does not lower-bound all COPY
+implementations. Exhaustive permutations through dimension seven check it.
+
+Head/tail physical orders are opposite. Across both banks and both directions,
+there are 6r reverse pivot stars and four reverse graph passes. The diagonal
+appears only on the head, in both directions, and has 4r reverse scalar
+slots in total. Hence the exact fixed emitted counts are
+
+    scalar ADD factors = 4[3r(m-r)+2r(m-r)]+2[4r]
+                       =20r(m-r)+8r,
+    ordinary calls     =20r+8 min(r,m-r).
+
+At (m,r)=(64,7), these are **8,036** and **196**. Breakdown of ordinary calls:
+84 pivot, 56 graph, 56 diagonal. There is one reversed child, not one per
+prefix. At fixed header/column some coefficients can vanish; the invoice does
+not omit them. The interpreter checks every emitted ADD's physical direction
+and executes every ordinary swap, including routing back.
+
+## 6. Full caller, consumer and relative bill
+
+Use the complete packet shape and ownership contract of PR3950:
+
+    [Z physical prefixes][U unused fresh rows][B][A^n head][G][A^n tail][S],
+    n=64f+delta, 0<=delta<64, v=Z U B G S A^(2n).
+
+Clone the borrowed complete arbitrary source. Apply the complete address
+permutation using the two conjugation words and one reversed 7f child, return
+the owned result to the actual COPY private port, and preserve it through all
+63 literal XOR readers. Release every intermediate only after its last reader.
+At the equality guard, clear the private output and reset its port.
+
+Matrix words are chronological left actions on address vectors. Pullback
+implementation reverses the entire vector-event order. That reversal preserves
+the physical direction and coefficient of each emitted ADD; it is not the
+operation of negating a factor. Inverse conjugators separately reverse and
+negate their scalar words. The finite payload checker executes these primitive
+pullbacks and all 63 dirty consumers, rather than checking only matrix rank.
+
+The central child's spectators are B'=B, G'=G A^(114f+2delta), S'=S, with
+fresh rows U and all Z physical prefixes. Their volume equals v exactly and
+keeps the peeled atoms/external gap in their original coordinate order. The
+child is one complete call outside any prefix loop. For the inherited stock
+K0=269241600 |GL64(F_q)| q^(4096(w-1)) and
+D(n)=0 below64, otherwise1+D(42 floor(n/64)), the standard parent stock
+ t K0^D(n) leaves U=t*9475*K0^(D(n)-1). Since 7f<=42f<n, child divisibility
+follows. This is reuse of the stock implication; it does not prove the original
+producer's stock coefficient or authorize replacing its source program.
+
+Let t_R(v,7f,w) be the full completed reversed-child cost. Let gamma include
+principal-chart search, matrix/weight coefficient generation and recomputation,
+Counts, source/program authentication, numerical work erasure and metadata
+preparation not included in the completed primitives. Let C_scan cover actual
+linear copying, scalar ADD, transfers, rewinds, releases and disposal. Then
+
+    C_residual <= t_R(v,7f,w) + 196 b(v,f)
+                     + C_scan,q v(8036f+196+3) + gamma.          (1)
+
+There are at most 8036f+196+1 intermediate releases; this upper bound is paid in
+the scan term. Borrowed source is never cleared. For the literal COPY episode,
+append 63 X(v) for the completed XOR readers and the actual outer owner gather,
+route/scatter, directory producer and protected return charges if those have
+not already been charged by the caller. No reader recomputes the residual;
+no reader's arbitrary incoming target is assumed zero.
+
+Conditional on fixed reusable tape inventories, a conservative visited-cell
+reserve is
+
+    2v + S_R(v,7f,w) + S_B(v,f) + S_ADD(v) + M_coeff + F_q,
+
+where each backend reserve is a whole-run lifetime maximum on its fixed
+reusable inventory, including owned output, numerical work, parking and
+blank-but-visited cells. The two volume buffers must likewise use fixed reusable
+inventories; M_coeff and F_q include whole-run coefficient and finite-control
+backing. Per-call live occupancy does not establish these bounds. If a backend
+allocates disjoint tapes across occurrences, their lifetime backing must be
+summed instead. Sequential cleanup does not justify taking a maximum
+across disjoint tape inventories. There is no stored length-f array of matrices;
+coefficients can be recomputed from header and column, with recomputation time
+included in gamma. Successful cleanup is covered by the named contracts;
+interruption recovery is not proved.
+
+No hidden absorption is made in (1). Under the additionally admitted backend
+and root/history metadata premises one may substitute
+b(v,f)<=C_B v(fw)^p+E_B and absorb the justified scan/preparation terms. However
+the 196 C_B v(fw)^p contribution remains, as does 196 E_B until separately
+absorbed. This package does not prove those physical premises or implement a
+source-bound alternative SelectedBinding.
+
+## 7. Cost gate, evidence and remaining obligations
+
+For c_R=1736646042038446578551/10^24, n approximately e and w approximately
+e^c_R, the retained B1 and B2 rates give (1+c_R)(1-a_B)-1>0. Multiplying their
+upper bound by 196 instead of 41832 does not change its exponent. Thus this
+new constructive constant improvement still cannot infer an O_q(v(n+w^p))
+local allowance from those upper bounds. It is not a runtime lower bound.
+
+The source-bound finite evidence reconstructs all nine actual capture projectors
+from R437's root rows at a24f9ff, covering45 contexts at q=3,5,7,11 with high
+lifts and unit ancestors,192 GL2/weight contexts, an ambient64 nonzero graph
+with singular leading chart, complete small arbitrary payload/63 readers,
+and semantic failures. Separate principal-minor/chart and routing checks do not
+import the compiler. Tests at small q establish their stated algebraic cases;
+large-prime supplier cost theorems still require their admitted q domain.
+
+Still open: an encoded coefficient producer and physical primitive realization
+for this alternate schedule; a genuinely cheaper complete ordinary tariff or
+an actual jointly charged consumer; uniform source/return/refinement and visited
+reserve admission; full native/router/precision/recovery obligations. No selected
+exponent changes. The written proof has not received independent human or
+formal-kernel review; separate code is still from this assisted session.
diff --git a/research/r437-parabolic-copy/README.md b/research/r437-parabolic-copy/README.md
new file mode 100644
index 0000000000..629e09370b
--- /dev/null
+++ b/research/r437-parabolic-copy/README.md
@@ -0,0 +1,139 @@
+# Rank-seven parabolic COPY with 196 ordinary adapters
+
+**Uniform algebra and a conditional relative construction; no supplier admission.**
+This package replaces PR3950's alternate full SL64 conjugator by a projector
+chart and fixed permutation networks. The complete emitted invoice falls from
+41,832 scalar ADD slots per column and 41,832 ordinary interchanges to
+**8,036 ADD slots per column and 196 ordinary interchanges**, surrounding one
+reversed child of width7f. All zero slots, inverse words, routing back, ancestor
+units, copying, intermediate release, 63 dirty readers and guarded disposal
+are included or explicitly retained in the full relative bill.
+
+The remaining ordinary term still cannot be absorbed using the pinned B1/B2
+upper tariffs at the R437 scaling. This is a constant improvement in an
+alternate construction, not a proof of R437's inherited cheap tariff. The
+original good/fallback algorithm is not repriced. No exponent or selected
+frontier changes.
+
+## What changed
+
+[PROOF.md](PROOF.md) gives the uniform argument over every Z/q^w split rank-seven
+projector, every high chart and arbitrary unit ancestor weights:
+
+1. A unit principal rank-seven minor exists by the characteristic-polynomial
+   coefficient identity, including characteristic seven. Fixed-support,
+   mutually exclusive pivot stars select it without conditional physical swaps.
+2. On the chart Q'=[[A,B],[C,D]], the two graph matrices
+   L_(CA^-1) U_(-B) diagonalize Q'. Internal image/kernel basis changes vanish
+   from the required conjugation.
+3. Ancestor weights are retained in the graph coefficients; only the seven
+   image weights need explicit diagonal factors, compensated at one kernel hub.
+4. Each reverse pivot star shares two ordinary calls. Each reverse graph pass
+   shares fourteen ordinary calls. This gives84+56+56=196 ordinary calls.
+
+This pairs algebraic stabilizers/parabolic charts with permutation-network
+optimization. A one-hot failure control shows why pivot regrouping cannot be
+extended to arbitrary simultaneous flags. The graph routing optimum is only
+for the stated permutation-only route-and-return model.
+
+## Evidence and replay
+
+The new compiler and event interpreter import no predecessor executable.
+`inputs/r437-word.json.gz` is an exact self-contained retained source from
+PR3950 head364701494bc3d726806a15d4d1d4b547c1e0f9d5, itself bound to R437/PR3647
+head a24f9ff95c12fd0b6792e3f710569237efd72db2. Its SHA256 is
+`e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e`.
+The old alternate proof is retained verbatim for the comparison. Runtime needs
+no pending Git object or external package; source bytes are authenticated by
+SHA256 and Git-blob identity. Canonical source-history pins remain at main
+20ecf2891d80b5acf18d980b2164fb44ea7faa90. See [SOURCES.json](SOURCES.json).
+
+Registered Python3.12 standard-library replay:
+
+```sh
+python3 -I -B scripts/research_package.py --package research/r437-parabolic-copy
+```
+
+Direct primary normal/optimized, separate checker and actual CLI controls:
+
+```sh
+python3 -I -B research/r437-parabolic-copy/verify.py
+python3 -I -O -B research/r437-parabolic-copy/verify.py
+python3 -I -B research/r437-parabolic-copy/independent.py
+python3 -I -B research/r437-parabolic-copy/test_package.py
+```
+
+The primary covers45 contexts on all nine literal R437 captures at q=3,5,7,11,
+192 complete GL2/diagonal-weight cases, and one ambient64 projector with
+nonzero graph coefficients and a singular leading chart. An exhaustive
+81-address pullback with three distinct physical prefix ordinals and two
+spectators checks all486 payload bits,63 dirty readers and in-place cleanup of
+the model private buffer after its last reader, with source and completed-target
+preservation checks. This cleanup is a model operation; physical disposal, head
+restoration and its scan cost remain charged backend premises.
+Small q is algebraic evidence; it does not satisfy the imported large-q cost
+premises. The finite ambient64 case supplies a valid principal subset to avoid
+an enormous lexicographic search; the uniform proof supplies existence and the
+full search cost remains in gamma.
+
+The separate checker imports no compiler or primary verifier. It checks all234
+nontrivial3×3 F3 idempotents and108 rank-one2×2 Z9 idempotents via direct
+permutation determinants and Cramer inverses, all5912 permutations in dimensions
+2..7 for21 routing minima,124 unit diagonal identities, and a separate invoice.
+These are different implementations within one assisted session, not independent
+human review or formal-kernel acceptance.
+
+[RESULT.json](RESULT.json) records exact scientific output. The CLI controls
+require a successful optimized Git-free read-only copy, then reject altered,
+missing and linked sources and a stale invoice. No physical tape compiler,
+full GL64 payload, global macro word, native/router join or selected cold replay
+is executed. The written theorem remains conditional on the completed backends,
+source/program continuation and root/history preparation/reserve premises.
+
+## Task, overlap and stop decision
+
+Explicit user-authorized parallel continuation of the R437 COPY stream refines
+`independent-moment`, priority revision6. [TASK.json](TASK.json) preserves the
+original card and the exact changed construction. The canonical coordination
+claim is [PR3967's parallel-session claim](https://github.com/CrocSwap/integer-mult-bounds/pull/3967#issuecomment-6262146714).
+The repository overlap helper had no usable remote snapshot; it searched local
+notes only. A live newest40 open-PR search for COPY included3967,3950,3936,
+3958 and3959. Their physical binding, original good/fallback audit and pooled
+rank-profile claims are distinct from this changed factorization. This is a
+bounded overlap check, not a novelty certificate or complete Discussion census.
+The parent read the required Discussion guidance and posted the shared claim.
+
+The initial optimistic gate already found the positive ordinary exponent gap.
+This bounded construction was continued only to discharge the concrete
+alternative-factorization/routing question; supplier expansion stops at the
+same unproved cost implication. A smaller positive constant does not remove it.
+
+## Open next questions
+
+- Can a complete ordinary adapter or a jointly compiled real consumer remove
+  the surviving196 b(v,f) term at the required scaling? Start with one reverse
+  star and its actual encoded coefficient source, ownership and return; do not
+  substitute an unpriced random-access permutation.
+- Can the new fixed-support schedule be bound to an encoded coefficient producer
+  and protected full-volume caller with a proved preparation and visited-cell
+  reserve? Start with current R437 COPY515 and its actual rank26 ancestor,
+  retaining all source identities, physical prefixes and fresh rows. The finite
+  PR3967 return is context, not proof of this new schedule's implementation.
+
+The relevance, first steps and blockers are also structured in TASK.json.
+
+## Credit
+
+Prepared by Chris R / Clear1nsight with substantial OpenAI Codex assistance,
+including a coordinating-agent cross-review that identified the image-only
+kernel compensation. All agents are in the same assisted donor session.
+
+Retain credit to ai-nanachi/R437 PR3647, Ali Romman/PR1043,
+Sagar Thakrar/PR3700 and OQ4; the full lineage in the retained R437 notice;
+alephnan/PR1627, eumemic's local-ring GL lineage and Jose Manuel/PR2234 for
+split-projector/common-chart arguments; David Arias/PR2753, Jose Manuel/PR2809
+for the complete caller; Jose Manuel/PR2899/2915 for ordinary/fast-primitive
+composition; Chris R/PR3936/3950/3967 for the preceding COPY audit, relative
+bill and current-source binding; and zxv/PR3690 for the preceding adapter.
+The old alternate is reused as the comparison, not independently re-proved.
+Generic elementary-matrix and stabilizer facts are not claimed as new mathematics.
diff --git a/research/r437-parabolic-copy/RESULT.json b/research/r437-parabolic-copy/RESULT.json
new file mode 100644
index 0000000000..3b036d8880
--- /dev/null
+++ b/research/r437-parabolic-copy/RESULT.json
@@ -0,0 +1,49 @@
+{
+  "ambient64_invoice": {
+    "add": 8036,
+    "swap": 196
+  },
+  "finite_payload": {
+    "addresses": 81,
+    "dirty_readers": 63,
+    "payload_bits": 486,
+    "physical_prefixes": 3,
+    "primitive_events": 57,
+    "spectators": 2
+  },
+  "fixed_support_hash_8": "2526b1557f4d1ccb4387974f29da96c93f4f13bf4e2135a796a79af726152e8e",
+  "full_GL2_weighted_contexts": 192,
+  "full_ambient64_cases": 1,
+  "inherited_cheap_tariff_proved": false,
+  "literal_contexts": 45,
+  "old_alternate_add_per_column": 41832,
+  "old_alternate_ordinary_calls": 41832,
+  "one_reversed_child_width": "7f",
+  "physical_backend_implemented": false,
+  "power_gaps": {
+    "B1": "3658876267404271047807531239/100000000000000000000000000000000",
+    "B2": "33698665299123223902351340421063/1000000000000000000000000000000000000"
+  },
+  "semantic_controls": [
+    "two active pivot flags",
+    "force bad leading chart",
+    "nonunit ancestor weight",
+    "wrong rank",
+    "drop ancestor weights",
+    "omit one router swap",
+    "free ordinary adapters"
+  ],
+  "source_capture_projector_hashes": [
+    "48dc372319cc093038dbdb1edb6b063827b501ecf2cf36c44c05bccc33cc5dec",
+    "082eb8841573259ccfdff731dd97e31ad53e136da958948056757f05c194ce74",
+    "15e3bd0160aabca63e242ae487cbf1841be12380b32631517f9bc877bd7a040d",
+    "eccbba6e86eb53dbe1af1456de5aef450884f6e1abd1e53a83b58d82b5335e66",
+    "72d3ef2e5dab6d5c75f562e3b4fbae1b9bad4df5ffa37186d5743915c17e1286",
+    "6b710ec1abe0bb8f8d252c7872a64b9c97f77252a4b8c615584c9b15ecb4b714",
+    "1767972ba33c5b500c10fa05e2b557234a0ff08e28e70fbbd0dfe824d54eadab",
+    "834018d1dc78d932487eb4d6fc86c9a1c9daf859bb953ae29dba1b9d84c16490",
+    "a3f7c0bf53d5f976a2afa1f5dbda3005ff1302f77fd0fbea782054766a80e714"
+  ],
+  "status": "PASS_PARABOLIC_COPY_RELATIVE_CONSTRUCTION",
+  "supplier_admitted": false
+}
diff --git a/research/r437-parabolic-copy/SOURCES.json b/research/r437-parabolic-copy/SOURCES.json
new file mode 100644
index 0000000000..496be37f0c
--- /dev/null
+++ b/research/r437-parabolic-copy/SOURCES.json
@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    }
+  ],
+  "retained": [
+    {
+      "path": "inputs/R437-LICENSE",
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+      "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64",
+      "origin_commit": "364701494bc3d726806a15d4d1d4b547c1e0f9d5",
+      "origin_path": "research/r437-uniform-copy-reduction/R437-LICENSE"
+    },
+    {
+      "path": "inputs/R437-UPSTREAM-NOTICE.md",
+      "sha256": "8ed83f2f0bde43a41e44279f44d29efaeae3df44850b86f0e3578edf3ee104e4",
+      "git_blob": "9b519b904d456b0b5861f7469a66c365e77799a6",
+      "origin_commit": "364701494bc3d726806a15d4d1d4b547c1e0f9d5",
+      "origin_path": "research/r437-uniform-copy-reduction/R437-UPSTREAM-NOTICE.md"
+    },
+    {
+      "path": "inputs/pr3950-PROOF.md",
+      "sha256": "cec65c8feb59ce9852d7ee6d3c24396d8a2f395df2dd7454213fc0456fd8050c",
+      "git_blob": "855c8c0ea24afd1e586ffc59cf9f0967bc186c69",
+      "origin_commit": "364701494bc3d726806a15d4d1d4b547c1e0f9d5",
+      "origin_path": "research/r437-uniform-copy-reduction/PROOF.md"
+    },
+    {
+      "path": "inputs/r437-word.json.gz",
+      "sha256": "e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e",
+      "git_blob": "c558a221dd44cbdaa732a401f9876de4c096d4a7",
+      "origin_commit": "364701494bc3d726806a15d4d1d4b547c1e0f9d5",
+      "origin_path": "research/r437-uniform-copy-reduction/inputs/r437-word.json.gz"
+    }
+  ]
+}
diff --git a/research/r437-parabolic-copy/TASK.json b/research/r437-parabolic-copy/TASK.json
new file mode 100644
index 0000000000..0bb3aa9b17
--- /dev/null
+++ b/research/r437-parabolic-copy/TASK.json
@@ -0,0 +1,85 @@
+{
+  "schema_version": 1,
+  "task_id": "independent-moment",
+  "priority_revision": 6,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "original_card": {
+    "id": "independent-moment",
+    "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?",
+    "starting_points": [
+      "certificates/selected-result.json",
+      "research/rank7-joint-endframes/README.md",
+      "docs/research/research-family-status.md"
+    ],
+    "methods": [
+      "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.",
+      "Implement certified moment inequalities through a different exact enclosure method."
+    ],
+    "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.",
+    "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.",
+    "allowed_variations": [
+      "Reconstruct either a source ledger or a numeric enclosure with a different method."
+    ],
+    "scope_change_triggers": [
+      "Importing the primary function and calling its output independent verification.",
+      "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing."
+    ],
+    "overlap_terms": [
+      "independent moment",
+      "rank histogram",
+      "exact enclosure",
+      "2979",
+      "rank7 joint endframes",
+      "paired extraction",
+      "joint lowering"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Construct and fully price a distinct all-class rank-seven COPY factorization using projector stabilizers, one-hot pivot stars and fixed permutation routing; retain the unabsorbed ordinary tariff.",
+  "scope_change_reason": "Explicit donor parallel follow-up to PR3950/3967; replace the alternate full SL64 mechanism, not rerun an unchanged root or frame search.",
+  "bottleneck_link": "The alternate generic conjugator had41832 ordinary calls. A smaller correctly restored factorization isolates the surviving physical tariff premise.",
+  "budget_minutes": 60,
+  "stop_rule": "One session from07:35UTC to08:33UTC, construction frozen before08:15; reserve the final quarter for proof, replay and publication. Stop supplier expansion at the surviving exponent gap.",
+  "outcome": "partial",
+  "evidence": "PROOF.md supplies the uniform parabolic construction. RESULT.json records8036 scalar ADDs per column and196 ordinary calls, one reversed7f child,45 literal contexts,192 GL2/weight cases and one ambient64 bad-chart case. Separate determinant/routing checks and actual optimized export controls pass.",
+  "author": "Chris R / Clear1nsight, with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in mathematics, implementation, tests and prose; coordinating-agent cross-review supplied image-only diagonal compensation. Same assisted session, not independent human review.",
+  "open_questions": [
+    {
+      "question": "Can a complete ordinary adapter or an actual shared consumer afford the surviving196 b(v,f) term?",
+      "why_it_matters": "The available B1/B2 upper tariffs still have a positive exponent gap despite the constant reduction.",
+      "first_step": "Bind one reverse star to the real encoded source, ownership, reader and return, and derive its complete bill.",
+      "blocked_by": "No cheaper complete ordinary bound or jointly charged physical consumer has been supplied."
+    },
+    {
+      "question": "Can this fixed-support alternate schedule obtain an encoded producer and full-volume caller with uniform reserve?",
+      "why_it_matters": "Algebraic event execution does not implement the source-bound physical machine or prove preparation and visited backing.",
+      "first_step": "Instantiate current COPY515 under the actual rank26 ancestor with authenticated headers, fresh rows and protected return.",
+      "blocked_by": "The coefficient producer, physical primitive/compiler refinement and uniform preparation/visited reserve remain open."
+    }
+  ],
+  "coordination_claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/3967#issuecomment-6262146714",
+  "freshness": {
+    "entry_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+    "shared_checkpoint_utc": "2026-10-19T07:49:55Z",
+    "shared_checkpoint_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+    "priority_revision": 6,
+    "overlap": "Local find_overlap.py cache unavailable for remote records; live newest40 COPY PR search; parent read Discussion guidance. Bounded coverage, not novelty proof.",
+    "submission_checkpoint_utc": "2026-10-19T07:52Z",
+    "submission_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+    "live_pr3950_head": "364701494bc3d726806a15d4d1d4b547c1e0f9d5",
+    "live_pr3967_head": "32af060614fefa9729c86370524c2e72265acd76",
+    "submission_overlap": "Latest12 open COPY PRs refreshed; new3978 P104 fixed-owner and3974 Toom3 scopes differ. Shared Discussion claim remains canonical."
+  }
+}
diff --git a/research/r437-parabolic-copy/VALIDATION.json b/research/r437-parabolic-copy/VALIDATION.json
new file mode 100644
index 0000000000..8b7093cf83
--- /dev/null
+++ b/research/r437-parabolic-copy/VALIDATION.json
@@ -0,0 +1,90 @@
+{
+  "status": "PASS_LOCAL_REGISTERED_PACKAGE",
+  "checked_utc": "2026-10-19T07:52:12Z",
+  "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]",
+  "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39",
+  "registered_commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Exact R437 source, every emitted ordered operation and full weighted COPY, bad charts and one-hot/ownership controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Same scientific checks with assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "No compiler imports: exhaustive principal chart and Cramer identities, permutation route minima, four-shear diagonal and invoice."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/test_package.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Actual optimized Git-free read-only export positive and five source/invoice CLI rejections."
+    }
+  ],
+  "markers": [
+    "PASS_PACKAGE_METADATA_AND_PINS",
+    "PASS_PARABOLIC_COPY_RELATIVE_CONSTRUCTION {add:8036,swap:196} normal and optimized",
+    "PASS_SEPARATE_PRINCIPAL_CHART_AND_ROUTING charts234+108 permutations5912 cases21 diagonal_units124",
+    "PASS_OPTIMIZED_EXPORT_AND_FIVE_CLI_REJECTIONS",
+    "PASS_REGISTERED_RESEARCH_PACKAGE outcome=partial"
+  ],
+  "scope": "Written uniform algebra and conditional complete relative cost; finite event model. No physical compiler or supplier admission.",
+  "scientific_hashes": {
+    "parabolic.py": "bd76a6a2491f4c1ffba46e6ab9720dd5dea30de629bb1f0e463a579bcbc633cb",
+    "verify.py": "53b75e7ef6e485fac21ca72241ac699e173a835a56dea691724ded0616d2ed6d",
+    "independent.py": "159580f4591c705b8c88560402f85c3c3141f37243839c3e1dfa559c83664245",
+    "test_package.py": "aea25cadecf4bc7b33c77f70e827d8205c71f5232b98d8b5e0ad1a8ec5f947be",
+    "PROOF.md": "729a490a9997cdcbd0bae87573dff487c0bb0bd84e00fa70a4d3d3e818873fee",
+    "RESULT.json": "330fb7b230cea5c588507f795344748f578e562d4f20f12fdeb5bb6255d6d18b"
+  },
+  "record_scope": "Original 07:52 baseline receipt is preserved above. Its scientific_hashes describe baseline bytes only; see correction_validations for current verifier/proof bytes.",
+  "correction_validations": [
+    {
+      "checked_utc": "2026-10-19T08:11:12.946196+00:00",
+      "code_head": "4aa94543e95d1c70a15d3d1143bf34074ffdfd3a",
+      "status": "PASS_LOCAL_AFFECTED_COMMANDS_AND_EXACT_CODE_HEAD_BYTES",
+      "changes": "Clear the actual nonzero model private buffer in place and check source/target preservation; label physical cleanup a charged backend premise. Require fixed reusable tape inventories and whole-run lifetime backing in reserve formula.",
+      "credit": "Same-session native_transport cross-review found the previous zero-buffer check was tautological; coordinating review requested explicit lifetime reserve qualification.",
+      "passed_commands": [
+        "python3 -I -B research/r437-parabolic-copy/verify.py",
+        "python3 -I -O -B research/r437-parabolic-copy/verify.py",
+        "python3 -I -B research/r437-parabolic-copy/test_package.py"
+      ],
+      "exact_head_checks": [
+        "All 16 package files byte-equal to published code head before this receipt-only amendment",
+        "git diff --check against 112e8265 passed"
+      ],
+      "scientific_hashes": {
+        "verify.py": "13cfc3c6004ca2d2d47dbf67c82dd0a28fa512db8f15441434458a54299d85a9",
+        "README.md": "bf5f5587d6d696741d21bd86615b5665f3e738c14e41fd72cb8d16271eb4dcd2",
+        "PROOF.md": "27d54dcc80d2d9b6be05eab2202806c25833b680af89613fab94af911701c47a"
+      },
+      "qualification": "The separate checker and mathematical construction are unchanged. Hosted replay status must be checked at the final publication head; no pending or earlier run is asserted to cover that head."
+    }
+  ]
+}
diff --git a/research/r437-parabolic-copy/VERIFY.json b/research/r437-parabolic-copy/VERIFY.json
new file mode 100644
index 0000000000..95b52fb4ff
--- /dev/null
+++ b/research/r437-parabolic-copy/VERIFY.json
@@ -0,0 +1,50 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Exact R437 source, every emitted ordered operation and full weighted COPY, bad charts and one-hot/ownership controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Same scientific checks with assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "No compiler imports: exhaustive principal chart and Cramer identities, permutation route minima, four-shear diagonal and invoice."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/test_package.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Actual optimized Git-free read-only export positive and five source/invoice CLI rejections."
+    }
+  ]
+}
diff --git a/research/r437-parabolic-copy/independent.py b/research/r437-parabolic-copy/independent.py
new file mode 100644
index 0000000000..afdacf3fe1
--- /dev/null
+++ b/research/r437-parabolic-copy/independent.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Separate determinant/chart and minimum permutation-route checks.
+No imports from the construction or verifier. Same assisted session, not human review.
+"""
+from itertools import combinations, permutations, product
+import json
+from math import gcd
+from pathlib import Path
+
+
+def check(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def times(a,b,m):
+    return [[sum(x*y for x,y in zip(row,column))%m for column in zip(*b)] for row in a]
+
+
+def det(a,m):
+    total=0
+    for p in permutations(range(len(a))):
+        sign=(-1)**sum(p[i]>p[j] for i in range(len(p)) for j in range(i+1,len(p)))
+        term=sign
+        for i,j in enumerate(p):term*=a[i][j]
+        total+=term
+    return total%m
+
+
+def inv_cramer(a,m):
+    d=det(a,m)
+    check(gcd(d,m)==1,'unit minor')
+    n=len(a)
+    return [[(-1)**(i+j)*det([[a[k][l] for l in range(n) if l!=i] for k in range(n) if k!=j],m)*pow(d,-1,m)%m for j in range(n)] for i in range(n)]
+
+
+def rank_field(a,q):
+    rows=[[x%q for x in row] for row in a];r=0
+    for j in range(len(rows[0])):
+        k=next((k for k in range(r,len(rows)) if rows[k][j]),None)
+        if k is None:continue
+        rows[r],rows[k]=rows[k],rows[r]
+        z=pow(rows[r][j],-1,q);rows[r]=[x*z%q for x in rows[r]]
+        for k in range(r+1,len(rows)):
+            z=rows[k][j];rows[k]=[(x-z*y)%q for x,y in zip(rows[k],rows[r])]
+        r+=1
+    return r
+
+
+def charts():
+    accepted={}
+    for n,m,q in [(3,3,3),(2,9,3)]:
+        count=0
+        for flat in product(range(m),repeat=n*n):
+            matrix=[list(flat[n*i:n*i+n]) for i in range(n)]
+            if times(matrix,matrix,m)!=matrix:continue
+            r=rank_field(matrix,q)
+            if not 0<r<n:continue
+            minors=[(s,det([[matrix[i][j] for j in s] for i in s],m)) for s in combinations(range(n),r)]
+            check(sum(d for _,d in minors)%m==1,'principal minor sum exactly one')
+            s=next(s for s,d in minors if gcd(d,m)==1)
+            order=list(s)+[i for i in range(n) if i not in s]
+            qp=[[matrix[i][j] for j in order] for i in order]
+            a=[row[:r] for row in qp[:r]];b=[row[r:] for row in qp[:r]];c=[row[:r] for row in qp[r:]]
+            x=times(c,inv_cramer(a,m),m)
+            t=[[int(i==j) for j in range(n)] for i in range(n)]
+            for i in range(r):
+                for j in range(n-r):t[i][r+j]=-b[i][j]%m
+            for i in range(n-r):
+                for j in range(r):t[r+i][j]=x[i][j]
+                for j in range(n-r):t[r+i][r+j]=(int(i==j)-sum(x[i][k]*b[k][j] for k in range(r)))%m
+            te=[[entry if j<r else 0 for j,entry in enumerate(row)] for row in t]
+            check(times(qp,t,m)==te and det(t,m)==1,'Cramer chart intertwiner and determinant')
+            count+=1
+        accepted[f'{n}x{n}_mod{m}']=count
+    return accepted
+
+
+def transpositions(p):
+    seen=set();cycles=0
+    for i in range(len(p)):
+        if i in seen:continue
+        cycles+=1;j=i
+        while j not in seen:seen.add(j);j=p[j]
+    return len(p)-cycles
+
+
+def routes():
+    cases=0;perms=0
+    for n in range(2,8):
+        best={r:n for r in range(1,n)}
+        for p in permutations(range(n)):
+            perms+=1;cost=transpositions(p)
+            for r in range(1,n):
+                if min(p[:r])>max(p[r:]):best[r]=min(best[r],cost)
+        for r,cost in best.items():
+            check(cost==min(r,n-r),'optimal graph routing transpositions')
+            for i in range(r):
+                endpoint=n-r+i
+                p=list(range(n));p[i],p[endpoint]=p[endpoint],p[i]
+                check(all(p[k]<p[i] for k in range(i+1,endpoint+1)),'star route turns every arm')
+            cases+=1
+    return {'dimension_rank_cases':cases,'all_permutations':perms}
+
+
+def diagonals():
+    checked=0
+    for m in [3,9,25,49,81]:
+        for a in range(m):
+            if gcd(a,m)!=1:continue
+            word=[[[1,1],[0,1]],[[1,0],[a-1,1]],[[1,-pow(a,-1,m)],[0,1]],[[1,0],[-a*(a-1),1]]]
+            result=[[1,0],[0,1]]
+            for factor in word:result=times(result,factor,m)
+            check(result==[[a,0],[0,pow(a,-1,m)]],'four shear diagonal')
+            checked+=1
+    return checked
+
+
+def main():
+    result=json.loads((Path(__file__).resolve().parent/'RESULT.json').read_bytes())
+    # Count from stages, independently of the primary invoice implementation.
+    m,r=64,7
+    pivot=4*sum(3*len(range(i+1,m-r+i+1)) for i in range(r))
+    graph=4*sum(1 for i in range(r) for j in range(r,m))*2
+    diagonal=2*4*r
+    adds=pivot+graph+diagonal
+    swaps=2*(2*3*r)+4*2*r+2*(2*r)*2
+    check(result['ambient64_invoice']=={'add':adds,'swap':swaps}=={'add':8036,'swap':196},'separate stage invoice')
+    print('PASS_SEPARATE_PRINCIPAL_CHART_AND_ROUTING',json.dumps({'charts':charts(),'routes':routes(),'diagonal_units':diagonals(),'invoice':[adds,swaps]},sort_keys=True))
+
+if __name__=='__main__':main()
diff --git a/research/r437-parabolic-copy/inputs/R437-LICENSE b/research/r437-parabolic-copy/inputs/R437-LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/research/r437-parabolic-copy/inputs/R437-LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/research/r437-parabolic-copy/inputs/R437-UPSTREAM-NOTICE.md b/research/r437-parabolic-copy/inputs/R437-UPSTREAM-NOTICE.md
new file mode 100644
index 0000000000..9b519b904d
--- /dev/null
+++ b/research/r437-parabolic-copy/inputs/R437-UPSTREAM-NOTICE.md
@@ -0,0 +1,71 @@
+# Notice
+
+Apache-2.0 (`LICENSE`, copied from #493's package). Prepared by eumemic with substantial Anthropic Claude
+assistance.
+
+## New in this package
+
+- `code/gen_p3.py` (the generator of the punctured word: the L3 skeleton of #543 restricted to the live lines, the
+  pseudo-target totals, the phase-A mini-nodes and extra carriers), `code/pwordl.py` (word builder for a live subset
+  of the 120 lines; output in the bitE8/1 layout with the `ports_geom` and `punctured` fields introduced by #545),
+  `data/bitE8mut-p111.json.gz` (the word), `data/punct.json` (its frozen parameters), `discovery/choose.py` and
+  `discovery/search.py` (the nomination of P and of the parameters; not run by `verify.sh`).
+- `code/gen_p3.py` carries `derive`, `ex_part` and `plan_thirds` from #543's `code/gen_l3.py` (eumemic), and
+  `data/plan-l3.json` is #543's CP-SAT plan, unchanged. `code/nodeopt.py`, `code/planio.py`, `code/mutants.py`,
+  `code/mutrec_b.py` and `code/provenance.py` are #543's files, unchanged.
+- `code/xcheck_p.py`: #543's independent checker `code/xcheck.py` with nine listed edits for v <= 120 live labels
+  (root-line enumeration of the lattice, frame closure and target frames over the live labels) and a new part T (the
+  frame and COPY rank of every retained total at the scatter, and whether it is the hyperplane of a punctured line).
+- `code/mutants_p.py` (punctured-design controls), `code/adapt9p.py` (#510's nine-stage files parameterised for
+  v <= 120 and any copy ranks, the way #545's `adapt.py` parameterises #493's eleven-stage files), `code/cited.py`,
+  `code/receipt_kappa.py`, `code/summary.py`, `verify.sh`, `EXPECTED.json`, `DEPENDS.json`, `requirements.txt`,
+  `data/complex-b.json`, `data/selection9-p111.json` and `data/hosting11-p111.json` (frozen nominations of #442's
+  hosting programme, rediscovered by `verify.sh`), `.github/workflows/e8-bit-p111.yml`.
+
+## Vendored, byte-identical (git blob ids in `SOURCE-pr*.json`, checked by `code/provenance.py`)
+
+- **PR #510 (DreamingOfClouds, with Claude Opus 5.5 via Claude Code), commit 64edee1** (`vendor/pr510/`): the same 19
+  files as #543's package (#510's nine-stage chain with the files it vendors from #463, #443, #442 and #315, and #503's
+  R480 word). Their notices are listed in #543's NOTICE and in the files.
+- **PR #545 (DreamingOfClouds, with Claude Opus 5.5 via Claude Code; draft), commit 376426f** (`vendor/pr545/`):
+  `code/adapt.py` and `code/punct_cfg.py`, run unchanged on this package's word; `data/bitE8mut-v111-r489.json.gz`,
+  `data/hosting-v111-r489.json` and `EXPECTED.json` (a control).
+- **PR #548 (Dugongue), commit 66dbc2b** (`data/complex/pr548/`): `EXPECTED.json` and `evidence/EXACT-ASSEMBLY.json`.
+- **PR #544 (chafreaky, with OpenAI Codex assistance), commit 4858bb3** (`data/complex/pr544/`): `EXPECTED.json` and
+  the Linux exact-assembly receipt.
+- **PR #535 (icekylinx, with GPT-6 Astra assistance), commit 8b758a1** (`data/complex/pr535/`): `EXPECTED.json` and
+  `evidence/audit/EXACT-ASSEMBLY-PR493.json`.
+
+## Used from main, unchanged (pinned in `DEPENDS.json`)
+
+- `research/e8-bit-carrier-skeleton` (PR #493, eumemic): the skeleton modules and D4 partition the generator imports,
+  #370's checker (run here in #545's v <= 120 form), the official cohort checkers, `gram_frames.py`, the record
+  exporter, the geometries and the eleven-stage chain that #545's `adapt.py` parameterises, #442's hosting programme,
+  the R489 word, the control receipts and #315's engines.
+- `research/direct-delivery504-global/EXPECTED.json` (PR #531, icekylinx): its complex b and kappa.
+
+## Cited, not rebuilt
+
+Complex coarse savings in `data/complex-b.json`, each bound to its PR's receipt by `code/cited.py`: PR #548 (primary;
+open), PR #544 and PR #535 (open), PR #531 (merged), and PR #484, #471 and #458 (controls).
+
+## Ideas used
+
+- PR #545 (DreamingOfClouds): the punctured-star unit. Nine lines are neither sources nor targets; each retained total
+  is a pseudo-target that reads what the removed target would read, at frame rank 7, so the decoder constant is 63;
+  the rank-mass identity with v and the decoder constant as parameters; the parameterisation of the hub chain.
+- PR #543 (eumemic): the R420 L3 skeleton with keepers read by targets and rewritten in phase B.
+- PR #493 (eumemic), PR #503 and #510 (DreamingOfClouds), PR #425 (Zhihao Chen / jacklightChen), PR #370 (Dylan Crow),
+  PR #472, #445, #443 (chafreaky), PR #442 (DaysSky), PR #463 and #315 (DreamingOfClouds), PR #386 (Zhihao Chen): the
+  skeleton, the scalar-interface lemma, the format, and the pricing pipelines.
+- PR #523 (icekylinx): the puncture pattern on the complex side, cited by #545.
+- Jacob Sussman introduced the E8 unit.
+
+R437 composition: Ali Romman (@aliromman), with substantial OpenAI Codex assistance, authored the public1043 helper470 source-boundary deletion. Its exact canonical-main package and NOTICE are retained in public1043/. The new contribution here composes that credited deletion with the independently validated helper464 GL, then reconstructs actual owners, full invoice, independent checks and portable replay.
+
+Sagar Thakrar (thakrarsagar), PR3700 Open question4, proposed the exact
+window6 two-leftover coalescing used by this follow-up. No code from that
+PR is imported by the author pipeline; root independently replayed its
+hosting and price engines. Full owner/template/invoice regeneration and
+packaging used substantial OpenAI Codex assistance. All prior credits and
+Apache-2.0 notices remain in place.
diff --git a/research/r437-parabolic-copy/inputs/pr3950-PROOF.md b/research/r437-parabolic-copy/inputs/pr3950-PROOF.md
new file mode 100644
index 0000000000..855c8c0ea2
--- /dev/null
+++ b/research/r437-parabolic-copy/inputs/pr3950-PROOF.md
@@ -0,0 +1,346 @@
+# Uniform rank-seven COPY: a constructive reduction and its full relative bill
+
+Chris R / Clear1nsight, with substantial OpenAI Codex assistance.
+
+**Status.** The algebraic reduction below is uniform, including every local-ring
+cover class. The caller and cost theorem is conditional on explicitly named
+completed backends. It gives a larger, fully displayed relative bill. It does
+**not** establish R437's inherited cheap rank-seven tariff, implement an encoded
+physical compiler for the new schedule, or independently discharge the universal
+C0/B1 source arguments. Those are substantive remaining obligations, not facts
+inferred from the checks. Section 8 gives the resulting stopping decision.
+
+The split-projector/common-chart argument is credited to alephnan/PR1627,
+eumemic's GL local-ring lineage, and Jose Manuel/PR2234. The selected complete
+caller is David Arias/PR2753 and Jose Manuel/PR2809; the ordinary backends and
+fast-primitive composition are Jose Manuel/PR2899/2915. Generic conjugation and
+Gaussian elimination are not claimed as new mathematics. This contribution
+specializes and bills a fixed-support determinant-normalized reduction at the
+actual R437 COPY boundary, including arbitrary dirt, weighted ancestors and
+the reverse-order adapters that a rank-only argument would omit.
+
+## 1. Quantified address and ownership domain
+
+Fix one odd prime q and w>=1. Put R=Z/q^w and A=q^w. Source-admissible large
+primes are required when importing the selected backend time/stock theorems;
+the algebra alone works for every odd q. Let m=64, r=7, n=64f+delta,
+f>=1 and 0<=delta<64. One complete selected low packet has shape
+
+    [Z physical prefixes][U unused fresh rows]
+    [B][A^n head][G][A^n tail][S],
+    v = Z U B G S A^(2n).
+
+Z,U,B,G,S are independent positive complete extents. In a parent invocation
+Z=C H, H=q^(4096(w-1)). The prefixes retain **physical ordinals**, including
+repeated or correlated field values; they are not a set of distinct headers.
+Every incoming Boolean payload is arbitrary. In particular it may be the
+complete dirty capture in PR3936, with input 340 present. No SOURCE/helper
+projection, clean-input restriction or independence of payloads is allowed.
+
+For each prefix and column j, let a_(i,j) be the incoming diagonal units.
+They can depend on the source-bound ancestor program and j, but not on body
+addresses or fresh unused rows. Let g be the complete invertible cover matrix
+over R at that prefix. Let P be the rank-seven rational projector of the
+literal capture, embedded into the first eight of m coordinates. Section 7
+binds all nine projectors to the exact R437 input.
+
+Write E=diag(I_7,0_57), Q=g P g^-1, H_j=diag(a_(0,j),...,a_(63,j)). In
+reflected tail coordinates the requested address map is
+
+    D(Q) = [[I-Q,Q],[Q,I-Q]],
+    D_H(Q) = diag(H_j,I) D(Q) diag(H_j^-1,I).
+
+The physical reflected tail sends the partner of head (i,j) to tail
+(m-1-i,f-1-j), with the peeled delta and external G left in the middle.
+Thus the central E map is exactly one **reversed** interchange of width 7f;
+it is not an ordinary scalar swap on one representative address.
+
+The output contract is: preserve borrowed source, program, directory and
+Counts; return a distinct owned stream f_in composed with the complete
+requested address permutation; preserve every spectator and physical prefix
+ordinal pointwise; reset borrowed heads; restore owned scratch before reuse.
+At the guarded ERASE the caller clears the owned output, charging that scan.
+Successful execution is the contract. Interruption recovery is not asserted.
+
+## 2. Kernel normalization removes diagonal scaling from the factor alphabet
+
+The retained projectors have dyadic entries and satisfy P^2=P. Their rational
+characteristic polynomials specialize to t^57(t-1)^7, so reduction modulo q
+has rank seven even for q=7; trace modulo q is not a rank test. As in PR2234,
+choose seven independent columns of P modulo q and 57 independent columns
+of I-P. Lift those columns to R and concatenate them into B_P. Then
+
+    P B_P = B_P E,   det(B_P) is a unit.
+
+This follows because their residue-field image/kernel spaces are a direct
+sum. Unit determinant over the local ring implies invertibility, and hence
+P=B_P E B_P^-1. The same selected column labels work for every precision w
+at this fixed prime. They are source/compiler data, not payload-dependent
+advice. The proof does not require symmetry of Q or g^-1=g^T.
+
+Set T=g B_P, S_h=H_j T and S_t=T. Both are invertible. For either S, multiply
+its first kernel column (column 7, zero based) by det(S)^-1. Call the result
+U. Thus U=S Z_S, det(U)=1 and Z_S changes only a kernel coordinate of E.
+The two independent kernel scalings, on head and tail, commute with D(E):
+D(E) fixes each of these kernel coordinates. Consequently
+
+    K=diag(U_h,U_t),
+    K D(E) K^-1 = D_H(Q).                                  (1)
+
+Normalizing an image column independently on the two banks would generally
+change the weighted swap. The unused kernel column is essential to (1).
+This proves a complete matrix identity over R for every admitted g and all
+unit ancestor weights. It uses neither a good-leading-minor assumption nor
+an exceptional-class probability. Its new costs are billed below; this is
+not permission to delete the original fallback charge from R437's invoice.
+
+## 3. A fixed-support word of elementary shears
+
+For U in SL_d(R), d>=2, the reference compiler emits exactly
+
+    L_d = 3d(d-1)/2 + d(d-1) + 6(d-1)
+        = (d-1)(5d+12)/2
+
+elementary factors. Their ordered (target,source) pairs are independent of
+U, q, w, the prefix and the column. Zero coefficients remain emitted and paid.
+
+At Gaussian column j, the invertible remaining residue-field block has a
+nonzero entry in that column, hence a unit pivot over R. Select its first
+row k. For **every** candidate k>j emit
+
+    E_(j,k)(s), E_(k,j)(-s), E_(j,k)(s),
+    s=1 if k is selected, and 0 otherwise.
+
+The selected triple is a signed row exchange, of determinant one; the other
+triples are identities. Then emit one elimination shear for every i!=j,
+including a zero shear if the entry is already zero. Previous diagonal
+columns stay diagonal because the pivot row is zero in them. The reduction
+G U=D is diagonal, and det(D)=1. This proves the first two terms of L_d.
+
+For each i<d-1, the diagonal pair diag(b_i,b_i^-1) on (i,d-1) is six shears:
+w(b_i) w(-1), where
+
+    w(a)=E_(i,k)(a) E_(k,i)(-a^-1) E_(i,k)(a).
+
+Their product gives D, since b_(d-1)=product_(i<d-1) b_i^-1. Reverse the
+elimination factors and negate their coefficients to obtain U=G^-1 D.
+This proves both correctness and the last term of L_d. `factor_sl` records
+chronological **left** actions; `word_matrix` multiplies them in that order.
+For pullbacks, the stream operation order is the reverse matrix factor order.
+The inverse word is again formed by reversal and negation, not by reusing
+the forward word. These conventions are part of the statement.
+
+At d=64, L=10458. The two banks and both conjugation directions have 4L=41832
+factor slots. The numerical coefficients can vary across columns, while their
+support remains fixed. Therefore a caller can process one factor across all
+f columns, recomputing its scalar from the authenticated header and encoded
+column index. It need not keep f matrices or a data-sized operation trace.
+All determinant, inverse and coefficient preparation remains charged work.
+
+This is an algebra compiler and an effective finite-control construction
+argument. The Python reference uses host integers for the exact ring algebra;
+it is **not** an implementation of that encoded physical compiler.
+
+## 4. Whole-packet caller, chronological restoration and fresh stock
+
+Use this successful-call sequence on fixed owned roles:
+
+1. Clone the complete borrowed source into an owned current stream.
+2. Apply K^-1 to its addresses using the elementary factor word.
+3. Invoke one complete reversed interchange on the first seven image blocks
+   and their reflected tail partners.
+4. Apply K, return its complete output into the private role, and release
+   every intermediate after its last reader.
+5. Keep that private output unchanged throughout the literal read-only COPY
+   window. At the existing transported equality guard, clear it and reset
+   its owned port before reuse.
+
+The displayed sequence is address-vector order; its pullback implementation
+uses the corresponding reversed factor schedule so its output is f_in
+composed with K D(E) K^-1. Induction on completed source-preserving primitive
+returns proves this for arbitrary functions. The source may itself be any
+correlated XOR of earlier dirty inputs. Equation (1) then supplies exactly
+the complete map required by PR3936; matrix rank alone would not suffice.
+
+The central child is **outside** the prefix loop. Its three spectators are
+
+    B'=B, G'=G A^(114f+2delta), S'=S,
+    child width=7f, fresh rows=U, frozen physical prefixes=Z.
+
+Their product with A^(14f) is exactly the original complete packet volume v.
+The injection preserves each peeled atom and the external G, not just the
+product of their cardinalities. The child receives the entire packet with
+all Z prefixes. It cannot deduplicate equal header values or make Z separate
+coarse calls. The requested child weight is one after conjugation; the caller
+must bind that request and preserve its frozen program/directory context.
+We do not assert that the present `SelectedBinding` has been replaced by this
+new schedule or that an arbitrary reset of its source program is legal.
+
+For the inherited compatible stock, let W=28416,
+N=|GL64(F_q)|, H=q^(4096(w-1)), M=lcm(28416,28425)=269241600, K0=MNH and
+D(n)=0 below 64, otherwise 1+D(42 floor(n/64)). A parent row count
+t K0^D(n) gives U=t*9475*K0^(D(n)-1). Since 7f<=42f<n,
+D(7f)<=D(n)-1; the required child divisor K0^D(7f) divides U. It is crucial
+that U is a fresh row coordinate, not U*B or a cardinality reconstructed from
+the transformed payload. Ordinary adapter interchanges below require their
+own stock-free completed contract, rather than spending this U again.
+
+Returned source identity, program identity, width, depth, complete prefix
+count, three extents and successor label belong to the continuation contract.
+The PR2809 fixed-role protocol parks and restores them before the parent
+resumes. Its implementation and universal refinement remain dependencies;
+we have not independently proved them by checking this matrix reduction.
+
+## 5. The reverse-order adapters and a complete relative time inequality
+
+Let b(v,u) bound a completed same-q **ordinary** interchange of two adjacent
+or separated blocks of u atoms, preserving the full intervening spectator.
+Its bit/radix width is u*w; B1/B2 have the conditional form
+
+    b(v,u) <= C_B v (u w)^p + E_B,  p=1-a_B.
+
+Let t(v,7f,w) bound the completed reversed central child on the exact stock
+and shape above. Neither function is an oracle of zero cost. Both include
+their numerical work, output, full restoration, and input-head returns.
+
+A shear whose source is physically earlier than its target is a complete
+ordered ADD pass, performed for each column with that column's generated
+coefficient. For the reverse direction, first ordinary-interchange its two
+**whole f-atom blocks**, perform the now-ordered column ADDs, then interchange
+the blocks back. The block swaps preserve internal column order; they do not
+replace the central reversed child. This costs two b(v,f) calls per reverse
+factor. The coefficient depends only on saved prefix/index metadata, so it
+can be evaluated after the payload block swap without reading changed body
+values. Both ordinary calls act on the entire packet, with all Z prefixes.
+
+Head and reflected-tail words have the same support but opposite physical
+order. In each head/tail pair exactly L factor slots are reverse-order,
+including zero coefficients. The inverse pair contributes another L. Thus
+the complete paid schedule has
+
+    one reversed child of width 7f;
+    41832*f ordered scalar ADD passes;
+    41832 ordinary block interchanges of width f;
+    one initial complete clone and one final guarded disposal.
+
+In addition there are at most 41832*f+41832+1 intermediate output releases,
+one after each completed primitive. These are genuine scans. They fit the
+linear term below and do not erase arbitrary borrowed state. This accounting
+does not add a second reversed uncompute: the owned clone is transformed and
+later cleared. Conversely it does not make any linear release free.
+
+Let gamma be the total cost of evaluating the actual header/index-dependent
+unit weights, determinant-normalized factor coefficients and projected Counts,
+including all work erasure. Do not substitute a constant for gamma outside
+its admitted domain. Complete ordered ADD, copying, rewinding, transfers and
+disposal give the relative inequality
+
+    C_COPY(v,n,w) <= t(v,7f,w)
+       +41832*b(v,f) + C_q*v*(41832*f+41832+3) + gamma.       (2)
+
+Source/directory production and owner gather/route/scatter occur in the outer
+caller and are **additional**. They are not eliminated by (2). If they are
+included in the definition of a complete requested episode, append their
+actual producer and return charges to its right side. The existing same-q
+ordinary backend has no binary-padding volume factor at this interface.
+
+Equation (2) is a bound for all positive spectators, not a measured simulator
+runtime. Under the imported canonical root/history coupling and polynomial
+coefficient-preparation argument, gamma and Count setup can be absorbed into
+the local C_q*v*(f+1) allowance. Without that argument retain gamma, E_B and
+the actual encoded widths explicitly. This new package does not independently
+re-prove the source callback's universal polynomial bound.
+
+The resulting simplified **conditional** bound is
+
+    C_COPY <= t(v,7f,w) +41832*C_B*v*(f*w)^p
+                              +C'_q*v*(f+1).              (3)
+
+All terms in (3) are present; there is no bad-class multiplier on the added
+ordinary term. This is a different proposed implementation from the original
+good/fallback construction and cannot inherit its invoice without a new proof.
+
+## 6. Storage, exact arithmetic and successful cleanup
+
+Let S_R,S_B,S_A denote each completed backend's maximum **owned** visited-cell
+span, excluding its borrowed current input but including output, templates,
+numerical work, markers and parking. Let M_coef be this reduction's numerical
+and control storage, also including blank-but-visited backing. One conservative
+full bound, including the original borrowed source and owned current stream, is
+
+    S_COPY <= 2v + S_R(v,7f,w) + S_B(v,f*w) + S_A(v)
+                  + M_coef + F_q.                         (4)
+
+The backends execute sequentially, so their active contents can instead use
+the maximum of their owned live-content bounds. For **visited physical cells**,
+separate backend tape inventories are safely added as in (4). Replacing their
+sum by a maximum needs a proved shared-pool realization; cleanup alone does
+not unvisit tape cells. No factor f, Z or recursion depth multiplies their
+sequential inventories. The factor scalars can be recomputed per header and
+column using constant-size matrices; no length-f coefficient array is required.
+If the backend reserve and metadata absorption premises give O_q(v)+F_q,
+(4) has that same form, with a new constant. It does not establish a numerical
+constant or fit the complete machine into nine reserved family packets.
+
+All address arithmetic is exact in Z/q^w. Inverses are requested only for
+units; P's dyadic denominators are units at odd q. Determinant normalization
+and scalar elimination introduce no floating approximation or fractional-bit
+rounding. Payloads remain Boolean. This local observation supplies no global
+integer-product recovery, complex-side numerical, or interrupted-macro
+restoration theorem. Borrowed data stay intact throughout successful calls;
+owned work closes through the named backend contracts and explicit releases.
+
+## 7. Source binding and finite checks
+
+The retained word is PR3647 at a24f9ff95c12fd0b6792e3f710569237efd72db2,
+as byte-bound in PR3936 commit 125f5afad680ef128e386fa58e76eef5fadaa5d6.
+Its nine retained centres are 470..478. Replaying frame assignments through
+sections D and A derives the actual capture frames 510..518. The new checker
+reconstructs their projectors directly from the root rows; it imports no
+predecessor executable. It checks 45 modular contexts over q=3,5,7,11,
+including precision two, nonorthogonal high matrices and weighted ancestors.
+A full ambient-64 case has a deliberately zero leading seven-by-seven minor
+yet still compiles. This tests a case excluded by the usual leading-minor
+good branch, without implying that the new physical tariff is cheap.
+
+A complete 81-address small cube checks arbitrary Boolean data across repeated
+physical-prefix labels and independent spectators. It is a function-model
+check, not selected GL64 payload execution. The independent checker obtains
+the rank-seven projectors from the one-dimensional rational nullspaces, rather
+than the producer's orthogonal elimination, and independently counts the fixed
+factor support and its physical order.
+
+Normal/optimized equality and actual exported CLI source/result/missing/symlink
+controls are separate from the algebra checks. They cannot turn an unimplemented
+physical compiler or inherited source theorem into independent validation.
+CI3936 was checked first: run 39202988286, plan and registered replay both
+completed successfully, including its unchanged-input check. That CI replays
+the earlier package, not this all-parameter proof.
+
+## 8. Admission decision and smallest remaining task
+
+The requested inherited cheap rank-seven bound is **not closed** by this route.
+The extra term in (3) is not t(v,7f,w), and the rank label seven does not pay it.
+For a diagnostic use the retained R437 scalar target
+c_R=1736646042038446578551/10^24, the root scaling w approximately e^c_R,
+and n approximately e. A claimed local allowance O(v*(n+w^p)) has leading
+power v*e. The new ordinary term has power v*e^((1+c_R)*p).
+For the pinned original B1 rate a1=(17/10000)(1-17/10000), and even the stronger
+B2 rate a2=(17/10000)(1-(17/10000)^2), exact arithmetic gives
+
+    (1+c_R)*(1-a1)-1 > 0,
+    (1+c_R)*(1-a2)-1 > 0.
+
+Thus those **available upper bounds** do not justify absorbing this term
+into that allowance with an input-independent constant. This is not a lower
+bound on actual runtime, not a counterexample to the original good/fallback
+algorithm, and not an impossibility theorem for a different COPY realization.
+It is a failed cost implication for this generic replacement schedule.
+
+Continue only after binding a cheaper reverse adapter, sharing it inside an
+actual child/consumer, or supplying an affordable different factorization.
+Start with one nonzero reverse factor, its generated coefficient and the exact
+source-preserving complete-packet interface. Preserve the full return, scratch,
+preparation and disposal bill. Separately, independently review C0/B1's universal
+source/refinement arguments before treating the conditional composition as a
+physical supplier proof. No selected result or frontier is changed here.
diff --git a/research/r437-parabolic-copy/inputs/r437-word.json.gz b/research/r437-parabolic-copy/inputs/r437-word.json.gz
new file mode 100644
index 0000000000..c558a221dd
Binary files /dev/null and b/research/r437-parabolic-copy/inputs/r437-word.json.gz differ
diff --git a/research/r437-parabolic-copy/parabolic.py b/research/r437-parabolic-copy/parabolic.py
new file mode 100644
index 0000000000..fab164afc7
--- /dev/null
+++ b/research/r437-parabolic-copy/parabolic.py
@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Chris R / Clear1nsight, with substantial OpenAI Codex assistance.
+"""Parabolic graph compiler and ordered-operation model; no physical backend."""
+from itertools import combinations
+from math import gcd, prod
+
+
+def require(test, message):
+    if not test:
+        raise ValueError(message)
+
+
+def identity(n):
+    return [[int(i == j) for j in range(n)] for i in range(n)]
+
+
+def multiply(a, b, modulus):
+    out = [[0] * len(b[0]) for _ in a]
+    for i in range(len(a)):
+        for k, x in enumerate(a[i]):
+            if x:
+                for j, y in enumerate(b[k]):
+                    if y:
+                        out[i][j] = (out[i][j] + x*y) % modulus
+    return out
+
+
+def inverse(a, modulus):
+    n = len(a)
+    work = [list(row) + unit for row, unit in zip(a, identity(n))]
+    for j in range(n):
+        pivot = next((k for k in range(j, n) if gcd(work[k][j], modulus) == 1), None)
+        require(pivot is not None, 'nonunit minor')
+        work[j], work[pivot] = work[pivot], work[j]
+        scalar = pow(work[j][j], -1, modulus)
+        work[j] = [scalar*x % modulus for x in work[j]]
+        for k in range(n):
+            if k != j:
+                scalar = work[k][j]
+                work[k] = [(x-scalar*y) % modulus for x, y in zip(work[k], work[j])]
+    return [row[n:] for row in work]
+
+
+def row_add(matrix, i, j, a, modulus):
+    matrix[i] = [(x+a*y) % modulus for x, y in zip(matrix[i], matrix[j])]
+
+
+def word_matrix(word, n, modulus):
+    ans = identity(n)
+    for i, j, a in word:
+        row_add(ans, i, j, a, modulus)
+    return ans
+
+
+def invert_word(word):
+    return [(i, j, -a) for i, j, a in reversed(word)]
+
+
+def choose_chart(projector, rank, modulus, supplied=None):
+    n = len(projector)
+    candidates = [tuple(supplied)] if supplied is not None else combinations(range(n), rank)
+    for subset in candidates:
+        require(len(subset) == rank and tuple(sorted(set(subset))) == subset and
+                all(0 <= i < n for i in subset), 'invalid principal subset')
+        try:
+            inverse([[projector[i][j] for j in subset] for i in subset], modulus)
+        except ValueError:
+            continue
+        return subset
+    raise ValueError('no unit principal chart')
+
+
+def pivot_groups(n, rank, subset):
+    # One active candidate per stage permits grouping the three signed-swap
+    # shears into three stars. Zero flags retain fixed support and full payment.
+    groups = []
+    for i in range(rank):
+        candidates = range(i+1, n-rank+i+1)
+        first = [(i, k, int(subset[i] == k)) for k in candidates]
+        middle = [(k, i, -int(subset[i] == k)) for k in candidates]
+        groups.extend([('star', first), ('star', middle), ('star', first[:])])
+    require(sum(len(word) for _, word in groups) == 3*rank*(n-rank), 'pivot schedule count')
+    return groups
+
+
+def diagonal_word(diagonal, modulus, rank=None):
+    require(prod(diagonal) % modulus == 1, 'diagonal determinant')
+    n, out = len(diagonal), []
+    count = n-1 if rank is None else rank
+    require(all(diagonal[i] == 1 for i in range(count+1, n)), 'unused kernel diagonal')
+    for i, a in enumerate(diagonal[:count]):
+        k = count
+        out += [(k, i, -a*(a-1)), (i, k, -pow(a, -1, modulus)),
+                (k, i, a-1), (i, k, 1)]
+    return out
+
+
+def compile_banks(projector, rank, weights, modulus, supplied=None):
+    n = len(projector)
+    require(0 < rank < n, 'nontrivial rank')
+    require(multiply(projector, projector, modulus) == projector, 'idempotence')
+    require(len(weights) == n and all(gcd(x, modulus) == 1 for x in weights), 'unit weights')
+    subset = choose_chart(projector, rank, modulus, supplied)
+    pivots = pivot_groups(n, rank, subset)
+    jmat = word_matrix([entry for _, word in pivots for entry in word], n, modulus)
+    q = multiply(multiply(jmat, projector, modulus), inverse(jmat, modulus), modulus)
+    a = [row[:rank] for row in q[:rank]]
+    b = [row[rank:] for row in q[:rank]]
+    c = [row[:rank] for row in q[rank:]]
+    x = multiply(c, inverse(a, modulus), modulus)
+    z = [[-entry % modulus for entry in row] for row in b]
+    upper = [(i, rank+k, z[i][k]) for i in range(rank) for k in range(n-rank)]
+    lower = [(rank+k, i, x[k][i]) for k in range(n-rank) for i in range(rank)]
+    t0 = word_matrix(upper+lower, n, modulus)
+    e = [[int(i == j and i < rank) for j in range(n)] for i in range(n)]
+    require(multiply(multiply(t0, e, modulus), inverse(t0, modulus), modulus) == q,
+            'rank or graph identity')
+    # J H J^-1 is diagonal; signed permutation signs cancel.
+    d = [weights[next(k for k, v in enumerate(row) if v)] for row in jmat]
+    normalized = d[:rank]+[1]*(n-rank)
+    normalized[rank] = pow(prod(d[:rank]) % modulus, -1, modulus)
+    upper_h = [(i, k, a*d[i]*pow(d[k], -1, modulus) % modulus) for i, k, a in upper]
+    lower_h = [(i, k, a*d[i]*pow(d[k], -1, modulus) % modulus) for i, k, a in lower]
+    tail = [('graph', upper), ('graph', lower)] + inverse_groups(pivots)
+    head = [('single', diagonal_word(normalized, modulus, rank)), ('graph', upper_h),
+            ('graph', lower_h)] + inverse_groups(pivots)
+    return dict(head=head, tail=tail, subset=list(subset))
+
+
+def inverse_groups(groups):
+    return [(kind, invert_word(word)) for kind, word in reversed(groups)]
+
+
+def route_groups(groups, n, rank, reflected=False):
+    """Return abstract completed primitive calls in chronological left-action order."""
+    position = (lambda i: n-1-i) if reflected else (lambda i: i)
+    events = []
+    t = min(rank, n-rank)
+    pairs = [(i, n-t+i) for i in range(t)]
+    permutation = list(range(n))
+    for i, k in pairs:
+        permutation[i], permutation[k] = permutation[k], permutation[i]
+    for kind, word in groups:
+        if kind in ('graph', 'star'):
+            local_pairs = pairs
+            local_permutation = permutation
+            if kind == 'star':
+                vertices = {i for i,j,_ in word} | {j for i,j,_ in word}
+                centre = min(vertices)
+                endpoint = max(vertices)
+                require(all(i == centre or j == centre for i,j,_ in word), 'fixed-centre star')
+                local_pairs = [(centre, endpoint)]
+                local_permutation = list(range(n))
+                local_permutation[centre],local_permutation[endpoint] = endpoint,centre
+            ordered = [position(j) < position(i) for i, j, _ in word]
+            require(all(ordered) or not any(ordered), 'one bipartite orientation')
+            if all(ordered):
+                events.extend(('add', i, j, a) for i, j, a in word)
+            else:
+                events.extend(('swap', i, k, 0) for i, k in local_pairs)
+                events.extend(('add', local_permutation[i], local_permutation[j], a) for i, j, a in word)
+                events.extend(('swap', i, k, 0) for i, k in reversed(local_pairs))
+        else:
+            for i, j, a in word:
+                if position(j) < position(i):
+                    events.append(('add', i, j, a))
+                else:
+                    events.extend([('swap', i, j, 0), ('add', j, i, a), ('swap', i, j, 0)])
+    require(all(kind != 'add' or position(j) < position(i) for kind, i, j, _ in events),
+            'every emitted ADD is physically ordered')
+    return events
+
+
+def execute(events, n, modulus):
+    ans = identity(n)
+    for kind, i, j, a in events:
+        if kind == 'swap':
+            ans[i], ans[j] = ans[j], ans[i]
+        elif kind == 'add':
+            row_add(ans, i, j, a, modulus)
+        else:
+            raise ValueError('unknown primitive')
+    return ans
+
+
+def direct_residual(q, weights, modulus):
+    n = len(q)
+    ans = [[0]*(2*n) for _ in range(2*n)]
+    for i in range(n):
+        for j in range(n):
+            c = (int(i == j)-q[i][j]) % modulus
+            ans[i][j] = weights[i]*c*pow(weights[j], -1, modulus) % modulus
+            ans[i][n+j] = weights[i]*q[i][j] % modulus
+            ans[n+i][j] = q[i][j]*pow(weights[j], -1, modulus) % modulus
+            ans[n+i][n+j] = c
+    return ans
+
+
+def block_diagonal(a, b):
+    n = len(a)
+    return [row+[0]*n for row in a] + [[0]*n+row for row in b]
+
+
+def complete_model(projector, rank, weights, modulus, supplied=None):
+    n = len(projector)
+    banks = compile_banks(projector, rank, weights, modulus, supplied)
+    matrices, counts, supports = {}, {'add': 0, 'swap': 0}, []
+    for bank in ('head', 'tail'):
+        for backwards in (False, True):
+            groups = inverse_groups(banks[bank]) if backwards else banks[bank]
+            events = route_groups(groups, n, rank, bank == 'tail')
+            for kind, *_ in events:
+                counts[kind] += 1
+            matrices[bank, backwards] = execute(events, n, modulus)
+            supports.append([(kind, i, j) for kind, i, j, _ in events])
+            if backwards:
+                require(multiply(matrices[bank, False], matrices[bank, True], modulus) == identity(n),
+                        'each bank restored exactly')
+    k = block_diagonal(matrices['head', False], matrices['tail', False])
+    kinv = block_diagonal(matrices['head', True], matrices['tail', True])
+    e = [[int(i == j and i < rank) for j in range(n)] for i in range(n)]
+    result = multiply(multiply(k, direct_residual(e, [1]*n, modulus), modulus), kinv, modulus)
+    require(result == direct_residual(projector, weights, modulus), 'complete weighted COPY identity')
+    require(counts == invoice(n, rank), 'enumerated full invoice')
+    return dict(matrix=result, counts=counts, subset=banks['subset'], supports=supports)
+
+
+def invoice(n=64, rank=7):
+    return {'add': 20*rank*(n-rank)+8*rank,
+            'swap': 20*rank+8*min(rank, n-rank)}
diff --git a/research/r437-parabolic-copy/test_package.py b/research/r437-parabolic-copy/test_package.py
new file mode 100644
index 0000000000..a5ae037534
--- /dev/null
+++ b/research/r437-parabolic-copy/test_package.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Actual optimized CLI: clean export, source corruption and stale invoice."""
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+HERE=Path(__file__).resolve().parent
+
+
+def run(root, expected, label):
+    environment=dict(os.environ)
+    environment['PATH']='/nonexistent'
+    environment['PYTHONDONTWRITEBYTECODE']='1'
+    command=[sys.executable,'-I','-O','-B',str(root/'verify.py')]
+    result=subprocess.run(command,cwd=root,env=environment,capture_output=True,text=True,timeout=30)
+    if (result.returncode==0)!=expected:
+        raise ValueError(label+': '+result.stdout+result.stderr)
+    if expected and 'PASS_PARABOLIC_COPY_RELATIVE_CONSTRUCTION' not in result.stdout:
+        raise ValueError('missing positive marker')
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix='parabolic-export-') as tmp:
+        tmp=Path(tmp)
+        clean=tmp/'clean';shutil.copytree(HERE,clean,ignore=shutil.ignore_patterns('__pycache__','*.pyc'))
+        for p in clean.rglob('*'):
+            p.chmod(0o555 if p.is_dir() else 0o444)
+        clean.chmod(0o555)
+        run(clean,True,'Git-free read-only positive')
+        for mutation in ['altered-source','missing-source','symlink-source','stale-invoice','boolean-invoice']:
+            clone=tmp/mutation;shutil.copytree(clean,clone)
+            clone.chmod(0o755)
+            for p in clone.rglob('*'):
+                p.chmod(0o755 if p.is_dir() else 0o644)
+            source=clone/'inputs/r437-word.json.gz'
+            if mutation=='altered-source':source.write_bytes(source.read_bytes()+b'bad')
+            elif mutation=='missing-source':source.unlink()
+            elif mutation=='symlink-source':
+                source.unlink();source.symlink_to(clean/'inputs/r437-word.json.gz')
+            else:
+                p=clone/'RESULT.json';data=json.loads(p.read_text())
+                data['ambient64_invoice']['swap']=41832 if mutation=='stale-invoice' else True
+                p.write_text(json.dumps(data))
+            run(clone,False,mutation)
+        # Make the owned temporary export removable on all supported POSIX users.
+        clean.chmod(0o755)
+        for p in clean.rglob('*'):
+            if p.is_dir():p.chmod(0o755)
+    print('PASS_OPTIMIZED_EXPORT_AND_FIVE_CLI_REJECTIONS')
+
+if __name__=='__main__':main()
diff --git a/research/r437-parabolic-copy/verify.py b/research/r437-parabolic-copy/verify.py
new file mode 100644
index 0000000000..02cd084ef8
--- /dev/null
+++ b/research/r437-parabolic-copy/verify.py
@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Source-bound finite algebra/event checks; no physical supplier admission."""
+import argparse
+from collections import Counter
+from fractions import Fraction
+import gzip
+import hashlib
+from itertools import product
+import json
+from pathlib import Path
+import random
+import sys
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from parabolic import (require, identity, multiply, inverse, row_add, word_matrix,
+                       compile_banks, complete_model, inverse_groups, route_groups,
+                       invoice, direct_residual, diagonal_word)
+HERE = Path(__file__).resolve().parent
+WORD_SHA = 'e432182d5b62c8bbefeb871fce30317234d707e5e18d4295e65ac21f7fd8365e'
+
+
+def canonical(data):
+    return json.dumps(data, sort_keys=True, separators=(',', ':')).encode()
+
+
+def authenticate():
+    sources = json.loads((HERE/'SOURCES.json').read_bytes())
+    for row in sources['retained']:
+        p = HERE/row['path']
+        require(p.is_file() and not p.is_symlink(), 'retained source missing or linked')
+        b = p.read_bytes()
+        require(hashlib.sha256(b).hexdigest() == row['sha256'], 'retained source hash')
+        require(hashlib.sha1(b'blob '+str(len(b)).encode()+b'\0'+b).hexdigest() == row['git_blob'], 'retained source blob')
+    raw = (HERE/'inputs/r437-word.json.gz').read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == WORD_SHA, 'R437 exact word pin')
+    return json.loads(gzip.decompress(raw))
+
+
+def rational_projector(rows):
+    # Reconstruct the one-dimensional orthogonal complement; no predecessor imports.
+    a = [[Fraction(x) for x in row] for row in rows]
+    pivots, k, n = [], 0, len(a[0])
+    for j in range(n):
+        p = next((i for i in range(k, len(a)) if a[i][j]), None)
+        if p is None:
+            continue
+        a[k], a[p] = a[p], a[k]
+        scalar = a[k][j]
+        a[k] = [x/scalar for x in a[k]]
+        for i in range(len(a)):
+            if i != k:
+                scalar = a[i][j]
+                a[i] = [x-scalar*y for x, y in zip(a[i], a[k])]
+        pivots.append(j)
+        k += 1
+    free = [j for j in range(n) if j not in pivots]
+    require(len(free) == 1 and len(pivots) == 7, 'literal rank-seven hyperplane')
+    v = [Fraction(int(j == free[0])) for j in range(n)]
+    for i, j in enumerate(pivots):
+        v[j] = -a[i][free[0]]
+    norm = sum(x*x for x in v)
+    return [[Fraction(i == j)-v[i]*v[j]/norm for j in range(n)] for i in range(n)]
+
+
+def modular(a, modulus):
+    return [[x.numerator*pow(x.denominator, -1, modulus) % modulus for x in row] for row in a]
+
+
+def generated_unit(n, modulus, seed):
+    rng = random.Random(seed)
+    ans = identity(n)
+    for _ in range(4*n):
+        i, j = rng.sample(range(n), 2)
+        row_add(ans, i, j, rng.randrange(modulus), modulus)
+    return ans
+
+
+def reject(action, label):
+    try:
+        action()
+    except ValueError:
+        return label
+    raise ValueError('accepted negative control: '+label)
+
+
+def finite_payload():
+    n, rank, modulus = 2, 1, 3
+    q = [[0, 0], [1, 1]]
+    weights = [2, 1]
+    banks = compile_banks(q, rank, weights, modulus)
+    vector_events = []
+    for backwards in (True, False):
+        if not backwards:
+            vector_events.append(('swap', 0, n, 0))
+        for bank in ('head', 'tail'):
+            groups = inverse_groups(banks[bank]) if backwards else banks[bank]
+            offset = n if bank == 'tail' else 0
+            vector_events += [(op, i+offset, j+offset, a) for op,i,j,a in route_groups(groups,n,rank,bank=='tail')]
+    addresses = list(product(range(modulus), repeat=2*n))
+    index = {a:i for i,a in enumerate(addresses)}
+    source = tuple(random.Random(17000+i).randrange(2) for i in range(3*2*len(addresses)))
+    # All distinct physical prefixes, including equal field-header labels, survive.
+    current = source
+    for op,i,j,a in reversed(vector_events):
+        transformed = []
+        for prefix in range(3):
+            for spectator in range(2):
+                base = (2*prefix+spectator)*len(addresses)
+                for x in addresses:
+                    y = list(x)
+                    if op == 'swap':
+                        y[i],y[j] = y[j],y[i]
+                    else:
+                        y[i] = (y[i]+a*y[j]) % modulus
+                    transformed.append(current[base+index[tuple(y)]])
+        current = tuple(transformed)
+    matrix = direct_residual(q,weights,modulus)
+    expected = []
+    for prefix in range(3):
+        for spectator in range(2):
+            base = (2*prefix+spectator)*len(addresses)
+            for x in addresses:
+                y = tuple(sum(a*b for a,b in zip(row,x)) % modulus for row in matrix)
+                expected.append(source[base+index[y]])
+    require(current == tuple(expected), 'actual event pullback on every payload cell')
+    dirty_targets = [[(i+target)%2 for i in range(len(source))] for target in range(63)]
+    original_targets = [row[:] for row in dirty_targets]
+    private = list(current)
+    for row in dirty_targets:
+        row[:] = [a^b for a,b in zip(row,private)]
+    require(all(row == [a^b for a,b in zip(old,private)] for row,old in zip(dirty_targets,original_targets)), 'all 63 dirty readers')
+    # Model-only cleanup of the actual private buffer after its last reader.
+    # Physical erasure, head restoration and scan cost remain backend premises.
+    completed_targets = [row[:] for row in dirty_targets]
+    require(any(private), 'nonzero private-buffer disposal control')
+    for i in range(len(private)):
+        private[i] = 0
+    require(not any(private), 'model private buffer erased in place')
+    require(dirty_targets == completed_targets, 'cleanup preserves completed dirty targets')
+    require(source == tuple(random.Random(17000+i).randrange(2) for i in range(len(source))), 'cleanup preserves borrowed source')
+    return {'addresses':len(addresses),'physical_prefixes':3,'spectators':2,'payload_bits':len(source),'dirty_readers':63,'primitive_events':len(vector_events)}
+
+
+def calculate():
+    word = authenticate()
+    require(word['R'] == 437 and word['ret'] == list(range(470,479)), 'current R437 captures')
+    current = word['start'][:]
+    for section in ('D','A'):
+        for frame,target,sources in word[section]:
+            for role in [target]+sources:
+                current[role] = frame
+    require([current[c] for c in word['ret']] == list(range(510,519)), 'capture frames')
+    contexts, support_hashes, projector_hashes = 0,set(),[]
+    for centre in word['ret']:
+        p = rational_projector([word['lines'][i] for i in word['frames'][current[centre]]])
+        projector_hashes.append(hashlib.sha256(canonical([[str(x) for x in row] for row in p])).hexdigest())
+        for prime,w in [(3,1),(3,2),(5,2),(7,2),(11,1)]:
+            modulus=prime**w
+            g=generated_unit(8,modulus,centre*prime+w)
+            q=multiply(multiply(g,modular(p,modulus),modulus),inverse(g,modulus),modulus)
+            units=[i for i in range(1,modulus) if i%prime]
+            weights=[units[i%len(units)] for i in range(8)]
+            result=complete_model(q,7,weights,modulus)
+            support_hashes.add(hashlib.sha256(canonical(result['supports'])).hexdigest())
+            contexts+=1
+    require(len(support_hashes)==1,'one ordered operation support across every tested low/high/weight class')
+    # Entire GL2(F3), all rank-one conjugates and all diagonal unit weights.
+    exhaustive=0
+    for values in product(range(3),repeat=4):
+        g=[list(values[:2]),list(values[2:])]
+        if (g[0][0]*g[1][1]-g[0][1]*g[1][0])%3 == 0:
+            continue
+        q=multiply(multiply(g,[[1,0],[0,0]],3),inverse(g,3),3)
+        for weights in product((1,2),repeat=2):
+            complete_model(q,1,list(weights),3)
+            exhaustive+=1
+    # Bad leading minor in full ambient64, with nonzero graph factors and weights.
+    n,r,modulus=64,7,9
+    rng=random.Random(5348)
+    upper=[(i,r+k,rng.randrange(modulus)) for i in range(r) for k in range(n-r)]
+    lower=[(r+k,i,rng.randrange(modulus)) for k in range(n-r) for i in range(r)]
+    # Multiples of3 in the graph ensure the last7 principal block stays a unit.
+    graph=word_matrix([(i,j,3*(a%3)) for i,j,a in upper+lower],n,modulus)
+    perm=identity(n)
+    for i in range(r): perm[i],perm[n-r+i]=perm[n-r+i],perm[i]
+    t=multiply(perm,graph,modulus)
+    e=[[int(i==j and i<r) for j in range(n)] for i in range(n)]
+    q=multiply(multiply(t,e,modulus),inverse(t,modulus),modulus)
+    require(all(q[i][j]%3==0 for i in range(r) for j in range(r)), 'bad leading chart is truly singular')
+    weights=[1+3*(i%3) for i in range(n)]
+    ambient=complete_model(q,r,weights,modulus,list(range(n-r,n)))
+    controls=[]
+    interleaved=[(0,1,1),(1,0,-1),(0,1,1),(0,2,1),(2,0,-1),(0,2,1)]
+    grouped=[(0,1,1),(0,2,1),(1,0,-1),(2,0,-1),(0,1,1),(0,2,1)]
+    controls.append(reject(lambda: require(word_matrix(interleaved,3,3)==word_matrix(grouped,3,3),'one-hot flags required'), 'two active pivot flags'))
+    controls.append(reject(lambda: complete_model(q,r,weights,modulus,list(range(r))), 'force bad leading chart'))
+    controls.append(reject(lambda: complete_model(q,r,[3]+weights[1:],modulus,list(range(n-r,n))), 'nonunit ancestor weight'))
+    controls.append(reject(lambda: complete_model(q,6,weights,modulus,list(range(n-6,n))), 'wrong rank'))
+    small=[[0,0],[1,1]]
+    bb=compile_banks(small,1,[2,1],3)
+    correct=complete_model(small,1,[2,1],3)['matrix']
+    controls.append(reject(lambda: require(correct==direct_residual(small,[1,1],3),'weights matter'), 'drop ancestor weights'))
+    events=route_groups(bb['head'],2,1)
+    from parabolic import execute
+    trimmed=events[:]
+    first=next(i for i,x in enumerate(trimmed) if x[0]=='swap')
+    del trimmed[first]
+    controls.append(reject(lambda: require(execute(trimmed,2,3)==execute(events,2,3),'routing restoration matters'), 'omit one router swap'))
+    controls.append(reject(lambda: require(invoice()['swap']==0,'ordinary bill nonzero'), 'free ordinary adapters'))
+    b=Fraction(17,10000)
+    target=Fraction(1736646042038446578551,10**24)
+    gaps={name:str((1+target)*(1-rate)-1) for name,rate in [('B1',b*(1-b)),('B2',b*(1-b*b))]}
+    require(all(Fraction(g)>0 for g in gaps.values()),'same positive exponent gap')
+    return {'status':'PASS_PARABOLIC_COPY_RELATIVE_CONSTRUCTION','source_capture_projector_hashes':projector_hashes,
+            'literal_contexts':contexts,'full_GL2_weighted_contexts':exhaustive,'full_ambient64_cases':1,
+            'fixed_support_hash_8':next(iter(support_hashes)),'ambient64_invoice':ambient['counts'],
+            'one_reversed_child_width':'7f','old_alternate_add_per_column':41832,'old_alternate_ordinary_calls':41832,
+            'power_gaps':gaps,'finite_payload':finite_payload(),'semantic_controls':controls,
+            'physical_backend_implemented':False,'inherited_cheap_tariff_proved':False,'supplier_admitted':False}
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--write',action='store_true');args=parser.parse_args()
+    result=calculate()
+    if args.write:
+        (HERE/'RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:
+        expected=json.loads((HERE/'RESULT.json').read_bytes())
+        require(canonical(expected)==canonical(result),'exact result receipt')
+    print(result['status'],json.dumps(result['ambient64_invoice'],sort_keys=True), 'contexts=45+192+1')
+
+if __name__=='__main__': main()