Independent verification: R420 ghost return and recursive cost screen

research/r420-exterior-frames/CLAIM.md

@@ -0,0 +1,82 @@
+# Sprint claim — independent verification
+
+- Assignment seed: **78**, generated once with Python `secrets.randbelow(100)`
+  (operating-system randomness).
+- Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+- Track: independent verification or formalization.
+- Claimed at: 2026-10-13 04:36 UTC (10:06 IST).
+- Expected finish: 2026-10-13 05:31 UTC (11:01 IST).
+- Exact object: the 672 rational frames in the selected PR543 R420 word,
+  `research/e8-bit-r420/data/bitE8mut-r420.json.gz`, source head
+  `2065fe4f72a914d907f1046603f5a36f17018535`.
+- Hypothesis: an independent exterior-algebra implementation can certify the
+  frame ranks, orthogonal projections and root-line closures, and determine
+  exactly which odd primes (if any) invalidate those finite certificates.
+- Method: integer exterior products and contraction identities; no imported
+  producer, row-reduction, Gram determinant, or prime-witness engine. Seed 78
+  rotates the root order when selecting a spanning blade and selects adversarial
+  controls. All 672 frames and all 120 root memberships per frame are covered;
+  there is no adaptive search or early-success stopping rule.
+- Deliverable: scoped mathematical note, self-contained exact checker, pinned
+  inputs, deterministic certificate and meaningful rejecting controls. No new
+  kappa or full multiplication theorem is claimed.
+- Time allocation: one hour from 04:31 UTC; selection completed within the first
+  20%; stop implementation by 05:16 UTC and reserve the remaining 15 minutes for
+  verification, overlap refresh and a single focused PR or patch handoff.
+
+## Selection and overlap
+
+Three narrow candidates were considered:
+
+1. Independent enclosure of the selected bit moment: already covered by #678;
+   #706 has also just appeared for the complex moments.
+2. Direct amplitude identities for selected cold wrappers: #702 already covers
+   all selected four-dimensional wrappers by a different exact engine.
+3. Exterior-algebra certificates for the R420 frame geometry: selected. #612
+   formalizes frame-table boundaries and B-XOR interfaces; #661 optimizes fixed
+   B-frame paths. Neither supplies this exterior projector/prime-specialization
+   check. Newly opened #707 accelerates the existing Bareiss Gram engine on the
+   same frames; this work independently checks geometry with exterior products,
+   without using that engine or its adapter. It makes no performance claim.
+
+The accepted #626/#543 certificate and actual construction/review were read,
+including the conditional compiler, hosting and analytic boundaries. The PR
+ledger, research integration index and archived frame-search negatives were
+consulted. This is verification of a fixed object, not reopening a closed search.
+The initial queue contained 523 open PRs through #704; the immediate follow-up
+was refreshed through #708 at 04:35 UTC. GitHub reports no pinned issues and
+Discussions disabled; the only open issue is #650 requesting Discussions.
+Accordingly the claim is recorded locally, without creating a reservation issue.
+
+Prepared for Ishan (@ishan-1729), with substantial OpenAI Codex assistance.
+
+## Owner-directed extension within the claimed object
+
+The owner requested ideas from `math_prime`, including Ghost Parametrization
+and Ghost Properties. The bounded extension uses the same fixed R420 word:
+test correctness of the target translation separately from restoration of
+source/helper state, then price gifting its full-frame scalar cleanup while
+retaining every frame endpoint, copy, child and hosting obligation. It does
+not start a new supplier search. The owner subsequently requested multiple
+GPT Astra subagents; seven bounded reviews cover frame geometry, independent
+F2 replay, dirty-state compatibility, overlap, provenance, adversarial scalar
+controls, and mathematical limits within the existing recursive interface.
+
+## Result
+
+Completed at the owner's wind-down request. No new exponent is claimed.
+The exact ghost screen records rank-539 restoration debt, rank-120 source
+readout drift and the helper-251 counterexample to unchanged second-call use.
+Gifting all cleanup leaves the fixed recursive profile unchanged; the selected
+complex supplier excludes the next recorded exponent grid tick under the
+inherited framework. Ten focused tests, both receipt checks, the selected
+record check and unchanged predecessor scalar/Gram checks pass.
+
+The final overlap review found concurrent #737 had submitted the same main
+exterior geometry result first. We credit Sagar Thakrar and retain that part as
+independent corroboration; the ghost return/carryover evidence is central.
+#710's restored-cleanup cost observation and #731's different compensation
+matrix are also credited. Reviewed heads are in README.md.
+
+Result: [reviewable contribution branch](https://github.com/ishan-1729/integer-mult-bounds/tree/research/r420-exterior-frames-seed78/research/r420-exterior-frames).
+See README.md and VALIDATION.md for commands, scope, provenance and outcomes.

research/r420-exterior-frames/GHOST-SCREEN.json

@@ -0,0 +1,52 @@
+{
+  "assembly": {
+    "bit_lower": "413456747036699736067/250000000000000000000000",
+    "cap_minus_selected_kappa": "456684945111964070059/1956324622484976732153468750000000000000",
+    "complex_fixed_favorable_cap": "102387919519255428911/62602387919519255428911",
+    "complex_lower": "65528268492323474503/40000000000000000000000",
+    "complex_rejected_endpoint": "102387919519255428911/62500000000000000000000",
+    "kappa": "51110230636731/31250000000000000",
+    "kappa_with_optimistically_doubled_bit_rate": "51110230636731/31250000000000000",
+    "next_1e_minus_18_grid_tick_excluded": true,
+    "source_semantic_sha256": "a7c7786172a8e8f22dcd9426a2fb48ecb554122bb433c9f333ef75f10aa15708"
+  },
+  "carryover_obstruction": {
+    "helper_to_source_rank_F2": 120,
+    "original_sources_all_zero": true,
+    "second_call_target": 0,
+    "second_call_target_error": 1,
+    "source_drift_rank_F2": 120,
+    "unit_helper_input_register": 251
+  },
+  "cleanup_gates": 2661,
+  "cleanup_scalar_xors": 2973,
+  "columns_replayed": 660,
+  "correct_target_rows_before_return": 120,
+  "debt_rows_sha256": "4e2c66610e6431bd353f63222c7e306e25af3e60cce1ff9ede4d56119c0d07eb",
+  "full_frame": 1,
+  "gifted_cleanup_child_profile": {
+    "1": 1320,
+    "2": 1440,
+    "4": 60,
+    "5": 120,
+    "8": 9
+  },
+  "helper_rows_with_debt": 420,
+  "ordinary_child_profile": {
+    "1": 1320,
+    "2": 1440,
+    "4": 60,
+    "5": 120,
+    "8": 9
+  },
+  "rank_mass": 5112,
+  "rejected_return_controls": [
+    "no_cleanup",
+    "last_cleanup_gate_omitted"
+  ],
+  "restoration_debt_rank_F2": 539,
+  "scope": "Fixed word, frames, endpoint frames and global hosting; gift all scalar C work, retain every child/copy. No new construction or kappa.",
+  "source_rows_with_debt": 120,
+  "status": "PASS_R420_GHOST_RETURN_SCREEN",
+  "word_semantic_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2"
+}

research/r420-exterior-frames/GHOST-SCREEN.md

@@ -0,0 +1,188 @@
+# A ghost-state return screen for the fixed R420 supplier
+
+**Scoped negative result, not a new construction or a general impossibility
+theorem.** Allowing this word's source/helper state to remain temporarily
+unrestored does not improve its paid recursive profile when its frames,
+endpoint contract, copies, children and hosting stay fixed. Even gifting every
+scalar cleanup operation leaves the profile unchanged. Moreover, the selected
+assembly is already complex-bound, so improving the bit rate alone cannot
+improve its recorded exponent on the existing 10^-18 output grid.
+
+## Hypothesis and exact return condition
+
+The motivating Ghost Parametrization idea is to enlarge the working state,
+preserve an exact property, and separately establish return to the required
+output state. Ishan's `math_prime` work suggested applying that distinction to
+dirty auxiliary registers. This note defines the complete application here;
+it does not import a theorem, algorithm, or text from that project.
+
+Let z comprise the 120 source and 420 helper registers, and y the 120 targets.
+After the word's D, A, scatter and B sections, exact F2 replay has the form
+
+```text
+(z, y) -> (U z, y + S z),
+```
+
+where S selects the original 120 sources. U has no target dependence. The
+ghost property is correctness of the target translation; the return condition
+is additionally `U=I` on arbitrary source and helper input, not merely on clean
+helpers. Section C restores that condition. This is the scalar state contract;
+the frame and compiled child contracts are additional requirements.
+
+The independent bit-packed replay covers every one of the 660 input columns.
+Before C, all 120 targets are correct, but all 120 source rows and 420 helper
+rows differ from the identity. `rank_F2(U-I)=539`. This rank diagnoses a failed
+return condition; it is **not** a lower bound of 539 gates, copies, new helper
+registers, or recursive children. With the full word every required row is
+correct. Both omitted C and omitted last C gate are rejected. These controls
+exercise the endpoint identity directly, independently of source hash checks.
+
+## Favorable cost before implementation
+
+All 2,661 C gates (2,973 scalar XORs) are at the full frame. All z registers
+already have that same required final frame. Thus, if C's scalar XORs are
+gifted at zero cost, each frame climb previously needed by C is still needed
+by the final-frame contract. It moves to the endpoint with the same source
+frame, destination frame, and rank. Earlier gates and nine retained helper
+copies do not change. Exact replay checks this accounting:
+
+| Child rank | Ordinary count | Cleanup gifted |
+|---:|---:|---:|
+| 1 | 1,320 | 1,320 |
+| 2 | 1,440 | 1,440 |
+| 4 | 60 | 60 |
+| 5 | 120 | 120 |
+| 8 | 9 | 9 |
+
+Both rank masses are 5,112. Every source-access gate, helper, frame change,
+retained copy and recursive child outside the gifted scalar cleanup remains
+charged. In particular this does not treat the unrestored word as a valid
+replacement supplier.
+
+With the selected nine-stage composition and whole-call hosting held fixed,
+the inherited full profile is
+
+```text
+H = {1:380160, 2:426624, 4:32640, 5:34560,
+     6:15360, 7:23040, 8:2592, 42:3456}.
+m=64, W=30720, sum(r H[r])=1956096.
+```
+
+These values are pinned in `research/e8-bit-r420/EXPECTED.json`. The cleanup
+gift changes only the finite scalar overhead in that composition; it leaves
+the child profile and inherited bad-class contribution unchanged. Hence the
+same bit moment inequality determines the same rate. This is a price-first
+rejection of the fixed-interface mechanism, not an unsuccessful large search.
+Changing endpoint frames, copied information, or child interfaces is outside
+this class and needs a new complete invoice and compatibility proof.
+
+More explicitly, with `E=sum(H[r])=918432`, the complete contraction moment is
+
+```text
+Phi(c) = sum_r [r H[r]/(64*30720)] (64/r)^c
+         + [9567/1562500000000000] 64^c.
+```
+
+The second term is the inherited bad-class charge `32*m*E/(10^16*W)`.
+The deficit is 9,984. Gifting C removes at most `288*2973=856224` scalar XORs
+from the additive invoice, while leaving every term of Phi unchanged. The
+pinned `assemble9.py` sends scalar additions to `unit`/`coefficient`, whereas
+the moment depends only on H, m, W and E. This prices the existing complete
+recursive profile; it supplies no recurrence for a new ghost compiler.
+
+## Why the same dirty state cannot feed an unchanged next call
+
+There is a concrete obstruction beyond the failed final return condition.
+Write P for projection from z onto its original source coordinates. The exact
+map above is `G(z,y)=(Uz,y+Pz)`, so two unchanged invocations yield
+
+```text
+G^2(z,y) = (U^2 z, y + Pz + PUz).
+```
+
+For the fixed word, `rank(PU-P)=120`, and the helper-to-source block of U also
+has rank 120. With all sources zero and only helper register **251** set to
+one, `(Uz)_0=1`. The second call therefore adds one to target 0, although its
+original source was zero. This is an exact counterexample to using the same
+readout on carried dirty state; it is not a counterexample to all possible
+ghost interfaces. Helper dirt can induce arbitrary source drift.
+
+The pinned nine-stage `global_k.py` requires every z row restored and the
+canonical target shear in both orientations. Its retained-copy window also
+requires the center to remain unchanged through erase. A new encoding E of
+the ghost state would require subsequent children to read `P E^-1`, compatible
+bridge and copy operations, and final reconstruction back to E=I. Those
+operations and any frame changes or extra children must be priced. No such
+construction is supplied here, and the already-favorable fixed-profile price
+cannot improve the exponent.
+
+## The other supplier still binds
+
+The consumed assembly is the accepted #626 replay, not the historical kappa
+in the #543 supplier's own receipt. Its exact lower endpoints are
+
+```text
+b = 65528268492323474503/40000000000000000000000
+c = 413456747036699736067/250000000000000000000000
+kappa = 51110230636731/31250000000000000
+```
+
+Here c is the bit rate and b the complex rate; `c>b`. The screen independently
+implements the pinned seven-level arithmetic using exact fractions:
+
+```text
+eta = beta = 10^-24
+s = min(c, (1-beta)b) - 10^-27
+a_0 = 384599/10^10
+a_(j+1) = (1-s)s + s a_j,  j=0,...,6
+q = (1-2 eta)a_7
+margin = (1-eta)q/(1+q)
+kappa = largest multiple of 10^-18 strictly below margin.
+```
+
+Replacing c by 2c reproduces exactly the same kappa. This is an intentionally
+favorable arithmetic control, not a claim that a doubled bit rate is attainable.
+The complex moment's next rejected endpoint in the pinned receipt is
+`b_plus=b+10^-24`. Inheriting that moment certificate and its monotonicity,
+even eliminating outer losses and taking the limiting iteration gives the
+favorable ceiling `b_plus/(1+b_plus)`. Its excess over the selected kappa is
+exactly
+
+```text
+456684945111964070059/1956324622484976732153468750000000000000
+```
+
+which is strictly between zero and 10^-18. This excludes the next recorded
+grid tick with that complex supplier fixed, within the inherited moment and
+outer-assembly framework. It does not exclude every smaller
+real-number improvement or a different complex supplier, and does not claim
+a universal exponent ceiling.
+
+## Reproduction and boundaries
+
+```sh
+python3 -I -B research/r420-exterior-frames/ghost_screen.py
+```
+
+Expected: `PASS_R420_GHOST_RETURN_SCREEN: debt rank 539; 2973 gifted XORs; child profile unchanged; selected kappa unchanged; 2 rejected returns`.
+
+[GHOST-SCREEN.json](GHOST-SCREEN.json) contains the exact result, both profiles,
+debt-row digest and fraction comparisons. [SOURCE.json](SOURCE.json) pins the
+word and selected assembly. The implementation imports this package's exterior
+geometry checker, but no producer, original scalar replay or moment engine.
+The two ghost tests compare F2 rank against exhaustive image cardinality on
+all 512 binary 3x3 row sets and check that target correctness does not satisfy
+the restored endpoint. The geometry check has its own separate controls.
+
+The screen does not re-prove the selected moment enclosures or compiler,
+common-label, mutable-basis, hosting, precision, tape or analytic assumptions.
+The finite F2 replay is exact for this word; the fixed-profile conclusion is
+the cost argument above. Neither is a formal proof of the full multiplication
+theorem, nor a reason to abandon other ghost-state mechanisms.
+
+Concurrent predecessor credit: #710 already shows that shorter full-frame
+scalar cleanup leaves the recursive terms unchanged; this screen extends the
+favorable relaxation to all cleanup and tests the actual failed return.
+#731's rank-120 helper-to-target compensation matrix is a different map from
+the rank-120 helper-to-source drift certified here. #737 independently reached
+the supporting exterior-frame result first. See README.md for reviewed heads.

research/r420-exterior-frames/NOTICE.md

@@ -0,0 +1,53 @@
+# Attribution and license
+
+Prepared for Ishan (@ishan-1729), with substantial OpenAI Codex assistance in
+research, implementation, mathematical exposition, tests and packaging.
+GPT-6 Astra subagents provided independent geometry review, a separately
+implemented scalar replay, and a bounded recursive-interface audit. Their
+checks are computational/mathematical reviews, not proof-assistant proofs.
+New files are contributed under this repository's Apache-2.0 license.
+
+The unchanged R420 word and its construction are due to eumemic, with
+substantial Anthropic Claude assistance, in PR #543, source commit
+`2065fe4f72a914d907f1046603f5a36f17018535`. Its own
+[`NOTICE.md`](../e8-bit-r420/NOTICE.md) preserves the full predecessor chain,
+including the D4 carrier skeleton, retained totals, hosting and pricing work.
+No supplier source is vendored or relicensed by this package.
+
+The reference exporter and Gram/prime-witness checkers are credited to Dylan
+Crow / utcorvusvolat-dotcom and their recorded predecessors; see
+[`NOTICE.md`](../e8-bit-carrier-skeleton/NOTICE.md). Their implementation was
+consulted for the exact obligation, but this geometry verifier uses exterior
+products and contractions and imports none of those engines. The original
+R420 scalar/nullspace checker is eumemic's independent checker. Concurrent
+PR #707 by CharlesBethin optimizes the inherited Gram engine; our result is
+independent geometry evidence, not a competing timing claim.
+
+The selected #626 complex construction and its accepted review are credited
+to their authors and retained source notices in
+[`community-k492-review.md`](../../docs/research/community-k492-review.md) and
+[`complex-k492-owner-repair`](../complex-k492-owner-repair). Exact source pins
+appear in [SOURCE.json](SOURCE.json). The cost screen inherits the selected
+assembly's moment certificate and does not claim authorship of that bound.
+
+Concurrent exterior-algebra work by Sagar Thakrar / @thakrarsagar in
+[PR #737](https://github.com/CrocSwap/integer-mult-bounds/pull/737) reached
+the same main geometry result before this submission. The geometry code here
+was independently developed; its inclusion is corroboration, with additional
+all-pairs inclusion/complement coverage. The distinct result is the ghost
+return screen. Credit also [PR #710](https://github.com/CrocSwap/integer-mult-bounds/pull/710)
+for restored cleanup conjugation and unchanged child pricing, and Joshua
+Snider's [PR #731](https://github.com/CrocSwap/integer-mult-bounds/pull/731)
+for the different helper-to-target compensation map. None is a code dependency.
+
+The owner suggested Ghost Parametrization and Ghost Properties from their
+`math_prime` research as motivation: distinguish an enlarged working state
+and preserved property from exact return to the desired state. Only that
+methodological idea is used; no private project text or code is reproduced,
+and no result from that project is a dependency of this public certificate.
+The operational definition and the bounded test are self-contained here.
+
+PR #612's formal boundary work, #661's fixed-order optimization, #678's bit
+moment verification, and #702's cold-wrapper amplitude audit informed scope
+selection. This package neither supersedes those contributions nor turns
+their different scopes into alleged defects.