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/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 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. [x] Create PR169, read back exact bytes/identities, request nonauthor + algebra/integration and probability reviews, and observe initial-head 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. + +7. [x] Derive the separate companion-ratio unit-square law, its small-ratio/height + asymptotic and ideal-real rejection sampler; add fail-first exact controls. +8. [ ] Publish the additive successor with original main proof/code unchanged, + request separate Slice D review, and read its actual hosted results. + +Ruling: the companion sampler is explicitly ordinary floating point, while all +normalization/envelope/acceptance constants are checked by exact rational algebra. +Ruling: adopt the peer's physical-order counterexample as credited support only; +it validates the scope boundary and is not an independent mathematical verdict. 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..e5c71f7ec --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/README.md @@ -0,0 +1,130 @@ +# 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. + +## Separate companion-ratio addendum + +COMPANION_RATIO.md adds a unit-square parametrization of the limiting extreme +DOUBLE cluster. Its explicit positive rational density determines both heights +and the companion/maximum radius ratio rho, without an unknown Gaussian integral. +It gives the further small-ratio law + + P(rho0, 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/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..f9220a2e0 --- /dev/null +++ b/frontiers/extreme_cluster_sampling_20260930/VALIDATION.md @@ -0,0 +1,126 @@ +# 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. + +## 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/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/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_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()