diff --git a/.github/workflows/cusp-torus-transfer.yml b/.github/workflows/cusp-torus-transfer.yml new file mode 100644 index 000000000..b00d26777 --- /dev/null +++ b/.github/workflows/cusp-torus-transfer.yml @@ -0,0 +1,49 @@ +name: Cusp torus transfer exact checks + +'on': + pull_request: + paths: + - 'frontiers/cusp_torus_transfer_20261001/**' + - '.github/workflows/cusp-torus-transfer.yml' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'frontiers/cusp_second_order_20261001/PROOF.md' + - 'frontiers/cusp_coefficient_certified_20261001/NOTE.md' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-source: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + fetch-depth: 0 + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Fetch exact historical source commits + run: | + set -euo pipefail + git fetch --no-tags origin 3e0a91b69892b9717564c592e7a966492a81566a + git fetch --no-tags origin 826b8be512e86f2de73c33d6ac7a76908dc2e0e6 + git fetch --no-tags origin 3ac897a16d79d6c37aed29d59b71966058e75a00 + - name: Authenticate sources and replay exact controls + env: + PYTHONDONTWRITEBYTECODE: '1' + GIT_NO_REPLACE_OBJECTS: '1' + run: | + set -euo pipefail + cd frontiers/cusp_torus_transfer_20261001 + python -B -S verify_sources.py + python -B -S -m unittest discover -v + python -B -O -S -m unittest discover -v + python -B -S transfer.py > "$RUNNER_TEMP/cusp-transfer-normal.json" + python -B -O -S transfer.py > "$RUNNER_TEMP/cusp-transfer-optimized.json" + cmp RESULTS.json "$RUNNER_TEMP/cusp-transfer-normal.json" + cmp RESULTS.json "$RUNNER_TEMP/cusp-transfer-optimized.json" + python -B -S verify_sources.py + git diff --exit-code diff --git a/frontiers/cusp_torus_transfer_20261001/MANIFEST.json b/frontiers/cusp_torus_transfer_20261001/MANIFEST.json new file mode 100644 index 000000000..a2ec68f30 --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/MANIFEST.json @@ -0,0 +1,61 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW_OPEN", + "files": [ + { + "path": "PROOF.md", + "bytes": 15534, + "sha256": "6b818bdc34c6908505c6b2ad65584f740254a8525ddc8a45197d560386243bb0", + "git_blob": "de3d85fdcf65487adc982bae7318246c1b8f016c" + }, + { + "path": "README.md", + "bytes": 3334, + "sha256": "1cec04720d6b70a06222710e7ae6016c42458f4a1d47056f47c79ee9d6e3eed2", + "git_blob": "b184c57bccd3f9c5082cc900c3668059017db5ac" + }, + { + "path": "RESULTS.json", + "bytes": 2955, + "sha256": "1ca1b76e5ad6a55083fb72b533106311e751aafd9f9e4c3173de413f3aa66b43", + "git_blob": "f044f2b2da19c756a8aa14831f7aa85e03e018a5" + }, + { + "path": "SOURCES.json", + "bytes": 1384, + "sha256": "b6606206be695451e65b7e9ae19d75f81d7048f0b37b5bc48dd3e8789d06d152", + "git_blob": "6c5ddcf37bb736b233f3c3a63e80984ca08fd7ea" + }, + { + "path": "VALIDATION.md", + "bytes": 3366, + "sha256": "5e94c2befb7ef1d22bc4aefe519ed80391119cfb9f78a035b2ca77a9920b89e7", + "git_blob": "9d131d7f3c58281ee76a4b6f59d87efa0e29fed5" + }, + { + "path": "test_sources.py", + "bytes": 4636, + "sha256": "81ca50dc51a852723a7c57ef9384bd2841f6c88bc4c0d1aedc2522f6901dc818", + "git_blob": "30584172a156f8a154d06d073076f6adacf90af7" + }, + { + "path": "test_transfer.py", + "bytes": 8782, + "sha256": "d11d5bf6a00de387044097c490781a35466b81516822c653864dd8aa20ae3cb5", + "git_blob": "9be8cf7c03e46e56b197bb7e8e9bc8646023307c" + }, + { + "path": "transfer.py", + "bytes": 9677, + "sha256": "49acaca69d437aebed4547a802430b4b2906d5c96827dabb4b622e96f3190b32", + "git_blob": "de48ca6c7e3637001b510d9b9aab0d789a76de70" + }, + { + "path": "verify_sources.py", + "bytes": 4494, + "sha256": "6fa7c165aa380f66ca253ebbe5f72d9e40d0e9bc4e0fb362208134f87d321b9f", + "git_blob": "175e676f8d04f8b01e3c5d02d5fb21a8bb065cdb" + } + ] +} diff --git a/frontiers/cusp_torus_transfer_20261001/PROOF.md b/frontiers/cusp_torus_transfer_20261001/PROOF.md new file mode 100644 index 000000000..de3d85fdc --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/PROOF.md @@ -0,0 +1,312 @@ +# Cusp coefficient on the finite torus: birth-marginal covariance transfer + +Object OA-CUSP-TORUS-TRANSFER-20261001-v1. OpenAI / GPT-6 Astra Pro. +Author-side mathematical candidate; new nonauthor review OPEN. Scientific effect NONE. +No source proof, status register, Boolean, prize or earlier verdict is changed. + +## 1. Scope, credit and statement + +This completes the interrupted pickup on Math-#219 (5930612079), recovered under +Dylan's new screenshot continuation. The peer subsequently published Lemma S in +#219 v1.1 (3ac897a), already treating d=2,3 and L>=24 by a full-jet density +sandwich. That overlap is credited, not represented as independent acceptance. +The present distinct improvement integrates out birth BEFORE the comparison, +proves a stronger reference floor, and supplies bounds for every L>=10 in +**d=1,2,3 and every orthonormal frame**. No expensive reference quadrature is rerun. + +Let phi(x)=exp(-|x|^2/2), and use the normalized periodic covariance + + K_L(x)=sum_{n in Z^d} phi(x+Ln)/sum_{n in Z^d} phi(Ln). (T1) + +For an axial unit vector u with orthonormal transverse frame Theta, set m=d-1, +A=D_Theta^2 f, gamma=grad_Theta d_u^2 f, f4=d_u^4 f, +Delta=det A, Y=f4 Delta/12-gamma^T adj(A)gamma/4 and + + h(A,gamma,f4)=|Y|^(7/4)|Delta|^(1/4) 1{A<0}. (T2) + +When d=1, det(empty)=1, the quadratic term is zero and h=|f4/12|^(7/4). +The object c1 is the explicit integral CU.2 in [CU]: + + c1[K]=-(192/7)2^(1/4) int_{S^(d-1)} int_R + p_(f,Q)(b,0) E[h | f=b,Q=0] db d sigma(u), + Q=(grad f,H_f u,d_u^3 f). (T3) + +It is defined here as a finite Gaussian integral. Its identification as the +ell^(1/4) term of an ACTUAL elder lifetime density is the distinct, conditional +claim of [CU], not proved or reviewed by this packet. For d=1 the same expression +is covered, without extending [P]'s d>=2 parent theorem by notation. + +**Theorem T.** Write N_d=3d+1+d(d-1)/2, so N_1=4,N_2=8,N_3=13, and + + E_d(L)=3d 3^(d-1) (764 d^4 L^8+105) exp(-L^2/2), + delta_d(L)=3N_d E_d(L), eta_d(L)=13 delta_d(L). (T4) + +For d=1,2,3 and every real L>=10, the integral (T3) is strictly negative and + + |c1[K_L]/c1[phi]-1| <= eta_d(L). (T5) + +The same relative comparison holds for the positive integrand after birth +integration at EACH frame. In particular, rigorously rounded upper bounds are + +| dimension | all L>=10 | all L>=24 | +|---|---|---| +| 1 | 6.89628366587e-9 | 3.29775477012e-109 | +| 2 | 1.32408646215e-6 | 6.33168915861e-107 | +| 3 | 4.90170601596e-5 | 2.34396164673e-105 | + +Thus both estimates in the interruption screenshot are achieved, conservatively: +**less than 5e-5 for L>=10 and less than 3e-105 for L>=24** in these dimensions. +These are covariance-transfer bounds for a specified coefficient integral, +NOT total errors of a finite-lifetime approximation and NOT 105-digit reference +coefficient evaluations. The original reference interval widths remain present. + +## 2. Integrate birth, retain its correlations + +Let Z consist of the independent upper-triangular entries of A, then gamma, then +f4; let X=(Q,Z) and C_{L,u}=Cov X. There are q=2d+1 zero-pin coordinates and +n=m(m+1)/2+m+1 free coordinates, with q+n=N_d. All are centered before conditioning. +Because h is nonnegative and independent of f itself, Tonelli and Gaussian +marginalization give the EXACT identity + + int_R p_(f,Q)(b,0) E[h | f=b,Q=0] db + =int_{R^n} h(z) p_X(0,z) dz =: J(C_{L,u}). (T6) + +No old full-normalizer or pin-density factor is inserted a second time. This +step discards f as a coordinate of the covariance, not as a source of correlations. +For the reference kernel, conditioning on (f=b,Q=0) gives independent f4, gamma +and A with means -3b,0,-bI and variances24,2I and GOE variances2/1. But after birth +integration, the normalized b-mixture has b~N(0,2/3). Thus, for example, + + Var(f4 | Q=0)=30, + Cov(f4,A_ii | Q=0)=2, + Var(A_ii | Q=0)=8/3, + Cov(A_ii,A_jj | Q=0)=2/3, i!=j. (T7) + +Pretending that all these variables remain independent would change (T3). +The exact companion recomputes both Schur complements and their mixture identity. +At finite L no reference conditional independence or rotational invariance is +assumed: C_{L,u} retains every covariance entry. + +The weight is homogeneous under simultaneous POSITIVE amplitude scaling: + + h(tA,t gamma,t f4)=t^p h(A,gamma,f4), + p=2m+7/4=2d-1/4. (T8) + +Indeed Delta has degree m, each term in Y has degree m+1, and the cone A<0 is +preserved. Even at a singular A, the adjugate is a polynomial; there is no inverse +matrix in (T2). The weight is measurable, nonnegative and polynomially bounded. +For positive definite C, its Gaussian slice integral is finite and positive: +the negative cone and the set Y!=0 contain a nonempty open set with positive +density. These facts also cover d=1 directly. + +Substituting z=sqrt(a)w into the density integral yields + + J(aC)=a^((p-q)/2) J(C)=a^(-5/8)J(C). (T9) + +The zero-pin count is 2d+1, not 2d+2, because birth was INTEGRATED, not set to zero. +Neither h's lack of differentiability nor the cone boundary is differentiated. + +## 3. An exact reference-covariance floor + +For the reference kernel in any orthonormal frame, + + Cov(d^alpha f,d^beta f)=(-1)^|beta| d^(alpha+beta)phi(0). (T10) + +If a coordinate of alpha+beta is odd, the entry vanishes. Otherwise it is +(-1)^(|beta|+|alpha+beta|/2) product_i (alpha_i+beta_i-1)!!. +The sign can equivalently use |alpha|; all nonzero entries have even total order. + +**Lemma F.** In the stated raw independent-entry coordinates, C_0>I/3. +In fact the proof holds for every fixed integer d>=1, though the quantitative +image bound and table of this packet are restricted to d<=3. + +Proof. By coordinate parity and permutation, the odd block is the direct sum +of [[1,-3],[-3,15]] (f_u,f_uuu) and m copies of [[1,-1],[-1,3]] +(f_{theta_j},f_{uu theta_j}). After subtracting I/3 their leading pivots are2/3, +and the respective second pivots are7/6. Thus each block is positive definite. +All off-diagonal Hessian entries are independent variance-one scalar blocks. +The remaining even block comprises the d diagonal Hessian entries and f4: + + B=2I_d+11^T, v=-3*1-12*e_1, Var(f4)=105. + +After subtracting I/3, B'=(5/3)I+11^T is positive definite and + + (B')^-1=(3/5)I-9/[5(3d+5)] 11^T. + +Its last Schur pivot is exactly + + 314/3-v^T(B')^-1 v = (417d+2018)/[15(3d+5)]>0. (T11) + +This exhausts every covariance coordinate and proves the matrix inequality. +It is a dimension-valid algebraic identity, not an eigenvalue estimate from a +floating-point table. The code also performs a separate exact LDL^T elimination. + +For example, its complete pivots for C_0-I/3 in d=3, in the ordered labels of +the script, are + + 2/3,2/3,2/3,8/3,2/3,2/3,7/6,55/24,2/3,70/33,7/6,7/6,467/30. + +The birth-INCLUDED covariance does not have this floor in d=3; its first valid +simple floor in the peer's proof is1/4. Marginalization improves this proof's +conditioning without changing the integral, and reduces N from14 to13. QED. + +## 4. Order-eight derivative and lattice-tail control + +A covariance involving f4 and f4 uses EIGHT derivatives. The old order-six +SIDE24 estimate cannot be used for this purpose. + +For unit directions v_1,...,v_j, differentiation of exp(-|x|^2/2) gives a sum over +partial matchings of the directions: each singleton contributes x.v_i and each +paired pair contributes v_i.v_k, with signs. The number of terms is + + T_j=sum_{a=0}^{floor(j/2)} j!/[2^a a!(j-2a)!]. + +For0<=j<=8 this is at most T_8=764. Thus for |x|>=1, + + |D^j phi(x)[v_1,...,v_j]|<=764 |x|^8 phi(x), + |D^j phi(0)[v_1,...,v_j]|<=105. (T12) + +At zero only perfect matchings survive; the largest number is7!!=105. The +argument is for arbitrary unit directions, not only Cartesian derivatives. + +For the infinity-norm shell |n|_infinity=a>=1, the number of lattice points is +(2a+1)^d-(2a-1)^d <=2d3^(d-1)a^(d-1), and |n|^8<=d^4 a^8. +At L>=10,d<=3, successive terms of a^s exp(-L^2a^2/2), for0<=s<=d+7, have ratio +at most2^10 exp(-150)<1/3. Already exp(150)>1+150+150^2/2=11401>3072 +proves this last bound. Therefore + + sum_{a>=1} a^s exp(-L^2a^2/2) <= (3/2)exp(-L^2/2). (T13) + +Let S_L=sum_{n!=0}phi(Ln). Normalization in (T1) gives + + D^j K_L(0)-D^j phi(0) + = [sum_{n!=0}D^j phi(Ln)-S_L D^j phi(0)]/(1+S_L). + +Using (T12)-(T13) and 1+S_L>=1 proves that every entry of C_{L,u}-C_0 has +absolute value at most E_d(L) in (T4). This includes the denominator correction +105; it is not silently discarded. There is no extra rotation norm: every +contraction used in (T10) consists of unit frame directions covered by (T12). + +For an N by N symmetric perturbation bounded entrywise by E, its operator norm +is at most NE (for instance by its Frobenius norm). Since C_0>I/3, + + (1-delta)C_0 <= C_{L,u} <= (1+delta)C_0, + delta=3NE_d(L). (T14) + +The computed delta at d=3,L=10 is below3.771e-6, in particular below1e-4. The +function (a L^8+b)exp(-L^2/2) is decreasing for L>=10 when a,b>0, by differentiation. +Thus every bound at10 or24 remains valid for all larger REAL side lengths. +No lattice-axis alignment or isotropy of the finite torus is assumed. + +## 5. Transfer of the entire nonsmooth cone integral + +For positive definite C satisfying (T14), inverse and determinant inequalities +give pointwise on R^N + + [(1-delta)/(1+delta)]^(N/2) p_((1-delta)C0) + <=p_C<= + [(1+delta)/(1-delta)]^(N/2) p_((1+delta)C0). (T15) + +Restrict to Q=0, multiply by the NONNEGATIVE h, and integrate. By (T9), + + L_N(delta) <= J(C)/J(C0) <= U_N(delta), + L_N=(1-delta)^(N/2-5/8)/(1+delta)^(N/2), + U_N=(1+delta)^(N/2-5/8)/(1-delta)^(N/2). (T16) + +This is not a uniform relative expectation bound for arbitrary measurable tests: +h's specific nonnegative homogeneity is essential. In particular it avoids the +invalid strategy of perturbing the negative-cone boundary or differentiating a +fractional power through singular matrices. + +For N<=13 and0<=delta<=1e-4, put a=N/2-5/8,b=N/2. Both a,b are positive. The +absolute logarithmic derivatives of L_N and U_N are bounded above by + + a+b/(1-delta) or a/(1-delta)+b <= (99/8)/(1-1e-4)<25/2. + +Consequently L_N>=exp(-(25/2)delta)>=1-(25/2)delta, and +U_N<=exp((25/2)delta)<=1/[1-(25/2)delta]<=1+13delta on this interval. +The final inequality follows by multiplication of positive denominators. Thus + + 1-13delta <= L_N <= U_N <=1+13delta. (T17) + +The reference J(C0) is the same in every frame, but the actual J(C_{L,u}) need +not be. Angular integration preserves the bounds since it integrates positive +quantities. Multiplying by the common NEGATIVE prefactor in (T3) preserves the +positive ratio c1[K_L]/c1[phi]. This proves (T5). + +Normalization matters: if K_L^raw=(1+S_L)K_L, then exactly +c1[K_L^raw]=(1+S_L)^(-5/8)c1[K_L]. We state our theorem for normalized (T1), +not as equality of normalized and unnormalized coefficients. + +## 6. Exact arithmetic and what the numerical table does establish + +Only integer/Fraction arithmetic is used for the certificate. For x>=0 and an +integer n with x/(n+2)<1, write S_n=sum_{j=0}^n x^j/j! and t_{n+1}=x^(n+1)/(n+1)!. +All remaining successive term ratios are <=x/(n+2), so + + S_n <=exp(x)<=S_n+t_{n+1}/(1-x/(n+2)). + +Reciprocals provide a rational interval for exp(-x). The code uses +n=2ceil(x)+64 and applies this to x=50 and288. No libm exponential is trusted. +Rational values are rounded upward for error bounds; negative absolute coefficient +intervals use a separate correct floor/ceiling rule. Fractional sandwich powers +are verified by raising both positive sides of (T16)-(T17) to the EIGHTH power, +which reduces each comparison to rational arithmetic. + +The broad headline bounds are strictly below5e-5 and3e-105. The table in §1 keeps +12 significant digits rounded upward, not nearest rounding. An absolute interval +[alpha,beta] for c1[phi], alpha=10,d=3 the resulting +interval is [-0.2118587311831697,-0.2118379618168794]. At SIDE24 the reference +certificate's much wider uncertainty dominates the negligible transfer allowance. + +The bound on covariance replacement does not control the o(ell^(1/4)) term in +[CU], any finite-lifetime percentage forecast, c2, or parameter-uniform asymptotic +rates. The existence and value of the CU.2 integral are distinct from its +interpretation as a persistence asymptotic coefficient. + +## 7. Recovery, review and verification boundaries + +Sources in SOURCES.json bind [P] (model definition only), [CU] (expression CU.2 +only), and [NUM] (reference interval transcription and peer overlap credit). +No independent proof status for these source theorems is manufactured. The older +R.1 reference-regression review5378866830 was recovered on GitHub: it was delivered +by this same conversation before interruption. It is NOT issued again or counted +as independent acceptance of this transfer. New exact matrix replay agrees with it. + +New review requests: +A: (T6)-(T11), birth marginalization, retained mixture correlations, positive +homogeneity and dimension-valid reference floor. +B: (T12)-(T17), order-eight/all-frame image estimate, normalized denominator, +entrywise-to-operator conversion, two-sided Gaussian sandwich and linear bound. +C: numerical comparisons/rounding, conditional use of [NUM], and separation of +coefficient transfer from the parent asymptotic theorem. Tests do not replace +these analytic reviews. No self-merge, register change or new Lean formalization. + +The finite controls rebuild all covariance matrices from derivative multi-indices, +verify independent Hermite recurrences, LDL reconstruction, full-birth regression +and marginal mixtures, homogeneous polynomial identities and signed interval +transport. Both modes and eight semantic mutations are replayed. The original +eight-method scaffold failed all eight tests before implementation. Code for +historical source verification is reused from the prior D1 audit with a small +per-source-commit entry adaptation and its real-Git tests retained. + +The local raw-host network lookup failed DNS, so historical source objects were +not available locally. `--local-only` reports that fact. Actual project source +commit/path/blob authentication is a hosted requirement, not replaced by matching +local fixture data. The author's isolated mathematical checks are not a new +provider review. Final head-specific hosted observations belong in the PR receipt. + +External background: DLMF §4.2(iii), equation4.2.19, supplies the familiar exponential +series, and DLMF §18.5 gives Hermite polynomial representations. The needed +remainder, matching-count and covariance calculations are derived above. These +primary web records were read at page/search depth, not as an exhaustive novelty +audit. The peer's #219 Lemma S already contains the overlapping density-sandwich +idea; this packet contributes the wider side range, marginal floor and bounds. diff --git a/frontiers/cusp_torus_transfer_20261001/README.md b/frontiers/cusp_torus_transfer_20261001/README.md new file mode 100644 index 000000000..b184c57bc --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/README.md @@ -0,0 +1,66 @@ +# Cusp coefficient transfer to every torus side L >= 10 + +OpenAI / GPT-6 Astra Pro. Author-side proof candidate; nonauthor review OPEN. +Scientific effect NONE. No self-merge or change to any source proof/status register. + +This recovers the interrupted covariance-transfer calculation on Math-#219. +The reference numerical author added its own Lemma S for L>=24 during the +interruption. That overlapping method is credited, not counted twice. The +present extension covers d=1,2,3, every frame and every real L>=10, using the +birth-MARGINAL jet and a proved covariance floor1/3. No source quadrature is rerun. + +The theorem bounds the CU.2 coefficient EXPRESSION for the exact normalized +periodic kernel, not the finite-lifetime density or the correctness of Theorem CU. +For each dimension, the relative difference from the Gaussian reference is at most: + +| d | L>=10 | L>=24 | +|---|---|---| +| 1 | 6.89628366587e-9 | 3.29775477012e-109 | +| 2 | 1.32408646215e-6 | 6.33168915861e-107 | +| 3 | 4.90170601596e-5 | 2.34396164673e-105 | + +Read PROOF.md for the order-eight image estimate, the birth-marginal floor, +nonnegative homogeneous density-slice sandwich and exact rational rounding. +All bounds cover arbitrary orthonormal frames, without imposing GOE independence +on the torus jets. Correlations induced by integrating birth are explicitly retained. +The coefficient is not equated to its reference value. + +`conditional_absolute_c1` values in RESULTS.json consume the reference interval +table of PR219 conditionally. They are not independent certification of its +Mellin transform, Gauss quadrature or special-function code. A tiny transfer error +does not create more accurate reference digits or a finite-lifetime error bound. + +## Replay + +From this standalone packet: + + python -B -S -m unittest discover -v + python -B -O -S -m unittest discover -v + python -B -S transfer.py + python -B -S verify_sources.py --local-only + +The last command checks packet identities and reports no historical-source +verification. In a full checkout with the pinned source commits use: + + python -B -S frontiers/cusp_torus_transfer_20261001/verify_sources.py + +All mathematical code is standard-library Python. The suite has33 methods, +including reused real-Git custody fixtures; eight semantic variants must reject +in both modes. Exact exponential Taylor tails replace untrusted transcendental +calls. The covariance matrix is reconstructed from derivative multi-indices. +There is no Lean formalization of the new integral comparison. + +## Review and coordination + +Original pickup219/5930612079; recovery and overlap reconciliation219/5932010316. +The prior R.1-only review5378866830 was actually delivered before interruption; +this conversation does not issue it again or count it as acceptance here. + +A: birth marginalization/homogeneity and the exact covariance floor. +B: normalized all-frame order-eight image estimate and Gaussian sandwich. +C: rational enclosures, inherited reference intervals and scope boundaries. + +The current user continuation authorizes this foreground research/recovery under +main/governance/OP-WORKFLOW-20260930.md. No stopped agent, watch or timer is +restarted. The targeted PR workflow is an execution check, not a scientific vote. +The author remains exposed to the earlier OpenAI source chain and will not self-merge. diff --git a/frontiers/cusp_torus_transfer_20261001/RESULTS.json b/frontiers/cusp_torus_transfer_20261001/RESULTS.json new file mode 100644 index 000000000..f044f2b2d --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/RESULTS.json @@ -0,0 +1,111 @@ +{ + "covariance_floor": "1/3", + "derivative_order": 8, + "dimensions": { + "1": { + "floor_ldlt_pivots": [ + "2/3", + "8/3", + "7/6", + "487/24" + ], + "marginal_jet_dimension": 4, + "side_bounds": { + "10": { + "conditional_absolute_c1": [ + "-0.2276063603452181", + "-0.2276063572054019" + ], + "entry_error_upper": "4.42069465761e-11", + "relative_c1_error_upper": "6.89628366587e-9", + "relative_covariance_upper": "5.30483358914e-10" + }, + "24": { + "conditional_absolute_c1": [ + "-0.2276063587755801", + "-0.2276063587750399" + ], + "entry_error_upper": "2.11394536546e-111", + "relative_c1_error_upper": "3.29775477012e-109", + "relative_covariance_upper": "2.53673443855e-110" + } + } + }, + "2": { + "floor_ldlt_pivots": [ + "2/3", + "2/3", + "8/3", + "2/3", + "7/6", + "55/24", + "7/6", + "2852/165" + ], + "marginal_jet_dimension": 8, + "side_bounds": { + "10": { + "conditional_absolute_c1": [ + "-0.2693991823813380", + "-0.2693984689646620" + ], + "entry_error_upper": "4.24386686584e-9", + "relative_c1_error_upper": "1.32408646215e-6", + "relative_covariance_upper": "1.01852804781e-7" + }, + "24": { + "conditional_absolute_c1": [ + "-0.2693988256740001", + "-0.2693988256719999" + ], + "entry_error_upper": "2.02938755084e-109", + "relative_c1_error_upper": "6.33168915861e-107", + "relative_covariance_upper": "4.87053012201e-108" + } + } + }, + "3": { + "floor_ldlt_pivots": [ + "2/3", + "2/3", + "2/3", + "8/3", + "2/3", + "2/3", + "7/6", + "55/24", + "2/3", + "70/33", + "7/6", + "7/6", + "467/30" + ], + "marginal_jet_dimension": 13, + "side_bounds": { + "10": { + "conditional_absolute_c1": [ + "-0.2118587311831697", + "-0.2118379618168794" + ], + "entry_error_upper": "9.66805920307e-8", + "relative_c1_error_upper": "4.90170601596e-5", + "relative_covariance_upper": "3.77054308920e-6" + }, + "24": { + "conditional_absolute_c1": [ + "-0.2118483470000001", + "-0.2118483459999999" + ], + "entry_error_upper": "4.62319851425e-108", + "relative_c1_error_upper": "2.34396164673e-105", + "relative_covariance_upper": "1.80304742056e-106" + } + } + } + }, + "matching_count": 764, + "mathematical_acceptance": false, + "scientific_effect": "NONE", + "scope": "rational checks of explicit transfer; not CU proof or reference quadrature", + "slice_covariance_scaling": "-5/8" +} diff --git a/frontiers/cusp_torus_transfer_20261001/SOURCES.json b/frontiers/cusp_torus_transfer_20261001/SOURCES.json new file mode 100644 index 000000000..6c5ddcf37 --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "sources": [ + { + "id": "P", + "commit": "3e0a91b69892b9717564c592e7a966492a81566a", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "bytes": 40261, + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "use": "Exact normalized periodic covariance only; no revalidation of parent asymptotic theorem." + }, + { + "id": "CU", + "commit": "826b8be512e86f2de73c33d6ac7a76908dc2e0e6", + "path": "frontiers/cusp_second_order_20261001/PROOF.md", + "git_blob": "f6df5a7356a54771b0052e42a864a140709903ad", + "use": "Definition CU.2 of coefficient integral, not acceptance of CU.1 or CU prime." + }, + { + "id": "NUM", + "commit": "3ac897a16d79d6c37aed29d59b71966058e75a00", + "path": "frontiers/cusp_coefficient_certified_20261001/NOTE.md", + "git_blob": "b20ab28f366e56ce024492dde5b3eaba3e0b963f", + "use": "Reference interval table is an explicitly conditional input; R.1 checked algebraically; overlapping Lemma S credited, not independently accepted." + } + ], + "identity_scope": "Each historical commit/path/blob is authenticated by the hosted verifier. P additionally has recorded size/SHA256. No absent source digest is invented." +} diff --git a/frontiers/cusp_torus_transfer_20261001/VALIDATION.md b/frontiers/cusp_torus_transfer_20261001/VALIDATION.md new file mode 100644 index 000000000..9d131d7f3 --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/VALIDATION.md @@ -0,0 +1,57 @@ +# Recovery and validation record + +The screenshot's numbers were proposed, not a saved verified theorem. Runtime +inspection found the earlier published packets but no saved implementation of +this cusp transfer. The present implementation was rebuilt from the definitions. +The pre-existing R.1 review5378866830 was found in the native GitHub review list; +its original30-test execution claim is not reused as this packet's execution. + +## Test-first and reused execution + +The initial eight-method transfer scaffold failed all eight tests before the +new implementation. The expanded mathematical suite has26 methods. It checks +independent Hermite recurrences, exact LDL^T reconstruction, rejection of an +invalid1/2 floor and of a1/3 floor before removing birth, both Gaussian Schur +regressions and their mixture identity, homogeneous polynomial weights, lattice +shell counting, outward exponential bounds and all six(d,L) comparisons. + +Source custody is reused from the previous D1 audit. Its original real-Git +functions/fixtures were retained; only source IDs and the per-source-commit entry +were adapted. The new multi-commit test failed against a no-op adapter, then +passed after implementation. Seven custody methods plus26 mathematical methods +make33 tests. The same-path/different-commit fixture ensures source commits are +not incorrectly replaced by one global checkout ref. + +All eight semantic variants are tested in both normal and optimized Python: +order6, wrong-floor, retain-birth-pin, drop-gamma-degree, omit-entry-count, +omit-normalization, reverse-sandwich, wrong-f4-variance. Each must return1; +an unknown label returns2. Baseline serialization must be byte-identical and +match RESULTS.json. These controls corroborate their finite identities only. + +Reference exp values from high-precision Decimal are diagnostic tests, not +certificate inputs. Production bounds use only Fraction/integer operations and +positive-series remainders. Exploratory eigenvalues were likewise not used for +the certified reference floor: the manuscript proves its exact Schur formula. + +## Source/acceptance boundary + +A public raw-host lookup failed with temporary DNS resolution error. Thus no +complete upstream checkout was obtained locally, and local-only explicitly +reports historical_sources_checked=false. Three historical commit/path/Git-blob +bindings are required by the hosted verifier; P additionally carries its existing +size/SHA256 pin. No SHA256 digest is invented for source files not fetched as +complete local bytes. Exact source identity is not proof of those sources. + +Runtime: Python3.13.5, Git2.47.3. The hosted workflow uses the project's pinned +Python3.11.16/actions convention. All supplied syntax is standard-library3.11. +Full local/hosted pass claims belong to actual final replay records, not this +pre-publication account. New analytic review remains separate. The reference +quadrature, Theorem CU, numerical c2 and full D1 kernel formalization were not +executed or accepted by this recovery. + +## Limited external source check + +The actual web searches were for NIST DLMF Hermite explicit representations and +the exponential power series. The primary DLMF §4.2 and §18.5 page/search records +were consulted. Equation4.2.19 is the usual exp series; the rational remainder +used here is derived in PROOF §6. No exhaustive novelty or priority claim follows. diff --git a/frontiers/cusp_torus_transfer_20261001/test_sources.py b/frontiers/cusp_torus_transfer_20261001/test_sources.py new file mode 100644 index 000000000..30584172a --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/test_sources.py @@ -0,0 +1,74 @@ +"""Local real-Git fixtures test custody behavior, not the project premises.""" +import hashlib +import os +from pathlib import Path +import subprocess +import tempfile +import unittest +import verify_sources as v + +class SourcesTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.repo=Path(t.name) + (self.repo/'imports').mkdir();self.data=b'fixture source only\n' + (self.repo/'imports/P.md').write_bytes(self.data) + self.git('init','-q');self.git('add','imports');self.git('commit','-qm','original') + self.commit=self.git('rev-parse','HEAD').decode().strip() + self.entry={'path':'imports/P.md','git_blob':self.git('rev-parse','HEAD:imports/P.md').decode().strip(), + 'bytes':len(self.data),'sha256':hashlib.sha256(self.data).hexdigest()} + self.nested=self.repo/'reviews/packet';self.nested.mkdir(parents=True) + def git(self,*args): + env=os.environ.copy();env.pop('GIT_NO_REPLACE_OBJECTS',None) + return subprocess.run(['git','-c','user.name=Fixture','-c','user.email=fixture@example.invalid',*args], + cwd=self.repo,env=env,capture_output=True,check=True,timeout=15).stdout + def test_valid_from_nested_directory(self): + self.assertEqual(v.verify_bindings(self.nested,self.commit,[self.entry]),1) + def test_bad_identities(self): + for key,val in [('git_blob','0'*40),('bytes',0),('sha256','0'*64)]: + with self.subTest(key=key),self.assertRaises(ValueError): + v.verify_bindings(self.nested,self.commit,[dict(self.entry,**{key:val})]) + def test_bad_paths_and_inventories(self): + for path in ['../P.md','/imports/P.md','imports//P.md','missing.md']: + with self.subTest(path=path),self.assertRaises(ValueError): + v.verify_bindings(self.nested,self.commit,[dict(self.entry,path=path)]) + with self.assertRaises(ValueError):v.verify_bindings(self.nested,self.commit,[]) + with self.assertRaises(ValueError):v.verify_bindings(self.nested,self.commit,[self.entry,self.entry]) + def test_only_real_commit(self): + for obj in ['HEAD^{tree}','HEAD:imports/P.md']: + with self.subTest(obj=obj),self.assertRaises(ValueError): + v.verify_bindings(self.nested,self.git('rev-parse',obj).decode().strip(),[self.entry]) + def test_symlink_source(self): + p=self.repo/'imports/P.md';p.unlink();p.symlink_to('../target') + self.git('add','imports');self.git('commit','-qm','link') + with self.assertRaises(ValueError):v.verify_bindings(self.nested,self.git('rev-parse','HEAD').decode().strip(),[self.entry]) + def test_replacement_does_not_forge_or_invalidate(self): + forged=b'replaced\n';(self.repo/'imports/P.md').write_bytes(forged) + self.git('add','imports');self.git('commit','-qm','replacement') + new=self.git('rev-parse','HEAD').decode().strip();self.git('replace',self.commit,new) + self.assertEqual(self.git('show',self.commit+':imports/P.md'),forged) + self.assertEqual(v.verify_bindings(self.nested,self.commit,[self.entry]),1) + altered=dict(self.entry,git_blob=self.git('rev-parse','HEAD:imports/P.md').decode().strip(),bytes=len(forged),sha256=hashlib.sha256(forged).hexdigest()) + with self.assertRaises(ValueError):v.verify_bindings(self.nested,self.commit,[altered]) + + + +class MultiCommitTests(unittest.TestCase): + setUp=SourcesTests.setUp + git=SourcesTests.git + def test_source_set_calls_distinct_commits(self): + import json + e1=dict(self.entry,id='P',commit=self.commit) + (self.repo/'imports/P.md').write_bytes(b'second fixture source\n') + self.git('add','imports');self.git('commit','-qm','second') + c2=self.git('rev-parse','HEAD').decode().strip() + e2={'path':'imports/P.md','id':'CU','commit':c2,'git_blob':self.git('rev-parse','HEAD:imports/P.md').decode().strip()} + (self.repo/'imports/P.md').write_bytes(b'third fixture source\n') + self.git('add','imports');self.git('commit','-qm','third') + c3=self.git('rev-parse','HEAD').decode().strip() + e3={'path':'imports/P.md','id':'NUM','commit':c3,'git_blob':self.git('rev-parse','HEAD:imports/P.md').decode().strip()} + path=self.nested/'SOURCES.json';path.write_text(json.dumps({'sources':[e1,e2,e3]})) + self.assertEqual(v.verify_source_set(self.nested),3) + e2['commit']=self.commit;path.write_text(json.dumps({'sources':[e1,e2,e3]})) + with self.assertRaises(ValueError):v.verify_source_set(self.nested) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/cusp_torus_transfer_20261001/test_transfer.py b/frontiers/cusp_torus_transfer_20261001/test_transfer.py new file mode 100644 index 000000000..9be8cf7c0 --- /dev/null +++ b/frontiers/cusp_torus_transfer_20261001/test_transfer.py @@ -0,0 +1,162 @@ +from fractions import Fraction as F +import unittest +import transfer as t + +class InitialTests(unittest.TestCase): + def test_dimensions(self): + self.assertEqual([len(t.jet_labels(d)) for d in (1,2,3)],[4,8,13]) + def test_covariance_eighth_order(self): + self.assertEqual(t.covariance((4,),(4,)),105) + def test_reference_floor(self): + self.assertTrue(all(x>0 for x in t.floor_pivots(3))) + self.assertEqual(t.floor_pivots(3)[-1],F(467,30)) + def test_scale_exponent(self): + self.assertEqual([t.slice_exponent(d) for d in (1,2,3)],[F(-5,8)]*3) + def test_eight_derivative_count(self): + self.assertEqual(t.matching_count(8),764) + def test_side10_bound(self): + self.assertTrue(00 for x in D)) + def test_no_half_floor(self): + C=t.matrix(1) + with self.assertRaises(ValueError):t.ldlt([[x-(F(1,2) if i==j else 0) for j,x in enumerate(row)] for i,row in enumerate(C)]) + def test_conditional_reference_regression(self): + for d in (1,2,3): + mean,S,det,ff=t.pin_regression(d) + m=d-1;labels=t.jet_labels(d,True)[2*d+2:] + expmean=[];vars=[] + for jet in labels: + if sum(jet)==4:expmean.append(-3);vars.append(24) + elif sum(jet)==3:expmean.append(0);vars.append(2) + elif max(jet)==2:expmean.append(-1);vars.append(2) + else:expmean.append(0);vars.append(1) + self.assertEqual(mean,expmean) + self.assertEqual(S,[[F(vars[i]) if i==j else 0 for j in range(len(S))] for i in range(len(S))]) + self.assertEqual(det,12);self.assertEqual(ff,F(3,2)) + def test_homogeneity_without_fractional_powers(self): + # h^4=|Y|^7|det A|, so every arithmetic operation is rational. + for A,gamma,f4 in (([[F(-2)]],[F(3)],F(5)), + ([[F(-2),F(1,3)],[F(1,3),F(-3)]],[F(1),F(-2)],F(7))): + m=len(A) + def value(A,g,f): + if m==1:det=A[0][0];quad=g[0]**2 + else:det=A[0][0]*A[1][1]-A[0][1]**2;quad=A[1][1]*g[0]**2-2*A[0][1]*g[0]*g[1]+A[0][0]*g[1]**2 + return abs(f*det/12-quad/4)**7*abs(det) + v=value(A,gamma,f4) + for a in (F(1,3),F(2),F(5)): + self.assertEqual(value([[a*x for x in row] for row in A],[a*x for x in gamma],a*f4),a**(8*m+7)*v) + def test_shell_ratios_by_rational_exponential(self): + # 1024 exp(-150) < 1/3 follows already from exp(150)>11401. + self.assertLess(F(1024,11401),F(1,3)) + for d in (1,2,3): + for j in range(1,11): + self.assertLessEqual((2*j+1)**d-(2*j-1)**d,2*d*3**(d-1)*j**(d-1)) + def test_exp_bounds_and_reference_values(self): + from decimal import Decimal,localcontext + with localcontext() as ctx: + ctx.prec=180 + for x in (F(0),F(1,2),F(3),F(50),F(288)): + lo,hi=t.exp_negative_interval(x) + ref=F((-Decimal(x.numerator)/Decimal(x.denominator)).exp()) + self.assertLessEqual(lo,ref);self.assertLessEqual(ref,hi) + self.assertLess(t.exp_negative_interval(50)[1],F(193,10**24)) + self.assertLess(t.exp_negative_interval(288)[1],F(1,10**125)) + def test_side_bound_monotonicity(self): + for d in (1,2,3): + self.assertGreater(t.error_bound(d,10),t.error_bound(d,12)) + self.assertGreater(t.error_bound(d,12),t.error_bound(d,24)) + def test_actual_sandwich_bound_no_transcendentals(self): + for d in (1,2,3): + for delta in (F(0),F(1,10**8),F(1,10000)): + lo,hi=t.sandwich_eighth_powers(d,delta) + self.assertTrue((1-13*delta)**8<=lo<=1<=hi<=(1+13*delta)**8) + def test_operator_dimension_factor(self): + # An all-E perturbation has Rayleigh quotient N*E on all-ones. + for N in (4,8,13): + E=F(1,10**8);ones=[1]*N + rayleigh=sum(E*ones[i]*ones[j] for i in range(N) for j in range(N))/sum(x*x for x in ones) + self.assertEqual(rayleigh,N*E) + def test_outward_formatting_and_negative_interval(self): + for v in (F(1,3),F(1,10**105),F(5,10**5),F(999999,100)): + self.assertGreaterEqual(F(t.scientific_upper(v)),v) + lo,hi=t.inherited_interval(2,10);s=t.decimal_enclosure((lo,hi)) + self.assertTrue(F(s[0])<=lo3:raise ValueError('uniform image theorem here covers d=1,2,3') + side=rational(side) + if not 10<=side<=64:raise ValueError('implemented side threshold in [10,64] required') + p=matching_count(image_derivative_order()) + norm=normalization_allowance() + return 3*d*3**(d-1)*(p*d**4*side**8+norm)*exp_negative_interval(side*side/2)[1] + + +def relative_covariance_bound(d,side): + n=1 if _MUTANT=='omit-entry-count' else len(jet_labels(d)) + return 3*n*image_bound(d,side) + + +def error_bound(d,side): + delta=relative_covariance_bound(d,side) + if delta>F(1,10000):raise ValueError('outside proved linearization range') + return 13*delta + + +def sandwich_eighth_powers(d,delta): + delta=rational(delta) + if not 0<=delta<1:raise ValueError('relative covariance error in [0,1) required') + n=len(jet_labels(d));a,b=4*n-5,4*n + lo=(1-delta)**a/(1+delta)**b + hi=(1+delta)**a/(1-delta)**b + return (hi,lo) if _MUTANT=='reverse-sandwich' else (lo,hi) + + +def scientific_upper(x,digits=12): + x=rational(x) + if x<0 or type(digits) is not int or digits<2:raise ValueError('nonnegative value and >=2 digits required') + if x==0:return '0' + exponent=len(str(x.numerator))-len(str(x.denominator)) + ten=F(10)**exponent + if x=10**digits:n//=10;exponent+=1 + s=str(n).rjust(digits,'0') + return s[0]+'.'+s[1:]+'e'+str(exponent) + + +def decimal_enclosure(interval,digits=16): + out=[] + for i,v in enumerate(interval): + v=rational(v)*10**digits + q=v.numerator//v.denominator if i==0 else -((-v.numerator)//v.denominator) + sign='-' if q<0 else '';q=abs(q) + out.append(sign+str(q//10**digits)+'.'+str(q%10**digits).zfill(digits)) + return out + + +def inherited_interval(d,side): + # Exact transcription of the outward table in the pinned peer NOTE, not a + # recomputation or independent acceptance of its quadrature certificate. + source={1:('-0.22760635877558','-0.22760635877504'), + 2:('-0.269398825674','-0.269398825672'), + 3:('-0.211848347','-0.211848346')} + lo,hi=map(F,source[d]);eta=error_bound(d,side) + return lo*(1+eta),hi*(1-eta) + + +def checks(): + if matching_count(8)!=764 or covariance((4,),(4,))!=105: + raise ValueError('order-eight Gaussian derivative identity') + needed=max(sum(a)+sum(b) for a in jet_labels(3) for b in jet_labels(3)) + if image_derivative_order()(1+eta)**8: + raise ValueError('Gaussian slice sandwich direction or linearization') + if not error_bound(3,10)=10 target') + if not error_bound(3,24)