From 37140e872e29c4c0e5a734078b8bd1299eb4ae49 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 5 Oct 2026 19:28:26 +0000 Subject: [PATCH 1/2] IBA1 item 2: exact-periodic contact-jet covariances and measured anisotropy Carries out item 2 of the first independent audit's remaining work (main#252, IBA-20261003-P1): exact-periodic derivative tensors and conditional-covariance Schur complements in several directions for d = 2, 3, 4, positivity, and an explicit anisotropy measurement, from image sums with a controlled tail, not an isotropic surrogate. Also evaluates P's (15.2) in d = 2 by directional quadrature. The SIDE24 kernel factorizes over coordinates, so every derivative tensor is the moment tensor of a spectral law with independent coordinates; moments come from cumulants k2, k4, k6. Results: positivity everywhere tested; at L = 24 the anisotropy is measured at about 4e-118 relative, twelve orders below side24_v1's periodization bound 1e-106, and c_{2,24} lies in side24_v1's published interval; at L = 4 the anisotropy is 31% and at L = 3 a factor 7. Smaller-L coefficients are diagnostics (floating decimal, 270 digits). Packet reviews/iba1_periodic_jet_claude_20261005 (NOTE, checker, RESULTS, SOURCE_FILES) and a replay workflow with pinned actions: manifest and main pins, byte-identical replay in -B -S and -B -O -S, mutants M1-M3 rejected. Scientific effect NONE. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .github/workflows/iba1-periodic-jet.yml | 66 +++ .../iba1_periodic_jet_claude_20261005/NOTE.md | 116 +++++ .../RESULTS.json | 191 ++++++++ .../SOURCE_FILES.json | 49 +++ .../periodic_jet_check.py | 413 ++++++++++++++++++ 5 files changed, 835 insertions(+) create mode 100644 .github/workflows/iba1-periodic-jet.yml create mode 100644 reviews/iba1_periodic_jet_claude_20261005/NOTE.md create mode 100644 reviews/iba1_periodic_jet_claude_20261005/RESULTS.json create mode 100644 reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json create mode 100644 reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py diff --git a/.github/workflows/iba1-periodic-jet.yml b/.github/workflows/iba1-periodic-jet.yml new file mode 100644 index 000000000..12b4e483f --- /dev/null +++ b/.github/workflows/iba1-periodic-jet.yml @@ -0,0 +1,66 @@ +name: IBA1 periodic jet (exact-periodic anisotropy replay) + +'on': + pull_request: + paths: + - 'reviews/iba1_periodic_jet_claude_20261005/**' + - '.github/workflows/iba1-periodic-jet.yml' + - 'coefficients/side24_v1/ENCLOSURE.json' + - 'coefficients/side24_v1/PROOF.md' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + workflow_dispatch: + +permissions: + contents: read + +jobs: + periodic-jet-replay: + runs-on: ubuntu-latest + timeout-minutes: 30 + strategy: + fail-fast: false + matrix: + flags: ['-B -S', '-B -O -S'] + name: periodic-jet-replay (${{ matrix.flags }}) + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify the manifest and main pins, replay the checker, reject the mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + FLAGS: ${{ matrix.flags }} + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, os, pathlib, subprocess, sys + root = pathlib.Path('reviews/iba1_periodic_jet_claude_20261005').resolve() + meta = json.loads((root / 'SOURCE_FILES.json').read_text()) + present = sorted(p.name for p in root.iterdir()) + if present != sorted([e['path'] for e in meta['files']] + ['SOURCE_FILES.json']): + raise ValueError('packet tree differs from manifest: ' + repr(present)) + def blob(data): + return hashlib.sha1(b'blob %d\0' % len(data) + data).hexdigest() + for entry in meta['files'] + meta['pins_on_main']: + path = pathlib.Path(entry['path']) if 'pins' in entry.get('kind', '') else root / entry['path'] + if path.is_symlink(): + raise ValueError('regular file required: ' + entry['path']) + data = path.read_bytes() + if blob(data) != entry['git_blob']: + raise ValueError('git blob mismatch: ' + entry['path']) + if 'sha256' in entry and (len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']): + raise ValueError('source identity mismatch: ' + entry['path']) + flags = os.environ['FLAGS'].split() + checker = str(root / 'periodic_jet_check.py') + run = subprocess.run([sys.executable] + flags + [checker], capture_output=True, cwd=root) + if run.returncode != 0 or run.stdout != (root / 'RESULTS.json').read_bytes(): + raise ValueError('replay differs from RESULTS.json') + for label, code in (('M1', 1), ('M2', 1), ('M3', 1), ('M9', 2)): + m = subprocess.run([sys.executable] + flags + [checker, '--mutant', label], capture_output=True, cwd=root) + if m.returncode != code: + raise ValueError('mutant %s exited %d, expected %d' % (label, m.returncode, code)) + print('periodic jet replay: manifest, pins, replay and mutants PASS') + PY diff --git a/reviews/iba1_periodic_jet_claude_20261005/NOTE.md b/reviews/iba1_periodic_jet_claude_20261005/NOTE.md new file mode 100644 index 000000000..845e91c7f --- /dev/null +++ b/reviews/iba1_periodic_jet_claude_20261005/NOTE.md @@ -0,0 +1,116 @@ +# Exact-periodic contact-jet covariances and measured anisotropy + +Object: `CL-IBA1-ITEM2-PERIODIC-JET-20261005-v1`. Author: Anthropic Claude, session `017Mi3hx…` (Dylan Roy — delegated AI work). +Scientific effect: **NONE**. No proof, status, register, catalog, PROOF_INDEX, GRAPH or `formal/` surface is touched. + +## Scope + +This packet carries out item 2 of "Remaining work and falsification experiments" in the first independent audit, +[main#252](https://github.com/d6g8k5htny-coder/main/issues/252) (IBA-20261003-P1): + +> Independently implement exact-periodic derivative tensors and conditional covariance Schur complements for several +> directions in d=2,3,4; check positivity and explicitly measure anisotropy. Use image sums or spectral sums with +> controlled tails, not an isotropic surrogate. + +It also evaluates P's coefficient formula (15.2) in `d = 2` by directional quadrature (part of item 3). At `L = 24` the value +is checked against the published enclosure of `coefficients/side24_v1`; at smaller `L` it is reported as a diagnostic. +The disposition map for the audit is [main#252 comment 6001303987](https://github.com/d6g8k5htny-coder/main/issues/252#issuecomment-6001303987). + +The field is P's: centred, variance one, with the exact normalized periodized covariance + + K_L(z) = sum_{n in Z^d} exp(-|z + L n|^2 / 2) / sum_{n in Z^d} exp(-|L n|^2 / 2). + +## Method + +1. **Product structure.** `exp(-|z|^2/2)` factorizes over coordinates, so the image sum does too: + `K_L(z) = prod_i q_L(z_i)` with `q_L(t) = theta_L(t)/theta_L(0)` and `theta_L(t) = sum_n exp(-(t + L n)^2/2)`. + Every derivative tensor of `K_L` at `0` is therefore the moment tensor of a spectral law with independent coordinates, + determined by `q2 = q_L''(0)`, `q4 = q_L''''(0)` and `q6 = q_L^(6)(0)`. No isotropy is assumed. +2. **Image sums with a controlled tail.** `theta_L^(j)(0) = sum_n He_j(L n) exp(-(L n)^2/2)` for `j = 0, 2, 4, 6`. + The sum is truncated once `(L n)^2/2` exceeds the working precision, and the two-sided tail is bounded by + `8 x^6 exp(-x^2/2)` at the first omitted node `x ≥ 10`. That bound is recorded per `L`, and is at most `5.1e-373`. +3. **Moments from cumulants.** With `m2 = -q2`, `m4 = q4`, `m6 = -q6`, the cumulants are `k2 = m2`, + `k4 = m4 - 3 m2^2` and `k6 = m6 - 15 m4 m2 + 30 m2^3`. Then `E[prod ]` is the sum over partitions into + even blocks: `k2 ` for a pair, and `k_{2j} sum_i prod v_{k,i}` for a block of size 4 or 6. Finally + `Cov(d_A f, d_B f) = (-1)^|B| (-1)^((|A|+|B|)/2) E[prod ]`. +4. **The contact jet in a frame `(u, w_1, …, w_m)`.** + - Odd block: `G = grad f` and `t_u = d_u^3 f`. + - Even block: `f`, `V_u = H u` and the transverse block `A_u`. + - Schur complements: `tau_u^2 = Var(t_u | G = 0)` and `Sigma_{A|V} = Cov(A_u | V_u = 0)`. + - Positivity: the Cholesky pivots of the odd block, the even block and `Sigma_{A|V}`. +5. **Anisotropy.** For `det Cov(G)`, `det Cov(V_u)`, `tau_u^2`, `det Sigma_{A|V}` and `tr Sigma_{A|V}`, take the largest + relative deviation over the tested directions from the value at `e_1`. The directions are: + - `d = 2`: 16 equally spaced; + - `d = 3`: 10 (the axes, the face and body diagonals, and three generic directions); + - `d = 4`: 8. + + These quantities do not depend on the choice of transverse frame. +6. **`d = 2` coefficient.** In (15.2), `A_u` is a centred scalar normal, so `D_u = Sigma_{A|V}/2`. The angular integral + uses the trapezoid rule, which converges geometrically for this smooth periodic integrand. + +Arithmetic: Python `decimal` at 270 significant digits. This is floating, not interval, arithmetic: see the limits below. + +## Results (`RESULTS.json`) + +| `L` | `k4/k2^2` | max relative anisotropy, `d = 2 / 3 / 4` | smallest Cholesky pivot | +|---|---|---|---| +| 24 | `5.6e-120` | `4.0e-118` / `4.7e-118` / `4.9e-118` | `1.0` | +| 8 | `1.0e-10` | `7.5e-10` / `8.8e-10` / `9.2e-10` | `1.0` | +| `2π` | `8.3e-6` | `3.5e-5` / `4.0e-5` / `4.2e-5` | `0.9999996` | +| 4 | `0.175` | `0.283` / `0.311` / `0.312` | `0.979` | +| 3 | `2.54` | `6.20` / `6.20` / `6.20` | `0.647` | + +`d = 2` coefficient (15.2): +- reference (nonperiodic contact covariance): `c_2 = 0.0734069193060342710301359629577740500177…`; +- `L = 24`: relative difference from the reference `-2.2e-118`, on 8 and on 16 directions. Both values lie inside + `side24_v1`'s published interval `(0.07340691930603427103, 0.07340691930603427104)`; +- smaller `L` (diagnostic; 256 and 512 directions agree to `< 1e-26`): `c_{2,L} / c_2` is `0.999999999615` at `L = 8`, + `0.999983180835` at `L = 2π`, `0.920467147230` at `L = 4` and `0.679492248662` at `L = 3`. + +## What this shows + +- Every conditional covariance is positive definite in every tested direction, at every tested `L`. This is consistent + with P §2's finite-jet rank, which holds for every `L > 0`. +- At `L = 24` the anisotropy is nonzero and measured, at about `4e-118` relative. That is about twelve orders of magnitude + below `side24_v1`'s periodization bound of `1e-106`, which it confirms independently. The isotropic reference value of + `c_{2,24}` is therefore correct far beyond its 20 published digits. +- At smaller `L` the anisotropy is material: 31% at `L = 4`, and a factor of about 7 in `tau_u^2` at `L = 3`. An isotropic + surrogate would be wrong there, as the audit warned; the mutant M1 shows it. + +## What this does not show + +- The arithmetic is floating `decimal`, not interval. The `L = 24` values are checked against the published enclosure, but + the smaller-`L` values are diagnostics, not certified enclosures. +- The anisotropy is a maximum over finitely many directions, so it is a lower bound on the supremum over the sphere. In + `d = 2` the 16 directions include the extremes `ψ = 0` and `ψ = π/4`. +- `d = 3, 4` coefficients are not evaluated: `D_u` for a non-scalar `A_u` needs a cone integral. +- Nothing here bears on the lifetime theorem itself; (15.2) is imported from P (blob `dfed3b8d`). + +## Checks and mutants + +`periodic_jet_check.py` asserts: +- **R1**: the nonperiodic reference reproduces `side24_v1` §1. That means `Cov G = I`, `det Cov V = 3`, `tau^2 = 6`, + `Sigma_{A|V} = 8/3` in `d = 2`, and trace `19/3` in `d = 3`. +- **R2**: positivity for every `L` and `d`. +- **R3**: the `L = 24` anisotropy lies in `(1e-130, 1e-106)`, and the `L = 4` anisotropy exceeds `1e-3`. +- **R4**: `c_{2,24}` lies in `side24_v1`'s interval and equals the reference to `1e-100`. +- **R5**: the small-`L` quadrature has settled to `1e-12` relative. + +The mutants must fail (exit 1): +- **M1**: an isotropic surrogate for the fourth- and sixth-order tensors (fails R3); +- **M2**: the transverse block not conditioned on `V = 0` (fails R1 and R4); +- **M3**: the (15.2) prefactor divided by 12 (fails R4). + +An unknown mutant label exits 2. + +Replay: `python3 -B -S periodic_jet_check.py` and `python3 -B -O -S periodic_jet_check.py` each print `RESULTS.json` +byte for byte, in about 30 seconds. + +## Provenance and independence + +The coefficient packet `coefficients/side24_v1` is by OpenAI / ChatGPT, and the audit is by OpenAI Codex. Earlier +nonauthor reviews of `side24_v1` are by xAI / Grok ([main#65 5841269490](https://github.com/d6g8k5htny-coder/main/issues/65#issuecomment-5841269490)) +and Anthropic Claude `01NMeK…` (`reviews/side24_v1_coefficient_claude_20260929`). This implementation was written from +P's (15.2) and the audit's item 2. It shares no code with `side24_v1` or its reviews, and it uses a different route: +product structure and cumulants instead of a density comparison. It is the same provider as the second review, and the +same GitHub account as every lane, so organizational-independence credit is 0. diff --git a/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json b/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json new file mode 100644 index 000000000..3e9a66cde --- /dev/null +++ b/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json @@ -0,0 +1,191 @@ +{ + "c_2": { + "L24_N16": "7.340691930603427103013596295777405001766e-2", + "L24_N8": "7.340691930603427103013596295777405001766e-2", + "L24_relative_to_reference": "-2.18234e-118", + "reference": "7.340691930603427103013596295777405001766e-2", + "side24_v1_interval": [ + "0.07340691930603427103", + "0.07340691930603427104" + ] + }, + "c_2_diagnostic_small_L": { + "2pi": { + "N256": "7.3405684662965293709e-2", + "N512": "7.3405684662965293709e-2", + "abs_diff": "2.00e-271", + "ratio_to_reference": "9.99983180835e-1" + }, + "3": { + "N256": "4.9879432666614182044e-2", + "N512": "4.9879432666614182044e-2", + "abs_diff": "6.98e-27", + "ratio_to_reference": "6.79492248662e-1" + }, + "4": { + "N256": "6.7568657600538789458e-2", + "N512": "6.7568657600538789458e-2", + "abs_diff": "3.31e-82", + "ratio_to_reference": "9.20467147230e-1" + }, + "8": { + "N256": "7.3406919277779905474e-2", + "N512": "7.3406919277779905474e-2", + "abs_diff": "2.30e-270", + "ratio_to_reference": "9.99999999615e-1" + } + }, + "cases": { + "24": { + "dims": { + "2": { + "directions": 16, + "max_relative_anisotropy": "3.96140e-118", + "min_cholesky_pivot": "1.0000000e+0" + }, + "3": { + "directions": 10, + "max_relative_anisotropy": "4.68882e-118", + "min_cholesky_pivot": "1.0000000e+0" + }, + "4": { + "directions": 8, + "max_relative_anisotropy": "4.94133e-118", + "min_cholesky_pivot": "1.0000000e+0" + } + }, + "k4_over_k2sq": "5.55986e-120", + "q2": "-1.000000000000000000000000e+0", + "q4": "3.000000000000000000000000e+0", + "q6": "-1.500000000000000000000000e+1", + "theta_tail_bound": "2.27e-1114" + }, + "2pi": { + "dims": { + "2": { + "directions": 16, + "max_relative_anisotropy": "3.48991e-5", + "min_cholesky_pivot": "9.9999958e-1" + }, + "3": { + "directions": 10, + "max_relative_anisotropy": "4.04352e-5", + "min_cholesky_pivot": "9.9999958e-1" + }, + "4": { + "directions": 8, + "max_relative_anisotropy": "4.20602e-5", + "min_cholesky_pivot": "9.9999958e-1" + } + }, + "k4_over_k2sq": "8.33912e-6", + "q2": "-9.999997887677280831117230e-1", + "q4": "3.000007071722210750769012e+0", + "q6": "-1.499978636618772598028085e+1", + "theta_tail_bound": "5.06e-410" + }, + "3": { + "dims": { + "2": { + "directions": 16, + "max_relative_anisotropy": "6.20350e+0", + "min_cholesky_pivot": "6.4703231e-1" + }, + "3": { + "directions": 10, + "max_relative_anisotropy": "6.20350e+0", + "min_cholesky_pivot": "6.4703231e-1" + }, + "4": { + "directions": 8, + "max_relative_anisotropy": "6.20350e+0", + "min_cholesky_pivot": "6.4703231e-1" + } + }, + "k4_over_k2sq": "2.54359e+0", + "q2": "-8.043831847582616279147440e-1", + "q4": "3.586879409292646013832026e+0", + "q6": "-1.675968243015139532969256e+1", + "theta_tail_bound": "3.93e-373" + }, + "4": { + "dims": { + "2": { + "directions": 16, + "max_relative_anisotropy": "2.83202e-1", + "min_cholesky_pivot": "9.7865987e-1" + }, + "3": { + "directions": 10, + "max_relative_anisotropy": "3.11011e-1", + "min_cholesky_pivot": "9.7865987e-1" + }, + "4": { + "directions": 8, + "max_relative_anisotropy": "3.12430e-1", + "min_cholesky_pivot": "9.7865987e-1" + } + }, + "k4_over_k2sq": "1.75032e-1", + "q2": "-9.892723933277496349347860e-1", + "q4": "3.107276066800260115010033e+0", + "q6": "-1.434561598793855754775891e+1", + "theta_tail_bound": "2.33e-410" + }, + "8": { + "dims": { + "2": { + "directions": 16, + "max_relative_anisotropy": "7.52150e-10", + "min_cholesky_pivot": "1.0000000e+0" + }, + "3": { + "directions": 10, + "max_relative_anisotropy": "8.79910e-10", + "min_cholesky_pivot": "1.0000000e+0" + }, + "4": { + "directions": 8, + "max_relative_anisotropy": "9.20735e-10", + "min_cholesky_pivot": "1.0000000e+0" + } + }, + "k4_over_k2sq": "1.03745e-10", + "q2": "-9.999999999983789868097160e-1", + "q4": "3.000000000094018765036473e+0", + "q6": "-1.499999999484355704170655e+1", + "theta_tail_bound": "4.82e-490" + } + }, + "checks": { + "R1_reference_d3_trace_shared": true, + "R1_reference_jet": true, + "R2_positive_L24_d2": true, + "R2_positive_L24_d3": true, + "R2_positive_L24_d4": true, + "R2_positive_L2pi_d2": true, + "R2_positive_L2pi_d3": true, + "R2_positive_L2pi_d4": true, + "R2_positive_L3_d2": true, + "R2_positive_L3_d3": true, + "R2_positive_L3_d4": true, + "R2_positive_L4_d2": true, + "R2_positive_L4_d3": true, + "R2_positive_L4_d4": true, + "R2_positive_L8_d2": true, + "R2_positive_L8_d3": true, + "R2_positive_L8_d4": true, + "R3_L24_anisotropy_measured": true, + "R3_L4_anisotropy_visible": true, + "R4_c224_equals_reference": true, + "R4_c224_in_side24_interval": true, + "R5_quadrature_settled_L2pi": true, + "R5_quadrature_settled_L3": true, + "R5_quadrature_settled_L4": true, + "R5_quadrature_settled_L8": true + }, + "object": "CL-IBA1-ITEM2-PERIODIC-JET-20261005-v1", + "passed": true, + "precision_digits": 270, + "scientific_effect": "NONE" +} diff --git a/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json b/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json new file mode 100644 index 000000000..947dd73a7 --- /dev/null +++ b/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json @@ -0,0 +1,49 @@ +{ + "schema": 1, + "object": "CL-IBA1-ITEM2-PERIODIC-JET-20261005-v1", + "scientific_effect": "NONE", + "author": { + "provider": "Anthropic / Claude", + "session": "017Mi3hx", + "attribution": "Dylan Roy - delegated AI work" + }, + "audit": "https://github.com/d6g8k5htny-coder/main/issues/252", + "audit_item": "Remaining work 2 (and part of 3)", + "files": [ + { + "path": "NOTE.md", + "bytes": 7705, + "sha256": "c9e44b8ea00e07e4db0954904c69b403d4ed5327aebbdef413d112467557111a", + "git_blob": "845e91c7f31f2668c943d28a9296fec501cac138" + }, + { + "path": "RESULTS.json", + "bytes": 5073, + "sha256": "f490077da285ee47922d65853584e206715b6faabc521dbc7d00ac3f905d5955", + "git_blob": "3e9a66cdeb968171566d6e5aa995d1f679bceb33" + }, + { + "path": "periodic_jet_check.py", + "bytes": 14232, + "sha256": "f3f7ce388cf0a4ffc2238534ac2ced5305c83833b7d6be6793f2b54f3b1c5a35", + "git_blob": "98012028ebf4c10581c1833341edae290855d6aa" + } + ], + "pins_on_main": [ + { + "path": "coefficients/side24_v1/ENCLOSURE.json", + "git_blob": "57af39a05e14ed0ba8ebc00a9b4aca4dffb067c7", + "kind": "pins_on_main" + }, + { + "path": "coefficients/side24_v1/PROOF.md", + "git_blob": "44b66f04f89fcd87383b3603fa69f1feb64cdddd", + "kind": "pins_on_main" + }, + { + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "kind": "pins_on_main" + } + ] +} diff --git a/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py b/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py new file mode 100644 index 000000000..98012028e --- /dev/null +++ b/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py @@ -0,0 +1,413 @@ +"""Exact-periodic contact-jet covariances for the SIDE24 family (main#252, IBA-20261003-P1, item 2). + +Standard library only. The field is centred, variance one, with covariance + + K_L(z) = prod_i q_L(z_i), q_L(t) = theta_L(t) / theta_L(0), + theta_L(t) = sum_{n in Z} exp(-(t + L n)^2 / 2), + +so every derivative tensor at 0 is a polynomial in q2 = q_L''(0), q4 = q_L''''(0), q6 = q_L^(6)(0). +With spectral moments m2 = -q2, m4 = q4, m6 = -q6 of one coordinate and cumulants +k2 = m2, k4 = m4 - 3 m2^2, k6 = m6 - 15 m4 m2 + 30 m2^3, the moment E[prod ] is the sum over +partitions into even blocks of k2 (pairs) and k_{2j} sum_i prod v_{k,i} (blocks of size 4, 6). +Cov(d_A f, d_B f) = (-1)^|B| (-1)^((|A|+|B|)/2) E[prod_{A+B} ] for |A|+|B| even, else 0. + +Usage: python3 -B -S periodic_jet_check.py [--mutant M1|M2|M3] +Normal run prints RESULTS.json and exits 0. A mutant must make a check fail (exit 1): + M1 isotropic surrogate for the fourth- and sixth-order tensors (q4 = 3 q2^2, q6 = -15 (-q2)^3); + M2 transverse Hessian block not conditioned on V = 0; + M3 prefactor of (15.2) divided by 12. +An unknown mutant label exits 2. +""" +import decimal +import fractions +import json +import sys +from decimal import Decimal as D + +PREC = 270 +decimal.getcontext().prec = PREC +MUTANT = None + + +def pi_dec(): + # Machin: pi = 16 atan(1/5) - 4 atan(1/239) + def atan_inv(x): + x = D(x) + x2 = x * x + term = D(1) / x + total = term + k = 1 + eps = D(10) ** (-(PREC + 5)) + while True: + term /= -x2 + add = term / (2 * k + 1) + if abs(add) < eps: + break + total += add + k += 1 + return total + return 16 * atan_inv(5) - 4 * atan_inv(239) + + +PI = pi_dec() + + +def cos_sin(theta): + theta = D(theta) + eps = D(10) ** (-(PREC + 5)) + c, s = D(1), theta + tc, ts = D(1), theta + k = 1 + while True: + tc = -tc * theta * theta / ((2 * k - 1) * (2 * k)) + ts = -ts * theta * theta / ((2 * k) * (2 * k + 1)) + if abs(tc) < eps and abs(ts) < eps: + break + c += tc + s += ts + k += 1 + return c, s + + +def he(j, x): + # probabilists' Hermite polynomials He_0, He_2, He_4, He_6 + x2 = x * x + return {0: D(1), 2: x2 - 1, 4: x2 * x2 - 6 * x2 + 3, 6: x2 ** 3 - 15 * x2 * x2 + 45 * x2 - 15}[j] + + +def q_derivatives(L): + """(q2, q4, q6, tail): image sums with a rigorous tail bound `tail` on every theta_j.""" + if L is None: + return D(-1), D(3), D(-15), D(0) + L = D(L) + target = D(PREC + 30) * D(10).ln() + N = 1 + while (L * N) ** 2 / 2 < target: + N += 1 + x = L * (N + 1) + assert x >= 10 + # for x >= 10: |He_j(x)| <= 2 x^j (j <= 6) and x^6 e^{-x^2/2} decreases with ratio <= 1/2 per + # step n -> n+1, so the two-sided tail is at most 2 * 2 * (2 x^6 e^{-x^2/2}). + tail = 8 * x ** 6 * (-(x * x) / 2).exp() + th = {} + for j in (0, 2, 4, 6): + s = he(j, D(0)) + for n in range(1, N + 1): + y = L * n + s += 2 * he(j, y) * (-(y * y) / 2).exp() + th[j] = s + q2, q4, q6 = th[2] / th[0], th[4] / th[0], th[6] / th[0] + if MUTANT == 'M1': + q4 = 3 * q2 * q2 # isotropic surrogate for the fourth-order tensor + q6 = -15 * (-q2) ** 3 # and for the sixth-order tensor + return q2, q4, q6, tail + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + + +def even_partitions(items): + if not items: + yield [] + return + first, rest = items[0], items[1:] + n = len(rest) + for size in (1, 3, 5): + if size > n: + break + for combo in _combinations(range(n), size): + block = [first] + [rest[i] for i in combo] + remaining = [rest[i] for i in range(n) if i not in combo] + for p in even_partitions(remaining): + yield [block] + p + + +def _combinations(seq, r): + seq = list(seq) + if r == 0: + yield () + return + for i in range(len(seq)): + for tail in _combinations(seq[i + 1:], r - 1): + yield (seq[i],) + tail + + +def moment(vs, k): + """E[prod ] for the product spectral law with cumulants k = {2: k2, 4: k4, 6: k6}.""" + if len(vs) % 2: + return D(0) + total = D(0) + for part in even_partitions(list(range(len(vs)))): + term = D(1) + for block in part: + if len(block) == 2: + term *= k[2] * dot(vs[block[0]], vs[block[1]]) + else: + s = D(0) + for i in range(len(vs[0])): + pr = D(1) + for b in block: + pr *= vs[b][i] + s += pr + term *= k[len(block)] * s + if term == 0: + break + total += term + return total + + +def cov(A, B, k): + p, q = len(A), len(B) + if (p + q) % 2: + return D(0) + sign = (-1) ** q * (-1) ** ((p + q) // 2) + return sign * moment(list(A) + list(B), k) + + +def cholesky_pivots(M): + n = len(M) + Lm = [[D(0)] * n for _ in range(n)] + piv = [] + for i in range(n): + for j in range(i + 1): + s = M[i][j] - sum(Lm[i][t] * Lm[j][t] for t in range(j)) + if i == j: + piv.append(s) + if s <= 0: + return piv, None + Lm[i][i] = s.sqrt() + else: + Lm[i][j] = s / Lm[j][j] + return piv, Lm + + +def det_pd(M): + piv, Lm = cholesky_pivots(M) + assert Lm is not None, 'not positive definite' + out = D(1) + for p in piv: + out *= p + return out + + +def solve(M, b): + n = len(M) + a = [row[:] + [b[i]] for i, row in enumerate(M)] + for c in range(n): + piv = max(range(c, n), key=lambda r: abs(a[r][c])) + a[c], a[piv] = a[piv], a[c] + for r in range(n): + if r != c: + f = a[r][c] / a[c][c] + a[r] = [x - f * y for x, y in zip(a[r], a[c])] + return [a[i][n] / a[i][i] for i in range(n)] + + +def schur(Saa, Sav, Svv): + # Saa - Sav Svv^{-1} Sva + cols = [solve(Svv, [Sav[i][j] for j in range(len(Svv))]) for i in range(len(Saa))] + return [[Saa[i][j] - dot(Sav[i], cols[j]) for j in range(len(Saa))] for i in range(len(Saa))] + + +def frame(u): + d = len(u) + basis = [u] + for e in range(d): + v = [D(1) if i == e else D(0) for i in range(d)] + for b in basis: + c = dot(v, b) + v = [x - c * y for x, y in zip(v, b)] + nv = dot(v, v) + if nv > D('1e-20'): + nn = nv.sqrt() + basis.append([x / nn for x in v]) + if len(basis) == d: + break + return basis + + +def normalize(v): + v = [D(x) for x in v] + n = dot(v, v).sqrt() + return [x / n for x in v] + + +def jet_data(u, k): + fr = frame(u) + w = fr[1:] + m = len(w) + G = [[x] for x in fr] + t = [u, u, u] + V = [[u, u]] + [[u, wj] for wj in w] + A = [[w[i], w[j]] for i in range(m) for j in range(i, m)] + S_GG = [[cov(a, b, k) for b in G] for a in G] + c_tG = [cov(t, b, k) for b in G] + var_t = cov(t, t, k) + tau2 = var_t - dot(c_tG, solve(S_GG, c_tG)) + S_VV = [[cov(a, b, k) for b in V] for a in V] + S_AA = [[cov(a, b, k) for b in A] for a in A] + S_AV = [[cov(a, b, k) for b in V] for a in A] + S_AgV = schur(S_AA, S_AV, S_VV) + if MUTANT == 'M2': + S_AgV = S_AA # transverse block not conditioned on V = 0 + even = [[]] + V + A + odd = G + [t] + S_even = [[cov(a, b, k) for b in even] for a in even] + S_odd = [[cov(a, b, k) for b in odd] for a in odd] + pe, _ = cholesky_pivots(S_even) + po, _ = cholesky_pivots(S_odd) + pa, _ = cholesky_pivots(S_AgV) + return { + 'det_G': det_pd(S_GG), 'det_V': det_pd(S_VV), 'tau2': tau2, + 'det_AgV': det_pd(S_AgV), 'tr_AgV': sum(S_AgV[i][i] for i in range(len(S_AgV))), + 'S_AgV': S_AgV, 'min_pivot': min(pe + po + pa), + } + + +def directions(d): + if d == 2: + out = [] + for j in range(16): + c, s = cos_sin(2 * PI * j / 16) + out.append([c, s]) + return out + raw = { + 3: [(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1), + (1, 2, 3), (3, -1, 2), (2, 5, -7)], + 4: [(1, 0, 0, 0), (0, 0, 0, 1), (1, 1, 0, 0), (1, 1, 1, 0), (1, 1, 1, 1), + (1, 2, 3, 4), (4, -3, 2, -1), (2, 7, -1, 5)], + }[d] + return [normalize(v) for v in raw] + + +def fmt(x, digits=25): + return format(x, '.%de' % (digits - 1)) if x != 0 else '0' + + +def stirling_gamma(z): + # Gamma(z) for real z > 0 by shifting to z + S and the Stirling series with Bernoulli terms. + S = 200 + B = bernoulli(60) + zz = z + S + lng = (zz - D('0.5')) * zz.ln() - zz + (2 * PI).ln() / 2 + for n in range(1, 31): + b = B[2 * n] + lng += D(b.numerator) / D(b.denominator) / (2 * n * (2 * n - 1) * zz ** (2 * n - 1)) + g = lng.exp() + for i in range(S): + g /= (z + i) + return g + + +def bernoulli(n): + A = [fractions.Fraction(0)] * (n + 1) + Bs = [] + for m in range(n + 1): + A[m] = fractions.Fraction(1, m + 1) + for j in range(m, 0, -1): + A[j - 1] = j * (A[j - 1] - A[j]) + Bs.append(A[0]) + return Bs + + +def coefficient_d2(k, N): + """(15.2) for d = 2 by the trapezoid rule on N equally spaced directions.""" + pref = stirling_gamma(D(7) / 6) / (D(24) ** (D(1) / 3) * PI.sqrt()) + if MUTANT == 'M3': + pref = pref / 12 # a lost factor 12 in the gamma/Jacobian prefactor + total = D(0) + for j in range(N): + c, s = cos_sin(2 * PI * j / N) + jd = jet_data([c, s], k) + pG = 1 / (2 * PI * jd['det_G'].sqrt()) + pV = 1 / (2 * PI * jd['det_V'].sqrt()) + Du = jd['S_AgV'][0][0] / 2 + total += pG * pV * jd['tau2'] ** (D(2) / 3) * Du + return pref * total * (2 * PI / N) + + +def main(): + global MUTANT + if len(sys.argv) == 3 and sys.argv[1] == '--mutant': + if sys.argv[2] not in ('M1', 'M2', 'M3'): + print('unknown mutant'); sys.exit(2) + MUTANT = sys.argv[2] + elif len(sys.argv) != 1: + print(__doc__); sys.exit(2) + + checks = {} + out = {'object': 'CL-IBA1-ITEM2-PERIODIC-JET-20261005-v1', 'precision_digits': PREC, + 'scientific_effect': 'NONE', 'cases': {}} + + # R1: the nonperiodic reference reproduces the published reference jet (side24_v1 section 1). + q2, q4, q6, _ = q_derivatives(None) + kref = {2: -q2, 4: q4 - 3 * q2 * q2, 6: -q6 - 15 * q4 * (-q2) + 30 * (-q2) ** 3} + jr = jet_data([D(1), D(0)], kref) + checks['R1_reference_jet'] = (jr['det_G'] == 1 and jr['det_V'] == 3 and jr['tau2'] == 6 + and abs(jr['S_AgV'][0][0] - D(8) / 3) < D('1e-250')) + jr3 = jet_data(normalize((1, 2, 3)), kref) + checks['R1_reference_d3_trace_shared'] = abs(jr3['tr_AgV'] - D(19) / 3) < D('1e-250') + + Ls = [('24', D(24)), ('8', D(8)), ('2pi', 2 * PI), ('4', D(4)), ('3', D(3))] + aniso = {} + for name, L in Ls: + q2, q4, q6, tail = q_derivatives(L) + m2, m4, m6 = -q2, q4, -q6 + k = {2: m2, 4: m4 - 3 * m2 * m2, 6: m6 - 15 * m4 * m2 + 30 * m2 ** 3} + case = {'q2': fmt(q2), 'q4': fmt(q4), 'q6': fmt(q6), 'theta_tail_bound': fmt(tail, 3), + 'k4_over_k2sq': fmt(k[4] / (k[2] * k[2]), 6), 'dims': {}} + for d in (2, 3, 4): + dirs = directions(d) + data = [jet_data(u, k) for u in dirs] + minpiv = min(x['min_pivot'] for x in data) + dev = D(0) + for key in ('det_G', 'det_V', 'tau2', 'det_AgV', 'tr_AgV'): + vals = [x[key] for x in data] + base = vals[0] + dev = max(dev, max(abs(v / base - 1) for v in vals)) + case['dims'][str(d)] = {'directions': len(dirs), 'min_cholesky_pivot': fmt(minpiv, 8), + 'max_relative_anisotropy': fmt(dev, 6)} + checks['R2_positive_L%s_d%d' % (name, d)] = minpiv > 0 + aniso[(name, d)] = dev + out['cases'][name] = case + + # R3: anisotropy at L = 24 is nonzero but far below side24_v1's periodization bound 1e-106; + # at L = 4 it is of order one-tenth and must be seen (an isotropic surrogate is rejected). + checks['R3_L24_anisotropy_measured'] = all(D('1e-130') < aniso[('24', d)] < D('1e-106') for d in (2, 3, 4)) + checks['R3_L4_anisotropy_visible'] = all(aniso[('4', d)] > D('1e-3') for d in (2, 3, 4)) + + # R4: c_{2,24} by directional quadrature lies in side24_v1's published interval and equals the + # reference closed form to far below that interval's width. + q2, q4, q6, _ = q_derivatives(D(24)) + m2, m4, m6 = -q2, q4, -q6 + k24 = {2: m2, 4: m4 - 3 * m2 * m2, 6: m6 - 15 * m4 * m2 + 30 * m2 ** 3} + c24_8 = coefficient_d2(k24, 8) + c24_16 = coefficient_d2(k24, 16) + lo, hi = D('0.07340691930603427103'), D('0.07340691930603427104') + cref = coefficient_d2(kref, 4) + checks['R4_c224_in_side24_interval'] = lo < c24_8 < hi and lo < c24_16 < hi + checks['R4_c224_equals_reference'] = abs(c24_16 / cref - 1) < D('1e-100') + out['c_2'] = {'reference': fmt(cref, 40), 'L24_N8': fmt(c24_8, 40), 'L24_N16': fmt(c24_16, 40), + 'L24_relative_to_reference': fmt(c24_16 / cref - 1, 6), + 'side24_v1_interval': [str(lo), str(hi)]} + + # R5 (diagnostic): c_{2,L} for smaller L, trapezoid on 256 and 512 directions. + diag = {} + for name, L in Ls[1:]: + q2, q4, q6, _ = q_derivatives(L) + m2, m4, m6 = -q2, q4, -q6 + kk = {2: m2, 4: m4 - 3 * m2 * m2, 6: m6 - 15 * m4 * m2 + 30 * m2 ** 3} + a, b = coefficient_d2(kk, 256), coefficient_d2(kk, 512) + diag[name] = {'N256': fmt(a, 20), 'N512': fmt(b, 20), 'abs_diff': fmt(abs(a - b), 3), + 'ratio_to_reference': fmt(b / cref, 12)} + checks['R5_quadrature_settled_L%s' % name] = abs(a - b) < D('1e-12') * b + out['c_2_diagnostic_small_L'] = diag + out['checks'] = {key: bool(v) for key, v in sorted(checks.items())} + out['passed'] = all(checks.values()) + print(json.dumps(out, indent=1, sort_keys=True)) + sys.exit(0 if out['passed'] else 1) + + +if __name__ == '__main__': + main() From d8be92076dae46f9504d279b286da0432d01e088 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 5 Oct 2026 19:49:51 +0000 Subject: [PATCH 2/2] IBA1 item 2 r2: Frobenius trace of the transverse block (AMEND PJ-A-001) Applies the slice (a) amendment PJ-A-001 on Math-#297 (OpenAI / GPT-6 Astra Pro, comment 6001649072; also found by the slice (b) read, Grok Bot agent 16, 6001648683): the raw upper-triangle sum of conditional variances of A_u is not a transverse-frame invariant for d >= 3. - tr Sigma_{A|V} is now the Frobenius trace (off-diagonal variances count twice); R1's d = 3 reference changes from 19/3 to 22/3. - New check R6: at u = e_1, L = 4, a transverse rotation by (3/5, 4/5) leaves all five invariants unchanged in d = 3, 4 (<= 1e-268). - New mutant M4 (raw trace) fails R1 and R6; workflow expects exit 1. - NOTE: invariance sentence corrected; text nits from the slice (b) and (c) reads (tail figure 3.93e-373, "consistent with", Gamma accuracy ~1e-108, R4's equality is internal); revision history. No reported number changes: tau_u^2 drives every anisotropy maximum. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .github/workflows/iba1-periodic-jet.yml | 2 +- .../iba1_periodic_jet_claude_20261005/NOTE.md | 42 ++++++++++++++--- .../RESULTS.json | 12 +++-- .../SOURCE_FILES.json | 18 +++---- .../periodic_jet_check.py | 47 +++++++++++++++---- 5 files changed, 93 insertions(+), 28 deletions(-) diff --git a/.github/workflows/iba1-periodic-jet.yml b/.github/workflows/iba1-periodic-jet.yml index 12b4e483f..1a9f1b3be 100644 --- a/.github/workflows/iba1-periodic-jet.yml +++ b/.github/workflows/iba1-periodic-jet.yml @@ -58,7 +58,7 @@ jobs: run = subprocess.run([sys.executable] + flags + [checker], capture_output=True, cwd=root) if run.returncode != 0 or run.stdout != (root / 'RESULTS.json').read_bytes(): raise ValueError('replay differs from RESULTS.json') - for label, code in (('M1', 1), ('M2', 1), ('M3', 1), ('M9', 2)): + for label, code in (('M1', 1), ('M2', 1), ('M3', 1), ('M4', 1), ('M9', 2)): m = subprocess.run([sys.executable] + flags + [checker, '--mutant', label], capture_output=True, cwd=root) if m.returncode != code: raise ValueError('mutant %s exited %d, expected %d' % (label, m.returncode, code)) diff --git a/reviews/iba1_periodic_jet_claude_20261005/NOTE.md b/reviews/iba1_periodic_jet_claude_20261005/NOTE.md index 845e91c7f..e36e341f4 100644 --- a/reviews/iba1_periodic_jet_claude_20261005/NOTE.md +++ b/reviews/iba1_periodic_jet_claude_20261005/NOTE.md @@ -28,7 +28,7 @@ The field is P's: centred, variance one, with the exact normalized periodized co determined by `q2 = q_L''(0)`, `q4 = q_L''''(0)` and `q6 = q_L^(6)(0)`. No isotropy is assumed. 2. **Image sums with a controlled tail.** `theta_L^(j)(0) = sum_n He_j(L n) exp(-(L n)^2/2)` for `j = 0, 2, 4, 6`. The sum is truncated once `(L n)^2/2` exceeds the working precision, and the two-sided tail is bounded by - `8 x^6 exp(-x^2/2)` at the first omitted node `x ≥ 10`. That bound is recorded per `L`, and is at most `5.1e-373`. + `8 x^6 exp(-x^2/2)` at the first omitted node `x ≥ 10`. That bound is recorded per `L`, and is at most `3.93e-373` (at `L = 3`). 3. **Moments from cumulants.** With `m2 = -q2`, `m4 = q4`, `m6 = -q6`, the cumulants are `k2 = m2`, `k4 = m4 - 3 m2^2` and `k6 = m6 - 15 m4 m2 + 30 m2^3`. Then `E[prod ]` is the sum over partitions into even blocks: `k2 ` for a pair, and `k_{2j} sum_i prod v_{k,i}` for a block of size 4 or 6. Finally @@ -39,12 +39,15 @@ The field is P's: centred, variance one, with the exact normalized periodized co - Schur complements: `tau_u^2 = Var(t_u | G = 0)` and `Sigma_{A|V} = Cov(A_u | V_u = 0)`. - Positivity: the Cholesky pivots of the odd block, the even block and `Sigma_{A|V}`. 5. **Anisotropy.** For `det Cov(G)`, `det Cov(V_u)`, `tau_u^2`, `det Sigma_{A|V}` and `tr Sigma_{A|V}`, take the largest - relative deviation over the tested directions from the value at `e_1`. The directions are: + relative deviation over the tested directions from the value at `e_1`. Here `tr` is the Frobenius trace of the + conditional covariance of `A_u` as a symmetric matrix: the diagonal variances plus twice the off-diagonal ones. The directions are: - `d = 2`: 16 equally spaced; - `d = 3`: 10 (the axes, the face and body diagonals, and three generic directions); - `d = 4`: 8. - These quantities do not depend on the choice of transverse frame. + These quantities do not depend on the choice of transverse frame. Check R6 verifies this at fixed `u`. The raw + upper-triangle sum of variances, used in the first revision, is frame-dependent for `d ≥ 3` (finding PJ-A-001, + below). 6. **`d = 2` coefficient.** In (15.2), `A_u` is a centred scalar normal, so `D_u = Sigma_{A|V}/2`. The angular integral uses the trapezoid rule, which converges geometrically for this smooth periodic integrand. @@ -72,8 +75,9 @@ Arithmetic: Python `decimal` at 270 significant digits. This is floating, not in - Every conditional covariance is positive definite in every tested direction, at every tested `L`. This is consistent with P §2's finite-jet rank, which holds for every `L > 0`. - At `L = 24` the anisotropy is nonzero and measured, at about `4e-118` relative. That is about twelve orders of magnitude - below `side24_v1`'s periodization bound of `1e-106`, which it confirms independently. The isotropic reference value of - `c_{2,24}` is therefore correct far beyond its 20 published digits. + below `side24_v1`'s periodization bound of `1e-106`, and consistent with it. This is a floating-point consistency + check, not an independent proof of that bound. The isotropic reference value of `c_{2,24}` agrees far beyond its 20 + published digits. - At smaller `L` the anisotropy is material: 31% at `L = 4`, and a factor of about 7 in `tau_u^2` at `L = 3`. An isotropic surrogate would be wrong there, as the audit warned; the mutant M1 shows it. @@ -84,22 +88,28 @@ Arithmetic: Python `decimal` at 270 significant digits. This is floating, not in - The anisotropy is a maximum over finitely many directions, so it is a lower bound on the supremum over the sphere. In `d = 2` the 16 directions include the extremes `ψ = 0` and `ψ = π/4`. - `d = 3, 4` coefficients are not evaluated: `D_u` for a non-scalar `A_u` needs a cone integral. +- `Γ(7/6)` comes from a Stirling series with shift 200 and is accurate to about `1e-108` relative, not to the full 270 + digits. That accuracy is ample for every stated number, since the prefactor cancels in every ratio. R4's `1e-100` + equality compares two outputs of the same code; the external anchors are `side24_v1`'s interval and its closed form. - Nothing here bears on the lifetime theorem itself; (15.2) is imported from P (blob `dfed3b8d`). ## Checks and mutants `periodic_jet_check.py` asserts: - **R1**: the nonperiodic reference reproduces `side24_v1` §1. That means `Cov G = I`, `det Cov V = 3`, `tau^2 = 6`, - `Sigma_{A|V} = 8/3` in `d = 2`, and trace `19/3` in `d = 3`. + `Sigma_{A|V} = 8/3` in `d = 2`, and Frobenius trace `8/3 + 8/3 + 2·1 = 22/3` in `d = 3`. - **R2**: positivity for every `L` and `d`. - **R3**: the `L = 24` anisotropy lies in `(1e-130, 1e-106)`, and the `L = 4` anisotropy exceeds `1e-3`. - **R4**: `c_{2,24}` lies in `side24_v1`'s interval and equals the reference to `1e-100`. - **R5**: the small-`L` quadrature has settled to `1e-12` relative. +- **R6**: at `u = e_1` and `L = 4`, rotating the transverse frame by `(cos, sin) = (3/5, 4/5)` changes none of the five + invariants (`d = 3, 4`; changes `≤ 1e-268`). The mutants must fail (exit 1): - **M1**: an isotropic surrogate for the fourth- and sixth-order tensors (fails R3); - **M2**: the transverse block not conditioned on `V = 0` (fails R1 and R4); -- **M3**: the (15.2) prefactor divided by 12 (fails R4). +- **M3**: the (15.2) prefactor divided by 12 (fails R4); +- **M4**: the raw upper-triangle trace (fails R1 and R6). An unknown mutant label exits 2. @@ -114,3 +124,21 @@ and Anthropic Claude `01NMeK…` (`reviews/side24_v1_coefficient_claude_20260929 P's (15.2) and the audit's item 2. It shares no code with `side24_v1` or its reviews, and it uses a different route: product structure and cumulants instead of a density comparison. It is the same provider as the second review, and the same GitHub account as every lane, so organizational-independence credit is 0. + +## Revision history + +- **r1** (`37140e8`): first revision. +- **r2**: the amendment PJ-A-001 from the slice (a) read (OpenAI / GPT-6 Astra Pro, + [Math-#297 6001649072](https://github.com/d6g8k5htny-coder/Math-/pull/297#issuecomment-6001649072)), also found by the + slice (b) read (Grok Bot agent 16, [6001648683](https://github.com/d6g8k5htny-coder/Math-/pull/297#issuecomment-6001648683)). + - The trace of the transverse block is now the Frobenius trace. + - R1's `d = 3` reference changes from `19/3` (raw) to `22/3`. + - The new check R6 and mutant M4 guard the frame invariance. + + The same revision carries text nits from the slice (b) and (c) reads: + - the tail figure is `3.93e-373`; + - "confirms" becomes "consistent with"; + - the accuracy of `Γ` and the internal nature of R4's equality are stated (agent 15, + [6001651974](https://github.com/d6g8k5htny-coder/Math-/pull/297#issuecomment-6001651974)). + + No reported number changes. `tau_u^2` drives every anisotropy maximum, as both readers noted. diff --git a/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json b/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json index 3e9a66cde..c1e5849cb 100644 --- a/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json +++ b/reviews/iba1_periodic_jet_claude_20261005/RESULTS.json @@ -158,7 +158,7 @@ } }, "checks": { - "R1_reference_d3_trace_shared": true, + "R1_reference_d3_trace_frobenius": true, "R1_reference_jet": true, "R2_positive_L24_d2": true, "R2_positive_L24_d3": true, @@ -182,10 +182,16 @@ "R5_quadrature_settled_L2pi": true, "R5_quadrature_settled_L3": true, "R5_quadrature_settled_L4": true, - "R5_quadrature_settled_L8": true + "R5_quadrature_settled_L8": true, + "R6_transverse_frame_invariance_d3": true, + "R6_transverse_frame_invariance_d4": true }, "object": "CL-IBA1-ITEM2-PERIODIC-JET-20261005-v1", "passed": true, "precision_digits": 270, - "scientific_effect": "NONE" + "scientific_effect": "NONE", + "transverse_rotation_max_abs_change_L4": { + "3": "3.00e-269", + "4": "1.00e-268" + } } diff --git a/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json b/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json index 947dd73a7..175cdac2c 100644 --- a/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json +++ b/reviews/iba1_periodic_jet_claude_20261005/SOURCE_FILES.json @@ -12,21 +12,21 @@ "files": [ { "path": "NOTE.md", - "bytes": 7705, - "sha256": "c9e44b8ea00e07e4db0954904c69b403d4ed5327aebbdef413d112467557111a", - "git_blob": "845e91c7f31f2668c943d28a9296fec501cac138" + "bytes": 9737, + "sha256": "4c2535ebfc3c494b3fcb9327b7336730ca46420c780173809166eb95908685ef", + "git_blob": "e36e341f4f7b2781ef3bbcb0df8580ac17f85f8b" }, { "path": "RESULTS.json", - "bytes": 5073, - "sha256": "f490077da285ee47922d65853584e206715b6faabc521dbc7d00ac3f905d5955", - "git_blob": "3e9a66cdeb968171566d6e5aa995d1f679bceb33" + "bytes": 5253, + "sha256": "4dbf00f768486dbd3079463699b62ca461d4bf94ead398ce19671769467124f5", + "git_blob": "c1e5849cb198c1dbd965cc04806642800ec5a012" }, { "path": "periodic_jet_check.py", - "bytes": 14232, - "sha256": "f3f7ce388cf0a4ffc2238534ac2ced5305c83833b7d6be6793f2b54f3b1c5a35", - "git_blob": "98012028ebf4c10581c1833341edae290855d6aa" + "bytes": 15870, + "sha256": "59b53e5c2e8fdcacc9983f705b9d301fcfcf9242ac6c4d8b7bfbcf0ada7caf9f", + "git_blob": "a2beeeee90abfc2988cf8f491d54ea835b23a1c5" } ], "pins_on_main": [ diff --git a/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py b/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py index 98012028e..a2beeeee9 100644 --- a/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py +++ b/reviews/iba1_periodic_jet_claude_20261005/periodic_jet_check.py @@ -11,11 +11,12 @@ partitions into even blocks of k2 (pairs) and k_{2j} sum_i prod v_{k,i} (blocks of size 4, 6). Cov(d_A f, d_B f) = (-1)^|B| (-1)^((|A|+|B|)/2) E[prod_{A+B} ] for |A|+|B| even, else 0. -Usage: python3 -B -S periodic_jet_check.py [--mutant M1|M2|M3] +Usage: python3 -B -S periodic_jet_check.py [--mutant M1|M2|M3|M4] Normal run prints RESULTS.json and exits 0. A mutant must make a check fail (exit 1): M1 isotropic surrogate for the fourth- and sixth-order tensors (q4 = 3 q2^2, q6 = -15 (-q2)^3); M2 transverse Hessian block not conditioned on V = 0; - M3 prefactor of (15.2) divided by 12. + M3 prefactor of (15.2) divided by 12; + M4 raw upper-triangle trace of the transverse block (frame-dependent; finding PJ-A-001). An unknown mutant label exits 2. """ import decimal @@ -210,6 +211,15 @@ def schur(Saa, Sav, Svv): return [[Saa[i][j] - dot(Sav[i], cols[j]) for j in range(len(Saa))] for i in range(len(Saa))] +def frobenius_trace(S, idx): + # trace of the conditional covariance of A as a symmetric matrix (Frobenius inner product): an + # off-diagonal entry counts twice, so the value does not depend on the transverse frame; the raw + # upper-triangle sum would (main#252 / Math-#297 finding PJ-A-001) + if MUTANT == 'M4': + return sum(S[a][a] for a in range(len(idx))) # raw upper-triangle trace + return sum(S[a][a] * (1 if i == j else 2) for a, (i, j) in enumerate(idx)) + + def frame(u): d = len(u) basis = [u] @@ -233,14 +243,17 @@ def normalize(v): return [x / n for x in v] -def jet_data(u, k): +def jet_data(u, k, w=None): fr = frame(u) - w = fr[1:] + if w is None: + w = fr[1:] + fr = [u] + list(w) m = len(w) G = [[x] for x in fr] t = [u, u, u] V = [[u, u]] + [[u, wj] for wj in w] - A = [[w[i], w[j]] for i in range(m) for j in range(i, m)] + idx = [(i, j) for i in range(m) for j in range(i, m)] + A = [[w[i], w[j]] for i, j in idx] S_GG = [[cov(a, b, k) for b in G] for a in G] c_tG = [cov(t, b, k) for b in G] var_t = cov(t, t, k) @@ -260,7 +273,7 @@ def jet_data(u, k): pa, _ = cholesky_pivots(S_AgV) return { 'det_G': det_pd(S_GG), 'det_V': det_pd(S_VV), 'tau2': tau2, - 'det_AgV': det_pd(S_AgV), 'tr_AgV': sum(S_AgV[i][i] for i in range(len(S_AgV))), + 'det_AgV': det_pd(S_AgV), 'tr_AgV': frobenius_trace(S_AgV, idx), 'S_AgV': S_AgV, 'min_pivot': min(pe + po + pa), } @@ -330,7 +343,7 @@ def coefficient_d2(k, N): def main(): global MUTANT if len(sys.argv) == 3 and sys.argv[1] == '--mutant': - if sys.argv[2] not in ('M1', 'M2', 'M3'): + if sys.argv[2] not in ('M1', 'M2', 'M3', 'M4'): print('unknown mutant'); sys.exit(2) MUTANT = sys.argv[2] elif len(sys.argv) != 1: @@ -347,7 +360,7 @@ def main(): checks['R1_reference_jet'] = (jr['det_G'] == 1 and jr['det_V'] == 3 and jr['tau2'] == 6 and abs(jr['S_AgV'][0][0] - D(8) / 3) < D('1e-250')) jr3 = jet_data(normalize((1, 2, 3)), kref) - checks['R1_reference_d3_trace_shared'] = abs(jr3['tr_AgV'] - D(19) / 3) < D('1e-250') + checks['R1_reference_d3_trace_frobenius'] = abs(jr3['tr_AgV'] - D(22) / 3) < D('1e-250') Ls = [('24', D(24)), ('8', D(8)), ('2pi', 2 * PI), ('4', D(4)), ('3', D(3))] aniso = {} @@ -377,6 +390,24 @@ def main(): checks['R3_L24_anisotropy_measured'] = all(D('1e-130') < aniso[('24', d)] < D('1e-106') for d in (2, 3, 4)) checks['R3_L4_anisotropy_visible'] = all(aniso[('4', d)] > D('1e-3') for d in (2, 3, 4)) + # R6: at fixed u = e_1, rotating the transverse frame by (cos, sin) = (3/5, 4/5) leaves every invariant + # unchanged (L = 4, d = 3 and d = 4), including the Frobenius trace. + q2, q4, q6, _ = q_derivatives(D(4)) + m2, m4, m6 = -q2, q4, -q6 + k4L = {2: m2, 4: m4 - 3 * m2 * m2, 6: m6 - 15 * m4 * m2 + 30 * m2 ** 3} + rot = {} + for d in (3, 4): + u = [D(1)] + [D(0)] * (d - 1) + base = jet_data(u, k4L) + e = [[D(1) if i == j else D(0) for i in range(d)] for j in range(1, d)] + cs, sn = D(3) / 5, D(4) / 5 + w = [[cs * a - sn * b for a, b in zip(e[0], e[1])], [sn * a + cs * b for a, b in zip(e[0], e[1])]] + e[2:] + turned = jet_data(u, k4L, w) + dev = max(abs(turned[key] - base[key]) for key in ('det_G', 'det_V', 'tau2', 'det_AgV', 'tr_AgV')) + rot[str(d)] = fmt(dev, 3) + checks['R6_transverse_frame_invariance_d%d' % d] = dev < D('1e-250') + out['transverse_rotation_max_abs_change_L4'] = rot + # R4: c_{2,24} by directional quadrature lies in side24_v1's published interval and equals the # reference closed form to far below that interval's width. q2, q4, q6, _ = q_derivatives(D(24))