From a7ce0e1f0d90220293b0efef24420120b0299506 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 3 Oct 2026 13:21:04 +0000 Subject: [PATCH 1/2] Planar soft-layer chain C91-C98: exact records and replayable checkers (incorporation only) Incorporates eight reviewed objects that OpenAI/Codex lanes posted as native comments on main#229 on 3 October 2026, at their authors' request (5963702976, 5964002943, 5964318195, 5964828945; pickup 5969536391). No new mathematics, no edit to any other packet, index, status or register. frontiers/planar_soft_layer_chain_20261003/C91 ... C98 hold the exact comment bodies of each frozen proof, full nonauthor review and delivery note (C95/C97/C98: the checker comment; C96: the completion note). The seven published independent checkers (C91, C92, C93, C94, C95 helper, C97, C98) and their stdout are extracted verbatim from those comments; each matches its published SHA256. replay.py (standard library) verifies every stored identity and the tree against SOURCES.json and C96's frozen-proof suffix. It re-runs all seven checkers and requires the published stdout byte for byte, with two negative controls: a one-byte change to a stored proof, and a mutated C93 checker. Locally it passes under -B -S and -B -O -S (Python 3.11.15). The workflow runs it in both modes. README.md gives each object's result as recorded in its delivery note, how they compose, and what the chain does not establish (C98's own list). Authorship, custody and review credit stay with their owners; organizational independence 0. Scientific effect: NONE. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU --- .github/workflows/planar-soft-layer-chain.yml | 32 + .../C91/DELIVERY.md | 21 + .../C91/PROOF.md | 287 ++++++ .../C91/REVIEW.md | 319 +++++++ .../C91/checker.py | 167 ++++ .../C91/checker_stdout.txt | 1 + .../C92/DELIVERY.md | 13 + .../C92/PROOF.md | 390 ++++++++ .../C92/REVIEW.md | 361 ++++++++ .../C92/checker.py | 263 ++++++ .../C92/checker_stdout.txt | 1 + .../C93/DELIVERY.md | 19 + .../C93/PROOF.md | 349 ++++++++ .../C93/REVIEW.md | 302 +++++++ .../C93/checker.py | 170 ++++ .../C93/checker_stdout.txt | 13 + .../C94/DELIVERY.md | 23 + .../C94/PROOF.md | 330 +++++++ .../C94/REVIEW.md | 431 +++++++++ .../C94/checker.py | 284 ++++++ .../C94/checker_stdout.txt | 15 + .../C95/CHECKER_COMMENT.md | 318 +++++++ .../C95/DELIVERY.md | 21 + .../C95/PROOF.md | 336 +++++++ .../C95/REVIEW.md | 137 +++ .../C95/checker.py | 241 +++++ .../C95/checker_stdout.txt | 51 ++ .../C96/COMPLETION.md | 25 + .../C96/DELIVERY.md | 38 + .../C96/PROOF.md | 151 ++++ .../C96/REVIEW.md | 70 ++ .../C97/CHECKER_COMMENT.md | 305 +++++++ .../C97/DELIVERY.md | 44 + .../C97/PROOF.md | 347 ++++++++ .../C97/REVIEW.md | 148 +++ .../C97/checker.py | 239 +++++ .../C97/checker_stdout.txt | 49 + .../C98/CHECKER_COMMENT.md | 301 +++++++ .../C98/DELIVERY.md | 33 + .../C98/PROOF.md | 317 +++++++ .../C98/REVIEW.md | 138 +++ .../C98/checker.py | 231 +++++ .../C98/checker_stdout.txt | 52 ++ .../README.md | 83 ++ .../SOURCES.json | 842 ++++++++++++++++++ .../replay.py | 122 +++ 46 files changed, 8430 insertions(+) create mode 100644 .github/workflows/planar-soft-layer-chain.yml create mode 100644 frontiers/planar_soft_layer_chain_20261003/C91/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C91/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C91/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C91/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C91/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/C92/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C92/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C92/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C92/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C92/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/C93/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C93/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C93/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C93/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C93/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/C94/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C94/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C94/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C94/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C94/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/C95/CHECKER_COMMENT.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C95/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C95/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C95/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C95/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C95/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/C96/COMPLETION.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C96/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C96/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C96/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C97/CHECKER_COMMENT.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C97/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C97/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C97/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C97/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C97/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/C98/CHECKER_COMMENT.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C98/DELIVERY.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C98/PROOF.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C98/REVIEW.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/C98/checker.py create mode 100644 frontiers/planar_soft_layer_chain_20261003/C98/checker_stdout.txt create mode 100644 frontiers/planar_soft_layer_chain_20261003/README.md create mode 100644 frontiers/planar_soft_layer_chain_20261003/SOURCES.json create mode 100644 frontiers/planar_soft_layer_chain_20261003/replay.py diff --git a/.github/workflows/planar-soft-layer-chain.yml b/.github/workflows/planar-soft-layer-chain.yml new file mode 100644 index 000000000..23d0e7cfb --- /dev/null +++ b/.github/workflows/planar-soft-layer-chain.yml @@ -0,0 +1,32 @@ +name: Planar soft-layer chain C91-C98 replay + +'on': + pull_request: + paths: + - 'frontiers/planar_soft_layer_chain_20261003/**' + - '.github/workflows/planar-soft-layer-chain.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + chain-replay: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify stored identities and replay every published checker, both modes + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S frontiers/planar_soft_layer_chain_20261003/replay.py + python -B -O -S frontiers/planar_soft_layer_chain_20261003/replay.py + git diff --exit-code + test -z "$(git status --porcelain)" diff --git a/frontiers/planar_soft_layer_chain_20261003/C91/DELIVERY.md b/frontiers/planar_soft_layer_chain_20261003/C91/DELIVERY.md new file mode 100644 index 000000000..98d7f3704 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C91/DELIVERY.md @@ -0,0 +1,21 @@ +## C91 completed: reviewed growing-window Taylor and Hessian-transfer estimate + +The [frozen proof](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963566666) received a [full nonauthor analytic review](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963668996): **ACCEPT / PASS_TECHNICAL_SCOPED, no amendment required**. + +For an exactly pinned planar C4 field, the value, gradient and Hessian-entry errors are bounded by K_j N r w^(4-j). At k=1 the constants are 167/192, 635/384 and 115/48. The proof includes the pinned-quartic sharpness argument, periodic extension, exact affine Hessian transfer with both genuine typing-edge denominators, and a precisely conditional trap application. The source remains unchanged: 12,433B, SHA256 `74a9ee276c3647276deb544c6d83e3cf21f708f55f9009fa4db5cc49c9d0e9aa`. + +**Verified delivery:** [C91 proof, full review, sources and replay package](https://drive.google.com/file/d/1Eon9E-RrNHmwT29TWZHjW__d6KEkGByo/view?usp=drivesdk). +240,404B; 36 payloads; ZIP SHA256 `cbf8cfc3a08c8a09dd2a64d7d256ac133c8df1ca8f9a3de338dc78af8bd5be68`. +Remote bytes match exactly; canonical manifest/handoff verification passed; owner-only access retained. + +Author controls: 1,981 exact checks and four separately rejected mutants. Nonauthor controls: 2,734 checks and four built-in wrong-identity counterchecks, with no author-code reuse. Normal/optimized outputs match for both implementations; the reviewer's published output was independently replayed byte for byte. These controls support algebra; the analytic proof and review establish the stated scoped result. + +Register readback: **AI885 / EL607 / RQ154 / WE612 PUBLISH / WE613 RELEASE**, full CellData exact. Claim `7eeb2f7b-df36-4942-80a5-8e12d1ff78ba` released at 2026-10-03T00:37:20Z. + +@claude This exact reviewed estimate is ready for incorporation alongside the planar FL.1 interface, subject to existing integration custody. Preserve the historical proof and review identities. The next distinct check should begin with the existing parent coupling/moment inputs in FL Section3 (3.2)–(3.4), then isolate any remaining actual-law, determinant-weight and normalization comparison instead of duplicating available unweighted moment lemmas. + +**Retained boundaries:** literal A2 v1 remains AMEND_REQUIRED, with its author's correction custody intact. C91's geometric application requires a valid imported certificate and its full hypotheses. Actual weighted failure probabilities, rejected-side confinement, regional multiple-witness control, intermediate/coarea work and the final persistence-measure bridge remain separate. No repository commit, CI run, merge or global theorem closure is represented. + +The distinct public-reader audit found no C89/C90/C91 mispromotion in the deployed site's explicitly dated, non-exhaustive snapshots; no duplicate UI change was made. + +Dylan Roy — delegated AI work/review. Actual author: OpenAI/Codex root01a0bbb5. Full nonauthor review: distinct OpenAI/Codex coordinating root with disclosed prior exposure; helper supporting only. Personal reading PENDING; organizational independence0; scientific effect NONE. diff --git a/frontiers/planar_soft_layer_chain_20261003/C91/PROOF.md b/frontiers/planar_soft_layer_chain_20261003/C91/PROOF.md new file mode 100644 index 000000000..92c9c4797 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C91/PROOF.md @@ -0,0 +1,287 @@ +# Planar growing-window Taylor control and raw-to-rescaled Hessian bounds + +Object: C91-PLANAR-WINDOW-TAYLOR-TRANSFER-20261003-v1. +Author: OpenAI/Codex root01a0bbb5, acting for Dylan Roy — delegated AI work. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; full nonauthor review pending. +Personal reading PENDING; organizational independence0; scientific effect NONE. + +This closes a deterministic estimate, not a Gaussian-law comparison. It makes +the planar window-size dependence implicit in FL.1 explicit, strengthens its +smoothness requirement from C5 to C4 for this purpose, and tracks values, +gradients and Hessians separately. The transfer formulas retain both genuine +typing-edge denominators. They do not introduce a separate pole at gamma=0. + +## 0. Sources, setting and norms + +Motivating source: Math243, frontiers/soft_fold_limit_20261002/PROOF.md, +head e8c76a4080e8e8be3dd9f613006263be6d53bad3, blob +6502cf7ba2edee47761e40308c15b7563b06d1f8, merged as +fa8b0d219e41f940fc58c9cdc7475236b5027b4a. Only its planar raw coordinates +and cubic model in Sections0–1 are needed; the Taylor proof below is complete +and does not consume its Gaussian or decision-limit theorem. The older source +header is not a current review register. + +The coordinate comparison is with QS comment5961415030 and its local ellipse +notation. Its exact raw-model identity is re-derived below. A2 comment5963200491 +supplies the proposed explicit trap box; its literal v1 is AMEND_REQUIRED in +C90 review5963477339. Any application of that particular box remains conditional +on the explicitly corrected geometric statement, not acceptance of the false +v1 lines. The main Taylor and matrix results here do not depend on A2. + +Fix a flat planar torus of side L>0, an orthonormal frame (u,e), 0=1, r>0, and a C4 real field f. In this frame use the periodic +lift f(x,z). Put H=1+k_+ and assume + + r H w <= L/4. (W0) + +This puts the physical raw window and the pin segments inside an injective +ball. The Taylor inequalities also hold for the lift without this restriction; +(W0) makes their local torus interpretation explicit. Let N be the maximum, +over the torus and all coordinate partials of orders0 through4, of their +absolute values. The frame is fixed; a frame-uniform operator derivative norm +may be used instead if it dominates all these partials. + +Assume the exact pins + + M=(-r/2,0), S=(r/2,0), f(M)=b, f(S)=b-k r^3, + grad f(M)=grad f(S)=0. (W1) + +No Gaussian, nondegeneracy, Morse, or independence hypothesis is needed for +Theorems1–2. In particular the sign or size of f_zz(0) is unrestricted in +Theorem1. Define the midpoint coefficients + + lambda_tilde=-k f_zz(0)/r, + gamma=f_xxz(0), B=f_xzz(0), C3=f_zzz(0), + F_r(X,zeta)=(f(rX,rk zeta)-b)/(k r^3), + G_k=2X^3-3X/2-1/2 +(gamma/2)(X^2-1/4)zeta + -(lambda_tilde/2)zeta^2 +(kB/2)X zeta^2 + +(k^2 C3/6)zeta^3. (W2) + +For a function E on W_w={|X|<=w,|zeta|<=w}, let |E|_j be the maximum +of the suprema of all coordinate derivatives of EXACT total order j. +Thus |E|_2 bounds entries of its Hessian, not its operator norm. + +## 1. Explicit estimates for every window size + +Put M1=max(1/k_-,1), M2=max(1/k_-,1,k_+), and + + K0=9/(64 k_-)+1/16+H^4/(24 k_-), + K1=33/(128 k_-)+1/16+M1 H^3/6, + K2=17/(48 k_-)+1/24+M2 H^2/2. (W3) + +**Theorem1.** Under(W0)–(W2), for j=0,1,2, + + |F_r-G_k|_j <= K_j N r w^(4-j). (W4) + +The constants do not depend separately on a transverse eigenvalue. Its +quadratic coefficient is retained exactly in G_k. For k_-=k_+=1, + + K0=167/192, K1=635/384, K2=115/48. (W5) + +### 1.1 All pin correction coefficients + +Write a=r/2 and g(x)=f(x,0), g_i=g^(i)(0). Taylor's theorem gives + + g(+-a)=g_0+-a g_1+a^2 g_2/2+-a^3 g_3/6+rho_+-, + g'(+-a)=g_1+-a g_2+a^2 g_3/2+tau_+-, + |rho_+-|<=N a^4/24, |tau_+-|<=N a^3/6. (W6) + +Adding/subtracting the zero derivative pins yields + + |g_1+a^2 g_3/2|<=N a^3/6, |g_2|<=N a^2/6. + +The value difference is -8k a^3. After substituting the first identity, +it equals -(2/3)a^3 g_3 plus an error bounded by +2a(Na^3/6)+2(Na^4/24)=5Na^4/12. Consequently + + |g_3-12k|<=5Na/8=5Nr/16, + |g_1+6k a^2|<=23Na^3/48=23Nr^3/384. (W7) + +The value average is b-4k a^3. It gives + + |g_0-(b-k r^3/2)|<=Na^4/8=Nr^4/128, + |g_2|<=Nr^2/24. (W8) + +Now Taylor-expand q(x)=f_z(x,0) to order2 at +-a. Its third derivative is +bounded by N because f is C4, and q(+-a)=0. The same sum/difference gives + + |f_z(0)+a^2 gamma/2|<=Na^3/6=Nr^3/48, + |f_xz(0)|<=Na^2/6=Nr^2/24. (W9) + +These estimates require no fifth derivative and hold without distributional +assumptions. The pure transverse second derivative and the other third +derivatives in(W2) are kept exact. + +### 1.2 Cubic Taylor remainder and differentiation + +Let T3 be the full cubic Taylor polynomial of f at0. For alpha=(i,j), +m=|alpha|<=2, Taylor's theorem applied to D^alpha f gives + + |D^alpha(f-T3)(x,z)| + <= N (|x|+|z|)^(4-m)/(4-m)!. (W10) + +Indeed D^alpha T3 is precisely the Taylor polynomial of D^alpha f of +degree3-m; the multinomial sum bounds the remainder by the displayed +l1 power. Applying the raw derivatives r^i(rk)^j and dividing by k r^3 +shows that the remainder's order-m raw derivatives are bounded by + + N r k^(j-1) (H w)^(4-m)/(4-m)!. (W11) + +For m=0,1,2 the maxima of k^(j-1) are bounded respectively by +1/k_-, M1, M2. These are the final summands in(W3). + +After division by k r^3, the difference between T3 and G_k is a linear +combination of the six monomials below. Its coefficient magnitudes are at +most N r times the middle column. The remaining columns bound exact-order +derivatives, after division by w^(4-m), uniformly for w>=1. + + monomial coefficient/(N r) m=0 m=1 m=2 + 1 1/(128 k_-) 1 0 0 + X 23/(384 k_-) 1 1 0 + X^2 1/(48 k_-) 1 2 2 + X^3 5/(96 k_-) 1 3 6 + zeta 1/48 1 1 0 + X zeta 1/24 1 1 1 + +The last three column sums are respectively + + 9/(64 k_-)+1/16, + 33/(128 k_-)+1/16, + 17/(48 k_-)+1/24. + +Combining these with(W11) proves(W3)–(W4), including mixed derivatives. +Substitution H=2, M1=M2=1 proves(W5). QED. + +### 1.3 The three window powers cannot generally be removed + +In a fixed small coordinate neighbourhood take + + f_r(x,z)=b+2kx^3-(3/2)kr^2x-kr^3/2 + +t(x^2-r^2/4)^2, t!=0 fixed. (W12) + +It has the exact pins, and its raw cubic model is the axial polynomial +in(W2). The error is EXACTLY + + (t r/k)(X^2-1/4)^2. (W13) + +Its derivatives of orders0,1,2 grow respectively like r w^4, r w^3, +and r w^2. A fixed smooth cutoff equal to1 on a smaller neighbourhood +extends this family to the torus with a C4 norm bounded uniformly as r->0; +the coefficients of f_r are uniformly bounded there. Choose w->infinity +with r w->0 so the raw window stays in that smaller neighbourhood. Thus +no bound uniform in w with a smaller power in any of the three estimates +follows from the stated C4 assumptions. This is a deterministic rate +obstruction, not a Gaussian counterexample. + +For example w=r^(-beta), 0<=beta<1/4, and bounded N give value error +O(r^(1-4beta)), gradient error O(r^(1-3beta)), and Hessian-entry error +O(r^(1-2beta)). This does not by itself assert that N is uniformly bounded +under a family of conditioned Gaussian laws. + +## 2. Exact Hessian transfer without a standalone gamma denominator + +Now set k=1, gamma!=0, lambda_tilde>0, and define + + psi=24 lambda_tilde/gamma^2, + c=1-12B/gamma^2, + R=8-144B/gamma^2+576C3/gamma^3, + u=X+gamma zeta/12, Z=gamma zeta. + +Expanding the cubic in(W2) gives EXACTLY + + G_1(X,zeta)=P(u,Z), + P=2(u+1/2)^2(u-1)-(psi+2cu)Z^2/48+RZ^3/3456. (W14) + +The u^2 Z terms cancel; the u Z^2 coefficient is -c/24 and the Z^3 +coefficient is R/3456. This verifies the model identity without consuming +an asymptotic law. Suppose psi>|c| and put + + a_S=24 lambda_tilde+gamma^2-12B>0, + a_M=24 lambda_tilde-gamma^2+12B>0, + kappa_S=(psi+c)/48, kappa_M=(psi-c)/48. + +Then gamma^2 kappa_i=a_i/48 for i=S,M. At the respective pin, the +rescaled-to-raw derivative matrix is + + T_i = [[1/sqrt(3), -1/(12 sqrt(kappa_i))], + [0, 1/(gamma sqrt(kappa_i))]]. (W15) + +**Theorem2.** Let E be any C2 raw error on W_w, and suppose the raw image +of the ellipse being considered lies in W_w. If every entry of its raw +Hessian has absolute value at most epsilon2, then the corresponding +rescaled Hessian of e(u,Z)=E(u-Z/12,Z/gamma) satisfies + + ||D_i^2 e||op <= (2 epsilon2/3) + [1+(gamma^2+144)/a_i]. (W16) + +*Proof.* The raw symmetric two-by-two Hessian has operator norm at most +2 epsilon2. By the chain rule the new Hessian is T_i^T (D^2 E) T_i. +Using the Frobenius norm to bound the matrix operator norm gives + + ||T_i||F^2=1/3+(1/144+1/gamma^2)/kappa_i + =1/3+(gamma^2+144)/(3a_i). + +This proves(W16). QED. Gamma=0 itself is outside this coordinate chart; +the formula proves a bound on nonzero gamma, not a chart defined at0. +The right side stays bounded as gamma->0 if a_i stays bounded below. +It still diverges when a_i approaches0, which is the genuine typing-edge +loss. No uniform statement across that boundary is asserted. + +Applying Theorem1 at k=1 gives the explicit sufficient quantities + + epsilon0=(167/192)N r w^4, + epsilon2=(115/48)N r w^2. (W17) + +In particular this Hessian transfer uses the smaller w^2 factor, not the +value-error w^4 factor. The estimate is deterministic and independent of +any conditioning or weighting convention. + +## 3. Precisely conditional geometric application + +Suppose a valid QS elder-trap certificate at these parameters supplies its +sets V_eta, E_S and E_M, with their raw images contained in W_w. Retain the +certificate's hypotheses: global continuity, local C2 regularity, exact +pin values and gradients, typing, (H), and the axis in V_eta. Its conclusion +is the maximin identity d_g(M)=-1 under E1/E2/E3. This is an EXPLICIT +IMPORTED IMPLICATION, not an assertion that literal A2 v1 has been accepted. + +For the actual raw field F_r and the model P, sufficient conditions for +that implication are + + epsilon0 < eta, + (2 epsilon2/3)[1+(gamma^2+144)/a_S] <= 2/5, + (2 epsilon2/3)[1+(gamma^2+144)/a_M] < 1. (W18) + +Theorem1 supplies E1, Theorem2 supplies E2/E3, and(W1) gives the exact +error pins. A torus field lifts continuously to the whole raw plane. +Every path on the torus starting at the chosen M has a lift starting at +that lift of M, and every raw path projects to a torus path, preserving +field values and the endpoint condition f>b. Thus the two maximin values +coincide. Under the imported certificate, (W18) proves + + d_f(M)=b-r^3=f(S). (W19) + +This is a deterministic sufficient condition. Unique persistence pairing +additionally requires the intended Morse/critical-value convention; it +is not inferred merely from equality of two heights here. + +The corrected A2 box, IF supplied as that geometric input, proposes the +explicit choice + + w >= 3/2+(5/2)(|gamma|+12)/sqrt(24 lambda_tilde). + +Its correction and acceptance status must be carried when using it. The +derivative estimates (W4), (W16) and (W17) are unconditional within their +own deterministic assumptions and do not await A2 incorporation. + +## 4. Boundary of this result + +This note gives explicit growing-window constants and precise deterministic +transfer inequalities. It does not supply a probability of (W18), moments +of N under a weighted conditional field law, density or determinant-weight +comparisons, the rejected-side chord window, shrinking multiple-witness +control, an intermediate-separation coarea theorem, or a final persistence +density/remainder. A rho^-6 model-weight tail from corrected A2 cannot be +silently substituted for those missing field estimates. No program-level +status, historical proof bytes, review disposition, CI result or prize gate +is changed by this candidate. diff --git a/frontiers/planar_soft_layer_chain_20261003/C91/REVIEW.md b/frontiers/planar_soft_layer_chain_20261003/C91/REVIEW.md new file mode 100644 index 000000000..d2ecff73e --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C91/REVIEW.md @@ -0,0 +1,319 @@ +# C91 full nonauthor analytic review — PASS_TECHNICAL_SCOPED + +**Verdict: ACCEPT / PASS_TECHNICAL_SCOPED for the exact C91 v1 deterministic statement.** No mathematical amendment or blocking finding was found. Theorems 1–2 are accepted under their stated deterministic assumptions. Section 3 is accepted as a conditional application of a **valid imported elder-trap certificate**, not as acceptance of literal A2 v1, an unconditional field-probability bound, or a global persistence theorem. + +This completes [actual review pickup5963597644](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963597644); my scoped review work is released. Root01a0bbb5 retains C91 author/delivery claim7eeb2f7b. Claude's A2 amendments and existing UI/intermediate/coarea custody are unchanged. + +## Exact source and actual exposure + +Full candidate read: [comment5963566666](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963566666), `C91-PLANAR-WINDOW-TAYLOR-TRANSFER-20261003-v1`, **12,433 UTF-8 bytes**, SHA256 `74a9ee276c3647276deb544c6d83e3cf21f708f55f9009fa4db5cc49c9d0e9aa`. Fresh native readback was unchanged before publication. + +Actual executor: OpenAI/Codex coordinating `/root` Work Mode session, distinct from C91 author root01a0bbb5. Exact model-build identifier is not exposed here. Prior C91 outline, FL.1/QS intake and cubic-source exposure are disclosed. I did not author C91, amend its proof or use author checker code. Existing OpenAI/Codex helper `c86_fresh_review` read the full candidate and supplied supporting reconstruction of §§1.3, 2, 3; this is not a second acceptance vote or organizational-independence credit. No proof repair contribution was incorporated. + +Dylan Roy — delegated AI review. Personal reading **PENDING**, organizational independence **0**, scientific effect **NONE**. + +Consumed interfaces actually read: +- FL.1 and raw setting: [Math243 PROOF at e8c76a4](https://github.com/d6g8k5htny-coder/Math-/blob/e8c76a4080e8e8be3dd9f613006263be6d53bad3/frontiers/soft_fold_limit_20261002/PROOF.md), blob `6502cf7ba2edee47761e40308c15b7563b06d1f8`, **78,874B**, SHA256 `f972f46d6b7348a4ff5d2eea022694364895a5273265818533dd01204b4c06a0`. Motivating source, not an imported C5 proof of this new C4 estimate. +- [QS5961415030](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5961415030), **37,032B**, SHA256 `12ffa126e45253fea5eec47f50ffa842a61165a2cbc0f5917e3543e81c09c1f2`: global setting, local rescalings and E1/E2/E3 interface freshly read. +- CU.1 pin interface at blob `f6df5a7356a54771b0052e42a864a140709903ad` and #242 raw model at blob `271412dbc96a29590f5f805258e15c9e335cb430` were source-exposed during intake. The pin/Taylor and coordinate arguments below reconstruct directly; no Gaussian or decision-limit theorem is imported from them. + +## 1. C4 pin corrections: every coefficient reconstructs + +Let a=r/2. C4 regularity supplies value remainders bounded by `Na^4/24` and derivative remainders bounded by `Na^3/6`. The two derivative pins give + +```text +|g1+a^2 g3/2| <= Na^3/6, +|g2| <= Na^2/6. +``` + +The value difference is -8ka^3. Substitution of the first inequality makes it `-(2/3)a^3 g3` plus an error at most + +```text +2a(Na^3/6)+2(Na^4/24)=5Na^4/12. +``` + +Therefore `|g3-12k|<=5Na/8`. Substituting back gives `|g1+6ka^2|<=(5/16+1/6)Na^3=23Na^3/48`. In the value average, `a^2g2/2` contributes at most `Na^4/12` and the averaged remainder at most `Na^4/24`; their sum is `Na^4/8`. This proves all W7–W8 constants. + +For q=f_z on the axis, C4 gives q a bounded third derivative. Its order-two Taylor formula and the two transverse-gradient pins give exactly W9. No fifth derivative is needed. After raw scaling, the six correction coefficients are bounded by Nr times + +```text +1/(128k_-), 23/(384k_-), 1/(48k_-), 5/(96k_-), 1/48, 1/24, +``` + +for `1,X,X^2,X^3,zeta,X*zeta`, respectively. The pure transverse second derivative and the remaining third jets are retained exactly in G_k; no smallness or sign assumption on them is hidden. + +## 2. Differentiated remainder and all mixed derivatives + +For any multiindex alpha of total order m<=2, `D^alpha T3` is exactly the degree-(3-m) Taylor polynomial of `D^alpha f`. Its next derivative has total order four. The directional integral remainder and multinomial expansion therefore give + +```text +|D^alpha(f-T3)(x,z)| <= N(|x|+|z|)^(4-m)/(4-m)!. +``` + +This uses the stated maximum of **all coordinate partials through order four**, in the fixed frame. A dominating operator-derivative norm is sufficient, but an unrelated or lower-order norm would not be. + +A raw alpha=(i,j) derivative multiplies by `r^i(rk)^j`. Dividing by kr^3 yields W11, including the mixed alpha=(1,1) case. The respective maxima of `k^(j-1)` for m=0,1,2 are bounded by `1/k_-,M1,M2`. + +For each correction monomial, coordinate derivatives of exact order m have size at most its tabulated number times `w^(4-m)`, since w>=1 and its degree is at most three. The three sums are + +```text +9/(64k_-)+1/16, +33/(128k_-)+1/16, +17/(48k_-)+1/24. +``` + +Adding the differentiated remainder bounds proves W3–W4. At k=1 the exact sums are + +```text +K0=167/192, K1=635/384, K2=115/48. +``` + +The order-two quantity is an **entrywise Hessian bound**, not yet an operator norm. Theorem 2 correctly accounts for that distinction. W0 gives the claimed injective local-chart interpretation; the globally periodic lift itself permits the Taylor segments without that geometric restriction. + +## 3. Sharpness survives the global C4 norm and periodic extension + +For the stated quartic family, + +```text +E=(tr/k)(X^2-1/4)^2, +E_X=(tr/k)(4X^3-X), +E_XX=(tr/k)(12X^2-1). +``` + +The quartic and its first axial derivative vanish at both pins, and no transverse jet is introduced. Thus the model really is the axial cubic. + +Choose fixed b,k,t and a fixed smooth cutoff supported in an injective torus chart, equal to one on a smaller ball. The polynomial coefficients are uniformly bounded for small r. By the product rule, every derivative through order four of the cutoff field is uniformly bounded on the torus: all cutoff derivatives are fixed, and the polynomial is evaluated on a fixed compact support. Hence the global N in the statement stays bounded. + +Choose w tending to infinity with rw tending to zero, for example `w=r^(-1/8)`; for fixed k the entire raw window eventually lies where the cutoff equals one. Evaluating at X=w gives nonzero leading coefficients 1,4,12 in degrees 4,3,2. Against any smaller proposed power p<4-j, the ratio grows at least as a fixed positive multiple of `w^(4-j-p)`. This proves the stated obstruction, not just a local formal example. + +This sharpness fixture need not satisfy Theorem 2's later typing assumptions; Theorem 1 and its sharpness statement do not require them. No Gaussian-family norm bound is inferred. + +## 4. Exact shear and Hessian transfer + +Substitute `X=u-Z/12,zeta=Z/gamma`. The axial cubic and gamma mixed term cancel the linear Z and u^2Z terms, leaving `-uZ^2/24+Z^3/432`. Adding the transverse terms gives + +```text +-(lambda_tilde/(2gamma^2)) Z^2 ++(-1/24+B/(2gamma^2)) u Z^2 ++(1/432-B/(24gamma^2)+C3/(6gamma^3)) Z^3. +``` + +These are precisely W14's psi,c,R coefficients. The identity holds for either sign of nonzero gamma. + +The inverse affine shear followed by the QS ellipse rescaling gives T_i in W15. There is no gradient-dependent Hessian-chain correction, because the transformation is affine. Typing gives `a_S,a_M>0` and + +```text +gamma^2 kappa_i=a_i/48, +||T_i||F^2=1/3+(1/144+1/gamma^2)/kappa_i + =1/3+(gamma^2+144)/(3a_i). +``` + +A symmetric 2-by-2 raw Hessian with entries bounded by epsilon2 has operator norm at most 2epsilon2. Therefore + +```text +||T_i^T H_E T_i||op + <= 2epsilon2 ||T_i||F^2 + = (2epsilon2/3)[1+(gamma^2+144)/a_i]. +``` + +This is W16, with both genuine typing-edge denominators retained. Gamma=0 is still outside the coordinate chart. Along nonzero gamma tending to zero, the right side stays bounded if a_i stays bounded below. No uniform assertion through a_i=0 is made. + +## 5. Conditional trap application and global path lifting + +The raw containment of V_eta and both ellipses is a necessary premise. W17 and W18 then supply exactly QS's strict C0 bound, its S-Hessian bound <=2/5, and its M-Hessian bound <1. W1 and the exact model pins supply zero error values and gradients at both pins. The periodic C4 lift supplies global continuity and the required local C2 regularity. + +For any valid imported certificate, retain **all** its restrictions. If the original QS-E certificate is used, its Delta exclusion is retained; using a corrected A2 replacement requires that replacement as an identified valid input. C91 does not itself validate the proposed A2 box or erase the recorded v1 AMEND disposition. + +Every continuous torus path starting at M lifts to a plane path starting at the chosen lift of M; every plane path projects back. Values and the endpoint condition f>b are preserved. Paths are not required to stay in the injective chart. Thus the maximin of f equals that of its unnormalized lift. Positive affine normalization at k=1 gives + +```text +d_F_r(M)=(d_f(M)-b)/r^3. +``` + +The invertible raw/sheared coordinate map preserves this normalized maximin. A valid certificate yielding d_g(M)=-1 therefore gives `d_f(M)=b-r^3=f(S)`, as claimed. This is not a proof of unique persistence pairing in the absence of the additionally stated Morse/critical-value convention. + +## 6. Independent exact controls and reproducible source + +I wrote and ran the standard-library script below without author-code reliance. It passes **2,734 explicit checks** in normal and optimized modes with identical **276-byte output**, SHA256 `f583ed9982c2c9e31e3fea24c732fefc753c8a5e11d149deb979318440db3c92`. + +The script is **6,510 UTF-8 bytes**, including its final newline, SHA256 `2d456e6da00c11a7b9a306c8d56d97b7868ddeda4924201d814a85818484d409`. It checks exactly pinned quartic polynomial families, all six derivative multiindices through order two, explicit norm-majorized window fixtures, the constants, both signs of gamma in the shear, and both typing-edge identities. Four built-in wrong-identity counterchecks detect an omitted X*zeta pin correction, an omitted k^2 chain factor, a lost gamma^2 numerator and a lost cubic shear term. These are identity counterchecks, not four separately executed mutant programs. + +The polynomial norm bounds used in fixtures are certified coefficient-sum upper bounds on their fixed physical square. They are computational support for those fixtures, not a sampled inference of the universal C4 theorem. The universal Taylor, cutoff and topological proofs are reconstructed above. + +```python +from fractions import Fraction as F +from math import factorial +import json + +checks = 0 +def require(ok, label): + global checks + checks += 1 + if not ok: + raise ValueError(label) +def clean(p): + return {a:F(c) for a,c in p.items() if c} +def add(*ps): + q={} + for p in ps: + for a,c in p.items(): + q[a]=q.get(a,F(0))+c + return clean(q) +def scale(p,c): + return clean({a:v*c for a,v in p.items()}) +def mul(p,q): + z={} + for (i,j),v in p.items(): + for (a,b),w in q.items(): + e=(i+a,j+b) + z[e]=z.get(e,F(0))+v*w + return clean(z) +def deriv(p, alpha): + q=p + for axis,n in enumerate(alpha): + for _ in range(n): + z={} + for a,c in q.items(): + if a[axis]: + b=list(a); b[axis]-=1 + z[tuple(b)]=c*a[axis] + q=clean(z) + return q +def val(p,x,z): + return sum((c*x**i*z**j for (i,j),c in p.items()),F(0)) +def pull(p,r,k): + return clean({(i,j):c*r**i*(r*k)**j/(k*r**3) + for (i,j),c in p.items()}) +def norm_bound(p,w): + return sum((abs(c)*w**(i+j) for (i,j),c in p.items()),F(0)) +def jet(p,i,j): + return val(deriv(p,(i,j)),F(0),F(0)) +alphas=[(0,0),(1,0),(0,1),(2,0),(1,1),(0,2)] +rejected=[] +def rejection(label, actual, wrong): + require(actual != wrong, "mutant did not differ: "+label) + rejected.append(label) + +for r in (F(1,32),F(1,16),F(1,8)): + for k in (F(1,2),F(1),F(3,2)): + a=r/2 + D={(2,0):F(1),(0,0):-a*a} + base={(3,0):2*k,(1,0):-F(3,2)*k*r*r,(0,0):-k*r**3/2} + lam,gam,B,C=F(2),F(3),F(-2),F(1) + cubic=add(base,{(0,2):-lam*r/(2*k)}, + scale(mul({(0,1):F(1)},D),gam/2), + {(1,2):B/2,(0,3):C/6}) + families=[(1,0,0,0,0),(0,1,0,0,0),(0,0,1,0,0), + (0,0,0,1,0),(0,0,0,0,1),(2,-3,4,-2,1)] + for t,d,e,h,l in families: + f=add(cubic,scale(mul(D,D),F(t)), + scale(mul(mul({(1,1):F(1)},D),{(0,0):F(1)}),F(d)), + {(2,2):F(e),(1,3):F(h),(0,4):F(l)}) + require(val(f,-a,F(0)) == 0 and val(f,a,F(0)) == -k*r**3,"values") + for q in (deriv(f,(1,0)),deriv(f,(0,1))): + require(val(q,-a,F(0)) == val(q,a,F(0)) == 0,"gradient pins") + g3,gamma,bj,cj=jet(f,3,0),jet(f,2,1),jet(f,1,2),jet(f,0,3) + lt=-k*jet(f,0,2)/r + G={(3,0):F(2),(1,0):-F(3,2),(0,0):-F(1,2), + (2,1):gamma/2,(0,1):-gamma/8,(0,2):-lt/2, + (1,2):k*bj/2,(0,3):k*k*cj/6} + E=add(pull(f,r,k),scale(G,-1)) + Q={(2,0):F(1),(0,0):-F(1,4)} + expected=scale(add(scale(mul(Q,Q),F(t)/k), + scale(mul({(1,1):F(1)},Q),F(d)), + {(2,2):F(e)*k,(1,3):F(h)*k*k,(0,4):F(l)*k**3}),r) + require(E == expected,"exact quartic raw error") + N=max(norm_bound(deriv(f,(i,j)),F(1)) + for m in range(5) for i in range(m+1) for j in [m-i]) + require(abs(g3-12*k)<=5*N*r/16,"g3") + require(abs(jet(f,1,0)+F(3,2)*k*r*r)<=23*N*r**3/384,"g1") + require(abs(jet(f,0,0)+k*r**3/2)<=N*r**4/128,"g0") + require(abs(jet(f,2,0))<=N*r*r/24,"g2") + require(abs(jet(f,0,1)+r*r*gamma/8)<=N*r**3/48,"fz") + require(abs(jet(f,1,1))<=N*r*r/24,"fxz") + H=1+k + Ks=[F(9,64)/k+F(1,16)+H**4/(24*k), + F(33,128)/k+F(1,16)+max(1/k,F(1))*H**3/6, + F(17,48)/k+F(1,24)+max(1/k,F(1),k)*H**2/2] + for alpha in alphas: + require(deriv(E,alpha)==deriv(expected,alpha),"mixed polynomial identity") + # Pulled physical derivatives and raw derivatives must agree exactly. + i,j=alpha + lhs=deriv(pull(f,r,k),alpha) + rhs=scale(pull(deriv(f,alpha),r,k),r**(i+j)*k**j) + require(lhs==rhs,"derivative pullback") + for w in (F(1),F(2)): + require(r*(1+k)*w<=1,"fixture domain") + require(norm_bound(deriv(E,alpha),w)<=Ks[i+j]*N*r*w**(4-i-j), + "coefficient-certified window fixture") + if d and not t and not e and not h and not l and r==F(1,32) and k==1: + rejection("omit_Xzeta_pin_correction", E, + add(E,{(1,1):F(d)*r/4})) + if l and not t and not d and not e and not h and r==F(1,32) and k==F(3,2): + alpha=(0,2) + wrong=scale(pull(deriv(f,alpha),r,k),r*r) # missing k^2 + rejection("omit_k_squared_chain_factor",deriv(pull(f,r,k),alpha),wrong) + +require(F(9,64)+F(1,16)+F(16,24)==F(167,192),"K0") +require(F(33,128)+F(1,16)+F(8,6)==F(635,384),"K1") +require(F(17,48)+F(1,24)+F(4,2)==F(115,48),"K2") +for gamma in (F(1,4),F(1),F(2),F(4)): + for lt in (F(1),F(2)): + for B in (F(-1,4),F(0),F(1,4)): + for sign in (-1,1): + a=24*lt+sign*(gamma*gamma-12*B) + require(a>0,"typed transfer fixture") + kap=a/(48*gamma*gamma) + left=F(1,3)+(F(1,144)+1/(gamma*gamma))/kap + right=F(1,3)+(gamma*gamma+144)/(3*a) + require(left==right,"Frobenius denominator identity") + if gamma==1 and lt==1 and B==0 and sign==1: + rejection("drop_gamma_squared_numerator",right,F(1,3)+F(144)/(3*a)) +# Exact constant leading derivatives of the quartic obstruction. +Q={(2,0):F(1),(0,0):-F(1,4)} +quartic=mul(Q,Q) +for j,leading in ((0,F(1)),(1,F(4)),(2,F(12))): + p=deriv(quartic,(j,0)) + require(p[(4-j,0)]==leading,"sharpness derivative power") + +def power(p,n): + q={(0,0):F(1)} + for _ in range(n): + q=mul(q,p) + return q +def compose(p,x,z): + return add(*(scale(mul(power(x,i),power(z,j)),c) + for (i,j),c in p.items())) +for gamma in (F(-4),F(-2),F(-1),F(-1,4),F(1,4),F(1),F(2),F(4)): + for lt in (F(1),F(2)): + for B in (F(-1,4),F(0),F(1,4)): + for C in (F(-1),F(0),F(1)): + raw={(3,0):F(2),(1,0):-F(3,2),(0,0):-F(1,2), + (2,1):gamma/2,(0,1):-gamma/8,(0,2):-lt/2, + (1,2):B/2,(0,3):C/6} + X={(1,0):F(1),(0,1):-F(1,12)} + zeta={(0,1):1/gamma} + shear=compose(raw,X,zeta) + psi=24*lt/(gamma*gamma) + c=1-12*B/(gamma*gamma) + R=8-144*B/(gamma*gamma)+576*C/(gamma**3) + P=clean({(3,0):F(2),(1,0):-F(3,2),(0,0):-F(1,2), + (0,2):-psi/48,(1,2):-c/24,(0,3):R/3456}) + require(shear==P,"exact G1/P shear identity, both gamma signs") + if gamma==1 and lt==1 and B==0 and C==1: + rejection("drop_transverse_cubic_shear_term",P, + add(P,{(0,3):-F(1,6)})) + +print(json.dumps({"checks":checks,"rejected_mutants":rejected, + "constants":["167/192","635/384","115/48"], + "scope":"exact polynomial/chain/constant fixtures, not universal proof"}, + sort_keys=True,separators=(",",":"))) +``` + +Observed stdout in both modes: + +```json +{"checks":2734,"constants":["167/192","635/384","115/48"],"rejected_mutants":["omit_Xzeta_pin_correction","omit_k_squared_chain_factor","drop_gamma_squared_numerator","drop_transverse_cubic_shear_term"],"scope":"exact polynomial/chain/constant fixtures, not universal proof"} +``` + +Still outside this verdict: probabilities of W18, Gaussian weighted moments of N on growing windows, law/determinant-weight comparison, actual-field rejected-side confinement, regional collision, intermediate coarea, unrestricted density/remainder and the full persistence-measure bridge. No source commit, CI, merge, independent human acceptance or scientific status change is represented. diff --git a/frontiers/planar_soft_layer_chain_20261003/C91/checker.py b/frontiers/planar_soft_layer_chain_20261003/C91/checker.py new file mode 100644 index 000000000..a2131adfd --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C91/checker.py @@ -0,0 +1,167 @@ +from fractions import Fraction as F +from math import factorial +import json + +checks = 0 +def require(ok, label): + global checks + checks += 1 + if not ok: + raise ValueError(label) +def clean(p): + return {a:F(c) for a,c in p.items() if c} +def add(*ps): + q={} + for p in ps: + for a,c in p.items(): + q[a]=q.get(a,F(0))+c + return clean(q) +def scale(p,c): + return clean({a:v*c for a,v in p.items()}) +def mul(p,q): + z={} + for (i,j),v in p.items(): + for (a,b),w in q.items(): + e=(i+a,j+b) + z[e]=z.get(e,F(0))+v*w + return clean(z) +def deriv(p, alpha): + q=p + for axis,n in enumerate(alpha): + for _ in range(n): + z={} + for a,c in q.items(): + if a[axis]: + b=list(a); b[axis]-=1 + z[tuple(b)]=c*a[axis] + q=clean(z) + return q +def val(p,x,z): + return sum((c*x**i*z**j for (i,j),c in p.items()),F(0)) +def pull(p,r,k): + return clean({(i,j):c*r**i*(r*k)**j/(k*r**3) + for (i,j),c in p.items()}) +def norm_bound(p,w): + return sum((abs(c)*w**(i+j) for (i,j),c in p.items()),F(0)) +def jet(p,i,j): + return val(deriv(p,(i,j)),F(0),F(0)) +alphas=[(0,0),(1,0),(0,1),(2,0),(1,1),(0,2)] +rejected=[] +def rejection(label, actual, wrong): + require(actual != wrong, "mutant did not differ: "+label) + rejected.append(label) + +for r in (F(1,32),F(1,16),F(1,8)): + for k in (F(1,2),F(1),F(3,2)): + a=r/2 + D={(2,0):F(1),(0,0):-a*a} + base={(3,0):2*k,(1,0):-F(3,2)*k*r*r,(0,0):-k*r**3/2} + lam,gam,B,C=F(2),F(3),F(-2),F(1) + cubic=add(base,{(0,2):-lam*r/(2*k)}, + scale(mul({(0,1):F(1)},D),gam/2), + {(1,2):B/2,(0,3):C/6}) + families=[(1,0,0,0,0),(0,1,0,0,0),(0,0,1,0,0), + (0,0,0,1,0),(0,0,0,0,1),(2,-3,4,-2,1)] + for t,d,e,h,l in families: + f=add(cubic,scale(mul(D,D),F(t)), + scale(mul(mul({(1,1):F(1)},D),{(0,0):F(1)}),F(d)), + {(2,2):F(e),(1,3):F(h),(0,4):F(l)}) + require(val(f,-a,F(0)) == 0 and val(f,a,F(0)) == -k*r**3,"values") + for q in (deriv(f,(1,0)),deriv(f,(0,1))): + require(val(q,-a,F(0)) == val(q,a,F(0)) == 0,"gradient pins") + g3,gamma,bj,cj=jet(f,3,0),jet(f,2,1),jet(f,1,2),jet(f,0,3) + lt=-k*jet(f,0,2)/r + G={(3,0):F(2),(1,0):-F(3,2),(0,0):-F(1,2), + (2,1):gamma/2,(0,1):-gamma/8,(0,2):-lt/2, + (1,2):k*bj/2,(0,3):k*k*cj/6} + E=add(pull(f,r,k),scale(G,-1)) + Q={(2,0):F(1),(0,0):-F(1,4)} + expected=scale(add(scale(mul(Q,Q),F(t)/k), + scale(mul({(1,1):F(1)},Q),F(d)), + {(2,2):F(e)*k,(1,3):F(h)*k*k,(0,4):F(l)*k**3}),r) + require(E == expected,"exact quartic raw error") + N=max(norm_bound(deriv(f,(i,j)),F(1)) + for m in range(5) for i in range(m+1) for j in [m-i]) + require(abs(g3-12*k)<=5*N*r/16,"g3") + require(abs(jet(f,1,0)+F(3,2)*k*r*r)<=23*N*r**3/384,"g1") + require(abs(jet(f,0,0)+k*r**3/2)<=N*r**4/128,"g0") + require(abs(jet(f,2,0))<=N*r*r/24,"g2") + require(abs(jet(f,0,1)+r*r*gamma/8)<=N*r**3/48,"fz") + require(abs(jet(f,1,1))<=N*r*r/24,"fxz") + H=1+k + Ks=[F(9,64)/k+F(1,16)+H**4/(24*k), + F(33,128)/k+F(1,16)+max(1/k,F(1))*H**3/6, + F(17,48)/k+F(1,24)+max(1/k,F(1),k)*H**2/2] + for alpha in alphas: + require(deriv(E,alpha)==deriv(expected,alpha),"mixed polynomial identity") + # Pulled physical derivatives and raw derivatives must agree exactly. + i,j=alpha + lhs=deriv(pull(f,r,k),alpha) + rhs=scale(pull(deriv(f,alpha),r,k),r**(i+j)*k**j) + require(lhs==rhs,"derivative pullback") + for w in (F(1),F(2)): + require(r*(1+k)*w<=1,"fixture domain") + require(norm_bound(deriv(E,alpha),w)<=Ks[i+j]*N*r*w**(4-i-j), + "coefficient-certified window fixture") + if d and not t and not e and not h and not l and r==F(1,32) and k==1: + rejection("omit_Xzeta_pin_correction", E, + add(E,{(1,1):F(d)*r/4})) + if l and not t and not d and not e and not h and r==F(1,32) and k==F(3,2): + alpha=(0,2) + wrong=scale(pull(deriv(f,alpha),r,k),r*r) # missing k^2 + rejection("omit_k_squared_chain_factor",deriv(pull(f,r,k),alpha),wrong) + +require(F(9,64)+F(1,16)+F(16,24)==F(167,192),"K0") +require(F(33,128)+F(1,16)+F(8,6)==F(635,384),"K1") +require(F(17,48)+F(1,24)+F(4,2)==F(115,48),"K2") +for gamma in (F(1,4),F(1),F(2),F(4)): + for lt in (F(1),F(2)): + for B in (F(-1,4),F(0),F(1,4)): + for sign in (-1,1): + a=24*lt+sign*(gamma*gamma-12*B) + require(a>0,"typed transfer fixture") + kap=a/(48*gamma*gamma) + left=F(1,3)+(F(1,144)+1/(gamma*gamma))/kap + right=F(1,3)+(gamma*gamma+144)/(3*a) + require(left==right,"Frobenius denominator identity") + if gamma==1 and lt==1 and B==0 and sign==1: + rejection("drop_gamma_squared_numerator",right,F(1,3)+F(144)/(3*a)) +# Exact constant leading derivatives of the quartic obstruction. +Q={(2,0):F(1),(0,0):-F(1,4)} +quartic=mul(Q,Q) +for j,leading in ((0,F(1)),(1,F(4)),(2,F(12))): + p=deriv(quartic,(j,0)) + require(p[(4-j,0)]==leading,"sharpness derivative power") + +def power(p,n): + q={(0,0):F(1)} + for _ in range(n): + q=mul(q,p) + return q +def compose(p,x,z): + return add(*(scale(mul(power(x,i),power(z,j)),c) + for (i,j),c in p.items())) +for gamma in (F(-4),F(-2),F(-1),F(-1,4),F(1,4),F(1),F(2),F(4)): + for lt in (F(1),F(2)): + for B in (F(-1,4),F(0),F(1,4)): + for C in (F(-1),F(0),F(1)): + raw={(3,0):F(2),(1,0):-F(3,2),(0,0):-F(1,2), + (2,1):gamma/2,(0,1):-gamma/8,(0,2):-lt/2, + (1,2):B/2,(0,3):C/6} + X={(1,0):F(1),(0,1):-F(1,12)} + zeta={(0,1):1/gamma} + shear=compose(raw,X,zeta) + psi=24*lt/(gamma*gamma) + c=1-12*B/(gamma*gamma) + R=8-144*B/(gamma*gamma)+576*C/(gamma**3) + P=clean({(3,0):F(2),(1,0):-F(3,2),(0,0):-F(1,2), + (0,2):-psi/48,(1,2):-c/24,(0,3):R/3456}) + require(shear==P,"exact G1/P shear identity, both gamma signs") + if gamma==1 and lt==1 and B==0 and C==1: + rejection("drop_transverse_cubic_shear_term",P, + add(P,{(0,3):-F(1,6)})) + +print(json.dumps({"checks":checks,"rejected_mutants":rejected, + "constants":["167/192","635/384","115/48"], + "scope":"exact polynomial/chain/constant fixtures, not universal proof"}, + sort_keys=True,separators=(",",":"))) diff --git a/frontiers/planar_soft_layer_chain_20261003/C91/checker_stdout.txt b/frontiers/planar_soft_layer_chain_20261003/C91/checker_stdout.txt new file mode 100644 index 000000000..11803703e --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C91/checker_stdout.txt @@ -0,0 +1 @@ +{"checks":2734,"constants":["167/192","635/384","115/48"],"rejected_mutants":["omit_Xzeta_pin_correction","omit_k_squared_chain_factor","drop_gamma_squared_numerator","drop_transverse_cubic_shear_term"],"scope":"exact polynomial/chain/constant fixtures, not universal proof"} diff --git a/frontiers/planar_soft_layer_chain_20261003/C92/DELIVERY.md b/frontiers/planar_soft_layer_chain_20261003/C92/DELIVERY.md new file mode 100644 index 000000000..883d21226 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C92/DELIVERY.md @@ -0,0 +1,13 @@ +C92 reviewed delivery complete — quantitative weighted soft-jet transfer + +**Theorem J has passed a complete nonauthor technical review with no amendment required.** The immutable [proof5963825788](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963825788) gives an O(r) polynomial-weighted L1 comparison for the actual finite-dimensional weighted jets on a fixed bounded signed soft-Hessian layer. The full normalizer gives soft-layer probability r^3 m_Lambda/z0 + O(r^4), and the growing-window Taylor-failure estimate is o(r^3) in the stated regime. Scope: d=2, k=1, fixed finite L, compact births, all orthonormal frames, fixed Lambda. + +The [full review5963946854](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963946854) reconstructs J1–J20 and includes independently written checker source. Local final master replay passed: author 49,948 exact controls and seven separately rejected mutants; reviewer 10,599 controls and eight built-in false-claim fixtures. Both implementations are byte-identical between normal and optimized runs; reviewer stdout also matches across the review's Python3.12 and local Python3.11. These controls do not replace the analytic proof. + +[One immutable Drive delivery](https://drive.google.com/file/d/1Q_p1ONCSiYJVpzMRLScBCR13GT8NLKpL/view?usp=drivesdk): 335,686 bytes, 31 payloads; SHA256 `e2fdb6e16299f25100b7351dcddb3e2c40dcfd1abbe663e92837e83c63bd0202`. Uploaded bytes were downloaded and matched exactly; canonical archive/manifest/handoff verification passed; owner-only sharing retained. Registered AI886 / Evidence Lineage608 / RQ155 / WE615. Full CellData readback passed. Claim `c0f75fd7-d866-4a5d-b248-2e2ce62622f2` released at WE616 after verified delivery. + +@claude — exact proof incorporation is available for the existing analytic source. This is an incorporation request, not an assertion that another worker has picked it up. Preserve the proof/review bodies and the A2 v1 AMEND history; this theorem does not depend on A2. No repository commit, remote CI or merge is claimed by this comment-based delivery. + +Next precise analytic target, after a fresh custody/claim check: weighted typing-edge strips and the truncation needed for the C91 Hessian transfer. C92's L1 bound does not license unbounded inverse-margin observables. Growing Lambda, all-mark uniformity, window containment, actual elder-decision identification, shrinking regional collisions, intermediate/coarea composition and the full persistence bridge remain separate obligations. Existing A2 correction and intermediate/coarea author custody is untouched. + +Dylan Roy — delegated AI work/review. Actual author OpenAI/Codex root01a0bbb5; distinct OpenAI/Codex coordinating-root nonauthor reviewer, with prior intake/outline/source/C91 exposure disclosed and one supporting helper. Personal reading PENDING; organizational independence 0; scientific effect NONE. \ No newline at end of file diff --git a/frontiers/planar_soft_layer_chain_20261003/C92/PROOF.md b/frontiers/planar_soft_layer_chain_20261003/C92/PROOF.md new file mode 100644 index 000000000..4f6598a15 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C92/PROOF.md @@ -0,0 +1,390 @@ +# Quantitative planar soft-jet transfer under the actual determinant weight + +Object: C92-PLANAR-COMPACT-SOFT-JET-WEIGHTED-TRANSFER-20261003-v1. +Author: OpenAI/Codex root01a0bbb5, acting for Dylan Roy — delegated AI work. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; nonauthor technical review pending. +Personal reading PENDING; organizational independence 0; scientific effect NONE. + +This proves an O(r) comparison of finite measures on a bounded soft-Hessian +layer, and a determinant-weighted growing-window Taylor-failure estimate on +its r^3 probability scale. The measures keep the actual endpoint typing and +the FULL weighted normalizer. This is neither total variation of field laws +nor a persistence-identification theorem. + +## 0. Exact interfaces and scope + +Fix the planar torus R^2/(L Z^2), L>0 fixed, and the centered variance-one +Gaussian field with covariance + + K_L(z)=sum_{n in Z^2} exp(-|z+Ln|^2/2) + / sum_{n in Z^2} exp(-|Ln|^2/2). + +All constants may depend on L and on the stated fixed cutoffs. No uniformity +as L varies, no higher-dimensional transfer and no general-covariance claim +is made. Take birth b in a fixed nonempty compact set B0 in R, gap mark k=1, +and any orthonormal frame (u,e), including either orientation. Coordinates +(x,z) refer to the periodic lift in that frame. All assertions below are +uniform in b in B0 and in the frame, for 00, mu_r has a density g_r, and for +every fixed finite q>=0 there is C_{Lambda,q}=z_*/2. (J4) + +For the finite measure eta_r(E)=r^(-3)Q_r^W((lambda,t) in E), + + eta_r=mu_r/z_r, + integral_{D_Lambda}(1+|t|)^q |g_r/z_r-g_0/z_0|<=C r, + Q_r^W(|lambda|<=Lambda) + =r^3 m_Lambda/z_0+O(r^4). (J5) + +All constants in (J3)–(J5) may depend on L, B0, Lambda and q; none is claimed +numerically evaluated. This is a local finite measure on D_Lambda, not a +probability density on all lambda. The limiting density is zero for +lambda<=0, although the finite-r measure was restricted symmetrically. + +For the Taylor statement put + + F_r(X,zeta)=(f(rX,r zeta)-b)/r^3, + G=2X^3-3X/2-1/2+(gamma/2)(X^2-1/4)zeta + -(lambda/2)zeta^2+(B1/2)X zeta^2+(C3/6)zeta^3, + E_r=F_r-G, K0=167/192, K1=635/384, K2=115/48. + +Let |E_r|_j denote the maximum of all exact-order-j coordinate derivative +suprema on |X|,|zeta|<=w. For any finite p>=1, deterministic epsilon>0, +w>=1 with 2rw<=L/4, and j=0,1,2, + + Q_r^W(|lambda|<=Lambda, |E_r|_j>epsilon) + <= C_{Lambda,p} r^3 (K_j r w^(4-j)/epsilon)^p. (J6) + +The statement holds pointwise in deterministic epsilon,w, so they may be +chosen as functions of r. If w=r^(-beta), epsilon=r^eta with beta,eta>=0 +and 4beta+eta<1, a union over the three derivative orders gives + + Q_r^W(|lambda|<=Lambda, max_{0<=j<=2}|E_r|_j>r^eta) + <= C_{Lambda,p} r^[3+p(1-4beta-eta)] = o(r^3). (J7) + +Constants depend on p; this does not assert an exponential tail or permit +p to grow with r. By (J5) the conditional failure probability given the +soft layer is O(r^[p(1-4beta-eta)]). Random jet-dependent tolerances require +additional inverse-margin estimates and are not covered by (J6)–(J7). + +## 2. Uniform Gaussian facts at the actual ten observations + +Use the exact centered observations, with a=-r/2 and c=r/2, + + U_r=((f(a)+f(c))/2, (f(c)-f(a))/r, + (f_x(c)-f_x(a))/r, + (6/r^2)[f_x(a)+f_x(c)-2(f(c)-f(a))/r], + (f_z(a)+f_z(c))/2, (f_z(c)-f_z(a))/r). + +Their target is v_r=(b-r^3/2,-r^2,0,12,0,0). For r>0 this is an invertible +linear change of the six original pin observations. At r=0 it has the +continuous extension U_0 above. Append (A,t) and write V_r=(U_r,A,t). +At contact its ten entries are precisely the ten distinct planar derivative +functionals through order3. There is no duplicated functional. + +The periodized covariance has positive Fourier coefficients a_n for every +n in Z^2, with sum sqrt(a_n)(1+|n|)^s finite for every finite s. If a real +linear combination of those ten contact jets has variance zero, its +Fourier multiplier P(2pi i n/L) vanishes for every n. P is a polynomial +of degree at most3, expressed in the chosen frame. A polynomial vanishing +on all integer lattice points is zero: fix the second coordinate and use +the univariate polynomial zero theorem in the first, then apply it to each +coefficient polynomial in the second. Rotation of coordinates is an +invertible polynomial substitution, so all ten coefficients are zero. +Consequently Gamma_0=Cov(V_0) is positive definite in every frame. + +The frame space O(2) is compact, Gamma_0 is continuous there, and therefore +its smallest eigenvalue has a positive minimum and its largest a finite +maximum. Centered differences give V_r-V_0=O(r^2) in every finite L^p; +the appended entries are unchanged. In particular the fourth row is +f_xxx(0)+(r^2/40)f_xxxxx(0)+O(r^4). Fourier summability controls these +estimates, as well as their cross-covariances with any fixed derivative of +the field, uniformly over position and frame. Thus, after reducing r0, + + cI<=Gamma_r<=CI, Gamma_r-Gamma_0=O(r^2), + Gamma_r^(-1)-Gamma_0^(-1)=O(r^2). (J8) + +This is full-spectrum positivity plus continuity, not a numerical grid or +a finite-mode test. The same estimates hold for the U-block. Schur +complement formulas then imply that (A,t)|U_r=v_r has a uniformly positive +four-dimensional covariance, bounded mean, and covariance/mean differences +O(r^2) from contact. The mean assertion uses compact b and +v_r-v_0=O(r^2). Let its joint density be rho_r(a,t). + +For |lambda|<=Lambda, Gaussian interpolation yields + + rho_r(-r lambda,t)<=C_Lambda exp(-c|t|^2), + |rho_r(-r lambda,t)-rho_0(0,t)| + <=C_Lambda r(1+|t|)^2 exp(-c|t|^2). (J9) + +For completeness, interpolate the conditional covariance and mean on their +straight segment. Uniform ellipticity persists on the segment. Differentiating +the Gaussian density gives that density times a polynomial of degree at most2 +in (a,t), with coefficients O(r^2). The means are bounded, so every density +on the segment is bounded by C exp(-c|(a,t)|^2) after reducing c. The remaining +shift from a=0 to a=-r lambda is of size at most rLambda; its derivative is +density times an affine polynomial, again with a common Gaussian majorant in +t. Integration of both derivatives proves (J9), retaining r rather than r^2 +because of the soft-coordinate shift. The l1 norm |t| is equivalent to the +Euclidean norm used in this calculation. + +We will also need the field law conditional on V_r=(v_r,-r lambda,t), not +an independent replacement of its jets. The exact Gaussian regression has +mean Cov(f,V_r)Gamma_r^(-1)(v_r,-r lambda,t). Uniform bounds on four position +derivatives of this covariance, (J8) and compact b imply that its C4 norm +is at most C_Lambda(1+|t|). The centered residual has C4 moments of every +finite order uniformly in r and frame. One direct proof conditions the +real Fourier coefficients: each centered conditional coefficient has variance +no larger than its original variance. Minkowski's inequality and +sum sqrt(a_n)(1+|n|)^4=1, + + E[N^p | U_r=v_r,A=-r lambda,t] + <=C_{Lambda,p}(1+|t|)^p. (J10) + +These formulas define continuous regression versions for every finite target. +Under them the pin and midpoint observations hold almost surely: each +conditioned linear observation has its specified mean and zero residual +variance. No independence between N and t, or between N and endpoint +Hessians, is being assumed. Smoothness follows from the same Fourier +summability. All disintegrations below use these versions. + +## 3. Keep the actual typed determinant, including its boundary + +At the two pins the cubic Hessians are + + L_M=[[-6,-gamma/2],[-gamma/2,-lambda-B1/2]], + L_S=[[ 6, gamma/2],[ gamma/2,-lambda+B1/2]]. (J11) + +Since k=1, D^2 F_r=H/r. Apply [C91] at w=1, reducing r0 so 2r<=L/4. +The N in this note dominates its C4 bound. Each entry of H_i/r-L_i has +absolute value at most (115/48)rN, hence + + ||H_i/r-L_i||_op <= (115/24)rN, i=M,S. (J12) + +There is no assumption that the eigenvalues of L_i stay away from zero. +For a symmetric 2 by 2 matrix put + + F_j(H)=|det H|1{index(H)=j}, zero on singular H. + +For symmetric X,Y the filtered determinant satisfies + + |F_j(X)-F_j(Y)|<=2 max(||X||,||Y||)||X-Y||. (J13) + +If both indices equal j, use the determinant difference bound and +|| |a|-|b| ||<=|a-b|. If neither contributes, the assertion is immediate. +If only one contributes, the segment reaches a singular matrix; apply the +determinant difference bound between the contributing endpoint and that +matrix. The segment's norm and length are bounded by the endpoint maximum +and the full difference respectively. The determinant difference bound follows +by telescoping its two columns and Hadamard's inequality. Singular endpoints +are included. The inertia indicator itself is discontinuous; (J13) makes +no Lipschitz assertion about that indicator. + +The pivots -6 and +6 in (J11) give exactly + + F_2(L_M)=(6lambda+3B1-gamma^2/4)_+, + F_1(L_S)=(6lambda-3B1+gamma^2/4)_+. (J14) + +Thus their product is w_lambda for all signed lambda and all t, including +typing edges. If lambda<=0, both factors cannot be strictly positive because +their sum before taking positive parts is 12lambda, so the product vanishes. + +Define D_r=W_r/r^4. Positive scalar rescaling preserves inertia, and the +determinant of a 2 by 2 matrix scales quadratically. Therefore exactly + + D_r=F_2(H_M/r)F_1(H_S/r). (J15) + +Let D=1+Lambda+|t| and T=C(D+rN) bound the four endpoint/model operator norms. +Each filtered determinant is at most T^2. By (J12)–(J13) and the product +difference inequality, + + |D_r-w_lambda|<=C rN(D+rN)^3, + D_r<=C(D+rN)^4. (J16) + +Taking the further conditional expectations in (J10), using r<=1, proves + + |E[D_r | U_r=v_r,A=-r lambda,t]-w_lambda(t)| + <=C_Lambda r(1+|t|)^4, + E[D_r N^p | U_r=v_r,A=-r lambda,t] + <=C_{Lambda,p}(1+|t|)^(p+4). (J17) + +For the first line expand rN(D+rN)^3 and use moments through order4. +For the second, (D+rN)^4<=8(D^4+(rN)^4) and use orders p and p+4. +This step preserves the actual weight rather than replacing it by its limit. + +## 4. Disintegration, density rate and full normalization + +The change of variable A=-r lambda has absolute Jacobian r. Combining this +with W_r=r^4 D_r proves the exact density identity + + g_r(lambda,t)=rho_r(-r lambda,t) + E[D_r | U_r=v_r,A=-r lambda,t]. (J18) + +Indeed the numerator in (J1) is r^5 times the integral of the right side. +Tonelli applies to these nonnegative integrands. Equations (J9) and (J17) +also prove finiteness of all the polynomial-weighted integrals used here. + +Subtract g_0 by first comparing the conditional determinants, then comparing +the densities. On D_Lambda, w_lambda<=C_Lambda(1+|t|)^4. Thus (J9), (J17) +and (J18) give the integrable pointwise bound + + |g_r-g_0|<=C_Lambda r(1+|t|)^6 exp(-c|t|^2). (J19) + +Integration against (1+|t|)^q proves (J3), for every fixed finite q. Gaussian +integrability here is explicit and uniform; no differentiation of a weak +limit or unproved exchange of limits is involved. + +For any lambda in (0,Lambda), the weight at t=0 is 36lambda^2>0. The joint +Gaussian density is strictly positive, so integration over a small open box +around lambda=Lambda/2,t=0 gives m_Lambda>0. On one fixed such box the +Gaussian means and eigenvalues range over a compact set; the density has a +positive uniform lower bound. Shrinking the box once keeps w_lambda bounded +below there. This proves a uniform m_*>0. The upper bound follows from the +Gaussian majorant. The same compact-parameter argument applied to the +nondegenerate conditional Gaussian A on a fixed negative interval gives a +uniform positive lower bound for z_0 in (J2), with a finite upper bound. + +The full normalizer estimate is [R](R10), specialized to k=1 and b in B0: +|Z_r/r^2-z_0|<=Cr. To spell out its interface, under the centered common +regression coupling the transverse A at the pins differs by O(rT) from +contact, with all moments of T uniformly finite. Congruence by +diag(r^(-1/2),1) transforms each actual Hessian to +[[alpha_i,sqrt(r) beta_i],[sqrt(r) beta_i,A_i]], +where alpha_i=+-6+O(rT), beta_i=O(T). Removing the sqrt(r) off-diagonal +changes a filtered determinant by at most r beta_i^2, including at singular +A_i: the determinant is affine in r, and an inertia change crosses its zero. +Then (J13) bounds the remaining diagonal comparison by CrT^2. The reference +product is 36 A^2 1{A<0}; multiplying and using the uniform moments gives +the stated O(r) expectation estimate. This is the corrected inverse-square- +root congruence from E1; no false O(sqrt(r)) loss is inserted. Decrease r0 +so z_r>=z_*/2. This establishes (J4) for the FULL Z_r. + +Now exactly r^(-3)Q_r^W(E)=mu_r(E)/z_r. By adding and subtracting g_0/z_r, +using (J3), |1/z_r-1/z_0|<=Cr and the finite weighted integral of g_0, +we obtain (J5). In particular the unnormalized soft-layer mass is +r^5 m_Lambda+O(r^6); division by the full r^2 z_r gives r^3, not r^5 +and not a conditional normalizer restricted to the layer. + +## 5. Weighted failures on growing windows + +[C91] gives |E_r|_j<=K_j N r w^(4-j) for every C4 field obeying the pins +and the stated geometric window restriction. Thus + + 1{|E_r|_j>epsilon} + <=(K_j r w^(4-j)/epsilon)^p N^p. + +Multiply by the actual D_r in (J18), integrate rho_r(-r lambda,t), and use +(J9),(J17). This yields + + r^(-5) E_{Q_r}[W_r 1{|lambda|<=Lambda} + 1{|E_r|_j>epsilon}] + <=C_{Lambda,p}(K_j r w^(4-j)/epsilon)^p. (J20) + +Division by Z_r>=r^2 z_*/2 proves (J6). For beta,eta in (J7), beta<1 ensures +2rw<=L/4 eventually; 4beta+eta<1 ensures the smallest exponent among +1-(4-j)beta-eta is positive. A union bound proves (J7), and the lower +soft-layer mass in (J5) proves its conditional version. All events and +derivative suprema are measurable on C4. QED. + +## 6. What this result can and cannot supply downstream + +For any measurable jet event in D_Lambda, (J3) controls the actual weighted +mass by the model mass with O(r) error after r^5 rescaling, uniformly even +for r-dependent events. More generally it controls measurable observables +bounded by a fixed multiple of (1+|t|)^q. This includes discontinuous typing +or fixed-margin cutoffs in these jets. It does not control observables with +unbounded inverse typing margins merely because the jet weight vanishes at +the boundary. + +The Taylor statement controls field errors jointly with the soft layer under +the actual determinant weight. To infer pairing loss still requires a valid +deterministic decision certificate, window containment and quantitative +integration of any jet-dependent margins. Unbounded lambda tails, all-mark +uniformity, shrinking collisions, intermediate/remote/coarea composition and +the equality of critical-pair and persistence coefficients are not closed by +this note. No whole-field total-variation convergence, global probability +normalization of w_lambda rho_0(0,t), evaluated numerical constants, new +theorem-level status, human review or organizational independence is claimed. + +Exact rational controls for matrices, Jacobians, pin scalings and negative +mutants can test transcription and algebra. The analytic proof above, and +its substantive nonauthor review, are necessary for the Gaussian density +and moment assertions; a finite list of tests cannot establish them. diff --git a/frontiers/planar_soft_layer_chain_20261003/C92/REVIEW.md b/frontiers/planar_soft_layer_chain_20261003/C92/REVIEW.md new file mode 100644 index 000000000..9deb08108 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C92/REVIEW.md @@ -0,0 +1,361 @@ +# C92 full nonauthor analytic review — PASS_TECHNICAL_SCOPED + +**Verdict: ACCEPT / PASS_TECHNICAL_SCOPED for Theorem J as stated in the exact frozen C92 v1.** I reconstructed the complete proof, J1–J20 and the downstream scope paragraph. No blocking defect or mathematical amendment was found. This is a technical verdict on the bounded-soft-layer finite-jet and weighted Taylor-failure statements, not acceptance of a persistence theorem or a scientific-status change. + +## Object, execution and exposure + +Reviewed object: [main229 comment5963825788](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963825788), **19,567 UTF-8 bytes**, SHA256 `6fa4c3d6d1e8c3d8590c865802d5df061ad5b17652ddc7fd7bf5c5e8b8de084a`, including its final newline. The author is OpenAI/Codex root01a0bbb5 in thread `01a0bbb5-2fcb-77f0-b78b-4d220ddd7ab2`, not this reviewer. The actual [review pickup5963845378](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963845378) is distinct from the author's WE614 claim `c0f75fd7-d866-4a5d-b248-2e2ce62622f2`. + +**Dylan Roy — delegated AI review. Actual performer: OpenAI/Codex, coordinating `/root` Work Mode review session.** Exact model-build identifier is not exposed in this runtime. Prior C92 intake/outline and P/R/FL source-interface exposure, plus the completed C91 review, are disclosed. I supplied no C92 proof text or incorporated proof repair and claim no C92 coauthorship. The prior exposure is not independent corroboration. The existing OpenAI/Codex helper `/root/c86_fresh_review` performed one disjoint read-only Gaussian/regression/normalizer audit of §§2 and 4, including a full C92 source read; its conclusions were checked against my own reconstruction. It made no edits, native publication or author-checker run. Supporting analysis only: **one coordinated review verdict, no second review credit**. No extra helper or fan-out was used. + +Organizational independence **0**; same-provider work. Dylan's personal reading **PENDING**. Scientific effect **NONE**. Neither account ownership nor this delegation supplies human review. + +## Source binding and consumption + +Math source cut: `e8c76a4080e8e8be3dd9f613006263be6d53bad3`. The following fetched contents were checked by actual byte counts and SHA256, not by their headers. Paths are relative to `d6g8k5htny-coder/Math-` at that cut. + +| Source | Exact identity | Consumed scope | +|---|---|---| +| P: `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md` | blob `dfed3b8d318a3ab1950957f393307733a4bef3f2`; 40261 B; SHA256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7` | §§2–5: spectrum, pins, regression and full normalization; topology/selection excluded. | +| R: `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md` | blob `247b3ecf80bfbe896948d5d489b2d5842a81c481`; 17734 B; SHA256 `380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a` | R2–R4, R6 and R10, specialized as stated; the required arguments were reconstructed. | +| E1: `imports/lifetime_parent_20260925/ERRATUM_CONGRUENCE.md` | blob `213594d6ca6a86fb938110f4d166d9ce275a02d0`; 1782 B; SHA256 `bad7ef609c4ad8c41ad6af562c1b6807921e19a9d556ed793ad1a0db6e202028` | Correct inverse-square-root congruence. | +| E2: `reviews/d1_section9_borel_repair_20260925/REPAIR.md` | blob `fe9b9ce4999908bb3814b500ee2d0ceb0c6f704a`; 9062 B; SHA256 `845abf9f9c99d672c2a10a887b5a2e7206a3d2de3d876f35f75ff6e2dc13e62f` | P reading rule retained; no elder/Kac–Rice theorem is needed for J. | +| REC: `reviews/d1_chain_reconciliation_20260928/RECONCILIATION.md` | blob `75da2597971510f843f8d90c743950cb8c177342`; 23312 B; SHA256 `451b9d7ffee072a73fc904cab891b6693e3f233808b89df10cce1b57036b65da` | Reading rule, W1, embedding and interface scopes; no fresh whole-parent acceptance. | +| C91: [comment5963566666](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963566666) | 12433 B; SHA256 `74a9ee276c3647276deb544c6d83e3cf21f708f55f9009fa4db5cc49c9d0e9aa` | Only deterministic C4 W4–W5 at k=1; A2/QS and maximin application excluded. | + +Historical review bindings were also reconciled: P review blob `bc11369c41ebc76de5700df3f931939ccfc88b9b` (24105 B; SHA256 `b7328d4bab97fa2d12622ca730dc698970febc1ea8bcbc0b24555e69e2a66392`) and R review blob `529c5264ed790ab1df36c14f567f460e2a5ed974` (20595 B; SHA256 `8679afd19ad313ade3602bba48b744183fdbefc9596a7793cfe7f921988a5dfd`). Their source and exposure/disposition records are historical inputs, not new votes or substitutes for this reconstruction. The historical parent bytes remain unchanged. + +## Analytic reconstruction + +### 1. Ten observations, centering and all-frame rank — ACCEPT + +The contact vector is exactly `f, fx, fxx, fxxx, fz, fxz, fzz, fxxz, fxzz, fzzz`: all ten distinct planar derivatives through order three. Appending A and t introduces no duplicated mixed derivative. A zero-variance combination annihilates every positive-weight Fourier mode. Its degree-at-most-three multiplier, after the invertible frame substitution, vanishes on the integer lattice and is identically zero. This works for complex multipliers and reflected as well as rotated frames. Continuity and compactness of O(2), not rotational invariance of the torus, give one contact covariance gap. + +The six-row observation transform has absolute determinant `12 r^-5` and the specified target exactly. Its centered rows cancel odd radius errors. In particular, the fourth row is `fxxx + r² fxxxxx/40 + O(r⁴)`. Rapid Fourier summability controls these remainders and derivative cross-covariances uniformly in position/frame. Thus the full ten-dimensional covariance and its inverse have O(r²) perturbations on a common small-radius band. The Schur complement retains a uniform four-dimensional covariance gap. Its conditional mean and covariance change by O(r²), because the birth targets are compact and `v_r-v_0=O(r²)`. + +### 2. Gaussian density and further-conditioned moments — ACCEPT + +Here rho is the **joint** density of `(A,t)` given U, not the density of t given A=0. Consequently `rho_0(0,t)=p(A=0|U_0) p(t|U_0,A=0)` in density notation; the first factor must remain. No original pin-density factor belongs to a measure already under Q_r. + +Gaussian interpolation with uniformly elliptic covariance and bounded means gives an O(r²) quadratic-score error at fixed `(a,t)`. Evaluating at `a=-r lambda` adds an O(r) affine-score shift for bounded signed lambda. These two contributions yield J9 with its Gaussian t-envelope; the final error is not wrongly promoted to O(r²). + +Regressing the whole field on the full V target gives a C4 mean bounded by `C(1+|t|)`, not a t-independent bound. The residual covariance is target-independent. Each centered conditional real Fourier coefficient has variance at most its original variance; Minkowski and the summable fourth-derivative spectral amplitudes give all fixed finite residual C4 moments. Correlations among residual coefficients are retained. This establishes J10 for every finite target under continuous regression versions, including A=0. Each imposed pin/jet has zero residual variance and its exact target mean. Nothing assumes N independent of t, Hessians or the tilt. + +### 3. Actual typing and filtered determinants — ACCEPT + +Differentiating the actual k=1 cubic gives J11, with off-diagonals `-gamma/2,+gamma/2` and transverse entries `-lambda-B1/2,-lambda+B1/2`. Since `D²F_r=H/r`, C91's entrywise estimate produces the operator error `2 K2 r N = (115/24)rN`. No spectral margin is needed. + +For the filtered determinant, equal contributing indices use the determinant telescoping bound. When only one endpoint contributes, a singular point on the symmetric straight segment controls that endpoint's determinant; the segment norm is bounded by the endpoint maximum. Singular endpoints cause no exception. This proves J13, not a false Lipschitz statement about the bare inertia indicator. + +The nonzero pivots -6 and +6 give the exact positive-part factors J14. Their unfiltered sum is `12 lambda`, so the product vanishes for lambda<=0. The sign-changing and singular cases are covered, not discarded. Scalar Hessian rescaling gives the exact product J15. Applying J13 and the product difference inequality with endpoint/model norm bound `C(D+rN)` gives J16. Expanding `rN(D+rN)^3`, and then using conditional moments through order four, gives the first J17 bound. The second uses moments p and p+4. Both preserve the **actual** endpoint-filtered weight, including its typing boundary. + +### 4. L1 measure, positivity and full normalizer — ACCEPT + +The absolute Jacobian `dA=r d lambda` and `W_r=r⁴D_r` give J18: the unnormalized layer has scale r⁵. Nonnegative disintegration/Tonelli and the J9/J17 envelope make every fixed polynomial-weighted integral finite. The density error has the stated majorant `Cr(1+|t|)^6 exp(-c|t|²)`, proving J3 for arbitrary fixed finite q, not merely bounded t. + +At `lambda=Lambda/2,t=0`, w is strictly positive. One fixed small box preserves its lower bound. Compact birth/frame parameters and uniformly elliptic bounded Gaussian parameters give a uniform positive joint-density lower bound there. Hence m_Lambda has a positive uniform floor. A fixed negative A-interval similarly gives the positive floor for z_0. These are pointwise parameter-uniform statements; the nonempty compact birth set need not have positive length. + +For the full normalization, the common Gaussian coupling from R3–R4 gives endpoint transverse errors O(rT) with every fixed T-moment uniformly bounded. The corrected congruence transforms H to `[[alpha,sqrt(r) beta],[sqrt(r) beta,A]]`, with `alpha=∓6+O(rT)`. Removing the off-diagonal changes a filtered determinant by at most `r beta²`: its determinant is affine in r, and a contributing inertia transition crosses zero. This remains true at singular A. The diagonal comparison costs `CrT²`. The reference filtered product is exactly `36 A_0² 1{A_0<0}`; multiplication and finite moments give `|Z_r/r²-z_0|<=Cr`, without an O(sqrt(r)) loss or inverse-margin moment. + +The normalization ledger is therefore `r⁴ × r / r² = r³`. Algebraically `r^-3 Q_r^W(E)=mu_r(E)/z_r`. A common positive z_r floor and the weighted L1 bound give J5, including the O(r⁴) absolute soft-layer probability remainder. Neither the restricted mass nor an extra pin-density factor replaces the full Z_r. + +### 5. Growing windows and downstream interpretation — ACCEPT + +C91 is applied to exact pinned C4 fields, with N here dominating its norm and `2rw<=L/4`. Its constants at k=1 are exactly `167/192,635/384,115/48`, for values, gradients and Hessian entries respectively. Multiplying the **pointwise** Markov bound by the actual D_r, then disintegrating and applying J10/J17, proves J20. Division by the full Z_r produces the r³ weighted rare-layer factor in J6. This procedure needs no independence and is not an unweighted failure estimate substituted into a rare tilted population. + +For `w=r^-beta, epsilon=r^eta`, the worst exponent is `1-4 beta-eta`; the hypothesis makes it strictly positive and ensures eventual physical containment. A three-event union proves J7. The positive soft mass gives its conditional version. Equality `4 beta+eta=1` would not imply o(r³). Constants may depend on each fixed p; choosing p to grow with r is not justified. + +The L1 statement does control r-dependent measurable jet events and observables with a fixed polynomial envelope. It does not control inverse random typing margins, growing Lambda, a whole-field TV comparison, other gap marks, an actual elder decision, confinement, collision/intermediate composition, or a persistence coefficient. A2's literal AMEND history is not consumed or erased. These exclusions and the fixed finite-L, planar, k=1, compact-birth/all-frame scope are correctly preserved. + +## Independent controls and actual execution + +The complete standard-library checker is supplied below, independently written for this review. It contains no author checker, author test output or executed source code. Final source: **9983 UTF-8 bytes**, SHA256 `5a4529ab99723d52e0e21bb442f572f466a9dd1bf993d383f520aa1459e45c0a`, including final newline. + +Frozen normal and optimized runs both exit 0 with **10,599 positive checks and eight refuted false-claim fixtures**. These fixtures run within the checker; they are not eight separately executed mutant programs. They challenge omitted positive parts, bare-indicator Lipschitzness, a wrong cubic row, wrong radius power, omitted A-marginal density, restricted normalization, critical window equality, and an independence substitution in weighted Markov. The finite rank fixtures use their own rational positive spectral weights at three frames and deliberately test duplicate-jet degeneracy; they do not sample or certify the continuum Gaussian covariance. Quartic fixtures preserve the exact pins and cover mixed derivative and raw Hessian scaling. Analytic arguments above, not these finite controls, establish all-frame ellipticity and Gaussian estimates. + +Actual checker invocations in this review: one development run, then two normal and one optimized run of the frozen source (the second normal run captured the output digest). No author controls were run. The canonical commands are: + +```text +python -B -S c92_independent_controls.py +python -B -O -S c92_independent_controls.py +``` + +Runtime Python 3.12.14. Frozen stdout is **757 bytes**, SHA256 `13dc0bd8b380a9c9e30c7989242c7a7d320e3d28e78abea572f4c7c6096534e2`, including its final newline. Normal/optimized output is byte-identical. + +## Disposition and release + +This completes and releases the bounded nonauthor review scope from pickup5963845378. The author retains C92 source, incorporation, custody and delivery responsibilities under WE614; I have neither changed nor released that claim. No repository source/head edit, branch update, merge, status promotion, formal acceptance or human approval occurred. No mathematical finding requires an amendment to this exact object. Downstream application and any provider-distinct/human/formal predicates remain separate. + +## Reproducible checker source + +```python +#!/usr/bin/env python3 +"""Independent C92 transcription/obstruction controls; not a Gaussian proof. + +Standard library, exact Fractions, no author checker or source execution. +Every check is an explicit exception, so python -O retains all checks. +""" +from fractions import Fraction as F +from itertools import product +from math import factorial +import json + +COUNTS = {} +NEGATIVE = [] + + +def check(group, condition): + if not condition: + raise RuntimeError(group) + COUNTS[group] = COUNTS.get(group, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError("negative control survived: " + name) + NEGATIVE.append(name) + + +def add(*polys): + out = {} + for p in polys: + for ij, a in p.items(): + out[ij] = out.get(ij, F(0)) + a + return {ij: a for ij, a in out.items() if a} + + +def scale(p, a): + return {ij: a * b for ij, b in p.items() if a * b} + + +def mul(p, q): + out = {} + for (i, j), a in p.items(): + for (k, l), b in q.items(): + out[i+k, j+l] = out.get((i+k, j+l), F(0)) + a*b + return out + + +def deriv(p, i, j): + return {(k-i, l-j): a*F(factorial(k), factorial(k-i)) + * F(factorial(l), factorial(l-j)) + for (k, l), a in p.items() if k >= i and l >= j} + + +def ev(p, x, z): + return sum((a*x**i*z**j for (i, j), a in p.items()), F(0)) + + +def raw(p, r): + return {(i, j): a*r**(i+j-3) for (i, j), a in p.items()} + + +def model(lam, gam, b1, c3): + return {(3, 0): F(2), (1, 0): F(-3, 2), (0, 0): F(-1, 2), + (2, 1): gam/2, (0, 1): -gam/8, (0, 2): -lam/2, + (1, 2): b1/2, (0, 3): c3/6} + + +def filtered(a, b, c, j): + det = a*c-b*b + if not det: + return F(0) + index = 1 if det < 0 else (2 if a+c < 0 else 0) + return abs(det) if index == j else F(0) + + +def determinant(a): + a = [row[:] for row in a] + answer = F(1) + for i in range(len(a)): + pivot = next((j for j in range(i, len(a)) if a[j][i]), None) + if pivot is None: + return F(0) + if pivot != i: + a[i], a[pivot] = a[pivot], a[i] + answer = -answer + v = a[i][i] + answer *= v + for j in range(i+1, len(a)): + q = a[j][i]/v + for k in range(i+1, len(a)): + a[j][k] -= q*a[i][k] + return answer + + +def positive_ldl(a): + a = [row[:] for row in a] + for i in range(len(a)): + if a[i][i] <= 0: + return False + for j in range(i+1, len(a)): + for k in range(j, len(a)): + a[j][k] -= a[j][i]*a[k][i]/a[i][i] + a[k][j] = a[j][k] + return True + + +# Finite rank fixtures use rational positive weights and omega=1, NOT the +# periodized covariance. They test jet bookkeeping, not all-frame ellipticity. +jets = [(0,0), (1,0), (2,0), (3,0), (0,1), (1,1), + (0,2), (2,1), (1,2), (0,3)] +check("jet_list", len(set(jets)) == 10) +check("jet_list", set(jets) == {(i,j) for i in range(4) + for j in range(4-i)}) +for ux, uz, ex, ez in [(F(1),F(0),F(0),F(1)), + (F(3,5),F(4,5),F(-4,5),F(3,5)), + (F(3,5),F(4,5),F(4,5),F(-3,5))]: + gram = [[F(0) for _ in jets] for _ in jets] + for nx, nz in product(range(-2,3), repeat=2): + ax, az = ux*nx+uz*nz, ex*nx+ez*nz + amps = [ax**i*az**j for i,j in jets] + weight = F(1, (1+nx*nx+nz*nz)**6) + for a, (i,j) in enumerate(jets): + for b, (k,l) in enumerate(jets): + diff = i+j-k-l + phase = (F(0) if diff % 2 else + (F(1) if (diff//2) % 2 == 0 else F(-1))) + gram[a][b] += weight*amps[a]*amps[b]*phase + check("finite_rank_fixtures", all(isinstance(v,F) + for row in gram for v in row)) + check("finite_rank_fixtures", positive_ldl(gram)) + duplicate = [row[:] for row in gram] + duplicate[-1] = duplicate[0][:] + for row in duplicate: + row[-1] = row[0] + check("duplicate_rank_negative", determinant(duplicate) == 0) + +# Exact six-row transform, target, and centered cancellation. +for r in [F(1,2), F(1,4), F(1,8), F(1,16)]: + a, c = -r/2, r/2 + tmat = [[F(1,2),0,F(1,2),0,0,0], + [-1/r,0,1/r,0,0,0], [0,-1/r,0,1/r,0,0], + [12/r**3,6/r**2,-12/r**3,6/r**2,0,0], + [0,0,0,0,F(1,2),F(1,2)], [0,0,0,0,-1/r,1/r]] + check("pin_transform", abs(determinant(tmat)) == 12/r**5) + original = [F(2),0,F(2)-r**3,0,0,0] + target = [F(2)-r**3/2,-r**2,0,F(12),0,0] + check("pin_transform", [sum(x*y for x,y in zip(row,original)) + for row in tmat] == target) + for degree in range(10): + p = {(degree,0): F(1)} + obs = [ev(p,a,0),ev(deriv(p,1,0),a,0), + ev(p,c,0),ev(deriv(p,1,0),c,0),0,0] + row3 = sum(x*y for x,y in zip(tmat[3], obs)) + expected = ev(deriv(p,3,0),0,0) + if degree == 5: + expected += r*r*F(factorial(5),40) + if degree <= 6: + check("centered_cubic_row", row3 == expected) + check("centered_cubic_row", r*r*F(factorial(5),40) == 3*r*r) + +# Signed model weight and off-diagonal filtered cancellation, including zero. +grid = [F(-2),F(-1),F(-1,2),F(0),F(1,2),F(1),F(2)] +for lam, gam, b1 in product(grid, repeat=3): + dm = 6*lam+3*b1-gam*gam/4 + ds = 6*lam-3*b1+gam*gam/4 + fm = filtered(F(-6),-gam/2,-lam-b1/2,2) + fs = filtered(F(6),gam/2,-lam+b1/2,1) + check("signed_typed_weight", fm == max(dm,0)) + check("signed_typed_weight", fs == max(ds,0)) + if lam <= 0: + check("nonpositive_limit", fm*fs == 0) +for a,b,c in product(grid, repeat=3): + for j in range(3): + check("filtered_offdiagonal", abs(filtered(a,b,c,j) + - filtered(a,0,c,j)) <= b*b) +for ax,cz,ay,dz in product(grid, repeat=4): + norm = max(abs(ax),abs(cz),abs(ay),abs(dz)) + diff = max(abs(ax-ay),abs(cz-dz)) + for j in range(3): + check("diagonal_filtered_lipschitz", + abs(filtered(ax,0,cz,j)-filtered(ay,0,dz,j)) + <= 2*norm*diff) + +# Independent pin-preserving quartics test exact raw Hessian scaling and all +# mixed derivatives. Nbound is a deterministic bound on the unit local box, +# not a Gaussian sample or a global torus construction. +for r in [F(1,2),F(1,4),F(1,8)]: + q = {(2,0):F(1),(0,0):-r*r/4} + quartics = [mul(q,q), mul(q,{(1,1):F(1)}), + mul(q,{(0,2):F(1)}), {(1,3):F(1)}, {(0,4):F(1)}] + for lam,gam,b1,c3 in [(F(-1,2),F(0),F(1),F(-1)), + (F(0),F(2),F(-1),F(1)), + (F(1),F(1),F(0),F(2))]: + base = {(i,j):v*r**(3-i-j) for (i,j),v + in model(lam,gam,b1,c3).items()} + f = add(base, *[scale(p,F(i+1,7)) for i,p in enumerate(quartics)]) + check("quartic_pins", ev(f,-r/2,0) == 0) + check("quartic_pins", ev(f,r/2,0) == -r**3) + for x in [-r/2,r/2]: + for i,j in [(1,0),(0,1)]: + check("quartic_pins", ev(deriv(f,i,j),x,0) == 0) + midpoint = [ev(deriv(f,i,j),0,0) + for i,j in [(0,2),(2,1),(1,2),(0,3)]] + actual_model = model(-midpoint[0]/r,*midpoint[1:]) + error = add(raw(f,r),scale(actual_model,F(-1))) + nbound = F(1) + max(sum(abs(v) for v in deriv(f,i,j).values()) + for i in range(5) for j in range(5-i)) + for x in [-F(1,2),F(1,2)]: + for i,j in [(2,0),(1,1),(0,2)]: + check("raw_hessian_scale", ev(deriv(raw(f,r),i,j),x,0) + == ev(deriv(f,i,j),r*x,0)/r) + constants = [F(167,192),F(635,384),F(115,48)] + for w in [F(1),F(2),F(4)]: + if r*w > 1: + continue + for x,z in product([-w,F(0),w], repeat=2): + for order in range(3): + for i in range(order+1): + j = order-i + check("quartic_derivative_bounds", + abs(ev(deriv(error,i,j),x,z)) + <= constants[order]*nbound*r*w**(4-order)) + +# Exact radius bookkeeping and a correlated weighted Markov fixture. +for r in [F(1,2),F(1,8),F(1,32)]: + m,z = F(7,3),F(5,2) + numerator,normalizer = r**4*r*m, r**2*z + check("radius_ledger", numerator/normalizer == r**3*m/z) + check("radius_ledger", r**(-3)*numerator/normalizer == m/z) +atoms = [(F(1,2),F(1),F(1)), (F(1,3),F(3),F(4)), + (F(1,6),F(9),F(25))] # (mass,N,D), correlated on purpose +for p in [1,2,3,5]: + for threshold in [F(1),F(2),F(4),F(10)]: + left = sum(m*d for m,n,d in atoms if n > threshold) + right = sum(m*d*n**p for m,n,d in atoms)/threshold**p + check("weighted_markov", left <= right) +for beta,eta in [(F(0),F(0)),(F(1,8),F(1,4)), + (F(1,10),F(1,10)),(F(6,25),F(1,100))]: + exps = [1-(4-j)*beta-eta for j in range(3)] + check("window_exponents", min(exps) == 1-4*beta-eta) + check("window_exponents", min(exps) > 0 and beta < 1) + +reject("omit-positive-parts", (-6+3)*(-6-3) + == filtered(F(-6),F(0),F(1,2),2) + *filtered(F(6),F(0),F(3,2),1)) +reject("inertia-indicator-is-Lipschitz", + F(1) <= 2*F(1,100)*(2*F(1,100))) +reject("wrong-cubic-row-factor", F(3) == F(6)) +reject("wrong-soft-radius-power", F(1,8)**5 == F(1,8)**3) +reject("drop-joint-A-marginal", F(2,3)*F(5,7) == F(5,7)) +reject("normalize-by-soft-layer", F(1,8)**3 == 1) +reject("critical-window-also-o-r3", 1-4*F(1,4) > 0) +reject("weighted-Markov-by-independence", + sum(m*d*n**2 for m,n,d in atoms) + == sum(m*d for m,n,d in atoms)*sum(m*n**2 for m,n,d in atoms)) + +print(json.dumps({"object":"C92-independent-controls-v1", + "positive_counts":COUNTS, + "positive_total":sum(COUNTS.values()), + "rejected_mutants":NEGATIVE, + "mutant_total":len(NEGATIVE), + "scope":"exact finite controls; Gaussian assertions analytic"}, + sort_keys=True, separators=(",", ":"))) +``` + +## Canonical checker stdout + +```json +{"mutant_total":8,"object":"C92-independent-controls-v1","positive_counts":{"centered_cubic_row":32,"diagonal_filtered_lipschitz":7203,"duplicate_rank_negative":3,"filtered_offdiagonal":1029,"finite_rank_fixtures":6,"jet_list":2,"nonpositive_limit":196,"pin_transform":8,"quartic_derivative_bounds":1296,"quartic_pins":54,"radius_ledger":6,"raw_hessian_scale":54,"signed_typed_weight":686,"weighted_markov":16,"window_exponents":8},"positive_total":10599,"rejected_mutants":["omit-positive-parts","inertia-indicator-is-Lipschitz","wrong-cubic-row-factor","wrong-soft-radius-power","drop-joint-A-marginal","normalize-by-soft-layer","critical-window-also-o-r3","weighted-Markov-by-independence"],"scope":"exact finite controls; Gaussian assertions analytic"} +``` diff --git a/frontiers/planar_soft_layer_chain_20261003/C92/checker.py b/frontiers/planar_soft_layer_chain_20261003/C92/checker.py new file mode 100644 index 000000000..ca78fe807 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C92/checker.py @@ -0,0 +1,263 @@ +#!/usr/bin/env python3 +"""Independent C92 transcription/obstruction controls; not a Gaussian proof. + +Standard library, exact Fractions, no author checker or source execution. +Every check is an explicit exception, so python -O retains all checks. +""" +from fractions import Fraction as F +from itertools import product +from math import factorial +import json + +COUNTS = {} +NEGATIVE = [] + + +def check(group, condition): + if not condition: + raise RuntimeError(group) + COUNTS[group] = COUNTS.get(group, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError("negative control survived: " + name) + NEGATIVE.append(name) + + +def add(*polys): + out = {} + for p in polys: + for ij, a in p.items(): + out[ij] = out.get(ij, F(0)) + a + return {ij: a for ij, a in out.items() if a} + + +def scale(p, a): + return {ij: a * b for ij, b in p.items() if a * b} + + +def mul(p, q): + out = {} + for (i, j), a in p.items(): + for (k, l), b in q.items(): + out[i+k, j+l] = out.get((i+k, j+l), F(0)) + a*b + return out + + +def deriv(p, i, j): + return {(k-i, l-j): a*F(factorial(k), factorial(k-i)) + * F(factorial(l), factorial(l-j)) + for (k, l), a in p.items() if k >= i and l >= j} + + +def ev(p, x, z): + return sum((a*x**i*z**j for (i, j), a in p.items()), F(0)) + + +def raw(p, r): + return {(i, j): a*r**(i+j-3) for (i, j), a in p.items()} + + +def model(lam, gam, b1, c3): + return {(3, 0): F(2), (1, 0): F(-3, 2), (0, 0): F(-1, 2), + (2, 1): gam/2, (0, 1): -gam/8, (0, 2): -lam/2, + (1, 2): b1/2, (0, 3): c3/6} + + +def filtered(a, b, c, j): + det = a*c-b*b + if not det: + return F(0) + index = 1 if det < 0 else (2 if a+c < 0 else 0) + return abs(det) if index == j else F(0) + + +def determinant(a): + a = [row[:] for row in a] + answer = F(1) + for i in range(len(a)): + pivot = next((j for j in range(i, len(a)) if a[j][i]), None) + if pivot is None: + return F(0) + if pivot != i: + a[i], a[pivot] = a[pivot], a[i] + answer = -answer + v = a[i][i] + answer *= v + for j in range(i+1, len(a)): + q = a[j][i]/v + for k in range(i+1, len(a)): + a[j][k] -= q*a[i][k] + return answer + + +def positive_ldl(a): + a = [row[:] for row in a] + for i in range(len(a)): + if a[i][i] <= 0: + return False + for j in range(i+1, len(a)): + for k in range(j, len(a)): + a[j][k] -= a[j][i]*a[k][i]/a[i][i] + a[k][j] = a[j][k] + return True + + +# Finite rank fixtures use rational positive weights and omega=1, NOT the +# periodized covariance. They test jet bookkeeping, not all-frame ellipticity. +jets = [(0,0), (1,0), (2,0), (3,0), (0,1), (1,1), + (0,2), (2,1), (1,2), (0,3)] +check("jet_list", len(set(jets)) == 10) +check("jet_list", set(jets) == {(i,j) for i in range(4) + for j in range(4-i)}) +for ux, uz, ex, ez in [(F(1),F(0),F(0),F(1)), + (F(3,5),F(4,5),F(-4,5),F(3,5)), + (F(3,5),F(4,5),F(4,5),F(-3,5))]: + gram = [[F(0) for _ in jets] for _ in jets] + for nx, nz in product(range(-2,3), repeat=2): + ax, az = ux*nx+uz*nz, ex*nx+ez*nz + amps = [ax**i*az**j for i,j in jets] + weight = F(1, (1+nx*nx+nz*nz)**6) + for a, (i,j) in enumerate(jets): + for b, (k,l) in enumerate(jets): + diff = i+j-k-l + phase = (F(0) if diff % 2 else + (F(1) if (diff//2) % 2 == 0 else F(-1))) + gram[a][b] += weight*amps[a]*amps[b]*phase + check("finite_rank_fixtures", all(isinstance(v,F) + for row in gram for v in row)) + check("finite_rank_fixtures", positive_ldl(gram)) + duplicate = [row[:] for row in gram] + duplicate[-1] = duplicate[0][:] + for row in duplicate: + row[-1] = row[0] + check("duplicate_rank_negative", determinant(duplicate) == 0) + +# Exact six-row transform, target, and centered cancellation. +for r in [F(1,2), F(1,4), F(1,8), F(1,16)]: + a, c = -r/2, r/2 + tmat = [[F(1,2),0,F(1,2),0,0,0], + [-1/r,0,1/r,0,0,0], [0,-1/r,0,1/r,0,0], + [12/r**3,6/r**2,-12/r**3,6/r**2,0,0], + [0,0,0,0,F(1,2),F(1,2)], [0,0,0,0,-1/r,1/r]] + check("pin_transform", abs(determinant(tmat)) == 12/r**5) + original = [F(2),0,F(2)-r**3,0,0,0] + target = [F(2)-r**3/2,-r**2,0,F(12),0,0] + check("pin_transform", [sum(x*y for x,y in zip(row,original)) + for row in tmat] == target) + for degree in range(10): + p = {(degree,0): F(1)} + obs = [ev(p,a,0),ev(deriv(p,1,0),a,0), + ev(p,c,0),ev(deriv(p,1,0),c,0),0,0] + row3 = sum(x*y for x,y in zip(tmat[3], obs)) + expected = ev(deriv(p,3,0),0,0) + if degree == 5: + expected += r*r*F(factorial(5),40) + if degree <= 6: + check("centered_cubic_row", row3 == expected) + check("centered_cubic_row", r*r*F(factorial(5),40) == 3*r*r) + +# Signed model weight and off-diagonal filtered cancellation, including zero. +grid = [F(-2),F(-1),F(-1,2),F(0),F(1,2),F(1),F(2)] +for lam, gam, b1 in product(grid, repeat=3): + dm = 6*lam+3*b1-gam*gam/4 + ds = 6*lam-3*b1+gam*gam/4 + fm = filtered(F(-6),-gam/2,-lam-b1/2,2) + fs = filtered(F(6),gam/2,-lam+b1/2,1) + check("signed_typed_weight", fm == max(dm,0)) + check("signed_typed_weight", fs == max(ds,0)) + if lam <= 0: + check("nonpositive_limit", fm*fs == 0) +for a,b,c in product(grid, repeat=3): + for j in range(3): + check("filtered_offdiagonal", abs(filtered(a,b,c,j) + - filtered(a,0,c,j)) <= b*b) +for ax,cz,ay,dz in product(grid, repeat=4): + norm = max(abs(ax),abs(cz),abs(ay),abs(dz)) + diff = max(abs(ax-ay),abs(cz-dz)) + for j in range(3): + check("diagonal_filtered_lipschitz", + abs(filtered(ax,0,cz,j)-filtered(ay,0,dz,j)) + <= 2*norm*diff) + +# Independent pin-preserving quartics test exact raw Hessian scaling and all +# mixed derivatives. Nbound is a deterministic bound on the unit local box, +# not a Gaussian sample or a global torus construction. +for r in [F(1,2),F(1,4),F(1,8)]: + q = {(2,0):F(1),(0,0):-r*r/4} + quartics = [mul(q,q), mul(q,{(1,1):F(1)}), + mul(q,{(0,2):F(1)}), {(1,3):F(1)}, {(0,4):F(1)}] + for lam,gam,b1,c3 in [(F(-1,2),F(0),F(1),F(-1)), + (F(0),F(2),F(-1),F(1)), + (F(1),F(1),F(0),F(2))]: + base = {(i,j):v*r**(3-i-j) for (i,j),v + in model(lam,gam,b1,c3).items()} + f = add(base, *[scale(p,F(i+1,7)) for i,p in enumerate(quartics)]) + check("quartic_pins", ev(f,-r/2,0) == 0) + check("quartic_pins", ev(f,r/2,0) == -r**3) + for x in [-r/2,r/2]: + for i,j in [(1,0),(0,1)]: + check("quartic_pins", ev(deriv(f,i,j),x,0) == 0) + midpoint = [ev(deriv(f,i,j),0,0) + for i,j in [(0,2),(2,1),(1,2),(0,3)]] + actual_model = model(-midpoint[0]/r,*midpoint[1:]) + error = add(raw(f,r),scale(actual_model,F(-1))) + nbound = F(1) + max(sum(abs(v) for v in deriv(f,i,j).values()) + for i in range(5) for j in range(5-i)) + for x in [-F(1,2),F(1,2)]: + for i,j in [(2,0),(1,1),(0,2)]: + check("raw_hessian_scale", ev(deriv(raw(f,r),i,j),x,0) + == ev(deriv(f,i,j),r*x,0)/r) + constants = [F(167,192),F(635,384),F(115,48)] + for w in [F(1),F(2),F(4)]: + if r*w > 1: + continue + for x,z in product([-w,F(0),w], repeat=2): + for order in range(3): + for i in range(order+1): + j = order-i + check("quartic_derivative_bounds", + abs(ev(deriv(error,i,j),x,z)) + <= constants[order]*nbound*r*w**(4-order)) + +# Exact radius bookkeeping and a correlated weighted Markov fixture. +for r in [F(1,2),F(1,8),F(1,32)]: + m,z = F(7,3),F(5,2) + numerator,normalizer = r**4*r*m, r**2*z + check("radius_ledger", numerator/normalizer == r**3*m/z) + check("radius_ledger", r**(-3)*numerator/normalizer == m/z) +atoms = [(F(1,2),F(1),F(1)), (F(1,3),F(3),F(4)), + (F(1,6),F(9),F(25))] # (mass,N,D), correlated on purpose +for p in [1,2,3,5]: + for threshold in [F(1),F(2),F(4),F(10)]: + left = sum(m*d for m,n,d in atoms if n > threshold) + right = sum(m*d*n**p for m,n,d in atoms)/threshold**p + check("weighted_markov", left <= right) +for beta,eta in [(F(0),F(0)),(F(1,8),F(1,4)), + (F(1,10),F(1,10)),(F(6,25),F(1,100))]: + exps = [1-(4-j)*beta-eta for j in range(3)] + check("window_exponents", min(exps) == 1-4*beta-eta) + check("window_exponents", min(exps) > 0 and beta < 1) + +reject("omit-positive-parts", (-6+3)*(-6-3) + == filtered(F(-6),F(0),F(1,2),2) + *filtered(F(6),F(0),F(3,2),1)) +reject("inertia-indicator-is-Lipschitz", + F(1) <= 2*F(1,100)*(2*F(1,100))) +reject("wrong-cubic-row-factor", F(3) == F(6)) +reject("wrong-soft-radius-power", F(1,8)**5 == F(1,8)**3) +reject("drop-joint-A-marginal", F(2,3)*F(5,7) == F(5,7)) +reject("normalize-by-soft-layer", F(1,8)**3 == 1) +reject("critical-window-also-o-r3", 1-4*F(1,4) > 0) +reject("weighted-Markov-by-independence", + sum(m*d*n**2 for m,n,d in atoms) + == sum(m*d for m,n,d in atoms)*sum(m*n**2 for m,n,d in atoms)) + +print(json.dumps({"object":"C92-independent-controls-v1", + "positive_counts":COUNTS, + "positive_total":sum(COUNTS.values()), + "rejected_mutants":NEGATIVE, + "mutant_total":len(NEGATIVE), + "scope":"exact finite controls; Gaussian assertions analytic"}, + sort_keys=True, separators=(",", ":"))) diff --git a/frontiers/planar_soft_layer_chain_20261003/C92/checker_stdout.txt b/frontiers/planar_soft_layer_chain_20261003/C92/checker_stdout.txt new file mode 100644 index 000000000..013067bb4 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C92/checker_stdout.txt @@ -0,0 +1 @@ +{"mutant_total":8,"object":"C92-independent-controls-v1","positive_counts":{"centered_cubic_row":32,"diagonal_filtered_lipschitz":7203,"duplicate_rank_negative":3,"filtered_offdiagonal":1029,"finite_rank_fixtures":6,"jet_list":2,"nonpositive_limit":196,"pin_transform":8,"quartic_derivative_bounds":1296,"quartic_pins":54,"radius_ledger":6,"raw_hessian_scale":54,"signed_typed_weight":686,"weighted_markov":16,"window_exponents":8},"positive_total":10599,"rejected_mutants":["omit-positive-parts","inertia-indicator-is-Lipschitz","wrong-cubic-row-factor","wrong-soft-radius-power","drop-joint-A-marginal","normalize-by-soft-layer","critical-window-also-o-r3","weighted-Markov-by-independence"],"scope":"exact finite controls; Gaussian assertions analytic"} diff --git a/frontiers/planar_soft_layer_chain_20261003/C93/DELIVERY.md b/frontiers/planar_soft_layer_chain_20261003/C93/DELIVERY.md new file mode 100644 index 000000000..e2f501b7d --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C93/DELIVERY.md @@ -0,0 +1,19 @@ +C93 completed — reviewed actual typing-edge and Hessian-transfer estimate + +The frozen [C93 proof](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964167051) is 15545 UTF-8 bytes, SHA256 f25f86cc66ae335b4832ea53670646815567ec7854fa0386f8c57f6939e0af1c. The full [nonauthor review](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964232937) is 21678 bytes, SHA256 ede5964069465cda02ae7d3c1d880fe6c3ed5e4d8d7bc9401302d223d1097b7f. Verdict: ACCEPT / PASS_TECHNICAL_SCOPED for E2–E20, no amendment. Both native bodies remain unchanged and were read back exactly. + +What this supplies: +- Actual correlated moment-weighted edge mass bounded by C(delta^2+r delta), with the finite-r term retained. +- Full normalized edge probability at most C r^3(delta^2+r delta). +- Truncated third-moment Hessian-transfer bound C r^3(epsilon^2+r epsilon), epsilon=(115/72)rw^2/tau. +- On deterministic w=r^-beta, 0<=beta<1/4, fixed positive budgets and a fixed sufficiently high moment order: analytic bad mass O(r^4), versus soft-layer mass r^3 m_Lambda/z0+O(r^4), hence conditional analytic success 1-O(r). + +Scope remains d2, k1, fixed finite L, fixed bounded soft coordinate, compact births/all frames. Model inverse moments are finite exactly below order2; no untruncated actual inverse threshold is inferred. A1's model estimate is an antecedent with its correction retained. No A2 acceptance, trap containment, random-margin control, elder/branch-adjacency equivalence or persistence completion is claimed. + +Verification: 693 author rational controls and nine separately rejected mutants; 3537 reviewer controls and thirteen built-in false-inference fixtures. Normal and optimized runs agree. Reviewer Python3.12.14 source/stdout replay exactly on Python3.11.16. Complete final packet verification ran once on the stable tree and passed. + +One immutable [Drive delivery](https://drive.google.com/file/d/1WICg_Blacd5mRfGJbV25F77If7SiWS6U/view?usp=drivesdk): 312893 bytes, 28 payloads, ZIP SHA256 785ba293e70389c4135b0a9189955e86006baee61a540634057c94c786cd7fa8. Remote bytes match exactly; canonical manifest/handoff verify; owner-only access. Registered AI887 / EL609 / RQ156 / WE618. Claim e925c728-e82d-4db2-b58e-4d10c806a423 released at WE619, 2026-10-03T01:52:06Z; all registration/release CellData read back exactly. + +@claude — incorporation request, not an assertion of pickup: incorporate the exact reviewed C93 artifact additively through the privacy-safe author/integrator route, preserving C91/C92 source scopes and A2/intermediate custody. Run affected checks and current-commit CI before any integration. The next mathematical target is actual weighted containment and random value/decision-margin integration against a valid corrected geometric criterion; fixed budgets alone do not supply that bridge. + +Dylan Roy — delegated AI work/review. Actual author OpenAI/Codex root01a0bbb5; distinct OpenAI/Codex coordinating reviewer, disclosed C93 intake/target and C91/C92 exposure; helper supports E2–E12 only. Personal reading PENDING; organizational independence 0; scientific effect NONE. This is a reviewed native proof delivery; no repository commit, remote CI or merge is represented. diff --git a/frontiers/planar_soft_layer_chain_20261003/C93/PROOF.md b/frontiers/planar_soft_layer_chain_20261003/C93/PROOF.md new file mode 100644 index 000000000..204fd6f3d --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C93/PROOF.md @@ -0,0 +1,349 @@ +# Actual weighted typing-edge control and planar Hessian transfer + +Object: C93-PLANAR-TYPING-EDGE-HESSIAN-TRANSFER-20261003-v1. +Author: OpenAI/Codex root01a0bbb5, acting for Dylan Roy — delegated AI work. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; nonauthor technical review pending. +Personal reading PENDING; organizational independence 0; scientific effect NONE. + +This note bounds the actual finite-radius determinant-weighted mass near the +two cubic typing edges and controls the Hessian-transfer loss across their +complement. It retains the finite-r density term. The model edge suppression +has antecedents in the QS addendum; the new scope is its actual weighted +field/jet transfer, with field-norm factors and full normalization. + +## 0. Inputs and exact setting + +Use exactly the model, pins and notation of C92 Theorem J: planar normalized +periodized Gaussian covariance on a fixed torus of side L>0; gap mark k=1; +birth b in a fixed nonempty compact set B0; every orthonormal frame; exact +pins at M=(-r/2,0), S=(r/2,0), values b,b-r^3 and zero gradients. +Q_r is the continuous Gaussian regression law at these pins. W_r is the +actual product of absolute Hessian determinants with the maximum/saddle +typing indicator. Z_r is its FULL expectation, Q_r^W=(W_r/Z_r)Q_r. + +Set + + A=f_zz(0), lambda=-A/r, + t=(gamma,B1,C3)=(f_xxz(0),f_xzz(0),f_zzz(0)), + P=1+|gamma|+|B1|+|C3|, + N=1+max_{|alpha|<=4} sup_torus |D^alpha f|, + D_Lambda={|lambda|<=Lambda}, 00,a_S>0}, h=min(a_M,a_S), + w_lambda=(a_M)_+(a_S)_+/16, + dmu_0=rho_0(0,t) w_lambda d lambda dt on D_Lambda. (E1) + +Thus T implies lambda>0, a_M+a_S=48lambda, and mu_0 is supported in T +up to a null boundary. The finite-r mu_r need not be supported in T: it +uses the actual endpoint typing, not the cubic typing. + +The complete C92 proof is main229 comment5963825788, 19567 bytes, +SHA256 6fa4c3d6d1e8c3d8590c865802d5df061ad5b17652ddc7fd7bf5c5e8b8de084a. +Full nonauthor review5963946854: 24984 bytes, SHA256 +298bbf9ccd75b57fde9d131551b32b9b5b3a5a7910e7c9df7ce796cdf3334fac. +We use J4/J5 and the pointwise inputs J9/J10/J16/J18/J19, with their full +fixed-parameter scope. Its underlying P/R sources and errata remain part +of that imported Gaussian interface; they are not silently reclassified. + +The deterministic C91 proof is main229 comment5963566666, 12433 bytes, +SHA256 74a9ee276c3647276deb544c6d83e3cf21f708f55f9009fa4db5cc49c9d0e9aa. +Full review5963668996: 17914 bytes, SHA256 +0c472af06e13f564d44c1723b5492c6c60681000f1f00d653b2bbb5f2e992eda. +Only W4/W5 and W15/W16 are used. Neither the QS/A2 trap implication nor +its containment/margin assumptions are proved or assumed satisfied here. +SOURCE_IDENTITIES.json carries exact source/extraction records. + +Historical antecedent: QS addendum A1, main229 comment5961913750, already +has a MODEL typing-edge suppression estimate. Read it with its nonauthor +review5962025965 and author correction5962385282: the fixed-R integrated +sharpness sentence is withdrawn, and the corrected W3 cubic coefficient is +576000. Those sources are retained byte-exact in this packet. C93 does not +claim novelty for the model mechanism or import the withdrawn sharpness. +Its actual finite-r, correlated field-norm and full-normalization estimates +below are derived from C91/C92. No QS geometric implication is a premise. + +## 1. The actual moment-weighted edge integral + +For fixed finite p,q>=0, interpret expectations with N^p P^q as moments +under the ACTUAL field law; they are not observables of the limiting jets. +All constants below are finite and uniform in b and frame for 0=0, + + integral_T P^q phi(a_i) dmu_0 + <= C_q integral_0^{A_*} phi(s) s ds. (E3) + +In particular, for 0=2. (E10) + +The upper assertion follows from (E3) and integral_0^{A_*}s^(1-v)ds. +To prove the lower assertion, restrict lambda to [Lambda/3,2Lambda/3], +gamma,C3 to a fixed small box around0, and 0=8Lambda. B1 as given in (E9) +stays in a compact set, the joint Gaussian density has a positive lower +bound there, and w_lambda>=c s. Thus the integral dominates +c integral_0^{s0}s^(1-v)ds, which diverges exactly when v>=2. +The same reasoning is uniform over compact birth/frame parameters. + +For the loss factor + + L_i=1+(gamma^2+144)/a_i on T, + +the same threshold holds for integral_T L_i^v dmu_0: the lower bound uses +L_i>=144/a_i; the upper bound uses a_i<=A_* and +L_i<=(A_*+gamma^2+144)/a_i together with (E3) and a polynomial jet weight. + +For the actual field, (E2) instead supplies the truncated inequality, for +every finite v>=0, p,q>=0 and 0=delta}] + <= C_{p,q} integral_delta^{A_*}[s^(1-v)+r s^(-v)]ds. (E11) + +In the case v=3 this is at most + + C_{p,q}[delta^(-1)+r/(2delta^2)]. (E12) + +No statement of an untruncated actual inverse moment is inferred. For a +simple obstruction to such an inference, on (0,1) take g_0(s)=s and +g_r(s)=s+r. Their L1 distance is r, the model first inverse moment is1, +but integral_0^1 g_r(s)/s ds is infinite for every r>0. This is an exact +measure-theoretic counterexample to the inference, not a claim that these +are the Gaussian densities of the present field. + +## 3. Actual probability of a Hessian-transfer failure + +Let w>=1 with 2rw<=L/4. Let F_r,G,E_r=F_r-G be the raw field, cubic and +error of C92, and W_w={|X|,|zeta|<=w}. On T and gamma!=0, set + + kappa_i=a_i/(48gamma^2), + T_i=[[1/sqrt(3), -1/(12sqrt(kappa_i))], + [0, 1/(gamma sqrt(kappa_i))]], + H_i(r,w)=sup_{W_w} ||T_i^T D^2 E_r T_i||_op. (E13) + +The supremum here is over raw points in W_w. It bounds the corresponding +rescaled Hessian on any set whose raw image is contained in W_w. It does +not assert that a geometric trap or ellipse is contained there. +These are measurable events: on the smooth-field event each supremum on +the compact raw window equals its supremum on a countable dense subset; +the matrices are measurable functions of the jets on their stated chart. + +For any fixed deterministic tau>0, put + + epsilon=(115/72) r w^2/tau. + +Whenever epsilon<=delta0, the actual weighted failure probability satisfies + + Q_r^W(D_Lambda intersect T intersect {gamma!=0} + intersect {H_i(r,w)>=tau}) + <= C r^3(epsilon^2+r epsilon). (E14) + +The constant in this form is independent of tau,w; their effect is inside +epsilon. With tau fixed, w>=1 and epsilon<=delta0, this implies + + Q_r^W(D_Lambda intersect T intersect {gamma!=0} + intersect {H_i(r,w)>=tau}) + <= C_tau r^5 w^4. (E15) + +### Proof + +C91 W4/W5 bounds each raw Hessian entry by (115/48)Nrw^2. Its exact +matrix transfer W16 therefore gives + + H_i(r,w)<=(115/72)Nrw^2 L_i. (E16) + +The apparent gamma inverse in the coordinate matrix has cancelled in +this bound; gamma=0 itself remains outside the chart. There is no positive +lower bound imposed on |gamma| or on either a_i. + +Under mu_r, split the event in (E14) into a_i=delta. +The first part is bounded by C(delta^2+r delta) using (E4). On the second, +the pointwise Markov inequality and (E16) give + + 1_{H_i>=tau} <= epsilon^3 N^3 L_i^3. + +Because a_i<=A_* on T, + + L_i^3 <= C_Lambda P^6 a_i^(-3). + +Apply (E12) with p=3,q=6 to get an unnormalized rescaled bound + + C[delta^2+r delta+ + epsilon^3(delta^(-1)+r delta^(-2))]. (E17) + +Choose delta=epsilon. If epsilon=delta0=A_* the away set is empty except +a null boundary, and the strip bound alone gives the same conclusion; +otherwise (E12) applies directly. Then (E17) is +C(epsilon^2+r epsilon). Division by the full z_r and multiplication by +r^3 proves (E14). For fixed tau and w>=1, +r/epsilon=tau/[(115/72)w^2] is bounded, proving (E15). Using a third +moment rather than the critical second moment avoids a logarithmic loss. +All field-norm/jet correlations remain inside (E7)–(E12). + +Under Q_r^W restricted to D_Lambda the jet law has a Lebesgue density by +C92 J18/J5. Hence gamma=0 is a null set and its exclusion adds no mass. +It does not create a coordinate chart at gamma=0. QED. + +## 4. Simultaneous analytic conditions at the r^3 rare-layer scale + +Fix deterministic positive budgets tau0,tauM,tauS. Define G_{r,w} inside +D_Lambda by + + T, gamma!=0, |E_r|_0=1, and sufficiently small epsilon_i +as in (E14), + + Q_r^W(D_Lambda minus G_{r,w}) + <= C[r^4+r^5 w^4+r^3(rw^4)^p]. (E19) + +Constants may additionally depend on the fixed budgets and p. To prove +this, use (E6) for the outside-T term, the null gamma slice, (E15) for +both Hessian terms, and C92's weighted Taylor Markov argument for the value +term. That argument also handles the non-strict bad event |E_r|_0>=tau0, +since its pointwise bound is (K0Nrw^4/tau0)^p, K0=167/192. The union bound +requires no independence among these events. + +In particular let w=r^(-beta), 0<=beta<1/4, and choose any fixed finite +p>=max(1,1/(1-4beta)). For sufficiently small r the physical window and +epsilon_i restrictions hold. Then (E19), C92 J5 and the positive mass floor +give + + Q_r^W(D_Lambda minus G_{r,w})<=Cr^4, + Q_r^W(G_{r,w})=r^3 m_Lambda/z_0+O(r^4), + Q_r^W(G_{r,w} | D_Lambda)=1-O(r). (E20) + +The Hessian term is r^(5-4beta), of order at least r^4, and the value term +is r^[3+p(1-4beta)] with exponent at least4. This calculation uses a fixed +p chosen after beta, never a radius-dependent moment order. The scale and +conditioning in (E20) are those of the FULL actual determinant-weighted law. + +## 5. Retained geometric and global obligations + +For the C91 sufficient Hessian thresholds, one may take tauM=1 and +tauS=2/5; the strict bounds in G_{r,w} imply the corresponding weak/strict +requirements. A geometric application ALSO needs a valid imported trap +certificate, its raw sets contained in W_w, and its value tolerance at +least tau0. None of those events is proved likely by (E20). In particular +a random model tolerance tending to zero cannot be replaced by fixed tau0. +Such tolerances, containment and any model-decision exclusions must be +estimated and combined separately. + +No unbounded-lambda or all-mark conclusion is asserted. The actual outside- +model-typing estimate here is C92's O(r^4) bound, not a sharper unproved +crossing estimate. The construction does not resolve A2's literal-v1 +amendments, shrinking witness collisions, intermediate/coarea composition, +elder versus branch-adjacency identification, or the final persistence +coefficient/remainder. Model edge integrability is not presented as a new +geometric mechanism. Exact rational controls check the coordinate, +integration and scaling algebra; they do not prove the Gaussian analytic +inputs, topology, or canonical scientific completion. diff --git a/frontiers/planar_soft_layer_chain_20261003/C93/REVIEW.md b/frontiers/planar_soft_layer_chain_20261003/C93/REVIEW.md new file mode 100644 index 000000000..43d5b23a1 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C93/REVIEW.md @@ -0,0 +1,302 @@ +# C93 full nonauthor technical review — PASS_TECHNICAL_SCOPED + +Verdict: ACCEPT / PASS_TECHNICAL_SCOPED for E2–E20 in the exact frozen C93 v1. I reconstructed the whole argument and its consumed C91/C92 interfaces. No blocking defect or required mathematical amendment was found. This accepts only the actual, bounded-soft-layer analytic estimates stated here; it is not acceptance of a QS trap, an elder identification or a persistence theorem. + +## Performer, exposure and custody + +Dylan Roy — delegated AI review. Actual performer: OpenAI / Codex, this /root review session, distinct from author root01a0bbb5. The runtime does not expose an exact underlying model build or a durable session identifier; those are UNKNOWN, not inferred from earlier review labels. Personal reading PENDING; independent human review NONE; organizational-independence credit 0; scientific effect NONE. + +I had already performed the C93 read-only source/custody intake, saw the prospective actual-edge target, and previously reviewed C91 and C92. I did not author C93, supply a C93 proof repair, or see/run its author test code. That source/outline exposure is retained, not represented as blind review. + +One fresh OpenAI helper, /root/c93_edge_integral_audit, read the complete exact C93 and C92 proofs and independently reconstructed E2–E12. It reported no defect; it did not read C91 or author checkers, create files, publish, acquire a claim or author a repair. This was one supporting same-provider check, not a second independent acceptance. I independently reconstructed E2–E20 and wrote/executed the checker below. + +The author's R17 claim e925c728-e82d-4db2-b58e-4d10c806a423 / WE617 remains author custody. This bounded review is COMPLETE/RELEASED upon this delivery. No branch, source, integration, Drive-delivery, A2 or intermediate/coarea ownership is taken. + +## Exact public source exposure + +All three complete proof bodies were fetched from the native main229 discussion, copied without body changes, and verified by SHA256 and UTF-8 byte count: + +| Object | Native comment | Bytes | SHA256 | +|---|---|---:|---| +| C93 v1 | [5964167051](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964167051) | 15545 | f25f86cc66ae335b4832ea53670646815567ec7854fa0386f8c57f6939e0af1c | +| C92 v1 | [5963825788](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963825788) | 19567 | 6fa4c3d6d1e8c3d8590c865802d5df061ad5b17652ddc7fd7bf5c5e8b8de084a | +| C91 v1 | [5963566666](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5963566666) | 12433 | 74a9ee276c3647276deb544c6d83e3cf21f708f55f9009fa4db5cc49c9d0e9aa | + +The ancestor QS A1 was read fully with [review5962025965](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5962025965) and [author correction5962385282](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5962385282). Native original5961913750 is 6256 bytes / SHA256 c8373f30cc167d8b5bfa158cbc41a74d1da6b42bdaab9c5db8402a236e90df2c; native correction5962385282 is 3035 bytes / SHA256 85f4b5cc0d6b5dd82b7674e30fbb6d41514c93b9e70a142d5500f8c70b44704b. Neither native body has a final newline; local reading copies add one and are not assigned those native hashes. + +A1's fixed-R integrated sharpness sentence remains withdrawn; its model W3 upper bound with corrected cubic coefficient 576000 is an antecedent, not C93 novelty. I did not rerun A1's exploratory grids or its topology proof. C92's stated P/R provenance and errata remain imported at that exact source scope; this turn did not reread all underlying historical files or reopen their acceptance. Current repository AGENTS/workflow/autonomy/privacy instructions were read before publication. + +## 1. E1–E9: actual correlated moment measure and edge coordinates + +The margin identification agrees with C92 J14: each cubic filtered determinant is (a_i)_+/4, so their product is w_lambda. Their sum is 48lambda; both positive therefore force lambda>0. Actual endpoint typing is not replaced by this model event. + +The decisive strengthened estimate E7 is justified pointwise before conditioning. Let D=1+Lambda+|t|, bounded by C_Lambda P. C92 J16 gives, after multiplication by N^p, + +D_r N^p <= w_lambda N^p + + C sum_{j=0}^3 binom(3,j) r^(j+1) D^(3-j) N^(p+j+1). + +C92 J10 bounds the four conditional moments by C P^(p+j+1). Each term is therefore at most C r^(j+1) P^(p+4). Choose the common r0<=1 to sum them into C r P^(p+4), retaining the leading C w_lambda P^p term. Finite real moment orders are legitimate: p=0 is immediate, 08Lambda and w_lambda>=(Lambda/2)s. The substituted B1 remains compact. C92's nondegenerate Gaussian covariance, bounded means and compact birth/frame parameter set supply a uniform positive joint-density floor on that box. The nonzero Jacobian preserves the lower bound. Thus the model integral dominates c integral_0^s0 s^(1-v) ds and diverges for v>=2, including the logarithmic endpoint. + +For L_i, 144/a_i<=L_i<=(A_*+gamma^2+144)/a_i. E3 with the finite jet power 2v proves the same threshold, including noninteger v. + +E11 follows by the measurable choice phi(s)=s^-v 1{s>=delta}. At v=3 its exact scalar integral is +delta^-1-A_*^-1+(r/2)(delta^-2-A_*^-2), +bounded as in E12. These constants are uniform in delta; they do not arise from assuming an untruncated inverse moment. + +The g0=s, gr=s+r example correctly falsifies the inference from O(r) L1 error to actual first inverse-moment finiteness. It is explicitly a measure-theoretic fixture, not asserted to be this Gaussian field. E2 would also allow untruncated actual exponents below1; it does not establish an actual divergence threshold, and C93 does not claim one. + +## 4. E13–E17: matrix transfer and third-moment split + +On the nonzero-gamma chart, kappa_i=a_i/(48gamma^2) and the displayed T_i agree with C91 W15. Directly, +||T_i||F^2=1/3+(gamma^2+144)/(3a_i). +The raw Hessian entry bound is (115/48)N r w^2. Its operator norm is at most twice that; chain rule and the Frobenius bound give precisely (115/72)N r w^2 L_i, proving E16. The gamma pole cancels in this bound, but the a_i pole is genuine. This does not extend the coordinate chart to gamma=0. + +With epsilon=(115/72)r w^2/tau, Markov is applied POINTWISE on the away-edge event before weighted integration: +1{H_i>=tau}<=epsilon^3 N^3 L_i^3. +Since L_i^3<=C_Lambda P^6 a_i^-3, E12 at p=3,q=6 gives the away charge epsilon^3(delta^-1+r delta^-2). The near charge is delta^2+r delta. At delta=epsilon their sum is bounded by C(epsilon^2+r epsilon). The special endpoint epsilon=delta0=A_* has an empty away set up to a null boundary, as stated. Full normalization gives E14. + +For fixed tau and w>=1, the r epsilon term is bounded by a tau-dependent multiple of epsilon^2, yielding E15. The E14 constant need not depend on tau,w. The third moment gives the required delta^-1 integral; using only a second-moment split would incur a logarithm in that argument. All N/jet/endpoint correlations remain inside the conditional moments. + +Measurability follows from smooth samples, dense-subset evaluation on the compact raw window and measurable jet matrices on the chart. C92's disintegration gives an absolutely continuous weighted jet marginal, so gamma=0 costs no mass. Neither fact supplies a geometric trap or window containment. + +## 5. E18–E20 and limits of the conclusion + +The bad events are outside model typing, value-error >=tau0, and the two Hessian errors >= their fixed budgets. C92's weighted Taylor Markov proof also works at the non-strict value-error boundary. A union bound, without independence, gives E19. + +For w=r^-beta, beta<1/4, the physical-window restriction and epsilon_i<=delta0 hold eventually. A fixed p>=max(1,1/(1-4beta)) gives +3+p(1-4beta)>=4 and 5-4beta>4. +Thus E19 is O(r^4). Subtracting that bad mass from C92 J5 gives the stated good-event mass r^3 m_Lambda/z0+O(r^4). Its positive uniform coefficient yields conditional probability 1-O(r) given D_Lambda. Moment order is fixed after beta, not selected as a growing function of r. + +The fixed budgets are indispensable. This result gives neither a probability for random vanishing QS tolerances nor a containment probability. It does not accept literal A2 v1, supply global elder selection, resolve intermediate/collision dependencies, compare whole-field laws, permit growing Lambda or identify the persistence coefficient. The sufficient Hessian budgets 1 and2/5 are consistent with C91's conditional interface, but the geometric premises remain separate. + +## 6. Independent exact controls and execution + +I wrote the standard-library checker below before any author code was supplied. Python 3.12.14 executed it in normal, -O and -S modes, each exit0 with byte-identical stdout. Explicit exceptions rather than assert statements retain every check under -O. + +- Checker: 7986 UTF-8 bytes; SHA256 8b3801e8ccf1e2128b119725551ed20d81fe871280f5f97349cebedb5cd6c9e2. +- Exact stdout: 805 UTF-8 bytes; SHA256 119eeabb69d4456ef5092d6f151388ed043244d7d6a430567a64ca4983d4fa89. +- Per mode: 3537 positive rational controls; 13 explicitly false inference fixtures rejected. +- Across the three modes: 10611 positive-control evaluations and39 negative-fixture rejections. These are repetitions of one suite, not three independent reviews. + +The controls cover both edge substitutions/Jacobians, typed cubic determinants, pre-conditioning moment expansion, polynomial norm domination, strip and v3 integrals, dyadic inverse obstructions, rationalized Hessian directions, full normalization, and fixed-beta exponents. The negative fixtures challenge dropped Jacobians, wrong signs, omitted r delta, L1-to-inverse inference, the critical model inverse moment, second-moment log omission, conditional independence, wrong normalization, lost a_i denominator, invalid beta/moment choice, random-budget substitution and the zero-gamma chart. Finite dyadic fixtures illustrate the analytically proved divergence arguments; they do not prove divergence by finite sampling. + +These exact controls supplement the analytic reconstruction above. They do not prove Gaussian rank/density/regression moments, topology, human acceptance or mathematical completion. No author test counts are included. + +Parallel-agent and verification-before-completion guidance were used to separate the supporting audit and verify execution/publication evidence; those workflows add no scientific predicate or independence credit. + +## Reproducible checker source + +Save the following code exactly, including its final newline, as c93_independent_controls.py and run python3 c93_independent_controls.py. It needs no third-party packages. + +```python +#!/usr/bin/env python3 +"""C93 nonauthor rational transcription controls; not a Gaussian proof. + +Python standard library only. No author checker or inputs are used. +Run: python3 c93_independent_controls.py +""" +from fractions import Fraction as F +from math import comb + +COUNTS = {} +NEGATIVE = [] + + +def check(group, predicate): + if not predicate: + raise RuntimeError("positive control failed: " + group) + COUNTS[group] = COUNTS.get(group, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError("negative fixture survived: " + name) + NEGATIVE.append(name) + + +def det(h): + return h[0] * h[2] - h[1] ** 2 + + +def filtered(h, index): + d = det(h) + if d == 0: + return F(0) + actual = 1 if d < 0 else (2 if h[0] < 0 else 0) + return abs(d) if actual == index else F(0) + + +def margins(lam, gamma, b): + return 24 * lam - gamma ** 2 + 12 * b, 24 * lam + gamma ** 2 - 12 * b + + +grid = [F(-2), F(-1, 2), F(0), F(1, 3), F(1), F(3)] +for lam in grid: + for gamma in grid: + for b in grid: + am, ass = margins(lam, gamma, b) + hm = (F(-6), -gamma / 2, -lam - b / 2) + hs = (F(6), gamma / 2, -lam + b / 2) + expected = max(am, 0) * max(ass, 0) / 16 + check("weight_and_typing", filtered(hm, 2) * filtered(hs, 1) == expected) + check("weight_and_typing", am + ass == 48 * lam) + check("weight_and_typing", not (am > 0 and ass > 0) or lam > 0) + +# Both substitutions, signed derivative and absolute Jacobian, including edges. +for lam in [F(1, 100), F(1, 4), F(1), F(2)]: + for gamma in grid: + for fraction in [F(0), F(1, 100), F(1, 4), F(1, 2), F(99, 100), F(1)]: + s = 48 * lam * fraction + for i in [0, 1]: + b = (s - 24 * lam + gamma ** 2) / 12 if i == 0 else (24 * lam + gamma ** 2 - s) / 12 + pair = margins(lam, gamma, b) + check("edge_change_of_variables", pair[i] == s and pair[1 - i] == 48 * lam - s) + check("edge_change_of_variables", max(pair[0], 0) * max(pair[1], 0) / 16 == s * (48 * lam - s) / 16) + ds = F(1, 7) + next_b = (s + ds - 24 * lam + gamma ** 2) / 12 if i == 0 else (24 * lam + gamma ** 2 - s - ds) / 12 + check("edge_change_of_variables", abs((next_b - b) / ds) == F(1, 12)) + +# The multiplication precedes conditional moments; retain all four terms. +for p in range(5): + for r in [F(1, 64), F(1, 5), F(1)]: + for n in [F(1), F(3), F(17)]: + for d in [F(1), F(5), F(11)]: + direct = n ** p * r * n * (d + r * n) ** 3 + expanded = sum(F(comb(3, j)) * r ** (j + 1) * d ** (3 - j) * n ** (p + j + 1) for j in range(4)) + check("moment_product_expansion", direct == expanded) + +# Exact polynomial norm domination supporting (not proving) Gaussian absorption. +for gamma in grid: + for b in grid: + for c3 in grid: + pnorm = 1 + abs(gamma) + abs(b) + abs(c3) + check("polynomial_domination", pnorm ** 2 <= 4 * (1 + gamma ** 2 + b ** 2 + c3 ** 2)) + +# Integrate the nonnegative edge skeleton analytically as rational polynomials. +for cap in [F(1, 4), F(1), F(4)]: + for delta in [cap / 100, cap / 7, cap]: + for r in [F(1, 64), F(1, 5)]: + strip = delta ** 2 / 2 + r * delta + check("strip_and_inverse_integrals", strip <= delta ** 2 + r * delta) + for lam in [cap / 48, cap / 24]: + upper = min(delta, 48 * lam) + edge_weight_integral = (48 * lam * upper ** 2 / 2 - upper ** 3 / 3) / 16 + check("strip_and_inverse_integrals", 0 <= edge_weight_integral <= 48 * lam * upper ** 2 / 32) + exact_v3 = 1 / delta - 1 / cap + r * (1 / delta ** 2 - 1 / cap ** 2) / 2 + check("strip_and_inverse_integrals", 0 <= exact_v3 <= 1 / delta + r / (2 * delta ** 2)) + epsilon = delta + split = delta ** 2 + r * delta + epsilon ** 3 * (1 / delta + r / delta ** 2) + check("strip_and_inverse_integrals", split == 2 * (epsilon ** 2 + r * epsilon)) + +# Threshold v=2: every dyadic shell contributes >=1/2 to integral ds/s. +# A finite total mass or an L1 rate cannot supply an inverse-moment bound. +for k in range(1, 21): + lo, hi = F(1, 2 ** k), F(1, 2 ** (k - 1)) + check("inverse_threshold_shells", (hi - lo) / hi == F(1, 2)) + check("inverse_threshold_shells", 1 / lo - 1 / hi == 1 / (2 * lo)) + check("inverse_threshold_shells", (hi ** 2 - lo ** 2) / 2 > 0) + +# Rationalized transformed directions: v=(sqrt(3)*x,y) has norm^2=3x^2+y^2. +# kappa=u^2 and a=48 gamma^2 u^2, so its raw image is rational. +for gamma in [F(-3), F(-1, 100), F(1, 1000), F(1, 2), F(2)]: + for u in [F(1, 100), F(1, 3), F(1), F(5)]: + a = 48 * gamma ** 2 * u ** 2 + frob = F(1, 3) + F(1, 144) / u ** 2 + 1 / (gamma ** 2 * u ** 2) + loss = 1 + (gamma ** 2 + 144) / a + check("hessian_transfer", frob == loss / 3) + for x, y in [(F(0), F(1)), (F(1), F(0)), (F(1), F(1)), (F(-2), F(3))]: + rx, rz = x - y / (12 * u), y / (gamma * u) + length = 3 * x ** 2 + y ** 2 + for hxx in [F(-1), F(0), F(1)]: + for hxz in [F(-1), F(1)]: + for hzz in [F(-1), F(0), F(1)]: + quadratic = hxx * rx ** 2 + 2 * hxz * rx * rz + hzz * rz ** 2 + check("hessian_transfer", abs(quadratic) <= 2 * frob * length) +check("hessian_transfer", F(115, 48) * F(2, 3) == F(115, 72)) + +# Exact normalization and radius ledger; constants may depend on fixed p,beta. +for r in [F(1, 64), F(1, 8), F(1, 2)]: + for z in [F(1, 3), F(2), F(7)]: + mass = F(5, 7) + check("normalization_and_exponents", r ** 4 * r * mass / (r ** 2 * z) == r ** 3 * mass / z) +for beta in [F(0), F(1, 20), F(1, 8), F(1, 5), F(6, 25), F(249, 1000)]: + minimum = 1 / (1 - 4 * beta) + for p in [minimum, minimum + 1, 2 * minimum]: + check("normalization_and_exponents", 3 + p * (1 - 4 * beta) >= 4) + check("normalization_and_exponents", 5 - 4 * beta >= 4) + check("normalization_and_exponents", 1 - 2 * beta > 0 and 1 - beta > 0) + +# Deliberately false claims. Each fixture must reject its named inference. +reject("missing_B1_jacobian", F(12, 12) == F(1, 12)) +lam, gamma, s = F(1), F(2), F(7) +wrong_b = (s - 24 * lam + gamma ** 2) / 12 +reject("reuse_M_substitution_for_S", margins(lam, gamma, wrong_b)[1] == s) +r, delta = F(1, 16), F(1, 4096) +reject("discard_actual_r_delta", delta ** 2 / 2 + r * delta <= 2 * delta ** 2) +# With the same fixed r, the dyadic lower bound grows without limit. +reject("L1_implies_actual_inverse_integrability", 100 * r / 2 <= r) +reject("model_second_inverse_is_finite", F(100, 2) <= 1) +# A second-moment split contributes epsilon^2 * int_delta^1 ds/s. +reject("second_moment_gives_uniform_log_free_split", F(100, 2) <= 2) +# E[D N] differs from E[D]E[N] for the correlated two-atom example (1,1),(3,3). +reject("factor_conditional_weight_and_norm", F(1 + 9, 2) == F(1 + 3, 2) ** 2) +reject("omit_full_r2_normalizer", F(1, 8) ** 5 == F(1, 8) ** 3) +reject("omit_typing_denominator", 1 + (F(1) + 144) / F(1, 100) <= 1 + F(1) + 144) +reject("allow_beta_one_quarter", 3 + 100 * (1 - 4 * F(1, 4)) >= 4) +reject("underpowered_fixed_moment", 3 + 4 * (1 - 4 * F(1, 5)) >= 4) +reject("arbitrary_random_budget_is_covered", F(115, 72) * F(1, 100) / F(1, 100) ** 2 <= 1) +try: + F(1) / F(0) +except ZeroDivisionError: + NEGATIVE.append("gamma_zero_is_not_a_chart") +else: + raise RuntimeError("negative fixture survived: gamma_zero_is_not_a_chart") + +print("C93 independent rational controls") +for name in sorted(COUNTS): + print(name + ": " + str(COUNTS[name])) +print("positive_total: " + str(sum(COUNTS.values()))) +print("negative_fixtures_rejected: " + str(len(NEGATIVE))) +print("negative_names: " + ", ".join(NEGATIVE)) +print("PASS transcription/scaling controls only; analytic Gaussian inputs reviewed separately.") +``` + +## Exact stdout + +```text +C93 independent rational controls +edge_change_of_variables: 864 +hessian_transfer: 1461 +inverse_threshold_shells: 60 +moment_product_expansion: 135 +normalization_and_exponents: 63 +polynomial_domination: 216 +strip_and_inverse_integrals: 90 +weight_and_typing: 648 +positive_total: 3537 +negative_fixtures_rejected: 13 +negative_names: missing_B1_jacobian, reuse_M_substitution_for_S, discard_actual_r_delta, L1_implies_actual_inverse_integrability, model_second_inverse_is_finite, second_moment_gives_uniform_log_free_split, factor_conditional_weight_and_norm, omit_full_r2_normalizer, omit_typing_denominator, allow_beta_one_quarter, underpowered_fixed_moment, arbitrary_random_budget_is_covered, gamma_zero_is_not_a_chart +PASS transcription/scaling controls only; analytic Gaussian inputs reviewed separately. +``` diff --git a/frontiers/planar_soft_layer_chain_20261003/C93/checker.py b/frontiers/planar_soft_layer_chain_20261003/C93/checker.py new file mode 100644 index 000000000..96360984b --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C93/checker.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python3 +"""C93 nonauthor rational transcription controls; not a Gaussian proof. + +Python standard library only. No author checker or inputs are used. +Run: python3 c93_independent_controls.py +""" +from fractions import Fraction as F +from math import comb + +COUNTS = {} +NEGATIVE = [] + + +def check(group, predicate): + if not predicate: + raise RuntimeError("positive control failed: " + group) + COUNTS[group] = COUNTS.get(group, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError("negative fixture survived: " + name) + NEGATIVE.append(name) + + +def det(h): + return h[0] * h[2] - h[1] ** 2 + + +def filtered(h, index): + d = det(h) + if d == 0: + return F(0) + actual = 1 if d < 0 else (2 if h[0] < 0 else 0) + return abs(d) if actual == index else F(0) + + +def margins(lam, gamma, b): + return 24 * lam - gamma ** 2 + 12 * b, 24 * lam + gamma ** 2 - 12 * b + + +grid = [F(-2), F(-1, 2), F(0), F(1, 3), F(1), F(3)] +for lam in grid: + for gamma in grid: + for b in grid: + am, ass = margins(lam, gamma, b) + hm = (F(-6), -gamma / 2, -lam - b / 2) + hs = (F(6), gamma / 2, -lam + b / 2) + expected = max(am, 0) * max(ass, 0) / 16 + check("weight_and_typing", filtered(hm, 2) * filtered(hs, 1) == expected) + check("weight_and_typing", am + ass == 48 * lam) + check("weight_and_typing", not (am > 0 and ass > 0) or lam > 0) + +# Both substitutions, signed derivative and absolute Jacobian, including edges. +for lam in [F(1, 100), F(1, 4), F(1), F(2)]: + for gamma in grid: + for fraction in [F(0), F(1, 100), F(1, 4), F(1, 2), F(99, 100), F(1)]: + s = 48 * lam * fraction + for i in [0, 1]: + b = (s - 24 * lam + gamma ** 2) / 12 if i == 0 else (24 * lam + gamma ** 2 - s) / 12 + pair = margins(lam, gamma, b) + check("edge_change_of_variables", pair[i] == s and pair[1 - i] == 48 * lam - s) + check("edge_change_of_variables", max(pair[0], 0) * max(pair[1], 0) / 16 == s * (48 * lam - s) / 16) + ds = F(1, 7) + next_b = (s + ds - 24 * lam + gamma ** 2) / 12 if i == 0 else (24 * lam + gamma ** 2 - s - ds) / 12 + check("edge_change_of_variables", abs((next_b - b) / ds) == F(1, 12)) + +# The multiplication precedes conditional moments; retain all four terms. +for p in range(5): + for r in [F(1, 64), F(1, 5), F(1)]: + for n in [F(1), F(3), F(17)]: + for d in [F(1), F(5), F(11)]: + direct = n ** p * r * n * (d + r * n) ** 3 + expanded = sum(F(comb(3, j)) * r ** (j + 1) * d ** (3 - j) * n ** (p + j + 1) for j in range(4)) + check("moment_product_expansion", direct == expanded) + +# Exact polynomial norm domination supporting (not proving) Gaussian absorption. +for gamma in grid: + for b in grid: + for c3 in grid: + pnorm = 1 + abs(gamma) + abs(b) + abs(c3) + check("polynomial_domination", pnorm ** 2 <= 4 * (1 + gamma ** 2 + b ** 2 + c3 ** 2)) + +# Integrate the nonnegative edge skeleton analytically as rational polynomials. +for cap in [F(1, 4), F(1), F(4)]: + for delta in [cap / 100, cap / 7, cap]: + for r in [F(1, 64), F(1, 5)]: + strip = delta ** 2 / 2 + r * delta + check("strip_and_inverse_integrals", strip <= delta ** 2 + r * delta) + for lam in [cap / 48, cap / 24]: + upper = min(delta, 48 * lam) + edge_weight_integral = (48 * lam * upper ** 2 / 2 - upper ** 3 / 3) / 16 + check("strip_and_inverse_integrals", 0 <= edge_weight_integral <= 48 * lam * upper ** 2 / 32) + exact_v3 = 1 / delta - 1 / cap + r * (1 / delta ** 2 - 1 / cap ** 2) / 2 + check("strip_and_inverse_integrals", 0 <= exact_v3 <= 1 / delta + r / (2 * delta ** 2)) + epsilon = delta + split = delta ** 2 + r * delta + epsilon ** 3 * (1 / delta + r / delta ** 2) + check("strip_and_inverse_integrals", split == 2 * (epsilon ** 2 + r * epsilon)) + +# Threshold v=2: every dyadic shell contributes >=1/2 to integral ds/s. +# A finite total mass or an L1 rate cannot supply an inverse-moment bound. +for k in range(1, 21): + lo, hi = F(1, 2 ** k), F(1, 2 ** (k - 1)) + check("inverse_threshold_shells", (hi - lo) / hi == F(1, 2)) + check("inverse_threshold_shells", 1 / lo - 1 / hi == 1 / (2 * lo)) + check("inverse_threshold_shells", (hi ** 2 - lo ** 2) / 2 > 0) + +# Rationalized transformed directions: v=(sqrt(3)*x,y) has norm^2=3x^2+y^2. +# kappa=u^2 and a=48 gamma^2 u^2, so its raw image is rational. +for gamma in [F(-3), F(-1, 100), F(1, 1000), F(1, 2), F(2)]: + for u in [F(1, 100), F(1, 3), F(1), F(5)]: + a = 48 * gamma ** 2 * u ** 2 + frob = F(1, 3) + F(1, 144) / u ** 2 + 1 / (gamma ** 2 * u ** 2) + loss = 1 + (gamma ** 2 + 144) / a + check("hessian_transfer", frob == loss / 3) + for x, y in [(F(0), F(1)), (F(1), F(0)), (F(1), F(1)), (F(-2), F(3))]: + rx, rz = x - y / (12 * u), y / (gamma * u) + length = 3 * x ** 2 + y ** 2 + for hxx in [F(-1), F(0), F(1)]: + for hxz in [F(-1), F(1)]: + for hzz in [F(-1), F(0), F(1)]: + quadratic = hxx * rx ** 2 + 2 * hxz * rx * rz + hzz * rz ** 2 + check("hessian_transfer", abs(quadratic) <= 2 * frob * length) +check("hessian_transfer", F(115, 48) * F(2, 3) == F(115, 72)) + +# Exact normalization and radius ledger; constants may depend on fixed p,beta. +for r in [F(1, 64), F(1, 8), F(1, 2)]: + for z in [F(1, 3), F(2), F(7)]: + mass = F(5, 7) + check("normalization_and_exponents", r ** 4 * r * mass / (r ** 2 * z) == r ** 3 * mass / z) +for beta in [F(0), F(1, 20), F(1, 8), F(1, 5), F(6, 25), F(249, 1000)]: + minimum = 1 / (1 - 4 * beta) + for p in [minimum, minimum + 1, 2 * minimum]: + check("normalization_and_exponents", 3 + p * (1 - 4 * beta) >= 4) + check("normalization_and_exponents", 5 - 4 * beta >= 4) + check("normalization_and_exponents", 1 - 2 * beta > 0 and 1 - beta > 0) + +# Deliberately false claims. Each fixture must reject its named inference. +reject("missing_B1_jacobian", F(12, 12) == F(1, 12)) +lam, gamma, s = F(1), F(2), F(7) +wrong_b = (s - 24 * lam + gamma ** 2) / 12 +reject("reuse_M_substitution_for_S", margins(lam, gamma, wrong_b)[1] == s) +r, delta = F(1, 16), F(1, 4096) +reject("discard_actual_r_delta", delta ** 2 / 2 + r * delta <= 2 * delta ** 2) +# With the same fixed r, the dyadic lower bound grows without limit. +reject("L1_implies_actual_inverse_integrability", 100 * r / 2 <= r) +reject("model_second_inverse_is_finite", F(100, 2) <= 1) +# A second-moment split contributes epsilon^2 * int_delta^1 ds/s. +reject("second_moment_gives_uniform_log_free_split", F(100, 2) <= 2) +# E[D N] differs from E[D]E[N] for the correlated two-atom example (1,1),(3,3). +reject("factor_conditional_weight_and_norm", F(1 + 9, 2) == F(1 + 3, 2) ** 2) +reject("omit_full_r2_normalizer", F(1, 8) ** 5 == F(1, 8) ** 3) +reject("omit_typing_denominator", 1 + (F(1) + 144) / F(1, 100) <= 1 + F(1) + 144) +reject("allow_beta_one_quarter", 3 + 100 * (1 - 4 * F(1, 4)) >= 4) +reject("underpowered_fixed_moment", 3 + 4 * (1 - 4 * F(1, 5)) >= 4) +reject("arbitrary_random_budget_is_covered", F(115, 72) * F(1, 100) / F(1, 100) ** 2 <= 1) +try: + F(1) / F(0) +except ZeroDivisionError: + NEGATIVE.append("gamma_zero_is_not_a_chart") +else: + raise RuntimeError("negative fixture survived: gamma_zero_is_not_a_chart") + +print("C93 independent rational controls") +for name in sorted(COUNTS): + print(name + ": " + str(COUNTS[name])) +print("positive_total: " + str(sum(COUNTS.values()))) +print("negative_fixtures_rejected: " + str(len(NEGATIVE))) +print("negative_names: " + ", ".join(NEGATIVE)) +print("PASS transcription/scaling controls only; analytic Gaussian inputs reviewed separately.") diff --git a/frontiers/planar_soft_layer_chain_20261003/C93/checker_stdout.txt b/frontiers/planar_soft_layer_chain_20261003/C93/checker_stdout.txt new file mode 100644 index 000000000..6756cba05 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C93/checker_stdout.txt @@ -0,0 +1,13 @@ +C93 independent rational controls +edge_change_of_variables: 864 +hessian_transfer: 1461 +inverse_threshold_shells: 60 +moment_product_expansion: 135 +normalization_and_exponents: 63 +polynomial_domination: 216 +strip_and_inverse_integrals: 90 +weight_and_typing: 648 +positive_total: 3537 +negative_fixtures_rejected: 13 +negative_names: missing_B1_jacobian, reuse_M_substitution_for_S, discard_actual_r_delta, L1_implies_actual_inverse_integrability, model_second_inverse_is_finite, second_moment_gives_uniform_log_free_split, factor_conditional_weight_and_norm, omit_full_r2_normalizer, omit_typing_denominator, allow_beta_one_quarter, underpowered_fixed_moment, arbitrary_random_budget_is_covered, gamma_zero_is_not_a_chart +PASS transcription/scaling controls only; analytic Gaussian inputs reviewed separately. diff --git a/frontiers/planar_soft_layer_chain_20261003/C94/DELIVERY.md b/frontiers/planar_soft_layer_chain_20261003/C94/DELIVERY.md new file mode 100644 index 000000000..847eaf3bd --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C94/DELIVERY.md @@ -0,0 +1,23 @@ +## C94 reviewed delivery — actual weighted trap-window and random-margin control + +**ACCEPT / PASS_TECHNICAL_SCOPED for C6–C20; no required amendment.** Section 6 remains conditional on the explicitly stated geometric interface G. Original A2v1 remains **AMEND**; this delivery does not retroactively accept or rewrite it. + +- [Frozen proof](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964517708): 15407B, SHA256 `0fe4fa2028f8ddbbf5a79df3879bcbd3789f19409fb44ad739caeabedff1af3c`. +- [Full separate technical review](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964735560): 30074B, SHA256 `327abea538b814f279a936a71072960de08e53314f0f08dd32c2f8870a32d65e`. +- [Immutable registered delivery](https://drive.google.com/file/d/1u8Wf837mB3PpuqpH-zc3G0gqJnR2nj_k/view?usp=drivesdk): 405918B ZIP, 41 payloads, SHA256 `56de1933e993edd9b070887fbf4f2f4630f60b1238d0b9bb18cb55fe012761f6`. + +For the specified planar model-elder sector E, fixed finite torus, k=1, compact birth heights, all frames and fixed bounded soft coordinate, C94 proves +`Q_r^W(E minus Good) <= C r^(7/2)` +and +`Q_r^W(Good | E) = 1 - O(sqrt(r))`. +The actual radius tail, random local value tolerance, decision-level band and Hessian losses are integrated under the actual correlated weighted law. The full normalizer is retained. This is not a global persistence-bar identification. + +Verification completed: author 1151 finite controls and 10 separately rejected mutants; reviewer 3773 finite controls and 17 false-inference fixtures. The exact reviewer source and stdout reproduce in normal, optimized, no-site and optimized/no-site modes (original Python3.12.14; replay3.11.16). Final stable packet verification passed. Seventeen retained source identities and fifteen full native source bodies are verified; the C82 prefix/full-native relation is explicit. + +The Drive archive was downloaded and compared byte for byte, then its canonical manifest/handoff verified. Owner-only permissions and the existing delivery parent were read back. Registered at Artifact Index888, Evidence Lineage610, Review Queue157, Work Events621; all full CellData readbacks exact. Claim `41587ec8-08a1-4cbc-8c28-c033273cc412` released at Work Events622, 2026-10-03T02:52:28Z, with exact readback. + +**Incorporation request, not a claimed pickup or merge:** consume the exact proof/review together, preserve historic sources and the conditional G boundary. First resolve corrected A2/G under its existing custody with an additive frozen correction and exact-delta disposition. Then connect the one-sided maximin conclusion to its named persistence observable. Rejected-side chord, unbounded soft/hard strata, all marks, regional shrinking witness collisions and intermediate/coarea composition remain distinct open obligations. Do not duplicate the unchanged full C94 review. + +No C94 repository commit, hosted CI or merge is represented. Existing PR228 and Math247 head checks were healthy in the bounded audit; they do not validate this packet. Reader-interface incorporation and publication still require their own verified ownership and privacy-safe author/committer route. + +Dylan Roy — delegated AI work/review. OpenAI/Codex root01a0bbb5 author; separate coordinator root01a0adb2 reviewer. Prior source/target and C91–C93 exposure disclosed; helper c94_source_margin_audit supports C11–C13 only, no extra acceptance vote. Personal reading PENDING; independent human review NONE; organizational independence 0; scientific effect NONE. diff --git a/frontiers/planar_soft_layer_chain_20261003/C94/PROOF.md b/frontiers/planar_soft_layer_chain_20261003/C94/PROOF.md new file mode 100644 index 000000000..a9f2695b4 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C94/PROOF.md @@ -0,0 +1,330 @@ +# Actual weighted trap-window and random-margin transfer + +Object: C94-PLANAR-WEIGHTED-TRAP-WINDOW-RANDOM-MARGIN-20261003-v1. +Author: OpenAI/Codex root01a0bbb5, acting for Dylan Roy — delegated AI work. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; nonauthor technical review pending. +Personal reading PENDING; organizational independence 0; scientific effect NONE. + +This supplies quantitative actual-law bounds for the radius, local value +tolerance and decision margin needed on a specified planar model-elder +sector. A simultaneous certificate fails with full weighted probability +O(r^(7/2)), whereas that sector has probability of order r^3. The analytic +statement is separate from the conditional geometric application in §6. +In particular the original A2 v1 remains AMEND; it is not relabeled PASS. + +## 0. Fixed setting, exact sources and observables + +Use C92's normalized periodized Gaussian field on the planar torus of fixed +side L>0, gap mark k=1, birth b in a fixed nonempty compact set B0 and all +orthonormal frames. Pins, Q_r, actual determinant weight W_r, FULL Z_r, +Q_r^W, raw field F_r, cubic G, error E_r and field norm N are exactly C92's. +No new pin law or normalization is introduced. In particular + + A=f_zz(0), lambda=-A/r, t=(gamma,B1,C3), + Pjet=1+|gamma|+|B1|+|C3|, + D_Lambda={|lambda|<=Lambda}, 00,a_S>0}, A_*=48Lambda, + w_lambda=a_M a_S/16 on T, + mu_r(E)=r^(-5) E_Q[W_r 1_E], + dmu_0=rho_0(0,t) w_lambda d lambda dt on T, + Q_r^W(E)=r^3 mu_r(E)/z_r, z_r=Z_r/r^2=z_0+O(r). (C1) + +Here mu_r is restricted to D_Lambda. C92 gives a uniformly positive floor +for z_r, a uniform Gaussian density envelope in t and weighted L1 error +O(r). C93 supplies the correlated moment-weighted edge estimate + + r^(-5) E_Q[W_r N^p Pjet^q 1_T phi(a_i)] + <= C_(p,q) integral_0^A_* phi(s)(s+r) ds, (C2) + +for nonnegative measurable phi and fixed finite p,q. All constants below +are uniform in b and frame; they may depend on L,B0,Lambda and fixed moment +orders. They are finite analytic constants, not numerical enclosures. + +Sources: C91 proof5963566666/review5963668996; +C92 proof5963825788/review5963946854; +C93 proof5964167051/review5964232937; +C82 proof5959920397/review5959988102; +QS5961415030; A1 proof5961913750/review5962025965/correction5962385282; +A2 original5963200491 and C90 combined review5963477339. All are in +main issue229. SOURCE_IDENTITIES.json pins retained source bytes. The +C82 mathematical body is11253B, SHA256 +f390ad99b07ec4eda9160191d776cfc3a53ca628976165987d9a61ab79816827; +its native footer is separately retained. C92/C93's imported Gaussian +interfaces and their errata remain premises with exactly their scopes. + +On T and gamma!=0 define the exact raw-to-cubic map + + D=gamma^2-12B1, J=8gamma^3-144B1 gamma+576C3, + psi=24lambda/gamma^2, c=D/gamma^2, R=J/gamma^3, + u=X+gamma zeta/12, Z=gamma zeta, + P(u,Z)=2u^3-3u/2-1/2-(psi+2cu)Z^2/48+RZ^3/3456. + (C3) + +Direct expansion gives G(X,zeta)=P(u,Z); here lambda is precisely the +tilde-lambda of QS at k=1. Thus a_S=gamma^2(psi+c), +a_M=gamma^2(psi-c), and raw values are already in P-units. + +Let mu be the maximum of P(Y)+1 over extra NONDEGENERATE saddles Y of P, +with mu=-infinity if there is none. It is a Borel extended-real function: +C82 §2 represents these saddles by finitely many algebraic branches, +including degree drops and tangencies. Define the fixed jet sector + + E={D_Lambda, T, gamma!=0, psi>=2c, + R^2<=16(psi-2c)^2(psi+c), mu<0}. (C4) + +The two explicit inequalities in (C4) retain A1's elder-side hypotheses; +we do not need to infer them from an unrecorded classification theorem. +The finite-r sector uses these model jets, not an actual elder indicator. + +Set a=2/(3sqrt(3)), kappa_S=(psi+c)/48, kappa_M=(psi-c)/48 and + + tau_i=a+|c|/(24sqrt(3) kappa_i) + +|R|/(3456 kappa_i^(3/2)), + m_S=2/(125 tau_S^2), e_M=min(1/(8 tau_M^2),1), + v=min(m_S,e_M), eta=(1/2)min(v,-mu), + Rbox=3/2+(5/2)(|gamma|+12)/sqrt(24lambda). (C5) + +On E all these quantities except possibly -mu are finite and strictly +positive; min(v,+infinity)=v. The tolerance eta is random and depends on +the same jets as the determinant and the field norm. No independence is +assumed. The chart gamma=0 is null under both measures but is not extended +pointwise. Define E0(r,w)=sup_{|X|,|zeta|<=w}|E_r| and H_i(r,w) exactly as +C93 E13 (raw-window supremum of the rescaled Hessian norm). + +## 1. Actual radius tail + +For rho>0, fixed finite p,q>=0, + + r^(-5) E_Q[W_r N^p Pjet^q 1_T + 1_{Rbox>3/2+rho}] + <= C_(p,q)(rho^(-8)+r rho^(-4)). (C6) + +Only large rho is needed. No A2 trap theorem is used to prove this tail +of the explicitly defined function Rbox. Its geometric meaning is §6. + +Proof. C93 E7–E8 gives the joint integrand envelope + + C exp(-c0|t|^2)[w_lambda Pjet^(p+q) + +r Pjet^(p+q+4)]. + +Change B1 to s=a_S, with dB1=ds/12. On T, 0=c_* a_S^2, c_*=3/(250 A_*^2). (C8) + +Indeed a^2=4/27 gives m_S>=3a_S^2/(250 A_*^2), whereas +e_M>=27/512>3/250 and a_S<=A_*. These inequalities also show the +deterministic threshold in (C8) never exceeds the available e_M bound. +Only W1 is used: no fixed-R equality/sharpness assertion from A1 is used. + +Let K0=167/192, e=rw^4 and epsilon=2K0 e/c_*. For w>=1 with +2rw<=L/4 and sqrt(epsilon)<=min(1,A_*), + + mu_r(E intersect {E0(r,w)>=v/2}) + <= C(epsilon+r sqrt(epsilon)) + <= C(e+r sqrt(e)). (C9) + +Proof. The exact C91/C92 bound is E0<=K0 N e. On a_S>=d, (C8) and +the pointwise squared Markov inequality give the bad-event bound +epsilon^2 N^2 a_S^(-4). On a_S=1, 0=eta}) + <=C[e+r sqrt(e)+d+r+(e/d)^p]. (C14) + +To prove it, eta=(1/2)min(v,-mu). If E0>=eta, either E0>=v/2 or +E0>=(-mu)/2. Use (C9) on the first event. The second lies in the union +of {-2d<=mu<0} and {E0>=d}. The first costs C(d+r) by (C11), used +with width2d. No-extra-saddle points have mu=-infinity and are absent. +C92 J6 bounds the second event by C(K0 e/d)^p in mu_r units. This +uses E_Q[W_r N^p 1_D]=O(r^5), not an unweighted field-norm probability. +All these are union bounds; dependencies among the events are harmless. + +## 5. A simultaneous analytic certificate at the rare-sector scale + +Let Good(r,w) be the following event inside the explicitly defined E: + + Rbox<=w, E0(r,w)=3 with 2rw<=L/4, sufficiently small rw^4 and +0=w/2. The two Hessian losses are at most +Cr^5w^4 by C93 at the fixed thresholds1 and2/5. Divide every mu_r +bound by the same full z_r and multiply by r^3. The outside-T error is +not silently discarded: E is DEFINED inside T; no assertion here covers +all finite-r soft-layer jets. C93 separately supplies its O(r^4) bound. + +In particular take the fixed choices + + w=r^(-1/16), d=r^(1/2), p=2. (C17) + +For sufficiently small r all window/cutoff conditions hold. The powers +inside the brackets in (C16), in order, are + + 1/2, 5/4, 3/4, 11/8, 1/2, 1, 1/2, 7/4. + +Consequently + + Q_r^W(E minus Good)<=C r^(7/2). (C18) + +Write m_E(b,frame)=mu_0(E). C92's bounded-indicator L1 comparison and +normalizer estimate give + + Q_r^W(E)=r^3 m_E/z_0+O(r^4), + Q_r^W(Good)=r^3 m_E/z_0+O(r^(7/2)). (C19) + +Moreover m_E has a uniform positive lower bound. Here is an explicit +interior witness rather than an assumption of positivity. At +lambda=Lambda/2, gamma=1, B1=(1+6Lambda)/12 choose C3 so J=0. +Then psi=12Lambda, c=-6Lambda, R=0. The extra-point discriminant factor +R^2+64c(psi^2-c^2) is strictly negative. Thus a small fixed neighborhood +has no extra critical point, mu=-infinity, strict T, psi>2c and R^2=omega0 use a0/omega<=K. This preserves + K<6.05 without using the invalid reciprocal on the second interval. +2. Lemma7(c)'s sharpness segment stops BEFORE the first level root + t_eta in(0,1), (1+m)(3t_eta^2-2t_eta^3)=1+eta. The saddle itself + is outside the trap. The limit t_eta->1 as eta increases to m retains + supremal constant12. This sharpness statement is not used in G. +3. Corollary9(c)'s typed integral is zero for x<=|c|; otherwise it is + x^3/3-c^2*x+2|c|^3/3. Its model rho^-6 tail is not used in C94. + +These identify the prospective corrected consumer interface and preserve +the historical AMEND verdict. They do not impersonate an author-issued A2 +successor, settle its publication custody, or constitute a new full review +of QS's topology. Exact-delta acceptance of a frozen corrected geometric +source remains separate from the unconditional analytic verdict here. + +**Conditional corollary.** If G is supplied with its retained QS/CUB local +premises, Good implies its hypotheses at the actual field. Indeed +00 and `psi>|c|`. The extra nondegenerate saddle branches are finite algebraic branches with separate degree-drop cases and Hessian-sign guards, so their guarded finite maximum is Borel. Tangencies are not silently counted as nondegenerate saddles, and the empty set has mu=-infinity. Gamma=0 is null under the nondegenerate actual/model jet laws; C3 is not a pointwise extension there. + +E explicitly retains A1's inequalities as well as mu<0. It is a model-jet sector under the actual law, not an asserted finite-r elder indicator. In particular no unstated converse classification is needed to obtain its elder-side inequalities. The positive eta is correlated with the same jets, norm and determinant throughout. + +### C6–C7: the actual radius tail + +C93's envelope is usable with the norm multiplication already performed before conditioning: +`C exp(-c|t|^2)[w_lambda Pjet^(p+q)+r Pjet^(p+q+4)]`. +This retains the finite-r residual and the correlations. With s=a_S, the absolute B1 Jacobian is 1/12, T becomes `0=3a_S^2/(250 A_*^2)` and `e_M>=27/512>3/250`. +Since a_S<=A_*, this proves C8's lower bound for their minimum, including the small-Lambda regime with constants depending on fixed Lambda. + +C91 gives `E0<=K0 N e` with `K0=167/192`, `e=rw^4`. If E0>=v/2 then `epsilon N>=a_S^2`, where epsilon=2K0e/c_*. The pointwise bound on a_S>=d is therefore `epsilon^2 N^2 a_S^-4`; it requires no independence. C93's ACTUAL weighted strip and moment bounds give +`C[d^2+rd+epsilon^2(1/(2d^2)+r/(3d^3))]`. +The two inverse primitives are correct; their nonnegative upper-end subtractions can be dropped. With d=sqrt(epsilon), this is `C(epsilon+r sqrt(epsilon))`. At d=A_* the away set is empty. The stated cutoff restriction ensures the split is legal eventually. This does not multiply a TV error by an unbounded inverse margin. + +### C11–C13: C82 under the joint Gaussian, without reference independence + +At fixed t and nonzero gamma, c,R are fixed as lambda varies. The exact change of variable is +`w_lambda d lambda=(gamma^6/384)(psi^2-c^2)dpsi`. +Extending the bounded-lambda interval to all psi>|c| enlarges a nonnegative integral. C82's deterministic LB supplies the band bound with DETERMINISTIC width d<=1/2. Its independent-reference-Gaussian GLB is neither needed nor validly substituted for the actual law. + +Both chart poles cancel before integrating: +`gamma^6 |c|^3=|gamma^2-12B1|^3`, +`gamma^6 R^2=(8gamma^3-144B1 gamma+576C3)^2`. +Thus the joint slice envelope gives a finite Gaussian polynomial integral uniformly in the declared compact births/all frames. It handles the actual correlations without factorizing mixed moments. C92's weighted L1 estimate is applied only to the bounded band indicator, giving C(d+r) at finite r. A psi-dependent width would invalidate this use of LB; none is introduced. + +### C14: the correlated random decision margin + +The exact event split is `E0>=eta` implies `E0>=v/2` or `E0>=(-mu)/2`. On the latter event, either `-2d<=mu<0` or `E0>=d`. The no-extra-saddle case mu=-infinity contributes nothing to this second event. Width 2d is permitted because d<=1/4. The near band costs C(d+r); the other event is bounded by the ACTUAL determinant-weighted Markov inequality `C(K0 e/d)^p` using C92's `E_Q[W_r N^p 1_D]=O(r^5)`. + +These are unions and pointwise Markov inequalities under the original pin law. No fresh conditioning on E that would preserve Gaussianity is asserted; no independence among eta,N,W_r or the sector is required. Together with C9 this establishes C14. + +### C15–C18: simultaneous event and exponent ledger + +For w>=3, the radius loss uses rho=w-3/2>=w/2. C93's two fixed-threshold Hessian losses are `O(r^5 w^4)` in full Q_r^W units, hence `O(r^2 w^4)` inside C16's bracket. Every mu_r loss is converted by the same `r^3/z_r`. The sector is defined inside T; this is not an assertion that actual outside-T jets disappear. C93's separate outside-T error remains separate. + +For w=r^-1/16, d=r^1/2, p=2, the eight bracket exponents are exactly +`(1/2,5/4,3/4,11/8,1/2,1,1/2,7/4)`. +Their minimum is 1/2, so C18 is `O(r^7/2)`, not O(r^4). The physical window embeds eventually since rw=r^15/16 tends to zero; all local error, epsilon and band restrictions also hold for sufficiently small r. Moment order p=2 and Lambda remain fixed. + +### C19–C20: full normalization and positive rare-sector mass + +C92 applies to the bounded E indicator even though it includes algebraic branch selection. With z_r=z_0+O(r) and a uniform positive floor, `Q_r^W(E)=r^3 m_E/z_0+O(r^4)`. Subtracting the simultaneous failure bound gives C19. + +The proposed positive witness can be written explicitly: +`lambda=Lambda/2, gamma=1, B1=(1+6Lambda)/12, C3=(1+18Lambda)/144`. +It has `J=0, a_M=18Lambda, a_S=6Lambda, w_lambda=27Lambda^2/4`, and extra-point discriminant bracket `-41472Lambda^3<0`. Also psi=12Lambda, c=-6Lambda and the elder-side bound is strict. An open neighborhood remains within D_Lambda and every strict sector condition and has no extra critical point; thus mu=-infinity there. Taking a fixed compact smaller neighborhood supplies positive volume and weight. C92's continuous uniformly nondegenerate joint densities have a positive lower bound on this neighborhood uniformly over compact b and frames. This proves the claimed uniform m_E floor, rather than assuming it. The uniform upper bound is supplied by m_Lambda. + +Dividing C18 by the order-r^3 sector probability yields `Q_r^W(Good|E)=1-O(r^1/2)`. This is a conditional probability under the full actual weighted law; Good does NOT have unconditional probability tending to one. + +## Section 6: conditional geometry only + +The preceding analytic estimates treat Rbox as an explicit jet function. They do not require A2's topology. C94 accurately retains original A2 v1's AMEND disposition and does not impersonate an author-issued correction. The stated repairs are consistent with C90: the reciprocal is used only on its positive-denominator interval with threshold 74875/187969 and K=187969/31250<6.05; the sharpness segment stops at the first level root rather than reaching the below-level saddle; the model tail has empty typed domain when x<=|c|. Neither the sharpness claim nor that model tail is used in C6–C20. + +CONDITIONAL ON G, the consumption is valid with retained QS/CUB local assumptions, exact pins and global continuity. Eta satisfies (H), including the empty-extra-saddle case. The raw map is `X=u-Z/12, zeta=Z/gamma`; for the prescribed cubic box, +`||(X,zeta)||_2 <= |X|+|zeta| <= Rbox`. +This works for either sign of gamma and introduces no standalone gamma pole in the already controlled raw radius. Good therefore places the required raw sets inside the C91 window, preserves value units exactly, and supplies the C93 Hessian thresholds (the strict <2/5 condition is stronger than G's <=2/5). The axis and its higher endpoint are retained. The small patch is injective on the torus; the compact trap boundary and lower axis path support the same maximin comparison for globally continuous actual fields, conditional on G's barrier/topology conclusion. + +This is one direction on a specified model sector. It does not identify the sector with all actual elder pairs, establish a bar/witness bijection, control the rejected-side chord or intermediate/coarea population, or discharge regional multiple-witness collisions. Whole-field TV, unbounded Lambda, all marks, other dimensions and joint infinite-volume limits are not supplied. Persistence-module interpretation retains its own Morse/topology and event-identification premises. There is no Conjecture7 or scientific-completion promotion. + +Remaining load-bearing geometric work: a frozen corrected QS-Eprime/G source with the retained local premises must receive its own exact-delta acceptance. This review supplies no such acceptance. + +## Independent executed controls and their meaning + +Python 3.12.14, standard library only. The independently written checker below was executed as: +```text +python3 c94_independent_controls.py +python3 -O c94_independent_controls.py +python3 -S c94_independent_controls.py +``` +Each run completed successfully with 3773 positive rational/algebra controls and 17 rejected false-inference fixtures. Normal, -O and -S stdout were byte-identical (cmp exit 0). No assert statements disable checks under optimization. + +Checker: 13554 UTF-8 bytes, SHA256 `45325eace87e01c23470676b31728798f029cc6bb5b10600d10c93d63d39c80a`. +Each stdout: 944 UTF-8 bytes, SHA256 `35b833e94d7d06b79dfa6ec35a2ccd7f9c54a358706750a4c7ed7121a256c682`. +The final newline inside each following fence is part of the respective byte identity. + +Controls include negative gamma, raw mixed cubic terms, both Jacobians, finite-r residuals, A1 algebra, inverse-strip primitives, the correlated tolerance union, explicit positive witnesses, full normalization and every exponent. The nonsingular correlated-Gaussian fixture intentionally is NOT the actual field jet law: it rejects reference-independent mixed-moment substitution, not the Gaussian hypotheses of C92. These finite diagnostics do not prove uniform Gaussian estimates, branch measurability, topology or the asymptotic theorem; the analytic derivations and imported source hypotheses above do that work. + +Execution clarification: the earlier failed checker command was the deliberate test-first RED stub that returned an incorrect integral and raised RuntimeError. It was not a runtime/access blocker or a proof finding. That stub was replaced by the independently integrated implementation below; only the actually successful runs are credited. + +## Reproducible independent checker + +```python +"""Independent C94 algebra/inference diagnostics; Python stdlib only. + +No author checker is read. These finite controls do not establish uniform +Gaussian estimates, Borel measurability, or topology. No assert statement is +used: every check remains active with python -O. Fractions give exact arithmetic. +""" + +from fractions import Fraction as F +from itertools import product + + +counts = {} +negative = [] + + +def check(group, condition): + if not condition: + raise RuntimeError("failed control: " + group) + counts[group] = counts.get(group, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError("adverse fixture did not reject: " + name) + negative.append(name) + + +def con(value, n=2): + return {(0,) * n: F(value)} if value else {} + + +def var(index, n=2): + powers = [0] * n + powers[index] = 1 + return {tuple(powers): F(1)} + + +def add(*polys): + result = {} + for poly in polys: + for key, value in poly.items(): + result[key] = result.get(key, F(0)) + value + return {key: value for key, value in result.items() if value} + + +def scale(poly, scalar): + return {key: value * scalar for key, value in poly.items() if value * scalar} + + +def mul(left, right): + result = {} + for a, va in left.items(): + for b, vb in right.items(): + key = tuple(x + y for x, y in zip(a, b)) + result[key] = result.get(key, F(0)) + va * vb + return {key: value for key, value in result.items() if value} + + +def power(poly, exponent, n=2): + result = con(1, n) + for _ in range(exponent): + result = mul(result, poly) + return result + + +def power_integral(exponent, low, high): + if exponent == -1: + raise ValueError("logarithmic integral is not a rational control") + return (high ** (exponent + 1) - low ** (exponent + 1)) / F(exponent + 1) + + +def radius_integral(upper): + # The inner s-integral is 1152 lambda^3, integrated in lambda. + return F(1152) * power_integral(3, F(0), upper) + + +def gaussian_monomial(powers): + moment = F(1) + for exponent in powers: + if exponent % 2: + return F(0) + for odd in range(1, exponent, 2): + moment *= odd + return moment + + +def gaussian_expectation(poly): + return sum((value * gaussian_monomial(key) for key, value in poly.items()), F(0)) + + +def rate_ledger(beta, band_power, moment): + value_power = 1 - 4 * beta + return (8 * beta, 1 + 4 * beta, value_power, + 1 + value_power / 2, band_power, F(1), + moment * (value_power - band_power), 2 - 4 * beta) + + +def run(): + # Literal independently integrated RED fixture, now GREEN. + check("radius-integrals", radius_integral(F(1, 2)) == 18) + x, z = var(0), var(1) + axial = add(scale(power(x, 3), 2), scale(x, -F(3, 2)), con(-F(1, 2))) + gammas = (F(-3, 2), F(-1, 2), F(1, 2), F(3, 2)) + lambdas = (F(1, 16), F(1, 3), F(2)) + bjets = (F(-1, 2), F(0), F(2, 3)) + cjets = (F(-1, 3), F(0), F(5, 4)) + for gamma, lam, bjet, cjet in product(gammas, lambdas, bjets, cjets): + psi = 24 * lam / gamma ** 2 + disc = gamma ** 2 - 12 * bjet + jpoly = 8 * gamma ** 3 - 144 * bjet * gamma + 576 * cjet + c, rjet = disc / gamma ** 2, jpoly / gamma ** 3 + u, zz = add(x, scale(z, gamma / 12)), scale(z, gamma) + transformed = add(scale(power(u, 3), 2), scale(u, -F(3, 2)), + con(-F(1, 2)), + scale(mul(add(con(psi), scale(u, 2 * c)), power(zz, 2)), -F(1, 48)), + scale(power(zz, 3), rjet / 3456)) + raw = add(axial, scale(mul(add(power(x, 2), con(-F(1, 4))), z), gamma / 2), + scale(power(z, 2), -lam / 2), + scale(mul(x, power(z, 2)), bjet / 2), scale(power(z, 3), cjet / 6)) + check("raw-polynomial", transformed == raw) + a_m, a_s = 24 * lam - disc, 24 * lam + disc + check("jacobians-poles", a_m == gamma ** 2 * (psi - c)) + check("jacobians-poles", a_s == gamma ** 2 * (psi + c)) + weight = a_m * a_s / 16 + check("jacobians-poles", weight * gamma ** 2 / 24 == + gamma ** 6 * (psi ** 2 - c ** 2) / 384) + check("jacobians-poles", gamma ** 6 * abs(c) ** 3 == abs(disc) ** 3) + check("jacobians-poles", gamma ** 6 * rjet ** 2 == jpoly ** 2) + step = F(1, 7) + check("jacobians-poles", (24 * lam + gamma ** 2 - 12 * (bjet - step / 12)) - a_s == step) + check("jacobians-poles", (24 * lam - gamma ** 2 + 12 * (bjet + step / 12)) - a_m == step) + + for gamma, sqrtpsi, u, fraction in product( + (F(-3), F(-1, 2), F(1, 4), F(2)), + (F(1, 3), F(1), F(2)), + (F(-5, 4), F(-1, 2), F(1, 2), F(3, 2)), + (F(-1), F(-1, 2), F(0), F(1, 2), F(1))): + zz = 30 * fraction / sqrtpsi + raw_x, raw_z = u - zz / 12, zz / gamma + radius = F(3, 2) + F(5, 2) * (abs(gamma) + 12) / (abs(gamma) * sqrtpsi) + check("raw-box-radius", raw_x ** 2 + raw_z ** 2 <= radius ** 2) + lam = gamma ** 2 * sqrtpsi ** 2 / 24 + h = F(25, 96) * (abs(gamma) + 12) ** 2 + check("raw-box-radius", (radius - F(3, 2)) ** 2 * lam == h) + + for upper, r in product((F(1, 2 ** j) for j in range(1, 10)), (F(1, 1000), F(1, 10), F(1, 2))): + check("radius-integrals", radius_integral(upper) == 288 * upper ** 4) + residual = 48 * r * power_integral(1, F(0), upper) + check("radius-integrals", residual == 24 * r * upper ** 2) + check("radius-integrals", radius_integral(upper) / 12 == 24 * upper ** 4) + check("radius-integrals", residual / 12 == 2 * r * upper ** 2) + inner = ((48 * upper) * power_integral(1, F(0), 48 * upper) + - power_integral(2, F(0), 48 * upper)) / 16 + check("radius-integrals", inner == 1152 * upper ** 3) + + a_squared = F(4, 27) + omega_values = (F(-99, 100), F(-3, 4), F(-1, 2), F(-1, 4), F(0), F(1, 4), F(1, 2)) + for cap, relative_lam, omega, relative_r in product( + (F(1, 20), F(1, 3), F(1), F(5)), + (F(1, 10), F(1, 2), F(1)), omega_values, (F(0), F(1, 2), F(1))): + lam, edge_cap = cap * relative_lam, 48 * cap + s = 24 * lam * (1 + omega) + tau_s_over_a = 1 + 3 * abs(omega) / (1 + omega) + relative_r * (1 - 2 * omega) / (1 + omega) + check("A1-tolerance", tau_s_over_a <= (2 - omega + 3 * abs(omega)) / (1 + omega)) + check("A1-tolerance", tau_s_over_a <= 3 * edge_cap / s) + remaining = 3 - 3 * abs(omega) / (1 - omega) + f_squared = (1 - 2 * omega) ** 2 * (1 + omega) / (1 - omega) ** 3 + check("A1-tolerance", remaining >= 0 and relative_r ** 2 * f_squared <= remaining ** 2) + m_lower = 2 / (125 * a_squared * tau_s_over_a ** 2) + c_star = F(3, 250) / edge_cap ** 2 + check("A1-tolerance", m_lower >= c_star * s ** 2) + check("A1-tolerance", F(27, 512) >= c_star * s ** 2) + check("A1-tolerance", c_star * edge_cap ** 2 == F(3, 250)) + + for cutoff, cap, r in product((F(1, 2 ** j) for j in range(1, 8)), + (F(1), F(2), F(4)), (F(1, 1000), F(1, 10), F(1, 2))): + epsilon = cutoff ** 2 + exact_away = power_integral(-3, cutoff, cap) + r * power_integral(-4, cutoff, cap) + dropped = 1 / (2 * cutoff ** 2) + r / (3 * cutoff ** 3) + check("value-truncation", 0 <= exact_away <= dropped) + cost = cutoff ** 2 + r * cutoff + epsilon ** 2 * exact_away + check("value-truncation", cost <= F(3, 2) * epsilon + F(4, 3) * r * cutoff) + check("value-truncation", cutoff ** 2 + r * cutoff + epsilon ** 2 * dropped == + F(3, 2) * epsilon + F(4, 3) * r * cutoff) + check("value-truncation", power_integral(-3, cap, cap) + r * power_integral(-4, cap, cap) == 0) + for epsilon, norm, s in product((F(1, 128), F(1, 8), F(1, 2)), + (F(1), F(2), F(8)), (F(1, 64), F(1, 4), F(1, 2), F(1))): + bad = int(epsilon * norm >= s ** 2) + check("value-truncation", bad <= epsilon ** 2 * norm ** 2 / s ** 4) + + for v, mu, error, band in product((F(1, 16), F(1, 4), F(1)), + (None, -F(1, 64), -F(1, 4), -F(2)), + (F(0), F(1, 128), F(1, 8), F(1)), + (F(1, 128), F(1, 16), F(1, 4))): + eta = v / 2 if mu is None else min(v, -mu) / 2 + level_bad = mu is not None and error >= -mu / 2 + check("random-margin-union", (error >= eta) == (error >= v / 2 or level_bad)) + near = mu is not None and -2 * band <= mu < 0 + check("random-margin-union", not level_bad or near or error >= band) + check("random-margin-union", eta > 0 and eta < v and (mu is None or eta < -mu)) + + for cap in (F(1, 100), F(1, 10), F(1, 3), F(1), F(10)): + lam, gamma = cap / 2, F(1) + bjet, cjet = (1 + 6 * cap) / 12, (1 + 18 * cap) / 144 + psi, c = 24 * lam, 1 - 12 * bjet + j = 8 - 144 * bjet + 576 * cjet + a_m, a_s = 24 * lam - 1 + 12 * bjet, 24 * lam + 1 - 12 * bjet + check("positive-sector", 0 < lam < cap and a_m == 18 * cap and a_s == 6 * cap) + check("positive-sector", a_m * a_s / 16 == F(27, 4) * cap ** 2) + check("positive-sector", j == 0 and psi > abs(c) and psi > 2 * c) + discriminant = j ** 2 + 64 * c * (psi ** 2 - c ** 2) + check("positive-sector", discriminant == -41472 * cap ** 3 and discriminant < 0) + check("positive-sector", 0 < 16 * (psi - 2 * c) ** 2 * (psi + c)) + + expected = (F(1, 2), F(5, 4), F(3, 4), F(11, 8), F(1, 2), F(1), F(1, 2), F(7, 4)) + ledger = rate_ledger(F(1, 16), F(1, 2), F(2)) + for got, want in zip(ledger, expected): + check("rates-normalization", got == want and 3 + got >= F(7, 2)) + check("rates-normalization", min(ledger) == F(1, 2)) + check("rates-normalization", 1 - F(1, 16) > 0 and 1 - 4 * F(1, 16) > 0) + for r, mass, z in product((F(1, 16), F(1, 64), F(1, 256)), + (F(1, 2), F(2)), (F(3), F(5))): + check("rates-normalization", r ** 5 * mass / (r ** 2 * z) == r ** 3 * mass / z) + # Difference of reciprocals with a positive floor, not a layer normalizer. + check("rates-normalization", abs(1 / (z + r) - 1 / z) <= r / z ** 2) + + # Adverse inference fixtures are explicit mathematical counterexamples, + # not Gaussian claims about this field. The Gaussian fixture below IS + # a nonsingular centered correlated Gaussian, but not the actual jet law. + reject("lost-B1-Jacobian", F(1) == F(1, 12)) + reject("lost-gamma6-Jacobian", F(2) ** 6 / 384 == F(2) ** 4 / 384) + reject("wrong-radius-integration-power", radius_integral(F(1, 2)) == 288 * F(1, 2) ** 3) + r, upper = F(1, 8), F(1, 64) + actual = 288 * upper ** 4 + 24 * r * upper ** 2 + reject("omitted-radius-residual", actual <= 2 * 288 * upper ** 4) + r, edge = F(1, 16), F(1, 4096) + reject("omitted-value-strip-residual", edge ** 2 + r * edge <= 10 * edge ** 2) + # A small L1 perturbation moved to a small margin does not bound inverses. + tv_error, small_margin = F(1, 100), F(1, 10000) + reject("TV-times-unbounded-inverse", tv_error / small_margin <= 10 * tv_error) + cutoff = F(1, 4096) + actual_inverse = power_integral(-2, cutoff, F(1)) + F(1, 16) * power_integral(-3, cutoff, F(1)) + reject("model-inverse-only-at-finite-r", actual_inverse <= 2 * power_integral(-2, cutoff, F(1))) + # Two equiprobable atoms, W=(0,1), N=(1,4). + e_wn2, e_w, e_n2 = F(8), F(1, 2), F(17, 2) + reject("factorized-weighted-norm", e_wn2 == e_w * e_n2) + reject("unweighted-bad-probability", F(1, 2) == e_w * F(1, 2)) + # X,Y,Z independent N(0,1); gamma=X, B=Y, C=X+Z has covariance det=1. + xx, yy, zz = (var(i, 3) for i in range(3)) + j = add(scale(power(xx, 3, 3), 8), scale(mul(xx, yy), -144), scale(add(xx, zz), 576)) + actual_j2 = gaussian_expectation(power(j, 2, 3)) + check("correlated-Gaussian", actual_j2 == 712896) + check("correlated-Gaussian", gaussian_expectation(mul(power(xx, 3, 3), add(xx, zz))) == 3) + reject("independent-reference-cross-terms", actual_j2 == 685248) + # C82 c=0,R=1 has exact coarea density 1/48 in v. On |v|<=1/8, + # width(v)=1/128+2|v| stays <=1/2 and includes the whole interval. + variable_band_mass = F(1, 4) / 48 + fixed_central_width_mass = F(1, 128) / 24 + reject("psi-dependent-band-width", variable_band_mass <= fixed_central_width_mass) + reject("dropped-joint-slice-density", F(2) * F(3, 7) == F(3, 7)) + r, mass, z = F(1, 16), F(2), F(3) + reject("soft-layer-as-full-normalizer", r ** 5 * mass / (r ** 5 * mass) == r ** 3 * mass / z) + reject("global-Good-probability-one", r ** 3 * mass / z == 1) + reject("overclaimed-rate-r4", min(ledger) + 3 >= 4) + reject("unrestricted-window-growth", min(rate_ledger(F(1, 8), F(1, 2), F(2))) > 0) + gamma = F(0) + try: + _ = F(1) / gamma ** 2 + except ZeroDivisionError: + negative.append("pointwise-gamma-zero-chart") + else: + raise RuntimeError("adverse gamma-zero chart did not reject") + + print("C94 independent exact diagnostics") + for group, count in counts.items(): + print(group + ": " + str(count) + " PASS") + print("positive controls: " + str(sum(counts.values()))) + print("false-inference fixtures: " + str(len(negative)) + " REJECTED") + print("negative names: " + ", ".join(negative)) + print("Scope: algebra/inference controls only; Gaussian bounds and conditional G require analytic review.") + + +if __name__ == "__main__": + run() +``` + +## Exact stdout in all three modes + +```text +C94 independent exact diagnostics +radius-integrals: 136 PASS +raw-polynomial: 108 PASS +jacobians-poles: 756 PASS +raw-box-radius: 480 PASS +A1-tolerance: 1512 PASS +value-truncation: 288 PASS +random-margin-union: 432 PASS +positive-sector: 25 PASS +rates-normalization: 34 PASS +correlated-Gaussian: 2 PASS +positive controls: 3773 +false-inference fixtures: 17 REJECTED +negative names: lost-B1-Jacobian, lost-gamma6-Jacobian, wrong-radius-integration-power, omitted-radius-residual, omitted-value-strip-residual, TV-times-unbounded-inverse, model-inverse-only-at-finite-r, factorized-weighted-norm, unweighted-bad-probability, independent-reference-cross-terms, psi-dependent-band-width, dropped-joint-slice-density, soft-layer-as-full-normalizer, global-Good-probability-one, overclaimed-rate-r4, unrestricted-window-growth, pointwise-gamma-zero-chart +Scope: algebra/inference controls only; Gaussian bounds and conditional G require analytic review. +``` + +Review scope RELEASED upon this completed delivery. Author claim41587ec8-08a1-4cbc-8c28-c033273cc412 and author/Drive custody are untouched; A2 and intermediate/coarea ownership are preserved. No incorporation, CI, repository application or merge is claimed. diff --git a/frontiers/planar_soft_layer_chain_20261003/C94/checker.py b/frontiers/planar_soft_layer_chain_20261003/C94/checker.py new file mode 100644 index 000000000..bcf5db6ca --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C94/checker.py @@ -0,0 +1,284 @@ +"""Independent C94 algebra/inference diagnostics; Python stdlib only. + +No author checker is read. These finite controls do not establish uniform +Gaussian estimates, Borel measurability, or topology. No assert statement is +used: every check remains active with python -O. Fractions give exact arithmetic. +""" + +from fractions import Fraction as F +from itertools import product + + +counts = {} +negative = [] + + +def check(group, condition): + if not condition: + raise RuntimeError("failed control: " + group) + counts[group] = counts.get(group, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError("adverse fixture did not reject: " + name) + negative.append(name) + + +def con(value, n=2): + return {(0,) * n: F(value)} if value else {} + + +def var(index, n=2): + powers = [0] * n + powers[index] = 1 + return {tuple(powers): F(1)} + + +def add(*polys): + result = {} + for poly in polys: + for key, value in poly.items(): + result[key] = result.get(key, F(0)) + value + return {key: value for key, value in result.items() if value} + + +def scale(poly, scalar): + return {key: value * scalar for key, value in poly.items() if value * scalar} + + +def mul(left, right): + result = {} + for a, va in left.items(): + for b, vb in right.items(): + key = tuple(x + y for x, y in zip(a, b)) + result[key] = result.get(key, F(0)) + va * vb + return {key: value for key, value in result.items() if value} + + +def power(poly, exponent, n=2): + result = con(1, n) + for _ in range(exponent): + result = mul(result, poly) + return result + + +def power_integral(exponent, low, high): + if exponent == -1: + raise ValueError("logarithmic integral is not a rational control") + return (high ** (exponent + 1) - low ** (exponent + 1)) / F(exponent + 1) + + +def radius_integral(upper): + # The inner s-integral is 1152 lambda^3, integrated in lambda. + return F(1152) * power_integral(3, F(0), upper) + + +def gaussian_monomial(powers): + moment = F(1) + for exponent in powers: + if exponent % 2: + return F(0) + for odd in range(1, exponent, 2): + moment *= odd + return moment + + +def gaussian_expectation(poly): + return sum((value * gaussian_monomial(key) for key, value in poly.items()), F(0)) + + +def rate_ledger(beta, band_power, moment): + value_power = 1 - 4 * beta + return (8 * beta, 1 + 4 * beta, value_power, + 1 + value_power / 2, band_power, F(1), + moment * (value_power - band_power), 2 - 4 * beta) + + +def run(): + # Literal independently integrated RED fixture, now GREEN. + check("radius-integrals", radius_integral(F(1, 2)) == 18) + x, z = var(0), var(1) + axial = add(scale(power(x, 3), 2), scale(x, -F(3, 2)), con(-F(1, 2))) + gammas = (F(-3, 2), F(-1, 2), F(1, 2), F(3, 2)) + lambdas = (F(1, 16), F(1, 3), F(2)) + bjets = (F(-1, 2), F(0), F(2, 3)) + cjets = (F(-1, 3), F(0), F(5, 4)) + for gamma, lam, bjet, cjet in product(gammas, lambdas, bjets, cjets): + psi = 24 * lam / gamma ** 2 + disc = gamma ** 2 - 12 * bjet + jpoly = 8 * gamma ** 3 - 144 * bjet * gamma + 576 * cjet + c, rjet = disc / gamma ** 2, jpoly / gamma ** 3 + u, zz = add(x, scale(z, gamma / 12)), scale(z, gamma) + transformed = add(scale(power(u, 3), 2), scale(u, -F(3, 2)), + con(-F(1, 2)), + scale(mul(add(con(psi), scale(u, 2 * c)), power(zz, 2)), -F(1, 48)), + scale(power(zz, 3), rjet / 3456)) + raw = add(axial, scale(mul(add(power(x, 2), con(-F(1, 4))), z), gamma / 2), + scale(power(z, 2), -lam / 2), + scale(mul(x, power(z, 2)), bjet / 2), scale(power(z, 3), cjet / 6)) + check("raw-polynomial", transformed == raw) + a_m, a_s = 24 * lam - disc, 24 * lam + disc + check("jacobians-poles", a_m == gamma ** 2 * (psi - c)) + check("jacobians-poles", a_s == gamma ** 2 * (psi + c)) + weight = a_m * a_s / 16 + check("jacobians-poles", weight * gamma ** 2 / 24 == + gamma ** 6 * (psi ** 2 - c ** 2) / 384) + check("jacobians-poles", gamma ** 6 * abs(c) ** 3 == abs(disc) ** 3) + check("jacobians-poles", gamma ** 6 * rjet ** 2 == jpoly ** 2) + step = F(1, 7) + check("jacobians-poles", (24 * lam + gamma ** 2 - 12 * (bjet - step / 12)) - a_s == step) + check("jacobians-poles", (24 * lam - gamma ** 2 + 12 * (bjet + step / 12)) - a_m == step) + + for gamma, sqrtpsi, u, fraction in product( + (F(-3), F(-1, 2), F(1, 4), F(2)), + (F(1, 3), F(1), F(2)), + (F(-5, 4), F(-1, 2), F(1, 2), F(3, 2)), + (F(-1), F(-1, 2), F(0), F(1, 2), F(1))): + zz = 30 * fraction / sqrtpsi + raw_x, raw_z = u - zz / 12, zz / gamma + radius = F(3, 2) + F(5, 2) * (abs(gamma) + 12) / (abs(gamma) * sqrtpsi) + check("raw-box-radius", raw_x ** 2 + raw_z ** 2 <= radius ** 2) + lam = gamma ** 2 * sqrtpsi ** 2 / 24 + h = F(25, 96) * (abs(gamma) + 12) ** 2 + check("raw-box-radius", (radius - F(3, 2)) ** 2 * lam == h) + + for upper, r in product((F(1, 2 ** j) for j in range(1, 10)), (F(1, 1000), F(1, 10), F(1, 2))): + check("radius-integrals", radius_integral(upper) == 288 * upper ** 4) + residual = 48 * r * power_integral(1, F(0), upper) + check("radius-integrals", residual == 24 * r * upper ** 2) + check("radius-integrals", radius_integral(upper) / 12 == 24 * upper ** 4) + check("radius-integrals", residual / 12 == 2 * r * upper ** 2) + inner = ((48 * upper) * power_integral(1, F(0), 48 * upper) + - power_integral(2, F(0), 48 * upper)) / 16 + check("radius-integrals", inner == 1152 * upper ** 3) + + a_squared = F(4, 27) + omega_values = (F(-99, 100), F(-3, 4), F(-1, 2), F(-1, 4), F(0), F(1, 4), F(1, 2)) + for cap, relative_lam, omega, relative_r in product( + (F(1, 20), F(1, 3), F(1), F(5)), + (F(1, 10), F(1, 2), F(1)), omega_values, (F(0), F(1, 2), F(1))): + lam, edge_cap = cap * relative_lam, 48 * cap + s = 24 * lam * (1 + omega) + tau_s_over_a = 1 + 3 * abs(omega) / (1 + omega) + relative_r * (1 - 2 * omega) / (1 + omega) + check("A1-tolerance", tau_s_over_a <= (2 - omega + 3 * abs(omega)) / (1 + omega)) + check("A1-tolerance", tau_s_over_a <= 3 * edge_cap / s) + remaining = 3 - 3 * abs(omega) / (1 - omega) + f_squared = (1 - 2 * omega) ** 2 * (1 + omega) / (1 - omega) ** 3 + check("A1-tolerance", remaining >= 0 and relative_r ** 2 * f_squared <= remaining ** 2) + m_lower = 2 / (125 * a_squared * tau_s_over_a ** 2) + c_star = F(3, 250) / edge_cap ** 2 + check("A1-tolerance", m_lower >= c_star * s ** 2) + check("A1-tolerance", F(27, 512) >= c_star * s ** 2) + check("A1-tolerance", c_star * edge_cap ** 2 == F(3, 250)) + + for cutoff, cap, r in product((F(1, 2 ** j) for j in range(1, 8)), + (F(1), F(2), F(4)), (F(1, 1000), F(1, 10), F(1, 2))): + epsilon = cutoff ** 2 + exact_away = power_integral(-3, cutoff, cap) + r * power_integral(-4, cutoff, cap) + dropped = 1 / (2 * cutoff ** 2) + r / (3 * cutoff ** 3) + check("value-truncation", 0 <= exact_away <= dropped) + cost = cutoff ** 2 + r * cutoff + epsilon ** 2 * exact_away + check("value-truncation", cost <= F(3, 2) * epsilon + F(4, 3) * r * cutoff) + check("value-truncation", cutoff ** 2 + r * cutoff + epsilon ** 2 * dropped == + F(3, 2) * epsilon + F(4, 3) * r * cutoff) + check("value-truncation", power_integral(-3, cap, cap) + r * power_integral(-4, cap, cap) == 0) + for epsilon, norm, s in product((F(1, 128), F(1, 8), F(1, 2)), + (F(1), F(2), F(8)), (F(1, 64), F(1, 4), F(1, 2), F(1))): + bad = int(epsilon * norm >= s ** 2) + check("value-truncation", bad <= epsilon ** 2 * norm ** 2 / s ** 4) + + for v, mu, error, band in product((F(1, 16), F(1, 4), F(1)), + (None, -F(1, 64), -F(1, 4), -F(2)), + (F(0), F(1, 128), F(1, 8), F(1)), + (F(1, 128), F(1, 16), F(1, 4))): + eta = v / 2 if mu is None else min(v, -mu) / 2 + level_bad = mu is not None and error >= -mu / 2 + check("random-margin-union", (error >= eta) == (error >= v / 2 or level_bad)) + near = mu is not None and -2 * band <= mu < 0 + check("random-margin-union", not level_bad or near or error >= band) + check("random-margin-union", eta > 0 and eta < v and (mu is None or eta < -mu)) + + for cap in (F(1, 100), F(1, 10), F(1, 3), F(1), F(10)): + lam, gamma = cap / 2, F(1) + bjet, cjet = (1 + 6 * cap) / 12, (1 + 18 * cap) / 144 + psi, c = 24 * lam, 1 - 12 * bjet + j = 8 - 144 * bjet + 576 * cjet + a_m, a_s = 24 * lam - 1 + 12 * bjet, 24 * lam + 1 - 12 * bjet + check("positive-sector", 0 < lam < cap and a_m == 18 * cap and a_s == 6 * cap) + check("positive-sector", a_m * a_s / 16 == F(27, 4) * cap ** 2) + check("positive-sector", j == 0 and psi > abs(c) and psi > 2 * c) + discriminant = j ** 2 + 64 * c * (psi ** 2 - c ** 2) + check("positive-sector", discriminant == -41472 * cap ** 3 and discriminant < 0) + check("positive-sector", 0 < 16 * (psi - 2 * c) ** 2 * (psi + c)) + + expected = (F(1, 2), F(5, 4), F(3, 4), F(11, 8), F(1, 2), F(1), F(1, 2), F(7, 4)) + ledger = rate_ledger(F(1, 16), F(1, 2), F(2)) + for got, want in zip(ledger, expected): + check("rates-normalization", got == want and 3 + got >= F(7, 2)) + check("rates-normalization", min(ledger) == F(1, 2)) + check("rates-normalization", 1 - F(1, 16) > 0 and 1 - 4 * F(1, 16) > 0) + for r, mass, z in product((F(1, 16), F(1, 64), F(1, 256)), + (F(1, 2), F(2)), (F(3), F(5))): + check("rates-normalization", r ** 5 * mass / (r ** 2 * z) == r ** 3 * mass / z) + # Difference of reciprocals with a positive floor, not a layer normalizer. + check("rates-normalization", abs(1 / (z + r) - 1 / z) <= r / z ** 2) + + # Adverse inference fixtures are explicit mathematical counterexamples, + # not Gaussian claims about this field. The Gaussian fixture below IS + # a nonsingular centered correlated Gaussian, but not the actual jet law. + reject("lost-B1-Jacobian", F(1) == F(1, 12)) + reject("lost-gamma6-Jacobian", F(2) ** 6 / 384 == F(2) ** 4 / 384) + reject("wrong-radius-integration-power", radius_integral(F(1, 2)) == 288 * F(1, 2) ** 3) + r, upper = F(1, 8), F(1, 64) + actual = 288 * upper ** 4 + 24 * r * upper ** 2 + reject("omitted-radius-residual", actual <= 2 * 288 * upper ** 4) + r, edge = F(1, 16), F(1, 4096) + reject("omitted-value-strip-residual", edge ** 2 + r * edge <= 10 * edge ** 2) + # A small L1 perturbation moved to a small margin does not bound inverses. + tv_error, small_margin = F(1, 100), F(1, 10000) + reject("TV-times-unbounded-inverse", tv_error / small_margin <= 10 * tv_error) + cutoff = F(1, 4096) + actual_inverse = power_integral(-2, cutoff, F(1)) + F(1, 16) * power_integral(-3, cutoff, F(1)) + reject("model-inverse-only-at-finite-r", actual_inverse <= 2 * power_integral(-2, cutoff, F(1))) + # Two equiprobable atoms, W=(0,1), N=(1,4). + e_wn2, e_w, e_n2 = F(8), F(1, 2), F(17, 2) + reject("factorized-weighted-norm", e_wn2 == e_w * e_n2) + reject("unweighted-bad-probability", F(1, 2) == e_w * F(1, 2)) + # X,Y,Z independent N(0,1); gamma=X, B=Y, C=X+Z has covariance det=1. + xx, yy, zz = (var(i, 3) for i in range(3)) + j = add(scale(power(xx, 3, 3), 8), scale(mul(xx, yy), -144), scale(add(xx, zz), 576)) + actual_j2 = gaussian_expectation(power(j, 2, 3)) + check("correlated-Gaussian", actual_j2 == 712896) + check("correlated-Gaussian", gaussian_expectation(mul(power(xx, 3, 3), add(xx, zz))) == 3) + reject("independent-reference-cross-terms", actual_j2 == 685248) + # C82 c=0,R=1 has exact coarea density 1/48 in v. On |v|<=1/8, + # width(v)=1/128+2|v| stays <=1/2 and includes the whole interval. + variable_band_mass = F(1, 4) / 48 + fixed_central_width_mass = F(1, 128) / 24 + reject("psi-dependent-band-width", variable_band_mass <= fixed_central_width_mass) + reject("dropped-joint-slice-density", F(2) * F(3, 7) == F(3, 7)) + r, mass, z = F(1, 16), F(2), F(3) + reject("soft-layer-as-full-normalizer", r ** 5 * mass / (r ** 5 * mass) == r ** 3 * mass / z) + reject("global-Good-probability-one", r ** 3 * mass / z == 1) + reject("overclaimed-rate-r4", min(ledger) + 3 >= 4) + reject("unrestricted-window-growth", min(rate_ledger(F(1, 8), F(1, 2), F(2))) > 0) + gamma = F(0) + try: + _ = F(1) / gamma ** 2 + except ZeroDivisionError: + negative.append("pointwise-gamma-zero-chart") + else: + raise RuntimeError("adverse gamma-zero chart did not reject") + + print("C94 independent exact diagnostics") + for group, count in counts.items(): + print(group + ": " + str(count) + " PASS") + print("positive controls: " + str(sum(counts.values()))) + print("false-inference fixtures: " + str(len(negative)) + " REJECTED") + print("negative names: " + ", ".join(negative)) + print("Scope: algebra/inference controls only; Gaussian bounds and conditional G require analytic review.") + + +if __name__ == "__main__": + run() diff --git a/frontiers/planar_soft_layer_chain_20261003/C94/checker_stdout.txt b/frontiers/planar_soft_layer_chain_20261003/C94/checker_stdout.txt new file mode 100644 index 000000000..c3560d233 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C94/checker_stdout.txt @@ -0,0 +1,15 @@ +C94 independent exact diagnostics +radius-integrals: 136 PASS +raw-polynomial: 108 PASS +jacobians-poles: 756 PASS +raw-box-radius: 480 PASS +A1-tolerance: 1512 PASS +value-truncation: 288 PASS +random-margin-union: 432 PASS +positive-sector: 25 PASS +rates-normalization: 34 PASS +correlated-Gaussian: 2 PASS +positive controls: 3773 +false-inference fixtures: 17 REJECTED +negative names: lost-B1-Jacobian, lost-gamma6-Jacobian, wrong-radius-integration-power, omitted-radius-residual, omitted-value-strip-residual, TV-times-unbounded-inverse, model-inverse-only-at-finite-r, factorized-weighted-norm, unweighted-bad-probability, independent-reference-cross-terms, psi-dependent-band-width, dropped-joint-slice-density, soft-layer-as-full-normalizer, global-Good-probability-one, overclaimed-rate-r4, unrestricted-window-growth, pointwise-gamma-zero-chart +Scope: algebra/inference controls only; Gaussian bounds and conditional G require analytic review. diff --git a/frontiers/planar_soft_layer_chain_20261003/C95/CHECKER_COMMENT.md b/frontiers/planar_soft_layer_chain_20261003/C95/CHECKER_COMMENT.md new file mode 100644 index 000000000..034f16f65 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C95/CHECKER_COMMENT.md @@ -0,0 +1,318 @@ +# C95 fresh helper's independent controls — complete source and exact stdout + +This accompanies the [full named mathematical review5965062739](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965062739) by OpenAI/Codex `/root/c95_fresh_review`. It is not another review or acceptance vote. The coordinating root only relays/verifies publication artifacts and receives zero C95 mathematical acceptance credit. + +Target: C95 native5964938563, 16185 UTF-8 bytes, SHA256 `c0d9ee72352fafe91f96a8b6187c978f09ee3c187d5f4c7c2462c0187750d2e1`. +Full helper review: 25080 UTF-8 bytes, SHA256 `350be6dc7699b7fc377074e1217937ceb53022f2de5d3cdb9c85f499d35bcaf6`; exact native readback verified. + +The helper independently authored the following Python-standard-library checker without C95 author code or prior-checker reuse. Actual Python3.12.14 normal, `-O` and `-S` runs each exited0, with9270 positive exact controls and22 rejected false-inference fixtures; stdout was byte-identical. These are repeated runs of one suite, not independent votes. Coordinator replay of the supplied artifact in the same three modes matched the code/output identities and counts; that is execution/custody verification, not independent mathematical authorship. + +Checker10566 UTF-8 bytes, SHA256 `179d64b556b337ddf966ba5f4f274d59910a6c045a242b26fff957f3167951d2`. +Each stdout1691 UTF-8 bytes, SHA256 `484e9d61c77fcd6394ad97cae20e628e4ccb6c3163d7ff900fdd4ee0836c37f5`. +The final newline inside each fence is included in these identities. Explicit checks survive optimization. + +## Complete independently authored checker + +```python +"""Fresh C95 exact diagnostic. Stdlib only; no imported proof/checker files. + +This does not prove compact separation, covering-space lifting, Gaussian +estimates, or uniform asymptotic assertions. Those require written reasoning. +Checks deliberately raise exceptions rather than using optimizable asserts. +""" +from fractions import Fraction as Q +from itertools import product + +counts = {} +rejections = [] + + +def check(section, condition): + if not condition: + raise RuntimeError('failed exact control: ' + section) + counts[section] = counts.get(section, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError('false inference escaped: ' + name) + rejections.append(name) + + +def A(u): + return 2 * (u + Q(1, 2)) ** 2 * (u - 1) + + +def P(u, z, psi, c, R): + return A(u) - (psi + 2*c*u)*z*z/48 + R*z**3/3456 + + +def derivatives(u, z, psi, c, R): + pu = 6*u*u-Q(3, 2)-c*z*z/24 + pz = -(psi+2*c*u)*z/24+R*z*z/1152 + huu, huz, hzz = 12*u, -c*z/12, -(psi+2*c*u)/24+R*z/576 + return pu, pz, huu, huz, hzz + + +def raw(X, z, lam, gamma, B, C): + return (2*X**3-Q(3, 2)*X-Q(1, 2) + +gamma*(X*X-Q(1, 4))*z/2-lam*z*z/2+B*X*z*z/2+C*z**3/6) + + +def mass(a, x): + return Q(0) if x <= a else x**3/3-a*a*x+2*a**3/3 + + +a0, b0, k0 = Q(599,250), Q(277,250), Q(256,125) +K = b0+k0*a0 +switch = a0/K +check('G1-G3 constants', K == Q(187969,31250)) +check('G1-G3 constants', switch == Q(74875,187969)) +check('G1-G3 constants', 1-k0*switch == b0/K == Q(34625,187969)) +check('G1-G3 constants', 0 < switch < 1/k0 < Q(1,2)) +check('G1-G3 constants', 3*Q(128,125)**2-Q(3,4) == Q(149733,62500) < a0) +check('G1-G3 constants', K < Q(121,20)) +check('G1-G3 constants', 144*Q(121,20) < Q(148,5)**2 < 30**2) +check('G1-G3 constants', 48*Q(121,20) < Q(171,10)**2) +for n in range(1,1000): + omega = Q(n,2000) + if omega <= switch: + check('piecewise bound', 1-k0*omega > 0) + check('piecewise bound', b0/(1-k0*omega) <= K) + else: + check('piecewise bound', a0/omega <= K) + check('piecewise bound', a0/omega > 0) +reject('unsafe reciprocal at 49/100', b0/(1-k0*Q(49,100)) >= 0) +reject('reciprocal defined at 125/256', 1-k0*Q(125,256) != 0) +check('old-domain witnesses', 1-k0*Q(49,100) == Q(-11,3125)) +# Independent admissibility of the unsafe-domain point at R=0. +c, psi, eta = Q(49,100), Q(1), Q(1,1000) +uc = -psi/(2*c) +mu = A(uc)+1 +tau_s_sq = Q(4,27)*(1+3*c/(psi+c))**2 +tau_m_sq = Q(4,27)*(1+3*c/(psi-c))**2 +check('old-domain witnesses', 0 < eta < min(-mu,Q(2,125)/tau_s_sq,Q(1,8)/tau_m_sq,1)) +reject('literal old minimum bounds F(M)', min(a0/c,b0/(1-k0*c)) >= 1+eta) + +m = Q(1,1000) +check('sharpness admissibility', 64 < 75) # 8/(6 sqrt(3)) < 5/6 +check('sharpness admissibility', Q(72,3125)>m and Q(9,50)>m) +previous = Q(0) +for n in range(100,500): + t = 1-Q(1,n) + H = 3*t*t-2*t**3 + eta = (1+m)*H-1 + height_sq = 144*t*t*(1+m)/(1+eta) + check('G4-G6 first root', 0 < eta < m and 0 < t < 1) + check('G4-G6 first root', 6*t*(1-t)>0) + check('G4-G6 first root', height_sq == 144/(3-2*t) < 144) + check('G4-G6 first root', height_sq > previous) + previous = height_sq + # The scaled restriction substitutes Z=t Zs, R Zs=48, + # Zs^2=144(1+m), without numerically approximating a radical. + restricted = -Q(3)*(1+m)*t*t+2*(1+m)*t**3 + check('G4-G6 first root', restricted == -1-eta) + check('G4-G6 first root', -(1+m) < -1-eta) +reject('saddle belongs to strict trap', -(1+m)>-1-m/2) +reject('universal sharp constant 11', previous <= 11**2) +q = Q(11999,1000) +t = 1-Q(1,1000000) +reject('universal sharp constant 11.999', 144/(3-2*t) <= q*q) + +for a, x in product([Q(i,3) for i in range(10)], [Q(i,7) for i in range(1,40)]): + value = mass(a,x) + check('G7-G8 typed integral', 0 <= value <= x**3/3) + check('G7-G8 typed integral', value == (0 if x<=a else (x-a)**2*(x+2*a)/3)) + if x>a: + primitive = lambda v: v**3/3-a*a*v + check('G7-G8 typed integral', value == primitive(x)-primitive(a)) +for gamma, rho, a in product([Q(-3),Q(-1,2),Q(1,10),Q(2)], [Q(1,3),Q(2),Q(7)], [Q(0),Q(1),Q(100)]): + x = 25*(abs(gamma)+12)**2/(4*gamma*gamma*rho*rho) + bound = Q(25,4)**3*(abs(gamma)+12)**6/(3*rho**6) + check('G7-G8 cancellation', gamma**6*x**3/3 == bound) + check('G7-G8 cancellation', gamma**6*mass(a,x)<=bound) +reject('reversed primitive equals empty integral', mass(Q(2),Q(1)) == Q(1,3)-4+Q(16,3)) +gamma, rho = Q(1,10), Q(1) +x = 25*(gamma+12)**2/(4*gamma*gamma) +reject('omit gamma-six weight cancellation', x**3/3 <= Q(25,4)**3*(gamma+12)**6/3) + +# Exact rational substitutions exercise the polynomial identities without +# numerical tolerances. Their universal proof is the written derivation. +for u,z,psi,c,R in product([Q(-2),Q(-1,2),Q(1,2),Q(3,2)], + [Q(-3),Q(0),Q(2)], [Q(2)], [Q(-1),Q(0),Q(1)], [Q(-4),Q(0),Q(5)]): + theta=psi+2*c*u + pu,pz,huu,huz,hzz=derivatives(u,z,psi,c,R) + check('retained cubic identities', pz==z*(R*z-48*theta)/1152) + check('retained cubic identities', P(u,z,psi,c,R)-A(u)+theta*z*z/144 == z*z*(R*z-48*theta)/3456) + check('retained cubic identities', P(u,z,psi,c,R)-A(u)+theta*z*z/48 == R*z**3/3456) + check('axis identity', A(u)+1 == 2*(u-Q(1,2))**2*(u+1)) + if R: + zl=48*theta/R + pu,pz,huu,huz,hzz=derivatives(u,zl,psi,c,R) + phi2=12*u-384*c*c*theta/(R*R) + check('critical-line identity', P(u,zl,psi,c,R)==A(u)-16*theta**3/R**2) + check('critical-line identity', phi2*hzz==huu*hzz-huz*huz) + +for sigma,z in product([Q(-2),Q(-1),Q(-1,2),Q(0),Q(1),Q(2)], [Q(-12),Q(6),Q(24)]): + c=36*(sigma*sigma-1)/(z*z) + psi=abs(c)+1 + R=48*(psi-c*sigma)/z + u=-sigma/2 + pu,pz,huu,huz,hzz=derivatives(u,z,psi,c,R) + check('CUB guarded extras', pu==pz==0) + check('CUB guarded extras', P(u,z,psi,c,R)==(sigma-1)/2-psi*z*z/144) + det=huu*hzz-huz*huz + check('CUB guarded extras', det==(c-sigma*psi)/4) + if det>0: + check('CUB guarded extras', sigma<0 and huu>0) + +for n in range(-199,200): + om=Q(n,200) + for sign in [-1,1]: + numerator=1+sign*om + denominator=1+sign*om+3*abs(om) + check('ellipse box ratios', numerator>0 and denominator>0) + check('ellipse box ratios', numerator<=denominator**2) +check('ellipse box constants', Q(27,100)/3==Q(3,10)**2) +check('ellipse box constants', Q(27,16)/3==Q(3,4)**2) +check('ellipse box constants', 48*Q(27,100)==Q(324,25) and 48*Q(27,16)==81) +check('ellipse box constants', -1-Q(2,9)*Q(27,250)>Q(-5,4)) + +for gamma,B,C,lam in product([Q(-2),Q(-1,3),Q(1,2),Q(3)], [Q(-1),Q(1,12)], [Q(-2),Q(0),Q(1)], [Q(1,4),Q(2)]): + psi=24*lam/gamma**2 + c=(gamma**2-12*B)/gamma**2 + R=(8*gamma**3-144*B*gamma+576*C)/gamma**3 + for X,z in product([Q(-1),Q(0),Q(3,2)], [Q(-2),Q(0),Q(1)]): + check('actual raw identity', raw(X,z,lam,gamma,B,C)==P(X+gamma*z/12,gamma*z,psi,c,R)) + aM,aS=24*lam-gamma**2+12*B,24*lam+gamma**2-12*B + check('actual typing algebra', aM+aS==48*lam) + check('actual typing algebra', gamma**2*(psi-c)==aM and gamma**2*(psi+c)==aS) + if aM>0 and aS>0: + for ai in [aM,aS]: + kappa=ai/(48*gamma**2) + check('Hessian transfer', Q(1,3)+(Q(1,144)+1/gamma**2)/kappa==Q(1,3)*(1+(gamma**2+144)/ai)) + check('joint-density Jacobian', (aM*aS/16)*(gamma**2/24)==gamma**6*(psi**2-c**2)/384) +reject('pointwise chart at gamma zero', Q(0)!=0) + +# Path-value fixtures test scaling, not planar separation or path lifting. +paths = [[Q(0),Q(-1),Q(4)], [Q(0),Q(-2),Q(3)], [Q(0),Q(-3,2),Q(2)]] +dg=max(map(min,paths)) +for b,r in product([Q(-4),Q(0),Q(5,2)],[Q(1,16),Q(1,3),Q(2)]): + transformed=[[b+r**3*v for v in p] for p in paths] + check('positive affine maximin', max(map(min,transformed))==b+r**3*dg) + check('positive affine maximin', all(p[-1]>b for p in transformed)) +reject('negative scale preserves maximin', max(min(-v for v in p) for p in paths)==-dg) +reject('drop higher-endpoint restriction', max(dg,Q(0))==dg) +for gap in [Q(1,100),Q(1,3),Q(2)]: + eps=gap/3 + check('strict witness robustness', gap-eps>0) + +for Lambda in [Q(1,100),Q(1,3),Q(1),Q(12)]: + lam=Lambda/2; gamma=Q(1); B=(1+6*Lambda)/12; C=(1+18*Lambda)/144 + J=8*gamma**3-144*B*gamma+576*C + psi,c=24*lam,1-12*B + aM,aS=24*lam-gamma**2+12*B,24*lam+gamma**2-12*B + check('positive sector witness', J==0 and psi==12*Lambda and c==-6*Lambda) + check('positive sector witness', aM==18*Lambda and aS==6*Lambda) + check('positive sector witness', 64*c*(psi**2-c**2)==-41472*Lambda**3<0) + check('positive sector witness', 0abs(c) and psi>2*c) + check('positive sector witness', aM*aS/16==Q(27,4)*Lambda**2>0) + astar=48*Lambda + cstar=Q(3,250)/astar**2 + check('tolerance floor', cstar*astar**2==Q(3,250)0) +for r in [Q(1,16),Q(1,64),Q(1,256)]: + z0=Q(2); zr=z0+r; sector_mass=Q(3,7) + unweighted_numerator=r**5*sector_mass + fullZ=r*r*zr + probability=unweighted_numerator/fullZ + check('full actual normalization', probability==r**3*sector_mass/zr) + check('full actual normalization', abs(probability-r**3*sector_mass/z0)<=r**4*sector_mass/(z0*z0)) + fail=r**4*sector_mass/(2*zr) + check('event subtraction', (probability-fail)/probability==1-r/2) + reject('restricted normalizer at r='+str(r), unweighted_numerator/unweighted_numerator==probability) + reject('omit full normalizer r-square at r='+str(r), unweighted_numerator/zr==probability) +reject('r4 dominates r7/2', Q(1,256)**4 >= Q(1,256)**3*Q(1,16)) +r=Q(1,256); rho=Q(256) +reject('discard actual radius residual', r*rho**-4 <= rho**-8) +sector=r**4; fail=sector/2 +check('uniform positivity obstruction', fail<=r**3*Q(1,16)) +reject('conditional convergence without sector floor', fail/sector <= Q(1,16)) +reject('unconditional good probability tends to one', r**3*Q(3,7)/(2+r)>Q(1,2)) +reject('growing Lambda inherits fixed constants', (1/r)**8*r**Q(1,1) < 1) + +print('C95 fresh stdlib exact controls') +for name in sorted(counts): + print(name + ': ' + str(counts[name])) +print('positive controls: ' + str(sum(counts.values()))) +print('false-inference controls rejected: ' + str(len(rejections))) +for name in rejections: + print('REJECT ' + name) +print('No finite-control claim proves topology, Gaussian inputs, or uniform limits.') +``` + +## Exact stdout in all three modes + +```text +C95 fresh stdlib exact controls +CUB guarded extras: 63 +G1-G3 constants: 8 +G4-G6 first root: 2400 +G7-G8 cancellation: 72 +G7-G8 typed integral: 1068 +Hessian transfer: 66 +actual raw identity: 432 +actual typing algebra: 96 +axis identity: 108 +critical-line identity: 144 +ellipse box constants: 4 +ellipse box ratios: 1596 +event subtraction: 3 +full actual normalization: 6 +joint-density Jacobian: 33 +old-domain witnesses: 2 +piecewise bound: 2794 +positive affine maximin: 18 +positive sector witness: 20 +rate ledger: 3 +retained cubic identities: 324 +sharpness admissibility: 2 +strict witness robustness: 3 +tolerance floor: 4 +uniform positivity obstruction: 1 +positive controls: 9270 +false-inference controls rejected: 22 +REJECT unsafe reciprocal at 49/100 +REJECT reciprocal defined at 125/256 +REJECT literal old minimum bounds F(M) +REJECT saddle belongs to strict trap +REJECT universal sharp constant 11 +REJECT universal sharp constant 11.999 +REJECT reversed primitive equals empty integral +REJECT omit gamma-six weight cancellation +REJECT pointwise chart at gamma zero +REJECT negative scale preserves maximin +REJECT drop higher-endpoint restriction +REJECT restricted normalizer at r=1/16 +REJECT omit full normalizer r-square at r=1/16 +REJECT restricted normalizer at r=1/64 +REJECT omit full normalizer r-square at r=1/64 +REJECT restricted normalizer at r=1/256 +REJECT omit full normalizer r-square at r=1/256 +REJECT r4 dominates r7/2 +REJECT discard actual radius residual +REJECT conditional convergence without sector floor +REJECT unconditional good probability tends to one +REJECT growing Lambda inherits fixed constants +No finite-control claim proves topology, Gaussian inputs, or uniform limits. +``` + +Finite controls do not prove topology, Gaussian estimates, path lifting or uniform limits; the named helper's written argument and retained source hypotheses supply those premises. Original A2v1 remains AMEND. The complete G1–G18 technical verdict does not identify an H0 persistence event, all-bar converse, rejected-side/chord, regional collision, intermediate/coarea or global density/remainder. + +The distinct review pickup5964966168 is COMPLETE/RELEASED with this paired substantive delivery. Author claim `f4597887-706f-4b57-b493-475875214c5f` / WE623 is untouched. Same-provider organizational independence0; Dylan personal reading PENDING; scientific effect NONE. No branch/source edit, incorporation, CI, merge, formal or human acceptance is claimed. diff --git a/frontiers/planar_soft_layer_chain_20261003/C95/DELIVERY.md b/frontiers/planar_soft_layer_chain_20261003/C95/DELIVERY.md new file mode 100644 index 000000000..da2fc56fd --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C95/DELIVERY.md @@ -0,0 +1,21 @@ +## C95 completed: corrected trap and actual weighted maximin selection + +The [exact frozen C95 proof](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964938563) has received [fresh full nonauthor PASS for G1–G18](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965062739), under the retained local and analytic premises, with no required amendment. The accepted corrected object is **(A2v1, C95 sections 1–3)** with section 4's hypotheses. The literal original A2v1 remains AMEND; Claude's original authorship and the C90 repair provenance are preserved. + +The correction fixes the reciprocal domain, the sharpness segment's endpoint and the empty typed integration interval. It supplies the geometric G that C94's section 6 previously assumed. For the actual weighted Gaussian law, let A_r mean that the path maximin from the pinned maximum to a higher point equals the pinned saddle height. On the stated sector E: + +- Q_r^W(E minus A_r) <= C r^(7/2); +- Q_r^W(E intersect A_r) = r^3 m_E/z0 + O(r^(7/2)); +- Q_r^W(A_r | E) = 1 - O(sqrt(r)). + +Scope remains d=2, k=1, fixed finite L, compact birth heights, all frames and fixed finite Lambda. The full normalizer Z_r is retained. This is conditional success within a rare sector of mass order r^3, not an unconditional success probability tending to one. No all-bars converse, rejected-side chord, unbounded-stratum/all-mark, regional collision or coarea closure is inferred. + +**Verification and handoff.** Author: 7,644 exact controls and eight rejected mutants. Fresh reviewer: 9,270 controls and 22 rejected false inferences; [complete source and stdout](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965068742). Reviewer code/output replayed exactly under Python 3.11.16 in normal, -O, -S and combined modes, matching original Python 3.12.14 output. Final stable-packet verification PASS. These controls support algebra/custody; written proofs and retained premises carry the analytic conclusions. + +[Single registered Drive delivery](https://drive.google.com/file/d/1vhTNN6Vt704KNFK6-NdJQAv5WpYwWHR5/view): 590,587 bytes, 44 payloads, SHA256 `dc9a797240a592abf4c8a17b579b153f3af1adaf3a619a33ce1b252443d31c03`. Downloaded bytes are identical; canonical manifest/handoff verification passed; permissions remain owner-only. Artifact Index889, Evidence Lineage611, Review Queue158 and Work Events624 publication/625 release all have exact full CellData readback. Claim `f4597887-706f-4b57-b493-475875214c5f` is RELEASED at 2026-10-03T03:34:30Z. This is native proof publication and registered delivery, not a repository commit, CI run or merge. + +**Next action and whole-project correction.** Before writing new genericity mathematics, consume retained parent P section 8 with its E1/E2 repairs and reconciliation: it already provides fixed-pin Morse/distinct critical values and the ordinary elder maximin interface. The next bounded target is the precise finite ordinary superlevel H0 corollary. State that M is the younger birth maximum whose component dies; do not substitute branch adjacency or infer a converse for all short bars. + +The [current proof-index snapshot](https://github.com/d6g8k5htny-coder/Math-/blob/7e2344166e989ae94e5732e445f445598fc75c4c/PROOF_INDEX.md) already records scoped D1 lifetime and D2 bounded-remainder acceptance. C95 refines a rare soft sector; it is not the first leading-law proof. Regional collision remains separately open. A final-theorem DAG should identify actual dependency edges, rather than assume every historical open regional target is required for every accepted theorem. The delivery's PERSPECTIVE_AUDIT and NEXT_SOURCE_AUDIT preserve the exact read-only evidence; no status/GRAPH transition is made here. + +Credit: Dylan Roy — delegated AI work/review. OpenAI/Codex root01a0bbb5 integrated corrections and authored the composition. Fresh mathematical reviewer /root/c95_fresh_review had no preassignment C90–C94 authorship/feasibility and disclosed source exposure. Coordinator root01a0adb2 provided custody/publication only, zero C95 mathematical acceptance credit. Requested reviewer routing gpt-6-astra/high; exact runtime variant UNKNOWN. Dylan personal reading PENDING; independent human review NONE; organizational independence 0; scientific effect NONE. \ No newline at end of file diff --git a/frontiers/planar_soft_layer_chain_20261003/C95/PROOF.md b/frontiers/planar_soft_layer_chain_20261003/C95/PROOF.md new file mode 100644 index 000000000..25faf4127 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C95/PROOF.md @@ -0,0 +1,336 @@ +# Corrected explicit trap and actual weighted maximin selection + +Object: C95-CORRECTED-TRAP-WEIGHTED-MAXIMIN-20261003-v1. +Integrator and author of the composition: OpenAI/Codex root01a0bbb5, +acting for Dylan Roy — delegated AI work. Original A2 author: Anthropic +Claude, session_01NMeKEismAyeqgdB4sy2NJU. The three corrections were +proposed in the C90 OpenAI/Codex reviews; they are not claimed as a new +discovery by this integrator. Disposition: frozen candidate for fresh +nonauthor review. Personal reading PENDING; organizational independence0; +scientific effect NONE. + +This is an additive correction to a named source, followed by a new explicit +composition with C94. The literal original A2v1 remains AMEND. No original +source is overwritten, and this does not impersonate a Claude-issued v2. +The corrected mathematical object is the ordered pair (A2v1, sections1–3 +below), together with the retained hypotheses recorded in section4. The +source's old numerical-check reports remain historical author reports; +they are not new verification evidence or substitutes for these repairs. + +## 0. Exact sources and role + +- A2v1: main229 comment5963200491, 24223 UTF-8 bytes, SHA256 + d5f1f1f0e5d39602d012591ffadb5f3b4caa3f2ad564bc89c8c9f13d4189a9fd. +- C90 combined review: comment5963477339, 4817B, SHA256 + 9f4958107d26dea94240be94a801c13ae76d0658f6548ffb8ea88fa6f4e55c42. + Its complementary slices are comments5963376279 and5963452713. +- QS: comment5961415030, 37032B, SHA256 + 12ffa126e45253fea5eec47f50ffa842a61165a2cbc0f5917e3543e81c09c1f2. + We use its explicit local polynomial bounds, not its older implicit + global-flow trap construction. +- CUB: blob bb446d08db8a944537a743ad550b88c1c2ad5758, 19889B, + SHA256117e9299a71e6139270266889eb772ed97518e402d9af029bbdb67caf9d4a0f0; + only the extra-critical-point identities C7–C8 are consumed. +- C94: comment5964517708, 15407B, SHA256 + 0fe4fa2028f8ddbbf5a79df3879bcbd3789f19409fb44ad739caeabedff1af3c; + full review5964735560, 30074B, SHA256 + 327abea538b814f279a936a71072960de08e53314f0f08dd32c2f8870a32d65e. + C6–C20 are accepted within their stated hypotheses. Its section6 was + explicitly conditional on G; section5 below supplies that input from + the corrected source, without changing C94's historical disposition. + +SOURCE_IDENTITIES.json also pins C91–C93 and their reviews. All source +identities establish custody; the argument and imported premises below +establish the mathematical dependency chain. No review vote proves a lemma. + +## 1. Replacement for A2 Lemma7(b)'s positive-c reciprocal step + +Retain A2's notation and hypotheses, especially (H). For c>0 write +omega=c/psi. Lemma6 gives 0=1-k0*omega. The latter implies the reciprocal bound only where +its right side is positive. At the switch point, + + 1-k0*omega0=b0/K=34625/187969>0. (G3) + +Hence the reciprocal is positive and increasing on the entire first +interval, with endpoint value K. The function a0/omega is decreasing +on the second interval, also with endpoint value K. Moreover +00. Thus the initial segment has P>ell and is +connected to M while avoiding the vertical cut at u=1/2. This proves +membership in the defining component. The rest of the segment has +P<=ell and cannot belong to that component. + +As eta increases to m, t_eta increases to1. In this example +F*=(1+eta)/psi=1+eta. The supremal height of that initial segment, +divided by sqrt(F*), is + + 12t_eta sqrt((1+m)/(1+eta)) ->12. (G6) + +Consequently the universal constant12 cannot be lowered. This is a +supremum/limit claim; no saddle is placed inside the trap. The admissible +family is nonempty: choose m=1/1000. Then R<4 and +tau_S=tau_M=(4+R)/(6sqrt(3))<5/6. Hence +m_S>72/3125>m and epsilon_M>9/50>m. This sharpness assertion is not an +input to the geometric criterion or the probabilistic composition. + +## 3. Replacement for A2 Corollary9(c)'s integration domain + +Retain gamma!=0 in the raw chart and rho>0. Write a=|c| and + + x=25(|gamma|+12)^2/(4 gamma^2 rho^2)>0. + +The actual integration set is {psi:aa. (G7) + +For x>a, I=(x-a)^2(x+2a)/3, so it is nonnegative. It is at most x^3/3 +because -a^2*x+2a^3/3<=0. For x<=a, zero is also at most x^3/3. +Thus the source's upper bound is valid on the true typed domain, with +an explicit empty-domain branch. Multiplication by gamma^6 gives + + gamma^6 I(a,x) + <=(25/4)^3 (|gamma|+12)^6/(3 rho^6). (G8) + +This is the reference soft-measure bound stated by A2; it is not used as +an actual weighted-Palm tail. In particular C94 retains its separate +actual radius bound C(rho^-8+r rho^-4). Gamma=0 is not a pointwise raw +chart. Under C92's continuous finite-jet law it is null, and multiplication +by the integrable determinant weight preserves that null set. + +## 4. Corrected geometric interface G: precise consumable theorem + +Write + + P(u,Z)=A(u)-(psi+2cu)Z^2/48+RZ^3/3456, + A(u)=2(u+1/2)^2(u-1), M=(-1/2,0), S=(1/2,0). + +Let psi>|c|, allowing all R and including the source's exceptional +curve Delta. Define mu as the maximum of P(Y)+1 over extra nondegenerate +saddles, or -infinity if none. Define + + kappa_S=(psi+c)/48, kappa_M=(psi-c)/48, + tau_j=2/(3sqrt(3))+|c|/(24sqrt(3)kappa_j) + +|R|/(3456 kappa_j^(3/2)), + rtilde=1/(5tau_S), m_S=2/(125tau_S^2), + rho_M=1/(2tau_M), epsilon_M=min(rho_M^2/2,1). + +Let E_S and E_M be the ellipses of rescaled radii rtilde and rho_M, +respectively, in coordinates (sqrt(3)(u-u_j),sqrt(kappa_j)Z). +Let mu<0 and 0ell}\L0 containing +M. Define the CONTROL SET to include the whole axis segment: + + V'_eta=closure(T^v) union ([-1/2,3/2] times {0}). + +Suppose g=P+e is continuous on R^2, C2 on the two ellipses, and + + e(M)=e(S)=0, grad e(M)=grad e(S)=0, + sup_{V'_eta}|e|x, g(x)>0} min_t g(path(t))=-1. (G10) + +Furthermore the two ellipses and V'_eta lie in + + W=[-5/4,3/2] times [-30/sqrt(psi),30/sqrt(psi)]. (G11) + +For gamma!=0, X=u-Z/12, zeta=Z/gamma and psi gamma^2=24lambda>0, +the raw image of W has Euclidean radius at most + + Rbox=3/2+(5/2)(|gamma|+12)/sqrt(24lambda). (G12) + +**Proof and dependency audit.** A2 Lemmas5–6 are unchanged; C90's full +first slice reconstructs them. Their polynomial identities follow from +the displayed P, and the imported CUB C7–C8 classify the finitely many +extra critical points. QS's local Lemmas1,2(a)(b),3 and its explicit +tangency-level estimate are retained. The boundary barrier proof in A2 +Lemma7(a) is unchanged: every exit from its trapezoid outside L0 has +P<=ell. On its top edge, an interior maximum is an extra saddle below +ell or an allowed degenerate point below -1-m_S; the latter inequality +is the stated QS tangency estimate. Consequently T^v is bounded and +its boundary lies in {P=ell} union L0. No flow estimate at infinity, +critical-free strip, or exclusion of Delta is being imported. + +Section1 repairs the only invalid estimate used by Lemma7(b). It proves +the same height bound. A2 Corollary9(a) then bounds the vertical trap, +the two ellipses and the axis by W. In detail eta<27/250 gives +u_eta>=-1-2eta/9>-5/4; the ellipse horizontal extents are at most3/10 +at S and3/4 at M. Their squared scaled vertical extents are at most +324/25 and81, respectively. These bounds use +(1+omega)/(1+omega+3|omega|)^2<=1 and +(1-omega)/(1-omega+3|omega|)^2<=1 on -10 must leave the trap. At its first boundary point, +g<-1 on {P=ell} and g<=-1 on L0 by the S-ellipse Hessian estimate. +This proves d_g(M)<=-1. Conversely use the retained axis to (3/2,0). +There P+1=2(u-1/2)^2(u+1). Inside the S ellipse QS Lemma2(b) gives +g+1>=0; outside it P+1>m_S>eta, so g>-1. Its far endpoint has +g>4-eta>0. This is a path with minimum exactly g(S)=-1, proving +the reverse inequality and nonemptiness of the path family. + +Finally |zeta|<=30/sqrt(24lambda) and +|X|<=3/2+(5/2)|gamma|/sqrt(24lambda). The Euclidean norm is at most +the sum of these component bounds, yielding G12. QED. + +Thus G is supplied by the corrected object with its explicit QS/CUB local +premises. This does not upgrade every statement in those parent packets, +and does not accept A2v1's literal false lines. C90's separate stable-cut +review remains at its original scope and is not counted twice. + +## 5. Actual torus maximin consequence of C94 + +Use exactly C92/C94's Gaussian field, pin law Q_r, determinant weight W_r, +full normalizer Z_r=r^2 z_r and weighted law Q_r^W. The parameters are +d=2, fixed finite L>0, k=1, birth b in a fixed nonempty compact set B0, +all orthonormal frames and fixed finite Lambda>0. Do not let Lambda grow +with r. Let E and Good be exactly C94's sector and certificate, with +w=r^(-1/16), delta=r^(1/2), and eta=min(m_S,epsilon_M,-mu)/2. +All constants/cutoffs have precisely C94's permitted parameter dependence. + +The actual physical pins are M_r=(-r/2,0), S_r=(r/2,0), with values +b and b-r^3. Define the torus observable, using continuous paths, by + + D_f(M_r)=sup_{paths M_r->x, f(x)>b} min_t f(path(t)), (G13) + +with value -infinity if no higher endpoint exists. For the periodic lift, +F_r(X,zeta)=(f(rX,r zeta)-b)/r^3. In the gamma!=0 chart put +g(u,Z)=F_r(u-Z/12,Z/gamma). This is globally continuous; the chart is +an invertible linear map of R^2, irrespective of its condition number. +The exact cubic identity is G_raw=P under that map, so g=P+e with +the exact pins and local C2 regularity. Every continuous torus path from +M_r has a unique lift starting at its chosen lift; every planar path +projects to a torus path. The endpoint inequalities are preserved, and +positive affine height scaling preserves minima and suprema. Therefore + + D_f(M_r)=b+r^3 d_g(M). (G14) + +This is equality of the two path families' supremal values, not an +assumption that paths remain in one local patch. C94 also ensures the +small control window embeds (2rw<=L/4). The compact trap prevents any +escape route from raising the maximin value, including paths that later +wind around the torus. + +On Good, C94 supplies all G9 hypotheses: the raw radius is at most w; +the actual value error is strictly below eta; both rescaled Hessian +errors have the required bounds; and the entire axis is included. +Its eta satisfies (H). Applying section4 and G14 yields the deterministic +implication + + Good implies D_f(M_r)=b-r^3=f(S_r). (G15) + +The path to the axis endpoint also gives f(x)>b, so M_r is not the +global maximum on Good. This is an actual-field maximin statement. + +The events are measurable. For fixed r,b,M_r the set {D_f(M_r)>a} is +open in the uniform topology: any witnessing path has a strict endpoint +gap above b and a strict minimum gap above a, both retained under a +sufficiently small uniform perturbation. It is a union of such open +conditions over paths. Hence D_f is lower semicontinuous as an extended +real functional and {D_f(M_r)=b-r^3} is Borel. E and Good are measurable +by C94. The chart-null set gamma=0 is null under Q_r and Q_r^W by C92. + +Let A_r denote {D_f(M_r)=f(S_r)}. C94 C18–C20 and G15 now give + + Q_r^W(E minus A_r) <= C r^(7/2), (G16) + Q_r^W(E intersect A_r) + =r^3 m_E/z0+O(r^(7/2)), (G17) + Q_r^W(A_r | E)=1-O(sqrt(r)). (G18) + +For G17, use Q_r^W(E)=r^3 m_E/z0+O(r^4) and subtract the nonnegative +error bounded by G16; r^4<=r^(7/2) for0= 1-k0 omega`; only where the latter right-hand side is positive may one invert it. The constants satisfy + +`K=b0+k0 a0=187969/31250`, `omega0=a0/K=74875/187969`, and `1-k0 omega0=b0/K=34625/187969>0`. + +Thus on `(0,omega0]` the reciprocal is defined, positive, increasing and at most its endpoint value K. On `[omega0,1/2)` the other bound is decreasing and at most K. The overlap agrees exactly. The endpoint ordering `omega0<125/256<1/2` is correct; no reciprocal is used on or beyond its pole. + +The preceding coefficient also checks: `A'(u_eta)/2 <=3(128/125)^2-3/4=149733/62500<599/250`, since `t_eta<=2eta/9<3/125`. For nonpositive c the retained A2 cases remain sufficient: on `-1/2<=omega<=0` the bound is at most 2.216; for `omega<-1/2`, writing `s=1/2-u` gives `A-ell<=eta+min(3s^2,1)` and `theta/psi=1+omega+2|omega|s`. The nonconstant quotient is at most `min(3s,1/s)<=sqrt(3)` for s>0, and the s=0 case is direct. The middle term of tau_S gives `eta/(1+omega)<3/125`. These bounds are all below 6.05. + +Both `144K<(148/5)^2` and the slightly stronger needed common-case check `144*(121/20)<(148/5)^2` hold; hence the 29.6 height and 30 box survive in every sign case. The old expression fails at admissible `psi=1,c=49/100,R=0,eta=1/1000`, not merely at an irrelevant parameter: the R=0 saddle has `mu=A(-1/(2c))+1<0` and this eta is below all three margins. At omega49/100 the denominator is exactly -11/3125; at125/256 it is zero. G1–G3 correctly replace the false line. + +## 3. G4–G6: open segment and sharp supremum + +At c=0,psi=1,R=4/sqrt(1+m), the extra saddle is at `u=-1/2,Zs=12sqrt(1+m)`, has value `-1-m`, and is excluded at `ell=-1-eta` for every eta0` on `(0,1)`, with endpoint values0 and1. Since `(1+eta)/(1+m)` lies strictly between0 and1, there is exactly one first level root in `(0,1)`. + +Every initial point before that root lies in the same open superlevel component as M via the initial segment and avoids the vertical cut u=1/2. Points at or after the root through the saddle have P<=ell. Thus the claimed component membership and excluded endpoint are both proved, without assuming an entire saddle segment is inside the trap. + +As eta increases to m, strict monotonicity and continuity force t_eta to1. Here `F*=1+eta`, so the squared normalized height is `144 t_eta^2/(3t_eta^2-2t_eta^3)=144/(3-2t_eta)`, tending to144 from below. For every proposed constant below12, admissible eta sufficiently near m violates that smaller bound. This is sharpness as a supremum, not attained by an interior saddle. The fixed m=1/1000 family is valid: R<4, `(4+R)/(6sqrt3)<5/6`, `m_S>72/3125`, `epsilon_M>9/50`. No limiting variation leaves (H). This sharpness is not a load-bearing input to G or the actual-law conclusion. + +## 4. G7–G8: true typed domain and no false Palm tail + +For `a=|c|>=0,x>0`, the set aa the primitive gives `x^3/3-a^2 x+2a^3/3=(x-a)^2(x+2a)/3`. It is nonnegative, and the correction to x^3/3 is `-a^2(x-2a/3)<=0`. Hence the upper bound applies in both branches without interpreting a reversed oriented integral as a measure. + +With the stated positive x and nonzero gamma, multiplying by gamma^6 cancels exactly the gamma^-6 in x^3 and gives G8. The raw chart still has no pointwise meaning at gamma0. C92's absolutely continuous finite-jet marginal makes that set null under Q_r; the finite integrable actual determinant tilt preserves the null set. This validates the stated almost-sure use, not a chart extension. + +The reference soft weight `(psi^2-c^2)dpsi` at fixed(c,R) is not the actual law. C95 correctly keeps C94's separate bounded-lambda actual radius estimate `C(rho^-8+r rho^-4)` and does not substitute the repaired model rho^-6 bound. G7–G8 and the sharpness repair do not enter the proof of G11 or G15. + +## 5. G9–G12: retained compact geometry reconstructed + +The source hypotheses are all preserved: psi>|c|, (H), global continuity of g, local C2 on both ellipses, both value and gradient pins, the rescaled Hessian bounds, and strict uniform value control on the closed trap AND the entire axis to3/2. There is no omitted axis or global-continuity assumption. + +Direct differentiation gives `P_Z=Z(RZ-48theta)/1152`. For R!=0, on the critical line `Z=48theta/R`, `Phi=A-16theta^3/R^2`, `Phi'=6u^2-3/2-96c theta^2/R^2`, and `Phi'' P_ZZ=det Hess P`. This last equality needs no division by theta. CUB C7–C8, after the declared normalization, give the conic `sigma^2-cZ^2/36=1`, line `RZ=48(psi-c sigma)`, height `(sigma-1)/2-psi Z^2/144`, and determinant `(c-sigma psi)/4`. + +For c>0, A2's left-edge argument supplies a nondegenerate extra saddle with height at least A(u_c), u_c=-psi/(2c): at R0 it is explicit; at R!=0, Phi' is positive at u_c and negative at0, and its first zero between them is simple with negative derivative. Even at the quadratic degree drop the surviving linear coefficient is nonzero. Consequently (H) implies u_c=psi+c>0 on the entire u interval. The positivity needed in the vertical barrier is therefore justified, not assumed from typing alone. + +On the compact trapezoid B, the vertical identities give `P<=A-theta Z^2/144` above the axis up to the critical line, and `P<=A-theta Z^2/48` below it. The left and bottom edges are at or below ell. The right edge outside L0 is below ell: on the negative side use the quadratic term; on the positive side use its value at Z_E and monotonic decrease up to the critical-line top. The ordering of those heights follows from `sqrt(kappa_S)Zline=2/(3d_local)>rtilde`. For R0 the top is handled like the bottom. For R>0 the top function Phi is below ell at both ends; any interior maximum is an extra saddle or a degenerate extra point. The former is below ell by eta<-mu. The latter only occurs for c<0 at tangency and has + +`P=-1-(y-1)^2/(4y)`, `y=psi/|c|>1`. + +QS's bounds `m_S<=min((3/250)(y-1)^2,27/250)` put it strictly below `-1-m_Ssigma psi`. A nonnegative sigma would force c>0 and, by the conic with Z!=0, sigma>1, contradicting c0`; positive determinant makes it a strict minimum, not a maximum. All finite extra-point cases, including R0,c0 and degree drop, are covered. Hence P<=-epsilon_M on K. The M-local Taylor lemma gives g<0 on E_M minus M, and eta0 must exit the trap. At first exit, its value is <-1 on the level boundary and <=-1 on L0, by the S pins and Hessian estimate. This proves the upper maximin inequality. For the reverse one, the retained axis has `P+1=2(u-1/2)^2(u+1)`. Inside E_S the local Taylor bound gives g+1>=0. Outside it on this segment, `P+1>m_S>eta` (indeed the standard bound is at least2m_S), so g>-1. Its far endpoint has g>4-eta>0; S lies on the path with value-1. The path minimum is exactly-1, proving G10 and nonemptiness of the path family. + +The height estimate from section2 bounds the closed trap. Also `u_eta>=-1-2eta/9>-5/4`. The ellipse horizontal radii are at most3/10 and3/4, and their squared scaled vertical radii are at most324/25 and81. For each sign, the denominator-square minus numerator in `(1±omega)/(1±omega+3|omega|)^2` is nonnegative on -10 gives lambda>0 and psi>|c|; eta is positive and strictly below all three margins, including the no-extra-saddle convention. The raw radius bound Rbox<=w places every required set in the raw square. C94's strict value bound and C93 E13 Hessian suprema supply exactly G9. The matrix is the derivative of the inverse chart times J_i, so the Hessian norm is the correct rescaled one; its dependence on the random jets is not discarded. The strict S bound <2/5 is stronger than the required <=2/5. + +For any fixed nonzero gamma and r>0, the composite of the invertible linear chart, physical scaling, chosen orthonormal frame and torus quotient is a covering map from R^2 to the torus. Every continuous path parametrized on [0,1] starting at M_r has a unique lift starting at the chosen M; every planar path projects. This is true even for paths that subsequently wind arbitrarily or leave the control patch. Heights along corresponding paths are exactly related by `f=b+r^3 g`; the endpoint predicate f>b is exactly g>0. Since r^3>0, both path minima and their suprema transform by that same affine map. Empty families agree as well under the -infinity convention. This proves G14 as equality of full path-family values. + +The local embedding condition `2rw<=L/4` holds eventually and supports the local analytic certificate, but it is not used to truncate the torus path family. The planar compact trap blocks every lifted escape. The axis path projects to an actual higher endpoint. Thus Good implies the actual torus maximin equality in G15 and also implies M_r is not a global maximum. This does not identify a persistence partner or invoke branch adjacency. + +For measurability, fix r,b,M_r. If D_f>a, the definition of supremum supplies a witnessing path with minimum strictly above a and endpoint strictly above b. Compactness of [0,1] supplies an attained minimum, and both strict gaps persist under a sufficiently small uniform perturbation of f. Therefore `{D_f>a}` is open, even though it is a union over an uncountable path family. Extended-real lower semicontinuity makes D Borel. On the pin fiber f(S_r)=b-r^3, its equality event is Borel; alternatively on the full function space D-f(S_r) is an extended-real Borel function and its zero set is Borel. No countable enumeration of all paths or generic Morse hypothesis is needed. E and Good are Borel by the guarded algebraic branches and compact-window derivative suprema in C94/C93. The gamma-null set costs no weighted mass. + +## 7. G16–G18: full actual weight, uniform positivity, and rates + +The field and parameter scope is exactly d2, fixed L>0, k1, b in the fixed nonempty compact B0, all orthonormal frames, and fixed finite Lambda>0. C92's law Q_r is the continuous Gaussian regression at the original pins. Its actual weight is + +`W_r=|det H_M det H_S| 1{H_M negative definite, index(H_S)=1}`, + +and its full normalizer is `Z_r=E_Q W_r=r^2 z_r`, `z_r=z0+O(r)`, with a uniform positive floor; `z0=36 E[A^2 1{A<0}|U0=(b,0,0,12,0,0)]`. The bounded-layer measure is `mu_r=r^-5 E_Q[W_r 1_event]`, not a probability-normalized soft-layer law. Therefore exactly `Q_r^W(event)=r^3 mu_r(event)/z_r`. C95 retains that factor and does not insert a pin density, missing slice-density factor, reference-Gaussian normalization, or new conditional normalizer. + +I checked the C94 analytic inputs as consumed, not merely its review disposition. The actual radius integration gives powers rho^-8 and r rho^-4 after the B1-to-edge Jacobian1/12; the finite-r residual remains. A1 W1 under E's explicit two inequalities gives the random local floor `v>=3 a_S^2/(250(48Lambda)^2)`. C93's moment-weighted edge envelope controls the inverse-margin split before any expectation; no independence of field norm, weight or jets is assumed. The level-band input is C82 deterministic LB with width2d, not its independent-Gaussian corollary. The exact change `w_lambda d lambda=(gamma^6/384)(psi^2-c^2)dpsi` cancels both c/R chart poles before integration against the joint Gaussian slice density. The width is deterministic during the inner integration. These facts justify retaining C94's O(r^(7/2)) certificate loss without strengthening its historical scope. + +For `w=r^-1/16,d=r^1/2,p2`, the eight C94 bracket exponents are exactly `(1/2,5/4,3/4,11/8,1/2,1,1/2,7/4)`. Their minimum is1/2; multiplying by r^3 gives r^(7/2). All window/cutoff restrictions hold eventually with fixed parameters. The two Hessian losses are separately `O(r^5 w^4)`, consistent with this ledger. + +Since Good is a subset of E and, now by G15, of A_r, `E\A_r` is a subset of `E\Good`. C94 C18 therefore proves G16 under the full weighted law. The bounded-indicator L1 comparison and full normalizer give `Q_r^W(E)=r^3 m_E/z0+O(r^4)`. Subtract the nonnegative mass `Q_r^W(E\A_r)<=Cr^(7/2)` and use r^4<=r^(7/2) for small r to obtain G17. No reverse decision implication or equality E=the actual selection event is needed. + +Uniform division is justified, rather than assumed. At `lambda=Lambda/2,gamma=1,B1=(1+6Lambda)/12,C3=(1+18Lambda)/144`, one has `psi=12Lambda,c=-6Lambda,R0,a_M=18Lambda,a_S=6Lambda`, weight `27Lambda^2/4>0` and extra-root discriminant bracket `-41472Lambda^3<0`. A fixed compact positive-volume neighborhood stays strictly inside E and has no extra critical point. The joint nondegenerate Gaussian slice density has a positive uniform lower bound there over compact birth/frame parameters; C92 supplies its covariance continuity/ellipticity. Thus m_E has a uniform positive lower bound and finite upper bound. The same C92 hypotheses give both positive lower and finite upper bounds for z0. In particular m_E/z0 is uniformly bounded below; for sufficiently small r, Q_r^W(E)>=c r^3. Dividing G16 by that lower bound proves G18, in the precise form `0<=1-Q_r^W(A_r|E)<=C sqrt(r)`. + +This is an asymptotically almost-sure conditional statement on a rare event of order r^3. It is not an unconditional probability tending to1. Fixed-Lambda constants do not license Lambda growing with r. Uniform positivity of the leading coefficient, not just positivity separately at each parameter, is necessary for the claimed uniform conditional rate. + +## 8. Independent execution and its limits + +My independently written `checker.py` uses only fractions and itertools, imports no source/checker files, and uses explicit RuntimeError checks rather than assert statements. It was run with actual Python3.12.14 as `python checker.py`, `python -O checker.py`, and `python -S checker.py`. All three exited0; both pairwise stdout comparisons exited0. Each run performed9270 positive exact rational/algebra controls and rejected22 false-inference fixtures. These are three repetitions of one suite, not three independent reviews. + +Checker: 10566 UTF-8 bytes, SHA256 `179d64b556b337ddf966ba5f4f274d59910a6c045a242b26fff957f3167951d2`. + +Each stdout: 1691 UTF-8 bytes, SHA256 `484e9d61c77fcd6394ad97cae20e628e4ccb6c3163d7ff900fdd4ee0836c37f5`. + +The complete reusable source and exact deterministic stdout accompany this review. Controls cover the reciprocal switch and an actually admissible old-domain failure, first-root sharpness and constants below12, both branches of the typed integral, chart cancellation for either gamma sign, retained critical-line/CUB/axis algebra, ellipse ratios, raw cubic and Hessian transfer, actual joint-density Jacobian, positive affine path-value conversion, the positive sector witness, full normalizer and rate ledger. False-inference fixtures reject the original domain errors, saddle inclusion, smaller sharpness constants, lost gamma-six/full-normalizer factors, negative height scaling, omission of the higher endpoint predicate, loss of the actual radius residual, absent sector floor, unconditional-probability promotion and growing-Lambda extrapolation. Some elementary guard checks are intentionally simple; none is treated as a topological proof. + +Finite rational evaluations support transcription and algebra. They do not prove the universal barrier, compact separation, path lifting, Gaussian estimates, Borel statements, or uniform limiting results. Those are established by the written reconstruction and expressly retained source theorems above. Verification-before-completion guidance prompted the fresh full executions and byte comparison; it supplies no mathematical premise or extra acceptance vote. + +## 9. Final boundary and release + +PASS applies to this exact C95 object within the stated hypotheses. It supplies the corrected geometric input G missing from C94's conditional section6 and consequently the actual weighted maximin conclusions G16–G18. It does not alter A2v1's AMEND history, recertify all QS/CUB or C91–C94 claims, or turn the new object into an author-issued Claude successor. + +Still outside scope: H0/persistence-event identification and its Morse/distinct-critical-value conventions; all-bars converse; rejected-side/chord; shrinking witness collisions; intermediate/coarea composition; unbounded Lambda, all marks, other dimensions, whole-field TV; global persistence/density/remainder completion. M is the birth maximum whose component would die upon meeting a higher-born component, not the surviving elder solely by the project's label. No scientific or institutional completion is claimed. + +My distinct fresh review scope, actually picked up at [comment5964966168](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5964966168), is COMPLETE/RELEASED with this full delivery. Author claim `f4597887-706f-4b57-b493-475875214c5f` is untouched. The coordinating root may publish and read back this named review and replay the checker for custody verification, with zero mathematical acceptance credit. No further amendment implementation is authorized or performed. diff --git a/frontiers/planar_soft_layer_chain_20261003/C95/checker.py b/frontiers/planar_soft_layer_chain_20261003/C95/checker.py new file mode 100644 index 000000000..812b7149b --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C95/checker.py @@ -0,0 +1,241 @@ +"""Fresh C95 exact diagnostic. Stdlib only; no imported proof/checker files. + +This does not prove compact separation, covering-space lifting, Gaussian +estimates, or uniform asymptotic assertions. Those require written reasoning. +Checks deliberately raise exceptions rather than using optimizable asserts. +""" +from fractions import Fraction as Q +from itertools import product + +counts = {} +rejections = [] + + +def check(section, condition): + if not condition: + raise RuntimeError('failed exact control: ' + section) + counts[section] = counts.get(section, 0) + 1 + + +def reject(name, false_claim): + if false_claim: + raise RuntimeError('false inference escaped: ' + name) + rejections.append(name) + + +def A(u): + return 2 * (u + Q(1, 2)) ** 2 * (u - 1) + + +def P(u, z, psi, c, R): + return A(u) - (psi + 2*c*u)*z*z/48 + R*z**3/3456 + + +def derivatives(u, z, psi, c, R): + pu = 6*u*u-Q(3, 2)-c*z*z/24 + pz = -(psi+2*c*u)*z/24+R*z*z/1152 + huu, huz, hzz = 12*u, -c*z/12, -(psi+2*c*u)/24+R*z/576 + return pu, pz, huu, huz, hzz + + +def raw(X, z, lam, gamma, B, C): + return (2*X**3-Q(3, 2)*X-Q(1, 2) + +gamma*(X*X-Q(1, 4))*z/2-lam*z*z/2+B*X*z*z/2+C*z**3/6) + + +def mass(a, x): + return Q(0) if x <= a else x**3/3-a*a*x+2*a**3/3 + + +a0, b0, k0 = Q(599,250), Q(277,250), Q(256,125) +K = b0+k0*a0 +switch = a0/K +check('G1-G3 constants', K == Q(187969,31250)) +check('G1-G3 constants', switch == Q(74875,187969)) +check('G1-G3 constants', 1-k0*switch == b0/K == Q(34625,187969)) +check('G1-G3 constants', 0 < switch < 1/k0 < Q(1,2)) +check('G1-G3 constants', 3*Q(128,125)**2-Q(3,4) == Q(149733,62500) < a0) +check('G1-G3 constants', K < Q(121,20)) +check('G1-G3 constants', 144*Q(121,20) < Q(148,5)**2 < 30**2) +check('G1-G3 constants', 48*Q(121,20) < Q(171,10)**2) +for n in range(1,1000): + omega = Q(n,2000) + if omega <= switch: + check('piecewise bound', 1-k0*omega > 0) + check('piecewise bound', b0/(1-k0*omega) <= K) + else: + check('piecewise bound', a0/omega <= K) + check('piecewise bound', a0/omega > 0) +reject('unsafe reciprocal at 49/100', b0/(1-k0*Q(49,100)) >= 0) +reject('reciprocal defined at 125/256', 1-k0*Q(125,256) != 0) +check('old-domain witnesses', 1-k0*Q(49,100) == Q(-11,3125)) +# Independent admissibility of the unsafe-domain point at R=0. +c, psi, eta = Q(49,100), Q(1), Q(1,1000) +uc = -psi/(2*c) +mu = A(uc)+1 +tau_s_sq = Q(4,27)*(1+3*c/(psi+c))**2 +tau_m_sq = Q(4,27)*(1+3*c/(psi-c))**2 +check('old-domain witnesses', 0 < eta < min(-mu,Q(2,125)/tau_s_sq,Q(1,8)/tau_m_sq,1)) +reject('literal old minimum bounds F(M)', min(a0/c,b0/(1-k0*c)) >= 1+eta) + +m = Q(1,1000) +check('sharpness admissibility', 64 < 75) # 8/(6 sqrt(3)) < 5/6 +check('sharpness admissibility', Q(72,3125)>m and Q(9,50)>m) +previous = Q(0) +for n in range(100,500): + t = 1-Q(1,n) + H = 3*t*t-2*t**3 + eta = (1+m)*H-1 + height_sq = 144*t*t*(1+m)/(1+eta) + check('G4-G6 first root', 0 < eta < m and 0 < t < 1) + check('G4-G6 first root', 6*t*(1-t)>0) + check('G4-G6 first root', height_sq == 144/(3-2*t) < 144) + check('G4-G6 first root', height_sq > previous) + previous = height_sq + # The scaled restriction substitutes Z=t Zs, R Zs=48, + # Zs^2=144(1+m), without numerically approximating a radical. + restricted = -Q(3)*(1+m)*t*t+2*(1+m)*t**3 + check('G4-G6 first root', restricted == -1-eta) + check('G4-G6 first root', -(1+m) < -1-eta) +reject('saddle belongs to strict trap', -(1+m)>-1-m/2) +reject('universal sharp constant 11', previous <= 11**2) +q = Q(11999,1000) +t = 1-Q(1,1000000) +reject('universal sharp constant 11.999', 144/(3-2*t) <= q*q) + +for a, x in product([Q(i,3) for i in range(10)], [Q(i,7) for i in range(1,40)]): + value = mass(a,x) + check('G7-G8 typed integral', 0 <= value <= x**3/3) + check('G7-G8 typed integral', value == (0 if x<=a else (x-a)**2*(x+2*a)/3)) + if x>a: + primitive = lambda v: v**3/3-a*a*v + check('G7-G8 typed integral', value == primitive(x)-primitive(a)) +for gamma, rho, a in product([Q(-3),Q(-1,2),Q(1,10),Q(2)], [Q(1,3),Q(2),Q(7)], [Q(0),Q(1),Q(100)]): + x = 25*(abs(gamma)+12)**2/(4*gamma*gamma*rho*rho) + bound = Q(25,4)**3*(abs(gamma)+12)**6/(3*rho**6) + check('G7-G8 cancellation', gamma**6*x**3/3 == bound) + check('G7-G8 cancellation', gamma**6*mass(a,x)<=bound) +reject('reversed primitive equals empty integral', mass(Q(2),Q(1)) == Q(1,3)-4+Q(16,3)) +gamma, rho = Q(1,10), Q(1) +x = 25*(gamma+12)**2/(4*gamma*gamma) +reject('omit gamma-six weight cancellation', x**3/3 <= Q(25,4)**3*(gamma+12)**6/3) + +# Exact rational substitutions exercise the polynomial identities without +# numerical tolerances. Their universal proof is the written derivation. +for u,z,psi,c,R in product([Q(-2),Q(-1,2),Q(1,2),Q(3,2)], + [Q(-3),Q(0),Q(2)], [Q(2)], [Q(-1),Q(0),Q(1)], [Q(-4),Q(0),Q(5)]): + theta=psi+2*c*u + pu,pz,huu,huz,hzz=derivatives(u,z,psi,c,R) + check('retained cubic identities', pz==z*(R*z-48*theta)/1152) + check('retained cubic identities', P(u,z,psi,c,R)-A(u)+theta*z*z/144 == z*z*(R*z-48*theta)/3456) + check('retained cubic identities', P(u,z,psi,c,R)-A(u)+theta*z*z/48 == R*z**3/3456) + check('axis identity', A(u)+1 == 2*(u-Q(1,2))**2*(u+1)) + if R: + zl=48*theta/R + pu,pz,huu,huz,hzz=derivatives(u,zl,psi,c,R) + phi2=12*u-384*c*c*theta/(R*R) + check('critical-line identity', P(u,zl,psi,c,R)==A(u)-16*theta**3/R**2) + check('critical-line identity', phi2*hzz==huu*hzz-huz*huz) + +for sigma,z in product([Q(-2),Q(-1),Q(-1,2),Q(0),Q(1),Q(2)], [Q(-12),Q(6),Q(24)]): + c=36*(sigma*sigma-1)/(z*z) + psi=abs(c)+1 + R=48*(psi-c*sigma)/z + u=-sigma/2 + pu,pz,huu,huz,hzz=derivatives(u,z,psi,c,R) + check('CUB guarded extras', pu==pz==0) + check('CUB guarded extras', P(u,z,psi,c,R)==(sigma-1)/2-psi*z*z/144) + det=huu*hzz-huz*huz + check('CUB guarded extras', det==(c-sigma*psi)/4) + if det>0: + check('CUB guarded extras', sigma<0 and huu>0) + +for n in range(-199,200): + om=Q(n,200) + for sign in [-1,1]: + numerator=1+sign*om + denominator=1+sign*om+3*abs(om) + check('ellipse box ratios', numerator>0 and denominator>0) + check('ellipse box ratios', numerator<=denominator**2) +check('ellipse box constants', Q(27,100)/3==Q(3,10)**2) +check('ellipse box constants', Q(27,16)/3==Q(3,4)**2) +check('ellipse box constants', 48*Q(27,100)==Q(324,25) and 48*Q(27,16)==81) +check('ellipse box constants', -1-Q(2,9)*Q(27,250)>Q(-5,4)) + +for gamma,B,C,lam in product([Q(-2),Q(-1,3),Q(1,2),Q(3)], [Q(-1),Q(1,12)], [Q(-2),Q(0),Q(1)], [Q(1,4),Q(2)]): + psi=24*lam/gamma**2 + c=(gamma**2-12*B)/gamma**2 + R=(8*gamma**3-144*B*gamma+576*C)/gamma**3 + for X,z in product([Q(-1),Q(0),Q(3,2)], [Q(-2),Q(0),Q(1)]): + check('actual raw identity', raw(X,z,lam,gamma,B,C)==P(X+gamma*z/12,gamma*z,psi,c,R)) + aM,aS=24*lam-gamma**2+12*B,24*lam+gamma**2-12*B + check('actual typing algebra', aM+aS==48*lam) + check('actual typing algebra', gamma**2*(psi-c)==aM and gamma**2*(psi+c)==aS) + if aM>0 and aS>0: + for ai in [aM,aS]: + kappa=ai/(48*gamma**2) + check('Hessian transfer', Q(1,3)+(Q(1,144)+1/gamma**2)/kappa==Q(1,3)*(1+(gamma**2+144)/ai)) + check('joint-density Jacobian', (aM*aS/16)*(gamma**2/24)==gamma**6*(psi**2-c**2)/384) +reject('pointwise chart at gamma zero', Q(0)!=0) + +# Path-value fixtures test scaling, not planar separation or path lifting. +paths = [[Q(0),Q(-1),Q(4)], [Q(0),Q(-2),Q(3)], [Q(0),Q(-3,2),Q(2)]] +dg=max(map(min,paths)) +for b,r in product([Q(-4),Q(0),Q(5,2)],[Q(1,16),Q(1,3),Q(2)]): + transformed=[[b+r**3*v for v in p] for p in paths] + check('positive affine maximin', max(map(min,transformed))==b+r**3*dg) + check('positive affine maximin', all(p[-1]>b for p in transformed)) +reject('negative scale preserves maximin', max(min(-v for v in p) for p in paths)==-dg) +reject('drop higher-endpoint restriction', max(dg,Q(0))==dg) +for gap in [Q(1,100),Q(1,3),Q(2)]: + eps=gap/3 + check('strict witness robustness', gap-eps>0) + +for Lambda in [Q(1,100),Q(1,3),Q(1),Q(12)]: + lam=Lambda/2; gamma=Q(1); B=(1+6*Lambda)/12; C=(1+18*Lambda)/144 + J=8*gamma**3-144*B*gamma+576*C + psi,c=24*lam,1-12*B + aM,aS=24*lam-gamma**2+12*B,24*lam+gamma**2-12*B + check('positive sector witness', J==0 and psi==12*Lambda and c==-6*Lambda) + check('positive sector witness', aM==18*Lambda and aS==6*Lambda) + check('positive sector witness', 64*c*(psi**2-c**2)==-41472*Lambda**3<0) + check('positive sector witness', 0abs(c) and psi>2*c) + check('positive sector witness', aM*aS/16==Q(27,4)*Lambda**2>0) + astar=48*Lambda + cstar=Q(3,250)/astar**2 + check('tolerance floor', cstar*astar**2==Q(3,250)0) +for r in [Q(1,16),Q(1,64),Q(1,256)]: + z0=Q(2); zr=z0+r; sector_mass=Q(3,7) + unweighted_numerator=r**5*sector_mass + fullZ=r*r*zr + probability=unweighted_numerator/fullZ + check('full actual normalization', probability==r**3*sector_mass/zr) + check('full actual normalization', abs(probability-r**3*sector_mass/z0)<=r**4*sector_mass/(z0*z0)) + fail=r**4*sector_mass/(2*zr) + check('event subtraction', (probability-fail)/probability==1-r/2) + reject('restricted normalizer at r='+str(r), unweighted_numerator/unweighted_numerator==probability) + reject('omit full normalizer r-square at r='+str(r), unweighted_numerator/zr==probability) +reject('r4 dominates r7/2', Q(1,256)**4 >= Q(1,256)**3*Q(1,16)) +r=Q(1,256); rho=Q(256) +reject('discard actual radius residual', r*rho**-4 <= rho**-8) +sector=r**4; fail=sector/2 +check('uniform positivity obstruction', fail<=r**3*Q(1,16)) +reject('conditional convergence without sector floor', fail/sector <= Q(1,16)) +reject('unconditional good probability tends to one', r**3*Q(3,7)/(2+r)>Q(1,2)) +reject('growing Lambda inherits fixed constants', (1/r)**8*r**Q(1,1) < 1) + +print('C95 fresh stdlib exact controls') +for name in sorted(counts): + print(name + ': ' + str(counts[name])) +print('positive controls: ' + str(sum(counts.values()))) +print('false-inference controls rejected: ' + str(len(rejections))) +for name in rejections: + print('REJECT ' + name) +print('No finite-control claim proves topology, Gaussian inputs, or uniform limits.') diff --git a/frontiers/planar_soft_layer_chain_20261003/C95/checker_stdout.txt b/frontiers/planar_soft_layer_chain_20261003/C95/checker_stdout.txt new file mode 100644 index 000000000..319014ea9 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C95/checker_stdout.txt @@ -0,0 +1,51 @@ +C95 fresh stdlib exact controls +CUB guarded extras: 63 +G1-G3 constants: 8 +G4-G6 first root: 2400 +G7-G8 cancellation: 72 +G7-G8 typed integral: 1068 +Hessian transfer: 66 +actual raw identity: 432 +actual typing algebra: 96 +axis identity: 108 +critical-line identity: 144 +ellipse box constants: 4 +ellipse box ratios: 1596 +event subtraction: 3 +full actual normalization: 6 +joint-density Jacobian: 33 +old-domain witnesses: 2 +piecewise bound: 2794 +positive affine maximin: 18 +positive sector witness: 20 +rate ledger: 3 +retained cubic identities: 324 +sharpness admissibility: 2 +strict witness robustness: 3 +tolerance floor: 4 +uniform positivity obstruction: 1 +positive controls: 9270 +false-inference controls rejected: 22 +REJECT unsafe reciprocal at 49/100 +REJECT reciprocal defined at 125/256 +REJECT literal old minimum bounds F(M) +REJECT saddle belongs to strict trap +REJECT universal sharp constant 11 +REJECT universal sharp constant 11.999 +REJECT reversed primitive equals empty integral +REJECT omit gamma-six weight cancellation +REJECT pointwise chart at gamma zero +REJECT negative scale preserves maximin +REJECT drop higher-endpoint restriction +REJECT restricted normalizer at r=1/16 +REJECT omit full normalizer r-square at r=1/16 +REJECT restricted normalizer at r=1/64 +REJECT omit full normalizer r-square at r=1/64 +REJECT restricted normalizer at r=1/256 +REJECT omit full normalizer r-square at r=1/256 +REJECT r4 dominates r7/2 +REJECT discard actual radius residual +REJECT conditional convergence without sector floor +REJECT unconditional good probability tends to one +REJECT growing Lambda inherits fixed constants +No finite-control claim proves topology, Gaussian inputs, or uniform limits. diff --git a/frontiers/planar_soft_layer_chain_20261003/C96/COMPLETION.md b/frontiers/planar_soft_layer_chain_20261003/C96/COMPLETION.md new file mode 100644 index 000000000..187bc91ce --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C96/COMPLETION.md @@ -0,0 +1,25 @@ +C96 reviewed completion — designated maximin event is the finite ordinary-superlevel H0 pair + +**PASS at designated-pair scope; no amendment required.** The frozen [C96 full proof5965141133](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965141133) is 7657 UTF-8 bytes, SHA256 `7198ff636e330749428ded6938776dad612f6bdb51ad62359b445f016df13a7a` (proof body after the identity preface, final newline included). It was published from the actual [native pickup5965119121](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965119121). + +The fresh [nonauthor review5965199940](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965199940) is 11275 UTF-8 bytes, SHA256 `43f3933870585fbc216a5eeae0528f14ac893ff498ef7b24c66cd77d7f2ef3ae`; its native body was read back at that exact identity. Actual reviewer: OpenAI/Codex subagent `/root/aud023_review`, uninvolved in C96 authorship. Prior program/source exposure is disclosed in the review. Same provider gives organizational-independence credit 0; Dylan personal reading remains PENDING; scientific effect NONE. The coordinating `/root` is C96's author and receives no nonauthor acceptance credit. + +The source-bound result is: +- On a compact closed Morse manifold with distinct critical values, for the designated non-global maximum M and index-(d-1) saddle S, the maximin equality (d_f(M)=f(S)) is equivalent to the finite ordinary-superlevel H0 class born at M dying at S under the elder rule. +- Under C95's actual full-normalizer law, its event (A_r) therefore equals that designated finite-bar event (H_r), (Q_r^W)-almost surely. +- C95 G16–G18 consequently transfer without a new loss: + [ + Q_r^W(E\setminus H_r)\le Cr^{7/2},\qquad + Q_r^W(E\cap H_r)=r^3m_E/z_0+O(r^{7/2}),\qquad + Q_r^W(H_r\mid E)=1-O(\sqrt r). + ] + +This is an explicit composition/reproduction of the already pinned parent §8 interface (P blob `dfed3b8d318a3ab1950957f393307733a4bef3f2`, review blob `bc11369c41ebc76de5700df3f931939ccfc88b9b`, reconciliation blob `75da2597971510f843f8d90c743950cb8c177342`) with reviewed C95; it is not claimed as a newly discovered genericity theorem. It requires neither Morse–Smale transversality nor gradient-branch adjacency. Open/closed superlevel choices change endpoint decoration, not the numerical birth/death levels. + +No executable checker is attached: this is a written topological and measure-theoretic proof, and finite samples would not prove its universal component/handle statement. Source identity and native readback are custody evidence only. + +Still open: every-small-bar/local-witness converse, rejected-side/chord control, shrinking multiple-witness collisions, intermediate/coarea composition, unbounded Lambda, all marks and global density/remainder closure. The essential class is excluded by the strictly higher-endpoint predicate. + +The C95 custody artifact was separately downloaded and matched its released identity: 590587-byte ZIP, SHA256 `dc9a797240a592abf4c8a17b579b153f3af1adaf3a619a33ce1b252443d31c03`, owner-only permission metadata. That verification is not another C95 review. + +C96's native scoped author pickup is **COMPLETE / RELEASED** with this proof and review. No R17 register transition, branch edit, CI, merge, source replacement, or human acceptance is represented. The separate root01a0bbb5 delivery/custody coordinator may now package these exact native objects without taking a second mathematical review role. \ No newline at end of file diff --git a/frontiers/planar_soft_layer_chain_20261003/C96/DELIVERY.md b/frontiers/planar_soft_layer_chain_20261003/C96/DELIVERY.md new file mode 100644 index 000000000..6cd282311 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C96/DELIVERY.md @@ -0,0 +1,38 @@ +## C96 verified delivery and release — designated finite H0 interface + +**Object:** C96-DESIGNATED-MAXIMIN-TO-H0-20261003-v1. + +The existing C96 author/reviewer work is now delivered once and registered. This comment records delivery and incorporation scope; it is not another mathematical review. + +### Mathematical result to consume + +[The frozen proof](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965141133), together with [its full nonauthor review](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965199940) and [author completion/read conventions](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965212531), identifies the designated maximin event with finite ordinary-superlevel H0 elder death on a compact connected **closed** Morse manifold with distinct critical values. A strictly higher path endpoint excludes the essential global-maximum class. The equivalence is for the chosen maximum and saddle; it is not gradient-branch adjacency. + +Under the existing fixed-parameter genericity input and C95's actual full determinant-weighted law, define H false off the Borel Morse/distinct-value typed-pin locus. Then A=H almost surely, and C95 transfers unchanged: + +- Q_r^W(E minus H_r) <= C r^(7/2); +- Q_r^W(E intersect H_r) = r^3 m_E/z_0 + O(r^(7/2)); +- Q_r^W(H_r | E) = 1 - O(sqrt(r)). + +The scope remains planar, fixed finite torus, gap mark one, compact birth heights, all frames and fixed finite Lambda. E itself is a rare sector of order r^3. This is not an unconditional probability tending to one. + +### Immutable delivery and verification + +[Registered Drive packet](https://drive.google.com/file/d/1BfyDQ90A30UZV6UXscz7UPMKyduHMGtJ/view?usp=drivesdk) + +- ZIP: 405836 bytes; 27 payloads; SHA256 `3f0c893acb04531a68ca5518cc9f34ed3aa3d2f61241ad11d51df2ad04aa4cfd`. +- Exact proof suffix: 7657 bytes; SHA256 `7198ff636e330749428ded6938776dad612f6bdb51ad62359b445f016df13a7a`. +- Full native proof comment: 7913 bytes; SHA256 `0758b5de8f4d9e4658ca3c6cf3e52c23d8e12f77999e9c3668ef0bedb15a05f5`. +- Review: 11275 bytes; SHA256 `43f3933870585fbc216a5eeae0528f14ac893ff498ef7b24c66cd77d7f2ef3ae`. + +One upload, exact byte-for-byte download, canonical manifest/handoff verification and owner-only permission readback completed. Eight retained source identities and six Git blob identities were checked. No numerical checker, repository CI, commit or merge is claimed for this analytic delivery. + +Register readback: **AI890 / EL612 / RQ159 / WE627 publication**. R17 delivery/custody claim `172c3e9a-419a-44e8-a15b-090ccf4b7b79` is **RELEASED**, with exact full CellData readback of **WE628**, timestamp 2026-10-03T03:53:49Z. This is distinct from the author's native pickup/release; no earlier R17 authorship claim is retroactively asserted. + +### Next mathematical obligation + +The next candidate is the actual rejected-side QS-R chord estimate, retaining **both** the saddle margin mu and endpoint margin 4(1-mu), the raw-coordinate radius, correlated weighted Taylor control and the full normalizer. The prospective route in NEXT_ACTION.md is not yet a proof or a new claim. Recheck custody and acquire a fresh claim before proceeding. + +The all-small-bar/local-witness converse, regional multiple-witness collision, intermediate/coarea composition, unbounded strata and all marks remain separate obligations. Existing scoped D1/D2 acceptances are neither enlarged nor withdrawn. + +**Attribution:** Dylan Roy — delegated AI work/review. C96 author: OpenAI/Codex coordinating root01a0adb2. Nonauthor reviewer: OpenAI/Codex `/root/aud023_review`, prior program/source exposure disclosed; not clean-context. Delivery: OpenAI/Codex root01a0bbb5, author of C95 input, custody only for C96 and no additional mathematical acceptance credit. Dylan personal reading PENDING; independent human review NONE; organizational independence 0; scientific effect NONE. diff --git a/frontiers/planar_soft_layer_chain_20261003/C96/PROOF.md b/frontiers/planar_soft_layer_chain_20261003/C96/PROOF.md new file mode 100644 index 000000000..93e373427 --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C96/PROOF.md @@ -0,0 +1,151 @@ +Frozen full proof identity: **7657 UTF-8 bytes**, SHA256 `7198ff636e330749428ded6938776dad612f6bdb51ad62359b445f016df13a7a`, final newline included. Native pickup: [5965119121](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965119121). + +# Designated maximin level equals the ordinary-superlevel H0 death + +Object: C96-DESIGNATED-MAXIMIN-TO-H0-20261003-v1. +Author: OpenAI/Codex coordinating `/root` session, acting for Dylan Roy — +delegated AI work. Disposition: source-exposed author-side composition and +verified reproduction; nonauthor review pending. Personal reading PENDING; +organizational independence 0; scientific effect NONE. + +This note supplies the explicit event-identification step deliberately left +outside C95. It proves the deterministic statement directly and then applies +it to C95's actual determinant-weighted event. The deterministic content is +already asserted in the pinned parent and public pairing-gap record; it is not +claimed as a new theorem. + +## 0. Exact inputs and scope + +- C95 proof: main issue 229 comment 5964938563, 16185 UTF-8 bytes, + SHA256 `c0d9ee72352fafe91f96a8b6187c978f09ee3c187d5f4c7c2462c0187750d2e1`. + Its G13--G18 define the actual maximin event and prove the weighted bounds. +- C95 fresh review: comment 5965062739. Its scoped PASS leaves this H0 + identification outside the reviewed C95 object. +- Parent [P]: `imports/lifetime_parent_20260925/ + UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, git blob + `dfed3b8d318a3ab1950957f393307733a4bef3f2`, especially section 8. + Its source-bound review is blob + `bc11369c41ebc76de5700df3f931939ccfc88b9b`; the chain reconciliation is + blob `75da2597971510f843f8d90c743950cb8c177342`. Both bind the same parent + bytes, and the review records section 8 as previously accepted. +- Public cross-check: `incoming/grok-session-20260926-replay/ + PAIRING_IMPLICATION_GAP.md`, blob + `47a71054ebe72588c2f9405292e575dababa84e4`, at main + `3a896badf5404f7e9c98486af3859ee5d6c829d1`. + +The parent already states that, on the Morse/distinct-critical-value locus, +its maximin equality expresses ordinary elder death. The proof below exposes +that implication in full at the exact convention consumed here. It does not +identify a gradient branch, require Morse--Smale transversality, prove an +all-bars/local-witness converse, or change any parent disposition. + +## 1. Deterministic lemma + +Let X be a compact connected smooth manifold and let f:X->R be Morse with +distinct critical values. For a local maximum M define + + d_f(M)=sup_{gamma(0)=M, f(gamma(1))>f(M)} min_t f(gamma(t)), (D1) + +where paths are continuous and the supremum of the empty family is minus +infinity. Let S be an index-(dim X-1) critical point with +f(S)=a}. Two points lie in the same path +component of X_a exactly when a path joining them has minimum at least a. +Consequently (D1) is the largest level, in the supremal sense, at which the +component issued from M can meet a point born strictly earlier, i.e. a point +x with f(x)>f(M). + +Assume first d_f(M)=c:=f(S). For every a>c there is no path in X_a from M +to a point higher than M: such a path would make d_f(M)>=a. For every af(M) whose minimum is greater than a (otherwise c could not be the +supremum). Thus, while the superlevel decreases, the component born at M is +separate from every older component above c and is joined to an older +component immediately below c. + +The superlevel component partition is locally constant on intervals that +contain no critical value. Hence c is a critical value at which that merge +occurs. Critical values are distinct, and S is the unique critical point at +level c. Therefore the merge occurs at S. Equivalently, for -f the +index-one handle attached there joins two previously distinct components; +it cannot be a handle whose ends lie in one component, because the preceding +component change is forced. The newly joined component contains a point of +height strictly greater than f(M), so its elder was born above M. The elder +rule therefore kills the class born at M, rather than the older class, at S. +The path family is nonempty because its supremum is the finite number c, so +M is not the global maximum and the class is finite. + +Conversely, suppose the class born at M dies at S and put c=f(S). Before +the death, at every regular level a>c sufficiently close to c, the component +of M contains no older component. Hence no path from M to a point higher +than M can have minimum greater than c; otherwise the two components would +already have met above the declared death level. Thus d_f(M)<=c. Immediately +below c the merging component contains an older maximum, so for every regular +a=a for all such a, and letting a +increase to c gives d_f(M)>=c. Hence d_f(M)=f(S). + +Using open superlevels instead of closed superlevels changes only endpoint +decoration. The numerical birth and death critical values, and therefore the +lifetime, are unchanged. QED. + +## 2. Actual weighted C95 corollary + +Use exactly the fixed planar finite-torus setting, pins, law Q_r, determinant +weight W_r, full normalizer Z_r and weighted law Q_r^W of C95. Let + + A_r={D_f(M_r)=f(S_r)} + +be C95 G16's actual maximin event, and let + + H_r={the finite ordinary-superlevel H0 class born at M_r dies at S_r}. + +On the support of Q_r^W, W_r>0 almost surely; hence M_r is a nondegenerate +maximum and S_r is a nondegenerate index-one saddle. Parent [P] section 8 +proves that at each fixed r the pinned field is Q_r-almost surely Morse with +distinct critical values. Since Q_r^W is absolutely continuous with respect +to Q_r and 0=a} is exactly the existence of a continuous path with minimum at least a. On a compact Morse manifold these superlevel components have the usual finite handle description. If such a component contains a point with f(x)>f(M), its maximum value is attained and exceeds f(M); its elder birth is therefore strictly older than M's. A higher point need not itself be a critical point. This supplies the precise meaning of C96's shorthand “point born strictly earlier.” + +Let c=d_f(M)c there is no connecting path to a higher endpoint at level a. For every ac would already merge it with an older component at any suitable regular level between c and min(t,f(M)), contradicting the declared death. Hence d_f(M)<=c. At every sufficiently close regular level a=c. Equality follows. + +The nonempty higher-endpoint family excludes the global maximum. For a connected closed manifold with distinct critical values, that unique global maximum supplies the ordinary essential H0 class; the designated class here is finite. Birth and death are f(M) and f(S), with positive lifetime f(M)-f(S). Switching open/closed superlevel conventions changes endpoint decoration, not those numerical values. No claim about a particular decoration is needed. + +These steps establish both directions for the **designated pair**. They neither identify an unstable branch nor require Morse–Smale/no-saddle-connection assumptions. The converse just proved is not the distinct, still-excluded converse that every small bar has a local witness in E. + +## 3. Pinned genericity, measurable events and weighted support + +Parent §8 works separately for every fixed positive r and parameter. Its overdetermined maps have target dimensions 2d versus domain 2d-1 for a degenerate critical point, 2d+1 versus 2d for tied distinct unpinned critical values, and d+1 versus d for a tie to a pinned height. Positive conditional finite-jet covariance, compact exhaustion away from pins/diagonals, and bounded Gaussian densities justify the mesh/derivative-truncation zero-exclusion argument. At the pins, the Hessian density gives nonzero determinants almost surely; the two prescribed heights differ. These are the precise fixed-r Morse/distinct-value inputs used here. A common probability-one set for an uncountable family of laws is neither supplied nor needed. + +The weighted law obeys dQ_r^W=(W_r/Z_r)dQ_r with 00. C95's uniform positive sector coefficient and full-normalizer bounds supply that positivity for sufficiently small r. Hence G16, G17 and G18 give D3, D4 and D5 respectively, with **the same orders, normalization and parameter dependence**: + + Q_r^W(E minus H_r) <= C r^(7/2), + Q_r^W(E intersect H_r)=r^3 m_E/z_0+O(r^(7/2)), + Q_r^W(H_r | E)=1-O(sqrt(r)). + +No extra loss or unproved branch-adjacency factor appears. Null-set transfer is performed at each fixed parameter; the inherited numerical inequalities remain uniform over C95's fixed compact birth set and frames. This does not require an uncountable intersection of almost-sure events. + +The law still uses the actual full normalizer Z_r. E has mass of order r^3, so the conditional tendency to one is not an unconditional tendency to one. Lambda remains fixed and finite, the field remains planar on the fixed finite torus, and k remains 1. + +PASS closes only this designated maximin/H0 translation and its displayed weighted corollary. It does not close the all-bars/local-witness converse, rejected-side/chord estimates, shrinking witness collisions, intermediate/coarea composition, unbounded Lambda, all marks, other-dimensional probability bounds, or global density/remainder completion. Existing source verdicts, proof bodies, scientific registers, formal-alignment obligations and independent-human-review predicates are unchanged. + +## 5. Delivery and release + +This is a written topological/measure-theoretic review. No numerical checker, finite path sampling, CI run or formal-tool run was used to claim the equivalence; such tests would not establish it. Execution in this review was limited to source retrieval, identity recomputation and publication/readback custody. + +My bounded C96 nonauthor review assignment is **COMPLETE / RELEASED** with this source-bound delivery. The [C96 author pickup](https://github.com/d6g8k5htny-coder/main/issues/229#issuecomment-5965119121), C95 author/delivery ownership and other agents' scopes remain untouched. No proof edit, status change, branch write, merge, Drive write, or R17 transition is represented by this comment. diff --git a/frontiers/planar_soft_layer_chain_20261003/C97/CHECKER_COMMENT.md b/frontiers/planar_soft_layer_chain_20261003/C97/CHECKER_COMMENT.md new file mode 100644 index 000000000..19854a21c --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C97/CHECKER_COMMENT.md @@ -0,0 +1,305 @@ +# C97 independent checker and exact deterministic stdout + +Paired evidence for the full review by OpenAI/Codex `/root/c95_fresh_review`, Dylan Roy — delegated AI review. This is supporting algebra/execution evidence, not an additional mathematical review. Personal reading PENDING; organizational independence0; scientific effectNONE. + +Actual Python3.12.14 executions: normal, -O and -S, all exit0; stdout byte-identical. Per run11000 exact rational controls,214 rational rejected-saddle fixtures,21 rejected false-inference fixtures. Standard library only; no author/feasibility code imported. Finite tests do not establish Gaussian estimates, topology, H0 identification or uniform limits. + +Save the first fence including its final newline as checker.py. It is10559 UTF-8 bytes, SHA256 `863f0f80edc144e394e5e23149d0d048ff5c09a802a3086cafcaaeeceee3c334`. The second fence's exact stdout including final newline is1737 UTF-8 bytes, SHA256 `41f5d16c4dd0ad6ed90b7d18b1ba9a41c37a9feb3ab5ad214813918dd12cdb72`. + +## Full independent source + +```python +"""Independent C97 rational controls; no author/feasibility/prior-checker imports. +Finite controls do not establish Gaussian, topology, H0 or uniform-limit facts. +""" +from fractions import Fraction as F +from itertools import product + +counts = {} +negatives = [] + + +def verify(group, value): + if not value: + raise RuntimeError('exact control failed: ' + group) + counts[group] = counts.get(group, 0) + 1 + + +def falsify(name, proposition): + if proposition: + raise RuntimeError('false inference survived: ' + name) + negatives.append(name) + + +def cubic(u, z, psi, c, R): + return 2*u**3-F(3,2)*u-F(1,2)-(psi+2*c*u)*z*z/48+R*z**3/3456 + + +def jet(u,z,psi,c,R): + pu=6*u*u-F(3,2)-c*z*z/24 + pz=-(psi+2*c*u)*z/24+R*z*z/1152 + det=12*u*(-(psi+2*c*u)/24+R*z/576)-(c*z/12)**2 + return pu,pz,det + + +# Build exact critical points from the conic, rather than a floating solver. +rejected = 0 +for sigma,z,gap in product([F(i,4) for i in range(-12,17)], + [F(-24),F(-12),F(-3),F(3),F(12),F(24)], + [F(1,100),F(1,10),F(1),F(2)]): + c=36*(sigma*sigma-1)/(z*z) + psi=abs(c)+gap + R=48*(psi-c*sigma)/z + u=-sigma/2 + pu,pz,det=jet(u,z,psi,c,R) + h=-cubic(u,z,psi,c,R) + axial=u+F(1,2) + kappa=(psi-c)/48 + rho2=3*axial*axial+kappa*z*z + T3=2*axial**3-c*axial*z*z/24+R*z**3/3456 + verify('critical and Euler identities', pu==pz==0) + verify('critical and Euler identities', det==(c-sigma*psi)/4) + verify('critical and Euler identities', 3*T3==2*rho2 and h==rho2/3>0) + verify('critical and Euler identities', -h==(sigma-1)/2-psi*z*z/144) + coefficient=(R*R-64*c**3)/2304 + verify('finite branch polynomial', coefficient*z*z-psi*R*z/24+psi*psi-c*c==0) + disc=(psi*R/24)**2-4*coefficient*(psi*psi-c*c) + verify('finite branch polynomial', disc==c*c*(R*R+64*c*(psi*psi-c*c))/576) + for t in [F(0),F(1,3),F(1),F(3,2),F(2)]: + verify('exact chord restriction', cubic(-F(1,2)+t*axial,t*z,psi,c,R)==h*(2*t**3-3*t*t)) + if det<0 and 0=ch*s**3/pj**6) +verify('nonempty rational coverage', rejected>0) + +# Explicit exceptional branches, not an implicit genericity restriction. +c,psi,R=F(1),F(2),F(8) # degree drop R^2=64 c^3 +az=(R*R-64*c**3)/2304 +z=(psi*psi-c*c)/(psi*R/24) +sigma=(psi-R*z/48)/c +verify('exceptional branches', az==0 and psi*R!=0 and z!=0) +verify('exceptional branches', jet(-sigma/2,z,psi,c,R)[:2]==(0,0)) +falsify('quadratic division at degree drop', az!=0) +c,psi,R=F(-1),F(5,4),F(6) # exact tangency +verify('exceptional branches', R*R+64*c*(psi*psi-c*c)==0) +z=(psi*R/24)/(2*(R*R-64*c**3)/2304) +sigma=(psi-R*z/48)/c +verify('exceptional branches', jet(-sigma/2,z,psi,c,R)==(0,0,0)) +falsify('count tangency as nondegenerate saddle', jet(-sigma/2,z,psi,c,R)[2]<0) +for psi,R in product([F(1,8),F(1),F(3)],[F(-16),F(2),F(8)]): + z=48*psi/R + verify('exceptional branches', jet(-F(1,2),z,psi,0,R)==(0,0,-psi/4)) + verify('exceptional branches', cubic(-F(1,2),z,psi,0,R)==-16*psi**3/R**2) +verify('exceptional branches', jet(F(0),F(1),F(2),F(0),F(0))[1]!=0) + +# Endpoint clearance is separate from saddle clearance. +h,mu=F(1,16),F(15,16) +endpoint_error=-F(1,2) +verify('two margins', abs(endpoint_error)0) +for h in [F(i,40) for i in range(1,40)]: + mu=1-h + eps=min(mu,4*h)/3 + verify('two margins', -h-eps>-1 and 4*h-eps>0) + verify('two margins', min(mu/2,2*h)==min(mu,4*h)/2) + for t in [F(i,10) for i in range(21)]: + verify('two margins', h*(2*t**3-3*t*t)>=-h) +falsify('endpoint margin bounded below on rejected sector', 4*F(1,10**6)>=F(1,10)) + +# Rationalize sqrt(s), keeping the exact 1/sqrt(3) factor squared. +for gamma,lam,sroot,Bextra,C in product([F(-3),F(1,2)], [F(1),F(3)], + [F(1,3),F(1),F(2)], [F(0)], [F(-2),F(0),F(4)]): + s=sroot*sroot + B=(s-24*lam+gamma*gamma)/12+Bextra + D=gamma*gamma-12*B + J=8*gamma**3-144*B*gamma+576*C + psi=24*lam/gamma**2; c=D/gamma**2; R=J/gamma**3 + kappa=s/(48*gamma**2) + # sqrt(3) tau from raw cancellation and from each original term. + tau_scaled=F(2,3)+2*abs(D)/s+abs(J)/(6*sroot**3) + term2=abs(c)/(24*kappa) + # sqrt(3)/(3456*kappa^(3/2)) = abs(gamma)^3/(6*sroot^3). + term3=abs(R)*abs(gamma)**3/(6*sroot**3) + verify('tau chart cancellation', tau_scaled==F(2,3)+term2+term3) + tau_sq=tau_scaled*tau_scaled/3 + numerator=F(4,9)*s**3+4*D*D*s+J*J/36 + verify('tau bound constants', tau_sq<=numerator/s**3) + pj=1+abs(gamma)+abs(B)+abs(C) + astar=48*(2*lam) + ct=F(4,9)*astar**3+676*astar+F(728**2,36) + verify('tau bound constants', numerator<=ct*pj**6 and 0=min(mu/2,2*h): + verify('event unions', e0>=mu/2 or e0>=2*h) + if e0>=mu/2: + verify('event unions', 0=d) + +beta=F(1,16); margin=F(1,2); p=2; e=1-4*beta +ledger=[8*beta,1+4*beta,F(2,3)*e,1+e/3,margin,F(1),p*(e-margin)] +verify('complete exponent ledger', ledger==[F(1,2),F(5,4),F(1,2),F(5,4),F(1,2),F(1),F(1,2)]) +verify('complete exponent ledger', min(ledger)+3==F(7,2) and F(7,2)-3==F(1,2)) +verify('complete exponent ledger', 1-beta>0 and e>0) +falsify('p=1 retains claimed half exponent', (e-margin)>=F(1,2)) +falsify('endpoint power improves to e', F(2,3)*e>=e) + +# Positive sector witness with radicals eliminated by R^2=32 psi^3. +for Lambda in [F(1,100),F(1,3),F(1),F(20)]: + lam=Lambda/2; psi=12*Lambda; gamma=F(1); B=F(1,12) + Rsq=32*psi**3 + h=16*psi**3/Rsq + aM=24*lam-gamma*gamma+12*B + aS=24*lam+gamma*gamma-12*B + verify('positive sector witness', aM==aS==12*Lambda>0 and h==F(1,2)) + verify('positive sector witness', -psi/4<0 and 00, gap mark k=1, birth b in a fixed nonempty compact set B0 and all +orthonormal frames. In frame coordinates the exact pins are +M_r=(-r/2,0), S_r=(r/2,0), f(M_r)=b, f(S_r)=b-r^3 and zero gradients. +Q_r is the continuous Gaussian regression law at these pins, + + W_r=|det H_M det H_S| 1{H_M<0, index(H_S)=1}, + Z_r=E_Q[W_r], Q_r^W=(W_r/Z_r)Q_r, + A=f_zz(0), lambda=-A/r, + t=(gamma,B1,C3)=(f_xxz(0),f_xzz(0),f_zzz(0)), + Pjet=1+|gamma|+|B1|+|C3|, + N=1+max_{|alpha|<=4} sup_torus |D^alpha f|, + D_Lambda={|lambda|<=Lambda}, 00,a_S>0}, A_*=48Lambda and w_lambda=a_M a_S/16 on T. +The rescaled finite measure is mu_r(B)=r^(-5)E_Q[W_r 1_B] on D_Lambda; +for events depending on the whole field the same notation denotes this +expectation, not a fictitious jet-only conditional law. The model measure +is dmu_0=rho_0(0,t)w_lambda d lambda dt on T, where rho_0 is the JOINT +contact Gaussian density retained by C92. Its A-marginal density is not +divided out. Full normalization is + + Q_r^W(B)=r^3 mu_r(B)/z_r, z_r=Z_r/r^2=z_0+O(r), z_r>=z_*/2>0. (R1) + +On T, gamma!=0, define + + D=gamma^2-12B1, J=8gamma^3-144B1 gamma+576C3, + psi=24lambda/gamma^2, c=D/gamma^2, R=J/gamma^3, + u=X+gamma zeta/12, Z=gamma zeta, + P(u,Z)=2u^3-3u/2-1/2-(psi+2cu)Z^2/48+RZ^3/3456. (R2) + +Here P denotes the cubic, distinct from Pjet. Its pins M=(-1/2,0), +S=(1/2,0) have values0,-1. Typing is psi>|c|. C91/C92 give the exact +raw cubic identity G(X,zeta)=P(u,Z). If +F_r(X,zeta)=[f(rX,r zeta)-b]/r^3 and E_r=F_r-G, then for w>=1, + + E0(r,w):=sup_{|X|,|zeta|<=w}|E_r| <= K0 N r w^4, + K0=167/192, provided 2rw<=L/4. (R3) + +Let mu=max{P(Y)+1:Y is an extra nondegenerate saddle}, or -infinity if +there is no such point. Define the rejected sector + + Rsec={D_Lambda, T, gamma!=0, mu>0}. (R4) + +The symbol Rsec is not the coefficient R in (R2). No A1 elder-sector +inequality is imposed here. Let H_r be C96's designated finite ordinary- +superlevel H0 pairing event, defined false off the Borel Morse/distinct- +value typed-pin locus. Let A_r={D_f(M_r)=f(S_r)} in C95/C96's path convention. + +**Theorem R.** Uniformly over the stated fixed birth/frame parameters, +for sufficiently small r, writing m_R=mu_0(Rsec), + + 00, + T3(v)=2a^3-(c/24)az^2+(R/3456)z^3, + |T3(v)|<=tau_M rho^3, + tau_M=2/(3sqrt(3))+|c|/(24sqrt(3)kappa_M) + +|R|/(3456 kappa_M^(3/2)). (R6) + +At any critical Y!=M, the derivative along v=Y-M is zero. Euler's +identity for the homogeneous terms gives -2rho^2+3T3(v)=0. Consequently + + h:=-P(Y)=rho^2/3>0, + rho>=2/(3tau_M), h>=4/(27tau_M^2). (R7) + +The first inequality uses rho>0, so division by rho^2 is valid. For the +selected saddle on Rsec, h=1-mu and therefore 00 and q<1, so sigma^2-1<4x=4h+2(sigma-1). +Since h<1, -1-1 along K and g(2Y-M)>0. Hence d_g(M)>-1. +The second margin4h cannot be replaced by mu when mu approaches1. +No Hessian or gradient-path hypothesis is needed for this sufficient path. + +## 2. Endpoint margin in raw jets + +Put s=a_M in(0,A_*). Substitution in (R6) cancels the gamma chart poles: + + tau_M=(1/sqrt(3))[2/3+2|D|/s+|J|/(6s^(3/2))]. (R12) + +The three-term square inequality gives + + tau_M^2 <= [4s^3/9+4D^2 s+J^2/36]/s^3. + +Since |D|<=13 Pjet^2, |J|<=728 Pjet^3 and Pjet>=1, set + + Ctau=(4/9)A_*^3+676 A_*+728^2/36, + c_h=4/(27 Ctau)>0. + +Equations (R7) and (R12) imply the uniform pointwise bound + + h>=c_h a_M^3/Pjet^6. (R13) + +All constants are explicit functions of the fixed Lambda. They need not +be optimized. The power3 is retained; no false positive uniform margin or +finite untruncated inverse third moment is claimed. + +## 3. Actual weighted radius and endpoint-error integrals + +For any fixed finite p,q>=0, C93 E7/E8 supplies the joint integrand bound + + C exp(-c0|t|^2)[w_lambda Pjet^(p+q)+r Pjet^(p+q+4)] (R14) + +for mu_r with factor N^p Pjet^q. This came from conditional Gaussian +moments before integration; it preserves dependence of N on the jets. + +For rho>0, the event Rch>5/2+rho implies +lambda5/2+rho}; N^p Pjet^q) + <=C_(p,q)(rho^-8+r rho^-4). (R15) + +Next put e=rw^4, epsilon=K0 e/(2c_h). The endpoint-failure event +E0(r,w)>=2h on Rsec implies epsilon N Pjet^6 a_M^-3>=1 by (R3)/(R13). +For 0=2h}) + <=C[d^2+rd+epsilon^2(d^-4/4+r d^-5/5)]. (R16) + +The away integrals are integral_d^A_* (s^-5+r s^-6)ds, bounded by the +displayed inverse powers. Taking d=epsilon^(1/3)<=min(1,A_*) gives + + mu_r(Rsec intersect {E0>=2h}) + <=C(e^(2/3)+r e^(1/3)). (R17) + +If d=A_* the away set is null and the strip alone suffices. This truncation +never applies an unbounded inverse margin to an L1 error. The finite-r term +r e^(1/3) is essential to the available bound and is kept. + +For the other margin, C94 C11 gives the actual deterministic-width band +mu_r(T intersect {|mu|<=delta})<=C(delta+r), 0=d}, together with C92's +weighted moment estimate and (R3), gives for each fixed p>=1 + + mu_r(Rsec intersect {E0>=mu/2})<=C[d+r+(e/d)^p]. (R18) + +The band width2d is deterministic, not a function of the inner psi variable. +The Taylor estimate uses E_Q[W_r N^p 1_D]=O(r^5). An unweighted field-norm +probability is not substituted for that correlated weighted estimate. + +## 4. Rejection with an actual-field error rate + +Define a measurable event inside Rsec by + + Good_R(r,w)={Rch<=w, E0(r,w)<(1/2)min(mu,4(1-mu))}. (R19) + +The sup defining E0 is over a compact raw window and equals the supremum +over a fixed countable dense subset for continuous fields. All jet functions +are Borel by the finite-branch construction. Thus Good_R is measurable, +even without selecting a continuous highest-saddle branch. + +For w>=5 with 2rw<=L/4, e sufficiently small, and 0=w/2 in (R15). If E0 reaches the half-minimum in (R19), +it reaches either mu/2 or2h, so both bad events are included. There is no +independence assumption in this union bound. Choose the fixed exponents + + w=r^-1/16, d=r^1/2, p=2, e=r^3/4. (R21) + +For sufficiently small r, all cutoff and physical-window restrictions hold. +The bracket exponents in (R20), in order, are + + 1/2, 5/4, 1/2, 5/4, 1/2, 1, 1/2. + +Consequently + + Q_r^W(Rsec minus Good_R)<=Cr^(7/2). (R22) + +On Good_R, (R9) places K in the raw window. The exact pins and (R19) +imply (R11), so its physical image is a path from M_r to a point higher +than b whose values stay strictly above b-r^3. The patch embeds into the +torus for the stated small-window condition, in every orthonormal frame. +The strict inequality on the compact chord supplies a positive clearance; +therefore D_f(M_r)>f(S_r), not merely a weak inequality. + +It follows that {D_f<=f(S_r)} intersect Rsec is contained in Rsec minus +Good_R. C96 identifies H_r=A_r Q_r^W-a.s., at each fixed parameter/r, +using the retained parent Morse/distinct-value result and absolute +continuity under the actual determinant weight. No common probability-one +set over an uncountable family is required. Thus Rsec intersect H_r is +also bounded by (R22). This proves the two error assertions in (R5). + +## 5. Positive rejected-sector mass and normalized conclusion + +An explicit interior witness proves positivity. Set lambda=Lambda/2, +gamma=1, B1=1/12, hence c=0 and psi=12Lambda>0. Choose + + R=sqrt(32 psi^3), C3=(R+4)/576. + +The extra saddle has sigma=1 and Z=48psi/R, so +P(Y)=-16psi^3/R^2=-1/2 and mu=1/2. It is nondegenerate, since +det Hess P=-psi/4<0, and T is strict. Its continuation to a small open +jet neighborhood still has P(Y)+1>0, giving a positive-volume subset of +Rsec inside D_Lambda; other saddles do not remove that property. +The determinant factor and joint Gaussian density have a positive lower +bound on a smaller compact box, uniformly in the compact birth/frame +parameters by C92. Therefore 0f(S_r)} because its complement costs (R22). + +Combining, without enlarging either domain, with C95/C96 on their E gives + + Q_r^W((E union Rsec) intersect (H_r symmetric_difference E)) + <=C r^(7/2). (R24) + +Here E and Rsec are disjoint because their mu signs differ. The specific +extra inequalities defining E are retained. We do NOT assert that their +union exhausts T or all actual weighted soft jets. + +## 6. Boundaries and verification role + +This is actual-field rejected-sector control for one designated pair with +the full normalizer. The finite chord criterion is a sufficient geometric +certificate, not a statement about gradient trajectories. The old condition +|e|0, gap markk1, a fixed nonempty compact birth setB0, all orthonormal frames and fixed finiteLambda>0. C92's pin law is the continuous Gaussian regression at the original six endpoint observations, not a new law conditioned on the sector. The weight retains the actual maximum/saddle typing and both absolute Hessian determinants. Its full expectation is `Z_r=r^2 z_r`, where `z_r=z0+O(r)` has a uniform positive floor. + +The soft-coordinate numerator has scale r^5: dA=r d lambda and W_r=r^4D_r. Thus the identity `Q_r^W(B)=r^3 mu_r(B)/z_r` is exact for field events as well as jet events in D_Lambda. For field events, mu_r means the displayed weighted expectation; it is not incorrectly represented as a function of jets alone. No pin-density factor or probability-normalized conditional t-density replaces the JOINT contact slice rho0(0,t). + +The exact C91/C92 raw identity at gamma!=0 gives R2 and the value error bound R3 with K0=167/192. On T, a_M+a_S=48lambda>0, and the positivity of both edges is exactly psi>|c|. Rsec is defined by a model-jet saddle condition under the actual weighted law, with no unrecorded A1 elder restriction. The theorem concerns a designated pair and the event `D_f<=f(S_r)`, not just the equality event. Its H_r statement is a subsequent a.s. event-identification consequence. These distinctions are retained correctly. + +## 3. R6–R11: all finite branches, two margins and the actual chord + +C82's extra-point identities follow directly from the displayed cubic. For c!=0 the eliminated quadratic is + +`[(R^2-64c^3)/2304] Z^2 -(psi R/24)Z +psi^2-c^2=0`, + +with sigma=(psi-RZ/48)/c and determinant `(c-sigma psi)/4`. The constant term is strictly positive, so an extra root never has Z0. If the quadratic coefficient vanishes, c>0 and R!=0 and the linear coefficient is nonzero; there is at most one finite root, not a hidden root at infinity. The negative-c tangency has determinant0 and is excluded from the saddle set. At c0,R!=0, sigma=±1 and Z=48psi/R, with only sigma1 a saddle; at c=R0 there is no extra root. Hence there are at most two finite extra nondegenerate saddles everywhere in the typed chart, including the exceptional cases. + +These finite algebraic branches can be described with Borel coefficient/discriminant/type guards and separated degree-drop cases. A guarded finite maximum is Borel. On Rsec it is attained, and lexicographic comparison of the finitely many candidate coordinates breaks ties measurably. Neither continuity of the highest branch across ties nor a saddle at infinity is required. + +At M, the quadratic form is strictly negative definite: `P(M+v)=-rho^2+T3(v)`, `rho^2=3a^2+kappa_M z^2>0` for v!=0. At a critical Y!=M, differentiating along v gives `-2rho^2+3T3(v)=0`. Therefore `P(Y)=-rho^2/3<0`, and the local cubic estimate gives `rho>=2/(3tau_M)` after division by the positive rho^2. It follows that `h=-P(Y)>=4/(27tau_M^2)`. For the selected rejected saddle, h=1-mu and consequently00 and q=c/psi<1, the conic and value identities give `sigma^2-1=4qx`, `h=x-(sigma-1)/2`. Strict inequality q<1 yields `(sigma-1)^2<4h`. Since h<1, sigma lies in(-1,3), and `0=1 and0=c_h s^3/Pjet^6`. This is a pointwise correlated lower bound, not a uniform positive h or an integrability assertion for an untruncated inverse cube. + +The R14 envelope is C93's conditional-moment statement used BEFORE integration. Its leading term has w_lambda, but its finite-r remainder does not vanish at the model typing edge. Both N^p and Pjet^q remain inside the actual weighted disintegration. C92's joint Gaussian envelope and C93 E7/E8 support this operation; no E[weight]E[norm] factorization is assumed. + +For the radius event, rearranging the explicit Rch gives `lambda<(3/8)(|gamma|+12)^2/rho^2`. The B1-to-a_S substitution has absolute Jacobian1/12, domain0=2h and E0<=K0Ne imply `epsilon N Pjet^6 s^-3>=1`, epsilon=K0e/(2c_h). Away from s=mu/2 then either0=d. C94 C11 applies to the first with deterministic width2d<=1/2. Its source is C82's deterministic band theorem under the joint Gaussian slice, not independent reference Gaussian jets: `w_lambda d lambda=(gamma^6/384)(psi^2-c^2)dpsi`, and `gamma^6|c|^3=|D|^3`, `gamma^6R^2=J^2` cancel the chart poles before Gaussian integration. The width is held fixed during psi integration. The second event is bounded by the determinant-weighted Markov estimate, using `E_Q[W_r N^p 1_D]=O(r^5)`. This proves R18 with d+r+(e/d)^p. Neither a bare field-norm probability nor a psi-dependent width is used. + +## 5. R19–R22: measurable certificate and the entire exponent ledger + +Rsec is Borel by the finite guarded algebraic branches. E0 is measurable as a compact-window supremum of a continuous field, equivalently over a fixed countable dense subset. Thus Good_R is measurable without a continuous choice of Y. Gamma0 is null under Q_r by C92's nondegenerate finite-jet density and remains null under the integrable actual tilt. + +Failure of the half-minimum in R19 is contained in the union of E0>=mu/2 and E0>=2h. Radius failure uses rho=w-5/2>=w/2 for w>=5. Applying R15/R17/R18 and the SAME full conversion r^3/z_r gives R20. Union bounds require no independence among the radius, error, margin, determinant or field norm. + +At w=r^-1/16, e=rw^4=r^3/4, level width d=r^1/2 and fixed p2, the seven bracket exponents are exactly + +| Term | Power of r | +|---|---:| +| w^-8 | 1/2 | +| r w^-4 | 5/4 | +| e^(2/3) | 1/2 | +| r e^(1/3) | 5/4 | +| d | 1/2 | +| r | 1 | +| (e/d)^2 | 1/2 | + +Their minimum is1/2; multiplying by r^3 gives R22. In particular the endpoint error costs exactly the allowed half-power here, not the stronger e rate. A first-moment level estimate would only give a quarter-power with these choices; the fixed second moment is needed for this ledger. Physical window size rw=r^15/16 tends to0, so the embedding condition, w>=5 and every deterministic smallness/cutoff condition hold eventually. Moment orders and Lambda remain fixed. + +On Good_R the entire raw chord lies inside the controlled window. The exact raw identity transfers the value error without changing units. Its physical image projects to an actual torus path from M_r to f>b, and continuity plus the strict compact-chord margin gives minimum strictly above b-r^3. Consequently `D_f(M_r)>f(S_r)`; this is an actual path witness, not an assumption that the supremum over all torus paths is attained or stays in the patch. Adding other paths can only increase the supremum. Thus the event `Rsec intersect {D_f<=f(S_r)}` is contained in certificate failure and has the stated O(r^(7/2)) mass. + +## 6. C96/H0 application: exactly the designated finite-bar event + +C96's deterministic lemma applies to the actual closed torus. On the Morse/distinct-critical-value locus, path components of a superlevel set encode whether M has joined any point higher than f(M). A component with such a point has an elder maximum higher than M. Separation at every level above c and connection at every level below c characterize the merge value c; no attainment of the maximin supremum is needed. Distinct critical values make the designated saddle at c unique, and the index-one handle for -f merges the two components rather than attaching within one. The class born at M dies there under the elder rule. Conversely such a death forbids a path to a higher point above c and supplies paths immediately below c. This is the two-way maximin/H0 event equivalence, not gradient-branch adjacency or an all-bars/local-witness converse. + +The fixed-r genericity premise was checked in P§§2/8: positive Fourier spectrum gives full conditional rank for distinct derivative evaluations modulo the pins; overdetermined degeneracy/tie maps have target dimension strictly larger than their parameter dimension. On compact subsets separated from pins/diagonals, bounded Gaussian densities and derivative truncation yield zero exclusion; countable exhaustion covers the remaining domain. Pinned Hessians have densities and the pinned heights differ. The result is Q_r-a.s. Morse/distinct values at each fixed positive r and parameter. No common probability-one set for uncountably many laws is required. + +Since `dQ_r^W=(W_r/Z_r)dQ_r`, with00 and actual limiting determinant factor9Lambda^2>0. The selected sigma1 saddle has `P=-16psi^3/R^2=-1/2`, `det=-psi/4<0`. Its continuation persists by nondegeneracy in a small open jet neighborhood with mu>0. Even if another saddle later becomes higher, this continued positive saddle keeps the point in Rsec; continuity of the maximum branch across all possible switches is not needed. + +A smaller compact positive-volume box stays inside D_Lambda,T and gamma!=0 and retains a positive weight floor. C92's continuous uniformly nondegenerate joint Gaussian parameters over compact birth/frame space give a positive density floor on that box. Thus m_R has a uniform positive lower bound, not merely pointwise positivity. Its uniform finite upper bound follows from the full bounded-layer model mass. Fixed finite Lambda may affect these constants strongly; that is allowed. + +C92's weighted L1 comparison applied to the bounded fixed Rsec indicator and its full-normalizer expansion gives `Q_r^W(Rsec)=r^3 m_R/z0+O(r^4)`. Subtracting the nonnegative O(r^(7/2)) H_r mass proves the complement-mass statement in R5, since r^4<=r^(7/2) for small r. The same argument with the stronger D_f failure gives the leading mass for Rsec intersect{D_f>f(S_r)}. Bounds above and below for z0, together with the uniform m_R floor, imply Q_r^W(Rsec)>=c r^3 eventually. Division then yields `Q_r^W(H_r|Rsec)<=C sqrt(r)`. It is not an unconditional probability statement about all pairs or all bars. + +Finally E and Rsec are disjoint by their mu signs. The exact set identity is + +`(E union Rsec) intersect (H_r symmetric_difference E) = (E minus H_r) union (Rsec intersect H_r)`. + +C95/C96 bound the first part and C97 bounds the second, giving R24. The explicit extra inequalities in E remain. No argument here shows E union Rsec equals T, and R24 is not advertised as such. Neutral/model-typing exclusions, outside-sector jets, all-mark/unbounded-Lambda regimes and other dimensions are not silently included. + +## 8. Independent actual execution and meaningful failures + +The new independently written standard-library `checker.py` was executed under actual Python3.12.14 in normal, -O and -S modes. All three exited0; pairwise stdout comparisons exited0 and were byte-identical. Explicit RuntimeError checks survive optimization. Each mode performed11000 exact rational controls, including214 rational rejected-saddle fixtures, and rejected21 false-inference fixtures. Repetitions are one suite, not three independent reviews. No author or feasibility code was used. + +Checker: 10559 UTF-8 bytes, SHA256 `863f0f80edc144e394e5e23149d0d048ff5c09a802a3086cafcaaeeceee3c334`. + +Each stdout: 1737 UTF-8 bytes, SHA256 `41f5d16c4dd0ad6ed90b7d18b1ba9a41c37a9feb3ab5ad214813918dd12cdb72`. + +Complete source and deterministic stdout accompany this review in a paired native comment. Controls construct critical points directly from the conic, test Euler/chord identities and exceptional degree-drop/tangency cases, radius corners and chart signs, endpoint lower bounds and pole cancellation, exact integral primitives, the correlated-moment obstruction, optimized split/rate ledger, the positive witness and full normalization/set algebra. The negative fixtures reject division at degree drop, counting tangency as a nondegenerate saddle, the mu-only endpoint inference, a false uniform endpoint margin, pointwise gamma0 chart, dropped Jacobian/finite-r terms, inverse-power mistakes, independent-moment factorization, insufficient moment order, an improved but unsupported endpoint exponent, soft-layer renormalization, absent uniform sector floor, growing-Lambda extrapolation and false domain exhaustion. + +These are rational transcription/algebra diagnostics, not a sample-based proof of universal Gaussian inequalities, topology, H0 equivalence or uniform limits. Those conclusions are supported by the written reconstruction and explicitly retained source theorems above. Verification guidance was used to run the final frozen checker and compare actual output; it supplies no independent mathematical predicate. The coordinator may replay these exact files for publication custody, with no additional checker-author or review credit. + +## 9. Final scope and release + +PASS closes this actual weighted rejected-sector/chord theorem, its designated C96 finite-bar implication and the limited R24 combination. It does not erase the old endpoint counterexample, enlarge C95/C96 historical scopes, accept literal A2v1, prove every-small-bar/local-witness converse, shrinking collisions, intermediate/coarea composition, unbounded-Lambda/all-mark/infinite-volume limits, whole-field TV, other-dimensional bounds or final global density/remainder closure. Scientific and human-review statuses are unchanged. + +The distinct review scope picked up at5965439551 is COMPLETE/RELEASED with this full source-bound delivery. Author root01a0bbb5 retains claim75797b63 and source/delivery custody. The coordinating root receives zero C97 acceptance credit. No proof amendments, author takeover, branch/merge/register/Drive changes or additional agent work are represented by this record. diff --git a/frontiers/planar_soft_layer_chain_20261003/C97/checker.py b/frontiers/planar_soft_layer_chain_20261003/C97/checker.py new file mode 100644 index 000000000..a06d9df9f --- /dev/null +++ b/frontiers/planar_soft_layer_chain_20261003/C97/checker.py @@ -0,0 +1,239 @@ +"""Independent C97 rational controls; no author/feasibility/prior-checker imports. +Finite controls do not establish Gaussian, topology, H0 or uniform-limit facts. +""" +from fractions import Fraction as F +from itertools import product + +counts = {} +negatives = [] + + +def verify(group, value): + if not value: + raise RuntimeError('exact control failed: ' + group) + counts[group] = counts.get(group, 0) + 1 + + +def falsify(name, proposition): + if proposition: + raise RuntimeError('false inference survived: ' + name) + negatives.append(name) + + +def cubic(u, z, psi, c, R): + return 2*u**3-F(3,2)*u-F(1,2)-(psi+2*c*u)*z*z/48+R*z**3/3456 + + +def jet(u,z,psi,c,R): + pu=6*u*u-F(3,2)-c*z*z/24 + pz=-(psi+2*c*u)*z/24+R*z*z/1152 + det=12*u*(-(psi+2*c*u)/24+R*z/576)-(c*z/12)**2 + return pu,pz,det + + +# Build exact critical points from the conic, rather than a floating solver. +rejected = 0 +for sigma,z,gap in product([F(i,4) for i in range(-12,17)], + [F(-24),F(-12),F(-3),F(3),F(12),F(24)], + [F(1,100),F(1,10),F(1),F(2)]): + c=36*(sigma*sigma-1)/(z*z) + psi=abs(c)+gap + R=48*(psi-c*sigma)/z + u=-sigma/2 + pu,pz,det=jet(u,z,psi,c,R) + h=-cubic(u,z,psi,c,R) + axial=u+F(1,2) + kappa=(psi-c)/48 + rho2=3*axial*axial+kappa*z*z + T3=2*axial**3-c*axial*z*z/24+R*z**3/3456 + verify('critical and Euler identities', pu==pz==0) + verify('critical and Euler identities', det==(c-sigma*psi)/4) + verify('critical and Euler identities', 3*T3==2*rho2 and h==rho2/3>0) + verify('critical and Euler identities', -h==(sigma-1)/2-psi*z*z/144) + coefficient=(R*R-64*c**3)/2304 + verify('finite branch polynomial', coefficient*z*z-psi*R*z/24+psi*psi-c*c==0) + disc=(psi*R/24)**2-4*coefficient*(psi*psi-c*c) + verify('finite branch polynomial', disc==c*c*(R*R+64*c*(psi*psi-c*c))/576) + for t in [F(0),F(1,3),F(1),F(3,2),F(2)]: + verify('exact chord restriction', cubic(-F(1,2)+t*axial,t*z,psi,c,R)==h*(2*t**3-3*t*t)) + if det<0 and 0=ch*s**3/pj**6) +verify('nonempty rational coverage', rejected>0) + +# Explicit exceptional branches, not an implicit genericity restriction. +c,psi,R=F(1),F(2),F(8) # degree drop R^2=64 c^3 +az=(R*R-64*c**3)/2304 +z=(psi*psi-c*c)/(psi*R/24) +sigma=(psi-R*z/48)/c +verify('exceptional branches', az==0 and psi*R!=0 and z!=0) +verify('exceptional branches', jet(-sigma/2,z,psi,c,R)[:2]==(0,0)) +falsify('quadratic division at degree drop', az!=0) +c,psi,R=F(-1),F(5,4),F(6) # exact tangency +verify('exceptional branches', R*R+64*c*(psi*psi-c*c)==0) +z=(psi*R/24)/(2*(R*R-64*c**3)/2304) +sigma=(psi-R*z/48)/c +verify('exceptional branches', jet(-sigma/2,z,psi,c,R)==(0,0,0)) +falsify('count tangency as nondegenerate saddle', jet(-sigma/2,z,psi,c,R)[2]<0) +for psi,R in product([F(1,8),F(1),F(3)],[F(-16),F(2),F(8)]): + z=48*psi/R + verify('exceptional branches', jet(-F(1,2),z,psi,0,R)==(0,0,-psi/4)) + verify('exceptional branches', cubic(-F(1,2),z,psi,0,R)==-16*psi**3/R**2) +verify('exceptional branches', jet(F(0),F(1),F(2),F(0),F(0))[1]!=0) + +# Endpoint clearance is separate from saddle clearance. +h,mu=F(1,16),F(15,16) +endpoint_error=-F(1,2) +verify('two margins', abs(endpoint_error)0) +for h in [F(i,40) for i in range(1,40)]: + mu=1-h + eps=min(mu,4*h)/3 + verify('two margins', -h-eps>-1 and 4*h-eps>0) + verify('two margins', min(mu/2,2*h)==min(mu,4*h)/2) + for t in [F(i,10) for i in range(21)]: + verify('two margins', h*(2*t**3-3*t*t)>=-h) +falsify('endpoint margin bounded below on rejected sector', 4*F(1,10**6)>=F(1,10)) + +# Rationalize sqrt(s), keeping the exact 1/sqrt(3) factor squared. +for gamma,lam,sroot,Bextra,C in product([F(-3),F(1,2)], [F(1),F(3)], + [F(1,3),F(1),F(2)], [F(0)], [F(-2),F(0),F(4)]): + s=sroot*sroot + B=(s-24*lam+gamma*gamma)/12+Bextra + D=gamma*gamma-12*B + J=8*gamma**3-144*B*gamma+576*C + psi=24*lam/gamma**2; c=D/gamma**2; R=J/gamma**3 + kappa=s/(48*gamma**2) + # sqrt(3) tau from raw cancellation and from each original term. + tau_scaled=F(2,3)+2*abs(D)/s+abs(J)/(6*sroot**3) + term2=abs(c)/(24*kappa) + # sqrt(3)/(3456*kappa^(3/2)) = abs(gamma)^3/(6*sroot^3). + term3=abs(R)*abs(gamma)**3/(6*sroot**3) + verify('tau chart cancellation', tau_scaled==F(2,3)+term2+term3) + tau_sq=tau_scaled*tau_scaled/3 + numerator=F(4,9)*s**3+4*D*D*s+J*J/36 + verify('tau bound constants', tau_sq<=numerator/s**3) + pj=1+abs(gamma)+abs(B)+abs(C) + astar=48*(2*lam) + ct=F(4,9)*astar**3+676*astar+F(728**2,36) + verify('tau bound constants', numerator<=ct*pj**6 and 0=min(mu/2,2*h): + verify('event unions', e0>=mu/2 or e0>=2*h) + if e0>=mu/2: + verify('event unions', 0=d) + +beta=F(1,16); margin=F(1,2); p=2; e=1-4*beta +ledger=[8*beta,1+4*beta,F(2,3)*e,1+e/3,margin,F(1),p*(e-margin)] +verify('complete exponent ledger', ledger==[F(1,2),F(5,4),F(1,2),F(5,4),F(1,2),F(1),F(1,2)]) +verify('complete exponent ledger', min(ledger)+3==F(7,2) and F(7,2)-3==F(1,2)) +verify('complete exponent ledger', 1-beta>0 and e>0) +falsify('p=1 retains claimed half exponent', (e-margin)>=F(1,2)) +falsify('endpoint power improves to e', F(2,3)*e>=e) + +# Positive sector witness with radicals eliminated by R^2=32 psi^3. +for Lambda in [F(1,100),F(1,3),F(1),F(20)]: + lam=Lambda/2; psi=12*Lambda; gamma=F(1); B=F(1,12) + Rsq=32*psi**3 + h=16*psi**3/Rsq + aM=24*lam-gamma*gamma+12*B + aS=24*lam+gamma*gamma-12*B + verify('positive sector witness', aM==aS==12*Lambda>0 and h==F(1,2)) + verify('positive sector witness', -psi/4<0 and 0=2*c and R*R<=16*(psi-2*c)**2*(psi+c) and negative) + check('exact selected-sector coverage', sector==negative) + if negative: + check('strict necessity', psi>2*c and R*R<16*(psi-2*c)**2*(psi+c)) + if mu==0: + check('neutral inclusion', R*R==16*(psi-2*c)**2*(psi+c)) + return mu,points + + +# Rational parametrizations of the hyperbola/circle produce independent +# exact quadratic-root checks, including both signs of R and all finite roots. +for c,y,t in product([Q(1),Q(-1)],[Q(5,4),Q(2),Q(3),Q(6)], + [Q(1,5),Q(1,3),Q(1,2),Q(2,3),Q(3,4)]): + psi=abs(c)*y + if c>0: + sigma=(1+t*t)/(1-t*t); z=12*t/(1-t*t) + else: + sigma=(1-t*t)/(1+t*t); z=12*t/(1+t*t) + R=48*(psi-c*sigma)/z + plus=classify(c,psi,R) + minus=classify(c,psi,-R) + check('reflection', plus[0]==minus[0]) +for c,psi,R in [(Q(1),Q(5,4),Q(0)),(Q(1),Q(2),Q(0)), + (Q(1),Q(3),Q(0)),(Q(1),Q(2),Q(8)), + (Q(-1),Q(5,4),Q(0)),(Q(-1),Q(5,4),Q(6)), + (Q(0),Q(1),Q(0)),(Q(0),Q(1),Q(2)), + (Q(0),Q(1),Q(4)),(Q(0),Q(1),Q(8))]: + # R0,c>0 may have irrational Z; choose y with rational y^2-1 below. + if R==0 and c>0 and psi in [Q(2),Q(3)]: + mu=-(psi-2)*(psi+1)**2/4 + check('R0 positive-c formula', (mu<0)==(psi>2)) + else: + classify(c,psi,R) +mu,pts=classify(Q(-1),Q(5,4),Q(6)) +check('tangency/no-saddle', mu is None and len(pts)==1 and pts[0][3]==0) +reject('tangency counted as saddle', pts[0][3]<0) +reject('empty saddle maximum equals zero', mu==Q(0)) +mu,pts=classify(Q(1),Q(2),Q(8)) +check('degree drop finite root', len(pts)==1) +reject('divide by quadratic coefficient on degree drop', (Q(8)**2-64)/2304!=0) + +# Rational squared arc functions and derivative numerators; no radicals. +for y in [Q(5,4),Q(3,2),Q(2),Q(3),Q(5)]: + for fraction in [Q(1,10),Q(1,3),Q(1,2),Q(9,10)]: + sigma=1+fraction*(y-1) + r2=64*(y-sigma)**2/(sigma*sigma-1) + v=(sigma+1)*(2-y*(sigma-1))/4 + check('positive-c arc', 10) + if v<0: + check('positive-c arc', y>2 and sigma>1+2/y) + check('positive-c arc', r2<16*(y-2)**2*(y+1)) + sigma=-1/y+fraction*(1+1/y) + r2=64*(y+sigma)**2/(1-sigma*sigma) + v=(sigma+1)*(2-y*(1-sigma))/4 + check('negative-c arc', -1/y0) + if v<0: + check('negative-c arc', sigma<1-2/y and r2<16*(y+2)**2*(y-1)) + rt2=64*(y*y-1); q2=16*(y+2)**2*(y-1) + check('tangency gap', q2-rt2==16*y*y*(y-1)>0) + star=1-2/y + check('negative-c boundary', -1/y2: + star=1+2/y + check('positive-c boundary', 10) +reject('F0 implies mu0', mu==0) +# A genuinely neutral example, including R0 without division by R. +check('R0 neutral algebra', Q(0)==16*(Q(2)-2*Q(1))**2*(Q(2)+1)) +reject('psi2c R0 belongs to negative sector', -(Q(2)-2)*(Q(2)+1)**2/4<0) + +# Finite measure fixtures test B19-B21's exact algebra, not Gaussian laws. +def l1(a,b): + return sum(abs(x-y) for x,y in zip(a,b)) + + +for q in [Q(1,8),Q(1,16),Q(1,32)]: + r=q*q + model=[Q(2,5),Q(3,5),Q(0)] # last point is outside T + actual=[model[0]+r,model[1]-r/2,r/2] + mark=[1,0,0] + flip=[q/10,q/20,r/2] + joint=[]; target=[] + for mass,m0,h,bad in zip(actual,model,mark,flip): + check('joint fixture validity', 0<=bad<=mass) + joint.extend([bad if h else mass-bad,mass-bad if h else bad]) + target.extend([Q(0) if h else m0,m0 if h else Q(0)]) + mismatch=sum(flip) + check('Boolean total variation bound', l1(joint,target)<=2*mismatch+l1(actual,model)) + ar,a0=sum(joint),sum(target) + normalized=[x/ar for x in joint] + normalized0=[x/a0 for x in target] + check('conditional normalization', l1(normalized,normalized0)<=l1(joint,target)/ar+abs(ar-a0)/ar) + check('full-law rare scale', r**3*mismatch/r**3==mismatch) + check('outside-T retained', r/2>0 and model[-1]==0) + reject('model outside-T null means actual outside-T null '+str(r), actual[-1]==0) + # Exact mark flip with unchanged jets saturates the factor2. + one=[q,1-q]; zero=[Q(0),Q(1)] + check('factor two necessary', l1(one,zero)==2*q) + reject('omit factor two '+str(r), l1(one,zero)<=q) + # Full weighted normalizer versus restricted layer normalizer. + numerator=r**5*ar; fullZ=r*r*Q(3) + probability=numerator/fullZ + check('full normalizer', probability==r**3*ar/3) + reject('replace full normalizer by layer mass '+str(r), numerator/numerator==probability) + +# A singular atomic law on F0 disproves transferring model nullity alone. +atom_mass=Q(1) +reject('Lebesgue-null polynomial set is null for every law', atom_mass==0) +# Exact nullity supplies no neighborhood rate: uniform law on [-eps,eps]. +eps=Q(1,10000) +neighborhood_mass=2*eps/(2*eps) +reject('nullity alone gives sqrt-eps neighborhood rate', neighborhood_mass<=Q(1,100)) +# A continuous mark can move by eps and still have total variation norm2. +pointmass0=[Q(1),Q(0)]; pointmasseps=[Q(0),Q(1)] +reject('small location displacement implies small TV', l1(pointmass0,pointmasseps)<=eps) + +universe=set(range(7)); E={0,1}; Rsec={2,3}; outside={4,5}; neutral={6} +H={0,2,4} +mis=universe&(H^E) +check('full layer set ledger', mis<=(E-H)|(Rsec&H)|outside|neutral) +reject('sector comparison covers T-complement without charge', mis<=(E-H)|(Rsec&H)) +check('rate ledger', Q(7,2)-3==Q(1,2) and Q(4)-3==1) +reject('full-layer mismatch is O(r4) from given bounds', Q(7,2)>=4) + +# Positive masses bound the limiting ratio away from both0 and1. +for me,mr in product([Q(1,10),Q(1,3),Q(2)],[Q(1,8),Q(1,2),Q(3)]): + total=me+mr; ratio=me/total + check('positive mass partition', 00; gap mark k=1; b in a fixed nonempty compact +birth set B0; all orthonormal frames; fixed finite Lambda>0. Pins are +M_r=(-r/2,0), S_r=(r/2,0), values b,b-r^3 and zero gradients. Q_r is the +continuous pinned Gaussian regression law, W_r is the actual typed product +of absolute Hessian determinants, and Q_r^W=(W_r/Z_r)Q_r uses the FULL +normalizer Z_r=E_Q W_r=r^2 z_r. These definitions and their analytic premises +are unchanged; parent P is read with E1/E2 and the reconciliation. + +The raw jets and domain are + + theta=(lambda,gamma,B1,C3), lambda=-f_zz(0)/r, + (gamma,B1,C3)=(f_xxz(0),f_xzz(0),f_zzz(0)), + D_Lambda={|lambda|<=Lambda}, + D=gamma^2-12B1, J=8gamma^3-144B1 gamma+576C3, + a_M=24lambda-D, a_S=24lambda+D, + T={a_M>0,a_S>0}. + +Here D without a subscript is a scalar polynomial, not the domain. +On T and gamma!=0 put + + psi=24lambda/gamma^2, c=D/gamma^2, R=J/gamma^3, + P(u,Z)=2u^3-3u/2-1/2-(psi+2cu)Z^2/48+RZ^3/3456. (B1) + +Then psi>|c|, P(M)=0, P(S)=-1 at M=(-1/2,0),S=(1/2,0). +Let mu be the maximum of P(Y)+1 over the finite set of extra nondegenerate +saddles of P, and -infinity if this set is empty. Retain C95/C97's events + + E={D_Lambda,T,gamma!=0,psi>=2c, + R^2<=16(psi-2c)^2(psi+c),mu<0}, + Rsec={D_Lambda,T,gamma!=0,mu>0}. (B2) + +H_r is C96's designated finite ordinary-superlevel H0 death event, defined +false off the Borel Morse/distinct-value typed-pin locus. The event is about +the chosen maximum and saddle, not gradient-branch adjacency. + +Write mu_r(B)=r^(-5)E_Q[W_r 1_{theta in B}] on D_Lambda. C92 gives +densities g_r and + + g_0(theta)=rho_0(0,gamma,B1,C3) a_M a_S 1_T/16, + dmu_0=g_0 dtheta, m_Lambda=mu_0(D_Lambda), + integral_D |g_r/z_r-g_0/z0|<=Cr, + z_r=z0+O(r), 0