From d535999efcaca676433988d6231c674a17c810ab Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 29 Sep 2026 12:59:38 +0000 Subject: [PATCH] review record: nonauthor review of #135 SARD-G slice R3/R4 (scientific effect NONE) Anthropic/Claude nonauthor analytic review of OA-SARD-ROBUST-CHARTS-20260929-v1 sections 7-8 (PROOF.md blob 7e223706, head ee94b063). ACCEPT R3 (dense point-evaluation covariance images, independent Gaussian residual, nonvanishing direction given A3-A4) and R4 (Borel regular-zero sets, countable regular zeros per shift line, Tonelli null, completed-measure conclusion), conditional as stated on A2-T via R2, A2-D and A3-A4. R1/R2 not reviewed (Harper's slice). N1: single point evaluations suffice for (R3d). Exact finite illustration checker (3 mutants). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .github/workflows/sard-g-r3r4-review.yml | 59 +++++++++ .../sard_g_r3r4_claude_20260929/RESULTS.json | 13 ++ reviews/sard_g_r3r4_claude_20260929/REVIEW.md | 78 +++++++++++ .../SOURCE_FILES.json | 38 ++++++ .../r3r4_review_check.py | 122 ++++++++++++++++++ 5 files changed, 310 insertions(+) create mode 100644 .github/workflows/sard-g-r3r4-review.yml create mode 100644 reviews/sard_g_r3r4_claude_20260929/RESULTS.json create mode 100644 reviews/sard_g_r3r4_claude_20260929/REVIEW.md create mode 100644 reviews/sard_g_r3r4_claude_20260929/SOURCE_FILES.json create mode 100644 reviews/sard_g_r3r4_claude_20260929/r3r4_review_check.py diff --git a/.github/workflows/sard-g-r3r4-review.yml b/.github/workflows/sard-g-r3r4-review.yml new file mode 100644 index 000000000..77c81e099 --- /dev/null +++ b/.github/workflows/sard-g-r3r4-review.yml @@ -0,0 +1,59 @@ +name: SARD-G R3-R4 nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/sard_g_r3r4_claude_20260929/**' + - '.github/workflows/sard-g-r3r4-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/sard_g_r3r4_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 / 'r3r4_review_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['wrong-residual', 'keep-degenerate', 'span-deficient'] + 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/reviews/sard_g_r3r4_claude_20260929/RESULTS.json b/reviews/sard_g_r3r4_claude_20260929/RESULTS.json new file mode 100644 index 000000000..280eb9df1 --- /dev/null +++ b/reviews/sard_g_r3r4_claude_20260929/RESULTS.json @@ -0,0 +1,13 @@ +{ + "checks": { + "R3a_rkhs_identity": true, + "R3c_residual_uncorrelated": true, + "degenerate_direction_removed": true, + "fewer_points_rank_deficient_control": true, + "regular_zeros_have_nonzero_derivative": true, + "span_of_point_evaluation_images_is_full": true + }, + "object": "CLAUDE-REVIEW-SARD-G-R3R4-20260929-v1", + "passed": true, + "scope": "exact finite illustrations only; not the Banach-space proof" +} diff --git a/reviews/sard_g_r3r4_claude_20260929/REVIEW.md b/reviews/sard_g_r3r4_claude_20260929/REVIEW.md new file mode 100644 index 000000000..8c6fd343e --- /dev/null +++ b/reviews/sard_g_r3r4_claude_20260929/REVIEW.md @@ -0,0 +1,78 @@ +# Nonauthor analytic review: SARD-G robust charts, slice R3/R4 (Math-#135) + +Scientific effect: **NONE**. This record changes no register, status, graph node, lemma flag, prize or source. It +reviews slice R3/R4 only. R1/R2 is xAI/Harper's slice. Integration is a separate act. + +## Object and exposure + +| Field | Value | +|---|---| +| Object | OA-SARD-ROBUST-CHARTS-20260929-v1 (OpenAI / ChatGPT), sections 7–8 and claims R3–R4 | +| Head | `ee94b06368c29bceca80662698b4b4d6ee81ec91` ([Math-#135](https://github.com/d6g8k5htny-coder/Math-/pull/135)); `PROOF.md` blob `7e2237063a8dd0120e9d5bd15a3caaa32e8495fa`, 25022 B, SHA256 `b91b9f792c6322204a0f2a573b2ca76d5c951e49ddd7caa6ffd1abed0aa79e79` | +| Request / pickup | [5890713526](https://github.com/d6g8k5htny-coder/Math-/pull/135#issuecomment-5890713526) / [5890766663](https://github.com/d6g8k5htny-coder/Math-/pull/135#issuecomment-5890766663) | +| Reviewer | Anthropic Claude, session `session_017Mi3hxjaxV45x6zo6o1ee3`. I have no authorship of, and no prior review of, SG (`research/q0/sard_g/`, main `a1fc9581`), BR (OpenAI/Codex, main `f43f243`) or RI (xAI/Harper). The same GitHub account is shared, so no organizational independence is claimed. | +| Own checks | `r3r4_review_check.py`: exact finite illustrations, 3 mutants, identical under `-O`. | + +## Verdicts + +| Claim | Verdict | +|---|---| +| **R3** (§7): point-evaluation covariance images are dense in `H`; the normalized rational family; standard `ξ_ℓ`; the independent residual (R3b)–(R3c); a nonvanishing direction (R3d) given the A3–A4 premise | **ACCEPT** | +| **R4** (§8): `B_{χ,ℓ}` is Borel; open validity sets; countable regular zeros on each shift line; Tonelli gives `μ(B_{χ,ℓ}) = 0`; the covering inclusion; the completed-measure conclusion given `μ(Ω_gen) = 1` | **ACCEPT**, conditional exactly as stated on A2-T (through R2), A2-D and A3–A4 | +| A2-T, A2-D, A3–A4, `μ(Ω_gen) = 1`; the R1/R2 geometry | Not reviewed; these are imports or another slice. R4 uses them only as stated. | + +No defect was found. + +## Re-derivations + +**R3.** +- *Density.* For `h ∈ H` and `ℓ ∈ X*`, `⟨h, Qℓ⟩_H = ℓ(h)`. If `h ⊥ Qℓ_n` for every `n`, then `h` vanishes on the + dense set `S`. Since `H ↪ C²`, `h` is continuous, so `h = 0`, and the span of `{k_n}` is dense. +- *Normalization.* `v_ℓ = ℓ(Qℓ) = ‖Qℓ‖_H²`, so `v_ℓ = 0` exactly when `Qℓ = 0`; those `ℓ` are removed. Then + `‖h_ℓ‖_H = 1` and `ξ_ℓ ~ N(0, 1)`. +- *Residual.* `Cov(a(f), ξ_ℓ) = a(Qℓ)/√v_ℓ = a(h_ℓ)`, so `Cov(a(g_ℓ), ξ_ℓ) = 0` for every `a ∈ X*`. The pair + `(g_ℓ, ξ_ℓ)` is a continuous linear image of `f` in the separable space `X × ℝ`, hence jointly Gaussian. Its + characteristic functional factorizes, and that functional determines Borel laws on a separable Banach space. So + the pair is independent. The derivative-evaluation remark in the note is a valid alternative, not needed. +- *(R3d).* `D_χ'(f)` lies in `X*` by A2-D, and its restriction to `H` is continuous. If that restriction is nonzero, + it cannot vanish on a set with dense span. + +**R4.** +- *Borel.* `B_{χ,ℓ}` is Borel because `U_χ^rob` is open (R2, under A2-T) and both `D_χ` and + `f ↦ D_χ'(f)[h_ℓ]` are continuous there (A2-D). +- *Shift lines.* `I_g` is open, because `t ↦ g + th_ℓ` is continuous into `X`. On it, `F_g` is `C¹` with + `F_g' = D_χ'(g + th_ℓ)[h_ℓ]`. Zeros with `F_g' ≠ 0` are isolated, so they form a countable set, even where + singular zeros or the ends of the intervals accumulate. +- *Tonelli.* The set `{(g, t): g + th_ℓ ∈ B}` is the preimage of a Borel set under a continuous map. By + independence and Tonelli, `μ(B) = ∫ N(0,1)({t: g + th_ℓ ∈ B}) dP_{g_ℓ}(g) = 0`. +- *Countable union.* Both index sets `χ` and `ℓ` are countable. +- *Conclusion.* The covering inclusion follows from (R2b) and (R3d). Outer measure zero means null in the completion, + and with `μ(Ω_gen) = 1` the conclusion follows. No shift line is assumed generic. + +The finite checker (in exact rationals, on a trigonometric circle field, at dense Pythagorean points +`x_m = mθ` with `cos θ = 3/5`) exhibits: +- the reproducing identity; +- full span once there are `2K + 1` points, and rank deficiency with fewer; +- the uncorrelated residual; +- removal of a degenerate direction; +- a regular zero versus a singular zero. + +It illustrates the proof; it does not replace the Banach-space argument. + +## Notes + +- **N1 (simplification).** Single point evaluations already suffice for (R3d). Since the span of `{Qℓ_n}` is dense, + a nonzero continuous functional on `H` is nonzero on some `k_n = Qℓ_n`. For the variance-one field, + `v_{ℓ_n} = 1`, so no removal is needed. Rational combinations and density in the unit sphere are valid but not + required. +- **N2 (dependency).** R4's Borel step uses the openness of `U_χ^rob`, which is part of R2 and rests on A2-T and + R1. The R4 conclusion is therefore also conditional on the outcome of the R1/R2 slice, not only on A2-D and A3–A4. + The note's §1 dependency statement says this; the verdict here does not discharge R1/R2. +- **N3.** The note correctly avoids any claim that a whole shift line is Morse. Only regular zeros inside the open + validity intervals are counted. + +## Reproduce + + python -B -S r3r4_review_check.py # prints RESULTS.json byte for byte + python -B -O -S r3r4_review_check.py # identical + python -B -S r3r4_review_check.py --mutant M # exit 1 for each of the 3 mutants diff --git a/reviews/sard_g_r3r4_claude_20260929/SOURCE_FILES.json b/reviews/sard_g_r3r4_claude_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..b183cd42a --- /dev/null +++ b/reviews/sard_g_r3r4_claude_20260929/SOURCE_FILES.json @@ -0,0 +1,38 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW", + "slice": "R3/R4", + "reviewed_object": { + "pr": "d6g8k5htny-coder/Math-#135", + "head": "ee94b06368c29bceca80662698b4b4d6ee81ec91", + "paths": [ + { + "path": "frontiers/sard_g_robust_charts_20260929/PROOF.md", + "git_blob": "7e2237063a8dd0120e9d5bd15a3caaa32e8495fa", + "bytes": 25022, + "sha256": "b91b9f792c6322204a0f2a573b2ca76d5c951e49ddd7caa6ffd1abed0aa79e79" + } + ] + }, + "files": [ + { + "path": "REVIEW.md", + "bytes": 5538, + "sha256": "72f1107d7a42bb53ff8dcfc53d1ebab5fc34b98b57eaaace773b97c4a4d7349b", + "git_blob": "8c6fd343e876c911df060be67d9d5c97028a46a8" + }, + { + "path": "RESULTS.json", + "bytes": 431, + "sha256": "f0b1a94edcc9a956cb9ce98776d40cc8c0917b59bdff2cc23743f124200b2e59", + "git_blob": "280eb9df1a9d3a0a5e8a89867a387041fe14ee66" + }, + { + "path": "r3r4_review_check.py", + "bytes": 5206, + "sha256": "81679a5d25ed9f888369cfb3d8a47d79400512270032cbcc2b1e060dfdc1d641", + "git_blob": "25873d3c7438a42b1173553298512937c1a11f9f" + } + ] +} diff --git a/reviews/sard_g_r3r4_claude_20260929/r3r4_review_check.py b/reviews/sard_g_r3r4_claude_20260929/r3r4_review_check.py new file mode 100644 index 000000000..25873d3c7 --- /dev/null +++ b/reviews/sard_g_r3r4_claude_20260929/r3r4_review_check.py @@ -0,0 +1,122 @@ +"""Independent nonauthor finite checks for OA-SARD-ROBUST-CHARTS-20260929-v1 slice R3/R4 (Math-#135). Exact rationals. + +MODEL a trigonometric Gaussian field on the circle with modes 0..K and positive rational weights, in coefficient + coordinates (covariance Sigma = diag(w)); point evaluations at x_m = m*theta with cos(theta) = 3/5, so every + cos(k x_m), sin(k x_m) is rational (Chebyshev recursion) and {x_m} is dense (theta/pi irrational). +RKHS (R3a) _H = l(h) for h = Sigma a, with _H = a^T Sigma b. +SPAN the images Sigma l_{x_m} span the Cameron-Martin space (rank 2K+1) once m runs over 2K+1 points; fewer points + are rank-deficient (control). Single point evaluations already suffice (note N1). +RESIDUAL (R3b)-(R3c) unnormalized: xi = l(f), h = Sigma l / v, g = f - xi h gives Cov(a(g), xi) = 0 for all a + (checked on a basis); a degenerate l (v = 0) in a singular model must be removed. +ZEROS (R4) a C1 function with accumulating singular zeros: regular zeros are isolated, hence countable; exact + model F(t) = t^2 sin-free polynomial surrogate with a double zero and simple zeros. +Mutants (each must fail): wrong-residual, keep-degenerate, span-deficient. +""" +import argparse +import json +import sys +from fractions import Fraction as F + +MUTANTS = ("wrong-residual", "keep-degenerate", "span-deficient") +MUT = None +K = 3 +W = [F(1)] + [F(1, 2 ** k) for k in range(1, K + 1) for _ in (0, 1)] # weights for 1, cos x, sin x, cos 2x, ... + + +def trig(c, s, kmax): + """cos(kx), sin(kx) for k = 0..kmax from cos x = c, sin x = s (exact).""" + cs, ss = [F(1)], [F(0)] + for _ in range(kmax): + cs.append(cs[-1] * c - ss[-1] * s) + ss.append(ss[-1] * c + cs[-2] * s) + return cs, ss + + +def point_eval(m): + c, s = F(1), F(0) + for _ in range(m): # x_m = m theta, cos theta = 3/5, sin theta = 4/5 + c, s = c * F(3, 5) - s * F(4, 5), s * F(3, 5) + c * F(4, 5) + cs, ss = trig(c, s, K) + vec = [F(1)] + for k in range(1, K + 1): + vec += [cs[k], ss[k]] + return vec + + +def rank(rows): + M = [list(r) for r in rows] + rk = 0 + for col in range(len(M[0]) if M else 0): + p = next((i for i in range(rk, len(M)) if M[i][col] != 0), None) + if p is None: + continue + M[rk], M[p] = M[p], M[rk] + for i in range(len(M)): + if i != rk and M[i][col] != 0: + f = M[i][col] / M[rk][col] + M[i] = [x - f * y for x, y in zip(M[i], M[rk])] + rk += 1 + return rk + + +def sig(v, w=W): + return [wi * vi for wi, vi in zip(w, v)] + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + + +def check(): + out = {} + n = 2 * K + 1 + # RKHS identity: _H = a^T Sigma l = l(Sigma a) + ok = True + for m in range(4): + l = point_eval(m) + for a in ([F(1)] + [F(0)] * (n - 1), [F(j + 1, 3) for j in range(n)]): + h = sig(a) + ok &= dot(a, sig(l)) == dot(l, h) + out["R3a_rkhs_identity"] = ok + npts = n - 1 if MUT == "span-deficient" else n + imgs = [sig(point_eval(m)) for m in range(npts)] + out["span_of_point_evaluation_images_is_full"] = rank(imgs) == n + out["fewer_points_rank_deficient_control"] = rank([sig(point_eval(m)) for m in range(n - 1)]) < n + # residual: xi = l(f), h = Sigma l / v, g = f - xi h; Cov(a(g), xi) = a^T Sigma l - (a^T h) v = 0 + ok = True + for m in range(1, 4): + l = point_eval(m) + v = dot(l, sig(l)) + h = [x / v for x in sig(l)] if MUT != "wrong-residual" else sig(l) + for j in range(n): + a = [F(int(i == j)) for i in range(n)] + ok &= dot(a, sig(l)) - dot(a, h) * v == 0 + out["R3c_residual_uncorrelated"] = ok + # degenerate direction in a singular model (last weight zero): l supported on that mode has v = 0 and is removed + Ws = W[:-1] + [F(0)] + l_deg = [F(0)] * (n - 1) + [F(1)] + v_deg = dot(l_deg, sig(l_deg, Ws)) + kept = [l for l in (point_eval(1), l_deg) if dot(l, sig(l, Ws)) != 0 or MUT == "keep-degenerate"] + out["degenerate_direction_removed"] = v_deg == 0 and all(dot(l, sig(l, Ws)) != 0 for l in kept) + # (R4) isolated regular zeros: F(t) = t^2 (t - 1)(t + 2): simple zeros at 1, -2 have F' != 0, the double zero at 0 + # has F'(0) = 0; F is C1 and the regular zeros are isolated, hence countable + Fp = lambda t: 4 * t ** 3 + 3 * t ** 2 - 4 * t # derivative of t^4 + t^3 - 2 t^2 + Fv = lambda t: t ** 4 + t ** 3 - 2 * t ** 2 + out["regular_zeros_have_nonzero_derivative"] = all(Fv(t) == 0 and Fp(t) != 0 for t in (F(1), F(-2))) and Fp(F(0)) == 0 + return out + + +def main(): + global MUT + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + MUT = ap.parse_args().mutant + checks = check() + passed = all(checks.values()) + print(json.dumps({"object": "CLAUDE-REVIEW-SARD-G-R3R4-20260929-v1", "checks": checks, "passed": passed, + "scope": "exact finite illustrations only; not the Banach-space proof"}, indent=2, sort_keys=True)) + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main())