diff --git a/.github/workflows/c6-fourier-cutoff.yml b/.github/workflows/c6-fourier-cutoff.yml new file mode 100644 index 000000000..5a6ccdd93 --- /dev/null +++ b/.github/workflows/c6-fourier-cutoff.yml @@ -0,0 +1,39 @@ +name: C6 Fourier-cutoff finite controls + +'on': + pull_request: + paths: + - 'frontiers/c6_fourier_cutoff_20260929/**' + - '.github/workflows/c6-fourier-cutoff.yml' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'frontiers/c6_factorial_moment_20260929/PROOF.md' + - 'frontiers/c6_sharpened_20260929/PROOF.md' + - 'frontiers/intermediate_window_20260928/PROOF.md' + - 'reviews/d5_reconciliation_20260929/RECONCILIATION.md' + - 'reviews/d5_punctured_pin_continuum_claude_20260929/REVIEW.md' + push: + branches: [main] + paths: + - 'frontiers/c6_fourier_cutoff_20260929/**' + - '.github/workflows/c6-fourier-cutoff.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-fourier: + 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 packet, both Python modes, and six upstream identities + run: | + set -euo pipefail + python -B -S frontiers/c6_fourier_cutoff_20260929/verify.py --repo "${GITHUB_WORKSPACE}" --output "${RUNNER_TEMP}/fourier-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + git diff --exit-code diff --git a/.github/workflows/d1-cde-fulldepth-review.yml b/.github/workflows/d1-cde-fulldepth-review.yml new file mode 100644 index 000000000..fa03e30ab --- /dev/null +++ b/.github/workflows/d1-cde-fulldepth-review.yml @@ -0,0 +1,59 @@ +name: D1-C/D/E full-depth nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/d1_cde_full_depth_claude_20260929/**' + - '.github/workflows/d1-cde-fulldepth-review.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-probe: + 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: Verify sources, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('reviews/d1_cde_full_depth_claude_20260929').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + script = str(root / 'cde_review_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['M1', 'M2', 'M3'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=300).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in mutants: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=300).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/frontiers/c6_fourier_cutoff_20260929/PROOF.md b/frontiers/c6_fourier_cutoff_20260929/PROOF.md new file mode 100644 index 000000000..1d9177a25 --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/PROOF.md @@ -0,0 +1,370 @@ +# C6 Fourier cutoff: an exponential planar count cap and a single logarithm + +Object: OA-C6-FOURIER-20260929-v1. +Author: OpenAI / ChatGPT, foreground continuation, 29 September 2026. +Disposition: AUTHOR-SIDE MATHEMATICAL CANDIDATE; nonauthor analytic review required. +Scientific effect NONE. No existing proof, review disposition, register, graph, +lemma flag, premise, prize or numerical certificate is changed. + +## 1. Model, results and exact logical scope + +Use the ORIGINAL normalized periodized Gaussian field on X=R^d/(T Z^d), for a +FIXED d>=2 and T>0. Its covariance is the normalized sum of +exp(-|x-y+Tn|^2/2). Put omega=2pi/T. The Fourier variances are + + a_n = c_T exp(-omega^2 |n|^2/2), n in Z^d, a_n>0. + +Real-valuedness imposes conjugacy of the complex Fourier coefficients. No +independence of their conditional laws will be used. All orthonormal original +pin frames are allowed; the lattice used for Fourier truncation is FIXED in the +torus coordinates and is NOT rotated with that pin frame. + +Retain the exact original value/gradient observations at M=-(r/2)u and S=(r/2)u, +with f(M)=b, f(S)=b-kr^3 and both gradients zero. Let Q_r be their continuous +Gaussian regression, equivalently the bounded-target nonsingular frame U_r=v_r +of LP. Birth and positive-gap marks range over the original compact sets, with +k>=k_->0. Use the full typed endpoint weight W_r and full Z_r=E_Qr W_r: + + dQ_r^W=(W_r/Z_r)dQ_r. + +N counts critical points other than M,S with values in I_r=(b-kr^3,b), all +indices. C(f) counts ALL real critical points on the torus, including the pins +and all heights. The two are not interchangeable. Constants depend on fixed +d,T and compact parameter ranges; no growing-dimension, k->0 or numerical +uniformity is claimed. Reduce r_* as needed within the parent validity regime. + +**Theorem F (count cap, no G_d input).** There is a measurable field functional +Psi_F>=C(f) such that uniformly in this original pin family + + Q_r(Psi_F>x) <= C exp(-c x^(2/d)), + Q_r^W(Psi_F>x) <= C exp(-c x^(2/d)), (F1) + +for x>=1, after changing constants. Thus all its fixed moments are uniformly +finite under either law. In particular, for some a>0, + + sup E_Qr^W exp(a Psi_F^(2/d)) < infinity. (F2) + +The same statements hold for the unconditioned field, without the pin/tilt +steps. In d=2 this is a uniform EXPONENTIAL tail for the total critical count, +not just a finite collection of moments. + +**Theorem W (window consequence).** Let G_d denote the dimension-matched +hypothesis E_Qr^W N<=C r^3. Given G_d, for every fixed integer p>=2, + + E_Qr^W (N)_p <= C_p r^3 [log(1/r)]^(d(p-1)/2). (F3) + +For d=2, G_2 is the reviewed planar I5 composition under the complete D5 +reading rule, including its actual full-depth P2 continuum review. Hence + + E_Qr^W N(N-1) <= C r^3 log(1/r), (F4) + E_Qr^W (N)_p <= C_p r^3 [log(1/r)]^(p-1). + +This is a NEW candidate improvement over the integrated Taylor-radius bound +r^3[log(1/r)/log log(1/r)]^2. For d>=3 only (F1)-(F2) are asserted without G_d; +the factorial composition remains explicitly conditional on that still-separate +first-moment input. No assertion that #141 or #145 is accepted is made here. + +**Proposition B (an inference boundary, not a Gaussian counterexample).** The +factor [log(1/r)]^(d(p-1)/2) cannot in general be removed using only G_d, a +nonnegative count cap, and the tail/moment statements (F1)-(F2). Section 8 gives +exact rare-count variables attaining that factor. This does not prove that the +factor is optimal for this Gaussian field and does not refute the Palm route. + +## 2. Inputs, including their conditioning boundaries + +LP Sections 3-5 provide the uniform covariance sandwich for U_r, bounded v_r, + + sup v_r^T Cov(U_r)^(-1)v_r < infinity, + ||W_r||_(L2(Q_r)) <= C r^2, Z_r>=c r^2. (F5) + +The matrix/moment facts are consumed in the original law; no witness is added. +C6L supplies the compact-analytic-set/holomorphic-degree argument and the +protected covering of the torus. C6S Section 4 explicitly extends its +polynomial-symbol independence and complex small-ball density argument to +fixed d. Section 4 below restates why the needed density estimate holds; no +uniform lower covariance bound is asserted at a real pinned critical point. +I5 and D5R supply only the planar small-window mean for (F4). Their original +source and reviewer identities are in SOURCE_MAP.json. Historical narrower +algebra-only HOLDs are preserved, not counted as full analytic acceptance. + +The new ingredients are a cutoff of the FULL conditioned field in its original +Fourier coordinates, uniform Gaussian-frequency error bounds, and conversion +of each truncated gradient to a Laurent system. The Taylor truncation tail of +C6S and the new witness-conditioning claims of #145 are not inputs. + +## 3. Uniform Fourier error AFTER conditioning + +Let c_n(f) be the complex Fourier coefficient of a realization. Define + + f_[m](z)=sum_(|n|_infinity<=m) c_n(f) exp(i omega n.z), + P_m(z)=grad f_[m](z), F(z)=grad f(z). (F6) + +This is the Fourier truncation of f drawn under Q_r, not the prior field +conditioned on a truncated set of observations. f_[m] generally does NOT satisfy +the original pin equations; no argument below requires it to do so. F, N, W +and Z always refer to the original, exactly pinned field. + +For a real standardized prior Fourier coordinate xi, Gaussian regression gives + + |E[xi | U_r=v_r]|^2 <= v_r^T Cov(U_r)^(-1)v_r, + Var(xi | U_r=v_r) <= 1. (F7) + +The first is covariance Cauchy-Schwarz after whitening U_r, and the second is +variance reduction by orthogonal projection. Thus, for every fixed s>=1, + + ||c_n||_(Ls(Q_r)) <= C_s sqrt(a_n), (F8) + +uniformly in m,r and marks/frames, with an immaterial factor for real and +imaginary components. The coefficients need NOT be conditionally independent. +This bound includes the conditional mean, not just the centered residual. + +Fix a complex tube |Im z|<=Y, with real parts taken modulo the torus. For every +fixed derivative order j, Minkowski and absolute convergence give + + ||sup |D^j(f-f_[m])|||_(Ls(Q_r)) + <= C_s sum_(|n|_infinity>m) (1+|n|)^j + exp(-omega^2 |n|^2/4 + omega Y |n|). + +To bound this tail put A=omega^2/4 and B=omega Y. Since +Bv <= A v^2/2+B^2/(2A), and |n|^2>m^2 in the omitted set, + + exp(-A|n|^2+B|n|) + <= exp(B^2/(2A)) exp(-A m^2/4) exp(-A|n|^2/4). + +The remaining polynomial-weighted lattice sum is finite. In particular, there +is a fixed a>0, chosen smaller if necessary, such that for the fixed tube used +by the cover, + + R_m := sup |F-P_m|, + E_Qr R_m^2 <= C exp(-4a m^2), + E_Qr [sup ||DF||]^2 <= C. (F9) + +The constants absorb the finitely many small cutoffs. This also proves uniform +absolute convergence of the relevant complex derivative series. Differentiating +a finite Fourier sum and taking its complex analytic extension commute. No +Cauchy radius tending to infinity is needed. + +## 4. Protected annuli and small-gradient volume + +Choose 0=7eta/8 with +radii eta_j=eta/8; set eta_0=eta. Their real balls cover the torus. For every +centre c_j take fixed complex test radii rho in [eta_j,2eta_j], and write + + A'_j={eta_j/2<=|z-c_j|<=3eta_j}. + +Its real slice stays at least eta/4 from the original pins. In each chart choose +real lifts of the centre. Distances near the torus seam are understood using +lifts; the local balls have diameter less than T and no aliasing occurs there. + +For z=x+itu, t=|Im z|>0, define the REAL 2d-dimensional observation + + G(z)=(Re F(z), Im F(z)/t). + +It extends continuously at t=0, with direction u retained, to (grad f(x),H_f(x)u). +For t>0 the evaluation symbols at z, conjugate z, and the real pin sites are +independent exponential-polynomial characters of Z^d. At t=0 the extra symbols +at remote x are i b.n and -(u.n)(c.n), independent because their linear and +quadratic parts cannot cancel and u is nonzero. At r=0 the pin frame consists +of its nonduplicated contact jets at the midpoint. Independence of characters +with polynomial coefficients follows by separation of the joint generalized +eigenspaces of the commuting lattice shifts. This is the C6L Lemma E/C6S +Section 4 argument, not an assumed isotropic GOE law. + +The joint covariance of the pin frame and G is therefore positive at each +point of the compact annulus/mark/direction/frame parameter set, including the +contact limit. Continuity and the Schur complement give a UNIFORM covariance +floor for G under Q_r. Mean shifts cannot increase the Gaussian density supremum. +Consequently, uniformly on these annuli for 0=1, introduce w_l=exp(i omega z_l), l=1,...,d. Each component of +P_m is a Laurent polynomial with exponent support in [-m,m]^d. Multiplication +of each component by the nonvanishing monomial (w_1...w_d)^m clears the negative +exponents and gives an ordinary polynomial Q_(m,l) of total degree at most 2dm. +Extra zeros on coordinate hyperplanes w_l=0 are irrelevant to the original +complex torus but may be counted in an upper bound. + +The exponential map is injective on every closed test ball of radius at most +2eta: equality of exponentials implies an original coordinate difference in +T Z^d; the distance between two points in the ball is at most 4eta=1 for which (F12) holds on at least one test +sphere, or infinity if none works. Let J be the finite number of cover balls, + + Psi_F=(2d)^d sum_j k_j^d. (F14) + +On the event all k_j are finite, C(f)<=Psi_F. The successful radius can vary +with j and f; all of them still cover the fixed real balls. Boundaries of one +cover ball need not carry any zero: a strict Rouché success excludes them. + +Measurability is explicit. For fixed m the sphere minimum of +|P_m|-|F-P_m| is continuous in rho and in the compact analytic field norm. +Strict success at some rho in the closed interval can be detected at a rational +radius in its interior, by continuity (also at endpoint success). The event +{k_j<=m} is the UNION of success events for cutoffs 1,...,m, not just success at +cutoff m; monotonicity of individual Fourier tests is not assumed. + +## 6. Gaussian cutoff tail and stretched-exponential count tail + +Fix j and define h_m=exp(-a m^2), lambda_m=exp(a m^2/(4d)) and + + delta_m=h_m/lambda_m. + +Let L_j be the supremum of ||DF|| on the fixed ball of radius 3eta_j. For large +m, delta_m<=eta_j/2. If k_j>m, the cutoff-m Rouché test fails at EVERY radius, +so each sphere contains z_rho with |P_m(z_rho)|<=|F-P_m|(z_rho). On +{R_m<=h_m,L_j<=lambda_m}, this gives |F(z_rho)|<=2h_m and |F|<=3h_m on the ball +of radius delta_m around it. + +Take radii eta_j+2i delta_m within [eta_j,2eta_j]. There are at least +eta_j/(2delta_m) such radii. Their centres are separated by at least 2delta_m, +so the OPEN balls have disjoint interiors; touching boundaries have zero volume. +All lie in A'_j. Thus failure forces sublevel volume at least + + c_d eta_j delta_m^(2d-1). + +Combining this lower volume with (F11) and Markov gives + + Q_r(k_j>m,R_m<=h_m,L_j<=lambda_m) + <= C h_m lambda_m^(2d-1)(1+a m^2) + = C(1+a m^2) exp[-a(2d+1)m^2/(4d)]. (F15) + +The other two events are bounded using (F9): + + Q_r(R_m>h_m) <= C exp(-2a m^2), + Q_r(L_j>lambda_m) <= C exp[-a m^2/(2d)]. (F16) + +Absorb the fixed polynomial and finite small-cutoff range into constants: + + Q_r(k_j>m) <= C exp(-c m^2). (F17) + +This proves k_jx, some k_j exceeds (x/[(2d)^d J])^(1/d); integer floors change only +constants for x large. A finite union gives the Q_r part of (F1). + +Under the ORIGINAL tilt, covariance Cauchy-Schwarz and (F5) give + + Q_r^W(A) <= ||W_r/Z_r||_2 Q_r(A)^(1/2) <= C Q_r(A)^(1/2). + +The square root changes c, not the power x^(2/d). This proves the other part +of (F1). For Y=Psi_F^(2/d), integrate its exponential tail to obtain (F2) for +sufficiently small a. All constants are uniform only in the specified original +pin family. No further witness-conditioned cap bound has been proved. + +## 7. Factorial moments: exactly one mean and a tail + +For an integer p>=2, N<=Psi_F gives the pathwise inequality + + (N)_p <= N Psi_F^(p-1) + <= Lambda^(p-1) N + Psi_F^p 1_{Psi_F>Lambda}. (F18) + +By Cauchy-Schwarz under Q_r^W, its uniformly bounded 2p-th cap moment and (F1), + + E_Qr^W[Psi_F^p 1_{Psi_F>Lambda}] + <= C_p exp(-c Lambda^(2/d)). (F19) + +Assume G_d. With L_r=log(1/r)>=1 choose Lambda=(A L_r)^(d/2), where A is a fixed +large constant making cA>=3. Then (F18)-(F19) give (F3). Each p has its own +finite constant; no uniform assertion for growing p is made. In d=2 insert +the dimension-matched planar I5, yielding (F4). + +The planar conclusion is asymptotically stronger than the Taylor bound because +L_r/[L_r/log L_r]^2=(log L_r)^2/L_r ->0. In fixed general d the analogous ratio +is (log L_r)^d/L_r^(d/2)->0. Neither comparison makes a numerical radius promise. +G_d for d>=3 remains a separate analytic dependency and is NOT proved by (F1). + +## 8. Why a marked estimate is still needed for O(r^3) + +The following is an EXACT abstract construction, not a Gaussian field. Fix d>=2 +and an integer m>=2. Set r_m=2^(-m^2), n_m=m^d, and let + + N_m=Psi_m=n_m with probability 2^(-3m^2)/n_m, + N_m=Psi_m=0 otherwise. + +Then E N_m=r_m^3 and for 0<=xx)=2^(-3m^2)/n_m <= exp[-2(log 2) x^(2/d)]. + +Above n_m the tail is zero. Also E exp[(log 2)Psi_m^(2/d)]<=2 uniformly. For +fixed integer p>=2, eventually n_m>=p and + + E (N_m)_p = r_m^3 product_(j=1)^(p-1)(n_m-j) + ~ r_m^3 m^(d(p-1)) + = constant * r_m^3[log(1/r_m)]^(d(p-1)/2). (F20) + +Thus even an exponential planar cap tail does not turn an unconditional small +mean into an O(r^3) factorial bound. The exact size-biased identity is + + E(N)_p = (E N) E_sizebiased[(N-1)_(p-1)], + dP_sizebiased = N dQ_r^W / E N. + +A uniform bound on that SIZE-BIASED moment, or an appropriate marked Kac-Rice +estimate, would be an additional input. This identifies the role of #145's +proposed marked argument, not a proof of it. The previous #146 obstruction for +the Taylor-cap tail is credited as motivation; (F20) is a new simpler exact +construction matched to the present Fourier-tail class. The true Gaussian C6 +order may still be Theta(r^3). + +## 9. Review and execution boundaries + +New analytic targets: (i) the FULL conditioned Fourier coefficient bound, +including its mean; (ii) keeping truncation distinct from exact pin constraints; +(iii) exponential-coordinate injectivity and isolated-zero Bezout, even for +nongeneric coefficient systems; (iv) the two cutoffs and all three probabilities +in (F15)-(F16); (v) the correct dimension power and separate G_d dependency. + +The finite checker verifies Laurent clearing and degree counts, rational Gaussian +regression inequalities, completing-square algebra, the probability exponents, +measurability's finite-union convention, and the exact inference-boundary +example. It does not establish Gaussian uniformity, complex analytic zero-set +facts, Kac-Rice or nonauthor acceptance. No hidden import or old missing runner +is used. The exact dependency identities are in SOURCE_MAP.json; local packet +replay does not claim a full upstream checkout, and the hosted workflow separately +checks the pinned upstream bytes. + +The statement is a source-consumer extension, not a novelty/priority claim. +There is no new persistent-pair law, Poisson approximation, same-index refinement, +quantitative SARD rate, numerical C103 certificate, status promotion, or resumed +stopped process. References and the actual limited reconnaissance scope are in +RECONNAISSANCE.md. diff --git a/frontiers/c6_fourier_cutoff_20260929/README.md b/frontiers/c6_fourier_cutoff_20260929/README.md new file mode 100644 index 000000000..19abb3cc4 --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/README.md @@ -0,0 +1,27 @@ +# C6 Fourier-cutoff candidate + +Scientific effect NONE. Author-side analytic candidate; nonauthor review required. + +PROOF.md replaces Taylor truncation with Fourier truncation of the FULL original +conditioned field. Uniform Gaussian-frequency error and Laurent-polynomial zero +counting give a cap tail exp(-c x^(2/d)). In d=2 this is exponential, and combining +it with the reviewed planar window mean gives the proposed r^3 log(1/r) second +factorial bound. In d>=3 the factorial composition remains conditional on G_d; +the count tail itself does not require that input. An exact abstract rare-count +example shows why an additional marked estimate is still needed for O(r^3). + +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 + +Each invocation runs all 18 finite tests in BOTH Python modes and rejects nine +semantic mutants on intended assertions. Source membership, hashes and Git blobs +are checked before and after. Outputs must be new directories outside the packet. +With a complete repository checkout, add --repo /path/to/repository to verify all +six upstream byte identities. The hosted workflow uses that option; a packet-only +local replay does not claim a full checkout or upstream-byte verification. + +The code tests finite identities and guards, not the analytic theorem. No previous +proof, source verdict, scientific-status register, price/lemma/prize flag or stopped +agent process is changed. The original and truncated pin laws are NOT identified. diff --git a/frontiers/c6_fourier_cutoff_20260929/RECONNAISSANCE.md b/frontiers/c6_fourier_cutoff_20260929/RECONNAISSANCE.md new file mode 100644 index 000000000..c067fb81f --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/RECONNAISSANCE.md @@ -0,0 +1,31 @@ +# Dependency-focused reconnaissance, 29 September 2026 + +Consensus was called for analytic Gaussian critical counts, Fourier truncation +and Laurent-polynomial bounds. The response was the monthly 30-search quota +error, with October 1 reset. No search result from that call is claimed. + +Primary records read through web search: + +- Gass and Stecconi, The number of critical points of a Gaussian field: + finiteness of moments, arXiv:2305.17586; Probability Theory and Related Fields + 190 (2024), 1167-1197, DOI 10.1007/s00440-024-01273-5. + https://arxiv.org/abs/2305.17586 +- Soprunova, Zeros of systems of exponential sums and trigonometric polynomials, + arXiv:math/0401074. + https://arxiv.org/abs/math/0401074 + +Read scope is abstract/publisher metadata, NOT a full-text theorem audit. The first +establishes the existing general moment-finiteness context. The second explicitly +discusses exponential changes of variables and Laurent-polynomial systems. Neither +abstract is treated as proving this uniform coalescing-pin count-tail theorem. + +The isolated-zero Bezout and holomorphic-degree ingredients are the same classical +facts used by the completely source-read project C6L/C6S proofs. The new note gives +the actual exponent-clearing map, degree bound, local injectivity and conditioned +Fourier-tail argument. No generic-coefficient BKK equality is imported. The complete +source-bound Gaussian model, density, pin-energy and first-moment interfaces are +identified in SOURCE_MAP.json. No original missing executable is reconstructed. + +This is limited reconnaissance, not a proof of novelty or a claim of worldwide +priority. The author is exposed to the prior growing-radius route and to some +first-moment inputs; an actual nonauthor source review remains a separate task. diff --git a/frontiers/c6_fourier_cutoff_20260929/RESULTS.json b/frontiers/c6_fourier_cutoff_20260929/RESULTS.json new file mode 100644 index 000000000..c751becf0 --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/RESULTS.json @@ -0,0 +1,7 @@ +{ + "tests_per_mode": 18, + "mutants_per_mode": 9, + "identical_output_pairs": 10, + "scientific_effect": "NONE", + "analytic_acceptance": false +} diff --git a/frontiers/c6_fourier_cutoff_20260929/SOURCE_FILES.json b/frontiers/c6_fourier_cutoff_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..2c441da67 --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/SOURCE_FILES.json @@ -0,0 +1,54 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "files": [ + { + "path": "PROOF.md", + "bytes": 18174, + "sha256": "c1692379a3a066589bd2522aaa5b4d480e736b737c8c39a474d1735185793733", + "git_blob": "1d9177a259654df0fb7c558fcb803685e09608d2" + }, + { + "path": "README.md", + "bytes": 1555, + "sha256": "43fbaab3170f4a96e80fdf16e344d1b377545b900505b24f6f588ce0ef40ff67", + "git_blob": "19abb3cc4d3c39c93046116e3eb20ba89ead55af" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 1775, + "sha256": "a86a44e58e1b5db52c3b8905366ddba4052b75a94ebe5796f25d41039ce502c4", + "git_blob": "c067fb81f08f66e6aad75899077a7f8406c9c37e" + }, + { + "path": "RESULTS.json", + "bytes": 147, + "sha256": "4be9dfec746731ccd4a678644aee3cccef6f2919a5efdcefbc6d074924a9e64a", + "git_blob": "c751becf04d8fcf377cf8ba5b68ce091b4618e7b" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 2518, + "sha256": "776115b6481ebc74ee07c094c13c32e1171402a41c6b479cfc3cd49fce99724f", + "git_blob": "d9c0ff09cb3001381d9a70a45b9771581db5f2cf" + }, + { + "path": "fourier.py", + "bytes": 3094, + "sha256": "d64bfbc0658a50d65462552e1366639ae68b9b2ee57fe61d0f06bd198ffff7ad", + "git_blob": "b4963133c4a7a841e227b6cd8b661a9a593a7de5" + }, + { + "path": "test_fourier.py", + "bytes": 5164, + "sha256": "462baf4c630a790221bae1676a167f291260e161dbb0e19d6e49f71cb469e7f7", + "git_blob": "47a66eb7e430f7270c840046811253bbc756dc13" + }, + { + "path": "verify.py", + "bytes": 5451, + "sha256": "06044bcbaa0f3a3fc52180f1d95266f48d9bbe5ceeee4f4f21d5a6395e41933d", + "git_blob": "5cd9c137803d4ed545d846b73e6caff844ad7696" + } + ] +} diff --git a/frontiers/c6_fourier_cutoff_20260929/SOURCE_MAP.json b/frontiers/c6_fourier_cutoff_20260929/SOURCE_MAP.json new file mode 100644 index 000000000..d9c0ff09c --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/SOURCE_MAP.json @@ -0,0 +1,57 @@ +{ + "scientific_effect": "NONE", + "repository": "d6g8k5htny-coder/Math-", + "source_commit": "bf7c45f5e180332be97270df2361b2b890890fc3", + "sources": [ + { + "id": "LP", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "role": "Original pin frame, bounded energy, full W/Z moments and lower normalizer" + }, + { + "id": "C6L", + "path": "frontiers/c6_factorial_moment_20260929/PROOF.md", + "sha256": "b19927563e2e9ff8f38648b61cd3f2c09ee1a081494b98cc285283554746e6d3", + "git_blob": "f5bd013b7134be9efd246fc9bbb8d18ad5a728bc", + "role": "Protected cover, analytic zero/degree argument and planar complex density" + }, + { + "id": "C6S", + "path": "frontiers/c6_sharpened_20260929/PROOF.md", + "sha256": "9f45274ab59d4f4417d1a51e9c97f5916240fdb0a4640ca6f0d3e9e0aea37dd7", + "git_blob": "70ba19726a9114bfceae04d021095e6c8eed5026", + "role": "Fixed-d cover and complex density extension; its Taylor tail is not an input" + }, + { + "id": "I5", + "path": "frontiers/intermediate_window_20260928/PROOF.md", + "sha256": "b3eb9456d7058b5b78149cfca4e072679beda85cd1a0293d209664a542db66cf", + "git_blob": "f53a527ce0204fda271f24730b62b4223a5e43ec", + "role": "Planar height-window first moment only, under D5R" + }, + { + "id": "D5R", + "path": "reviews/d5_reconciliation_20260929/RECONCILIATION.md", + "sha256": "14342b7eb0ad47c1c99b06be58fb6c901f5c7c72fc70f73e81de3dde50c23432", + "git_blob": "4062d76bdf3c60bc73f04295b88c245bcee395de", + "role": "Complete planar first-moment reading rule, not an executed graph transition" + }, + { + "id": "P2REVIEW", + "path": "reviews/d5_punctured_pin_continuum_claude_20260929/REVIEW.md", + "sha256": "124c472cc064ba24021cb4bb8da1002836a4ce26c8df506228f5c20609f6575a", + "git_blob": "4904e3d929d6dc7bc16b49eee85d7c3a21b6b484", + "role": "Actual full-depth P2 continuum acceptance; older xAI partial HOLD remains historical" + } + ], + "higher_dimensional_mean": "G_d is an additional hypothesis, not discharged by #141 or #145 in this packet", + "not_consumed": [ + "C6S Taylor degree tail", + "unreviewed #145 marked estimates", + "unavailable historical algebra.py" + ], + "local_packet_replay_verifies_upstream": false, + "new_analytic_review_required": true +} diff --git a/frontiers/c6_fourier_cutoff_20260929/fourier.py b/frontiers/c6_fourier_cutoff_20260929/fourier.py new file mode 100644 index 000000000..b4963133c --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/fourier.py @@ -0,0 +1,79 @@ +"""Exact finite companions for C6 Fourier cutoff. Not a Gaussian proof checker.""" +from fractions import Fraction as F +from math import prod + +MUTANT = None + +def dimension(d): + if type(d) is not int or d < 2: + raise ValueError('fixed integer dimension at least two required') + return d + +def clear_laurent(terms, d, m): + dimension(d) + if type(m) is not int or m < 1: + raise ValueError('positive integer cutoff required') + out={} + shift = 0 if MUTANT == 'omit-monomial' else m + for n, c in terms.items(): + if len(n)!=d or any(type(k) is not int or abs(k)>m for k in n): + raise ValueError('exponent outside integer Fourier box') + key=tuple(k+shift for k in n) + out[key]=out.get(key,F(0))+F(c) + return {n:c for n,c in out.items() if c} + +def evaluate(terms, w): + if any(F(x)==0 for x in w): + raise ValueError('nonzero Laurent coordinates required') + return sum((F(c)*prod(F(x)**n for x,n in zip(w,ns)) for ns,c in terms.items()),F(0)) + +def bezout_cap(d,m): + dimension(d) + if type(m) is not int or m<1: raise ValueError('positive cutoff required') + degree=2*m if MUTANT=='degree-without-dimension' else 2*d*m + power=2 if MUTANT=='planar-cap-everywhere' else d + return degree**power + +def count_tail_power(d): + dimension(d) + return F(1) if MUTANT=='exponential-all-dimensions' else F(2,d) + +def decay_coefficients(d,a=F(1)): + dimension(d);a=F(a) + if a<=0: raise ValueError('positive rate required') + cut=a/d if MUTANT=='oversized-lipschitz-cutoff' else a/(4*d) + # Coefficients of m^2 in the three NEGATIVE exponential bounds. + return {'remainder':2*a,'sublevel':a-(2*d-1)*cut,'lipschitz':2*cut} + +def mean_log_power(d,p): + dimension(d) + if type(p) is not int or p<2: raise ValueError('integer factorial order >=2 required') + return F(p-1) if MUTANT=='planar-log-everywhere' else F(d*(p-1),2) + +def success_up_to(success,m): + if m<1: return False + return bool(success.get(m,False)) if MUTANT=='single-cutoff-event' else any(success.get(n,False) for n in range(1,m+1)) + +def regression_second_moment(var,cov,target): + """One standardized observation. Full conditional second moment includes mean.""" + var,cov,target=map(F,(var,cov,target)) + if var<0 or cov*cov>var: raise ValueError('joint covariance must be positive semidefinite') + mean=cov*target + return var-cov*cov+(0 if MUTANT=='drop-conditional-mean' else mean*mean) + +def rare_count(d,m,p=2): + dimension(d) + if type(m) is not int or m<2 or type(p) is not int or p<1: raise ValueError('invalid example indices') + n=m**d; mean=F(1,2**(3*m*m));prob=mean/n + factorial=prod(n-j for j in range(p)) if n>=p else 0 + return {'count':n,'probability':prob,'mean':prob*n,'factorial':prob*factorial} + +def tail_after_tilt(c): + c=F(c) + if c<=0: raise ValueError('positive rate required') + return c if MUTANT=='drop-cauchy-square-root' else c/2 + +def square_margin(a,b,x): + a,b,x=map(F,(a,b,x)) + if a<=0: raise ValueError('positive Gaussian rate required') + return a*x*x/2+b*b/(2*a)-b*x diff --git a/frontiers/c6_fourier_cutoff_20260929/test_fourier.py b/frontiers/c6_fourier_cutoff_20260929/test_fourier.py new file mode 100644 index 000000000..47a66eb7e --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/test_fourier.py @@ -0,0 +1,118 @@ +"""Finite exact algebra, exponent and inference-boundary controls.""" +import itertools +import unittest +from fractions import Fraction as F +from math import prod +import fourier as f + +class FourierTests(unittest.TestCase): + def test_clearing_keeps_laurent_values(self): + for d in (2,3,4): + m=2 + terms={tuple([m]*d):F(2),tuple([-m]*d):F(-3),tuple([0]*d):F(5)} + w=[F(i+2,i+1) for i in range(d)] + out=f.clear_laurent(terms,d,m) + self.assertEqual(f.evaluate(out,w),prod(x**m for x in w)*f.evaluate(terms,w)) + self.assertTrue(all(min(n)>=0 for n in out)) + + def test_total_degree_attains_2dm(self): + for d in range(2,7): + for m in range(1,5): + out=f.clear_laurent({(m,)*d:F(1)},d,m) + degree=max(map(sum,out)) + self.assertEqual(degree,2*d*m) + self.assertEqual(f.bezout_cap(d,m),degree**d) + + def test_cap_dimension_not_always_planar(self): + self.assertEqual(f.bezout_cap(3,2),1728) + self.assertEqual(f.bezout_cap(2,2),64) + + def test_separable_cosine_attains_cutoff_order(self): + # grad sum cos(m*x_i) has 2m independent zeros per coordinate on a 2pi torus. + for d in range(2,6): + for m in range(1,6): + self.assertLessEqual((2*m)**d,f.bezout_cap(d,m)) + self.assertEqual(F((2*m)**d,m**d),2**d) + + def test_gaussian_square_completion(self): + for a,b,x in itertools.product((F(1,4),F(1),F(3)),(F(0),F(2),F(5)),(F(-2),F(0),F(3))): + self.assertEqual(f.square_margin(a,b,x),(a*x-b)**2/(2*a)) + self.assertGreaterEqual(f.square_margin(a,b,x),0) + + def test_conditional_mean_must_be_retained(self): + self.assertEqual(f.regression_second_moment(1,F(1,2),3),3) + self.assertGreater(f.regression_second_moment(1,F(1,2),3),1) + + def test_uniform_coefficient_second_moment_bound(self): + for cov,y in itertools.product((F(-1),F(-1,2),F(0),F(1,2),F(1)),range(-5,6)): + self.assertLessEqual(f.regression_second_moment(1,cov,y),1+y*y) + + def test_all_three_cutoff_terms_decay(self): + for d in range(2,15): + vals=f.decay_coefficients(d,F(3,7)) + self.assertTrue(all(x>0 for x in vals.values())) + self.assertEqual(vals['sublevel'],F(3,7)*F(2*d+1,4*d)) + self.assertEqual(vals['lipschitz'],F(3,7)*F(1,2*d)) + + def test_density_volume_powers(self): + for d in range(2,12): + # h^(2d)/(h/lambda)^(2d-1)=h*lambda^(2d-1). + h,lam=F(1,128),F(4) + self.assertEqual(h**(2*d)/(h/lam)**(2*d-1),h*lam**(2*d-1)) + self.assertEqual(d-1-d,-1) + + def test_measurable_degree_is_a_union(self): + history={1:False,2:True,3:False,4:True} + self.assertTrue(f.success_up_to(history,3)) + self.assertFalse(f.success_up_to(history,1)) + + def test_count_tail_power(self): + self.assertEqual(f.count_tail_power(2),1) + self.assertEqual(f.count_tail_power(3),F(2,3)) + self.assertEqual(f.count_tail_power(4),F(1,2)) + + def test_factorial_logarithm_exponents(self): + for d,p in itertools.product(range(2,8),range(2,6)): + self.assertEqual(f.mean_log_power(d,p),F(d*(p-1),2)) + self.assertEqual(f.mean_log_power(d,p)*f.count_tail_power(d),p-1) + + def test_original_tilt_keeps_square_root(self): + for c in (F(1,8),F(1),F(3,2)): + self.assertEqual(f.tail_after_tilt(c),c/2) + + def test_rare_example_exact_first_and_second_moments(self): + for d,m in itertools.product(range(2,6),range(2,9)): + z=f.rare_count(d,m) + self.assertEqual(z['mean'],F(1,2**(3*m*m))) + self.assertEqual(z['factorial']/z['mean'],m**d-1) + + def test_rare_example_uniform_stretched_tail(self): + for d,m in itertools.product(range(2,6),range(2,9)): + z=f.rare_count(d,m) + for k in range(m+1): + # Threshold x=k^d, so x^(2/d)=k^2 is exact. + tail=z['probability'] if km: + self.assertGreaterEqual(F(n*n,2),F(m*m,4)+F(n*n,4)) + + def test_invalid_arguments(self): + with self.assertRaises(ValueError):f.clear_laurent({(-3,0):1},2,2) + with self.assertRaises(ValueError):f.count_tail_power(1) + with self.assertRaises(ValueError):f.regression_second_moment(1,2,0) + with self.assertRaises(ValueError):f.mean_log_power(2,F(3,2)) + +if __name__=='__main__': unittest.main() diff --git a/frontiers/c6_fourier_cutoff_20260929/verify.py b/frontiers/c6_fourier_cutoff_20260929/verify.py new file mode 100644 index 000000000..5cd9c1378 --- /dev/null +++ b/frontiers/c6_fourier_cutoff_20260929/verify.py @@ -0,0 +1,108 @@ +"""Verify exact source membership and both-mode finite controls. Standard library only.""" +import argparse +import hashlib +import io +import json +from pathlib import Path +import subprocess +import sys +import unittest + +ROOT=Path(__file__).resolve().parent +MUTANTS={ + 'omit-monomial':'test_clearing_keeps_laurent_values', + 'degree-without-dimension':'test_total_degree_attains_2dm', + 'planar-cap-everywhere':'test_cap_dimension_not_always_planar', + 'exponential-all-dimensions':'test_count_tail_power', + 'oversized-lipschitz-cutoff':'test_all_three_cutoff_terms_decay', + 'planar-log-everywhere':'test_factorial_logarithm_exponents', + 'single-cutoff-event':'test_measurable_degree_is_a_union', + 'drop-conditional-mean':'test_conditional_mean_must_be_retained', + 'drop-cauchy-square-root':'test_original_tilt_keeps_square_root', +} + +def require(ok,message): + if not ok: raise ValueError(message) + +def loads(text): + def pairs(items): + d={} + for k,v in items: + require(k not in d,'duplicate JSON key: '+k);d[k]=v + return d + return json.loads(text,object_pairs_hook=pairs) + +def identity(path): + require(path.is_file() and not path.is_symlink(),'regular source required: '+str(path)) + b=path.read_bytes() + return {'bytes':len(b),'sha256':hashlib.sha256(b).hexdigest(), + 'git_blob':hashlib.sha1(f'blob {len(b)}\0'.encode()+b).hexdigest()} + +def sources(): + identity(ROOT/'SOURCE_FILES.json') + entries=loads((ROOT/'SOURCE_FILES.json').read_text())['files'] + names=[e['path'] for e in entries] + require(len(names)==len(set(names)) and all(Path(n).name==n and n!='SOURCE_FILES.json' for n in names),'flat unique paths required') + require(sorted(p.name for p in ROOT.iterdir())==sorted(names+['SOURCE_FILES.json']),'source membership differs') + for e in entries: + require(identity(ROOT/e['path'])=={k:e[k] for k in ('bytes','sha256','git_blob')},'source identity differs: '+e['path']) + return {p.name:identity(p) for p in sorted(ROOT.iterdir())} + +def upstream(repo): + repo=repo.resolve() + data=loads((ROOT/'SOURCE_MAP.json').read_text()) + for e in data['sources']: + rel=Path(e['path']) + require(not rel.is_absolute() and '..' not in rel.parts,'upstream path escapes root') + require(not any(repo.joinpath(*rel.parts[:i]).is_symlink() for i in range(1,len(rel.parts)+1)),'upstream symlink') + actual=identity(repo/rel) + require(actual['sha256']==e['sha256'] and actual['git_blob']==e['git_blob'],'upstream identity differs: '+e['id']) + return len(data['sources']) + +def child(mutant): + import fourier, test_fourier + fourier.MUTANT=mutant + result=unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromModule(test_fourier)) + payload={'tests':result.testsRun,'passed':result.wasSuccessful(), + 'failures':sorted(t.id().split('.')[-1] for t,_ in result.failures), + 'errors':sorted(t.id().split('.')[-1] for t,_ in result.errors)} + print(json.dumps(payload,sort_keys=True)) + return 0 if result.wasSuccessful() else 1 + +def replay(out,repo): + out=out.resolve() + require(not out.exists() and not out.is_relative_to(ROOT),'new external output directory required') + before=sources(); up=upstream(repo) if repo else None + out.mkdir(parents=True) + records={} + for name in ['baseline',*MUTANTS]: + outputs=[] + 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) + (out/(name+'_'+mode+'.stdout')).write_bytes(p.stdout) + (out/(name+'_'+mode+'.stderr')).write_bytes(p.stderr) + result=loads(p.stdout.decode()) + require(not p.stderr and not result['errors'] and result['tests']==18,'execution error or wrong count: '+name) + if name=='baseline':require(p.returncode==0 and result['passed'] and not result['failures'],'baseline failed') + else:require(p.returncode==1 and not result['passed'] and MUTANTS[name] in result['failures'],'intended semantic failure missing: '+name) + outputs.append(p.stdout) + require(outputs[0]==outputs[1],'mode outputs differ: '+name) + records[name]=loads(outputs[0].decode()) + summary={'tests_per_mode':18,'mutants_per_mode':9,'identical_output_pairs':10, + 'scientific_effect':'NONE','analytic_acceptance':False} + require(summary==loads((ROOT/'RESULTS.json').read_text()),'stored summary differs') + require(sources()==before,'sources changed during execution') + report={**summary,'sources_unchanged':True,'upstream_verified_count':up, + 'source_identities':before,'cases':records} + (out/'REPORT.json').write_text(json.dumps(report,sort_keys=True,indent=2)+'\n') + print(json.dumps(summary,sort_keys=True,indent=2)) + return 0 + +if __name__=='__main__': + p=argparse.ArgumentParser(description=__doc__);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);p.add_argument('--repo',type=Path) + a=p.parse_args();require(a.child or a.mutant is None,'mutant needs child mode') + raise SystemExit(child(a.mutant) if a.child else replay(a.output,a.repo)) diff --git a/reviews/c6_fourier_completion_20260929/READING_NOTE.md b/reviews/c6_fourier_completion_20260929/READING_NOTE.md new file mode 100644 index 000000000..682d7045e --- /dev/null +++ b/reviews/c6_fourier_completion_20260929/READING_NOTE.md @@ -0,0 +1,88 @@ +# Fourier C6: source-bound review completion and multiplicity reference + +Recorded by OpenAI / ChatGPT, 29 September 2026. Scientific effect NONE. +This is an editorial reading note and the response to one bibliographic review +request. It is not a second nonauthor review or a scientific-status register. +The complete original nine-file author packet is unchanged. + +## Exact reviewed object and actual verdict + +Original source: `4d59319b7fbe0790ebd5a1482bc91c4d9cc2d4f3`, +`frontiers/c6_fourier_cutoff_20260929/PROOF.md`, 18174 bytes, Git blob +`1d9177a259654df0fb7c558fcb803685e09608d2`, SHA256 +`c1692379a3a066589bd2522aaa5b4d480e736b737c8c39a474d1735185793733`. +Original packet tree: `bd6e5602566280d20f4083e868b335d0f9a5ff9c`. + +Anthropic/Claude's submitted review 5356335148 has its native `commit_id` bound +to that exact full source commit. The abbreviated hash in the review prose has +a transcription error; the native binding and the proof identities resolve it. + +https://github.com/d6g8k5htny-coder/Math-/pull/148#pullrequestreview-5356335148 + +The review ACCEPTs Theorem F (F1)-(F2) for every fixed d>=2 at the stated original +pin/tilt, fixed torus and compact-mark scope; Theorem W (F3) as a composition +conditional on the corresponding global window mean G_d; (F4) at d=2 under +the complete planar D5/I5 reading rule; and Proposition B (F20) solely as an +abstract count construction. Its six independent derivations address the full +conditioned Fourier means, residual variance, Laurent cap, all three tail terms, +weighted factorial assembly and the abstract example. This paragraph summarizes +that published review; it is not a reconstructed original reviewer manuscript. + +Claude authored #141 and #145 and disclosed that exposure. No authorship in this +Fourier source was claimed. One provider's nonauthor review is one provider's +review, not an organizational-independence claim from a shared GitHub login. +The author-side historical labels in the unchanged packet do not erase the +subsequently published review, and this note does not strengthen its verdict. + +## Review note N1: isolated zeros and their multiplicities + +The reference for the multiplicity-weighted isolated-zero inequality used in +PROOF.md Section 5 is: + +William Fulton, *Intersection Theory*, second edition, Springer, 1998, +Section 12.3, Theorem 12.3 and Example 12.3.1 (the refined Bezout theorem), +starting on page 223. DOI: 10.1007/978-1-4612-1700-8. + +The relevant inequality bounds the sum of multiplicities of the isolated common +zeros of d polynomial equations in d variables by the product of their degrees, +even when other components of positive dimension exist elsewhere. Affine zeros +are included among the corresponding projective intersection contributions. +The original proof's no-boundary-zero/compact-analytic-set argument ensures +that the zeros actually counted in its local chart are isolated; it does not +postulate a globally zero-dimensional polynomial system. + +Here is the requested local-multiplicity clarification. Multiplying the equations +by a nowhere-vanishing holomorphic factor multiplies their local generators by +units and leaves their local ideal unchanged. A biholomorphic coordinate change +induces an isomorphism of local analytic rings. The length of the resulting +zero-dimensional local quotient, hence the local intersection multiplicity, is +therefore unchanged in both steps. Clearing the Laurent exponents and applying +the locally injective exponential coordinates preserve precisely the +multiplicities used in the bound. Identically zero components are handled by +the original Section 5 dimension argument, not by claiming a positive degree +for the zero polynomial. + +The second-edition publisher metadata and the original Section 12.3 text were +inspected for this reference. This is a citation and explanation of the same +classical input, not a new theorem or a replacement of the original proof. +Review notes N2-N4 require no changes: 2dm is an upper degree bound; factors of +omega in derivative bounds are absorbed in fixed constants; the finite number +of small cutoffs is absorbed after m0 is chosen. + +## Verification and unchanged exclusions + +In this continuation the unchanged packet was freshly replayed through both +ordinary and optimized entry points: 18 finite tests in each inner Python mode, +nine intended semantic mutants per mode, ten identical stdout pairs, valid JSON, +no execution errors or stderr, and exact packet identities before and after. +That is a local packet replay, not a full local checkout of the six upstream +sources and not a proof of the analytic claims. The current PR's complete +source/upstream/required formal checks must still be inspected before merging +this added note; old separate-head receipts are not a substitute. + +No claim of G_d for d>=3, sharp Gaussian Theta(r^3), witness-conditioned cap tail, +acceptance of the Palm route, numerical cutoff, uniformity in d/T/k, scientific +register/graph transition, or independent formal alignment is added. The +abstract example proves only the limitation of the mean-plus-cap-tail method. +The fixed count-cap exponent is 2/d; only the planar case is exponential in +count. Existing scalar Lean checks do not formalize this full theorem. diff --git a/reviews/d1_cde_full_depth_claude_20260929/RESULTS.json b/reviews/d1_cde_full_depth_claude_20260929/RESULTS.json new file mode 100644 index 000000000..21ab159fb --- /dev/null +++ b/reviews/d1_cde_full_depth_claude_20260929/RESULTS.json @@ -0,0 +1,60 @@ +{ + "object": "CL-D1-CDE-FULLDEPTH-20260929-v1-CHECKS", + "passed": true, + "results": { + "C1_detTr_exact_12_r_minus_d_plus_3": [ + [ + 2, + "1/7", + "201684" + ], + [ + 2, + "3/5", + "12500/81" + ], + [ + 2, + "1", + "12" + ], + [ + 2, + "9/4", + "4096/19683" + ], + [ + 3, + "1/7", + "1411788" + ], + [ + 3, + "3/5", + "62500/243" + ], + [ + 3, + "1", + "12" + ], + [ + 3, + "9/4", + "16384/177147" + ] + ], + "C2_radial_ledger_power": 1, + "C3_target_coercivity_13_1": "grid 6x4x3 exact", + "C4_pushforward_11_1_cubed_identity": "exact", + "C5_gamma_factor_15_2": "rel<1e-9 at tau=1,2.5", + "C6_half_gaussian_moment": "rel<1e-9", + "C7_amplitude_scaling_exponent": "-2/3 all d in 2..10", + "C8_specialization_concordance": { + "c2": "0.073406919306034296", + "c3": "0.041775931840598357" + }, + "C9_E1_congruence": "det(DHD)=det(H)/r exact; sqrt-r mutant differs" + }, + "scope": "finite exact/numerical controls for parent Sections 10, 13-14, 15 as read with E1/E2/W1; not the Gaussian proof" +} diff --git a/reviews/d1_cde_full_depth_claude_20260929/REVIEW.md b/reviews/d1_cde_full_depth_claude_20260929/REVIEW.md new file mode 100644 index 000000000..f05700e24 --- /dev/null +++ b/reviews/d1_cde_full_depth_claude_20260929/REVIEW.md @@ -0,0 +1,152 @@ +# Nonauthor-lane full-depth review: D1-C, D1-D, D1-E (parent §§10, 13–14, 15) + +Scientific effect: **NONE**. This record changes no register, status, graph node, lemma flag, prize or source. +It answers the reconciliation's §8 invitation, item 3: a full-depth Claude review of the three interfaces where +xAI is full-depth and Claude was previously partial. Integration is a separate act, by a non-Claude lane, after +reading, and only when the owner stop is lifted or an explicit owner instruction authorizes it. + +## Object and exposure + +| Field | Value | +|---|---| +| Object | UNIFORM-MATRIX-CAP-LIFETIME-20260924-v1 (OpenAI/ChatGPT), interfaces D1-C (§10), D1-D (§§13–14), D1-E (§15) | +| Parent bytes | `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, blob `dfed3b8d318a3ab1950957f393307733a4bef3f2`, 40261 B, SHA256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7` | +| Reading rule | Parent read WITH E1 (blob `213594d6…`), E2 §9 replacement v1.1 (blob `fe9b9ce4…`), W1 and the embedding radius, exactly per `reviews/d1_chain_reconciliation_20260928/RECONCILIATION.md` §1 | +| Read at | Math- default head `dbccbb41a58f2328b3bec6c4609a4b8fb3ac811f` (shallow clone, 2026-09-29) | +| Reviewer | Anthropic Claude (claude.ai session `session_01NMeKEismAyeqgdB4sy2NJU`), a different Claude session from reconciler/reviewer C1–C2 (`session_017Mi3hxjaxV45x6zo6o1ee3`) | +| Exposure | Same provider as C1/C2 and same shared GitHub account: this record converts Claude's partial depth on D1-C/D/E to full depth; it does NOT add a third provider, does not revalidate §§2–9 (outside scope), and claims no organizational independence. This session separately audited the superseded 2026-08-01 SIDE24 packet and maintains the 06B verification suite; that prior work is disclosed, and none of it is treated as review evidence here. | +| Own checks | `cde_review_check.py`: exact Fraction controls C1–C4, C7, C9 and numerical controls C5, C6, C8 (tolerances stated inline); byte-identical under `-O`; three semantic mutants exit 1. Finite controls only — not the Gaussian proof. | + +## Verdicts + +| Interface | Parent lines | Verdict | +|---|---|---| +| **D1-C §10** — exact radial ledger | 310–336 | **ACCEPT** (full depth) | +| **D1-D §13** — target-growth majorant, removal of all birth/gap cutoffs | 386–434 | **ACCEPT** (full depth) | +| **D1-D §14** — off-diagonal bound (14.1) and Theorem C composition | 435–446 | **ACCEPT** (full depth) | +| **D1-E §15** — parity, b-disintegration, gamma factor, (15.2) | 447–481 | **ACCEPT** (full depth) | + +No defect was found in the reviewed sections as read under the reading rule. Everything accepted is at the +reconciliation §2 existential scope: no numerical `C`, `r_*`, `z_*`, `c_{B,K}` or `c_{d,L}`, no `d ≥ 3` lower +bound, no unrestricted difference rate. + +## Re-derivations — D1-C (§10) + +1. **(10.1) pin-density transfer.** `U_r = T_r O_r` with `T_r` linear invertible, so + `density_{O_r}(pins) = |det T_r| · π_r(v_r)`. I re-derived `|det T_r|` from the (3.1) display by exact block + computation: basis change `(f(a),f(c)) → (p,q)` and `(f_x(a),f_x(c)) → (p_x,q_x)` contributes `|det| = 4`; + in the new basis the axial rows are triangular with pivots `1/2, 1/r, 1/r, 6/r²`, product `3/r⁴`; total + axial factor `12/r⁴`. Each transverse pair contributes `det [[1/2,1/2],[−1/r,1/r]] = 1/r`. Hence + `|det T_r| = 12 r^{−4} · r^{−m} = 12 r^{−(d+3)}`, agreeing with (3.2). Checked exactly for `d = 2, 3` at four + rationals each (checker C1). +2. **Measure factors.** `(M,S) → (z,h)` has absolute determinant 1 (standard midpoint/difference block matrix); + `h = ru` polar gives `r^{d−1} dr dσ(u)` with ordinary (unnormalized) surface measure; at fixed `r` the height + map `(b,k) → (f(M), f(S)) = (b, b − kr³)` has Jacobian matrix `[[1,0],[1,−r³]]`, absolute determinant `r³`. +3. **Power ledger.** `(d−1) + 3 − (d+3) + 2 = 1` for every `d` (checker C2), giving the intensity + `r A_r dr db dk dσ(u)` with `A_r = 12 π_r(v_r)(Z_r/r²)` — exactly (10.2). The `Z_r/r²` normalizer is the §5 + object; its use here consumes (5.5) only through boundedness/positivity already reviewed at A3. +4. **No 1/2 factor.** The pair is typed (maximum vs index-(d−1) saddle), and the antipodal direction `−u` + corresponds to the role-swapped pair, which is a different typed configuration; no double count and no + half-factor. This agrees with an independent check of the same convention I ran against the superseded + 2026-08 line (ordered-pair/directed-sphere module), a useful cross-era consistency datum. +5. **Frame invariance.** (10.2) depends on the frame only through `u`: a transverse orthogonal change fixes the + pins, the typed indicator and `|det H_M det H_S|`, and `π_r(v_r)` is computed at a target invariant under + that change. The uniformity transfer from the compact orthogonal group to the sphere is sound; no global + transverse frame on `S^{d−1}` is needed. + +## Re-derivations — D1-D (§13) + +1. **(13.1).** `|v_r| ≤ C(|b| + k)` is immediate from the five displayed coordinates with `r ≤ 1`. For the lower + bound, `b² ≤ 2(b − kr³/2)² + 2(kr³/2)² ≤ 2(b − kr³/2)² + k²/2`, so + `(b − kr³/2)² + 144k² ≥ b²/2 − k²/4 + 144k² ≥ (b² + k²)/2`. Verified exactly on a 6×4×3 rational grid + (checker C3). +2. **(13.2).** §3's eigenvalue band for `Σ_r` on `r ≤ r₀` is target-free, so the Gaussian density bound + `π_r(v_r) ≤ C exp(−c|v_r|²) ≤ C exp(−c(b²+k²))` follows with `c = 1/(2λ_max)` uniform in frame and radius. +3. **(13.3).** The conditional mean of each standardized Fourier coefficient is `Cov(ξ, U_r) Σ_r^{−1} v_r`, with + norm `≤ C_ξ |v_r|` and `Σ C_ξ < ∞` by the rapidly decaying spectral weights; centered conditional variances + are ≤ 1. The Minkowski/summability argument is the same mechanism as (4.1), which is already reviewed at A1/A4; + its polynomial-growth version here is a correct rereading, not a new estimate (see N1). +4. **Weight bound without k-division.** From (5.1) and the canceled-pivot identity (5.3), + `|det H_i|/r ≤ |α_i| ‖A_i‖^{m} + r ‖β_i‖² ‖A_i‖^{m−1}` up to fixed constants, and `|α_i|, ‖β_i‖ ≤ M3/2`, + so `W_r/r² ≤ C (1 + ‖f‖_{C³})^{2d}`. No division by `k` or by `Z_r` occurs, which is what lets the majorant + cover the `k → 0` boundary. +5. **(13.4)–(13.5).** The unnormalized product `A_r = 12 π_r (Z_r/r²)` is then dominated by + `H(b,k) = C(1+|b|+k)^{2d} e^{−c(b²+k²)}`. The near-restriction indicator is exactly `k ≥ ℓ/r₀³` under + `r = (ℓ/k)^{1/3}`; the pushforward factor is (11.1), whose cubed form + `[r dr/dℓ]³ = 1/(27k²ℓ)` I verified exactly (checker C4). `H(b,k) k^{−2/3}` is integrable on + `R × (0,∞)`: exponent `−2/3 > −1` at zero, Gaussian tails elsewhere. +6. **`Z_r > 0` at fixed parameters.** Appending both endpoint transverse Hessians to the §2-distinct pin list + gives a nondegenerate joint Gaussian; the open cone product (negative-definite at `M`, index-(d−1) at `S`) + has positive probability, and `W_r` is strictly positive there. So `p_r` is defined for every fixed + `(r, b, k, R)` without any global floor — the step the majorant route genuinely needs. +7. **DCT and (13.6).** Pointwise in `(b,k,u)`: the indicator → 1, `A_r → A_0` (§§3, 5 uniform-on-compacts + convergence), `p_r → 1` (Theorem A applied on a compact neighborhood). Dominated convergence gives the common + limit for candidate and elder densities and `c_{B,K} ↑ c_{d,L}` along exhausting mark rectangles. The text + correctly refuses to manufacture an unrestricted remainder rate from DCT. + +## Re-derivations — D1-D (§14) + +1. **(14.1).** On the compact far domain (torus distance ≥ r₀), the 2(d+1) value/gradient pin covariance is + uniformly positive definite (§2 distinct-site rank + compactness; no diagonal singularity), the target + `(b, 0, …, 0, b−ℓ, 0, …, 0)` has squared norm ≥ b², the height pair Jacobian is exactly 1, and conditional + determinant-product moments grow at most polynomially in `|b|`. Integrating `C(1+|b|)^{2d} e^{−cb²}` over `b` + and the compact position domain gives `ν_cand^far(ℓ) ≤ C` uniformly on `0 < ℓ ≤ 1`, and the elder mark ≤ 1 + gives `ν_eld^far ≤ ν_cand^far`. Hence `ℓ^{1/3} ν^far → 0`, which is all Theorem C consumes. +2. **Consistency triangle.** (14.1) is an upper `O(1)`; the separately reviewed Theorem U + (`frontiers/unrestricted_selection_difference_20260929`, OpenAI review 2026-09-29) gives a positive lower + constant for far rejected pairs. Together: far rejected density `Θ(1)` — consistent, and jointly they refute + any `ν^far = O(ℓ)`-type claim, of the kind that appeared (unproven) in the superseded 2026-08-01 line and + was tagged there by this session as finding F-02. The current parent never makes that claim. +3. **Covering and multiplicity.** Near/far cover all distinct ordered pairs (the boundary is spatially null); + stationarity converts to per-volume densities; on the Morse distinct-value locus each finite ordinary + superlevel H0 bar has exactly one maximum birth and one index-(d−1) merge death, so the selected count is the + bar count; the essential class is excluded. Accepted as written. + +## Re-derivations — D1-E (§15) + +1. **Parity split.** Real stationarity gives `K(−z) = K(z)`, so every odd-total-order derivative covariance at 0 + vanishes: `(G, t_u)` (orders 1, 3) is independent of `(f, V_u, A_u)` (orders 0, 2, 2). The §3 contact vector + is exactly `(f, V_u) ⊕ (G, t_u)`, so `π_0(v_0) = p_{(f,V_u)}(b,0) · p_G(0) · φ_{τ_u}(12k)` with + `t_u | G = 0` centered (odd regression on odd, evaluated at 0) and `τ_u² > 0` by §2 jet rank. +2. **b-disintegration.** `A_u` is even, so conditioning it on `(f, V_u) = (b, 0)` only; then + `∫_R p_{(f,V_u)}(b,0) E[(det A_u)² 1{A_u<0} | f=b, V_u=0] db = p_{V_u}(0) D_u` by ordinary Gaussian + disintegration. This is the exact analogue of the birth-integration collapse in the superseded line, now in + clean form. +3. **Gamma factor.** `z_0 = (6k)² E[…]` and the leading 4 give `4·36 = 144`; with `t = 12k`, + `∫_0^∞ k^{4/3} φ_τ(12k) dk = 12^{−7/3} ∫_0^∞ t^{4/3} φ_τ(t) dt = 12^{−7/3} · τ^{4/3} 2^{−1/3} Γ(7/6)/√π`, + and `144 · 12^{−7/3} · 2^{−1/3} = 12^{−1/3} 2^{−1/3} = 24^{−1/3}`. Hence the display + `Γ(7/6) τ^{4/3} / (24^{1/3} √π)` is exact (checker C5/C6 numerically to < 1e−9; the reconciliation's own + check is corroborated). The parent's remark that 24 is a Jacobian/gamma constant, not the side length, is + correct. +4. **Amplitude normalization.** Under `f → af`: `p_G(0) ∼ a^{−d}`, `p_{V_u}(0) ∼ a^{−d}`, `τ_u^{4/3} ∼ a^{4/3}`, + `D_u ∼ a^{2(d−1)}`; the exponent sum is `−2/3` for every `d` (checker C7), matching + `ν_{af}(ℓ) = a^{−1} ν_f(ℓ/a)`. +5. **Specialization concordance (context, not part of the verdict).** For the nonperiodic reference law + (`Cov G = I_d`, `V_u ∼ diag(3,1,…,1)`, `τ² = 6`), (15.2) reduces to + `Γ(7/6)(3/2)^{1/3} D_{d−1} / (2√3 π^{d−1} √π)` — exactly `coefficients/side24_v1/PROOF.md` eq. (1) — and for + `d = 3` this equals `2^{−23/6} 3^{−8/3} (29√6 − 36) Γ(1/6) π^{−5/2}` identically + (`Γ(7/6) = Γ(1/6)/6`; `(3/2)^{1/3} = 6^{2/3}/24^{1/3}`, checker C8), whose 40-digit value + `0.0417759318405983433429366654285755564666…` lies in the #65-reviewed enclosure. A clean-context agent + re-derived `D₂ = 29/6 − √6` by two further independent routes on 2026-09-29 (eigenvalue-density quadrature to + 28 digits; exact symbolic `s/R²` integration). This corroborates the arithmetic chain; it does not enlarge + the existential scope of Theorem C, which still carries no numerical enclosure for the periodized `c_{d,L}`. + +## Notes + +- **N1.** (13.3) rests on the same summable-Fourier/Minkowski mechanism as (4.1) (interface A1/A4, C1-accepted). + I re-derived the mechanism rather than treating A1/A4's acceptance as covering it, but a reviewer who rejects + A1/A4 would have to revisit (13.3) too; the dependency is real and one-directional. +- **N2.** §13 deliberately never uses a globally uniform `Z_r` floor or a globally uniform Theorem-A constant; + every global statement passes through the unnormalized product `π_r Z_r`. This is the load-bearing design + point of the section and it is sound. +- **N3.** My checker's C5, C6, C8 are numerical (tolerances 1e−9 for C5 and C6; 1e−12 and 1e−15 within C8); + C1–C4, C7, C9 are exact rational. None of them proves a continuum estimate. +- **N4.** The parent bytes standalone still contain the incorrect §5 congruence display (`diag(√r, I)`); E1 is + load-bearing and consumers must keep the reading rule. My checker's C9 verifies the E1 identity and that the + uncorrected factor genuinely differs. + +## Reproduce + + python -B -S cde_review_check.py # prints RESULTS.json byte for byte + python -B -O -S cde_review_check.py # identical output + python -B -S cde_review_check.py --mutant M # exit 1 for M in {M1, M2, M3} diff --git a/reviews/d1_cde_full_depth_claude_20260929/SOURCE_FILES.json b/reviews/d1_cde_full_depth_claude_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..8ee87d8d6 --- /dev/null +++ b/reviews/d1_cde_full_depth_claude_20260929/SOURCE_FILES.json @@ -0,0 +1,59 @@ +{ + "author": "Anthropic Claude", + "delivered_under": "owner instruction in claude.ai session 2026-09-29 (resumes the reconciliation \u00a78 item-3 invitation); OWNER_STOP left in place, no self-merge, scientific effect NONE", + "files": [ + { + "bytes": 13279, + "path": "REVIEW.md", + "sha256": "8f137401f1f27b76f0202f7d4c271f47899f786cf3bb7064249b46c1c268d09c" + }, + { + "bytes": 8692, + "path": "cde_review_check.py", + "sha256": "a5f5a874a396aba358b81cb41c8ee82b668efc8f50e805b254470a8c24a3daf5" + }, + { + "bytes": 1238, + "path": "RESULTS.json", + "sha256": "97b44def5a7659d500e81817b19eb54dd8de9c7e31b0db683b9eb35b430e38f0" + } + ], + "mathematical_acceptance_by_this_record": "scoped ACCEPT, nonauthor lane, existential scope only", + "mutants": [ + "M1", + "M2", + "M3" + ], + "object": "CL-D1-CDE-FULLDEPTH-20260929-v1", + "read_at_head": "dbccbb41a58f2328b3bec6c4609a4b8fb3ac811f", + "reviewed_sources": [ + { + "blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "bytes": 40261, + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "role": "parent (P)", + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7" + }, + { + "blob": "213594d6ca6a86fb938110f4d166d9ce275a02d0", + "bytes": 1782, + "path": "imports/lifetime_parent_20260925/ERRATUM_CONGRUENCE.md", + "role": "amendment E1", + "sha256": "bad7ef609c4ad8c41ad6af562c1b6807921e19a9d556ed793ad1a0db6e202028" + }, + { + "blob": "fe9b9ce4999908bb3814b500ee2d0ceb0c6f704a", + "bytes": 9062, + "path": "reviews/d1_section9_borel_repair_20260925/REPAIR.md", + "role": "amendment E2", + "sha256": "845abf9f9c99d672c2a10a887b5a2e7206a3d2de3d876f35f75ff6e2dc13e62f" + }, + { + "blob": "75da2597971510f843f8d90c743950cb8c177342", + "path": "reviews/d1_chain_reconciliation_20260928/RECONCILIATION.md", + "role": "reading rule" + } + ], + "reviewer_session": "https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU", + "scientific_effect": "NONE" +} diff --git a/reviews/d1_cde_full_depth_claude_20260929/cde_review_check.py b/reviews/d1_cde_full_depth_claude_20260929/cde_review_check.py new file mode 100644 index 000000000..59fbf3d77 --- /dev/null +++ b/reviews/d1_cde_full_depth_claude_20260929/cde_review_check.py @@ -0,0 +1,224 @@ +#!/usr/bin/env python3 +# cde_review_check.py — finite exact/numerical controls for the full-depth +# review of D1-C (parent Section 10), D1-D (Sections 13-14), D1-E (Section 15) +# of UNIFORM-MATRIX-CAP-LIFETIME-20260924-v1 (read with E1/E2/W1). +# +# Python standard library only. Fail-closed: any failed check raises +# SystemExit(1) via check(); no `assert` statements are used, so `-O` +# output is byte-identical. Mutants: run with --mutant M1|M2|M3 -> exit 1. +# +# These are finite algebra/implementation controls. They do NOT prove the +# continuum Gaussian estimates; the analytic review lives in REVIEW.md. + +import json +import math +import sys +from fractions import Fraction as F + +FAILURES = [] + + +def check(name, cond): + if not cond: + FAILURES.append(name) + print("FAIL " + name) + raise SystemExit(1) + + +def det_fraction(mat): + """Exact determinant of a square Fraction matrix by fraction-free + Gaussian elimination with partial pivoting (exact over Q).""" + n = len(mat) + m = [row[:] for row in mat] + det = F(1) + for col in range(n): + piv = None + for row in range(col, n): + if m[row][col] != 0: + piv = row + break + if piv is None: + return F(0) + if piv != col: + m[col], m[piv] = m[piv], m[col] + det = -det + det *= m[col][col] + inv = F(1) / m[col][col] + for row in range(col + 1, n): + factor = m[row][col] * inv + if factor != 0: + for k in range(col, n): + m[row][k] -= factor * m[col][k] + return det + + +def build_T(r, d, u3_coeff=F(6)): + """Exact matrix of the Section 3 transformation U_r = T_r O_r. + Ordering of O_r: (f(a), f_x(a), f(c), f_x(c), + f_y1(a), f_y1(c), ..., f_ym(a), f_ym(c)). + u3_coeff is 6 in the parent display (3.1); mutant M1 uses 3.""" + m = d - 1 + n = 4 + 2 * m + T = [[F(0)] * n for _ in range(n)] + # U0 = (f(a)+f(c))/2 + T[0][0] = F(1, 2) + T[0][2] = F(1, 2) + # U1 = (f(c)-f(a))/r + T[1][0] = -F(1) / r + T[1][2] = F(1) / r + # U2 = (f_x(c)-f_x(a))/r + T[2][1] = -F(1) / r + T[2][3] = F(1) / r + # U3 = (c6/r^2)[f_x(a)+f_x(c) - 2(f(c)-f(a))/r] + c6 = u3_coeff / (r * r) + T[3][0] = c6 * F(2) / r + T[3][1] = c6 + T[3][2] = -c6 * F(2) / r + T[3][3] = c6 + # per transverse j: Vj0=(f_yj(a)+f_yj(c))/2, Vj1=(f_yj(c)-f_yj(a))/r + for j in range(m): + i0 = 4 + 2 * j + T[i0][i0] = F(1, 2) + T[i0][i0 + 1] = F(1, 2) + T[i0 + 1][i0] = -F(1) / r + T[i0 + 1][i0 + 1] = F(1) / r + return T + + +def main(argv): + mutant = None + if len(argv) == 3 and argv[1] == "--mutant": + mutant = argv[2] + elif len(argv) != 1: + print("usage: cde_review_check.py [--mutant M1|M2|M3]") + raise SystemExit(2) + + results = {} + + # ---- C1: |det T_r| = 12 r^-(d+3) exactly (parent (3.2), used in (10.1)) + u3 = F(3) if mutant == "M1" else F(6) + c1 = [] + for d in (2, 3): + for r in (F(1, 7), F(3, 5), F(1), F(9, 4)): + got = abs(det_fraction(build_T(r, d, u3))) + want = F(12) * r ** (-(d + 3)) + check("C1_detTr_d%d_r%s" % (d, r), got == want) + c1.append([d, str(r), str(got)]) + results["C1_detTr_exact_12_r_minus_d_plus_3"] = c1 + + # ---- C2: Section 10 radial power ledger sums to exactly 1 for every d + # spatial (d-1) + height-mark 3 + pin -(d+3) + determinant-normalizer 2 + height_power = 0 if mutant == "M2" else 3 + for d in range(2, 11): + total = (d - 1) + height_power - (d + 3) + 2 + check("C2_ledger_power_d%d" % d, total == 1) + results["C2_radial_ledger_power"] = 1 + + # ---- C3: (13.1) coercivity on an exact rational grid, r <= 1 + grid_b = [F(-3), F(-1), F(0), F(1, 2), F(2), F(5)] + grid_k = [F(1, 10), F(1), F(3), F(10)] + grid_r = [F(1, 10), F(1, 2), F(1)] + for b in grid_b: + for k in grid_k: + for r in grid_r: + x = b - k * r ** 3 / 2 + check("C3a", b * b <= 2 * x * x + k * k / 2) + check("C3b", x * x + 144 * k * k >= (b * b + k * k) / 2) + results["C3_target_coercivity_13_1"] = "grid %dx%dx%d exact" % ( + len(grid_b), len(grid_k), len(grid_r)) + + # ---- C4: (11.1) lifetime pushforward, checked exactly via cubes: + # with ell = k r^3, [r dr/d ell]^3 = 1/(27 k^2 ell) + for r in (F(1, 5), F(2, 3), F(7, 4)): + for k in (F(1, 3), F(1), F(8)): + ell = k * r ** 3 + lhs_cubed = (F(1) / (3 * k * r)) ** 3 + rhs_cubed = F(1) / (27 * k * k * ell) + check("C4_pushforward", lhs_cubed == rhs_cubed) + results["C4_pushforward_11_1_cubed_identity"] = "exact" + + # ---- C5/C6: the (15.2) gamma factor, numerically (Simpson) + # 144 * int_0^inf k^(4/3) phi_tau(12k) dk = Gamma(7/6) tau^(4/3) / (24^(1/3) sqrt(pi)) + def simpson(f, a, b, n): + if n % 2: + n += 1 + h = (b - a) / n + s = f(a) + f(b) + for i in range(1, n): + s += f(a + i * h) * (4 if i % 2 else 2) + return s * h / 3 + + exponent = 5.0 / 6.0 if mutant == "M3" else 7.0 / 6.0 + for tau in (1.0, 2.5): + def integrand(k, tau=tau): + if k <= 0.0: + return 0.0 + return 144.0 * k ** (4.0 / 3.0) * math.exp( + -(12.0 * k) ** 2 / (2.0 * tau * tau)) / ( + tau * math.sqrt(2.0 * math.pi)) + got = simpson(integrand, 0.0, 4.0 * tau, 400000) + want = math.gamma(exponent) * tau ** (4.0 / 3.0) / ( + 24.0 ** (1.0 / 3.0) * math.sqrt(math.pi)) + rel = abs(got - want) / want + check("C5_gamma_factor_tau%s" % tau, rel < 1e-9) + results["C5_gamma_factor_15_2"] = "rel<1e-9 at tau=1,2.5" + + # C6: the underlying half-Gaussian moment + # int_0^inf t^(4/3) phi_tau(t) dt = tau^(4/3) 2^(-1/3) Gamma(7/6)/sqrt(pi) + tau = 1.7 + got = simpson(lambda t: 0.0 if t <= 0 else t ** (4.0 / 3.0) * math.exp( + -t * t / (2 * tau * tau)) / (tau * math.sqrt(2 * math.pi)), + 0.0, 12.0 * tau, 400000) + want = tau ** (4.0 / 3.0) * 2.0 ** (-1.0 / 3.0) * math.gamma( + 7.0 / 6.0) / math.sqrt(math.pi) + check("C6_half_gaussian_moment", abs(got - want) / want < 1e-9) + results["C6_half_gaussian_moment"] = "rel<1e-9" + + # ---- C7: amplitude-scaling exponent of (15.2): a^(-2/3) for every d + for d in range(2, 11): + total = F(-d) + F(-d) + F(4, 3) + F(2) * (d - 1) + check("C7_amplitude_d%d" % d, total == F(-2, 3)) + results["C7_amplitude_scaling_exponent"] = "-2/3 all d in 2..10" + + # ---- C8: specialization concordance ((15.2) -> side24_v1 eq (1) -> value) + check("C8_cube_identity", F(36, 24) == F(3, 2)) # (6^(2/3)/24^(1/3))^3 + D2 = 29.0 / 6.0 - math.sqrt(6.0) + g76 = math.gamma(7.0 / 6.0) + c3_spec = (g76 / (24.0 ** (1.0 / 3.0) * math.sqrt(math.pi))) * \ + 4.0 * math.pi * (2.0 * math.pi) ** -3.0 * 3.0 ** -0.5 * \ + 6.0 ** (2.0 / 3.0) * D2 + c3_formula1 = g76 * (1.5) ** (1.0 / 3.0) * D2 / ( + 2.0 * math.sqrt(3.0) * math.pi ** 2.5) + check("C8_spec_eq_formula1", + abs(c3_spec - c3_formula1) / c3_formula1 < 1e-12) + check("C8_value_d3", abs(c3_formula1 - 0.041775931840598343) < 1e-15) + c2_formula1 = g76 * (1.5) ** (1.0 / 3.0) * (4.0 / 3.0) / ( + 2.0 * math.sqrt(3.0) * math.pi ** 1.5) + check("C8_value_d2", abs(c2_formula1 - 0.073406919306034271) < 1e-15) + results["C8_specialization_concordance"] = { + "c3": "%.18f" % c3_formula1, "c2": "%.18f" % c2_formula1} + + # ---- C9: E1 congruence D_r = diag(r^(-1/2), I): det(D H D) = det(H)/r, + # exact over Q for m=1 (the sqrt(r) entries only ever appear squared) + for r in (F(1, 4), F(2, 3), F(5)): + for (al, be, A) in ((F(3), F(1, 2), F(-2)), (F(-1), F(4), F(7, 3))): + detH = (r * al) * A - (r * be) * (r * be) + det_scaled_correct = al * A - r * be * be # diag(r^-1/2, 1) + det_scaled_wrong = (r * r * al) * A - (r ** 3) * be * be # diag(r^1/2,1) + check("C9_E1_identity", det_scaled_correct == detH / r) + if r != 1: + check("C9_E1_mutant_differs", det_scaled_wrong != detH / r) + results["C9_E1_congruence"] = "det(DHD)=det(H)/r exact; sqrt-r mutant differs" + + out = { + "object": "CL-D1-CDE-FULLDEPTH-20260929-v1-CHECKS", + "scope": ("finite exact/numerical controls for parent Sections 10, " + "13-14, 15 as read with E1/E2/W1; not the Gaussian proof"), + "results": results, + "passed": True, + } + print(json.dumps(out, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main(sys.argv)