From 703c97a4985bb7c07ce42148aeebd93cb02ad576 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 16:45:18 -0500 Subject: [PATCH] Add C7 zero-gap limit, equal-height coefficient and rejected intensity law candidate OpenAI / GPT-6 Astra Pro. On the reviewed C7 K1/K2 source now integrated at7f438fca, derive a positive finite equal-height Kac-Rice coefficient B, rho_rej(ell)->B, polynomial-birth-weighted L1 convergence and normalized mark-law TV convergence. Add sharp truncated moments and intensity-sampling asymptotics without an individual second-order expansion or numerical B. Twelve standalone tests pass in both Python modes; eight semantic mutants reject per mode. New additive packet and source-bound hosted workflow only. Author-side analytic candidate; non-OpenAI review required; no self-merge or scientific register changes. --- .github/workflows/c7-zero-gap.yml | 40 ++ frontiers/c7_zero_gap_limit_20260929/PROOF.md | 347 ++++++++++++++++++ .../RECONNAISSANCE.md | 39 ++ .../c7_zero_gap_limit_20260929/RESULTS.json | 35 ++ .../c7_zero_gap_limit_20260929/SOURCES.json | 94 +++++ frontiers/c7_zero_gap_limit_20260929/check.py | 212 +++++++++++ .../c7_zero_gap_limit_20260929/test_check.py | 141 +++++++ 7 files changed, 908 insertions(+) create mode 100644 .github/workflows/c7-zero-gap.yml create mode 100644 frontiers/c7_zero_gap_limit_20260929/PROOF.md create mode 100644 frontiers/c7_zero_gap_limit_20260929/RECONNAISSANCE.md create mode 100644 frontiers/c7_zero_gap_limit_20260929/RESULTS.json create mode 100644 frontiers/c7_zero_gap_limit_20260929/SOURCES.json create mode 100644 frontiers/c7_zero_gap_limit_20260929/check.py create mode 100644 frontiers/c7_zero_gap_limit_20260929/test_check.py diff --git a/.github/workflows/c7-zero-gap.yml b/.github/workflows/c7-zero-gap.yml new file mode 100644 index 000000000..00e01f63f --- /dev/null +++ b/.github/workflows/c7-zero-gap.yml @@ -0,0 +1,40 @@ +name: C7 zero-gap finite controls + +'on': + pull_request: + paths: + - 'frontiers/c7_zero_gap_limit_20260929/**' + - '.github/workflows/c7-zero-gap.yml' + push: + branches: [main] + paths: + - 'frontiers/c7_zero_gap_limit_20260929/**' + - '.github/workflows/c7-zero-gap.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-zero-gap: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Exact sources, both Python modes, semantic and path negatives + run: | + set -euo pipefail + P=frontiers/c7_zero_gap_limit_20260929 + python -B -S "$P/check.py" --verify-sources "$GITHUB_WORKSPACE" + python -B -S "$P/check.py" > "$RUNNER_TEMP/zero-gap-normal.json" + python -B -O -S "$P/check.py" > "$RUNNER_TEMP/zero-gap-optimized.json" + cmp "$P/RESULTS.json" "$RUNNER_TEMP/zero-gap-normal.json" + cmp "$RUNNER_TEMP/zero-gap-normal.json" "$RUNNER_TEMP/zero-gap-optimized.json" + python -B -S "$P/test_check.py" -v + python -B -O -S "$P/test_check.py" -v + git diff --exit-code diff --git a/frontiers/c7_zero_gap_limit_20260929/PROOF.md b/frontiers/c7_zero_gap_limit_20260929/PROOF.md new file mode 100644 index 000000000..5b6328ea3 --- /dev/null +++ b/frontiers/c7_zero_gap_limit_20260929/PROOF.md @@ -0,0 +1,347 @@ +# C7 zero-gap limit: a positive coefficient and the rejected-pair intensity law + +Object: **OA-C7-ZERO-GAP-LIMIT-20260929-v1**. +Author: **OpenAI / GPT-6 Astra Pro**, foreground session, 29 September 2026. +Disposition: **AUTHOR-SIDE ANALYTIC CANDIDATE; non-OpenAI review required**. +Scientific effect: **NONE**. No existing theorem, review disposition, register, +graph, claim, prize, premise or lemma flag is changed. No self-merge. + +## 1. Model, exact convention, and results + +Fix an integer d >= 2 and L > 0. Work on the flat torus T_L^d with the same +variance-one periodized Gaussian covariance as the lifetime parent P: + + K_L(x) = [sum_(n in Z^d) exp(-|x+Ln|^2/2)] / + [sum_(n in Z^d) exp(-|Ln|^2/2)]. + +P means UNIFORM_MATRIX_CAP_AND_LIFETIME.md with its complete retained reading +rule (CAP, congruence erratum E1, marked-measure repair E2, reconciliation E3). +K means Claude's gap-mark-explicit Theorem K, proof Git blob +`28748b086ec6761ef467dc67cba475fbdf8b7455`, from Math-#150. SOURCES.json binds +these inputs. We consume K1/K2, not its unused normalized-form remark, and do +not re-review P or K here. We do not require Theorem U's positive lower bound. + +Count all ORDERED maximum/index-(d-1)-saddle pairs. The index counts negative +Hessian eigenvalues. Birth b is the value at the maximum, not the midpoint of +the two heights. The positive gap is ell=f(M)-f(S). Every density and expected +count below is PER UNIT SPATIAL VOLUME. Only finite ordinary superlevel H0 +bars are selected; an essential maximum has elder mark zero for every saddle. + +For y != 0 on the torus let + + O_y = (f(0), grad f(0), f(y), grad f(y)), + v_(b,ell) = (b, 0_d, b-ell, 0_d), + p_y(v) = the Gaussian density of O_y at v, + Q_(y,b,ell) = its continuous full-field Gaussian regression law, + W(f) = |det H_0 det H_y| 1{H_0<0, index(H_y)=d-1}. + +For ell>0, write e_y(f) for the parent's Borel ordinary elder-partner mark and +set + + Psi_ell(b,y) = p_y(v_(b,ell)) E_Q[W(f)(1-e_y(f))]. (Z1) + +At zero define a different-looking, UNMARKED equal-height kernel: + + Psi_0(b,y) = p_y(v_(b,0)) E_(Q_(y,b,0))[W(f)]. (Z2) + +The pins at equal critical heights specify a Gaussian regression kernel, not +a positive-probability conditioning event or a population of actual zero bars. +Define + + B_(d,L) = integral_(T_L^d \ {0}) integral_R + Psi_0(b,y) db dy. (Z3) + +**Theorem Z (candidate).** The integral (Z3) satisfies 0 B_(d,L) as ell decreases to zero. (Z4) + +More strongly, for every fixed real p>=0, + + integral (1+|b|)^p |Psi_ell(b,y)-Psi_0(b,y)| db dy + -> 0. (Z5) + +Thus the normalized birth/displacement law obtained by sampling the REJECTED +INTENSITY at gap ell converges in total variation to + + Psi_0(b,y) db dy / B_(d,L). (Z6) + +This limit has positive density at every (b,y) with y!=0. For 00 for P's common leading coefficient. + + expected rejected count with gap in (0,t] = B_(d,L)t+o(t), + integral_0^t ell^q rho_rej(ell) d ell + ~ B_(d,L)t^(q+1)/(q+1), q>-1, (Z7) + rho_rej(ell)/nu_cand^all(ell) + ~ [B_(d,L)/c] ell^(1/3), (Z8) + [integral_0^t rho_rej]/[integral_0^t nu_cand^all] + ~ [2B_(d,L)/(3c)] t^(1/3). (Z9) + +The rejected inverse-moment boundary is exactly q=-1, with coefficient +B_(d,L) in the logarithmic divergence. The ratios (Z8)-(Z9) concern normalized +ANNEALED INTENSITIES; they are not fixed-radius Palm probabilities, not an +expectation of a samplewise ratio, and not uniformly sampled fields followed +by uniformly sampled pairs. Those are different sampling procedures. + +No numerical value for B_(d,L), no error rate in (Z4)-(Z6), and no next-order +expansion of either individual density is asserted. + +## 2. Nondegenerate two-site jets and continuous Gaussian coupling + +The covariance has strictly positive Fourier coefficients at every lattice +frequency. The full two-site jet list through order two is nondegenerate for +y!=0, by P Section 2's argument: a zero-variance linear combination would be a +finite linear combination T of derivatives of point masses at 0 and y with +all Fourier coefficients zero. Trigonometric polynomials approximate smooth +test functions in their C^2 norm, so the distribution T would vanish. Smooth +functions with arbitrary jets supported in disjoint neighborhoods of the two +sites then force every coefficient of T to be zero. Consequently the full +jet covariance is positive definite, as is the conditional covariance of the +two Hessians given O_y. It has an everywhere positive finite-dimensional +Gaussian density. Singular endpoint Hessians have conditional probability zero. + +For fixed y!=0 and b, the covariance of Q_(y,b,ell) does not depend on ell or b. +Using one common centered residual field, Gaussian regression yields the +coupling + + f_ell = f_0 + ell h_y, (Z10) + +where f_0 has law Q_(y,b,0) and h_y is a deterministic smooth regression +function. It has h_y(0)=0, h_y(y)=-1 and zero gradient at both sites. Thus all +f_ell have exactly the required pins, and f_ell -> f_0 in C^2 on the torus. +This is only a FIXED-SEPARATION assertion; no bound on h_y as y approaches the +diagonal is assumed. The covariance is not assumed rotationally invariant. + +## 3. The local barrier makes every fixed-separation limit rejected + +We first record the deterministic point that replaces any supposed global +continuity of the elder selector. + +**Local barrier lemma.** Suppose g_j -> g in C^2, grad g_j(M)=0, g_j(M)=b, +and H_g(M)<0. Fix S!=M. There exist a ball B_R(M) disjoint from S and a +constant delta>0 such that, for every sufficiently large j, g_j0 such +that H_g<=-aI throughout its closure. C^2 convergence gives H_(g_j)<=-aI/2 +there for large j. Taylor's integral formula along straight segments, using +the EXACT zero gradient at M, gives + + g_j(x) <= b-(a/4)|x-M|^2. + +Take delta=aR^2/4. In particular there is no point higher than b inside the +ball. Every path from M to a point with value higher than b must cross the +boundary, so its minimum is <=b-delta. Therefore the maximin elder-death level +satisfies d_(g_j)(M)<=b-delta0}. A ball and delta may depend +on the realization, b and y, but each delta is positive. For all sufficiently +small ell, the mark e_y(f_ell)=0. On the complementary type configurations, +W(f_ell)->0 because the limiting endpoint Hessians are nonsingular almost +surely. Hence in all cases outside a conditional null set, + + W(f_ell)(1-e_y(f_ell)) -> W(f_0). (Z11) + +There is no assumption that the ordinary elder selector is continuous, that +f_0 has distinct critical values, that a saddle has a particular ascending +trajectory, or that a Morse-Smale property survives the coupling. Its forced +equal critical heights cause no problem for the local concavity argument. + +For fixed y,b and 0<=ell<=1, the endpoint Hessians in (Z10) differ by a bounded +deterministic matrix. Their determinant product is dominated by a polynomial +of degree 2d in the norm of the finite Gaussian endpoint Hessian vector under +Q_(y,b,0). This is integrable. Conditional dominated convergence and the +continuity of p_y(v_(b,ell)) give + + Psi_ell(b,y) -> Psi_0(b,y) for every y!=0 and b in R. (Z12) + +The role of Section 4 is to make this limit integrable even as y approaches +zero. Fixed-separation continuity alone would not justify that step. + +## 4. Uniform integrable domination: the two gap-mark regimes + +Take P's target-independent r_0 below one and the torus injectivity scale. +For y=ru with 0(b,b-ell) has absolute determinant one. There is no +factor 1/2 for ordered critical types and no extra torus-volume multiplier. + +The input K gives fixed C,N such that, for every b, k>0 and r<=r_0, + + E_Q[W_r/r^2] <= C(k+r)^2(1+|b|+k)^N, (K1) + E_Q[(W_r/r^2)1_(G_r^c)] + <= C(r^3/k)(1+|b|+k)^N, provided r<=k. (K2) + +The parent cap theorem supplies 1-e<=1_(G_r^c) on the generic locus, and its +repaired Borel marked-measure formula legitimizes that bound under Kac-Rice. +P (13.2) gives pi_r(v_r)<=C exp[-c(b^2+k^2)] uniformly over these unrestricted +targets and all frames. Now separate two cases: + +* If r<=k, use K2. The right side of (Z14) is at most + C(r/k)(1+|b|+k)^N exp[-c(b^2+k^2)]. Here r/k<=1. +* If k0. The K2 bound was NOT used at k=r_0, P Section 14's +nonsingular full-pin covariance bounds give, for 0=r_0}]. (Z17) + +In polar coordinates the near spatial singularity cancels to dr. Thus +D and (1+|b|)^p D are integrable for every fixed p>=0. In particular, + + integral_(dist(0,y)0. The finite-dimensional Gaussian expectation in +(Z2) is continuous away from the diagonal, by continuous regression and a +local polynomial Gaussian majorant (the type boundaries have zero Gaussian +measure). Integrating over any small open product neighborhood proves B>0 +and establishes the full-support assertion in Section 1. This positivity +argument does not consume a rare-cap lower theorem or Theorem U. + +Let mu_ell and mu_0 be the finite measures with densities Psi_ell and Psi_0; +their masses are rho_rej(ell) and B, respectively. The first mass is positive +for sufficiently small ell because it tends to B>0. The elementary inequality + + ||mu_ell/rho_rej(ell)-mu_0/B||_TV + <= ||Psi_ell-Psi_0||_(L1)/B (Z19) + +follows by adding/subtracting mu_ell/B and using +|rho_rej(ell)-B|<=||Psi_ell-Psi_0||_1; TV for probability measures is half the +L1 distance. This proves (Z6). The same reasoning with (Z5) gives convergence +of all fixed polynomial birth moments. Pushforward to displacement or distance +preserves TV convergence. From (Z18) and rho_rej(ell)>=B/2 eventually, the +conditional rejected-distance mass below delta is also O(delta). + +**Why this does not make the candidate density bounded.** At each fixed +separation the unmarked candidate kernel also tends to (Z2), but its positive-gap +spatial integral diverges like c ell^(-1/3), by P. There is no contradiction: +the uniform near-diagonal bound (Z15) uses the REJECTION factor via K2 on r<=k. +It is unavailable for candidates or selected pairs. Their leading mass can +concentrate at shrinking separation; the rejected population cannot. Interchanging +the candidate's zero-gap and near-diagonal limits would be the invalid step. + +## 6. Counts, moment coefficients and intensity sampling + +Since rho_rej(ell)=B+o(1), integration gives the first assertion in (Z7). For +any q>-1, for every epsilon>0 the bound |rho_rej(ell)-B|<=epsilon holds for all +sufficiently small positive ell. Its integral against ell^q is at most +epsilon t^(q+1)/(q+1), proving the weighted asymptotic in (Z7). + +The positive lower bound rho_rej>=B/2 eventually implies divergence of the +full inverse moment for q<=-1. More precisely, for every sufficiently small +fixed t>0, + + integral_epsilon^t rho_rej(ell) d ell/ell + ~ B log(t/epsilon) as epsilon->0, (Z20) + +and for q<-1, + + integral_epsilon^t ell^q rho_rej(ell) d ell + ~ [B/(-q-1)] epsilon^(q+1). (Z21) + +These follow by bounding rho_rej between B plus/minus any positive tolerance +on a small interval; the remaining fixed interval contributes a finite term. +The moments are of the rejected counting measure itself, not the subtraction +of two individually infinite expectations. The individual candidate and selected +threshold remains q=-2/3, as in P. + +P's unrestricted leading result is nu_cand^all(ell)~c ell^(-1/3), c>0. Division +of (Z4) by this result gives (Z8). Its cumulative version is +integral_0^t nu_cand^all~(3/2)c t^(2/3); combined with (Z7) it gives (Z9). +These formulas identify the leading rare-rejection coefficient for the indicated +intensity-weighted sampling procedures. They do not change P's compact-window +1-p_r=O(r^3) estimate or replace its fixed-radius probability by a lifetime ratio. + +The identity nu_eld^all=nu_cand^all-B+o(1) is legitimate as a DIFFERENCE +statement. Writing nu_eld^all=c ell^(-1/3)-B+o(1) would be unjustified: P gives +no o(1) remainder for nu_cand^all by itself. Nothing here asserts such a remainder. + +## 7. Verification and review boundaries + +The source manifest retains the parent reading rule and the exact K1/K2 proof. +Twelve finite tests were written first and failed at the intended missing- +implementation check; after implementation they pass in normal and optimized +Python. Eight semantic mutants fail in both modes, and unknown labels are +rejected rather than silently treated as a normal run. RESULTS.json is exact, +deterministic bookkeeping for coarea, the two radial regimes, residual concavity, +the positive type example, normalization of finite measures, and moment/ratio +exponents. Source identity and path-negative controls are tested separately. + +These tests do NOT prove continuous Gaussian regression, the local-path topology, +Gaussian nullity of type boundaries, infinite-dimensional marked Kac-Rice, or +dominated convergence. The displayed arguments and the specified inputs are the +analytic evidence. Whole-repository/formal replay is hosted evidence only when +its actual run is inspected; no local repository checkout is claimed. + +External reconnaissance is recorded in RECONNAISSANCE.md. No priority or novelty +verdict is asserted. Requested non-OpenAI review slices: + +A. (Z10)-(Z12): fixed-site regression, local CONCAVITY barrier and limiting mark; + in particular exclude an older point inside the ball rather than relying on + its low boundary alone. +B. (Z13)-(Z18): all normalization factors, domain-correct K1/K2 use, all b/k/axes, + and the integrable diagonal majorant. +C. (Z3)-(Z9),(Z19)-(Z21): positive finite coefficient, weighted L1 and TV law, + moment coefficients and the precise intensity-sampling interpretation. + +All author-side claims remain candidates pending that review. Same GitHub account +as other model lanes; zero organizational-independence credit. No register fold, +RN numerical closure, Poisson approximation, or uniform-in-d/L assertion is implied. diff --git a/frontiers/c7_zero_gap_limit_20260929/RECONNAISSANCE.md b/frontiers/c7_zero_gap_limit_20260929/RECONNAISSANCE.md new file mode 100644 index 000000000..9c5e6a5f9 --- /dev/null +++ b/frontiers/c7_zero_gap_limit_20260929/RECONNAISSANCE.md @@ -0,0 +1,39 @@ +# External reconnaissance — C7 zero-gap coefficient + +Object: OA-C7-ZERO-GAP-RECON-20260929-v1. OpenAI / GPT-6 Astra Pro. +Scientific effect NONE. Date: 29 September 2026. No novelty certification. + +The project inputs, not external abstracts, supply the marked Kac-Rice interface +and K1/K2. Their source identities and parent amendments are retained in SOURCES.json. +The local concavity barrier and the radial two-regime domination are derived in +PROOF.md; no outside paper is represented as having proved this new packet. + +Primary-source web checks actually executed: + +1. Diego Armentano, Jean-Marc Azaïs, José Rafael León, *On a general Kac-Rice + formula for the measure of a level set*, https://arxiv.org/abs/2304.07424v3. + The v3 record identifies 5 December 2023 as that version, and a newer v4 dated + 22 April 2025. Its abstract describes general Kac-Rice level-set formulas. + The parent specifically consumes v3 Theorem7.1 through its source-bound Borel + repair. We inspected the version record/abstract in this pass, not a fresh + full-text verification of that theorem, and do not silently substitute v4. + +2. Job Feldbrugge, Matti van Engelen, Rien van de Weygaert, Pratyush Pranav, + Gert Vegter, *Stochastic Homology of Gaussian vs. non-Gaussian Random Fields: + Graphs towards Betti Numbers and Persistence Diagrams*, + https://arxiv.org/abs/1908.01619; DOI10.1088/1475-7516/2019/09/052. + The primary abstract describes two-dimensional Gaussian-field Betti and + persistence statistics, a one-parameter fitting formula, and numerical + sensitivity to non-Gaussianity. That establishes relevant prior work, not + whether its full text contains the equal-height rejected-density limit. + +Executed queries were `site.arxiv.org 2304.07424 Kac Rice expected integrals Gaussian` +and `site.arxiv.org 1908.01619 persistent homology Gaussian random fields`, followed +by the exact primary records above. These narrow checks are not an exhaustive +literature search. No conclusion of absence of prior art follows. + +Consensus.search was actually attempted earlier in this foreground pass and +returned the exhausted 30-search monthly quota, resetting October1. No Consensus +paper or completed Consensus review was obtained; web primary sources were the +fallback. No PDF, diagram, simulated field or finite-grid topology supplies the +analytic proof in this packet. diff --git a/frontiers/c7_zero_gap_limit_20260929/RESULTS.json b/frontiers/c7_zero_gap_limit_20260929/RESULTS.json new file mode 100644 index 000000000..c9ae08b74 --- /dev/null +++ b/frontiers/c7_zero_gap_limit_20260929/RESULTS.json @@ -0,0 +1,35 @@ +{ + "claimed_convergence_rate": null, + "cumulative_sampling_exponent": "1/3", + "cumulative_sampling_multiplier": "2/3", + "density_sampling_exponent": "1/3", + "groups": [ + "coarea", + "ordered-normalization", + "radial-domination", + "concavity-barrier", + "typed-open-set-example", + "normalization-TV", + "moment-threshold", + "sampling-exponents" + ], + "mutants": [ + "wrong-radial-power", + "missing-gap-jacobian", + "drop-k-plus-r", + "apply-K2-outside-domain", + "boundary-only", + "unordered-half", + "wrong-moment-threshold", + "swap-intensity-probability" + ], + "object": "OA-C7-ZERO-GAP-LIMIT-20260929-v1", + "passed": true, + "positive_limit": "B_(d,L), explicit equal-height integral; not numerically evaluated", + "radial_power": "-2", + "rejected_moment_threshold": "q > -1", + "scalar_branch_bound": 4, + "scientific_acceptance": false, + "scientific_effect": "NONE", + "scope": "exact finite ledgers only; regression, barrier topology and dominated convergence require analytic review" +} diff --git a/frontiers/c7_zero_gap_limit_20260929/SOURCES.json b/frontiers/c7_zero_gap_limit_20260929/SOURCES.json new file mode 100644 index 000000000..2bcae1fc9 --- /dev/null +++ b/frontiers/c7_zero_gap_limit_20260929/SOURCES.json @@ -0,0 +1,94 @@ +{ + "author": "OpenAI / GPT-6 Astra Pro", + "disposition": "AUTHOR_SIDE_ANALYTIC_CANDIDATE", + "execution_boundary": "Standalone local arithmetic and unit tests executed; upstream source identity verified through connector and, when observed, hosted workflow. No local whole-repository or Lean replay claimed.", + "files": [ + { + "bytes": 17592, + "path": "PROOF.md", + "sha256": "f0e563c45c41333f2bb6e5bf5cb98f0d3b592e2abf2af1c1b098c21ad77cb777" + }, + { + "bytes": 2383, + "path": "RECONNAISSANCE.md", + "sha256": "1a0b2c8b6bbf92bf1de00085c09820b99e230096f5ada96dd2d8d8f269329710" + }, + { + "bytes": 1042, + "path": "RESULTS.json", + "sha256": "14aa50e91890ec8c0553d16e51a62a6973ce666557edacc67d50cd702a321a49" + }, + { + "bytes": 8350, + "path": "check.py", + "sha256": "b306053817bdda6d5f8cce6da5a39b70c7449aa1add7851c1e17e936f7f21ffd" + }, + { + "bytes": 6766, + "path": "test_check.py", + "sha256": "63e4c72170b3efc1441e8bd9aa5a0bf0b14b90a11ee7681477a4fdb158976f07" + } + ], + "non_claims": [ + "no numerical B_(d,L)", + "no convergence rate", + "no individual second-order lifetime expansion", + "no fixed-radius Palm reinterpretation", + "no dimension-uniform or volume-uniform result" + ], + "object": "OA-C7-ZERO-GAP-LIMIT-20260929-v1", + "organizational_independence_credit": 0, + "scientific_acceptance": false, + "scientific_effect": "NONE", + "upstream": [ + { + "commit": "f4c3f215b39a332d7d9c4b6f1e0bf01f10bf243f", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "repository": "d6g8k5htny-coder/Math-", + "role": "coefficient expression (15.2)", + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7" + }, + { + "commit": "f4c3f215b39a332d7d9c4b6f1e0bf01f10bf243f", + "git_blob": "0633aca3c2a2882b0de4399da0a75d64c2e6b2e1", + "path": "imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md", + "repository": "d6g8k5htny-coder/Math-", + "role": "retained parent reading-rule context, not re-proved", + "sha256": "0bf922b9203c29088b12388807aa0e2ecd020485eb0f6e919679841b5b2636fc" + }, + { + "commit": "f4c3f215b39a332d7d9c4b6f1e0bf01f10bf243f", + "git_blob": "213594d6ca6a86fb938110f4d166d9ce275a02d0", + "path": "imports/lifetime_parent_20260925/ERRATUM_CONGRUENCE.md", + "repository": "d6g8k5htny-coder/Math-", + "role": "retained parent amendment E1", + "sha256": "bad7ef609c4ad8c41ad6af562c1b6807921e19a9d556ed793ad1a0db6e202028" + }, + { + "commit": "f4c3f215b39a332d7d9c4b6f1e0bf01f10bf243f", + "git_blob": "fe9b9ce4999908bb3814b500ee2d0ceb0c6f704a", + "path": "reviews/d1_section9_borel_repair_20260925/REPAIR.md", + "repository": "d6g8k5htny-coder/Math-", + "role": "retained parent amendment E2", + "sha256": "845abf9f9c99d672c2a10a887b5a2e7206a3d2de3d876f35f75ff6e2dc13e62f" + }, + { + "commit": "f4c3f215b39a332d7d9c4b6f1e0bf01f10bf243f", + "git_blob": "75da2597971510f843f8d90c743950cb8c177342", + "path": "reviews/d1_chain_reconciliation_20260928/RECONCILIATION.md", + "repository": "d6g8k5htny-coder/Math-", + "role": "reading rule, E3 and scoped source interpretation" + }, + { + "bytes": 14982, + "commit": "f4c3f215b39a332d7d9c4b6f1e0bf01f10bf243f", + "git_blob": "28748b086ec6761ef467dc67cba475fbdf8b7455", + "path": "frontiers/c7_total_bounded_20260929/PROOF.md", + "repository": "d6g8k5htny-coder/Math-", + "role": "Theorem K1/K2 only, not normalized aside; existing source-exposed reviews5357773376/5358141048 and v1.2 wording check", + "sha256": "16c0efe372c1b1f26460aaa109287fed78e6fbd2dd00a0530998db296278dd01" + } + ], + "upstream_status_boundary": "K source pin belongs to PR150 integration branch; exact reviewed bytes retained. Landing is not assumed by this manifest." +} diff --git a/frontiers/c7_zero_gap_limit_20260929/check.py b/frontiers/c7_zero_gap_limit_20260929/check.py new file mode 100644 index 000000000..81f0ac78e --- /dev/null +++ b/frontiers/c7_zero_gap_limit_20260929/check.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +"""Exact ledger controls, not a proof of the C7 zero-gap continuum limit. + +Standard library only. Positive output makes no scientific acceptance claim. +""" +import argparse +from fractions import Fraction as F +import hashlib +import json +from pathlib import Path +import sys + +MUTANTS = ('wrong-radial-power', 'missing-gap-jacobian', 'drop-k-plus-r', + 'apply-K2-outside-domain', 'boundary-only', 'unordered-half', + 'wrong-moment-threshold', 'swap-intensity-probability') + + +def exact(value): + if isinstance(value,bool) or not isinstance(value,(int,F)): + raise TypeError('an exact integer or Fraction is required') + return F(value) + + +def require(condition,message): + if not condition: + raise ValueError(message) + + +def pushforward_exponents(): + # (1/3) ell^(-1/3) k^(-2/3) |dk/dr|, k=ell/r^3. + return F(1,3)*3, F(-1,3)+F(-2,3)+1, -3*F(-2,3)-4 + + +def radial_ledger(d): + if isinstance(d,bool) or not isinstance(d,int) or d<2: + raise ValueError('fixed integer dimension d >= 2 required') + spatial=d-1 + pin=-(d+3) + weight=2 + return spatial+pin+weight+3, spatial+pin+weight + + +def ordered_height_jacobian(): + # det d(b,b-ell)/d(b,ell)=-1; the two critical types are distinct roles. + return abs(F(1)*F(-1)-F(0)*F(1)) + + +def parent_pin_prefactor(): + return 12 + + +def radial_bound(r,k): + r,k=exact(r),exact(k) + require(00,'need 0 < r <= 1 and k > 0') + return r/k if k>=r else (1+k/r)**2 + + +def barrier_drop(curvature,perturbation,radius): + a,eta,R=map(exact,(curvature,perturbation,radius)) + require(a>eta>=0 and R>0,'positive residual concavity and radius required') + return (a-eta)*R**2/2 + + +def barrier_excludes_gap(curvature,perturbation,radius,separation,gap): + R,sep,ell=map(exact,(radius,separation,gap)) + require(sep>0 and 00,'strictly separated positive ball and gap required') + return ell=2,'two same-dimensional Hessian diagonals required') + if not all(x<0 for x in a) or sum(x<0 for x in b)!=len(b)-1 or any(x==0 for x in b): + return F(0) + out=F(1) + for x in a+b: + out*=x + return abs(out) + + +def normalized_tv(current,limit): + a,b=tuple(map(exact,current)),tuple(map(exact,limit)) + require(len(a)==len(b)>0 and all(x>=0 for x in a+b),'equal nonempty nonnegative measures required') + A,B=sum(a),sum(b) + require(A>0 and B>0,'both masses must be positive') + tv=sum(abs(x/A-y/B) for x,y in zip(a,b))/2 + l1=sum(abs(x-y) for x,y in zip(a,b)) + return tv,l1/B + + +def moment_case(q): + q=exact(q) + return 'finite' if q>-1 else 'logarithmic' if q==-1 else 'power-divergent' + + +def moment_coefficient(q): + q=exact(q) + require(q>-1,'power integral from zero requires q > -1') + return 1/(q+1) + + +def sampling_ledger(): + candidate=F(-1,3) + rejected=F(0) + return rejected-candidate,(rejected+1)-(candidate+1),(candidate+1)/(rejected+1) + + +def verify_identity(root,row): + root=Path(root).resolve() + name=row['path'] + require(isinstance(name,str),'source path must be a string') + rel=Path(name) + require(not rel.is_absolute() and '..' not in rel.parts and bool(rel.parts),'relative source path required') + path=root/rel + require(path.resolve().is_relative_to(root),'source escapes root') + for j in range(1,len(rel.parts)+1): + require(not root.joinpath(*rel.parts[:j]).is_symlink(),'symlink source path rejected') + data=path.read_bytes() + require('sha256' in row or 'git_blob' in row,'at least one content identity required') + if 'bytes' in row: + require(len(data)==row['bytes'],'source length mismatch: '+name) + if 'sha256' in row: + require(hashlib.sha256(data).hexdigest()==row['sha256'],'source SHA256 mismatch: '+name) + if 'git_blob' in row: + blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + require(blob==row['git_blob'],'source Git blob mismatch: '+name) + + +def verify_sources(repository): + here=Path(__file__).resolve().parent + manifest=json.loads((here/'SOURCES.json').read_text(encoding='utf-8')) + names=[row['path'] for row in manifest['files']] + require(len(names)==len(set(names)),'duplicate packet identity') + require(all(Path(p).name==p for p in names),'flat packet inventory required') + require({p.name for p in here.iterdir()}==set(names)|{'SOURCES.json'},'packet inventory mismatch') + for row in manifest['files']: + verify_identity(here,row) + for row in manifest['upstream']: + verify_identity(repository,row) + + +def verify(mutant=None): + require(mutant in (None,*MUTANTS),'unknown semantic variant') + coeff,ell_power,r_power=pushforward_exponents() + if mutant=='wrong-radial-power': + r_power=F(-1) + require((coeff,ell_power,r_power)==(1,0,-2),'lifetime-to-radius coarea mismatch') + for d in range(2,13): + marked,unmarked=radial_ledger(d) + if mutant=='missing-gap-jacobian': + unmarked=marked + require(marked==1 and unmarked==-2,'gap Jacobian missing in radial ledger') + pair_jac=ordered_height_jacobian()*(F(1,2) if mutant=='unordered-half' else 1) + require(pair_jac==1 and parent_pin_prefactor()==12,'ordered pair normalization mismatch') + for r in (F(1,100),F(1,7),F(1,2),F(1)): + for k in (r/100,r/2,r,2*r,F(5)): + bound=radial_bound(r,k) + if mutant=='drop-k-plus-r' and k -1', + 'density_sampling_exponent':str(sample[0]), + 'cumulative_sampling_exponent':str(sample[1]), + 'cumulative_sampling_multiplier':str(sample[2]), + 'claimed_convergence_rate':None, + 'mutants':list(MUTANTS)} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--mutant',choices=MUTANTS) + parser.add_argument('--verify-sources',metavar='REPOSITORY_ROOT') + args=parser.parse_args() + try: + report=verify(args.mutant) + if args.verify_sources: + verify_sources(args.verify_sources) + report['source_manifest_verified']=True + print(json.dumps(report,indent=2,sort_keys=True)) + return 0 + except (TypeError,ValueError,KeyError,OSError) as exc: + print('REJECTED: '+str(exc),file=sys.stderr) + return 1 + +if __name__=='__main__': + sys.exit(main()) diff --git a/frontiers/c7_zero_gap_limit_20260929/test_check.py b/frontiers/c7_zero_gap_limit_20260929/test_check.py new file mode 100644 index 000000000..4eaf12c6c --- /dev/null +++ b/frontiers/c7_zero_gap_limit_20260929/test_check.py @@ -0,0 +1,141 @@ +"""Finite controls for the C7 zero-gap candidate; no continuum proof assertion.""" +import importlib.util +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest +from fractions import Fraction as F +import hashlib + +HERE = Path(__file__).resolve().parent +MOD = None +if (HERE/'check.py').is_file(): + spec = importlib.util.spec_from_file_location('c7_zero_gap_check', HERE/'check.py') + MOD = importlib.util.module_from_spec(spec) + spec.loader.exec_module(MOD) + +class ZeroGapTests(unittest.TestCase): + def setUp(self): + self.assertIsNotNone(MOD, 'Missing zero-gap finite-control implementation') + + def test_exact_lifetime_to_radius_pushforward(self): + self.assertEqual(MOD.pushforward_exponents(), (F(1), F(0), F(-2))) + for r in (F(1,100), F(1,3), F(1)): + for k in (F(1,1000), F(2,7), F(3)): + ell = k*r**3 + # Coarea expressed without fractional powers of rational numbers. + self.assertEqual((1/(3*r*k))*(3*ell/r**4), r**-2) + + def test_dimension_and_ordered_pair_normalization(self): + for d in range(2,13): + self.assertEqual(MOD.radial_ledger(d), (1, -2)) + self.assertEqual(MOD.ordered_height_jacobian(), F(1)) + self.assertEqual(MOD.parent_pin_prefactor(), 12) + + def test_piecewise_radial_majorant(self): + for r in (F(1,100), F(1,7), F(1,2), F(1)): + for k in (r/100, r/2, r, 2*r, F(5)): + value = MOD.radial_bound(r,k) + self.assertGreater(value,0) + self.assertLessEqual(value,4) + self.assertEqual(value, r/k if k>=r else (1+k/r)**2) + + def test_why_the_two_branches_are_needed(self): + r,k=F(1,100),F(1,10000) + self.assertGreater(r/k,4) # K2 may not be used when k < r. + self.assertGreater(r**-2,4) # Crude K1 without (k+r)^2 is not uniform. + self.assertLessEqual(MOD.radial_bound(r,k),4) + self.assertLessEqual(MOD.radial_bound(r,F(100)),1) + + def test_local_concavity_barrier_and_strictness(self): + self.assertEqual(MOD.barrier_drop(F(2),F(1,2),F(1,3)),F(1,12)) + self.assertTrue(MOD.barrier_excludes_gap(2,F(1,2),F(1,3),1,F(1,24))) + self.assertFalse(MOD.barrier_excludes_gap(2,F(1,2),F(1,3),1,F(1,12))) + self.assertFalse(MOD.barrier_excludes_gap(2,F(1,2),F(1,3),1,F(1,10))) + with self.assertRaises(ValueError): + MOD.barrier_excludes_gap(2,0,F(1,2),1,F(1,100)) + with self.assertRaises(ValueError): + MOD.barrier_drop(2,2,1) + + def test_positive_typed_hessian_open_set_example(self): + for d in range(2,8): + self.assertEqual(MOD.typed_diagonal_weight([-1]*d,[1]+[-1]*(d-1)),1) + self.assertEqual(MOD.typed_diagonal_weight([-1]*d,[-1]*d),0) + self.assertEqual(MOD.typed_diagonal_weight([0]+[-1]*(d-1),[1]+[-1]*(d-1)),0) + self.assertEqual(MOD.typed_diagonal_weight([-2,-3],[4,-5]),120) + + def test_normalization_total_variation_inequality(self): + examples = [([1,2,0],[2,3,4]), ([0,1],[1,0]), ([2,4],[1,2]), ([F(1,1000),1],[1,1])] + for a,b in examples: + tv,bound = MOD.normalized_tv(a,b) + self.assertLessEqual(tv,bound) + self.assertLessEqual(tv,1) + self.assertEqual(MOD.normalized_tv([2,4],[1,2])[0],0) + with self.assertRaises(ValueError): + MOD.normalized_tv([0,0],[1,1]) + with self.assertRaises(ValueError): + MOD.normalized_tv([-1,3],[1,1]) + + def test_rejected_moments_and_pole(self): + for q in (F(-9,10),F(-2,3),F(0),F(3,2),F(5)): + self.assertEqual(MOD.moment_case(q),'finite') + self.assertEqual(MOD.moment_coefficient(q)*(q+1),1) + self.assertEqual(MOD.moment_case(-1),'logarithmic') + self.assertEqual(MOD.moment_case(F(-4,3)),'power-divergent') + with self.assertRaises(ValueError): + MOD.moment_coefficient(-1) + + def test_intensity_sampling_not_fixed_radius_probability(self): + self.assertEqual(MOD.sampling_ledger(), (F(1,3),F(1,3),F(2,3))) + # rho -> B, nu_cand ~ c*ell^(-1/3); cumulatives are Bt and (3/2)c*t^(2/3). + self.assertEqual(MOD.sampling_ledger()[2],1/F(3,2)) + self.assertNotEqual(MOD.sampling_ledger()[0],3) + + def test_invalid_scalar_and_dimension_inputs(self): + for x in (True,1.0,'1',None): + with self.assertRaises((ValueError,TypeError)): + MOD.exact(x) + for d in (True,1,0,-2,F(3,2)): + with self.assertRaises((ValueError,TypeError)): + MOD.radial_ledger(d) + for r,k in ((0,1),(1,0),(-1,2),(2,1)): + with self.assertRaises(ValueError): + MOD.radial_bound(r,k) + + def test_source_checker_rejects_identity_and_path_mutations(self): + with tempfile.TemporaryDirectory() as tmp: + root=Path(tmp) + data=b'bounded source\n' + (root/'source.txt').write_bytes(data) + blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + row={'path':'source.txt','bytes':len(data),'sha256':hashlib.sha256(data).hexdigest(),'git_blob':blob} + MOD.verify_identity(root,row) + for key,bad in (('bytes',0),('sha256','0'*64),('git_blob','0'*40),('path','../source.txt')): + with self.assertRaises(ValueError): + MOD.verify_identity(root,{**row,key:bad}) + (root/'alias.txt').symlink_to(root/'source.txt') + with self.assertRaises(ValueError): + MOD.verify_identity(root,{**row,'path':'alias.txt'}) + + def test_cli_both_modes_and_semantic_mutants(self): + outputs=[] + for flags in (['-B','-S'],['-B','-O','-S']): + proc=subprocess.run([sys.executable,*flags,str(HERE/'check.py')],capture_output=True,timeout=20) + self.assertEqual(proc.returncode,0,proc.stderr.decode()) + report=json.loads(proc.stdout) + self.assertTrue(report['passed']) + self.assertFalse(report['scientific_acceptance']) + outputs.append(proc.stdout) + for mutant in MOD.MUTANTS: + bad=subprocess.run([sys.executable,*flags,str(HERE/'check.py'),'--mutant',mutant],capture_output=True,timeout=20) + self.assertEqual(bad.returncode,1,(mutant,bad.stdout,bad.stderr)) + bad=subprocess.run([sys.executable,*flags,str(HERE/'check.py'),'--mutant','UNKNOWN'],capture_output=True,timeout=20) + self.assertEqual(bad.returncode,2) + self.assertEqual(outputs[0],outputs[1]) + if (HERE/'RESULTS.json').is_file(): + self.assertEqual(outputs[0],(HERE/'RESULTS.json').read_bytes()) + +if __name__=='__main__': + unittest.main()