Supplier-boundary audit: all 36 selected frontier1094 residual wrappers exact with global phase, by two kernels (no new kappa)

[thakrarsagar]

Supplier-boundary audit: an independent, byte-bound check. No new κ, and the selected record is unchanged.

All 36 residual wrappers stored in the selected frontier1094 gauge44 word are exact. They satisfy L ∘ F_w ∘ R ∘ T_E = T_end on all 512 columns, including global phase. Two independent kernels check this.

• Track: adversarial audit, seed 62.
• Card: supplier-boundary-audit, scope refined.
• Base: 179089e4.
• Package: research/frontier1094-residual-wrappers-seed62/.

Why this is needed

Lemma A's exact part (e8-lemma-a-lean, e8-lemma-g-lean/PROOF.md §4) needs a stored wrapper (L, R) for every helper that enters at a nonzero frame E or ends at a hyperplane U. Each wrapper must satisfy L ∘ (C_[w] ⊗ I) ∘ R = T_end ∘ T_E⁻¹. For the selected word these are the 36 records in RESIDUAL-ADAPTERS.json (383f40aa).

Tracing the acceptance in the selected chain:

• The bytes are pinned. Both the owner audit and the certificate's fresh invoice (input_sha256.fresh_invoice → PREFIX-AND-INVOICE.json → providers.gauge44.artifacts) pin RESIDUAL-ADAPTERS.json. The fresh invoice also pins WRAPPER-CHECKS.json.
• The chain's own audit checks structure only. gauge44-slots-t16/code/audit_allcold.py (lines 56–61) checks only the wrappers' structural fields: frame, terminal, vectors and ranks.
• Exactness is established only by the producer's own code. hpe_adapters_local.py generates the wrappers and decodes them again with the same clifford_exact primitives, writing WRAPPER-CHECKS.json (PASS_RESIDUAL_WRAPPERS_ARE_EXACT).
  • The cold replay re-runs that producer (e.g. gauge44-slots/construction/slots/verify_slots.py:103).
  • No chain code reads the receipt's status or content.
• Our merged Independent verification: every child record and endpoint adapter of the selected frontier1094 CLIFFORD-RECIPES exact with global phase (no new kappa) #1781 checked the child and endpoint records but explicitly left these 36 open.

Result

PASS_FRONTIER1094_RESIDUAL_WRAPPERS_EXACT:

	Records	Kernel B	Kernel A
FULL-ended	22	exact	exact
Cold hyperplane-end 0:U	12	exact	exact
Entering hyperplane-end (2:999, 3:998)	2	exact	exact

Every identity holds on all 512 columns, with the global phase included.

How

• Binding.
  • The merged Independent verification: every child record and endpoint adapter of the selected frontier1094 CLIFFORD-RECIPES exact with global phase (no new kappa) #1781 binding is imported with its digests pinned: selected record → frontier1094 certificate → capsule → owner audit → word and programs.
  • RESIDUAL-ADAPTERS.json must equal the owner audit's own digest.
  • The split-centres decoy has the same basename and is rejected by digest.
  • The certificate's fresh invoice pins both files' bytes.
  • The global8 twin is byte-identical.
• Inventory.
  • The 36 keys are exactly the word's entering helpers ending at FULL (key = start) and its hyperplane-ending helpers (key = start:final).
  • Every record's frames, vectors and ranks match the word, and all 72 monomials are well formed.
  • In both programs, each of the 240 wrapped helpers has exactly one pre and one post residual event, with the correct key. The pre comes first and the post last.
• Kernel B (closed_form.py, new, standard library only) works from closed-form amplitudes: the frame operator's closed formula, the closed form of the monomial records, and F_w as a product of √X gates. It uses sparse exact columns and evaluates no gate lists. Before judging any record:
  • its frame operator must reproduce Research audit: verify all selected cold-wrapper amplitudes (no new kappa) #702's 14 frame-kernel digests and Independent audit: semantic binding of three Lean HPE Clifford pairs (no new kappa) #1415's three operator digests;
  • its monomials and F_w must equal kernel A's on every column.
• Kernel A is Independent verification: every child record and endpoint adapter of the selected frontier1094 CLIFFORD-RECIPES exact with global phase (no new kappa) #1781's packed evaluator. Both kernels must pass every record; RESULT records 36/36 for each.
• Lean pairs. 3:998 and 2:999 are field-for-field Exact.lean's pair 2 and pair 3.

Controls

Each mutation is rejected on every record it applies to:

Mutation	Rejected
Global phase +1	36/36
Input character (linear_Z4 += 2)	36/36
CZ term in Q	36/36
Offset translation	36/36
Swapped wrappers	36/36
Width −1 and width +1	36/36 each
Transposed matrix	36/36
Hyperplane-end record against FULL	14/14
FULL-ended wrapper reused for a hyperplane end	2/2
Another basis of the same span (reordered rows pass)	2/2
Kernel B phase and width mutants	8/8

The tests also reject:

• the decoy;
• a mismatched invoice;
• a flipped archive byte;
• a dropped pre event;
• a wrong event key;
• a wrong record vector.

In the inventory, residual events must be pre or post only, and every record must have exactly its expected fields.

Checks run

• verify.py passes (about 40 s), and RESULT.json is reproduced byte for byte.
• All 17 tests pass.
• research_package.py --check-only passes.
• The registered python3.12 replay gives PASS_REGISTERED_RESEARCH_PACKAGE (48 s).
• These were run on Python 3.12.15 and 3.14.8 (macOS 26.5, arm64).

Overlap

• The Lean pairs. 2:999 and 3:998 are the Exact.lean pairs ([Lean] Hyperplane-ended helpers: Lemma A with an arbitrary terminal frame (no κ claim) #593, with Independent audit: semantic binding of three Lean HPE Clifford pairs (no new kappa) #1415's binding). Bind emitted k8 helper 450 to the retained Lean wrapper pair #1611 had tied 2:999 to pair 3 for this word.
• The cold rank-4 records. The eight records 0:124…0:327 are byte-identical to records in earlier provider files (e.g. complex-sw4-frame8-validation). Research audit: verify all selected cold-wrapper amplitudes (no new kappa) #702 checked that family's cold wrappers by amplitudes, for PR626.
• The four cold hyperplane-end records 0:1000…0:1003. They are hyperplane cases of Independent verification: bind all 511 cold hyperplane operators with phase and spectator #1697's audit of all 511 cold hyperplane terminals, which used wrappers generated by its own run.
• What was producer-only. The 22 FULL-ended entrance wrappers had only producer evidence.
• What is new. All 36 are now checked from the selected word's bound bytes, by two kernels, and tied to its programs.
• Open Research audit: the selected #1094 local programs satisfy Lemma G's extended-label H1 (HPE-aware check, 0 violations); the selected chain runs no tag check (published checker needs a cold-HPE patch; the frame-only replay accepts three adapter mutants) (no new kappa) #1964 (ours, from another session) is about Lemma G H1 extended labels and wrapper placement; that is a different obligation.

Scope

This PR does not show:

• the executor bridge (Lemma G's H1, and rec(A,B) = record circuit);
• the identity adapters;
• Lean proofs beyond the two Exact.lean pairs;
• any new κ.

Reproduce

python3 -I -B research/frontier1094-residual-wrappers-seed62/verify.py        # about 40 s
python3 -I -B -m unittest discover -s research/frontier1094-residual-wrappers-seed62 -p test_package.py
python3.12 scripts/research_package.py --package research/frontier1094-residual-wrappers-seed62

Credit

• Lean packages: Lemma A (Lemma A of #484: the realization of paid wrappers and spectators, proved in Lean 4 #516) and Lemma G (Lemma G of #484: clean proof and Lean 4 formalisation of its core #509), both by DreamingOfClouds and formalizing Complex supplier b ≈ 1.327·10⁻³ (+4.7%) on whole-residual hosting: shared-donor kernel and entrance gauges with paid residual wrappers (conditional on two lemmas) #484.
• The wrapper producer: hpe_adapters_local.py (DreamingOfClouds, after PR Conditional κ = 0.001274032589159993: complex kernel with paid residual adapters #458 by chafreaky), using clifford_exact.py (icekylinx), which adapts PR425 (jacklightChen).
• Exact.lean: jeremykothe2 ([Lean] Hyperplane-ended helpers: Lemma A with an arbitrary terminal frame (no κ claim) #593).
• Calibration sources: Independent audit: semantic binding of three Lean HPE Clifford pairs (no new kappa) #1415 (commdata2338) and Research audit: verify all selected cold-wrapper amplitudes (no new kappa) #702 (BigCactusLabs).
• Related checks: Independent verification: bind all 511 cold hyperplane operators with phase and spectator #1697 (navinor) and Bind emitted k8 helper 450 to the retained Lean wrapper pair #1611 (bbMisk).
• The packed kernel and binding: our Independent verification: every child record and endpoint adapter of the selected frontier1094 CLIFFORD-RECIPES exact with global phase (no new kappa) #1781.

Disclosure

Prepared by Sagar Thakrar (thakrarsagar) with substantial AI assistance from Claude (Anthropic) via Claude Code. Parallel read-only scout and judge subagents selected the obligation; both judges ranked it first. The closed-form kernel, the verifier and the controls were then written fresh. A post-PR adversarial review corrected the supplier trace (the fresh invoice pins the receipt's bytes), the overlap and the credits, and added the kernel cross-check and further controls; these are in the second commit. No claim was posted to Discussions. New material is Apache-2.0.