From cbb2f978f9b3e8e2eaca94f3b359b18d7c144f1b Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 17:41:30 -0500 Subject: [PATCH 1/2] Publish marked Fourier exponential-cluster candidate and exact source controls Author-side successor of the local handoff, on the landed Palm/D5 sources. Retain witness-regression prefactor, fixed field cap, full W/Z, and explicit #153 prior credit. Complete finite tests and mandatory current/historical source checks. No existing proof, review, status or graph changes; independent analytic review required. --- .github/workflows/c6-marked-fourier.yml | 44 +++ frontiers/c6_marked_fourier_20260929/PROOF.md | 292 ++++++++++++++++++ .../PUBLICATION_NOTE.md | 14 + .../c6_marked_fourier_20260929/README.md | 34 ++ .../RECONNAISSANCE.md | 17 + .../SOURCE_FILES.json | 46 +++ .../SOURCE_MAP.json | 62 ++++ .../c6_marked_fourier_20260929/marked.py | 72 +++++ .../source_check.py | 69 +++++ .../c6_marked_fourier_20260929/test_marked.py | 69 +++++ .../test_sources.py | 46 +++ .../c6_marked_fourier_20260929/verify.py | 52 ++++ 12 files changed, 817 insertions(+) create mode 100644 .github/workflows/c6-marked-fourier.yml create mode 100644 frontiers/c6_marked_fourier_20260929/PROOF.md create mode 100644 frontiers/c6_marked_fourier_20260929/PUBLICATION_NOTE.md create mode 100644 frontiers/c6_marked_fourier_20260929/README.md create mode 100644 frontiers/c6_marked_fourier_20260929/RECONNAISSANCE.md create mode 100644 frontiers/c6_marked_fourier_20260929/SOURCE_FILES.json create mode 100644 frontiers/c6_marked_fourier_20260929/SOURCE_MAP.json create mode 100644 frontiers/c6_marked_fourier_20260929/marked.py create mode 100644 frontiers/c6_marked_fourier_20260929/source_check.py create mode 100644 frontiers/c6_marked_fourier_20260929/test_marked.py create mode 100644 frontiers/c6_marked_fourier_20260929/test_sources.py create mode 100644 frontiers/c6_marked_fourier_20260929/verify.py diff --git a/.github/workflows/c6-marked-fourier.yml b/.github/workflows/c6-marked-fourier.yml new file mode 100644 index 000000000..7f42a1874 --- /dev/null +++ b/.github/workflows/c6-marked-fourier.yml @@ -0,0 +1,44 @@ +name: C6 marked Fourier controls + +'on': + pull_request: + paths: + - 'frontiers/c6_marked_fourier_20260929/**' + - '.github/workflows/c6-marked-fourier.yml' + - 'frontiers/c6_fourier_cutoff_20260929/PROOF.md' + - 'frontiers/c6_palm_route_20260929/PROOF.md' + - 'frontiers/c6_palm_route_20260929/SOURCE_MAP.json' + - 'frontiers/d5_dimension_lift_20260929/PROOF.md' + - 'frontiers/elder_dimension_lift_20260928/PROOF.md' + - 'frontiers/c6_rare_cluster_laws_20260929/PROOF.md' + push: + branches: [main] + paths: + - 'frontiers/c6_marked_fourier_20260929/**' + - '.github/workflows/c6-marked-fourier.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-marked: + 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: Both-mode controls and exact upstream custody + run: | + set -euo pipefail + packet=frontiers/c6_marked_fourier_20260929 + python -B -S "$packet/verify.py" --output "${RUNNER_TEMP}/marked-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + python -B -S -m unittest discover -s "$packet" -p test_sources.py -v + python -B -O -S -m unittest discover -s "$packet" -p test_sources.py -v + python -B -S "$packet/source_check.py" --repo "${GITHUB_WORKSPACE}" + git diff --exit-code diff --git a/frontiers/c6_marked_fourier_20260929/PROOF.md b/frontiers/c6_marked_fourier_20260929/PROOF.md new file mode 100644 index 000000000..efb702f60 --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/PROOF.md @@ -0,0 +1,292 @@ +# Marked Fourier cap: exponential-power control of rare critical-point clusters + +Object: OA-C6-MARKED-FOURIER-20260929-v1.1 (publication successor). +Author: OpenAI / ChatGPT. Date: 29 September 2026. +Disposition: AUTHOR-SIDE CANDIDATE; NONAUTHOR ANALYTIC REVIEW REQUIRED. +Scientific effect NONE. This note changes no source, review, graph, register or prize. + +## 1. Exact model and proposed strengthening + +Use precisely the original variance-one periodized Gaussian field, fixed dimension +`d>=2`, fixed torus side `T`, compact birth and positive-gap marks with `k>=k_->0`, +and original maximum/saddle value-and-gradient pins of sources F and P below. +The original endpoint-conditioned law is Q_r, the typed determinant weight is +W_r, and the full endpoint-only normalizer is Z_r. Write Q_r^W=(W_r/Z_r)Q_r. +N counts additional all-index critical points in (b-kr^3,b), excluding both pins. +No random observation set, changing dimension, vanishing gap floor, or additional +normalizer is introduced. + +Source F provides a Borel functional Psi_F of the FULL field, constructed from +Fourier truncation and successful Rouche radii, which bounds its total critical +count. Source P provides canonical Gaussian witness kernels, the witness-excluded +annulus geometry, the joint-frame floors, and the regional marked Kac--Rice +estimates. This note must extend F under those witness kernels; F's unconditional +tail by itself is not enough. + +**Proposed theorem.** There are theta>0, C0 such that, uniformly +on the stated fixed compact family, + + E_{Q_r^W}[ N exp(theta N^(2/d)) ] <= C r^3, 02 it is stretched +exponential with exponent 2/d, NOT an ordinary exponential moment. + +With the accepted additional-point lower event (P's source EDL), P(N>=1)>=c r^3. +Consequently both of the following are uniformly bounded: + + E[exp(theta N^(2/d)) | N>=1], + E_sizebiased[exp(theta N^(2/d))], + dP_sizebiased = N dQ_r^W / E_{Q_r^W}N. (MF2) + +These two probability laws are different. The theorem does not claim equality +or independence of their marks. Also + + P(N>=n) <= C r^3 n^(-1) exp(-theta n^(2/d)), n>=1. (MF3) + +This is a new proposed quantitative strengthening of the source's fixed-order +moment conclusions, not another acceptance of the source theorem. + +## 2. Source identities and dependencies + +F: `frontiers/c6_fourier_cutoff_20260929/PROOF.md`, on Math- main +`e1ca400b3414e5a7bec13b91bc4f1e5293df32be`, Git blob +`1d9177a259654df0fb7c558fcb803685e09608d2`, SHA256 +`c1692379a3a066589bd2522aaa5b4d480e736b737c8c39a474d1735185793733`. +Consumed: conditioned Fourier-coefficient method, fixed cover, local exponential +coordinate injectivity, isolated-zero Bezout and the successful-frequency cap. +The unconditioned Fourier tail is not assumed to hold under a witness kernel. + +P: `frontiers/c6_palm_route_20260929/PROOF.md`, merged by PR145 at +`820d4435c5f13c12b9c2f3590e859212d2648dc0`, Git blob +`89eb8adf08fe7afc2cab9662d3a9875c05ae5cc5`, SHA256 +`aa37f16040ab9e05bb2e4e3f1d678367497e8dc2cf43eef197a4d6592c2f129b`. +Consumed: Sections 4.1--4.4 definitions and witness slab; Section 5 canonical +kernel / nonnegative Borel field-mark formula; Section 6 joint floors and +regional determinants/density bounds; EDL only for the lower probability used +in MF2. Its mathematical Sections 3--7 are the source-reviewed successor; +the PR was open during the earlier local draft but is now merged. The proof blob +is unchanged from the originally read `78ac1100217279e7b692f0959f86eee34cd1910e`. +The exact landed dependency and its source map are verified by this packet workflow. + +G: the dimension-matched first-moment source was integrated by PR141 at the +above main commit; P binds its proof blob `9d82c707fdb17d3072a8930f26dabedf59e456fc`. +The marked argument below uses P's REGIONAL proof, not merely G's small mean. + +Prior-result credit: the independently reviewed and merged #153 packet +`frontiers/c6_rare_cluster_laws_20260929/PROOF.md`, blob +`2ab625cedfc2e47575c4a7fa4853413418c532da`, already supplies the independent-replica +and polynomially weighted compactness consequences from fixed-order moments. +Section 7 repeats the elementary replica proof for self-containment, not priority. +The new contribution there is exponential-power weighted compactness; MF1 is NOT +inferred from #153's finite-moment hypotheses or its ordinary TV bounds. + +This note is exposed to the earlier OpenAI work and reviews. An actual nonauthor +review of the new conditional Fourier argument and its exponential-mark insertion +is still required. No new theorem is inferred just from the supplied programs. + +## 3. Fourier coefficients under the actual witness regression + +Fix a witness kernel Q'=Q_r(. | Lambda=tau), where Lambda is one of P's regional +frames with invertible covariance Sigma, and let d_tau=tau-E_Qr Lambda. Put + + beta = sqrt(sum_i Var_Qr Lambda_i) ||Sigma^(-1)|| |d_tau|. + +For a real component c_n of the Fourier coefficient, let a_n be its prior +variance scale. Source F and bounded original pin-regression energy give +|E_Qr c_n|<=C sqrt(a_n), and Var_Qr(c_n)<=C a_n. +The EXTRA regression correction obeys + + |Cov_Qr(c_n,Lambda) Sigma^(-1)d_tau| + <= sqrt(Var_Qr c_n) sqrt(sum_i Var_Qr Lambda_i) + ||Sigma^(-1)|| |d_tau| + <= C sqrt(a_n) beta. + +Hence |E_Q'c_n|<=C sqrt(a_n)(1+beta), while Var_Q'c_n<=C a_n by projection. +For every fixed p, ||c_n||_{L^p(Q')}<=C_p sqrt(a_n)(1+beta). Real/imaginary parts +are treated separately; they need not be conditionally independent. + +Let P_m be the gradient of the frequency-m truncation of the FULL realized +field, in its fixed torus lattice. On the same fixed complex tube as F, Gaussian +spectral decay and Minkowski therefore give constants a>0,C independent of the +particular regional kernel such that + + E_Q' R_m^2 <= C(1+beta^2) exp(-4a m^2), + E_Q' L^2 <= C(1+beta^2), (MF4) + +where R_m=sup|grad f-P_m| and L is the fixed-annulus supremum of its derivative. +The frequency truncation is not a new pinned field. Only the original field +is used by N,W,Z, by the kernel, and by the conditional covariance floors. +The conditional MEAN is included in MF4; omitting it would invalidate the result. + +## 4. Witness-excluded Fourier tail + +Retain exactly the Psi_F of F, independent of which witness is being integrated. +Its definition allows all test radii in each interval [eta_j,2eta_j]. At a fixed +witness X, remove the slab of radii within zeta_0 of its local periodic lift's +distance from the centre, as in P. The actual cover has zeta_0<=eta_j/8. Failure +of the ORIGINAL cap test at all radii implies failure on this retained subset. +Thus one does not define or insert a different witness-dependent mark. + +Let Phi=max(1,phi^(-1/2)) with phi the infimum of det Cov_Q'G on the protected, +witness-excluded annuli, G=(Re grad f, Im grad f/t). All following bounds are +vacuous if phi=0; P's regional lemmas supply positive floors where used. +P's small-gradient volume bound reads, for small h, + + E_Q' Vol{ |grad f|<=3h in retained annuli } + <= C Phi h^(2d)(1+log(1/h)). (MF5) + +Take h_m=exp(-a m^2), lambda_m=exp(a m^2/(4d)), and delta_m=h_m/lambda_m. +For all m above a FIXED geometric threshold, delta_m<=eta_j/8 and <=zeta_0/2. +On R_m<=h_m and L<=lambda_m, failure on every retained radius yields separated +open balls in the sublevel set. Their number is at least c eta_j/delta_m. +P's corrected packing gives volume at least c eta_j delta_m^(2d-1). +Mean-volume Markov and MF4 consequently bound the three failure contributions by + + C Phi (1+a m^2) exp[-a(2d+1)m^2/(4d)], + C(1+beta^2) exp(-2a m^2), + C(1+beta^2) exp[-a m^2/(2d)]. (MF6) + +Absorb the fixed polynomial by reducing the rate. With A=1+beta^2+Phi>=1, + + Q'(k_j>m) <= C A exp(-c m^2), + Q'(Psi_F>x) <= C A exp(-c x^(2/d)), x>=0, (MF7) + +after constants absorb finitely many small cutoffs. No monotonicity of success +at the individual frequency m is assumed; 'success by m' is the finite union +used by F. The source's zero-count cap is pathwise, so no new analytic zero-set +or generic-coefficient hypothesis has entered. + +Set alpha=2/d and Y=Psi_F^alpha. From MF7, for 0t)dt + <= 1 + C A u/(c-u) <= C_u A. (MF8) + +The prefactor A is retained. A uniform exponential moment without this prefactor +has NOT been proved for arbitrary witness regressions. + +## 5. The exponential mark uses the same regional absorption + +Choose theta>0 with 2theta=2)>=c r^3, hence EN>=P(N>=1)>=c r^3; G gives +EN<=C r^3. On N>=1, exp(theta N^alpha)<=N exp(theta N^alpha), proving both MF2 +bounds after normalizing by the proper denominator. MF3 follows by Markov with +the increasing function n exp(theta n^alpha). + +For integer p>=2, (N)_p<=N N^(p-1), and elementary calculus gives + + sup_{x>=0} x^(p-1) exp(-theta x^alpha) + = [(p-1)/(e theta alpha)]^((p-1)/alpha). + +Consequently the proposed theorem makes the growth of the earlier unspecified +factorial constants explicit: + + E(N)_p <= C r^3 [(p-1)/(e theta alpha)]^((p-1)/alpha). (MF10) + +It does not give a lower bound of order r^3 for p>=3. A count taking only values +0 and2 is still a counterexample to that unwarranted inference. + +Since MF3 makes the rescaled tail uniformly small, choose a FIXED M sufficiently +large that C M^-1 exp(-theta M^alpha)<=c/2. Then + + P(2<=N<=M)>=c r^3/2. + +Thus the known multiple-point lower event cannot owe all its order-r^3 mass to +clusters of diverging size. This is not a limit law for cluster shape or location. + +## 7. A subsequential independent-replica consequence, not a Poisson field claim + +Fix one parameter sequence r_n down to zero in the admissible family. Define +nu_n(k)=r_n^-3 P(N_{r_n}=k), k>=1. MF1 gives +sum_k k exp(theta k^alpha) nu_n(k)<=C. Thus there is a subsequence converging +coordinatewise to a finite measure nu on the positive integers. For theta'=2}nu(k)>0, using the original +lower event and tightness. Uniqueness of nu is NOT implied by these bounds. + +For independent copies of the field at each r_n, take floor(t/r_n^3) copies and +sum their window counts. Its probability generating function is exactly + + [1+r_n^3 sum_{k>=1}nu_n(k)(z^k-1)]^floor(t/r_n^3), 0<=z<=1, + +which tends along the selected subsequence to + + exp[t sum_{k>=1}nu(k)(z^k-1)]. + +The replica sums are tight because their means are uniformly bounded. Every +subsequential weak limit has the displayed probability generating function, +which uniquely determines a probability measure on the nonnegative integers. +This is a compound-Poisson law with finite activity sum nu(k) and jump-size law +nu/sum nu. In d=2 the generating functions have a common complex neighborhood +of the closed unit disk, because alpha=1; in d>2 no such analytic-disk conclusion +follows from the stretched-exponential estimate alone. + +This conclusion concerns INDEPENDENT REPLICAS on a diverging sample-count scale. +It is not a Poisson or compound-Poisson spatial limit within one field, nor a +unique r->0 count distribution. Alternating rare counts of size2 and3 satisfy +the moment/tail hypotheses but produce different subsequential jump measures. + +## 8. Review boundary and useful falsifiers + +No full-field simulation or finite algebra test proves MF1. Review must check: +extra-conditioned coefficient means; a cap fixed before witness selection; +retained-radius geometry at tiny imaginary parts and periodic lifts; the uniform +positive rate in MF7 versus its nonuniform prefactor A; 2theta2 stretched exponential. +The prefactor under arbitrary witness conditioning is retained, not suppressed. + +The independent-replica argument is already present in merged #153 and is +credited explicitly. New exponential-weight compactness is separate. No unique +cluster law, spatial Poisson theorem, numerical constants or higher-factorial +lower bounds are claimed. Prior handoff bytes stay in their original delivery; +this is a documented successor, not a recovery of missing historical code. + +Run from this directory: + + python -B -S verify.py --output /path/to/new-output + python -B -O -S verify.py --output /path/to/other-new-output + python -B -S -m unittest -v test_sources + python -B -O -S -m unittest -v test_sources + +Each full verifier runs 17 finite mathematical controls and eight intended +semantic variants in BOTH Python modes. The ten additional custody controls use +synthetic local sources; they are not Gaussian checks or full upstream replays. +With a complete historical repository checkout, additionally run: + + python -B -S source_check.py --repo /path/to/repository + +That checks six current and historical proof/reading-rule identities, including +the credited prior result. The hosted workflow executes it with fetch-depth:0. +Passing finite or formal-scalar checks cannot accept the new analytic argument. diff --git a/frontiers/c6_marked_fourier_20260929/RECONNAISSANCE.md b/frontiers/c6_marked_fourier_20260929/RECONNAISSANCE.md new file mode 100644 index 000000000..a0ed64c1a --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/RECONNAISSANCE.md @@ -0,0 +1,17 @@ +# Dependency-focused reconnaissance, 29 September 2026 + +Consensus.search was actually attempted for Gaussian critical-point exponential +moments and Palm/Fourier cluster control; it returned the monthly 30-search quota +error with October 1 reset. No search record was invented from that response. + +Primary abstract and publisher metadata inspected via web: +Gass and Stecconi, The number of critical points of a Gaussian field: finiteness +of moments, arXiv:2305.17586; PTRF 190 (2024), 1167-1197, +DOI 10.1007/s00440-024-01273-5. +https://arxiv.org/abs/2305.17586 + +Read scope was abstract/metadata only, not full text. The record establishes the +existing general finite-moment context; it is not imported as a theorem for the +uniform coalescing-pin exponential mark proved here. No claim of exhaustive +novelty search, first priority, or new Gaussian-conditioning principle is made. +The actual technical premises are the pinned project sources in SOURCE_MAP.json. diff --git a/frontiers/c6_marked_fourier_20260929/SOURCE_FILES.json b/frontiers/c6_marked_fourier_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..66607f283 --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/SOURCE_FILES.json @@ -0,0 +1,46 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "files": { + "PROOF.md": { + "bytes": 15304, + "sha256": "a5163679400d7d68c1c51538c9ed4ac111015487f79e820057f4ff3e20d09544" + }, + "PUBLICATION_NOTE.md": { + "bytes": 900, + "sha256": "ce8c1215a2310411d4f367b5ba0a1ef241fb4e008458beee2c3c9010a5ebc6d3" + }, + "README.md": { + "bytes": 1815, + "sha256": "8325998b807fbcabb791bcc35a4e7e518772742c586450154fb0eb8d49215c7f" + }, + "RECONNAISSANCE.md": { + "bytes": 959, + "sha256": "20849f4240b2994e5051d494e8266f466c9f6f57370decc16736cbb2a312ab9d" + }, + "SOURCE_MAP.json": { + "bytes": 2650, + "sha256": "371c1259d1f352101fae614f4c40601a8d2ac36036145b276d1d0be913ef4ca0" + }, + "marked.py": { + "bytes": 2950, + "sha256": "0711e16b4e28903d04214c9b87de2e9f5c8a37c26df9142f081e9fe944a66d3f" + }, + "source_check.py": { + "bytes": 2797, + "sha256": "0a2fc856ca362dbc5e60ab7c06a90214934af308e9bd9ef1c2423bb659ec35bb" + }, + "test_marked.py": { + "bytes": 3564, + "sha256": "1834c399d250617e064f2ce0b137fbe54cdfc1ec9922342602db6bbf3af059ad" + }, + "test_sources.py": { + "bytes": 2476, + "sha256": "0b42855a27ff27287d4258d396e90477330633eb3f37a6d9c27d48d7d06befa4" + }, + "verify.py": { + "bytes": 3607, + "sha256": "39a17d9e3d363b957c5874cb23b0c91ee76615da9483bf725552a8a0d2ae5444" + } + } +} diff --git a/frontiers/c6_marked_fourier_20260929/SOURCE_MAP.json b/frontiers/c6_marked_fourier_20260929/SOURCE_MAP.json new file mode 100644 index 000000000..473085282 --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/SOURCE_MAP.json @@ -0,0 +1,62 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "sources": [ + { + "id": "F", + "path": "frontiers/c6_fourier_cutoff_20260929/PROOF.md", + "bytes": 18174, + "sha256": "c1692379a3a066589bd2522aaa5b4d480e736b737c8c39a474d1735185793733", + "git_blob": "1d9177a259654df0fb7c558fcb803685e09608d2", + "commit": "8ba851fb2addeccb7ff9befb6bdedac456b4cb9b", + "role": "Fourier coefficient method, fixed cover and pathwise cutoff cap; no witness-tail inference" + }, + { + "id": "P", + "path": "frontiers/c6_palm_route_20260929/PROOF.md", + "bytes": 53364, + "sha256": "aa37f16040ab9e05bb2e4e3f1d678367497e8dc2cf43eef197a4d6592c2f129b", + "git_blob": "89eb8adf08fe7afc2cab9662d3a9875c05ae5cc5", + "commit": "8ba851fb2addeccb7ff9befb6bdedac456b4cb9b", + "role": "Canonical kernels, protected witness geometry, joint floors and regional marked bounds" + }, + { + "id": "P-MAP", + "path": "frontiers/c6_palm_route_20260929/SOURCE_MAP.json", + "bytes": 14037, + "sha256": "c7cc195f00cc0c45577b7a27eb5e76f5cd9f1dbd1f11d855bcc9be427d699278", + "git_blob": "b528fe10aed99f1ee0947bb58da8623b0fabe354", + "commit": "8ba851fb2addeccb7ff9befb6bdedac456b4cb9b", + "role": "Complete parent input reading rule and review exposure" + }, + { + "id": "G", + "path": "frontiers/d5_dimension_lift_20260929/PROOF.md", + "bytes": 53727, + "sha256": "6fb94b247e8e45bca9dc02f46670ac6029fb54e0ef906001efe48fe908549b80", + "git_blob": "9d82c707fdb17d3072a8930f26dabedf59e456fc", + "commit": "8ba851fb2addeccb7ff9befb6bdedac456b4cb9b", + "role": "Dimension-matched window mean and regional geometry" + }, + { + "id": "EDL", + "path": "frontiers/elder_dimension_lift_20260928/PROOF.md", + "bytes": 23971, + "sha256": "b529fe3780e1909014b3cb144b9a74156d976bbdc19b6711d0c5b1a1da9e5669", + "git_blob": "7303bd791a68a1139251f0f6e403a9f7cc89b006", + "commit": "8ba851fb2addeccb7ff9befb6bdedac456b4cb9b", + "role": "Additional-point lower event only for MF2 and bounded-size positive mass" + }, + { + "id": "PRIOR153", + "path": "frontiers/c6_rare_cluster_laws_20260929/PROOF.md", + "bytes": 11811, + "sha256": "c52a3cf197b5cf26071a8cc951e15ef3ac564b3d7453d41647f91af540a1b8eb", + "git_blob": "2ab625cedfc2e47575c4a7fa4853413418c532da", + "commit": "8ba851fb2addeccb7ff9befb6bdedac456b4cb9b", + "role": "Explicit prior credit: independent replicas and polynomially weighted subsequences; not premise for MF1" + } + ], + "local_upstream_verification": false, + "new_analytic_review_required": true +} diff --git a/frontiers/c6_marked_fourier_20260929/marked.py b/frontiers/c6_marked_fourier_20260929/marked.py new file mode 100644 index 000000000..e0d6bcf37 --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/marked.py @@ -0,0 +1,72 @@ +"""Exact finite controls for the marked Fourier candidate, not a continuum prover.""" +from fractions import Fraction as F +from math import prod +MUTANT=None + +def alpha(d): + if type(d) is not int or d<2:raise ValueError('fixed dimension d>=2 required') + return F(1) if MUTANT=='exponential-every-d' else F(2,d) + +def admissible_rate(c,theta): + c,theta=F(c),F(theta) + return c>0 and theta>0 and (theta if MUTANT=='forget-holder-two' else 2*theta)var*obsvar:raise ValueError('invalid joint covariance') + mean=base_mean+cov*target/obsvar + return var-cov*cov/obsvar+(0 if MUTANT=='drop-mean' else mean*mean) + +def exponential_moment_bound(c,u,A): + c,u,A=map(F,(c,u,A)) + if not (0=1):raise ValueError('positive rate gap and A>=1 required') + return 1+(1 if MUTANT=='drop-prefactor' else A)*u/(c-u) + +def cutoff_rates(d,a): + alpha(d);a=F(a) + if a<=0:raise ValueError('positive rate required') + return 2*a,a*F(2*d+1,4*d),a/F(2*d) + +def check_law(p,n): + p=list(map(F,p));n=list(n) + if len(p)!=len(n) or not p or any(x<0 for x in p) or sum(p)!=1 or any(type(k) is not int or k<0 for k in n):raise ValueError('finite probability count law required') + return p,n + +def weighted_mark(p,n,w,b): + p,n=check_law(p,n);w=list(map(F,w));b=F(b) + if len(w)!=len(p) or min(w)<0 or b<=1:raise ValueError('nonnegative weights and b>1 required') + Z=sum(x*y for x,y in zip(p,w)) + if Z<=0:raise ValueError('positive normalizer required') + return sum(x*(y*y if MUTANT=='duplicate-weight' else y)*(1 if MUTANT=='drop-count-mark' else k)*b**k for x,y,k in zip(p,w,n))/Z + +def nonempty(p,n): + p,n=check_law(p,n);mass=sum(x for x,k in zip(p,n) if k>0) + if not mass:raise ValueError('nonempty event must have positive mass') + return [x/mass if k else F(0) for x,k in zip(p,n)] + +def sizebiased(p,n): + p,n=check_law(p,n) + if MUTANT=='nonempty-is-palm':return nonempty(p,n) + mean=sum(x*k for x,k in zip(p,n)) + if not mean:raise ValueError('positive count mean required') + return [x*k/mean for x,k in zip(p,n)] + +def tail_bound(M,epsilon,n,b): + M,epsilon,b=map(F,(M,epsilon,b)) + if M<0 or epsilon<0 or type(n) is not int or n<1 or b<=1:raise ValueError('invalid tail parameters') + return M*epsilon/((1 if MUTANT=='drop-tail-count' else n)*b**n) + +def factorial_power(d,p): + a=alpha(d) + if type(p) is not int or p<2:raise ValueError('integer moment p>=2 required') + return F(p-1)/a + +def levy_exponent(p,n,epsilon,z): + p,n=check_law(p,n);epsilon,z=F(epsilon),F(z) + if epsilon<=0 or not 0<=z<=1:raise ValueError('positive epsilon and real pgf domain required') + return sum(x*(z**k-1)/epsilon for x,k in zip(p,n) if k>0) + +def factorial_mean(p,n,q): + p,n=check_law(p,n) + if type(q) is not int or q<1:raise ValueError('positive integer order required') + return sum(x*prod(k-j for j in range(q)) for x,k in zip(p,n) if k>=q) diff --git a/frontiers/c6_marked_fourier_20260929/source_check.py b/frontiers/c6_marked_fourier_20260929/source_check.py new file mode 100644 index 000000000..055036f98 --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/source_check.py @@ -0,0 +1,69 @@ +"""Byte-bound upstream evidence, including explicitly credited prior results.""" +from pathlib import Path, PurePosixPath +import argparse +import hashlib +import json +import subprocess + + +def decode(text): + def pairs(items): + result = {} + for key, value in items: + if key in result: + raise ValueError('duplicate JSON key: '+key) + result[key] = value + return result + return json.loads(text, object_pairs_hook=pairs) + + +def identity(data): + return {'bytes': len(data), 'sha256': hashlib.sha256(data).hexdigest(), + 'git_blob': hashlib.sha1(f'blob {len(data)}\0'.encode()+data).hexdigest()} + + +def verify_files(root, entries): + root = Path(root).resolve() + seen = set() + ids = set() + for item in entries: + rel = PurePosixPath(item['path']) + if (not rel.parts or rel.is_absolute() or '..' in rel.parts or + '\\' in item['path'] or str(rel) in seen or item['id'] in ids): + raise ValueError('unsafe or duplicate source path/id') + seen.add(str(rel)); ids.add(item['id']) + path = root.joinpath(*rel.parts) + if any(root.joinpath(*rel.parts[:i]).is_symlink() for i in range(1, len(rel.parts)+1)): + raise ValueError('symlink source component') + if not path.is_file(): + raise ValueError('missing regular source: '+str(rel)) + expected = {key:item[key] for key in ('bytes','sha256','git_blob')} + if identity(path.read_bytes()) != expected: + raise ValueError('source byte identity differs: '+item['id']) + return len(entries) + + +def verify_git(root, entries): + for item in entries: + commit = item['commit'] + if len(commit)!=40 or any(c not in '0123456789abcdef' for c in commit): + raise ValueError('full lowercase commit identity required') + target = commit+':'+item['path'] + run = subprocess.run(['git','cat-file','blob',target],cwd=root,capture_output=True,timeout=30) + if run.returncode or run.stderr: + raise ValueError('historical source unavailable: '+item['id']) + if identity(run.stdout) != {key:item[key] for key in ('bytes','sha256','git_blob')}: + raise ValueError('historical source identity differs: '+item['id']) + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo',type=Path,required=True) + args=parser.parse_args() + entries=decode((Path(__file__).resolve().parent/'SOURCE_MAP.json').read_text())['sources'] + count=verify_files(args.repo,entries) + verify_git(args.repo,entries) + print(json.dumps({'upstream_files':count,'current_and_historical_bytes':'PASS', + 'analytic_acceptance':False},sort_keys=True)) + +if __name__=='__main__':main() diff --git a/frontiers/c6_marked_fourier_20260929/test_marked.py b/frontiers/c6_marked_fourier_20260929/test_marked.py new file mode 100644 index 000000000..5beb2f10b --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/test_marked.py @@ -0,0 +1,69 @@ +"""Finite normalization and boundary controls; not Gaussian continuum verification.""" +import unittest +from fractions import Fraction as F +import marked as m + +class MarkedTests(unittest.TestCase): + def test_holder_needs_twice_the_rate(self): + self.assertFalse(m.admissible_rate(F(1),F(3,4))) + self.assertFalse(m.admissible_rate(F(1),F(1,2))) + self.assertTrue(m.admissible_rate(F(1),F(1,4))) + def test_dimension_exponent(self): + self.assertEqual(m.alpha(2),1);self.assertEqual(m.alpha(3),F(2,3));self.assertEqual(m.alpha(4),F(1,2)) + def test_conditional_mean_is_not_dropped(self): + self.assertEqual(m.regression_second(1,F(1,2),1,3,0),3) + self.assertEqual(m.regression_second(1,F(1,2),1,3,1),7) + def test_residual_projection_decreases_variance(self): + for c in (F(-1),F(-1,2),F(0),F(1,2),F(1)): + self.assertLessEqual(m.regression_second(1,c,1,0,0),1) + def test_tail_prefactor_is_retained(self): + self.assertEqual(m.exponential_moment_bound(2,F(1,2),7),F(10,3)) + self.assertGreater(m.exponential_moment_bound(2,F(1,2),7),m.exponential_moment_bound(2,F(1,2),1)) + def test_cutoff_three_positive_rates(self): + for d in range(2,11): + v=m.cutoff_rates(d,F(3,5)) + self.assertTrue(all(x>0 for x in v)) + self.assertEqual(v[1],F(3,5)*F(2*d+1,4*d)) + def test_one_original_weight_and_normalizer(self): + probs=[F(1,2),F(1,3),F(1,6)];counts=[0,1,2];weights=[1,2,3] + self.assertEqual(m.weighted_mark(probs,counts,weights,F(2)),F(16,5)) + def test_count_weight_is_required(self): + self.assertEqual(m.weighted_mark([F(3,4),F(1,4)],[0,3],[1,1],2),6) + def test_nonempty_and_sizebiased_are_distinct(self): + p=[F(7,10),F(2,10),F(1,10)];n=[0,1,3] + self.assertEqual(m.nonempty(p,n),[F(0),F(2,3),F(1,3)]) + self.assertEqual(m.sizebiased(p,n),[F(0),F(2,5),F(3,5)]) + self.assertNotEqual(m.nonempty(p,n),m.sizebiased(p,n)) + def test_cluster_tail_includes_n(self): + self.assertEqual(m.tail_bound(F(2),F(1,100),4,2),F(1,3200)) + def test_exact_finite_exponential_cluster_family(self): + eps=F(1,1024);n=list(range(17));p=[F(0)]+[eps/F(k*4**k) for k in range(1,17)] + p[0]=1-sum(p[1:]);M=m.weighted_mark(p,n,[1]*17,2) + self.assertEqual(M,eps*(1-F(1,2**16)));self.assertLess(M,eps) + for k in range(1,17):self.assertLessEqual(sum(p[k:]),m.tail_bound(1,eps,k,2)) + def test_factorial_constant_growth_exponent(self): + for d in range(2,8): + for p in range(2,8):self.assertEqual(m.factorial_power(d,p),F(d*(p-1),2)) + def test_pgf_first_order_is_exact(self): + eps=F(1,100);probs=[1-3*eps,eps,2*eps];counts=[0,2,3] + for z in (F(0),F(1,4),F(1,2),F(1)): + self.assertEqual(sum(p*z**n for p,n in zip(probs,counts)),1+eps*m.levy_exponent(probs,counts,eps,z)) + def test_replica_independence_is_an_extra_assumption(self): + eps=F(1,10);z=F(1,2) + single=1-eps+eps*z**2 + independent=single**2;identical_copies=1-eps+eps*z**4 + self.assertNotEqual(independent,identical_copies) + def test_no_unique_limit_from_uniform_moment_bounds(self): + eps=F(1,100) + self.assertNotEqual(m.levy_exponent([1-eps,eps],[0,2],eps,F(1,2)),m.levy_exponent([1-eps,eps],[0,3],eps,F(1,2))) + def test_higher_factorial_lower_bound_not_implied(self): + eps=F(1,100) + self.assertEqual(m.factorial_mean([1-eps,eps],[0,2],2),2*eps) + self.assertEqual(m.factorial_mean([1-eps,eps],[0,2],3),0) + def test_bad_inputs(self): + with self.assertRaises(ValueError):m.alpha(1) + with self.assertRaises(ValueError):m.exponential_moment_bound(1,1,2) + with self.assertRaises(ValueError):m.sizebiased([1],[0]) + with self.assertRaises(ValueError):m.regression_second(1,2,1,0,0) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/c6_marked_fourier_20260929/test_sources.py b/frontiers/c6_marked_fourier_20260929/test_sources.py new file mode 100644 index 000000000..eaf284b51 --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/test_sources.py @@ -0,0 +1,46 @@ +"""Synthetic byte-custody controls; not analytic or upstream theorem verification.""" +from pathlib import Path +import hashlib +import tempfile +import unittest +import source_check as m + +class SourceTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + (self.root/'sources').mkdir() + self.data = b'original source\n' + (self.root/'sources'/'proof.md').write_bytes(self.data) + self.entry = {'id':'F','path':'sources/proof.md','bytes':len(self.data), + 'sha256':hashlib.sha256(self.data).hexdigest(), + 'git_blob':hashlib.sha1(f'blob {len(self.data)}\0'.encode()+self.data).hexdigest()} + def test_original_passes(self): + self.assertEqual(m.verify_files(self.root,[self.entry]),1) + def test_changed_byte_fails(self): + (self.root/'sources'/'proof.md').write_bytes(b'changed source!\n') + with self.assertRaises(ValueError):m.verify_files(self.root,[self.entry]) + def test_missing_file_fails(self): + (self.root/'sources'/'proof.md').unlink() + with self.assertRaises(ValueError):m.verify_files(self.root,[self.entry]) + def test_wrong_length_fails(self): + with self.assertRaises(ValueError):m.verify_files(self.root,[dict(self.entry,bytes=1)]) + def test_wrong_sha_fails(self): + with self.assertRaises(ValueError):m.verify_files(self.root,[dict(self.entry,sha256='0'*64)]) + def test_wrong_blob_fails(self): + with self.assertRaises(ValueError):m.verify_files(self.root,[dict(self.entry,git_blob='0'*40)]) + def test_traversal_fails(self): + with self.assertRaises(ValueError):m.verify_files(self.root,[dict(self.entry,path='../proof.md')]) + def test_leaf_link_fails(self): + (self.root/'original').write_bytes(self.data) + p=self.root/'sources'/'proof.md';p.unlink();p.symlink_to('../original') + with self.assertRaises(ValueError):m.verify_files(self.root,[self.entry]) + def test_parent_link_fails(self): + (self.root/'sources').rename(self.root/'actual') + (self.root/'sources').symlink_to('actual',target_is_directory=True) + with self.assertRaises(ValueError):m.verify_files(self.root,[self.entry]) + def test_duplicate_fails(self): + with self.assertRaises(ValueError):m.verify_files(self.root,[self.entry,self.entry]) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/c6_marked_fourier_20260929/verify.py b/frontiers/c6_marked_fourier_20260929/verify.py new file mode 100644 index 000000000..5e30a8c9f --- /dev/null +++ b/frontiers/c6_marked_fourier_20260929/verify.py @@ -0,0 +1,52 @@ +"""Exact packet controls and named negative variants. No analytic acceptance.""" +from pathlib import Path +import sys,unittest,io,json,argparse,hashlib,subprocess +ROOT=Path(__file__).resolve().parent +MUTANTS={'forget-holder-two':'test_holder_needs_twice_the_rate','exponential-every-d':'test_dimension_exponent','drop-mean':'test_conditional_mean_is_not_dropped','drop-prefactor':'test_tail_prefactor_is_retained','duplicate-weight':'test_one_original_weight_and_normalizer','drop-count-mark':'test_count_weight_is_required','nonempty-is-palm':'test_nonempty_and_sizebiased_are_distinct','drop-tail-count':'test_cluster_tail_includes_n'} +def require(ok,msg): + if not ok:raise ValueError(msg) +def identity(p): + require(p.is_file() and not p.is_symlink(),'regular file required') + b=p.read_bytes();return {'bytes':len(b),'sha256':hashlib.sha256(b).hexdigest()} +def decode(s): + def pairs(xs): + d={} + for k,v in xs: + require(k not in d,'duplicate JSON key');d[k]=v + return d + return json.loads(s,object_pairs_hook=pairs) +def sources(): + identity(ROOT/'SOURCE_FILES.json');m=decode((ROOT/'SOURCE_FILES.json').read_text())['files'] + require(sorted(p.name for p in ROOT.iterdir())==sorted([*m,'SOURCE_FILES.json']),'packet membership differs') + for n,e in m.items(): + require(Path(n).name==n and identity(ROOT/n)==e,'source identity differs: '+n) + return m + +def child(mutant): + import marked,test_marked + marked.MUTANT=mutant + r=unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromModule(test_marked)) + print(json.dumps({'tests':r.testsRun,'passed':r.wasSuccessful(),'failures':sorted(t.id().split('.')[-1] for t,_ in r.failures),'errors':sorted(t.id().split('.')[-1] for t,_ in r.errors)},sort_keys=True)) + return 0 if r.wasSuccessful() else 1 + +def replay(out): + out=out.resolve();require(not out.exists() and not out.is_relative_to(ROOT),'new external output required');before=sources();out.mkdir(parents=True) + cases={} + for name in ['baseline',*MUTANTS]: + pair=[] + for mode,flags in [('normal',[]),('optimized',['-O'])]: + cmd=[sys.executable,'-B',*flags,'-S',str(ROOT/'verify.py'),'--child'] + if name!='baseline':cmd+=['--mutant',name] + p=subprocess.run(cmd,capture_output=True,timeout=30);r=decode(p.stdout.decode()) + (out/(name+'_'+mode+'.stdout')).write_bytes(p.stdout);(out/(name+'_'+mode+'.stderr')).write_bytes(p.stderr) + require(not p.stderr and not r['errors'] and r['tests']==17,'execution error or test-count mismatch') + if name=='baseline':require(p.returncode==0 and r['passed'],'baseline failed') + else:require(p.returncode==1 and not r['passed'] and MUTANTS[name] in r['failures'],'intended semantic failure absent') + pair.append(p.stdout) + require(pair[0]==pair[1],'mode mismatch');cases[name]=decode(pair[0].decode()) + require(before==sources(),'source mutation') + report={'tests_per_mode':17,'semantic_mutants_per_mode':8,'identical_output_pairs':9,'all_passed':True,'sources_unchanged':True,'analytic_acceptance':False,'verification_scope':'local packet; upstream check separate','cases':cases} + (out/'REPORT.json').write_text(json.dumps(report,indent=2,sort_keys=True)+'\n');print(json.dumps({k:v for k,v in report.items() if k!='cases'},sort_keys=True)) +if __name__=='__main__': + p=argparse.ArgumentParser();g=p.add_mutually_exclusive_group(required=True);g.add_argument('--child',action='store_true');g.add_argument('--output',type=Path);p.add_argument('--mutant',choices=MUTANTS);a=p.parse_args() + require(a.child or a.mutant is None,'mutant requires child');raise SystemExit(child(a.mutant) if a.child else replay(a.output)) From 4583648f5cbef334556ee05d2d91998f49d026f5 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 19:11:22 -0500 Subject: [PATCH 2/2] Run marked Fourier custody on upstream-only main pushes Mirror the six already-declared source paths in the main push filter so source-only changes cannot skip current and historical custody. Preserve all mathematical packet bytes. --- .github/workflows/c6-marked-fourier.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/c6-marked-fourier.yml b/.github/workflows/c6-marked-fourier.yml index 7f42a1874..183d345b5 100644 --- a/.github/workflows/c6-marked-fourier.yml +++ b/.github/workflows/c6-marked-fourier.yml @@ -16,6 +16,12 @@ name: C6 marked Fourier controls paths: - 'frontiers/c6_marked_fourier_20260929/**' - '.github/workflows/c6-marked-fourier.yml' + - 'frontiers/c6_fourier_cutoff_20260929/PROOF.md' + - 'frontiers/c6_palm_route_20260929/PROOF.md' + - 'frontiers/c6_palm_route_20260929/SOURCE_MAP.json' + - 'frontiers/d5_dimension_lift_20260929/PROOF.md' + - 'frontiers/elder_dimension_lift_20260928/PROOF.md' + - 'frontiers/c6_rare_cluster_laws_20260929/PROOF.md' workflow_dispatch: permissions: