diff --git a/docs/ci-verification.md b/docs/ci-verification.md index f700630922..006bf5a3d5 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -3,7 +3,9 @@ ## Current selected-family replay: #5599 The [selected record](../certificates/selected-result.json) binds conditional -κ = 0.00310045. `make frontier5599-verify` authenticates the complete source +κ = 0.00310045 to the [proof review](research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md) +and [explicit source closure](../certificates/frontier5599-source.json). +`make frontier5599-verify` authenticates the complete source closure and claim derivation, then executes primary, independent caller positive-control, adapted caller and optimized primary checks serially. The Linux [audit run](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/40253906841) diff --git a/research/uniform-two-call-invoice-qualification/NOTICE b/research/uniform-two-call-invoice-qualification/NOTICE new file mode 100644 index 0000000000..34c7c5febe --- /dev/null +++ b/research/uniform-two-call-invoice-qualification/NOTICE @@ -0,0 +1,3 @@ +Uniform two-call invoice qualification + +Prepared with substantial OpenAI Codex assistance. New text is intended for the upstream Apache-2.0 repository. The unchanged PR5687 caller and PR5673 method excerpt retain their authors, source notices and credit. The classical rank-separation method receives no novelty claim. No scientific replay or new kappa is claimed. diff --git a/research/uniform-two-call-invoice-qualification/PROOF.md b/research/uniform-two-call-invoice-qualification/PROOF.md new file mode 100644 index 0000000000..f558783938 --- /dev/null +++ b/research/uniform-two-call-invoice-qualification/PROOF.md @@ -0,0 +1,79 @@ +# The frozen [PR #5687](https://github.com/CrocSwap/integer-mult-bounds/pull/5687) G5 invoice has negative raw moment for every positive exponent saving + +This is a paper qualification of one explicitly supplied invoice. It assumes the complete paid and productive lists stated in [PR #5687](https://github.com/CrocSwap/integer-mult-bounds/pull/5687), Theorem G5, at head `b3b0fc751d3f5ecdd1498a99a4bfcfa97a0a5b97`. It does not independently establish the physical construction or dispute its relative improvement. The method is elementary rank separation after cancellation; repository precedent includes [PR #5673](https://github.com/CrocSwap/integer-mult-bounds/pull/5673) section 4 for a different invoice. No new general inequality is claimed. + +## Exact input and conventions + +The primary text is `research/restricted-gaussian-coframe-improvement/caller.md`, section 7. The authenticated local copy has SHA256 `f5fe6f217a55a684132114522e15c0f3424c10248fb5d0d4b48ccea0a8c08650` and Git blob `2d6cbce0f076a325cf498989eb2ed2268f16d5f3`. Its immutable public source is [the frozen caller](https://github.com/Dugongue/integer-mult-bounds/blob/b3b0fc751d3f5ecdd1498a99a4bfcfa97a0a5b97/research/restricted-gaussian-coframe-improvement/caller.md). + +For a real parameter C define H_r(C)=r^(1-C), for positive integer r. Use the source's complete two-call lists: + +$$ +P(C)=3732H_1+1046H_2+836H_3+278H_4+24H_6, +$$ + +$$ +T(C)=52H_3+4H_4+24H_7+736H_8+224H_{15}. +$$ + +The target-minus-paid raw Gaussian moment is M(C)=T(C)-P(C). All original 224 main inputs and the two distinct 408-helper banks have the source's declared independent ownership. No target is added for scratch, no banks are identified, and no helper is credited a second time. These ownership statements bind the invoice being qualified; they are not an independent replay of the physical endpoint. + +## Scoped inequality + +Cancel exactly the common 52H3 and 4H4 terms. Then + +$$ +M(C)=24H_7+736H_8+224H_{15} + -3732H_1-1046H_2-784H_3-274H_4-24H_6. +$$ + +Each complete original invoice has rank mass 9,588. Canceling the common terms removes 172 from each side. The remaining productive rank mass is + +$$ +24\cdot7+736\cdot8+224\cdot15=168+5888+3360=9416. +$$ + +The remaining paid rank mass is + +$$ +3732+1046\cdot2+784\cdot3+274\cdot4+24\cdot6 +=3732+2092+2352+1096+144=9416. +$$ + +For every C>0, the function r^(-C) is strictly decreasing in r. Write each H_r as r times r^(-C). Every remaining productive rank is at least 7, and every remaining paid rank is at most 6. Consequently + +$$ +M(C)\le9416\left(7^{-C}-6^{-C}\right)<0 +\qquad(C>0). +$$ + +At C=0, M(0)=0. This proof uses no approximated logarithm, numerical power evaluation, monotonicity of a difference of signed moments, or inference from one tested point. Its declared domain includes every positive C, in particular .0033. + +## Meaning for the next gate + +The frozen G5 invoice cannot supply a positive raw moment. If a proposed admission route requires a strictly positive target-minus-paid raw moment for these same lists, it fails this necessary condition before nonnegative additional recursive charges or a positive reserve. Positive finite ordinary costs remain separate obligations; they do not turn a negative recursive moment into a positive one. + +This does not prove failure of an unspecified compiler architecture or outer theorem with a different premise. Any claimed alternative route must name and justify its actual admission inequality. Nor does this rule out a different consumer, target census, helper profile, source invoice or resource contract. + +The source's predecessor-relative gain greater than 148C on its stated interval can coexist with M(C)<0: the predecessor can have a still lower absolute moment. The relative gain and operator construction remain source-author contributions. The present result only settles the previously unproved absolute sign for the displayed frozen lists. + +Let an actual changed construction supply productive increment DeltaT(C), paid increment DeltaP(C), and a reserve R(C) expressed in the same units only when a compiler theorem justifies doing so. A necessary raw funding condition is + +$$ +\Delta T(C)-\Delta P(C)>-M(C)+R(C). +$$ + +The displayed upper bound on M implies the weaker necessary threshold + +$$ +\Delta T(C)-\Delta P(C)> +9416\left(6^{-C}-7^{-C}\right)+R(C). +$$ + +Neither inequality grants an implementable repair budget or a new target. Actual physical changes must preserve arbitrary inputs, native phases and charts, observations, ownership and restoration, and carry their complete new invoice plus ordinary, precision, stock, tape, compiler and outer obligations. + +## Scope and credit + +The result applies only to [PR #5687](https://github.com/CrocSwap/integer-mult-bounds/pull/5687)'s stated G5 lists at the frozen head. [PR #5698](https://github.com/CrocSwap/integer-mult-bounds/pull/5698)'s separate actual-C coframe optimum, [PR #5678](https://github.com/CrocSwap/integer-mult-bounds/pull/5678)'s P104/535-helper stream, historical rank17/rank16 templates, and every other consumer have different contracts. Their inventories are not combined here. The source's two-call endpoint contains rank15 jobs; it is not replaced with a rank16 grant. + +Credit Dugongue and the retained source authors for the uniform provider, two-call endpoint, complete lists and relative improvement; [PR #5673](https://github.com/CrocSwap/integer-mult-bounds/pull/5673) for the repository's earlier use of the elementary rank-separation technique on another invoice; and Cao Yifan, Cinna Davis and the native/helper/code/controller/compiler lineage retained in the source. Prepared with substantial OpenAI Codex assistance. Static mathematical review is separate from independent physical validation, hosted CI and formal proof-kernel acceptance. No construction, numerical experiment, paid saving or new kappa is claimed. diff --git a/research/uniform-two-call-invoice-qualification/README.md b/research/uniform-two-call-invoice-qualification/README.md new file mode 100644 index 0000000000..028e242cef --- /dev/null +++ b/research/uniform-two-call-invoice-qualification/README.md @@ -0,0 +1,35 @@ +# Absolute moment qualification of the frozen uniform two-call invoice + +## Change and mathematical scope + +The exact two-call invoice in [PR #5687](https://github.com/CrocSwap/integer-mult-bounds/pull/5687), Theorem G5, has a negative target-minus-paid Gaussian moment for every positive saving parameter C, under its stated tariff H_r(C)=r^(1-C). The [paper proof](PROOF.md) settles the absolute sign left unestablished by the source's positive predecessor-relative comparison. It does not challenge that relative improvement or claim a physical impossibility theorem. + +After cancellation, productive and paid rank masses both equal 9,416; every remaining productive rank is at least seven and every paid rank is at most six. Hence M(C) is at most 9416(7^(-C)-6^(-C)), which is strictly negative for C>0. At zero it is zero. The full original masses are 9,588 each. + +An admission route requiring a positive raw moment for these exact lists fails this necessary condition. A different invoice, target census, tariff or compiler premise needs a separate argument. No paid saving, emitted construction, numerical price, scientific replay or new kappa is claimed. + +## Task and overlap + +This is a source-bound application to head `b3b0fc751d3f5ecdd1498a99a4bfcfa97a0a5b97`, `research/restricted-gaussian-coframe-improvement/caller.md`, section 7. The unchanged [primary caller text](inputs/PR5687-CALLER.md) supplies 224 independent main inputs and two distinct 408-helper banks. The complete paired profiles, cancellation convention and exact source pins are inspectable in this package. + +The method is elementary and established. [PR #5673](https://github.com/CrocSwap/integer-mult-bounds/pull/5673), section 4, uses rank separation on a different invoice; its [minimum primary excerpt](inputs/PR5673-METHOD-EXCERPT.md) is preserved for credit. The canonical signed-invoice preflight also supplies a generic classical comparator. No new inequality or screening algorithm is claimed. The contribution is the absolute sign of this specific published G5 invoice. + +Bounded source and discussion checks found no matching exact G5 result in their declared coverage; this is not exhaustive novelty. [PR #5698](https://github.com/CrocSwap/integer-mult-bounds/pull/5698)'s actual-C coframe optimum and [PR #5678](https://github.com/CrocSwap/integer-mult-bounds/pull/5678)'s P104/535-helper contract are distinct. Their lists are not substituted or combined here. + +## Validation + +This is an unregistered static proof package. Read the exact histograms and three-line rank-separation argument in PROOF.md. No verifier, TASK, VERIFY or synthetic RESULT is supplied. SOURCE-CUSTODY.json is custom packaging provenance, not generic runner metadata or a scientific execution receipt. + +The root argument passed a separate local AI mathematical review at its original exact bytes. The publication proof differs only by linked and spaced PR references and the explicit full-versus-reduced rank-mass sentence; final publication-copy review is recorded separately against the actual package hashes. Source copies retain exact bytes. Acceptance of an earlier argument is not silently transferred to changed package bytes. + +No logarithm, power evaluator, source engine, WORD/archive, matrix, solver, numerical screen or scientific replay was executed. The physical producer/caller, native phases and ROW interface, protected reads, ownership/restoration, fixed-odd arithmetic, ordinary costs, stock, precision, tape, compiler and outer hypotheses were not independently verified here. The source author's physical and execution claims remain source evidence. + +## Credit + +Credit Dugongue and the retained source authors for the uniform provider, two-call endpoint, complete invoice and relative comparison. Credit PR5673 and the classical signed-invoice method for rank separation; Cao Yifan, Cinna Davis and the native/helper/code/controller/compiler lineage remain credited through the unchanged primary text. Source notices and Apache-2.0 terms are retained. Prepared with substantial OpenAI Codex assistance, including separate local AI review; no independent human scientific or proof-kernel acceptance is claimed. + +## Open next questions + +1. Supply one changed complete endpoint or paid bill with independently owned targets whose legitimate gain exceeds the exact deficit and applicable compiler reserve. State the actual source-bound operations before construction; a relative gain alone is insufficient. +2. For a proposed joint raw-code caller, retain all entrance-target debits and provide exact all-width boundary operators, residual corrections and native tariffs. A low owner rank or inexpensive residual alone supplies no independent Gaussian reward. +3. Review this frozen source binding and elementary sign argument. An emitted physical host would not rescue these unchanged lists under an admission route requiring a positive raw moment; a new scientific construction is therefore not the next task for this invoice. diff --git a/research/uniform-two-call-invoice-qualification/SOURCE-CUSTODY.json b/research/uniform-two-call-invoice-qualification/SOURCE-CUSTODY.json new file mode 100644 index 0000000000..d0d097c522 --- /dev/null +++ b/research/uniform-two-call-invoice-qualification/SOURCE-CUSTODY.json @@ -0,0 +1,60 @@ +{ + "schema": "uniform-two-call-invoice-custom-custody/v1", + "generic_runner_registration": false, + "scientific_execution": false, + "publication_base": "df0137efd35e11b4445734bf612bdd4c7ebc330c", + "primary_head": "b3b0fc751d3f5ecdd1498a99a4bfcfa97a0a5b97", + "primary_caller_git_blob": "2d6cbce0f076a325cf498989eb2ed2268f16d5f3", + "primary_caller_sha256": "f5fe6f217a55a684132114522e15c0f3424c10248fb5d0d4b48ccea0a8c08650", + "method_source": { + "kind": "Exactboundedtext-excerptfromauthenticatedprimarysource;notnewsourcefetch", + "source_head": "c10f75f09e41803ae8efe478331a7509b7379b2f", + "source_repository": "aliromman/integer-mult-bounds", + "source_path": "research/crossed-connector-caller/PROOF.md", + "url": "https://github.com/aliromman/integer-mult-bounds/blob/c10f75f09e41803ae8efe478331a7509b7379b2f/research/crossed-connector-caller/PROOF.md", + "whole_git_blob": "e3800fbcf1c5f5633e14d9856ca1400985292a0d", + "whole_sha256": "e086b3376173f6b790e05ef09f23b4d5970c8ac5145ab2970e084743f782190b", + "first_line": 178, + "last_line": 199, + "excerpt_sha256": "5a3545407eb373426067897fd0808a23f421ba2859c461fc3c88987fe8a4d53d", + "meaning": "Priorrank-separatedmomentboundonDIFFERENT8fieldescapeinvoice;creditmethodonly,noP/Torphysicalclaimtransfer", + "current_guidance_main": "df0137efd35e11b4445734bf612bdd4c7ebc330c", + "guidance_basis": "Freshmaincheck06:37:48UTCsameimmutablecommit;existingguidance/template/catalogpinsunchanged", + "original_capture_excerpt_file": "PR5673-SECTION4-METHOD-EXCERPT.md", + "packaged_excerpt_path": "inputs/PR5673-METHOD-EXCERPT.md" + }, + "original_proof_sha256": "7bcd0f7264c1c47dac0b05ccfa3fa6cffdba5c7e379ac50862021ce6ac60bde0", + "original_review_sha256": "1cec509bff3c7910e5fced45176b40783e1ff0a84c9e31b4f6bb81e47da82d09", + "publication_changes": "Only spaced/linked PR references and explicit full9588 versus reduced9416 mass sentence; final publication-copy review recorded separately against the actual package hashes", + "source_urls": [ + "https://github.com/Dugongue/integer-mult-bounds/blob/b3b0fc751d3f5ecdd1498a99a4bfcfa97a0a5b97/research/restricted-gaussian-coframe-improvement/caller.md", + "https://github.com/aliromman/integer-mult-bounds/blob/c10f75f09e41803ae8efe478331a7509b7379b2f/research/crossed-connector-caller/PROOF.md" + ], + "files": [ + { + "path": "NOTICE", + "bytes": 365, + "sha256": "a93f201dc50a0376e51ea3b1a9667f98e2e05af910af07d6eb9652e22c6192b1" + }, + { + "path": "PROOF.md", + "bytes": 5874, + "sha256": "9badaf7aad0f3fc49001607231cdf3f0a30541c4bb3cc933515e5b9ebc89017f" + }, + { + "path": "README.md", + "bytes": 5007, + "sha256": "37ff11084685802bd116ab9367bc4f39e871a40e65a487c1bc76f9d434bb74af" + }, + { + "path": "inputs/PR5673-METHOD-EXCERPT.md", + "bytes": 998, + "sha256": "5a3545407eb373426067897fd0808a23f421ba2859c461fc3c88987fe8a4d53d" + }, + { + "path": "inputs/PR5687-CALLER.md", + "bytes": 21022, + "sha256": "f5fe6f217a55a684132114522e15c0f3424c10248fb5d0d4b48ccea0a8c08650" + } + ] +} diff --git a/research/uniform-two-call-invoice-qualification/inputs/PR5673-METHOD-EXCERPT.md b/research/uniform-two-call-invoice-qualification/inputs/PR5673-METHOD-EXCERPT.md new file mode 100644 index 0000000000..a01bc5180f --- /dev/null +++ b/research/uniform-two-call-invoice-qualification/inputs/PR5673-METHOD-EXCERPT.md @@ -0,0 +1,22 @@ +## 4. Constructive escape and its price + +`ESCAPE-WORD.json` contains a complete eight-field binary word. It has three +paired stages, six full calls with rank-one queries, and eight rank-one thin calls. +Every local projector, query rank and compatibility relation is checked. +The verifier retains every exponent of each independent D variable and +checks every coefficient of the full word. It also checks that the thin +maps distinguish all three leaves in both directions. + +Thus the changed connector contract has a real positive operator. It does +not give a profitable supplier. At the pinned PR5599 tariff, 104 copies have +complete optimistic moment coefficients + +```text +208 H25 + 624 H9 + 6 helpers - 6 paid - 832 H1. +``` + +Its linear margin is -336. After common ranks are cancelled, all positive +terms have rank at least eight and all negative terms have rank at most +seven. For every `0<=t<=1`, the margin is at most `8^(t-1)*(-336)<0`. +Additional physical adapters cannot repair that price. + diff --git a/research/uniform-two-call-invoice-qualification/inputs/PR5687-CALLER.md b/research/uniform-two-call-invoice-qualification/inputs/PR5687-CALLER.md new file mode 100644 index 0000000000..2d6cbce0f0 --- /dev/null +++ b/research/uniform-two-call-invoice-qualification/inputs/PR5687-CALLER.md @@ -0,0 +1,207 @@ +# Ordinary decoder closure for a dimension-specialized center-free word + +Dugongue, with substantial OpenAI Codex assistance. This note supplies the complete main caller of a specified coframe rebuild of the retained center-free coded word. The owner code is scalar in this rebuilt provider, so its inverse is an actual ordinary operation on the stated raw fields. This is different from treating the old port-conjugated physical code as scalar. Every changed native child and independent helper target still uses the new coframe invoice below. No profitable particular invoice, Gaussian exponent above 0.0035, or whole multiplication kappa is claimed. + +No mathematical computation, executable evaluation, source replay, solver, Lean process, external search or network access was used. Sources were read at retained revision `5e0052ca0aa3036a3afa8b0438927377c8d97d53`. + +## 1. The actual constant-code premise + +The source `research/native-center-free-code/CODED-PROOF.md` supplies a fully emitted center-cleared word and a ground-chart helper pre-compensation. Over the rational free group algebra on its native warp symbols its logical endpoints are + + forward: (u,v,h) -> (u,v+A u,h), + backward: (u,v,h) -> (u-A^T v,v,h). + +All 112 u, 112 v and 408 helper inputs are arbitrary. The one original center is owned zero on return. A is an explicitly supplied scalar owner matrix with + + A^T=A, + A=I+E, + E^2=-14 E, + A^(-1)=I+E/13. + +Its new ground pre-compensation consists of the source's actual 6,596 dyadic ADDs; it reads only the certified ground-starting helpers and writes ground-starting receiver fields. Its literal matrix entries and original free-word endpoint are predecessor results. The eight original H8 center calls have already been replaced by owned CLEARs in this source. + +The stated free-group premise is essential: it says the same logical endpoints hold when every native generator is assigned identity, with positive and inverse occurrences consistently matched. It is not an inference from a single numerical evaluation of those generators. + +## 2. Emit the actual replacement word + +Let Q be the Gaussian on one fixed reference central direction and D the Gaussian on the other eight reference directions. Put R=DQ=QD and J=Q^2. J and its inverse are ordinary literal monomial operators, with the actual source phases retained. + +Choose exact source-admitted Cliffords H_d for dimensions d=0,...,9, subject to + + H_0=I, H_1=Q, H_8=D, H_9=R. + +For each old field version of frame f use the physical coframe H_d(f). Emit each old scalar ADD, SCALE, COPY and owned CLEAR at its common new coframe. Emit every old native warp as physical identity, and every proper transition f -> g as the exact new physical operator H_d(g) H_d(f)^(-1). Use the source's exact Clifford compiler to factor this operator into its ordinary words and one child of its true Gaussian rank; omit a rank-zero child. The cleared centers remain owned, with whole-payload clearing and zero-header costs paid. + +Original physical adapter instructions are not silently carried over. Entry, exit and intermediate logical-identity conversions are absorbed into the new explicit coframes and their literal boundary or transition words, exactly as in the dimension-coframe construction in the preceding deliverable. Named metadata records are metadata; no old scalar phase is appended to a newly defined transport. Every instruction of the replacement template is specified by these rules. + +**Theorem G1.** This emitted word has exactly the source's two constant-code logical endpoints in the new coframes, on all original independent inputs and with the original owned center zero on return. + +**Proof.** A newly emitted proper transition preserves its logical row, since H_g^(-1)[H_g H_f^(-1)]H_f=I. A scalar instruction acts on its original logical rows because all its operands have the same old frame and hence the same new coframe. A native warp preserves dimension, so its old input and output have equal new coframes; physical identity assigns its logical generator identity. Every positive and negative occurrence therefore has one consistent invertible assignment. Apply the retained free-group endpoint. The ground helper pre-compensation stays at H_0=I. Owned CLEARs erase only their declared owned field. No independent main or helper value is erased. All phases belong to the specified new Clifford words. The argument is an operator identity at each positive width. ∎ + +This theorem is an actual prescribed compiler. It does not transfer the old paid histogram: its new transition ranks may differ substantially, and some helper endpoints may also differ. + +## 3. An exact ordinary main decoder + +All products below act rightmost first. Scalar A acts on owner indices and is applied once per field; Q,D,R,J act on the address payload. Consequently A commutes with all four in this replacement provider. + +**Theorem G2.** The rebuilt backward word, followed and preceded only by finite ordinary operations, realizes the unrestricted standard physical main map + + (x,y) -> (Dx-Ry,Dy). + +The rebuilt forward word similarly realizes + + (x,y) -> (Dx,Dy+Rx). + +No Q, D or R decoder call is added. All original helpers keep their independent newly specified endpoints. + +**Proof for backward.** Regard the actual entering physical SOURCE x as Q times its logical input u=Q^(-1)x. This equality defines the logical input; it is not an instruction executing Q^(-1). The receiver's physical input y has logical value y. The rebuilt backward endpoint is therefore + + (x,y) -> (R[Q^(-1)x-A^T y], Dy) + = (Dx-R A^T y,Dy). + +Before that word apply the scalar ordinary code (A^T)^(-1) to y. After it apply A^T to the y output. The first output becomes Dx-Ry. The second becomes A^T D (A^T)^(-1)y=Dy. The x input and output are untouched by these two scalar recodings. Helpers have autonomous logical endpoints in G1, so the recodings do not change their prescribed independent operators. + +**Proof for forward.** Before the word apply J A^(-1) to the x bank, leaving y unchanged. The logical SOURCE input is Q^(-1)J A^(-1)x=Q A^(-1)x. The SOURCE output is R Q A^(-1)x=D J A^(-1)x. The receiver output is + + D[y+A Q A^(-1)x] = Dy+DQx = Dy+Rx. + +Apply A J^(-1) to the SOURCE output. Since these scalar and monomial operators commute with D, its final value is Dx. The receiver stays Dy+Rx. Every executed preprocessing/postprocessing operation is scalar or the literal ordinary J power. No initial Gaussian transform was treated as free. ∎ + +The original physical code diag(K_p^(-1)) A diag(K_p) is not used as A here. This theorem follows from a new generator-identity/coframe implementation of the logical word. It would be invalid for the old port-dependent physical implementation merely renamed with a common central axis. + +### Exact fixed-odd implementation + +The factor 1/13 is a fixed ordinary coefficient service, not a free dyadic SCALE. One concrete additive/in-place evaluation of A^(-1) is to multiply all owner values by 13, accumulate E times an immutable copy of the entering bank, and divide the resulting complete bank by 13. The result is x+Ex/13. Use separately owned initialized buffers, perform all reads of the immutable source before replacing it, and clear the buffers after last use. A itself uses its actual supplied finite dyadic scalar program. All copies, scalar passes, division scans, addresses and owned reserves are paid. + +Alternatively the explicit eight-mode factor A=I-W_s Z_s with Z_s W_s=14I yields A^(-1)=I-W_s Z_s/13 in these scalar owner coordinates. It is enough to use the source's given matrix entries; no unproved inverse oracle is required. Fixed-odd grid depth, guards, input/output conversions and suspended-instance reserves must be refreshed for this complete new finite template. + +## 4. The entire recursive invoice that must be consumed + +For each proper event e let f_e,g_e be its literal original input and output frames. For each original helper i let a_i,b_i be its literal original boundary frames. Define + + r_e = GaussianRank(H_d(g_e) H_d(f_e)^(-1)), + k_i = GaussianRank(H_d(b_i) H_d(a_i)^(-1)). + +The complete rebuilt native paid list is exactly the positive r_e. The autonomous helper endpoint on helper i is the actual Clifford H_d(b_i) H_d(a_i)^(-1). Its exact ordinary input/output normalizers convert it into one canonical rank-k_i Gaussian job. A rank-zero endpoint is retained as an independent ordinary identity job, with no positive Gaussian target credit. Every old H4, H7, H8 or H9 helper target is replaced by its actual k_i target, rather than silently preserved. + +G2 leaves the main standard ABI unchanged and adds no Gaussian request to these lists. All its scalar/monomial decoder passes enter the ordinary finite invoice. A proper Gaussian supplier must use a choice with every positive r_e strictly below the admitted parent rank, plus the actual all-column, ROW/spectator, matching, precision, cover, finite backend and complete-caller conditions. This note proves the main decoder and explicit finite program; it supplies neither an unlisted favorable rank census nor a transferred moment inequality. + +## 5. A separate exact reconstruction of the old coded offer + +The actual PR5402 raw provider has + + X=Dx-Ry+RW h, Y=Dy, H=D(h-Zy), + +where RW=WR, ZR=RZ and ZW=14I. Its W,Z are the actual supplied ordinary scalar/monomial words. + +**Theorem G3.** Prepend h += Zy to that raw provider. After it apply Q to the eight H fields and subtract WH from X. The resulting full endpoint is + + X=Dx-R C y, Y=Dy, H=R h, + C=I-WZ. + +Its paid profile is p_raw+8H1 and its independent helper profile is the 400 old autonomous jobs plus eight H9 jobs. No required main query is assumed. + +**Proof.** The raw helper becomes D[(h+Zy)-Zy]=Dh, hence the eight Q calls produce Rh. The raw X is Dx-Ry+RWh+RWZy. Subtracting WH=WRh=RWh leaves Dx-R(I-WZ)y. All input pre-compensation is at the actual common ground cuts; every W/Z map and its ordinary finite cost is retained. All arbitrary original h remain independent productive inputs. ∎ + +This is an alternate implementation of the existing center-free code. Its paid profile, helper profile and physical C agree with the predecessor `CODED-PROOF.md`; no new recursive gain is claimed from G3. The point of G1-G2 is that the coframe rebuild makes its owner code genuinely scalar before main decoding, while requiring a fresh fully paid transition/helper invoice. + +## Attribution and scope + +The center-free code and its actual polynomial inverse are the retained `research/native-center-free-code/CODED-PROOF.md` construction for Dugongue with OpenAI Codex assistance, building on Cinna Davis PR4694 and PR4698 and Cao Yifan's round-three source PR4610. The raw eight-mode alternative is Dillon Amburgey's PR5402, Chris R / Clear1nsight's PR5407 audit and PR5413 completion, and Ali Romman PR5383/PR5398, with the native/helper/controller lineage and all source notices retained. The dimension-coframe construction and its changed helper invoice in the preceding pure-mathematics deliverable are direct predecessors of G1. + +Retain the source Clifford/compiler, scalar, fixed-odd, ownership, higher-moment, finite ordinary, precision and outer-caller contributions, including Cinna Davis, Ryanson Jonathan, zxv and Jacob Alan Sussman. The new useful scope is the fully explicit ordinary main decoder for the rebuilt center-free word, with both orientations and its actual code placement. No formal check, literature-wide priority, completed profitable Gaussian profile or new multiplication kappa is claimed. New text is Apache-2.0 with substantial OpenAI Codex assistance. + +## 6. Primary actual construction: uniformize the restricted center-free source + +The following construction uses the actual new restricted source in [coframes.md](coframes.md), rather than an unspecified dimension-coframe invoice. Its main SOURCE final coframe is one common eight-plane coframe F_H. Its receiver final coframes F_Ai have rank seven. Its actual main SOURCE entrance coframes F_i are surviving rank-one port lines on 56 ports and identity on the other 56. Every receiver starts at ground. + +The actual new source has + + P = 1810 H1+523 H2+418 H3+139 H4+12 H6+8 H7, + T = 26 H3+2 H4+12 H7+368 H8. + +The eight H7 calls are its eight owned centers. Its logical scalar/native word is the retained source word with logical-identity proper retimings; the two auxiliary-line changes preserve every logical native generator. Thus the constant center-clear error identity from CODED-PROOF applies to this word too. The same cold-helper ground pre-compensation produces logical response A, with independent logical helper endpoints. Its 106 cold helper sources still start at ground: intersecting a ground frame and retaining the ground coframe cannot change that fact, and the new auxiliary-line changes concern nonzero lines. The four source retimings are logical identities and are retained in the paid list. + +**Theorem G4.** There is a complete uniform C provider on all 112 main pairs, + + C_unif = [[R,0],[D,D]], + +where D acts on seven directions and R=DQ acts on those directions plus a central direction. Every original helper remains independent with profile T. Its complete paid Gaussian profile is + + P_unif = P-8H7+56H1 + = 1866 H1+523 H2+418 H3+139 H4+12 H6. + +No A-type port or port-dependent logical code remains. + +**Proof.** At each port choose the actual ordinary full-basis monomial N_i sending the standard eight-plane to H and its standard seven-plane to A_i. Such a basis exists because A_i is a hyperplane in H. Choose a vector of H outside A_i, append a basis of A_i, then extend outside H. This is the same explicit K_G construction used in the admitted port normalizers. Its input and output ordinary words have their exact phases supplied by that retained compiler. + +Apply N_i to both original main inputs x_i,y_i. These are genuine ordinary maps on arbitrary payloads. On the whole SOURCE bank, while the new input is ground, apply the scalar owner matrix A^(-1). Now apply F_i to the corresponding SOURCE field. This costs one H1 on each of the 56 surviving-line ports, and no query on the other ports. Its exact child normalizers and scalar phase are paid. There is no claim that this preparation merges with a later child. + +The actual SOURCE entrance is consequently F_i[A^(-1)N x]_i. The SOURCE logical input to the native word is exactly A^(-1)N x. The receiver logical input is N y. Execute the actual ground-helper pre-compensation and the restricted word with its eight owned center queries replaced by complete owned CLEARs. The constant source identity gives + + SOURCE = F_H A^(-1)N x, + receiver_i = F_Ai [N_i y_i+N_i x_i]. + +At this actual common SOURCE output coframe, apply scalar A to all SOURCE fields. Because F_H is literally common, this is an actual ordinary code and yields SOURCE_i=F_H N_i x_i. + +Finally apply the explicit ordinary output words + + O_Xi = R N_i^(-1) F_H^(-1), + O_Yi = D N_i^(-1) F_Ai^(-1). + +They are ordinary by exactly the source's equal-Lagrangian normalizer proof: N_i matches the full eight-plane and seven-plane respectively. Their literal phase and monomial coefficients are included. They give + + SOURCE_i = R x_i, + receiver_i = D(y_i+x_i). + +The center-clear identity is independent of every helper input. All old autonomous helper endpoints remain those of the actual new source. SOURCE pre/post coding changes no helper target. Eight rank-seven owned queries have been removed and exactly 56 rank-one preparations added, giving the stated complete P_unif. No input is zero-specialized. ∎ + +The finite ordinary bill includes the actual 6,596-ADD ground pre-compensation, scalar A and A^(-1), all 224 paired input normalizers, all 224 output normalizers, every rank-one preparation's own matchers, all retained scalar and native words, dirty-owned initialization, whole-payload clears, swaps, routes and parking. A^(-1) uses the explicit fixed denominator 13 algorithm from Section 3. A separately owned full-bank scratch reserve suffices; each suspended instance has its own reserve. No ordinary constant, old guard or old live-field count is reused without including these additions. + +### One-call diagonal interpretation + +The actual ordinary input shear y -= x gives + + C_unif [[I,0],[-I,I]] = diag(R,D). + +Thus G4 already supplies 112 independent rank-eight and 112 independent rank-seven main jobs, in addition to T, at the same paid profile. This is a complete finite Gaussian converter, not a claim that its moment is funded at a positive exponent. Both the added 56 H1 preparations and all old helper target changes are essential to that comparison. + +## 7. A complete two-call Gaussian consumer and its exact relative improvement + +Let D0,D1 be Gaussians on disjoint seven-axis blocks, with one common separate Q. Apply G4's plain-transpose/bank-swap construction from [transpose.md](transpose.md) to obtain + + B0 = [[D0,0],[D0,D0 Q]], + +with exactly P_unif and T. On a separate fresh copy of its helper bank run G4 with D1, conjugating the two main boundaries by the ordinary sign diag(-I,I), to obtain + + C1_minus = [[D1 Q,0],[-D1,D1]]. + +**Theorem G5.** The chronological two-call word B0 followed by C1_minus has the all-input main endpoint + + diag(D1 D0 Q,D1 D0 Q). + +Every original main input is therefore an independent canonical rank-fifteen Gaussian job, with its actual monomial whole-job normalizers. The two helper banks remain independent with two copies of T. Its complete profiles are + + P_pair = 3732 H1+1046 H2+836 H3+278 H4+24 H6, + T_pair = 52 H3+4 H4+24 H7+736 H8+224 H15. + +Both main signs, the actual plain-transpose owned compiler, all field swaps and every new ordinary pass are paid. No thin query, endpoint gauge correction or independent-input identification is required. + +**Proof.** Block multiplication gives + + C1_minus B0 + = [[D1 Q D0,0], + [-D1 D0+D1 D0,D1 D0 Q]] + = diag(D1 D0 Q,D1 D0 Q). + +The blocks commute because their active Gaussian directions are disjoint apart from the shared Q, which occurs just once in each displayed final operator. Its rank is seven plus seven plus one. The source's direct-sum main/helper endpoint and the complete transpose theorem retain all helper jobs on their distinct original arbitrary inputs. Adding the two explicit paid lists and two helper lists gives the stated profiles. All owned work returns zero before its instance is reused. ∎ + +The two-call word can live in one fifteen-direction ambient block. Identity spectators of the source are retained as actual address coordinates where needed; the main input/output normalizers operate on the declared actual source embedding. Every queried child has rank at most six, below the fifteen-direction main targets. The 224 main inputs and both full helper banks are independent, and no scratch is productive. + +**Theorem G6.** Compare G5 to the identical construction made from the admitted predecessor restricted source before the two auxiliary-line folds. Its full target-minus-paid moment is strictly improved by more than 148 C for every 074C. There are two distinct source calls, so the complete consumer's difference is 2G(C)>148C. No call or target is counted twice. ∎ + +This is a favorable complete Gaussian converter comparison. It does not by itself prove that either absolute moment is positive. Its two rank masses are equal. The standard whole-caller, critical/mirror and ordinary outer transfer cannot replace this honest absolute funding question by the strict relative gain. No Gaussian exponent above 0.0035 or new multiplication kappa is claimed in G4-G6. + +The direct predecessor for this uniformization is the actual restricted source and its explicit main normalizers in `research/native-dual-suppliers/DUAL-PROVIDER.md` and `ROUND3-IMPROVEMENT.md`; the ground compensation and scalar inverse are the existing center-free coded proof; the same-price B interface uses the present complete plain-transpose construction. Preserve Cao Yifan PR4610/PR4470, Cinna Davis PR4694/PR4698 and native/frame/controller lineage, DaysSky, Nick Petalas, Ryanson Jonathan, Dugongue, zxv, Jacob Alan Sussman, all phase/Clifford/compiler contributors and all retained source notices. The new contribution is this fully paid all-port uniform C construction, its exact two-call diagonal consumer, and the resulting complete positive relative comparison. No fresh executable or formal verification was performed.