diff --git a/.github/workflows/cluster-exponential-weight.yml b/.github/workflows/cluster-exponential-weight.yml new file mode 100644 index 000000000..b01274852 --- /dev/null +++ b/.github/workflows/cluster-exponential-weight.yml @@ -0,0 +1,40 @@ +name: Cluster exponential weight controls +'on': + pull_request: + paths: + - 'frontiers/cluster_exponential_weight_20260930/**' + - '.github/workflows/cluster-exponential-weight.yml' + push: + branches: [main] + paths: + - 'frontiers/cluster_exponential_weight_20260930/**' + - '.github/workflows/cluster-exponential-weight.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-exponential: + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + fetch-depth: 0 + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Finite controls and immutable source custody (not proof acceptance) + run: | + set -euo pipefail + packet=frontiers/cluster_exponential_weight_20260930 + python -B -S "$packet/verify_packet.py" + python -B -O -S "$packet/verify_packet.py" + python -B -S "$packet/finite_checks.py" > /tmp/exponential-normal.json + python -B -O -S "$packet/finite_checks.py" > /tmp/exponential-optimized.json + cmp /tmp/exponential-normal.json /tmp/exponential-optimized.json + python -B -S -m unittest discover -s "$packet" -p 'test_*.py' -v + python -B -O -S -m unittest discover -s "$packet" -p 'test_*.py' -v + git fetch --no-tags origin cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b 7a44130b41b827577424a73c4feac4cde20b5568 + python -B -S "$packet/verify_sources.py" --repo-root "$GITHUB_WORKSPACE" + git diff --exit-code diff --git a/frontiers/cluster_exponential_weight_20260930/INTERNAL_REVIEWS.md b/frontiers/cluster_exponential_weight_20260930/INTERNAL_REVIEWS.md new file mode 100644 index 000000000..a2f77a2d8 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/INTERNAL_REVIEWS.md @@ -0,0 +1,141 @@ +# Review chronology and current scoped disposition + +The original author-side snapshot below is preserved verbatim as published at +commit `0e70540b70e5e3183df5ed1a6bd70a212b734c9c` on 30 September 2026 UTC. +Its pending-review wording describes that original snapshot. The appended +current disposition records later actual native reviews of the same proof. + +## Original author-side snapshot (historical) + +# Internal challenges, exposure and unresolved review + +Target in both mathematical slices: PROOF.md, 12576 bytes, Git blob +`bf1268b9c18ec05561fd9b14c645ef0b8e530484`, SHA256 +`3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee`. +The target was not amended after either mathematical review. + +Root authored the proof. The two OpenAI agents below made no proof edits and +were noncontributors to this implication; both had the root's draft and source +copies as exposure. Same-provider work supplies **zero organizational +independence**. Exact model version was not independently verified. These are +internal challenge results, not external organizational review or acceptance +of either upstream theorem. Public nonauthor review of this packet remains +required; its disposition is AUTHOR_SIDE / CONDITIONAL. + +## Slice A: endpoint tails and normalization (agent exp_weight_tail_review) + +**ACCEPT — §§1–3, conditional on MF1 and SC(3). No amendment required.** + +The declared input interfaces agree: original variance-one periodized field, +endpoint regression, typed determinant weight, full endpoint-only normalizer, +and all-index additional count in the open height window with both pins +excluded. Setting T=L resolves the side-length notation. A fixed admissible +positive gap lies inside a compact family with positive gap floor. No extra +conditioning or size bias enters E1–E2. + +E1 gives sum n w(n)nu_r(n)<=C; retaining n yields the endpoint tail +sum_(n>M)w(n)nu_r(n)<=C/(M+1). Fatou gives the same bound for the limit. +Finite-coordinate convergence then proves EW1 at theta itself. Since w>=1, +a_r->a>0. Centering at zero gives E4; positive conditioning correctly uses +the denominator a_r. For q and theta'=0, exp(-s a_r) sum_j s^j nu_r^{*j}/j! is nonnegative with mass one; +the comparisons therefore use genuine compound-Poisson laws. Independence +supplies the convolution power of the one-copy law. m=0, t=0 and T=0 are +handled. For alpha=1, absolute weighted convergence controls PGFs uniformly +on the closed disk of radius exp(theta), with analyticity in the interior +and continuity at the boundary. For alpha<1, the proposed +n^-3 exp(-2theta n^alpha) contamination obeys the premise but yields +prelimit radius exactly one. No larger disk follows. + +Excluded stronger claims have concrete falsifiers: all replicas equal to +the same N_r defeats the compound-Poisson limit; a coefficient perturbation +1/|log r| defeats an automatic O(r³) replica rate and O(r6) one-copy +limiting-mark error; alpha>1 defeats E11 using two unit atoms. + +Custody caveat at the first read: SOURCES.json was not yet present and the +historical Git objects were unavailable locally. The root later supplied +SOURCES.json and separately verified the source identities through the +public GitHub connector. This is not attributed to the first reviewer as +a historical-tree replay. + +## Custody challenge, repair and separate re-review (agent exp_weight_tail_review) + +Initial verifier SHA256 `45bddfbdd3e4c8b9cf5dd7311f46db870856f28c93c3d6a2bbbf9d4a3ecc78bb`: +**AMEND**. Eight controls passed, but a tree could masquerade as a commit, +and local Git replacement refs could make absent paths pass under an empty +commit's identity. A boolean JSON schema also passed as integer 1. + +Root reproduced all three defects with failing tests before repair. Every +Git read now uses --no-replace-objects; cat-file requires object type commit; +schema requires an actual integer. Repaired verifier SHA256 +`0bc355e6b5bc4459d5395f1730456bca8bb26aa6220f94e657f6dd57f93d7784`: +**PASS — bounded custody re-review**, 11 controls in each Python mode. +The real manifest correctly fails locally when historical objects are absent. +This repair concerns custody code only, not a proof amendment or parent verdict. + +--- + +## Current disposition after actual native reviews (30 September 2026 UTC) + +The unchanged PROOF.md now has **scoped nonauthor ACCEPT, CONDITIONAL** for +Slice A (§§1–3) and Slice B (§§4–5). This supersedes the historical pending-review +status above; it does not rewrite the author-side challenges or make them +independent reviews. The complete actual bodies are retained in +[REVIEW_RECORD.json](REVIEW_RECORD.json): + +- [Anthropic/Claude A+B, review5360109371](https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360109371): + actual analytic acceptance of the elementary implications of E1–E2, at fixed + parameters with existential constants, independent copies and no rate. +- [OpenAI/Codex A, review5360144037](https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360144037): + §§1–3, E1–E10, conditional on the exact MF1 and SC(3) interfaces; Slice B + outside that individual verdict. +- [OpenAI/Codex B, review5360159070](https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360159070): + §§4–5, EW3/EW4, E11–E15 and dimension/independence/rate qualifications, + retaining E1–E2 and Slice A's endpoint consequence as dependencies. + +All three native objects identify original commit +`0e70540b70e5e3183df5ed1a6bd70a212b734c9c`, PROOF.md's 12,576 bytes, +Git blob `bf1268b9c18ec05561fd9b14c645ef0b8e530484`, and SHA256 +`3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee`. +Their source exposure is preserved in their complete native bodies, not +replaced by this summary. Claude identifies provider distinction from the +author and reviewer exposure to SC; both Codex reviewers disclose their earlier +source reviews and challenges. All use the same GitHub account and carry +**zero organizational-independence credit**. + +The original MF1/SC(3) statements remain imported hypotheses; these reviews +do not prove their Gaussian, spectral or regional parents, supply rates or +moving-mark uniformity, identify a spatial event, or justify spatial +independence. Scientific effect remains NONE. The later engineering repair +preserves every mathematical source byte. Its implementer previously reviewed +Slice B; that does not self-accept the engineering repair. A separate engineering +review, current-base CI and authorized integration remain distinct gates. + +VALIDATION.json is retained unchanged as the original author execution/history +record. The new packet guard binds its proof hash and REVIEW_RECORD.json's +proof identity to actual PROOF.md and checks MANIFEST.json membership and hashes. +Passing that guard establishes local custody only, not GitHub authenticity or +mathematical acceptance. diff --git a/frontiers/cluster_exponential_weight_20260930/MANIFEST.json b/frontiers/cluster_exponential_weight_20260930/MANIFEST.json new file mode 100644 index 000000000..b854d28a8 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/MANIFEST.json @@ -0,0 +1,85 @@ +{ + "files": [ + { + "path": "INTERNAL_REVIEWS.md", + "bytes": 8160, + "sha256": "3df02b032e97e735a3a52973312d6459aa103e069fde38359e250741e11b0f5d", + "git_blob": "a2f77a2d8e5516e1a851e6db06266edac7489cc3" + }, + { + "path": "PROOF.md", + "bytes": 12576, + "sha256": "3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee", + "git_blob": "bf1268b9c18ec05561fd9b14c645ef0b8e530484" + }, + { + "path": "README.md", + "bytes": 4224, + "sha256": "c4fe795143c4b922bea2f215e73b97ca30cd697f3aca2eabbd58f26ebea8f894", + "git_blob": "31bfd56bce487a695a46b257e95ef57a9af75689" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 1440, + "sha256": "fb0ecd7559e5d451c567896fcc8e5a614ad4f6cb010fdc9699b138ac4c62d847", + "git_blob": "e0b3d9ea52aff5b1abc4b808f96be416289adcb1" + }, + { + "path": "REVIEW_RECORD.json", + "bytes": 42755, + "sha256": "0d9239543a0c23eb476843f6c122884f2b6258c2bf371adad598266b2fa5b56e", + "git_blob": "ee34321999980716e320b8c25eb0f12a7abd3e15" + }, + { + "path": "SOURCES.json", + "bytes": 1650, + "sha256": "478bd0ad93200b0993562d1a7ea3a6f96c7e15620781df469df1e5c127a1b4a1", + "git_blob": "4b3eeb938bca54aa28ce4746028a2f152a94dac6" + }, + { + "path": "VALIDATION.json", + "bytes": 1932, + "sha256": "b1e6b78b10c61820e3ee25db4602348690a2f20dd63348de37f5aa0dec0e1347", + "git_blob": "ab9e91fce0c8b8dba5c69a3538ed6dad826794b2" + }, + { + "path": "finite_checks.py", + "bytes": 7409, + "sha256": "143e3a64f7f07d2d2e0c29bb5dae5cc1ad59b06d50650ff72dc1daf4e1be8ad2", + "git_blob": "86d7f2482acf9326f47b9e39ebe3d56a92fce8f1" + }, + { + "path": "test_finite_checks.py", + "bytes": 11876, + "sha256": "134f7e3074afa8b5fa2e5fbc67fd7867b246434469e00d96575e51a3df477787", + "git_blob": "d350286f0b1291813d6c0dcbb9c3b849e1b0e2f3" + }, + { + "path": "test_verify_packet.py", + "bytes": 9862, + "sha256": "6409627e94f41358d880aacb25f90fc58b693c641c5c9251d54424c4188243e4", + "git_blob": "e597b179f3d116ae79e15c616f3b17b4f13630ea" + }, + { + "path": "test_verify_sources.py", + "bytes": 4863, + "sha256": "ac8a0ae72e3f1982ea722992ae3c9af2684454301a7fc7d407ea3e23e5b3186f", + "git_blob": "0cde3642d6fff16223e94003978d9a00e1de9383" + }, + { + "path": "verify_packet.py", + "bytes": 5441, + "sha256": "a505f52939e10eff494aab7ae81f7dce96f5ea8f78a94a34e49d689fa15aceab", + "git_blob": "70b540e53f9921885c62a2a09724d022fdadcadf" + }, + { + "path": "verify_sources.py", + "bytes": 3410, + "sha256": "0bc355e6b5bc4459d5395f1730456bca8bb26aa6220f94e657f6dd57f93d7784", + "git_blob": "a8ac3636c011337d9d4a12f4cd052d666572afb8" + } + ], + "manifest_self_excluded": true, + "schema": 1, + "scientific_effect": "NONE" +} diff --git a/frontiers/cluster_exponential_weight_20260930/PROOF.md b/frontiers/cluster_exponential_weight_20260930/PROOF.md new file mode 100644 index 000000000..bf1268b9c --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/PROOF.md @@ -0,0 +1,259 @@ +# Endpoint exponential-weight closure and independent-replica error + +Object: OA-CLUSTER-EXP-WEIGHT-20260930-v1. +Author: OpenAI / Codex. Date: 30 September 2026 UTC. +Disposition: AUTHOR_SIDE conditional proof; nonauthor review required. +Scientific effect NONE. No source theorem, review, register, graph, prize or +Boolean is changed. This is a new implication of two exact interfaces, not a +proof or retrospective acceptance of either interface. + +## 1. Exact consumption and the mathematical purpose + +Fix one dimension d>=2, torus side L>0, real birth b, gap k>0 and frame. Use the +same variance-one periodized field, endpoint observations, ORIGINAL typed +determinant weight W_r, full endpoint-only Z_r and law Q_r^W=(W_r/Z_r)Q_r as +the two sources. N_r is their ALL-INDEX additional critical-point count in +(b-k r^3,b), with both endpoint pins excluded. In the marked source T=L; a +fixed admissible mark can be placed inside its compact family. No further +normalizer, height conditioning, or Palm size bias enters this definition. + +The source interface [MF] is MF1 at Math-#157, exact commit +cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b. For alpha=2/d there exist +theta>0, C0 such that + + E_QW[N_r exp(theta N_r^alpha)] <= C r^3. (E1) + +The source interface [SC] is (3) at Math-#162, exact commit +7a44130b41b827577424a73c4feac4cde20b5568. At these fixed parameters, + + nu_r(n)=r^-3 Q_r^W(N_r=n), n>=1, + nu=nu1 delta_1+nu2 delta_2, 0 nu(n) for each n>=1. (E2) + +[SC] proves more than the coordinate convergence consumed here. Its separate +A/B/C review requirements and parent premises remain separate; an open slice +is not discharged by this implication. [MF] has its own Fourier-regression +and regional marked-Kac--Rice premises. SOURCES.json binds both full texts. + +[MF] Section7 previously gives only subsequential weighted compactness from +(E1). [SC] identifies the coefficients in polynomial weights without consuming +(E1). Here their intersection removes the subsequence in exponential weights, +including a boundary exponent that does not require slack. It also gives a +finite error bound for replica sums in that stronger norm. The generic +probability argument below is self-contained and does not use a new Gaussian +regression, Kac--Rice formula, spatial independence, or a coefficient rate. + +## 2. The endpoint norm theorem + +For a signed or complex measure sigma on the nonnegative integers define + + ||sigma||_w = sum_(n>=0) w(n)|sigma(n)|, + w(n)=exp(theta n^alpha), w(0)=1. (E3) + +Measures nu_r and nu have zero mass at0. Put epsilon_r=||nu_r-nu||_w. + +**Theorem EW1.** Under (E1)--(E2), epsilon_r ->0 as r->0. This is convergence +at theta ITSELF, not only at theta'0. (E4) + +The zero mass is centered; r^-3 Q(N_r=0) has no finite limit. + +**Proof.** Equation(E1) is exactly + + sum_(n>=1) n w(n)nu_r(n)<=C. (E5) + +For every integer M>=1, + + sum_(n>M) w(n)nu_r(n)<= C/(M+1). (E6) + +Fatou on finite sums in(E2) gives sum n w(n)nu(n)<=C. Therefore the same +tail estimate holds for nu. On1<=n<=M, coordinate convergence and finiteness +of the sum give convergence in the w-norm. The norm outside that set is at +most2C/(M+1). First let r->0 at fixed M, then M->infinity. This proves EW1. +The retained n factor in(E5), not an extra exponential moment, supplies the +endpoint uniform integrability. Since |a_r-a|<=epsilon_r and the exact law is +delta_0+r^3 H_r, (E4) follows. The full original tilt was used once in(E1) +and(E2); this step introduces no additional field normalizer. QED. + +**Theorem EW2.** For every fixed integer q>=0 and0<=theta'=1) n^q exp(theta' n^alpha)|nu_r(n)-nu(n)| ->0. (E7) + +In particular the positive-conditioned law converges in the ENDPOINT w-norm +to nu/a. The size-biased law converges in every STRICTLY smaller exponential +weight exp(theta'n^alpha) to +(nu1 delta_1+2nu2 delta_2)/(nu1+2nu2). + +**Proof.** Put gamma=theta-theta'>0. On n>M the weighted tail of nu_r is bounded +by + + C sup_(n>M) n^(q-1) exp(-gamma n^alpha), (E8) + +which tends to zero. The same holds for nu by Fatou. Finite-coordinate +convergence proves(E7). For positive conditioning use a_r->a>0 and + + ||nu_r/a_r-nu/a||_w + <= epsilon_r/a_r+|a_r-a| ||nu||_w/(a a_r). + +For size bias let z_r=sum n nu_r(n), z=nu1+2nu2. The q=1 case of(E7) gives +convergence of n nu_r in the smaller exponential norm and z_r->z>0. Divide +by z_r as above. These are distinct denominators and distinct probability +laws. QED. + +## 3. Why endpoint size bias is excluded: an exact escaping-mass example + +The endpoint exponent for EW1 does NOT justify n times that weight. For any +00 take m=m(r)>=3 tending to infinity and + + nu_r=delta_1+delta_2+eta_m delta_m, + eta_m=1/[m exp(theta m^alpha)]. (E9) + +For small r, define the genuine probability law +mu_r=(1-r^3(2+eta_m))delta_0+r^3 nu_r. Its nonempty intensity satisfies(E2) +with nu1=nu2=1 and satisfies(E5) with the constant +exp(theta)+2exp(theta 2^alpha)+1. Every fixed polynomial moment of nu_r +converges. Its endpoint norm error is exactly1/m, as EW1 requires. + +But z_r=3+exp(-theta m^alpha). The size-biased law has w-weighted mass + + w(m) m eta_m/z_r=1/[3+exp(-theta m^alpha)] ->1/3 (E10) + +at m, where the limiting size-biased law has zero mass. It therefore fails +endpoint weighted convergence. This is a counterexample to a tempting stronger +inference, not a counterexample to the Gaussian source law. Extra uniform +integrability at n exp(theta n^alpha) would be needed for that inference. + +## 4. Weighted convolution and an explicit replica bound + +**Lemma EW3 (convolution algebra).** For0=0, +(x+y)^alpha<=x^alpha+y^alpha, so w(x+y)<=w(x)w(y). Thus on measures with finite +w-norm, convolution satisfies + + ||sigma*tau||_w<=||sigma||_w ||tau||_w. (E11) + +This normed space is complete, has identity delta_0, and +exp_*(A)=sum_(j>=0) A^(*j)/j! converges in norm with +||exp_*(A)||_w<=exp(||A||_w). + +**Proof.** For alpha<1, the derivative in y of (x+y)^alpha-y^alpha is +nonpositive for y>0, and its value at y=0 is x^alpha. For alpha=1 equality +holds. Multiplying absolute convolution coefficients by w, summing and using +nonnegative Fubini gives(E11). Completeness is that of weighted l1, equivalently +ordinary l1 after multiplying coordinates by w. The exponential series is +dominated in norm by the scalar exponential series. QED. + +Let delta=r^3, m_r(t)=floor(t/delta), and take m_r(t) deliberately INDEPENDENT +copies of N_r. Write their sum as S_r(t). By(E5), ||H_r||_w<=2C and +||H||_w<=2C. Choose B=2C. Let + + P_t=Law(P1+2P2), P1~Pois(t nu1), P2~Pois(t nu2), + P1 and P2 independent. + +**Theorem EW4.** For every finite T>=0 and all0<=t<=T, + + ||Law(S_r(t))-P_t||_w + <= exp(TB)[delta(TB^2/2+B)+2T epsilon_r]. (E12) + +In particular the replica laws converge uniformly on bounded t intervals in +the endpoint exponential-weight norm. This includes weighted tail control, +not only an ordinary TV or PGF limit. It claims no rate for epsilon_r. + +**Proof.** One-copy law is u_r=delta_0+delta H_r. Independence gives the exact +law u_r^(*m). The convolution exponential + + exp_*(s H_r)=exp(-s a_r) sum_(j>=0) s^j nu_r^(*j)/j! + +is a compound-Poisson probability law. Thus exp_*(t H)=P_t. These are +convolution exponentials of signed generators, not signed approximating +probability laws. The series remainder obeys + + ||exp_*(delta H_r)-u_r||_w + <= delta^2 B^2 exp(delta B)/2. (E13) + +Indeed for every j>=2,1/j!<=1/[2(j-2)!], so the scalar remainder is bounded +by that right side. Also ||u_r||_w<=1+delta B<=exp(delta B). +Telescoping m convolution factors with(E11) gives, for m>=1, + + ||u_r^(*m)-exp_*(m delta H_r)||_w + <= m delta^2 B^2 exp(m delta B)/2 + <= t delta B^2 exp(tB)/2. (E14) + +For m=0 the first difference is zero. For any A,D in this commutative algebra, +norm differentiation of the exponential series and integration in s imply + + exp_*(A)-exp_*(D) + = integral_0^1 exp_*((1-s)D+sA)*(A-D) ds, + ||exp_*(A)-exp_*(D)||_w + <= ||A-D||_w exp(max(||A||_w,||D||_w)). (E15) + +The floor error0<=t-m delta=1)(nu_r(n)-nu(n))(z^n-1)|<=2epsilon_r. + +Each PGF is analytic in its interior and continuous on the boundary. By(E12) +the replica PGFs converge uniformly on that closed disk to +exp[t nu1(z-1)+t nu2(z^2-1)], uniformly0<=t<=T. This does not claim an analytic +neighborhood beyond that disk for each prelimit. + +For d>2, alpha<1. No common disk extending the unit disk follows from(E1) +and(E2), despite the finite-support limit. To see this, let q(n),n>=3, be a +probability proportional to n^-3 exp(-2theta n^alpha), and set +nu_r=delta_1+delta_2+epsilon(r)q with epsilon(r)>0 tending to zero. It satisfies +(E1)--(E2): sum n exp(theta n^alpha)q(n)1, +sum z^n q(n)=infinity, since n log z-2theta n^alpha-3log n ->infinity. +The associated small-r probability laws are constructed exactly as in(E9). +So prelimit PGFs may have radius1. The endpoint convolution norm result still +holds. This generic counterexample does not assert that Gaussian counts +actually have radius1; a larger radius needs another argument. + +## 6. Scope, source exposure, falsifiers and review division + +The elementary theorems EW1--EW4 apply to ANY nonnegative-integer laws satisfying +(E1)--(E2), with delta=r^3; the proofs also work for another positive delta->0. +Their application here is conditional on BOTH full mathematical interfaces +at the listed fixed parameters. This does not upgrade [SC]'s fixed-parameter +claim to mark-uniform convergence, or [MF]'s compact-family statement to +unbounded birth/gap/dimension/volume. Constants theta,C,B are existential; +no extra coefficient digits or numerical enclosure is claimed. + +The author is exposed to both OpenAI source packets and the prior Slice-C +review of [SC]. That source-exposed work is not independent acceptance of +[SC] or [MF]. Internal OpenAI challenge agents have zero organizational +independence. A contributor who changes this proof cannot self-accept it. +Finite checks, custody hashes and CI establish finite/custody facts only. + +Falsifiers of the conditional application: unequal original W/Z/count +interfaces; failure of(E1) at any sufficiently small r; failure of(E2)'s +coefficient limit; replacement of independent copies by coupled copies. +Falsifiers of the NEW implication: an arithmetic/algebra error in the tail +bound(E6), absolute convolution(E11), floor/telescoping ledger(E12)--(E15), +or normalized-law passage. The exact examples(E9)--(E10) preserve the failure +of endpoint SIZE-BIASED convergence; they must not be removed from an honest +stronger-weight statement. The dimension counterexample preserves the +non-implication of a complex neighborhood for alpha<1. + +Proposed nonauthor slices, each independently rejectable: +A: endpoint intensity tails, strict-weight moments, positive/size-biased +normalizations and the escaping-mass falsifier (§§2--3). +B: submultiplicative convolution, uniform replica error and actual-versus-limit +mark rate (§4), plus the complex-disk boundary (§5). +The parent Gaussian/spectral and Fourier arguments are OUTSIDE these slices. +No merge or scientific-status transition is justified solely by this packet. diff --git a/frontiers/cluster_exponential_weight_20260930/README.md b/frontiers/cluster_exponential_weight_20260930/README.md new file mode 100644 index 000000000..31bfd56bc --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/README.md @@ -0,0 +1,71 @@ +# Endpoint exponential-weight closure + +Read [the complete conditional proof](PROOF.md) and [the exact inputs](SOURCES.json). +The packet combines Math-#157 MF1 with Math-#162's fixed-parameter coefficient +limit. Neither parent is accepted or promoted by this combination. + +It proves convergence of the nonempty count intensity in the endpoint norm +sum exp(theta n^(2/d))|nu_r(n)-nu(n)|, removes the subsequence from #157's +weighted consequence, and gives an explicit uniform finite-time replica bound. +Positive conditioning retains that endpoint weight. Size bias requires a +strictly smaller exponent; an exact escaping-mass counterexample preserves +this boundary. The replica construction uses independent copies of the field. + +The earlier polynomial and ordinary-TV consequences remain credited to the +input packets. No spatial independence, new Gaussian theorem, convergence +rate for coefficients, uniformity in moving marks, or numerical enclosure +is introduced. The unchanged proof now has actual scoped nonauthor +**ACCEPT, CONDITIONAL** dispositions for Slice A (§§1–3) and Slice B (§§4–5). +The [source-bound review record](REVIEW_RECORD.json) preserves the actual native +bodies, original commit, exact proof identity and exposure. These reviews +retain MF1 and SC(3) as imported premises; they do not accept the parents or +establish engineering merge readiness. Scientific effect NONE. + +The three recorded reviews are [Claude A+B](https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360109371), +[Codex A](https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360144037), +and [Codex B](https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360159070), +all on original commit `0e70540b70e5e3183df5ed1a6bd70a212b734c9c` and +proof SHA256 `3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee`. +They use the same GitHub account and carry zero organizational-independence +credit. The original author-side [validation history](VALIDATION.json) and +the dated original section of [internal challenges](INTERNAL_REVIEWS.md) +remain historical snapshots; their pending-review language is not the current +disposition. + +## Bounded plan and verification + +1. Bind the two existing interfaces at exact commit/path/blob/SHA256 identities. +2. Prove endpoint tail tightness and retain the failure of endpoint size bias. +3. Prove the weighted convolution and floor/Euler/intensity error ledger. +4. Run independent finite rational controls and deliberate wrong variants. +5. Preserve the completed source-bound reviews of §§1–3 and §§4–5, including + exact original source exposure, in REVIEW_RECORD.json. +6. Publish on an isolated additive branch; require real source-tree verification + and current-head hosted checks before any engineering integration. + +From the repository root, run the commands used by the packet workflow: + +```sh +packet=frontiers/cluster_exponential_weight_20260930 +python -B -S "$packet/verify_packet.py" +python -B -O -S "$packet/verify_packet.py" +python -B -S "$packet/finite_checks.py" +python -B -O -S "$packet/finite_checks.py" +python -B -S -m unittest discover -s "$packet" -p 'test_*.py' -v +python -B -O -S -m unittest discover -s "$packet" -p 'test_*.py' -v +python -B -S "$packet/verify_sources.py" --repo-root . +``` + +The two finite-control outputs must be byte-identical; they establish finite +arithmetic only. The packet guard enforces exact file membership and recorded +byte counts, SHA256 and Git blobs, excluding the manifest itself. It separately +binds VALIDATION.json and REVIEW_RECORD.json to the unchanged PROOF.md. +This checks custody, not remote review authenticity or mathematical acceptance. +VALIDATION.json is a historical record, not finite_checks.py output. Historical +source verification requires both pinned Git objects in a complete checkout; +connector-acquired copies do not substitute for that historical-tree check. + +Publication adds this packet and its isolated workflow only. Existing sources, +root indexes, live integration branches and scientific registers stay under +their own owners. Internal OpenAI challenge reviews carry zero organizational +independence and never self-accept the author's amendments. diff --git a/frontiers/cluster_exponential_weight_20260930/RECONNAISSANCE.md b/frontiers/cluster_exponential_weight_20260930/RECONNAISSANCE.md new file mode 100644 index 000000000..e0b3d9ea5 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/RECONNAISSANCE.md @@ -0,0 +1,27 @@ +# Reconnaissance memo — 30 September 2026 UTC + +Purpose: check the literature context for the elementary compound-Poisson +convolution step, without importing an unverified external theorem or making +novelty claims. + +Consensus was queried for compound-Poisson approximation with weighted total +variation and submultiplicative convolution weights. That lookup could not +complete. No Consensus result is claimed or consumed. + +Two primary author records were retrieved directly afterward: + +- Bero Roos, *Refined total variation bounds in the multivariate and compound + Poisson approximation*, arXiv:1509.04167v2, revised7 March2017: + https://arxiv.org/abs/1509.04167v2 . The abstract concerns approximation of + convolutions by compound-Poisson and signed measures. Only the abstract was + read here; no exact bound or weighted theorem from that paper is consumed. +- A.D. Barbour, Oliver Johnson, Ioannis Kontoyiannis and Mokshay Madiman, + *Compound Poisson Approximation via Information Functionals*, + arXiv:1004.3692v1, submitted21 April2010: + https://arxiv.org/abs/1004.3692v1 . The abstract gives independent-sum + compound-Poisson approximation context. Only the abstract was read; its + information-functional machinery is not used. + +The new implication is proved directly in PROOF.md using a weighted l1 +convolution algebra. This memo gives limited context, not a priority/novelty +audit and not an additional mathematical premise. diff --git a/frontiers/cluster_exponential_weight_20260930/REVIEW_RECORD.json b/frontiers/cluster_exponential_weight_20260930/REVIEW_RECORD.json new file mode 100644 index 000000000..ee3432199 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/REVIEW_RECORD.json @@ -0,0 +1,57 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "recorded_at_utc": "2026-09-30", + "original_review_head": "0e70540b70e5e3183df5ed1a6bd70a212b734c9c", + "proof": { + "path": "PROOF.md", + "bytes": 12576, + "sha256": "3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee", + "git_blob": "bf1268b9c18ec05561fd9b14c645ef0b8e530484" + }, + "source_map": { + "path": "SOURCES.json", + "bytes": 1650, + "sha256": "478bd0ad93200b0993562d1a7ea3a6f96c7e15620781df469df1e5c127a1b4a1", + "git_blob": "4b3eeb938bca54aa28ce4746028a2f152a94dac6" + }, + "current_disposition": "Scoped nonauthor ACCEPT, CONDITIONAL: Slice A and Slice B at the exact original proof bytes. Imported MF1 and SC(3), fixed parameters, independent copies and all stated limits remain hypotheses or restrictions. No parent acceptance, register transition or engineering merge readiness is inferred.", + "identity_policy": "verify_packet.py binds this declared proof identity to the actual proof and verifies this record through MANIFEST.json. It does not authenticate GitHub, recompute analytic review, or accept mathematical conclusions. The native records below were read back through authenticated GitHub access; their exact bodies and original source exposure are retained.", + "exposure_and_credit": [ + "Review5360109371 identifies Anthropic/Claude, provider-distinct from the mathematical author, same GitHub account, zero organizational-independence credit, reviewer-only prior exposure to SC.", + "Review5360144037 identifies OpenAI/Codex agent /root/c17_metadata_repair, same provider as the mathematical author; it discloses prior SC Slice A review and later complementary Claude exposure.", + "Review5360159070 identifies OpenAI/Codex agent /root/c17_pr158_slice_d_audit, same provider as the mathematical author; it discloses prior157 engineering,158D,162 spectral challenge and triage exposure, plus one same-provider internal challenge. It did not consume the complementary Claude analytic review before its own verdict.", + "All three native reviews use the same GitHub account. Provider distinction is not organizational independence. These records add no vote beyond the original scoped reviews.", + "The later C23 engineering repair was implemented by the prior Slice B reviewer, preserving the proof and mathematical sources. That contribution cannot self-accept the engineering repair; a separate nonauthor engineering review and current-base CI remain required." + ], + "historical_records": "VALIDATION.json and the original portion of INTERNAL_REVIEWS.md remain the original author-side snapshot, including pending-review language and historical run counts. This record supplies the later actual scoped dispositions without rewriting that history.", + "native_reviews": [ + { + "id": 5360109371, + "html_url": "https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360109371", + "commit_id": "0e70540b70e5e3183df5ed1a6bd70a212b734c9c", + "submitted_at": "2026-09-30T00:30:29Z", + "state": "COMMENTED", + "body": "## Anthropic/Claude NONAUTHOR analytic review — **Slices A (§§2–3) and B (§§4–5)** — exact head `0e70540b70e5e3183df5ed1a6bd70a212b734c9c`\n\n`frontiers/cluster_exponential_weight_20260930/PROOF.md`, blob `bf1268b9c18ec05561fd9b14c645ef0b8e530484`, SHA256 `3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee`, 12576 B. Scientific effect **NONE**. Will not merge. Exposure and provenance as in pickup [5901664947](https://github.com/d6g8k5htny-coder/Math-/pull/164#issuecomment-5901664947): provider-distinct from the author, same GitHub account, zero organizational-independence credit; not the author of [MF] or [SC]; reviewer-only exposure to [SC].\n\n### Interface check (§1) before the slices\n- [MF] at `cbb2f978`, blob `efb702f6…`, SHA256 `a5163679…` (verified from the object store): MF1 is `E_{Q_r^W}[N exp(θ N^{2/d})] ≤ C r³` for the original variance-one periodized field, original value/gradient pins, typed `W_r`, endpoint-only `Z_r`, `Q_r^W = (W_r/Z_r)Q_r`, all-index count in `(b − kr³, b)` excluding both pins, uniformly on a fixed compact family (`T` is the torus side). Fixing one parameter inside the family is legitimate. ✔\n- [SC] at `7a44130`, blob `16c56821…`: (3) at fixed `d, L, b, k, frame` with the same `W_r`, `Z_r`, `N_r` (§1 of that proof) gives, at `q = 0`, the coordinate convergence `r^{−3}Q(N_r = n) → ν1 1{n=1} + ν2 1{n=2}` with `0 < ν1 = a1 + β_far, ν2 = a2 < ∞`. ✔ So (E1)–(E2) are the two sources' statements at one common parameter, with identical `W/Z/count` interfaces; the packet's \"unequal interfaces\" falsifier does not fire.\n\n### VERDICT: **ACCEPT Slice A** (EW1, EW2, the escaping-mass example §3) and **ACCEPT Slice B** (Lemma EW3, EW4 with (E12)–(E15), the actual-versus-limit mark remark, and the §5 dimension boundary) — as elementary implications of (E1)–(E2) for any nonnegative-integer laws with `δ = r³`, at fixed `d, L, b, k, frame`, existential `θ, C, B`, independent copies only, no rate. No defect found. Four non-blocking wording notes.\n\n### Slice A — what I checked\n- **(E5)/(E6).** `r^{−3}E[N_r w(N_r)] = Σ_{n≥1} n w(n) ν_r(n)` (the `n = 0` term vanishes), so (E1) is (E5); for `n > M`, `1 ≤ n/(M+1)` gives (E6). Passing to the limit in the finite sums `Σ_{n≤M} n w(n) ν_r(n) ≤ C` and letting `M → ∞` gives `Σ n w(n) ν(n) ≤ C`, hence the same tail for `ν`. ✔\n- **EW1.** `ε_r ≤ Σ_{n≤M} w(n)|ν_r(n) − ν(n)| + 2C/(M+1)`; `r → 0` then `M → ∞`. Convergence at `θ` itself, as claimed: the retained factor `n` is what supplies the uniform integrability. **(E4):** `Law(N_r) = (1 − r³a_r)δ_0 + r³ν_r`, so `r^{−3}(Law − δ_0) = H_r`; `‖H_r − H‖_w = |a_r − a| + Σ_{n≥1} w|ν_r − ν| ≤ 2ε_r` since `w ≥ 1` gives `|a_r − a| ≤ ε_r`. ✔ The zero mass is centred, not scaled. ✔\n- **EW2.** With `γ = θ − θ' > 0`, `Σ_{n>M} n^q e^{θ'n^α}ν_r(n) ≤ C sup_{n>M} n^{q−1}e^{−γn^α} → 0` for every fixed `q` (E8); same for `ν`; finite coordinates converge. Positive conditioning: `ν_r/a_r` is `Law(N_r | N_r ≥ 1)`, `a_r → a > 0`, and the displayed two-term bound is the triangle inequality with `‖ν‖_w ≤ C`. Size bias: `nν_r(n)/z_r` is `N_r dQ_r^W/EN_r` on `{n ≥ 1}`; `q = 1` in (E7) gives the strictly-smaller-weight convergence and `z_r → ν1 + 2ν2`; limit `(ν1δ_1 + 2ν2δ_2)/(ν1 + 2ν2)`. ✔ The two denominators are correctly kept distinct.\n- **§3 example.** `Σ n w(n)ν_r(n) = e^θ + 2e^{θ2^α} + 1` (the `m` term is exactly 1) ✔; `ν_r(n) → ν(n)` coordinatewise as `m(r) → ∞` ✔; polynomial moments `m^{q−1}e^{−θm^α} → 0` ✔; `‖ν_r − ν‖_w = w(m)η_m = 1/m` ✔; `z_r = 3 + e^{−θm^α}` ✔; size-biased `w`-mass at `m` equals `1/(3 + e^{−θm^α}) → 1/3` (E10) while the limit size-biased law has no mass there ✔; `μ_r` is a probability law once `r³(2 + η_m) ≤ 1` ✔. This is a correct counterexample to endpoint size-biased convergence under (E1)–(E2) alone.\n\n### Slice B — what I checked\n- **Lemma EW3.** `(x+y)^α ≤ x^α + y^α` on `x, y ≥ 0`, `0 < α ≤ 1` (the derivative argument is right: `α[(x+y)^{α−1} − y^{α−1}] ≤ 0`, value `x^α` at `y = 0`), hence `w(x+y) ≤ w(x)w(y)` with `w(0) = 1`; (E11) by nonnegative Fubini; `(ℓ¹_w, *)` is a unital commutative Banach algebra (`‖δ_0‖_w = 1`), so `exp_*` converges with `‖exp_*(A)‖_w ≤ e^{‖A‖_w}`. ✔\n- **`B = 2C`.** `‖H_r‖_w = a_r + Σ_{n≥1} wν_r ≤ 2Σ_{n≥1} wν_r ≤ 2Σ nwν_r ≤ 2C`; same for `H`. ✔\n- **Compound Poisson identification.** `exp_*(sH_r) = e^{−sa_r}Σ_j s^jν_r^{*j}/j!` (commutativity, `exp_*(−sa_rδ_0) = e^{−sa_r}δ_0`) is the compound-Poisson law with intensity `sν_r`; `exp_*(tH) = Law(P1 + 2P2)` ✔.\n- **(E13).** `‖Σ_{j≥2}δ^jH_r^{*j}/j!‖ ≤ Σ_{j≥2}δ^jB^j/j! ≤ (δ²B²/2)e^{δB}` by `j! ≥ 2(j−2)!` ✔; `‖u_r‖_w ≤ 1 + δB ≤ e^{δB}` ✔.\n- **(E14).** Telescoping `u^{*m} − E^{*m} = Σ_{i 2`: `q(n) ∝ n^{−3}e^{−2θn^α}` has `Σ n e^{θn^α}q(n) < ∞` yet `Σ z^n q(n) = ∞` for every `z > 1`, so the prelimit PGF radius is 1; the laws are built as in (E9). Correct, and correctly limited to \"no common disk follows\", not a claim about the Gaussian counts. ✔\n\n### Custody (finite/custody facts only, never proof)\nWorktree at `0e70540`: `test_finite_checks` + `test_verify_sources` → **23/23** in `-B -S` and `-B -O -S`; `finite_checks.py` output byte-identical across the two modes (`12` checks, `8` positive, `4` intended negatives all rejected); `verify_sources.py --repo-root` reproduces both pinned identities (MF `efb702f6…`/`a5163679…`, SC `16c56821…`/`e971b2cb…`); tree clean. Hosted checks on `0e70540` read SUCCESS (`exact-exponential`, downstream, formal, gates). `VALIDATION.json` is a record file, not the checker's output, so no byte comparison to it is claimed.\n\n### Non-blocking wording notes\n1. §2, EW1 proof: \"Fatou on finite sums\" — the step is a limit of finite sums followed by `M → ∞` (monotone convergence of the partial sums); naming it so avoids a reader looking for a lim inf of a series.\n2. (E6) and (E8) use `ν_r ≥ 0` and `w ≥ 1`; one clause \"(`w ≥ 1`, so `|a_r − a| ≤ ε_r`)\" before (E4) would make the factor 2 self-evident.\n3. §3: say once that `μ_r` is a probability law for `r³(2 + η_m) ≤ 1`, i.e. for small `r` (the text says \"for small r\" in the definition but not why).\n4. §5, `d = 2`: the closed disk `|z| ≤ e^θ` is where the *intensity* PGFs converge by (E4); the replica PGF statement uses (E12) — already so, but one cross-reference to (E12) in the sentence would help.\n\n### Not established by this review\nNothing beyond Slices A and B at the scope above: no revalidation of [MF] or [SC] or of their parents; no mark-uniformity, no rate for `ε_r`, no within-field Poisson process, no spatial independence, no numerical constant; no register transition, no merge, and no second independent vote (same account; provider-distinct from the author and from the Codex pickup, but Claude sibling sessions share my provider).\n\n---\n_Generated by [Claude Code](https://claude.ai/code)_", + "github_login": "d6g8k5htny-coder" + }, + { + "id": 5360144037, + "html_url": "https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360144037", + "commit_id": "0e70540b70e5e3183df5ed1a6bd70a212b734c9c", + "submitted_at": "2026-09-30T00:36:55Z", + "state": "COMMENTED", + "body": "# C22 — nonauthor analytic review of PR164 Slice A\n\n**Verdict: ACCEPT Slice A, §§1–3, equations (E1)–(E10), as an elementary implication conditional on the exact MF1 and SC(3) interfaces. No blocking defect found.** The two imported statements are checked for matching objects and scope; their Gaussian, Fourier, spectral and regional proofs are not reaccepted by this review. Slice B, §§4–5, is outside this verdict.\n\nThe reviewed object is `OA-CLUSTER-EXP-WEIGHT-20260930-v1`, Math PR164, exact head `0e70540b70e5e3183df5ed1a6bd70a212b734c9c`, path `frontiers/cluster_exponential_weight_20260930/PROOF.md`: **12,576 bytes**, SHA256 `3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee`, Git blob `bf1268b9c18ec05561fd9b14c645ef0b8e530484`. I read the complete actual proof, then reconstructed §§1–3 and the consumed source interfaces. Later sections were read for boundaries, not reviewed as Slice B.\n\nScientific effect **NONE**. This review does not authorize a register transition, a source amendment, a whole-PR acceptance or a merge. Organizational-independence credit is **zero**.\n\n## Authorship, exposure and coordination\n\nI am the OpenAI/Codex review agent `/root/c17_metadata_repair`, operating in the GPT-6 agent environment. I did not author or modify PR164's proof, its implementation, or either consumed mathematical source. My earlier work includes an unpublished C17 metadata repair that was stopped after a competing author's successor, triage exposure, the actual PR162 Slice A nonauthor review, and the C21 delivery builder. Reviewing SC Slice A is prior exposure; its verdict is not transferred into acceptance of SC(3) or this new implication. This is fresh review of PR164's new conditional probability argument, with disclosed source exposure and the same provider as its author.\n\nThe first independent current timeline read showed only the author's request5901532627 and our actual pickup5901632715. Claim `cb43a8b2-57e1-4e51-8cab-21c9efa7fe6a` was read back in Work Events296, with expiry2026-09-30T02:26:20Z. I verified the exact row in root's saved actual readback before creating review evidence. Source and evidence writes are confined to this review directory; no source file or remote object was changed.\n\nAfter my analytic reconstruction and exact control runs were complete, the final coordination read exposed complementary Claude pickup5901664947 and actual review5360109371 at the same original head. That review's body was returned in the live timeline and therefore constitutes disclosed later exposure. It is not the basis for my reconstruction, tests or verdict, supplies no additional organizational independence, and is not counted as my work. Its remarks do not change the calculations recorded below. The timeline also identifies the separate C23 engineering pickup5901702618; that is not a competing analytic claim and is not integration evidence for this report. The shared GitHub account does not identify an independent organization. I did not use author-side internal challenges as review substitutes.\n\n## Exact parent interfaces and the common probability law\n\nThe target `SOURCES.json` contains two immutable proof inputs. Both full texts were read. Existing source bytes were reused only after byte count, SHA256 and computed Git-blob verification; no whole-Drive or repository recrawl occurred.\n\n| Input | Exact source | Identity | Consumption here |\n| --- | --- | --- | --- |\n| MF | `cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b`, `frontiers/c6_marked_fourier_20260929/PROOF.md` | 15,304 bytes; SHA256 `a5163679400d7d68c1c51538c9ed4ac111015487f79e820057f4ff3e20d09544`; blob `efb702f601eb0c0a24dad6d125061158158867b9` | MF1 at one fixed admissible parameter; its Fourier-regression and regional marked-Kac–Rice premises remain imported. Author: OpenAI / ChatGPT. |\n| SC | `7a44130b41b827577424a73c4feac4cde20b5568`, `frontiers/spectral_cluster_closure_20260929/PROOF.md` | 25,006 bytes; SHA256 `e971b2cbe50a8a06b47c1219191201e0d1037c9adac23e5e3b7d2051bb70c2eb`; blob `16c56821b52fd76b0be791622b9c3809eafde75a` | Coordinate consequence of (3), together with finite positive ν1,ν2, at fixed d,L,b,k,frame. Its other slices and imported premises remain separate. Author: OpenAI / GPT-6 Astra Pro. |\n\nMF §1 fixes the original variance-one periodized field, original maximum/saddle value-and-gradient endpoint pins, endpoint-conditioned Q_r, typed determinant product W_r, full endpoint-only Z_r, and Q_r^W=(W_r/Z_r)Q_r. Its N counts additional **all-index** critical points in the open height window `(b-k r³,b)`, excluding both pins. SC §1 explicitly defines the same observations at M=(-r/2,0), S=(r/2,0), the same typed product `F_d(H_M)F_(d-1)(H_S)`, same tilt, and same count. MF's torus-side notation T agrees with SC's L. There is no restriction to a single extra-point index, elder-selected points, or branch-adjacent points in the consumed count.\n\nFor any one admissible fixed d≥2, L>0, real b, k>0 and frame, the fixed mark can be placed inside the declared compact family with a positive gap floor. Restricting MF's compact-family assertion to that point supplies θ>0, C<∞ and r_* without making them explicit, uniform in unbounded b/k, or uniform in dimension/volume. SC(3) is explicitly fixed-parameter. Its q=0 consequence implies every coordinate limit in E2, with ν1=a1+β_far and ν2=a2 strictly positive and finite. None of these premises gives a convergence rate.\n\nConsequently the common law can consistently satisfy E1 and E2 without a change of normalization. All later divisions by a_r or z_r define new count laws only where the proof explicitly asks for them. They are not inserted into MF1, SC(3), W_r or Z_r. As a check on the distinction, the probability law with masses μ(1)=μ(2)=δ and μ(0)=1-2δ has full-law `E[N2^N]=10δ`, while conditioning on N≥1 gives expectation5. The latter cannot replace an O(δ) input bound. The retained original full tilt is essential.\n\n## EW1: retained-index endpoint tail and centered zero\n\nSet α=2/d, so 0<α≤1, and w(n)=exp(θn^α), w(0)=1. The measures ν_r and ν are nonnegative and have zero mass at0. Multiplying E1 by r^-3 gives the exact identity\n\n`sum_{n≥1} n w(n)ν_r(n) = r^-3 E_QW[N_r w(N_r)] ≤ C`.\n\nThere is no zero-atom contribution because of the factor n. For integer n>M, n≥M+1, hence\n\n`sum_{n>M} w(n)ν_r(n) ≤ (M+1)^-1 sum_{n>M} n w(n)ν_r(n) ≤ C/(M+1)`.\n\nThe denominator M+1 is sharp under this sole moment bound: a measure concentrated at M+1 with mass `C/[(M+1)w(M+1)]` attains equality. The stronger denominator M+2 is false. This also identifies precisely what would be lost if the retained n were dropped. A bound only on `sum wν_r` allows a mass `1/w(m)` to move to m→∞ while keeping endpoint weighted mass1; coordinate convergence alone would not eliminate it.\n\nFor each finite K, coordinate convergence gives `sum_{n≤K} n w(n)ν(n)≤C`. Increasing K proves the same full bound for ν by monotone convergence of nonnegative partial sums. This is the elementary content of the text's “Fatou on finite sums.” No dominated convergence of the whole infinite series is being assumed. In particular ν has the same C/(M+1) tail, and `||ν||_w≤C`.\n\nWriting ε_r=||ν_r−ν||_w, split the norm at a fixed M. The finite part tends to0; the rest is at most2C/(M+1). Thus `limsup_{r→0} ε_r≤2C/(M+1)` for every M, and sending M→∞ proves ε_r→0. The θ in the norm is exactly the θ from E1. No larger exponential moment or smaller-exponent slack was used. The order of limits is fixed M first, then M→∞.\n\nLet a_r=sumν_r and a=sumν=ν1+ν2>0. Since w≥1, `|a_r−a|≤ε_r`. The exact complete probability law is\n\n`μ_r=Law_QW(N_r)=(1−r³a_r)δ_0+r³ν_r=δ_0+r³H_r`, where `H_r=ν_r−a_rδ_0`.\n\nSupports at0 and at positive integers are disjoint, so there is an exact norm identity, stronger than the displayed inequality:\n\n`||r^-3(μ_r−δ_0)−H||_w = ε_r+|a_r−a| ≤ 2ε_r`, with `H=ν−aδ_0`.\n\nThis verifies E4. The uncentered scaled zero atom is `r^-3μ_r(0)=r^-3−a_r→+∞`; it cannot be silently included in a finite nonempty intensity measure. H and H_r have total signed mass0. The actual tests exercise this identity on genuine probability laws, including signed coefficient differences and the zero-error case.\n\n## EW2: strict exponent gap and the two normalized laws\n\nFix an integer q≥0 and 0≤θ'<θ, and set γ=θ−θ'>0. On n≥1,\n\n`n^q exp(θ'n^α) = n w(n) · n^(q−1) exp(−γn^α)`.\n\nTherefore the tail in E8 is bounded by `C sup_{n>M} n^(q−1)exp(−γn^α)`. The ratio tends to0 because `(q−1)log n−γn^α→−∞` for every fixed q and α>0. For q=0 the n^-1 factor is defined on the positive support and presents no singular zero-coordinate issue. The same bound holds for ν from the just-established moment bound. Finite-coordinate convergence then proves E7. This argument covers θ'=0, which supplies all polynomial moments and in particular first-moment convergence. It supplies no rate for ε_r or E7: coordinate convergence on the finite portion has no specified rate.\n\nFor conditioning on positivity, `Q(N_r≥1)=r³a_r`, so the conditional count distribution is ν_r/a_r. Because a_r→a>0, its denominator is bounded away from0 for all sufficiently small r. The triangle decomposition\n\n`ν_r/a_r−ν/a = (ν_r−ν)/a_r + ν(1/a_r−1/a)`\n\ngives the displayed bound `ε_r/a_r+|a_r−a|||ν||_w/(aa_r)`, which tends to0 at the **endpoint θ**. Its limit is `(ν1δ_1+ν2δ_2)/(ν1+ν2)`.\n\nFor size bias, the original first moment is `E_QW N_r = r³z_r`, where z_r=sum nν_r(n). The count law is `nν_r(n)/z_r`. E7 with q=1 and any strictly smaller θ' gives convergence of nν_r in that smaller weighted norm. Since its weights are at least1, it also gives z_r→z=ν1+2ν2>0. The same triangle argument with denominator z_r yields the asserted strict-weight convergence. Its limit is `(ν1δ_1+2ν2δ_2)/(ν1+2ν2)`.\n\nThe denominators a_r and z_r are distinct. With ν1,ν2>0 the two limiting distributions are distinct as well. The proof does not infer endpoint size-biased convergence from mere boundedness of its endpoint moment, and MF2's boundedness is not such a convergence statement. No additional field normalizer is introduced by these explicitly named count-law operations.\n\nA concrete no-rate family reinforces the qualifier: take θ=log2, α=1, r→0 and ν_r=(1+r)δ_1+δ_2. It satisfies the same type of uniform E5 bound and the required positive finite coordinate limit, but ε_r=2r and ε_r/r³=2/r²→∞. A sufficiently small-r probability law is again formed with zero mass1−r³sumν_r. Consequently coefficient convergence cannot be assigned an automatic O(r³) rate. This is an implication counterexample, not a statement about the source field's actual rate.\n\n## E9–E10: the genuine escaping-mass counterexample\n\nFix any 0<α≤1, θ>0 and any integer m=m(r)≥3 tending to∞. Let `t_m=exp(−θm^α)` and `η_m=t_m/m`. Then ν_r=δ_1+δ_2+η_mδ_m has total mass2+η_m, and η_m≤1/3. Hence, for all sufficiently small r, `r³(2+η_m)≤1` and the displayed μ_r is a genuine nonnegative probability law with positive nonempty intensity exactly ν_r.\n\nFor every fixed coordinate n≥3, the moving atom eventually leaves n; coordinates1 and2 stay1. Thus E2 holds with ν1=ν2=1. The full retained-index exponential budget is exactly\n\n`sum n w(n)ν_r(n) = exp(θ)+2exp(θ2^α)+m exp(θm^α)η_m = exp(θ)+2exp(θ2^α)+1`.\n\nIt is independent of r. Thus the actual μ_r satisfies E1 with that fixed constant. For every fixed polynomial moment q, the moving atom contributes `m^qη_m=m^(q−1)exp(−θm^α)→0`. The endpoint intensity error is exactly `w(m)η_m=1/m→0`, in accordance with EW1.\n\nBut z_r=3+t_m, and the size-biased law assigns m mass `mη_m/z_r=t_m/(3+t_m)`. Weighting it by w(m)=1/t_m gives exactly `1/(3+t_m)→1/3`. The limiting size-biased distribution is supported on1,2 and has zero mass at m. Absolute weighted norm cannot cancel that moving positive contribution. Indeed, the entire endpoint norm error is\n\n`1/(3+t_m) + [w(1)+2w(2)] t_m/[3(3+t_m)] → 1/3`.\n\nThis directly verifies the failure of endpoint weighted convergence, not merely failure of one proposed proof. The ordinary and strict-weight size-biased limits remain consistent with EW2 because the escaping weighted contribution then contains the decaying factor exp[−(θ−θ')m^α]. No contradiction with the endpoint positive-conditioned law occurs: its escaped weighted mass is `1/[m(2+η_m)]→0`.\n\nThe example is fully within the abstract assumptions E1–E2, so it refutes the stronger implication from those assumptions alone. It is expressly not asserted to arise from the Gaussian field. An additional uniform-integrability condition on n w(n)ν_r, or a genuinely stronger moment premise sufficient for it, would be needed to infer endpoint size-biased convergence.\n\n## Actual finite evidence and falsification controls\n\nThe independent script `exact_controls.py` is **8,655 bytes**, SHA256 `f8f0b8af48ca8cfa697cdc91076a96d4cfa9f761b006a839077a1c79681c966d`. It does not import or execute the author's verifier or finite controls. It uses exact Fraction arithmetic, explicit exceptions rather than removable assertions, and transparent rational interval bounds. The analytic derivation above proves the general statements; these finite calculations detect concrete algebraic/scope failures and do not prove Gaussian inputs or infinite-limit theorems by testing.\n\nThere were **20 actual executions**, ten with `-B -S` and ten with `-B -S -O`. In each mode the baseline exited0, all eight deliberate mutants exited1, and the unknown-mutant check exited2. Every corresponding stdout is byte-identical between modes. Original command vectors, return codes, stdout/stderr files and hashes are preserved in `controls/`. `execution-summary.json` is11,186 bytes, SHA256 `8b8faf298e8bfe7acf032ef7a3b3053f06373405f518fc4eaa2cc17be9b97d1f`. The deterministic baseline `RESULTS.json` is580 bytes, SHA256 `6e591f2400d7482695328aa664a53f90e0a88147ed8a9a65ee44c0c6cdb153a8`.\n\nThe positive checks comprise 1,458 retained-index tail inequalities,16 sharp M+1 atoms and M+2 falsifiers,12 exact centered-law identities,12 distinct normalized-law cases,62 genuine escaping probability laws,217 exact strict-exponent-gap identities,33 higher-dimensional rational interval cases, and6 no-automatic-rate cases. For d=2 the weight is exactly2^n. For d=4,6,8, choosing m=j^(d/2) makes m^(2/d)=j and w(m)=2^j exact; the sole irrational small-support weight w(2) lies in[2,4]. E5 is affine in that value, giving the rigorous rational budget interval[7,11]. This interval control is not a numerical coefficient claim.\n\nThe eight deliberately rejected alterations are:\n\n1. Dropping the retained n while retaining the endpoint tail conclusion.\n2. Replacing the sharp denominator M+1 by M+2.\n3. Scaling the raw zero atom without centering it.\n4. Using the size-biased denominator for positive conditioning.\n5. Using the positive-conditioning denominator for size bias.\n6. Inferring endpoint size-biased convergence from E1–E2.\n7. Assigning an automatic r³ coefficient-convergence rate.\n8. Substituting a nonempty-conditioned normalization for the original full tilt in MF1.\n\nThese controls supplement the explicit counterexamples and exact equalities in this report. No full master verification was run or is claimed for this read-only analytic review.\n\n## Retained obligations\n\nAcceptance is confined to the conditional implication in §§1–3 at the original immutable head. MF1 and SC(3) and all their imported hypotheses retain their separate review obligations and scopes. This report supplies no new global field estimate, coefficient value or rate, mark-uniform result, varying-dimension/volume assertion, spatial independence, elder pairing, event-identification result, or RN/JETMOD/prize closure. Independent-copy consequences belong to separately reviewed Slice B. A source amendment would require an affected fresh review; hash equality, CI and this scoped verdict do not authorize whole-PR integration by themselves.\n", + "github_login": "d6g8k5htny-coder" + }, + { + "id": 5360159070, + "html_url": "https://github.com/d6g8k5htny-coder/Math-/pull/164#pullrequestreview-5360159070", + "commit_id": "0e70540b70e5e3183df5ed1a6bd70a212b734c9c", + "submitted_at": "2026-09-30T00:38:56Z", + "state": "COMMENTED", + "body": "# PR164 Slice B — actual nonauthor analytic review\n\nDisposition: **ACCEPT, CONDITIONAL**, limited to PROOF.md §§4–5 (EW3, EW4,\nE11–E15, the actual-versus-limit mark-rate qualification, and the dimension\nboundary for complex PGFs). No actionable defect found in that scope.\n\nThis is an actual reconstruction by the OpenAI/Codex agent\n`/root/c17_pr158_slice_d_audit`, completed 30 September 2026 UTC. It is neither\nauthor self-acceptance nor an organizationally independent vote. The parent\nagent owns any native GitHub publication and disposition. This directory makes\nno remote change and cannot itself merge or change scientific status.\n\n## Exact object and authority\n\nRepository: `d6g8k5htny-coder/Math-`, PR164, exact head\n`0e70540b70e5e3183df5ed1a6bd70a212b734c9c`.\n\nReviewed full source:\n`frontiers/cluster_exponential_weight_20260930/PROOF.md`.\n\n- Bytes: `12576`.\n- Git blob: `bf1268b9c18ec05561fd9b14c645ef0b8e530484`.\n- SHA256: `3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee`.\n- Source-map bytes: `1650`; SHA256\n `478bd0ad93200b0993562d1a7ea3a6f96c7e15620781df469df1e5c127a1b4a1`.\n\nFresh PR metadata was read back during this review: same head, draft/open,\nbase `aa288385af9392c509233c25a0f4012c9ba023e5`. This review is of immutable\nmathematical bytes; those metadata do not establish current-base merge readiness.\n\nRoot R17 claim `cb43a8b2-57e1-4e51-8cab-21c9efa7fe6a` was read back in Work\nEvents row296, with expiry `2026-09-30T02:26:20Z`; pickup comment5901632715.\nThe exact claim/readback envelope is preserved as `claim-and-entry.json`.\nRoot authorized material output only in this Slice-B directory. The later\nClaude complementary pickup reported by root was coordination information,\nnot a premise or source of this verdict; I did not consume its analytic review.\n\n## Provider, authorship, and exposure\n\nActual provider/model identity available here: OpenAI/Codex. No unverifiable\nmodel version or external provider is imputed. I did not author PR164, either\nmathematical source, or the prior #157 mathematical proof. Prior exposure\nincludes #157's engineering workflow repair, #158 Slice D analytic review,\n#162's spectral-Jacobian challenge, and coordination triage. This review read\nthe full PR164 proof, its exact source map, and the consumed parent interfaces.\nI did not read PR164's author internal-review packet or import its test program.\n\nA separate internal read-only challenge agent,\n`/root/c17_pr158_slice_d_audit/c22_pgf_challenge`, directly fetched and read the\nsame full proof and challenged only §5 and the §4 independence/no-rate\nqualifications. It inherited our context and used the same provider. Its report\nis summarized separately in `CHALLENGE.md`; it supplies **zero additional\norganizational independence and no separate vote**. My derivations of the full\nSlice B ledger and the persisted test implementation remain this review's\nown work. Slice A is another agent's assignment and is not accepted here.\n\n## Pinned hypotheses, retained without re-proving them\n\nThe exact parent source bytes were hash-verified and preserved:\n\n| Interface | Immutable source | Bytes | SHA256 |\n|---|---|---:|---|\n| MF1: weighted first moment | commit `cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b`, `frontiers/c6_marked_fourier_20260929/PROOF.md`, blob `efb702f601eb0c0a24dad6d125061158158867b9` | 15304 | `a5163679400d7d68c1c51538c9ed4ac111015487f79e820057f4ff3e20d09544` |\n| SC(3): coordinate limit | commit `7a44130b41b827577424a73c4feac4cde20b5568`, `frontiers/spectral_cluster_closure_20260929/PROOF.md`, blob `16c56821b52fd76b0be791622b9c3809eafde75a` | 25006 | `e971b2cbe50a8a06b47c1219191201e0d1037c9adac23e5e3b7d2051bb70c2eb` |\n\nMF1 uses the variance-one periodized field, endpoint regression, original typed\nweight W, full endpoint-only Z, and the all-index additional count in the open\nwindow `(b-k*r^3,b)`, with both pins excluded. SC §1 names the same objects and\npins. MF's torus notation T corresponds to the fixed torus side L here; its\ncompact-family guarantee may be evaluated at this one fixed admissible mark.\nSC(3) supplies positive finite nu1,nu2 and coordinate convergence at these\nfixed parameters. None of the matching read or byte verification re-proves\nthe Gaussian, Fourier, regional Kac–Rice, spectral, or global-assembly parents.\n\nFor this slice I retain E1/E2 and Slice A's endpoint conclusion\n`epsilon_r=||nu_r-nu||_w -> 0` as hypotheses/dependencies. In particular, my\nverdict does not independently accept §§2–3, source-status changes, unresolved\nparent premises, or mark-uniformity. E5 is the exact re-expression of E1:\n`sum n*w(n)*nu_r(n) <= C`. All statements below apply for sufficiently small r\nwhere that interface holds, with one fixed dimension, torus, birth, gap, frame,\ntheta and C. No source of an epsilon rate or additional normalizer is supplied.\n\n## Analytic reconstruction\n\n### EW3 and the algebra required by EW4\n\nFor `00, the derivative of\n`(x+y)^alpha-y^alpha` is nonpositive. Its limit at y=0 is x^alpha, proving\nsubadditivity; the x=0 and alpha=1 cases are immediate. Consequently\n`w(n+m)<=w(n)*w(m)` on nonnegative integers. For signed or complex measures,\nthe triangle inequality followed by nonnegative Fubini bounds the convolution\nnorm by the product of norms. This simultaneously justifies absolute\nconvergence and rearrangement. The coordinate map `sigma(n) -> w(n)*sigma(n)`\nis an isometry to ordinary l1, giving completeness; delta0 is a norm-one unit.\nNo positivity of signed generators is needed for E11.\n\nThe exponential series converges absolutely in this unital commutative Banach\nalgebra, with norm bounded by the scalar exponential. The use of a commutative\nalgebra matters for the simple E15 derivative identity; it holds here because\naddition of the nonnegative integer indices commutes. There is no missing\nnoncommutative correction.\n\n### The actual one-copy law and B\n\nBy definition of nu_r on the positive indices, the one-copy law is exactly\n`u_r=delta0+delta*H_r`, with `delta=r^3` and\n`H_r=nu_r-a_r*delta0`. The coefficient at zero is centered. For small r this\nis an actual probability measure, already supplied by the original law, not\nan arbitrarily signed approximation.\n\nSince n>=1 and w(n)>=1,\n`||nu_r||_w<=C`, `a_r<=C`, and hence `||H_r||_w<=2C=B`.\nThe limit has the same bounds by finite-sum Fatou under coordinate convergence.\nAlso `|a_r-a|<=epsilon_r`, so `||H_r-H||_w<=2*epsilon_r`; the zero-coordinate\nerror is essential even when not sharp. For s>=0, splitting the commuting\ngenerator gives\n`exp_*(s*H_r)=exp(-s*a_r)*sum_j s^j*nu_r^(*j)/j!`, which is a compound-Poisson\nprobability law. For `H=nu1*delta1+nu2*delta2-(nu1+nu2)*delta0`, it is exactly\nthe law of the stated independent Poisson counts with jump sizes one and two.\n\n### E13, E14, E15, and the complete error ledger\n\nFor E13, the jth remainder norm is at most `(delta*B)^j/j!`. For j>=2,\n`1/j!<=1/[2*(j-2)!]`, giving the displayed\n`delta^2*B^2*exp(delta*B)/2`. The power delta^2 and coefficient1/2 are correct.\n\nLet `v=exp_*(delta*H_r)`. For m>=1, the exact telescoping difference of m\nconvolution factors has m terms. Each remaining product contains m-1 factors,\neach with norm at most `exp(delta*B)`: for u use `1+delta*B<=exp(delta*B)`;\nfor v use the exponential norm bound. Thus each error term contributes at\nmost `delta^2*B^2*exp(m*delta*B)/2`, and their sum has the factor m in E14.\nThere is no extra uncompensated `exp(delta*B)` after counting all factors.\nFor m=0 both powers are the unit and that difference is exactly zero.\n\nFor E15, set `G(s)=D+s*(A-D)`. Norm-convergent differentiation, justified\nuniformly on the compact s interval by the exponential majorant, gives\n`d exp_*(G(s))/ds=exp_*(G(s))*(A-D)`. Its Bochner integral is the desired\ndifference. Convexity of the norm gives\n`||G(s)||<=max(||A||,||D||)`, proving the stated Lipschitz bound. This\nargument is valid for both signed-real and complex sequences.\n\nThe triangle decomposition is precisely\n\n1. `u_r^(*m)` to `exp_*(m*delta*H_r)` (Euler term);\n2. `exp_*(m*delta*H_r)` to `exp_*(t*H_r)` (floor term);\n3. `exp_*(t*H_r)` to `exp_*(t*H)` (intensity replacement).\n\nWith `m=floor(t/delta)`, `m*delta<=t` and `0<=t-m*delta2, alpha<1. The normalization constant for\n`q(n) proportional to n^-3*exp(-2*theta*n^alpha), n>=3`, is finite and\nstrictly positive. Its required weighted first moment is the finite series\n`constant*sum n^-2*exp(-theta*n^alpha)`. A positive function epsilon(r)->0\nis bounded for sufficiently small r, so the perturbed intensities have one\nuniform E1 constant and converge at each fixed index as in E2. Choosing r\nsmall makes `1-r^3*(2+epsilon(r))` nonnegative, giving genuine probability\nlaws. For every real z>1, the logarithm of the unnormalized PGF term is\n`n*log(z)-2*theta*n^alpha-3*log(n)`, which tends to positive infinity, since\nalpha<1. Thus the terms do not even tend to zero. Their radius is exactly\none because the laws still have finite total mass. The conclusion is a\nfailure of implication for the abstract interfaces; it says nothing negative\nabout the actual Gaussian count's analytic radius.\n\n## Actual finite and interval controls\n\n`verify_slice_b.py` is a new independent implementation using only Python's\nstandard library. It imports neither the author verifier nor any parent test.\nI executed it once successfully; `execution.json` captures the actual command,\nPython version, start/end time, exit code, and exact stdout/stderr hashes.\n`verification.stdout` and `.stderr` are the captured original byte streams.\nThe source identities are checked again during that execution.\n\n- 81 finite signed-rational convolution pairs satisfy E11 and commutativity.\n- 567 exact finite telescoping identities include the zero-factor case.\n- 567 homogeneous coefficient/integral identities reconstruct E15 term by\n term, using exact integration of powers of the interpolation variable.\n- 41 scalar Taylor coefficient inequalities test E13's remainder bound.\n- 25 rational square comparisons test alpha=1/2 subadditivity, including zero.\n- 60 actual replica-law comparisons use d=2, theta=log2, w(n)=2^n, rational\n one/two-jump intensities and times. Of these, 24 have m=0 and 45 have a\n nonzero actual/limiting intensity difference. The entire weighted norm\n against the infinite compound-Poisson law is enclosed: rational Taylor\n bounds enclose the exponential, exact recurrences enclose every retained\n coefficient, and a positive geometric bound covers the omitted weighted\n Poisson jump-count tail. Comparing this norm upper bound with a lower\n enclosure of E12's right side verifies the actual inequality for each case.\n\nEight negative controls were rejected as intended: extending alpha above\none; deleting the floor error; deleting intensity replacement; claiming a\ndelta^3 Euler remainder; replacing independent copies by fully coupled ones;\ndeducing an automatic delta^2 actual-to-limit one-copy rate; removing zero\ncentering; and inferring a disk beyond one from a stretched-exponential bound.\nIn particular, for `delta=k^-2` and positive intensities\n`nu_r=(1+1/k)*delta1+delta2`, the exact one-copy weighted error is `3/k^3`;\nits ratio to delta^2 is `3*k`, recorded as12,24,48,96,192. For fully coupled\ncopies with delta=1/100 and both limiting intensities one, the zero-mass\ndiscrepancy at t=1 is rigorously greater than4/5.\n\nThese finite controls supplement the preceding analytic derivation. Their\npassing does not prove an infinite theorem, validate either parent, or add a\nsecond acceptance. No master or author workflow was rerun by this reviewer.\n\n## Remaining gates\n\nNo amendment is requested for this exact Slice B. It remains conditional on\nE1/E2, the fixed-parameter identification, and Slice A's endpoint norm\nconvergence. The proof's existential constants, missing epsilon rate,\nindependent-copy scope, original W/Z normalization, distinction between\npositive conditioning and size bias, all-index count, and unaccepted parent\nobligations are retained. This verdict grants no all-angle/all-radius result,\nspatial Poisson process, new Gaussian moment proof, event-identification\ntheorem, organizational independence, prize closure, or merge readiness.\n\nExact mathematical changes require a new affected review. Source-preserving\nintegration, current-base CI, native-review custody, R17 release, and delivery\nremain with root under their own applicable authority.\n", + "github_login": "d6g8k5htny-coder" + } + ] +} diff --git a/frontiers/cluster_exponential_weight_20260930/SOURCES.json b/frontiers/cluster_exponential_weight_20260930/SOURCES.json new file mode 100644 index 000000000..4b3eeb938 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema": 1, + "repository": "d6g8k5htny-coder/Math-", + "scientific_effect": "NONE", + "policy": "Direct mathematical interfaces only. Verifying immutable bytes does not accept either parent theorem or this new implication.", + "sources": [ + { + "id": "MF", + "commit": "cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b", + "path": "frontiers/c6_marked_fourier_20260929/PROOF.md", + "bytes": 15304, + "git_blob": "efb702f601eb0c0a24dad6d125061158158867b9", + "sha256": "a5163679400d7d68c1c51538c9ed4ac111015487f79e820057f4ff3e20d09544", + "author": "OpenAI / ChatGPT", + "use": "MF1 only at a fixed parameter inside the declared compact family, alpha=2/d, ORIGINAL W/Z and ALL-INDEX count. Parent proof not revalidated here.", + "source_url": "https://github.com/d6g8k5htny-coder/Math-/blob/cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b/frontiers/c6_marked_fourier_20260929/PROOF.md" + }, + { + "id": "SC", + "commit": "7a44130b41b827577424a73c4feac4cde20b5568", + "path": "frontiers/spectral_cluster_closure_20260929/PROOF.md", + "bytes": 25006, + "git_blob": "16c56821b52fd76b0be791622b9c3809eafde75a", + "sha256": "e971b2cbe50a8a06b47c1219191201e0d1037c9adac23e5e3b7d2051bb70c2eb", + "author": "OpenAI / GPT-6 Astra Pro", + "use": "Coordinate consequence of (3), finite positive nu1,nu2 at FIXED d,L,b,k,frame. Pending parent slices and imported premises remain conditional; no source status promotion.", + "source_url": "https://github.com/d6g8k5htny-coder/Math-/blob/7a44130b41b827577424a73c4feac4cde20b5568/frontiers/spectral_cluster_closure_20260929/PROOF.md" + } + ] +} diff --git a/frontiers/cluster_exponential_weight_20260930/VALIDATION.json b/frontiers/cluster_exponential_weight_20260930/VALIDATION.json new file mode 100644 index 000000000..ab9e91fce --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/VALIDATION.json @@ -0,0 +1,28 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "scope": "finite rational algebra, immutable source custody and conditional prose", + "proof_sha256": "3f32fdd744350a15359451bbbee6c6bcc71af47e4f57f6110d7afb4978e941ee", + "author_disposition": "AUTHOR_SIDE / CONDITIONAL; external scoped nonauthor review required", + "internal_reviews": "INTERNAL_REVIEWS.md; zero organizational independence", + "local_runs": { + "finite_controls": {"tests": 12, "positive": 8, "intended_negative": 4, "normal_exit": 0, "optimized_exit": 0, "stdout_byte_identical": true}, + "signed_convolution_pairs": 729, + "custody_controls": {"tests": 11, "normal_exit": 0, "optimized_exit": 0}, + "packet_discovery": {"tests": 23, "normal_exit": 0, "optimized_exit": 0} + }, + "preserved_failures": [ + "Initial finite-control implementation omitted zero centering; a mass check failed before correction.", + "Four checker-bypass mutation runs each caused one named negative control to fail and exit 1.", + "Initial repository-root discovery found zero tests and exited 5; targeted packet discovery is the supported command.", + "Initial source verifier accepted tree-as-commit, replacement-ref substitution and boolean schema; all three added controls failed before the minimal repairs. Separate re-review passed." + ], + "source_exposure": { + "connector_commit_path_blob_size_sha256_checks": true, + "current_MF_successor_proof_equals_pinned_text": true, + "local_complete_historical_git_objects_available": false, + "local_full_repository_suite_run": false, + "hosted_actual_checkout_source_verification": "REQUIRED, not yet claimed" + }, + "excluded_inferences": ["Gaussian proof from tests", "parent theorem acceptance", "spatial independence", "coefficient convergence rate", "larger-disk analyticity for d>2", "endpoint size-bias convergence", "register transition", "external organizational review", "engineering merge"] +} diff --git a/frontiers/cluster_exponential_weight_20260930/finite_checks.py b/frontiers/cluster_exponential_weight_20260930/finite_checks.py new file mode 100644 index 000000000..86d7f2482 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/finite_checks.py @@ -0,0 +1,218 @@ +"""Deterministic exact finite algebra controls for the conditional EW packet. + +All arithmetic is rational at alpha=1 and theta=log(2), so w(n)=2**n. +These controls validate selected finite identities and inequalities only. +They do not prove MF1, SC, a coefficient rate, or any field independence. +No source-cache content is read or exported by this module. + +Run ``python finite_checks.py`` (also with ``-O``) for one small JSON result. +The only intended failures are the four named variants in the test module. +""" + +from fractions import Fraction +from io import StringIO +import json +from math import factorial +import sys +import unittest + + +class ControlFailure(ValueError): + """An explicit finite invariant failed; never relies on Python assert.""" + + +def require(condition, label): + if not condition: + raise ControlFailure(label) + + +def rational(value): + require(isinstance(value, (int, Fraction)), "exact rational required") + return Fraction(value) + + +def canonical(measure): + result = {} + for n, coefficient in measure.items(): + require(isinstance(n, int) and n >= 0, "nonnegative integer atom required") + coefficient = rational(coefficient) + if coefficient: + result[n] = coefficient + return result + + +def add(left, right): + result = canonical(left) + for n, q in canonical(right).items(): + result[n] = result.get(n, Fraction(0)) + q + return canonical(result) + + +def scale(measure, scalar): + scalar = rational(scalar) + return canonical({n: scalar * q for n, q in canonical(measure).items()}) + + +def subtract(left, right): + return add(left, scale(right, -1)) + + +def weighted_norm(measure): + return sum((2**n * abs(q) for n, q in canonical(measure).items()), Fraction(0)) + + +def positive_intensity(intensity): + intensity = canonical(intensity) + require(all(n >= 1 and q >= 0 for n, q in intensity.items()), "positive intensity required") + return intensity + + +def center(intensity): + intensity = positive_intensity(intensity) + return add(intensity, {0: -sum(intensity.values(), Fraction(0))}) + + +def probability_from_intensity(intensity, delta): + delta = rational(delta) + require(delta > 0, "delta must be positive") + law = add({0: Fraction(1)}, scale(center(intensity), delta)) + require(all(q >= 0 for q in law.values()), "one-copy law must be nonnegative") + check_equal(sum(law.values(), Fraction(0)), Fraction(1), "one-copy probability mass") + return law + + +def escaping_intensity(m): + require(isinstance(m, int) and m >= 3, "escaping atom m must be at least 3") + return {1: Fraction(1), 2: Fraction(1), m: Fraction(1, m * 2**m)} + + +def positive_conditioned(intensity): + intensity = positive_intensity(intensity) + normalizer = sum(intensity.values(), Fraction(0)) + require(normalizer > 0, "positive-conditioned normalizer") + return scale(intensity, 1 / normalizer) + + +def size_biased(intensity): + intensity = positive_intensity(intensity) + biased = {n: n * q for n, q in intensity.items()} + normalizer = sum(biased.values(), Fraction(0)) + require(normalizer > 0, "size-biased normalizer") + return scale(biased, 1 / normalizer) + + +def convolve(left, right): + result = {} + for n, q in canonical(left).items(): + for k, p in canonical(right).items(): + result[n + k] = result.get(n + k, Fraction(0)) + q * p + return canonical(result) + + +def convolution_power(measure, exponent): + require(isinstance(exponent, int) and exponent >= 0, "nonnegative replica count required") + result, base = {0: Fraction(1)}, canonical(measure) + while exponent: + if exponent % 2: + result = convolve(result, base) + exponent //= 2 + if exponent: + base = convolve(base, base) + return result + + +def replica_law(intensity, delta, t): + delta, t = rational(delta), rational(t) + require(delta > 0 and t >= 0, "replica time and delta") + # This operation encodes deliberately independent replicas only. + return convolution_power(probability_from_intensity(intensity, delta), t // delta) + + +def exp_polynomial(generator, t, order=8): + """Signed convolution Taylor polynomial, not an infinite CP law. + + Its mass is exactly 1 when the generator has total mass zero, by + cancellation. For an uncentered positive generator even this mass + statement fails. The remainder must be added to every comparison + with exp_*(t*generator). + """ + t = rational(t) + require(t >= 0 and isinstance(order, int) and order >= 0, "Taylor time and order") + argument = scale(generator, t) + total = term = {0: Fraction(1)} + for j in range(1, order + 1): + term = scale(convolve(term, argument), Fraction(1, j)) + total = add(total, term) + return total + + +def scalar_exp_prefix(x, order=8): + x = rational(x) + require(x >= 0 and isinstance(order, int) and order >= 0, "scalar Taylor argument and order") + return sum((x**j / factorial(j) for j in range(order + 1)), Fraction(0)) + + +def scalar_tail_bound(x, order=8): + """Rigorous rational upper bound for sum_(j>order) x**j/j!. + + The first omitted term is x**(order+1)/(order+1)!. Each subsequent + ratio is at most x/(order+2), so a geometric series bounds the entire + infinite scalar tail when that ratio is below 1. Submultiplicativity + then bounds the omitted convolution tail at x=||t*generator||_w. + Fixtures keep x<=1/4 and use the fixed order 8 for replica comparisons; + no floating-point exponential or adaptive digit refinement is used. + """ + x = rational(x) + require(x >= 0 and isinstance(order, int) and order >= 0, "scalar remainder argument and order") + ratio = x / (order + 2) + require(ratio < 1, "geometric scalar remainder requires ratio below 1") + return x**(order + 1) / factorial(order + 1) / (1 - ratio) + + +def check_zero_mass(measure, label): + require(sum(canonical(measure).values(), Fraction(0)) == 0, label) + + +def check_upper(actual, upper, label): + require(actual <= upper, label) + + +def check_equal(actual, expected, label): + require(actual == expected, label) + + +def run_controls(): + import test_finite_checks + + suite = unittest.defaultTestLoader.loadTestsFromModule(test_finite_checks) + + def flatten(tests): + for test in tests: + if isinstance(test, unittest.TestSuite): + yield from flatten(test) + else: + yield test + + tests = list(flatten(suite)) + negative_ids = {test.id() for test in tests if getattr(test, "NEGATIVE_CONTROL", False)} + diagnostics = StringIO() + result = unittest.TextTestRunner(stream=diagnostics, verbosity=0).run(suite) + failed_ids = {test.id() for test, _ in result.failures + result.errors} + summary = { + "all_passed": result.wasSuccessful(), + "checks": result.testsRun, + "failed": len(failed_ids), + "positive_controls": len(tests) - len(negative_ids), + "intended_negative_controls": len(negative_ids), + "intended_negative_controls_rejected": len(negative_ids - failed_ids), + "scientific_effect": "NONE", + "scope": "finite_algebra_only", + } + print(json.dumps(summary, sort_keys=True, separators=(",", ":"))) + if not result.wasSuccessful(): + sys.stderr.write(diagnostics.getvalue()) + return 0 if result.wasSuccessful() else 1 + + +if __name__ == "__main__": + sys.exit(run_controls()) diff --git a/frontiers/cluster_exponential_weight_20260930/test_finite_checks.py b/frontiers/cluster_exponential_weight_20260930/test_finite_checks.py new file mode 100644 index 000000000..d350286f0 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/test_finite_checks.py @@ -0,0 +1,233 @@ +"""Exact finite controls only: no MF1/SC validation or field simulation.""" + +from fractions import Fraction as F +from itertools import product +from math import factorial +import unittest + +import finite_checks as fc + + +def coefficient_product(left, right): + """Independent oracle: evaluate PGF products, then Newton-interpolate. + + This never forms pairs of measure atoms. Exact product evaluations at + degree+1 distinct integers determine the polynomial coefficients. + """ + degree = max(left, default=0) + max(right, default=0) + values = [ + sum(q * x**n for n, q in left.items()) + * sum(q * x**n for n, q in right.items()) + for x in range(degree + 1) + ] + coefficients = [F(0)] * (degree + 1) + basis = [F(1)] # binomial(x, 0) + for j in range(degree + 1): + for n, q in enumerate(basis): + coefficients[n] += values[0] * q + values = [b - a for a, b in zip(values, values[1:])] + next_basis = [F(0)] * (len(basis) + 1) + for n, q in enumerate(basis): + next_basis[n] -= F(j, j + 1) * q + next_basis[n + 1] += F(1, j + 1) * q + basis = next_basis + return {n: q for n, q in enumerate(coefficients) if q} + + +class PositiveFiniteControls(unittest.TestCase): + def test_original_probability_and_zero_centering(self): + """An omitted negative atom at zero must fail this control.""" + for m in (3, 4, 8, 12): + eta = F(1, m * 2**m) + nu = {1: F(1), 2: F(1), m: eta} + self.assertEqual(fc.escaping_intensity(m), nu) + centered = fc.center(nu) + self.assertEqual(sum(centered.values()), 0) + delta = F(1, 128 * m) + law = fc.probability_from_intensity(nu, delta) + self.assertEqual(sum(law.values()), 1) + self.assertGreater(law[0], 0) + self.assertTrue(all(q >= 0 for q in law.values())) + self.assertEqual(law[m], delta * eta) + scaled = {n: q / delta for n, q in law.items()} + scaled[0] -= 1 / delta + self.assertEqual(scaled, centered) + self.assertEqual(centered[0], -(2 + eta)) + + def test_endpoint_errors_and_distinct_normalizers(self): + """Omitting n in size bias, or equating its denominator with a, fails.""" + limit = {1: F(1), 2: F(1)} + for m in (3, 4, 8, 12): + nu = fc.escaping_intensity(m) + eta = F(1, m * 2**m) + a, z = sum(nu.values()), sum(n * q for n, q in nu.items()) + self.assertEqual(a, 2 + eta) + self.assertEqual(z, 3 + F(1, 2**m)) + self.assertNotEqual(a, z) + self.assertEqual(fc.weighted_norm(fc.subtract(nu, limit)), F(1, m)) + centered_error = fc.weighted_norm( + fc.subtract(fc.center(nu), fc.center(limit)) + ) + self.assertEqual(centered_error, F(1, m) + eta) + self.assertLessEqual(centered_error, F(2, m)) + ordinary, biased = fc.positive_conditioned(nu), fc.size_biased(nu) + self.assertEqual(sum(ordinary.values()), 1) + self.assertEqual(sum(biased.values()), 1) + self.assertEqual(ordinary[1], 1 / a) + self.assertEqual(biased[1], 1 / z) + self.assertEqual(biased[2], 2 / z) + self.assertEqual(2**m * ordinary[m], 1 / (m * a)) + self.assertEqual(2**m * biased[m], 1 / z) + self.assertGreaterEqual(2**m * biased[m], F(1, 4)) + + def test_retained_n_factor_certifies_endpoint_tail(self): + """Replacing the first weighted moment by the zeroth breaks E6.""" + for m in (3, 4, 8, 12): + nu = fc.escaping_intensity(m) + first_moment = sum(n * 2**n * q for n, q in nu.items()) + self.assertEqual(first_moment, 11) + for cutoff in (1, 2, m - 1, m, m + 1): + tail = sum(2**n * q for n, q in nu.items() if n > cutoff) + fc.check_upper(tail, F(11, cutoff + 1), "E6 endpoint tail") + + def test_signed_convolution_against_coefficient_product(self): + """Lost signs, missed coefficients and a wrong weight fail the oracle.""" + measures = [ + {n: q for n, q in enumerate(entries) if q} + for entries in product((F(-2, 3), F(0), F(1, 2)), repeat=3) + ] + for left, right in product(measures, repeat=2): + convolution = fc.convolve(left, right) + self.assertEqual(convolution, coefficient_product(left, right)) + fc.check_upper( + fc.weighted_norm(convolution), + fc.weighted_norm(left) * fc.weighted_norm(right), + "E11 signed convolution", + ) + cancellation = fc.convolve({0: F(1), 1: F(-1)}, {0: F(1), 1: F(1)}) + self.assertEqual(cancellation, {0: F(1), 2: F(-1)}) + self.assertEqual(fc.weighted_norm(cancellation), 5) + + def test_taylor_polynomial_remainder_and_mass_are_explicit(self): + """Dropping the tail or treating every Taylor polynomial as a law fails.""" + generator = {0: F(-1), 1: F(1)} + polynomial = fc.exp_polynomial(generator, F(1, 16), order=2) + self.assertEqual(polynomial, {0: F(481, 512), 1: F(15, 256), 2: F(1, 512)}) + self.assertEqual(sum(polynomial.values()), 1) # centered cancellation + positive_polynomial = fc.exp_polynomial({1: F(1), 2: F(1)}, F(1, 128), 8) + positive_mass = sum(positive_polynomial.values()) + expected_mass = sum(F(1, 64)**j / factorial(j) for j in range(9)) + self.assertEqual(positive_mass, expected_mass) + self.assertNotEqual(positive_mass, 1) + self.assertGreater(F(1, 64)**9 / factorial(9), 0) # omitted CP-series mass + for x in (F(0), F(1, 16), F(1, 4)): + for order in (0, 2, 8): + remainder = fc.scalar_tail_bound(x, order) + tail_prefix = sum(x**j / factorial(j) for j in range(order + 1, order + 10)) + self.assertGreaterEqual(remainder, tail_prefix) + self.assertEqual(fc.scalar_exp_prefix(x, order), sum(x**j / factorial(j) for j in range(order + 1))) + + def test_one_copy_euler_error_with_infinite_tail_allowance(self): + """E13 comparison adds a rigorous remainder instead of truncating truth.""" + bound = F(22) # B=2C, C=11 in these escaping-mass fixtures. + for m in (3, 4, 8, 12): + nu, delta = fc.escaping_intensity(m), F(1, 128 * m) + generator = fc.center(nu) + x = delta * fc.weighted_norm(generator) + self.assertLessEqual(x, F(1, 4)) + law = fc.probability_from_intensity(nu, delta) + polynomial = fc.exp_polynomial(generator, delta, 8) + certified_error = fc.weighted_norm(fc.subtract(law, polynomial)) + fc.scalar_tail_bound(x, 8) + # A lower scalar enclosure makes this a stronger finite check. + e13_lower = delta**2 * bound**2 * fc.scalar_exp_prefix(delta * bound, 8) / 2 + fc.check_upper(certified_error, e13_lower, "E13 with Taylor remainder") + + def test_actual_replica_convolution_and_floor_ledger(self): + """Wrong replica multiplication or omitting m=floor(t/delta) fails.""" + bound = F(22) + for escape_m in (3, 4, 8, 12): + nu = fc.escaping_intensity(escape_m) + delta = F(1, 128 * escape_m) + generator = fc.center(nu) + for t in (F(0), delta / 2, 2 * delta, 7 * delta / 3): + copies = t // delta + law = fc.replica_law(nu, delta, t) + one_copy = fc.probability_from_intensity(nu, delta) + self.assertEqual(law, fc.convolution_power(one_copy, copies)) + self.assertEqual(sum(law.values()), 1) + self.assertGreaterEqual(t - copies * delta, 0) + self.assertLess(t - copies * delta, delta) + s = copies * delta + polynomial = fc.exp_polynomial(generator, s, 8) + x = s * fc.weighted_norm(generator) + self.assertLessEqual(x, F(1, 4)) + certified_error = fc.weighted_norm(fc.subtract(law, polynomial)) + fc.scalar_tail_bound(x, 8) + e14_lower = copies * delta**2 * bound**2 * fc.scalar_exp_prefix(s * bound, 8) / 2 + fc.check_upper(certified_error, e14_lower, "E14 with Taylor remainder") + bernoulli = {0: F(7, 8), 1: F(1, 8)} + self.assertEqual(fc.convolution_power(bernoulli, 2), {0: F(49, 64), 1: F(7, 32), 2: F(1, 64)}) + self.assertEqual(fc.convolution_power(bernoulli, 0), {0: F(1)}) + + def test_e12_actual_laws_against_limit_exponential_with_remainder(self): + """Endpoint mark error, floor and infinite-series tail all enter E12.""" + limit = {1: F(1), 2: F(1)} + generator = fc.center(limit) + bound, horizon = F(22), F(1, 100) + self.assertLessEqual(horizon * bound, F(1, 4)) + exponential_lower = fc.scalar_exp_prefix(horizon * bound, 8) + for m in (3, 4, 8, 12): + nu, delta = fc.escaping_intensity(m), F(1, 128 * m) + epsilon = fc.weighted_norm(fc.subtract(nu, limit)) + self.assertEqual(epsilon, F(1, m)) + for t in (F(0), delta / 2, 2 * delta, 7 * delta / 3): + self.assertLessEqual(t, horizon) + actual = fc.replica_law(nu, delta, t) + polynomial = fc.exp_polynomial(generator, t, 8) + x = t * fc.weighted_norm(generator) + certified_error = fc.weighted_norm(fc.subtract(actual, polynomial)) + fc.scalar_tail_bound(x, 8) + e12_lower = exponential_lower * ( + delta * (horizon * bound**2 / 2 + bound) + 2 * horizon * epsilon + ) + fc.check_upper(certified_error, e12_lower, "E12 with Taylor remainder") + + +class IntendedNegativeControls(unittest.TestCase): + NEGATIVE_CONTROL = True + + def test_reject_omitted_zero_centering(self): + """Deliberately wrong generator nu must be rejected as noncentered.""" + wrong_generator = fc.escaping_intensity(8) + with self.assertRaisesRegex(fc.ControlFailure, "zero-centering"): + fc.check_zero_mass(wrong_generator, "omitted-zero-centering") + + def test_reject_omitted_n_factor(self): + """A bounded zeroth weighted moment cannot justify the endpoint tail.""" + m = 16 + wrong_intensity = {1: F(1), 2: F(1), m: F(1, 2**m)} + wrong_constant = fc.weighted_norm(wrong_intensity) + self.assertEqual(wrong_constant, 7) + self.assertEqual(sum(n * 2**n * q for n, q in wrong_intensity.items()), 26) + with self.assertRaisesRegex(fc.ControlFailure, "omitted-n-factor"): + fc.check_upper(F(1), wrong_constant / m, "omitted-n-factor") + + def test_reject_endpoint_size_bias_convergence_inference(self): + """The false extension of the intensity's 2/m bound is rejected.""" + limit_biased = {1: F(1, 3), 2: F(2, 3)} + for m in (16, 32, 64): + biased = fc.size_biased(fc.escaping_intensity(m)) + error = fc.weighted_norm(fc.subtract(biased, limit_biased)) + self.assertGreaterEqual(error, F(1, 4)) + with self.assertRaisesRegex(fc.ControlFailure, "endpoint-size-bias"): + fc.check_upper(error, F(2, m), "endpoint-size-bias") + + def test_reject_coupled_replicas_as_independent(self): + """Perfectly coupled Bernoulli copies omit the positive middle atom.""" + coupled_sum = {0: F(7, 8), 2: F(1, 8)} + independent_sum = {0: F(49, 64), 1: F(7, 32), 2: F(1, 64)} + self.assertEqual(fc.weighted_norm(fc.subtract(coupled_sum, independent_sum)), F(63, 64)) + with self.assertRaisesRegex(fc.ControlFailure, "coupled-replicas"): + fc.check_equal(coupled_sum, independent_sum, "coupled-replicas") + + +if __name__ == "__main__": + unittest.main() diff --git a/frontiers/cluster_exponential_weight_20260930/test_verify_packet.py b/frontiers/cluster_exponential_weight_20260930/test_verify_packet.py new file mode 100644 index 000000000..e597b179f --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/test_verify_packet.py @@ -0,0 +1,249 @@ +"""Fail-closed packet custody regressions; no mathematical claim is tested.""" +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest + + +CHECKER = Path(__file__).with_name('verify_packet.py') + + +class PacketIdentityTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.root = Path(self.temp.name) / 'packet' + self.root.mkdir() + (self.root / 'PROOF.md').write_bytes(b'Exact synthetic proof.\n') + (self.root / 'SOURCES.json').write_bytes(b'{"synthetic":true}\n') + (self.root / 'README.md').write_bytes(b'Original custody fixture.\n') + self.validation = {'schema': 1, 'scientific_effect': 'NONE', + 'proof_sha256': hashlib.sha256(b'Exact synthetic proof.\n').hexdigest(), + 'preserved_failures': ['Historical fixture, not finite output.']} + self.write_validation() + proof = (self.root / 'PROOF.md').read_bytes() + self.review = {'schema': 1, 'scientific_effect': 'NONE', 'proof': { + 'path': 'PROOF.md', 'bytes': len(proof), + 'sha256': hashlib.sha256(proof).hexdigest(), + 'git_blob': hashlib.sha1(b'blob '+str(len(proof)).encode()+b'\0'+proof).hexdigest()}} + (self.root / 'REVIEW_RECORD.json').write_text(json.dumps(self.review) + '\n') + self.resign() + + def tearDown(self): + self.temp.cleanup() + + def write_validation(self): + (self.root / 'VALIDATION.json').write_text(json.dumps(self.validation) + '\n') + + def resign(self): + self.manifest = {'schema': 1, 'scientific_effect': 'NONE', + 'manifest_self_excluded': True, 'files': []} + for p in sorted(self.root.iterdir()): + if p.name != 'MANIFEST.json': + b = p.read_bytes() + self.manifest['files'].append({'path': p.name, 'bytes': len(b), + 'sha256': hashlib.sha256(b).hexdigest(), + 'git_blob': hashlib.sha1(b'blob '+str(len(b)).encode()+b'\0'+b).hexdigest()}) + self.write_manifest() + + def write_manifest(self): + (self.root / 'MANIFEST.json').write_text(json.dumps(self.manifest) + '\n') + + def check(self, accepted=False): + flags = ['-B', '-S'] + (['-O'] if sys.flags.optimize else []) + p = subprocess.run([sys.executable, *flags, str(CHECKER), '--packet-root', str(self.root)], + capture_output=True) + if accepted: + self.assertEqual(p.returncode, 0, p.stderr.decode()) + result = json.loads(p.stdout) + self.assertEqual(result['packet_files_verified'], 5) + self.assertTrue(result['validation_proof_identity_verified']) + self.assertTrue(result['review_proof_identity_verified']) + self.assertFalse(result['mathematical_acceptance']) + else: + self.assertEqual(p.returncode, 1, 'bad packet accepted or wrong failure: '+p.stdout.decode()+p.stderr.decode()) + self.assertEqual(p.stdout, b'') + self.assertIn(b'packet identity failed:', p.stderr) + + def test_valid_packet_cli_and_historical_validation(self): + self.check(accepted=True) + + def test_stale_file_bytes_rejected(self): + (self.root / 'README.md').write_bytes(b'Changed but unrecorded.\n') + self.check() + + def test_each_recorded_identity_is_enforced(self): + original = json.loads(json.dumps(self.manifest)) + for key, wrong in [('bytes', 1), ('sha256', '0'*64), ('git_blob', '0'*40)]: + with self.subTest(key=key): + self.manifest = json.loads(json.dumps(original)) + self.manifest['files'][0][key] = wrong + self.write_manifest() + self.check() + + def test_unlisted_file_rejected(self): + (self.root / 'EXTRA.txt').write_bytes(b'Unlisted.\n') + self.check() + + def test_missing_declared_file_rejected(self): + (self.root / 'README.md').unlink() + self.check() + + def test_duplicate_manifest_path_rejected(self): + self.manifest['files'].append(dict(self.manifest['files'][0])) + self.write_manifest() + self.check() + + def test_empty_manifest_rejected(self): + self.manifest['files'] = [] + self.write_manifest() + self.check() + + def test_essential_proof_cannot_be_removed_and_resigned(self): + (self.root / 'PROOF.md').unlink() + self.resign() + self.check() + + def test_essential_validation_cannot_be_removed_and_resigned(self): + (self.root / 'VALIDATION.json').unlink() + self.resign() + self.check() + + def test_manifest_self_exclusion_must_be_true_boolean(self): + for wrong in [False, 1, 'true', None]: + with self.subTest(value=wrong): + self.manifest['manifest_self_excluded'] = wrong + self.write_manifest() + self.check() + + def test_boolean_schema_rejected(self): + self.manifest['schema'] = True + self.write_manifest() + self.check() + + def test_invalid_size_types_rejected(self): + for wrong in [True, -1, 1.0, '1', None]: + with self.subTest(value=wrong): + self.manifest['files'][0]['bytes'] = wrong + self.write_manifest() + self.check() + + def test_unsafe_or_nonflat_paths_rejected(self): + for wrong in ['', '.', '..', '../PROOF.md', '/PROOF.md', './PROOF.md', + 'a//b', 'a/b', 'a\\b', 'C:proof', 'bad\0name', 7]: + with self.subTest(path=wrong): + self.manifest['files'][0]['path'] = wrong + self.write_manifest() + self.check() + + def test_duplicate_manifest_json_key_rejected(self): + text = (self.root / 'MANIFEST.json').read_text() + (self.root / 'MANIFEST.json').write_text(text.replace('"schema": 1', '"schema": 1, "schema": 1')) + self.check() + + def test_duplicate_record_key_rejected(self): + text = (self.root / 'MANIFEST.json').read_text() + (self.root / 'MANIFEST.json').write_text(text.replace('"bytes": ', '"bytes": 0, "bytes": ', 1)) + self.check() + + def test_manifest_symlink_rejected(self): + manifest = self.root / 'MANIFEST.json' + outside = self.root.parent / 'outside.json' + manifest.replace(outside) + manifest.symlink_to(outside) + self.check() + + def test_payload_symlink_rejected_even_when_bytes_match(self): + path = self.root / 'README.md' + outside = self.root.parent / 'outside.md' + path.replace(outside) + path.symlink_to(outside) + self.check() + + def test_unlisted_directory_rejected(self): + (self.root / 'extra').mkdir() + self.check() + + def test_listed_directory_rejected(self): + p = self.root / 'README.md' + p.unlink() + p.mkdir() + self.check() + + def test_symlink_packet_root_rejected(self): + original = self.root + self.root = original.parent / 'linked' + self.root.symlink_to(original, target_is_directory=True) + self.check() + + def test_false_validation_proof_rejected_after_manifest_resign(self): + self.validation['proof_sha256'] = '0'*64 + self.write_validation() + self.resign() + self.check() + + def test_boolean_validation_schema_rejected_after_manifest_resign(self): + self.validation['schema'] = True + self.write_validation() + self.resign() + self.check() + + def test_missing_validation_digest_rejected_after_manifest_resign(self): + del self.validation['proof_sha256'] + self.write_validation() + self.resign() + self.check() + + def test_duplicate_validation_key_rejected_after_manifest_resign(self): + p = self.root / 'VALIDATION.json' + text = p.read_text().replace('"schema": 1', '"schema": 1, "schema": 1') + p.write_text(text) + self.resign() + self.check() + + def test_nonfinite_json_rejected_after_manifest_resign(self): + self.validation['unexpected_number'] = float('nan') + self.write_validation() + self.resign() + self.check() + + def test_validation_history_not_compared_to_finite_output(self): + self.validation['local_runs'] = {'old_count': 23, 'old_missing_objects': True} + self.write_validation() + self.resign() + self.check(accepted=True) + + def test_overflowed_json_number_rejected_after_manifest_resign(self): + p = self.root / 'VALIDATION.json' + text = p.read_text().replace('"schema": 1', '"unbounded": 1e999, "schema": 1') + p.write_text(text) + self.resign() + self.check() + + def test_review_cannot_transfer_after_proof_validation_manifest_resign(self): + (self.root / 'PROOF.md').write_bytes(b'New proof with stale old review.\n') + self.validation['proof_sha256'] = hashlib.sha256((self.root / 'PROOF.md').read_bytes()).hexdigest() + self.write_validation() + self.resign() + self.check() + + def test_each_review_proof_identity_is_enforced_after_resign(self): + original = json.loads(json.dumps(self.review)) + for key, wrong in [('bytes', True), ('git_blob', '0'*40), ('sha256', '0'*64), ('path', 'README.md')]: + with self.subTest(key=key): + self.review = json.loads(json.dumps(original)) + self.review['proof'][key] = wrong + (self.root / 'REVIEW_RECORD.json').write_text(json.dumps(self.review) + '\n') + self.resign() + self.check() + + def test_review_record_cannot_be_removed_and_manifest_resigned(self): + (self.root / 'REVIEW_RECORD.json').unlink() + self.resign() + self.check() + + +if __name__ == '__main__': + unittest.main() diff --git a/frontiers/cluster_exponential_weight_20260930/test_verify_sources.py b/frontiers/cluster_exponential_weight_20260930/test_verify_sources.py new file mode 100644 index 000000000..0cde3642d --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/test_verify_sources.py @@ -0,0 +1,112 @@ +"""Hostile custody controls in synthetic Git trees; no Gaussian claim is tested.""" +import copy +import hashlib +import json +from pathlib import Path +import subprocess +import tempfile +import unittest + +from verify_sources import no_duplicates, verify + + +class SourceCustodyTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.root = Path(self.temp.name) + subprocess.run(["git", "init", "-q", str(self.root)], check=True) + entries, sources = [], [] + for label in ("MF", "SC"): + data = ("Synthetic " + label + " custody fixture\n").encode() + blob = self.git("hash-object", "-w", "--stdin", data=data).decode().strip() + name = "parent/" + label + ".md" + entries.append("100644 blob " + blob + "\t" + name + "\n") + sources.append({"id": label, "path": name, "git_blob": blob, + "sha256": hashlib.sha256(data).hexdigest(), "bytes": len(data)}) + sub = self.git("mktree", data="".join(e.replace("parent/", "") for e in entries).encode()).decode().strip() + tree = self.git("mktree", data=("040000 tree " + sub + "\tparent\n").encode()).decode().strip() + commit = self.git("-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid", + "commit-tree", tree, data=b"Synthetic fixture\n").decode().strip() + for source in sources: + source["commit"] = commit + self.manifest = {"schema": 1, "scientific_effect": "NONE", "sources": sources} + + def tearDown(self): + self.temp.cleanup() + + def git(self, *args, data=None): + return subprocess.run(["git", "-C", str(self.root), *args], input=data, + check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout + + def test_valid_historical_trees(self): + self.assertEqual(len(verify(self.root, self.manifest)["historical_sources_verified"]), 2) + + def test_nested_caller_has_full_tree_semantics(self): + nested = self.root / "frontiers" / "new-packet" + nested.mkdir(parents=True) + self.assertEqual(verify(nested, self.manifest), verify(self.root, self.manifest)) + + def test_wrong_path_even_with_correct_blob(self): + bad = copy.deepcopy(self.manifest) + bad["sources"][0]["path"] = "MF.md" + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_wrong_digest_or_size(self): + for key, wrong in (("sha256", "0" * 64), ("bytes", 1)): + bad = copy.deepcopy(self.manifest) + bad["sources"][0][key] = wrong + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_wrong_blob_in_real_commit(self): + bad = copy.deepcopy(self.manifest) + bad["sources"][0]["git_blob"] = bad["sources"][1]["git_blob"] + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_absent_commit_fails(self): + bad = copy.deepcopy(self.manifest) + bad["sources"][0]["commit"] = "0" * 40 + with self.assertRaises(subprocess.CalledProcessError): + verify(self.root, bad) + + def test_tree_must_not_pass_as_commit(self): + bad = copy.deepcopy(self.manifest) + tree = self.git("rev-parse", bad["sources"][0]["commit"] + "^{tree}").decode().strip() + for source in bad["sources"]: + source["commit"] = tree + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_local_replace_cannot_substitute_historical_commit(self): + empty_tree = self.git("mktree", data=b"").decode().strip() + empty_commit = self.git("-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid", + "commit-tree", empty_tree, data=b"No source paths\n").decode().strip() + self.git("replace", empty_commit, self.manifest["sources"][0]["commit"]) + bad = copy.deepcopy(self.manifest) + for source in bad["sources"]: + source["commit"] = empty_commit + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_boolean_schema_rejected(self): + bad = copy.deepcopy(self.manifest) + bad["schema"] = True + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_unsafe_path_fails(self): + for name in ("../parent/MF.md", "/parent/MF.md", "parent//MF.md"): + bad = copy.deepcopy(self.manifest) + bad["sources"][0]["path"] = name + with self.assertRaises(ValueError): + verify(self.root, bad) + + def test_duplicate_json_keys_fail(self): + with self.assertRaises(ValueError): + json.loads('{"schema":1,"schema":2}', object_pairs_hook=no_duplicates) + + +if __name__ == "__main__": + unittest.main() diff --git a/frontiers/cluster_exponential_weight_20260930/verify_packet.py b/frontiers/cluster_exponential_weight_20260930/verify_packet.py new file mode 100644 index 000000000..70b540e53 --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/verify_packet.py @@ -0,0 +1,135 @@ +"""Check local packet custody; this neither authenticates reviews nor proves mathematics.""" +import argparse +import hashlib +import json +import math +from pathlib import Path +import re +import stat +import sys + + +ESSENTIAL = {'PROOF.md', 'SOURCES.json', 'VALIDATION.json', 'REVIEW_RECORD.json'} + + +def unique_object(pairs): + result = {} + for key, value in pairs: + if key in result: + raise ValueError('duplicate JSON key: '+key) + result[key] = value + return result + + +def reject_constant(value): + raise ValueError('nonfinite JSON constant: '+value) + + +def finite_float(value): + result = float(value) + if not math.isfinite(result): + raise ValueError('nonfinite JSON number: '+value) + return result + + +def read_regular(path): + if not stat.S_ISREG(path.lstat().st_mode): + raise ValueError('not a regular, nonsymlink file: '+str(path)) + return path.read_bytes() + + +def read_json(data, label): + result = json.loads(data, object_pairs_hook=unique_object, parse_constant=reject_constant, + parse_float=finite_float) + if not isinstance(result, dict): + raise ValueError(label+' must be a JSON object') + if type(result.get('schema')) is not int or result['schema'] != 1: + raise ValueError(label+' must have integer schema 1') + if result.get('scientific_effect') != 'NONE': + raise ValueError(label+' scientific_effect must be NONE') + return result + + +def safe_name(value): + if (not isinstance(value, str) or not value or value in {'.', '..'} + or any(c in value for c in '/\\:\0')): + raise ValueError('unsafe or nonflat packet path: '+repr(value)) + return value + + +def check_identity(record, data, label): + if not isinstance(record, dict): + raise ValueError(label+' identity must be an object') + size = record.get('bytes') + if type(size) is not int or size < 0 or size != len(data): + raise ValueError(label+' byte count mismatch or invalid type') + actual = {'sha256': hashlib.sha256(data).hexdigest(), + 'git_blob': hashlib.sha1(b'blob '+str(len(data)).encode('ascii')+b'\0'+data).hexdigest()} + for key, length in [('sha256', 64), ('git_blob', 40)]: + value = record.get(key) + if not isinstance(value, str) or re.fullmatch('[0-9a-f]{'+str(length)+'}', value) is None: + raise ValueError(label+' invalid '+key) + if value != actual[key]: + raise ValueError(label+' '+key+' mismatch') + + +def verify(packet_root): + root = Path(packet_root) + if not stat.S_ISDIR(root.lstat().st_mode): + raise ValueError('packet root must be a nonsymlink directory') + manifest = read_json(read_regular(root / 'MANIFEST.json'), 'MANIFEST.json') + if manifest.get('manifest_self_excluded') is not True: + raise ValueError('MANIFEST.json must explicitly exclude itself') + records = manifest.get('files') + if not isinstance(records, list) or not records: + raise ValueError('MANIFEST.json files must be a nonempty list') + indexed = {} + for record in records: + if not isinstance(record, dict): + raise ValueError('manifest file entry must be an object') + name = safe_name(record.get('path')) + if name == 'MANIFEST.json' or name in indexed: + raise ValueError('self or duplicate manifest path: '+name) + indexed[name] = record + if not ESSENTIAL <= indexed.keys(): + raise ValueError('manifest lacks essential packet files') + observed = {p.name for p in root.iterdir()} + expected = set(indexed) | {'MANIFEST.json'} + if observed != expected: + raise ValueError('packet membership mismatch; missing='+repr(sorted(expected-observed)) + +'; undeclared='+repr(sorted(observed-expected))) + payloads = {} + for name, record in indexed.items(): + data = read_regular(root / name) + check_identity(record, data, name) + payloads[name] = data + proof = payloads['PROOF.md'] + validation = read_json(payloads['VALIDATION.json'], 'VALIDATION.json') + # VALIDATION is a retained author execution/history record, not finite_checks output. + if validation.get('proof_sha256') != hashlib.sha256(proof).hexdigest(): + raise ValueError('VALIDATION.json proof_sha256 does not bind current PROOF.md') + reviews = read_json(payloads['REVIEW_RECORD.json'], 'REVIEW_RECORD.json') + proof_record = reviews.get('proof') + if not isinstance(proof_record, dict) or proof_record.get('path') != 'PROOF.md': + raise ValueError('REVIEW_RECORD.json must bind PROOF.md') + check_identity(proof_record, proof, 'REVIEW_RECORD.json proof') + return {'schema': 1, 'scientific_effect': 'NONE', 'packet_files_verified': len(indexed), + 'validation_proof_identity_verified': True, 'review_proof_identity_verified': True, + 'remote_review_authenticity_checked': False, 'mathematical_acceptance': False} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--packet-root', type=Path, default=Path(__file__).absolute().parent) + args = parser.parse_args() + try: + result = verify(args.packet_root) + except (ValueError, OSError) as error: + print('packet identity failed: '+str(error), file=sys.stderr) + return 1 + print(json.dumps(result, indent=2, sort_keys=True)) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/frontiers/cluster_exponential_weight_20260930/verify_sources.py b/frontiers/cluster_exponential_weight_20260930/verify_sources.py new file mode 100644 index 000000000..a8ac3636c --- /dev/null +++ b/frontiers/cluster_exponential_weight_20260930/verify_sources.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +"""Verify immutable upstream Git trees; byte custody is not mathematical acceptance.""" +import argparse +import hashlib +import json +from pathlib import Path, PurePosixPath +import re +import subprocess + + +def no_duplicates(pairs): + result = {} + for key, value in pairs: + if key in result: + raise ValueError("duplicate JSON key: " + key) + result[key] = value + return result + + +def git(repo, *args): + return subprocess.run(["git", "--no-replace-objects", "-C", str(repo), *args], check=True, + stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout + + +def verify(repo, manifest): + if type(manifest.get("schema")) is not int or manifest["schema"] != 1 or manifest.get("scientific_effect") != "NONE": + raise ValueError("unexpected source manifest scope") + sources = manifest.get("sources") + if not isinstance(sources, list) or [s.get("id") for s in sources] != ["MF", "SC"]: + raise ValueError("exactly the MF and SC interfaces are required") + verified = [] + for source in sources: + commit, blob, digest = (source.get(k, "") for k in ("commit", "git_blob", "sha256")) + if not (re.fullmatch("[0-9a-f]{40}", commit) + and re.fullmatch("[0-9a-f]{40}", blob) + and re.fullmatch("[0-9a-f]{64}", digest)): + raise ValueError("invalid immutable identity") + name = source.get("path", "") + path = PurePosixPath(name) + if not name or path.is_absolute() or ".." in path.parts or str(path) != name: + raise ValueError("invalid repository-relative source path") + if type(source.get("bytes")) is not int or source["bytes"] < 1: + raise ValueError("invalid source size") + if git(repo, "cat-file", "-t", commit).strip() != b"commit": + raise ValueError(source["id"] + ": expected an actual historical commit") + # --full-tree is essential: callers may run from a nested packet directory. + listing = git(repo, "ls-tree", "--full-tree", "-z", commit, "--", name) + expected = ("100644 blob " + blob + "\t" + name + "\0").encode() + if listing != expected: + raise ValueError(source["id"] + ": historical commit/path/blob mismatch") + data = git(repo, "cat-file", "blob", blob) + if len(data) != source["bytes"] or hashlib.sha256(data).hexdigest() != digest: + raise ValueError(source["id"] + ": source bytes mismatch") + if hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() != blob: + raise ValueError(source["id"] + ": Git blob content mismatch") + verified.append({"id": source["id"], "commit": commit, "path": name, + "git_blob": blob, "sha256": digest, "bytes": len(data)}) + return {"scientific_effect": "NONE", "historical_sources_verified": verified} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo-root", required=True) + args = parser.parse_args() + manifest = json.loads(Path(__file__).with_name("SOURCES.json").read_text(), + object_pairs_hook=no_duplicates, + parse_constant=lambda value: (_ for _ in ()).throw(ValueError(value))) + print(json.dumps(verify(Path(args.repo_root).resolve(), manifest), sort_keys=True)) + + +if __name__ == "__main__": + main()