From 7ab0d31b09b9d93272b5b0f635aa1d80a662130c Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 20:31:47 -0500 Subject: [PATCH 01/13] Add extreme whole-cluster law and exact maximum/minimum tail coefficients OpenAI author-side source-bound consumer of PR166's limiting microscopic measure. Companion involution and once-per-cluster anchor yield exact rational/log2 coefficients, antipodal doublet marks, height ordering and iid-only Frechet normalization. Original r limit precedes extreme-radius limit; no finite-r uniformity or global status changes. 66 tests pass in each Python mode, 893 rational shape cases, 32 Jacobian probes, eight semantic mutants reject per mode, real Git custody tested including replacements/noncommits/nested paths. All 12 remote packet blobs match independently computed local tree. Nonauthor analytic and hosted actual-source/full-gate review remain required; no self-merge. --- .../workflows/extreme-cluster-sampling.yml | 38 ++ .../MANIFEST.json | 73 +++ .../extreme_cluster_sampling_20260930/PLAN.md | 44 ++ .../PROOF.md | 486 ++++++++++++++++++ .../README.md | 97 ++++ .../RECONNAISSANCE.md | 57 ++ .../RESULTS.json | 69 +++ .../SOURCES.json | 44 ++ .../VALIDATION.md | 90 ++++ .../extremes.py | 352 +++++++++++++ .../test_extremes.py | 213 ++++++++ .../test_verify.py | 169 ++++++ .../verify.py | 167 ++++++ 13 files changed, 1899 insertions(+) create mode 100644 .github/workflows/extreme-cluster-sampling.yml create mode 100644 frontiers/extreme_cluster_sampling_20260930/MANIFEST.json create mode 100644 frontiers/extreme_cluster_sampling_20260930/PLAN.md create mode 100644 frontiers/extreme_cluster_sampling_20260930/PROOF.md create mode 100644 frontiers/extreme_cluster_sampling_20260930/README.md create mode 100644 frontiers/extreme_cluster_sampling_20260930/RECONNAISSANCE.md create mode 100644 frontiers/extreme_cluster_sampling_20260930/RESULTS.json create mode 100644 frontiers/extreme_cluster_sampling_20260930/SOURCES.json create mode 100644 frontiers/extreme_cluster_sampling_20260930/VALIDATION.md create mode 100644 frontiers/extreme_cluster_sampling_20260930/extremes.py create mode 100644 frontiers/extreme_cluster_sampling_20260930/test_extremes.py create mode 100644 frontiers/extreme_cluster_sampling_20260930/test_verify.py create mode 100644 frontiers/extreme_cluster_sampling_20260930/verify.py diff --git a/.github/workflows/extreme-cluster-sampling.yml b/.github/workflows/extreme-cluster-sampling.yml new file mode 100644 index 000000000..d47c6fcba --- /dev/null +++ b/.github/workflows/extreme-cluster-sampling.yml @@ -0,0 +1,38 @@ +name: Extreme whole-cluster sampling checks + +'on': + pull_request: + paths: + - 'frontiers/extreme_cluster_sampling_20260930/**' + - '.github/workflows/extreme-cluster-sampling.yml' + 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 public source objects + run: | + set -euo pipefail + git fetch --no-tags origin 80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337 + git fetch --no-tags origin 382c0f9ff2281f43651ddbdf2e9b36dd52e2c6bf + git fetch --no-tags origin bfcc67dc8957b3ed1fbb789e5a0305e98d7359c8 + - name: Verify historical sources, packet and exact controls + env: + PYTHONDONTWRITEBYTECODE: '1' + GIT_NO_REPLACE_OBJECTS: '1' + run: | + set -euo pipefail + python -B -S frontiers/extreme_cluster_sampling_20260930/verify.py + git diff --exit-code diff --git a/frontiers/extreme_cluster_sampling_20260930/MANIFEST.json b/frontiers/extreme_cluster_sampling_20260930/MANIFEST.json new file mode 100644 index 000000000..e6fd5bb0b --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/MANIFEST.json @@ -0,0 +1,73 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW_OPEN", + "files": [ + { + "path": "PLAN.md", + "bytes": 2741, + "sha256": "f158b7b7d0b42a9aa437c00d4c2962c2597a22b754a33b48412a59a3d4d39c4e", + "git_blob": "fcad3058aac543b9dfcd13fa8e6bd42779ca8397" + }, + { + "path": "PROOF.md", + "bytes": 21891, + "sha256": "b90cf745e2e67bc9b501c481552f7080d27c28245580668cf72aefa5b7f04715", + "git_blob": "19a6044f2066643b5baab34ce5b6b6efb431e84a" + }, + { + "path": "README.md", + "bytes": 4932, + "sha256": "c3dd601e8a47ca63bd968982ef6a800245e5b7b6aed3e5458122a345003a8534", + "git_blob": "1584485a724810f67dd467883fbac56db7c84f28" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 3088, + "sha256": "67b2c7eedc6b4e78d858a97f50badea2974d57f9f3c73dde2287c2e3dee37511", + "git_blob": "12bfcc069d02dc859ba5b6d5a1c774c52f7c7e24" + }, + { + "path": "RESULTS.json", + "bytes": 1867, + "sha256": "0eb7da9f37524838a6504962b1f7bfc2afe33ec9ba4c4de8d706128bd8b7ff09", + "git_blob": "6cfef6d63e100e720a3230822747b70eb019168a" + }, + { + "path": "SOURCES.json", + "bytes": 1950, + "sha256": "689463f46d53157d78b7f6461049a16b7d6c7b2c0fb86459064475e0d26feae8", + "git_blob": "c990aa1c0eb8010cf01480b3845d9f65c401d66c" + }, + { + "path": "VALIDATION.md", + "bytes": 5122, + "sha256": "76e43cd157de80c635fcf20b1cb2043bbc213a8acb71015f1ab063344c5b9676", + "git_blob": "381f28bfaa4aebfbc937e70db4492de27f1e2b07" + }, + { + "path": "extremes.py", + "bytes": 12483, + "sha256": "df1cc369d26de5ad99d5c39fac47a3c2fa2aea7d645a54ac9cea5bb0f5f4c0b1", + "git_blob": "38f3d45373418a6637cbcb0dcf5c23bbd59146db" + }, + { + "path": "test_extremes.py", + "bytes": 9800, + "sha256": "b4402e5d62f8e02b864d514d41860a3bc4122a8b76a9ef08d3f995d2fc892171", + "git_blob": "503ca3571152980af85a87332790bfbe49e37ace" + }, + { + "path": "test_verify.py", + "bytes": 8949, + "sha256": "8ee5af4b0aad766f181d5df4356b86c1f56fab1d6a2e29e22baadb73bc57cce7", + "git_blob": "c9e472183382174a44dbd6e1eda65326947a1080" + }, + { + "path": "verify.py", + "bytes": 7985, + "sha256": "7d4004b6b12d981777683ebf30b09178495ffaa358beebddca62edd34271abd7", + "git_blob": "f0971a307768d8c13ce05d8f8a07ce189012beea" + } + ] +} diff --git a/frontiers/extreme_cluster_sampling_20260930/PLAN.md b/frontiers/extreme_cluster_sampling_20260930/PLAN.md new file mode 100644 index 000000000..fcad3058a --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/PLAN.md @@ -0,0 +1,44 @@ +# Extreme whole-cluster sampling — implementation and proof plan + +Goal: identify the tail measure of a whole extreme microscopic configuration, +not repeat PR166's point-intensity theorem or a claimed peer review. + +Design: consume the exact explicit limiting micro measure and the reviewed +root-parametrized Gaussian integral. Compute the second root, select one root +per cluster, integrate the selector exactly, then prove the conditional joint +limit with the source's majorant. Keep all original model/mark/normalizer scope. +The r->0 limit is taken before the new radius->infinity limit. + +Isolation: dedicated new runtime directory; upstream repository checkout is +not available (public raw-host DNS failed). GitHub writes will be additive on +a new branch. No frozen packet or another writer branch is edited. + +Execution: foreground inline; no subagent or independent-provider activity is +invented. Dylan's explicit autonomous continuation supplies the task authority. + +1. [x] Write fail-first rational tests of the root involution, anchor and constants. +2. [x] Implement stdlib Fraction controls with a separate Laurent integration + certificate and rational lower/upper bounds for log(2). +3. [x] Prove and document the root-sector partition, once-per-cluster change of + variables, maximum/minimum tail constants, joint anchored law, height + ordering, and deliberately independent-replica maximum consequence. +4. [x] Test source custody against real Git fixtures, including replacement refs, + noncommit objects, symlinks, nested cwd and duplicate/empty inventories. +5. [x] Verify both Python modes, deterministic outputs, semantic negative controls + and complete flat packet inventory. Publish all exact source pins. +6. [ ] Create a separate PR, read back exact bytes/identities, request nonauthor + algebra/integration and probability reviews, and observe hosted checks. + +Review focus: strict height endpoints; denominator-zero and equal-radius sets; +point versus configuration multiplicity; physical radius versus |Z|; the +order of limits; latent parameter/orientation bias; finite controls versus +analytic proofs; all source and provider-exposure limitations. + +Scientific effect NONE. No self-acceptance, self-merge, global-register or prize +change. No finite-r spatial rate, growing-volume result, numerical Gaussian +coefficient or independence inside the original field is promised. + +Ruling: no duplicate review of PR166 A/B/C. Its explicit maximum-coefficient +and ordinary-cluster sampling nonclaims define this separate consumer. +Ruling: preserve source commits even when a metadata-only peer successor appears; +new target source authentication remains pinned to the consumed mathematical bytes. diff --git a/frontiers/extreme_cluster_sampling_20260930/PROOF.md b/frontiers/extreme_cluster_sampling_20260930/PROOF.md new file mode 100644 index 000000000..19a6044f2 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/PROOF.md @@ -0,0 +1,486 @@ +# Extreme whole-cluster sampling: exact maximum/minimum tails and the anchored doublet law + +Object: OA-EXTREME-CLUSTER-SAMPLING-20260930-v1. +Author: OpenAI / GPT-6 Astra Pro. Foreground continuation authorized by Dylan. +Disposition: AUTHOR-SIDE CONDITIONAL PROOF CANDIDATE; NONAUTHOR REVIEW OPEN. +Scientific effect NONE. No earlier proof, review, global register, Boolean, +prize or integration disposition is changed. Same-provider/source exposure is +not organizational independence. Finite checks below are not analytic acceptance. + +## 1. Exact object and source boundary + +Fix d>=2, L>0, b in R, k>0 and one axial/transverse orthonormal frame. This +paper concerns the ALREADY-FORMED limiting microscopic cubic measure M, not +the full finite-r Gaussian field and not its remote singleton component. +The limit that forms M is taken BEFORE the radius t tends to infinity. + +Sources and their complete identities are in SOURCES.json: + +[R] PR166 RADIAL_TAIL.md, exact head80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337, +blob0f14417ef7038b9c6f50e4b01e393a58b7b5e3a4, 12533 bytes. Consume the exact +root-parametrized integral R4-R12, its Gaussian majorant, the point tail R13, +and the height moment identities H3-H4. Its separate reviews B/C bind these +unchanged bytes. This paper adds a once-per-cluster selector; R does NOT already +claim the coefficient of the maximum or an ordinary cluster-selected H1 law. + +[M] PR166 TWO_SCALE_LAW.md at the same head, bloba32fd5f7d941bbe1fe943df045b1e0fbec8d691c, +17139 bytes: only the definition M1-M2 of the explicit microscopic measure and +its embedding in the fixed original frame. The new two-scale convergence theorem +of that file is NOT a premise of the calculation here. + +[SC] PR162 PROOF.md at382c0f9ff2281f43651ddbdf2e9b36dd52e2c6bf, +blob16c56821b52fd76b0be791622b9c3809eafde75a: the explicit Gaussian/spectral M, +its finite nonempty mass, and the contact-density bound. This conversation +AUTHORED SC; citing it does not independently revalidate its parent premises. + +[CUB] PR158 PROOF.md atbfcc67dc8957b3ed1fbb789e5a0305e98d7359c8, +blobbb446d08db8a944537a743ad550b88c1c2ad5758: the exact deterministic cubic +classifier only. Its Gaussian-sector statement is not consumed. This conversation +authored CUB. R and M are also OpenAI-authored, in a separate active lane. + +All Gaussian conditions remain conditional on those exact sources. No whole +review disposition is inferred from these source-local uses. + +For theta=(s,h,O,tau), the hard curvatures satisfy 00 is finite, with total mass +A_micro=a1+a2>0, and n belongs to {0,1,2} almost everywhere. + +The unsheared cubic and its physical limiting root position are + + P(X,Z)=2kX^3-3kX/2-k/2+sZ^2/2+(a/2)(X^2-1/4)Z + +(beta/2)XZ^2+(c/6)Z^3, + z_i=X_i e_axis+Z_i e_soft(O), R_i=|z_i|, + eta_i=-P(X_i,Z_i)/k in (0,1). (E2) + +Only additional strict-window roots are included, not the pins. Every such +root has full limiting index d-1. Define R_max on nonempty configurations; +on doublets also define R_min. Let + + F(t)=integral sum_i 1{R_i>t} dM, + G(t)=M(n>0,R_max>t), + G2(t)=M(n=2,R_max>t), B2(t)=M(n=2,R_min>t). (E3) + +F is a POINT intensity. G is a CLUSTER tail. Exactly, for every t, + + F(t)=G(t)+B2(t). (E4) + +This elementary multiplicity identity is the distinction missing from a +naive transfer of the point-selected law to whole clusters. + +## 2. Main constants and results + +Let J_cusp and gamma(a) be the positive finite integral and physical-shear +factor from R12: + + gamma(a)=sqrt(1+(a/(12k))^2), + J_cusp=integral H(h) gamma(a)^11 + h0(A0,Rot_O tau(a,a^2/(12k),a^3/(144k^2),xi)) da dxi dh dO. + +Set + + C0=(216/11) k^7 (c_m/z0) J_cusp, + I=246528/35, + J=1083417/280, + D=27066286003/223205220-(79298560/4782969) log(2), + I_max=I-D. (E5) + +Here D is a universal scalar shape integral, NOT a hard Hessian or the cubic +coefficient called D in CUB/R. In Sections3-4 the latter is written D_cub. + +**Theorem 1 (whole-cluster tail coefficients).** All the constants multiplying +C0 below are strictly positive, and + + F(t) ~ C0 I t^-11, [the prior R result] + G(t) ~ C0 (I-D) t^-11, + G2(t) ~ C0 J t^-11, + B2(t) ~ C0 D t^-11, + M(n=1,R_max>t) ~ C0 (I-D-J) t^-11. (E6) + +In particular the maximum/point coefficient ratio is the exact universal number + + theta_star=(I-D)/I + =1545114756173/1572181042176 + +(10841600/4605999147)log(2). (E7) + +This ratio is NOT asserted to be a temporal extremal index of the original +field. There is no stationary sequence of pin pairs or mixing assertion here. + +Under the ordinary microscopic cluster probability law +pi=A_micro^-1 1{n>0}dM, conditioning on R_max>t gives + + P_pi(n=2 | R_max>t) -> J/(I-D), + P_pi(K_t=2 | R_max>t) -> D/(I-D), + E_pi[K_t | R_max>t] -> I/(I-D), (E8) + +where K_t is the number of points above threshold t. A double cluster need +not have both of its points above the threshold. Exact rational/logarithmic +interval certificates, not numerical Gaussian integration, give + + 0.984415773209943375 < theta_star < 0.984415773209943376, + 0.558034234065747870 < J/(I-D) < 0.558034234065747871, + 0.015830939745347846 < D/(I-D) < 0.015830939745347847. (E9) + +**Theorem 2 (anchored extreme configuration).** Section6 specifies the full +weak limit of a cluster under pi(. | R_max>t), with its positions divided by t, +its original normalized heights, and its maximum-radius root distinguished. +The radial ratio has Pareto exponent11 and is independent of its anchored shape, +sign and cusp parameters. The limiting doublet is antipodal, has radius ratio +rho in (0,1), and its farther saddle has strictly GREATER downward height eta, +i.e. it lies lower in the height window. Shape/count/height/radius-ratio laws +are universal for these fixed-parameter microscopic extremes; the orientation +and tail amplitude generally retain model dependence. + +Theorems1-2 are new consumers, not part of R's already reviewed point theorem. + +## 3. Companion-root involution and the once-per-cluster shape domain + +Use R's shear invariants + + u=X+aZ/(12k), x=-s>0, + b0(u)=3-12u^2, v=xZ^2/k, + B=k b0(u)/Z^2, D_cub=k(v-b0(u)u)/Z^3. (E10) + +A strict typed window root is parametrized exactly by Z!=0 and + + S={-3/20. (E11) + +The letter S denotes this bounded SHAPE region, not the conditioned saddle. + +Put b=b0(u) temporarily and define + + L=4v^2-8buv+b^2, + t_c=(4v^2-b^2)/L, + u_c=[2bv-u(4v^2+b^2)]/L, v_c=v t_c^2. (E12) + +Off L=0, (u_c,v_c,t_c Z) is the other extra stationary root. Its membership +in S determines whether it is also counted. Thus n=2 exactly when (u_c,v_c) +is in S. L=0 is the degree-drop locus: the second root in this parametrization +is at infinity rather than a finite second point. It is an algebraic null set. +No contribution is assigned to a fictitious point there. + +Proof of E12. At Z'=tZ the stationary line and conic reduce to + + b u'+(v-bu)t=v, 12(u')^2+b t^2=3. + +When b!=0, substitute u'=(v-(v-bu)t)/b. The resulting quadratic has one root +1; its other root is the ratio of its constant to its leading coefficient: + + t_c=(12v^2-3b^2)/(12(v-bu)^2+b^3) + =(4v^2-b^2)/(4v^2-8buv+b^2). + +Substitution gives u_c and then v_c. At b=0 the direct equations give the +same formula wherever L!=0; the b=0 slice is null in any case. Since the +construction swaps the two roots, applying it twice returns the original +(u,v), with t_c t_cc=1. Direct useful identities are + + b0(u_c)=b t_c^2, + v_c-b0(u_c)u_c=(v-bu)t_c^3. (E13) + +These preserve the same x,B,D_cub under E10 with Z'=t_cZ. + +### 3.1 Explicit doublet and anchor domains + +For doublets b<0. Write p=-u, A=12p^2-3=-b>0. Define + + V_+(p)=[36p^2-12p-3+3 sqrt((2p-1)^3(18p+7))]/4, + L_p=A/2, U_p=3+6p. + +Up to boundary null sets, the doublet region splits into + + S2_outer: + 1/2=0 cannot meet v<-b. +For b<0, u=-p with 1/20. If p<1, +H_p(A)=18(p-1)(2p-1)^2(2p+1)<0 and A=1, U_p<=A and +H_p(U_p)=36(p-1)(2p+1)^2>=0, so the interval is (L_p,U_p). + +Both counted roots are on the negative branch of the hyperbola. The stationary +line minus that strictly concave branch is strictly convex and is negative +at Z=0 (its line intercept is -v/A<-1/2). If it has two zeros, zero lies strictly +between them: a strictly convex function with two zeros is positive outside +their interval. Hence t_c<0 on doublets. Since 4v^2-b^2>0, L<0 there. Consequently + + |t_c|>1 iff v>b u=A p, + |t_c|<1 iff v0, so +L_p=1, Ap-U_p=3(p-1)(2p+1)^2>=0. These +observations prove E14. Thus S_star contains exactly one asymptotic maximum +anchor per cluster, apart from the harmless tie curve. + +### 3.2 Height ordering and the intensity-change identity + +On a doublet put ell=v/A (>1/2). A direct substitution in E12 gives + + eta_c-eta=2(ell-p)(4p ell-1)^3/(4ell^2-8p ell+1)^2. (E17) + +Here p>1/2 and 4p ell>1. The outer anchor has ell

0 over a nonempty open set. I-D-J is positive because the single-root shape +sector is also nonempty and open. + +For later height moments define D_j=integral_(S2_inner) eta^j Q du dv. An explicit +primitive for the same rationalization is + + P_j(p,v)=sum_(ell=0..j) binom(j,ell)(1/2-p)^(j-ell)/6^ell + *[16p v^(ell+4)/(ell+4)-4A v^(ell+3)/(ell+3) + -4p A^2 v^(ell+2)/(ell+2)+A^3 v^(ell+1)/(ell+1)]. (E24) + +E22-E23 then give + + D_0=27066286003/223205220-(79298560/4782969)log2, + D_1=1259212131941593/15982386572880 + -(3186360320/387420489)log2, + D_2=72706616008642669/1315122095139840 + -(15686696960/3486784401)log2. (E25) + +For certified decimal bounds use log2=2 sum_(j>=0)3^(-(2j+1))/(2j+1). +After N terms the omitted positive remainder is bounded above by + + 2*3^(-(2N+1))/[(2N+1)(1-1/9)]. (E26) + +All interval endpoints are rational. The code uses60 terms, propagates coefficient +signs and positive divisions, and rounds the displayed lower/upper decimals +OUTWARD. No floating-point quadrature is used to establish E9 or E25. + +## 5. Proof of the maximum and minimum tails + +R's exact root-resolved integral is, with the physical radius retained, + + (108 k^7 c_m/z0) Q(u,v) H(h) |Z|^-12 + h0(A0,Rot_O tau(a,a^2/(12k)+k b0/Z^2, + a^3/(144k^2)+a b0/(4Z^2)+2k(v-b0u)/Z^3,xi)) + du dv dZ da dxi dh dO. (E27) + +It counts a cluster once for each of its qualifying roots. For G(t), multiply +by 1{R_i>t} times the indicator that this root has the greatest ACTUAL physical +radius, dividing by the number of ties if necessary. The sum over roots is +exactly 1{R_max>t}. This is a Borel operation on a finite configuration and +introduces no extra determinant or normalizer. + +Put Z=t z. For almost every shape, off the algebraic exceptional sets L=0, +eta_c in{0,1} and |t_c|=1, the actual maximum indicator tends to 1_(S_star). +Indeed, R_i/t->gamma(a)|z| and R_c/t->gamma(a)|t_c z| if a counted companion +exists. The bounded u and u_c offsets disappear, but a is NOT integrated away: +its gamma factor remains inside the radius condition. + +The dominating argument is exactly the source R11-R12 argument with one more +factor between0 and1. For t>=3, |u|<=3/2 and R_i>t imply +|z|>1/(2gamma(a)). Orthogonal Gaussian norm equivalence bounds the density by +C exp[-c(|h|^2+a^2+|xi|^2)]. The z-integral of |z|^-12 over that set costs +only C gamma(a)^11; S is bounded, H(h) is polynomial, and the resulting +Gaussian integral is finite. Thus dominated convergence applies, including +the unbounded a and hard/tensor coordinates. No inverse hard eigenvalue enters. + +The limiting z-integral on either sign, with the radius condition retained, +is gamma(a)^11/11. Both signs, the source factors108 and the cusp integral +yield C0. The shape integral is I_max=integral_(S_star)Q=I-D, proving +G(t)~C0(I-D)t^-11. Multiplying by 1{n=2} gives shape S2_outer and coefficient +C0 J for G2. E4 and the known point tail then give the B2 coefficient C0 D. +Subtract G2 from G to get the singleton coefficient. This proves E6, and all +ratios E7-E9 follow since the denominators have strictly positive limits. + +There is no assumption that the seed root's |Z| ordering equals physical +radius ordering at finite t. It need only agree almost everywhere in the limit; +the exact physical selector was used before taking that limit. + +Moment consequences: under the appropriate normalized nonempty/doublet measure, +R_max and R_min both have moment threshold11. For R_min the doublet condition is +understood. The capped unnormalized moments have exact boundary coefficients + + integral_(n>0) min(R_max,t)^11 dM ~11 C0(I-D)log t, + integral_(n=2) min(R_min,t)^11 dM ~11 C0 D log t. (E28) + +These follow from Tonelli and E6. They are not uniform finite-r spatial moments. + +## 6. Full anchored extreme law and its universal consequences + +Distinguish the actual maximum-radius root, using any Borel tie rule. Under +pi(. | R_max>t), retain its seed shape(u,v), q=R_max/t, sign epsilon=sign Z, +and remaining parameters(a,h,O,xi). The limiting joint probability is the product +of + + Q(u,v)1_(S_star)/I_max du dv; + 11q^-12 dq on q>1; + the uniform sign law on{-1,1}; + H(h)gamma(a)^11 h0(A0,Rot_O tau_cusp)/J_cusp da dxi dh dO. (E29) + +Proof: insert a bounded continuous function of these variables into E27 with +the exact maximum selector. The same majorant works. The limiting change +q=gamma(a)|z| produces gamma(a)^11 q^-12 dq, so normalization by the maximum +coefficient gives E29. The maps and the selector are continuous off the +already excluded null curves. This proves weak convergence, not total variation +of spatial laws. No uniformity in escaping model parameters is asserted. + +Let + + e_*(a,O)=[-a e_axis/(12k)+e_soft(O)]/gamma(a). + +If the selected shape is a singleton, the limiting marked configuration is +one point at epsilon q e_* with height eta=u+1/2+v/6. If it is a doublet, +put rho=|t_c|<1, eta_c=u_c+1/2+v_c/6. The full configuration, in positions +divided by the threshold t, is + + {(epsilon q e_*, eta, d-1), + (-epsilon q rho e_*, eta_c, d-1)}. (E30) + +E17 proves eta_c1. +Combining E31 with P(n=2)=J/I_max gives D/I_max in E8 once more. This reconciles +the two-point-cluster frequency with the much smaller double-exceedance frequency. + +### 6.1 The maximum anchor's height is not the old intensity-selected height + +Let H_eta(e) be R's nonnegative height numerator (H1-H2), with integral I. +The height density for the maximum anchor is instead + + [H_eta(e)-6 integral_(1/2)^1 Q(-p,6(e+p-1/2)) + 1{A(p)p<6(e+p-1/2)0, E6 gives + + P(max_(i<=n) R_max(C_i) <= a_n x) + =[1-P_pi(R_max>a_n x)]^n -> exp(-x^-11). (E34) + +This is the standard iid extreme-value consequence with the newly identified +cluster coefficient. Normalizing by the POINT tail coefficient instead gives +exp(-theta_star x^-11); it is not the same normalization. No new coefficient +convergence rate, simultaneous n/r limit, within-field Poisson assertion or +stationary-sequence extremal-index theorem follows from E34. + +## 8. Review obligations and nonclaims + +A: E10-E19, companion involution, strict-window partition, tie/degree-drop +boundaries, exact Jacobian/multiplicity and the height ordering. +B: E20-E26 and E33, the rationalized Laurent integral, all logarithmic constants, +certified rational intervals and the independent finite integration controls. +C: E27-E34, actual physical maximum selection, domination, full anchored weak +law, the differing sampling measures, min/max/exceedance coefficients and iid +scope. These are not waived by tests or parent review acceptance. + +No global scientific-status change, numerical evaluation of J_cusp, finite-r +uniform spatial tail/moment, new elder-pairing law, dependence theorem across pin +pairs, growing-volume theorem, or Lean formalization is claimed. Counterexamples +to shortcuts: F counts both above-threshold roots whereas G counts the cluster +once; replacing G by F sets theta_star=1 incorrectly. Omitting the maximum +selector and summing over roots gives the prior point-intensity height law, not +E32. Uniformly choosing one root inside each uniformly selected cluster is yet +another sampling convention and must not be identified with point intensity. Dropping log2 from E21 changes a positive exact shape integral. A single +1/r rescaling still cannot retain the remote singleton population. diff --git a/frontiers/extreme_cluster_sampling_20260930/README.md b/frontiers/extreme_cluster_sampling_20260930/README.md new file mode 100644 index 000000000..1584485a7 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/README.md @@ -0,0 +1,97 @@ +# Extreme whole-cluster sampling + +OpenAI / GPT-6 Astra Pro. New source-bound conditional proof candidate. +**Nonauthor analytic review OPEN. Scientific effect NONE. No self-merge.** + +PR166 identified the point-INTENSITY radius tail and extreme-height law. This +packet keeps the same limiting microscopic measure and selects each extreme +CLUSTER once. Those are different probability laws: a cluster with both roots +above a threshold contributes twice to point intensity but once to a maximum. + +Start with PROOF.md. It supplies an explicit companion-root involution, the +larger-radius anchor domain, exact maximum/minimum tail coefficients, a joint +anchored extreme law, strict height ordering in doublets, and certified universal +constants. Generic Palm/anchor and iid extreme-value principles are credited in +RECONNAISSANCE.md; no claim of inventing those general principles is made. + +## Main candidate results + +Let C0 be the common positive spectral/Gaussian amplitude defined in PROOF E5. +Put + + I=246528/35, + J=1083417/280, + D=27066286003/223205220-(79298560/4782969)log(2). + +The point tail is the prior C0 I t^-11. New proposed tails are + + cluster maximum: C0(I-D)t^-11; + doublet maximum: C0 J t^-11; + doublet minimum: C0 D t^-11. + +Thus maximum/point coefficient ratio is approximately0.9844157732099434; +a cluster conditioned to have an extreme maximum is a doublet with probability +about0.5580342340657479, whereas BOTH points exceed that same threshold with +probability about0.01583093974534785. These are not interchangeable statistics. +All displayed decimals have rational interval certificates, not quadrature fits. +No numerical evaluation of the Gaussian amplitude C0 is claimed. + +The maximum anchor's limiting downward height has mean about0.8195869887849185, +not the old point-intensity mean. On an extreme doublet its companion lies in +the opposite direction, is closer, and has a strictly smaller downward height. +The cluster radial maximum ratio is independently Pareto(11). See the full +parameter/shape law and qualifications in PROOF E29-E33. + +## Exact scope + +Every theorem here concerns the ALREADY-FORMED limiting microscopic measure: +**first r->0, then t->infinity**. Fixed d>=2,L>0,b real,k>0 and frame. The full +original endpoint normalizer is retained through its source z0. The remote +singleton population is not part of this measure. No finite-r uniform spatial +moment, convergence rate, original-field independence, numerical Gaussian +coefficient, new elder pairing, Lean formalization or global-register change. + +The source use is explicitly conditional: RADIAL root integral/majorant and +point theorem, MICRO definition M1-M2 only, SC's spectral measure/finite nonempty +mass, and CUB's deterministic classifier. MICRO's separate two-scale theorem, +PR159's alternative proof and PR157's exponential theorem are not premises. +The author of this thread authored SC/CUB; no independent revalidation is implied. + +## Reproduction + +Python standard library, compatible with Python3.11+. Full project source +verification requires a Git checkout with all four exact commit/path identities: + + python -B -S frontiers/extreme_cluster_sampling_20260930/verify.py + +The hosted workflow fetches the named public source commits, verifies every +historical path/blob/byte/SHA256, checks the complete packet, runs both Python +modes and the semantic negative controls. Git replacement refs are disabled, +annotated tags/trees cannot masquerade as commits, and source ancestors/leaves +are checked for actual regular-file/tree modes. + +Standalone replay without actual upstream Git objects: + + python -B -S verify.py --local-only + +This explicitly reports source_pins_checked=false. It still runs all real-Git +fixture regressions, but those authenticate test fixtures, not project sources. + +`extremes.py` is the independent exact control entry point. It uses Fraction +arithmetic for companion roots, strict domains, the anchor partition, Laurent +integration and outward log(2) enclosures. `test_extremes.py` includes an independent +line/conic root oracle, exact automatic differentiation of the involution Jacobian, +and dense interpolation checks of the Laurent integrand. Tests do not prove the +Gaussian domination, multiplicity change of variables, or weak convergence. + +## Review requested + +A: PROOF E10-E19, companion roots, type/window/degree-drop/tie boundaries, + exact anchor partition, weighted involution and height ordering. +B: E20-E26/E33, both strip integrals, Laurent rationalization, log(2) constants, + interval certificates and the distinct height sampling laws. +C: E27-E34, exact PHYSICAL maximum selector before the limit, Gaussian domination, + whole-cluster weak law, min/max/double-exceedance probabilities and iid scope. + +Pickups and verdicts must bind exact proof bytes and declare source exposure. +Neither a prior source verdict nor green code is acceptance of this new consumer. diff --git a/frontiers/extreme_cluster_sampling_20260930/RECONNAISSANCE.md b/frontiers/extreme_cluster_sampling_20260930/RECONNAISSANCE.md new file mode 100644 index 000000000..12bfcc069 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/RECONNAISSANCE.md @@ -0,0 +1,57 @@ +# Reconnaissance memo — 30 September 2026 UTC + +Scientific effect NONE. Limited literature reconnaissance, not a novelty or +priority audit. No retrieved paper supplies the Gaussian/pinned-field premises +of the new manuscript; those come from the exact GitHub sources. + +## Connector attempts + +Consensus.search was actually invoked on the two listed Primary and Gadget +accounts with queries about Gaussian critical-point clusters, Palm distributions, +regular variation and extreme cluster marks (years2015-2026/2018-2026). Both +returned the 30-search monthly quota error and an October1 reset. No search +result or paper record was obtained from that connector and none is fabricated. + +## Primary web searches and access depth + +Queries included: +- site.arxiv.org tail processes anchored cluster distributions extremal index regular variation +- site.arxiv.org Gaussian critical points repulsion Palm conditioning short range saddles + +Opened primary arXiv abstract/metadata records only: + +1. Hrvoje Planinic, "Palm theory for extremes of stationary regularly varying + time series and random fields", arXiv:2104.03810v2 (14 March2023). + https://arxiv.org/abs/2104.03810 + Relevant concept: exceedance-selected cluster laws carry a size bias relative + to an anchored/typical cluster law. This generic distinction predates this + packet. The new work is the exact companion involution, shape partition and + coefficients for the specified limiting pinned-Gaussian cubic measure. + +2. Gunter Last, "Tail processes and tail measures: An approach via Palm calculus", + arXiv:2112.15380v3 (9 January2023). + https://arxiv.org/abs/2112.15380 + Relevant concept: tail/exceedance measures, anchor maps and Palm calculus. + No temporal extremal index is inferred here: our original field is not turned + into a stationary regularly varying sequence of pin pairs by analogy. + +3. Dmitry Beliaev, Valentina Cammarota, Igor Wigman, "No repulsion between critical + points for planar Gaussian random fields", arXiv:1911.03455v3 (27 November2020). + https://arxiv.org/abs/1911.03455 + Related but different: short-range critical-point behavior in an unconditioned + planar isotropic model. It is not a proof of the present exact pinned, + determinant-tilted, already-formed microscopic extreme-cluster law. + +No full text of these papers was read for this memo. No exhaustive absence claim +is justified by these searches. The iid Frechet consequence in PROOF Section7 is +standard once its regularly varying tail has been derived; only its source-specific +coefficient is newly calculated here. + +## Source exposure and coordination + +This conversation authored PR158/CUB and PR162/SC. PR166/RADIAL and MICRO are +another OpenAI author lane, with their separate nonauthor records. Sharing a +provider or GitHub login confers no organizational independence. New consumers +require their own review. Main#95 pickup5901916663 and PR166 comment5902055460 +identify the nonoverlapping frontier and shared candidate formulas. No claimed +reviewer/writer lane was duplicated and no parent proof was changed. diff --git a/frontiers/extreme_cluster_sampling_20260930/RESULTS.json b/frontiers/extreme_cluster_sampling_20260930/RESULTS.json new file mode 100644 index 000000000..6cfef6d63 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/RESULTS.json @@ -0,0 +1,69 @@ +{ + "constants": { + "companion_ratio_11th_moment_given_double": { + "lower": "0.028369119274289249", + "upper": "0.028369119274289250" + }, + "double_cluster_given_extreme": { + "lower": "0.558034234065747870", + "upper": "0.558034234065747871" + }, + "inner_double_shape_mass": { + "lower": "109.769950345687984746", + "upper": "109.769950345687984747" + }, + "maximum_shape_mass": { + "lower": "6933.887192511454872396", + "upper": "6933.887192511454872397" + }, + "maximum_to_point_tail_ratio": { + "lower": "0.984415773209943375", + "upper": "0.984415773209943376" + }, + "mean_exceedance_count": { + "lower": "1.015830939745347846", + "upper": "1.015830939745347847" + }, + "outer_double_shape_mass": { + "lower": "3869.346428571428571428", + "upper": "3869.346428571428571429" + }, + "outer_height_mean": { + "lower": "0.819586988784918536", + "upper": "0.819586988784918537" + }, + "outer_height_second_moment": { + "lower": "0.694438469047655310", + "upper": "0.694438469047655311" + }, + "point_shape_mass": { + "lower": "7043.657142857142857142", + "upper": "7043.657142857142857143" + }, + "two_exceedances_given_extreme": { + "lower": "0.015830939745347846", + "upper": "0.015830939745347847" + } + }, + "inner_integrals": { + "0": [ + "27066286003/223205220", + "-79298560/4782969" + ], + "1": [ + "1259212131941593/15982386572880", + "-3186360320/387420489" + ], + "2": [ + "72706616008642669/1315122095139840", + "-15686696960/3486784401" + ] + }, + "log2_terms": 60, + "mathematical_acceptance": false, + "passed": true, + "rational_shape_cases": 893, + "scientific_effect": "NONE", + "scope": "exact finite identities and rational/logarithmic integrals only", + "tail_power": 11 +} diff --git a/frontiers/extreme_cluster_sampling_20260930/SOURCES.json b/frontiers/extreme_cluster_sampling_20260930/SOURCES.json new file mode 100644 index 000000000..c990aa1c0 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/SOURCES.json @@ -0,0 +1,44 @@ +{ + "schema": 1, + "repository": "d6g8k5htny-coder/Math-", + "scientific_effect": "NONE", + "new_consumer_review": "OPEN", + "sources": [ + { + "id": "RADIAL", + "commit": "80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337", + "path": "frontiers/two_scale_cluster_geometry_20260929/RADIAL_TAIL.md", + "bytes": 12533, + "sha256": "250897858c8b314c0ff85ec1860a725efacfdae0ff7409fced4cadf7bfb85973", + "git_blob": "0f14417ef7038b9c6f50e4b01e393a58b7b5e3a4", + "use": "Exact R4-R13 root integral, Gaussian domination, point tail; H3-H4 point height moments." + }, + { + "id": "MICRO", + "commit": "80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337", + "path": "frontiers/two_scale_cluster_geometry_20260929/TWO_SCALE_LAW.md", + "bytes": 17139, + "sha256": "e81d7fe09d25c3266eb8e62922756f54761d7f74d692fb35d9a8071fffd73769", + "git_blob": "a32fd5f7d941bbe1fe943df045b1e0fbec8d691c", + "use": "M1-M2 definition and original-frame embedding ONLY, not the two-scale convergence theorem." + }, + { + "id": "SC", + "commit": "382c0f9ff2281f43651ddbdf2e9b36dd52e2c6bf", + "path": "frontiers/spectral_cluster_closure_20260929/PROOF.md", + "bytes": 25006, + "sha256": "e971b2cbe50a8a06b47c1219191201e0d1037c9adac23e5e3b7d2051bb70c2eb", + "git_blob": "16c56821b52fd76b0be791622b9c3809eafde75a", + "use": "Explicit spectral/Gaussian micro measure, finite positive nonempty mass and raw Gaussian density bound. Author-side exposure." + }, + { + "id": "CUB", + "commit": "bfcc67dc8957b3ed1fbb789e5a0305e98d7359c8", + "path": "frontiers/planar_cubic_cluster_20260929/PROOF.md", + "bytes": 19889, + "sha256": "117e9299a71e6139270266889eb772ed97518e402d9af029bbdb67caf9d4a0f0", + "git_blob": "bb446d08db8a944537a743ad550b88c1c2ad5758", + "use": "Exact typed deterministic cubic classifier ONLY; no Gaussian-sector consumption. Author-side exposure." + } + ] +} diff --git a/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md b/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md new file mode 100644 index 000000000..381f28bfa --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md @@ -0,0 +1,90 @@ +# Validation record — author-side, not analytic acceptance + +Scientific effect NONE. Runtime: Python3.13.5 and Git2.47.3. Shipped code is +standard-library only and uses Python3.11-compatible syntax. The hosted workflow +requests Python3.11.16 and real historical project source objects. + +## Test-first mathematical work + +The initial ten-test scaffold produced ten expected assertion failures before +implementation. One proposed companion fixture was first recalculated from an +independent line/conic intersection and corrected BEFORE the implementation: +for u=-1,v=6 the correct companion is(-13/23,294/529,-7/23). + +After implementation, all ten tests passed. Subsequent mathematical tests bring +the suite to35 tests:893 rational shape/companion/classifier/anchor checks; +independent exact line/conic elimination;32 exact automatic-differentiation +checks of Q(T)|det DT|=Q|t_c|^11; direct polynomial-strip integrals; dense Lagrange +interpolation checks of the rationalized Laurent integrand at four rational +y-values and four height-moment orders; strict endpoint, degree-drop and tie +cases; outward rational log(2) intervals and normalized ratios. + +An exploratory generic symbolic integration timed out. The delivered integral +certificate instead uses the explicit rationalizing substitution and a finite +Laurent polynomial, integrated termwise by Fraction arithmetic. Exploratory CAS +scripts are not runtime dependencies or shipped proof evidence. + +## Test-first custody work + +A no-op verifier scaffold ran31 real-Git/inventory test methods and produced45 +expected assertion failures (including separate subtests). The completed verifier +passed all31. Hostile fixtures cover changed historical identities, source files +whose worktree contents differ, missing/duplicate/unexpected identities, path +traversal, duplicate JSON, ancestor and leaf symlinks, tree/blob/annotated-tag +objects offered as commits, and Git replacement refs that can forge or invalidate +ordinary git-show results. All Git reads disable replacements, and the nested +packet path test exercises --full-tree. No project source tampering is asserted. + +The hosted environment also sets GIT_NO_REPLACE_OBJECTS=1. Replaying the hostile +fixture under that environment first produced two expected failures because its +ordinary git-show precondition inherited the protection. The fixture now removes +that variable ONLY for its deliberately ordinary Git calls; the real verifier +always disables replacements. Replaying the same environment passes both controls. +This fixes the test harness, not the source-authentication policy. + +## Fresh complete local replay + +66 tests PASS under python -B -S and66 under python -B -O -S. Normal/optimized +baseline stdout is byte-identical to RESULTS.json with no stderr. The eight +semantic mutants reject with return code1 in EACH mode on the intended assertions: + +| Mutation | Intended rejected statement | +|---|---| +| drop-companion-sign | signed companion | +| point-is-cluster | one maximum anchor, not point counting | +| close-window | height endpoint must be open | +| drop-log2 | inner integral | +| double-count-inner | inner integral | +| lose-height-jacobian | point integral and height convention | +| wrong-tail-power | cusp exponent ledger | +| uniform-cluster-from-point | cluster law must be unbiassed | + +Unknown mutant labels return2. The complete packet inventory is authenticated +before and after replay. No temporary files or __pycache__ are added to it. + +The decimal enclosures use60 rational terms of the convergent log(2) series, +a rigorous rational remainder upper bound, signed interval arithmetic, positive +divisions and outward decimal rounding. No Gaussian coefficient is numerically +computed and no quadrature is used to certify a decimal. + +## Limitations and corrections + +The local environment could not resolve raw.githubusercontent.com; no full +upstream checkout was obtained. Therefore local-only replay explicitly reports +source_pins_checked=false. Real-Git fixtures test the verifier but do not replace +actual source authentication. The hosted target must fetch and verify all four +SOURCES.json identities, separately from the existing full downstream/formal gates. +No hosted pass is asserted by this author-time file; actual head/run/job readbacks +will be posted on the PR, with revalidation if head or base changes. + +During manuscript self-review, a loose sentence equating a uniformly chosen root +of a uniformly chosen cluster with point intensity was corrected before the +first publication. Point intensity sums over roots and biases cluster sampling; +uniformly choosing a root within a uniformly chosen cluster is a third convention. +The corrected PROOF Section8 explicitly distinguishes them. + +Finite exact tests support algebra and implementation. They do not independently +prove the source Gaussian assumptions, changes of variables with multiplicity, +physical-anchor domination or weak convergence. Those new arguments require +source-bound nonauthor analytic review. Existing Lean package success is not a +Lean formalization of this manuscript. No self-merge or scientific-register fold. diff --git a/frontiers/extreme_cluster_sampling_20260930/extremes.py b/frontiers/extreme_cluster_sampling_20260930/extremes.py new file mode 100644 index 000000000..38f3d4537 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/extremes.py @@ -0,0 +1,352 @@ +"""Exact controls for the extreme whole-cluster candidate; standard library only. + +The rational identities and integral certificates are executable. Gaussian +conditioning, changes of variables and weak limits are analytic obligations, +not conclusions that this program certifies. +""" +from __future__ import annotations +import argparse +from fractions import Fraction as F +import json +from math import comb +from typing import Optional + +Poly = dict[int, F] +AffineLog = tuple[F, F] # a + b log(2) +Interval = tuple[F, F] +MUTANTS = ('drop-companion-sign', 'point-is-cluster', 'close-window', + 'drop-log2', 'double-count-inner', 'lose-height-jacobian', + 'wrong-tail-power', 'uniform-cluster-from-point') +_MUTANT: Optional[str] = None + + +def _r(x: F | int) -> F: + if isinstance(x, bool) or not isinstance(x, (F, int)): + raise TypeError('an integer or Fraction is required') + return F(x) + + +def b0(u: F | int) -> F: + u = _r(u) + return 3 - 12*u*u + + +def height(u: F | int, v: F | int) -> F: + return _r(u) + F(1, 2) + _r(v)/6 + + +def in_shape(u: F | int, v: F | int) -> bool: + u, v = _r(u), _r(v) + if _MUTANT == 'close-window': + return -F(3,2) <= u <= F(1,2) and abs(b0(u))/2 <= v <= 3-6*u + return -F(3,2) < u < F(1,2) and abs(b0(u))/2 < v < 3-6*u + + +def shape_weight(u: F | int, v: F | int) -> F: + u, v = _r(u), _r(v) + b = b0(u) + return (4*v*v-b*b)*(b-4*u*v) + + +def companion(u: F | int, v: F | int) -> Optional[tuple[F, F, F]]: + """Other root's (u',v',Z'/Z); None is the linear degree-drop case. + + This algebraic map is defined even outside the strict shape region; + membership must be checked separately. It is not a field root solver. + """ + u, v = _r(u), _r(v) + b = b0(u) + den = 4*v*v - 8*b*u*v + b*b + if den == 0: + return None + t = (4*v*v-b*b)/den + up = (2*b*v-u*(4*v*v+b*b))/den + vp = v*t*t + if _MUTANT == 'drop-companion-sign': + t = abs(t) + return up, vp, t + + +def is_double(u: F | int, v: F | int) -> bool: + if not in_shape(u,v): + return False + c = companion(u,v) + return c is not None and in_shape(c[0], c[1]) + + +def classifier_double(u: F | int, v: F | int) -> bool: + """Independent CUB threshold read on an already counted root.""" + u, v = _r(u), _r(v) + b = b0(u) + return in_shape(u,v) and v < -b and 12*(v-b*u)**2 < (v+b)**2*(2*v-b) + + +def anchor_weight(u: F | int, v: F | int) -> F: + """Asymptotic |Z|-maximum selector; ties have weight one half.""" + if not in_shape(u,v): + raise ValueError('strictly typed in-window root required') + if _MUTANT == 'point-is-cluster': + return F(1) + c = companion(u,v) + if c is None or not in_shape(c[0], c[1]): + return F(1) + ratio = abs(c[2]) + return F(1) if ratio < 1 else F(1,2) if ratio == 1 else F(0) + + +def inner_double(u: F | int, v: F | int) -> bool: + """Polynomial description; strict boundary, no square-root comparison.""" + u, v = _r(u), _r(v) + p = -u + a = 12*p*p-3 + f = -2*v*v+(36*p*p-12*p-3)*v-72*p**3+36*p*p+18*p-9 + return in_shape(u,v) and F(1,2)0 + + +def outer_double(u: F | int, v: F | int) -> bool: + u, v = _r(u), _r(v) + p = -u + a = 12*p*p-3 + return ((F(1,2) Poly: + out: Poly = {} + for poly in polys: + for k, value in poly.items(): + out[k] = out.get(k,F(0)) + value + return {k:v for k,v in out.items() if v} + + +def scale(poly: Poly, c: F | int) -> Poly: + c = _r(c) + return {k:v*c for k,v in poly.items() if v*c} + + +def multiply(left: Poly, right: Poly) -> Poly: + out: Poly = {} + for i,x in left.items(): + for j,y in right.items(): + out[i+j] = out.get(i+j,F(0)) + x*y + return {k:v for k,v in out.items() if v} + + +def power(poly: Poly, n: int) -> Poly: + if isinstance(n,bool) or not isinstance(n,int) or n<0: + raise ValueError('nonnegative integer power required') + result: Poly = {0:F(1)} + base = dict(poly) + while n: + if n & 1: + result = multiply(result,base) + base = multiply(base,base) + n //= 2 + return result + + +def evaluate(poly: Poly, x: F | int) -> F: + x = _r(x) + return sum((v*x**k for k,v in poly.items()),F(0)) + + +def integrate_polynomial(poly: Poly, left: F, right: F) -> F: + if any(k<0 for k in poly): + raise ValueError('ordinary polynomial required') + return sum((v*(right**(k+1)-left**(k+1))/F(k+1) + for k,v in poly.items()),F(0)) + + +def _moment_gap(u: Poly, b: Poly, hi: Poly, lo: Poly, j: int) -> Poly: + """Integrate Q(u,v)*(u+1/2+v/6)^j in v between polynomial bounds.""" + if isinstance(j,bool) or not isinstance(j,int) or not 0<=j<=12: + raise ValueError('moment order must be an integer between 0 and 12') + q = {3:scale(u,-16), 2:scale(b,4), + 1:scale(multiply(u,power(b,2)),4), 0:scale(power(b,3),-1)} + bias = add(u,{0:F(1,2)}) + total: Poly = {} + for ell in range(j+1): + eta = scale(power(bias,j-ell),F(comb(j,ell),6**ell)) + for order, coef in q.items(): + n = order+ell+1 + gap = add(power(hi,n),scale(power(lo,n),-1)) + total = add(total,scale(multiply(multiply(eta,coef),gap),F(1,n))) + return total + + +def point_moment(j: int) -> F: + u: Poly = {1:F(1)} + b = add({0:F(3)},scale(power(u,2),-12)) + hi = add({0:F(3)},scale(u,-6)) + value = F(0) + for left,right,sgn in ((F(-3,2),F(-1,2),-1),(F(-1,2),F(1,2),1)): + poly = _moment_gap(u,b,hi,scale(b,F(sgn,2)),j) + value += integrate_polynomial(poly,left,right) + return value/6 if _MUTANT=='lose-height-jacobian' else value + + +def inner_certificate(j: int) -> Poly: + """Laurent integrand on y in [1/4,1], after rationalizing V_+(p).""" + p: Poly = {-1:F(2,9), 0:F(1,18), 1:F(2,9)} + a = add(scale(power(p,2),12),{0:F(-3)}) + hi: Poly = {-2:F(8,9), -1:F(-4,3), 1:F(4,9)} + lo = multiply(a,p) + gap = _moment_gap(scale(p,-1),scale(a,-1),hi,lo,j) + return multiply(gap,{-2:F(2,9),0:F(-2,9)}) + + +def inner_moment(j: int) -> AffineLog: + poly = inner_certificate(j) + rat = sum((c*(1-F(1,4)**(k+1))/F(k+1) + for k,c in poly.items() if k!=-1),F(0)) + log = 2*poly.get(-1,F(0)) + if _MUTANT=='drop-log2': + log = F(0) + if _MUTANT=='double-count-inner': + rat,log = 2*rat,2*log + return rat,log + + +def outer_double_mass() -> F: + p: Poly = {1:F(1)} + a = add(scale(power(p,2),12),{0:F(-3)}) + u,b,lo = scale(p,-1),scale(a,-1),scale(a,F(1,2)) + first = _moment_gap(u,b,multiply(a,p),lo,0) + second = _moment_gap(u,b,add({0:F(3)},scale(p,6)),lo,0) + return (integrate_polynomial(first,F(1,2),F(1)) + + integrate_polynomial(second,F(1),F(3,2))) + + +def log_two_bounds(n: int=60) -> Interval: + """Rational atanh(1/3) lower sum and a proved geometric upper remainder.""" + if isinstance(n,bool) or not isinstance(n,int) or n<1: + raise ValueError('positive integer number of terms required') + z,power_z = F(1,3), F(1,3) + lower = F(0) + for j in range(n): + lower += 2*power_z/F(2*j+1) + power_z *= z*z + remainder = 2*power_z/(F(2*n+1)*(1-z*z)) + return lower,lower+remainder + + +def affine_bounds(value: AffineLog, log: Interval) -> Interval: + a,b = value + return (a+b*log[0],a+b*log[1]) if b>=0 else (a+b*log[1],a+b*log[0]) + + +def divide_positive(numerator: Interval, denominator: Interval) -> Interval: + if numerator[0]<0 or denominator[0]<=0: + raise ValueError('positive interval division required') + return numerator[0]/denominator[1],numerator[1]/denominator[0] + + +def subtract_fixed(x: F, interval: Interval) -> Interval: + return x-interval[1],x-interval[0] + + +def certified_constants(n: int=60) -> dict[str,Interval]: + log = log_two_bounds(n) + I,J = point_moment(0),outer_double_mass() + inner = affine_bounds(inner_moment(0),log) + max_mass = subtract_fixed(I,inner) + inner1 = affine_bounds(inner_moment(1),log) + inner2 = affine_bounds(inner_moment(2),log) + double_probability = divide_positive((J,J),max_mass) + if _MUTANT=='uniform-cluster-from-point': + double_probability = ((J+inner[0])/I,(J+inner[1])/I) + return { + 'point_shape_mass':(I,I), 'inner_double_shape_mass':inner, + 'maximum_shape_mass':max_mass, 'outer_double_shape_mass':(J,J), + 'maximum_to_point_tail_ratio':(max_mass[0]/I,max_mass[1]/I), + 'double_cluster_given_extreme':double_probability, + 'two_exceedances_given_extreme':divide_positive(inner,max_mass), + 'mean_exceedance_count':divide_positive((I,I),max_mass), + 'companion_ratio_11th_moment_given_double':(inner[0]/J,inner[1]/J), + 'outer_height_mean':divide_positive(subtract_fixed(point_moment(1),inner1),max_mass), + 'outer_height_second_moment':divide_positive(subtract_fixed(point_moment(2),inner2),max_mass), + } + + +def decimal_bounds(interval: Interval, digits: int=18) -> dict[str,str]: + if not 1<=digits<=60: + raise ValueError('digits must lie between 1 and 60') + unit = 10**digits + lo = interval[0]*unit + hi = interval[1]*unit + low = lo.numerator//lo.denominator + high = -((-hi.numerator)//hi.denominator) + def fmt(n: int) -> str: + sign='-' if n<0 else '' + n=abs(n) + return f'{sign}{n//unit}.{n%unit:0{digits}d}' + return {'lower':fmt(low),'upper':fmt(high)} + + +def _need(ok: bool, message: str) -> None: + if not ok: + raise AssertionError(message) + + +def finite_checks() -> int: + _need(not in_shape(F(-1),F(9)),'height endpoint must be open') + _need(companion(F(-1),F(6))==(F(-13,23),F(294,529),F(-7,23)), 'signed companion') + _need(anchor_weight(F(-3,4),F(3))==0,'one maximum anchor, not point counting') + _need(point_moment(0)==F(246528,35),'point integral and height convention') + _need(point_moment(1)/point_moment(0)==F(5771,7062),'point first moment') + _need(inner_moment(0)==(F(27066286003,223205220),-F(79298560,4782969)), 'inner integral') + _need(outer_double_mass()==F(1083417,280),'outer double integral') + const = certified_constants(50) + p2=const['double_cluster_given_extreme'] + _need(F(558,1000)=high:continue + for j in range(1,20): + v=low+(high-low)*F(j,20) + _need(in_shape(u,v) and shape_weight(u,v)>0,'open positive shape') + c=companion(u,v) + _need(is_double(u,v)==classifier_double(u,v),'companion/CUB disagreement') + if c is not None: + up,vp,t=c + _need(b0(up)==b*t*t,'conic invariance') + _need(b*up+(v-b*u)*t==v,'line invariance') + back=companion(up,vp) + _need(back is not None and back[0]==u and back[1]==v and back[2]*t==1,'involution') + if in_shape(up,vp): + _need(t<0,'doublet transverse signs') + _need(anchor_weight(u,v)+anchor_weight(up,vp)==1,'once per cluster') + if abs(t)!=1: + _need(inner_double(u,v)==(abs(t)>1),'inner region') + _need(outer_double(u,v)==(abs(t)<1),'outer region') + _need((height(up,vp)-height(u,v))*(abs(t)-1)>0,'outer saddle is deeper') + cases+=1 + return cases + + +def results() -> dict: + cases=finite_checks() + return {'passed':True,'scientific_effect':'NONE','mathematical_acceptance':False, + 'scope':'exact finite identities and rational/logarithmic integrals only', + 'rational_shape_cases':cases,'log2_terms':60, + 'tail_power':11, + 'inner_integrals':{str(j):[str(x) for x in inner_moment(j)] for j in range(3)}, + 'constants':{k:decimal_bounds(v) for k,v in sorted(certified_constants().items())}} + + +def main() -> None: + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--mutant',choices=MUTANTS) + args=parser.parse_args() + global _MUTANT + _MUTANT=args.mutant + print(json.dumps(results(),indent=2,sort_keys=True)) + + +if __name__=='__main__':main() diff --git a/frontiers/extreme_cluster_sampling_20260930/test_extremes.py b/frontiers/extreme_cluster_sampling_20260930/test_extremes.py new file mode 100644 index 000000000..503ca3571 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/test_extremes.py @@ -0,0 +1,213 @@ +"""Exact algebra controls; these tests do not certify the Gaussian arguments.""" +from fractions import Fraction as F +import unittest +import extremes as e + +class InitialTests(unittest.TestCase): + def test_strict_shape(self): + self.assertTrue(e.in_shape(F(-3,4),F(3))) + def test_companion_exact(self): + self.assertEqual(e.companion(F(-1),F(6)),(F(-13,23),F(294,529),F(-7,23))) + def test_outer_double_mass(self): + self.assertEqual(e.outer_double_mass(),F(1083417,280)) + def test_point_mass(self): + self.assertEqual(e.point_moment(0),F(246528,35)) + def test_point_mean(self): + self.assertEqual(e.point_moment(1)/F(246528,35),F(5771,7062)) + def test_inner_mass(self): + self.assertEqual(e.inner_moment(0),(F(27066286003,223205220),-F(79298560,4782969))) + def test_inner_first_moment(self): + self.assertEqual(e.inner_moment(1),(F(1259212131941593,15982386572880),-F(3186360320,387420489))) + def test_inner_second_moment(self): + self.assertEqual(e.inner_moment(2),(F(72706616008642669,1315122095139840),-F(15686696960,3486784401))) + def test_log_two_lower(self): + lo,hi=e.log_two_bounds(30) + self.assertGreater(lo,F(6931471805599453,10**16)) + def test_log_two_upper(self): + lo,hi=e.log_two_bounds(30) + self.assertLess(hi,F(6931471805599454,10**16)) + self.assertGreater(hi,lo) + + +class GeometryTests(unittest.TestCase): + def test_full_rational_grid(self): + self.assertEqual(e.finite_checks(),893) + def test_degree_drop(self): + self.assertTrue(e.in_shape(F(-5,8),F(27,16))) + self.assertIsNone(e.companion(F(-5,8),F(27,16))) + self.assertEqual(e.anchor_weight(F(-5,8),F(27,16)),1) + def test_equal_radius_doublet(self): + u,v=F(-3,4),F(45,16) + self.assertEqual(e.companion(u,v),(u,v,F(-1))) + self.assertEqual(e.anchor_weight(u,v),F(1,2)) + def test_zero_B_finite_companion_outside_window(self): + c=e.companion(F(-1,2),F(3)) + self.assertEqual(c,(F(1,2),F(3),F(1))) + self.assertFalse(e.is_double(F(-1,2),F(3))) + self.assertEqual(e.anchor_weight(F(-1,2),F(3)),1) + def test_height_and_type_boundaries_are_open(self): + for u,v in ((F(-1),F(9)),(F(-1),F(9,2)),(F(-1,2),F(0))): + self.assertFalse(e.in_shape(u,v)) + def test_invalid_numeric_types(self): + for x in (True,0.5,'1/2'): + with self.subTest(x=x),self.assertRaises(TypeError):e.b0(x) + def test_anchor_rejects_outside_shape(self): + with self.assertRaises(ValueError):e.anchor_weight(2,1) + def test_other_root_via_independent_line_conic(self): + for iu in range(-21,7): + u=F(iu,16);b=3-12*u*u + if not -F(3,2) Path: + """Check spelling before resolve; a symlinked ancestor must not disappear.""" + path=Path(os.path.abspath(path)) + for p in (path,*path.parents): + if p.is_symlink(): raise ValueError('symlink prohibited: '+str(p)) + return path + + +def read_json(path: Path) -> dict: + path=no_symlinks(path) + def unique(pairs): + result={} + for key,value in pairs: + if key in result: raise ValueError('duplicate JSON key: '+key) + result[key]=value + return result + obj=json.loads(path.read_text(encoding='utf-8'),object_pairs_hook=unique) + if not isinstance(obj,dict): raise ValueError('JSON object required: '+str(path)) + return obj + + +def source_path(text: str) -> PurePosixPath: + if not isinstance(text,str) or not text or '\\' in text or '\0' in text: + raise ValueError('invalid path') + p=PurePosixPath(text) + if p.is_absolute() or '..' in p.parts or str(p)!=text or str(p)=='.': + raise ValueError('noncanonical source path: '+text) + return p + + +def check_identity(data: bytes, entry: dict) -> None: + if not isinstance(entry,dict): raise ValueError('identity entry must be an object') + size=entry.get('bytes'); sha=entry.get('sha256'); blob=entry.get('git_blob') + if type(size) is not int or size<0 or not isinstance(sha,str) or not HEX64.fullmatch(sha): + raise ValueError('invalid size/hash metadata') + if not isinstance(blob,str) or not HEX40.fullmatch(blob): raise ValueError('invalid blob identity') + actual_blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if len(data)!=size or hashlib.sha256(data).hexdigest()!=sha or actual_blob!=blob: + raise ValueError('identity mismatch: '+str(entry.get('path'))) + + +def git(root: Path, *args: str) -> bytes: + env=os.environ.copy() + for key in ('GIT_DIR','GIT_WORK_TREE','GIT_INDEX_FILE','GIT_OBJECT_DIRECTORY', + 'GIT_ALTERNATE_OBJECT_DIRECTORIES','GIT_NAMESPACE'): + env.pop(key,None) + env['GIT_NO_REPLACE_OBJECTS']='1' + command=['git','--no-replace-objects','--literal-pathspecs',*args] + try: + return subprocess.run(command,cwd=root,env=env,capture_output=True, + check=True,timeout=60).stdout + except (subprocess.CalledProcessError,subprocess.TimeoutExpired) as exc: + raise ValueError('Git authentication failed: '+' '.join(args)) from exc + + +def verify_sources(root: Path, required_ids=None) -> int: + root=no_symlinks(root) + required=SOURCE_IDS if required_ids is None else frozenset(required_ids) + entries=read_json(root/'SOURCES.json').get('sources') + if not isinstance(entries,list) or not entries or not required: + raise ValueError('nonempty exact source inventory required') + ids=[]; paths=[] + for entry in entries: + if not isinstance(entry,dict) or not isinstance(entry.get('id'),str): + raise ValueError('invalid source entry') + ids.append(entry['id']) + commit=entry.get('commit'); path=entry.get('path') + if not isinstance(commit,str) or not HEX40.fullmatch(commit): + raise ValueError('literal full commit identity required') + p=source_path(path); paths.append((commit,path)) + # Reject tree/blob/annotated-tag objects, rather than peeling them. + if git(root,'cat-file','-t',commit)!=b'commit\n': + raise ValueError('declared source object is not a commit') + for count in range(1,len(p.parts)+1): + prefix='/'.join(p.parts[:count]) + raw=git(root,'ls-tree','--full-tree','-z',commit,'--',prefix) + records=[record for record in raw.split(b'\0') if record] + if len(records)!=1: raise ValueError('missing/ambiguous source path: '+prefix) + try: + header,name=records[0].split(b'\t',1) + mode,kind,object_sha=header.split() + except ValueError as exc: raise ValueError('malformed Git tree record') from exc + if name.decode('utf-8')!=prefix: raise ValueError('Git path mismatch') + if count int: + root=no_symlinks(root) + entries=read_json(root/'MANIFEST.json').get('files') + if not isinstance(entries,list) or not entries: raise ValueError('empty packet inventory') + names=[] + for entry in entries: + if not isinstance(entry,dict): raise ValueError('invalid packet identity') + text=entry.get('path'); p=source_path(text) + if len(p.parts)!=1 or text=='MANIFEST.json': raise ValueError('flat packet leaf required') + names.append(text) + path=no_symlinks(root/text) + if not path.is_file(): raise ValueError('missing regular packet file: '+text) + check_identity(path.read_bytes(),entry) + if len(names)!=len(set(names)): raise ValueError('duplicate packet path') + if sorted(p.name for p in root.iterdir())!=sorted(names+['MANIFEST.json']): + raise ValueError('complete packet inventory mismatch') + return len(entries) + + +def main() -> None: + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--local-only',action='store_true') + args=parser.parse_args() + root=no_symlinks(Path(__file__).absolute().parent) + verify_inventory(root) + n_sources=0 if args.local_only else verify_sources(root) + expected=(root/'RESULTS.json').read_bytes() + for flags in (['-B','-S'],['-B','-O','-S']): + subprocess.run([sys.executable,*flags,'-m','unittest','discover','-v'], + cwd=root,check=True,timeout=180) + command=[sys.executable,*flags,str(root/'extremes.py')] + result=subprocess.run(command,cwd=root,capture_output=True,check=True,timeout=60) + if result.stdout!=expected or result.stderr: + raise ValueError('deterministic mathematical output mismatch') + for name in MUTANTS+('unknown',): + result=subprocess.run(command+['--mutant',name],cwd=root, + capture_output=True,timeout=60) + if result.returncode!=(2 if name=='unknown' else 1): + raise ValueError('negative control did not reject: '+name) + verify_inventory(root) + print(json.dumps({'passed':True,'source_pins_checked':not args.local_only, + 'source_count':n_sources,'scientific_effect':'NONE', + 'mathematical_acceptance':False},sort_keys=True)) + + +if __name__=='__main__': main() From 40159ba8c051ee5e9293178e110d108a940734fa Mon Sep 17 00:00:00 2001 From: d6g8k5htny-coder Date: Wed, 30 Sep 2026 01:55:14 +0000 Subject: [PATCH 02/13] Remote coefficient numerics: script, source map, README and replay workflow (RESULTS.json and NOTE.md follow after the full run) Work in progress on the second numerics packet frontiers/c6_remote_coefficient_numerics_20260930: evaluation of the contact kernel Lambda_j of [RM] (13) in the plane for the parent kernel, its far field, the correlation-hole constant and k integral_X Lambda. Scientific effect NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../c6-remote-coefficient-numerics.yml | 62 ++ .../NOTE_template.md | 155 ++++ .../README.md | 20 + .../SOURCE_MAP.json | 65 ++ .../remote.py | 717 ++++++++++++++++++ 5 files changed, 1019 insertions(+) create mode 100644 .github/workflows/c6-remote-coefficient-numerics.yml create mode 100644 frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md create mode 100644 frontiers/c6_remote_coefficient_numerics_20260930/README.md create mode 100644 frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json create mode 100644 frontiers/c6_remote_coefficient_numerics_20260930/remote.py diff --git a/.github/workflows/c6-remote-coefficient-numerics.yml b/.github/workflows/c6-remote-coefficient-numerics.yml new file mode 100644 index 000000000..068d3a0c9 --- /dev/null +++ b/.github/workflows/c6-remote-coefficient-numerics.yml @@ -0,0 +1,62 @@ +name: C6 remote coefficient numerics (replay) + +'on': + pull_request: + paths: + - 'frontiers/c6_remote_coefficient_numerics_20260930/**' + - '.github/workflows/c6-remote-coefficient-numerics.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-controls-and-replay: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify manifest and main-resident pins, replay exact controls and sample kernels, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('frontiers/c6_remote_coefficient_numerics_20260930').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + if present != sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']): + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + pins = json.loads((root / 'SOURCE_MAP.json').read_text()) + for entry in pins['sources']: + if not entry['current_required']: + continue + data = pathlib.Path(entry['path']).read_bytes() + blob = hashlib.sha1(b'blob %d\0' % len(data) + data).hexdigest() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256'] or blob != entry['git_blob']: + raise ValueError('consumed source identity mismatch on this tree: ' + entry['path']) + script = str(root / 'remote.py') + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script, '--check'], cwd=root, capture_output=True, timeout=900) + if out.returncode != 0: + raise RuntimeError('check failed under ' + ' '.join(flags) + ': ' + out.stdout.decode()[-400:]) + for m in ['hermite-sign', 'det-abs', 'weight-indicator']: + rc = subprocess.run([sys.executable, *flags, script, '--check', '--mutant', m], cwd=root, capture_output=True, timeout=900).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'certified': False})) + PY + git diff --exit-code diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md new file mode 100644 index 000000000..03171e09c --- /dev/null +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md @@ -0,0 +1,155 @@ +# Numerical values of the remote singleton coefficient `k integral_X Lambda` (planar, parent kernel) + +**Object:** `CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1`. **Author lane:** Anthropic / Claude. **Kind:** numerical +note. **Scientific effect:** NONE. **Certified:** no (floating-point quadrature with convergence checks; not an +enclosure). Companion of the near-coefficient note `frontiers/c6_cluster_coefficients_numerics_20260930` +(Math-#168), which evaluated `nu_near(1) = alpha_1` and `nu(2) = alpha_2` and listed the remote part of `nu(1)` as +not evaluated. This note evaluates that part. + +## 1. What is evaluated + +[CL] (1.4) writes the one-point cluster coefficient as + + nu(1) = nu_near(1) + k integral_X Lambda(x; b, k, u) dx, Lambda = sum_j Lambda_j, + +with `Lambda_j` the contact kernel of [RM] (13): + + Lambda_j(x) = p_(Y_x | U_0 = v_0)(0, b) / z_0 . E[ w_0 F_j(H_x) | U_0 = v_0, Y_x = (0, b) ], + +`U_0 = (f, f_x, f_z, f_xx, f_xz, f_xxx)(0) = (b, 0, 0, 0, 0, 12k)` the contact observation, `A_0 = f_zz(0)` the soft +curvature, `w_0 = (6k)^2 A_0^2 1{A_0 < 0}` ([RM] (10) at `d = 2`), `z_0 = E[w_0 | U_0 = v_0] = 36 k^2 m_(2,b)` +([RM] (11), [LP] (5.4)), `Y_x = (f_x, f_z, f)(x)`, `H_x` the Hessian at `x`, `F_j(H) = |det H| 1{index H = j}`. The +field is the centered unit-variance Gaussian field on `X = R^2/(L Z^2)` with the exact kernel of [LP] section 2, +`K_L(z) = sum_n exp(-|z + Ln|^2/2) / sum_n exp(-|Ln|^2/2)`. Everything is a finite-dimensional Gaussian +computation: the 13-vector of jets (seven at `0`, six at `x`) has covariance +`Cov(d^alpha f(s), d^beta f(t)) = (-1)^|alpha| (d^(alpha+beta) K_L)(t - s)`, with +`d^a_x d^c_z exp(-|z|^2/2) = (-1)^(a+c) He_a(x_1) He_c(z) exp(-|z|^2/2)` (probabilists' Hermite polynomials). + +[CL] section 5.1 shows `k integral_X Lambda = lim_(rho -> 0) k integral_(D_rho) Lambda` exists, with +`k integral_(|x| < rho) Lambda <= C rho^2`; so `Lambda` is integrable at the pin and the torus integral of the +kernel is the right object. A direct scaling check is consistent with this: at a critical point `x` of the contact +field at level `b` with `|x| = eps` small, the Euler identity `x . grad f = 3 C + A_0 z^2 + 4 q + ...` for the cubic +part `C`, the soft quadratic `A_0 z^2 / 2` and the quartic part `q` forces `A_0 z^2 = O(eps^4)`, i.e. `A_0 = O(eps^2)`; +the density of `Y_x` at `(0, b)` is `O(eps^(-6))` while `w_0 |det H_x| = O(eps^4 . eps^2)`, so `Lambda = O(1)` as +`x -> 0`. (A first guess `A_0 = O(eps)` would give `Lambda ~ eps^(-2)` and a logarithmically divergent integral; +it is wrong exactly because of the Euler identity.) The computed values confirm boundedness and, in fact, +`Lambda(x) -> 0` as `x -> 0` (section 4). + +## 2. Exact structure + +**Far field.** As `|x| -> infinity` the two sites decouple: `p_(Y_x | U_0)(0, b) -> phi(b)/(2 pi)` (`f`, `f_x`, +`f_z` independent with unit variance), `E[w_0 | U_0] / z_0 -> 1`, and `H_x | (f = b, grad f = 0)` has `h_1 = f_xx`, +`h_3 = f_zz ~ N(-b, 2)` independent (`Var f_xx = 3`, `Cov(f_xx, f_zz) = 1`, `Cov(f, f_xx) = -1`, regression on +`f = b` removes the common part), `h_2 = f_xz ~ N(0, 1)`. Hence + + Lambda_inf,j(b) = phi(b)/(2 pi) . E[ F_j(H) | f = b, grad f = 0 ], + +the ordinary height-resolved density of index-`j` critical points at level `b`, per unit height and area. It is +`k`-free; the `k`-dependence of `Lambda(x)` enters only through the conditioning on `f_xxx(0) = 12k` and dies with +the correlations. + +**Exact control of the Hessian integrator.** For the unconditional planar Hessian (`Var h_1 = Var h_3 = 3`, +`Cov(h_1, h_3) = 1`, `Var h_2 = 1`) write `h_1 = a + c`, `h_3 = a - c` with `a ~ N(0, 2)`, `c ~ N(0, 1)` independent; +then `det H = a^2 - (c^2 + h_2^2) = a^2 - rho^2` with `rho^2 ~ Exp(mean 2)`, so +`E|det H| = 2 E[(rho^2 - a^2)_+] = 4 E exp(-a^2/2) = 4/sqrt3`, `E F_1 = 2/sqrt3`, `E F_0 = E F_2 = 1/sqrt3`, +`E det H = 0`. (Total critical-point density `2/(pi sqrt3) = 0.3676`, maxima `1/(2 pi sqrt3) = 0.0919`: the +Longuet-Higgins values for this spectrum.) The integrator reproduces these to `{{absdet_err}}` (absolute). + +**Coordinates adapted to the cone `det H = 0`.** The integrals `E[A_0^2 1{A_0 < 0} |det H| 1{index j}]` over the +conditional Gaussian law of `(A_0, H_x)` are computed with `A_0` integrated out in closed form +(`E[A^2 1{A < 0}] = (m^2 + s^2) Phi(-m/s) - m s phi(m/s)` for `A | H ~ N(m, s^2)`, `m` affine in `H`) and the +three Hessian coordinates written as `a = tr H / 2` and polar `(rho, theta)` in the traceless plane `(c, h_2)`. +Then `det H = a^2 - rho^2`, the kink of `|det H|` is the coordinate surface `rho = |a|`, and the index is read off +from `rho < |a|` (definite; sign of `a` separates minimum and maximum) or `rho > |a|` (saddle). The `a`-range is +split at `0`, the `rho`-range at `|a|`, the `theta` nodes are those of the periodic trapezoid rule under an +analytic map concentrating them at the angular position of the (generally offset and anisotropic) conditional +mean; every piece of the integrand is smooth, and the nested rule converges geometrically on the exact control +(`{{absdet_err_hi}}` at the higher order). + +**Ill-conditioned points.** Near the pin axis the conditional law of `Y_x` given `U_0` has variances down to +`|x|^6`, and the double-precision regression can lose positivity where `Lambda` is already below `10^(-20)`. Such +points (`{{exact_count}}` in the whole run) are recomputed in 50-digit decimal arithmetic; none carries weight. + +## 3. Method + +`Lambda_j(x)` is evaluated on midpoint grids (spacing `h`, reflection symmetry `z -> -z` used) and integrated by +the midpoint rule: + +- continuum kernel, hole constant `c_hole,j = integral_(R^2) (Lambda_j - Lambda_inf,j) dx` on `[-6, 6]^2` + (`h = 0.15`; the neglected exterior has `|Lambda - Lambda_inf| < 10^(-6) Lambda_inf`, correlations at distance 6 + being of size `K(6) = e^(-18)`); +- periodized kernel at `L = 6`, direct integral over the fundamental domain `[-3, 3]^2` (`h = 0.15`); +- periodized kernel at `L = 12`, direct integral (`h = 0.2`), compared with `L^2 Lambda_inf + c_hole`. + +Then `integral_X Lambda ~ L^2 Lambda_inf + c_hole` for `L = 12, 24` (the periodization correction being +`O(e^(-18))` at `L >= 12`), and the remote singleton mass is `k` times that. + +## 4. Values + +**Far field** (`k`-free), per unit height and area: + +| `b` | `Lambda_inf` | minima `j = 0` | saddles `j = 1` | maxima `j = 2` | `p_inf = phi(b)/(2 pi)` | +|---|---|---|---|---|---| +{{far_rows}} + +(At `b = 0`: `E|det H_0| = {{EdetH0}}` with `h_1, h_3 ~ N(0, 2)`, `h_2 ~ N(0, 1)`.) + +**Correlation hole** `c_hole = integral_(R^2) (Lambda - Lambda_inf) dx` (dimension of an area times a density +per height; negative means depletion): + +| `k` | `b` | `c_hole` | `j = 0` | `j = 1` | `j = 2` | `c_hole / Lambda_inf` (effective depleted area) | +|---|---|---|---|---|---|---| +{{hole_rows}} + +The pinned pair depletes its neighbourhood: along the pin axis the contact field is `b + 2k x_1^3 + ...` to leading +order, a monotone ramp, so window-level critical points near the pins live in the transverse sector only +(`Lambda(x)/Lambda_inf` is below `10^(-10)` on the axis out to `|x_1| ~ 1.5` and recovers to `1` at `|x| ~ 3`; +the ray profiles at angles `0, 30, 45, 60, 90` degrees are in `RESULTS.json`, `ray_profile`). Near the pin +`Lambda -> 0` (`near_zero_profile`: `Lambda(0.05, 45 deg) = {{near05}}`, `Lambda(0.4, 90 deg) = {{near04}}` at +`k = 1, b = 0`). Almost the whole `k`-dependence of the hole comes from the transverse sector where the +`f_xxx = 12k` conditioning is felt. + +**Remote singleton mass** `R(k, b, L) = k integral_X Lambda dx` and the assembled `nu(1)`, with `alpha_1` from the +companion note (Math-#168, GH60 values; `alpha_2` likewise): + +| `k` | `b` | `L` | `integral_X Lambda` | `R = k integral_X Lambda` | `alpha_1` (#168) | `nu(1) = alpha_1 + R` | `nu(2) = alpha_2` | `nu(2)/nu(1)` | +|---|---|---|---|---|---|---|---|---| +{{total_rows}} + +For `L = 6` the direct periodized integral and the approximation `36 Lambda_inf + c_hole` are both given +(`RESULTS.json`, `remote_total`); they differ by `{{L6_dev}}` relative (the periodization changes the one-site +covariances by up to `8.8e-4` at `L = 6`). For `L = 12` the direct integral at `k = 1, b = 0` is +`{{L12_direct}}` against `{{L12_approx}}` from the far field plus hole. + +**Reading.** For the parent torus sizes the remote singletons dominate `nu(1)` by two orders of magnitude at +`L = 24` (`R ~ L^2 Lambda_inf`), so the two-point cluster probability relative to a nonempty window is +`nu(2)/(nu(1) + nu(2)) ~ {{share24}}` at `k = 1, b = 0, L = 24`, against the near-only share `0.019` reported in +#168. The near share is the right object for the cluster geometry; the global share is the right object for the +finite-torus count. + +## 5. Precision (empirical, not bounds) + +- Quadrature: at the eight sample points the default orders `(24, 32, 24)` differ from `(32, 48, 32)` by at most + `{{qdev}}` relative; on the exact unconditional control the default order is accurate to `{{absdet_err}}`. +- Grid: at `k = 1, b = 0` the hole constant is `{{hole_h03}}` (`h = 0.3`), `{{hole_h015}}` (`h = 0.15`), + `{{hole_h01}}` (`h = 0.1`); with the higher quadrature order at `h = 0.3`: `{{hole_h03_hi}}`. Cutting the domain at + `|x_i| <= 5` instead of `6` changes it by `{{tail_dev}}`. +- The periodized `L = 12` direct integral agrees with far field plus hole to `{{L12_rel}}` relative. + +These are observed discrepancies. No error bound is claimed. + +## 6. What the numbers are not + +Not a proof and not an enclosure. They are values of the formula [RM] (13) integrated as [CL] (1.4) prescribes; +[RM] is an accepted source, [CL] nonauthor-accepted and merged; the numbers do not re-review either. Planar only +(`d = 2`); no rate, no finite-`r` statement; the assembled `nu(1)` inherits the empirical precision of #168's +`alpha_1` (about `0.3%` or better). No register, catalog or STATUS change. Same GitHub account as every lane; zero +organizational-independence credit. The author will not merge. + +## 7. Provenance + +`remote.py` (standard library; `--check` replays the exact controls, the far field, sixteen sample kernels at two +parameter pairs for the continuum and the `L = 6` kernel, one decimal-regression point and the near-zero profile +against `RESULTS.json`; three mutants `hermite-sign`, `det-abs`, `weight-indicator` must exit 1), `RESULTS.json` +(full run, about {{minutes}} minutes), `SOURCE_MAP.json` (pins [LP], [RM], [CL], [RC] on `main` +`7d0c89a`), `SOURCE_FILES.json`, workflow `c6-remote-coefficient-numerics.yml`. diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/README.md b/frontiers/c6_remote_coefficient_numerics_20260930/README.md new file mode 100644 index 000000000..3822b393a --- /dev/null +++ b/frontiers/c6_remote_coefficient_numerics_20260930/README.md @@ -0,0 +1,20 @@ +# Remote singleton coefficient numerics (planar, parent kernel) + +**Object:** `CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1`. **Author lane:** Anthropic / Claude. **Kind:** numerical +note (floating-point quadrature with convergence checks; no proof, no enclosure). **Scientific effect:** NONE. + +Evaluates the contact kernel `Lambda_j(x; b, k, u)` of [RM] (13) in the plane for the parent kernel +`K(z) = exp(-|z|^2/2)` and its `L`-periodization, its far-field value, the correlation-hole constant +`c_hole = integral_(R^2) (Lambda - Lambda_inf) dx`, and the remote singleton mass `k integral_X Lambda dx` +that enters `nu(1)` by [CL] (1.4). Companion of the near-coefficient note (Math-#168), whose values of +`alpha_1 = nu_near(1)` are quoted to assemble `nu(1)`. + +- `NOTE.md` — statement of what is evaluated, exact structure, method, values, precision, non-claims. +- `remote.py` — standard-library script: `--check` (exact controls and replay against `RESULTS.json`), full run + regenerates `RESULTS.json`; `--mutant {hermite-sign, det-abs, weight-indicator}` must exit 1. +- `RESULTS.json` — all numbers, grids and convergence checks. +- `SOURCE_MAP.json` — pinned sources on `main` (blob identities); `SOURCE_FILES.json` — packet manifest. +- Workflow `.github/workflows/c6-remote-coefficient-numerics.yml` replays manifest, pins, both check modes and the + mutants. + +Same GitHub account as every other lane; zero organizational-independence credit. The author will not merge. diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json new file mode 100644 index 000000000..1366afcec --- /dev/null +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json @@ -0,0 +1,65 @@ +{ + "schema": 1, + "object": "CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1", + "scientific_effect": "NONE", + "source_repository": "d6g8k5htny-coder/Math-", + "main_at_creation": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", + "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures.", + "sources": [ + { + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "id": "LP", + "commit": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", + "role": "section 2: the exact periodized Gaussian kernel K_L (periodization of exp(-|z|^2/2)); section 3: contact frame U_0 and target v_0 = (b, 0, 0, 12k, 0, 0); (5.4)-(5.5): the full normalizer z_0 = lim Z_r / r^2", + "current_required": true, + "on_main": true + }, + { + "path": "frontiers/remote_window_20260924/PROOF.md", + "bytes": 18355, + "sha256": "a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7", + "git_blob": "b383bfcc88ec4ad497dff01fb6640e429ba24a84", + "id": "RM", + "commit": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", + "role": "Theorem A (fixed-remote mean measure) and the contact kernel Lambda_j(x; b, k, u) of (13): p_(Y_x | U_0 = v_0)(0, b) / z_0 times E[w_0 F_j(H_x) | U_0 = v_0, Y_x = (0, b)] with w_0 = (6k)^2 (det A_0)^2 1{A_0 < 0} ((10)) and z_0 = E[w_0 | U_0 = v_0] ((11)); this is the object evaluated", + "current_required": true, + "on_main": true + }, + { + "path": "frontiers/c6_cluster_law_20260929/PROOF.md", + "bytes": 70131, + "sha256": "96b8e2d59defee6059bf151a896b7fc7c91fc529b385a3db8a87574901197b38", + "git_blob": "ba492c8e62e58bfc055fc8254c790e893d346ba5", + "id": "CL", + "commit": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", + "role": "(1.4): nu(1) = nu_near(1) + k integral_X Lambda dx, nu(2) = nu_near(2); section 5.1 (5.2): existence of k integral_X Lambda = lim_(rho -> 0) k integral_(D_rho) Lambda with error <= C rho^2, which is what makes the torus integral of the bounded kernel the right object; Math-#159, nonauthor-accepted (OpenAI review 5360192822), merged", + "current_required": true, + "on_main": true + }, + { + "path": "frontiers/remote_collision_20260928/PROOF.md", + "bytes": 26002, + "sha256": "b9b8b58fd8266db7ffe6537078003888ef138b445d3289ec5588f116af9050c2", + "git_blob": "7b48a88e2af54e759e89a8c8219573bb450a65ea", + "id": "RC", + "commit": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", + "role": "Corollary E: Q_r^W{N_j(E) >= 1} = k r^3 integral_E Lambda_j + O(r^4 |E|) on fixed remote regions, the probability reading of the same kernel (context only)", + "current_required": true, + "on_main": true + } + ], + "companion": { + "path": "frontiers/c6_cluster_coefficients_numerics_20260930/RESULTS.json", + "pull_request": "Math-#168", + "head": "0b35e76ff05676e6ad5c89171d65807668c8de15", + "role": "near coefficients alpha_1(k, b), alpha_2(k, b) quoted in NOTE.md section 5 to assemble nu(1) = alpha_1 + k integral_X Lambda; unmerged at this writing, hence not a current_required pin and not checked by the workflow", + "current_required": false, + "on_main": false + }, + "nonauthor_acceptance": false, + "governing_status_changed": false, + "main_at_update": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d" +} diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py new file mode 100644 index 000000000..9bfdd36d7 --- /dev/null +++ b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py @@ -0,0 +1,717 @@ +#!/usr/bin/env python3 +"""Numerical evaluation of the remote contact kernel Lambda_j(x; b, k, u) of [RM] (13) for the +parent kernel K(z) = exp(-|z|^2/2) (and its L-periodization) in the plane d = 2, together with +its far-field value, the correlation-hole constant and the torus integral k * integral_X Lambda dx +that enters nu(1) = nu_near(1) + k integral_X Lambda ([CL] (1.4)). + +Standard library only. Deterministic nested Gauss quadrature; no random numbers except in the +optional Monte Carlo cross-check (fixed seed). Nothing here is a proof or an enclosure. + + python -B -S remote.py # full run, writes RESULTS.json (long: tens of minutes) + python -B -S remote.py --check # exact controls + replay of a small subset against RESULTS.json + python -B -S remote.py --check --mutant NAME # must exit 1 + +Conventions. Coordinates x = (x1, z): x1 along the pin axis u, z transverse. Jets are indexed by +derivative orders (a, c) = d^a/dx1^a d^c/dz^c. Cov(d^alpha f(s), d^beta f(t)) = (-1)^|alpha| +(d^(alpha+beta) K)(t - s). Contact observation U_0 = (f, f_x, f_z, f_xx, f_xz, f_xxx)(0) = +(b, 0, 0, 0, 0, 12k); A_0 = f_zz(0); Y_x = (f_x, f_z, f)(x) = (0, 0, b); H_x = (f_xx, f_xz, f_zz)(x). +w_0 = 36 k^2 A_0^2 1{A_0 < 0}; z_0 = E[w_0 | U_0] = 36 k^2 m_(2,b). +Lambda_j(x) = p_(Y_x | U_0)(0, 0, b) * E[w_0 F_j(H_x) | U_0, Y_x] / z_0, F_j(H) = |det H| 1{index j}. +""" +import argparse +import json +import math +import os +import random +import sys +from decimal import Decimal, getcontext +from fractions import Fraction + +getcontext().prec = 50 + +HERE = os.path.dirname(os.path.abspath(__file__)) +MUTANTS = ('hermite-sign', 'det-abs', 'weight-indicator') +MUT = None + +SITE0 = [(0, 0), (1, 0), (0, 1), (2, 0), (1, 1), (0, 2), (3, 0)] # f, f_x, f_z, f_xx, f_xz, f_zz, f_xxx at 0 +SITEX = [(0, 0), (1, 0), (0, 1), (2, 0), (1, 1), (0, 2)] # f, f_x, f_z, f_xx, f_xz, f_zz at x +OBS0 = [0, 1, 2, 3, 4, 6] # U_0 within the 13-vector +OBSX = [8, 9, 7] # Y_x = (f_x, f_z, f)(x) +TARGETS = [5, 10, 11, 12] # A_0 = f_zz(0), h1 = f_xx(x), h2 = f_xz(x), h3 = f_zz(x) + + +def require(cond, msg): + if not cond: + print('FAIL: ' + msg) + sys.exit(1) + + +# ----------------------------------------------------------------------------- Hermite / kernel +def hermite(n, t): + """Probabilists' Hermite polynomial He_n(t): (d/dt)^n exp(-t^2/2) = (-1)^n He_n(t) exp(-t^2/2).""" + h0, h1 = 1, t + if n == 0: + return h0 + for m in range(1, n): + h0, h1 = h1, t * h1 - m * h0 + return h1 + + +def _exp(t): + return t.exp() if isinstance(t, Decimal) else math.exp(t) + + +def _sqrt(t): + return t.sqrt() if isinstance(t, Decimal) else math.sqrt(t) + + +def _log(t): + return t.ln() if isinstance(t, Decimal) else math.log(t) + + +def kernel_derivative(a, c, x1, z, L=None, images=2): + """(d^a/dx1^a d^c/dz^c) K_L(x1, z) for K(z) = exp(-|z|^2/2), K_L its normalized L-periodization. + L = None: continuum kernel (single image). Works in float or Decimal arithmetic (type of x1).""" + if L is None: + return (-1) ** (a + c) * hermite(a, x1) * hermite(c, z) * _exp(-(x1 * x1 + z * z) / 2) + tot = 0 * x1 + norm = 0 * x1 + for m1 in range(-images, images + 1): + for m2 in range(-images, images + 1): + s1, s2 = x1 + L * m1, z + L * m2 + tot += (-1) ** (a + c) * hermite(a, s1) * hermite(c, s2) * _exp(-(s1 * s1 + s2 * s2) / 2) + norm += _exp(-(L * L) * (m1 * m1 + m2 * m2) / 2 + 0 * x1) + return tot / norm + + +def cov_entry(alpha, beta, dx1, dz, L=None): + """Cov(d^alpha f(s), d^beta f(t)) with t - s = (dx1, dz).""" + sign = (-1) ** (alpha[0] + alpha[1]) + if MUT == 'hermite-sign': + sign = (-1) ** (beta[0] + beta[1]) + return sign * kernel_derivative(alpha[0] + beta[0], alpha[1] + beta[1], dx1, dz, L) + + +def joint_covariance(x1, z, L=None): + """13 x 13 covariance of the two-site jet vector (SITE0 at 0, SITEX at x); float or Decimal.""" + jets = [(0, a) for a in SITE0] + [(1, a) for a in SITEX] + n = len(jets) + zero = 0 * x1 + if L is not None and isinstance(x1, Decimal): + L = Decimal(L) + C = [[zero] * n for _ in range(n)] + for i in range(n): + si, ai = jets[i] + for j in range(n): + sj, aj = jets[j] + d1 = (x1 if sj == 1 else zero) - (x1 if si == 1 else zero) + d2 = (z if sj == 1 else zero) - (z if si == 1 else zero) + C[i][j] = cov_entry(ai, aj, d1, d2, L) + return C + + +# ----------------------------------------------------------------------------- exact one-site table +def hermite_zero_exact(n): + """He_n(0) exactly: 0 for odd n, (-1)^(n/2) (n-1)!! for even n.""" + if n % 2: + return Fraction(0) + v = Fraction(1) + for m in range(1, n, 2): + v *= m + return v * (-1) ** (n // 2) + + +def exact_one_site_cov(alpha, beta): + return (-1) ** (alpha[0] + alpha[1]) * hermite_zero_exact(alpha[0] + beta[0]) * hermite_zero_exact(alpha[1] + beta[1]) + + +# ----------------------------------------------------------------------------- linear algebra +def cholesky(A): + n = len(A) + zero = 0 * A[0][0] + Lm = [[zero] * n for _ in range(n)] + for i in range(n): + for j in range(i + 1): + s = A[i][j] - sum((Lm[i][k] * Lm[j][k] for k in range(j)), zero) + if i == j: + if s <= 0: + raise ValueError('matrix not positive definite (pivot %r at %d)' % (s, i)) + Lm[i][j] = _sqrt(s) + else: + Lm[i][j] = s / Lm[j][j] + return Lm + + +def chol_solve(Lm, b): + n = len(Lm) + zero = 0 * Lm[0][0] + y = [zero] * n + for i in range(n): + y[i] = (b[i] - sum((Lm[i][k] * y[k] for k in range(i)), zero)) / Lm[i][i] + x = [zero] * n + for i in reversed(range(n)): + x[i] = (y[i] - sum((Lm[k][i] * x[k] for k in range(i + 1, n)), zero)) / Lm[i][i] + return x + + +def submatrix(C, rows, cols): + return [[C[i][j] for j in cols] for i in rows] + + +def condition(C, obs, values, targets): + """Gaussian regression: law of C[targets] given C[obs] = values (zero prior means). + Returns (mean, cov, obs_logdensity_at_values).""" + Coo = submatrix(C, obs, obs) + zero = 0 * C[0][0] + values = [v + zero for v in values] + Lm = cholesky(Coo) + alpha = chol_solve(Lm, values) + logdet = 2 * sum((_log(Lm[i][i]) for i in range(len(obs))), zero) + quad = sum((values[i] * alpha[i] for i in range(len(obs))), zero) + logdens = float(-quad / 2 - logdet / 2) - 0.5 * len(obs) * math.log(2 * math.pi) + mean = [] + cov = [] + Cto = submatrix(C, targets, obs) + for r, t in enumerate(targets): + mean.append(sum((Cto[r][i] * alpha[i] for i in range(len(obs))), zero)) + solved = [chol_solve(Lm, Cto[r]) for r in range(len(targets))] + for r, t in enumerate(targets): + row = [] + for s, u in enumerate(targets): + row.append(C[t][u] - sum((Cto[r][i] * solved[s][i] for i in range(len(obs))), zero)) + cov.append(row) + return mean, cov, logdens + + +# ----------------------------------------------------------------------------- quadrature rules +def gauss_legendre(n): + nodes, weights = [], [] + for i in range(1, n + 1): + x = math.cos(math.pi * (i - 0.25) / (n + 0.5)) + for _ in range(100): + p0, p1 = 1.0, x + for m in range(2, n + 1): + p0, p1 = p1, ((2 * m - 1) * x * p1 - (m - 1) * p0) / m + dp = n * (x * p1 - p0) / (x * x - 1.0) + dx = p1 / dp + x -= dx + if abs(dx) < 1e-15: + break + p0, p1 = 1.0, x + for m in range(2, n + 1): + p0, p1 = p1, ((2 * m - 1) * x * p1 - (m - 1) * p0) / m + dp = n * (x * p1 - p0) / (x * x - 1.0) + nodes.append(x) + weights.append(2.0 / ((1.0 - x * x) * dp * dp)) + return nodes, weights + + +def gauss_hermite(n): # retained for the Monte Carlo-free control of the normalization; unused in the main integral + """Probabilists' Gauss-Hermite: sum w_i g(t_i) ~ E g(T), T ~ N(0, 1).""" + nodes, weights = [], [] + for i in range(1, n + 1): + if i == 1: + x = math.sqrt(2 * n + 1) - 1.85575 * (2 * n + 1) ** (-1.0 / 6.0) + elif i == 2: + x = nodes[-1] - 1.14 * n ** 0.426 / nodes[-1] + elif i == 3: + x = 1.86 * nodes[-1] - 0.86 * nodes[0] + elif i == 4: + x = 1.91 * nodes[-1] - 0.91 * nodes[-2] + else: + x = 2.0 * nodes[-1] - nodes[-2] + for _ in range(200): + h0, h1 = 1.0, x + for m in range(1, n): + h0, h1 = h1, x * h1 - m * h0 + dh = n * h0 + dx = h1 / dh + x -= dx + if abs(dx) < 1e-14: + break + h0, h1 = 1.0, x + for m in range(1, n): + h0, h1 = h1, x * h1 - m * h0 + nodes.append(x) + weights.append(math.factorial(n) / (n * n * h0 * h0)) + return nodes, weights + + +SQRT2PI = math.sqrt(2 * math.pi) + + +def phi(t): + return math.exp(-t * t / 2) / SQRT2PI + + +def Phi(t): + return 0.5 * math.erfc(-t / math.sqrt(2)) + + +def m2_negative(m, s): + """E[A^2 1{A < 0}] for A ~ N(m, s^2).""" + if MUT == 'weight-indicator': + return m * m + s * s + if s <= 0.0: + return m * m if m < 0 else 0.0 + t = m / s + return (m * m + s * s) * Phi(-t) - m * s * phi(t) + + +class Rules: + """Quadrature orders: n_a Gauss-Legendre nodes on each side of a = 0, n_theta trapezoid nodes on the circle, + n_rho Gauss-Legendre nodes on each of [0, |a|] and [|a|, rho_max]; Gaussian ranges cut at cut standard deviations.""" + + def __init__(self, n_a=24, n_theta=32, n_rho=24, cut=9.0): + self.gl_a = gauss_legendre(n_a) + self.n_theta = n_theta + self.gl_rho = gauss_legendre(n_rho) + self.cut = cut + self.orders = [n_a, n_theta, n_rho] + + +def weighted_determinant_integrals(mu, S, rules): + """(A, h1, h2, h3) ~ N(mu, S). Returns dict with + G[j] = E[ A^2 1{A<0} |det H| 1{index H = j} ], F[j] = E[ |det H| 1{index H = j} ], D = E det H (control). + Coordinates: a = (h1 + h3)/2, c = (h1 - h3)/2, so det H = a^2 - c^2 - h2^2 = a^2 - rho^2 with (c, h2) = + rho (cos theta, sin theta). The cone det H = 0 is the coordinate surface rho = |a|; the a-range is split at 0 + (index by the sign of the trace) and the rho-range at |a|, so every piece of the integrand is smooth and the + nested Gauss-Legendre / trapezoid rule converges geometrically. The general (non-isotropic) Gaussian density + of (a, c, h2) is evaluated directly at the nodes; A is integrated out in closed form through m2_negative.""" + # linear map (h1, h2, h3) -> w = (a, c, h2) + T = [[0.5, 0.0, 0.5], [0.5, 0.0, -0.5], [0.0, 1.0, 0.0]] + SHH = [[S[i][j] for j in (1, 2, 3)] for i in (1, 2, 3)] + muH = [mu[1], mu[2], mu[3]] + muw = [sum(T[i][k] * muH[k] for k in range(3)) for i in range(3)] + TS = [[sum(T[i][k] * SHH[k][j] for k in range(3)) for j in range(3)] for i in range(3)] + Sw = [[sum(TS[i][k] * T[j][k] for k in range(3)) for j in range(3)] for i in range(3)] + Lw = cholesky(Sw) + logdet = 2.0 * sum(math.log(Lw[i][i]) for i in range(3)) + norm = math.exp(-0.5 * logdet) / (2 * math.pi) ** 1.5 + # A | w regression: A = muA + wA . (w - muw), residual sd sA + SAH = [S[0][j] for j in (1, 2, 3)] + SAw = [sum(T[i][k] * SAH[k] for k in range(3)) for i in range(3)] + wA = chol_solve(Lw, SAw) + sA = math.sqrt(max(S[0][0] - sum(SAw[i] * wA[i] for i in range(3)), 0.0)) + muA = mu[0] + # inverse via Cholesky for the quadratic form + Linv = [[0.0] * 3 for _ in range(3)] + for j in range(3): + e = [1.0 if i == j else 0.0 for i in range(3)] + col = chol_solve(Lw, e) + for i in range(3): + Linv[i][j] = col[i] + P = Linv # S_w^{-1} + cut = rules.cut + sa = math.sqrt(Sw[0][0]) + sc, s2 = math.sqrt(Sw[1][1]), math.sqrt(Sw[2][2]) + rho_max = math.hypot(muw[1], muw[2]) + cut * max(sc, s2) + G = [0.0, 0.0, 0.0] + F = [0.0, 0.0, 0.0] + # theta nodes: periodic trapezoid rule in u, theta = theta0 + u - beta sin u, concentrated at the angular + # position theta0 of the (c, h2) mean when the Gaussian is offset and narrow (analytic periodic map: the + # trapezoid rule keeps its geometric convergence; the Jacobian 1 - beta cos u is included in the weights) + rmu = math.hypot(muw[1], muw[2]) + smax = max(sc, s2) + width = min(1.0, smax / max(rmu, 1e-300)) + beta = max(0.0, 1.0 - rules.n_theta * width / (8 * math.pi)) + theta0 = math.atan2(muw[2], muw[1]) if rmu > 0 else 0.0 + cs = [] + for i in range(rules.n_theta): + u = -math.pi + 2 * math.pi * (i + 0.5) / rules.n_theta + th = theta0 + u - beta * math.sin(u) + cs.append((math.cos(th), math.sin(th), 1.0 - beta * math.cos(u))) + wtheta = 2 * math.pi / rules.n_theta + a_lo, a_hi = muw[0] - cut * sa, muw[0] + cut * sa + for lo, hi in ((a_lo, min(0.0, a_hi)), (max(0.0, a_lo), a_hi)): + if hi <= lo: + continue + mid, half = 0.5 * (lo + hi), 0.5 * (hi - lo) + for ta, wa in zip(*rules.gl_a): + a = mid + half * ta + wt_a = wa * half + aa = abs(a) + jpos = 0 if a > 0 else 2 # det > 0: sign of the trace decides minimum (0) / maximum (2) + segs = [] + if aa < rho_max: + segs.append((0.0, aa, jpos)) + segs.append((aa, rho_max, 1)) + else: + segs.append((0.0, rho_max, jpos)) + da = a - muw[0] + for lo_r, hi_r, j in segs: + if hi_r <= lo_r: + continue + mid_r, half_r = 0.5 * (lo_r + hi_r), 0.5 * (hi_r - lo_r) + accG = accF = 0.0 + for tr, wr in zip(*rules.gl_rho): + rho = mid_r + half_r * tr + adet = a * a - rho * rho + if MUT != 'det-abs': + adet = abs(adet) + base = wr * rho * adet + for cth, sth, jac in cs: + c = rho * cth + h2 = rho * sth + dc = c - muw[1] + d2 = h2 - muw[2] + q = (P[0][0] * da * da + P[1][1] * dc * dc + P[2][2] * d2 * d2 + + 2 * (P[0][1] * da * dc + P[0][2] * da * d2 + P[1][2] * dc * d2)) + if q > 2 * cut * cut: + continue + dens = math.exp(-0.5 * q) * jac + mA = muA + wA[0] * da + wA[1] * dc + wA[2] * d2 + accF += base * dens + accG += base * dens * m2_negative(mA, sA) + G[j] += wt_a * half_r * accG + F[j] += wt_a * half_r * accF + scale = norm * wtheta + G = [g * scale for g in G] + F = [f * scale for f in F] + D = (muw[0] ** 2 + Sw[0][0]) - (muw[1] ** 2 + Sw[1][1]) - (muw[2] ** 2 + Sw[2][2]) + return {'G': G, 'F': F, 'D': D} + + +# ----------------------------------------------------------------------------- Lambda +def m2b(b): + return m2_negative(-b, math.sqrt(2.0)) + + +def _conditioning(x1, z, b, k, L, exact): + """Density of Y_x at (0, 0, b) given U_0 (log) and the conditional law (mu, S) of (A_0, H_x) given + U_0 and Y_x. exact = True recomputes the Gaussian regression in 50-digit decimal arithmetic (used + automatically where the double-precision regression loses positivity; the near-axis points, where + Lambda is exponentially small).""" + if exact: + x1, z, bb, kk = Decimal(repr(x1)), Decimal(repr(z)), Decimal(repr(b)), Decimal(repr(k)) + else: + bb, kk = b, k + C = joint_covariance(x1, z, L) + u0 = [bb, 0 * bb, 0 * bb, 0 * bb, 0 * bb, 12 * kk] + meanY, covY, _ = condition(C, OBS0, u0, OBSX) + LY = cholesky(covY) + dev = [0 - meanY[0], 0 - meanY[1], bb - meanY[2]] + a = chol_solve(LY, dev) + logp = float(-sum((dev[i] * a[i] for i in range(3)), 0 * bb) / 2 - sum((_log(LY[i][i]) for i in range(3)), 0 * bb)) - 1.5 * math.log(2 * math.pi) + obs = OBS0 + OBSX + vals = u0 + [0 * bb, 0 * bb, bb] + mu, S, _ = condition(C, obs, vals, TARGETS) + mu = [float(v) for v in mu] + S = [[float(v) for v in row] for row in S] + # positivity of the (h1, h2, h3) block is needed by the quadrature + cholesky([[S[i][j] for j in (1, 2, 3)] for i in (1, 2, 3)]) + return logp, mu, S + + +def lambda_at(x1, z, b, k, rules, L=None): + """Returns dict: Lambda_j (j = 0, 1, 2), Lambda (sum), the unweighted remote density rho_j = + p * E[F_j | obs] (what the same point would carry without the pin weight), logp, coupling.""" + try: + logp, mu, S = _conditioning(x1, z, b, k, L, False) + exact = False + except ValueError: + logp, mu, S = _conditioning(x1, z, b, k, L, True) + exact = True + EXACT_COUNT[0] += 1 + p = math.exp(logp) + W = weighted_determinant_integrals(mu, S, rules) + mm = m2b(b) + lam = [p * W['G'][j] / mm for j in range(3)] + rho = [p * W['F'][j] for j in range(3)] + fsum = W['F'][0] + W['F'][1] + W['F'][2] + coupling = (W['G'][0] + W['G'][1] + W['G'][2]) / (mm * fsum) if fsum > 0 else None + return {'lambda_j': lam, 'lambda': sum(lam), 'rho_j': rho, 'rho': sum(rho), 'logp': logp, 'exact_regression': exact, + 'coupling': coupling} + + +def lambda_far(b, rules): + """Far-field value: p = phi(b)/(2 pi), H | (f = b, grad f = 0): h1, h3 ~ N(-b, 2) independent, + h2 ~ N(0, 1); A_0 independent of H. Lambda_inf,j = phi(b)/(2 pi) E[F_j(H)].""" + mu = [-b, -b, 0.0, -b] + S = [[2.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 2.0]] + W = weighted_determinant_integrals(mu, S, rules) + p = phi(b) / (2 * math.pi) + lam = [p * W['G'][j] / m2b(b) for j in range(3)] + return {'lambda_j': lam, 'lambda': sum(lam), 'rho_j': [p * W['F'][j] for j in range(3)], 'E_F_j': W['F']} + + +def unconditional_hessian_controls(rules): + """H unconditional: Var f_xx = Var f_zz = 3, Cov = 1, Var f_xz = 1. With h1 = a + c, h3 = a - c + (a ~ N(0, 2), c ~ N(0, 1) independent) det H = a^2 - (c^2 + h2^2) = a^2 - rho^2 with rho^2 ~ Exp(mean 2), + so E|det H| = 2 E[(rho^2 - a^2)_+] = 4 E exp(-a^2/2) = 4/sqrt3, E F_1 = 2/sqrt3, E F_0 = E F_2 = 1/sqrt3, + E det H = 0. Total critical density 2/(pi sqrt3), maxima 1/(2 pi sqrt3) (Longuet-Higgins).""" + mu = [0.0, 0.0, 0.0, 0.0] + S = [[2.0, 0.0, 0.0, 0.0], [0.0, 3.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 3.0]] + W = weighted_determinant_integrals(mu, S, rules) + return {'E_absdet': sum(W['F']), 'E_F_j': W['F'], 'E_det': W['D']} + + +def mc_absdet(n, seed=2026): + """Monte Carlo cross-check of E|det H| for the unconditional Hessian (fixed seed).""" + rng = random.Random(seed) + acc = acc2 = 0.0 + for _ in range(n): + g1, g2, g3 = rng.gauss(0, 1), rng.gauss(0, 1), rng.gauss(0, 1) + h1 = math.sqrt(2.0) * g1 + g3 # Var 3 + h3 = math.sqrt(2.0) * g2 + g3 # Var 3, Cov(h1, h3) = 1 + h2 = rng.gauss(0, 1) + v = abs(h1 * h3 - h2 * h2) + acc += v + acc2 += v * v + mean = acc / n + var = acc2 / n - mean * mean + return mean, math.sqrt(var / n) + + +# ----------------------------------------------------------------------------- grids +def hole_integral(b, k, rules, Rc=5.0, h=0.2, lam_inf=None): + """2 * sum over the midpoint grid on [-Rc, Rc] x (0, Rc] of (Lambda(x) - Lambda_inf) h^2, by index. + Continuum kernel.""" + n1 = int(round(2 * Rc / h)) + n2 = int(round(Rc / h)) + tot = [0.0, 0.0, 0.0] + tot_rho = [0.0, 0.0, 0.0] + minlam, maxlam = float('inf'), float('-inf') + for i in range(n1): + x1 = -Rc + (i + 0.5) * h + for j in range(n2): + z = (j + 0.5) * h + r = lambda_at(x1, z, b, k, rules) + for q in range(3): + tot[q] += r['lambda_j'][q] - lam_inf['lambda_j'][q] + tot_rho[q] += r['rho_j'][q] - lam_inf['rho_j'][q] + minlam = min(minlam, r['lambda']) + maxlam = max(maxlam, r['lambda']) + scale = 2.0 * h * h + return {'hole_j': [scale * t for t in tot], 'hole': scale * sum(tot), + 'hole_unweighted_j': [scale * t for t in tot_rho], 'hole_unweighted': scale * sum(tot_rho), + 'grid': {'Rc': Rc, 'h': h, 'points': n1 * n2, 'symmetry': 'z -> -z'}, + 'lambda_min_on_grid': minlam, 'lambda_max_on_grid': maxlam} + + +def torus_integral(b, k, rules, L, h=0.2): + """integral over the fundamental domain [-L/2, L/2]^2 of Lambda_L(x) dx (periodized kernel), by index.""" + n1 = int(round(L / h)) + n2 = int(round(L / (2 * h))) + tot = [0.0, 0.0, 0.0] + for i in range(n1): + x1 = -L / 2 + (i + 0.5) * h + for j in range(n2): + z = (j + 0.5) * h + r = lambda_at(x1, z, b, k, rules, L) + for q in range(3): + tot[q] += r['lambda_j'][q] + scale = 2.0 * h * h + return {'integral_j': [scale * t for t in tot], 'integral': scale * sum(tot), + 'grid': {'L': L, 'h': h, 'points': n1 * n2, 'symmetry': 'z -> -z'}} + + +# ----------------------------------------------------------------------------- controls +EXACT_COUNT = [0] +SAMPLE_POINTS = [(0.15, 0.15), (0.5, 0.3), (-0.7, 0.9), (1.0, 0.0), (0.0, 1.0), (2.0, 1.5), (-1.5, 0.5), (3.0, 3.0)] + + +def controls(rules): + out = {} + # (a) exact one-site Hermite table versus the floating kernel derivatives at 0 (continuum and L = 24, 12) + table = {} + maxdev = {'continuum': 0.0, 'L24': 0.0, 'L12': 0.0, 'L6': 0.0} + for a in SITE0: + for c in SITE0: + ex = exact_one_site_cov(a, c) + table['%d%d,%d%d' % (a + c)] = str(ex) + fl = cov_entry(a, c, 0.0, 0.0) + maxdev['continuum'] = max(maxdev['continuum'], abs(fl - float(ex))) + for L, key in ((24.0, 'L24'), (12.0, 'L12'), (6.0, 'L6')): + maxdev[key] = max(maxdev[key], abs(cov_entry(a, c, 0.0, 0.0, L) - float(ex))) + require(table['20,20'] == '3' and table['30,30'] == '15' and table['10,30'] == '-3' and table['00,20'] == '-1' + and table['20,02'] == '1' and table['11,11'] == '1' and table['00,00'] == '1', 'exact Hermite one-site table') + require(maxdev['continuum'] < 1e-12 and maxdev['L24'] < 1e-9 and maxdev['L12'] < 1e-9, 'lattice one-site covariances at L = 24, 12') + require(1e-4 < maxdev['L6'] < 2e-3, 'L = 6 one-site deviation is of the expected size') + out['one_site_exact'] = {'Var_fxx': table['20,20'], 'Var_fxxx': table['30,30'], 'Cov_fx_fxxx': table['10,30'], + 'Cov_f_fxx': table['00,20'], 'Cov_fxx_fzz': table['20,02'], 'Var_fxz': table['11,11']} + out['one_site_lattice_max_dev'] = maxdev + # (b) unconditional Hessian: E|det H| = sqrt3, E F_2 = sqrt3/4, E F_1 = sqrt3/2, E det = 0 + U = unconditional_hessian_controls(rules) + require(abs(U['E_absdet'] - 4 / math.sqrt(3)) < 1e-9, 'E|det H| = 4/sqrt(3) (exact: a^2 - rho^2 decomposition)') + require(abs(U['E_F_j'][2] - 1 / math.sqrt(3)) < 1e-9 and abs(U['E_F_j'][0] - 1 / math.sqrt(3)) < 1e-9 + and abs(U['E_F_j'][1] - 2 / math.sqrt(3)) < 1e-9, 'index split 1/sqrt3, 2/sqrt3, 1/sqrt3') + require(abs(U['E_det']) < 1e-12, 'E det H = 0 (Euler characteristic of the torus)') + out['unconditional_hessian'] = U + # (c) far field: E[w_0 | U_0] / z_0 = 1 and Lambda_inf = phi(b) E|det H_b| / (2 pi) + far = {} + for b in (0.0, 1.0): + r = lambda_far(b, rules) + far[str(b)] = r + rr = lambda_at(8.0, 0.0, b, 1.0, rules) + require(abs(rr['lambda'] - r['lambda']) < 1e-9 * r['lambda'], 'Lambda(8, 0) equals the far-field value, b = %r' % b) + require(abs(rr['coupling'] - 1.0) < 1e-9, 'pin weight decouples at |x| = 8') + out['far_field'] = far + # (d) z -> -z symmetry and a few sample values + sym = 0.0 + for (x1, z) in SAMPLE_POINTS[:4]: + r1 = lambda_at(x1, z, 0.0, 1.0, rules) + r2 = lambda_at(x1, -z, 0.0, 1.0, rules) + sym = max(sym, abs(r1['lambda'] - r2['lambda']) / r1['lambda']) + require(sym < 1e-10, 'reflection symmetry z -> -z') + out['reflection_symmetry_max_rel_dev'] = sym + # (e) k-dependence enters only through the f_xxx = 12k conditioning: at |x| = 8 Lambda is k-free + a1 = lambda_at(8.0, 0.0, 0.0, 0.5, rules)['lambda'] + a2 = lambda_at(8.0, 0.0, 0.0, 2.0, rules)['lambda'] + require(abs(a1 - a2) < 1e-9 * a1, 'far field is k-free') + return out + + +def sample_table(b, k, rules, L=None): + rows = [] + for (x1, z) in SAMPLE_POINTS: + r = lambda_at(x1, z, b, k, rules, L) + rows.append({'x': [x1, z], 'lambda': r['lambda'], 'lambda_j': r['lambda_j'], 'rho': r['rho'], 'coupling': r['coupling'], 'exact_regression': r['exact_regression']}) + return rows + + +def ray_profile(b, k, rules): + """Lambda(x)/Lambda_inf along rays from the pin at angles 90 (transverse), 60, 45, 30, 0 degrees.""" + far = lambda_far(b, rules)['lambda'] + rows = [] + for ang_deg in (90, 60, 45, 30, 0): + th = math.radians(ang_deg) + for rad in (0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0): + x1, z = rad * math.cos(th), rad * math.sin(th) + if ang_deg == 0: + z = 0.0 + r = lambda_at(x1, z, b, k, rules) + rows.append({'angle_deg': ang_deg, 'r': rad, 'ratio': r['lambda'] / far, 'ratio_unweighted': r['rho'] / far}) + return rows + + +def near_zero_profile(b, k, rules): + rows = [] + for rad in (0.05, 0.1, 0.2, 0.4): + for ang_deg in (0, 30, 60, 90, 120, 150, 180): + th = math.radians(ang_deg) + x1, z = rad * math.cos(th), rad * math.sin(th) + if ang_deg in (0, 180): + z = 0.0 + r = lambda_at(x1, z, b, k, rules) + rows.append({'r': rad, 'angle_deg': ang_deg, 'lambda': r['lambda'], 'lambda_j': r['lambda_j'], 'exact_regression': r['exact_regression']}) + return rows + + +# ----------------------------------------------------------------------------- main +def full_run(fast=False): + rules = Rules() + hi_rules = Rules(32, 48, 32) + res = {'object': 'CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1', 'scientific_effect': 'NONE', 'certified': False, + 'quadrature': {'coordinates': 'a = tr H / 2, (c, h2) polar; splits at a = 0 and rho = |a|', + 'a_gauss_legendre_per_side': 24, 'theta_trapezoid': 32, 'rho_gauss_legendre_per_side': 24, 'cut_sd': 9.0, + 'high_order_check': [32, 48, 32]}} + res['controls'] = controls(rules) + mc = mc_absdet(200000) + res['controls']['mc_absdet_unconditional'] = {'mean': mc[0], 'se': mc[1], 'n': 200000, 'seed': 2026} + # quadrature-order check at the sample points + qdev = 0.0 + for (x1, z) in SAMPLE_POINTS: + a = lambda_at(x1, z, 0.0, 1.0, rules)['lambda'] + c = lambda_at(x1, z, 0.0, 1.0, hi_rules)['lambda'] + qdev = max(qdev, abs(a - c) / c) + res['quadrature']['max_rel_dev_vs_high_order_at_samples'] = qdev + res['samples'] = {} + res['samples_L6'] = {} + res['near_zero_profile'] = {} + res['ray_profile'] = {} + res['far_field'] = {} + res['hole'] = {} + res['torus'] = {} + res['remote_total'] = {} + ks = (0.5, 1.0, 2.0) + bs = (0.0, 1.0) + grid_h = 0.4 if fast else 0.15 + for b in bs: + far = lambda_far(b, rules) + res['far_field'][str(b)] = {'lambda_inf': far['lambda'], 'lambda_inf_j': far['lambda_j'], 'E_F_j_given_level': far['E_F_j'], + 'p_inf': phi(b) / (2 * math.pi)} + for k in ks: + key = 'k=%s,b=%s' % (k, b) + res['samples'][key] = sample_table(b, k, rules) + res['samples_L6'][key] = sample_table(b, k, rules, 6.0) + res['near_zero_profile'][key] = near_zero_profile(b, k, rules) + res['ray_profile'][key] = ray_profile(b, k, rules) + H = hole_integral(b, k, rules, Rc=6.0, h=grid_h, lam_inf=far) + res['hole'][key] = H + T6 = torus_integral(b, k, rules, 6.0, h=grid_h) + res['torus'][key] = {'L=6': T6} + rt = {} + for L in (6.0, 12.0, 24.0): + approx = L * L * far['lambda'] + H['hole'] + rt['L=%g' % L] = {'integral_X_Lambda_approx': approx, 'k_integral': k * approx} + rt['L=6']['integral_X_Lambda_periodized_direct'] = T6['integral'] + rt['L=6']['k_integral_direct'] = k * T6['integral'] + res['remote_total'][key] = rt + print('done', key, 'hole', H['hole'], 'L6 direct', T6['integral'], 'approx', 36 * far['lambda'] + H['hole'], flush=True) + # grid-convergence, quadrature-order and tail checks for one parameter set; direct periodized L = 12 integral + far0 = lambda_far(0.0, rules) + far0_hi = lambda_far(0.0, hi_rules) + Hc = hole_integral(0.0, 1.0, rules, Rc=6.0, h=0.3, lam_inf=far0) + Hc_hi = hole_integral(0.0, 1.0, hi_rules, Rc=6.0, h=0.3, lam_inf=far0_hi) + Hf = hole_integral(0.0, 1.0, rules, Rc=6.0, h=0.1, lam_inf=far0) if not fast else Hc + Ht = hole_integral(0.0, 1.0, rules, Rc=5.0, h=0.3, lam_inf=far0) + T12 = torus_integral(0.0, 1.0, rules, 12.0, h=0.2) + res['grid_convergence'] = {'k=1.0,b=0.0': {'hole_h=0.3,Rc=6': Hc['hole'], 'hole_h=0.3,Rc=6,high_order': Hc_hi['hole'], + 'hole_h=0.3,Rc=5': Ht['hole'], 'hole_h=0.1,Rc=6': Hf['hole'], + 'hole_h=%s,Rc=6' % grid_h: res['hole']['k=1.0,b=0.0']['hole'], + 'hole_j_h=0.1,Rc=6': Hf['hole_j'], + 'torus_L=12_direct_h=0.2': T12['integral'], + 'torus_L=12_approx': 144 * far0['lambda'] + res['hole']['k=1.0,b=0.0']['hole'], + 'lambda_inf_high_order': far0_hi['lambda']}} + res['exact_regression_points'] = EXACT_COUNT[0] + return res + + +def check_run(): + rules = Rules() + ctl = controls(rules) + path = os.path.join(HERE, 'RESULTS.json') + require(os.path.exists(path), 'RESULTS.json present') + with open(path) as fh: + ref = json.load(fh) + for b in (0.0, 1.0): + far = lambda_far(b, rules) + require(abs(far['lambda'] - ref['far_field'][str(b)]['lambda_inf']) < 1e-10, 'far-field replay b = %r' % b) + for key, k in (('k=1.0,b=0.0', 1.0), ('k=0.5,b=1.0', 0.5)): + b = 0.0 if key.endswith('0.0') else 1.0 + rows = sample_table(b, k, rules) + for r, rr in zip(rows, ref['samples'][key]): + require(abs(r['lambda'] - rr['lambda']) <= 1e-9 * max(abs(rr['lambda']), 1e-6), 'sample replay %s at %r' % (key, r['x'])) + rows6 = sample_table(b, k, rules, 6.0) + for r, rr in zip(rows6, ref['samples_L6'][key]): + require(abs(r['lambda'] - rr['lambda']) <= 1e-9 * max(abs(rr['lambda']), 1e-6), 'L = 6 sample replay %s at %r' % (key, r['x'])) + # a near-axis point that needs the decimal regression + r = lambda_at(0.1, 0.0, 0.0, 1.0, rules) + require(r['exact_regression'] and r['lambda'] < 1e-20, 'near-axis point handled by the decimal regression and exponentially small') + for row in ref['near_zero_profile']['k=1.0,b=0.0']: + if row['r'] == 0.1 and row['angle_deg'] == 0: + require(abs(row['lambda'] - r['lambda']) <= 1e-9 * max(abs(r['lambda']), 1e-30), 'near-zero replay') + print(json.dumps({'check': 'ok', 'controls': list(ctl.keys()), 'mutant': MUT})) + + +def main(): + global MUT + ap = argparse.ArgumentParser() + ap.add_argument('--check', action='store_true') + ap.add_argument('--fast', action='store_true', help='coarser grid (development only)') + ap.add_argument('--mutant', choices=MUTANTS) + args = ap.parse_args() + MUT = args.mutant + if args.check: + check_run() + return + res = full_run(fast=args.fast) + with open(os.path.join(HERE, 'RESULTS.json'), 'w') as fh: + json.dump(res, fh, indent=1, sort_keys=True) + fh.write('\n') + print('wrote RESULTS.json') + + +if __name__ == '__main__': + main() From 56a7904f9ad7d409c31e23195c0e7eeab230613a Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 20:55:56 -0500 Subject: [PATCH 03/13] Add unit-square companion law and the small-ratio cubic height limit Separate conditional addendum preserves the original PROOF, exact checker/results/source pins and verification policy. Positive explicit square density yields the companion-ratio CDF coefficient137647104/3972529, boundary height law, ideal-real rejection normalization and an ordinary-float sampler. Adopt the author-exposed peer's finite-physical-radius counterexample with credit and exact regression. 82 tests pass in each Python mode; original semantic mutants remain rejected; all15 remote packet blobs and tree match local computation. Separate Slice D analytic review and fresh hosted current-head checks required. No self-acceptance, self-merge or global status change. --- .../COMPANION_RATIO.md | 236 ++++++++++++++++++ .../MANIFEST.json | 36 ++- .../extreme_cluster_sampling_20260930/PLAN.md | 14 +- .../README.md | 33 +++ .../VALIDATION.md | 36 +++ .../ratio_law.py | 106 ++++++++ .../test_ratio_law.py | 124 +++++++++ 7 files changed, 574 insertions(+), 11 deletions(-) create mode 100644 frontiers/extreme_cluster_sampling_20260930/COMPANION_RATIO.md create mode 100644 frontiers/extreme_cluster_sampling_20260930/ratio_law.py create mode 100644 frontiers/extreme_cluster_sampling_20260930/test_ratio_law.py diff --git a/frontiers/extreme_cluster_sampling_20260930/COMPANION_RATIO.md b/frontiers/extreme_cluster_sampling_20260930/COMPANION_RATIO.md new file mode 100644 index 000000000..56348f676 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/COMPANION_RATIO.md @@ -0,0 +1,236 @@ +# Addendum: an explicit unit-square law for the whole extreme doublet + +Object: OA-EXTREME-CLUSTER-SAMPLING-20260930-D1. +Author: OpenAI / GPT-6 Astra Pro. New conditional derivation; nonauthor review OPEN. +Scientific effect NONE. PROOF.md remains byte-identical. This addendum consumes +that manuscript's E12-E19/E29 as candidate inputs; their review is not inferred +from finite tests. It introduces no additional Gaussian source assumption. + +## 1. The law and its exact domain + +Consider the limiting ordinary extreme cluster of PROOF Theorem2, conditioned +on being a doublet. Its outer-root shape has density Q/J on S2_outer, with +J=1083417/280. Write p=-u, A=12p^2-3 and ell=v/A. Define + + rho=|Z_companion/Z_outer| in (0,1), + w=2ell, + z=(1+rho)(w-1)/(2rho). (D1) + +The map is a smooth bijection, up to the boundary null sets already stated in +PROOF, between S2_outer and the OPEN UNIT SQUARE 0p_c, equivalent to w>1 for 01,00 directly, +and eta_in(u,v)=(-p,A ell) has absolute Jacobian A. At fixed w, + + |partial p/partial rho|/2=(w^2-1)/(8rho^2 w). + +Together with Q=A^3(4ell^2-1)(4p ell-1), the density in (rho,w) is + + 81(1+rho)(w-1)^7(w+1)^7 + *(rho*w-rho+w+1)^4(rho*w+rho+w-1)^4 + /(4096rho^11 w^9). (D6) + +Insert w=1+2rho*z/(1+rho) and its Jacobian2rho/(1+rho) to obtain D2. These +identities can be checked by direct substitution; test_ratio_law.py also uses +independent exact two-variable differentiation of the inverse map to check +L=Q|det d(u,v)/d(rho,z)| on72 rational interior cases. Integration of D2 is J +because this is a bijective change of variables from the source outer sector, +not because of numerical normalization. + +## 3. A new small-companion asymptotic + +Let f_rho be the marginal density of rho under the doublet law. Set + + H0=integral_0^1 z^7(z+1)^4 dz=6401/3960, + Csmall=82944 H0/J=137647104/3972529. (D7) + +The rational factor multiplying165888 rho z^7(z+1)^4 in D2 tends uniformly +to1 as rho->0. Its denominator is bounded away from zero on the closed square. +Therefore + + f_rho(rho) ~ (275294208/3972529) rho, + P(rho0, then the microscopic extreme threshold->infinity, then epsilon->0. +It is not a uniform triple-scale assertion for the original field. + +More precisely, conditional on rho Zsmall^2, + eta_in/rho^3 -> 2 Zsmall^2(Zsmall+1). (D10) + +Equivalently eta_in/epsilon^3 has limit2 Qsmall^3 Zsmall^2(Zsmall+1). The small +companion thus approaches the upper height boundary with a CUBIC radius-ratio +scale while the outer height remains nonzero. This describes normalized height +marks, not an elder-pairing or actual finite-r persistence-lifetime theorem. + +The limiting outer-height density in D10 is particularly simple: + + e^3(1+sqrt(e))^4/(2H0), 01-, continuity of D2 and integration on the bounded +z interval give + + f_rho(1-)=857223/2889112-(945/361139)log2. (D12) + +For verification L(1,z)=81 z^7(z+2)^7/[8(z+1)]. Put x=z+1 and expand +(x^2-1)^7/x on[1,2]: its integral is2571669/2240-(81/8)log2. Dividing by J +gives D12. The equal-radius boundary itself still has probability zero. + +## 4. A rejection sampler with a certified ideal-real acceptance rate + +Define + + a(rho,z)=(rho*z+1)^4(rho*z+rho+1)^7 + /[(rho+1)^5(2rho*z+rho+1)^9]. (D13) + +It satisfies00, then extreme radius->infinity, THEN epsilon->0. No uniform triple-scale +statement about the original field is made. + +An ideal-real rejection algorithm has exact acceptance probability +3972529/137647104. `ratio_law.sample_doublet` implements its scalar shape/height +part with ordinary floating-point pseudorandom numbers and a bounded trial budget: + + import random + from ratio_law import sample_doublet + marks = sample_doublet(random.Random(20260930)) + +It does not simulate the Gaussian orientation/amplitude or a finite-r field, +and its rounding error is not interval-enclosed. Sixteen added test methods +bring the suite to82 per Python mode. An exact counterexample credited to the +supporting recovery lane pins the distinction between finite-scale physical +radius ordering and the |Z| ordering valid in the second limit. + +This addendum is a SEPARATE Slice D review obligation. It leaves PROOF.md, +extremes.py, the original RESULTS and all source identities unchanged. An +acceptance of A/B/C is not automatically an acceptance of the new addendum. diff --git a/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md b/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md index 381f28bfa..f9220a2e0 100644 --- a/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md +++ b/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md @@ -88,3 +88,39 @@ prove the source Gaussian assumptions, changes of variables with multiplicity, physical-anchor domination or weak convergence. Those new arguments require source-bound nonauthor analytic review. Existing Lean package success is not a Lean formalization of this manuscript. No self-merge or scientific-register fold. + +## Separate unit-square companion addendum — successor evidence + +Original PROOF.md, extremes.py, test_extremes.py, RESULTS.json, SOURCES.json, +verify.py and test_verify.py remain byte-identical to published head7ab0d31. +The new files are COMPANION_RATIO.md, ratio_law.py and test_ratio_law.py. + +Test-first record: the initial ratio scaffold ran12 methods and produced15 +expected assertion failures, including subtests. The sampler scaffold extension +ran15 methods and produced20 assertion failures plus one KeyError because its +stub returned an empty mapping. The implemented15 methods then passed. One more +exact physical-order counterexample from peer support5902401772 was independently +recomputed and added as a regression; it does not confer independent acceptance. + +Fresh normal and optimized replay, both with the hosted replacement-disabling +environment, now each run82 tests and PASS. The16 new methods include72 independent +exact Jacobian comparisons,25 rational companion/height substitutions, explicit +positive height-difference/top-boundary factors, exact endpoint and small-ratio +constants, ideal proposal-density factorization/envelope, reproducible float +sampler/range tests and rejection-budget checks. The original semantic mutants +and deterministic RESULTS identity remain required by verify.py. + +A seeded FLOATING-POINT diagnostic (seed20260930,20000 accepted doublets) observed +mean proposal count35.0511 and mean rho^11=0.030448088971641796. Every sampled height +pair and radius ratio satisfied the strict ranges. The exact theoretical values +are137647104/3972529 for mean proposals and D/J for the eleventh moment. This is +an illustrative Monte Carlo sanity check, not a proof, interval guarantee, or +assertion of exact finite-sample agreement. The exact ideal-real acceptance and +moment identities are established analytically, independently of this diagnostic. + +Initial published-head hosted evidence was directly read: target36655624974 / +job109699228659 SUCCESS; full36655625213 with downstream109699229856, +formal109699230080 and required aggregate109699995661 all SUCCESS. These are +7ab0d31 results ONLY. An addendum successor must obtain its own actual hosted +source authentication and current-base full checks; these predecessor runs do +not substitute for them. No new analytic review is claimed by this record. diff --git a/frontiers/extreme_cluster_sampling_20260930/ratio_law.py b/frontiers/extreme_cluster_sampling_20260930/ratio_law.py new file mode 100644 index 000000000..49404bf07 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/ratio_law.py @@ -0,0 +1,106 @@ +"""Universal extreme-doublet shape: exact rational controls and a float simulator. + +The density is for the already-formed limiting microscopic extreme doublet, +not finite-r field samples. sample_doublet uses ordinary floating-point random +numbers for experimentation; it is not an exact-real or interval sampler. +""" +from fractions import Fraction as F +from math import comb, sqrt +import random +import extremes as e + + +def _unit(x): + if isinstance(x,bool) or not isinstance(x,(int,F)): + raise TypeError('integer or Fraction required') + x=F(x) + if not 0<=x<=1: raise ValueError('unit interval required') + return x + + +def coordinates(rho,z): + """Continuous square extension of the outer root's (u,v); interior is typed.""" + rho,z=_unit(rho),_unit(z) + den=2*rho*z+rho+1 + p=(2*rho*z*z+2*rho*z+rho+2*z+1)/(2*den) + ell=(1+2*rho*z/(1+rho))/2 + return -p,(12*p*p-3)*ell + + +def acceptance(rho,z): + rho,z=_unit(rho),_unit(z) + return ((rho*z+1)**4*(rho*z+rho+1)**7 / + ((rho+1)**5*(2*rho*z+rho+1)**9)) + + +def density(rho,z): + """Unnormalized positive density Q(u,v)|d(u,v)/d(rho,z)|; integral is J.""" + rho,z=_unit(rho),_unit(z) + return 165888*rho*z**7*(z+1)**4*acceptance(rho,z) + + +def heights(rho,z): + """Downward heights of outer and companion roots, respectively.""" + rho,z=_unit(rho),_unit(z) + den=(rho+1)*(2*rho*z+rho+1) + outer=z*z*(rho*z+1)*(rho*z+2*rho+1)/den + inner=rho**3*z*z*(z+1)*(rho*z+rho+2)/den + return outer,inner + + +def z_normalizer(): + return sum((F(comb(4,j),8+j) for j in range(5)),F(0)) + + +def small_ratio_constant(): + """CDF coefficient P(rho=a:continue + den=(rho+1)*(2*rho*z+rho+1) + return {'radius_ratio':rho,'shape_coordinate':z, + 'height_maximum':z*z*(rho*z+1)*(rho*z+2*rho+1)/den, + 'height_companion':rho**3*z*z*(z+1)*(rho*z+rho+2)/den, + 'proposals':trial} + raise RuntimeError('extreme-doublet rejection sampler exhausted its trial budget') diff --git a/frontiers/extreme_cluster_sampling_20260930/test_ratio_law.py b/frontiers/extreme_cluster_sampling_20260930/test_ratio_law.py new file mode 100644 index 000000000..56346fa40 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/test_ratio_law.py @@ -0,0 +1,124 @@ +"""Exact unit-square controls; no Gaussian limit or exact sampling is asserted by tests.""" +from fractions import Fraction as F +from math import comb +import unittest +import random +import extremes as e +import ratio_law as r +from test_extremes import Dual + +class RatioTests(unittest.TestCase): + def test_coordinate_companion_ratio(self): + for rho in (F(1,1000),F(1,4),F(1,2),F(3,4),F(999,1000)): + for z in (F(1,9),F(1,4),F(1,2),F(3,4),F(8,9)): + u,v=r.coordinates(rho,z) + self.assertTrue(e.outer_double(u,v)) + uc,vc,t=e.companion(u,v) + self.assertEqual(t,-rho) + self.assertEqual((e.height(u,v),e.height(uc,vc)),r.heights(rho,z)) + def test_jacobian_against_independent_dual_calculation(self): + count=0 + for i in range(1,9): + for j in range(1,10): + rho,z=Dual(F(i,9),1,0),Dual(F(j,10),0,1) + p=(2*rho*z*z+2*rho*z+rho+2*z+1)/(2*(2*rho*z+rho+1)) + ell=(1+2*rho*z/(1+rho))/2 + u=-p;v=(12*p*p-3)*ell + jac=u.du*v.dv-u.dv*v.du + actual=e.shape_weight(u.x,v.x)*abs(jac) + self.assertEqual(r.density(rho.x,z.x),actual) + self.assertGreater(actual,0) + count+=1 + self.assertEqual(count,72) + def test_small_ratio_integral(self): + h=sum((F(comb(4,j),8+j) for j in range(5)),F(0)) + self.assertEqual(r.z_normalizer(),h) + self.assertEqual(h,F(6401,3960)) + self.assertEqual(r.small_ratio_constant(),F(137647104,3972529)) + def test_sampler_acceptance_bounds_and_factorization(self): + for i in range(1,10): + for j in range(1,10): + rho,z=F(i,10),F(j,10) + a=r.acceptance(rho,z) + self.assertTrue(0 Date: Wed, 30 Sep 2026 02:28:27 +0000 Subject: [PATCH 04/13] Remote coefficient numerics: RESULTS.json, NOTE.md, manifest; closed-form far-field controls Full run (about 36 minutes): far field, correlation-hole constants for k in {1/2, 1, 2}, b in {0, 1}, direct periodized integrals at L = 6 and 12, grid and quadrature convergence checks; k integral_X Lambda and the assembled nu(1) tabulated. --check adds the exact far-field closed forms Lambda_inf(b) = phi(b) (b^2 - 1 + 2 sqrt2 e^(-b^2/4)) / (2 pi). Scientific effect NONE; not certified. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../{NOTE_template.md => NOTE.md} | 111 +- .../RESULTS.json | 5430 +++++++++++++++++ .../SOURCE_FILES.json | 39 + .../remote.py | 22 + 4 files changed, 5572 insertions(+), 30 deletions(-) rename frontiers/c6_remote_coefficient_numerics_20260930/{NOTE_template.md => NOTE.md} (54%) create mode 100644 frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json create mode 100644 frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md similarity index 54% rename from frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md rename to frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index 03171e09c..c834258ff 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE_template.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -46,14 +46,23 @@ it is wrong exactly because of the Euler identity.) The computed values confirm the ordinary height-resolved density of index-`j` critical points at level `b`, per unit height and area. It is `k`-free; the `k`-dependence of `Lambda(x)` enters only through the conditioning on `f_xxx(0) = 12k` and dies with -the correlations. +the correlations. It is also closed-form: with `h_1 = a + c`, `h_3 = a - c` (`a ~ N(-b, 1)`, `c ~ N(0, 1)`, `h_2 ~ +N(0, 1)` independent) `det H = a^2 - rho^2`, `rho^2 ~ Exp(mean 2)`, and + + E F_1 = sqrt2 e^(-b^2/4), + E F_2 = (b^2+1) Phi(b) + b phi(b) - 2 Phi(b) + sqrt2 e^(-b^2/4) Phi(b/sqrt2), E F_0 = E F_2 |_(b -> -b), + E|det H_b| = b^2 - 1 + 2 sqrt2 e^(-b^2/4), Lambda_inf(b) = phi(b) E|det H_b| / (2 pi), + +so `Lambda_inf(0) = (2 sqrt2 - 1)/(2 pi)^(3/2) = 0.1160934862...`, and `integral Lambda_inf(b) db = 2/(pi sqrt3)`, the +total critical-point density. The quadrature reproduces these closed forms to `9e-13` (absolute), a +second exact end-to-end control of the Hessian integrator with a non-centered mean. **Exact control of the Hessian integrator.** For the unconditional planar Hessian (`Var h_1 = Var h_3 = 3`, `Cov(h_1, h_3) = 1`, `Var h_2 = 1`) write `h_1 = a + c`, `h_3 = a - c` with `a ~ N(0, 2)`, `c ~ N(0, 1)` independent; then `det H = a^2 - (c^2 + h_2^2) = a^2 - rho^2` with `rho^2 ~ Exp(mean 2)`, so `E|det H| = 2 E[(rho^2 - a^2)_+] = 4 E exp(-a^2/2) = 4/sqrt3`, `E F_1 = 2/sqrt3`, `E F_0 = E F_2 = 1/sqrt3`, `E det H = 0`. (Total critical-point density `2/(pi sqrt3) = 0.3676`, maxima `1/(2 pi sqrt3) = 0.0919`: the -Longuet-Higgins values for this spectrum.) The integrator reproduces these to `{{absdet_err}}` (absolute). +Longuet-Higgins values for this spectrum.) The integrator reproduces these to `9.7e-11` (absolute). **Coordinates adapted to the cone `det H = 0`.** The integrals `E[A_0^2 1{A_0 < 0} |det H| 1{index j}]` over the conditional Gaussian law of `(A_0, H_x)` are computed with `A_0` integrated out in closed form @@ -64,11 +73,11 @@ from `rho < |a|` (definite; sign of `a` separates minimum and maximum) or `rho > split at `0`, the `rho`-range at `|a|`, the `theta` nodes are those of the periodic trapezoid rule under an analytic map concentrating them at the angular position of the (generally offset and anisotropic) conditional mean; every piece of the integrand is smooth, and the nested rule converges geometrically on the exact control -(`{{absdet_err_hi}}` at the higher order). +(`1.8e-14 relative on Lambda_inf(0) between orders` at the higher order). **Ill-conditioned points.** Near the pin axis the conditional law of `Y_x` given `U_0` has variances down to `|x|^6`, and the double-precision regression can lose positivity where `Lambda` is already below `10^(-20)`. Such -points (`{{exact_count}}` in the whole run) are recomputed in 50-digit decimal arithmetic; none carries weight. +points (`24` in the whole run) are recomputed in 50-digit decimal arithmetic; none carries weight. ## 3. Method @@ -76,8 +85,10 @@ points (`{{exact_count}}` in the whole run) are recomputed in 50-digit decimal a the midpoint rule: - continuum kernel, hole constant `c_hole,j = integral_(R^2) (Lambda_j - Lambda_inf,j) dx` on `[-6, 6]^2` - (`h = 0.15`; the neglected exterior has `|Lambda - Lambda_inf| < 10^(-6) Lambda_inf`, correlations at distance 6 - being of size `K(6) = e^(-18)`); + (`h = 0.15`). The sixth-order jet correlations decay only like `He_6(|x|) e^(-|x|^2/2)` (`0.32` at distance 4, + `4.4e-4` at 6), so the cutoff is checked directly: `Lambda/Lambda_inf - 1` is `3.6e-5` (axis), `3.1e-6` (45 deg), + `4.4e-7` (transverse) at `|x| = 5`, and `4.8e-9`, `4.4e-10`, `3.8e-11` at `|x| = 6`; the neglected exterior + contributes less than `10^(-7)` to `c_hole`; - periodized kernel at `L = 6`, direct integral over the fundamental domain `[-3, 3]^2` (`h = 0.15`); - periodized kernel at `L = 12`, direct integral (`h = 0.2`), compared with `L^2 Lambda_inf + c_hole`. @@ -90,51 +101,91 @@ Then `integral_X Lambda ~ L^2 Lambda_inf + c_hole` for `L = 12, 24` (the periodi | `b` | `Lambda_inf` | minima `j = 0` | saddles `j = 1` | maxima `j = 2` | `p_inf = phi(b)/(2 pi)` | |---|---|---|---|---|---| -{{far_rows}} +| `0.0` | 0.116093 | 0.01315 | 0.0897936 | 0.01315 | 0.0634936 | +| `1.0` | 0.0848309 | 0.000850618 | 0.0424155 | 0.0415649 | 0.0385108 | -(At `b = 0`: `E|det H_0| = {{EdetH0}}` with `h_1, h_3 ~ N(0, 2)`, `h_2 ~ N(0, 1)`.) +(At `b = 0`: `E|det H_0| = 1.82843` with `h_1, h_3 ~ N(0, 2)`, `h_2 ~ N(0, 1)`.) **Correlation hole** `c_hole = integral_(R^2) (Lambda - Lambda_inf) dx` (dimension of an area times a density per height; negative means depletion): | `k` | `b` | `c_hole` | `j = 0` | `j = 1` | `j = 2` | `c_hole / Lambda_inf` (effective depleted area) | |---|---|---|---|---|---|---| -{{hole_rows}} +| `0.5` | `0.0` | -1.08414 | -0.302824 | -0.88442 | 0.103108 | -9.338 | +| `1.0` | `0.0` | -1.63115 | -0.313786 | -1.3325 | 0.0151367 | -14.05 | +| `2.0` | `0.0` | -2.1382 | -0.330282 | -1.75684 | -0.0510768 | -18.42 | +| `0.5` | `1.0` | -0.750629 | -0.00830817 | -0.260797 | -0.481524 | -8.849 | +| `1.0` | `1.0` | -1.18448 | -0.0055866 | -0.464948 | -0.713947 | -13.96 | +| `2.0` | `1.0` | -1.56814 | -0.00268732 | -0.636506 | -0.928945 | -18.49 | The pinned pair depletes its neighbourhood: along the pin axis the contact field is `b + 2k x_1^3 + ...` to leading order, a monotone ramp, so window-level critical points near the pins live in the transverse sector only -(`Lambda(x)/Lambda_inf` is below `10^(-10)` on the axis out to `|x_1| ~ 1.5` and recovers to `1` at `|x| ~ 3`; -the ray profiles at angles `0, 30, 45, 60, 90` degrees are in `RESULTS.json`, `ray_profile`). Near the pin -`Lambda -> 0` (`near_zero_profile`: `Lambda(0.05, 45 deg) = {{near05}}`, `Lambda(0.4, 90 deg) = {{near04}}` at -`k = 1, b = 0`). Almost the whole `k`-dependence of the hole comes from the transverse sector where the -`f_xxx = 12k` conditioning is felt. +(`Lambda(x)/Lambda_inf` at `k = 1, b = 0`: on the axis `2e-22` at `|x_1| = 1.5`, `1.6e-6` at `2`, `0.037` at +`2.5`, `0.68` at `3`, `1.02` at `4`; transversally `0.21` at `|z| = 1`, `0.68` at `2`, `1.00` at `3`; the ray +profiles at angles `0, 30, 45, 60, 90` degrees are in `RESULTS.json`, `ray_profile`). Near the pin `Lambda -> 0` +(`near_zero_profile`: `Lambda(0.05, 60 deg) = 0.001`, `Lambda(0.4, 90 deg) = 0.0079` at `k = 1, b = 0`; on the +axis and at `30` degrees it is below `10^(-20)`). **Remote singleton mass** `R(k, b, L) = k integral_X Lambda dx` and the assembled `nu(1)`, with `alpha_1` from the companion note (Math-#168, GH60 values; `alpha_2` likewise): | `k` | `b` | `L` | `integral_X Lambda` | `R = k integral_X Lambda` | `alpha_1` (#168) | `nu(1) = alpha_1 + R` | `nu(2) = alpha_2` | `nu(2)/nu(1)` | |---|---|---|---|---|---|---|---|---| -{{total_rows}} +| `0.5` | `0.0` | `6` (direct) | 3.05738 | 1.52869 | 1.11821 | 2.6469 | 0.0347454 | 0.0131 | +| `0.5` | `0.0` | `12` | 15.6333 | 7.81666 | 1.11821 | 8.93487 | 0.0347454 | 0.00389 | +| `0.5` | `0.0` | `24` | 65.7857 | 32.8929 | 1.11821 | 34.0111 | 0.0347454 | 0.00102 | +| `1.0` | `0.0` | `6` (direct) | 2.54211 | 2.54211 | 1.32906 | 3.87117 | 0.0255091 | 0.00659 | +| `1.0` | `0.0` | `12` | 15.0863 | 15.0863 | 1.32906 | 16.4154 | 0.0255091 | 0.00155 | +| `1.0` | `0.0` | `24` | 65.2387 | 65.2387 | 1.32906 | 66.5678 | 0.0255091 | 0.000383 | +| `2.0` | `0.0` | `6` (direct) | 2.17976 | 4.35953 | 2.1621 | 6.52163 | 0.0169281 | 0.0026 | +| `2.0` | `0.0` | `12` | 14.5793 | 29.1585 | 2.1621 | 31.3206 | 0.0169281 | 0.00054 | +| `2.0` | `0.0` | `24` | 64.7316 | 129.463 | 2.1621 | 131.625 | 0.0169281 | 0.000129 | +| `0.5` | `1.0` | `6` (direct) | 2.237 | 1.1185 | 0.320155 | 1.43866 | 0.00994791 | 0.00691 | +| `0.5` | `1.0` | `12` | 11.465 | 5.73251 | 0.320155 | 6.05267 | 0.00994791 | 0.00164 | +| `0.5` | `1.0` | `24` | 48.112 | 24.056 | 0.320155 | 24.3762 | 0.00994791 | 0.000408 | +| `1.0` | `1.0` | `6` (direct) | 1.81212 | 1.81212 | 0.380523 | 2.19264 | 0.00730347 | 0.00333 | +| `1.0` | `1.0` | `12` | 11.0312 | 11.0312 | 0.380523 | 11.4117 | 0.00730347 | 0.00064 | +| `1.0` | `1.0` | `24` | 47.6781 | 47.6781 | 0.380523 | 48.0587 | 0.00730347 | 0.000152 | +| `2.0` | `1.0` | `6` (direct) | 1.5302 | 3.0604 | 0.619027 | 3.67943 | 0.00484668 | 0.00132 | +| `2.0` | `1.0` | `12` | 10.6475 | 21.295 | 0.619027 | 21.9141 | 0.00484668 | 0.000221 | +| `2.0` | `1.0` | `24` | 47.2945 | 94.589 | 0.619027 | 95.208 | 0.00484668 | 5.09e-05 | For `L = 6` the direct periodized integral and the approximation `36 Lambda_inf + c_hole` are both given -(`RESULTS.json`, `remote_total`); they differ by `{{L6_dev}}` relative (the periodization changes the one-site -covariances by up to `8.8e-4` at `L = 6`). For `L = 12` the direct integral at `k = 1, b = 0` is -`{{L12_direct}}` against `{{L12_approx}}` from the far field plus hole. - -**Reading.** For the parent torus sizes the remote singletons dominate `nu(1)` by two orders of magnitude at -`L = 24` (`R ~ L^2 Lambda_inf`), so the two-point cluster probability relative to a nonempty window is -`nu(2)/(nu(1) + nu(2)) ~ {{share24}}` at `k = 1, b = 0, L = 24`, against the near-only share `0.019` reported in +(`RESULTS.json`, `remote_total`); they differ by between `2.4e-3` and `6.4e-2` relative, most at `k = 2`. At +`L = 6` the depleted region (radius about `3`) fills the fundamental domain, so the depletions around the image +pins overlap and the additive approximation `L^2 Lambda_inf + c_hole` is not valid; the table uses the direct +periodized integral for `L = 6`. (The periodization also changes the one-site covariances by up to `8.8e-4` at +`L = 6`; that is included in the direct value.) For `L = 12` the direct integral at `k = 1, b = 0` is `15.0866` +against `15.0863` from the far field plus hole, so the additive form is accurate to `2e-5` there and better at +`L = 24`. + +**Reading.** For the parent torus sizes the remote singletons dominate `nu(1)` (`R ~ L^2 Lambda_inf`: by a factor +`50` at `L = 24`, `k = 1, b = 0`), so the two-point cluster probability relative to a nonempty window is +`nu(2)/(nu(1) + nu(2)) ~ 3.83e-04` at `k = 1, b = 0, L = 24`, against the near-only share `0.019` reported in #168. The near share is the right object for the cluster geometry; the global share is the right object for the -finite-torus count. +finite-torus count. The pins do not only deplete: along the `45`-`60` degree rays `Lambda/Lambda_inf` overshoots to +`1.24`-`1.48` at `|x| = 2`-`2.5` (`k = 1, b = 0`) before settling, so the displaced critical points pile up in a +ring; the net hole is nevertheless negative for every `(k, b)` computed, and grows with `k` (steeper ramp +`2k x_1^3`, stronger `f_xxx` conditioning) and shrinks with `b`. ## 5. Precision (empirical, not bounds) -- Quadrature: at the eight sample points the default orders `(24, 32, 24)` differ from `(32, 48, 32)` by at most - `{{qdev}}` relative; on the exact unconditional control the default order is accurate to `{{absdet_err}}`. -- Grid: at `k = 1, b = 0` the hole constant is `{{hole_h03}}` (`h = 0.3`), `{{hole_h015}}` (`h = 0.15`), - `{{hole_h01}}` (`h = 0.1`); with the higher quadrature order at `h = 0.3`: `{{hole_h03_hi}}`. Cutting the domain at - `|x_i| <= 5` instead of `6` changes it by `{{tail_dev}}`. -- The periodized `L = 12` direct integral agrees with far field plus hole to `{{L12_rel}}` relative. +- Quadrature: at the sample points the default orders `(24, 32, 24)` differ from `(32, 48, 32)` by at most `3e-9` + relative wherever `Lambda > 10^(-2) Lambda_inf`, by `5e-4` at `(0.15, 0.15)` where `Lambda = 2e-5 Lambda_inf`, and + by up to `4.0e-01` at points where `Lambda < 10^(-16) Lambda_inf` (the recorded maximum, carried entirely by such + points: the conditional law of `H_x` is extremely anisotropic there and the value is exponentially small anyway). + On the exact controls the default order is accurate to `9.7e-11` (unconditional Hessian) and + `9e-13` (far field, both `b`). The `h = 0.3` hole constant changes by `4e-08` between the + two orders. +- Grid: at `k = 1, b = 0` the hole constant is `-1.629661` (`h = 0.3`), `-1.631148` (`h = 0.15`), + `-1.631335` (`h = 0.1`): the midpoint rule converges at an observed order of about `2.7` (`Lambda` has a + conical, direction-dependent limit at the pin), the `h = 0.15` values are within `2e-4` of the `h = 0.1` values, + and a power-law extrapolation puts the remaining error of the tabulated (`h = 0.15`) hole constants near + `1e-4` absolute (`1e-4` relative). The `h = 0.3` run on `[-5, 5]^2` differs by `2.1e-03`, which is grid + placement, not tail (see the direct tail check in section 3). +- The periodized `L = 12` direct integral (`h = 0.2`) agrees with far field plus hole to `2.0e-05` relative. +- The Monte Carlo cross-check of the unconditional control (`2 . 10^5` samples, seed 2026) gives + `E|det H| = 2.3032 +- 0.0058`, `4/sqrt3 = 2.3094` lying at `1.1` standard errors. These are observed discrepancies. No error bound is claimed. @@ -151,5 +202,5 @@ organizational-independence credit. The author will not merge. `remote.py` (standard library; `--check` replays the exact controls, the far field, sixteen sample kernels at two parameter pairs for the continuum and the `L = 6` kernel, one decimal-regression point and the near-zero profile against `RESULTS.json`; three mutants `hermite-sign`, `det-abs`, `weight-indicator` must exit 1), `RESULTS.json` -(full run, about {{minutes}} minutes), `SOURCE_MAP.json` (pins [LP], [RM], [CL], [RC] on `main` +(full run, about 36 minutes), `SOURCE_MAP.json` (pins [LP], [RM], [CL], [RC] on `main` `7d0c89a`), `SOURCE_FILES.json`, workflow `c6-remote-coefficient-numerics.yml`. diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json b/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json new file mode 100644 index 000000000..04f5b9fc4 --- /dev/null +++ b/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json @@ -0,0 +1,5430 @@ +{ + "certified": false, + "controls": { + "far_field": { + "0.0": { + "E_F_j": [ + 0.2071067811866195, + 1.4142135623732415, + 0.20710678118661952 + ], + "lambda": 0.11609348619094405, + "lambda_j": [ + 0.013149962564175739, + 0.08979356106259258, + 0.01314996256417574 + ], + "rho_j": [ + 0.013149962564175728, + 0.08979356106259259, + 0.01314996256417573 + ] + }, + "1.0": { + "E_F_j": [ + 0.022087746264714315, + 1.1013906298184966, + 1.079302883553834 + ], + "lambda": 0.08483094979588068, + "lambda_j": [ + 0.0008506175936846622, + 0.042415474897939356, + 0.04156485730425666 + ], + "rho_j": [ + 0.0008506175936846623, + 0.04241547489793938, + 0.04156485730425671 + ] + } + }, + "mc_absdet_unconditional": { + "mean": 2.3031855264703522, + "n": 200000, + "se": 0.005762874124208739, + "seed": 2026 + }, + "one_site_exact": { + "Cov_f_fxx": "-1", + "Cov_fx_fxxx": "-3", + "Cov_fxx_fzz": "1", + "Var_fxx": "3", + "Var_fxxx": "15", + "Var_fxz": "1" + }, + "one_site_lattice_max_dev": { + "L12": 7.003755912451762e-58, + "L24": 5.551522854989634e-244, + "L6": 0.0008783433650769723, + "continuum": 0.0 + }, + "reflection_symmetry_max_rel_dev": 8.38164154450512e-16, + "unconditional_hessian": { + "E_F_j": [ + 0.5773502692137803, + 1.1547005384275606, + 0.5773502692137802 + ], + "E_absdet": 2.309401076855121, + "E_det": 0.0 + } + }, + "exact_regression_points": 24, + "far_field": { + "0.0": { + "E_F_j_given_level": [ + 0.2071067811866195, + 1.4142135623732415, + 0.20710678118661952 + ], + "lambda_inf": 0.11609348619094405, + "lambda_inf_j": [ + 0.013149962564175739, + 0.08979356106259258, + 0.01314996256417574 + ], + "p_inf": 0.06349363593424098 + }, + "1.0": { + "E_F_j_given_level": [ + 0.022087746264714315, + 1.1013906298184966, + 1.079302883553834 + ], + "lambda_inf": 0.08483094979588068, + "lambda_inf_j": [ + 0.0008506175936846622, + 0.042415474897939356, + 0.04156485730425666 + ], + "p_inf": 0.038510836890748947 + } + }, + "grid_convergence": { + "k=1.0,b=0.0": { + "hole_h=0.1,Rc=6": -1.6313351977268296, + "hole_h=0.15,Rc=6": -1.6311476645638006, + "hole_h=0.3,Rc=5": -1.6317501830630747, + "hole_h=0.3,Rc=6": -1.6296607043116234, + "hole_h=0.3,Rc=6,high_order": -1.629660659845337, + "hole_j_h=0.1,Rc=6": [ + -0.31378570687015506, + -1.332596279425655, + 0.015046788568980531 + ], + "lambda_inf_high_order": 0.11609348619092598, + "torus_L=12_approx": 15.086314346932143, + "torus_L=12_direct_h=0.2": 15.086621885475793 + } + }, + "hole": { + "k=0.5,b=0.0": { + "grid": { + "Rc": 6.0, + "h": 0.15, + "points": 3200, + "symmetry": "z -> -z" + }, + "hole": -1.084135453753016, + "hole_j": [ + -0.3028235079276278, + -0.8844195042052593, + 0.10310755837987123 + ], + "hole_unweighted": 6.6558328680387655, + "hole_unweighted_j": [ + 1.6907231338002304, + 3.2743866004383944, + 1.6907231338001405 + ], + "lambda_max_on_grid": 0.1867399995903017, + "lambda_min_on_grid": 1.3675393485847551e-126 + }, + "k=0.5,b=1.0": { + "grid": { + "Rc": 6.0, + "h": 0.15, + "points": 3200, + "symmetry": "z -> -z" + }, + "hole": -0.7506293381103409, + "hole_j": [ + -0.008308169817322056, + -0.2607974077845683, + -0.4815237605084506 + ], + "hole_unweighted": 6.30991417071404, + "hole_unweighted_j": [ + 0.5638736743837274, + 3.4979879412468344, + 2.2480525550834787 + ], + "lambda_max_on_grid": 0.14996841549563256, + "lambda_min_on_grid": 1.6639091561363451e-127 + }, + "k=1.0,b=0.0": { + "grid": { + "Rc": 6.0, + "h": 0.15, + "points": 3200, + "symmetry": "z -> -z" + }, + "hole": -1.6311476645638006, + "hole_j": [ + -0.3137857115939324, + -1.3324986709058282, + 0.015136717935960147 + ], + "hole_unweighted": 1.7266312061970344, + "hole_unweighted_j": [ + 0.5963757449363564, + 0.5338797163242601, + 0.5963757449364179 + ], + "lambda_max_on_grid": 0.17946929470083037, + "lambda_min_on_grid": 0.0 + }, + "k=1.0,b=1.0": { + "grid": { + "Rc": 6.0, + "h": 0.15, + "points": 3200, + "symmetry": "z -> -z" + }, + "hole": -1.184482355875255, + "hole_j": [ + -0.005586604498269274, + -0.46494835381060384, + -0.713947397566382 + ], + "hole_unweighted": 1.850309671857266, + "hole_unweighted_j": [ + 0.23644269280226493, + 1.2280733401923594, + 0.38579363886264156 + ], + "lambda_max_on_grid": 0.13172552616590733, + "lambda_min_on_grid": 0.0 + }, + "k=2.0,b=0.0": { + "grid": { + "Rc": 6.0, + "h": 0.15, + "points": 3200, + "symmetry": "z -> -z" + }, + "hole": -2.1382024573116403, + "hole_j": [ + -0.3302820124213753, + -1.7568436474476312, + -0.051076797442633874 + ], + "hole_unweighted": 0.7685792561786426, + "hole_unweighted_j": [ + 0.47398232526493733, + -0.17938539435123557, + 0.4739823252649408 + ], + "lambda_max_on_grid": 0.19321540570437315, + "lambda_min_on_grid": 0.0 + }, + "k=2.0,b=1.0": { + "grid": { + "Rc": 6.0, + "h": 0.15, + "points": 3200, + "symmetry": "z -> -z" + }, + "hole": -1.5681389104271717, + "hole_j": [ + -0.002687318209144709, + -0.6365063443252986, + -0.9289452478927284 + ], + "hole_unweighted": 1.0599352141869065, + "hole_unweighted_j": [ + 0.21808343946028652, + 0.809045285026987, + 0.03280648969963292 + ], + "lambda_max_on_grid": 0.13923606549072168, + "lambda_min_on_grid": 0.0 + } + }, + "near_zero_profile": { + "k=0.5,b=0.0": [ + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.1007608503240916e-07, + "lambda_j": [ + 0.0, + 1.1007608503240916e-07, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0021365299065861923, + "lambda_j": [ + 0.0, + 0.0021353961230893073, + 1.1337834968849935e-06 + ], + "r": 0.05 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0010298236467895805, + "lambda_j": [ + 0.0, + 0.0003112408828513349, + 0.0007185827639382456 + ], + "r": 0.05 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.001727750351051215, + "lambda_j": [ + 0.0, + 9.726669613112576e-07, + 0.0017267776840899037 + ], + "r": 0.05 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.5119994676265612e-07, + "lambda_j": [ + 0.0, + 1.9335519354120295e-28, + 1.5119994676265612e-07 + ], + "r": 0.05 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 2.4465748675618857e-07, + "lambda_j": [ + 1.4121881852316648e-19, + 2.446574867560473e-07, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.006639808397580947, + "lambda_j": [ + 2.2246810058068508e-10, + 0.006636884153214578, + 2.924021898268832e-06 + ], + "r": 0.1 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0010080860681121154, + "lambda_j": [ + 7.906936453561304e-12, + 0.0005482721487587344, + 0.0004598139114464446 + ], + "r": 0.1 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.006978048185316661, + "lambda_j": [ + 3.0882611889734727e-14, + 3.225728075402479e-06, + 0.006974822457210376 + ], + "r": 0.1 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 2.3744972247452498e-07, + "lambda_j": [ + 0.0, + 1.5804457804777895e-14, + 2.3744970667006716e-07 + ], + "r": 0.1 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 7.579127842780078e-07, + "lambda_j": [ + 2.863931642068619e-12, + 7.579099203463658e-07, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.013618202308026461, + "lambda_j": [ + 3.692413859844749e-08, + 0.013611984538793328, + 6.180845094534226e-06 + ], + "r": 0.2 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.003402163614855698, + "lambda_j": [ + 1.8765794368147613e-09, + 0.0017711424504387784, + 0.0016310192878374833 + ], + "r": 0.2 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.013104695846141198, + "lambda_j": [ + 6.1196734527672555e-12, + 9.069469804746791e-06, + 0.013095626370216778 + ], + "r": 0.2 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 7.304482397677882e-07, + "lambda_j": [ + 0.0, + 7.078206519941104e-12, + 7.304411615612683e-07 + ], + "r": 0.2 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 7.777866697639638e-06, + "lambda_j": [ + 2.6582147444836883e-10, + 7.77760087616519e-06, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.02767651261013489, + "lambda_j": [ + 1.076438066700652e-06, + 0.02765732481848523, + 1.811135358295865e-05 + ], + "r": 0.4 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.007895409915249209, + "lambda_j": [ + 1.241778010901584e-07, + 0.004304011835059402, + 0.003591273902388717 + ], + "r": 0.4 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.02520173106836129, + "lambda_j": [ + 5.002668219335075e-10, + 4.4380670502617274e-05, + 0.02515734989759185 + ], + "r": 0.4 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 5.524247798601962e-06, + "lambda_j": [ + 0.0, + 9.842349660245204e-10, + 5.523263563635937e-06 + ], + "r": 0.4 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + } + ], + "k=0.5,b=1.0": [ + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 9.594634843599853e-08, + "lambda_j": [ + 0.0, + 9.594634843599853e-08, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0015470167907508838, + "lambda_j": [ + 0.0, + 0.001545863637273562, + 1.1531534773218286e-06 + ], + "r": 0.05 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 9.077394310139034e-05, + "lambda_j": [ + 0.0, + 2.387450431594391e-05, + 6.689943878544642e-05 + ], + "r": 0.05 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.0011700977049541024, + "lambda_j": [ + 0.0, + 1.1968387359862264e-06, + 0.0011689008662181162 + ], + "r": 0.05 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.2183235177665711e-07, + "lambda_j": [ + 0.0, + 5.074360246455502e-29, + 1.2183235177665711e-07 + ], + "r": 0.05 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 2.0136088041371947e-07, + "lambda_j": [ + 3.3272371468882465e-20, + 2.013608804136862e-07, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.00499415631089021, + "lambda_j": [ + 7.768930026103807e-11, + 0.00499117607627394, + 2.9801569269689147e-06 + ], + "r": 0.1 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0007736062406829406, + "lambda_j": [ + 1.8352209412149486e-12, + 0.00037778386987030065, + 0.000395822368977419 + ], + "r": 0.1 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.005281670828100035, + "lambda_j": [ + 6.337974805859862e-15, + 2.1476300128099494e-06, + 0.005279523198080887 + ], + "r": 0.1 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.859341786723266e-07, + "lambda_j": [ + 0.0, + 3.382737648201086e-15, + 1.8593417528958895e-07 + ], + "r": 0.1 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 6.434443586425052e-07, + "lambda_j": [ + 6.645956674907172e-13, + 6.434436940468377e-07, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.010715824940335128, + "lambda_j": [ + 9.611449894604162e-09, + 0.010708725460507188, + 7.089868378044434e-06 + ], + "r": 0.2 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0027847140995036646, + "lambda_j": [ + 4.141033583565802e-10, + 0.0013181662750302177, + 0.0014665474103700887 + ], + "r": 0.2 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.011190796912326639, + "lambda_j": [ + 1.0297699263006554e-12, + 5.1106644166797555e-06, + 0.01118568624688019 + ], + "r": 0.2 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 5.896808318664907e-07, + "lambda_j": [ + 0.0, + 1.738857818429096e-12, + 5.896790930086724e-07 + ], + "r": 0.2 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 6.6306081413754765e-06, + "lambda_j": [ + 6.211496682960097e-11, + 6.630546026408647e-06, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.020925565258625364, + "lambda_j": [ + 2.3353082589548588e-07, + 0.020897842654748467, + 2.7489073051000613e-05 + ], + "r": 0.4 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.006391708896535126, + "lambda_j": [ + 2.4405130107007963e-08, + 0.002875800496007248, + 0.003515883995397771 + ], + "r": 0.4 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.022424150459999827, + "lambda_j": [ + 6.296803158677452e-11, + 1.7313114522437837e-05, + 0.02240683728250936 + ], + "r": 0.4 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 4.907167592555362e-06, + "lambda_j": [ + 0.0, + 2.422447273352642e-10, + 4.9069253478280265e-06 + ], + "r": 0.4 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + } + ], + "k=1.0,b=0.0": [ + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 2.1093055695653464e-28, + "lambda_j": [ + 0.0, + 2.1093055695653464e-28, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0010042757961631174, + "lambda_j": [ + 0.0, + 0.001004275794294735, + 1.8683823980511778e-12 + ], + "r": 0.05 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0010298236467896796, + "lambda_j": [ + 0.0, + 0.00031124088285139015, + 0.0007185827639382895 + ], + "r": 0.05 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.0007364785619356328, + "lambda_j": [ + 0.0, + 7.972622650421557e-13, + 0.0007364785611383706 + ], + "r": 0.05 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.5190567657060656e-28, + "lambda_j": [ + 0.0, + 1.1158265486189182e-53, + 1.5190567657060656e-28 + ], + "r": 0.05 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 6.4087039930494485e-28, + "lambda_j": [ + 7.482288846062231e-58, + 6.4087039930494485e-28, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0025704808848457618, + "lambda_j": [ + 7.561733334564415e-12, + 0.0025704808730701374, + 4.213891115625729e-12 + ], + "r": 0.1 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0010080860681121113, + "lambda_j": [ + 7.906936453561307e-12, + 0.0005482721487587343, + 0.0004598139114464405 + ], + "r": 0.1 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.0027477128235462544, + "lambda_j": [ + 6.06766812808775e-20, + 7.94301107084324e-12, + 0.002747712815603243 + ], + "r": 0.1 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 2.61285628177819e-28, + "lambda_j": [ + 0.0, + 3.0380051876710584e-35, + 2.6128559779776714e-28 + ], + "r": 0.1 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 9.221098019682842e-27, + "lambda_j": [ + 2.7896581688335026e-33, + 9.221095230024673e-27, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.005194194425041268, + "lambda_j": [ + 2.3016580784159037e-08, + 0.005194171396702473, + 1.1758010765446167e-11 + ], + "r": 0.2 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0034021636148557142, + "lambda_j": [ + 1.8765794368147576e-09, + 0.001771142450438789, + 0.0016310192878374885 + ], + "r": 0.2 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.0050846836857588555, + "lambda_j": [ + 1.2014261385646596e-17, + 5.055149683100958e-08, + 0.005084633134262013 + ], + "r": 0.2 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 6.274845818799208e-27, + "lambda_j": [ + 0.0, + 8.021289091086913e-32, + 6.2747656059082974e-27 + ], + "r": 0.2 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 2.151856922084616e-23, + "lambda_j": [ + 5.722460504428276e-28, + 2.1517996974795717e-23, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.011304121250842698, + "lambda_j": [ + 5.157429191129455e-07, + 0.011303605401517397, + 1.0640618803830285e-10 + ], + "r": 0.4 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.007895409915249217, + "lambda_j": [ + 1.2417780109015846e-07, + 0.004304011835059409, + 0.0035912739023887183 + ], + "r": 0.4 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.010569112630676334, + "lambda_j": [ + 2.6352498253770692e-15, + 1.2610809982661303e-06, + 0.010567851549675433 + ], + "r": 0.4 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.120999565136782e-23, + "lambda_j": [ + 0.0, + 2.800186239519058e-27, + 1.12071954651283e-23 + ], + "r": 0.4 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + } + ], + "k=1.0,b=1.0": [ + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.5223996357803381e-28, + "lambda_j": [ + 0.0, + 1.5223996357803381e-28, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0007105275062101507, + "lambda_j": [ + 0.0, + 0.0007105275043187098, + 1.891440873565354e-12 + ], + "r": 0.05 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 9.077394310139184e-05, + "lambda_j": [ + 0.0, + 2.3874504315943866e-05, + 6.689943878544797e-05 + ], + "r": 0.05 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.00042481597485555706, + "lambda_j": [ + 0.0, + 7.562038382033871e-13, + 0.0004248159740993532 + ], + "r": 0.05 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 6.998906366234738e-29, + "lambda_j": [ + 0.0, + 5.9126061877243174e-55, + 6.998906366234738e-29 + ], + "r": 0.05 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 4.945854252929738e-28, + "lambda_j": [ + 1.639127578599705e-58, + 4.945854252929738e-28, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0020530144734832684, + "lambda_j": [ + 2.184575578510603e-12, + 0.0020530144666005075, + 4.698185212868141e-12 + ], + "r": 0.1 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.000773606240682945, + "lambda_j": [ + 1.835220941214936e-12, + 0.00037778386987030396, + 0.0003958223689774201 + ], + "r": 0.1 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.002205886036003058, + "lambda_j": [ + 1.0772978307399943e-20, + 4.048915475195213e-12, + 0.0022058860319541427 + ], + "r": 0.1 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 6.800064836993285e-28, + "lambda_j": [ + 0.0, + 6.763519745506458e-36, + 6.8000647693580875e-28 + ], + "r": 0.1 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 7.640884080017525e-27, + "lambda_j": [ + 6.59203249989553e-34, + 7.640883420814275e-27, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.0041902831765628125, + "lambda_j": [ + 5.424923772567412e-09, + 0.004190277734408652, + 1.723038799339847e-11 + ], + "r": 0.2 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0027847140995036664, + "lambda_j": [ + 4.1410335835665824e-10, + 0.0013181662750302258, + 0.0014665474103700824 + ], + "r": 0.2 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.004267986009122482, + "lambda_j": [ + 1.6015806691238693e-18, + 1.2212726670270489e-08, + 0.00426797379639581 + ], + "r": 0.2 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 6.490050835834233e-27, + "lambda_j": [ + 0.0, + 1.9094750805721791e-32, + 6.490031741083427e-27 + ], + "r": 0.2 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.9597753503142905e-23, + "lambda_j": [ + 1.3925142259819909e-28, + 1.9597614251720306e-23, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 0.008913928961954934, + "lambda_j": [ + 1.1802996398141025e-07, + 0.008913810681639087, + 2.5035186640758745e-10 + ], + "r": 0.4 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.006391708896535129, + "lambda_j": [ + 2.4405130107007986e-08, + 0.00287580049600725, + 0.0035158839953977725 + ], + "r": 0.4 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 0.009022106151949533, + "lambda_j": [ + 2.1825854545674902e-16, + 3.1590341643004654e-07, + 0.009021790248532885 + ], + "r": 0.4 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 9.800210691339238e-24, + "lambda_j": [ + 0.0, + 6.78103951267826e-28, + 9.79953258738797e-24 + ], + "r": 0.4 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + } + ], + "k=2.0,b=0.0": [ + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.702286082548244e-112, + "lambda_j": [ + 0.0, + 1.702286082548244e-112, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 2.804980898379168e-06, + "lambda_j": [ + 0.0, + 2.804980898379168e-06, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0010298236467895377, + "lambda_j": [ + 0.0, + 0.0003112408828513121, + 0.0007185827639382256 + ], + "r": 0.05 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 1.5794494127366118e-06, + "lambda_j": [ + 0.0, + 2.442477625234044e-30, + 1.5794494127366118e-06 + ], + "r": 0.05 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.1255857139074035e-112, + "lambda_j": [ + 0.0, + 6.84009218063367e-142, + 1.1255857139074035e-112 + ], + "r": 0.05 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 4.52572136447521e-111, + "lambda_j": [ + 2.8697230987881016e-211, + 4.52572136447521e-111, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 6.723284402103214e-06, + "lambda_j": [ + 5.107347803156441e-20, + 6.723284402103163e-06, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0010080860681121223, + "lambda_j": [ + 7.90693645356135e-12, + 0.0005482721487587413, + 0.00045981391144644463 + ], + "r": 0.1 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 8.22618419614483e-06, + "lambda_j": [ + 0.0, + 7.806148711054245e-16, + 8.226184195364214e-06 + ], + "r": 0.1 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.913126768040405e-111, + "lambda_j": [ + 0.0, + 1.7909774515050856e-118, + 1.9131265889426596e-111 + ], + "r": 0.1 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.9566775671874284e-107, + "lambda_j": [ + 1.1470532304708705e-118, + 1.956677567175958e-107, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 1.4506344718775665e-05, + "lambda_j": [ + 3.527218989548529e-11, + 1.450630944658577e-05, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.003402163614855708, + "lambda_j": [ + 1.876579436814757e-09, + 0.0017711424504387857, + 0.0016310192878374857 + ], + "r": 0.2 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 1.4503191855802134e-05, + "lambda_j": [ + 0.0, + 9.881223901873418e-11, + 1.4503093043563116e-05 + ], + "r": 0.2 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.336465837825128e-107, + "lambda_j": [ + 0.0, + 2.0918852786396756e-112, + 1.3364449189723417e-107 + ], + "r": 0.2 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.042388422743631e-94, + "lambda_j": [ + 9.585499469076187e-100, + 1.0423788372441619e-94, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 4.1855158115202624e-05, + "lambda_j": [ + 2.1398462910532028e-09, + 4.185301826891157e-05, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.007895409915249212, + "lambda_j": [ + 1.2417780109015835e-07, + 0.004304011835059408, + 0.003591273902388713 + ], + "r": 0.4 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 3.892791806960772e-05, + "lambda_j": [ + 0.0, + 3.4673029567213974e-09, + 3.8924450766651e-05 + ], + "r": 0.4 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 2.7316159980880942e-95, + "lambda_j": [ + 0.0, + 1.9533440430832328e-98, + 2.729662654045011e-95 + ], + "r": 0.4 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + } + ], + "k=2.0,b=1.0": [ + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.1256881386727306e-112, + "lambda_j": [ + 0.0, + 1.1256881386727306e-112, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 1.9134140831536693e-06, + "lambda_j": [ + 0.0, + 1.9134140831536693e-06, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 9.077394310139168e-05, + "lambda_j": [ + 0.0, + 2.3874504315944246e-05, + 6.689943878544744e-05 + ], + "r": 0.05 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 1.8680478260196573e-06, + "lambda_j": [ + 0.0, + 0.0, + 1.8680478260196573e-06 + ], + "r": 0.05 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 4.247113153275503e-112, + "lambda_j": [ + 0.0, + 8.865688347560173e-144, + 4.247113153275503e-112 + ], + "r": 0.05 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.05 + }, + { + "angle_deg": 0, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 3.47824398943578e-111, + "lambda_j": [ + 5.620966462066486e-212, + 3.47824398943578e-111, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 5.4717682417127276e-06, + "lambda_j": [ + 1.469748599906681e-20, + 5.471768241712713e-06, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.0007736062406829362, + "lambda_j": [ + 1.8352209412178477e-12, + 0.0003777838698703016, + 0.00039582236897741367 + ], + "r": 0.1 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 5.426687116957742e-06, + "lambda_j": [ + 0.0, + 1.877434092818391e-16, + 5.426687116769999e-06 + ], + "r": 0.1 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.1220594298861341e-111, + "lambda_j": [ + 0.0, + 3.180979303849326e-119, + 1.122059398076341e-111 + ], + "r": 0.1 + }, + { + "angle_deg": 180, + "exact_regression": true, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.1 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.7882663314679737e-107, + "lambda_j": [ + 3.2178423176640523e-119, + 1.788266331464756e-107, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 1.1809241761717542e-05, + "lambda_j": [ + 8.269725333334063e-12, + 1.1809233491992208e-05, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.002784714099503671, + "lambda_j": [ + 4.141033583565052e-10, + 0.001318166275030222, + 0.0014665474103700907 + ], + "r": 0.2 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 1.196165491191902e-05, + "lambda_j": [ + 0.0, + 2.370088392382352e-11, + 1.1961631211035097e-05 + ], + "r": 0.2 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 1.1843657859619608e-107, + "lambda_j": [ + 0.0, + 5.663391018186695e-113, + 1.1843601225709425e-107 + ], + "r": 0.2 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.2 + }, + { + "angle_deg": 0, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 30, + "exact_regression": false, + "lambda": 1.0595989301411022e-94, + "lambda_j": [ + 2.4965010725235053e-100, + 1.0595964336400296e-94, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 60, + "exact_regression": false, + "lambda": 3.37878391920449e-05, + "lambda_j": [ + 5.060528857936293e-10, + 3.378733313915911e-05, + 0.0 + ], + "r": 0.4 + }, + { + "angle_deg": 90, + "exact_regression": false, + "lambda": 0.006391708896535132, + "lambda_j": [ + 2.440513010700793e-08, + 0.0028758004960072513, + 0.0035158839953977742 + ], + "r": 0.4 + }, + { + "angle_deg": 120, + "exact_regression": false, + "lambda": 3.245386590834958e-05, + "lambda_j": [ + 0.0, + 8.585213531995287e-10, + 3.2453007386996385e-05 + ], + "r": 0.4 + }, + { + "angle_deg": 150, + "exact_regression": false, + "lambda": 2.2959157703415916e-95, + "lambda_j": [ + 0.0, + 4.725628392771363e-99, + 2.2954432075023144e-95 + ], + "r": 0.4 + }, + { + "angle_deg": 180, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "r": 0.4 + } + ] + }, + "object": "CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1", + "quadrature": { + "a_gauss_legendre_per_side": 24, + "coordinates": "a = tr H / 2, (c, h2) polar; splits at a = 0 and rho = |a|", + "cut_sd": 9.0, + "high_order_check": [ + 32, + 48, + 32 + ], + "max_rel_dev_vs_high_order_at_samples": 0.40391717052519804, + "rho_gauss_legendre_per_side": 24, + "theta_trapezoid": 32 + }, + "ray_profile": { + "k=0.5,b=0.0": [ + { + "angle_deg": 90, + "r": 0.25, + "ratio": 0.039490988260693596, + "ratio_unweighted": 63.16746850830896 + }, + { + "angle_deg": 90, + "r": 0.5, + "ratio": 0.08718208578297156, + "ratio_unweighted": 9.494284065739743 + }, + { + "angle_deg": 90, + "r": 0.75, + "ratio": 0.1410383214852956, + "ratio_unweighted": 3.449574209574775 + }, + { + "angle_deg": 90, + "r": 1.0, + "ratio": 0.2081573587558727, + "ratio_unweighted": 1.8922929036340805 + }, + { + "angle_deg": 90, + "r": 1.5, + "ratio": 0.4032502250014552, + "ratio_unweighted": 1.0829668264222414 + }, + { + "angle_deg": 90, + "r": 2.0, + "ratio": 0.6796734764925719, + "ratio_unweighted": 0.9536229801411701 + }, + { + "angle_deg": 90, + "r": 2.5, + "ratio": 0.9193080420260853, + "ratio_unweighted": 0.9692831834619947 + }, + { + "angle_deg": 90, + "r": 3.0, + "ratio": 1.0014637279244158, + "ratio_unweighted": 0.9923682660003456 + }, + { + "angle_deg": 90, + "r": 4.0, + "ratio": 1.0003721623791384, + "ratio_unweighted": 0.9999486896780728 + }, + { + "angle_deg": 60, + "r": 0.25, + "ratio": 0.1470057888552203, + "ratio_unweighted": 127.31730271673432 + }, + { + "angle_deg": 60, + "r": 0.5, + "ratio": 0.3012719494924743, + "ratio_unweighted": 17.139492517290375 + }, + { + "angle_deg": 60, + "r": 0.75, + "ratio": 0.4672733631091738, + "ratio_unweighted": 5.7542900865743345 + }, + { + "angle_deg": 60, + "r": 1.0, + "ratio": 0.6476258883836312, + "ratio_unweighted": 2.8972305270680754 + }, + { + "angle_deg": 60, + "r": 1.5, + "ratio": 1.0092769462431534, + "ratio_unweighted": 1.4122132422261242 + }, + { + "angle_deg": 60, + "r": 2.0, + "ratio": 1.1745551028518046, + "ratio_unweighted": 1.0870739712923185 + }, + { + "angle_deg": 60, + "r": 2.5, + "ratio": 1.0931498226541099, + "ratio_unweighted": 1.0059090162305244 + }, + { + "angle_deg": 60, + "r": 3.0, + "ratio": 1.0167466632271587, + "ratio_unweighted": 0.9967020894579159 + }, + { + "angle_deg": 60, + "r": 4.0, + "ratio": 0.999975572733961, + "ratio_unweighted": 0.9999572439947901 + }, + { + "angle_deg": 45, + "r": 0.25, + "ratio": 0.09289674169983599, + "ratio_unweighted": 36.311243176653946 + }, + { + "angle_deg": 45, + "r": 0.5, + "ratio": 0.22186217052024215, + "ratio_unweighted": 5.762957959340962 + }, + { + "angle_deg": 45, + "r": 0.75, + "ratio": 0.43027714112640947, + "ratio_unweighted": 2.4432606595267896 + }, + { + "angle_deg": 45, + "r": 1.0, + "ratio": 0.7477629623898842, + "ratio_unweighted": 1.5918234833864526 + }, + { + "angle_deg": 45, + "r": 1.5, + "ratio": 1.4677489663502015, + "ratio_unweighted": 1.1713421370872288 + }, + { + "angle_deg": 45, + "r": 2.0, + "ratio": 1.5383967630808733, + "ratio_unweighted": 1.057380067510981 + }, + { + "angle_deg": 45, + "r": 2.5, + "ratio": 1.1876291458332473, + "ratio_unweighted": 1.0057473661670722 + }, + { + "angle_deg": 45, + "r": 3.0, + "ratio": 1.0249948191725586, + "ratio_unweighted": 1.0018271300179102 + }, + { + "angle_deg": 45, + "r": 4.0, + "ratio": 1.0000317438928017, + "ratio_unweighted": 1.0003687231288774 + }, + { + "angle_deg": 30, + "r": 0.25, + "ratio": 1.1323716797741778e-05, + "ratio_unweighted": 0.0011315493169059292 + }, + { + "angle_deg": 30, + "r": 0.5, + "ratio": 0.00023292226647557746, + "ratio_unweighted": 0.0015140500125667095 + }, + { + "angle_deg": 30, + "r": 0.75, + "ratio": 0.004767670553293077, + "ratio_unweighted": 0.007394938967083044 + }, + { + "angle_deg": 30, + "r": 1.0, + "ratio": 0.0508016678151566, + "ratio_unweighted": 0.03779811148859605 + }, + { + "angle_deg": 30, + "r": 1.5, + "ratio": 0.5930390350197559, + "ratio_unweighted": 0.2949378080004211 + }, + { + "angle_deg": 30, + "r": 2.0, + "ratio": 1.059196541105937, + "ratio_unweighted": 0.6545610735726085 + }, + { + "angle_deg": 30, + "r": 2.5, + "ratio": 1.0441338533749804, + "ratio_unweighted": 0.8874737863345261 + }, + { + "angle_deg": 30, + "r": 3.0, + "ratio": 1.0144035103536144, + "ratio_unweighted": 0.9956220541515616 + }, + { + "angle_deg": 30, + "r": 4.0, + "ratio": 1.0010801700126166, + "ratio_unweighted": 1.0014624881536047 + }, + { + "angle_deg": 0, + "r": 0.25, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.5, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.75, + "ratio": 8.221271971269327e-85, + "ratio_unweighted": 4.466979124611998e-85 + }, + { + "angle_deg": 0, + "r": 1.0, + "ratio": 6.194650535106846e-27, + "ratio_unweighted": 5.064802636612562e-27 + }, + { + "angle_deg": 0, + "r": 1.5, + "ratio": 2.6628488495010084e-05, + "ratio_unweighted": 2.285631609327335e-05 + }, + { + "angle_deg": 0, + "r": 2.0, + "ratio": 0.08331704130263944, + "ratio_unweighted": 0.0786718730295742 + }, + { + "angle_deg": 0, + "r": 2.5, + "ratio": 0.5949140523783994, + "ratio_unweighted": 0.5846942619012991 + }, + { + "angle_deg": 0, + "r": 3.0, + "ratio": 0.9673329862889801, + "ratio_unweighted": 0.9639475613911047 + }, + { + "angle_deg": 0, + "r": 4.0, + "ratio": 1.003538764598419, + "ratio_unweighted": 1.0035168444160498 + } + ], + "k=0.5,b=1.0": [ + { + "angle_deg": 90, + "r": 0.25, + "ratio": 0.04394824928347523, + "ratio_unweighted": 78.41598358314276 + }, + { + "angle_deg": 90, + "r": 0.5, + "ratio": 0.09570762094163081, + "ratio_unweighted": 11.582997312139367 + }, + { + "angle_deg": 90, + "r": 0.75, + "ratio": 0.15014313721319839, + "ratio_unweighted": 4.086005447774196 + }, + { + "angle_deg": 90, + "r": 1.0, + "ratio": 0.2130828818035663, + "ratio_unweighted": 2.1676986752618106 + }, + { + "angle_deg": 90, + "r": 1.5, + "ratio": 0.3798488219726349, + "ratio_unweighted": 1.1601785742194737 + }, + { + "angle_deg": 90, + "r": 2.0, + "ratio": 0.6140195790184909, + "ratio_unweighted": 0.9702662424165897 + }, + { + "angle_deg": 90, + "r": 2.5, + "ratio": 0.8581465414760014, + "ratio_unweighted": 0.962381280209413 + }, + { + "angle_deg": 90, + "r": 3.0, + "ratio": 0.9915281367848631, + "ratio_unweighted": 0.9839832295187693 + }, + { + "angle_deg": 90, + "r": 4.0, + "ratio": 1.006249568064324, + "ratio_unweighted": 0.9991348984748696 + }, + { + "angle_deg": 60, + "r": 0.25, + "ratio": 0.15704682922861773, + "ratio_unweighted": 155.37499405267155 + }, + { + "angle_deg": 60, + "r": 0.5, + "ratio": 0.3046592740342447, + "ratio_unweighted": 20.236107484099122 + }, + { + "angle_deg": 60, + "r": 0.75, + "ratio": 0.44495068537242854, + "ratio_unweighted": 6.573653633203263 + }, + { + "angle_deg": 60, + "r": 1.0, + "ratio": 0.5803442484472724, + "ratio_unweighted": 3.2114657256982606 + }, + { + "angle_deg": 60, + "r": 1.5, + "ratio": 0.8278936373071835, + "ratio_unweighted": 1.4941422191225022 + }, + { + "angle_deg": 60, + "r": 2.0, + "ratio": 0.9722244384829813, + "ratio_unweighted": 1.114698926598593 + }, + { + "angle_deg": 60, + "r": 2.5, + "ratio": 0.9929321714206912, + "ratio_unweighted": 1.005217915220107 + }, + { + "angle_deg": 60, + "r": 3.0, + "ratio": 0.9938135784896569, + "ratio_unweighted": 0.9811482160673288 + }, + { + "angle_deg": 60, + "r": 4.0, + "ratio": 0.999743802620589, + "ratio_unweighted": 0.9946356513587027 + }, + { + "angle_deg": 45, + "r": 0.25, + "ratio": 0.10224342953236586, + "ratio_unweighted": 45.22046816869712 + }, + { + "angle_deg": 45, + "r": 0.5, + "ratio": 0.24270134751910086, + "ratio_unweighted": 7.285070271453708 + }, + { + "angle_deg": 45, + "r": 0.75, + "ratio": 0.4725711192601542, + "ratio_unweighted": 3.221752753422984 + }, + { + "angle_deg": 45, + "r": 1.0, + "ratio": 0.8222056004520534, + "ratio_unweighted": 2.195948072906509 + }, + { + "angle_deg": 45, + "r": 1.5, + "ratio": 1.5541448171409233, + "ratio_unweighted": 1.6212598350479626 + }, + { + "angle_deg": 45, + "r": 2.0, + "ratio": 1.5441921785908619, + "ratio_unweighted": 1.3147671938773093 + }, + { + "angle_deg": 45, + "r": 2.5, + "ratio": 1.1794952882669087, + "ratio_unweighted": 1.0989338446408359 + }, + { + "angle_deg": 45, + "r": 3.0, + "ratio": 1.0143361556167563, + "ratio_unweighted": 1.001350738462004 + }, + { + "angle_deg": 45, + "r": 4.0, + "ratio": 0.9919590571983622, + "ratio_unweighted": 0.9887910067079594 + }, + { + "angle_deg": 30, + "r": 0.25, + "ratio": 1.3317435040219016e-05, + "ratio_unweighted": 0.0014727398557857153 + }, + { + "angle_deg": 30, + "r": 0.5, + "ratio": 0.0002865024291763956, + "ratio_unweighted": 0.0022944910520233904 + }, + { + "angle_deg": 30, + "r": 0.75, + "ratio": 0.006725869287074077, + "ratio_unweighted": 0.013809587090550654 + }, + { + "angle_deg": 30, + "r": 1.0, + "ratio": 0.07818528197785432, + "ratio_unweighted": 0.07883035306431126 + }, + { + "angle_deg": 30, + "r": 1.5, + "ratio": 0.9026916867978404, + "ratio_unweighted": 0.5846628219579861 + }, + { + "angle_deg": 30, + "r": 2.0, + "ratio": 1.4380954211513064, + "ratio_unweighted": 1.0422373862755423 + }, + { + "angle_deg": 30, + "r": 2.5, + "ratio": 1.2202353857941217, + "ratio_unweighted": 1.1034921885156046 + }, + { + "angle_deg": 30, + "r": 3.0, + "ratio": 1.03740771067733, + "ratio_unweighted": 1.027383001739458 + }, + { + "angle_deg": 30, + "r": 4.0, + "ratio": 0.9837835928552275, + "ratio_unweighted": 0.9823220492649262 + }, + { + "angle_deg": 0, + "r": 0.25, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.5, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.75, + "ratio": 2.375275323493752e-84, + "ratio_unweighted": 2.273077033160661e-84 + }, + { + "angle_deg": 0, + "r": 1.0, + "ratio": 3.7899819078574724e-26, + "ratio_unweighted": 2.7012738643267095e-26 + }, + { + "angle_deg": 0, + "r": 1.5, + "ratio": 7.800773868026436e-05, + "ratio_unweighted": 6.227365346906256e-05 + }, + { + "angle_deg": 0, + "r": 2.0, + "ratio": 0.17495229241250873, + "ratio_unweighted": 0.15973518322083863 + }, + { + "angle_deg": 0, + "r": 2.5, + "ratio": 0.8808634471201148, + "ratio_unweighted": 0.8576923842465419 + }, + { + "angle_deg": 0, + "r": 3.0, + "ratio": 1.057246263472686, + "ratio_unweighted": 1.0515363705643406 + }, + { + "angle_deg": 0, + "r": 4.0, + "ratio": 0.9759421804845596, + "ratio_unweighted": 0.9758240095632997 + } + ], + "k=1.0,b=0.0": [ + { + "angle_deg": 90, + "r": 0.25, + "ratio": 0.039490988260693465, + "ratio_unweighted": 63.16746850830891 + }, + { + "angle_deg": 90, + "r": 0.5, + "ratio": 0.08718208578297151, + "ratio_unweighted": 9.494284065739745 + }, + { + "angle_deg": 90, + "r": 0.75, + "ratio": 0.1410383214852956, + "ratio_unweighted": 3.449574209574774 + }, + { + "angle_deg": 90, + "r": 1.0, + "ratio": 0.20815735875587274, + "ratio_unweighted": 1.8922929036340814 + }, + { + "angle_deg": 90, + "r": 1.5, + "ratio": 0.4032502250014551, + "ratio_unweighted": 1.0829668264222414 + }, + { + "angle_deg": 90, + "r": 2.0, + "ratio": 0.6796734764925719, + "ratio_unweighted": 0.9536229801411701 + }, + { + "angle_deg": 90, + "r": 2.5, + "ratio": 0.9193080420260853, + "ratio_unweighted": 0.9692831834619947 + }, + { + "angle_deg": 90, + "r": 3.0, + "ratio": 1.0014637279244158, + "ratio_unweighted": 0.9923682660003456 + }, + { + "angle_deg": 90, + "r": 4.0, + "ratio": 1.0003721623791384, + "ratio_unweighted": 0.9999486896780728 + }, + { + "angle_deg": 60, + "r": 0.25, + "ratio": 0.05692442159554174, + "ratio_unweighted": 49.705878512333015 + }, + { + "angle_deg": 60, + "r": 0.5, + "ratio": 0.12939808101843256, + "ratio_unweighted": 7.386237144573246 + }, + { + "angle_deg": 60, + "r": 0.75, + "ratio": 0.23862402067602873, + "ratio_unweighted": 2.8833583592724072 + }, + { + "angle_deg": 60, + "r": 1.0, + "ratio": 0.4134121746475836, + "ratio_unweighted": 1.745741142416309 + }, + { + "angle_deg": 60, + "r": 1.5, + "ratio": 1.017916297720146, + "ratio_unweighted": 1.2298366863909975 + }, + { + "angle_deg": 60, + "r": 2.0, + "ratio": 1.4788866117538042, + "ratio_unweighted": 1.1545334319654434 + }, + { + "angle_deg": 60, + "r": 2.5, + "ratio": 1.2673775414900035, + "ratio_unweighted": 1.0677253994057987 + }, + { + "angle_deg": 60, + "r": 3.0, + "ratio": 1.0494221655767704, + "ratio_unweighted": 1.0160268638630534 + }, + { + "angle_deg": 60, + "r": 4.0, + "ratio": 1.000102473311175, + "ratio_unweighted": 1.0003102419424925 + }, + { + "angle_deg": 45, + "r": 0.25, + "ratio": 3.0236451379592164e-05, + "ratio_unweighted": 0.011807114643084907 + }, + { + "angle_deg": 45, + "r": 0.5, + "ratio": 0.00016251597971010754, + "ratio_unweighted": 0.004063781466495098 + }, + { + "angle_deg": 45, + "r": 0.75, + "ratio": 0.0010610982385101176, + "ratio_unweighted": 0.005391802677426938 + }, + { + "angle_deg": 45, + "r": 1.0, + "ratio": 0.007560423710252632, + "ratio_unweighted": 0.013378222630051154 + }, + { + "angle_deg": 45, + "r": 1.5, + "ratio": 0.20092666435941745, + "ratio_unweighted": 0.12307554943689902 + }, + { + "angle_deg": 45, + "r": 2.0, + "ratio": 0.9964397398024314, + "ratio_unweighted": 0.528716419747668 + }, + { + "angle_deg": 45, + "r": 2.5, + "ratio": 1.243806787693739, + "ratio_unweighted": 0.9131568384647232 + }, + { + "angle_deg": 45, + "r": 3.0, + "ratio": 1.0761288060632765, + "ratio_unweighted": 1.0283207179775173 + }, + { + "angle_deg": 45, + "r": 4.0, + "ratio": 1.0016471084088314, + "ratio_unweighted": 1.0024313814077395 + }, + { + "angle_deg": 30, + "r": 0.25, + "ratio": 3.9875523196431946e-25, + "ratio_unweighted": 3.734086414319828e-23 + }, + { + "angle_deg": 30, + "r": 0.5, + "ratio": 2.0309075979121114e-20, + "ratio_unweighted": 1.1307225502312292e-19 + }, + { + "angle_deg": 30, + "r": 0.75, + "ratio": 4.756191498871468e-15, + "ratio_unweighted": 5.556819543196532e-15 + }, + { + "angle_deg": 30, + "r": 1.0, + "ratio": 2.2608509702817752e-10, + "ratio_unweighted": 1.194229248749143e-10 + }, + { + "angle_deg": 30, + "r": 1.5, + "ratio": 0.00017972633491160816, + "ratio_unweighted": 6.196898264769764e-05 + }, + { + "angle_deg": 30, + "r": 2.0, + "ratio": 0.06145082454933448, + "ratio_unweighted": 0.028392328977057995 + }, + { + "angle_deg": 30, + "r": 2.5, + "ratio": 0.5142678330609568, + "ratio_unweighted": 0.3816765792242292 + }, + { + "angle_deg": 30, + "r": 3.0, + "ratio": 0.9775337038827994, + "ratio_unweighted": 0.93490055995845 + }, + { + "angle_deg": 30, + "r": 4.0, + "ratio": 1.0067688578875311, + "ratio_unweighted": 1.0075532747065912 + }, + { + "angle_deg": 0, + "r": 0.25, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.5, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.75, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 1.0, + "ratio": 1.7533340743566104e-112, + "ratio_unweighted": 1.4991510750309477e-112 + }, + { + "angle_deg": 0, + "r": 1.5, + "ratio": 2.0750446532480025e-22, + "ratio_unweighted": 1.8232309326007793e-22 + }, + { + "angle_deg": 0, + "r": 2.0, + "ratio": 1.5952138227033e-06, + "ratio_unweighted": 1.5299327668704416e-06 + }, + { + "angle_deg": 0, + "r": 2.5, + "ratio": 0.03661185542666673, + "ratio_unweighted": 0.03614166199213023 + }, + { + "angle_deg": 0, + "r": 3.0, + "ratio": 0.6747067855676732, + "ratio_unweighted": 0.6722575316666797 + }, + { + "angle_deg": 0, + "r": 4.0, + "ratio": 1.016845463382698, + "ratio_unweighted": 1.01680240852149 + } + ], + "k=1.0,b=1.0": [ + { + "angle_deg": 90, + "r": 0.25, + "ratio": 0.043948249283475245, + "ratio_unweighted": 78.41598358314282 + }, + { + "angle_deg": 90, + "r": 0.5, + "ratio": 0.09570762094163077, + "ratio_unweighted": 11.582997312139366 + }, + { + "angle_deg": 90, + "r": 0.75, + "ratio": 0.15014313721319839, + "ratio_unweighted": 4.086005447774196 + }, + { + "angle_deg": 90, + "r": 1.0, + "ratio": 0.2130828818035663, + "ratio_unweighted": 2.1676986752618106 + }, + { + "angle_deg": 90, + "r": 1.5, + "ratio": 0.3798488219726348, + "ratio_unweighted": 1.1601785742194732 + }, + { + "angle_deg": 90, + "r": 2.0, + "ratio": 0.6140195790184907, + "ratio_unweighted": 0.9702662424165897 + }, + { + "angle_deg": 90, + "r": 2.5, + "ratio": 0.8581465414760014, + "ratio_unweighted": 0.962381280209413 + }, + { + "angle_deg": 90, + "r": 3.0, + "ratio": 0.9915281367848633, + "ratio_unweighted": 0.9839832295187693 + }, + { + "angle_deg": 90, + "r": 4.0, + "ratio": 1.006249568064324, + "ratio_unweighted": 0.9991348984748696 + }, + { + "angle_deg": 60, + "r": 0.25, + "ratio": 0.062463542950728486, + "ratio_unweighted": 61.676049531618965 + }, + { + "angle_deg": 60, + "r": 0.5, + "ratio": 0.13808468444103122, + "ratio_unweighted": 9.072065420500458 + }, + { + "angle_deg": 60, + "r": 0.75, + "ratio": 0.24734400066180037, + "ratio_unweighted": 3.5425811380362755 + }, + { + "angle_deg": 60, + "r": 1.0, + "ratio": 0.41498489460569093, + "ratio_unweighted": 2.160138865697299 + }, + { + "angle_deg": 60, + "r": 1.5, + "ratio": 0.9413614714957307, + "ratio_unweighted": 1.5020731505417482 + }, + { + "angle_deg": 60, + "r": 2.0, + "ratio": 1.2645274223365988, + "ratio_unweighted": 1.2907351621631007 + }, + { + "angle_deg": 60, + "r": 2.5, + "ratio": 1.1158353079347416, + "ratio_unweighted": 1.0860108153620203 + }, + { + "angle_deg": 60, + "r": 3.0, + "ratio": 1.006813404437864, + "ratio_unweighted": 0.9927870476880315 + }, + { + "angle_deg": 60, + "r": 4.0, + "ratio": 0.9962972997286528, + "ratio_unweighted": 0.9913697961901646 + }, + { + "angle_deg": 45, + "r": 0.25, + "ratio": 3.386292089537056e-05, + "ratio_unweighted": 0.014921831094148408 + }, + { + "angle_deg": 45, + "r": 0.5, + "ratio": 0.00018589394208290202, + "ratio_unweighted": 0.005433623500771513 + }, + { + "angle_deg": 45, + "r": 0.75, + "ratio": 0.0012684870922610714, + "ratio_unweighted": 0.008082383426690428 + }, + { + "angle_deg": 45, + "r": 1.0, + "ratio": 0.009529541109407007, + "ratio_unweighted": 0.022708237720117447 + }, + { + "angle_deg": 45, + "r": 1.5, + "ratio": 0.26914760028361945, + "ratio_unweighted": 0.23295993239811416 + }, + { + "angle_deg": 45, + "r": 2.0, + "ratio": 1.2766384950758856, + "ratio_unweighted": 0.8955031761837973 + }, + { + "angle_deg": 45, + "r": 2.5, + "ratio": 1.4118921865099943, + "ratio_unweighted": 1.1953490785156695 + }, + { + "angle_deg": 45, + "r": 3.0, + "ratio": 1.0839438605960736, + "ratio_unweighted": 1.0651387925877533 + }, + { + "angle_deg": 45, + "r": 4.0, + "ratio": 0.9845744608359893, + "ratio_unweighted": 0.9817735628894225 + }, + { + "angle_deg": 30, + "r": 0.25, + "ratio": 4.702980078075717e-25, + "ratio_unweighted": 5.226886648803399e-23 + }, + { + "angle_deg": 30, + "r": 0.5, + "ratio": 2.796330125110172e-20, + "ratio_unweighted": 2.036049810243635e-19 + }, + { + "angle_deg": 30, + "r": 0.75, + "ratio": 8.45015119266073e-15, + "ratio_unweighted": 1.4182377913543486e-14 + }, + { + "angle_deg": 30, + "r": 1.0, + "ratio": 4.5101624023716076e-10, + "ratio_unweighted": 3.585960480011269e-10 + }, + { + "angle_deg": 30, + "r": 1.5, + "ratio": 0.000392980779124985, + "ratio_unweighted": 0.00019511545884576327 + }, + { + "angle_deg": 30, + "r": 2.0, + "ratio": 0.12580347665686245, + "ratio_unweighted": 0.07345669062471187 + }, + { + "angle_deg": 30, + "r": 2.5, + "ratio": 0.8423037930226176, + "ratio_unweighted": 0.6819004240608795 + }, + { + "angle_deg": 30, + "r": 3.0, + "ratio": 1.1309152804193099, + "ratio_unweighted": 1.1044863047980609 + }, + { + "angle_deg": 30, + "r": 4.0, + "ratio": 0.9737923584022314, + "ratio_unweighted": 0.9726976210713407 + }, + { + "angle_deg": 0, + "r": 0.25, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.5, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.75, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 1.0, + "ratio": 2.5985985417919607e-111, + "ratio_unweighted": 1.4827757192573578e-111 + }, + { + "angle_deg": 0, + "r": 1.5, + "ratio": 1.3194538782436571e-21, + "ratio_unweighted": 1.0534944610784847e-21 + }, + { + "angle_deg": 0, + "r": 2.0, + "ratio": 6.182737019641913e-06, + "ratio_unweighted": 5.629688820303654e-06 + }, + { + "angle_deg": 0, + "r": 2.5, + "ratio": 0.0867578534241024, + "ratio_unweighted": 0.08418936160188543 + }, + { + "angle_deg": 0, + "r": 3.0, + "ratio": 0.9540155255017941, + "ratio_unweighted": 0.9473122778234625 + }, + { + "angle_deg": 0, + "r": 4.0, + "ratio": 0.9665701626350894, + "ratio_unweighted": 0.9664500332670383 + } + ], + "k=2.0,b=0.0": [ + { + "angle_deg": 90, + "r": 0.25, + "ratio": 0.03949098826069353, + "ratio_unweighted": 63.167468508308936 + }, + { + "angle_deg": 90, + "r": 0.5, + "ratio": 0.08718208578297146, + "ratio_unweighted": 9.494284065739738 + }, + { + "angle_deg": 90, + "r": 0.75, + "ratio": 0.14103832148529566, + "ratio_unweighted": 3.449574209574775 + }, + { + "angle_deg": 90, + "r": 1.0, + "ratio": 0.20815735875587277, + "ratio_unweighted": 1.8922929036340816 + }, + { + "angle_deg": 90, + "r": 1.5, + "ratio": 0.4032502250014552, + "ratio_unweighted": 1.0829668264222414 + }, + { + "angle_deg": 90, + "r": 2.0, + "ratio": 0.679673476492572, + "ratio_unweighted": 0.9536229801411701 + }, + { + "angle_deg": 90, + "r": 2.5, + "ratio": 0.9193080420260852, + "ratio_unweighted": 0.9692831834619947 + }, + { + "angle_deg": 90, + "r": 3.0, + "ratio": 1.0014637279244158, + "ratio_unweighted": 0.9923682660003456 + }, + { + "angle_deg": 90, + "r": 4.0, + "ratio": 1.0003721623791384, + "ratio_unweighted": 0.9999486896780728 + }, + { + "angle_deg": 60, + "r": 0.25, + "ratio": 0.00016732906439414897, + "ratio_unweighted": 0.14662230485353844 + }, + { + "angle_deg": 60, + "r": 0.5, + "ratio": 0.0005918351206295383, + "ratio_unweighted": 0.03335054250125826 + }, + { + "angle_deg": 60, + "r": 0.75, + "ratio": 0.002221732335366561, + "ratio_unweighted": 0.025452667008775 + }, + { + "angle_deg": 60, + "r": 1.0, + "ratio": 0.00960744574049454, + "ratio_unweighted": 0.03632812846000721 + }, + { + "angle_deg": 60, + "r": 1.5, + "ratio": 0.17901635780184436, + "ratio_unweighted": 0.17583476242158483 + }, + { + "angle_deg": 60, + "r": 2.0, + "ratio": 1.158012420890866, + "ratio_unweighted": 0.7164680145952175 + }, + { + "angle_deg": 60, + "r": 2.5, + "ratio": 1.5691459915220785, + "ratio_unweighted": 1.1329618380533737 + }, + { + "angle_deg": 60, + "r": 3.0, + "ratio": 1.1481044247123988, + "ratio_unweighted": 1.0800586200218618 + }, + { + "angle_deg": 60, + "r": 4.0, + "ratio": 1.00106205845638, + "ratio_unweighted": 1.0017199286426057 + }, + { + "angle_deg": 45, + "r": 0.25, + "ratio": 4.2570909047678823e-20, + "ratio_unweighted": 1.642768966479709e-17 + }, + { + "angle_deg": 45, + "r": 0.5, + "ratio": 5.561346329111716e-18, + "ratio_unweighted": 1.2691194196274534e-16 + }, + { + "angle_deg": 45, + "r": 0.75, + "ratio": 3.984888782378724e-15, + "ratio_unweighted": 1.638964582966069e-14 + }, + { + "angle_deg": 45, + "r": 1.0, + "ratio": 6.556049861834909e-12, + "ratio_unweighted": 8.581890439582216e-12 + }, + { + "angle_deg": 45, + "r": 1.5, + "ratio": 4.813208563721214e-06, + "ratio_unweighted": 1.9968526250581533e-06 + }, + { + "angle_deg": 45, + "r": 2.0, + "ratio": 0.019625063031415726, + "ratio_unweighted": 0.007070722554295678 + }, + { + "angle_deg": 45, + "r": 2.5, + "ratio": 0.5223976804884817, + "ratio_unweighted": 0.2975552981215637 + }, + { + "angle_deg": 45, + "r": 3.0, + "ratio": 1.077525956059638, + "ratio_unweighted": 0.9655804975762896 + }, + { + "angle_deg": 45, + "r": 4.0, + "ratio": 1.0089359047973059, + "ratio_unweighted": 1.0105835833727492 + }, + { + "angle_deg": 30, + "r": 0.25, + "ratio": 7.335763014588269e-104, + "ratio_unweighted": 6.0420474215884955e-102 + }, + { + "angle_deg": 30, + "r": 0.5, + "ratio": 9.997887663481414e-86, + "ratio_unweighted": 4.148878367567125e-85 + }, + { + "angle_deg": 30, + "r": 0.75, + "ratio": 2.5023253595985457e-64, + "ratio_unweighted": 1.865109135999556e-64 + }, + { + "angle_deg": 30, + "r": 1.0, + "ratio": 2.6037130967729112e-45, + "ratio_unweighted": 8.273491088006685e-46 + }, + { + "angle_deg": 30, + "r": 1.5, + "ratio": 4.626799481991789e-20, + "ratio_unweighted": 9.127822220680576e-21 + }, + { + "angle_deg": 30, + "r": 2.0, + "ratio": 4.8808936438602504e-08, + "ratio_unweighted": 1.4228092167559723e-08 + }, + { + "angle_deg": 30, + "r": 2.5, + "ratio": 0.006316243491195731, + "ratio_unweighted": 0.0036519722476297677 + }, + { + "angle_deg": 30, + "r": 3.0, + "ratio": 0.4766498380096713, + "ratio_unweighted": 0.42682383681747565 + }, + { + "angle_deg": 30, + "r": 4.0, + "ratio": 1.029474236829988, + "ratio_unweighted": 1.0309718604855411 + }, + { + "angle_deg": 0, + "r": 0.25, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.5, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.75, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 1.0, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 1.5, + "ratio": 1.0767500563459681e-91, + "ratio_unweighted": 9.551973310530084e-92 + }, + { + "angle_deg": 0, + "r": 2.0, + "ratio": 3.516860377720743e-26, + "ratio_unweighted": 3.40995954725731e-26 + }, + { + "angle_deg": 0, + "r": 2.5, + "ratio": 1.0658185903645112e-07, + "ratio_unweighted": 1.0572969080973156e-07 + }, + { + "angle_deg": 0, + "r": 3.0, + "ratio": 0.058115501006920825, + "ratio_unweighted": 0.057976880282225945 + }, + { + "angle_deg": 0, + "r": 4.0, + "ratio": 1.0652887847290435, + "ratio_unweighted": 1.065208213167798 + } + ], + "k=2.0,b=1.0": [ + { + "angle_deg": 90, + "r": 0.25, + "ratio": 0.04394824928347518, + "ratio_unweighted": 78.41598358314273 + }, + { + "angle_deg": 90, + "r": 0.5, + "ratio": 0.09570762094163085, + "ratio_unweighted": 11.582997312139376 + }, + { + "angle_deg": 90, + "r": 0.75, + "ratio": 0.15014313721319836, + "ratio_unweighted": 4.086005447774195 + }, + { + "angle_deg": 90, + "r": 1.0, + "ratio": 0.21308288180356627, + "ratio_unweighted": 2.1676986752618106 + }, + { + "angle_deg": 90, + "r": 1.5, + "ratio": 0.3798488219726348, + "ratio_unweighted": 1.1601785742194735 + }, + { + "angle_deg": 90, + "r": 2.0, + "ratio": 0.6140195790184907, + "ratio_unweighted": 0.9702662424165897 + }, + { + "angle_deg": 90, + "r": 2.5, + "ratio": 0.8581465414760016, + "ratio_unweighted": 0.962381280209413 + }, + { + "angle_deg": 90, + "r": 3.0, + "ratio": 0.9915281367848633, + "ratio_unweighted": 0.9839832295187693 + }, + { + "angle_deg": 90, + "r": 4.0, + "ratio": 1.006249568064324, + "ratio_unweighted": 0.9991348984748696 + }, + { + "angle_deg": 60, + "r": 0.25, + "ratio": 0.0001861888115879146, + "ratio_unweighted": 0.1835501651650323 + }, + { + "angle_deg": 60, + "r": 0.5, + "ratio": 0.000651748023199925, + "ratio_unweighted": 0.04229439355102498 + }, + { + "angle_deg": 60, + "r": 0.75, + "ratio": 0.0024380120723943265, + "ratio_unweighted": 0.033669785175212026 + }, + { + "angle_deg": 60, + "r": 1.0, + "ratio": 0.010567555681826659, + "ratio_unweighted": 0.05125928172435114 + }, + { + "angle_deg": 60, + "r": 1.5, + "ratio": 0.19778087028706948, + "ratio_unweighted": 0.27376163575799484 + }, + { + "angle_deg": 60, + "r": 2.0, + "ratio": 1.2287991777432359, + "ratio_unweighted": 1.0512695813737116 + }, + { + "angle_deg": 60, + "r": 2.5, + "ratio": 1.5095141927114166, + "ratio_unweighted": 1.3327758266218659 + }, + { + "angle_deg": 60, + "r": 3.0, + "ratio": 1.0811033695053884, + "ratio_unweighted": 1.0625036830807815 + }, + { + "angle_deg": 60, + "r": 4.0, + "ratio": 0.9899710136183282, + "ratio_unweighted": 0.9854229932803231 + }, + { + "angle_deg": 45, + "r": 0.25, + "ratio": 4.8270422463030845e-20, + "ratio_unweighted": 2.114903228591386e-17 + }, + { + "angle_deg": 45, + "r": 0.5, + "ratio": 6.6071609872701334e-18, + "ratio_unweighted": 1.8389431017192102e-16 + }, + { + "angle_deg": 45, + "r": 0.75, + "ratio": 5.213639227127308e-15, + "ratio_unweighted": 2.959200473746951e-14 + }, + { + "angle_deg": 45, + "r": 1.0, + "ratio": 9.74416632554946e-12, + "ratio_unweighted": 1.9256682680611072e-11 + }, + { + "angle_deg": 45, + "r": 1.5, + "ratio": 8.820647482689757e-06, + "ratio_unweighted": 5.688505918521638e-06 + }, + { + "angle_deg": 45, + "r": 2.0, + "ratio": 0.03730919648488384, + "ratio_unweighted": 0.019470572086655903 + }, + { + "angle_deg": 45, + "r": 2.5, + "ratio": 0.8702066369160758, + "ratio_unweighted": 0.6061938152535679 + }, + { + "angle_deg": 45, + "r": 3.0, + "ratio": 1.2787389934620534, + "ratio_unweighted": 1.2100650331311507 + }, + { + "angle_deg": 45, + "r": 4.0, + "ratio": 0.9737283703815497, + "ratio_unweighted": 0.9717355502009581 + }, + { + "angle_deg": 30, + "r": 0.25, + "ratio": 8.932323189309395e-104, + "ratio_unweighted": 9.39490263303482e-102 + }, + { + "angle_deg": 30, + "r": 0.5, + "ratio": 1.5604930503119474e-85, + "ratio_unweighted": 9.673036314668814e-85 + }, + { + "angle_deg": 30, + "r": 0.75, + "ratio": 5.739835217985818e-64, + "ratio_unweighted": 6.944798037637039e-64 + }, + { + "angle_deg": 30, + "r": 1.0, + "ratio": 8.967258562182673e-45, + "ratio_unweighted": 4.536310038439099e-45 + }, + { + "angle_deg": 30, + "r": 1.5, + "ratio": 1.9362101703412645e-19, + "ratio_unweighted": 6.033776429583763e-20 + }, + { + "angle_deg": 30, + "r": 2.0, + "ratio": 1.8989420935492606e-07, + "ratio_unweighted": 7.805839627019295e-08 + }, + { + "angle_deg": 30, + "r": 2.5, + "ratio": 0.018860296106058605, + "ratio_unweighted": 0.012611701203880152 + }, + { + "angle_deg": 30, + "r": 3.0, + "ratio": 0.8072069850735696, + "ratio_unweighted": 0.746540608247414 + }, + { + "angle_deg": 30, + "r": 4.0, + "ratio": 0.9672138168668959, + "ratio_unweighted": 0.9669356714213547 + }, + { + "angle_deg": 0, + "r": 0.25, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.5, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 0.75, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 1.0, + "ratio": 0.0, + "ratio_unweighted": 0.0 + }, + { + "angle_deg": 0, + "r": 1.5, + "ratio": 3.1486310598395164e-90, + "ratio_unweighted": 2.510132270642916e-90 + }, + { + "angle_deg": 0, + "r": 2.0, + "ratio": 4.294234307952424e-25, + "ratio_unweighted": 3.912279520890651e-25 + }, + { + "angle_deg": 0, + "r": 2.5, + "ratio": 5.736565377884086e-07, + "ratio_unweighted": 5.566094619286819e-07 + }, + { + "angle_deg": 0, + "r": 3.0, + "ratio": 0.1372999295177763, + "ratio_unweighted": 0.1362569068250281 + }, + { + "angle_deg": 0, + "r": 4.0, + "ratio": 0.9802351629287761, + "ratio_unweighted": 0.9800999972460147 + } + ] + }, + "remote_total": { + "k=0.5,b=0.0": { + "L=12": { + "integral_X_Lambda_approx": 15.633326557742928, + "k_integral": 7.816663278871464 + }, + "L=24": { + "integral_X_Lambda_approx": 65.78571259223075, + "k_integral": 32.892856296115376 + }, + "L=6": { + "integral_X_Lambda_approx": 3.09523004912097, + "integral_X_Lambda_periodized_direct": 3.05737526138796, + "k_integral": 1.547615024560485, + "k_integral_direct": 1.52868763069398 + } + }, + "k=0.5,b=1.0": { + "L=12": { + "integral_X_Lambda_approx": 11.465027432496477, + "k_integral": 5.7325137162482385 + }, + "L=24": { + "integral_X_Lambda_approx": 48.11199774431693, + "k_integral": 24.055998872158465 + }, + "L=6": { + "integral_X_Lambda_approx": 2.3032848545413636, + "integral_X_Lambda_periodized_direct": 2.2370039236173676, + "k_integral": 1.1516424272706818, + "k_integral_direct": 1.1185019618086838 + } + }, + "k=1.0,b=0.0": { + "L=12": { + "integral_X_Lambda_approx": 15.086314346932143, + "k_integral": 15.086314346932143 + }, + "L=24": { + "integral_X_Lambda_approx": 65.23870038141997, + "k_integral": 65.23870038141997 + }, + "L=6": { + "integral_X_Lambda_approx": 2.548217838310185, + "integral_X_Lambda_periodized_direct": 2.5421080540282226, + "k_integral": 2.548217838310185, + "k_integral_direct": 2.5421080540282226 + } + }, + "k=1.0,b=1.0": { + "L=12": { + "integral_X_Lambda_approx": 11.031174414731563, + "k_integral": 11.031174414731563 + }, + "L=24": { + "integral_X_Lambda_approx": 47.67814472655202, + "k_integral": 47.67814472655202 + }, + "L=6": { + "integral_X_Lambda_approx": 1.8694318367764495, + "integral_X_Lambda_periodized_direct": 1.812115296377527, + "k_integral": 1.8694318367764495, + "k_integral_direct": 1.812115296377527 + } + }, + "k=2.0,b=0.0": { + "L=12": { + "integral_X_Lambda_approx": 14.579259554184302, + "k_integral": 29.158519108368605 + }, + "L=24": { + "integral_X_Lambda_approx": 64.73164558867214, + "k_integral": 129.46329117734427 + }, + "L=6": { + "integral_X_Lambda_approx": 2.0411630455623455, + "integral_X_Lambda_periodized_direct": 2.1797649198343256, + "k_integral": 4.082326091124691, + "k_integral_direct": 4.359529839668651 + } + }, + "k=2.0,b=1.0": { + "L=12": { + "integral_X_Lambda_approx": 10.647517860179647, + "k_integral": 21.295035720359294 + }, + "L=24": { + "integral_X_Lambda_approx": 47.2944881720001, + "k_integral": 94.5889763440002 + }, + "L=6": { + "integral_X_Lambda_approx": 1.485775282224533, + "integral_X_Lambda_periodized_direct": 1.5301991395660177, + "k_integral": 2.971550564449066, + "k_integral_direct": 3.0603982791320354 + } + } + }, + "samples": { + "k=0.5,b=0.0": [ + { + "coupling": 0.0013347998737805087, + "exact_regression": false, + "lambda": 0.008997161568001377, + "lambda_j": [ + 4.2415324573566405e-08, + 0.008997119151863017, + 8.137870533623332e-13 + ], + "rho": 6.740457311041707, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.23734666626119014, + "exact_regression": false, + "lambda": 0.00018233592692150444, + "lambda_j": [ + 2.350450811356302e-08, + 0.00018231242241339087, + 5.797795764918883e-30 + ], + "rho": 0.0007682261975436862, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.24375768264096007, + "exact_regression": false, + "lambda": 0.05649474402271464, + "lambda_j": [ + 4.657359090868975e-07, + 0.00232023543617016, + 0.054174042850635394 + ], + "rho": 0.23176600388808216, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.2230783664356066, + "exact_regression": false, + "lambda": 7.191585763551508e-28, + "lambda_j": [ + 4.234550533129775e-29, + 6.76813071023853e-28, + 0.0 + ], + "rho": 5.879905949534375e-28, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.11000271594112836, + "exact_regression": false, + "lambda": 0.024165713454268295, + "lambda_j": [ + 1.473127222760222e-05, + 0.014912843942688724, + 0.009238138239351969 + ], + "rho": 0.21968288007726458, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.19403952034402, + "exact_regression": false, + "lambda": 0.13297957632490873, + "lambda_j": [ + 0.013682845859870138, + 0.11545464087023243, + 0.003842089594806162 + ], + "rho": 0.11136949326986714, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.4681640123522247, + "exact_regression": false, + "lambda": 0.00153584335767679, + "lambda_j": [ + 6.512390671793527e-12, + 0.0006691867856965605, + 0.0008666565654678388 + ], + "rho": 0.0032805668892834363, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 0.9998962653416301, + "exact_regression": false, + "lambda": 0.11609460083411186, + "lambda_j": [ + 0.013457536339208605, + 0.08979713535468875, + 0.0128399291402145 + ], + "rho": 0.11610664511727756, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=0.5,b=1.0": [ + { + "coupling": 0.0011816451638475367, + "exact_regression": false, + "lambda": 0.007251517701528527, + "lambda_j": [ + 9.71715596755084e-09, + 0.007251507982692201, + 1.6803582671529624e-12 + ], + "rho": 6.136798019734598, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.19563370398306065, + "exact_regression": false, + "lambda": 0.00017680783359851475, + "lambda_j": [ + 5.4381249056313444e-09, + 0.00017680239547360912, + 3.188833707371104e-28 + ], + "rho": 0.0009037698003909594, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.2955495656568713, + "exact_regression": false, + "lambda": 0.05666077867832258, + "lambda_j": [ + 2.6040919993732018e-08, + 0.0006166792130766919, + 0.056044073424325894 + ], + "rho": 0.19171328691480777, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.4030350487258436, + "exact_regression": false, + "lambda": 3.2150776495275335e-27, + "lambda_j": [ + 2.998040735279339e-29, + 3.18509724217474e-27, + 0.0 + ], + "rho": 2.291516275696237e-27, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.09829912442873572, + "exact_regression": false, + "lambda": 0.01807602324863991, + "lambda_j": [ + 2.0645229980440653e-06, + 0.007046349177726891, + 0.011027609547914976 + ], + "rho": 0.18388793749373172, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.1007428796012326, + "exact_regression": false, + "lambda": 0.10472518621398787, + "lambda_j": [ + 0.0019175197320715279, + 0.08891080744153346, + 0.013896859040382887 + ], + "rho": 0.0951404620958591, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.7434247320610644, + "exact_regression": false, + "lambda": 0.0009508748371417395, + "lambda_j": [ + 7.552120071379692e-14, + 0.0001544598011323832, + 0.0007964150359338351 + ], + "rho": 0.0012790465478671152, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.001767535376838, + "exact_regression": false, + "lambda": 0.08442985423318261, + "lambda_j": [ + 0.0008954886875238492, + 0.04295706909710692, + 0.04057729644855183 + ], + "rho": 0.08428088478772908, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=1.0,b=0.0": [ + { + "coupling": 0.0013337511324425409, + "exact_regression": false, + "lambda": 2.708085543210255e-06, + "lambda_j": [ + 1.4604817680949028e-11, + 2.708070938392574e-06, + 0.0 + ], + "rho": 0.0020304279241741686, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.2951302944859689, + "exact_regression": false, + "lambda": 1.1029419098839017e-17, + "lambda_j": [ + 6.013772842640704e-22, + 1.1028817721554752e-17, + 0.0 + ], + "rho": 3.7371355312910374e-17, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.2063740611469615, + "exact_regression": false, + "lambda": 0.008283690554448853, + "lambda_j": [ + 1.3952680692465282e-11, + 0.00019232007669658742, + 0.008091370463799584 + ], + "rho": 0.04013920406668711, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.1695512904330976, + "exact_regression": false, + "lambda": 2.035506651494308e-113, + "lambda_j": [ + 1.3955119259860762e-114, + 1.8959554588957005e-113, + 0.0 + ], + "rho": 1.7404167462724424e-113, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.11000271594112836, + "exact_regression": false, + "lambda": 0.024165713454268295, + "lambda_j": [ + 1.473127222760222e-05, + 0.014912843942688724, + 0.009238138239351969 + ], + "rho": 0.21968288007726458, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.3868030388781087, + "exact_regression": false, + "lambda": 0.1021044225602007, + "lambda_j": [ + 0.011196593733202694, + 0.09066957458517144, + 0.00023825424182657157 + ], + "rho": 0.07362575628821869, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.23360634059314445, + "exact_regression": false, + "lambda": 6.709121442309665e-11, + "lambda_j": [ + 2.289820976759197e-34, + 4.448649044698955e-11, + 2.260472397610711e-11 + ], + "rho": 2.8719774580067866e-10, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 0.9997652205926268, + "exact_regression": false, + "lambda": 0.11614711471938798, + "lambda_j": [ + 0.014005217085133914, + 0.0898231582784744, + 0.012318739355779663 + ], + "rho": 0.11617439007384145, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=1.0,b=1.0": [ + { + "coupling": 0.0011852745548398787, + "exact_regression": false, + "lambda": 2.214975518055656e-06, + "lambda_j": [ + 3.44759304165418e-12, + 2.2149720704626143e-06, + 0.0 + ], + "rho": 0.00186874467945942, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.2157902874249697, + "exact_regression": false, + "lambda": 1.1488932506278306e-17, + "lambda_j": [ + 1.4657489729406693e-22, + 1.1488785931381012e-17, + 0.0 + ], + "rho": 5.324119376908012e-17, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.264998801324006, + "exact_regression": false, + "lambda": 0.007270973301820235, + "lambda_j": [ + 3.2937305623954754e-13, + 5.0501558403101295e-05, + 0.007220471743087761 + ], + "rho": 0.02743775921057936, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.7525229932234514, + "exact_regression": false, + "lambda": 2.2044158243840257e-112, + "lambda_j": [ + 2.7203540887333047e-114, + 2.1772122834966927e-112, + 0.0 + ], + "rho": 1.2578527259887179e-112, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.09829912442873572, + "exact_regression": false, + "lambda": 0.01807602324863991, + "lambda_j": [ + 2.0645229980440653e-06, + 0.007046349177726891, + 0.011027609547914976 + ], + "rho": 0.18388793749373172, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.233509563363153, + "exact_regression": false, + "lambda": 0.10333970328413859, + "lambda_j": [ + 0.0021775455319044783, + 0.09971173114849526, + 0.0014504266037388557 + ], + "rho": 0.0837769777823074, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.4035709506744181, + "exact_regression": false, + "lambda": 2.054401073231451e-11, + "lambda_j": [ + 2.065375626345689e-37, + 7.034802327187759e-12, + 1.3509208405126751e-11 + ], + "rho": 5.09055735998413e-11, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0016758359521827, + "exact_regression": false, + "lambda": 0.08402207525361846, + "lambda_j": [ + 0.0009474385223607201, + 0.04357627221188679, + 0.03949836451937094 + ], + "rho": 0.08388150361413874, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=2.0,b=0.0": [ + { + "coupling": 0.0013069758683149615, + "exact_regression": false, + "lambda": 2.7687701498112533e-21, + "lambda_j": [ + 2.0689728873282906e-27, + 2.768768080838366e-21, + 0.0 + ], + "rho": 2.1184554488989396e-18, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.42372525112449744, + "exact_regression": false, + "lambda": 1.0855803610218994e-71, + "lambda_j": [ + 7.590387262964049e-77, + 1.0855727706346365e-71, + 0.0 + ], + "rho": 2.5619911915585558e-71, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.12211928031485988, + "exact_regression": false, + "lambda": 6.391010794773699e-07, + "lambda_j": [ + 4.1282539410900915e-28, + 2.297887135225486e-08, + 6.16122208125115e-07 + ], + "rho": 5.233416687599017e-06, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.0343154814073068, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "rho": 0.0, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.11000271594112836, + "exact_regression": false, + "lambda": 0.024165713454268295, + "lambda_j": [ + 1.473127222760222e-05, + 0.014912843942688724, + 0.009238138239351969 + ], + "rho": 0.21968288007726458, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.816012453345608, + "exact_regression": false, + "lambda": 0.008868968410056192, + "lambda_j": [ + 0.0006676160158203409, + 0.008201335920209833, + 1.6474026017517377e-08 + ], + "rho": 0.0048837596866238685, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.07127840244902967, + "exact_regression": false, + "lambda": 1.0069028958943768e-40, + "lambda_j": [ + 0.0, + 9.573733729955746e-41, + 4.9529522898802227e-42 + ], + "rho": 1.4126339273869123e-39, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 0.9995061393382996, + "exact_regression": false, + "lambda": 0.11638712556143374, + "lambda_j": [ + 0.015137558092887539, + 0.08993422886056755, + 0.011315338607978643 + ], + "rho": 0.11644463298493112, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=2.0,b=1.0": [ + { + "coupling": 0.0011789396796435185, + "exact_regression": false, + "lambda": 2.305551738891681e-21, + "lambda_j": [ + 4.92094898803099e-28, + 2.3055512467967824e-21, + 0.0 + ], + "rho": 1.95561467537408e-18, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.2755841295781233, + "exact_regression": false, + "lambda": 1.3475984017825205e-71, + "lambda_j": [ + 1.728779200220744e-77, + 1.3475966730033203e-71, + 0.0 + ], + "rho": 4.889971000309363e-71, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.19064731192523218, + "exact_regression": false, + "lambda": 4.90214103654052e-07, + "lambda_j": [ + 1.518151932771976e-30, + 5.837755725344078e-09, + 4.843763479287079e-07 + ], + "rho": 2.5713140075444837e-06, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 2.116297477517468, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "rho": 0.0, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.09829912442873572, + "exact_regression": false, + "lambda": 0.01807602324863991, + "lambda_j": [ + 2.0645229980440653e-06, + 0.007046349177726891, + 0.011027609547914976 + ], + "rho": 0.18388793749373172, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.5183055627578088, + "exact_regression": false, + "lambda": 0.014886605076929448, + "lambda_j": [ + 0.00020360615405411623, + 0.014682678974993781, + 3.199478815492129e-07 + ], + "rho": 0.009804749084821783, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.11575239500763133, + "exact_regression": false, + "lambda": 8.915112493385315e-42, + "lambda_j": [ + 0.0, + 7.416143163304738e-42, + 1.498969330080577e-42 + ], + "rho": 7.701881669746495e-41, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0014773803550947, + "exact_regression": false, + "lambda": 0.08329489101993598, + "lambda_j": [ + 0.001058099161553433, + 0.04487664547022176, + 0.03736014638816079 + ], + "rho": 0.08317201431988613, + "x": [ + 3.0, + 3.0 + ] + } + ] + }, + "samples_L6": { + "k=0.5,b=0.0": [ + { + "coupling": 0.0013352824240637966, + "exact_regression": false, + "lambda": 0.009000458710387486, + "lambda_j": [ + 4.2306984383691987e-08, + 0.009000416402587327, + 8.157752556274416e-13 + ], + "rho": 6.740490661889716, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.23828883959155878, + "exact_regression": false, + "lambda": 0.00018360006218508273, + "lambda_j": [ + 2.3185747996361956e-08, + 0.00018357687643708636, + 5.882423599731411e-30 + ], + "rho": 0.0007704937524551472, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.24369855908021865, + "exact_regression": false, + "lambda": 0.056506252857895, + "lambda_j": [ + 4.6640243479299636e-07, + 0.00232896825849067, + 0.05417681819696953 + ], + "rho": 0.2318694581993599, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.2278071654062748, + "exact_regression": false, + "lambda": 2.9186863777201024e-28, + "lambda_j": [ + 1.6794127477699003e-29, + 2.7507451029431125e-28, + 0.0 + ], + "rho": 2.377153725727219e-28, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.11054671577748665, + "exact_regression": false, + "lambda": 0.024316509096193283, + "lambda_j": [ + 1.424340757853108e-05, + 0.014996244633544539, + 0.009306021055070212 + ], + "rho": 0.21996591147165903, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.2066509791591224, + "exact_regression": false, + "lambda": 0.13729091478291414, + "lambda_j": [ + 0.01240788965173346, + 0.12061984887428272, + 0.004263176256897967 + ], + "rho": 0.11377848040084294, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.4435417129792033, + "exact_regression": false, + "lambda": 0.001413255392795007, + "lambda_j": [ + 1.0111578076382077e-11, + 0.0006701512942514966, + 0.0007431040884319325 + ], + "rho": 0.00318629646646396, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0001972162649189, + "exact_regression": false, + "lambda": 0.11602557357983916, + "lambda_j": [ + 0.012257478688314472, + 0.08970529163487585, + 0.014062803256648828 + ], + "rho": 0.11600269596142108, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=0.5,b=1.0": [ + { + "coupling": 0.001181777453979063, + "exact_regression": false, + "lambda": 0.007252705334252905, + "lambda_j": [ + 9.692273907215493e-09, + 0.0072526956402956, + 1.6833971027511652e-12 + ], + "rho": 6.137116010999305, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.19587390235746285, + "exact_regression": false, + "lambda": 0.00017761227458904948, + "lambda_j": [ + 5.357070546704964e-09, + 0.00017760691751850276, + 3.2232421450633133e-28 + ], + "rho": 0.0009067684487385839, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.29549203647987987, + "exact_regression": false, + "lambda": 0.0566461168393173, + "lambda_j": [ + 2.6161531879238826e-08, + 0.0006193258690924373, + 0.05602676480869298 + ], + "rho": 0.19170099307625288, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.4231372656895669, + "exact_regression": false, + "lambda": 1.2779946840452322e-27, + "lambda_j": [ + 1.1840042361501762e-29, + 1.2661546416837304e-27, + 0.0 + ], + "rho": 8.980122401797921e-28, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.09856225043773235, + "exact_regression": false, + "lambda": 0.01814230158049604, + "lambda_j": [ + 1.9970455389237825e-06, + 0.007066609584309618, + 0.011073694950647497 + ], + "rho": 0.1840694738596458, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.104252762369017, + "exact_regression": false, + "lambda": 0.10688106855213715, + "lambda_j": [ + 0.001727574250233007, + 0.09046756368139389, + 0.014685930620510258 + ], + "rho": 0.09679040179427673, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.7076776514081772, + "exact_regression": false, + "lambda": 0.0008630881288807054, + "lambda_j": [ + 1.3586344542963722e-13, + 0.00016318327434602738, + 0.0006999048543988146 + ], + "rho": 0.0012196063096853258, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0073726033434194, + "exact_regression": false, + "lambda": 0.08493677408620448, + "lambda_j": [ + 0.0008311352652289752, + 0.042166570197293356, + 0.04193906862368216 + ], + "rho": 0.08431515191529289, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=1.0,b=0.0": [ + { + "coupling": 0.0013346653987268507, + "exact_regression": false, + "lambda": 2.7096374629029337e-06, + "lambda_j": [ + 1.4528029858479458e-11, + 2.7096229348730752e-06, + 0.0 + ], + "rho": 0.0020301998279776195, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.29700058556465986, + "exact_regression": false, + "lambda": 1.1224234501461141e-17, + "lambda_j": [ + 5.869835540393228e-22, + 1.1223647517907103e-17, + 0.0 + ], + "rho": 3.7791960847893744e-17, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.20602145962604412, + "exact_regression": false, + "lambda": 0.008286196731516017, + "lambda_j": [ + 1.4107912183428742e-11, + 0.0001938945806034658, + 0.00809230213680464 + ], + "rho": 0.04022006613561785, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.1145285416418684, + "exact_regression": false, + "lambda": 4.796156151334233e-115, + "lambda_j": [ + 3.491234360034664e-116, + 4.447032715330766e-115, + 0.0 + ], + "rho": 4.303304915160604e-115, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.11054671577748665, + "exact_regression": false, + "lambda": 0.024316509096193283, + "lambda_j": [ + 1.424340757853108e-05, + 0.014996244633544539, + 0.009306021055070212 + ], + "rho": 0.21996591147165903, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.414037603028991, + "exact_regression": false, + "lambda": 0.1116583148390832, + "lambda_j": [ + 0.009070560605905392, + 0.10230031726174406, + 0.0002874369714337601 + ], + "rho": 0.07896417648293186, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.2177802312560826, + "exact_regression": false, + "lambda": 5.294051833956493e-11, + "lambda_j": [ + 7.856603250461557e-34, + 3.8847550943225116e-11, + 1.4092967396339818e-11 + ], + "rho": 2.4309147820360903e-10, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0001972162649189, + "exact_regression": false, + "lambda": 0.11590191030699754, + "lambda_j": [ + 0.012244414327720382, + 0.08960968124819547, + 0.014047814731081675 + ], + "rho": 0.11587905707217942, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=1.0,b=1.0": [ + { + "coupling": 0.0011855929356505506, + "exact_regression": false, + "lambda": 2.2156227847456665e-06, + "lambda_j": [ + 3.4290254943549784e-12, + 2.215619355720172e-06, + 0.0 + ], + "rho": 0.0018687887875528917, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.21630344038881227, + "exact_regression": false, + "lambda": 1.1652644981125905e-17, + "lambda_j": [ + 1.4257677518976314e-22, + 1.1652502404350715e-17, + 0.0 + ], + "rho": 5.3871750537947553e-17, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.26476259311553274, + "exact_regression": false, + "lambda": 0.00727251711119097, + "lambda_j": [ + 3.3495790775069134e-13, + 5.09435894807879e-05, + 0.007221573521375224 + ], + "rho": 0.027468068754023377, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.699359404154547, + "exact_regression": false, + "lambda": 5.8285767920378104e-114, + "lambda_j": [ + 6.686761788141136e-116, + 5.761709174156399e-114, + 0.0 + ], + "rho": 3.42986702976914e-114, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.09856225043773234, + "exact_regression": false, + "lambda": 0.018142301580496036, + "lambda_j": [ + 1.997045538923783e-06, + 0.0070666095843096195, + 0.011073694950647493 + ], + "rho": 0.1840694738596458, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.237598543087511, + "exact_regression": false, + "lambda": 0.11009257812876756, + "lambda_j": [ + 0.0016800326027014813, + 0.10679208649254338, + 0.001620459033522697 + ], + "rho": 0.08895661581348747, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.3607760112777661, + "exact_regression": false, + "lambda": 1.5649021496961578e-11, + "lambda_j": [ + 9.14055499222709e-37, + 6.678811120839875e-12, + 8.9702103761217e-12 + ], + "rho": 4.337600341424362e-11, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0073726033434194, + "exact_regression": false, + "lambda": 0.08484624611772276, + "lambda_j": [ + 0.0008302494182221377, + 0.04212162789781388, + 0.04189436880168675 + ], + "rho": 0.08422528648895386, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=2.0,b=0.0": [ + { + "coupling": 0.0013087088541291223, + "exact_regression": false, + "lambda": 2.770827325716849e-21, + "lambda_j": [ + 2.040492545407624e-27, + 2.7708252852243036e-21, + 0.0 + ], + "rho": 2.1172221132107264e-18, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.4270255732457859, + "exact_regression": false, + "lambda": 1.1406499594754295e-71, + "lambda_j": [ + 7.287322006820608e-77, + 1.1406426721534227e-71, + 0.0 + ], + "rho": 2.6711514038970643e-71, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.12154691248048743, + "exact_regression": false, + "lambda": 6.414145299649067e-07, + "lambda_j": [ + 4.335134871489145e-28, + 2.3381563279984918e-08, + 6.180329666849217e-07 + ], + "rho": 5.2770943899366945e-06, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 1.143036879287172, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "rho": 0.0, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.11054671577748668, + "exact_regression": false, + "lambda": 0.024316509096193283, + "lambda_j": [ + 1.424340757853108e-05, + 0.014996244633544539, + 0.009306021055070213 + ], + "rho": 0.219965911471659, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.858239085671107, + "exact_regression": false, + "lambda": 0.011073370879390183, + "lambda_j": [ + 0.00042139591016260617, + 0.010651951837810168, + 2.3131417408239805e-08 + ], + "rho": 0.005959066820183158, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.06862920990335121, + "exact_regression": false, + "lambda": 4.112392145922974e-41, + "lambda_j": [ + 0.0, + 4.0154910617416267e-41, + 9.690108418134735e-43 + ], + "rho": 5.992189261269877e-40, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0001972162649189, + "exact_regression": false, + "lambda": 0.11540857384902328, + "lambda_j": [ + 0.012192295980590412, + 0.08922825765793635, + 0.013988020210496522 + ], + "rho": 0.11538581788899459, + "x": [ + 3.0, + 3.0 + ] + } + ], + "k=2.0,b=1.0": [ + { + "coupling": 0.0011796385056819928, + "exact_regression": false, + "lambda": 2.3062342006097484e-21, + "lambda_j": [ + 4.8518119079949185e-28, + 2.3062337154285575e-21, + 0.0 + ], + "rho": 1.9550346902896567e-18, + "x": [ + 0.15, + 0.15 + ] + }, + { + "coupling": 0.27705045059401257, + "exact_regression": false, + "lambda": 1.4099034696462865e-71, + "lambda_j": [ + 1.6575456530324585e-77, + 1.4099018121006334e-71, + 0.0 + ], + "rho": 5.088977356374516e-71, + "x": [ + 0.5, + 0.3 + ] + }, + { + "coupling": 0.19007815996869268, + "exact_regression": false, + "lambda": 4.921308289368182e-07, + "lambda_j": [ + 1.6121784583640165e-30, + 5.948415402692936e-09, + 4.861824135341253e-07 + ], + "rho": 2.5890971851678063e-06, + "x": [ + -0.7, + 0.9 + ] + }, + { + "coupling": 2.205333914985709, + "exact_regression": false, + "lambda": 0.0, + "lambda_j": [ + 0.0, + 0.0, + 0.0 + ], + "rho": 0.0, + "x": [ + 1.0, + 0.0 + ] + }, + { + "coupling": 0.09856225043773235, + "exact_regression": false, + "lambda": 0.018142301580496036, + "lambda_j": [ + 1.997045538923782e-06, + 0.0070666095843096195, + 0.011073694950647493 + ], + "rho": 0.18406947385964578, + "x": [ + 0.0, + 1.0 + ] + }, + { + "coupling": 1.5240623570669611, + "exact_regression": false, + "lambda": 0.017487120040612404, + "lambda_j": [ + 0.00011220989025799633, + 0.01737451371364244, + 3.964367119647877e-07 + ], + "rho": 0.011474018736520828, + "x": [ + 2.0, + 1.5 + ] + }, + { + "coupling": 0.10867076432649085, + "exact_regression": false, + "lambda": 3.8652937000428516e-42, + "lambda_j": [ + 0.0, + 3.523859666847038e-42, + 3.4143403319581346e-43 + ], + "rho": 3.5568846174946813e-41, + "x": [ + -1.5, + 0.5 + ] + }, + { + "coupling": 1.0073726033434194, + "exact_regression": false, + "lambda": 0.08448509808814106, + "lambda_j": [ + 0.0008267154617400056, + 0.04194233719711555, + 0.04171604542928551 + ], + "rho": 0.08386678157390745, + "x": [ + 3.0, + 3.0 + ] + } + ] + }, + "scientific_effect": "NONE", + "torus": { + "k=0.5,b=0.0": { + "L=6": { + "grid": { + "L": 6.0, + "h": 0.15, + "points": 800, + "symmetry": "z -> -z" + }, + "integral": 3.05737526138796, + "integral_j": [ + 0.14802044636245085, + 2.3613765842445558, + 0.5479782307809531 + ] + } + }, + "k=0.5,b=1.0": { + "L=6": { + "grid": { + "L": 6.0, + "h": 0.15, + "points": 800, + "symmetry": "z -> -z" + }, + "integral": 2.2370039236173676, + "integral_j": [ + 0.015459566977056707, + 1.2312386408044722, + 0.9903057158358384 + ] + } + }, + "k=1.0,b=0.0": { + "L=6": { + "grid": { + "L": 6.0, + "h": 0.15, + "points": 800, + "symmetry": "z -> -z" + }, + "integral": 2.5421080540282226, + "integral_j": [ + 0.11682239256821302, + 1.9842331762729237, + 0.44105248518708556 + ] + } + }, + "k=1.0,b=1.0": { + "L=6": { + "grid": { + "L": 6.0, + "h": 0.15, + "points": 800, + "symmetry": "z -> -z" + }, + "integral": 1.812115296377527, + "integral_j": [ + 0.011577600011742996, + 1.03069716079891, + 0.7698405355668743 + ] + } + }, + "k=2.0,b=0.0": { + "L=6": { + "grid": { + "L": 6.0, + "h": 0.15, + "points": 800, + "symmetry": "z -> -z" + }, + "integral": 2.1797649198343256, + "integral_j": [ + 0.09916048767576933, + 1.702501518928095, + 0.3781029132304612 + ] + } + }, + "k=2.0,b=1.0": { + "L=6": { + "grid": { + "L": 6.0, + "h": 0.15, + "points": 800, + "symmetry": "z -> -z" + }, + "integral": 1.5301991395660177, + "integral_j": [ + 0.010491088476728362, + 0.9104572979768156, + 0.6092507531124737 + ] + } + } + } +} diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json new file mode 100644 index 000000000..0ebf7c919 --- /dev/null +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -0,0 +1,39 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "certified": false, + "review_status": "AUTHOR_SIDE_NUMERICAL_NOTE", + "object": "CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1", + "files": [ + { + "path": "NOTE.md", + "bytes": 15376, + "sha256": "96085e36a13978e816bf36eec601e5eb4f12925fc22bb0430b3e23d3b28455be", + "git_blob": "c834258ffaa80219aa424ac8e4276a757c8a5c8a" + }, + { + "path": "README.md", + "bytes": 1479, + "sha256": "64c524bf9143182ad3d76296eaa0bc824cccbdd1e63f8159ce41b6b0632bfcb1", + "git_blob": "3822b393a6cbfd10f6119cbffa6321c923727dde" + }, + { + "path": "RESULTS.json", + "bytes": 103175, + "sha256": "e26cc99abce33f212713efa09b3c396831dcc7a8878cb8895207cb182eecb466", + "git_blob": "04f5b9fc458e261ed2999ed7f3fc97b98abc3506" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 3890, + "sha256": "eaee7e5ea2d3c5743a949d1aaef49d59a5ad1174b073aa22ce0756a398e42a40", + "git_blob": "1366afcec4b337e517578bde2b9e2d045c5eaead" + }, + { + "path": "remote.py", + "bytes": 33854, + "sha256": "21c46498c538b809dfa0888ad0f041e776d1320df3c990003d9fff432e423ae4", + "git_blob": "b4021f8c592e6c14b655d1add21c1469a96ed702" + } + ] +} diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py index 9bfdd36d7..b4021f8c5 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py +++ b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py @@ -435,6 +435,24 @@ def lambda_far(b, rules): return {'lambda_j': lam, 'lambda': sum(lam), 'rho_j': [p * W['F'][j] for j in range(3)], 'E_F_j': W['F']} +def far_field_closed_form(b): + """Exact far field. With h1 = a + c, h3 = a - c, a ~ N(-b, 1), c ~ N(0, 1), h2 ~ N(0, 1) independent: + det H = a^2 - rho^2, rho^2 ~ Exp(mean 2). E[(rho^2 - a^2)_+ | a] = 2 exp(-a^2/2), E[(a^2 - rho^2)_+ | a] = + a^2 - 2 + 2 exp(-a^2/2), and E[exp(-a^2/2) 1{a < 0}] = exp(-b^2/4) Phi(b/sqrt2)/sqrt2. Hence + E F_1 = sqrt2 e^(-b^2/4) (saddles) + E F_2 = (b^2+1) Phi(b) + b phi(b) - 2 Phi(b) + sqrt2 e^(-b^2/4) Phi(b/sqrt2) (maxima, a < 0) + E F_0 = the same with b -> -b (minima) + E|det H_b| = b^2 - 1 + 2 sqrt2 e^(-b^2/4), + and Lambda_inf,j(b) = phi(b) E F_j / (2 pi). At b = 0: Lambda_inf = (2 sqrt2 - 1)/(2 pi)^(3/2). Integrating + Lambda_inf over b gives 2/(pi sqrt3), the total critical density (Longuet-Higgins).""" + e = math.exp(-b * b / 4) + F1 = math.sqrt(2) * e + F2 = (b * b + 1) * Phi(b) + b * phi(b) - 2 * Phi(b) + math.sqrt(2) * e * Phi(b / math.sqrt(2)) + F0 = (b * b + 1) * Phi(-b) - b * phi(b) - 2 * Phi(-b) + math.sqrt(2) * e * Phi(-b / math.sqrt(2)) + p = phi(b) / (2 * math.pi) + return {'lambda': p * (b * b - 1 + 2 * math.sqrt(2) * e), 'lambda_j': [p * F0, p * F1, p * F2], 'E_absdet': b * b - 1 + 2 * math.sqrt(2) * e} + + def unconditional_hessian_controls(rules): """H unconditional: Var f_xx = Var f_zz = 3, Cov = 1, Var f_xz = 1. With h1 = a + c, h3 = a - c (a ~ N(0, 2), c ~ N(0, 1) independent) det H = a^2 - (c^2 + h2^2) = a^2 - rho^2 with rho^2 ~ Exp(mean 2), @@ -678,6 +696,10 @@ def check_run(): for b in (0.0, 1.0): far = lambda_far(b, rules) require(abs(far['lambda'] - ref['far_field'][str(b)]['lambda_inf']) < 1e-10, 'far-field replay b = %r' % b) + closed = far_field_closed_form(b) + require(abs(far['lambda'] - closed['lambda']) < 1e-10 and max(abs(far['lambda_j'][j] - closed['lambda_j'][j]) for j in range(3)) < 1e-10, + 'far field equals its closed form, b = %r' % b) + require(abs(ref['far_field']['0.0']['lambda_inf'] - (2 * math.sqrt(2) - 1) / (2 * math.pi) ** 1.5) < 1e-10, 'Lambda_inf(0) = (2 sqrt2 - 1)/(2 pi)^(3/2)') for key, k in (('k=1.0,b=0.0', 1.0), ('k=0.5,b=1.0', 0.5)): b = 0.0 if key.endswith('0.0') else 1.0 rows = sample_table(b, k, rules) From 7f7003178ac72588925851bb6cedb9ca3506e90d Mon Sep 17 00:00:00 2001 From: d6g8k5htny-coder Date: Wed, 30 Sep 2026 02:36:05 +0000 Subject: [PATCH 05/13] Remote coefficient numerics: pin the merged companion note (Math-#168 RESULTS.json on main 02772ec) as [NUM] Metadata only: SOURCE_MAP.json gains the fifth main-resident pin, NOTE.md names it, SOURCE_FILES.json regenerated; remote.py and RESULTS.json unchanged. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../NOTE.md | 2 +- .../SOURCE_FILES.json | 12 +++++----- .../SOURCE_MAP.json | 23 +++++++++++-------- 3 files changed, 20 insertions(+), 17 deletions(-) diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index c834258ff..445c880ae 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -127,7 +127,7 @@ profiles at angles `0, 30, 45, 60, 90` degrees are in `RESULTS.json`, `ray_profi axis and at `30` degrees it is below `10^(-20)`). **Remote singleton mass** `R(k, b, L) = k integral_X Lambda dx` and the assembled `nu(1)`, with `alpha_1` from the -companion note (Math-#168, GH60 values; `alpha_2` likewise): +companion note ([NUM] = Math-#168 `RESULTS.json`, merged, pinned; GH60 values; `alpha_2` likewise): | `k` | `b` | `L` | `integral_X Lambda` | `R = k integral_X Lambda` | `alpha_1` (#168) | `nu(1) = alpha_1 + R` | `nu(2) = alpha_2` | `nu(2)/nu(1)` | |---|---|---|---|---|---|---|---|---| diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json index 0ebf7c919..390af691e 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 15376, - "sha256": "96085e36a13978e816bf36eec601e5eb4f12925fc22bb0430b3e23d3b28455be", - "git_blob": "c834258ffaa80219aa424ac8e4276a757c8a5c8a" + "bytes": 15415, + "sha256": "15e4779d79c03f8f578e16dc866d839d9a742f7eec37d5571b89f72de66730b8", + "git_blob": "445c880aed15a193ce0db8043ef28dba2a1420bf" }, { "path": "README.md", @@ -25,9 +25,9 @@ }, { "path": "SOURCE_MAP.json", - "bytes": 3890, - "sha256": "eaee7e5ea2d3c5743a949d1aaef49d59a5ad1174b073aa22ce0756a398e42a40", - "git_blob": "1366afcec4b337e517578bde2b9e2d045c5eaead" + "bytes": 4268, + "sha256": "1d98c67e3bdf6df7fe2b32689924f6d548757f41a671e8b833bfdd0dbcb44471", + "git_blob": "ba9924e142bf3569476b621a56a5711bd10fb0d3" }, { "path": "remote.py", diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json index 1366afcec..ba9924e14 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json @@ -4,7 +4,7 @@ "scientific_effect": "NONE", "source_repository": "d6g8k5htny-coder/Math-", "main_at_creation": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", - "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures.", + "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures. The companion near-coefficient note (Math-#168) merged to main on 30 September 2026 (02772ec) and is now pinned as [NUM].", "sources": [ { "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", @@ -49,17 +49,20 @@ "role": "Corollary E: Q_r^W{N_j(E) >= 1} = k r^3 integral_E Lambda_j + O(r^4 |E|) on fixed remote regions, the probability reading of the same kernel (context only)", "current_required": true, "on_main": true + }, + { + "path": "frontiers/c6_cluster_coefficients_numerics_20260930/RESULTS.json", + "bytes": 4095, + "sha256": "9c88ea85b6ba08199996c9b5ff74ecd06afc0f458e08c28b4c3af6191f437fcb", + "git_blob": "2648314f8c11f0637ce301ba76360142a8309e8f", + "id": "NUM", + "commit": "02772ec0427f4dda1f2a6b9e980a031804e276a6", + "role": "near coefficients alpha_1(k, b) (GH60) and alpha_2(k, b) quoted in NOTE.md section 4 to assemble nu(1) = alpha_1 + k integral_X Lambda; Math-#168, merged to main on 30 September 2026 (02772ec) with RESULTS.json bytes unchanged from the quoted head 0b35e76; xAI read 5360559751 accepted its Slices A and B as identities", + "current_required": true, + "on_main": true } ], - "companion": { - "path": "frontiers/c6_cluster_coefficients_numerics_20260930/RESULTS.json", - "pull_request": "Math-#168", - "head": "0b35e76ff05676e6ad5c89171d65807668c8de15", - "role": "near coefficients alpha_1(k, b), alpha_2(k, b) quoted in NOTE.md section 5 to assemble nu(1) = alpha_1 + k integral_X Lambda; unmerged at this writing, hence not a current_required pin and not checked by the workflow", - "current_required": false, - "on_main": false - }, "nonauthor_acceptance": false, "governing_status_changed": false, - "main_at_update": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d" + "main_at_update": "02772ec0427f4dda1f2a6b9e980a031804e276a6" } From 71772a8906cf6663d16be2cd5f63e5d4ebdcee2b Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 21:41:23 -0500 Subject: [PATCH 06/13] Add microscopic radial-rate expansion and sharp signed/unsigned metric asymptotics OpenAI author-side conditional consumer of the exact PR166 limiting point measure. Smooth fixed-domain reciprocal cutoff proves all-even tail expansion, explicit t^-13 correction, unsigned Pareto/height O(t^-2), signed latent joint Theta(t^-1), critical-moment finite part, and positive second coefficient for aligned planar exact periodic covariance. No original finite-r rate, spatial TV, whole-cluster tie rate or global status change. Fresh local40 tests per Python mode and8 semantic mutants per mode pass, all12 remote packet blobs and tree independently match. Actual historical source verification and nonauthor analytic review remain hosted obligations; no self-merge. --- .github/workflows/radial-rate.yml | 38 ++ frontiers/radial_rate_20260930/MANIFEST.json | 73 ++++ frontiers/radial_rate_20260930/PLAN.md | 29 ++ frontiers/radial_rate_20260930/PROOF.md | 334 ++++++++++++++++++ frontiers/radial_rate_20260930/README.md | 61 ++++ .../radial_rate_20260930/RECONNAISSANCE.md | 33 ++ frontiers/radial_rate_20260930/RESULTS.json | 21 ++ frontiers/radial_rate_20260930/SOURCES.json | 33 ++ frontiers/radial_rate_20260930/VALIDATION.md | 45 +++ frontiers/radial_rate_20260930/rate.py | 170 +++++++++ frontiers/radial_rate_20260930/test_rate.py | 137 +++++++ frontiers/radial_rate_20260930/test_verify.py | 102 ++++++ frontiers/radial_rate_20260930/verify.py | 104 ++++++ 13 files changed, 1180 insertions(+) create mode 100644 .github/workflows/radial-rate.yml create mode 100644 frontiers/radial_rate_20260930/MANIFEST.json create mode 100644 frontiers/radial_rate_20260930/PLAN.md create mode 100644 frontiers/radial_rate_20260930/PROOF.md create mode 100644 frontiers/radial_rate_20260930/README.md create mode 100644 frontiers/radial_rate_20260930/RECONNAISSANCE.md create mode 100644 frontiers/radial_rate_20260930/RESULTS.json create mode 100644 frontiers/radial_rate_20260930/SOURCES.json create mode 100644 frontiers/radial_rate_20260930/VALIDATION.md create mode 100644 frontiers/radial_rate_20260930/rate.py create mode 100644 frontiers/radial_rate_20260930/test_rate.py create mode 100644 frontiers/radial_rate_20260930/test_verify.py create mode 100644 frontiers/radial_rate_20260930/verify.py diff --git a/.github/workflows/radial-rate.yml b/.github/workflows/radial-rate.yml new file mode 100644 index 000000000..fa1a9abe5 --- /dev/null +++ b/.github/workflows/radial-rate.yml @@ -0,0 +1,38 @@ +name: Microscopic radial-rate checks + +'on': + pull_request: + paths: + - 'frontiers/radial_rate_20260930/**' + - '.github/workflows/radial-rate.yml' + 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 public source objects + run: | + set -euo pipefail + git fetch --no-tags origin 80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337 + git fetch --no-tags origin 382c0f9ff2281f43651ddbdf2e9b36dd52e2c6bf + git fetch --no-tags origin 7a1cb09a9d58d179393e6d29146252f714b9c9bf + - name: Verify sources, packet and both Python modes + env: + PYTHONDONTWRITEBYTECODE: '1' + GIT_NO_REPLACE_OBJECTS: '1' + run: | + set -euo pipefail + python -B -S frontiers/radial_rate_20260930/verify.py + git diff --exit-code diff --git a/frontiers/radial_rate_20260930/MANIFEST.json b/frontiers/radial_rate_20260930/MANIFEST.json new file mode 100644 index 000000000..b06df6fa3 --- /dev/null +++ b/frontiers/radial_rate_20260930/MANIFEST.json @@ -0,0 +1,73 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW_OPEN", + "files": [ + { + "path": "PLAN.md", + "bytes": 1772, + "sha256": "3a436b2f58a3b79bcb5471474d94fff7c07f5f4dce838525fed117cbb5d446db", + "git_blob": "db61274a4ce7f2e9e6c4b75303a285230f44d5db" + }, + { + "path": "PROOF.md", + "bytes": 15755, + "sha256": "a3693664900e23e1e763d88a0b5609936a6f31d844cbe6f18c7d0379b94ba710", + "git_blob": "65f24b1f9a7b80522a2ee059f5f6877c9f970f0d" + }, + { + "path": "README.md", + "bytes": 3186, + "sha256": "b31b309916639ce111f28f4c81fea061a62ac777c6a9f241185bcfd0f59655b8", + "git_blob": "cc0e2f5a45c76aa60a3782002321f0c47d0f3b17" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 2002, + "sha256": "54118b87d9a0dbe78ed9f2162ad413d1a9bfc1c1122c53855274b300751ede2b", + "git_blob": "3eb935b8d3fa2c10e8220c71c5243488beb25e31" + }, + { + "path": "RESULTS.json", + "bytes": 438, + "sha256": "c9cdb842befa92b8e26eb02831a1d20838cc75465f1db7840eba1c0eb1c70b4f", + "git_blob": "c7494046e449f30a6346572b2760cca6c1c62afb" + }, + { + "path": "SOURCES.json", + "bytes": 1396, + "sha256": "22b3064a278faff1d915dfb658e9d7e41ec5c4ee69f31e944d47a699a82f8a07", + "git_blob": "37f3dc7b5583bf2f4f0a8d1bb1fd5bd39ff12838" + }, + { + "path": "VALIDATION.md", + "bytes": 2898, + "sha256": "b14b2fb0576c7c7fd1a03baf3d7f479d901f186d0ef0a49dac5156805908409d", + "git_blob": "5a4a11b112723aaf9a67c1aeaafa3a216e5f17e8" + }, + { + "path": "rate.py", + "bytes": 6344, + "sha256": "e96be67c1703780dcd48113fa55809d98b87f0e498da132b162c9640d300577e", + "git_blob": "d213a2762e10a07f3290f9ae1b4dd9f8f73e5667" + }, + { + "path": "test_rate.py", + "bytes": 7286, + "sha256": "f2a096b91de1978dbaa6c1301ac1013d454cadcf96aa705fb66df3c43f53324f", + "git_blob": "4074549e593ad0f02f6931c6df211e25a02d84ea" + }, + { + "path": "test_verify.py", + "bytes": 5792, + "sha256": "1e8f2790b5861b520463ab1d44b87c29dd43ba46b652c46992889ecd001bd4c7", + "git_blob": "258288f8efa9039782432daf6dde77e2b594ef39" + }, + { + "path": "verify.py", + "bytes": 5169, + "sha256": "7f7006a1f3ba74964a00023dd418624612980e19f8e40a3506245ae43966119c", + "git_blob": "d5789cbe7b94b6243b55a62491ecd19bdeb9cbe0" + } + ] +} diff --git a/frontiers/radial_rate_20260930/PLAN.md b/frontiers/radial_rate_20260930/PLAN.md new file mode 100644 index 000000000..db61274a4 --- /dev/null +++ b/frontiers/radial_rate_20260930/PLAN.md @@ -0,0 +1,29 @@ +# Inverse-radius expansion: execution plan + +Goal: derive quantitative radius-tail and mark-law results from the exact R11 +integral of the already-formed limiting microscopic POINT intensity. The original +Gaussian-field limit r->0 is taken first. No whole-cluster maximum or finite-r +rate is to be inferred. + +Design: reciprocal radius z=1/Z makes the physical cutoff an interval with +explicit endpoints. Map it to [-1,1], prove a smooth even integrated function of +1/t using Gaussian derivative domination, and compute its first two coefficients. +Deduce radial and fixed latent-mark total-variation rates, keeping the sign- +retaining law separate. Preserve the complete original anisotropic covariance, +Haar factors and full normalizer. No original source or peer branch is edited. + +Execution: isolated new runtime directory and new additive GitHub branch. +Dylan's repeated autonomy instruction authorizes foreground work; no timers or +background agents are restarted. No subagent tool is available here. + +1. Read source R11-R13, exact Gaussian/spectral interface and current peer claims. +2. Write and observe failing tests for exact shape integrals and endpoint series. +3. Implement standard-library rational controls; test both signs and parity. +4. Write complete domination and coefficient proof, plus all scope exclusions. +5. Verify exact historical source identities, packet inventory and both Python + modes; include hostile Git fixtures and semantic mutants. +6. Publish a new source-bound candidate and request nonauthor analytic review. + +Separate supporting task: bounded nonauthor review of PR173 Route C; accept the +conditional count implication and repair its inadmissible fixed-R substitution +by a diagonal argument. No graph execution or parent revalidation. diff --git a/frontiers/radial_rate_20260930/PROOF.md b/frontiers/radial_rate_20260930/PROOF.md new file mode 100644 index 000000000..65f24b1f9 --- /dev/null +++ b/frontiers/radial_rate_20260930/PROOF.md @@ -0,0 +1,334 @@ +# Smooth inverse-radius expansion and sharp rates for microscopic extreme marks + +Object: OA-RADIAL-RATE-20260930-v1. Author: OpenAI / GPT-6 Astra Pro. +Disposition: AUTHOR-SIDE CONDITIONAL PROOF CANDIDATE; NONAUTHOR REVIEW OPEN. +Scientific effect NONE. No parent proof, register, Boolean, prize, or earlier +review is changed. This conversation authored SC/P and contributed to the +related cluster line; no independent revalidation of those premises is implied. + +## 1. Exact object and scope + +Fix d>=2, L>0, b real, k>0 and an orthonormal frame, under the original model +and full endpoint normalizer. This paper concerns the ALREADY-FORMED limiting +microscopic POINT intensity of [R]. First the original field radius r tends to +zero; only then does the microscopic distance threshold t tend to infinity. +No finite-r convergence rate is proved. Whole-cluster maximum selection and +its moving tie boundaries are not consumed or treated here. + +Exact source identities are in SOURCES.json. [R] is PR166 RADIAL_TAIL.md at +80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337, blob0f14417ef7038b9c6f50e4b01e393a58b7b5e3a4: +R7-R13 supply the root-resolved integral, Gaussian domination and positive leading +coefficient. [SC] is PR162 PROOF.md at382c0f9ff2281f43651ddbdf2e9b36dd52e2c6bf, +blob16c56821b52fd76b0be791622b9c3809eafde75a: the nondegenerate raw Gaussian contact +jet, orthogonal spectral convention and finite nonempty microscopic measure. +[P] is imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md at +7a1cb09a9d58d179393e6d29146252f714b9c9bf, blobdfed3b8d318a3ab1950957f393307733a4bef3f2: +only the exact periodized covariance and contact conditioning, used in Section7. +Neither PR169's whole-cluster candidate, its companion-ratio addendum, nor any +numerical coefficient note is a premise. Source reviews are not reviews here. + +Use [R]'s variables lambda=(a,h,O,xi), with ordered positive hard curvatures h, +normalized Haar O, and remaining cubic entries xi. Put + + A=a/(12k), gamma=sqrt(1+A^2), + beta0=a^2/(12k), c0=a^3/(144k^2), + A0=O diag(0,-h) O^T, + H(h)=product h_j^3 product_(i0 on S. + +For y=1/Z define + + g_lambda,u,v(y)=G_lambda(beta0+k b0 y^2, + c0+(a b0/4)y^2+2k(v-b0u)y^3). (2) + +[R, R11] says exactly that the tail F(t)=integral sum_i 1{|z_i|>t}dM is + + F(t)=K0 integral_(S,lambda) Q H + integral_R |Z|^-12 g(1/Z) + 1{(u-AZ)^2+Z^2>t^2}dZ du dv d lambda. (3) + +The multiplicity of roots is already correct in this formula. No extra factor +for a double cluster, pin density, or endpoint normalizer is introduced. + +## 2. A fixed-domain smooth even representation + +**Theorem 1.** There is a smooth even function C(delta), defined for +|delta|<2/3 and with every fixed derivative bounded on |delta|<=1/3, such that + + F(t)=t^-11 C(1/t), t>=3. (4) + +Smoothness also holds in L1 for the underlying UNSIGNED shape/parameter measures. +The claim is C-infinity, not analyticity or convergence of an infinite Taylor +series. Consequently for every fixed N>=0 there are finite coefficients C_(2j) +with + + F(t)=sum_(j=0..N) C_(2j) t^(-11-2j)+O_N(t^(-13-2N)), + -F'(t)=sum_(j=0..N)(11+2j)C_(2j)t^(-12-2j) + +O_N(t^(-14-2N)). (5) + +C_(0)>0 is [R]'s C_star. Constants are at the fixed source parameters; no growing +dimension, volume, vanishing-gap, or parameter-uniform claim is made. + +**Proof.** The reciprocal substitution in (3) gives |Z|^-12 dZ=|y|^10 dy on +both signs. For t>|u| the physical radius condition is + + (t^2-u^2)y^2+2uAy-gamma^2<0. + +Set delta=1/t and y=delta w. Its two endpoints in w are + + w_plus/minus(delta)=m(delta) +/- d(delta), + m(delta)=-uA delta/(1-u^2 delta^2), + d(delta)=sqrt(gamma^2-u^2 delta^2)/(1-u^2 delta^2). (6) + +Thus (4) holds with + + J_delta(u,v,lambda)=d(delta) integral_(-1)^1 + [m(delta)+d(delta)x]^10 + g(delta[m(delta)+d(delta)x]) dx, + C(delta)=K0 integral Q H J_delta du dv d lambda. (7) + +There is no moving integration boundary left. On |delta|<=delta0<2/3 the +denominator is uniformly positive and the square-root radicand is bounded +below by a positive constant, since |u|<=3/2 and gamma>=1. Each fixed derivative +of m,d is bounded by a polynomial in1+|a| with constants depending on delta0,k. + +For every fixed j the nondegenerate Gaussian contact density satisfies + + sup_(beta,c) |partial_(beta,c)^j G_lambda(beta,c)| + <= C_j exp[-c_j(|h|^2+a^2+|xi|^2)] (8) + +uniformly in O. Indeed each derivative is a polynomial times the same Gaussian; +absorb that polynomial into a weaker Gaussian exponent and then discard beta,c +from its quadratic lower bound. A bounded mean changes the constants only. +Uniform tensor norm equivalence under O supplies the displayed retained variables. +No inverse hard eigenvalue is used. This is an elementary derivative extension +of [R]'s raw Gaussian bound, not an extra stochastic assumption. + +The chain rule in (7), for any fixed number of delta derivatives, now gives an +integrable majorant of the form + + C Q H (1+|a|)^M exp[-c(|h|^2+a^2+|xi|^2)], (9) + +on the bounded shape domain and x in[-1,1]. The actual shifted beta,c values +may be large: (8) is a supremum over them, not an invalid compactness assumption. +This proves differentiation under all integrals and smoothness in L1 as well +as for the total mass. The exact identities m(-delta)=-m(delta), +d(-delta)=d(delta), followed by x->-x, show J_(-delta)=J_delta. This cancellation +holds even when g(y) is not even; its cubic y^3 term is retained. + +Taylor's theorem with the integrated derivative bounds proves (5), including +its differentiated remainder. It is NOT obtained by formally differentiating +an unspecified big-O estimate. C(0) is the positive source coefficient. QED. + +## 3. Explicit second coefficient + +Write C_0=C_(0), C_2=C_(2), to distinguish coefficients from their tail powers11,13. +Set the differential operator acting on G_lambda at fixed a,h,O,xi + + D_a=k partial_beta+(a/4)partial_c. + +The pointwise density has expansion g(y)=G0+g2 y^2+g3 y^3+O(y^4), with + + g2=b0 D_a G0. (10) + +There is no linear y term. Expanding the exact endpoints, or differentiating +(7), gives + + j0=(2/11)gamma^11 G0, + j2=u^2 gamma^9(1+12A^2)G0+(2/13)b0 gamma^13 D_a G0, + J_delta=j0+j2 delta^2+O_L1(delta^4). (11) + +For the geometric part, write w_+=gamma-uA delta+ +[u^2 gamma-u^2/(2gamma)]delta^2+O(delta^3), with the corresponding reflected +negative endpoint. Then (w_+^11-w_-^11)/11 equals +2gamma^11/11+u^2 gamma^9(1+12A^2)delta^2+O(delta^4). +The g2 term contributes2g2 gamma^13 delta^2/13. The odd g3 term first contributes +at order delta^4 after the two physical sides are summed; it is not dropped +from the all-order argument. + +The necessary exact shape integrals are + + I=integral_S Q=246528/35, + U2=integral_S u^2 Q=240192/35, + B=integral_S b0 Q=-428544/7=3I-12U2, + Uabs=integral_S |u|Q=5898627/880. (12) + +They follow by integrating the polynomial Q in v and then on the strips cut +at u=-1/2 and u=0. The companion computes them in exact Fraction arithmetic. +In particular + + C_0=K0*(2I/11) integral H gamma^11 G0 d lambda, + C_2=K0 integral H [U2 gamma^9(1+12A^2)G0 + +(2B/13)gamma^13 D_a G0]d lambda. (13) + +Both integrals are finite by (8). C_0>0. No general sign or nonzero assertion +for C_2 is made in arbitrary dimension/frame; Section7 supplies an exact +noncancellation result at a narrower source scope. No numerical evaluation of +either Gaussian integral is claimed. + +## 4. Rates for the radial ratio and unsigned marks + +Let P_t be point-INTENSITY sampling conditioned on physical radius R>t. Define +q=R/t>=1 and retain Y=(u,v,lambda), but FORGET sign Z. These are the root-resolved +latent coordinates of [R], not a configuration-uniform selection. Define the +finite measures with densities + + dmu0=K0 Q H j0 dY, dmu2=K0 Q H j2 dY, + c=C_2/C_0. (14) + +mu0 has mass C_0 and mu2 mass C_2. The joint law of (q,Y) has the L1 expansion + + dP_t(q,Y)=11q^-12 dq dmu0(Y)/C_0 + +t^-2 [13q^-14 dq dmu2(Y)/C_0 + -11c q^-12 dq dmu0(Y)/C_0]+O_L1(t^-4). (15) + +In particular its total-variation distance to the stated independent limiting +product is O(t^-2). Projection to Y, or to the downward height +eta=u+1/2+v/6, retains this rate. This supplies an O(t^-2) TV rate for the +intensity-selected height law H_eta/I in [R, H1-H2]. No spatial-configuration +TV claim is made: the map to actual positions depends on t. + +Proof: for fixed Y, the radius tail density is t^-11 K0 QH J_(1/t). +Differentiate the smooth expression already justified in Section2; at tq its +radial density times t equals + +t^-11 K0 QH q^-12[11J_(1/(tq))+(1/(tq))J'_(1/(tq))]. + +Divide by F(t)=t^-11 C(1/t) and use the L1 Taylor estimates. The remainder is +bounded after integration by a constant times t^-4 q^-12, integrable on q>=1. +This proves (15) without differentiating a merely pointwise asymptotic. QED. + +Let Pareto_11 have density11q^-12 on q>=1. For the scalar radial ratio, (15) gives + + p_t(q)=11q^-12[1+c t^-2((13/11)q^-2-1)]+O_L1(t^-4). + +**Sharp scalar coefficient:** + + dTV(Law_(P_t)(R/t),Pareto_11) + =kappa |c| t^-2+O(t^-4), + kappa=(2/13)(11/13)^(11/2). (16) + +The same leading coefficient holds for the supremum distance of their CDFs. +The correction changes sign only at q0=sqrt(13/11). Its positive integral is +q0^-11-q0^-13=kappa; its total integral is zero. Half its L1 norm is therefore +kappa, proving (16). The uniform CDF remainder follows from the L1 remainder; +the maximum of q^-11(1-q^-2) is also kappa. If C_2=0 the stated error is O(t^-4), +not an unjustified claim of a nonzero second-order term. + +As another quantitative consequence, uniformly over q>=1, + + F(tq)/F(t)=q^-11[1+c t^-2(q^-2-1)]+O(t^-4 q^-11). (17) + +This is a source-specific second-order regular-variation statement. Generic +second-order tail theory is not claimed novel. + +## 5. Retaining the sign has a different, strictly slower sharp rate + +The cancellation in Section2 used both signs. Keep epsilon=sign Z and the +same Y. The two half integrals are exactly + + J_delta,epsilon=integral_0^(d+epsilon m) w^10 g(epsilon delta w)dw, + J_delta,epsilon=j0/2+epsilon h1 delta+O_L1(delta^2), + h1=-uA gamma^10 G0. (18) + +The linear term comes from the physical cutoff shift m. g'(0)=0, so no density +term cancels it. Applying the differentiated density argument to each half yields + + dTV(Law_(P_t)(epsilon,R/t,Y), + UniformSign x Pareto_11 x mu0/C_0) + =B_sign t^-1+O(t^-2), + B_sign=(K0/C_0) Uabs integral H |A|gamma^10 G0 d lambda>0. (19) + +Indeed the first signed correction has density +12 epsilon h1 q^-13 K0 QH/C_0; its half-L1 norm, summed over the two signs and +integrated over q, is the displayed B_sign because integral_1^infinity12q^-13dq=1. +Finiteness follows from (8); strict positivity follows from the full positive +Gaussian density on open sets with a!=0 and positive hard spectrum. The gauge +convention for O is exactly that in [R]; (19) is a result for those retained +latent variables, not a statement that a sign alone has a nonzero marginal bias. +Marginalizing can cancel a correction, and specifically forgetting epsilon +cancels this one. Thus signed and unsigned rates must not be conflated. + +## 6. A finite part for the critical eleventh moment + +Let M11(t)=integral sum_i min(R_i,t)^11 dM. The prior theorem gave its leading +logarithm. There is now a finite constant L11 such that + + M11(t)=11 C_0 log t+L11-(11/2)C_2 t^-2+O(t^-4). (20) + +One exact definition is + + L11=11 integral_0^1 x^10 F(x)dx + +11 integral_1^infinity[x^10 F(x)-C_0/x]dx. + +The first integral is finite by finite total point mass. The second converges +by (5) at N=1. Tonelli gives M11(t)=11 integral_0^t x^10 F(x)dx; subtracting +its limiting finite part and integrating the controlled remainder proves (20). +No numerical value for L11 is asserted. This is again after the r limit only. + +## 7. Exact positive second correction in the aligned planar periodic model + +**Theorem 2.** In d=2, with the axial coordinate aligned with one of the lattice +axes of [P]'s EXACT periodized kernel, C_2>0 for every fixed L,k>0 and b real. +Consequently the radial TV and CDF errors in (16) are genuinely Theta(t^-2), +with the positive coefficient in (16); not merely an upper bound. + +Proof: [P]'s kernel factors as K_L(x,z)=k_L(x)k_L(z). Let m2,m4,m6 be the even +spectral moments of the one-dimensional variance-one factor; m2>0 and the full +positive lattice spectrum gives m4-m2^2>0 and m6-m4^2/m2>0. At contact condition +on (f,fx,fxx,fxxx,fz,fxz)=(b,0,0,12k,0,0). + +Even-total-order jets and odd-total-order jets are independent. For the odd +soft cubic jets (a,beta,c)=(fxxz,fxzz,fzzz), separability and reflection in each +axis give a centered DIAGONAL conditional Gaussian with variances + + va=vbeta=m2(m4-m2^2), vc=m6-m4^2/m2. (21) + +For transparency: Cov(beta,(fx,fxxx))=(-m2^2,m2 m4) is -m2 times the first row +of Cov(fx,fxxx), so its conditional mean is -m2 fx=0 even though fxxx=12k. +a and c correlate only with fz in that odd conditioning block, with covariances +-m2^2 and -m4; their raw covariance m2 m4 is removed by that regression. Their +conditional covariance with beta vanishes by coordinate reflection. The diagonal +variances follow by subtracting these rank-one regressions. The even soft +curvature has its own strictly positive conditional density at zero and merely +multiplies this cubic Gaussian by a positive b-dependent scalar. + +Therefore on the cusp + + D_a G0=-[a^2/(12vbeta)+a^4/(576k^2 vc)]G0<=0. (22) + +In (13), U2>0, B<0 and G0>0. The geometric term is strictly positive and the +second term is nonnegative. Thus C_2>0, without replacing finite L by a continuum +covariance or numerically approximating a lattice sum. The same common even +b-dependent factor cancels from c=C_2/C_0 and B_sign at this planar aligned +scope. We do not extend this diagonal regression or noncancellation assertion +to arbitrary rotations or d>=3 without a separate argument. QED. + +## 8. Verification and review boundary + +A: reciprocal physical cutoff, fixed-domain map, C-infinity L1 Gaussian derivative +domination, exact parity and differentiated all-order asymptotic expansion. +B: j0/j2 coefficients, all four exact shape integrals, signed/unsigned TV and CDF +constants, finite-part moment, and aligned planar regression/noncancellation. + +The stdlib companion checks shape integrals, formal endpoint equations, exact +Taylor coefficients, cancellation and signed bias, independent scalar controls +and deliberately false variants. These are finite checks, not a formal proof +of any Gaussian input or differentiation under an infinite-dimensional integral. +No Lean formalization, global status change, coefficient enclosure or self-merge. + +No rate for r->0, no uniform simultaneous t(r)->infinity statement, no claim +about the remote singleton population, no convergence rate for whole-cluster +maximum selectors across ties, and no spatial independence/elder pairing is +added by this packet. Sign-forgetting is part of (15), not an optional omission. diff --git a/frontiers/radial_rate_20260930/README.md b/frontiers/radial_rate_20260930/README.md new file mode 100644 index 000000000..cc0e2f5a4 --- /dev/null +++ b/frontiers/radial_rate_20260930/README.md @@ -0,0 +1,61 @@ +# Microscopic radial rates and an even inverse-radius expansion + +OpenAI / GPT-6 Astra Pro. Source-bound conditional candidate; nonauthor review +OPEN. Scientific effect NONE. No self-merge or parent/status/graph modification. + +The earlier point-intensity result F(t)~C0 t^-11 is sharpened here to a smooth +even expansion in delta=1/t, with controlled derivatives to every fixed order. +The original field limit r->0 is taken FIRST. This is not a rate for that limit. + +Main manuscript PROOF.md: +- F(t)=C0 t^-11+C2 t^-13+O(t^-15), with an explicit finite Gaussian-derivative + formula for C2 and all-even fixed-order extensions. +- The radial ratio's Pareto(11) TV error has coefficient + (2/13)(11/13)^(11/2)|C2/C0| t^-2+O(t^-4). +- The unsigned shape/parameter/radial joint law has an L1 second-order expansion; + its height marginal consequently converges in TV at O(t^-2). +- RETAINING sign Z gives a strictly positive first-order joint TV coefficient, + Bsign t^-1+O(t^-2). Forgetting sign cancels that term. +- The capped eleventh moment has a finite renormalized limit and an explicit + t^-2 correction, not merely a leading logarithm. +- For the exact aligned PLANAR periodized kernel, Gaussian separability proves + C2>0 at every fixed L,k>0 and b real. Thus the radial error is genuinely + Theta(t^-2) at that narrower scope. No isotropic replacement is used. + +No numerical Gaussian coefficient, finite-r spatial moment/rate, simultaneous +radius limit, whole-cluster maximum rate, spatial TV convergence or independence +between pin pairs is asserted. All-rate statements concern the root-resolved +POINT measure. The parent whole-cluster and elder-geometry lanes are untouched. + +## Replay + +From a full checkout with the three pinned historical source objects: + + python -B -S frontiers/radial_rate_20260930/verify.py + +Standalone download: + + python -B -S verify.py --local-only + +The latter reports source_pins_checked=false. Real local Git fixtures test +custody behavior, not the actual project sources. The full workflow verifies +all source identities and the flat packet before replaying both Python modes, +deterministic results and eight semantic negative controls. No third-party +Python library is required by the shipped scripts. + +Forty local tests passed in each normal/optimized mode at author validation. +They include exact shape integrals, endpoint identities, signed/unsigned formal +series, a high-precision scalar diagnostic, planar Gaussian Schur complements, +and real Git replacement/noncommit/path/inventory attacks. Tests do not prove +the Gaussian domination, differentiation, or the new probability limits. + +## Review requests + +A: Sections2-3, exact physical-cutoff inversion, fixed-domain representation, +C-infinity L1 domination, parity, derivatives and explicit second coefficient. +B: Sections4-7, normalized joint/radial TV rates, signed first-order bias, finite +critical-moment part and exact planar regression/noncancellation. + +The author is exposed to SC/P and related source packets. New reviews must state +that exposure and bind the exact mathematical bytes; existing source verdicts +or green workflows are not automatic acceptance of these new deductions. diff --git a/frontiers/radial_rate_20260930/RECONNAISSANCE.md b/frontiers/radial_rate_20260930/RECONNAISSANCE.md new file mode 100644 index 000000000..3eb935b8d --- /dev/null +++ b/frontiers/radial_rate_20260930/RECONNAISSANCE.md @@ -0,0 +1,33 @@ +# Narrow primary-source reconnaissance — 30 September 2026 UTC + +Exact searches actually executed: +1. second order regular variation Pareto approximation total variation Hall class tail expansion paper +2. site.arxiv.org Palm theory extremes anchored tail processes Planinic 2104.03810 + +Primary records consulted: +- Hrvoje Planinic, Palm theory for extremes of stationary regularly varying time + series and random fields, arXiv:2104.03810v2 (14 March2023). + https://arxiv.org/abs/2104.03810 + Direct abstract/metadata open succeeded. It distinguishes typical exceedances + from typical clusters; no generic sampling/Palm principle is claimed new here. +- Second-order regular variation, convolution and the central limit theorem, + Stochastic Processes and their Applications69(2),139-159(1997), + DOI10.1016/S0304-4149(97)00042-2. + https://www.sciencedirect.com/science/article/pii/S0304414997000422 + The search response supplied the abstract describing second-order tail theory. + Direct open returned403. No full-text/theorem-level audit is claimed. +- L. de Haan and L. Peng, Rates of Convergence for Bivariate Extremes, + Journal of Multivariate Analysis61(2),195-230(1997), DOI10.1006/jmva.1997.1669. + https://doi.org/10.1006/jmva.1997.1669 + Search abstract states rates in total variation and uniform metrics under a + second-order regular-variation condition. Direct open returned403. + +This new packet derives its particular inverse-radius expansion from exact +GitHub source R11, not by importing an unchecked second-order tail theorem. +Generic second-order regular variation and metric convergence rates are prior +frameworks. No exhaustive novelty, priority, or absence claim is made. + +Consensus was not invoked in this pass: the user requested GitHub/Superpowers, +and prior actual repeated attempts had returned the quota error. No changed +quota status is asserted. All external access depth above is limited to the +actual returned abstracts/metadata. No PDF or full paper was inspected. diff --git a/frontiers/radial_rate_20260930/RESULTS.json b/frontiers/radial_rate_20260930/RESULTS.json new file mode 100644 index 000000000..c7494046e --- /dev/null +++ b/frontiers/radial_rate_20260930/RESULTS.json @@ -0,0 +1,21 @@ +{ + "mathematical_acceptance": false, + "passed": true, + "scientific_effect": "NONE", + "scope": "finite rational coefficient and parity controls only", + "series_cases": 12, + "shape_integrals": { + "ABS_U": "5898627/880", + "B": "-428544/7", + "I": "246528/35", + "U2": "240192/35" + }, + "signed_joint_rate": 1, + "tail_exponents": [ + 11, + 13, + 15 + ], + "tv_crossing_squared": "13/11", + "unsigned_radial_rate": 2 +} diff --git a/frontiers/radial_rate_20260930/SOURCES.json b/frontiers/radial_rate_20260930/SOURCES.json new file mode 100644 index 000000000..37f3dc7b5 --- /dev/null +++ b/frontiers/radial_rate_20260930/SOURCES.json @@ -0,0 +1,33 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "sources": [ + { + "id": "R", + "commit": "80059a97cd8eb32d1a17a0ad9cb22cb2a0d7b337", + "path": "frontiers/two_scale_cluster_geometry_20260929/RADIAL_TAIL.md", + "bytes": 12533, + "sha256": "250897858c8b314c0ff85ec1860a725efacfdae0ff7409fced4cadf7bfb85973", + "git_blob": "0f14417ef7038b9c6f50e4b01e393a58b7b5e3a4", + "use": "R7-R13 exact point-intensity integral/majorant; H1-H2 limiting height law." + }, + { + "id": "SC", + "commit": "382c0f9ff2281f43651ddbdf2e9b36dd52e2c6bf", + "path": "frontiers/spectral_cluster_closure_20260929/PROOF.md", + "bytes": 25006, + "sha256": "e971b2cbe50a8a06b47c1219191201e0d1037c9adac23e5e3b7d2051bb70c2eb", + "git_blob": "16c56821b52fd76b0be791622b9c3809eafde75a", + "use": "Raw nondegenerate contact Gaussian, orthogonal spectral conventions, finite microscopic measure. Author exposure." + }, + { + "id": "P", + "commit": "7a1cb09a9d58d179393e6d29146252f714b9c9bf", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "use": "Exact product-periodized covariance and contact pin vector; no new parent acceptance." + } + ] +} diff --git a/frontiers/radial_rate_20260930/VALIDATION.md b/frontiers/radial_rate_20260930/VALIDATION.md new file mode 100644 index 000000000..5a4a11b11 --- /dev/null +++ b/frontiers/radial_rate_20260930/VALIDATION.md @@ -0,0 +1,45 @@ +# Author validation and limits + +The initial eight-test mathematics scaffold returned seven failing assertions +(the zero odd-series test already passed on the zero scaffold). After exact +implementation all eight passed. Expanded mathematics tests total21. + +The nineteen-test custody scaffold returned25 failing assertions including +subtests. The implemented verifier passed all19. It rejects changed identities, +missing/duplicate/unexpected source IDs, unsafe or missing paths, noncommit tree +and tag objects, Git symlinks, replacement refs, and altered packet inventories. +The replacement fixture verifies that ordinary Git reads really see the forged +bytes before confirming that the protected verifier still authenticates only +the actual original source. This is a test fixture, not observed source tampering. + +Complete local result:40 tests PASS in each normal and optimized Python mode; +12 exact formal-series parameter cases; eight explicit semantic mutants rejected +with rc1 in each mode; unknown mutant rc2; deterministic baseline equal to +RESULTS.json. The source/packet verifier checks its inventory before and after +execution. No temporary output is placed in the packet during replay. + +Exact controls cover all four shape integrals, formal physical-cutoff equations, +odd-term cancellation, the signed first-order term, the density multiplier13, +the TV crossing at sqrt(13/11), and exact planar Schur regressions. A Decimal +scalar diagnostic checks the constant-density endpoint remainder at three +thresholds; it is a finite diagnostic, not a Gaussian coefficient enclosure. +Exploratory SymPy integration reproduced the shape constants, but SymPy is not +a shipped dependency or a substitute for the analytic derivation. + +Local runtime Python3.13.5, Git2.47.3. The workflow requests Python3.11.16, as in +the actual upstream workflows. All shipped syntax uses standard-library3.11 +features. The local raw.githubusercontent.com request failed with DNS resolution +error, so no complete upstream checkout was obtained. Local-only replay states +source_pins_checked=false. The real three-source authentication remains a +HOSTED requirement, not inferred from local Git fixtures or manifest strings. +No hosted pass is anticipated in this author-time record. + +The full Gaussian derivative domination and L1 smoothness are written analytic +obligations. There is no Lean formalization of this new packet. No numerical +value of C0,C2,Bsign or the critical-moment finite part is evaluated. The retained +sign and the order r->0 before t->infinity are load-bearing qualifications. + +Peer support actually delivered: native review5360751376 accepts PR173 §3 Route C +at its conditional count-estimate scope and requests an explicit diagonal repair +of the alternate fixed-R/moving-cutoff reading. It does not authorize graph +execution or count as an independent review of this conversation's source proofs. diff --git a/frontiers/radial_rate_20260930/rate.py b/frontiers/radial_rate_20260930/rate.py new file mode 100644 index 000000000..d213a2762 --- /dev/null +++ b/frontiers/radial_rate_20260930/rate.py @@ -0,0 +1,170 @@ +"""Exact finite controls for the inverse-radius asymptotic candidate. + +Standard library only. Series calculations are formal algebra, not authentication +of Gaussian premises or a proof of domination/total-variation convergence. +""" +import argparse +from fractions import Fraction as F +import json +from math import comb + +MUTANTS=('omit-shift','omit-density-term','drop-a-shear','odd-term-survives', + 'unsigned-is-signed','wrong-b-integral','wrong-density-factor','wrong-tv-root') + + +def rational(x): + if type(x) not in (int,F): raise TypeError('exact int/Fraction required') + return F(x) + + +def add(a,b): + out=dict(a) + for i,x in b.items():out[i]=out.get(i,F(0))+x + return {i:x for i,x in out.items() if x} + + +def scale(a,c): return {i:x*c for i,x in a.items() if x*c} + + +def mul(a,b): + out={} + for i,x in a.items(): + for j,y in b.items():out[i+j]=out.get(i+j,F(0))+x*y + return {i:x for i,x in out.items() if x} + + +def power(a,n): + out={0:F(1)} + for _ in range(n):out=mul(out,a) + return out + + +def integral(a,lo,hi): + return sum((x*(hi**(i+1)-lo**(i+1))/F(i+1) for i,x in a.items()),F(0)) + + +def shape_integrals(): + b={0:F(3),2:F(-12)};u={1:F(1)};hi={0:F(3),1:F(-6)} + # Q=(4v^2-b^2)(b-4uv); dictionary index is v power. + Q={3:scale(u,-16),2:scale(b,4),1:scale(mul(u,power(b,2)),4),0:scale(power(b,3),-1)} + ans={key:F(0) for key in ('I','U2','B','ABS_U')} + for lo_u,hi_u,sgn_b,sgn_u in ((F(-3,2),F(-1,2),-1,-1),(F(-1,2),F(0),1,-1),(F(0),F(1,2),1,1)): + low=scale(b,F(sgn_b,2));vint={} + for j,c in Q.items(): + difference=add(power(hi,j+1),scale(power(low,j+1),-1)) + vint=add(vint,scale(mul(c,difference),F(1,j+1))) + for key,weight in [('I',{0:F(1)}),('U2',{2:F(1)}),('B',b),('ABS_U',{1:F(sgn_u)})]: + ans[key]+=integral(mul(vint,weight),lo_u,hi_u) + return ans + + +def smul(a,b,n): + out=[F(0)]*(n+1) + for i,x in enumerate(a[:n+1]): + for j,y in enumerate(b[:n+1-i]):out[i+j]+=x*y + return out + + +def spow(a,m,n): + out=[F(1)]+[F(0)]*n + for _ in range(m):out=smul(out,a,n) + return out + + +def endpoints(u,A,g,n): + u,A,g=map(rational,(u,A,g)) + if type(n) is not int or not 0<=n<=12: raise ValueError('series order 0..12 required') + if g<=0 or g*g!=1+A*A: raise ValueError('positive exact gamma^2=1+A^2 required') + inv=[F(0)]*(n+1);root=[F(0)]*(n+1) + binom=F(1) + for j in range(n//2+1): + inv[2*j]=u**(2*j) + if j:binom*= (F(1,2)-(j-1))/j + root[2*j]=g*binom*(-u*u/(g*g))**j + d=smul(inv,root,n) + m=[F(0)]+[-u*A*x for x in inv[:n]] + plus=[x+y for x,y in zip(m,d)];minus=[x-y for x,y in zip(m,d)] + return plus,minus + + +def validate_phi(phi,n): + if not isinstance(phi,dict) or any(type(j) is not int or j<0 for j in phi): + raise ValueError('nonnegative polynomial orders required') + return {j:rational(x) for j,x in phi.items() if j<=n} + + +def tail_series(u,A,g,phi,n): + plus,minus=endpoints(u,A,g,n);phi=validate_phi(phi,n) + out=[F(0)]*(n+1) + for j,c in phi.items(): + p=spow(plus,11+j,n-j);m=spow(minus,11+j,n-j) + for i in range(n-j+1):out[i+j]+=c*(p[i]-m[i])/F(11+j) + return out + + +def half_series(u,A,g,phi,n,sign): + if type(sign) is not int or sign not in (-1,1): raise ValueError('sign must be +/-1') + plus,minus=endpoints(u,A,g,n);phi=validate_phi(phi,n) + endpoint=plus if sign==1 else [-x for x in minus] + out=[F(0)]*(n+1) + for j,c in phi.items(): + p=spow(endpoint,11+j,n-j) + for i in range(n-j+1):out[i+j]+=c*sign**j*p[i]/F(11+j) + return out + + +def density_series(coeffs):return [(11+j)*x for j,x in enumerate(coeffs)] + + +def predicted_second(u,A,g,phi0,phi2): + return u*u*g**9*(1+12*A*A)*phi0+F(2,13)*g**13*phi2 + + +def check(mutant=None): + vals=shape_integrals() + expected={'I':F(246528,35),'U2':F(240192,35),'B':F(-428544,7),'ABS_U':F(5898627,880)} + if mutant=='wrong-b-integral': vals['B']=-vals['B'] + if vals!=expected: raise ValueError('shape integral mismatch') + cases=0 + for u in (F(-5,4),F(-3,4),F(-1,4),F(1,4)): + for p in (F(-1,2),F(0),F(1,3)): + A=2*p/(1-p*p);g=(1+p*p)/(1-p*p) + phi={0:F(2),2:F(-3),3:F(5),4:F(7)} + got=tail_series(u,A,g,phi,6) + if got[0]!=2*g**11*phi[0]/11:raise ValueError('leading coefficient') + guess=predicted_second(u,A,g,phi[0],phi[2]) + if mutant=='omit-shift':guess-=10*u*u*A*A*g**9*phi[0] + if mutant=='omit-density-term':guess-=F(2,13)*g**13*phi[2] + if mutant=='drop-a-shear':guess=predicted_second(u,F(0),F(1),phi[0],phi[2]) + if got[2]!=guess:raise ValueError('second coefficient mismatch') + odd=[got[i] for i in (1,3,5)] + if mutant=='odd-term-survives':odd[0]=1 + if any(odd):raise ValueError('odd inverse powers do not cancel') + hplus=half_series(u,A,g,phi,6,1);hminus=half_series(u,A,g,phi,6,-1) + if [a+b for a,b in zip(hplus,hminus)]!=got:raise ValueError('half sum') + h1=-u*A*g**10*phi[0] + if mutant=='unsigned-is-signed':h1=F(0) + if hplus[1]!=h1:raise ValueError('signed first-order bias') + den=density_series(got) + expected_den=13*got[2] + if mutant=='wrong-density-factor':expected_den=11*got[2] + if den[2]!=expected_den:raise ValueError('radial density coefficient') + cases+=1 + crossing2=F(13,11) if mutant!='wrong-tv-root' else F(11,13) + if F(13,11)/crossing2!=1:raise ValueError('TV crossing root') + return {'passed':True,'mathematical_acceptance':False,'scientific_effect':'NONE', + 'scope':'finite rational coefficient and parity controls only', + 'shape_integrals':{k:str(v) for k,v in expected.items()}, + 'series_cases':cases,'tail_exponents':[11,13,15], + 'unsigned_radial_rate':2,'signed_joint_rate':1,'tv_crossing_squared':str(crossing2)} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--mutant',choices=MUTANTS) + args=parser.parse_args() + try:result=check(args.mutant) + except ValueError as exc: + print(json.dumps({'passed':False,'error':str(exc)},sort_keys=True));raise SystemExit(1) + print(json.dumps(result,sort_keys=True,indent=2)) + +if __name__=='__main__':main() diff --git a/frontiers/radial_rate_20260930/test_rate.py b/frontiers/radial_rate_20260930/test_rate.py new file mode 100644 index 000000000..4074549e5 --- /dev/null +++ b/frontiers/radial_rate_20260930/test_rate.py @@ -0,0 +1,137 @@ +from fractions import Fraction as F +import unittest +import rate + +class InitialTests(unittest.TestCase): + def test_shape_mass(self): self.assertEqual(rate.shape_integrals()['I'],F(246528,35)) + def test_shape_u2(self): self.assertEqual(rate.shape_integrals()['U2'],F(240192,35)) + def test_shape_b(self): self.assertEqual(rate.shape_integrals()['B'],F(-428544,7)) + def test_shape_abs_u(self): self.assertEqual(rate.shape_integrals()['ABS_U'],F(5898627,880)) + def test_leading_boundary(self): + c=rate.tail_series(F(-3,4),F(3,4),F(5,4),{0:F(1)},4) + self.assertEqual(c[0],2*F(5,4)**11/11) + def test_second_boundary(self): + u,A,g=F(-3,4),F(3,4),F(5,4) + c=rate.tail_series(u,A,g,{0:F(1),2:F(2)},4) + self.assertEqual(c[2],u*u*g**9*(1+12*A*A)+F(4,13)*g**13) + def test_even_series(self): + c=rate.tail_series(F(-3,4),F(3,4),F(5,4),{0:F(1),2:F(2),3:F(7)},6) + self.assertEqual([c[i] for i in (1,3,5)],[0,0,0]) + def test_signed_first_coefficient(self): + u,A,g=F(-3,4),F(3,4),F(5,4) + c=rate.half_series(u,A,g,{0:F(1),2:F(2),3:F(7)},4,1) + self.assertEqual(c[1],-u*A*g**10) + + +class ExtendedTests(unittest.TestCase): + def test_endpoint_equation(self): + for u in (F(-5,4),F(-1,2),F(1,4)): + for p in (F(-1,2),F(0),F(1,3)): + A=2*p/(1-p*p);g=(1+p*p)/(1-p*p);n=8 + for B in rate.endpoints(u,A,g,n): + square=rate.smul(B,B,n) + for j in range(n+1): + value=square[j]-(u*u*square[j-2] if j>=2 else 0) + value+=2*u*A*B[j-1] if j>=1 else 0 + value-=g*g if j==0 else 0 + self.assertEqual(value,0) + def test_general_polynomial_parity(self): + phi={0:F(1),1:F(3),2:F(-5),3:F(7),4:F(2),5:F(-1)} + got=rate.tail_series(F(-4,3),F(3,4),F(5,4),phi,10) + self.assertTrue(all(got[j]==0 for j in (1,3,5,7,9))) + def test_half_reflection(self): + u,A,g=F(-3,4),F(3,4),F(5,4);phi={0:F(2),2:F(-3),3:F(5)} + plus=rate.half_series(u,A,g,phi,8,1);minus=rate.half_series(u,A,g,phi,8,-1) + self.assertEqual(minus,[x*(-1)**j for j,x in enumerate(plus)]) + def test_cubic_density_term_first_enters_at_four(self): + args=F(-3,4),F(3,4),F(5,4) + x=rate.tail_series(*args,{0:F(1)},6);y=rate.tail_series(*args,{0:F(1),3:F(5)},6) + self.assertEqual(x[:4],y[:4]);self.assertNotEqual(x[4],y[4]) + def test_shear_zero_removes_first_signed_bias(self): + got=rate.half_series(F(-3,4),F(0),F(1),{0:F(1),2:F(3),3:F(5)},6,1) + self.assertEqual(got[1],0);self.assertNotEqual(got[3],0) + def test_density_multiplier(self): + coeff=[F(2),0,F(3),0,F(5)] + self.assertEqual(rate.density_series(coeff),[F(22),0,F(39),0,F(75)]) + def test_b_integral_relation(self): + c=rate.shape_integrals();self.assertEqual(c['B'],3*c['I']-12*c['U2']) + def test_constant_density_decimal_remainder(self): + from decimal import Decimal,localcontext + with localcontext() as ctx: + ctx.prec=70;D=Decimal;u=D('-0.75');A=D('0.75');g=D('1.25') + c0=2*g**11/11;c2=u*u*g**9*(1+12*A*A) + vals=[] + for t in (D(40),D(80),D(160)): + delta=1/t;disc=(g*g-u*u*delta*delta).sqrt();den=1-u*u*delta*delta + bp=(-u*A*delta+disc)/den;bm=(-u*A*delta-disc)/den + J=(bp**11-bm**11)/11 + vals.append(abs((J-c0-c2*delta*delta)/delta**4)) + self.assertTrue(all(x0 for x in expected)) + def test_second_correction_positive_in_aligned_case(self): + vals=rate.shape_integrals() + for a in (F(0),F(1),F(-3)): + for k in (F(1,2),F(1),F(2)): + vbeta,vc=F(2),F(6);da=-(a*a/(12*vbeta)+a**4/(576*k*k*vc)) + self.assertGreater(vals['U2'],0) + self.assertGreaterEqual(vals['B']*da,0) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/radial_rate_20260930/test_verify.py b/frontiers/radial_rate_20260930/test_verify.py new file mode 100644 index 000000000..258288f8e --- /dev/null +++ b/frontiers/radial_rate_20260930/test_verify.py @@ -0,0 +1,102 @@ +"""Custody regressions on real local Git objects, never on invented upstream data.""" +import copy +import hashlib +import json +import os +from pathlib import Path +import subprocess +import tempfile +import unittest +import verify as v + + +def entry(path,data,**kw): + return dict(path=path,bytes=len(data),sha256=hashlib.sha256(data).hexdigest(), + git_blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest(),**kw) + +class SourceTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.repo=Path(t.name) + self.root=self.repo/'frontiers'/'packet';self.root.mkdir(parents=True) + self.git('init','-q');self.data=b'fixture\n' + for name in ('R','SC','P'):(self.repo/(name+'.md')).write_bytes(self.data) + self.git('add','R.md','SC.md','P.md');self.git('commit','-qm','fixture') + self.commit=self.git('rev-parse','HEAD').decode().strip() + self.es=[entry(x+'.md',self.data,id=x,commit=self.commit) for x in ('R','SC','P')];self.write() + 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,check=True,capture_output=True,timeout=15).stdout + def write(self,es=None): + (self.root/'SOURCES.json').write_text(json.dumps({'sources':self.es if es is None else es})) + def test_valid_nested(self):self.assertEqual(v.sources(self.root),3) + def test_identity_fields(self): + for k,val in (('bytes',0),('bytes',True),('sha256','0'*64),('git_blob','0'*40)): + es=copy.deepcopy(self.es);es[0][k]=val;self.write(es) + with self.subTest(k=k,val=val),self.assertRaises(ValueError):v.sources(self.root) + def test_missing_and_duplicate_inventory(self): + for es in ([],self.es[:-1],self.es+[self.es[0]]): + self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_wrong_id(self): + es=copy.deepcopy(self.es);es[0]['id']='X';self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_unsafe_paths(self): + for p in ('../R.md','/R.md','./R.md','x//R.md','x/../R.md',''): + es=copy.deepcopy(self.es);es[0]['path']=p;self.write(es) + with self.subTest(path=p),self.assertRaises(ValueError):v.sources(self.root) + def test_missing_file(self): + es=copy.deepcopy(self.es);es[0]['path']='missing.md';self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_noncommit_tree(self): + es=copy.deepcopy(self.es);es[0]['commit']=self.git('rev-parse','HEAD^{tree}').decode().strip();self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_annotated_tag(self): + self.git('tag','-a','tag','-m','tag');es=copy.deepcopy(self.es) + es[0]['commit']=self.git('rev-parse','tag').decode().strip();self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_missing_commit(self): + es=copy.deepcopy(self.es);es[0]['commit']='0'*40;self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_leaf_symlink(self): + (self.repo/'R.md').unlink();(self.repo/'R.md').symlink_to('SC.md');self.git('add','R.md');self.git('commit','-qm','link') + es=copy.deepcopy(self.es);es[0]['commit']=self.git('rev-parse','HEAD').decode().strip();self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_replacements_disabled(self): + changed=b'forged bytes\n';(self.repo/'R.md').write_bytes(changed);self.git('add','R.md');self.git('commit','-qm','changed') + newer=self.git('rev-parse','HEAD').decode().strip();self.git('replace',self.commit,newer) + self.assertEqual(self.git('show',self.commit+':R.md'),changed) + self.assertEqual(v.sources(self.root),3) + es=copy.deepcopy(self.es);es[0].update(entry('R.md',changed));self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + +class PacketTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name);self.data=b'payload\n' + (self.root/'proof.md').write_bytes(self.data) + self.entries=[entry('proof.md',self.data)];self.write() + def write(self): (self.root/'MANIFEST.json').write_text(json.dumps({'files':self.entries})) + def test_valid(self):self.assertEqual(v.inventory(self.root),1) + def test_changed(self): + (self.root/'proof.md').write_bytes(b'changed') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_extra(self): + (self.root/'extra').write_bytes(b'x') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_missing(self): + (self.root/'proof.md').unlink() + with self.assertRaises(ValueError):v.inventory(self.root) + def test_duplicate(self): + self.entries+=self.entries;self.write() + with self.assertRaises(ValueError):v.inventory(self.root) + def test_symlink_payload(self): + (self.root/'proof.md').unlink();(self.root/'proof.md').symlink_to('MANIFEST.json') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_symlink_manifest(self): + p=self.root/'MANIFEST.json';p.rename(self.root/'real');p.symlink_to('real') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_json_duplicate(self): + p=self.root/'MANIFEST.json';p.write_text('{"files":[],"files":[]}') + with self.assertRaises(ValueError):v.inventory(self.root) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/radial_rate_20260930/verify.py b/frontiers/radial_rate_20260930/verify.py new file mode 100644 index 000000000..d5789cbe7 --- /dev/null +++ b/frontiers/radial_rate_20260930/verify.py @@ -0,0 +1,104 @@ +"""Exact packet replay; --local-only does not authenticate upstream Git sources.""" +import argparse +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import re +import subprocess +import sys + +IDS={'R','SC','P'} +MUTANTS=('omit-shift','omit-density-term','drop-a-shear','odd-term-survives', + 'unsigned-is-signed','wrong-b-integral','wrong-density-factor','wrong-tv-root') + + +def read_json(path): + if path.is_symlink() or not path.is_file():raise ValueError('regular JSON file required') + def unique(pairs): + ans={} + for k,v in pairs: + if k in ans:raise ValueError('duplicate JSON key') + ans[k]=v + return ans + ans=json.loads(path.read_text(encoding='utf-8'),object_pairs_hook=unique) + if not isinstance(ans,dict):raise ValueError('JSON object required') + return ans + + +def path_parts(path): + if not isinstance(path,str) or not path:raise ValueError('nonempty path required') + p=PurePosixPath(path) + if p.is_absolute() or str(p)!=path or any(x in ('.','..') or not re.fullmatch('[A-Za-z0-9_.-]+',x) for x in p.parts): + raise ValueError('unsafe path') + return p.parts + + +def identity(data,e): + blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if type(e['bytes']) is not int or len(data)!=e['bytes'] or hashlib.sha256(data).hexdigest()!=e['sha256'] or blob!=e['git_blob']: + raise ValueError('identity mismatch: '+e['path']) + + +def git(root,*args): + run=subprocess.run(['git','--no-replace-objects',*args],cwd=root, + env=dict(os.environ,GIT_NO_REPLACE_OBJECTS='1'),capture_output=True,timeout=45) + if run.returncode:raise ValueError('Git object read failed: '+run.stderr.decode(errors='replace')[:200]) + return run.stdout + + +def sources(root): + es=read_json(root/'SOURCES.json')['sources'] + if not isinstance(es,list) or len(es)!=len(IDS) or {e['id'] for e in es}!=IDS: + raise ValueError('missing, duplicate or unexpected source IDs') + seen=set() + for e in es: + parts=path_parts(e['path']);commit=e['commit'] + if not isinstance(commit,str) or not re.fullmatch('[0-9a-f]{40}',commit):raise ValueError('exact commit required') + pair=(commit,e['path']) + if pair in seen:raise ValueError('duplicate source binding') + seen.add(pair) + if git(root,'cat-file','-t',commit).strip()!=b'commit':raise ValueError('not a commit object') + for j in range(1,len(parts)+1): + prefix='/'.join(parts[:j]);records=git(root,'ls-tree','--full-tree','-z',commit,'--',prefix).split(b'\0') + records=[x for x in records if x] + if len(records)!=1:raise ValueError('missing or ambiguous source path') + meta,name=records[0].split(b'\t',1);mode,kind,blob=meta.decode().split() + if name.decode()!=prefix:raise ValueError('path mismatch') + if j Date: Wed, 30 Sep 2026 02:42:04 +0000 Subject: [PATCH 07/13] Remote coefficient numerics: answer the five Codex findings in remote.py (interim; RESULTS.json regeneration follows) - z_0 normalizer from the conditional law of A_0 given U_0 under the same (continuum or periodized) kernel; - full 4x4 conditional covariance factored, so a nonpositive Var(A_0 | H_x) triggers the decimal regression instead of a silent clamp; - grid spacing derived from the integer cell count (fast mode tiled wrongly); - periodized values scoped to the axis-aligned pin direction u = e_1; - point-wise replay tolerance 1e-6 relative (interpreter differences), Python >= 3.11 documented. RESULTS.json is still the ad7c488 file: the L = 6 sample replay in --check is expected to fail until the regeneration run lands. Scientific effect NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../NOTE.md | 19 ++++--- .../README.md | 7 ++- .../SOURCE_FILES.json | 18 +++---- .../remote.py | 53 +++++++++++++------ 4 files changed, 65 insertions(+), 32 deletions(-) diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index 445c880ae..7f8c5db0e 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -18,10 +18,14 @@ with `Lambda_j` the contact kernel of [RM] (13): `U_0 = (f, f_x, f_z, f_xx, f_xz, f_xxx)(0) = (b, 0, 0, 0, 0, 12k)` the contact observation, `A_0 = f_zz(0)` the soft curvature, `w_0 = (6k)^2 A_0^2 1{A_0 < 0}` ([RM] (10) at `d = 2`), `z_0 = E[w_0 | U_0 = v_0] = 36 k^2 m_(2,b)` -([RM] (11), [LP] (5.4)), `Y_x = (f_x, f_z, f)(x)`, `H_x` the Hessian at `x`, `F_j(H) = |det H| 1{index H = j}`. The +([RM] (11), [LP] (5.4)) with `m_(2,b) = E[A_0^2 1{A_0 < 0} | U_0]` taken under the same kernel as the numerator +(continuum: `A_0 | U_0 ~ N(-b, 2)` exactly; `L = 6`: the periodized conditional law, `m_(2,0) = 1.0000175`), `Y_x = (f_x, f_z, f)(x)`, `H_x` the Hessian at `x`, `F_j(H) = |det H| 1{index H = j}`. The field is the centered unit-variance Gaussian field on `X = R^2/(L Z^2)` with the exact kernel of [LP] section 2, -`K_L(z) = sum_n exp(-|z + Ln|^2/2) / sum_n exp(-|Ln|^2/2)`. Everything is a finite-dimensional Gaussian -computation: the 13-vector of jets (seven at `0`, six at `x`) has covariance +`K_L(z) = sum_n exp(-|z + Ln|^2/2) / sum_n exp(-|Ln|^2/2)`. Orientation: the continuum kernel is isotropic, so +continuum quantities (`Lambda_inf`, `c_hole`, sample kernels, profiles) hold for every pin direction `u`; the +square torus is not rotation-invariant, and every `L`-periodized value in this note is computed with the pin +direction `u = e_1` aligned with a lattice axis (the image lattice is written in pin-frame coordinates). No other +orientation is computed. Everything is a finite-dimensional Gaussian computation: the 13-vector of jets (seven at `0`, six at `x`) has covariance `Cov(d^alpha f(s), d^beta f(t)) = (-1)^|alpha| (d^(alpha+beta) K_L)(t - s)`, with `d^a_x d^c_z exp(-|z|^2/2) = (-1)^(a+c) He_a(x_1) He_c(z) exp(-|z|^2/2)` (probabilists' Hermite polynomials). @@ -75,9 +79,12 @@ analytic map concentrating them at the angular position of the (generally offset mean; every piece of the integrand is smooth, and the nested rule converges geometrically on the exact control (`1.8e-14 relative on Lambda_inf(0) between orders` at the higher order). -**Ill-conditioned points.** Near the pin axis the conditional law of `Y_x` given `U_0` has variances down to -`|x|^6`, and the double-precision regression can lose positivity where `Lambda` is already below `10^(-20)`. Such -points (`24` in the whole run) are recomputed in 50-digit decimal arithmetic; none carries weight. +**Ill-conditioned points.** Near the pin the conditional law of `Y_x` given `U_0` has variances down to `|x|^6`, +and the double-precision regression can lose positivity, either in the Hessian block (near the axis, where +`Lambda` is below `10^(-20)`) or in the Schur complement `Var(A_0 | H_x)` (near the pin in the transverse sector, +where `Lambda` is small but not negligible: at `r = 0.05` transverse a clamped `Var(A_0 | H_x)` would misreport +`Lambda` by a factor ten). The full `4 x 4` conditional covariance of `(A_0, H_x)` is therefore Cholesky-factored, +and any nonpositive pivot sends the point (`{{exact_count}}` in the whole run) to a 50-digit decimal regression. ## 3. Method diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/README.md b/frontiers/c6_remote_coefficient_numerics_20260930/README.md index 3822b393a..79b060628 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/README.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/README.md @@ -10,8 +10,11 @@ that enters `nu(1)` by [CL] (1.4). Companion of the near-coefficient note (Math- `alpha_1 = nu_near(1)` are quoted to assemble `nu(1)`. - `NOTE.md` — statement of what is evaluated, exact structure, method, values, precision, non-claims. -- `remote.py` — standard-library script: `--check` (exact controls and replay against `RESULTS.json`), full run - regenerates `RESULTS.json`; `--mutant {hermite-sign, det-abs, weight-indicator}` must exit 1. +- `remote.py` — standard-library script (Python `>= 3.11`): `--check` (exact controls and replay against + `RESULTS.json`, point-wise tolerance `1e-6` relative to cover interpreter differences), full run regenerates + `RESULTS.json` (about 36 minutes); `--mutant {hermite-sign, det-abs, weight-indicator}` must exit 1. +- Orientation: continuum values hold for every pin direction `u`; all `L`-periodized values are for `u = e_1` + aligned with a lattice axis. - `RESULTS.json` — all numbers, grids and convergence checks. - `SOURCE_MAP.json` — pinned sources on `main` (blob identities); `SOURCE_FILES.json` — packet manifest. - Workflow `.github/workflows/c6-remote-coefficient-numerics.yml` replays manifest, pins, both check modes and the diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json index 390af691e..c04408f24 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -7,15 +7,15 @@ "files": [ { "path": "NOTE.md", - "bytes": 15415, - "sha256": "15e4779d79c03f8f578e16dc866d839d9a742f7eec37d5571b89f72de66730b8", - "git_blob": "445c880aed15a193ce0db8043ef28dba2a1420bf" + "bytes": 16372, + "sha256": "42594cdb4c7413d8f77ff7034614c50fba577ce82cabd5da9c166be49e54068c", + "git_blob": "7f8c5db0ea37c2f28411748811168cfc0a3caedd" }, { "path": "README.md", - "bytes": 1479, - "sha256": "64c524bf9143182ad3d76296eaa0bc824cccbdd1e63f8159ce41b6b0632bfcb1", - "git_blob": "3822b393a6cbfd10f6119cbffa6321c923727dde" + "bytes": 1731, + "sha256": "453e5adc6464cbbe020fcd20d59c3dd91afaaba20c91f96854510abf96b10e97", + "git_blob": "79b0606281822f3ec2809a8b87317dae648508d0" }, { "path": "RESULTS.json", @@ -31,9 +31,9 @@ }, { "path": "remote.py", - "bytes": 33854, - "sha256": "21c46498c538b809dfa0888ad0f041e776d1320df3c990003d9fff432e423ae4", - "git_blob": "b4021f8c592e6c14b655d1add21c1469a96ed702" + "bytes": 35916, + "sha256": "fb012fac939f990341c997a11f31aa18ea42326328ae70d5a1b77f63bfcaf16d", + "git_blob": "4e85a57fcc97ccb9966b6511f394df98e8877726" } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py index b4021f8c5..4e85a57fc 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py +++ b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py @@ -9,6 +9,8 @@ python -B -S remote.py # full run, writes RESULTS.json (long: tens of minutes) python -B -S remote.py --check # exact controls + replay of a small subset against RESULTS.json + # (Python >= 3.11; point-wise replay tolerance 1e-6 relative covers + # interpreter/libm differences between 3.11 and 3.14) python -B -S remote.py --check --mutant NAME # must exit 1 Conventions. Coordinates x = (x1, z): x1 along the pin axis u, z transverse. Jets are indexed by @@ -71,7 +73,11 @@ def _log(t): def kernel_derivative(a, c, x1, z, L=None, images=2): """(d^a/dx1^a d^c/dz^c) K_L(x1, z) for K(z) = exp(-|z|^2/2), K_L its normalized L-periodization. - L = None: continuum kernel (single image). Works in float or Decimal arithmetic (type of x1).""" + L = None: continuum kernel (single image). Works in float or Decimal arithmetic (type of x1). + Orientation: (x1, z) are pin-frame coordinates and the image lattice is L Z^2 in these SAME coordinates, + i.e. every periodized value in this note is for the pin direction u = e_1 aligned with a lattice axis. + The continuum kernel is isotropic, so its values hold for every u; the periodized ones do not ([RM]: + Lambda_j depends on u through the frame), and no other orientation is computed here.""" if L is None: return (-1) ** (a + c) * hermite(a, x1) * hermite(c, z) * _exp(-(x1 * x1 + z * z) / 2) tot = 0 * x1 @@ -292,7 +298,10 @@ def weighted_determinant_integrals(mu, S, rules): SAH = [S[0][j] for j in (1, 2, 3)] SAw = [sum(T[i][k] * SAH[k] for k in range(3)) for i in range(3)] wA = chol_solve(Lw, SAw) - sA = math.sqrt(max(S[0][0] - sum(SAw[i] * wA[i] for i in range(3)), 0.0)) + sA2 = S[0][0] - sum(SAw[i] * wA[i] for i in range(3)) + if sA2 <= 0.0: + raise ValueError('Var(A_0 | H) not positive: %r' % sA2) + sA = math.sqrt(sA2) muA = mu[0] # inverse via Cholesky for the quadratic form Linv = [[0.0] * 3 for _ in range(3)] @@ -388,6 +397,11 @@ def _conditioning(x1, z, b, k, L, exact): bb, kk = b, k C = joint_covariance(x1, z, L) u0 = [bb, 0 * bb, 0 * bb, 0 * bb, 0 * bb, 12 * kk] + # one-site contact law of A_0 = f_zz(0) given U_0 under the SAME kernel (continuum: exactly N(-b, 2); + # periodized: the L-dependent conditional law), so that z_0 = 36 k^2 E[A_0^2 1{A_0 < 0} | U_0] is the + # normalizer of the field actually used ([RM] (11)) + meanA, covA, _ = condition(C, OBS0, u0, [5]) + m2 = m2_negative(float(meanA[0]), math.sqrt(float(covA[0][0]))) meanY, covY, _ = condition(C, OBS0, u0, OBSX) LY = cholesky(covY) dev = [0 - meanY[0], 0 - meanY[1], bb - meanY[2]] @@ -398,24 +412,25 @@ def _conditioning(x1, z, b, k, L, exact): mu, S, _ = condition(C, obs, vals, TARGETS) mu = [float(v) for v in mu] S = [[float(v) for v in row] for row in S] - # positivity of the (h1, h2, h3) block is needed by the quadrature - cholesky([[S[i][j] for j in (1, 2, 3)] for i in (1, 2, 3)]) - return logp, mu, S + # the quadrature needs the (h1, h2, h3) block AND the Schur complement Var(A_0 | H_x) positive; a + # nonpositive pivot anywhere in the full 4 x 4 conditional covariance means the double-precision + # regression has lost the tiny residual variances and the caller must redo it in decimal arithmetic + cholesky(S) + return logp, mu, S, m2 def lambda_at(x1, z, b, k, rules, L=None): """Returns dict: Lambda_j (j = 0, 1, 2), Lambda (sum), the unweighted remote density rho_j = p * E[F_j | obs] (what the same point would carry without the pin weight), logp, coupling.""" try: - logp, mu, S = _conditioning(x1, z, b, k, L, False) + logp, mu, S, mm = _conditioning(x1, z, b, k, L, False) exact = False except ValueError: - logp, mu, S = _conditioning(x1, z, b, k, L, True) + logp, mu, S, mm = _conditioning(x1, z, b, k, L, True) exact = True EXACT_COUNT[0] += 1 p = math.exp(logp) W = weighted_determinant_integrals(mu, S, rules) - mm = m2b(b) lam = [p * W['G'][j] / mm for j in range(3)] rho = [p * W['F'][j] for j in range(3)] fsum = W['F'][0] + W['F'][1] + W['F'][2] @@ -485,8 +500,9 @@ def mc_absdet(n, seed=2026): def hole_integral(b, k, rules, Rc=5.0, h=0.2, lam_inf=None): """2 * sum over the midpoint grid on [-Rc, Rc] x (0, Rc] of (Lambda(x) - Lambda_inf) h^2, by index. Continuum kernel.""" - n1 = int(round(2 * Rc / h)) n2 = int(round(Rc / h)) + h = Rc / n2 # effective spacing: the cells tile [-Rc, Rc] x (0, Rc] exactly + n1 = 2 * n2 tot = [0.0, 0.0, 0.0] tot_rho = [0.0, 0.0, 0.0] minlam, maxlam = float('inf'), float('-inf') @@ -508,9 +524,11 @@ def hole_integral(b, k, rules, Rc=5.0, h=0.2, lam_inf=None): def torus_integral(b, k, rules, L, h=0.2): - """integral over the fundamental domain [-L/2, L/2]^2 of Lambda_L(x) dx (periodized kernel), by index.""" - n1 = int(round(L / h)) + """integral over the fundamental domain [-L/2, L/2]^2 of Lambda_L(x) dx (periodized kernel), by index. + The pin direction u is the lattice axis e_1 (see kernel_derivative).""" n2 = int(round(L / (2 * h))) + h = L / (2 * n2) # effective spacing: the cells tile [-L/2, L/2] x (0, L/2] exactly + n1 = 2 * n2 tot = [0.0, 0.0, 0.0] for i in range(n1): x1 = -L / 2 + (i + 0.5) * h @@ -521,11 +539,14 @@ def torus_integral(b, k, rules, L, h=0.2): tot[q] += r['lambda_j'][q] scale = 2.0 * h * h return {'integral_j': [scale * t for t in tot], 'integral': scale * sum(tot), - 'grid': {'L': L, 'h': h, 'points': n1 * n2, 'symmetry': 'z -> -z'}} + 'grid': {'L': L, 'h': h, 'points': n1 * n2, 'symmetry': 'z -> -z', 'u': 'e_1'}} # ----------------------------------------------------------------------------- controls EXACT_COUNT = [0] +# replay tolerance for point-wise kernel values: libm/interpreter differences (Python 3.11 versus 3.12-3.14 were +# observed at 8e-9 relative on a near-pin sample) stay far below this; the mutants move values by O(1) +REPLAY_TOL = 1e-6 SAMPLE_POINTS = [(0.15, 0.15), (0.5, 0.3), (-0.7, 0.9), (1.0, 0.0), (0.0, 1.0), (2.0, 1.5), (-1.5, 0.5), (3.0, 3.0)] @@ -621,6 +642,8 @@ def full_run(fast=False): rules = Rules() hi_rules = Rules(32, 48, 32) res = {'object': 'CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1', 'scientific_effect': 'NONE', 'certified': False, + 'orientation': 'continuum values (Lambda_inf, c_hole, samples, profiles) hold for every pin direction u (isotropic kernel); every L-periodized value is for u = e_1 aligned with a lattice axis', + 'python_requirement': '>= 3.11; point-wise replay tolerance 1e-6 relative', 'quadrature': {'coordinates': 'a = tr H / 2, (c, h2) polar; splits at a = 0 and rho = |a|', 'a_gauss_legendre_per_side': 24, 'theta_trapezoid': 32, 'rho_gauss_legendre_per_side': 24, 'cut_sd': 9.0, 'high_order_check': [32, 48, 32]}} @@ -704,16 +727,16 @@ def check_run(): b = 0.0 if key.endswith('0.0') else 1.0 rows = sample_table(b, k, rules) for r, rr in zip(rows, ref['samples'][key]): - require(abs(r['lambda'] - rr['lambda']) <= 1e-9 * max(abs(rr['lambda']), 1e-6), 'sample replay %s at %r' % (key, r['x'])) + require(abs(r['lambda'] - rr['lambda']) <= REPLAY_TOL * max(abs(rr['lambda']), 1e-6), 'sample replay %s at %r' % (key, r['x'])) rows6 = sample_table(b, k, rules, 6.0) for r, rr in zip(rows6, ref['samples_L6'][key]): - require(abs(r['lambda'] - rr['lambda']) <= 1e-9 * max(abs(rr['lambda']), 1e-6), 'L = 6 sample replay %s at %r' % (key, r['x'])) + require(abs(r['lambda'] - rr['lambda']) <= REPLAY_TOL * max(abs(rr['lambda']), 1e-6), 'L = 6 sample replay %s at %r' % (key, r['x'])) # a near-axis point that needs the decimal regression r = lambda_at(0.1, 0.0, 0.0, 1.0, rules) require(r['exact_regression'] and r['lambda'] < 1e-20, 'near-axis point handled by the decimal regression and exponentially small') for row in ref['near_zero_profile']['k=1.0,b=0.0']: if row['r'] == 0.1 and row['angle_deg'] == 0: - require(abs(row['lambda'] - r['lambda']) <= 1e-9 * max(abs(r['lambda']), 1e-30), 'near-zero replay') + require(abs(row['lambda'] - r['lambda']) <= REPLAY_TOL * max(abs(r['lambda']), 1e-30), 'near-zero replay') print(json.dumps({'check': 'ok', 'controls': list(ctl.keys()), 'mutant': MUT})) From fb45d12b895d8c9da140f8d1c1be6abbaefd4e42 Mon Sep 17 00:00:00 2001 From: d6g8k5htny-coder Date: Wed, 30 Sep 2026 09:07:43 +0000 Subject: [PATCH 08/13] Remote coefficient numerics: regenerated RESULTS.json after the Codex repairs; note numbers, manifest; record the OpenAI Sol Slice A read Regeneration with the periodized z_0, the full 4x4 positivity check (54 decimal-regression points, the r = 0.05 transverse profile value corrected by a factor ten), integer-count grid spacing and the orientation field. Continuum values (Lambda_inf, hole constants, samples) are byte-identical to ad7c488; the L = 6 direct integrals shift by the 1.75e-5 normalizer correction. NOTE.md numbers patched accordingly; OpenAI Sol review 5363739676 (Slice A ACCEPT) recorded in SOURCE_MAP.json and SOURCE_FILES.json. Scientific effect NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../NOTE.md | 16 +- .../RESULTS.json | 796 +++++++++--------- .../SOURCE_FILES.json | 25 +- .../SOURCE_MAP.json | 13 +- 4 files changed, 437 insertions(+), 413 deletions(-) diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index 7f8c5db0e..b8a7108ec 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -84,7 +84,7 @@ and the double-precision regression can lose positivity, either in the Hessian b `Lambda` is below `10^(-20)`) or in the Schur complement `Var(A_0 | H_x)` (near the pin in the transverse sector, where `Lambda` is small but not negligible: at `r = 0.05` transverse a clamped `Var(A_0 | H_x)` would misreport `Lambda` by a factor ten). The full `4 x 4` conditional covariance of `(A_0, H_x)` is therefore Cholesky-factored, -and any nonpositive pivot sends the point (`{{exact_count}}` in the whole run) to a 50-digit decimal regression. +and any nonpositive pivot sends the point (`54` in the whole run) to a 50-digit decimal regression. ## 3. Method @@ -130,7 +130,7 @@ order, a monotone ramp, so window-level critical points near the pins live in th (`Lambda(x)/Lambda_inf` at `k = 1, b = 0`: on the axis `2e-22` at `|x_1| = 1.5`, `1.6e-6` at `2`, `0.037` at `2.5`, `0.68` at `3`, `1.02` at `4`; transversally `0.21` at `|z| = 1`, `0.68` at `2`, `1.00` at `3`; the ray profiles at angles `0, 30, 45, 60, 90` degrees are in `RESULTS.json`, `ray_profile`). Near the pin `Lambda -> 0` -(`near_zero_profile`: `Lambda(0.05, 60 deg) = 0.001`, `Lambda(0.4, 90 deg) = 0.0079` at `k = 1, b = 0`; on the +(`near_zero_profile`: `Lambda(0.05, 60 deg) = 0.001`, `Lambda(0.05, 90 deg) = 0.000104`, `Lambda(0.4, 90 deg) = 0.0079` at `k = 1, b = 0`; on the axis and at `30` degrees it is below `10^(-20)`). **Remote singleton mass** `R(k, b, L) = k integral_X Lambda dx` and the assembled `nu(1)`, with `alpha_1` from the @@ -138,22 +138,22 @@ companion note ([NUM] = Math-#168 `RESULTS.json`, merged, pinned; GH60 values; ` | `k` | `b` | `L` | `integral_X Lambda` | `R = k integral_X Lambda` | `alpha_1` (#168) | `nu(1) = alpha_1 + R` | `nu(2) = alpha_2` | `nu(2)/nu(1)` | |---|---|---|---|---|---|---|---|---| -| `0.5` | `0.0` | `6` (direct) | 3.05738 | 1.52869 | 1.11821 | 2.6469 | 0.0347454 | 0.0131 | +| `0.5` | `0.0` | `6` (direct) | 3.05732 | 1.52866 | 1.11821 | 2.64687 | 0.0347454 | 0.0131 | | `0.5` | `0.0` | `12` | 15.6333 | 7.81666 | 1.11821 | 8.93487 | 0.0347454 | 0.00389 | | `0.5` | `0.0` | `24` | 65.7857 | 32.8929 | 1.11821 | 34.0111 | 0.0347454 | 0.00102 | -| `1.0` | `0.0` | `6` (direct) | 2.54211 | 2.54211 | 1.32906 | 3.87117 | 0.0255091 | 0.00659 | +| `1.0` | `0.0` | `6` (direct) | 2.54206 | 2.54206 | 1.32906 | 3.87112 | 0.0255091 | 0.00659 | | `1.0` | `0.0` | `12` | 15.0863 | 15.0863 | 1.32906 | 16.4154 | 0.0255091 | 0.00155 | | `1.0` | `0.0` | `24` | 65.2387 | 65.2387 | 1.32906 | 66.5678 | 0.0255091 | 0.000383 | -| `2.0` | `0.0` | `6` (direct) | 2.17976 | 4.35953 | 2.1621 | 6.52163 | 0.0169281 | 0.0026 | +| `2.0` | `0.0` | `6` (direct) | 2.17973 | 4.35945 | 2.1621 | 6.52155 | 0.0169281 | 0.0026 | | `2.0` | `0.0` | `12` | 14.5793 | 29.1585 | 2.1621 | 31.3206 | 0.0169281 | 0.00054 | | `2.0` | `0.0` | `24` | 64.7316 | 129.463 | 2.1621 | 131.625 | 0.0169281 | 0.000129 | -| `0.5` | `1.0` | `6` (direct) | 2.237 | 1.1185 | 0.320155 | 1.43866 | 0.00994791 | 0.00691 | +| `0.5` | `1.0` | `6` (direct) | 2.23698 | 1.11849 | 0.320155 | 1.43865 | 0.00994791 | 0.00691 | | `0.5` | `1.0` | `12` | 11.465 | 5.73251 | 0.320155 | 6.05267 | 0.00994791 | 0.00164 | | `0.5` | `1.0` | `24` | 48.112 | 24.056 | 0.320155 | 24.3762 | 0.00994791 | 0.000408 | -| `1.0` | `1.0` | `6` (direct) | 1.81212 | 1.81212 | 0.380523 | 2.19264 | 0.00730347 | 0.00333 | +| `1.0` | `1.0` | `6` (direct) | 1.8121 | 1.8121 | 0.380523 | 2.19262 | 0.00730347 | 0.00333 | | `1.0` | `1.0` | `12` | 11.0312 | 11.0312 | 0.380523 | 11.4117 | 0.00730347 | 0.00064 | | `1.0` | `1.0` | `24` | 47.6781 | 47.6781 | 0.380523 | 48.0587 | 0.00730347 | 0.000152 | -| `2.0` | `1.0` | `6` (direct) | 1.5302 | 3.0604 | 0.619027 | 3.67943 | 0.00484668 | 0.00132 | +| `2.0` | `1.0` | `6` (direct) | 1.53019 | 3.06037 | 0.619027 | 3.6794 | 0.00484668 | 0.00132 | | `2.0` | `1.0` | `12` | 10.6475 | 21.295 | 0.619027 | 21.9141 | 0.00484668 | 0.000221 | | `2.0` | `1.0` | `24` | 47.2945 | 94.589 | 0.619027 | 95.208 | 0.00484668 | 5.09e-05 | diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json b/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json index 04f5b9fc4..3e4a7ddb8 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/RESULTS.json @@ -70,7 +70,7 @@ "E_det": 0.0 } }, - "exact_regression_points": 24, + "exact_regression_points": 54, "far_field": { "0.0": { "E_F_j_given_level": [ @@ -105,7 +105,7 @@ "k=1.0,b=0.0": { "hole_h=0.1,Rc=6": -1.6313351977268296, "hole_h=0.15,Rc=6": -1.6311476645638006, - "hole_h=0.3,Rc=5": -1.6317501830630747, + "hole_h=0.3,Rc=5": -1.6297553083021523, "hole_h=0.3,Rc=6": -1.6296607043116234, "hole_h=0.3,Rc=6,high_order": -1.629660659845337, "hole_j_h=0.1,Rc=6": [ @@ -267,56 +267,56 @@ }, { "angle_deg": 30, - "exact_regression": false, - "lambda": 1.1007608503240916e-07, + "exact_regression": true, + "lambda": 1.1004555386134373e-07, "lambda_j": [ - 0.0, - 1.1007608503240916e-07, + 1.833295387377603e-61, + 1.1004555386134373e-07, 0.0 ], "r": 0.05 }, { "angle_deg": 60, - "exact_regression": false, - "lambda": 0.0021365299065861923, + "exact_regression": true, + "lambda": 0.002134947560851226, "lambda_j": [ - 0.0, - 0.0021353961230893073, - 1.1337834968849935e-06 + 4.867335485502547e-14, + 0.002133814722278417, + 1.1328385241355547e-06 ], "r": 0.05 }, { "angle_deg": 90, - "exact_regression": false, - "lambda": 0.0010298236467895805, + "exact_regression": true, + "lambda": 0.00010351960501910217, "lambda_j": [ - 0.0, - 0.0003112408828513349, - 0.0007185827639382456 + 1.1538890830569103e-14, + 2.4733228443575758e-05, + 7.878637656398753e-05 ], "r": 0.05 }, { "angle_deg": 120, - "exact_regression": false, - "lambda": 0.001727750351051215, + "exact_regression": true, + "lambda": 0.0017268476166370293, "lambda_j": [ - 0.0, - 9.726669613112576e-07, - 0.0017267776840899037 + 5.679609634872527e-17, + 9.722830217156197e-07, + 0.001725875333615257 ], "r": 0.05 }, { "angle_deg": 150, - "exact_regression": false, - "lambda": 1.5119994676265612e-07, + "exact_regression": true, + "lambda": 1.5109479250080098e-07, "lambda_j": [ 0.0, - 1.9335519354120295e-28, - 1.5119994676265612e-07 + 6.726828149800317e-23, + 1.510947925008009e-07 ], "r": 0.05 }, @@ -577,56 +577,56 @@ }, { "angle_deg": 30, - "exact_regression": false, - "lambda": 9.594634843599853e-08, + "exact_regression": true, + "lambda": 9.592868095199296e-08, "lambda_j": [ - 0.0, - 9.594634843599853e-08, + 1.902790604784803e-61, + 9.592868095199296e-08, 0.0 ], "r": 0.05 }, { "angle_deg": 60, - "exact_regression": false, - "lambda": 0.0015470167907508838, + "exact_regression": true, + "lambda": 0.001546171495926685, "lambda_j": [ - 0.0, - 0.001545863637273562, - 1.1531534773218286e-06 + 1.2987178738954032e-14, + 0.0015450190053427184, + 1.152490570979291e-06 ], "r": 0.05 }, { "angle_deg": 90, - "exact_regression": false, - "lambda": 9.077394310139034e-05, + "exact_regression": true, + "lambda": 9.069941096146156e-05, "lambda_j": [ - 0.0, - 2.387450431594391e-05, - 6.689943878544642e-05 + 2.7199580717855453e-15, + 2.3892309257505168e-05, + 6.680710170123643e-05 ], "r": 0.05 }, { "angle_deg": 120, - "exact_regression": false, - "lambda": 0.0011700977049541024, + "exact_regression": true, + "lambda": 0.0011698486784758868, "lambda_j": [ - 0.0, - 1.1968387359862264e-06, - 0.0011689008662181162 + 1.2635802355193506e-17, + 1.1961870908104367e-06, + 0.0011686524913850638 ], "r": 0.05 }, { "angle_deg": 150, - "exact_regression": false, - "lambda": 1.2183235177665711e-07, + "exact_regression": true, + "lambda": 1.2182098055323845e-07, "lambda_j": [ 0.0, - 5.074360246455502e-29, - 1.2183235177665711e-07 + 1.3040108002122639e-23, + 1.2182098055323845e-07 ], "r": 0.05 }, @@ -887,56 +887,56 @@ }, { "angle_deg": 30, - "exact_regression": false, - "lambda": 2.1093055695653464e-28, + "exact_regression": true, + "lambda": 2.1080411912855745e-28, "lambda_j": [ - 0.0, - 2.1093055695653464e-28, + 8.62163272136347e-291, + 2.1080411912855745e-28, 0.0 ], "r": 0.05 }, { "angle_deg": 60, - "exact_regression": false, - "lambda": 0.0010042757961631174, + "exact_regression": true, + "lambda": 0.0010035014647206176, "lambda_j": [ - 0.0, - 0.001004275794294735, - 1.8683823980511778e-12 + 3.590057018511172e-18, + 0.001003501462854009, + 1.8666049393700075e-12 ], "r": 0.05 }, { "angle_deg": 90, - "exact_regression": false, - "lambda": 0.0010298236467896796, + "exact_regression": true, + "lambda": 0.00010351960501910048, "lambda_j": [ - 0.0, - 0.00031124088285139015, - 0.0007185827639382895 + 1.1538890830569043e-14, + 2.473322844357601e-05, + 7.878637656398557e-05 ], "r": 0.05 }, { "angle_deg": 120, - "exact_regression": false, - "lambda": 0.0007364785619356328, + "exact_regression": true, + "lambda": 0.000736447556744653, "lambda_j": [ - 0.0, - 7.972622650421557e-13, - 0.0007364785611383706 + 1.2752941899337078e-22, + 7.971320953309199e-13, + 0.0007364475559475209 ], "r": 0.05 }, { "angle_deg": 150, - "exact_regression": false, - "lambda": 1.5190567657060656e-28, + "exact_regression": true, + "lambda": 1.5175042704749932e-28, "lambda_j": [ 0.0, - 1.1158265486189182e-53, - 1.5190567657060656e-28 + 6.777344985050669e-44, + 1.5175042704749925e-28 ], "r": 0.05 }, @@ -1197,56 +1197,56 @@ }, { "angle_deg": 30, - "exact_regression": false, - "lambda": 1.5223996357803381e-28, + "exact_regression": true, + "lambda": 1.522276492040333e-28, "lambda_j": [ - 0.0, - 1.5223996357803381e-28, + 2.4712162041177822e-288, + 1.522276492040333e-28, 0.0 ], "r": 0.05 }, { "angle_deg": 60, - "exact_regression": false, - "lambda": 0.0007105275062101507, + "exact_regression": true, + "lambda": 0.0007101589544587838, "lambda_j": [ - 0.0, - 0.0007105275043187098, - 1.891440873565354e-12 + 9.509579649729554e-19, + 0.0007101589525686068, + 1.8901761042919507e-12 ], "r": 0.05 }, { "angle_deg": 90, - "exact_regression": false, - "lambda": 9.077394310139184e-05, + "exact_regression": true, + "lambda": 9.069941096145963e-05, "lambda_j": [ - 0.0, - 2.3874504315943866e-05, - 6.689943878544797e-05 + 2.7199580717857666e-15, + 2.389230925750484e-05, + 6.680710170123482e-05 ], "r": 0.05 }, { "angle_deg": 120, - "exact_regression": false, - "lambda": 0.00042481597485555706, + "exact_regression": true, + "lambda": 0.00042502429251980116, "lambda_j": [ - 0.0, - 7.562038382033871e-13, - 0.0004248159740993532 + 2.6284301305351403e-23, + 7.563605007838872e-13, + 0.00042502429176344064 ], "r": 0.05 }, { "angle_deg": 150, - "exact_regression": false, - "lambda": 6.998906366234738e-29, + "exact_regression": true, + "lambda": 7.005633754908908e-29, "lambda_j": [ 0.0, - 5.9126061877243174e-55, - 6.998906366234738e-29 + 1.1701497308425346e-44, + 7.005633754908907e-29 ], "r": 0.05 }, @@ -1507,56 +1507,56 @@ }, { "angle_deg": 30, - "exact_regression": false, - "lambda": 1.702286082548244e-112, + "exact_regression": true, + "lambda": 1.700854640463175e-112, "lambda_j": [ 0.0, - 1.702286082548244e-112, + 1.700854640463175e-112, 0.0 ], "r": 0.05 }, { "angle_deg": 60, - "exact_regression": false, - "lambda": 2.804980898379168e-06, + "exact_regression": true, + "lambda": 2.8027005376563332e-06, "lambda_j": [ - 0.0, - 2.804980898379168e-06, + 1.6990267356486966e-37, + 2.8027005376563332e-06, 0.0 ], "r": 0.05 }, { "angle_deg": 90, - "exact_regression": false, - "lambda": 0.0010298236467895377, + "exact_regression": true, + "lambda": 0.00010351960501910388, "lambda_j": [ - 0.0, - 0.0003112408828513121, - 0.0007185827639382256 + 1.153889083056908e-14, + 2.4733228443577326e-05, + 7.878637656398766e-05 ], "r": 0.05 }, { "angle_deg": 120, - "exact_regression": false, - "lambda": 1.5794494127366118e-06, + "exact_regression": true, + "lambda": 1.579044469332315e-06, "lambda_j": [ 0.0, - 2.442477625234044e-30, - 1.5794494127366118e-06 + 4.427885001390319e-27, + 1.579044469332315e-06 ], "r": 0.05 }, { "angle_deg": 150, - "exact_regression": false, - "lambda": 1.1255857139074035e-112, + "exact_regression": true, + "lambda": 1.1276270966964014e-112, "lambda_j": [ 0.0, - 6.84009218063367e-142, - 1.1255857139074035e-112 + 7.218081029813728e-128, + 1.1276270966964008e-112 ], "r": 0.05 }, @@ -1817,56 +1817,56 @@ }, { "angle_deg": 30, - "exact_regression": false, - "lambda": 1.1256881386727306e-112, + "exact_regression": true, + "lambda": 1.1257133974630364e-112, "lambda_j": [ 0.0, - 1.1256881386727306e-112, + 1.1257133974630364e-112, 0.0 ], "r": 0.05 }, { "angle_deg": 60, - "exact_regression": false, - "lambda": 1.9134140831536693e-06, + "exact_regression": true, + "lambda": 1.9124947687286503e-06, "lambda_j": [ - 0.0, - 1.9134140831536693e-06, + 5.729491237223246e-38, + 1.9124947687286503e-06, 0.0 ], "r": 0.05 }, { "angle_deg": 90, - "exact_regression": false, - "lambda": 9.077394310139168e-05, + "exact_regression": true, + "lambda": 9.069941096146152e-05, "lambda_j": [ - 0.0, - 2.3874504315944246e-05, - 6.689943878544744e-05 + 2.719958071785549e-15, + 2.389230925750528e-05, + 6.680710170123629e-05 ], "r": 0.05 }, { "angle_deg": 120, - "exact_regression": false, - "lambda": 1.8680478260196573e-06, + "exact_regression": true, + "lambda": 1.8664092965120321e-06, "lambda_j": [ 0.0, - 0.0, - 1.8680478260196573e-06 + 1.735691900669088e-27, + 1.8664092965120321e-06 ], "r": 0.05 }, { "angle_deg": 150, - "exact_regression": false, - "lambda": 4.247113153275503e-112, + "exact_regression": true, + "lambda": 4.243921997212985e-112, "lambda_j": [ 0.0, - 8.865688347560173e-144, - 4.247113153275503e-112 + 1.253172961470713e-128, + 4.243921997212985e-112 ], "r": 0.05 }, @@ -2115,6 +2115,8 @@ ] }, "object": "CL-C6-REMOTE-COEFF-NUMERICS-20260930-v1", + "orientation": "continuum values (Lambda_inf, c_hole, samples, profiles) hold for every pin direction u (isotropic kernel); every L-periodized value is for u = e_1 aligned with a lattice axis", + "python_requirement": ">= 3.11; point-wise replay tolerance 1e-6 relative", "quadrature": { "a_gauss_legendre_per_side": 24, "coordinates": "a = tr H / 2, (c, h2) polar; splits at a = 0 and rho = |a|", @@ -3774,9 +3776,9 @@ }, "L=6": { "integral_X_Lambda_approx": 3.09523004912097, - "integral_X_Lambda_periodized_direct": 3.05737526138796, + "integral_X_Lambda_periodized_direct": 3.057321620877225, "k_integral": 1.547615024560485, - "k_integral_direct": 1.52868763069398 + "k_integral_direct": 1.5286608104386126 } }, "k=0.5,b=1.0": { @@ -3790,9 +3792,9 @@ }, "L=6": { "integral_X_Lambda_approx": 2.3032848545413636, - "integral_X_Lambda_periodized_direct": 2.2370039236173676, + "integral_X_Lambda_periodized_direct": 2.236984148652817, "k_integral": 1.1516424272706818, - "k_integral_direct": 1.1185019618086838 + "k_integral_direct": 1.1184920743264084 } }, "k=1.0,b=0.0": { @@ -3806,9 +3808,9 @@ }, "L=6": { "integral_X_Lambda_approx": 2.548217838310185, - "integral_X_Lambda_periodized_direct": 2.5421080540282226, + "integral_X_Lambda_periodized_direct": 2.5420634536888143, "k_integral": 2.548217838310185, - "k_integral_direct": 2.5421080540282226 + "k_integral_direct": 2.5420634536888143 } }, "k=1.0,b=1.0": { @@ -3822,9 +3824,9 @@ }, "L=6": { "integral_X_Lambda_approx": 1.8694318367764495, - "integral_X_Lambda_periodized_direct": 1.812115296377527, + "integral_X_Lambda_periodized_direct": 1.812099277399927, "k_integral": 1.8694318367764495, - "k_integral_direct": 1.812115296377527 + "k_integral_direct": 1.812099277399927 } }, "k=2.0,b=0.0": { @@ -3838,9 +3840,9 @@ }, "L=6": { "integral_X_Lambda_approx": 2.0411630455623455, - "integral_X_Lambda_periodized_direct": 2.1797649198343256, + "integral_X_Lambda_periodized_direct": 2.1797266766703105, "k_integral": 4.082326091124691, - "k_integral_direct": 4.359529839668651 + "k_integral_direct": 4.359453353340621 } }, "k=2.0,b=1.0": { @@ -3854,9 +3856,9 @@ }, "L=6": { "integral_X_Lambda_approx": 1.485775282224533, - "integral_X_Lambda_periodized_direct": 1.5301991395660177, + "integral_X_Lambda_periodized_direct": 1.5301856127083193, "k_integral": 2.971550564449066, - "k_integral_direct": 3.0603982791320354 + "k_integral_direct": 3.0603712254166386 } } }, @@ -4597,13 +4599,13 @@ "samples_L6": { "k=0.5,b=0.0": [ { - "coupling": 0.0013352824240637966, + "coupling": 0.0013352589970307778, "exact_regression": false, - "lambda": 0.009000458710387486, + "lambda": 0.009000300800690187, "lambda_j": [ - 4.2306984383691987e-08, - 0.009000416402587327, - 8.157752556274416e-13 + 4.230624212340141e-08, + 0.009000258493632302, + 8.157609431542862e-13 ], "rho": 6.740490661889716, "x": [ @@ -4612,13 +4614,13 @@ ] }, { - "coupling": 0.23828883959155878, + "coupling": 0.23828465890258058, "exact_regression": false, - "lambda": 0.00018360006218508273, + "lambda": 0.00018359684099034408, "lambda_j": [ - 2.3185747996361956e-08, - 0.00018357687643708636, - 5.882423599731411e-30 + 2.318534121104517e-08, + 0.00018357365564913302, + 5.8823203947993176e-30 ], "rho": 0.0007704937524551472, "x": [ @@ -4627,13 +4629,13 @@ ] }, { - "coupling": 0.24369855908021865, + "coupling": 0.243694283479726, "exact_regression": false, - "lambda": 0.056506252857895, + "lambda": 0.056505261476725285, "lambda_j": [ - 4.6640243479299636e-07, - 0.00232896825849067, - 0.05417681819696953 + 4.663942519359146e-07, + 0.002328927397609625, + 0.054175867684863724 ], "rho": 0.2318694581993599, "x": [ @@ -4642,12 +4644,12 @@ ] }, { - "coupling": 1.2278071654062748, + "coupling": 1.2277856239866574, "exact_regression": false, - "lambda": 2.9186863777201024e-28, + "lambda": 2.9186351704542015e-28, "lambda_j": [ - 1.6794127477699003e-29, - 2.7507451029431125e-28, + 1.679383283098468e-29, + 2.7506968421443545e-28, 0.0 ], "rho": 2.377153725727219e-28, @@ -4657,13 +4659,13 @@ ] }, { - "coupling": 0.11054671577748665, + "coupling": 0.1105447762765137, "exact_regression": false, - "lambda": 0.024316509096193283, + "lambda": 0.024316082472093964, "lambda_j": [ - 1.424340757853108e-05, - 0.014996244633544539, - 0.009306021055070212 + 1.4243157683247784e-05, + 0.014995981530015386, + 0.009305857784395332 ], "rho": 0.21996591147165903, "x": [ @@ -4672,13 +4674,13 @@ ] }, { - "coupling": 1.2066509791591224, + "coupling": 1.2066298089169165, "exact_regression": false, - "lambda": 0.13729091478291414, + "lambda": 0.13728850606492624, "lambda_j": [ - 0.01240788965173346, - 0.12061984887428272, - 0.004263176256897967 + 0.012407671959928847, + 0.12061773264393971, + 0.004263101461057675 ], "rho": 0.11377848040084294, "x": [ @@ -4687,13 +4689,13 @@ ] }, { - "coupling": 0.4435417129792033, + "coupling": 0.4435339312049749, "exact_regression": false, - "lambda": 0.001413255392795007, + "lambda": 0.0014132305977552805, "lambda_j": [ - 1.0111578076382077e-11, - 0.0006701512942514966, - 0.0007431040884319325 + 1.011140067250916e-11, + 0.0006701395366965291, + 0.0007430910509473508 ], "rho": 0.00318629646646396, "x": [ @@ -4702,13 +4704,13 @@ ] }, { - "coupling": 1.0001972162649189, + "coupling": 1.0001796681771224, "exact_regression": false, - "lambda": 0.11602557357983916, + "lambda": 0.11602353795434578, "lambda_j": [ - 0.012257478688314472, - 0.08970529163487585, - 0.014062803256648828 + 0.012257263635414215, + 0.08970371778893044, + 0.014062556530001123 ], "rho": 0.11600269596142108, "x": [ @@ -4719,13 +4721,13 @@ ], "k=0.5,b=1.0": [ { - "coupling": 0.001181777453979063, + "coupling": 0.0011817670071456834, "exact_regression": false, - "lambda": 0.007252705334252905, + "lambda": 0.007252641220824504, "lambda_j": [ - 9.692273907215493e-09, - 0.0072526956402956, - 1.6833971027511652e-12 + 9.692188228164635e-09, + 0.0072526315269528935, + 1.6833822216337555e-12 ], "rho": 6.137116010999305, "x": [ @@ -4734,13 +4736,13 @@ ] }, { - "coupling": 0.19587390235746285, + "coupling": 0.1958721708453118, "exact_regression": false, - "lambda": 0.00017761227458904948, + "lambda": 0.00017761070450846226, "lambda_j": [ - 5.357070546704964e-09, - 0.00017760691751850276, - 3.2232421450633133e-28 + 5.357023190560863e-09, + 0.0001776053474852717, + 3.223213651819074e-28 ], "rho": 0.0009067684487385839, "x": [ @@ -4749,13 +4751,13 @@ ] }, { - "coupling": 0.29549203647987987, + "coupling": 0.2954894243501089, "exact_regression": false, - "lambda": 0.0566461168393173, + "lambda": 0.05664561609144616, "lambda_j": [ - 2.6161531879238826e-08, - 0.0006193258690924373, - 0.05602676480869298 + 2.616130061305281e-08, + 0.0006193203942933197, + 0.05602626953585223 ], "rho": 0.19170099307625288, "x": [ @@ -4764,12 +4766,12 @@ ] }, { - "coupling": 1.4231372656895669, + "coupling": 1.42312468525165, "exact_regression": false, - "lambda": 1.2779946840452322e-27, + "lambda": 1.277983386657996e-27, "lambda_j": [ - 1.1840042361501762e-29, - 1.2661546416837304e-27, + 1.1839937696321913e-29, + 1.266143448961674e-27, 0.0 ], "rho": 8.980122401797921e-28, @@ -4779,13 +4781,13 @@ ] }, { - "coupling": 0.09856225043773235, + "coupling": 0.09856137915405334, "exact_regression": false, - "lambda": 0.01814230158049604, + "lambda": 0.018142141203767663, "lambda_j": [ - 1.9970455389237825e-06, - 0.007066609584309618, - 0.011073694950647497 + 1.9970278851752472e-06, + 0.007066547115955158, + 0.011073597059927328 ], "rho": 0.1840694738596458, "x": [ @@ -4794,13 +4796,13 @@ ] }, { - "coupling": 1.104252762369017, + "coupling": 1.104243000848708, "exact_regression": false, - "lambda": 0.10688106855213715, + "lambda": 0.10688012373066431, "lambda_j": [ - 0.001727574250233007, - 0.09046756368139389, - 0.014685930620510258 + 0.0017275589785925784, + 0.09046676395420254, + 0.014685800797869197 ], "rho": 0.09679040179427673, "x": [ @@ -4809,13 +4811,13 @@ ] }, { - "coupling": 0.7076776514081772, + "coupling": 0.7076713955852335, "exact_regression": false, - "lambda": 0.0008630881288807054, + "lambda": 0.0008630804992395709, "lambda_j": [ - 1.3586344542963722e-13, - 0.00016318327434602738, - 0.0006999048543988146 + 1.3586224440589788e-13, + 0.00016318183181683395, + 0.0006998986672868747 ], "rho": 0.0012196063096853258, "x": [ @@ -4824,13 +4826,13 @@ ] }, { - "coupling": 1.0073726033434194, + "coupling": 1.0073636982372143, "exact_regression": false, - "lambda": 0.08493677408620448, + "lambda": 0.08493602325082197, "lambda_j": [ - 0.0008311352652289752, - 0.042166570197293356, - 0.04193906862368216 + 0.0008311279180490109, + 0.04216619744764276, + 0.0419386978851302 ], "rho": 0.08431515191529289, "x": [ @@ -4841,12 +4843,12 @@ ], "k=1.0,b=0.0": [ { - "coupling": 0.0013346653987268507, + "coupling": 0.0013346419825193117, "exact_regression": false, - "lambda": 2.7096374629029337e-06, + "lambda": 2.7095899233224166e-06, "lambda_j": [ - 1.4528029858479458e-11, - 2.7096229348730752e-06, + 1.4527774969604223e-11, + 2.7095753955474468e-06, 0.0 ], "rho": 0.0020301998279776195, @@ -4856,12 +4858,12 @@ ] }, { - "coupling": 0.29700058556465986, + "coupling": 0.2969953747999563, "exact_regression": false, - "lambda": 1.1224234501461141e-17, + "lambda": 1.1224037576445477e-17, "lambda_j": [ - 5.869835540393228e-22, - 1.1223647517907103e-17, + 5.869732556313949e-22, + 1.1223450603189846e-17, 0.0 ], "rho": 3.7791960847893744e-17, @@ -4871,13 +4873,13 @@ ] }, { - "coupling": 0.20602145962604412, + "coupling": 0.2060178450562346, "exact_regression": false, - "lambda": 0.008286196731516017, + "lambda": 0.008286051353279226, "lambda_j": [ - 1.4107912183428742e-11, - 0.0001938945806034658, - 0.00809230213680464 + 1.410766466536171e-11, + 0.000193891178795234, + 0.008092160160376328 ], "rho": 0.04022006613561785, "x": [ @@ -4886,12 +4888,12 @@ ] }, { - "coupling": 1.1145285416418684, + "coupling": 1.1145089876535326, "exact_regression": false, - "lambda": 4.796156151334233e-115, + "lambda": 4.796072004560116e-115, "lambda_j": [ - 3.491234360034664e-116, - 4.447032715330766e-115, + 3.4911731076275664e-116, + 4.446954693797359e-115, 0.0 ], "rho": 4.303304915160604e-115, @@ -4901,13 +4903,13 @@ ] }, { - "coupling": 0.11054671577748665, + "coupling": 0.1105447762765137, "exact_regression": false, - "lambda": 0.024316509096193283, + "lambda": 0.024316082472093964, "lambda_j": [ - 1.424340757853108e-05, - 0.014996244633544539, - 0.009306021055070212 + 1.4243157683247784e-05, + 0.014995981530015386, + 0.009305857784395332 ], "rho": 0.21996591147165903, "x": [ @@ -4916,13 +4918,13 @@ ] }, { - "coupling": 1.414037603028991, + "coupling": 1.414012794265677, "exact_regression": false, - "lambda": 0.1116583148390832, + "lambda": 0.11165635583551857, "lambda_j": [ - 0.009070560605905392, - 0.10230031726174406, - 0.0002874369714337601 + 0.009070401466296434, + 0.10229852244076303, + 0.00028743192845910603 ], "rho": 0.07896417648293186, "x": [ @@ -4931,13 +4933,13 @@ ] }, { - "coupling": 0.2177802312560826, + "coupling": 0.2177764103830025, "exact_regression": false, - "lambda": 5.294051833956493e-11, + "lambda": 5.293958951787986e-11, "lambda_j": [ - 7.856603250461557e-34, - 3.8847550943225116e-11, - 1.4092967396339818e-11 + 7.856465409282458e-34, + 3.8846869377406346e-11, + 1.4092720140473513e-11 ], "rho": 2.4309147820360903e-10, "x": [ @@ -4946,13 +4948,13 @@ ] }, { - "coupling": 1.0001972162649189, + "coupling": 1.0001796681771224, "exact_regression": false, - "lambda": 0.11590191030699754, + "lambda": 0.11589987685113023, "lambda_j": [ - 0.012244414327720382, - 0.08960968124819547, - 0.014047814731081675 + 0.012244199504029468, + 0.0896081090796987, + 0.01404756826740207 ], "rho": 0.11587905707217942, "x": [ @@ -4963,12 +4965,12 @@ ], "k=1.0,b=1.0": [ { - "coupling": 0.0011855929356505506, + "coupling": 0.001185582455088569, "exact_regression": false, - "lambda": 2.2156227847456665e-06, + "lambda": 2.2156031987889476e-06, "lambda_j": [ - 3.4290254943549784e-12, - 2.215619355720172e-06, + 3.428995181999742e-12, + 2.2155997697937655e-06, 0.0 ], "rho": 0.0018687887875528917, @@ -4978,12 +4980,12 @@ ] }, { - "coupling": 0.21630344038881227, + "coupling": 0.21630152828091614, "exact_regression": false, - "lambda": 1.1652644981125905e-17, + "lambda": 1.1652541972526321e-17, "lambda_j": [ - 1.4257677518976314e-22, - 1.1652502404350715e-17, + 1.425755148206393e-22, + 1.1652399397011501e-17, 0.0 ], "rho": 5.3871750537947553e-17, @@ -4993,13 +4995,13 @@ ] }, { - "coupling": 0.26476259311553274, + "coupling": 0.2647602526319787, "exact_regression": false, - "lambda": 0.00727251711119097, + "lambda": 0.007272452822627791, "lambda_j": [ - 3.3495790775069134e-13, - 5.09435894807879e-05, - 0.007221573521375224 + 3.3495494674526707e-13, + 5.09431391428759e-05, + 0.00722150968314996 ], "rho": 0.027468068754023377, "x": [ @@ -5008,12 +5010,12 @@ ] }, { - "coupling": 1.699359404154547, + "coupling": 1.699344381931464, "exact_regression": false, - "lambda": 5.8285767920378104e-114, + "lambda": 5.828525267810146e-114, "lambda_j": [ - 6.686761788141136e-116, - 5.761709174156399e-114, + 6.686702677615701e-116, + 5.761658241033989e-114, 0.0 ], "rho": 3.42986702976914e-114, @@ -5023,13 +5025,13 @@ ] }, { - "coupling": 0.09856225043773234, + "coupling": 0.09856137915405333, "exact_regression": false, - "lambda": 0.018142301580496036, + "lambda": 0.01814214120376766, "lambda_j": [ - 1.997045538923783e-06, - 0.0070666095843096195, - 0.011073694950647493 + 1.9970278851752477e-06, + 0.007066547115955159, + 0.011073597059927325 ], "rho": 0.1840694738596458, "x": [ @@ -5038,13 +5040,13 @@ ] }, { - "coupling": 1.237598543087511, + "coupling": 1.23758760279945, "exact_regression": false, - "lambda": 0.11009257812876756, + "lambda": 0.11009160491776558, "lambda_j": [ - 0.0016800326027014813, - 0.10679208649254338, - 0.001620459033522697 + 0.0016800177513260261, + 0.10679114245766597, + 0.0016204447087735956 ], "rho": 0.08895661581348747, "x": [ @@ -5053,13 +5055,13 @@ ] }, { - "coupling": 0.3607760112777661, + "coupling": 0.36077282204203936, "exact_regression": false, - "lambda": 1.5649021496961578e-11, + "lambda": 1.5648883160661804e-11, "lambda_j": [ - 9.14055499222709e-37, - 6.678811120839875e-12, - 8.9702103761217e-12 + 9.140474190334415e-37, + 6.678752080597806e-12, + 8.970131080063998e-12 ], "rho": 4.337600341424362e-11, "x": [ @@ -5068,13 +5070,13 @@ ] }, { - "coupling": 1.0073726033434194, + "coupling": 1.0073636982372143, "exact_regression": false, - "lambda": 0.08484624611772276, + "lambda": 0.08484549608260142, "lambda_j": [ - 0.0008302494182221377, - 0.04212162789781388, - 0.04189436880168675 + 0.0008302420788730016, + 0.042121255545450195, + 0.04189399845827823 ], "rho": 0.08422528648895386, "x": [ @@ -5085,12 +5087,12 @@ ], "k=2.0,b=0.0": [ { - "coupling": 0.0013087088541291223, + "coupling": 0.0013086858933194952, "exact_regression": false, - "lambda": 2.770827325716849e-21, + "lambda": 2.770778712582969e-21, "lambda_j": [ - 2.040492545407624e-27, - 2.7708252852243036e-21, + 2.0404567457255683e-27, + 2.7707766721262235e-21, 0.0 ], "rho": 2.1172221132107264e-18, @@ -5100,12 +5102,12 @@ ] }, { - "coupling": 0.4270255732457859, + "coupling": 0.42701808124108037, "exact_regression": false, - "lambda": 1.1406499594754295e-71, + "lambda": 1.1406299471965422e-71, "lambda_j": [ - 7.287322006820608e-77, - 1.1406426721534227e-71, + 7.287194153468991e-77, + 1.1406226600023888e-71, 0.0 ], "rho": 2.6711514038970643e-71, @@ -5115,13 +5117,13 @@ ] }, { - "coupling": 0.12154691248048743, + "coupling": 0.12154477998515859, "exact_regression": false, - "lambda": 6.414145299649067e-07, + "lambda": 6.414032765857702e-07, "lambda_j": [ - 4.335134871489145e-28, - 2.3381563279984918e-08, - 6.180329666849217e-07 + 4.335058813161749e-28, + 2.3381153059161878e-08, + 6.180221235266084e-07 ], "rho": 5.2770943899366945e-06, "x": [ @@ -5130,7 +5132,7 @@ ] }, { - "coupling": 1.143036879287172, + "coupling": 1.1430168251306654, "exact_regression": false, "lambda": 0.0, "lambda_j": [ @@ -5145,13 +5147,13 @@ ] }, { - "coupling": 0.11054671577748668, + "coupling": 0.11054477627651373, "exact_regression": false, - "lambda": 0.024316509096193283, + "lambda": 0.024316082472093967, "lambda_j": [ - 1.424340757853108e-05, - 0.014996244633544539, - 0.009306021055070213 + 1.4243157683247784e-05, + 0.014995981530015386, + 0.009305857784395334 ], "rho": 0.219965911471659, "x": [ @@ -5160,13 +5162,13 @@ ] }, { - "coupling": 1.858239085671107, + "coupling": 1.8582064835581518, "exact_regression": false, - "lambda": 0.011073370879390183, + "lambda": 0.011073176601220602, "lambda_j": [ - 0.00042139591016260617, - 0.010651951837810168, - 2.3131417408239805e-08 + 0.0004213885169282436, + 0.010651764953280782, + 2.313101157613296e-08 ], "rho": 0.005959066820183158, "x": [ @@ -5175,13 +5177,13 @@ ] }, { - "coupling": 0.06862920990335121, + "coupling": 0.06862800582941338, "exact_regression": false, - "lambda": 4.112392145922974e-41, + "lambda": 4.112319995533774e-41, "lambda_j": [ 0.0, - 4.0154910617416267e-41, - 9.690108418134735e-43 + 4.0154206114458735e-41, + 9.689938408790064e-43 ], "rho": 5.992189261269877e-40, "x": [ @@ -5190,13 +5192,13 @@ ] }, { - "coupling": 1.0001972162649189, + "coupling": 1.0001796681771224, "exact_regression": false, - "lambda": 0.11540857384902328, + "lambda": 0.11540654904856047, "lambda_j": [ - 0.012192295980590412, - 0.08922825765793635, - 0.013988020210496522 + 0.012192082071296495, + 0.08922669218137447, + 0.01398777479588952 ], "rho": 0.11538581788899459, "x": [ @@ -5207,12 +5209,12 @@ ], "k=2.0,b=1.0": [ { - "coupling": 0.0011796385056819928, + "coupling": 0.0011796280777567724, "exact_regression": false, - "lambda": 2.3062342006097484e-21, + "lambda": 2.3062138136541946e-21, "lambda_j": [ - 4.8518119079949185e-28, - 2.3062337154285575e-21, + 4.851769018303274e-28, + 2.3062133284772926e-21, 0.0 ], "rho": 1.9550346902896567e-18, @@ -5222,12 +5224,12 @@ ] }, { - "coupling": 0.27705045059401257, + "coupling": 0.2770480014866231, "exact_regression": false, - "lambda": 1.4099034696462865e-71, + "lambda": 1.4098910061942384e-71, "lambda_j": [ - 1.6575456530324585e-77, - 1.4099018121006334e-71, + 1.6575310004401293e-77, + 1.409889348663238e-71, 0.0 ], "rho": 5.088977356374516e-71, @@ -5237,13 +5239,13 @@ ] }, { - "coupling": 0.19007815996869268, + "coupling": 0.1900764796905154, "exact_regression": false, - "lambda": 4.921308289368182e-07, + "lambda": 4.921264785333191e-07, "lambda_j": [ - 1.6121784583640165e-30, - 5.948415402692936e-09, - 4.861824135341253e-07 + 1.6121642068146436e-30, + 5.948362819099995e-09, + 4.86178115714219e-07 ], "rho": 2.5890971851678063e-06, "x": [ @@ -5252,7 +5254,7 @@ ] }, { - "coupling": 2.205333914985709, + "coupling": 2.2053144199819084, "exact_regression": false, "lambda": 0.0, "lambda_j": [ @@ -5267,13 +5269,13 @@ ] }, { - "coupling": 0.09856225043773235, + "coupling": 0.09856137915405334, "exact_regression": false, - "lambda": 0.018142301580496036, + "lambda": 0.01814214120376766, "lambda_j": [ - 1.997045538923782e-06, - 0.0070666095843096195, - 0.011073694950647493 + 1.997027885175247e-06, + 0.007066547115955159, + 0.011073597059927325 ], "rho": 0.18406947385964578, "x": [ @@ -5282,13 +5284,13 @@ ] }, { - "coupling": 1.5240623570669611, + "coupling": 1.5240488844580098, "exact_regression": false, - "lambda": 0.017487120040612404, + "lambda": 0.017486965455644866, "lambda_j": [ - 0.00011220989025799633, - 0.01737451371364244, - 3.964367119647877e-07 + 0.00011220889833009725, + 0.01737436012410728, + 3.964332074908602e-07 ], "rho": 0.011474018736520828, "x": [ @@ -5297,13 +5299,13 @@ ] }, { - "coupling": 0.10867076432649085, + "coupling": 0.10866980368422749, "exact_regression": false, - "lambda": 3.8652937000428516e-42, + "lambda": 3.8652595311059566e-42, "lambda_j": [ 0.0, - 3.523859666847038e-42, - 3.4143403319581346e-43 + 3.5238285161640815e-42, + 3.4143101494187483e-43 ], "rho": 3.5568846174946813e-41, "x": [ @@ -5312,13 +5314,13 @@ ] }, { - "coupling": 1.0073726033434194, + "coupling": 1.0073636982372143, "exact_regression": false, - "lambda": 0.08448509808814106, + "lambda": 0.08448435124554406, "lambda_j": [ - 0.0008267154617400056, - 0.04194233719711555, - 0.04171604542928551 + 0.0008267081536308076, + 0.04194196642966962, + 0.04171567666224363 ], "rho": 0.08386678157390745, "x": [ @@ -5336,13 +5338,14 @@ "L": 6.0, "h": 0.15, "points": 800, - "symmetry": "z -> -z" + "symmetry": "z -> -z", + "u": "e_1" }, - "integral": 3.05737526138796, + "integral": 3.057321620877225, "integral_j": [ - 0.14802044636245085, - 2.3613765842445558, - 0.5479782307809531 + 0.14801784939882576, + 2.361335154771501, + 0.547968616706899 ] } }, @@ -5352,13 +5355,14 @@ "L": 6.0, "h": 0.15, "points": 800, - "symmetry": "z -> -z" + "symmetry": "z -> -z", + "u": "e_1" }, - "integral": 2.2370039236173676, + "integral": 2.236984148652817, "integral_j": [ - 0.015459566977056707, - 1.2312386408044722, - 0.9903057158358384 + 0.015459430315522183, + 1.2312277567375214, + 0.9902969615997732 ] } }, @@ -5368,13 +5372,14 @@ "L": 6.0, "h": 0.15, "points": 800, - "symmetry": "z -> -z" + "symmetry": "z -> -z", + "u": "e_1" }, - "integral": 2.5421080540282226, + "integral": 2.5420634536888143, "integral_j": [ - 0.11682239256821302, - 1.9842331762729237, - 0.44105248518708556 + 0.11682034296282702, + 1.984198363640555, + 0.44104474708543256 ] } }, @@ -5384,13 +5389,14 @@ "L": 6.0, "h": 0.15, "points": 800, - "symmetry": "z -> -z" + "symmetry": "z -> -z", + "u": "e_1" }, - "integral": 1.812115296377527, + "integral": 1.812099277399927, "integral_j": [ - 0.011577600011742996, - 1.03069716079891, - 0.7698405355668743 + 0.011577497666535907, + 1.0306880495051842, + 0.7698337302282068 ] } }, @@ -5400,13 +5406,14 @@ "L": 6.0, "h": 0.15, "points": 800, - "symmetry": "z -> -z" + "symmetry": "z -> -z", + "u": "e_1" }, - "integral": 2.1797649198343256, + "integral": 2.1797266766703105, "integral_j": [ - 0.09916048767576933, - 1.702501518928095, - 0.3781029132304612 + 0.09915874794192943, + 1.7024716491727685, + 0.3780962795556126 ] } }, @@ -5416,13 +5423,14 @@ "L": 6.0, "h": 0.15, "points": 800, - "symmetry": "z -> -z" + "symmetry": "z -> -z", + "u": "e_1" }, - "integral": 1.5301991395660177, + "integral": 1.5301856127083193, "integral_j": [ - 0.010491088476728362, - 0.9104572979768156, - 0.6092507531124737 + 0.01049099573621032, + 0.9104492495954051, + 0.6092453673767042 ] } } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json index c04408f24..af8b48029 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 16372, - "sha256": "42594cdb4c7413d8f77ff7034614c50fba577ce82cabd5da9c166be49e54068c", - "git_blob": "7f8c5db0ea37c2f28411748811168cfc0a3caedd" + "bytes": 16397, + "sha256": "a4d9c45dc9b261a00ef9be2bf541628e1198076d1f0756e8381a83e7af30518a", + "git_blob": "b8a7108ecf59a01bf53b8f3ed22ec15a4c7fa800" }, { "path": "README.md", @@ -19,15 +19,15 @@ }, { "path": "RESULTS.json", - "bytes": 103175, - "sha256": "e26cc99abce33f212713efa09b3c396831dcc7a8878cb8895207cb182eecb466", - "git_blob": "04f5b9fc458e261ed2999ed7f3fc97b98abc3506" + "bytes": 103899, + "sha256": "e9af3b52761946b57d6f5fa50fdf6ccd8d26610461e471a2e97618da1611e48a", + "git_blob": "3e4a7ddb850818c4477b99f678847e68ab2b92e4" }, { "path": "SOURCE_MAP.json", - "bytes": 4268, - "sha256": "1d98c67e3bdf6df7fe2b32689924f6d548757f41a671e8b833bfdd0dbcb44471", - "git_blob": "ba9924e142bf3569476b621a56a5711bd10fb0d3" + "bytes": 5048, + "sha256": "c08c07a5d6251407f7e824d9154f9fe09fa93042d4f239942ab6a4c93f7ba8c7", + "git_blob": "7c2df9a35540e3ca6d7e3bf439b15dfa0a85a226" }, { "path": "remote.py", @@ -35,5 +35,12 @@ "sha256": "fb012fac939f990341c997a11f31aa18ea42326328ae70d5a1b77f63bfcaf16d", "git_blob": "4e85a57fcc97ccb9966b6511f394df98e8877726" } + ], + "nonauthor_reads": [ + { + "lane": "OpenAI/GPT-5.6 Sol", + "review_id": 5363739676, + "scope": "Slice A (exact structure) accepted; numerics not certified" + } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json index ba9924e14..7c2df9a35 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json @@ -4,7 +4,7 @@ "scientific_effect": "NONE", "source_repository": "d6g8k5htny-coder/Math-", "main_at_creation": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", - "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures. The companion near-coefficient note (Math-#168) merged to main on 30 September 2026 (02772ec) and is now pinned as [NUM].", + "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures. The companion near-coefficient note (Math-#168) merged to main on 30 September 2026 (02772ec) and is now pinned as [NUM]. OpenAI Sol review 5363739676 (30 September 2026, head f4d8bb9) accepts the closed-form structure of section 2 as identities; recorded under nonauthor_reads without changing review_status.", "sources": [ { "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", @@ -64,5 +64,14 @@ ], "nonauthor_acceptance": false, "governing_status_changed": false, - "main_at_update": "02772ec0427f4dda1f2a6b9e980a031804e276a6" + "main_at_update": "02772ec0427f4dda1f2a6b9e980a031804e276a6", + "nonauthor_reads": [ + { + "lane": "OpenAI/GPT-5.6 Sol", + "review_id": 5363739676, + "head": "f4d8bb9c30b5848996fceb18d213433cfe9956b9", + "date": "2026-09-30", + "disposition": "ACCEPT Slice A (closed-form far field, covariance rule, index split, unconditional controls, cone-adapted coordinates); the near-pin Euler paragraph read as a scaling heuristic only, with [CL] section 5.1 supplying the integrability bound; explicitly not an acceptance of the grids, the then-stale RESULTS.json, the precision claims or merge readiness; same account, credit 0" + } + ] } From a04fc81a8753769b8228419d33998aed0679fd30 Mon Sep 17 00:00:00 2001 From: d6g8k5htny-coder Date: Wed, 30 Sep 2026 09:10:49 +0000 Subject: [PATCH 09/13] Remote coefficient numerics: wording amendments from the OpenAI Astra Slice B read (truncation breakpoints; angular qualification of the Euler check); record the read NOTE.md and the remote.py docstring no longer claim smooth pieces / geometric convergence for the implemented truncated rule; the Euler scaling check is stated on cones |z| >= c|x| with the integrability resting on [CL] section 5.1. No numerical change: RESULTS.json unchanged, --check both modes, mutants exit 1. Scientific effect NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../NOTE.md | 20 +++++++++++----- .../SOURCE_FILES.json | 23 +++++++++++-------- .../SOURCE_MAP.json | 9 +++++++- .../remote.py | 6 +++-- 4 files changed, 40 insertions(+), 18 deletions(-) diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index b8a7108ec..e9fe79167 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -34,10 +34,14 @@ orientation is computed. Everything is a finite-dimensional Gaussian computation kernel is the right object. A direct scaling check is consistent with this: at a critical point `x` of the contact field at level `b` with `|x| = eps` small, the Euler identity `x . grad f = 3 C + A_0 z^2 + 4 q + ...` for the cubic part `C`, the soft quadratic `A_0 z^2 / 2` and the quartic part `q` forces `A_0 z^2 = O(eps^4)`, i.e. `A_0 = O(eps^2)`; -the density of `Y_x` at `(0, b)` is `O(eps^(-6))` while `w_0 |det H_x| = O(eps^4 . eps^2)`, so `Lambda = O(1)` as -`x -> 0`. (A first guess `A_0 = O(eps)` would give `Lambda ~ eps^(-2)` and a logarithmically divergent integral; -it is wrong exactly because of the Euler identity.) The computed values confirm boundedness and, in fact, -`Lambda(x) -> 0` as `x -> 0` (section 4). +the density of `Y_x` at `(0, b)` is `O(eps^(-6))` while `w_0 |det H_x| = O(eps^4 . eps^2)`, so `Lambda = O(1)` along +such a cone. (A first guess `A_0 = O(eps)` would give `Lambda ~ eps^(-2)` and a logarithmically divergent integral; +it is wrong exactly because of the Euler identity.) Two qualifications: the division by `z^2` is legitimate only on +cones `|z| >= c |x|`, so this is a scaling check on such cones and gives no pointwise bound towards the axis +(where the computed kernel is in any case exponentially small, section 4); and the integrability of `Lambda` at the +pin used by this note rests on [CL] section 5.1's integral bound `k integral_(|x| < rho) Lambda <= C rho^2`, not on +this heuristic. No uniform pointwise `Lambda = O(1)` is asserted. The computed values are bounded and, in fact, +`Lambda(x) -> 0` as `x -> 0` in every sampled direction (section 4). ## 2. Exact structure @@ -76,8 +80,12 @@ Then `det H = a^2 - rho^2`, the kink of `|det H|` is the coordinate surface `rho from `rho < |a|` (definite; sign of `a` separates minimum and maximum) or `rho > |a|` (saddle). The `a`-range is split at `0`, the `rho`-range at `|a|`, the `theta` nodes are those of the periodic trapezoid rule under an analytic map concentrating them at the angular position of the (generally offset and anisotropic) conditional -mean; every piece of the integrand is smooth, and the nested rule converges geometrically on the exact control -(`1.8e-14 relative on Lambda_inf(0) between orders` at the higher order). +mean. Apart from two truncations, each piece of the integrand is then smooth: the Gaussian ranges are cut at +`cut = 9` standard deviations (the `rho`-range endpoint `rho_max`, which the `|a|` split can cross, and a +Mahalanobis cut `q > 2 cut^2` inside the `rho`-loop), both of relative size `e^(-cut^2/2)` or smaller. No +geometric-convergence theorem is claimed for the implemented rule; what is claimed is the observed behaviour on +the exact controls (`E|det H| = 4/sqrt3` to `1e-10` at the default order and `3e-15` at the higher order; the +closed-form far field to `1e-12`) and the order comparisons of section 5. **Ill-conditioned points.** Near the pin the conditional law of `Y_x` given `U_0` has variances down to `|x|^6`, and the double-precision regression can lose positivity, either in the Hessian block (near the axis, where diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json index af8b48029..c1642f5a0 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 16397, - "sha256": "a4d9c45dc9b261a00ef9be2bf541628e1198076d1f0756e8381a83e7af30518a", - "git_blob": "b8a7108ecf59a01bf53b8f3ed22ec15a4c7fa800" + "bytes": 17325, + "sha256": "a3082bf92f0dfa246d4e8f14d61ea8b8be283498e399bb464c99ec4b15e8f5b2", + "git_blob": "e9fe791677ebeb4b05381daabdf4f442d8afe972" }, { "path": "README.md", @@ -25,15 +25,15 @@ }, { "path": "SOURCE_MAP.json", - "bytes": 5048, - "sha256": "c08c07a5d6251407f7e824d9154f9fe09fa93042d4f239942ab6a4c93f7ba8c7", - "git_blob": "7c2df9a35540e3ca6d7e3bf439b15dfa0a85a226" + "bytes": 5744, + "sha256": "c98a8e7101a392c8704884ca548b7feb7159da69e4ff9f6bb49a8a94ea038e84", + "git_blob": "de6d5dc3cc150716c9864706a8efd622f92150d6" }, { "path": "remote.py", - "bytes": 35916, - "sha256": "fb012fac939f990341c997a11f31aa18ea42326328ae70d5a1b77f63bfcaf16d", - "git_blob": "4e85a57fcc97ccb9966b6511f394df98e8877726" + "bytes": 36151, + "sha256": "086c04ce55ccc6842ebe42763ed766df17ddc114e1304a21c248b7b8d44d59ef", + "git_blob": "58d5a4ca9da911680b5e8bed573451f5b8e63867" } ], "nonauthor_reads": [ @@ -41,6 +41,11 @@ "lane": "OpenAI/GPT-5.6 Sol", "review_id": 5363739676, "scope": "Slice A (exact structure) accepted; numerics not certified" + }, + { + "lane": "OpenAI/GPT-6 Astra", + "review_id": 5364077220, + "scope": "Slice B (formulation) accepted with two wording amendments, applied" } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json index 7c2df9a35..de6d5dc3c 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json @@ -4,7 +4,7 @@ "scientific_effect": "NONE", "source_repository": "d6g8k5htny-coder/Math-", "main_at_creation": "7d0c89a5bb77a52a7a661d7292ba5d955bd0a66d", - "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures. The companion near-coefficient note (Math-#168) merged to main on 30 September 2026 (02772ec) and is now pinned as [NUM]. OpenAI Sol review 5363739676 (30 September 2026, head f4d8bb9) accepts the closed-form structure of section 2 as identities; recorded under nonauthor_reads without changing review_status.", + "note": "Numerical evaluation only. The formula evaluated is the contact kernel Lambda_j(x; b, k, u) of [RM] (13), summed and integrated over the torus as in [CL] (1.4)-(1.5) (the remote singleton part k integral_X Lambda of nu(1)), at d = 2 with the exact kernel of [LP] section 2. No source theorem is consumed as accepted beyond its recorded disposition; the numbers are deterministic floating-point quadrature values with reported convergence checks, not enclosures. The companion near-coefficient note (Math-#168) merged to main on 30 September 2026 (02772ec) and is now pinned as [NUM]. OpenAI Sol review 5363739676 (30 September 2026, head f4d8bb9) accepts the closed-form structure of section 2 as identities; recorded under nonauthor_reads without changing review_status. OpenAI Astra review 5364077220 (head f4d8bb9) accepts the Slice B formulation with two wording amendments, applied.", "sources": [ { "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", @@ -72,6 +72,13 @@ "head": "f4d8bb9c30b5848996fceb18d213433cfe9956b9", "date": "2026-09-30", "disposition": "ACCEPT Slice A (closed-form far field, covariance rule, index split, unconditional controls, cone-adapted coordinates); the near-pin Euler paragraph read as a scaling heuristic only, with [CL] section 5.1 supplying the integrability bound; explicitly not an acceptance of the grids, the then-stale RESULTS.json, the precision claims or merge readiness; same account, credit 0" + }, + { + "lane": "OpenAI/GPT-6 Astra", + "review_id": 5364077220, + "head": "f4d8bb9c30b5848996fceb18d213433cfe9956b9", + "date": "2026-09-30", + "disposition": "ACCEPT Slice B (cone-coordinate conditional-Gaussian formulation, closed-form A_0 integration, corrected full-normalizer interface, 4x4 positivity check) with two wording amendments (truncation breakpoints in the cubature; angular qualification of the Euler scaling check), applied in the successor commit; not an acceptance of numerical precision or merge readiness; same account, credit 0" } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py index 4e85a57fc..58d5a4ca9 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py +++ b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py @@ -281,8 +281,10 @@ def weighted_determinant_integrals(mu, S, rules): G[j] = E[ A^2 1{A<0} |det H| 1{index H = j} ], F[j] = E[ |det H| 1{index H = j} ], D = E det H (control). Coordinates: a = (h1 + h3)/2, c = (h1 - h3)/2, so det H = a^2 - c^2 - h2^2 = a^2 - rho^2 with (c, h2) = rho (cos theta, sin theta). The cone det H = 0 is the coordinate surface rho = |a|; the a-range is split at 0 - (index by the sign of the trace) and the rho-range at |a|, so every piece of the integrand is smooth and the - nested Gauss-Legendre / trapezoid rule converges geometrically. The general (non-isotropic) Gaussian density + (index by the sign of the trace) and the rho-range at |a|. Apart from the truncations at cut standard deviations + (the rho_max endpoint and the Mahalanobis cut q > 2 cut^2 below, of relative size exp(-cut^2/2) or smaller) each + piece of the integrand is smooth; the accuracy of the nested Gauss-Legendre / trapezoid rule is established + empirically on the exact controls, not by a convergence theorem. The general (non-isotropic) Gaussian density of (a, c, h2) is evaluated directly at the nodes; A is integrated out in closed form through m2_negative.""" # linear map (h1, h2, h3) -> w = (a, c, h2) T = [[0.5, 0.0, 0.5], [0.5, 0.0, -0.5], [0.0, 1.0, 0.0]] From ecba7057273398d86ef800a184d72a20d124e2b6 Mon Sep 17 00:00:00 2001 From: d6g8k5htny-coder Date: Wed, 30 Sep 2026 09:19:06 +0000 Subject: [PATCH 10/13] Remote coefficient numerics: truncation sentence repaired per the Astra reassessment (no universal relative bound; cap at standardized distance >= cut/sqrt2; exterior figure an estimate) NOTE.md section 2/3 and the remote.py docstring only; RESULTS.json unchanged; --check both modes, mutants exit 1. Scientific effect NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../NOTE.md | 16 +++++++++---- .../SOURCE_FILES.json | 23 +++++++++++-------- .../SOURCE_MAP.json | 7 ++++++ .../remote.py | 11 +++++---- 4 files changed, 40 insertions(+), 17 deletions(-) diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index e9fe79167..1ffdead6a 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -81,8 +81,15 @@ from `rho < |a|` (definite; sign of `a` separates minimum and maximum) or `rho > split at `0`, the `rho`-range at `|a|`, the `theta` nodes are those of the periodic trapezoid rule under an analytic map concentrating them at the angular position of the (generally offset and anisotropic) conditional mean. Apart from two truncations, each piece of the integrand is then smooth: the Gaussian ranges are cut at -`cut = 9` standard deviations (the `rho`-range endpoint `rho_max`, which the `|a|` split can cross, and a -Mahalanobis cut `q > 2 cut^2` inside the `rho`-loop), both of relative size `e^(-cut^2/2)` or smaller. No +`cut = 9` (the `a`-range at `cut` standard deviations; the `rho`-range endpoint `rho_max = |mean| + cut . max +marginal sd` of the transverse pair, which the `|a|` split can cross; and a Mahalanobis cut `q > 2 cut^2` inside +the `rho`-loop). These are numerical truncations whose omitted weighted mass depends on the actual conditional +covariance, mean and normalization; no universal relative size is claimed. What can be said in general is that +the transverse cap sits at standardized distance at least `cut/sqrt2 = 6.4` (the largest eigenvalue of a `2 x 2` +covariance is at most twice its largest marginal variance), so the omitted Gaussian mass is at most of order +`e^(-20)` times polynomial factors, and the `a`-cut and the Mahalanobis cut are at `9` and `sqrt2 . 9` +standard deviations; an absolute bound for the omitted Gaussian domain of the exact integral is the Maxwell-tail +majorant of the OpenAI lane (Math-#174 comment 5907931352, `3e-16` for the `b = 0` control). No geometric-convergence theorem is claimed for the implemented rule; what is claimed is the observed behaviour on the exact controls (`E|det H| = 4/sqrt3` to `1e-10` at the default order and `3e-15` at the higher order; the closed-form far field to `1e-12`) and the order comparisons of section 5. @@ -102,8 +109,9 @@ the midpoint rule: - continuum kernel, hole constant `c_hole,j = integral_(R^2) (Lambda_j - Lambda_inf,j) dx` on `[-6, 6]^2` (`h = 0.15`). The sixth-order jet correlations decay only like `He_6(|x|) e^(-|x|^2/2)` (`0.32` at distance 4, `4.4e-4` at 6), so the cutoff is checked directly: `Lambda/Lambda_inf - 1` is `3.6e-5` (axis), `3.1e-6` (45 deg), - `4.4e-7` (transverse) at `|x| = 5`, and `4.8e-9`, `4.4e-10`, `3.8e-11` at `|x| = 6`; the neglected exterior - contributes less than `10^(-7)` to `c_hole`; + `4.4e-7` (transverse) at `|x| = 5`, and `4.8e-9`, `4.4e-10`, `3.8e-11` at `|x| = 6`; from these sampled + profiles the neglected exterior is estimated at less than `10^(-7)` on `c_hole` (an estimate from the sampled + rays, not an integrated tail bound); - periodized kernel at `L = 6`, direct integral over the fundamental domain `[-3, 3]^2` (`h = 0.15`); - periodized kernel at `L = 12`, direct integral (`h = 0.2`), compared with `L^2 Lambda_inf + c_hole`. diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json index c1642f5a0..af27d6166 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 17325, - "sha256": "a3082bf92f0dfa246d4e8f14d61ea8b8be283498e399bb464c99ec4b15e8f5b2", - "git_blob": "e9fe791677ebeb4b05381daabdf4f442d8afe972" + "bytes": 18192, + "sha256": "15caa19e19d8f03c55898bc48d1a42420552ce3f359aa2beb75cc75e81117910", + "git_blob": "1ffdead6acf9f68f751f8cfb39ebdff7d1cd172b" }, { "path": "README.md", @@ -25,15 +25,15 @@ }, { "path": "SOURCE_MAP.json", - "bytes": 5744, - "sha256": "c98a8e7101a392c8704884ca548b7feb7159da69e4ff9f6bb49a8a94ea038e84", - "git_blob": "de6d5dc3cc150716c9864706a8efd622f92150d6" + "bytes": 6216, + "sha256": "ecbc258a67ada802cdaeae992bba84510578e21f7140f19a8d3b138226dff636", + "git_blob": "ffca4bbc02111882dfbd33aa60c94315d5c82605" }, { "path": "remote.py", - "bytes": 36151, - "sha256": "086c04ce55ccc6842ebe42763ed766df17ddc114e1304a21c248b7b8d44d59ef", - "git_blob": "58d5a4ca9da911680b5e8bed573451f5b8e63867" + "bytes": 36447, + "sha256": "3e3f35ec128fb32c606ff7bab215024e6a7c4f41ff9efd44df7a8c4d3fa5ddf2", + "git_blob": "0eaf5e6c516cdd5224bdf1e15f8b66c509929dbe" } ], "nonauthor_reads": [ @@ -46,6 +46,11 @@ "lane": "OpenAI/GPT-6 Astra", "review_id": 5364077220, "scope": "Slice B (formulation) accepted with two wording amendments, applied" + }, + { + "lane": "OpenAI/GPT-6 Astra", + "review_id": 5364176857, + "scope": "reassessment at a04fc81; formulation ACCEPT stands; truncation wording repaired" } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json index de6d5dc3c..ffca4bbc0 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json @@ -79,6 +79,13 @@ "head": "f4d8bb9c30b5848996fceb18d213433cfe9956b9", "date": "2026-09-30", "disposition": "ACCEPT Slice B (cone-coordinate conditional-Gaussian formulation, closed-form A_0 integration, corrected full-normalizer interface, 4x4 positivity check) with two wording amendments (truncation breakpoints in the cubature; angular qualification of the Euler scaling check), applied in the successor commit; not an acceptance of numerical precision or merge readiness; same account, credit 0" + }, + { + "lane": "OpenAI/GPT-6 Astra", + "review_id": 5364176857, + "head": "a04fc81a8753769b8228419d33998aed0679fd30", + "date": "2026-09-30", + "disposition": "successor reassessment: the two Slice B amendments resolved, the formulation ACCEPT stands; one further wording repair for the truncation sentence (no universal relative bound; exterior figure an estimate), applied in the successor commit; Slice C still open; same account, credit 0" } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py index 58d5a4ca9..0eaf5e6c5 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py +++ b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py @@ -281,10 +281,13 @@ def weighted_determinant_integrals(mu, S, rules): G[j] = E[ A^2 1{A<0} |det H| 1{index H = j} ], F[j] = E[ |det H| 1{index H = j} ], D = E det H (control). Coordinates: a = (h1 + h3)/2, c = (h1 - h3)/2, so det H = a^2 - c^2 - h2^2 = a^2 - rho^2 with (c, h2) = rho (cos theta, sin theta). The cone det H = 0 is the coordinate surface rho = |a|; the a-range is split at 0 - (index by the sign of the trace) and the rho-range at |a|. Apart from the truncations at cut standard deviations - (the rho_max endpoint and the Mahalanobis cut q > 2 cut^2 below, of relative size exp(-cut^2/2) or smaller) each - piece of the integrand is smooth; the accuracy of the nested Gauss-Legendre / trapezoid rule is established - empirically on the exact controls, not by a convergence theorem. The general (non-isotropic) Gaussian density + (index by the sign of the trace) and the rho-range at |a|. Apart from the truncations (a-range at cut standard + deviations; rho_max = |mean| + cut * max marginal sd of the transverse pair, i.e. at standardized distance at + least cut/sqrt2 since the largest eigenvalue is at most twice the largest marginal variance; the Mahalanobis cut + q > 2 cut^2 below) each piece of the integrand is smooth. The omitted weighted mass of these truncations depends + on the conditional covariance, mean and normalization (no universal relative bound is claimed); the accuracy of + the nested Gauss-Legendre / trapezoid rule is established empirically on the exact controls, not by a + convergence theorem. The general (non-isotropic) Gaussian density of (a, c, h2) is evaluated directly at the nodes; A is integrated out in closed form through m2_negative.""" # linear map (h1, h2, h3) -> w = (a, c, h2) T = [[0.5, 0.0, 0.5], [0.5, 0.0, -0.5], [0.0, 1.0, 0.0]] From a8c6d7918061c62a2e523b6cda34e9b78c9ac320 Mon Sep 17 00:00:00 2001 From: d6g8k5htny-coder Date: Wed, 30 Sep 2026 09:23:08 +0000 Subject: [PATCH 11/13] Remote coefficient numerics: run the pin check when a consumed source changes (workflow paths) Ports the Codex finding on Math-#178 (workflow trigger must include every current_required source path) to this packet's workflow. Packet files unchanged. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .github/workflows/c6-remote-coefficient-numerics.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/c6-remote-coefficient-numerics.yml b/.github/workflows/c6-remote-coefficient-numerics.yml index 068d3a0c9..fdb6f61ce 100644 --- a/.github/workflows/c6-remote-coefficient-numerics.yml +++ b/.github/workflows/c6-remote-coefficient-numerics.yml @@ -5,6 +5,11 @@ name: C6 remote coefficient numerics (replay) paths: - 'frontiers/c6_remote_coefficient_numerics_20260930/**' - '.github/workflows/c6-remote-coefficient-numerics.yml' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'frontiers/remote_window_20260924/PROOF.md' + - 'frontiers/c6_cluster_law_20260929/PROOF.md' + - 'frontiers/remote_collision_20260928/PROOF.md' + - 'frontiers/c6_cluster_coefficients_numerics_20260930/RESULTS.json' workflow_dispatch: permissions: From 0f448f469d391dee5f8a35cfb04b7cfa7709f947 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Wed, 30 Sep 2026 05:06:25 -0500 Subject: [PATCH 12/13] Derive fixed-separation lifetime tail and sharp inverse-moment boundary two thirds New conditional candidate at each fixed positive pin separation. Local cubic escape plus a full-dimensional Schur sector gives the lower epsilon^(2/3) bound; a deterministic sphere and conditional Gaussian weighted spectral integration give the matching upper bound. Full finite-death power-moment domain q>-2/3, with critical capped logarithmic growth. No contact uniformity, density equivalent, extreme-partner conditioning or elder/count-limit premise. Thirty tests pass in each Python mode, six semantic mutants reject per mode; exact eleven-file packet/tree63b77cf3 independently matches. Actual parent source authentication remains hosted. Fresh post-stop owner directive authorizes this foreground work, not a timer restart. Nonauthor review OPEN; no self-merge or scientific-status changes. --- .../workflows/fixed-r-inverse-lifetime.yml | 36 ++ .../MANIFEST.json | 67 ++++ .../PROOF.md | 332 ++++++++++++++++++ .../README.md | 72 ++++ .../RECONNAISSANCE.md | 37 ++ .../RESULTS.json | 15 + .../SOURCES.json | 15 + .../VALIDATION.md | 39 ++ .../inverse.py | 162 +++++++++ .../test_inverse.py | 121 +++++++ .../test_verify.py | 69 ++++ .../verify.py | 110 ++++++ 12 files changed, 1075 insertions(+) create mode 100644 .github/workflows/fixed-r-inverse-lifetime.yml create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/README.md create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/inverse.py create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py create mode 100644 frontiers/fixed_r_inverse_lifetime_20260930/verify.py diff --git a/.github/workflows/fixed-r-inverse-lifetime.yml b/.github/workflows/fixed-r-inverse-lifetime.yml new file mode 100644 index 000000000..9216a6e52 --- /dev/null +++ b/.github/workflows/fixed-r-inverse-lifetime.yml @@ -0,0 +1,36 @@ +name: Fixed-r inverse-lifetime checks + +'on': + pull_request: + paths: + - 'frontiers/fixed_r_inverse_lifetime_20260930/**' + - '.github/workflows/fixed-r-inverse-lifetime.yml' + 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 public parent model + run: | + set -euo pipefail + git fetch --no-tags origin 7a1cb09a9d58d179393e6d29146252f714b9c9bf + - name: Verify source, packet and both Python modes + env: + PYTHONDONTWRITEBYTECODE: '1' + GIT_NO_REPLACE_OBJECTS: '1' + run: | + set -euo pipefail + python -B -S frontiers/fixed_r_inverse_lifetime_20260930/verify.py + git diff --exit-code diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json b/frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json new file mode 100644 index 000000000..dd6871344 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json @@ -0,0 +1,67 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW_OPEN", + "files": [ + { + "path": "PROOF.md", + "bytes": 17213, + "sha256": "5adef725c1c696adae9bc73a525efe0bfe09d5c07e95ee3f067db9e877283630", + "git_blob": "0d4018777d13672c1de1696525512e80b23b7c3c" + }, + { + "path": "README.md", + "bytes": 3763, + "sha256": "cd167a13b3f7250b09635a61aec9b47f48da044c87bafeb86ce7486cb8d63d8b", + "git_blob": "dc87d46d95a7a5d6dcdd7debf1da7422a7d1d80c" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 2222, + "sha256": "38ca0b266398fcfcec2565f2bdd1b53b15494995fcd433f442090887e0a66158", + "git_blob": "47b0f54a2189efcfa9adbaae3ec4e8bb5fa744df" + }, + { + "path": "RESULTS.json", + "bytes": 516, + "sha256": "46ccc0f5e2d8cba11040ca1bc617e9e99e54ca7b19ac85ff4091e2601104efeb", + "git_blob": "ef9ff136e85198dad73d664d1250775baf3e1d7e" + }, + { + "path": "SOURCES.json", + "bytes": 651, + "sha256": "9ca481cd235a0e16ee8175538be0eea2477fbd8340833bc84d6ba995f20cf6e0", + "git_blob": "a7a4ebdd902a11f5daf87e0ea8fd93576aa403fa" + }, + { + "path": "VALIDATION.md", + "bytes": 2500, + "sha256": "b1528945a1d7610b2d3b27fbc907cf6538d887262f634d02b4fe0fc64fc0693c", + "git_blob": "7dc4ffe63a94db6e21164309f089b8ba0b8f1b85" + }, + { + "path": "inverse.py", + "bytes": 6501, + "sha256": "69c8e91e227bde716e237945358b0244d8a414eda9de9d4ce5e4fccb93ee7862", + "git_blob": "62698d649ff1eba92656fb555bf57d603f2bbc37" + }, + { + "path": "test_inverse.py", + "bytes": 6312, + "sha256": "0bcd93e078ee4800647f8af5aaf77894c63912d63dca9d74c49f732432bc5e6f", + "git_blob": "9695c472e7b0f4acc7946c310765d6ec204dc742" + }, + { + "path": "test_verify.py", + "bytes": 4083, + "sha256": "ee6aa8e6b589acb2eb32b482b4e9965d614d7c8416737624cd6df16eaa0b2960", + "git_blob": "1fccbe702825118906bfea6e266973a51225ca78" + }, + { + "path": "verify.py", + "bytes": 5190, + "sha256": "df2f54f44a95f1dc62022145feed2e22dca242bd37266e1eed82b12e519f6355", + "git_blob": "22db229cfc2be9d3486d7759c82c50bea83b14e0" + } + ] +} diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md b/frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md new file mode 100644 index 000000000..0d4018777 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md @@ -0,0 +1,332 @@ +# Fixed-separation lifetime tails and the sharp inverse-moment boundary + +Object OA-FIXED-R-INVERSE-LIFETIME-20260930-v1. +Author: OpenAI / GPT-6 Astra Pro. AUTHOR-SIDE PROOF CANDIDATE; new nonauthor +analytic review OPEN. Scientific effect NONE. No prior proof, status, graph, +Boolean, prize or review disposition is changed. + +## 1. Statement and the precise probability law + +Fix d>=2, L>0, b real, k>0, a unit vector u and 0b) min_t f(gamma(t)), + ell=b-d_f(M). (2) + +An empty class of paths has d_f=-infinity and ell=+infinity (essential class). +On finite deaths this is the actual lifetime, not a gap to a counted witness. +Let F denote failure of the prescribed saddle S to be the ordinary partner. +On the usual distinct-critical-value locus, (2) is the ordinary elder saddle +value. The estimates below apply directly to (2), without counting saddles +or assuming a particular local saddle is the global partner. + +**Theorem 1 (two-sided fixed-r small-lifetime order).** There are constants +00, depending on the fixed parameters, such that +for 0=0, + + E_QW[ell^(-p);ell finite] < infinity iff p<2/3, + E_QW[ell^(-p);F,ell finite] < infinity iff p<2/3. (4) + +For p=0 these denote the finite-event probabilities. The corresponding +conditional expectations have the same finiteness boundary. Multiplication by +the fixed positive scale Delta leaves the threshold unchanged, so (4) also +holds for the normalized lifetime X_r=ell/Delta. At critical and supercritical +powers the capped expectations obey + + E_QW[min(ell^(-1),T)^(2/3);F,ell finite]=Theta(log T), + E_QW[min(ell^(-1),T)^p;F,ell finite]=Theta(T^(p-2/3)) + for p>2/3. (5) + +The same holds without F or after the stated finite-event conditioning. The +constants are not evaluated. There is no claimed exact leading coefficient +or lifetime-density equivalent in (3). Together with elementary finiteness of +positive moments, the full finite-death power-moment domain is q>-2/3: +E[ell^q;finite] and E[ell^q;F,finite] are finite exactly on that range. + +**Scope.** These are statements at EACH FIXED positive r, with epsilon->0. +The constants and epsilon0 may degenerate arbitrarily as r->0. No uniform +integrability as r->0 or limit of inverse moments is asserted. In particular +this is NOT the distant-partner-conditioned law of PR181, where r->0 and a +second extreme-radius limit occur before a small-lifetime limit. Its exponent4 +and this exponent2/3 concern different laws and different limiting operations. + +[P] is the exact source in SOURCES.json. Only its model, observation, weighting +conventions and fixed-point Fourier facts in Sections1-2 are used; the latter +are reconstructed below. The uniform cap theorem, global count laws, elder +candidates PR170/175, positive-moment PR177 and extreme-mark PR181 are NOT proof +premises. The author is exposed to [P]. This is a new consumer, not independent +revalidation of that source's other theorems. + +## 2. Fixed-parameter Gaussian facts, with no contact uniformity + +Poisson summation gives Fourier weights + + a_n=exp(-2 pi^2 |n|^2/L^2)/sum_j exp(-2 pi^2 |j|^2/L^2)>0. + +For every integer m, sum_n sqrt(a_n)(1+|n|)^m is finite. A real sine/cosine +expansion and Minkowski's inequality show that every C^m norm of the field +has moments of every finite order. For orders below1 use a larger moment. +This also supplies a smooth version of the field. + +Any finite list of distinct derivative evaluations at distinct sites has +strictly positive covariance. Indeed a zero-variance linear combination +annihilates every Fourier mode since a_n>0. As a distribution it is a finite +sum of derivatives of delta masses, all of whose Fourier coefficients vanish. +The distribution is zero. Test functions supported near one site with arbitrary +finite jets show that all its coefficients vanish. Symmetric tensor entries +are listed once only; a change of orthonormal frame is invertible on these jets. + +This proves nondegeneracy of the original observation vector O and of the +following additional lists modulo O: + + U=(H_M,H_S), J=(H_M,H_S,D^3 f(M)). (6) + +All conditional covariances here are at FIXED r>0. None is replaced by its +singular r=0 counterpart. Their conditional Gaussian densities are strictly +positive on every compact set and bounded above by C exp(-c|U|^2), or the +analogous bound for J, with constants depending on the fixed observations. + +Full-field regression conditional on U has the form + + f=m_U+G_U, ||m_U||_C3 <= C(1+|U|), + G_U independent of U, E||G_U||_C3^q0. In particular K is NOT presumed +independent of the Hessians. The same argument conditional on J gives an +independent C4 residual and a uniform C4 mean bound on each compact J set. + +The Gaussian density of U is positive on the open product of the required +Hessian cones; W is strictly positive there. All its polynomial moments are +finite. Hence Z in (1) is positive and finite. No r^-2 normalizer estimate is +needed or used. + +For completeness, (2) is measurable: for hh is existence +of a path from M to a point above b with its minimum strictly above h. A +uniform approximation of such a path by torus piecewise-linear paths with +rational vertices retains both strict margins. Thus a countable set of paths +suffices; their endpoint values and compact-path minima are measurable field +functionals. An essential maximum simply has no eligible path. + +## 3. A deterministic local barrier gives a lower bound on lifetime + +Let f be any C3 field on the torus with f(M)=b, grad f(M)=0 and H_M<0. Write +lambda_min for the smallest eigenvalue of -H_M and use K above, so +0= c_L lambda_min^3/K^2, c_L=a_L^2/3>0. (9) + +This holds also as an inequality for ell=+infinity. It proves strict positivity +of every finite lifetime without any global Morse argument. The barrier does +not claim the partner is on that sphere; it bounds all older-reaching paths. + +## 4. Keep the determinant weight: the upper small-lifetime bound + +For any nonnegative measurable function psi, (7) and the Gaussian U density +imply a one-dimensional weighted eigenvalue estimate + + E_Q[W K^2 psi(lambda_min)] + <= C integral_0^infinity lambda psi(lambda) + (1+lambda)^N exp(-c lambda^2)d lambda. (10) + +Here is the full reduction. On H_M<0 diagonalize -H_M with ordered positive +eigenvalues 0=1. Apply (10) with +psi(lambda)=min(1,epsilon/lambda^3), and divide ONCE by Z. For epsilon=s^3<=1, +the portion lambda<=1 is bounded by a constant times the exact integral + + integral_0^1 lambda min(1,s^3/lambda^3)d lambda + =s^2/2+s^3(1/s-1)=(3/2)s^2-s^3. (12) + +The lambda>=1 portion is O(epsilon) by the Gaussian envelope. Therefore +Q^W(00. (13) + +Let C range over a compact box of strictly negative definite (d-1)-matrices, +v over a fixed small box of positive volume, and H_S over a compact box inside +the index-(d-1) cone. We may ensure eigenvalues of C stay between -2 and -1/2, +|det C|>=c_C>0 and |det H_S|>=c_S>0. The entire boxes can be chosen with +nonempty interiors. In these coordinates + + e^T H_M e=-lambda, H_M<0, + |det H_M|=lambda |det C|. (14) + +The change from the independent H_M entries to (lambda,v,C) has absolute +Jacobian1: only H_11 is replaced, with derivative -1 in lambda. We do not set +v=0 on a measure-zero slice, nor shrink its box with lambda. The direction e +adapts smoothly to v,C and has a uniform finite norm bound E. + +Let the third-derivative tensor T at M vary over a fixed compact positive-volume +box for which T[e,e,e]>=a>0 for every C,v in the chosen boxes. Such a box exists: +start with T_111=2a and all other entries zero, choose v small, and then a +sufficiently small full-dimensional tensor neighborhood. Initially allow +0<=lambda<=1. This defines a compact set of complete J targets. By Section2 its +raw conditional density has a strictly positive lower bound m_r on that set. + +Write the conditional full field as m_J+G_J. Choose a fixed residual C4 norm +bound with probability p0>0, possible because the residual has a finite norm +almost surely. It is independent of J. The conditional mean is bounded on the +compact targets; consequently there is a uniform directional fourth-derivative +bound M4>=1 along e on this event, accounting for |e|<=E. This uses a fixed +positive-probability residual event, not the probability of a shrinking Gaussian +ball. M4 and m_r may be very unfavorable as r decreases, which is allowed. + +For the straight path t -> M+t e, Taylor now gives + + f(M+t e) >= b-(lambda/2)t^2+(a/6)t^3-(M4/24)t^4. (15) + +Put B=6/a. If lambda<=6/(M4 B^2), then at t=B lambda the right side minus b is +at least (B^2/4)lambda^3>0. Over the entire interval 0<=t<=B lambda it is at +least -(3B^2/4)lambda^3, hence certainly at least -B^2 lambda^3. Reduce a +fixed lambda0>0 further so that B lambda0 Eb-Delta, not from a count of nearby critical +points. We need not identify the actual death saddle or forbid an even higher +alternative global path: either could only shorten ell further. + +For 0= c integral_0^((epsilon/B^2)^(1/3)) lambda d lambda + = (c/2)B^(-4/3)epsilon^(2/3). (17) + +This is the lower half of (3). It holds for all sufficiently small epsilon at +the fixed model parameters, not just along a sequence or finite numerical grid. + +## 6. Inverse moments and capped growth + +Both normalizing events {ell finite} and {F,ell finite} have positive probability +by (17). For epsilont) <= C t^(-2/3). (18) + +Endpoint strict versus weak inequalities cause no difficulty: upper bounds use +(3), and a lower bound at epsilon=1/(2t) is already enough. For p>0, Tonelli gives + + E[Y^p]=p integral_0^infinity t^(p-1) Q^W(Y>t)dt. + +The portion below a fixed large threshold is finite. The remaining integral +converges precisely when p<2/3. This proves (4). For positive powers, on finite deaths ell<=2||f||_infty; +all weighted positive moments of this norm are finite by the Gaussian norm +and Hessian moments of Section2 and Cauchy-Schwarz. This yields the stated +full power-moment domain without asserting any small-r moment convergence. +Truncating the same integral at T gives the logarithmic and power orders in (5). These are two-sided growth +orders, not exact coefficients; a density or precise regular-variation limit +was not proved by the two-sided comparison. + +## 7. What this closes, and what it does not + +The fixed-r inverse boundary is now determined at candidate-theorem level, +complementing PR177's separately derived positive finite-lifetime moments. +Neither the small-r marked law nor its moment-convergence hypotheses are used +here. In particular the new result cannot be reinterpreted as a failure of +PR181: that law further conditions on a distant replacement partner after +already taking r->0, whereas (3) includes all finite failures at fixed r. + +The exponent2/3 has two independent sources: local cubic escape costs a lifetime +of order lambda^3, while the original Palm weight and eigenvalue volume give +lambda d lambda. Dropping that weight changes the conclusion. As a comparison, +the same proof for the raw Gaussian law conditioned only on the two open Hessian +types, without either determinant tilt, gives exponent1/3; in its upper argument +integral_0^1 min(1,s^3/lambda^3)d lambda=(3/2)s-(1/2)s^3. +This comparison is not a change to the law (1) used in the main theorems. + +No exact lifetime density, leading coefficient, r-uniform constant, joint +r/epsilon limit, convergence of inverse moments as r->0, distant-partner inverse +threshold at finite r, or globally deduplicated persistence-bar intensity is +asserted. Essential-inclusive POSITIVE moments and their convention remain +separate. These proofs are not formalized in Lean and finite tests are not +analytic acceptance. + +Requested review A: fixed-r Gaussian nondegeneracy, regression and weighted +spectral reduction (Sections2-4), including the original full Z. Review B: +full-dimensional Schur sector, retained residual event, older-reaching path, +lower bound and the exact moment conclusions (Sections5-6). Prior source +verdicts or green workflows do not accept this new consumer. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/README.md b/frontiers/fixed_r_inverse_lifetime_20260930/README.md new file mode 100644 index 000000000..dc87d46d9 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/README.md @@ -0,0 +1,72 @@ +# Fixed-r lifetime moments: the inverse boundary is 2/3 + +OpenAI / GPT-6 Astra Pro. **New author-side theorem candidate; nonauthor review +OPEN. Scientific effect NONE. No self-merge.** + +For the exact determinant-weighted maximum/saddle pair-Palm law, hold the two +prescribed pins at any fixed positive embedded separation r. Let ell be the +ACTUAL ordinary elder lifetime, excluding the essential infinite lifetime. +The new proof gives two-sided small-lifetime bounds + + c_r epsilon^(2/3) <= P(0-2/3. Inverse moments of order p are finite exactly when p<2/3, both under +the finite-death restriction and conditional on failure and finite death. +The capped critical inverse moment grows as Theta(log T); above criticality +it grows as Theta(T^(p-2/3)). No exact leading coefficient is asserted. + +This fills the inverse-moment exclusion in the separately merged PR177. It +uses neither PR170/175's marked-limit candidates nor PR181's extreme-selected +law. The latter conditions on distant partners AFTER r->0 and has a different +small-lifetime exponent; it must not be substituted for this fixed-r law. + +## Why the exponent is 2/3 + +A deterministic sphere around the prescribed maximum forces +ell >= c lambda_min^3/K^2, where K controls the third derivative. Conditional +Gaussian norm moments retain K inside the endpoint determinant weight. The +remaining soft-eigenvalue integral is exactly + + integral_0^1 lambda min(1,s^3/lambda^3)d lambda=(3/2)s^2-s^3. + +An open Schur-coordinate sector gives the converse. The Hessian has a soft +curvature -lambda but a positive cubic derivative along an adapted direction. +A short straight path reaches a point above birth with only O(lambda^3) loss. +The original determinant weight supplies lambda, and full jet support supplies +d lambda. Thus the lower probability is of order epsilon^(2/3) as well. +The off-diagonal Hessian entries range over a fixed OPEN box, not a zero-measure +slice or a box shrinking with lambda. + +## Exact boundaries + +All constants can depend on fixed r,d,L,b,k and frame. No r-uniform rate, +interchange of limits, density equivalent, numerical amplitude, inverse-moment +convergence as r->0, or result conditional on a distant partner is claimed. +No source selection theorem, global count asymptotic or hard-fibre bridge is +required: maximin paths and local barriers control the actual lifetime directly. + +PROOF.md contains the full arguments. SOURCES.json binds the one parent model +carrier; only its model/weight conventions and fixed-jet Fourier facts are used, +and the latter are proved again here. Parent asymptotic theorems are not promoted. + +## Replay + + python -B -S frontiers/fixed_r_inverse_lifetime_20260930/verify.py + +The full mode requires the exact parent Git object. For a standalone extraction: + + python -B -S verify.py --local-only + +Local-only explicitly reports that historical project sources are not checked. +Thirty test methods run in each normal/optimized mode; six intentionally wrong +variants must fail per mode. Exact controls include36 Schur matrices across +four hard dimensions,36 Taylor-path cases/612 grid checks,36 local barriers, +and11 source/inventory fixture tests. These finite checks are not acceptance +of the Gaussian integration or the theorem. No new Lean formalization. + +The foreground work follows Dylan's NEW explicit September30 continuation +request, after the September27 stop. No stopped process or timer is restarted. +Review A covers Gaussian support/regression and the upper weighted bound; +review B covers the Schur sector, lower bound and moment domain. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md b/frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md new file mode 100644 index 000000000..47b0f54a2 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md @@ -0,0 +1,37 @@ +# Narrow primary reconnaissance and scope — 30 September 2026 + +Queries actually executed: +- site.arxiv.org Gaussian random fields persistence lifetime distribution critical points small persistence +- site.arxiv.org Gaussian critical points finiteness moments Gass Stecconi 2023 +- site.arxiv.org Gaussian fields Palm small eigenvalue Hessian local maximum saddle persistence + +Primary abstract/metadata pages actually opened: + +1. Louis Gass and Michele Stecconi, The number of critical points of a Gaussian + field: finiteness of moments, arXiv:2305.17586v2, revised19 July2023. + https://arxiv.org/abs/2305.17586 + Context: count-moment finiteness under regularity and jet nondegeneracy. This + is not an inverse ordinary-elder lifetime theorem and is not a premise here. + +2. Dmitry Beliaev, Valentina Cammarota and Igor Wigman, No repulsion between + critical points for planar Gaussian random fields, arXiv:1911.03455v3, + revised27 November2020. https://arxiv.org/abs/1911.03455 + Context: near-diagonal critical-point correlations with index information. + No unconditioned count-correlation formula is substituted for the actual + fixed-pin lifetime law in the new manuscript. + +Access depth was abstract/metadata, not a full-text novelty audit. The cubic +fold scaling, Schur-complement algebra, Gaussian regression, spectral matrix +Jacobian and layer-cake formula are existing general tools. No claim of +inventing them or of exhaustive priority is made. The specific new in-project +argument combines the actual maximin barrier, fixed-r full-jet support and the +original determinant tilt to identify the two-sided inverse-moment boundary. + +Connected repository context read: PR177 README at + d768a1761aee8d6911c14bc7524089e14c8cd81c, blob508e3963304cf323099bc0e118559a1f86f04146, +explicitly excludes inverse moments. That positive-moment work is credited, not +consumed as a premise or independently revalidated. PR181's distant-selected +limit is a different conditioning and is also not a premise. Coordination +pickup main#95/5908596793 and technical notes177/5908600694,5908718757 separate +these lanes. The user requested GitHub/Superpowers; Consensus was not invoked +and no quota-status change is claimed. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json b/frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json new file mode 100644 index 000000000..ef9ff136e --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json @@ -0,0 +1,15 @@ +{ + "critical_capped_growth": "Theta(log T)", + "extreme_partner_conditioning": false, + "fixed_r_small_lifetime_exponent": "2/3", + "inverse_moment_threshold": "2/3", + "mathematical_acceptance": false, + "passed": true, + "path_grid_checks": 612, + "path_parameter_cases": 36, + "scientific_effect": "NONE", + "scope": "finite rational Taylor, Schur and integral controls only", + "supercritical_capped_growth": "Theta(T^(p-2/3))", + "uniform_in_pin_separation": false, + "unweighted_comparison_exponent": "1/3" +} diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json b/frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json new file mode 100644 index 000000000..a7a4ebdd9 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json @@ -0,0 +1,15 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "sources": [ + { + "id": "P", + "commit": "7a1cb09a9d58d179393e6d29146252f714b9c9bf", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "use": "Sections1-2 model, exact original observations, full determinant weight and fixed-jet Fourier support. Gaussian facts reconstructed here. No Theorem A/B/C, contact limit, or marked elder law consumed. Author source exposure." + } + ] +} diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md b/frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md new file mode 100644 index 000000000..7dc4ffe63 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md @@ -0,0 +1,39 @@ +# Actual author validation, separate from analytic acceptance + +The initial eight-method mathematical scaffold failed all eight assertions. +After implementation all eight passed. The expanded mathematical suite has19 +methods; eleven real-Git/source/inventory tests bring the total to30. + +Fresh replay runs all30 methods in normal and optimized Python, including the +six CLI semantic mutants in each mode and the unknown label. Deterministic +baseline output must match RESULTS.json with no stderr. The exact controls +include36 full Schur matrices in hard dimensions1-4 with nonzero off-diagonal +entries,36 Taylor-path parameter sets and612 rational path points,36 sphere +barriers with360 interior points, exact cubic saddle gaps, weighted split +integrals, and the critical/supercritical scalar-model moment formulas. + +The verifier is reused from the author's PR181 driver, narrowed to the single +parent source and new mathematical CLI. Its byte-count field is required here. +The11 real-Git/inventory tests cover the actual nested working directory, byte +and hash drift, missing/duplicate source inventory, noncommit and unsafe paths, +symlink source/payload, historical replacement forgery, extra files and duplicate +JSON. The replacement fixture first verifies that an ordinary Git read sees +forged bytes, then that the protected reader authenticates the original bytes. +These fixtures are not evidence of tampering in the user's repository. + +The upper/lower Gaussian bounds and infinite-dimensional support are analytic +proof obligations, not conclusions of the scalar examples. No original field +is simulated and no Gaussian coefficient is numerically enclosed. No source +proof, review disposition or global status is changed. + +The local attempt to access the GitHub API failed with DNS resolution error. +Local-only replay therefore reports source_pins_checked=false. The hosted +workflow must fetch the ACTUAL parent commit and verify its full path, regular +mode, byte count, SHA256 and Git-blob identity before reporting source success. +Any hosted receipt belongs to the actual published head, not this author-time +record. Existing Lean checks do not formalize the new analytic proof. + +The new explicit owner instruction is the current September30 ChatGPT request +beginning "Continue to Work on closing as many mathematical items as possible". +It follows the September27 stop and authorizes foreground work, not timers. +No pre-stop autonomy grant or automated-loop restart is used as authorization. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/inverse.py b/frontiers/fixed_r_inverse_lifetime_20260930/inverse.py new file mode 100644 index 000000000..62698d649 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/inverse.py @@ -0,0 +1,162 @@ +"""Exact controls for the fixed-separation inverse-lifetime theorem candidate. + +Finite rational checks only: this does not simulate a conditioned Gaussian field +or certify the infinite-dimensional support argument. Standard library only. +""" +import argparse +from fractions import Fraction as F +import json + +MUTANTS=('lose-determinant-weight','wrong-cubic-power','wrong-soft-direction', + 'admit-critical-inverse','drop-endpoint-margin','unconditional-tail-shortcut') +_MUTANT=None + + +def rat(x): + if type(x) not in (int,F):raise TypeError('integer or Fraction required') + return F(x) + + +def determinant(matrix): + n=len(matrix) + if any(len(row)!=n for row in matrix):raise ValueError('square matrix required') + a=[[rat(x) for x in row] for row in matrix];out=F(1) + for j in range(n): + i=next((i for i in range(j,n) if a[i][j]),None) + if i is None:return F(0) + if i!=j:a[j],a[i]=a[i],a[j];out=-out + pivot=a[j][j];out*=pivot + for i in range(j+1,n): + q=a[i][j]/pivot + for k in range(j+1,n):a[i][k]-=q*a[j][k] + return out + + +def inverse(matrix): + n=len(matrix) + if any(len(row)!=n for row in matrix):raise ValueError('square matrix required') + a=[[rat(x) for x in row]+[F(i==j) for j in range(n)] for i,row in enumerate(matrix)] + for j in range(n): + i=next((i for i in range(j,n) if a[i][j]),None) + if i is None:raise ValueError('singular matrix') + a[j],a[i]=a[i],a[j];p=a[j][j];a[j]=[x/p for x in a[j]] + for i in range(n): + if i!=j: + q=a[i][j];a[i]=[x-q*y for x,y in zip(a[i],a[j])] + return [row[n:] for row in a] + + +def soft_chart(C,v,lam): + lam=rat(lam);C=[[rat(x) for x in row] for row in C];v=list(map(rat,v));n=len(C) + if not n or len(v)!=n or any(len(row)!=n for row in C) or lam<=0: + raise ValueError('positive soft curvature and a nonempty square hard block required') + if any(C[i][j]!=C[j][i] for i in range(n) for j in range(n)): + raise ValueError('hard block must be symmetric') + if any((-1)**j*determinant([row[:j] for row in C[:j]])<=0 for j in range(1,n+1)): + raise ValueError('hard block must be strictly negative definite') + inv=inverse(C);cv=[sum((inv[i][j]*v[j] for j in range(n)),F(0)) for i in range(n)] + top=sum((x*y for x,y in zip(v,cv)),F(0))-lam + H=[[top]+v]+[[v[i]]+C[i] for i in range(n)] + e=[F(1)]+[-x for x in cv] + if _MUTANT=='wrong-soft-direction':e=[F(1)]+cv + return H,e + + +def barrier(L,lam,K): + L,lam,K=map(rat,(L,lam,K)) + if L<=0 or not 0=1 required') + a=min(F(1),L/4);R=a*lam/K + return R,lam*R*R/3 + + +def path_constants(a,M): + """B=6/a, admissible lambda ceiling, loss bound C and endpoint-gain coefficient.""" + a,M=map(rat,(a,M)) + if a<=0 or M<0:raise ValueError('positive cubic lower bound and nonnegative fourth bound required') + B=6/a;cut=min(F(1),6/(M*B*B)) if M else F(1) + return B,cut,B*B,F(0) if _MUTANT=='drop-endpoint-margin' else B*B/4 + + +def cubic_gap(lam,g): + lam,g=map(rat,(lam,g)) + if lam<=0 or g<=0:raise ValueError('positive lambda and cubic required') + return 2*lam**(2 if _MUTANT=='wrong-cubic-power' else 3)/(3*g*g) + + +def upper_split(s): + """Integral_0^1 lambda min(1,s^3/lambda^3)d lambda, 0=0, 3p!=2 required') + n=2-three_p + return s**n+2*(1-s**n)/n + + +def check(): + def need(ok,msg): + if not ok:raise ValueError(msg) + need(tail_exponent(1)==F(2,3),'retain original maximum determinant weight') + need(cubic_gap(F(1,10),F(2))==F(1,6000),'cubic lifetime scale') + H,e=soft_chart([[F(-2)]],[F(1,3)],F(1,10)) + q=sum((e[i]*H[i][j]*e[j] for i in range(2) for j in range(2)),F(0)) + need(q==-F(1,10),'correct Schur soft direction') + need(not inverse_finite(F(2,3)),'critical inverse moment diverges') + need(path_constants(1,4)[3]==9,'strict endpoint above birth') + need(upper_split(F(1,10))==F(7,500),'retain weighted near-zero eigenvalue integral') + cases=0 + for a in (F(1,2),F(1),F(2)): + for M in (F(0),F(1),F(4),F(20)): + B,ceiling,C,gain=path_constants(a,M) + for frac in (F(1,10),F(1,2),F(1)): + lam=ceiling*frac + endpoint=-lam*(B*lam)**2/2+a*(B*lam)**3/6-M*(B*lam)**4/24 + need(endpoint>=gain*lam**3>0,'Taylor endpoint') + for j in range(17): + t=B*lam*F(j,16) + lower=-lam*t*t/2+a*t**3/6-M*t**4/24 + need(lower>=-C*lam**3,'Taylor path stays above lower barrier') + cases+=1 + return {'passed':True,'mathematical_acceptance':False,'scientific_effect':'NONE', + 'scope':'finite rational Taylor, Schur and integral controls only', + 'path_parameter_cases':cases,'path_grid_checks':17*cases, + 'fixed_r_small_lifetime_exponent':'2/3','inverse_moment_threshold':'2/3', + 'unweighted_comparison_exponent':'1/3', + 'critical_capped_growth':'Theta(log T)', + 'supercritical_capped_growth':'Theta(T^(p-2/3))', + 'uniform_in_pin_separation':False,'extreme_partner_conditioning':False} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--mutant',choices=MUTANTS) + args=parser.parse_args();global _MUTANT;_MUTANT=args.mutant + try:ans=check() + except ValueError as exc: + print(json.dumps({'passed':False,'error':str(exc)},sort_keys=True));raise SystemExit(1) + print(json.dumps(ans,indent=2,sort_keys=True)) + +if __name__=='__main__':main() diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py b/frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py new file mode 100644 index 000000000..9695c472e --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py @@ -0,0 +1,121 @@ +from fractions import Fraction as F +import unittest +import inverse as m + +class InitialTests(unittest.TestCase): + def test_schur_chart(self): + H,e=m.soft_chart([[F(-2)]],[F(1,3)],F(1,10)) + self.assertEqual(H,[[F(-7,45),F(1,3)],[F(1,3),F(-2)]]) + self.assertEqual(e,[F(1),F(1,6)]) + def test_barrier(self): + self.assertEqual(m.barrier(F(4),F(1,10),F(2)),(F(1,20),F(1,12000))) + def test_path_constants(self): + self.assertEqual(m.path_constants(F(1),F(4)),(F(6),F(1,24),F(36),F(9))) + def test_spectral_split(self): + self.assertEqual(m.upper_split(F(1,10)),F(7,500)) + def test_exact_cubic_gap(self): + self.assertEqual(m.cubic_gap(F(1,10),F(2)),F(1,6000)) + def test_tilt_exponent(self): + self.assertEqual(m.tail_exponent(1),F(2,3)) + self.assertEqual(m.tail_exponent(0),F(1,3)) + def test_threshold(self): + self.assertEqual([m.inverse_finite(p) for p in (F(0),F(1,3),F(2,3),F(1))],[True,True,False,False]) + def test_critical_cap(self): + self.assertEqual(m.critical_model(),(F(1),F(-2))) + + +class ExtendedTests(unittest.TestCase): + def test_full_scalar_controls(self): + r=m.check();self.assertEqual(r['path_parameter_cases'],36) + self.assertEqual(r['path_grid_checks'],612) + def test_schur_in_arbitrary_hard_dimensions(self): + count=0 + for n in range(1,5): + B=[[F((i+2*j)%5-2,7) for j in range(n)] for i in range(n)] + C=[[-sum(B[k][i]*B[k][j] for k in range(n))-int(i==j) for j in range(n)] for i in range(n)] + for numerator in (1,2,5): + v=[F(numerator*(i+1),11) for i in range(n)] + for lam in (F(1,100),F(1,10),F(1)): + H,e=m.soft_chart(C,v,lam) + He=[sum(H[i][j]*e[j] for j in range(n+1)) for i in range(n+1)] + self.assertEqual(He,[-lam]+[F(0)]*n) + self.assertEqual(m.determinant(H),-lam*m.determinant(C)) + for x in (F(-1),F(2,3)): + y=[F(i-1,3) for i in range(n)];vec=[x]+y + q=sum(vec[i]*H[i][j]*vec[j] for i in range(n+1) for j in range(n+1)) + cv=m.inverse(C);z=[y[i]+x*sum(cv[i][j]*v[j] for j in range(n)) for i in range(n)] + self.assertEqual(q,-lam*x*x+sum(z[i]*C[i][j]*z[j] for i in range(n) for j in range(n))) + count+=1 + self.assertEqual(count,36) + def test_uniform_scalar_barrier_inequality(self): + for L in (F(1,3),F(1),F(4),F(24)): + for K in (F(1),F(3),F(20)): + for ratio in (F(1,100),F(1,3),F(1)): + lam=K*ratio;R,gap=m.barrier(L,lam,K) + self.assertLess(R,L/2) + self.assertLessEqual(-lam*R**2/2+K*R**3/6,-gap) + for j in range(1,11): + t=R*F(j,10) + self.assertLess(-lam*t*t/2+K*t**3/6,0) + def test_scalar_cubic_stationary_point(self): + for lam in (F(1,100),F(1,7),F(1)): + for g in (F(1,2),F(1),F(7)): + t=2*lam/g + self.assertEqual(-lam*t+g*t*t/2,0) + self.assertGreater(-lam+g*t,0) + self.assertEqual(-lam*t*t/2+g*t**3/6,-m.cubic_gap(lam,g)) + def test_lower_path_at_worst_fourth_derivative(self): + for g0 in (F(1,3),F(1),F(3)): + for M in (F(1),F(10),F(100)): + B,cut,C,gain=m.path_constants(g0,M) + for g in (g0,2*g0): + lam=cut/2 + for h in (-M,F(0),M): + val=lambda t:-lam*t*t/2+g*t**3/6+h*t**4/24 + self.assertGreaterEqual(val(B*lam),gain*lam**3) + self.assertTrue(all(val(B*lam*F(j,20))>=-C*lam**3 for j in range(21))) + def test_weighted_split_by_independent_primitives(self): + for s in (F(1,100),F(1,3),F(1)): + direct=s*s/2+s**3*(1/s-1) + self.assertEqual(direct,m.upper_split(s)) + self.assertLessEqual(direct,F(3,2)*s*s) + self.assertGreaterEqual(direct,s*s/2) + def test_random_norm_factor_can_be_absorbed(self): + for A in (F(1),F(3,2),F(10)): + for x in (F(1,100),F(1,3),F(1),F(5)): + self.assertLessEqual(min(F(1),A*x),A*min(F(1),x)) + def test_capped_model_piecewise_integration(self): + for s in (F(1,20),F(1,3),F(1)): + for n in (0,1,3,4,5): + direct=s**(2-n)+2*(1-s**(2-n))/F(2-n) + self.assertEqual(m.cap_model(s,n),direct) + self.assertGreaterEqual(direct,1) + def test_critical_model_logarithm(self): + # For p=2/3, the lower part is1 and the upper integral is -2log(s). + self.assertEqual(m.critical_model(),(1,-2)) + self.assertEqual(F(2)/3,m.tail_exponent()) + def test_wrong_inputs_rejected(self): + for val in (True,0.5,'1/2'): + with self.assertRaises(TypeError):m.cubic_gap(val,1) + for C,v,l in (([[1]],[0],1),([[-1,1],[0,-1]],[0,0],1),([[-1]],[0],0)): + with self.assertRaises(ValueError):m.soft_chart(C,v,l) + with self.assertRaises(ValueError):m.barrier(0,1,2) + with self.assertRaises(ValueError):m.barrier(1,3,2) + with self.assertRaises(ValueError):m.path_constants(0,1) + with self.assertRaises(ValueError):m.upper_split(0) + def test_cli_both_modes_and_mutants(self): + import subprocess,sys + from pathlib import Path + path=str(Path(m.__file__).resolve());baseline=None + for flags in (['-B','-S'],['-B','-O','-S']): + run=subprocess.run([sys.executable,*flags,path],capture_output=True,timeout=25) + self.assertEqual(run.returncode,0,run.stderr);self.assertEqual(run.stderr,b'') + if baseline is None:baseline=run.stdout + self.assertEqual(run.stdout,baseline) + for mutant in m.MUTANTS: + bad=subprocess.run([sys.executable,*flags,path,'--mutant',mutant],capture_output=True,timeout=25) + self.assertEqual(bad.returncode,1,(mutant,bad.stdout,bad.stderr)) + bad=subprocess.run([sys.executable,*flags,path,'--mutant','unknown'],capture_output=True,timeout=25) + self.assertEqual(bad.returncode,2) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py b/frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py new file mode 100644 index 000000000..1fccbe702 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py @@ -0,0 +1,69 @@ +"""Real-Git regressions for the reused, narrowed source-verification driver.""" +import hashlib,json,os,subprocess,tempfile,unittest +from pathlib import Path +import verify as v + + +def entry(path,data,**kw): + return dict(path=path,bytes=len(data),sha256=hashlib.sha256(data).hexdigest(), + git_blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest(),**kw) + +class SourceTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.repo=Path(t.name) + self.root=self.repo/'frontiers/packet';self.root.mkdir(parents=True) + self.git('init','-q');self.data=b'source fixture\n' + (self.repo/'P.md').write_bytes(self.data);self.git('add','P.md');self.git('commit','-qm','fixture') + self.sha=self.git('rev-parse','HEAD').decode().strip();self.e=entry('P.md',self.data,id='P',commit=self.sha);self.write() + 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 write(self,es=None): + (self.root/'SOURCES.json').write_text(json.dumps({'sources':[self.e] if es is None else es})) + def test_original_nested_source(self):self.assertEqual(v.sources(self.root),1) + def test_identity_drift(self): + for k,x in [('bytes',0),('bytes',True),('sha256','0'*64),('git_blob','0'*40)]: + self.write([dict(self.e,**{k:x})]) + with self.subTest(k=k),self.assertRaises(ValueError):v.sources(self.root) + def test_empty_duplicate_sources(self): + for es in ([],[self.e,self.e]): + self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_noncommit_and_unsafe_path(self): + self.write([dict(self.e,commit=self.git('rev-parse','HEAD^{tree}').decode().strip())]) + with self.assertRaises(ValueError):v.sources(self.root) + self.write([dict(self.e,path='../P.md')]) + with self.assertRaises(ValueError):v.sources(self.root) + def test_replace_cannot_change_history(self): + new=b'forged\n';(self.repo/'P.md').write_bytes(new);self.git('add','P.md');self.git('commit','-qm','change') + self.git('replace',self.sha,self.git('rev-parse','HEAD').decode().strip()) + self.assertEqual(self.git('show',self.sha+':P.md'),new) + self.assertEqual(v.sources(self.root),1) + self.write([entry('P.md',new,id='P',commit=self.sha)]) + with self.assertRaises(ValueError):v.sources(self.root) + def test_symlink_source(self): + (self.repo/'P.md').unlink();(self.repo/'P.md').symlink_to('elsewhere') + self.git('add','P.md');self.git('commit','-qm','link') + self.write([dict(self.e,commit=self.git('rev-parse','HEAD').decode().strip())]) + with self.assertRaises(ValueError):v.sources(self.root) + +class PacketTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name) + self.data=b'packet\n';(self.root/'PROOF.md').write_bytes(self.data) + (self.root/'MANIFEST.json').write_text(json.dumps({'files':[entry('PROOF.md',self.data)]})) + def test_original(self):self.assertEqual(v.inventory(self.root),1) + def test_changed_payload(self): + (self.root/'PROOF.md').write_bytes(b'changed') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_extra_file(self): + (self.root/'extra').write_bytes(b'x') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_duplicate_json(self): + (self.root/'MANIFEST.json').write_text('{"files":[],"files":[]}') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_symlink_payload(self): + (self.root/'PROOF.md').unlink();(self.root/'PROOF.md').symlink_to('MANIFEST.json') + with self.assertRaises(ValueError):v.inventory(self.root) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/verify.py b/frontiers/fixed_r_inverse_lifetime_20260930/verify.py new file mode 100644 index 000000000..22db229cf --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/verify.py @@ -0,0 +1,110 @@ +"""Replay the fixed-r inverse-lifetime packet; --local-only excludes historical sources.""" +import argparse +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import re +import subprocess +import sys + +IDS={'P'} +MUTANTS=('lose-determinant-weight','wrong-cubic-power','wrong-soft-direction', + 'admit-critical-inverse','drop-endpoint-margin','unconditional-tail-shortcut') + + +def read_json(path): + if path.is_symlink() or not path.is_file():raise ValueError('regular JSON required') + def unique(pairs): + out={} + for k,v in pairs: + if k in out:raise ValueError('duplicate JSON key') + out[k]=v + return out + data=json.loads(path.read_text(encoding='utf-8'),object_pairs_hook=unique) + if not isinstance(data,dict):raise ValueError('JSON object required') + return data + + +def parts(path): + if not isinstance(path,str) or not path:raise ValueError('nonempty path required') + p=PurePosixPath(path) + if p.is_absolute() or str(p)!=path or any(x in ('.','..') or not re.fullmatch('[A-Za-z0-9_.-]+',x) for x in p.parts): + raise ValueError('unsafe or noncanonical path') + return p.parts + + +def identity(data,e): + blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if type(e['bytes']) is not int or len(data)!=e['bytes']: + raise ValueError('size mismatch') + if hashlib.sha256(data).hexdigest()!=e['sha256'] or blob!=e['git_blob']: + raise ValueError('hash mismatch: '+e['path']) + + +def git(root,*args): + run=subprocess.run(['git','--no-replace-objects',*args],cwd=root, + env=dict(os.environ,GIT_NO_REPLACE_OBJECTS='1'), + capture_output=True,timeout=45) + if run.returncode:raise ValueError('Git read failed: '+run.stderr.decode(errors='replace')[:160]) + return run.stdout + + +def sources(root): + es=read_json(root/'SOURCES.json')['sources'] + if not isinstance(es,list) or len(es)!=len(IDS) or {e['id'] for e in es}!=IDS: + raise ValueError('source inventory mismatch') + seen=set() + for e in es: + path=e['path'];ps=parts(path);commit=e['commit'] + if not isinstance(commit,str) or not re.fullmatch('[0-9a-f]{40}',commit): + raise ValueError('full commit identity required') + if (commit,path) in seen:raise ValueError('duplicate source binding') + seen.add((commit,path)) + if git(root,'cat-file','-t',commit).strip()!=b'commit':raise ValueError('not a commit object') + for j in range(1,len(ps)+1): + prefix='/'.join(ps[:j]) + rows=[s for s in git(root,'ls-tree','--full-tree','-z',commit,'--',prefix).split(b'\0') if s] + if len(rows)!=1:raise ValueError('missing or ambiguous source path') + meta,name=rows[0].split(b'\t',1);mode,kind,blob=meta.decode().split() + if name.decode()!=prefix:raise ValueError('source path mismatch') + if j Date: Wed, 30 Sep 2026 10:08:50 +0000 Subject: [PATCH 13/13] Remote coefficient numerics: reporting repairs from the Astra Slice C audit (review 5364643055); no numerical change NOTE section 5: the h = 0.3 comparison between [-5, 5]^2 and [-6, 6]^2 differs by 9.5e-5 (not 2.1e-3), and the rounded cell count makes the Rc = 5 spacing 5/17, so that comparison mixes grid placement with the exterior annulus; the fitted-error figures are now labelled as a nonrigorous three-point power-law model for k = 1, b = 0 only (p = 2.63, A_0 = -1.63143, residuals 2.9e-4 at h = 0.15 and 9.8e-5 at h = 0.1) next to the measured 1.88e-4 finest-grid difference. NOTE section 4: the L = 24 additive-form accuracy is an expectation, not a measurement. remote.py --check now replays this summary arithmetic from the stored grid_convergence block. SOURCE_MAP records the read; SOURCE_FILES fingerprints updated. RESULTS.json unchanged. Scientific effect NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../NOTE.md | 19 +++++---- .../SOURCE_FILES.json | 18 ++++----- .../SOURCE_MAP.json | 8 ++++ .../remote.py | 40 ++++++++++++++++++- 4 files changed, 68 insertions(+), 17 deletions(-) diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md index 1ffdead6a..47fc0fedf 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md +++ b/frontiers/c6_remote_coefficient_numerics_20260930/NOTE.md @@ -179,8 +179,8 @@ For `L = 6` the direct periodized integral and the approximation `36 Lambda_inf pins overlap and the additive approximation `L^2 Lambda_inf + c_hole` is not valid; the table uses the direct periodized integral for `L = 6`. (The periodization also changes the one-site covariances by up to `8.8e-4` at `L = 6`; that is included in the direct value.) For `L = 12` the direct integral at `k = 1, b = 0` is `15.0866` -against `15.0863` from the far field plus hole, so the additive form is accurate to `2e-5` there and better at -`L = 24`. +against `15.0863` from the far field plus hole, so the additive form is accurate to `2e-5` there. No direct +`L = 24` integral was run: at `L = 24` the additive form is expected, not measured, to be at least as accurate. **Reading.** For the parent torus sizes the remote singletons dominate `nu(1)` (`R ~ L^2 Lambda_inf`: by a factor `50` at `L = 24`, `k = 1, b = 0`), so the two-point cluster probability relative to a nonempty window is @@ -201,11 +201,16 @@ ring; the net hole is nevertheless negative for every `(k, b)` computed, and gro `9e-13` (far field, both `b`). The `h = 0.3` hole constant changes by `4e-08` between the two orders. - Grid: at `k = 1, b = 0` the hole constant is `-1.629661` (`h = 0.3`), `-1.631148` (`h = 0.15`), - `-1.631335` (`h = 0.1`): the midpoint rule converges at an observed order of about `2.7` (`Lambda` has a - conical, direction-dependent limit at the pin), the `h = 0.15` values are within `2e-4` of the `h = 0.1` values, - and a power-law extrapolation puts the remaining error of the tabulated (`h = 0.15`) hole constants near - `1e-4` absolute (`1e-4` relative). The `h = 0.3` run on `[-5, 5]^2` differs by `2.1e-03`, which is grid - placement, not tail (see the direct tail check in section 3). + `-1.631335` (`h = 0.1`). Measured: the tabulated `h = 0.15` value differs from the `h = 0.1` value by + `1.88e-4`. Model (NONRIGOROUS, this one parameter set only): a three-point power law `A(h) = A_0 + C h^p` + fitted to the non-nested spacings `0.3, 0.15, 0.1` gives `p = 2.63` (`Lambda` has a conical, + direction-dependent limit at the pin), `A_0 = -1.63143`, and model residuals `2.9e-4` at `h = 0.15` and + `9.8e-5` at `h = 0.1`; these are extrapolations, not error bounds, and nothing is inferred from them for the + other `(k, b)` rows. The `h = 0.3` run on `[-5, 5]^2` differs from the `[-6, 6]^2` run by `9.5e-5`; because + the cell count is rounded (`n = round(5/0.3) = 17`, effective spacing `5/17 = 0.294` against `0.3`), that + difference mixes grid placement with the exterior annulus and is not a pure exterior-tail measurement (the + exterior estimate rests on the sampled profiles of section 3). `--check` replays this summary arithmetic + from the stored numbers. - The periodized `L = 12` direct integral (`h = 0.2`) agrees with far field plus hole to `2.0e-05` relative. - The Monte Carlo cross-check of the unconditional control (`2 . 10^5` samples, seed 2026) gives `E|det H| = 2.3032 +- 0.0058`, `4/sqrt3 = 2.3094` lying at `1.1` standard errors. diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json index af27d6166..792906abf 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 18192, - "sha256": "15caa19e19d8f03c55898bc48d1a42420552ce3f359aa2beb75cc75e81117910", - "git_blob": "1ffdead6acf9f68f751f8cfb39ebdff7d1cd172b" + "bytes": 18777, + "sha256": "aa15838fb0c842f1d24ab5bc883e3546f2ad993b719470df2556b35a9878cf69", + "git_blob": "47fc0fedf10d9e68b6eef69808c3f3f7993c06de" }, { "path": "README.md", @@ -25,15 +25,15 @@ }, { "path": "SOURCE_MAP.json", - "bytes": 6216, - "sha256": "ecbc258a67ada802cdaeae992bba84510578e21f7140f19a8d3b138226dff636", - "git_blob": "ffca4bbc02111882dfbd33aa60c94315d5c82605" + "bytes": 6900, + "sha256": "3f3be8f5877c667158aa7aad4249af83d8cbaba37f4e5b06ce7efb3913f84126", + "git_blob": "0d3f8b889d6c8f8e99ac14238d9f09e2889f73ab" }, { "path": "remote.py", - "bytes": 36447, - "sha256": "3e3f35ec128fb32c606ff7bab215024e6a7c4f41ff9efd44df7a8c4d3fa5ddf2", - "git_blob": "0eaf5e6c516cdd5224bdf1e15f8b66c509929dbe" + "bytes": 38800, + "sha256": "e31571b6aaa27bbb88de22fe75e31ac23bbf446dbc2ddc521fd8421ae1fe0116", + "git_blob": "9553e3a95484c2dd19b0f83a19a6837cb5c23675" } ], "nonauthor_reads": [ diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json index ffca4bbc0..0d3f8b889 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json +++ b/frontiers/c6_remote_coefficient_numerics_20260930/SOURCE_MAP.json @@ -86,6 +86,14 @@ "head": "a04fc81a8753769b8228419d33998aed0679fd30", "date": "2026-09-30", "disposition": "successor reassessment: the two Slice B amendments resolved, the formulation ACCEPT stands; one further wording repair for the truncation sentence (no universal relative bound; exterior figure an estimate), applied in the successor commit; Slice C still open; same account, credit 0" + }, + { + "lane": "OpenAI GPT-6 Astra Pro", + "review_id": 5364643055, + "head": "a8c6d7918061c62a2e523b6cda34e9b78c9ac320", + "date": "2026-09-30", + "disposition": "AMEND (reporting only): two stale NOTE section 5 sentences; applied in the successor commit (Rc = 5 minus Rc = 6 at h = 0.3 is 9.46e-5, not 2.1e-3; fitted-error figures labelled nonrigorous model extrapolations for k = 1, b = 0 only with the measured 1.88e-4 finest-grid difference; unequal effective Rc = 5 spacing 5/17 noted; L = 24 improvement stated as expectation, not measurement). Does not certify quadrature accuracy or the table.", + "slice": "C (empirical precision reporting)" } ] } diff --git a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py index 0eaf5e6c5..9553e3a95 100644 --- a/frontiers/c6_remote_coefficient_numerics_20260930/remote.py +++ b/frontiers/c6_remote_coefficient_numerics_20260930/remote.py @@ -742,7 +742,45 @@ def check_run(): for row in ref['near_zero_profile']['k=1.0,b=0.0']: if row['r'] == 0.1 and row['angle_deg'] == 0: require(abs(row['lambda'] - r['lambda']) <= REPLAY_TOL * max(abs(r['lambda']), 1e-30), 'near-zero replay') - print(json.dumps({'check': 'ok', 'controls': list(ctl.keys()), 'mutant': MUT})) + gs = grid_summary(ref) + print(json.dumps({'check': 'ok', 'controls': list(ctl.keys()), 'grid_summary': gs, 'mutant': MUT})) + + +def grid_summary(ref): + """Replay of the NOTE section 5 summary arithmetic from the stored grid_convergence block (k = 1, b = 0): + the Rc = 5 / Rc = 6 difference at h = 0.3, the finest-grid difference, the three-point power-law model + A(h) = A_0 + C h^p on the non-nested spacings 0.3, 0.15, 0.1 (a floating extrapolation, not a bound), the + default/high-order difference and the L = 12 direct/additive discrepancy.""" + g = ref['grid_convergence']['k=1.0,b=0.0'] + a3, a15, a1 = g['hole_h=0.3,Rc=6'], g['hole_h=0.15,Rc=6'], g['hole_h=0.1,Rc=6'] + d_rc = g['hole_h=0.3,Rc=5'] - a3 + d_fine = a15 - a1 + ratio = (a3 - a15) / (a15 - a1) + f = lambda p: (0.3 ** p - 0.15 ** p) / (0.15 ** p - 0.1 ** p) - ratio + lo, hi = 1.0, 5.0 + require(f(lo) * f(hi) < 0, 'power-law exponent bracketed in (1, 5)') + for _ in range(200): + mid = 0.5 * (lo + hi) + if f(lo) * f(mid) <= 0: + hi = mid + else: + lo = mid + p = 0.5 * (lo + hi) + C = (a3 - a15) / (0.3 ** p - 0.15 ** p) + A0 = a15 - C * 0.15 ** p + out = {'rc5_minus_rc6_h0.3': d_rc, 'h0.15_minus_h0.1': d_fine, 'model_p': p, 'model_A0': A0, + 'model_residual_h0.15': abs(a15 - A0), 'model_residual_h0.1': abs(a1 - A0), + 'default_minus_high_order_h0.3': a3 - g['hole_h=0.3,Rc=6,high_order'], + 'L12_direct_minus_additive_rel': (g['torus_L=12_direct_h=0.2'] - g['torus_L=12_approx']) / g['torus_L=12_direct_h=0.2'], + 'certified': False} + require(abs(d_rc + 9.46e-5) < 5e-8, 'Rc = 5 minus Rc = 6 at h = 0.3 is -9.46e-5 (NOTE section 5)') + require(abs(d_fine - 1.875e-4) < 5e-7, 'h = 0.15 minus h = 0.1 is 1.875e-4 (NOTE section 5)') + require(abs(p - 2.63) < 5e-3 and abs(A0 + 1.63143) < 5e-5, 'power-law model p = 2.63, A_0 = -1.63143 (NOTE section 5)') + require(abs(out['model_residual_h0.15'] - 2.86e-4) < 5e-6 and abs(out['model_residual_h0.1'] - 9.83e-5) < 5e-7, + 'model residuals 2.9e-4 (h = 0.15) and 9.8e-5 (h = 0.1) (NOTE section 5)') + require(abs(out['default_minus_high_order_h0.3']) < 5e-8, 'default/high-order difference below 5e-8 (NOTE section 5)') + require(abs(out['L12_direct_minus_additive_rel'] - 2.04e-5) < 1e-7, 'L = 12 direct/additive discrepancy 2.0e-5 relative (NOTE section 4)') + return out def main():