diff --git a/.github/workflows/d2-remainder-fulldepth-review.yml b/.github/workflows/d2-remainder-fulldepth-review.yml new file mode 100644 index 000000000..ac73540c3 --- /dev/null +++ b/.github/workflows/d2-remainder-fulldepth-review.yml @@ -0,0 +1,64 @@ +name: D2 remainder full-depth nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/d2_remainder_full_depth_claude_20260930/**' + - '.github/workflows/d2-remainder-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 record tree, reviewed source identities, 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/d2_remainder_full_depth_claude_20260930').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text()) + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest['files']] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('record tree differs from manifest: ' + repr(present)) + for entry in manifest['files']: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular file required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('record file identity mismatch: ' + entry['path']) + for entry in manifest['reviewed_sources']: + data = pathlib.Path(entry['path']).read_bytes() + framed = b'blob ' + str(len(data)).encode() + b'\0' + data + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256'] or hashlib.sha1(framed).hexdigest() != entry['blob']: + raise ValueError('reviewed source drifted: ' + entry['path']) + script = str(root / 'remainder_review_check.py') + expected = (root / 'RESULTS.json').read_bytes() + 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 manifest['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') + rc = subprocess.run([sys.executable, *flags, script, '--mutant', 'M9'], capture_output=True, timeout=300).returncode + if rc != 2: + raise RuntimeError('unknown mutant label not rejected with exit 2') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/.github/workflows/fixed-r-inverse-lifetime.yml b/.github/workflows/fixed-r-inverse-lifetime.yml new file mode 100644 index 000000000..9216a6e52 --- /dev/null +++ b/.github/workflows/fixed-r-inverse-lifetime.yml @@ -0,0 +1,36 @@ +name: Fixed-r inverse-lifetime checks + +'on': + pull_request: + paths: + - 'frontiers/fixed_r_inverse_lifetime_20260930/**' + - '.github/workflows/fixed-r-inverse-lifetime.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-source: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + fetch-depth: 0 + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Fetch exact public parent model + run: | + set -euo pipefail + git fetch --no-tags origin 7a1cb09a9d58d179393e6d29146252f714b9c9bf + - name: Verify source, packet and both Python modes + env: + PYTHONDONTWRITEBYTECODE: '1' + GIT_NO_REPLACE_OBJECTS: '1' + run: | + set -euo pipefail + python -B -S frontiers/fixed_r_inverse_lifetime_20260930/verify.py + git diff --exit-code diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json b/frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json new file mode 100644 index 000000000..dd6871344 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/MANIFEST.json @@ -0,0 +1,67 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW_OPEN", + "files": [ + { + "path": "PROOF.md", + "bytes": 17213, + "sha256": "5adef725c1c696adae9bc73a525efe0bfe09d5c07e95ee3f067db9e877283630", + "git_blob": "0d4018777d13672c1de1696525512e80b23b7c3c" + }, + { + "path": "README.md", + "bytes": 3763, + "sha256": "cd167a13b3f7250b09635a61aec9b47f48da044c87bafeb86ce7486cb8d63d8b", + "git_blob": "dc87d46d95a7a5d6dcdd7debf1da7422a7d1d80c" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 2222, + "sha256": "38ca0b266398fcfcec2565f2bdd1b53b15494995fcd433f442090887e0a66158", + "git_blob": "47b0f54a2189efcfa9adbaae3ec4e8bb5fa744df" + }, + { + "path": "RESULTS.json", + "bytes": 516, + "sha256": "46ccc0f5e2d8cba11040ca1bc617e9e99e54ca7b19ac85ff4091e2601104efeb", + "git_blob": "ef9ff136e85198dad73d664d1250775baf3e1d7e" + }, + { + "path": "SOURCES.json", + "bytes": 651, + "sha256": "9ca481cd235a0e16ee8175538be0eea2477fbd8340833bc84d6ba995f20cf6e0", + "git_blob": "a7a4ebdd902a11f5daf87e0ea8fd93576aa403fa" + }, + { + "path": "VALIDATION.md", + "bytes": 2500, + "sha256": "b1528945a1d7610b2d3b27fbc907cf6538d887262f634d02b4fe0fc64fc0693c", + "git_blob": "7dc4ffe63a94db6e21164309f089b8ba0b8f1b85" + }, + { + "path": "inverse.py", + "bytes": 6501, + "sha256": "69c8e91e227bde716e237945358b0244d8a414eda9de9d4ce5e4fccb93ee7862", + "git_blob": "62698d649ff1eba92656fb555bf57d603f2bbc37" + }, + { + "path": "test_inverse.py", + "bytes": 6312, + "sha256": "0bcd93e078ee4800647f8af5aaf77894c63912d63dca9d74c49f732432bc5e6f", + "git_blob": "9695c472e7b0f4acc7946c310765d6ec204dc742" + }, + { + "path": "test_verify.py", + "bytes": 4083, + "sha256": "ee6aa8e6b589acb2eb32b482b4e9965d614d7c8416737624cd6df16eaa0b2960", + "git_blob": "1fccbe702825118906bfea6e266973a51225ca78" + }, + { + "path": "verify.py", + "bytes": 5190, + "sha256": "df2f54f44a95f1dc62022145feed2e22dca242bd37266e1eed82b12e519f6355", + "git_blob": "22db229cfc2be9d3486d7759c82c50bea83b14e0" + } + ] +} diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md b/frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md new file mode 100644 index 000000000..0d4018777 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/PROOF.md @@ -0,0 +1,332 @@ +# Fixed-separation lifetime tails and the sharp inverse-moment boundary + +Object OA-FIXED-R-INVERSE-LIFETIME-20260930-v1. +Author: OpenAI / GPT-6 Astra Pro. AUTHOR-SIDE PROOF CANDIDATE; new nonauthor +analytic review OPEN. Scientific effect NONE. No prior proof, status, graph, +Boolean, prize or review disposition is changed. + +## 1. Statement and the precise probability law + +Fix d>=2, L>0, b real, k>0, a unit vector u and 0b) min_t f(gamma(t)), + ell=b-d_f(M). (2) + +An empty class of paths has d_f=-infinity and ell=+infinity (essential class). +On finite deaths this is the actual lifetime, not a gap to a counted witness. +Let F denote failure of the prescribed saddle S to be the ordinary partner. +On the usual distinct-critical-value locus, (2) is the ordinary elder saddle +value. The estimates below apply directly to (2), without counting saddles +or assuming a particular local saddle is the global partner. + +**Theorem 1 (two-sided fixed-r small-lifetime order).** There are constants +00, depending on the fixed parameters, such that +for 0=0, + + E_QW[ell^(-p);ell finite] < infinity iff p<2/3, + E_QW[ell^(-p);F,ell finite] < infinity iff p<2/3. (4) + +For p=0 these denote the finite-event probabilities. The corresponding +conditional expectations have the same finiteness boundary. Multiplication by +the fixed positive scale Delta leaves the threshold unchanged, so (4) also +holds for the normalized lifetime X_r=ell/Delta. At critical and supercritical +powers the capped expectations obey + + E_QW[min(ell^(-1),T)^(2/3);F,ell finite]=Theta(log T), + E_QW[min(ell^(-1),T)^p;F,ell finite]=Theta(T^(p-2/3)) + for p>2/3. (5) + +The same holds without F or after the stated finite-event conditioning. The +constants are not evaluated. There is no claimed exact leading coefficient +or lifetime-density equivalent in (3). Together with elementary finiteness of +positive moments, the full finite-death power-moment domain is q>-2/3: +E[ell^q;finite] and E[ell^q;F,finite] are finite exactly on that range. + +**Scope.** These are statements at EACH FIXED positive r, with epsilon->0. +The constants and epsilon0 may degenerate arbitrarily as r->0. No uniform +integrability as r->0 or limit of inverse moments is asserted. In particular +this is NOT the distant-partner-conditioned law of PR181, where r->0 and a +second extreme-radius limit occur before a small-lifetime limit. Its exponent4 +and this exponent2/3 concern different laws and different limiting operations. + +[P] is the exact source in SOURCES.json. Only its model, observation, weighting +conventions and fixed-point Fourier facts in Sections1-2 are used; the latter +are reconstructed below. The uniform cap theorem, global count laws, elder +candidates PR170/175, positive-moment PR177 and extreme-mark PR181 are NOT proof +premises. The author is exposed to [P]. This is a new consumer, not independent +revalidation of that source's other theorems. + +## 2. Fixed-parameter Gaussian facts, with no contact uniformity + +Poisson summation gives Fourier weights + + a_n=exp(-2 pi^2 |n|^2/L^2)/sum_j exp(-2 pi^2 |j|^2/L^2)>0. + +For every integer m, sum_n sqrt(a_n)(1+|n|)^m is finite. A real sine/cosine +expansion and Minkowski's inequality show that every C^m norm of the field +has moments of every finite order. For orders below1 use a larger moment. +This also supplies a smooth version of the field. + +Any finite list of distinct derivative evaluations at distinct sites has +strictly positive covariance. Indeed a zero-variance linear combination +annihilates every Fourier mode since a_n>0. As a distribution it is a finite +sum of derivatives of delta masses, all of whose Fourier coefficients vanish. +The distribution is zero. Test functions supported near one site with arbitrary +finite jets show that all its coefficients vanish. Symmetric tensor entries +are listed once only; a change of orthonormal frame is invertible on these jets. + +This proves nondegeneracy of the original observation vector O and of the +following additional lists modulo O: + + U=(H_M,H_S), J=(H_M,H_S,D^3 f(M)). (6) + +All conditional covariances here are at FIXED r>0. None is replaced by its +singular r=0 counterpart. Their conditional Gaussian densities are strictly +positive on every compact set and bounded above by C exp(-c|U|^2), or the +analogous bound for J, with constants depending on the fixed observations. + +Full-field regression conditional on U has the form + + f=m_U+G_U, ||m_U||_C3 <= C(1+|U|), + G_U independent of U, E||G_U||_C3^q0. In particular K is NOT presumed +independent of the Hessians. The same argument conditional on J gives an +independent C4 residual and a uniform C4 mean bound on each compact J set. + +The Gaussian density of U is positive on the open product of the required +Hessian cones; W is strictly positive there. All its polynomial moments are +finite. Hence Z in (1) is positive and finite. No r^-2 normalizer estimate is +needed or used. + +For completeness, (2) is measurable: for hh is existence +of a path from M to a point above b with its minimum strictly above h. A +uniform approximation of such a path by torus piecewise-linear paths with +rational vertices retains both strict margins. Thus a countable set of paths +suffices; their endpoint values and compact-path minima are measurable field +functionals. An essential maximum simply has no eligible path. + +## 3. A deterministic local barrier gives a lower bound on lifetime + +Let f be any C3 field on the torus with f(M)=b, grad f(M)=0 and H_M<0. Write +lambda_min for the smallest eigenvalue of -H_M and use K above, so +0= c_L lambda_min^3/K^2, c_L=a_L^2/3>0. (9) + +This holds also as an inequality for ell=+infinity. It proves strict positivity +of every finite lifetime without any global Morse argument. The barrier does +not claim the partner is on that sphere; it bounds all older-reaching paths. + +## 4. Keep the determinant weight: the upper small-lifetime bound + +For any nonnegative measurable function psi, (7) and the Gaussian U density +imply a one-dimensional weighted eigenvalue estimate + + E_Q[W K^2 psi(lambda_min)] + <= C integral_0^infinity lambda psi(lambda) + (1+lambda)^N exp(-c lambda^2)d lambda. (10) + +Here is the full reduction. On H_M<0 diagonalize -H_M with ordered positive +eigenvalues 0=1. Apply (10) with +psi(lambda)=min(1,epsilon/lambda^3), and divide ONCE by Z. For epsilon=s^3<=1, +the portion lambda<=1 is bounded by a constant times the exact integral + + integral_0^1 lambda min(1,s^3/lambda^3)d lambda + =s^2/2+s^3(1/s-1)=(3/2)s^2-s^3. (12) + +The lambda>=1 portion is O(epsilon) by the Gaussian envelope. Therefore +Q^W(00. (13) + +Let C range over a compact box of strictly negative definite (d-1)-matrices, +v over a fixed small box of positive volume, and H_S over a compact box inside +the index-(d-1) cone. We may ensure eigenvalues of C stay between -2 and -1/2, +|det C|>=c_C>0 and |det H_S|>=c_S>0. The entire boxes can be chosen with +nonempty interiors. In these coordinates + + e^T H_M e=-lambda, H_M<0, + |det H_M|=lambda |det C|. (14) + +The change from the independent H_M entries to (lambda,v,C) has absolute +Jacobian1: only H_11 is replaced, with derivative -1 in lambda. We do not set +v=0 on a measure-zero slice, nor shrink its box with lambda. The direction e +adapts smoothly to v,C and has a uniform finite norm bound E. + +Let the third-derivative tensor T at M vary over a fixed compact positive-volume +box for which T[e,e,e]>=a>0 for every C,v in the chosen boxes. Such a box exists: +start with T_111=2a and all other entries zero, choose v small, and then a +sufficiently small full-dimensional tensor neighborhood. Initially allow +0<=lambda<=1. This defines a compact set of complete J targets. By Section2 its +raw conditional density has a strictly positive lower bound m_r on that set. + +Write the conditional full field as m_J+G_J. Choose a fixed residual C4 norm +bound with probability p0>0, possible because the residual has a finite norm +almost surely. It is independent of J. The conditional mean is bounded on the +compact targets; consequently there is a uniform directional fourth-derivative +bound M4>=1 along e on this event, accounting for |e|<=E. This uses a fixed +positive-probability residual event, not the probability of a shrinking Gaussian +ball. M4 and m_r may be very unfavorable as r decreases, which is allowed. + +For the straight path t -> M+t e, Taylor now gives + + f(M+t e) >= b-(lambda/2)t^2+(a/6)t^3-(M4/24)t^4. (15) + +Put B=6/a. If lambda<=6/(M4 B^2), then at t=B lambda the right side minus b is +at least (B^2/4)lambda^3>0. Over the entire interval 0<=t<=B lambda it is at +least -(3B^2/4)lambda^3, hence certainly at least -B^2 lambda^3. Reduce a +fixed lambda0>0 further so that B lambda0 Eb-Delta, not from a count of nearby critical +points. We need not identify the actual death saddle or forbid an even higher +alternative global path: either could only shorten ell further. + +For 0= c integral_0^((epsilon/B^2)^(1/3)) lambda d lambda + = (c/2)B^(-4/3)epsilon^(2/3). (17) + +This is the lower half of (3). It holds for all sufficiently small epsilon at +the fixed model parameters, not just along a sequence or finite numerical grid. + +## 6. Inverse moments and capped growth + +Both normalizing events {ell finite} and {F,ell finite} have positive probability +by (17). For epsilont) <= C t^(-2/3). (18) + +Endpoint strict versus weak inequalities cause no difficulty: upper bounds use +(3), and a lower bound at epsilon=1/(2t) is already enough. For p>0, Tonelli gives + + E[Y^p]=p integral_0^infinity t^(p-1) Q^W(Y>t)dt. + +The portion below a fixed large threshold is finite. The remaining integral +converges precisely when p<2/3. This proves (4). For positive powers, on finite deaths ell<=2||f||_infty; +all weighted positive moments of this norm are finite by the Gaussian norm +and Hessian moments of Section2 and Cauchy-Schwarz. This yields the stated +full power-moment domain without asserting any small-r moment convergence. +Truncating the same integral at T gives the logarithmic and power orders in (5). These are two-sided growth +orders, not exact coefficients; a density or precise regular-variation limit +was not proved by the two-sided comparison. + +## 7. What this closes, and what it does not + +The fixed-r inverse boundary is now determined at candidate-theorem level, +complementing PR177's separately derived positive finite-lifetime moments. +Neither the small-r marked law nor its moment-convergence hypotheses are used +here. In particular the new result cannot be reinterpreted as a failure of +PR181: that law further conditions on a distant replacement partner after +already taking r->0, whereas (3) includes all finite failures at fixed r. + +The exponent2/3 has two independent sources: local cubic escape costs a lifetime +of order lambda^3, while the original Palm weight and eigenvalue volume give +lambda d lambda. Dropping that weight changes the conclusion. As a comparison, +the same proof for the raw Gaussian law conditioned only on the two open Hessian +types, without either determinant tilt, gives exponent1/3; in its upper argument +integral_0^1 min(1,s^3/lambda^3)d lambda=(3/2)s-(1/2)s^3. +This comparison is not a change to the law (1) used in the main theorems. + +No exact lifetime density, leading coefficient, r-uniform constant, joint +r/epsilon limit, convergence of inverse moments as r->0, distant-partner inverse +threshold at finite r, or globally deduplicated persistence-bar intensity is +asserted. Essential-inclusive POSITIVE moments and their convention remain +separate. These proofs are not formalized in Lean and finite tests are not +analytic acceptance. + +Requested review A: fixed-r Gaussian nondegeneracy, regression and weighted +spectral reduction (Sections2-4), including the original full Z. Review B: +full-dimensional Schur sector, retained residual event, older-reaching path, +lower bound and the exact moment conclusions (Sections5-6). Prior source +verdicts or green workflows do not accept this new consumer. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/README.md b/frontiers/fixed_r_inverse_lifetime_20260930/README.md new file mode 100644 index 000000000..dc87d46d9 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/README.md @@ -0,0 +1,72 @@ +# Fixed-r lifetime moments: the inverse boundary is 2/3 + +OpenAI / GPT-6 Astra Pro. **New author-side theorem candidate; nonauthor review +OPEN. Scientific effect NONE. No self-merge.** + +For the exact determinant-weighted maximum/saddle pair-Palm law, hold the two +prescribed pins at any fixed positive embedded separation r. Let ell be the +ACTUAL ordinary elder lifetime, excluding the essential infinite lifetime. +The new proof gives two-sided small-lifetime bounds + + c_r epsilon^(2/3) <= P(0-2/3. Inverse moments of order p are finite exactly when p<2/3, both under +the finite-death restriction and conditional on failure and finite death. +The capped critical inverse moment grows as Theta(log T); above criticality +it grows as Theta(T^(p-2/3)). No exact leading coefficient is asserted. + +This fills the inverse-moment exclusion in the separately merged PR177. It +uses neither PR170/175's marked-limit candidates nor PR181's extreme-selected +law. The latter conditions on distant partners AFTER r->0 and has a different +small-lifetime exponent; it must not be substituted for this fixed-r law. + +## Why the exponent is 2/3 + +A deterministic sphere around the prescribed maximum forces +ell >= c lambda_min^3/K^2, where K controls the third derivative. Conditional +Gaussian norm moments retain K inside the endpoint determinant weight. The +remaining soft-eigenvalue integral is exactly + + integral_0^1 lambda min(1,s^3/lambda^3)d lambda=(3/2)s^2-s^3. + +An open Schur-coordinate sector gives the converse. The Hessian has a soft +curvature -lambda but a positive cubic derivative along an adapted direction. +A short straight path reaches a point above birth with only O(lambda^3) loss. +The original determinant weight supplies lambda, and full jet support supplies +d lambda. Thus the lower probability is of order epsilon^(2/3) as well. +The off-diagonal Hessian entries range over a fixed OPEN box, not a zero-measure +slice or a box shrinking with lambda. + +## Exact boundaries + +All constants can depend on fixed r,d,L,b,k and frame. No r-uniform rate, +interchange of limits, density equivalent, numerical amplitude, inverse-moment +convergence as r->0, or result conditional on a distant partner is claimed. +No source selection theorem, global count asymptotic or hard-fibre bridge is +required: maximin paths and local barriers control the actual lifetime directly. + +PROOF.md contains the full arguments. SOURCES.json binds the one parent model +carrier; only its model/weight conventions and fixed-jet Fourier facts are used, +and the latter are proved again here. Parent asymptotic theorems are not promoted. + +## Replay + + python -B -S frontiers/fixed_r_inverse_lifetime_20260930/verify.py + +The full mode requires the exact parent Git object. For a standalone extraction: + + python -B -S verify.py --local-only + +Local-only explicitly reports that historical project sources are not checked. +Thirty test methods run in each normal/optimized mode; six intentionally wrong +variants must fail per mode. Exact controls include36 Schur matrices across +four hard dimensions,36 Taylor-path cases/612 grid checks,36 local barriers, +and11 source/inventory fixture tests. These finite checks are not acceptance +of the Gaussian integration or the theorem. No new Lean formalization. + +The foreground work follows Dylan's NEW explicit September30 continuation +request, after the September27 stop. No stopped process or timer is restarted. +Review A covers Gaussian support/regression and the upper weighted bound; +review B covers the Schur sector, lower bound and moment domain. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md b/frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md new file mode 100644 index 000000000..47b0f54a2 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/RECONNAISSANCE.md @@ -0,0 +1,37 @@ +# Narrow primary reconnaissance and scope — 30 September 2026 + +Queries actually executed: +- site.arxiv.org Gaussian random fields persistence lifetime distribution critical points small persistence +- site.arxiv.org Gaussian critical points finiteness moments Gass Stecconi 2023 +- site.arxiv.org Gaussian fields Palm small eigenvalue Hessian local maximum saddle persistence + +Primary abstract/metadata pages actually opened: + +1. Louis Gass and Michele Stecconi, The number of critical points of a Gaussian + field: finiteness of moments, arXiv:2305.17586v2, revised19 July2023. + https://arxiv.org/abs/2305.17586 + Context: count-moment finiteness under regularity and jet nondegeneracy. This + is not an inverse ordinary-elder lifetime theorem and is not a premise here. + +2. Dmitry Beliaev, Valentina Cammarota and Igor Wigman, No repulsion between + critical points for planar Gaussian random fields, arXiv:1911.03455v3, + revised27 November2020. https://arxiv.org/abs/1911.03455 + Context: near-diagonal critical-point correlations with index information. + No unconditioned count-correlation formula is substituted for the actual + fixed-pin lifetime law in the new manuscript. + +Access depth was abstract/metadata, not a full-text novelty audit. The cubic +fold scaling, Schur-complement algebra, Gaussian regression, spectral matrix +Jacobian and layer-cake formula are existing general tools. No claim of +inventing them or of exhaustive priority is made. The specific new in-project +argument combines the actual maximin barrier, fixed-r full-jet support and the +original determinant tilt to identify the two-sided inverse-moment boundary. + +Connected repository context read: PR177 README at + d768a1761aee8d6911c14bc7524089e14c8cd81c, blob508e3963304cf323099bc0e118559a1f86f04146, +explicitly excludes inverse moments. That positive-moment work is credited, not +consumed as a premise or independently revalidated. PR181's distant-selected +limit is a different conditioning and is also not a premise. Coordination +pickup main#95/5908596793 and technical notes177/5908600694,5908718757 separate +these lanes. The user requested GitHub/Superpowers; Consensus was not invoked +and no quota-status change is claimed. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json b/frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json new file mode 100644 index 000000000..ef9ff136e --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/RESULTS.json @@ -0,0 +1,15 @@ +{ + "critical_capped_growth": "Theta(log T)", + "extreme_partner_conditioning": false, + "fixed_r_small_lifetime_exponent": "2/3", + "inverse_moment_threshold": "2/3", + "mathematical_acceptance": false, + "passed": true, + "path_grid_checks": 612, + "path_parameter_cases": 36, + "scientific_effect": "NONE", + "scope": "finite rational Taylor, Schur and integral controls only", + "supercritical_capped_growth": "Theta(T^(p-2/3))", + "uniform_in_pin_separation": false, + "unweighted_comparison_exponent": "1/3" +} diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json b/frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json new file mode 100644 index 000000000..a7a4ebdd9 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/SOURCES.json @@ -0,0 +1,15 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "sources": [ + { + "id": "P", + "commit": "7a1cb09a9d58d179393e6d29146252f714b9c9bf", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "use": "Sections1-2 model, exact original observations, full determinant weight and fixed-jet Fourier support. Gaussian facts reconstructed here. No Theorem A/B/C, contact limit, or marked elder law consumed. Author source exposure." + } + ] +} diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md b/frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md new file mode 100644 index 000000000..7dc4ffe63 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/VALIDATION.md @@ -0,0 +1,39 @@ +# Actual author validation, separate from analytic acceptance + +The initial eight-method mathematical scaffold failed all eight assertions. +After implementation all eight passed. The expanded mathematical suite has19 +methods; eleven real-Git/source/inventory tests bring the total to30. + +Fresh replay runs all30 methods in normal and optimized Python, including the +six CLI semantic mutants in each mode and the unknown label. Deterministic +baseline output must match RESULTS.json with no stderr. The exact controls +include36 full Schur matrices in hard dimensions1-4 with nonzero off-diagonal +entries,36 Taylor-path parameter sets and612 rational path points,36 sphere +barriers with360 interior points, exact cubic saddle gaps, weighted split +integrals, and the critical/supercritical scalar-model moment formulas. + +The verifier is reused from the author's PR181 driver, narrowed to the single +parent source and new mathematical CLI. Its byte-count field is required here. +The11 real-Git/inventory tests cover the actual nested working directory, byte +and hash drift, missing/duplicate source inventory, noncommit and unsafe paths, +symlink source/payload, historical replacement forgery, extra files and duplicate +JSON. The replacement fixture first verifies that an ordinary Git read sees +forged bytes, then that the protected reader authenticates the original bytes. +These fixtures are not evidence of tampering in the user's repository. + +The upper/lower Gaussian bounds and infinite-dimensional support are analytic +proof obligations, not conclusions of the scalar examples. No original field +is simulated and no Gaussian coefficient is numerically enclosed. No source +proof, review disposition or global status is changed. + +The local attempt to access the GitHub API failed with DNS resolution error. +Local-only replay therefore reports source_pins_checked=false. The hosted +workflow must fetch the ACTUAL parent commit and verify its full path, regular +mode, byte count, SHA256 and Git-blob identity before reporting source success. +Any hosted receipt belongs to the actual published head, not this author-time +record. Existing Lean checks do not formalize the new analytic proof. + +The new explicit owner instruction is the current September30 ChatGPT request +beginning "Continue to Work on closing as many mathematical items as possible". +It follows the September27 stop and authorizes foreground work, not timers. +No pre-stop autonomy grant or automated-loop restart is used as authorization. diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/inverse.py b/frontiers/fixed_r_inverse_lifetime_20260930/inverse.py new file mode 100644 index 000000000..62698d649 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/inverse.py @@ -0,0 +1,162 @@ +"""Exact controls for the fixed-separation inverse-lifetime theorem candidate. + +Finite rational checks only: this does not simulate a conditioned Gaussian field +or certify the infinite-dimensional support argument. Standard library only. +""" +import argparse +from fractions import Fraction as F +import json + +MUTANTS=('lose-determinant-weight','wrong-cubic-power','wrong-soft-direction', + 'admit-critical-inverse','drop-endpoint-margin','unconditional-tail-shortcut') +_MUTANT=None + + +def rat(x): + if type(x) not in (int,F):raise TypeError('integer or Fraction required') + return F(x) + + +def determinant(matrix): + n=len(matrix) + if any(len(row)!=n for row in matrix):raise ValueError('square matrix required') + a=[[rat(x) for x in row] for row in matrix];out=F(1) + for j in range(n): + i=next((i for i in range(j,n) if a[i][j]),None) + if i is None:return F(0) + if i!=j:a[j],a[i]=a[i],a[j];out=-out + pivot=a[j][j];out*=pivot + for i in range(j+1,n): + q=a[i][j]/pivot + for k in range(j+1,n):a[i][k]-=q*a[j][k] + return out + + +def inverse(matrix): + n=len(matrix) + if any(len(row)!=n for row in matrix):raise ValueError('square matrix required') + a=[[rat(x) for x in row]+[F(i==j) for j in range(n)] for i,row in enumerate(matrix)] + for j in range(n): + i=next((i for i in range(j,n) if a[i][j]),None) + if i is None:raise ValueError('singular matrix') + a[j],a[i]=a[i],a[j];p=a[j][j];a[j]=[x/p for x in a[j]] + for i in range(n): + if i!=j: + q=a[i][j];a[i]=[x-q*y for x,y in zip(a[i],a[j])] + return [row[n:] for row in a] + + +def soft_chart(C,v,lam): + lam=rat(lam);C=[[rat(x) for x in row] for row in C];v=list(map(rat,v));n=len(C) + if not n or len(v)!=n or any(len(row)!=n for row in C) or lam<=0: + raise ValueError('positive soft curvature and a nonempty square hard block required') + if any(C[i][j]!=C[j][i] for i in range(n) for j in range(n)): + raise ValueError('hard block must be symmetric') + if any((-1)**j*determinant([row[:j] for row in C[:j]])<=0 for j in range(1,n+1)): + raise ValueError('hard block must be strictly negative definite') + inv=inverse(C);cv=[sum((inv[i][j]*v[j] for j in range(n)),F(0)) for i in range(n)] + top=sum((x*y for x,y in zip(v,cv)),F(0))-lam + H=[[top]+v]+[[v[i]]+C[i] for i in range(n)] + e=[F(1)]+[-x for x in cv] + if _MUTANT=='wrong-soft-direction':e=[F(1)]+cv + return H,e + + +def barrier(L,lam,K): + L,lam,K=map(rat,(L,lam,K)) + if L<=0 or not 0=1 required') + a=min(F(1),L/4);R=a*lam/K + return R,lam*R*R/3 + + +def path_constants(a,M): + """B=6/a, admissible lambda ceiling, loss bound C and endpoint-gain coefficient.""" + a,M=map(rat,(a,M)) + if a<=0 or M<0:raise ValueError('positive cubic lower bound and nonnegative fourth bound required') + B=6/a;cut=min(F(1),6/(M*B*B)) if M else F(1) + return B,cut,B*B,F(0) if _MUTANT=='drop-endpoint-margin' else B*B/4 + + +def cubic_gap(lam,g): + lam,g=map(rat,(lam,g)) + if lam<=0 or g<=0:raise ValueError('positive lambda and cubic required') + return 2*lam**(2 if _MUTANT=='wrong-cubic-power' else 3)/(3*g*g) + + +def upper_split(s): + """Integral_0^1 lambda min(1,s^3/lambda^3)d lambda, 0=0, 3p!=2 required') + n=2-three_p + return s**n+2*(1-s**n)/n + + +def check(): + def need(ok,msg): + if not ok:raise ValueError(msg) + need(tail_exponent(1)==F(2,3),'retain original maximum determinant weight') + need(cubic_gap(F(1,10),F(2))==F(1,6000),'cubic lifetime scale') + H,e=soft_chart([[F(-2)]],[F(1,3)],F(1,10)) + q=sum((e[i]*H[i][j]*e[j] for i in range(2) for j in range(2)),F(0)) + need(q==-F(1,10),'correct Schur soft direction') + need(not inverse_finite(F(2,3)),'critical inverse moment diverges') + need(path_constants(1,4)[3]==9,'strict endpoint above birth') + need(upper_split(F(1,10))==F(7,500),'retain weighted near-zero eigenvalue integral') + cases=0 + for a in (F(1,2),F(1),F(2)): + for M in (F(0),F(1),F(4),F(20)): + B,ceiling,C,gain=path_constants(a,M) + for frac in (F(1,10),F(1,2),F(1)): + lam=ceiling*frac + endpoint=-lam*(B*lam)**2/2+a*(B*lam)**3/6-M*(B*lam)**4/24 + need(endpoint>=gain*lam**3>0,'Taylor endpoint') + for j in range(17): + t=B*lam*F(j,16) + lower=-lam*t*t/2+a*t**3/6-M*t**4/24 + need(lower>=-C*lam**3,'Taylor path stays above lower barrier') + cases+=1 + return {'passed':True,'mathematical_acceptance':False,'scientific_effect':'NONE', + 'scope':'finite rational Taylor, Schur and integral controls only', + 'path_parameter_cases':cases,'path_grid_checks':17*cases, + 'fixed_r_small_lifetime_exponent':'2/3','inverse_moment_threshold':'2/3', + 'unweighted_comparison_exponent':'1/3', + 'critical_capped_growth':'Theta(log T)', + 'supercritical_capped_growth':'Theta(T^(p-2/3))', + 'uniform_in_pin_separation':False,'extreme_partner_conditioning':False} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--mutant',choices=MUTANTS) + args=parser.parse_args();global _MUTANT;_MUTANT=args.mutant + try:ans=check() + except ValueError as exc: + print(json.dumps({'passed':False,'error':str(exc)},sort_keys=True));raise SystemExit(1) + print(json.dumps(ans,indent=2,sort_keys=True)) + +if __name__=='__main__':main() diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py b/frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py new file mode 100644 index 000000000..9695c472e --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/test_inverse.py @@ -0,0 +1,121 @@ +from fractions import Fraction as F +import unittest +import inverse as m + +class InitialTests(unittest.TestCase): + def test_schur_chart(self): + H,e=m.soft_chart([[F(-2)]],[F(1,3)],F(1,10)) + self.assertEqual(H,[[F(-7,45),F(1,3)],[F(1,3),F(-2)]]) + self.assertEqual(e,[F(1),F(1,6)]) + def test_barrier(self): + self.assertEqual(m.barrier(F(4),F(1,10),F(2)),(F(1,20),F(1,12000))) + def test_path_constants(self): + self.assertEqual(m.path_constants(F(1),F(4)),(F(6),F(1,24),F(36),F(9))) + def test_spectral_split(self): + self.assertEqual(m.upper_split(F(1,10)),F(7,500)) + def test_exact_cubic_gap(self): + self.assertEqual(m.cubic_gap(F(1,10),F(2)),F(1,6000)) + def test_tilt_exponent(self): + self.assertEqual(m.tail_exponent(1),F(2,3)) + self.assertEqual(m.tail_exponent(0),F(1,3)) + def test_threshold(self): + self.assertEqual([m.inverse_finite(p) for p in (F(0),F(1,3),F(2,3),F(1))],[True,True,False,False]) + def test_critical_cap(self): + self.assertEqual(m.critical_model(),(F(1),F(-2))) + + +class ExtendedTests(unittest.TestCase): + def test_full_scalar_controls(self): + r=m.check();self.assertEqual(r['path_parameter_cases'],36) + self.assertEqual(r['path_grid_checks'],612) + def test_schur_in_arbitrary_hard_dimensions(self): + count=0 + for n in range(1,5): + B=[[F((i+2*j)%5-2,7) for j in range(n)] for i in range(n)] + C=[[-sum(B[k][i]*B[k][j] for k in range(n))-int(i==j) for j in range(n)] for i in range(n)] + for numerator in (1,2,5): + v=[F(numerator*(i+1),11) for i in range(n)] + for lam in (F(1,100),F(1,10),F(1)): + H,e=m.soft_chart(C,v,lam) + He=[sum(H[i][j]*e[j] for j in range(n+1)) for i in range(n+1)] + self.assertEqual(He,[-lam]+[F(0)]*n) + self.assertEqual(m.determinant(H),-lam*m.determinant(C)) + for x in (F(-1),F(2,3)): + y=[F(i-1,3) for i in range(n)];vec=[x]+y + q=sum(vec[i]*H[i][j]*vec[j] for i in range(n+1) for j in range(n+1)) + cv=m.inverse(C);z=[y[i]+x*sum(cv[i][j]*v[j] for j in range(n)) for i in range(n)] + self.assertEqual(q,-lam*x*x+sum(z[i]*C[i][j]*z[j] for i in range(n) for j in range(n))) + count+=1 + self.assertEqual(count,36) + def test_uniform_scalar_barrier_inequality(self): + for L in (F(1,3),F(1),F(4),F(24)): + for K in (F(1),F(3),F(20)): + for ratio in (F(1,100),F(1,3),F(1)): + lam=K*ratio;R,gap=m.barrier(L,lam,K) + self.assertLess(R,L/2) + self.assertLessEqual(-lam*R**2/2+K*R**3/6,-gap) + for j in range(1,11): + t=R*F(j,10) + self.assertLess(-lam*t*t/2+K*t**3/6,0) + def test_scalar_cubic_stationary_point(self): + for lam in (F(1,100),F(1,7),F(1)): + for g in (F(1,2),F(1),F(7)): + t=2*lam/g + self.assertEqual(-lam*t+g*t*t/2,0) + self.assertGreater(-lam+g*t,0) + self.assertEqual(-lam*t*t/2+g*t**3/6,-m.cubic_gap(lam,g)) + def test_lower_path_at_worst_fourth_derivative(self): + for g0 in (F(1,3),F(1),F(3)): + for M in (F(1),F(10),F(100)): + B,cut,C,gain=m.path_constants(g0,M) + for g in (g0,2*g0): + lam=cut/2 + for h in (-M,F(0),M): + val=lambda t:-lam*t*t/2+g*t**3/6+h*t**4/24 + self.assertGreaterEqual(val(B*lam),gain*lam**3) + self.assertTrue(all(val(B*lam*F(j,20))>=-C*lam**3 for j in range(21))) + def test_weighted_split_by_independent_primitives(self): + for s in (F(1,100),F(1,3),F(1)): + direct=s*s/2+s**3*(1/s-1) + self.assertEqual(direct,m.upper_split(s)) + self.assertLessEqual(direct,F(3,2)*s*s) + self.assertGreaterEqual(direct,s*s/2) + def test_random_norm_factor_can_be_absorbed(self): + for A in (F(1),F(3,2),F(10)): + for x in (F(1,100),F(1,3),F(1),F(5)): + self.assertLessEqual(min(F(1),A*x),A*min(F(1),x)) + def test_capped_model_piecewise_integration(self): + for s in (F(1,20),F(1,3),F(1)): + for n in (0,1,3,4,5): + direct=s**(2-n)+2*(1-s**(2-n))/F(2-n) + self.assertEqual(m.cap_model(s,n),direct) + self.assertGreaterEqual(direct,1) + def test_critical_model_logarithm(self): + # For p=2/3, the lower part is1 and the upper integral is -2log(s). + self.assertEqual(m.critical_model(),(1,-2)) + self.assertEqual(F(2)/3,m.tail_exponent()) + def test_wrong_inputs_rejected(self): + for val in (True,0.5,'1/2'): + with self.assertRaises(TypeError):m.cubic_gap(val,1) + for C,v,l in (([[1]],[0],1),([[-1,1],[0,-1]],[0,0],1),([[-1]],[0],0)): + with self.assertRaises(ValueError):m.soft_chart(C,v,l) + with self.assertRaises(ValueError):m.barrier(0,1,2) + with self.assertRaises(ValueError):m.barrier(1,3,2) + with self.assertRaises(ValueError):m.path_constants(0,1) + with self.assertRaises(ValueError):m.upper_split(0) + def test_cli_both_modes_and_mutants(self): + import subprocess,sys + from pathlib import Path + path=str(Path(m.__file__).resolve());baseline=None + for flags in (['-B','-S'],['-B','-O','-S']): + run=subprocess.run([sys.executable,*flags,path],capture_output=True,timeout=25) + self.assertEqual(run.returncode,0,run.stderr);self.assertEqual(run.stderr,b'') + if baseline is None:baseline=run.stdout + self.assertEqual(run.stdout,baseline) + for mutant in m.MUTANTS: + bad=subprocess.run([sys.executable,*flags,path,'--mutant',mutant],capture_output=True,timeout=25) + self.assertEqual(bad.returncode,1,(mutant,bad.stdout,bad.stderr)) + bad=subprocess.run([sys.executable,*flags,path,'--mutant','unknown'],capture_output=True,timeout=25) + self.assertEqual(bad.returncode,2) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py b/frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py new file mode 100644 index 000000000..1fccbe702 --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/test_verify.py @@ -0,0 +1,69 @@ +"""Real-Git regressions for the reused, narrowed source-verification driver.""" +import hashlib,json,os,subprocess,tempfile,unittest +from pathlib import Path +import verify as v + + +def entry(path,data,**kw): + return dict(path=path,bytes=len(data),sha256=hashlib.sha256(data).hexdigest(), + git_blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest(),**kw) + +class SourceTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.repo=Path(t.name) + self.root=self.repo/'frontiers/packet';self.root.mkdir(parents=True) + self.git('init','-q');self.data=b'source fixture\n' + (self.repo/'P.md').write_bytes(self.data);self.git('add','P.md');self.git('commit','-qm','fixture') + self.sha=self.git('rev-parse','HEAD').decode().strip();self.e=entry('P.md',self.data,id='P',commit=self.sha);self.write() + def git(self,*args): + env=os.environ.copy();env.pop('GIT_NO_REPLACE_OBJECTS',None) + return subprocess.run(['git','-c','user.name=Fixture','-c','user.email=fixture@example.invalid',*args],cwd=self.repo,env=env,capture_output=True,check=True,timeout=15).stdout + def write(self,es=None): + (self.root/'SOURCES.json').write_text(json.dumps({'sources':[self.e] if es is None else es})) + def test_original_nested_source(self):self.assertEqual(v.sources(self.root),1) + def test_identity_drift(self): + for k,x in [('bytes',0),('bytes',True),('sha256','0'*64),('git_blob','0'*40)]: + self.write([dict(self.e,**{k:x})]) + with self.subTest(k=k),self.assertRaises(ValueError):v.sources(self.root) + def test_empty_duplicate_sources(self): + for es in ([],[self.e,self.e]): + self.write(es) + with self.assertRaises(ValueError):v.sources(self.root) + def test_noncommit_and_unsafe_path(self): + self.write([dict(self.e,commit=self.git('rev-parse','HEAD^{tree}').decode().strip())]) + with self.assertRaises(ValueError):v.sources(self.root) + self.write([dict(self.e,path='../P.md')]) + with self.assertRaises(ValueError):v.sources(self.root) + def test_replace_cannot_change_history(self): + new=b'forged\n';(self.repo/'P.md').write_bytes(new);self.git('add','P.md');self.git('commit','-qm','change') + self.git('replace',self.sha,self.git('rev-parse','HEAD').decode().strip()) + self.assertEqual(self.git('show',self.sha+':P.md'),new) + self.assertEqual(v.sources(self.root),1) + self.write([entry('P.md',new,id='P',commit=self.sha)]) + with self.assertRaises(ValueError):v.sources(self.root) + def test_symlink_source(self): + (self.repo/'P.md').unlink();(self.repo/'P.md').symlink_to('elsewhere') + self.git('add','P.md');self.git('commit','-qm','link') + self.write([dict(self.e,commit=self.git('rev-parse','HEAD').decode().strip())]) + with self.assertRaises(ValueError):v.sources(self.root) + +class PacketTests(unittest.TestCase): + def setUp(self): + t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name) + self.data=b'packet\n';(self.root/'PROOF.md').write_bytes(self.data) + (self.root/'MANIFEST.json').write_text(json.dumps({'files':[entry('PROOF.md',self.data)]})) + def test_original(self):self.assertEqual(v.inventory(self.root),1) + def test_changed_payload(self): + (self.root/'PROOF.md').write_bytes(b'changed') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_extra_file(self): + (self.root/'extra').write_bytes(b'x') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_duplicate_json(self): + (self.root/'MANIFEST.json').write_text('{"files":[],"files":[]}') + with self.assertRaises(ValueError):v.inventory(self.root) + def test_symlink_payload(self): + (self.root/'PROOF.md').unlink();(self.root/'PROOF.md').symlink_to('MANIFEST.json') + with self.assertRaises(ValueError):v.inventory(self.root) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/fixed_r_inverse_lifetime_20260930/verify.py b/frontiers/fixed_r_inverse_lifetime_20260930/verify.py new file mode 100644 index 000000000..22db229cf --- /dev/null +++ b/frontiers/fixed_r_inverse_lifetime_20260930/verify.py @@ -0,0 +1,110 @@ +"""Replay the fixed-r inverse-lifetime packet; --local-only excludes historical sources.""" +import argparse +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import re +import subprocess +import sys + +IDS={'P'} +MUTANTS=('lose-determinant-weight','wrong-cubic-power','wrong-soft-direction', + 'admit-critical-inverse','drop-endpoint-margin','unconditional-tail-shortcut') + + +def read_json(path): + if path.is_symlink() or not path.is_file():raise ValueError('regular JSON required') + def unique(pairs): + out={} + for k,v in pairs: + if k in out:raise ValueError('duplicate JSON key') + out[k]=v + return out + data=json.loads(path.read_text(encoding='utf-8'),object_pairs_hook=unique) + if not isinstance(data,dict):raise ValueError('JSON object required') + return data + + +def parts(path): + if not isinstance(path,str) or not path:raise ValueError('nonempty path required') + p=PurePosixPath(path) + if p.is_absolute() or str(p)!=path or any(x in ('.','..') or not re.fullmatch('[A-Za-z0-9_.-]+',x) for x in p.parts): + raise ValueError('unsafe or noncanonical path') + return p.parts + + +def identity(data,e): + blob=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if type(e['bytes']) is not int or len(data)!=e['bytes']: + raise ValueError('size mismatch') + if hashlib.sha256(data).hexdigest()!=e['sha256'] or blob!=e['git_blob']: + raise ValueError('hash mismatch: '+e['path']) + + +def git(root,*args): + run=subprocess.run(['git','--no-replace-objects',*args],cwd=root, + env=dict(os.environ,GIT_NO_REPLACE_OBJECTS='1'), + capture_output=True,timeout=45) + if run.returncode:raise ValueError('Git read failed: '+run.stderr.decode(errors='replace')[:160]) + return run.stdout + + +def sources(root): + es=read_json(root/'SOURCES.json')['sources'] + if not isinstance(es,list) or len(es)!=len(IDS) or {e['id'] for e in es}!=IDS: + raise ValueError('source inventory mismatch') + seen=set() + for e in es: + path=e['path'];ps=parts(path);commit=e['commit'] + if not isinstance(commit,str) or not re.fullmatch('[0-9a-f]{40}',commit): + raise ValueError('full commit identity required') + if (commit,path) in seen:raise ValueError('duplicate source binding') + seen.add((commit,path)) + if git(root,'cat-file','-t',commit).strip()!=b'commit':raise ValueError('not a commit object') + for j in range(1,len(ps)+1): + prefix='/'.join(ps[:j]) + rows=[s for s in git(root,'ls-tree','--full-tree','-z',commit,'--',prefix).split(b'\0') if s] + if len(rows)!=1:raise ValueError('missing or ambiguous source path') + meta,name=rows[0].split(b'\t',1);mode,kind,blob=meta.decode().split() + if name.decode()!=prefix:raise ValueError('source path mismatch') + if j 0`, has index 1 and `|det| = t`), and the contributing endpoint's `|det|` is `|t − t₀|·|slope| ≤ + r|βᵀadj(A)β|`. Checked on 390 endpoint/index + combinations, 12 of which cross inertia between nonsingular endpoints. The note's point — that a naive use of (R6) on the `√r` entries would + lose a square root, while (R7) does not, "also as `k` tends to zero" — is exactly the mechanism that makes + (R10) linear in `r`. No inverse of `A` and no eigenvalue margin is used. + +## R3 — the refined intensity and its contact error (§4) + +1. **Congruence.** `K_i = D_r^{−1}H_iD_r^{−1}` with `D_r = diag(√r, I)` gives `[[α_i, √rβ_iᵀ],[√rβ_i, A_i]]` and + `|det H_i|/r = |det K_i|`: this is the *corrected* congruence of erratum E1 (`diag(r^{−1/2}, I)` applied to + `H_i`), so the note reads the parent as the erratum requires. Sylvester's law keeps the inertia, so + `W_r/r² = F_d(K_M)F_{d−1}(K_S)`. +2. **(R8)–(R9).** `|α_M + 6k| + |α_S − 6k| ≤ CrM_4` is parent (5.2); `‖β_i‖ ≤ M_3/2` is (5.1); + `‖A_i − A_0‖ ≤ (r/2)‖F_r‖_{C³} + ‖F_r − F_0‖_{C²}` and the note's `T` (which includes `r^{−2}‖F_r − F_0‖_{C²}`, + of `L^p` size `≤ CP` by (R4)) gives `‖A_i − A_0‖ ≤ CrT` for `r ≤ 1` (with `C = 3/2` for the displayed + choice; the note's `T` absorbs it); `T ≥ 1 + k` with all moments `≤ C_pP^p`. + No independence of `T` and `A_0` is needed, as stated. +3. **Endpoint errors.** First (R7) removes the off-diagonal block: `≤ r|β_iᵀadj(A_i)β_i| ≤ CrT^{m+1} = CrT^d`. + Then (R6) between `diag(α_i, A_i)` and `diag(±6k, A_0)`: `≤ d(CT)^{d−1}(CrT + rT) = CrT^d`. The displayed + size bounds `F_j(K_i) ≤ C(k + r)T^d`, `F_d(diag(−6k, A_0)) ≤ CkT^{d−1}`, `F_{d−1}(diag(6k, A_0)) ≤ CkT^{d−1}` + follow from the block identity and `T ≥ 1 + k`. +4. **Reference product.** Index `d` for `diag(−6k, A_0)` and index `d − 1` for `diag(6k, A_0)` both force + `A_0 < 0` (checker C4 on three inertia patterns), so `W_0 = (6k)²det(A_0)²1{A_0 < 0}` and `E W_0 = z_0` is + exactly parent (5.4). +5. **(R10)–(R11).** Pathwise `|W_r/r² − W_0| ≤ Cr(k + r)T^{2d}`; expectations give + `|Z_r/r² − z_0| ≤ Cr(k + r)P^N` and `Z_r/r² ≤ C(k + r)²P^N`. With (R5): `|A_r − A_0| ≤ 12|π_r − π_0|Z_r/r² + + 12π_0|Z_r/r² − z_0| ≤ r(k + r)H(b,k)` after absorbing `r(k + r) ≤ k + 1` into the polynomial, and + `A_r ≤ (k + r)²H`, `A_0 ≤ k²H`. No division by `k` or `Z` anywhere — this is what allows the `k ↓ 0` region + in §§6–7. + +## R4 — the unnormalized cap-loss bound (§5) + +1. **(R13).** Appending the independent entries of `A_M` to `U_r` keeps the joint covariance uniformly positive at + contact and for `r ≤ r_0` (parent §3, last paragraph); the joint Gaussian density at `(v_r, A)` is therefore + `≤ Ce^{−c(b²+k²+‖A‖²)}` by coercivity of `(v_r, A)`, which is the product of `π_r(v_r)` and the conditional + density. Correct and uniform in eigenvector orientation. +2. **Depth failure, `m ≥ 2`.** With `M_3 ≤ K(T + Λ)` (mean `≤ C(P + ‖A‖)`, residual `J` independent of the + appended vector, `‖A‖_F ≤ √mΛ`), failure of `λ_min(−A_M) > (4/(3k))rM_3²` gives `λ_1 ≤ (4K²/3)(r/k)(T + Λ)² = + Dδ(T + Λ)²`, i.e. the depth width is `δ = r/k` times a polynomial, with the largest eigenvalue *inside* the + width. The envelope (R14) is parent (6.2) divided by `r²`, both soft factors retained. The soft integral + `∫_0^{DδU²} λ(λ + ErU)dλ = (D³/3)δ³U⁶ + (ED²/2)rδ²U⁵` (checker C5) and `rδ² = kδ³` make both terms + `δ³ × polynomial(P, J, Λ)`; the Vandermonde `≤ Λ^{m(m−1)/2}`, the Gaussian in `λ_2, …, λ_m` from (R13) and the + finite `J` moments give `π_rE_Q[(W/r²)1{depth}] ≤ δ³H`. Every corank stratum is included; no lower cutoff on + `λ_2`. +3. **`m = 1` (R15).** `λ ≤ Dδ(T + λ)²` implies `λ ≤ 4DδT²` or `λ ≥ 1/(4Dδ)` — from `(T + λ)² ≤ 2T² + 2λ²` and + `2Dδλ² ≤ λ/2` when `λ ≤ 1/(4Dδ)` (checker C5 tests it on a rational grid whose parameters keep the two + branches disjoint, so the hypothesis fails on most of the grid). Near branch: `h ≤ CT²` for `δ ≤ 1`, direct integration `δ³H`. Far branch: fourth-moment Markov, + `(4Dδ)⁴π_rE_Q[(W/r²)λ⁴] ≤ δ⁴H ≤ δ³H`. Correct; the scalar far branch is retained, as in the parent. +4. **Fourth-derivative exception.** `rM_4 > 3k/10 ⇔ M_4 > 3/(10δ)`; Markov with the actual weight gives + `≤ (10δ/3)⁴π_rE_Q[(W/r²)M_4⁴] ≤ δ⁴H`. Correct. +5. **Containment.** `A_r(1 − p_r) = 12π_rE_Q[(W/r²)1_F] ≤ 12π_rE_Q[(W/r²)1{G_r^c}] = B_r ≤ A_r` uses the cap + implication `F ⊂ G_r^c` on typed support (parent §8 with the cap theorem, reconciled), i.e. the consumption + contract's "§8 comparison `1 − p_r ≤ Q^W(G_r^c)`" in unnormalized form. (R12) `B_r ≤ δ³H` for `δ ≤ 1` is + proved; the note is right to say it is not a globally uniform *normalized* estimate. + +## R5 — cutoffs and the `η` split (§§6–7) + +1. **(R16).** `ℓ^{1/3}ν_cand^{near} = ∫_{k ≥ a}A_r/(3k^{2/3})` with `a = ℓ/r_0³` is parent (13.5); the contact + coefficient is `∫_{k > 0}A_0/(3k^{2/3}) = c` (13.6). Missing contact mass: `∫_0^a k²H/(3k^{2/3}) = O(a^{7/3})`. + The two monomials of `r(k + r)H/(3k^{2/3})` are exactly `rk^{1/3} = ℓ^{1/3}` and `r²k^{−2/3} = ℓ^{2/3}k^{−4/3}` + (checker C6, which binds every fractional power to its base by an exact cube identity, verifies the + antiderivatives by exponent differentiation and brackets the integrals by exact Riemann sums on a perfect-cube + geometric partition); `∫_a^1 k^{−4/3}dk = 3a^{−1/3} − 3`, so the second contributes at most `Cℓ^{2/3}a^{−1/3} = Cr_0ℓ^{1/3}` + (the constant from the integral of `H`) plus an `O(ℓ^{2/3})` tail. Hence `|ℓ^{1/3}ν_cand^{near} − c| ≤ Cℓ^{1/3}`. The note correctly observes that dropping the + lower cutoff would make the `r²k^{−2/3}` integral diverge; the cutoff is exactly the near/far split. +2. **(R17)–(R18).** On `a ≤ k ≤ η = ℓ^{1/6}`: `B_r ≤ A_r ≤ (2k² + 2r²)H` gives `Cη^{7/3} = Cℓ^{7/18}` and + `Cℓ^{2/3}a^{−1/3} = Cr_0ℓ^{1/3}`. On `k ≥ η`: `δ = ℓ^{1/3}k^{−4/3} ≤ ℓ^{1/9} ≤ 1`, so (R12) applies; + `B_r/(3k^{2/3}) ≤ Cℓk^{−14/3}H` and `∫_η^∞ k^{−14/3} = (3/11)η^{−11/3}`, giving `Cℓ^{1 − 11/18} = Cℓ^{7/18}`. + Since `7/18 > 1/3`, the scaled loss is `≤ Cℓ^{1/3}`. The choice `η = ℓ^{1/6}` balances the two error terms + exactly (`η^{7/3} = ℓη^{−11/3} ⇔ η⁶ = ℓ`), which I note as a sanity check on the exponent bookkeeping; checker + C7 evaluates the same split as a model integral with `H = 1`, `r_0 = 1/2`, exactly at `ℓ = 10^{−18m}`, + `m = 1, …, 4`, and finds the ratio to `ℓ^{1/3}` equal to `1.0376…`, `1.0038…`, `1.00038…`, `1.000038…` — + decreasing to the limit `2r_0 = 1` set by the cutoff term. + +## R6 — Theorem R and its corollaries (§§7–8) + +1. **Far pairs.** Parent (14.1) gives `0 ≤ ν_eld^{far} ≤ ν_cand^{far} ≤ C` for `0 < ℓ ≤ 1` on torus separations + `≥ r_0`, from the nonsingular full-pin covariance on a compact set; the note consumes it as stated in the + consumption contract. +2. **(R1).** `|ν_cand − cℓ^{−1/3}| ≤ ℓ^{−1/3}·Cℓ^{1/3} + C`, `0 ≤ ν_cand − ν_eld ≤ ℓ^{−1/3}·Cℓ^{1/3} + C`, and their + difference — all `≤ C`. The relative error `O(ℓ^{1/3})` follows. +3. **(R19)–(R20).** Integrating the density versions: `∫_0^t ℓ^{−1/3} = (3/2)t^{2/3}` and, for `q > −2/3`, + `∫_0^t ℓ^{q−1/3} = t^{q+2/3}/(q + 2/3)` with the `O(1)` remainder contributing `O(t^{q+1})` for `q > −1`; + the nonselected measure alone has weight `≤ C_qt^{q+1}` for `q > −1`, meaningful on `(−1, −2/3]` because it + bounds a single nonnegative measure. Correct, and the note's caveat that this is a sufficient inverse + integrability range for nonselected candidates, not an exact threshold, is right (the exact fixed-`r` + threshold is a different object; see Math- #182). + +## Remarks (non-blocking) + +1. **Embedding radius.** §2 chooses `r_0 ≤ 1` "inside the torus injectivity scale"; for the cap implication + `A_r(1 − p_r) ≤ B_r` (the step before (R12)) the reconciled requirement is the cap cylinder's embedding, + `r < L/(4√2)` (RECONCILIATION §5), which matters only when `L < 4√2` (for `L = 24` it is implied by `r_0 ≤ 1`). + Since every constant here is existential, taking `r_0 < min(1, L/(4√2))` costs nothing; a successor should + say so. +2. **Where the `O(1)` comes from.** At fixed `(b, k, u)` the contact error is in fact `O(r²)`, not `O(r)`: every + observation row is even in `r` (checker C1), the covariance and coupling are even, the only odd target + coordinate is `b − kr³/2` (an `O(r³)` shift that enters no Hessian and changes `Z_r` by `O(r⁵)`), and the + unsigned product `det H(−ru/2)·det H(ru/2)` is symmetric under the pin swap; the typed indicator's boundary + layer carries a vanishing determinant factor and is `o(r)`. So `A_r = A_0 + O(r²)`, and (R10)–(R11)'s + `r(k + r)` is valid but not sharp in `r` at fixed `k` (the pathwise (R7)/(R6) bounds are first-order; the + cancellation is one of expectations). This does not improve Theorem R: the near remainder is dominated by + the cutoff region `k ≍ a`, i.e. pairs at distance `≍ r_0`, which contribute a genuine `O(1)` (the term + `Cr_0ℓ^{1/3}` in (R16)), and the far density (14.1) is `O(1)`; for its rejected part a positive lower bound + is the content of Theorem U (`frontiers/unrestricted_selection_difference_20260929/PROOF.md`, blob + `5a55b179`, an Anthropic candidate whose header still reads "nonauthor analytic review required"; it carries + the nonauthor OpenAI record `reviews/c7_nonvanishing_openai_20260929/REVIEW.md`, blob `64794e5e`, verdict + ACCEPT at that blob). This remark is context only: no step of R1–R6 uses Theorem U, and this record does not + re-review it. The note's "we do not prove + convergence of the bounded remainder, [nor] identify a second coefficient" is the right boundary; a second + coefficient would need the second-order expansion of the typed determinant expectation (beyond the + first-order pathwise bounds) together with the zero-gap far pair density, and is not claimed anywhere. +3. **Consumption map.** Beyond the reconciliation §7 D2 row (§8 comparison, §9 as E2, §10, (14.1), (15.2) as + `c`), the note re-uses — without revalidating — parent §2 (Fourier summability and distinct-site rank), §3 + (rows (3.1)–(3.3) with the factor 12; uniform positivity of `Cov(U_r)` and of `Cov(U_r ⊕ A_M)`, which feeds + (R13)), §4 (the independent residual, in its (13.3) growth form), (5.1)–(5.4), (6.1)–(6.2), (7.2), + (13.1)–(13.6) and the cap theorem §1. All of these are reconciled interfaces and none depends on the + target, so nothing outside the reconciled scope is imported; the reconciliation's D2 row could list them. + +## What this record does not do + +No numerical `C`, `ℓ_*`, `r_0`, `z_*` or `c_{d,L}`; no convergence of the remainder; no second coefficient; no +unrestricted `O(ℓ^{2/3})` difference (the positive lower bound for the far rejected density on `(0, ℓ_0]` is +Theorem U, cited above with its OpenAI review; the limit of that density is the separate candidate Theorem Z, +`frontiers/c7_zero_gap_limit_20260929/PROOF.md`, blob `5b6328ea`, whose header reads "non-OpenAI review +required" — neither is reviewed or relied on here); no `d ≥ 3` lower bound; no register, STATUS, GRAPH, +PROOF_INDEX or catalog change; no merge. diff --git a/reviews/d2_remainder_full_depth_claude_20260930/SOURCE_FILES.json b/reviews/d2_remainder_full_depth_claude_20260930/SOURCE_FILES.json new file mode 100644 index 000000000..d1aebbfdc --- /dev/null +++ b/reviews/d2_remainder_full_depth_claude_20260930/SOURCE_FILES.json @@ -0,0 +1,103 @@ +{ + "author": "Anthropic Claude", + "cited_only": [ + { + "blob": "5a55b179a974a90c65d257f3f93765cc6fb30bb8", + "bytes": 13028, + "path": "frontiers/unrestricted_selection_difference_20260929/PROOF.md", + "role": "Theorem U (Anthropic candidate; header: nonauthor analytic review required) \u2014 cited in a non-blocking remark only, not relied on", + "sha256": "93a63002d32fd5c35ae994fe28b1205d8098026d6ddde19c67d4977dcf5817a9" + }, + { + "blob": "64794e5801b70d950c7e1202f7b6b7d07055cbb6", + "bytes": 10807, + "path": "reviews/c7_nonvanishing_openai_20260929/REVIEW.md", + "role": "nonauthor OpenAI review of Theorem U (ACCEPT at blob 5a55b179) \u2014 the review binding for the Theorem U citation", + "sha256": "68b6cd43351706745992c4af242abdc5bdabd46ab5ac99347f2c12b505e1a15d" + }, + { + "blob": "5b6328ea3d6afcbeb731698b3834e536f72d1bcb", + "bytes": 17592, + "path": "frontiers/c7_zero_gap_limit_20260929/PROOF.md", + "role": "Theorem Z (OpenAI candidate; header: non-OpenAI review required) \u2014 named in the scope statement only, not relied on", + "sha256": "f0e563c45c41333f2bb6e5bf5cb98f0d3b592e2abf2af1c1b098c21ad77cb777" + } + ], + "delivered_under": "owner instruction in claude.ai session 2026-09-30 (close open mathematical items; support other lanes); OWNER_STOP left in place, no self-merge, scientific effect NONE", + "files": [ + { + "bytes": 20595, + "path": "REVIEW.md", + "sha256": "8679afd19ad313ade3602bba48b744183fdbefc9596a7793cfe7f921988a5dfd" + }, + { + "bytes": 24294, + "path": "remainder_review_check.py", + "sha256": "fec1ec7cad865d2f5d1399fc93f1a4def554d862d9fb32ec6dae34ef64d293f5" + }, + { + "bytes": 2043, + "path": "RESULTS.json", + "sha256": "310e1c26b6b0fcd3d64367e1c2c7a0f5b6892e0f9f113c31a8db9520999dd761" + } + ], + "mathematical_acceptance_by_this_record": "scoped ACCEPT R1-R6, nonauthor lane (second provider after xAI/Grok), existential O(1) scope only", + "mutants": [ + "M1", + "M2", + "M3", + "M4", + "M5", + "M6", + "M7" + ], + "object": "CL-D2-REMAINDER-FULLDEPTH-20260930-v1.1", + "read_at_head": "f430fdecbb1d8802d8af40419b701f12af87c039", + "referee_pass": "clean-context Anthropic Claude subagent (same provider, same account; not a nonauthor review): no blocking finding; one false remark (contact error is O(r^2), not O(r)), one missing disclosure (#150 overlap), and script coverage claims corrected before landing", + "reviewed_sources": [ + { + "blob": "247b3ecf80bfbe896948d5d489b2d5842a81c481", + "bytes": 17734, + "path": "frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md", + "role": "reviewed object (D2, Theorem R)", + "sha256": "380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a" + }, + { + "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": "reading rule E1", + "sha256": "bad7ef609c4ad8c41ad6af562c1b6807921e19a9d556ed793ad1a0db6e202028" + }, + { + "blob": "fe9b9ce4999908bb3814b500ee2d0ceb0c6f704a", + "bytes": 9062, + "path": "reviews/d1_section9_borel_repair_20260925/REPAIR.md", + "role": "reading rule E2 (section 9 replacement)", + "sha256": "845abf9f9c99d672c2a10a887b5a2e7206a3d2de3d876f35f75ff6e2dc13e62f" + }, + { + "blob": "75da2597971510f843f8d90c743950cb8c177342", + "bytes": 23312, + "path": "reviews/d1_chain_reconciliation_20260928/RECONCILIATION.md", + "role": "reading rule W1, embedding radius, consumption contract", + "sha256": "451b9d7ffee072a73fc904cab891b6693e3f233808b89df10cce1b57036b65da" + }, + { + "blob": "0633aca3c2a2882b0de4399da0a75d64c2e6b2e1", + "bytes": 15160, + "path": "imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md", + "role": "cap theorem (deterministic part)", + "sha256": "0bf922b9203c29088b12388807aa0e2ecd020485eb0f6e919679841b5b2636fc" + } + ], + "revision": "v1.1 (2026-09-30): applied the three Codex findings on Math-#186 \u2014 C1 forbids the r^-3 coefficient of U3 (all powers from -offset through r^3 other than r^0, r^2); C6 binds a^(-1/3), eta^(-11/3) to the cutoff values by exact cube identities, verifies the antiderivatives by exponent differentiation and brackets the integrals by exact Riemann sums (mutant M7 corrupts a^(-1/3)); C7 binds every fractional power to its base; REVIEW.md cites Theorem U with its nonauthor OpenAI review record and marks it non-load-bearing", + "session": "https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU" +} diff --git a/reviews/d2_remainder_full_depth_claude_20260930/remainder_review_check.py b/reviews/d2_remainder_full_depth_claude_20260930/remainder_review_check.py new file mode 100644 index 000000000..0185e3d4b --- /dev/null +++ b/reviews/d2_remainder_full_depth_claude_20260930/remainder_review_check.py @@ -0,0 +1,491 @@ +#!/usr/bin/env python3 +"""Exact finite controls accompanying the D2 (Theorem R) full-depth review. Standard library only. + +They check, exactly in rational arithmetic, the displayed algebra that the review re-derives; they do not prove +the Gaussian estimates of the note and are not acceptance. Scientific effect: NONE. + + C1 the four axial rows (3.1) of the parent applied to a degree-7 polynomial: U0 = f0 + (r^2/8) f2 + O(r^4), + U1 = f1 + (r^2/24) f3 + O(r^4), U2 = f2 + (r^2/24) f4 + O(r^4), U3 = f3 + (r^2/40) f5 + O(r^4) + (note S2: "U_r - U_0 = O(r^2)", "(r^2/40) f_xxxxx"); every coefficient from the most negative power the + row can carry (r^-3 for U3, r^-1 for U1, U2) through r^3, other than r^0 and r^2, is asserted to vanish + (no unscaled residual, no odd term); the two transverse rows are the U0/U1 pattern applied to f_y and are + checked on a second polynomial; + C2 Lemma R3.2's affine determinant identity det K_t = alpha det A - t beta^T adj(A) beta on rational + 3x3 and 4x4 blocks, INCLUDING a singular A of corank one with NONZERO adjugate, and the bound + |F_j(K_r) - F_j(K_0)| <= r |beta^T adj(A) beta| on paths whose inertia changes (a singular crossing in + [0, r]); inertia is computed exactly by congruence diagonalisation (eigenvalue multiplicities counted); + C3 Lemma R3.1 on rational symmetric pairs whose inertia changes along the segment: the filtered + determinant difference is bounded by n max(||X||, ||Y||)^(n-1) ||X - Y|| (operator norms replaced by the + larger Frobenius norms, which only weakens the bound); + C4 the reference product: W_0 = (6k)^2 det(A_0)^2 1{A_0 < 0} is the only inertia pattern giving index d at + diag(-6k, A_0) and index d-1 at diag(6k, A_0) (three inertia patterns for A_0); + C5 the soft-eigenvalue integral of note S5: int_0^(D delta U^2) lambda (lambda + E r U) d lambda + = (D^3/3) delta^3 U^6 + (E D^2/2) r delta^2 U^5 (exact, at rational parameters); the scalar split (R15): + lambda <= D delta (T + lambda)^2 implies lambda <= 4 D delta T^2 or lambda >= 1/(4 D delta), on a rational + grid whose parameters satisfy 4 D delta T^2 < 1/(4 D delta), so that the two branches do not overlap and + the hypothesis fails on part of the grid (the check is informative); + C6 the exponent ledger of notes S6-S7 by exact monomial substitution r = (ell/k)^(1/3), a = ell r_0^-3, + eta = ell^(1/6): r k^(1/3) = ell^(1/3); r^2 k^(-2/3) = ell^(2/3) k^(-4/3); a^(7/3) = ell^(7/3) r_0^-7; + eta^(7/3) = ell^(7/18); delta = r/k at k = eta is ell^(1/9); ell eta^(-11/3) = ell^(7/18); 7/18 > 1/3; + and the antiderivatives int_a^1 k^(-4/3) dk = 3 a^(-1/3) - 3 and int_eta^oo k^(-14/3) dk = (3/11) eta^(-11/3) + evaluated exactly at ell = 10^-18 (all fractional powers rational there, each bound to its base by an exact + cube identity), verified by exponent differentiation and bracketed by exact lower/upper Riemann sums on a + perfect-cube geometric partition (tail on [1, oo) by geometric series); + C7 the split of note S7 as a model integral with H = 1, r_0 = 1/2, in EXACT rationals at ell = 10^(-18 m), + m = 1..4 (where ell^(1/6), ell^(1/3), a^(-1/3), a^(7/3) are rational): piece 1 = int_a^eta (2k^2 + 2r^2) + /(3 k^(2/3)) dk = (2/7)(eta^(7/3) - a^(7/3)) + 2 ell^(2/3)(a^(-1/3) - eta^(-1/3)); piece 2 = + int_eta^oo ell k^(-14/3)/3 dk = ell eta^(-11/3)/11; their sum divided by ell^(1/3) stays below 3/2 (every + fractional power bound to its base by an exact integer-power identity); + M semantic mutants (--mutant M1|M2|M3|M4|M5|M6|M7) exit 1; an unknown label exits 2 (M7 corrupts the + hard-coded a^(-1/3) of C6, which the cube identity must catch). +""" +import argparse +import json +import sys +from fractions import Fraction as F + + +# ---------------------------------------------------------------------------------------------------------- +# polynomial helpers (coefficient lists in r, exact) +def poly_mul(p, q): + out = [F(0)]*(len(p)+len(q)-1) + for i, a in enumerate(p): + for j, b in enumerate(q): + out[i+j] += a*b + return out + + +def poly_add(p, q): + n = max(len(p), len(q)) + return [(p[i] if i < len(p) else F(0)) + (q[i] if i < len(q) else F(0)) for i in range(n)] + + +def poly_scale(p, c): + return [c*a for a in p] + + +def taylor_eval(fcoef, point_poly): + """Sum_j f_j point^j / j! where point is a polynomial in r and f_j are the derivatives at 0.""" + total = [F(0)] + power = [F(1)] + fact = F(1) + for j, fj in enumerate(fcoef): + if j > 0: + power = poly_mul(power, point_poly) + fact *= j + total = poly_add(total, poly_scale(power, fj/fact)) + return total + + +def coeff(p, i): + return p[i] if 0 <= i < len(p) else F(0) + + +def rows_from(fc): + """The four axial rows of parent (3.1) as Laurent polynomials in r: returns dict name -> (offset, coeffs) + where the row equals sum_i coeffs[i] r^(i-offset).""" + fxc = [fc[j+1] for j in range(len(fc)-1)] + a = [F(0), F(-1, 2)] + c = [F(0), F(1, 2)] + fa, fcv = taylor_eval(fc, a), taylor_eval(fc, c) + fxa, fxcv = taylor_eval(fxc, a), taylor_eval(fxc, c) + U0 = (0, poly_scale(poly_add(fa, fcv), F(1, 2))) + d1 = poly_add(fcv, poly_scale(fa, F(-1))) # f(c) - f(a), then divide by r + U1 = (1, d1) + d2 = poly_add(fxcv, poly_scale(fxa, F(-1))) + U2 = (1, d2) + two_U1 = poly_scale(d1, F(-2)) # -2 (f(c)-f(a)) as polynomial; /r later + # inner = f_x(a) + f_x(c) - 2 (f(c)-f(a))/r : represent with a common offset 1: multiply first part by r + s = poly_add(fxa, fxcv) + inner_times_r = poly_add(poly_mul(s, [F(0), F(1)]), two_U1) # r * inner + U3 = (3, poly_scale(inner_times_r, F(6))) # (6/r^2) inner = 6 * (r inner)/r^3 + return {'U0': U0, 'U1': U1, 'U2': U2, 'U3': U3} + + +def check_rows(mutant): + fc = [F(v) for v in (2, 3, 5, 7, 11, 13, 17, 19)] # f_j = f^(j)(0), distinct primes + rows = rows_from(fc) + expect = {'U0': (fc[0], fc[2]/8), 'U1': (fc[1], fc[3]/24), 'U2': (fc[2], fc[4]/24), 'U3': (fc[3], fc[5]/40)} + if mutant == 'M1': + expect['U3'] = (fc[3], fc[5]/24) + vanishing = {} + for name, (off, p) in rows.items(): + # coefficient of r^e is coeff(p, e + off); every exponent from the most negative one the representation + # can carry (r^-off) through r^3, other than r^0 and r^2, must vanish: for U3 this includes r^-3 + # (a leftover constant in r*inner would make U3 diverge and break the second-order coupling) + forbidden = [e for e in range(-off, 4) if e not in (0, 2)] + for e in forbidden: + if coeff(p, e + off) != 0: + return False, 'row %s has a nonzero r^%d term' % (name, e) + vanishing[name] = ['r^%d' % e for e in forbidden] + c0, c2 = expect[name] + if coeff(p, off) != c0 or coeff(p, off + 2) != c2: + return False, 'row %s expansion mismatch' % name + # transverse rows: V0 = (g(a)+g(c))/2, V1 = (g(c)-g(a))/r with g = f_y: the U0/U1 algebra on another polynomial + gc = [F(v) for v in (23, 29, 31, 37, 41, 43, 47, 53)] + rows_g = rows_from(gc) + off, p = rows_g['U0'] + if coeff(p, off) != gc[0] or coeff(p, off + 2) != gc[2]/8 or coeff(p, off + 1) != 0: + return False, 'transverse row V0 mismatch' + off, p = rows_g['U1'] + if coeff(p, off) != gc[1] or coeff(p, off + 2) != gc[3]/24 or coeff(p, off + 1) != 0: + return False, 'transverse row V1 mismatch' + return True, {'axial_rows': 4, 'transverse_rows': 2, 'U3_second_order': str(fc[5]/40) + ' = f5/40', + 'vanishing_terms_asserted': vanishing} + + +# ---------------------------------------------------------------------------------------------------------- +# exact rational linear algebra +def det(M): + n = len(M) + if n == 1: + return M[0][0] + if n == 2: + return M[0][0]*M[1][1]-M[0][1]*M[1][0] + total = F(0) + for j in range(n): + minor = [row[:j]+row[j+1:] for row in M[1:]] + total += (-1)**j*M[0][j]*det(minor) + return total + + +def adjugate(A): + n = len(A) + adj = [[F(0)]*n for _ in range(n)] + for i in range(n): + for j in range(n): + minor = [row[:j]+row[j+1:] for k, row in enumerate(A) if k != i] + adj[j][i] = (-1)**(i+j)*det(minor) if n > 1 else F(1) + return adj + + +def inertia(M): + """Number of negative eigenvalues of a symmetric rational matrix, exactly, by congruence diagonalisation + (Sylvester's law of inertia). Repeated eigenvalues are counted with multiplicity.""" + n = len(M) + A = [row[:] for row in M] + neg = 0 + for p in range(n): + # find a nonzero diagonal pivot at or after p; else create one by a congruence if an off-diagonal + # entry exists in the trailing block; else the trailing block is zero + piv = None + for i in range(p, n): + if A[i][i] != 0: + piv = i; break + if piv is None: + found = None + for i in range(p, n): + for j in range(i+1, n): + if A[i][j] != 0: + found = (i, j); break + if found: break + if found is None: + break + i, j = found + # congruence e_i -> e_i + e_j : A <- E^T A E with E = I + e_j e_i^T (row/col i += row/col j) + for k in range(n): + A[i][k] += A[j][k] + for k in range(n): + A[k][i] += A[k][j] + piv = i if A[i][i] != 0 else None + if piv is None: + raise RuntimeError('congruence failed to create a pivot') + if piv != p: + A[p], A[piv] = A[piv], A[p] + for row in A: + row[p], row[piv] = row[piv], row[p] + d = A[p][p] + if d < 0: + neg += 1 + for i in range(p+1, n): + f = A[i][p]/d + if f != 0: + for k in range(p, n): + A[i][k] -= f*A[p][k] + for k in range(p, n): + A[k][i] -= f*A[k][p] + return neg + + +def filtered_det(M, j): + d = det(M) + if d == 0: + return F(0) + return abs(d) if inertia(M) == j else F(0) + + +def frob2(M): + return sum(x*x for row in M for x in row) # squared Frobenius norm (exact) + + +def embed(alpha, beta, A, s): + n = len(A) + K = [[F(0)]*(n+1) for _ in range(n+1)] + K[0][0] = alpha + for i in range(n): + K[0][i+1] = s*beta[i]; K[i+1][0] = s*beta[i] + for j in range(n): + K[i+1][j+1] = A[i][j] + return K + + +def check_R7(mutant): + """det K_t identity and Lemma R3.2's bound on inertia-changing paths (t = s^2 with rational s).""" + A1 = [[F(-2), F(1, 2), F(0)], [F(1, 2), F(-1), F(1, 3)], [F(0), F(1, 3), F(-3, 2)]] # negative definite + A2 = [[F(-1), F(1, 2), F(0)], [F(1, 2), F(-2), F(0)], [F(0), F(0), F(0)]] # corank one, adj != 0 + A3 = [[F(-1), F(0), F(0), F(0)], [F(0), F(-1, 2), F(1, 4), F(0)], [F(0), F(1, 4), F(-1, 3), F(0)], [F(0), F(0), F(0), F(-2)]] + betas = [[F(1), F(-1), F(2)], [F(3, 2), F(0), F(1, 5)], [F(2), F(1), F(1), F(-1)]] + alphas = [F(-6), F(6), F(1, 100), F(-1, 100), F(0)] + n_id = 0; n_bound = 0; crossings = 0; singular_adj_nonzero = 0 + for A in (A1, A2, A3): + n = len(A) + adjA = adjugate(A); dA = det(A) + if dA == 0 and any(x != 0 for row in adjA for x in row): + singular_adj_nonzero += 1 + for beta in betas: + if len(beta) != n: + continue + q = sum(beta[i]*sum(adjA[i][j]*beta[j] for j in range(n)) for i in range(n)) # beta^T adj(A) beta + for alpha in alphas: + for s in (F(0), F(1, 3), F(1, 2), F(1), F(3, 2), F(2)): + t = s*s + lhs = det(embed(alpha, beta, A, s)); rhs = alpha*dA - t*q + if mutant == 'M2': + rhs = alpha*dA + t*q + if lhs != rhs: + return False, 'det K_t identity fails (alpha=%s, t=%s)' % (alpha, t) + n_id += 1 + for s in (F(1, 2), F(1), F(2)): + r = s*s + K0 = embed(alpha, beta, A, F(0)); Kr = embed(alpha, beta, A, s) + if det(K0) != 0 and det(Kr) != 0 and inertia(K0) != inertia(Kr): + crossings += 1 + for j in range(n+2): + diff = abs(filtered_det(Kr, j) - filtered_det(K0, j)) + if diff > r*abs(q): + return False, 'Lemma R3.2 bound fails at alpha=%s r=%s j=%s' % (alpha, r, j) + n_bound += 1 + if crossings == 0 or singular_adj_nonzero == 0: + return False, 'test set lacks inertia crossings or a corank-one block with nonzero adjugate' + return True, {'identities': n_id, 'bound_checks': n_bound, 'inertia_crossings_both_endpoints_nonsingular': crossings, + 'singular_blocks_with_nonzero_adjugate': singular_adj_nonzero} + + +def check_R6(mutant): + """Lemma R3.1 on rational symmetric pairs with an inertia change along the segment (Frobenius norms).""" + pairs = [ + ([[F(-1), F(0)], [F(0), F(-1)]], [[F(1), F(0)], [F(0), F(-1)]]), + ([[F(-2), F(1)], [F(1), F(-2)]], [[F(2), F(1)], [F(1), F(1, 2)]]), + ([[F(-1), F(1, 2), F(0)], [F(1, 2), F(-1), F(0)], [F(0), F(0), F(-3)]], + [[F(1), F(1, 2), F(1, 3)], [F(1, 2), F(-1), F(0)], [F(1, 3), F(0), F(2)]]), + ] + checks = 0; crossings = 0 + if inertia([[F(-1), F(0)], [F(0), F(-1)]]) != 2 or inertia([[F(1), F(0)], [F(0), F(-1)]]) != 1: + return False, 'inertia routine miscounts a repeated eigenvalue' + for X, Y in pairs: + n = len(X) + if inertia(X) != inertia(Y): + crossings += 1 + nx, ny = frob2(X), frob2(Y) + dXY = frob2([[X[i][j]-Y[i][j] for j in range(n)] for i in range(n)]) + bound2 = F(n*n)*max(nx, ny)**(n-1)*dXY # squared bound, exact + for j in range(n+1): + diff = abs(filtered_det(X, j) - filtered_det(Y, j)) + if mutant == 'M3': + diff = diff*10 + if diff*diff > bound2: + return False, 'Lemma R3.1 bound fails on pair with j=%s' % j + checks += 1 + if crossings != len(pairs): + return False, 'expected every pair to change inertia' + return True, {'checks': checks, 'inertia_crossings': crossings} + + +def check_reference_product(mutant): + k = F(1, 3) + mats = { + 'negdef': [[F(-1), F(1, 4)], [F(1, 4), F(-2)]], + 'indef': [[F(-1), F(0)], [F(0), F(1)]], + 'posdef': [[F(1), F(0)], [F(0), F(2)]], + } + for name, A0 in mats.items(): + m = len(A0); d = m+1 + DM = embed(-6*k, [F(0)]*m, A0, F(0)); DS = embed(6*k, [F(0)]*m, A0, F(0)) + prod = filtered_det(DM, d)*filtered_det(DS, d-1) + expected = (6*k)**2*det(A0)**2 if name == 'negdef' else F(0) + if mutant == 'M4' and name == 'indef': + expected = (6*k)**2*det(A0)**2 + if prod != expected: + return False, 'reference product mismatch on %s' % name + return True, {'inertia_patterns': 3} + + +def check_soft_integral(mutant): + D, E, U, dl, k = F(4, 3), F(3, 2), F(7, 2), F(1, 5), F(2, 3) + r = k*dl + X = D*dl*U*U + lhs = X**3/3 + E*r*U*X*X/2 # closed form of int_0^X lambda(lambda + E r U) + rhs = (D**3/3)*dl**3*U**6 + (E*D*D/2)*r*dl*dl*U**5 + if lhs != rhs: + return False, 'soft integral identity fails' + # (R15) with non-overlapping branches: D delta small so that 4 D delta T^2 < 1/(4 D delta) + D2, dl2 = F(4, 3), F(1, 100) + hyp_false = 0; grid = 0 + for T in (F(1), F(3, 2), F(2)): + lo, hi = 4*D2*dl2*T*T, 1/(4*D2*dl2) + if not lo < hi: + return False, 'branch overlap; grid uninformative' + for lam in [F(n, 20) for n in range(1, 400)]: + hyp = lam <= D2*dl2*(T+lam)**2 + if mutant == 'M5': + hyp = True + if hyp and not (lam <= lo or lam >= hi): + return False, '(R15) branch logic fails at T=%s lam=%s' % (T, lam) + hyp_false += (0 if hyp else 1); grid += 1 + if hyp_false == 0: + return False, 'the hypothesis never fails on the grid; check uninformative' + return True, {'identity': True, 'grid_points': grid, 'points_where_hypothesis_fails': hyp_false} + + +class Mono: + """Monomial ell^a k^b r0^c with exact rational exponents.""" + def __init__(self, a=F(0), b=F(0), c=F(0)): + self.a, self.b, self.c = F(a), F(b), F(c) + def __mul__(self, o): + return Mono(self.a+o.a, self.b+o.b, self.c+o.c) + def __pow__(self, e): + e = F(e); return Mono(self.a*e, self.b*e, self.c*e) + def key(self): + return (self.a, self.b, self.c) + + +def check_exponents(mutant): + ell, k, r0 = Mono(1, 0, 0), Mono(0, 1, 0), Mono(0, 0, 1) + r = (ell * k**(-1))**F(1, 3) + if mutant == 'M6': + r = (ell * k**(-1))**F(1, 2) + a = ell * r0**(-3) + eta = ell**F(1, 6) + claims = { + 'r k^(1/3)': ((r * k**F(1, 3)).key(), (F(1, 3), F(0), F(0))), + 'r^2 k^(-2/3)': (((r**2) * k**F(-2, 3)).key(), (F(2, 3), F(-4, 3), F(0))), + 'a^(7/3)': ((a**F(7, 3)).key(), (F(7, 3), F(0), F(-7))), + 'ell^(2/3) a^(-1/3)': (((ell**F(2, 3)) * a**F(-1, 3)).key(), (F(1, 3), F(0), F(1))), + 'eta^(7/3)': ((eta**F(7, 3)).key(), (F(7, 18), F(0), F(0))), + 'delta = r/k at k = eta': (((ell**F(1, 3)) * eta**F(-4, 3)).key(), (F(1, 9), F(0), F(0))), + 'ell eta^(-11/3)': ((ell * eta**F(-11, 3)).key(), (F(7, 18), F(0), F(0))), + 'delta^3 k^(-2/3) at general k': ((((ell**F(1, 3)) * k**F(-4, 3))**3 * k**F(-2, 3)).key(), (F(1), F(-14, 3), F(0))), + } + for name, (got, want) in claims.items(): + if got != want: + return False, 'monomial claim fails: %s got %s' % (name, got) + if not (F(7, 18) > F(1, 3) and F(1, 9) > 0): + return False, 'exponent comparison fails' + # antiderivatives evaluated exactly at ell = 10^-18, r_0 = 1/2 (a = 8e-18, a^(-1/3) = 10^6/2, eta = 10^-3). + # The fractional powers are written down and then BOUND to the cutoff values by exact cube identities, so a + # wrong value cannot pass; the antiderivatives are verified by exponent differentiation and by exact + # Riemann brackets, not by re-evaluating their own closed form. + L = F(1, 10**18); a_v = L*8; eta_v = F(1, 1000) + a_third = F(10**6, 2) # a^(-1/3) + if mutant == 'M7': + a_third = F(10**6) # a wrong a^(-1/3) must be caught by the cube identity + if (1/a_third)**3 != a_v: + return False, 'a^(-1/3) does not match the cutoff a = ell r_0^-3' + if eta_v**6 != L: + return False, 'eta^6 != ell' + # d/dk [-3 k^(-1/3)] = k^(-4/3) and d/dk [-(3/11) k^(-11/3)] = k^(-14/3): coefficient and exponent, exactly + for (cst, p, want_c, want_p) in ((F(-3), F(-1, 3), F(1), F(-4, 3)), (F(-3, 11), F(-11, 3), F(1), F(-14, 3))): + if cst*p != want_c or p - 1 != want_p: + return False, 'antiderivative differentiation fails for exponent %s' % p + int_a_1 = 3*a_third - 3 # F(1) - F(a) with F(k) = -3 k^(-1/3) + # exact Riemann bracket of int_a^1 k^(-4/3) dk on the geometric partition k_i = a q^(3i), q = 21/20, closed + # by [k_N, 1]: the integrand is decreasing, k_i^(-1/3) = a^(-1/3) q^(-i) is rational, so the lower and + # upper sums are exact rationals and must bracket the closed form (their ratio is at most q^4 < 1.22) + q = F(21, 20) + ks, invs = [a_v], [a_third] # k_i and k_i^(-1/3) + while ks[-1]*q**3 < 1: + ks.append(ks[-1]*q**3); invs.append(invs[-1]/q) + ks.append(F(1)); invs.append(F(1)) + lower = sum((ks[i+1]-ks[i])*invs[i+1]**4 for i in range(len(ks)-1)) + upper = sum((ks[i+1]-ks[i])*invs[i]**4 for i in range(len(ks)-1)) + if not (lower <= int_a_1 <= upper): + return False, 'Riemann bracket fails for int_a^1 k^(-4/3)' + if not (upper < q**4*lower): + return False, 'Riemann bracket is looser than expected' + cells_a = len(ks) - 1 + eta_m113 = F(10**11) # eta^(-11/3) at eta = 10^-3 + if eta_m113**3 != eta_v**(-11): + return False, 'eta^(-11/3) does not match eta' + # int_eta^oo k^(-14/3) dk = (3/11) eta^(-11/3): bracket the piece on [eta, 1] by the same partition and the + # tail on [1, oo) by the geometric partition q^(3i) summed as exact geometric series (no antiderivative used): + # (q^3 - 1) q^(-14) / (1 - q^(-11)) <= int_1^oo k^(-14/3) dk <= (q^3 - 1) / (1 - q^(-11)) + int_eta_inf = F(3, 11)*eta_m113 + ks, invs = [eta_v], [F(10)] # k_i and k_i^(-1/3) with eta^(-1/3) = 10 + if invs[0]**(-3) != eta_v: + return False, 'eta^(-1/3) does not match eta' + while ks[-1]*q**3 < 1: + ks.append(ks[-1]*q**3); invs.append(invs[-1]/q) + ks.append(F(1)); invs.append(F(1)) + tail_lower = (q**3 - 1)*q**(-14)/(1 - q**(-11)) + tail_upper = (q**3 - 1)/(1 - q**(-11)) + lower = sum((ks[i+1]-ks[i])*invs[i+1]**14 for i in range(len(ks)-1)) + tail_lower + upper = sum((ks[i+1]-ks[i])*invs[i]**14 for i in range(len(ks)-1)) + tail_upper + if not (lower <= int_eta_inf <= upper): + return False, 'Riemann bracket fails for int_eta^oo k^(-14/3)' + info = {name: [str(x) for x in got] for name, (got, want) in claims.items()} + info['riemann_cells'] = {'int_a^1': cells_a, 'int_eta^1': len(ks) - 1} + return True, info + + +def check_loss_split(mutant): + """Model check of S7's split with H = 1, r_0 = 1/2, exactly, at ell = 10^(-18 m).""" + ratios = {} + for m in (1, 2, 3, 4): + L = F(1, 10**(18*m)) + eta = F(1, 10**(3*m)) # ell^(1/6) + l13 = F(1, 10**(6*m)); l23 = F(1, 10**(12*m)) + a = 8*L # ell / r0^3, r0 = 1/2 + a_m13 = F(10**(6*m), 2) # a^(-1/3) + a_73 = F(128, 10**(42*m)) # a^(7/3) = 2^7 10^(-42 m) + eta_73 = F(1, 10**(7*m)); eta_m13 = F(10**m); eta_m113 = F(10**(11*m)) + # every fractional power above is bound to its base by an exact integer-power identity + if (eta**6 != L or l13**3 != L or l23**3 != L*L or a_m13**(-3) != a or a_73**3 != a**7 + or eta_73**3 != eta**7 or eta_m13**(-3) != eta or eta_m113**3 != eta**(-11)): + return False, 'a fractional power does not match its base at m=%d' % m + if not a < eta < 1: + return False, 'cutoff order a < eta < 1 fails' + piece1 = F(2, 7)*(eta_73 - a_73) + 2*l23*(a_m13 - eta_m13) + if mutant == 'M6': + piece1 = piece1 + l13 + piece2 = L*eta_m113/11 + ratio = (piece1 + piece2)/l13 + if ratio > F(3, 2): + return False, 'loss split ratio exceeds 3/2 at m=%d: %s' % (m, ratio) + ratios['ell=1e-%d' % (18*m)] = str(ratio.limit_denominator(10**9)) + return True, ratios + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument('--mutant', default=None) + args = ap.parse_args() + mutant = args.mutant + if mutant is not None and mutant not in ('M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7'): + sys.stderr.write('unknown mutant label\n'); sys.exit(2) + results = {} + ok_all = True + for name, fn in (('C1_axial_and_transverse_rows', check_rows), ('C2_R7_affine_determinant', check_R7), + ('C3_R6_filtered_determinant', check_R6), ('C4_reference_product', check_reference_product), + ('C5_soft_integral_and_R15', check_soft_integral), ('C6_exponent_ledger', check_exponents), + ('C7_loss_split_model', check_loss_split)): + ok, info = fn(mutant) + results[name] = {'passed': bool(ok), 'info': info} + ok_all = ok_all and ok + out = {'object': 'CL-D2-REMAINDER-FULLDEPTH-20260930-v1', 'scientific_effect': 'NONE', 'passed': ok_all, + 'checks': results} + print(json.dumps(out, indent=1, sort_keys=True)) + sys.exit(0 if ok_all else 1) + + +if __name__ == '__main__': + main()