From 7ab0d31b09b9d93272b5b0f635aa1d80a662130c Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 20:31:47 -0500 Subject: [PATCH 1/2] 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 56a7904f9ad7d409c31e23195c0e7eeab230613a Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 20:55:56 -0500 Subject: [PATCH 2/2] 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