From 877f8825656ec41e4fd5a955225e0bf184ff3800 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 16:10:48 -0500 Subject: [PATCH 1/4] Add conditional C6 rare-cluster laws, sharp Poisson obstruction and exact controls OpenAI/ChatGPT author-side consequence packet; nonauthor review open. Six scoped abstract consequences of pinned C6/D5 inputs, no source/status/Boolean changes. Canonical r-dependent compound Poissonization is explicitly non-predictive; independent replicas are not spatial independence. Local 28-test suite passed in normal and optimized modes; source-object and repository-wide hosted checks remain separate. --- .github/workflows/c6-rare-cluster-laws.yml | 35 ++++ .../c6_rare_cluster_laws_20260929/PROOF.md | 145 ++++++++++++++ .../c6_rare_cluster_laws_20260929/README.md | 21 ++ .../RECONNAISSANCE.md | 13 ++ .../RESULTS.json | 15 ++ .../SOURCE_FILES.json | 55 ++++++ .../SOURCE_PINS.json | 33 ++++ .../cluster_check.py | 184 ++++++++++++++++++ .../test_cluster_check.py | 152 +++++++++++++++ .../verify_packet.py | 86 ++++++++ 10 files changed, 739 insertions(+) create mode 100644 .github/workflows/c6-rare-cluster-laws.yml create mode 100644 frontiers/c6_rare_cluster_laws_20260929/PROOF.md create mode 100644 frontiers/c6_rare_cluster_laws_20260929/README.md create mode 100644 frontiers/c6_rare_cluster_laws_20260929/RECONNAISSANCE.md create mode 100644 frontiers/c6_rare_cluster_laws_20260929/RESULTS.json create mode 100644 frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json create mode 100644 frontiers/c6_rare_cluster_laws_20260929/SOURCE_PINS.json create mode 100644 frontiers/c6_rare_cluster_laws_20260929/cluster_check.py create mode 100644 frontiers/c6_rare_cluster_laws_20260929/test_cluster_check.py create mode 100644 frontiers/c6_rare_cluster_laws_20260929/verify_packet.py diff --git a/.github/workflows/c6-rare-cluster-laws.yml b/.github/workflows/c6-rare-cluster-laws.yml new file mode 100644 index 000000000..2c7b8b261 --- /dev/null +++ b/.github/workflows/c6-rare-cluster-laws.yml @@ -0,0 +1,35 @@ +name: C6 rare-cluster consequence checks + +'on': + pull_request: + paths: + - 'frontiers/c6_rare_cluster_laws_20260929/**' + - '.github/workflows/c6-rare-cluster-laws.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 immutable public premise object + run: | + set -euo pipefail + git fetch --no-tags --depth=1 origin 78ac1100217279e7b692f0959f86eee34cd1910e + - name: Verify identities, both Python modes and negative controls + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S frontiers/c6_rare_cluster_laws_20260929/verify_packet.py + git diff --exit-code diff --git a/frontiers/c6_rare_cluster_laws_20260929/PROOF.md b/frontiers/c6_rare_cluster_laws_20260929/PROOF.md new file mode 100644 index 000000000..2ab625ced --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/PROOF.md @@ -0,0 +1,145 @@ +# Rare-cluster consequences of the sharp C6 moment bounds + +**Object:** OA-C6-RARE-CLUSTER-20260929-v1. **Author:** OpenAI / ChatGPT, current owner-authorized session, 29 September 2026. +**Disposition:** author-side conditional proof candidate; nonauthor review OPEN. **Scientific effect: NONE.** No source proof, status register, Boolean, prize or acceptance disposition is changed. Same GitHub account as the other model lanes: no organizational-independence claim. + +## 1. Exact interface and dependency boundary + +Use the count N=N_r under the original determinant-tilted pinned law Q_r^W of [C6, Section 1.1]: all-index critical points, excluding the two conditioned endpoints, with heights strictly between b-k r^3 and b. Fix d>=2, the torus side L, compact birth marks and compact positive gap marks k>=k_->0. The source covariance, conditioning, full normalizer and frames are unchanged. All constants below inherit this scope; none is numerical or uniform as d,L or the marks escape it. + +Put e=r^3. The ONLY analytic inputs to this note are + + (H1) E N <= A e, + (H2) P(N>=2) >= a e, where a>0, + (Hq) E (N)_q <= A_q e for every fixed integer q>=2. + +Here (N)_q=N(N-1)...(N-q+1), and A_1=A. [D5, Theorem G_d], summed over the fixed d+1 indices, gives H1. [C6, Corollary Theta] gives H2, and [C6, Theorem Q] gives Hq. Thresholds may be decreased for each finite collection of moment orders; no uniform-in-q assertion is needed. These premises imply 2a<=A. + +Both sources are pinned to commit 78ac1100217279e7b692f0959f86eee34cd1910e, with full byte identities in SOURCE_PINS.json. Their recorded nonauthor reviews do not constitute a review of this new note. The parent Gaussian proofs are not revalidated here. A defect in an input blocks the corresponding application, not the elementary abstract implication. + +[C6] frontiers/c6_palm_route_20260929/PROOF.md, Theorem Q and Corollary Theta. +[D5] frontiers/d5_dimension_lift_20260929/PROOF.md, Theorem G_d. +[LOCAL] frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md, Section 7, already proves the exact-mean Bernoulli-configuration obstruction. That result is prior in-project work, not a new claim of this note. + +For probability laws, dTV is the supremum over measurable events, equivalently half the l1 distance on this countable state space. Norms of finite or signed measures written ||.||_1 mean full l1, without the factor 1/2. + +## 2. Conditional counts and size-biased counts are different + +Write p=P(N>0), mu=E N, let J have law F=Law(N | N>0), and let Y have size-biased law P(Y=n)=n P(N=n)/mu. Then + + a e <= p <= A e, 2a e <= mu <= A e. (2.1) + +For each integer k>=1, define B_k=sum_{j=1}^k S(k,j) A_j, where S(k,j) are the nonnegative Stirling numbers of the second kind. The pointwise identity n^k=sum_j S(k,j)(n)_j gives + + E N^k <= B_k e, + E J^k <= B_k/a, E Y^k <= B_{k+1}/(2a). (2.2) + +Consequently both families are tight and every fixed power is uniformly integrable (use the next power in Markov's tail bound). Moreover + + P(J>=2) >= a/A, + E J-1 >= a/A, + 2a/A <= E(Y-1)=E(N)_2/mu <= A_2/(2a). (2.3) + +The exact difference between the two excess means is + + E(Y-1) - E(J-1) = Var(J)/E J >= 0. (2.4) + +Indeed P(Y=n)=n F(n)/E J, so E Y=E J^2/E J. This proves (2.4). It does not assert that the two sampling laws are equal: J taking 1 and 3 with probabilities 1/2 each has mean excess 1, while Y has mean excess 3/2. The new use of all-order C6 bounds is (2.2) and its compactness consequences, not merely the distinction already stated in C6's Corollary P. + +## 3. Sharp ordinary-Poisson obstruction, including optimized intensity + +**Theorem O.** Under H1 and H2 alone, for all sufficiently small r, + + (a/2) r^3 <= inf_{lambda>=0} dTV(Law N, Pois(lambda)) <= A r^3. (3.1) + +The same order holds for lambda=mu. Thus an ordinary Poisson law cannot achieve o(r^3) error, even by fitting an arbitrary intensity. Absolute distance still tends to zero; this is an obstruction at the rare-event scale, not a claim that the distance is bounded away from zero. + +**Proof.** Take e<=min{a/(4A^2),1/(4A)}. If lambda<=2Ae, then + + P(Pois(lambda)>=2) <= lambda^2/2 <= 2A^2 e^2, + +by the second factorial moment of a Poisson variable. Testing {n>=2} gives distance at least ae/2. If lambda>2Ae, test {n>0}; monotonicity and 1-exp(-x)>=x-x^2/2 give + + 1-exp(-lambda)-p >= 1-exp(-2Ae)-Ae + >= Ae-2A^2 e^2 >= Ae/2 >= ae/2. + +The upper bound in (3.1) uses Pois(0)=delta_0 and dTV(Law N,delta_0)=p. For mean matching, the triangle inequality through delta_0 gives at most p+1-exp(-mu)<=2Ae, and the same lower bound applies. This proves the theorem. Notice that Hq is not needed. + +Conditioning a mean-matched Poisson variable on positivity does not cure the discrepancy: its probability of being >=2 tends to zero as mu->0, whereas F([2,infinity))>=a/A. Therefore the conditional TV discrepancy has liminf at least a/A. + +## 4. Canonical r-dependent compound Poissonization: sharp r^6 error + +Let C_r have the compound Poisson law CP(p,F): K~Pois(p), independent positive integer marks J_1,J_2,... with law F, and C_r=sum_{i=1}^K J_i. The empty sum is zero. + +**Theorem C.** Under H1 and H2, for p<=1, + + p^2/3 <= dTV(Law N, Law C_r) <= p(1-exp(-p)) <= p^2. (4.1) + +In particular the error for THIS approximant is Theta(r^6), with bounds a^2 r^6/3 and A^2 r^6. Its mean is exactly mu. + +**Proof.** Law N=(1-p)delta_0+pF. Apply the same mark-summing probability kernel to a Bernoulli(p) count and a Pois(p) count. Total variation contracts under that kernel. The Bernoulli law has its sole positive difference at count 1, of mass p-p exp(-p), so their TV distance is exactly p(1-exp(-p))<=p^2. Positivity of all marks means P(C_r=0)=exp(-p). Testing the zero event gives + + dTV >= exp(-p)-1+p >= p^2/2-p^3/6 >= p^2/3. + +The Taylor inequalities follow from their signed integral remainders on p>=0. Finally E C_r=p E J=E N. + +**Essential limitation.** F is the actual, generally unknown, r-dependent conditional count law. This is a universal re-expression/Poissonization of a rare occurrence, not an explicitly identified cluster law, an asymptotic independence theorem, or a spatial Poisson-cluster process. No novelty is asserted for this elementary generic probability construction. The cluster rate is p, NOT mu: replacing it by mu changes the mean to mu E J in general. The r^6 lower bound is for CP(p,F), not a minimax lower bound over every conceivable compound Poisson parameterization. + +## 5. Factorial-moment matching to second rare-event order + +Let a_j=E(N)_j. Under Hq, for each fixed integer q>=1, + + E(C_r)_q = sum_{pi in Partitions({1,...,q})} product_{B in pi} a_{|B|}. (5.1) + +For q=1 this equals mu. For q>=2, + + 0 <= E(C_r)_q-E(N)_q = O_q(e^2)=O_q(r^6). (5.2) + +**Proof.** Conditional on K, expand the ordered selections of q distinct items in the sum of its independent integer-valued marks. A set partition of the q labels specifies which labels belong to the same mark; if it has j blocks its expectation is E(K)_j times the product of the mark factorial moments. Since E(K)_j=p^j and p E(J)_b=a_b, summing gives (5.1). All terms are nonnegative and moments finite, so Tonelli applies. No moment-generating-function analyticity is assumed. The single-block partition contributes a_q. Every other partition has at least two blocks; each a_b=O(e), and there are finitely many partitions for fixed q, proving (5.2). In particular the second-moment correction is exactly mu^2. + +## 6. Subsequential finite cluster-intensity measures, not a unique limit + +Define a finite measure on the positive integers by + + nu_r(n)=r^(-3) P(N_r=n), lambda_r=nu_r(N_+)=p/r^3. + +Then a<=lambda_r<=A, nu_r({2,3,...})>=a, and sum n^k nu_r(n)<=B_k for k>=1 (use B_0=A for mass). + +**Theorem S.** Every sequence r_i->0 has a subsequence and a finite measure nu on N_+ such that for every fixed nonnegative integer k, + + sum_{n>=1} n^k |nu_{r_i}(n)-nu(n)| -> 0. (6.1) + +Its mass lambda is in [a,A], and nu({2,3,...})>=a. Along that subsequence the positive conditional laws converge to nu/lambda in TV and all fixed moments. The size-biased laws converge to n nu(n)/sum_m m nu(m), also in TV and all fixed moments. + +**Proof.** Each coordinate is bounded by A. Diagonal selection gives coordinatewise convergence. Fatou preserves the moment bounds. For every k>=0 and M>=1, + + sum_{n>M} n^k nu_r(n) <= B_{k+1}/M, + +and the same holds for nu. On the finite set n<=M coordinatewise convergence gives weighted l1 convergence. First take the subsequence limit and then M->infinity. The SAME selected subsequence works for every k because it was selected only by coordinates and has all these tail bounds. Mass and the multiple-count lower bound pass to the limit by k=0 convergence. Denominators for the two normalized laws stay bounded below by a and 2a, respectively, so their claims follow from (6.1), using one extra power for size bias. + +There is also the exact signed-measure identity + + Law N_r = delta_0 + r^3 (nu_r-lambda_r delta_0). (6.2) + +Thus (6.1) gives a first-order signed-measure expansion along each selected subsequence. It gives neither uniqueness nor a rate for nu_r->nu. + +**Sharp non-implications.** Set P(N_r>0)=r^3 and let the positive count alternate between 2 and 3 on successive dyadic intervals of r. H1,H2 and every Hq hold, but nu_r alternates between delta_2 and delta_3. Taking N_r=2 Bernoulli(r^3) also shows that no positive lower bound for the third or higher factorial moments follows. Finally, all polynomial moments need not imply any exponential moment: let P(J=2^j) be proportional to 2^(-j^2), j>=1. Every polynomial moment is finite, whereas E exp(tJ)=infinity for each t>0. The rare mixture with probability r^3 satisfies H1,H2,Hq. These examples concern what the premises alone imply, not counterexamples to the specific Gaussian model having additional structure. + +## 7. Independent-replica limit, with an explicit extra assumption + +Take m_r=floor(t/r^3) INDEPENDENT copies of the entire count N_r, for fixed t>=0, and let T_r be their sum. Along a subsequence from Theorem S, + + dTV(Law T_r, CP(t nu)) + <= t A^2 r^3 + A r^3 + t ||nu_r-nu||_1 -> 0. (7.1) + +Here CP(t nu) denotes the compound Poisson law with finite Levy measure t nu, with no jump of size zero. + +**Proof.** Couple each copy to its Section 4 approximant: the total error is at most m_r p^2<=t A^2 r^3. The sum of the independent approximants has Levy measure m_r r^3 nu_r. Two finite Levy measures eta,zeta can be coupled by sharing their pointwise minimum and independent residual Poisson jumps; their compound count laws have TV distance at most ||eta-zeta||_1. Apply + + ||m_r r^3 nu_r-t nu||_1 <= r^3 A + t ||nu_r-nu||_1. + +No independence of windows or spatial cells in ONE field has been proved. Such a use needs a new dependence estimate. Equation (7.1) is a theorem about deliberately independent experiments, not a new spatial claim about the original torus. + +## 8. Review and verification boundary + +Requested nonauthor slices: (A) optimized-intensity Poisson bound and exact binary-kernel constants; (B) factorial partitions, weighted-l1 compactness and the independent-replica coupling; (C) source interface and non-claims. The checker covers exact finite identities, rational probes and explicit false variants only. Neither it nor a green workflow proves H1/H2/Hq, validates all infinite-dimensional arguments, or promotes any register. There is no Lean formalization of this packet. External primary-source reconnaissance is recorded separately, without claiming a comprehensive novelty audit. diff --git a/frontiers/c6_rare_cluster_laws_20260929/README.md b/frontiers/c6_rare_cluster_laws_20260929/README.md new file mode 100644 index 000000000..81730051a --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/README.md @@ -0,0 +1,21 @@ +# C6 rare-cluster consequence candidate + +Author-side conditional proof, nonauthor review OPEN. Scientific effect NONE. No register, Boolean, proof-index disposition or parent source is changed. Shared GitHub login is not organizational independence. + +PROOF.md derives six consequences of the exact C6/D5 count interface: conditional and size-biased moment bounds; a sharp r^3 ordinary-Poisson obstruction for arbitrary fitted intensity; a canonical r-dependent compound-Poisson representation with sharp r^6 error; factorial-moment matching to order r^6; subsequential weighted-l1 cluster-intensity limits; and a compound-Poisson limit for deliberately independent replicas only. + +The r^6 approximant uses the actual unknown conditional positive-count law. It is NOT an explicit limiting cluster law. Limits need not be unique from the premises alone. No spatial independence or higher-factorial lower bound is claimed. The ordinary-Poisson and canonical-compound TV bounds need only the first-moment upper and multiple-event lower bounds; C6's all-order upper bounds are used for conditional moments and compactness. + +## Replay + + python -B -S verify_packet.py + +Run from this directory in a Git checkout containing the exact source commit in SOURCE_PINS.json. The verifier checks source bytes, all packet identities, 28 unit tests in each Python mode, deterministic output, seven rejected semantic mutants per mode, and unknown-mutant rejection. Source objects may be fetched read-only using the exact pinned commit; the workflow does this. Full repository/formal checks are separate and remain mandatory. + + python -B -S verify_packet.py --local-only + +This explicitly excludes Git source-object verification and reports source_pins_checked=false. It is useful for the downloadable standalone packet, not a substitute for hosted source verification. Python standard library only. No Lean/formal verification of these claims is asserted. + +## Nonauthor review requested + +Claude/xAI Slice A: PROOF Sections 3–4, especially arbitrary fitted Poisson intensity and both compound TV constants. Slice B: Sections 5–7, including absence of moment-generating-function assumptions, weighted-l1 compactness and the independent-replica limitation. Either lane: source interface and scope. A request is not an acknowledged pickup or an acceptance. The author will not self-merge. diff --git a/frontiers/c6_rare_cluster_laws_20260929/RECONNAISSANCE.md b/frontiers/c6_rare_cluster_laws_20260929/RECONNAISSANCE.md new file mode 100644 index 000000000..20937d5df --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/RECONNAISSANCE.md @@ -0,0 +1,13 @@ +# External reconnaissance — 29 September 2026 + +Scope: locate relevant existing probability frameworks and prevent claiming elementary Poissonization as novel. This is a narrow reconnaissance memo, not an exhaustive novelty audit or an external acceptance of the project's Gaussian estimates. + +An actual Consensus search for "Gaussian random fields critical points factorial moments rare clusters Palm conditional distribution compound Poisson approximation domain:math" returned: all 30 monthly searches used, resetting October 1. No result was returned or attributed to Consensus. + +Primary arXiv abstract/metadata pages were opened directly: + +1. Louis Gass and Michele Stecconi, *The number of critical points of a Gaussian field: finiteness of moments*, arXiv:2305.17586v2, 19 July 2023. https://arxiv.org/abs/2305.17586 . Proves finite critical-count moments under finite-jet nondegeneracy. Finiteness by itself is not the uniform rare-pinned O(r^3) input used here. +2. Louis H. Y. Chen and Aihua Xia, *Stein's method, Palm theory and Poisson process approximation*, Annals of Probability 32 (2004), 2545–2569, DOI 10.1214/009117904000000027; arXiv:math/0410169. https://arxiv.org/abs/math/0410169 . Existing Palm/Stein/local-dependence framework. This note does not derive a Stein bound or silently identify positivity conditioning with size bias. +3. Michael V. Boutsikas and Eutichia Vaggelatou, *A new method for obtaining sharp compound Poisson approximation error estimates for sums of locally dependent random variables*, Bernoulli 16 (2010), 301–330, DOI 10.3150/09-BEJ201; arXiv:1010.1625. https://arxiv.org/abs/1010.1625 . Existing Poisson and compound-Poisson TV approximation for independent or locally dependent nonnegative integer variables. No novel generic Poissonization method is claimed here. + +Access depth: these three metadata/abstract pages, not a theorem-by-theorem full-text audit. None is imported as an unverified proof step: PROOF.md gives the elementary implications in full and names the in-project analytic premises separately. No statement that the conditional cluster law is absent from all literature, no spatial independence, and no priority claim follows from this reconnaissance. diff --git a/frontiers/c6_rare_cluster_laws_20260929/RESULTS.json b/frontiers/c6_rare_cluster_laws_20260929/RESULTS.json new file mode 100644 index 000000000..fece0ebe5 --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/RESULTS.json @@ -0,0 +1,15 @@ +{ + "groups": [ + "conditional-versus-size-biased", + "compound-rate-and-factorial-moments", + "ordinary-from-factorial-moments", + "poisson-obstruction-exact-probes", + "compound-TV-bounds-and-r6-ledger", + "nonclaims-counterexamples" + ], + "mathematical_acceptance": false, + "passed": true, + "schema": 1, + "scientific_effect": "NONE", + "scope": "finite exact identities and probes only" +} diff --git a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..3928e7df0 --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json @@ -0,0 +1,55 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW_OPEN", + "files": [ + { + "path": "PROOF.md", + "bytes": 11811, + "sha256": "c52a3cf197b5cf26071a8cc951e15ef3ac564b3d7453d41647f91af540a1b8eb", + "git_blob": "2ab625cedfc2e47575c4a7fa4853413418c532da" + }, + { + "path": "README.md", + "bytes": 2375, + "sha256": "ab26bff7586242d34518a2a8932428eae3a73f3acb4fca6a4e061e22b2dacea7", + "git_blob": "81730051ac12f37f02bc64892b170d1b0d3d06c7" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 2224, + "sha256": "cfea8bef86e21cbba34d7bb3a71fc25349623d8a0e5d714229ecdd85d0f080c1", + "git_blob": "20937d5dfc6fd93039a910b6793ed5cbfddf9105" + }, + { + "path": "RESULTS.json", + "bytes": 408, + "sha256": "67578132cbc2cac0029f0d138cc847f0484c38b6cdfabc4b62614ebc29df5bc4", + "git_blob": "fece0ebe53b1c42f71c9d8585da1ba86ede1d374" + }, + { + "path": "SOURCE_PINS.json", + "bytes": 1676, + "sha256": "2c5a2523bf186c0f057b1c309b00f927c3121f85b34f341d7ad9f194acf45ba2", + "git_blob": "21f7ee3f09334baf8033f8c0d8b880912e473016" + }, + { + "path": "cluster_check.py", + "bytes": 6243, + "sha256": "fa73f2cd3edd814b88d8e3da0c956e1d288ebeb82ff48f3daac389246a098045", + "git_blob": "ec24cd14ea1b0cc3971a9cb81875c7ab5e6c273e" + }, + { + "path": "test_cluster_check.py", + "bytes": 5255, + "sha256": "a89a89b4807e6dac175680a858adddf9a3a9dfe5287182dc54f657e7c0b94662", + "git_blob": "c1d58690b2b3ad7770c99a6eec1cab5051075d03" + }, + { + "path": "verify_packet.py", + "bytes": 3619, + "sha256": "6359e10c8a8dea466a44728507962dbb505e0d05852d3650e5b76fd9a5c4104f", + "git_blob": "29e0e82fd7b94709d7488959c053161ac5d3f88e" + } + ] +} diff --git a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_PINS.json b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_PINS.json new file mode 100644 index 000000000..21f7ee3f0 --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_PINS.json @@ -0,0 +1,33 @@ +{ + "schema": 1, + "repository": "d6g8k5htny-coder/Math-", + "scientific_effect": "NONE", + "scope": "Mathematical premise identities, not automatic status acceptance", + "sources": [ + { + "id": "C6", + "commit": "78ac1100217279e7b692f0959f86eee34cd1910e", + "path": "frontiers/c6_palm_route_20260929/PROOF.md", + "bytes": 53364, + "sha256": "aa37f16040ab9e05bb2e4e3f1d678367497e8dc2cf43eef197a4d6592c2f129b", + "git_blob": "89eb8adf08fe7afc2cab9662d3a9875c05ae5cc5", + "use": "Section 1.1 original count/law; Theorem Q factorial upper bounds; Corollary Theta multiple-occurrence lower bound", + "review_context": "PR145 records nonauthor review 5358116559 at 06bc0d6 and provenance-only successors; this is not a review of this new consequence packet. A stale top-level SOURCE_MAP note at the pinned head was separately reported in PR145 comment 5898765203." + }, + { + "id": "D5", + "commit": "78ac1100217279e7b692f0959f86eee34cd1910e", + "path": "frontiers/d5_dimension_lift_20260929/PROOF.md", + "bytes": 53727, + "sha256": "6fb94b247e8e45bca9dc02f46670ac6029fb54e0ef906001efe48fe908549b80", + "git_blob": "9d82c707fdb17d3072a8930f26dabedf59e456fc", + "use": "Theorem G_d, summed over d+1 fixed indices, for the first-moment bound" + } + ], + "prior_in_project_result": { + "commit": "78ac1100217279e7b692f0959f86eee34cd1910e", + "path": "frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md", + "git_blob": "b5c18aac5529c5f975ee5bb056b304debafc6697", + "use": "Section 7 already establishes the exact-mean Bernoulli obstruction; not claimed as new and not used as a premise" + } +} diff --git a/frontiers/c6_rare_cluster_laws_20260929/cluster_check.py b/frontiers/c6_rare_cluster_laws_20260929/cluster_check.py new file mode 100644 index 000000000..ec24cd14e --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/cluster_check.py @@ -0,0 +1,184 @@ +"""Exact finite controls for the conditional rare-cluster consequence packet. + +Standard library only. No Gaussian proof or statistical estimation is performed. +All probability inputs are exact int/Fraction values, never binary floats. +""" +import argparse +import json +import math +from fractions import Fraction as F +from functools import lru_cache + +MUTANTS = ('palm-is-conditional', 'cp-rate-is-mean', 'erase-cross-term', + 'third-lower', 'unique-limit', 'wrong-r6-ledger', 'ordinary-poisson') + + +def natural(n): + if type(n) is not int or n < 0: + raise ValueError('nonnegative integer required') + return n + + +def rational(x): + if type(x) not in (int, F): + raise ValueError('exact int/Fraction required') + return F(x) + + +def validate(law): + if not isinstance(law, dict) or not law: + raise ValueError('nonempty finite PMF mapping required') + out = {natural(n): rational(p) for n, p in law.items()} + if any(p < 0 for p in out.values()) or sum(out.values()) != 1: + raise ValueError('nonnegative masses summing to one required') + return out + + +def falling(n, q): + natural(n) + natural(q) + return math.prod(n-j for j in range(q)) if q <= n else 0 + + +@lru_cache(maxsize=None) +def stirling(n, k): + natural(n) + natural(k) + if n == 0: + return int(k == 0) + if k == 0 or k > n: + return 0 + return k*stirling(n-1, k) + stirling(n-1, k-1) + + +def moment(law, q, factorial=False): + law = validate(law) + natural(q) + return sum((p*(falling(n, q) if factorial else n**q) + for n, p in law.items()), F(0)) + + +def tilt(law, size_biased=False): + law = validate(law) + weights = {n: p*(n if size_biased else 1) for n, p in law.items() if n > 0} + total = sum(weights.values(), F(0)) + if total == 0: + raise ValueError('positive occurrence probability required') + return {n: p/total for n, p in weights.items() if p > 0} + + +def cp_moments(law, q): + """Factorial moments of CP(p, Law(N | N>0)); NOT CP(E N, ...).""" + natural(q) + law = validate(law) + a = [F(0)] + [moment(law, j, True) for j in range(1, q+1)] + bell = [F(1)] + for n in range(1, q+1): + bell.append(sum((math.comb(n-1, j-1)*a[j]*bell[n-j] + for j in range(1, n+1)), F(0))) + return bell + + +def exp_bounds(x, degree=40): + """Taylor lower/upper rational bounds on exp(-x), x >= 0. + + The odd/even Taylor remainder signs hold by Lagrange's formula, even + before terms decrease. Clipping to [0,1] is safe for x >= 0. + """ + x = rational(x) + natural(degree) + if x < 0 or degree % 2: + raise ValueError('x >= 0 and even degree required') + upper = sum(((-x)**j/F(math.factorial(j)) for j in range(degree+1)), F(0)) + lower = upper - x**(degree+1)/math.factorial(degree+1) + return max(F(0), lower), min(F(1), upper) + + +def poisson_tv(law, rate): + """Enclose exact TV via overlap; the Poisson tail is NOT discarded.""" + law = validate(law) + rate = rational(rate) + lo, hi = exp_bounds(rate) + overlap_lo = sum((min(p, lo*rate**n/math.factorial(n)) + for n, p in law.items()), F(0)) + overlap_hi = sum((min(p, hi*rate**n/math.factorial(n)) + for n, p in law.items()), F(0)) + return 1-overlap_hi, 1-overlap_lo + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def run_checks(mutant=None): + groups = [] + law = {0: F(3, 4), 1: F(1, 8), 3: F(1, 8)} + j = tilt(law) + y = j if mutant == 'palm-is-conditional' else tilt(law, True) + ej = moment(j, 1) + require(moment(y, 1)-ej == (moment(j, 2)-ej**2)/ej, 'Palm variance identity') + groups.append('conditional-versus-size-biased') + + p = 1-law.get(0, 0) + mu = moment(law, 1) + rate = mu if mutant == 'cp-rate-is-mean' else p + require(rate*ej == mu, 'compound occurrence rate, not count mean') + second = cp_moments(law, 2)[2] + if mutant == 'erase-cross-term': + second -= mu**2 + if mutant == 'ordinary-poisson': + second = mu**2 + require(second == moment(law, 2, True)+mu**2, 'compound second factorial moment') + groups.append('compound-rate-and-factorial-moments') + + for n in range(12): + for q in range(1, 9): + require(n**q == sum(stirling(q, k)*falling(n, k) for k in range(1, q+1)), + 'Stirling identity') + groups.append('ordinary-from-factorial-moments') + + eps = F(1, 128) + two = {0: 1-eps, 2: eps} + # A=2, a=1 meets the theorem's small-epsilon thresholds. + for rate in [F(i, 128) for i in range(33)] + [F(1), F(2), F(4)]: + lo, hi = poisson_tv(two, rate) + require(eps/2 <= lo <= hi <= 1, 'ordinary Poisson obstruction probes') + groups.append('poisson-obstruction-exact-probes') + + for p in [F(1, 100), F(1, 8), F(1, 2), F(1)]: + lo, hi = exp_bounds(p) + require(lo-1+p >= p*p/3, 'zero-event compound lower bound') + require(p*(1-lo) <= p*p, 'binary-kernel compound upper bound') + require(lo-1+p <= p*(1-hi), 'ordered compound bounds') + order = 5 if mutant == 'wrong-r6-ledger' else 2*3 + require(order == 6, 'epsilon squared is r to the sixth') + groups.append('compound-TV-bounds-and-r6-ledger') + + third = moment(two, 3, True) + require(third > 0 if mutant == 'third-lower' else third == 0, + 'no third-factorial lower bound follows') + lhs, rhs = {2: F(1)}, {3: F(1)} + require(lhs == rhs if mutant == 'unique-limit' else lhs != rhs, + 'oscillating intensity counterexample') + groups.append('nonclaims-counterexamples') + return {'schema': 1, 'passed': True, 'groups': groups, + 'scientific_effect': 'NONE', 'mathematical_acceptance': False, + 'scope': 'finite exact identities and probes only'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--mutant', choices=MUTANTS) + args = parser.parse_args() + try: + result = run_checks(args.mutant) + except ValueError as exc: + print(json.dumps({'passed': False, 'error': str(exc)}, sort_keys=True)) + return 1 + print(json.dumps(result, indent=2, sort_keys=True)) + return 0 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/frontiers/c6_rare_cluster_laws_20260929/test_cluster_check.py b/frontiers/c6_rare_cluster_laws_20260929/test_cluster_check.py new file mode 100644 index 000000000..c1d58690b --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/test_cluster_check.py @@ -0,0 +1,152 @@ +"""Exact finite regression tests; not a Gaussian-field proof.""" +import subprocess +import sys +import unittest +from fractions import Fraction as F +from pathlib import Path +import cluster_check as c + + +class ClusterTests(unittest.TestCase): + def setUp(self): + self.law = {0: F(3, 4), 1: F(1, 8), 3: F(1, 8)} + + def test_validate(self): + self.assertEqual(c.validate(self.law), self.law) + + def test_negative_mass(self): + with self.assertRaises(ValueError): + c.validate({0: F(2), 1: F(-1)}) + + def test_float_rejected(self): + with self.assertRaises(ValueError): + c.validate({0: 1.0}) + + def test_bool_key_rejected(self): + with self.assertRaises(ValueError): + c.validate({True: F(1)}) + + def test_bad_mass(self): + with self.assertRaises(ValueError): + c.validate({0: F(1, 2)}) + + def test_negative_key(self): + with self.assertRaises(ValueError): + c.validate({-1: F(1)}) + + def test_positive_law(self): + self.assertEqual(c.tilt(self.law, False), {1: F(1, 2), 3: F(1, 2)}) + + def test_size_bias(self): + self.assertEqual(c.tilt(self.law, True), {1: F(1, 4), 3: F(3, 4)}) + + def test_empty_condition(self): + with self.assertRaises(ValueError): + c.tilt({0: F(1)}, False) + + def test_empty_size_bias(self): + with self.assertRaises(ValueError): + c.tilt({0: F(1)}, True) + + def test_zero_moment(self): + self.assertEqual(c.moment(self.law, 0), 1) + + def test_first_moment(self): + self.assertEqual(c.moment(self.law, 1), F(1, 2)) + + def test_factorial_second(self): + self.assertEqual(c.moment(self.law, 2, True), F(3, 4)) + + def test_falling_above_support(self): + self.assertEqual(c.falling(2, 3), 0) + + def test_invalid_order(self): + with self.assertRaises(ValueError): + c.moment(self.law, -1) + + def test_stirling_identity(self): + for n in range(8): + for q in range(1, 8): + self.assertEqual(n**q, sum(c.stirling(q, j) * c.falling(n, j) + for j in range(1, q + 1))) + + def test_palm_variance_identity(self): + j, y = c.tilt(self.law, False), c.tilt(self.law, True) + mean = c.moment(j, 1) + self.assertEqual(c.moment(y, 1) - mean, + (c.moment(j, 2) - mean**2) / mean) + + def test_bell_two(self): + self.assertEqual(c.cp_moments(self.law, 2)[2], F(1)) + + def test_bell_three(self): + a = [c.moment(self.law, j, True) for j in range(1, 4)] + self.assertEqual(c.cp_moments(self.law, 3)[3], a[2]+3*a[1]*a[0]+a[0]**3) + + def test_bell_vs_partitions(self): + def partitions(xs): + if not xs: + yield [] + return + for p in partitions(xs[1:]): + yield [[xs[0]]] + p + for i in range(len(p)): + yield p[:i] + [[xs[0]] + p[i]] + p[i+1:] + for q in range(1, 7): + total = F(0) + for p in partitions(list(range(q))): + term = F(1) + for block in p: + term *= c.moment(self.law, len(block), True) + total += term + self.assertEqual(c.cp_moments(self.law, q)[q], total) + + def test_exp_zero(self): + self.assertEqual(c.exp_bounds(F(0)), (F(1), F(1))) + + def test_exp_nested(self): + for x in [F(1, 10), F(1), F(3)]: + lo, hi = c.exp_bounds(x, 20) + lo2, hi2 = c.exp_bounds(x, 40) + self.assertLessEqual(lo, lo2) + self.assertLessEqual(hi2, hi) + self.assertLessEqual(lo2, hi2) + + def test_exp_negative_rejected(self): + with self.assertRaises(ValueError): + c.exp_bounds(F(-1)) + + def test_poisson_zero_rate(self): + self.assertEqual(c.poisson_tv(self.law, F(0)), (F(1, 4), F(1, 4))) + + def test_poisson_zero_law(self): + lo, hi = c.poisson_tv({0: F(1)}, F(1, 2)) + elo, ehi = c.exp_bounds(F(1, 2)) + self.assertEqual((lo, hi), (1-ehi, 1-elo)) + + def test_nonunique_intensities(self): + self.assertNotEqual({2: F(1)}, {3: F(1)}) + + def test_no_third_lower_bound(self): + self.assertEqual(c.moment({0: F(7, 8), 2: F(1, 8)}, 3, True), 0) + + def test_main_and_mutants(self): + script = str(Path(c.__file__).resolve()) + reference = None + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + run = subprocess.run([sys.executable, *flags, script], capture_output=True) + self.assertEqual(run.returncode, 0, run.stderr) + if reference is None: + reference = run.stdout + self.assertEqual(run.stdout, reference) + for name in c.MUTANTS: + run = subprocess.run([sys.executable, *flags, script, '--mutant', name], + capture_output=True) + self.assertEqual(run.returncode, 1, (name, run.stdout, run.stderr)) + run = subprocess.run([sys.executable, *flags, script, '--mutant', 'unknown'], + capture_output=True) + self.assertEqual(run.returncode, 2) + + +if __name__ == '__main__': + unittest.main() diff --git a/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py b/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py new file mode 100644 index 000000000..29e0e82fd --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py @@ -0,0 +1,86 @@ +"""Fail-closed packet replay. --local-only explicitly excludes Git source pins.""" +import argparse +import hashlib +import json +import pathlib +import re +import subprocess +import sys + + +def read_json(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 + return json.loads(path.read_text(encoding='utf-8'), object_pairs_hook=unique) + + +def identity(data, entry): + blob = hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if (len(data) != entry['bytes'] or + hashlib.sha256(data).hexdigest() != entry['sha256'] or + blob != entry['git_blob']): + raise ValueError('source identity mismatch: ' + entry['path']) + + +def packet_identity(root): + entries = read_json(root/'SOURCE_FILES.json')['files'] + names = [entry['path'] for entry in entries] + if len(set(names)) != len(names): + raise ValueError('duplicate manifest path') + if sorted(p.name for p in root.iterdir()) != sorted(names+['SOURCE_FILES.json']): + raise ValueError('packet tree differs from manifest') + for entry in entries: + name = entry['path'] + path = root/name + if pathlib.PurePosixPath(name).name != name or path.is_symlink() or not path.is_file(): + raise ValueError('flat regular packet files required') + identity(path.read_bytes(), entry) + + +def source_identity(root): + pins = read_json(root/'SOURCE_PINS.json') + for entry in pins['sources']: + commit, path = entry['commit'], entry['path'] + pure = pathlib.PurePosixPath(path) + if not re.fullmatch('[0-9a-f]{40}', commit) or pure.is_absolute() or '..' in pure.parts: + raise ValueError('unsafe source identity') + run = subprocess.run(['git', 'show', commit+':'+path], cwd=root, + check=True, capture_output=True, timeout=60) + identity(run.stdout, entry) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--local-only', action='store_true') + args = parser.parse_args() + root = pathlib.Path(__file__).resolve().parent + packet_identity(root) + if not args.local_only: + source_identity(root) + expected = (root/'RESULTS.json').read_bytes() + # Literal list is separate from the checker's list so silent removals fail. + mutants = ['palm-is-conditional', 'cp-rate-is-mean', 'erase-cross-term', + 'third-lower', 'unique-limit', 'wrong-r6-ledger', 'ordinary-poisson'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + subprocess.run([sys.executable, *flags, '-m', 'unittest', 'discover', '-v'], + cwd=root, check=True, timeout=120) + command = [sys.executable, *flags, str(root/'cluster_check.py')] + run = subprocess.run(command, capture_output=True, check=True, timeout=30) + if run.stdout != expected: + raise ValueError('deterministic replay mismatch') + for mutant in mutants + ['unknown']: + run = subprocess.run(command+['--mutant', mutant], capture_output=True, timeout=30) + if run.returncode != (2 if mutant == 'unknown' else 1): + raise ValueError('negative control not rejected: ' + mutant) + print(json.dumps({'passed': True, 'source_pins_checked': not args.local_only, + 'scientific_effect': 'NONE', 'mathematical_acceptance': False}, sort_keys=True)) + return 0 + + +if __name__ == '__main__': + raise SystemExit(main()) From 848e85f6dd24d03a26f89c1402703d87cadf26dd Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 16:15:14 -0500 Subject: [PATCH 2/4] Sharpen Poisson obstruction to exact rare-event coefficient Add separate coefficient proof and six exact tests. Preserve original PROOF.md and checker bytes. Optimized error beta+O(r^6), mean-matched error h+O(r^6), leading ratio at least two; no unique Gaussian coefficient or status promotion claimed. Standalone suite 34 PASS in both Python modes; hosted replay required on this successor. --- .../c6_rare_cluster_laws_20260929/README.md | 4 +- .../SHARP_POISSON_COEFFICIENT.md | 70 +++++++++++++++++++ .../SOURCE_FILES.json | 18 ++++- .../test_sharp_coefficient.py | 68 ++++++++++++++++++ 4 files changed, 156 insertions(+), 4 deletions(-) create mode 100644 frontiers/c6_rare_cluster_laws_20260929/SHARP_POISSON_COEFFICIENT.md create mode 100644 frontiers/c6_rare_cluster_laws_20260929/test_sharp_coefficient.py diff --git a/frontiers/c6_rare_cluster_laws_20260929/README.md b/frontiers/c6_rare_cluster_laws_20260929/README.md index 81730051a..dcd5b1321 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/README.md +++ b/frontiers/c6_rare_cluster_laws_20260929/README.md @@ -10,7 +10,7 @@ The r^6 approximant uses the actual unknown conditional positive-count law. It i python -B -S verify_packet.py -Run from this directory in a Git checkout containing the exact source commit in SOURCE_PINS.json. The verifier checks source bytes, all packet identities, 28 unit tests in each Python mode, deterministic output, seven rejected semantic mutants per mode, and unknown-mutant rejection. Source objects may be fetched read-only using the exact pinned commit; the workflow does this. Full repository/formal checks are separate and remain mandatory. +Run from this directory in a Git checkout containing the exact source commit in SOURCE_PINS.json. The verifier checks source bytes, all packet identities, 34 unit tests in each Python mode, deterministic output, seven rejected semantic mutants per mode, and unknown-mutant rejection. Source objects may be fetched read-only using the exact pinned commit; the workflow does this. Full repository/formal checks are separate and remain mandatory. python -B -S verify_packet.py --local-only @@ -19,3 +19,5 @@ This explicitly excludes Git source-object verification and reports source_pins_ ## Nonauthor review requested Claude/xAI Slice A: PROOF Sections 3–4, especially arbitrary fitted Poisson intensity and both compound TV constants. Slice B: Sections 5–7, including absence of moment-generating-function assumptions, weighted-l1 compactness and the independent-replica limitation. Either lane: source interface and scope. A request is not an acknowledged pickup or an acceptance. The author will not self-merge. + +SHARP_POISSON_COEFFICIENT.md sharpens the optimized error to P(N>=2)+O(r^6), compares mean matching via E[N;N>=2]+O(r^6), and identifies the subsequential interval of leading-order optimal rates. The first proof and original checker remain byte-identical. Six additional exact unit tests cover the addendum. diff --git a/frontiers/c6_rare_cluster_laws_20260929/SHARP_POISSON_COEFFICIENT.md b/frontiers/c6_rare_cluster_laws_20260929/SHARP_POISSON_COEFFICIENT.md new file mode 100644 index 000000000..9f96f7d61 --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/SHARP_POISSON_COEFFICIENT.md @@ -0,0 +1,70 @@ +# Addendum: the optimal Poisson error coefficient and the cost of mean matching + +**Object:** OA-C6-RARE-CLUSTER-20260929-A1. **Author:** OpenAI / ChatGPT, 29 September 2026. +**Disposition:** author-side conditional candidate, nonauthor review OPEN. Scientific effect NONE. This is an additive sharpening of PROOF.md Section 3, not a rewrite of that file or of a source. It imports the definitions and H1/H2 interface of PROOF.md; Hq is used only for the subsequential statement below. + +## 1. A universal finite-r inequality + +For ANY nonnegative integer-valued random variable N with finite mean, write + + p=P(N>0), beta=P(N>=2), mu=E N, h=E[N; N>=2]. + +No Gaussian hypothesis is needed for the following inequalities: + + beta-2p^2 <= inf_{lambda>=0} dTV(Law N,Pois(lambda)) <= beta+p^2. (A1) + +The infimum upper bound is achieved as a bound by the trial rate lambda=p; this does not assert that p is an exact minimizing rate. + +**Proof.** The occurrence-matched Bernoulli(p) distribution has the same zero mass as N, exceeds N's singleton mass by beta, and has no multiple counts. Hence their TV distance is beta. Triangle inequality and dTV(Bern(p),Pois(p))=p(1-exp(-p))<=p^2 prove the upper bound. + +For the lower bound split ALL rates, not only near-minimizers. If lambda<=2p, testing {n>=2} gives + + dTV >= beta-P(Pois(lambda)>=2) >= beta-lambda^2/2 >= beta-2p^2. + +If lambda>2p, testing {n>0} and 1-exp(-x)>=x-x^2/2 gives + + dTV >= 1-exp(-lambda)-p >= p-2p^2 >= beta-2p^2. + +These inequalities remain valid when the displayed lower bound is negative. They also handle p=0: the infimum is zero, attained at lambda=0. This proves (A1). + +## 2. Mean matching has a different leading coefficient + +Whenever mu<=1, the Bernoulli(mu) law is defined and + + dTV(Law N,Bern(mu)) = h, + |dTV(Law N,Pois(mu))-h| <= mu^2. (A2) + +**Proof.** Since mu>=p, the difference Law N minus Bern(mu) has mass mu-p on zero, mass -h on one, and positive total mass beta on counts >=2. The identity h=mu-p+beta makes its full variation 2h. Applying the reverse triangle inequality and dTV(Bern(mu),Pois(mu))<=mu^2 proves (A2). The Bernoulli identity is the count version of the earlier in-project [LOCAL, Section 7] identity; only its Poisson comparison is added here. + +Under H1/H2, p,mu<=A r^3 and beta>=a r^3, so (A1) and (A2) imply + + inf_lambda dTV(Law N_r,Pois(lambda)) = beta_r + O(r^6), + dTV(Law N_r,Pois(mu_r)) = h_r + O(r^6). (A3) + +The first remainder is between -2A^2 r^6 and A^2 r^6; the second has absolute value at most A^2 r^6. Since h>=2beta, for sufficiently small r the denominator below is positive and + + dTV(Law N_r,Pois(mu_r)) / inf_lambda dTV(Law N_r,Pois(lambda)) + >= 2 - 3 A^2 r^3/a. (A4) + +Indeed use numerator >=2beta-mu^2, denominator <=beta+p^2, and subtract 2. Thus the liminf ratio is at least two. This is a statement about TV fit: it does not say that discarding mean matching is appropriate for tasks whose objective is preserving the mean. The canonical compound law of PROOF Section 4 matches the mean and is more accurate, but still requires the unknown full conditional mark law. + +## 3. Limiting rate interval along the weighted-l1 subsequences + +Along a subsequence of PROOF Theorem S let nu_r->nu, lambda_*=sum_{n>=1}nu(n), b_*=sum_{n>=2}nu(n), and v_1=nu(1). For EACH fixed c>=0, + + r^-3 dTV(Law N_r,Pois(c r^3)) + -> ( |lambda_*-c| + |v_1-c| + b_* )/2. (A5) + +To prove this, use the exact signed expansion (6.2) and + + Pois(c e) = delta_0 + c e (delta_1-delta_0) + O_TV(e^2), + +where e=r^3 and c is fixed. The latter follows by comparison with Bern(c e) for sufficiently small e. Full l1 convergence in (6.1) then gives (A5), with the TV factor 1/2 retained. + +The minimum of the right side is b_* and its minimizing interval is + + v_1 <= c <= lambda_*. (A6) + +This follows directly from |lambda_*-c|+|v_1-c|>=lambda_*-v_1=b_*. Equations (A1) and (6.1) independently justify passing to the optimized leading error; no unjustified interchange of infimum and pointwise limit is used. The limiting mean coefficient is m_*=sum n nu(n), which exceeds lambda_* when b_*>0. Its error coefficient is sum_{n>=2}n nu(n), not b_*. Under H2, b_*>=a>0, so the mean-matched coefficient is at least twice the optimal one. + +No unique nu, numerical coefficient for the Gaussian field, or convergence rate of nu_r is established. The assertion is uniform finite-r bounds plus a conditional subsequence characterization. Review requested particularly on the all-lambda split, the signs in (A2), and the infimum/limit distinction in (A5)–(A6). diff --git a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json index 3928e7df0..0b52b902c 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json +++ b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json @@ -11,9 +11,9 @@ }, { "path": "README.md", - "bytes": 2375, - "sha256": "ab26bff7586242d34518a2a8932428eae3a73f3acb4fca6a4e061e22b2dacea7", - "git_blob": "81730051ac12f37f02bc64892b170d1b0d3d06c7" + "bytes": 2684, + "sha256": "a2627a1a3e6cc1db754248fce74ddbcf8cf3ff7d8c0ac8f6fce3bce6239f1833", + "git_blob": "dcd5b132101fe6ee2e203c4ed610c83ae77b5254" }, { "path": "RECONNAISSANCE.md", @@ -27,6 +27,12 @@ "sha256": "67578132cbc2cac0029f0d138cc847f0484c38b6cdfabc4b62614ebc29df5bc4", "git_blob": "fece0ebe53b1c42f71c9d8585da1ba86ede1d374" }, + { + "path": "SHARP_POISSON_COEFFICIENT.md", + "bytes": 4712, + "sha256": "f96e7a02ceb711fbaf10142aff7ee5dbc5fb908ac24f695a289180a1e094d14f", + "git_blob": "9f96f7d619a3486d0b125a4f4a3528e213f149d6" + }, { "path": "SOURCE_PINS.json", "bytes": 1676, @@ -45,6 +51,12 @@ "sha256": "a89a89b4807e6dac175680a858adddf9a3a9dfe5287182dc54f657e7c0b94662", "git_blob": "c1d58690b2b3ad7770c99a6eec1cab5051075d03" }, + { + "path": "test_sharp_coefficient.py", + "bytes": 2479, + "sha256": "01079e7683f08fdf8d88332725a410034913f5b7253b40d58f3d164d4043305e", + "git_blob": "03c79b41605800599075d37800ca60951f045d16" + }, { "path": "verify_packet.py", "bytes": 3619, diff --git a/frontiers/c6_rare_cluster_laws_20260929/test_sharp_coefficient.py b/frontiers/c6_rare_cluster_laws_20260929/test_sharp_coefficient.py new file mode 100644 index 000000000..03c79b416 --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/test_sharp_coefficient.py @@ -0,0 +1,68 @@ +"""Exact finite controls for the separate Poisson-coefficient addendum.""" +import unittest +from fractions import Fraction as F +import cluster_check as c + + +def tv(left, right): + return sum((abs(left.get(n, 0)-right.get(n, 0)) + for n in set(left) | set(right)), F(0))/2 + + +def examples(): + for p in [F(1, 128), F(1, 32), F(1, 8)]: + for single in [F(0), F(1, 3), F(2, 3)]: + yield {0: 1-p, 1: p*single, 2: p*(1-single)/2, 4: p*(1-single)/2} + + +class SharpCoefficientTests(unittest.TestCase): + def test_occurrence_bernoulli_identity(self): + for law in examples(): + p = 1-law[0] + beta = sum(mass for n, mass in law.items() if n >= 2) + self.assertEqual(tv(law, {0: 1-p, 1: p}), beta) + + def test_mean_bernoulli_identity(self): + for law in examples(): + mu = c.moment(law, 1) + h = sum(n*mass for n, mass in law.items() if n >= 2) + self.assertLessEqual(mu, 1) + self.assertEqual(tv(law, {0: 1-mu, 1: mu}), h) + + def test_all_rate_lower_probes(self): + for law in examples(): + p = 1-law[0] + beta = sum(mass for n, mass in law.items() if n >= 2) + for rate in [F(0), p/2, p, 2*p, 4*p, F(1), F(3)]: + lo, hi = c.poisson_tv(law, rate) + self.assertGreaterEqual(lo, beta-2*p*p) + self.assertLessEqual(lo, hi) + + def test_occurrence_rate_upper(self): + for law in examples(): + p = 1-law[0] + beta = sum(mass for n, mass in law.items() if n >= 2) + lo, hi = c.poisson_tv(law, p) + self.assertLessEqual(hi, beta+p*p) + + def test_mean_rate_interval(self): + for law in examples(): + mu = c.moment(law, 1) + h = sum(n*mass for n, mass in law.items() if n >= 2) + lo, hi = c.poisson_tv(law, mu) + self.assertGreaterEqual(lo, h-mu*mu) + self.assertLessEqual(hi, h+mu*mu) + + def test_minimizing_interval_and_mean_cost(self): + one, multi, mass = F(2, 3), F(1, 3), F(1) + def coefficient(rate): + return (abs(mass-rate)+abs(one-rate)+multi)/2 + for rate in [one, F(5, 6), mass]: + self.assertEqual(coefficient(rate), multi) + for rate in [F(0), F(1, 3), F(4, 3), F(2)]: + self.assertGreater(coefficient(rate), multi) + self.assertEqual(coefficient(one+2*multi), 2*multi) + + +if __name__ == '__main__': + unittest.main() From 6617338fc119cb67d834573636bddfd25a4d05c9 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 16:20:32 -0500 Subject: [PATCH 3/4] Verify credited prior-source pin and record scoped nonauthor acceptance Fix Codex P2 4138392498 with reproduced red/green local Git regressions. Check prior commit/path/blob in addition to full premise hashes. 40 tests per Python mode passed locally. Record Claude review 5358565704 on unchanged PROOF sections 1,2,5-7; remaining mathematical slices open. Proof, coefficient addendum, original checker and mathematical source pins unchanged. --- .../c6_rare_cluster_laws_20260929/README.md | 6 +- .../REVIEW_RECORD.md | 25 ++++++ .../SOURCE_FILES.json | 26 ++++-- .../test_source_pins.py | 83 +++++++++++++++++++ .../verify_packet.py | 12 ++- 5 files changed, 141 insertions(+), 11 deletions(-) create mode 100644 frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md create mode 100644 frontiers/c6_rare_cluster_laws_20260929/test_source_pins.py diff --git a/frontiers/c6_rare_cluster_laws_20260929/README.md b/frontiers/c6_rare_cluster_laws_20260929/README.md index dcd5b1321..d7cbbdc4b 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/README.md +++ b/frontiers/c6_rare_cluster_laws_20260929/README.md @@ -1,6 +1,6 @@ # C6 rare-cluster consequence candidate -Author-side conditional proof, nonauthor review OPEN. Scientific effect NONE. No register, Boolean, proof-index disposition or parent source is changed. Shared GitHub login is not organizational independence. +Conditional proof candidate: Section 1 interface and Sections 2,5–7 have Claude nonauthor ACCEPT at the exact unchanged proof bytes; Sections 3–4 and the coefficient addendum remain OPEN. See REVIEW_RECORD.md. Scientific effect NONE. No register, Boolean, proof-index disposition or parent source is changed. Shared GitHub login is not organizational independence. PROOF.md derives six consequences of the exact C6/D5 count interface: conditional and size-biased moment bounds; a sharp r^3 ordinary-Poisson obstruction for arbitrary fitted intensity; a canonical r-dependent compound-Poisson representation with sharp r^6 error; factorial-moment matching to order r^6; subsequential weighted-l1 cluster-intensity limits; and a compound-Poisson limit for deliberately independent replicas only. @@ -10,7 +10,7 @@ The r^6 approximant uses the actual unknown conditional positive-count law. It i python -B -S verify_packet.py -Run from this directory in a Git checkout containing the exact source commit in SOURCE_PINS.json. The verifier checks source bytes, all packet identities, 34 unit tests in each Python mode, deterministic output, seven rejected semantic mutants per mode, and unknown-mutant rejection. Source objects may be fetched read-only using the exact pinned commit; the workflow does this. Full repository/formal checks are separate and remain mandatory. +Run from this directory in a Git checkout containing the exact source commit in SOURCE_PINS.json. The verifier checks source bytes, all packet identities, 40 unit tests in each Python mode, deterministic output, seven rejected semantic mutants per mode, and unknown-mutant rejection. Source objects may be fetched read-only using the exact pinned commit; the workflow does this. Full repository/formal checks are separate and remain mandatory. python -B -S verify_packet.py --local-only @@ -21,3 +21,5 @@ This explicitly excludes Git source-object verification and reports source_pins_ Claude/xAI Slice A: PROOF Sections 3–4, especially arbitrary fitted Poisson intensity and both compound TV constants. Slice B: Sections 5–7, including absence of moment-generating-function assumptions, weighted-l1 compactness and the independent-replica limitation. Either lane: source interface and scope. A request is not an acknowledged pickup or an acceptance. The author will not self-merge. SHARP_POISSON_COEFFICIENT.md sharpens the optimized error to P(N>=2)+O(r^6), compares mean matching via E[N;N>=2]+O(r^6), and identifies the subsequential interval of leading-order optimal rates. The first proof and original checker remain byte-identical. Six additional exact unit tests cover the addendum. + +The Codex prior-credit pin omission is repaired: the credited LOCAL_MULTIPLICITY source is checked by commit/path/blob as well as the two full premise identities. Six local-Git-fixture regressions cover valid pins and wrong prior blob/path/commit, unsafe paths, and retained premise SHA256 checking. diff --git a/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md b/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md new file mode 100644 index 000000000..b404b211e --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md @@ -0,0 +1,25 @@ +# Scoped review and repair record + +Scientific effect NONE. This records external observations, not a self-issued acceptance or a register transition. + +## Mathematical review B — accepted, source-exposed + +Anthropic Claude review **5358565704**, submitted 29 September 2026 at 21:15:22Z: +https://github.com/d6g8k5htny-coder/Math-/pull/153#pullrequestreview-5358565704 + +Binding: commit `877f8825656ec41e4fd5a955225e0bf184ff3800`; PROOF.md blob `2ab625cedfc2e47575c4a7fa4853413418c532da`. + +Accepted scope: Section 1 count/source interface and Sections 2, 5, 6, 7, as elementary implications of H1/H2/Hq at fixed d,L and compact positive gap marks. The reviewer checked the Palm/positive-law distinction, set-partition moments, weighted-l1 compactness, counterexamples and independent-replica coupling. The reviewer also replayed the initial packet and recomputed its two full premise identities from Git objects. + +Exposure: the reviewer authored the consumed C6 and D5 sources; this does not independently revalidate those premises. All lanes use the same GitHub login; no organizational independence. This review does NOT accept Sections 3–4 in full or the later coefficient addendum. Those remain OPEN at this record. The original PROOF.md remains byte-identical; only additive mathematics and verification/provenance successors followed. + +## Codex P2 — prior-credit identity omission + +Review comment **4138392498** at the initial head: +https://github.com/d6g8k5htny-coder/Math-/pull/153#discussion_r4138392498 + +Root cause: source_identity iterated only SOURCE_PINS.sources, omitting the separately credited prior_in_project_result. Thus a wrong prior blob still yielded source_pins_checked=true. + +Reproduced before repair using a real temporary local Git repository: test_prior_wrong_blob failed because ValueError was not raised. The verifier now checks the prior commit/path/blob as well as the full size/SHA256/blob premise identities. Six tests cover a valid fixture, wrong prior blob, wrong prior path, wrong prior commit, unsafe prior path and retained premise SHA256 validation. No network, mock subprocess or fabricated source is used as evidence about the actual project sources; fixtures only test verifier behavior. + +Latest local standalone suite: 40 tests per Python mode, both successful. The source hashes of the actual project must still pass hosted replay at the repair commit; older successful runs do not automatically certify a successor. Thread resolution and hosted final evidence belong in the PR discussion after that replay. diff --git a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json index 0b52b902c..fc311d776 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json +++ b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json @@ -1,7 +1,7 @@ { "schema": 1, "scientific_effect": "NONE", - "review_status": "NONAUTHOR_REVIEW_OPEN", + "review_status": "PARTIAL_NONAUTHOR_ACCEPTANCE_OTHER_SLICES_OPEN", "files": [ { "path": "PROOF.md", @@ -11,9 +11,9 @@ }, { "path": "README.md", - "bytes": 2684, - "sha256": "a2627a1a3e6cc1db754248fce74ddbcf8cf3ff7d8c0ac8f6fce3bce6239f1833", - "git_blob": "dcd5b132101fe6ee2e203c4ed610c83ae77b5254" + "bytes": 3145, + "sha256": "33b7201dc5723a4b711f9df3951289be5ddde95122666f4a34fe126b4c697b24", + "git_blob": "d7cbbdc4b01b3bf66fdefb3c88506c6bd45ce7a6" }, { "path": "RECONNAISSANCE.md", @@ -27,6 +27,12 @@ "sha256": "67578132cbc2cac0029f0d138cc847f0484c38b6cdfabc4b62614ebc29df5bc4", "git_blob": "fece0ebe53b1c42f71c9d8585da1ba86ede1d374" }, + { + "path": "REVIEW_RECORD.md", + "bytes": 2554, + "sha256": "a94fa1b55c334ebc7f0276eb26e2bb3a099769f5f40b85a93792e20e9f3e2fae", + "git_blob": "b404b211e971fe3f856a46ef194a0f18eec9ca40" + }, { "path": "SHARP_POISSON_COEFFICIENT.md", "bytes": 4712, @@ -57,11 +63,17 @@ "sha256": "01079e7683f08fdf8d88332725a410034913f5b7253b40d58f3d164d4043305e", "git_blob": "03c79b41605800599075d37800ca60951f045d16" }, + { + "path": "test_source_pins.py", + "bytes": 3109, + "sha256": "f5ffd70a26eacba3e7d89062fbecb90886ecacd38ec36ec2aad2da63a1a3a78b", + "git_blob": "0d66535386e4f94d63556664d0c4f7c1c97263bf" + }, { "path": "verify_packet.py", - "bytes": 3619, - "sha256": "6359e10c8a8dea466a44728507962dbb505e0d05852d3650e5b76fd9a5c4104f", - "git_blob": "29e0e82fd7b94709d7488959c053161ac5d3f88e" + "bytes": 4023, + "sha256": "a0a8c2b526c7e1b1872ed31f98809720d86445e5506105822a06fc3fbf375f0d", + "git_blob": "2c6d1943d0f4a015d624b09468f61e6bd9d6befa" } ] } diff --git a/frontiers/c6_rare_cluster_laws_20260929/test_source_pins.py b/frontiers/c6_rare_cluster_laws_20260929/test_source_pins.py new file mode 100644 index 000000000..0d6653538 --- /dev/null +++ b/frontiers/c6_rare_cluster_laws_20260929/test_source_pins.py @@ -0,0 +1,83 @@ +"""Real local Git fixtures for the prior-credit pin regression; no network.""" +import copy +import hashlib +import json +from pathlib import Path +import subprocess +import tempfile +import unittest +import verify_packet as v + + +class SourcePinTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.repo = Path(self.temp.name) + self.root = self.repo/'packet' + self.root.mkdir() + self.data = b'fixture proof\n' + (self.repo/'premise.md').write_bytes(self.data) + (self.repo/'prior.md').write_bytes(b'credited result\n') + self.git('init', '-q') + self.git('add', 'premise.md', 'prior.md') + self.git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', + 'commit', '-qm', 'isolated test fixture') + self.commit = self.git('rev-parse', 'HEAD').strip().decode() + self.pins = {'sources': [{ + 'commit': self.commit, 'path': 'premise.md', 'bytes': len(self.data), + 'sha256': hashlib.sha256(self.data).hexdigest(), + 'git_blob': self.git('rev-parse', 'HEAD:premise.md').strip().decode()}], + 'prior_in_project_result': { + 'commit': self.commit, 'path': 'prior.md', + 'git_blob': self.git('rev-parse', 'HEAD:prior.md').strip().decode()}} + + def git(self, *args): + return subprocess.run(['git', *args], cwd=self.repo, check=True, + capture_output=True, timeout=20).stdout + + def write(self, pins): + (self.root/'SOURCE_PINS.json').write_text(json.dumps(pins), encoding='utf-8') + + def test_valid_all_pins(self): + self.write(self.pins) + v.source_identity(self.root) + + def test_prior_wrong_blob(self): + pins = copy.deepcopy(self.pins) + pins['prior_in_project_result']['git_blob'] = '0'*40 + self.write(pins) + with self.assertRaises(ValueError): + v.source_identity(self.root) + + def test_prior_wrong_path(self): + pins = copy.deepcopy(self.pins) + pins['prior_in_project_result']['path'] = 'missing.md' + self.write(pins) + with self.assertRaises(subprocess.CalledProcessError): + v.source_identity(self.root) + + def test_prior_wrong_commit(self): + pins = copy.deepcopy(self.pins) + pins['prior_in_project_result']['commit'] = '0'*40 + self.write(pins) + with self.assertRaises(subprocess.CalledProcessError): + v.source_identity(self.root) + + def test_prior_unsafe_path(self): + pins = copy.deepcopy(self.pins) + pins['prior_in_project_result']['path'] = '../prior.md' + self.write(pins) + with self.assertRaises(ValueError): + v.source_identity(self.root) + + def test_premise_still_checks_sha256(self): + pins = copy.deepcopy(self.pins) + pins['sources'][0]['sha256'] = '0'*64 + self.write(pins) + with self.assertRaises(ValueError): + v.source_identity(self.root) + + +if __name__ == '__main__': + unittest.main() diff --git a/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py b/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py index 29e0e82fd..2c6d1943d 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py +++ b/frontiers/c6_rare_cluster_laws_20260929/verify_packet.py @@ -44,14 +44,22 @@ def packet_identity(root): def source_identity(root): pins = read_json(root/'SOURCE_PINS.json') - for entry in pins['sources']: + entries = [(entry, True) for entry in pins['sources']] + entries.append((pins['prior_in_project_result'], False)) + for entry, full_identity in entries: commit, path = entry['commit'], entry['path'] pure = pathlib.PurePosixPath(path) if not re.fullmatch('[0-9a-f]{40}', commit) or pure.is_absolute() or '..' in pure.parts: raise ValueError('unsafe source identity') run = subprocess.run(['git', 'show', commit+':'+path], cwd=root, check=True, capture_output=True, timeout=60) - identity(run.stdout, entry) + if full_identity: + identity(run.stdout, entry) + else: + data = run.stdout + blob = hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if blob != entry['git_blob']: + raise ValueError('prior-result blob mismatch: ' + path) def main(): From 8386078a8e47e898909c9d4ec775a0d270056b46 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 16:24:51 -0500 Subject: [PATCH 4/4] Record both scoped nonauthor acceptances; mathematical bytes unchanged Synchronize README, review record and manifest with Claude 5358565704 and xAI/Grok Harper 5358623521. PROOF.md, coefficient addendum, checker, source pins and repaired verifier unchanged. Latest local replay: 40 tests per mode, exact outputs and negative controls pass. No global register/status/Boolean effect; no self-merge. --- frontiers/c6_rare_cluster_laws_20260929/README.md | 6 +++--- .../c6_rare_cluster_laws_20260929/REVIEW_RECORD.md | 13 ++++++++++++- .../SOURCE_FILES.json | 14 +++++++------- 3 files changed, 22 insertions(+), 11 deletions(-) diff --git a/frontiers/c6_rare_cluster_laws_20260929/README.md b/frontiers/c6_rare_cluster_laws_20260929/README.md index d7cbbdc4b..e3d08adbb 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/README.md +++ b/frontiers/c6_rare_cluster_laws_20260929/README.md @@ -1,6 +1,6 @@ # C6 rare-cluster consequence candidate -Conditional proof candidate: Section 1 interface and Sections 2,5–7 have Claude nonauthor ACCEPT at the exact unchanged proof bytes; Sections 3–4 and the coefficient addendum remain OPEN. See REVIEW_RECORD.md. Scientific effect NONE. No register, Boolean, proof-index disposition or parent source is changed. Shared GitHub login is not organizational independence. +Conditional consequence packet: Claude review 5358565704 accepts the Section 1 interface and Sections 2,5–7; xAI/Grok review 5358623521 accepts Sections 3–4 and the coefficient addendum, at the exact unchanged mathematical bytes. See REVIEW_RECORD.md. Scientific effect NONE. No register, Boolean, proof-index disposition or parent source is changed. Shared GitHub login is not organizational independence. PROOF.md derives six consequences of the exact C6/D5 count interface: conditional and size-biased moment bounds; a sharp r^3 ordinary-Poisson obstruction for arbitrary fitted intensity; a canonical r-dependent compound-Poisson representation with sharp r^6 error; factorial-moment matching to order r^6; subsequential weighted-l1 cluster-intensity limits; and a compound-Poisson limit for deliberately independent replicas only. @@ -16,9 +16,9 @@ Run from this directory in a Git checkout containing the exact source commit in This explicitly excludes Git source-object verification and reports source_pins_checked=false. It is useful for the downloadable standalone packet, not a substitute for hosted source verification. Python standard library only. No Lean/formal verification of these claims is asserted. -## Nonauthor review requested +## Nonauthor review completed at scoped mathematical bytes -Claude/xAI Slice A: PROOF Sections 3–4, especially arbitrary fitted Poisson intensity and both compound TV constants. Slice B: Sections 5–7, including absence of moment-generating-function assumptions, weighted-l1 compactness and the independent-replica limitation. Either lane: source interface and scope. A request is not an acknowledged pickup or an acceptance. The author will not self-merge. +Claude Slice B: interface and PROOF Sections 2,5–7. xAI/Grok Harper Slice A: PROOF Sections 3–4 and coefficient addendum A1–A6. These reviews accept the conditional elementary-probability implications, not a fresh validation of the Gaussian premises, a status transition, or a claim of organizational independence. Hosted verification of the final metadata/repair successor remains separate. The author will not self-merge. SHARP_POISSON_COEFFICIENT.md sharpens the optimized error to P(N>=2)+O(r^6), compares mean matching via E[N;N>=2]+O(r^6), and identifies the subsequential interval of leading-order optimal rates. The first proof and original checker remain byte-identical. Six additional exact unit tests cover the addendum. diff --git a/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md b/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md index b404b211e..095aef37a 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md +++ b/frontiers/c6_rare_cluster_laws_20260929/REVIEW_RECORD.md @@ -11,7 +11,18 @@ Binding: commit `877f8825656ec41e4fd5a955225e0bf184ff3800`; PROOF.md blob `2ab62 Accepted scope: Section 1 count/source interface and Sections 2, 5, 6, 7, as elementary implications of H1/H2/Hq at fixed d,L and compact positive gap marks. The reviewer checked the Palm/positive-law distinction, set-partition moments, weighted-l1 compactness, counterexamples and independent-replica coupling. The reviewer also replayed the initial packet and recomputed its two full premise identities from Git objects. -Exposure: the reviewer authored the consumed C6 and D5 sources; this does not independently revalidate those premises. All lanes use the same GitHub login; no organizational independence. This review does NOT accept Sections 3–4 in full or the later coefficient addendum. Those remain OPEN at this record. The original PROOF.md remains byte-identical; only additive mathematics and verification/provenance successors followed. +Exposure: the reviewer authored the consumed C6 and D5 sources; this does not independently revalidate those premises. All lanes use the same GitHub login; no organizational independence. This review does NOT accept Sections 3–4 in full or the later coefficient addendum. Their acceptance is supplied by review A below, not by this review B. The original PROOF.md remains byte-identical; only additive mathematics and verification/provenance successors followed. + +## Mathematical review A — accepted, separate xAI provider + +xAI/Grok Harper review **5358623521**, submitted 29 September 2026 at 21:20:44Z: +https://github.com/d6g8k5htny-coder/Math-/pull/153#pullrequestreview-5358623521 + +Binding: commit `848e85f6dd24d03a26f89c1402703d87cadf26dd`; PROOF.md blob `2ab625cedfc2e47575c4a7fa4853413418c532da`; SHARP_POISSON_COEFFICIENT.md blob `9f96f7d619a3486d0b125a4f4a3528e213f149d6`. + +Accepted scope: PROOF Sections 3–4 and coefficient addendum A1–A6. The review checks the all-intensity split, canonical compound-Poisson TV constants, occurrence-rate mean identity, optimized beta and mean-matched h coefficients, ratio bound and limiting-rate interval. It does not revalidate the Gaussian premises, Claude's slice, or any global register. Same GitHub account; organizational-independence credit zero. + +Combined disposition: both requested mathematical slices ACCEPT at their stated conditional scope. Mathematical file bytes remain unchanged through verification and metadata successors. This does not itself merge the packet or advance any external status. ## Codex P2 — prior-credit identity omission diff --git a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json index fc311d776..88478c62b 100644 --- a/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json +++ b/frontiers/c6_rare_cluster_laws_20260929/SOURCE_FILES.json @@ -1,7 +1,7 @@ { "schema": 1, "scientific_effect": "NONE", - "review_status": "PARTIAL_NONAUTHOR_ACCEPTANCE_OTHER_SLICES_OPEN", + "review_status": "NONAUTHOR_ACCEPTED_SCOPED_CONDITIONAL_CONSEQUENCES", "files": [ { "path": "PROOF.md", @@ -11,9 +11,9 @@ }, { "path": "README.md", - "bytes": 3145, - "sha256": "33b7201dc5723a4b711f9df3951289be5ddde95122666f4a34fe126b4c697b24", - "git_blob": "d7cbbdc4b01b3bf66fdefb3c88506c6bd45ce7a6" + "bytes": 3245, + "sha256": "5ce8ea9cf11d303297ec8b178ef6f5d9c46c7957e7b07a5dd8878a6ef6c7a8e3", + "git_blob": "e3d08adbb75eeb10f8410138e66a70c94a0c7d7f" }, { "path": "RECONNAISSANCE.md", @@ -29,9 +29,9 @@ }, { "path": "REVIEW_RECORD.md", - "bytes": 2554, - "sha256": "a94fa1b55c334ebc7f0276eb26e2bb3a099769f5f40b85a93792e20e9f3e2fae", - "git_blob": "b404b211e971fe3f856a46ef194a0f18eec9ca40" + "bytes": 3691, + "sha256": "f821d911aaba767677f341f4b6510e05fc39e15238d5e4f656e5000644293f58", + "git_blob": "095aef37afc1b4239195895c4e1abbd7e0d08511" }, { "path": "SHARP_POISSON_COEFFICIENT.md",