From d5c8570d47ba49844f296e4ec9b47c0416d2ee9a Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 23:57:36 +0000 Subject: [PATCH 1/3] review record: nonauthor review of #125 elder lower event in every fixed dimension (scientific effect NONE) Anthropic nonauthor analytic review of OA-ELDER-DIMENSION-LIFT-20260928-v1 at exact head e3f10b3 (PROOF.md blob 7303bd79, SHA256 b529fe37). Verdict: ACCEPT at the stated existential scope for Theorem A (A2)-(A4) in every fixed d >= 3; Corollaries B (A5), (A6) and C (A6a) accepted as compositions with LP Theorem A (reconciled in #126) and LP's compact-mark ledger. No defect found. Independent stdlib checker (written from the markdown): exact dual-number Jacobian of the raw chart, end-to-end physical cubic fields in d = 3, 4, 5, quartic O(r) remainder rates, a labelled float saddle-persistence group, and 9 rejected mutants; output identical in -O. Dependency exposure disclosed. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../workflows/elder-dimension-lift-review.yml | 61 ++ .../RESULTS.json | 81 ++ .../REVIEW.md | 198 ++++ .../SOURCE_FILES.json | 37 + .../dimension_lift_review_check.py | 872 ++++++++++++++++++ 5 files changed, 1249 insertions(+) create mode 100644 .github/workflows/elder-dimension-lift-review.yml create mode 100644 reviews/elder_dimension_lift_claude_20260928/RESULTS.json create mode 100644 reviews/elder_dimension_lift_claude_20260928/REVIEW.md create mode 100644 reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json create mode 100644 reviews/elder_dimension_lift_claude_20260928/dimension_lift_review_check.py diff --git a/.github/workflows/elder-dimension-lift-review.yml b/.github/workflows/elder-dimension-lift-review.yml new file mode 100644 index 000000000..6a708cba4 --- /dev/null +++ b/.github/workflows/elder-dimension-lift-review.yml @@ -0,0 +1,61 @@ +name: Elder dimension-lift nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/elder_dimension_lift_claude_20260928/**' + - '.github/workflows/elder-dimension-lift-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/elder_dimension_lift_claude_20260928').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 / 'dimension_lift_review_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['raw-a-in-plane', 'shear-sign', 'drop-transverse-pin-term', + 'no-cross-schur', 'planar-point-is-critical', 'stable-scale-r', + 'density-dr', 'threshold-two-thirds', 'weight-2d'] + 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/elder_dimension_lift_claude_20260928/RESULTS.json b/reviews/elder_dimension_lift_claude_20260928/RESULTS.json new file mode 100644 index 000000000..59e62fdcd --- /dev/null +++ b/reviews/elder_dimension_lift_claude_20260928/RESULTS.json @@ -0,0 +1,81 @@ +{ + "checks": { + "CHART": { + "raw_chart_full_jacobian_is_one_d3_d4": true, + "rotated_lattice_unisolvence_degree3": true, + "schur_shear_cancels_and_det_A_equals_sigma_det_D_n1to4": true + }, + "LEDGER": { + "density_loss_ell_2_3_k_minus_5_3": true, + "inverse_moment_threshold_5_3": true, + "jet_count_U0_plus_J_is_binom_d3_3": true, + "ledger_r_r4_over_r2_is_r3_all_d": true + }, + "PATH": { + "path_segments_margins_and_saddle_data": true + }, + "PHYSICAL": { + "Hu_order_r": true, + "endpoint_blocks_A20": true, + "gradient_pin_average_A24": true, + "normal_form_A17_exact": true, + "pins": true, + "schur_det_inertia_A21_A22": true, + "shear_recovers_sigma_D_tau": true, + "weight_order_r4": true + }, + "QUARTIC": { + "A17_remainder_halves_with_r": true, + "Hu_halves_with_r": true, + "_rates": { + "A17_remainder": { + "3": [ + 2.0, + 2.0, + 2.0 + ], + "4": [ + 2.0, + 2.0, + 2.0 + ] + }, + "H_S_u": { + "3": [ + 1.9944, + 1.9972, + 1.9986 + ], + "4": [ + 2.0023, + 2.0011, + 2.0006 + ] + } + }, + "contact_frame_nonsingular": true, + "pins_exact_after_solve": true + }, + "SADDLES": { + "_ratios": { + "3": [ + 1.1962, + 1.1312 + ], + "4": [ + 1.0019, + 1.6157 + ] + }, + "distinct_from_each_other_and_pins": true, + "heights_inside_window": true, + "index_d_minus_1": true, + "planar_critical_point_not_full_critical": true, + "stable_displacement_W_converges_at_rate_r": true, + "two_extra_critical_points_exist": true + } + }, + "object": "CLAUDE-REVIEW-ELDER-DIMENSION-LIFT-20260928-v1", + "passed": true, + "scope": "exact chart/field identities and one labelled numerical saddle group; not an analytic proof" +} diff --git a/reviews/elder_dimension_lift_claude_20260928/REVIEW.md b/reviews/elder_dimension_lift_claude_20260928/REVIEW.md new file mode 100644 index 000000000..e5984338e --- /dev/null +++ b/reviews/elder_dimension_lift_claude_20260928/REVIEW.md @@ -0,0 +1,198 @@ +# Nonauthor analytic review: the elder lower event in every fixed dimension (Math-#125) + +Scientific effect: **NONE**. This file does not change `lemma_closed`, prizes, premises, `STATUS`, `PROOF_INDEX`, +`GRAPH`, landing claims or any author source. It records verdicts on the OpenAI candidate below. Integration is a +separate act. + +## Object + +| Field | Value | +|---|---| +| Object | OA-ELDER-DIMENSION-LIFT-20260928-v1 (OpenAI / ChatGPT) | +| Branch / head | `chatgpt/elder-dimension-lift-20260928` / `e3f10b390ae5ddd998d238206add5958d5b720bb` ([Math-#125](https://github.com/d6g8k5htny-coder/Math-/pull/125)), base `d39dbbc` | +| `PROOF.md` | Git blob `7303bd791a68a1139251f0f6e403a9f7cc89b006`, 23971 B, SHA256 `b529fe3780e1909014b3cb144b9a74156d976bbdc19b6711d0c5b1a1da9e5669`, 480 lines | +| Consumed, already on main | [LP] `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md` (blob `dfed3b8d…`): §1 selector, §§2–4 spectrum, contact frame and regression, §8 maximin; Theorem A and §§9–12 for the corollaries only. [EL] `frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md` (blob `aaefc8da…`): the planar cubic, path and d = 2 case. [LOCAL] `LOCAL_MULTIPLICITY.md` (blob `b5c18aac…`): planar saddle data. | + +## Provenance + +| Field | Value | +|---|---| +| Reviewer | Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3` | +| Relation | Different provider from the OpenAI author. Same GitHub account as every lane, so no organizational independence is claimed. | +| Exposure | I read `PROOF.md` in full, plus the packet README, SOURCE_MAP, RECONNAISSANCE, `lift.py`, `test_lift.py` and `verify.py`. I wrote the nonauthor review of [EL]/[LOCAL] (`reviews/d1_elder_lower_claude_20260928/`), the #106 review of LP Theorem A, and the D1 chain reconciliation (Math-#126, merged at `8224783`). Corollary B's upper half consumes LP Theorem A, whose reconciliation I authored, so for that half this review is **not** independent of its inputs. The direct lower Theorem A (A2)–(A4) consumes none of those objects except [EL]'s unchanged planar cubic and path, which this review re-derives. | +| Independent derivation | Before seeing #125 I had planned a d ≥ 3 lower proof by a nonlinear ridge reduction `y = φ(x, z)` in the stable directions. Its reduced midpoint Hessian is the same Schur complement `σ = f_zz − f_zw f_ww⁻¹ f_wz`. #125's linear shear reaches the same rare set with less machinery (N3), so I review #125 instead of writing a competing candidate. | +| Author code | I ran `verify.py --output` in `-B -S` and `-B -O -S` on the exact head: 18 tests per mode, 10 intended mutant failures, identical output pairs. Source identities match. | +| Independent checks | `dimension_lift_review_check.py` is my own suite, written from `PROOF.md` without reusing `lift.py`. It checks finite identities exactly, plus one labelled floating-point group. Every Gaussian step below was argued by hand and is not replaced by those checks. | + +## Verdicts + +| Interface (PROOF.md lines) | Verdict | +|---|---| +| §2 (98–130): complete 3-jet `(U_0, J)` of size `C(d+3,3)`, positive definite in every frame; uniform floor for `(U_r, J)`; raw-jet density floor under `Q_r` | **ACCEPT**; see §1 below. | +| §3 (132–187): Schur shear (A8)–(A9), unit-Jacobian raw chart (A10) | **ACCEPT**. Exact check `CHART`, including the full Jacobian by dual numbers. | +| §4 (189–216): raw rare set (A11), volume (A12), `Q_r ≥ c_J r` (A13) | **ACCEPT**; see §2 below. | +| §5 (218–246): `C^4` control after conditioning on all physical jets (A14)–(A16); constant order | **ACCEPT**; see §3 below. | +| §6 (248–282): sheared-plane normal form (A17), pin identities, target (A18) | **ACCEPT**. Hand-derived. Exact on physical cubic fields in d = 3, 4, 5 (zero remainder); `O(r)` remainder on quartic fields. | +| §7 (284–308): path (A19), margins `k/64`, `d_f(M) ≥ b − kr³/4 > f(S)` | **ACCEPT**. Identical to [EL] (E5)–(E6); recomputed. | +| §8 (310–361): endpoint blocks (A20), Schur (A21), inertia and determinant (A22), `W ≥ c r⁴` (A23), `Z ≤ C r²` (A24), ledger (A25) | **ACCEPT**; see §4 below. | +| **Theorem A (A2)–(A3)**: `1 − p_r ≥ c r³` for every fixed d ≥ 3 (d = 2 is [EL]) | **ACCEPT** at its stated existential scope. | +| §9 (363–415), **(A4)**: two extra index-(d−1) critical points, `Q^W(N_r ≥ 2) ≥ c r³`, factorial lower bound | **ACCEPT**; see §5 below. | +| **Corollary B (A5)**: `c r³ ≤ 1 − p_r ≤ C r³` in every fixed d | **ACCEPT** as a composition with LP Theorem A (1.1), consumable at existential scope under the D1 reconciliation (Math-#126, merged at `8224783`); see §6 below. | +| **(A6)**: compact-mark loss `ν_cand − ν_eld = Θ(ℓ^{2/3})` in every fixed d | **ACCEPT** as a composition with LP's compact-mark ledger and (A5). | +| **Corollary C (A6a)**: rejected-pair inverse moments finite iff `p < 5/3`; `Θ(t^{5/3−p})`; logarithmic endpoint | **ACCEPT** as a composition with (A6). | + +No defect was found. Notes N1–N5 record observations that sharpen or delimit the text without changing it. + +--- + +## §1 — the jet floor (§2 of PROOF.md) + +The count is exact. `U_0` has `4 + 2(d−1) = 2(d+1)` entries (lines 101–105), one per pin observation. `J` has the +`m(m+1)/2` transverse Hessian entries (`m = d − 1`) and the `C(d+2,3) − 1` third derivatives other than `f_xxx`. +Order by order, `U_0 ∪ J` is every derivative of order 0–3 exactly once. Order 2 has `d` entries in `U_0` (`f_xx`, +`f_xy_j`) and `m(m+1)/2` in `J`, total `d(d+1)/2`. The total is `C(d+3,3)` (`LEDGER`, d = 2…12). + +Positivity: the periodized covariance has Fourier weights `∝ exp(−|ω|²/2) > 0` on `(2π/L)Z^d`. A linear functional +`Σ c_α ∂^α f(0)` has variance `Σ_ω w_ω |Σ c_α (iω)^α|²`. If that variance is zero, the polynomial `Σ c_α (iω)^α` vanishes +on the dual lattice, rotated by the frame. Pulled back, it vanishes on `Z^d`, hence identically. So the complete jet +covariance is positive definite for each frame. Compactness of `O(d)` and continuity make the floor uniform. +`CHART.rotated_lattice_unisolvence_degree3` illustrates this exactly on Cayley-rational rotated lattices for d = 2, 3. + +`U_r → U_0` uniformly as `r → 0` is LP §§2–4. The quartic group re-solves the `2(d+1)` U_0 jets from the pins through +that frame and finds it nonsingular. Conditioning on `U_r = v_r` is Schur complementation, so the conditional covariance +of `J` is sandwiched between the joint floor and ceiling, and its mean `Cov(J,U_r)Cov(U_r)⁻¹v_r` is bounded. A Gaussian +density with sandwiched covariance and bounded mean is bounded below on every fixed compact set. The claim is about +**raw** jets (line 129), which is what §4 integrates. + +Note on `J` being free under `Q_r`: the pins tie `f_y(0)` to `f_xxy` at order `r²`, since +`f_y(0) = −(r²/8) f_xxy + O(r³)`. That relation lives inside the `U_r` rows, not as a constraint on `J`. The +`PHYSICAL` group builds fields with arbitrary `J` and verifies all `2(d+1)` pins exactly. + +## §2 — the chart and the rare set (§§3–4) + +With `q = D⁻¹v`, `y = (z, w − qz)` gives +`yᵀAy = az² + 2z vᵀ(w − qz) + (w − qz)ᵀD(w − qz)`. The `zw` terms cancel because `qᵀD = vᵀ`. The `z²` coefficient is +`a − 2vᵀD⁻¹v + vᵀD⁻¹v = σ`. So `SᵀAS = diag(σ, D)` and `det A = σ det D` (checked exactly, n = 1…4). The chart +`(σ, v, D, τ) ↦ (a, v, D, T)` is block triangular in the order `(v, D), σ, τ`, with diagonal blocks `I`, `1` and the +substitution `w ↦ w + qz` on third-derivative coordinates, which is unipotent. + +`f_xxx` is untouched, and no other coordinate depends on it: `∂_z` of the sheared field only introduces `∂_w`, which +preserves the number of `x` indices. So deleting `xxx` leaves determinant one. My check does not rely on the triangular +argument. It differentiates the whole map with exact dual numbers for d = 3 (12 variables) and d = 4 (25 variables), +and finds a full Jacobian determinant of exactly 1. + +The rare box (A11) is a product: an interval of length `2εkr` in `σ`, fixed boxes in `v` and `D`, and width-`2εk` boxes +in the `q_3 = C(d+2,3) − 1` coordinates of `τ`. Its raw volume is therefore (A12). All inverse-chart images lie in one +compact set, because `D⁻¹`, `q` and `σ` are bounded. So (A13) follows from §1. The raw entry `a` sits on the `O(1)` +surface `vᵀD⁻¹v`, inside a band of width `O(r)`. Only one scalar shrinks. That is why the power is `r¹` in every d +(line 185). Requiring all `m(m+1)/2` transverse entries to be `O(r)` would give `r^{m(m+1)/2}` instead. No law is +assigned to the sheared variables (lines 213–216): the raw Gaussian density is integrated against a unit Jacobian. + +## §3 — conditioning order and constants (§5) + +The field is regressed on `V = (U_r, J)` at each target. The pin rows are integral averages of derivatives of order +≤ 3, so the cross-covariances of the field's derivatives through order 4 with `V` are uniformly bounded. `Cov(V)⁻¹` is +bounded by §1, and the targets are compact. Hence (A15) holds uniformly. Markov's inequality gives `K_4` with conditional +mass ≥ 1/2 at every target, and integrating over the rare set gives (A16). No independence between jets and remainder is +used, and no unconditional tail is subtracted from an `O(r)` mass. + +The constant order is sound. The raw container is valid for all `ε ≤ 1`, so `K_4` is chosen first. `ε` is then chosen +for the planar `O(εk)` margins, which do not involve `K_4`. Finally `r_*` absorbs every `O(rK_4)` and `O(rK_4²)` term. + +## §4 — normal form, endpoints, weight and normalizer (§§6, 8) + +(A17): I rederived every pin identity (lines 266–270) from the axial restrictions `φ(x) = g(x,0)` and +`ψ(x) = g_z(x,0)`. The sums of `φ'(±r/2)` and `ψ(±r/2)` give `g_x` and `g_z`. Their differences give `g_xx` and `g_xz`. +The height difference gives `g_xxx = 12k + O(rK_4)`. The `Z²` coefficient is `σ/r`, not `a/r`. The `−a_3 Z/8` term comes +from `g_z(0)`. + +Two independent exact checks support this: + +- **Cubic fields.** On physical cubic fields in d = 3, 4, 5, built from chart data with all pins imposed and then + sheared, (A17) holds with **zero** remainder. The sheared midpoint jets reproduce `σ`, `D` and `τ` exactly + (`PHYSICAL`). +- **Quartic fields.** On quartic fields, where the pins are re-solved through the contact frame, the sup of + `F_r − P` over the rational grid in `B(0,3)` halves as `r` halves (successive ratios 2.0000 to four decimals), for + `r = 1/8 … 1/64` in d = 3, 4 + (`QUARTIC`). + +The mutants `raw-a-in-plane` and `drop-transverse-pin-term` are rejected. + +(A20)–(A22): for cubic fields the endpoint blocks are exactly `r P_i` (soft), `C_i = ±(r/2)(τ_xxw; τ_xzw)` (cross) and +`D ± (r/2) τ_xww` (stable). Then `det H = det D_i · det K_i`, and inertia(H) = inertia(D_i) + inertia(K_i), with index +d at `M` and d − 1 at `S`. `|K_i/r − P_i| ≤ rk`. All of this is checked exactly, with the physical Hessian computed +independently of the sheared one. Dropping the cross-block correction is rejected (`no-cross-schur`). The target planar +Hessians `diag(−6k, −k/2)` and `diag(6k, −5k/2)` are recomputed in `PATH`. Since `|det L| = 1`, physical and sheared +determinants agree, so `W_r ≥ c r⁴` with the power independent of d. + +(A24): `∇f(S) − ∇f(M) = r∫_{−1/2}^{1/2} H(tru)u dt = 0` (checked exactly). So `H_i u = O(r‖f‖_{C³})`. On cubic +fields `H_i u = ±(r/2)(f_xxx, f_xxy_j)` exactly, and on quartic fields it halves with `r`. Hadamard's inequality gives +`|det H_i| ≤ C r (1 + ‖f‖_{C³})^d`, and LP §4's endpoint-conditioned moments give `Z_r ≤ C_Z r²`. The ledger is +`r · r⁴ / r² = r³` in every d (`LEDGER`; `weight-2d` rejected). + +## §5 — the extra saddles (§9) + +The rescaling `x = rX, z = rZ, w = r²W` is the right one. I rederived (A27) term by term: + +- **Soft components.** These are `∇F_r` plus `r⁻²·r²W·f̃_{w,(x,z)}(rX, rZ, 0) = O(rK_4|W|)`. The mixed soft–stable + Hessian is `O(rK_4)` in the `O(r)` ball, because `f̃_zw(0) = 0` exactly and `f̃_xw(0) = O(K_4 r²)`. +- **Stable components.** These are `r⁻²[f̃_w(0) + f̃_wx rX + ½(τ_xxw r²X² + 2τ_xzw r²XZ + τ_zzw r²Z²) + r²DW] + O(rK_4)`, + with `f̃_w(0) = −(r²/8)τ_xxw + O(K_4 r³)`. This is `DW + Q(X,Z)` with `Q` as in (A28). +- **C¹ closeness.** `∂_X` of the stable part is `r⁻¹f̃_wx(…) = ∂_X Q + O(rK_4)`. `∂_W` of the soft part is `O(rK_4)`. + Second derivatives of `H_r` are bounded by `K_4`, so the quantitative inverse-function theorem applies uniformly + around the block-triangular nondegenerate zero `(p, −D⁻¹Q(p))`. + +Heights are `b + r³(F_r(p) + O(r))`, strictly inside the window. The index is `n + 1 = d − 1`, by the same Schur +argument as §4. + +`SADDLES` checks this in floating point on quartic fields in d = 3, 4 for `r = 1/16 … 1/128`: + +- Both extra critical points exist, with gradient residual below `1e−15`, index d − 1 and heights in `(b − kr³, b)`. + They are distinct from each other and from the pins. +- `|w/r² − W*|/r` stays within a factor 2 across the range, so the stable correction is `O(r)`. Scaling `w` by `r` + instead of `r²` is rejected. +- At the planar restriction's critical point, `∂_w f̃/r²` is nonzero. This confirms the manuscript's warning (line + 365) that a planar critical point is not a full critical point. + +## §6 — the corollaries (§10) + +(A5) consumes LP Theorem A (1.1). The D1 reconciliation (Math-#126, `reviews/d1_chain_reconciliation_20260928/`, merged at `8224783`) +records (1.1) as ACCEPT at existential scope in every fixed d ≥ 2, read with the congruence erratum, the §9 replacement +v1.1, wording W1 and `r < L/(4√2)`. Its consumption contract (§7 there) permits exactly this use. #126 is +now merged, so (A5)'s upper half rests on a reconciled register entry. The direct lower half never depended on it. + +(A6): with `ℓ = kr³` at fixed `k`, `r dr = (1/3)ℓ^{−1/3}k^{−2/3} dℓ`. Multiplying by `1 − p ≍ r³ = ℓ/k` gives +`ℓ^{2/3}k^{−5/3}`, which is integrable with positive integral on compact `K` with `k_− > 0`. For small `ℓ` every radius +is below the common cutoff. (A6a) follows: `∫_0^t ℓ^{2/3−p} dℓ` is finite iff `p < 5/3`, logarithmic at `p = 5/3`. The +rejected-pair measure is integrated directly, never as a difference of infinities (line 444). + +**Consequence for the D1 chain.** With this review and #126, Theorem A's cubic order is **two-sided** `Θ(r³)` in every +fixed d ≥ 2, and the compact-mark density loss is `Θ(ℓ^{2/3})` in every fixed d. #126 deliberately says "no d ≥ 3 lower +bound". That caveat can be lifted by a later register PR once both #125 and #126 are integrated, not inside either. + +## Notes + +- **N1.** (A20)'s bound `‖C_i‖ ≤ CrK_4` can be read more finely as `C_i = ±(r/2)(τ_xxw; τ_xzw) + O(K_4 r²)`, so the + Schur correction is `O(r²(εk + K_4 r)²)`. Not needed, but it shows the correction is small even before `r_*` is fixed. +- **N2.** (A4) should say whether `N_r` counts additional window critical points anywhere on the torus or only in the + `C_d r` ball. The lower bounds hold for either reading, since both counts are ≥ 2 on the event. +- **N3.** Why a *linear* shear suffices. The path obstruction needs field values on one plane only. The endpoint and + saddle data need only Schur complements with `O(r)` cross blocks. A nonlinear ridge `y = φ(x,z)` would give the same + midpoint Schur complement at the cost of implicit-function bookkeeping. Neither route needs the other. +- **N4.** The bound `‖q‖ ≤ 1/9` (line 146) is used only through a uniform bound on `‖L‖`. Any fixed bound works after + adjusting `r_*`. +- **N5.** `lift.py`'s tests are finite controls of the listed identities. The end-to-end physical-field checks here + (building `f`, imposing pins, shearing and recovering) are additional to them, not a replacement. + +## What this review does not do + +It does not accept a numerical `c`, `r_*` or cutoff, a uniform-in-d bound, an unrestricted-mark difference, a +leading loss constant, a global factorial upper bound, or any identification with historical `q`/`p` symbols. The +manuscript claims none of these. It changes no register. Integration, and any register transition that lifts #126's +d ≥ 3 caveat, are separate acts for a non-Claude integrator. + +## Reproduce + + python -B -S dimension_lift_review_check.py # prints RESULTS.json byte for byte + python -B -O -S dimension_lift_review_check.py # identical + python -B -S dimension_lift_review_check.py --mutant M # exit 1 for each of the 9 mutants diff --git a/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json b/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..f5a8f9024 --- /dev/null +++ b/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json @@ -0,0 +1,37 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW", + "reviewed_object": { + "pr": "d6g8k5htny-coder/Math-#125", + "head": "e3f10b390ae5ddd998d238206add5958d5b720bb", + "paths": [ + { + "path": "frontiers/elder_dimension_lift_20260928/PROOF.md", + "git_blob": "7303bd791a68a1139251f0f6e403a9f7cc89b006", + "bytes": 23971, + "sha256": "b529fe3780e1909014b3cb144b9a74156d976bbdc19b6711d0c5b1a1da9e5669" + } + ] + }, + "files": [ + { + "path": "REVIEW.md", + "bytes": 16746, + "sha256": "a937a36813faff5afb9b6ed135cb838d14dde8ddfbdbc7e6ad37534a2b5c9c62", + "git_blob": "e5984338eb48cd496d3e9b6c0ddc9322dcc1465b" + }, + { + "path": "RESULTS.json", + "bytes": 2035, + "sha256": "97a323d1d383c6bf5a8fe8d616e681d7a2ae1c2d4acee51eb6405ec8df55e8f4", + "git_blob": "59e62fdcd2e30e324ac74263a6b904b3da3d2b6e" + }, + { + "path": "dimension_lift_review_check.py", + "bytes": 37826, + "sha256": "768b0d8f84b66616f2c649c5f7ae132fa701563ead85b8f5aa20a30f2bc0bda8", + "git_blob": "36f258676a9aeb7f1b63e1f1267c3e4ebce52bb6" + } + ] +} diff --git a/reviews/elder_dimension_lift_claude_20260928/dimension_lift_review_check.py b/reviews/elder_dimension_lift_claude_20260928/dimension_lift_review_check.py new file mode 100644 index 000000000..36f258676 --- /dev/null +++ b/reviews/elder_dimension_lift_claude_20260928/dimension_lift_review_check.py @@ -0,0 +1,872 @@ +"""Independent nonauthor checks for OA-ELDER-DIMENSION-LIFT-20260928-v1 (Math- PR 125). + +Python standard library only. Written from the manuscript, not from the author's lift.py/test_lift.py. +Groups (exact rational arithmetic unless marked NUMERIC): + + CHART the Schur shear S^T A S = diag(sigma, D); the full raw chart (sigma,v,D,tau) -> (a,v,D,T) has + Jacobian determinant exactly one (forward-mode dual numbers over Fractions, d = 3, 4); the xxx + coordinate decouples; rational-orthogonal rotated lattices are unisolvent for degree <= 3. + PHYSICAL end to end on actual physical cubic fields in d = 3, 4, 5: build f from chart data and the + 2(d+1) pins, verify the pins, shear it, recover (sigma, D, tau) exactly, and check the planar + normal form (A17) with zero remainder, the endpoint blocks (A20), the Schur/determinant/inertia + identities (A21)-(A22), the gradient-pin average behind (A24) and |H u| = O(r). + QUARTIC physical quartic fields with pins re-solved through the 2(d+1)-row contact frame: the frame is + nonsingular, (A17)'s remainder is O(r) (exact values on a grid at r = 1/8 ... 1/64), and + H_i u = O(r). + SADDLES NUMERIC (floats): on the quartic fields the two extra critical points exist near (rP+-, r^2 W*), + have index d-1 and window heights, w/r^2 -> -D^{-1} Q(p) at rate O(r), and the planar + restriction's critical point is not a full critical point. + PATH the polygonal path (A19) and saddle data (A18), recomputed from the polynomial class. + LEDGER jet counts, the r * r^4 / r^2 = r^3 ledger, the density change of variables (A6) and the + inverse-moment threshold 5/3 (A6a). + +Mutants (each must make the checks fail): raw-a-in-plane, shear-sign, drop-transverse-pin-term, +no-cross-schur, planar-point-is-critical, stable-scale-r, density-dr, threshold-two-thirds, weight-2d. +This is not an analytic proof of the Gaussian covariance floor, conditional C^4 bounds or inverse-function +estimates; those are reviewed in REVIEW.md. +""" +import argparse +import json +import math +import random +import sys +from fractions import Fraction as F +from itertools import product +from math import comb, factorial + +MUTANTS = ("raw-a-in-plane", "shear-sign", "drop-transverse-pin-term", "no-cross-schur", + "planar-point-is-critical", "stable-scale-r", "density-dr", "threshold-two-thirds", "weight-2d") +MUT = None + + +# --------------------------------------------------------------------------------------------------------------- +# Polynomials: dict {exponent tuple: coefficient} +# --------------------------------------------------------------------------------------------------------------- + +def padd(*ps): + out = {} + for p in ps: + for e, c in p.items(): + out[e] = out.get(e, 0) + c + return {e: c for e, c in out.items() if c} + + +def pscale(p, s): + return {e: c * s for e, c in p.items() if c * s} + + +def pmul(p, q): + out = {} + for e1, c1 in p.items(): + for e2, c2 in q.items(): + e = tuple(a + b for a, b in zip(e1, e2)) + out[e] = out.get(e, 0) + c1 * c2 + return {e: c for e, c in out.items() if c} + + +def pconst(c, n): + return {(0,) * n: c} if c else {} + + +def pvar(i, n, c=1): + return {tuple(int(j == i) for j in range(n)): c} + + +def pcompose(p, subs, n_out): + """p(subs[0], ..., subs[n-1]) where each subs[i] is a polynomial in n_out variables.""" + out = {} + cache = {} + for e, c in p.items(): + term = pconst(c, n_out) + for i, power in enumerate(e): + if power: + key = (i, power) + if key not in cache: + acc = pconst(1, n_out) + for _ in range(power): + acc = pmul(acc, subs[i]) + cache[key] = acc + term = pmul(term, cache[key]) + out = padd(out, term) + return out + + +def pdiff(p, i): + out = {} + for e, c in p.items(): + if e[i]: + e2 = list(e) + e2[i] -= 1 + out[tuple(e2)] = out.get(tuple(e2), 0) + c * e[i] + return {e: c for e, c in out.items() if c} + + +def peval(p, pt): + total = 0 + for e, c in p.items(): + term = c + for x, k in zip(pt, e): + if k: + term *= x ** k + total += term + return total + + +def pderiv_at0(p, alpha): + """partial^alpha p (0).""" + return p.get(tuple(alpha), 0) * math.prod(factorial(a) for a in alpha) + + +def from_jets(jets, n): + """Polynomial sum_alpha jets[alpha] x^alpha / alpha!.""" + return {e: F(c) / math.prod(factorial(a) for a in e) for e, c in jets.items() if c} + + +def multi(n, deg): + return [e for e in product(range(deg + 1), repeat=n) if sum(e) == deg] + + +def unit(n, i): + return tuple(int(j == i) for j in range(n)) + + +def eplus(*es): + return tuple(map(sum, zip(*es))) + + +# --------------------------------------------------------------------------------------------------------------- +# Small exact linear algebra +# --------------------------------------------------------------------------------------------------------------- + +def solve(A, b): + n = len(A) + W = [list(map(F, row)) + [F(b[i])] for i, row in enumerate(A)] + for j in range(n): + p = next(i for i in range(j, n) if W[i][j] != 0) + W[j], W[p] = W[p], W[j] + piv = W[j][j] + W[j] = [x / piv for x in W[j]] + for i in range(n): + if i != j and W[i][j] != 0: + f = W[i][j] + W[i] = [x - f * y for x, y in zip(W[i], W[j])] + return [row[-1] for row in W] + + +def det(A): + n = len(A) + W = [list(row) for row in A] + out = 1 + for j in range(n): + p = next((i for i in range(j, n) if W[i][j] != 0), None) + if p is None: + return 0 * out + if p != j: + W[j], W[p] = W[p], W[j] + out = -out + out = out * W[j][j] + for i in range(j + 1, n): + f = W[i][j] / W[j][j] + for k in range(j, n): + W[i][k] = W[i][k] - f * W[j][k] + return out + + +def inertia(A): + """(negatives, positives, zeros) of a symmetric Fraction matrix via symmetric pivoting (Sylvester).""" + n = len(A) + W = [list(map(F, row)) for row in A] + idx = list(range(n)) + neg = pos = 0 + while idx: + j = next((i for i in idx if W[i][i] != 0), None) + if j is None: + # 2x2 pivot on a nonzero off-diagonal entry + pair = next(((i, l) for i in idx for l in idx if i < l and W[i][l] != 0), None) + if pair is None: + return neg, pos, len(idx) + i, l = pair + neg += 1 + pos += 1 + blk = [[W[i][i], W[i][l]], [W[l][i], W[l][l]]] + dB = blk[0][0] * blk[1][1] - blk[0][1] * blk[1][0] + inv = [[blk[1][1] / dB, -blk[0][1] / dB], [-blk[1][0] / dB, blk[0][0] / dB]] + rest = [m for m in idx if m not in (i, l)] + for a in rest: + for b in rest: + ca = [W[a][i], W[a][l]] + cb = [W[i][b], W[l][b]] + W[a][b] -= sum(ca[s] * inv[s][t] * cb[t] for s in range(2) for t in range(2)) + idx = rest + continue + piv = W[j][j] + neg += piv < 0 + pos += piv > 0 + rest = [m for m in idx if m != j] + for a in rest: + for b in rest: + W[a][b] -= W[a][j] * W[j][b] / piv + idx = rest + return neg, pos, 0 + + +def rank(rows): + W = [list(map(F, r)) for r in rows] + h = 0 + ncol = len(W[0]) if W else 0 + for j in range(ncol): + p = next((i for i in range(h, len(W)) if W[i][j] != 0), None) + if p is None: + continue + W[h], W[p] = W[p], W[h] + for i in range(h + 1, len(W)): + f = W[i][j] / W[h][j] + if f: + W[i] = [x - f * y for x, y in zip(W[i], W[h])] + h += 1 + return h + + +def matmul(A, B): + return [[sum(A[i][k] * B[k][j] for k in range(len(B))) for j in range(len(B[0]))] for i in range(len(A))] + + +def transpose(A): + return [list(r) for r in zip(*A)] + + +# --------------------------------------------------------------------------------------------------------------- +# Dual numbers over Fractions (forward-mode derivatives for the chart Jacobian) +# --------------------------------------------------------------------------------------------------------------- + +class Dual: + __slots__ = ("v", "g") + + def __init__(self, v, g=None): + self.v = F(v) + self.g = g or {} + + @staticmethod + def lift(x): + return x if isinstance(x, Dual) else Dual(x) + + def __add__(self, o): + o = Dual.lift(o) + g = dict(self.g) + for k, c in o.g.items(): + g[k] = g.get(k, 0) + c + return Dual(self.v + o.v, g) + + __radd__ = __add__ + + def __neg__(self): + return Dual(-self.v, {k: -c for k, c in self.g.items()}) + + def __sub__(self, o): + return self + (-Dual.lift(o)) + + def __rsub__(self, o): + return Dual.lift(o) - self + + def __mul__(self, o): + o = Dual.lift(o) + g = {k: c * o.v for k, c in self.g.items()} + for k, c in o.g.items(): + g[k] = g.get(k, 0) + c * self.v + return Dual(self.v * o.v, g) + + __rmul__ = __mul__ + + def __truediv__(self, o): + o = Dual.lift(o) + inv = Dual(1 / o.v, {k: -c / (o.v * o.v) for k, c in o.g.items()}) + return self * inv + + def __rtruediv__(self, o): + return Dual.lift(o) / self + + def __ne__(self, o): + return self.v != Dual.lift(o).v + + def __eq__(self, o): + return self.v == Dual.lift(o).v + + def __hash__(self): + return hash(self.v) + + +# --------------------------------------------------------------------------------------------------------------- +# The chart +# --------------------------------------------------------------------------------------------------------------- + +def rat(rng, lo, hi, steps=1000): + """A random rational in [lo, hi] on a grid of `steps` intervals (lo, hi may be Fractions).""" + lo, hi = F(lo), F(hi) + return lo + (hi - lo) * F(rng.randint(0, steps), steps) + + +def sample_chart(d, rng, r, k, eps=F(1, 100)): + """Chart data (sigma, v, D, tau) inside the manuscript's rare set; variables ordered (x, z, w_1..w_n).""" + n = d - 2 + D = [[F(0)] * n for _ in range(n)] + for i in range(n): + D[i][i] = -1 + rat(rng, -1 / 10, 1 / 10) + for j in range(i): + D[i][j] = D[j][i] = rat(rng, -1 / (10 * n), 1 / (10 * n)) + v = [rat(rng, -1 / (20 * n), 1 / (20 * n)) for _ in range(n)] + sigma = r * (F(-3, 2) * k + rat(rng, -eps, eps) * k) + tau = {} + for e in multi(d, 3): + tau[e] = rat(rng, -eps, eps) * k + xz, x, z = unit(d, 0), unit(d, 0), unit(d, 1) + tau[eplus(x, x, x)] = 12 * k # cubic model: pins force f_xxx = 12k exactly + tau[eplus(x, z, z)] = -2 * k + rat(rng, -eps, eps) * k + return sigma, v, D, tau + + +def shear_subs(d, q, sign=-1): + """Substitution (x, z, w) -> (x, z, w + sign*q z) as polynomials in d variables.""" + subs = [pvar(0, d), pvar(1, d)] + for j in range(d - 2): + subs.append(padd(pvar(j + 2, d), pvar(1, d, sign * q[j]))) + return subs + + +def build_physical_cubic(d, sigma, v, D, tau, r, k, b): + """Physical cubic f(x, y) with the 2(d+1) pins, transverse Hessian A = [[a, v^T], [v, D]] and physical third + derivatives T obtained from tau through the inverse shear y_w = w - q z, i.e. w = y_w + q y_z.""" + n = d - 2 + q = solve(D, v) if n else [] + a = sigma + sum(vi * qi for vi, qi in zip(v, q)) + cubic_tilde = from_jets({e: c for e, c in tau.items()}, d) + cubic_phys = pcompose(cubic_tilde, shear_subs(d, q, sign=+1), d) + T = {e: pderiv_at0(cubic_phys, e) for e in multi(d, 3)} + x = unit(d, 0) + jets = dict(T) + # transverse Hessian over y = (z, w) + A = [[a] + list(v)] + [[v[i]] + list(D[i]) for i in range(n)] + for i in range(d - 1): + for j in range(d - 1): + jets[eplus(unit(d, i + 1), unit(d, j + 1))] = A[i][j] + # pin-determined lower order jets (exact for cubic fields) + jets[(0,) * d] = b - k * r ** 3 / 2 + jets[x] = -F(3, 2) * k * r ** 2 + for j in range(1, d): + jets[unit(d, j)] = -r * r / 8 * T[eplus(x, x, unit(d, j))] + jets[eplus(x, unit(d, j))] = F(0) + jets[eplus(x, x)] = F(0) + return from_jets(jets, d), A, T, q, a + + +def hessian_at(p, pt, d): + return [[peval(pdiff(pdiff(p, i), j), pt) for j in range(d)] for i in range(d)] + + +def gradient_at(p, pt, d): + return [peval(pdiff(p, i), pt) for i in range(d)] + + +def planar_normal_form(k, s, a3, beta, c3): + """(A17) polynomial in (X, Z).""" + X, Z = pvar(0, 2), pvar(1, 2) + lin = F(0) if MUT == "drop-transverse-pin-term" else F(1, 4) + terms = [pscale(pmul(pmul(X, X), X), 2 * k), pscale(X, -F(3, 2) * k), pconst(-k / 2, 2), + pscale(pmul(Z, Z), s / 2), + pscale(pmul(padd(pmul(X, X), pconst(-lin, 2)), Z), a3 / 2), + pscale(pmul(X, pmul(Z, Z)), beta / 2), pscale(pmul(Z, pmul(Z, Z)), c3 / 6)] + return padd(*terms) + + +def scaled_plane(ftilde, d, r, b): + """F_r(X, Z) = [tilde f(rX, rZ, 0) - b] / r^3.""" + subs = [pvar(0, 2, r), pvar(1, 2, r)] + [{} for _ in range(d - 2)] + return pscale(padd(pcompose(ftilde, subs, 2), pconst(-b, 2)), 1 / r ** 3) + + +# --------------------------------------------------------------------------------------------------------------- +# CHART group +# --------------------------------------------------------------------------------------------------------------- + +def check_chart(): + out = {} + rng = random.Random(125001) + ok_cancel = True + for n in (1, 2, 3, 4): + for _ in range(3): + d = n + 2 + sigma, v, D, _ = sample_chart(d, rng, F(1, 16), F(1)) + q = solve(D, v) + a = sigma + sum(x * y for x, y in zip(v, q)) + A = [[a] + list(v)] + [[v[i]] + list(D[i]) for i in range(n)] + sgn = 1 if MUT == "shear-sign" else -1 + S = [[F(int(i == j)) for j in range(n + 1)] for i in range(n + 1)] + for i in range(n): + S[i + 1][0] = sgn * q[i] + B = matmul(transpose(S), matmul(A, S)) + want = [[sigma] + [F(0)] * n] + [[F(0)] + list(D[i]) for i in range(n)] + ok_cancel &= B == want and det(S) == 1 and det(A) == sigma * det(D) + out["schur_shear_cancels_and_det_A_equals_sigma_det_D_n1to4"] = ok_cancel + + # Full raw-chart Jacobian with dual numbers. + ok_jac = True + for d in (3, 4): + n = d - 2 + sigma, v, D, tau = sample_chart(d, rng, F(1, 16), F(1)) + names = ["sigma"] + [f"v{i}" for i in range(n)] + [f"D{i}{j}" for i in range(n) for j in range(i, n)] + cubic_labels = [e for e in multi(d, 3) if e != eplus(unit(d, 0), unit(d, 0), unit(d, 0))] + names += [f"tau{e}" for e in cubic_labels] + sd = Dual(sigma, {"sigma": F(1)}) + vd = [Dual(v[i], {f"v{i}": F(1)}) for i in range(n)] + Dd = [[None] * n for _ in range(n)] + for i in range(n): + for j in range(i, n): + Dd[i][j] = Dd[j][i] = Dual(D[i][j], {f"D{i}{j}": F(1)}) + td = {e: Dual(tau[e], {f"tau{e}": F(1)}) for e in cubic_labels} + # q = D^{-1} v with duals (Gauss-Jordan) + W = [list(Dd[i]) + [vd[i]] for i in range(n)] + for j in range(n): + piv = W[j][j] + W[j] = [x / piv for x in W[j]] + for i in range(n): + if i != j: + f = W[i][j] + W[i] = [x - f * y for x, y in zip(W[i], W[j])] + qd = [W[i][-1] for i in range(n)] + ad = sd + sum((vd[i] * qd[i] for i in range(n)), Dual(0)) + # T = substitution w -> w + q z applied to tau (dual coefficients). + cub = {e: td[e] / math.prod(factorial(x) for x in e) for e in cubic_labels} + subs = [pvar(0, d), pvar(1, d)] + [padd(pvar(j + 2, d), {unit(d, 1): qd[j]}) for j in range(n)] + phys = {} + for e, c in cub.items(): + term = {(0,) * d: c} + for i, power in enumerate(e): + for _ in range(power): + new = {} + for e1, c1 in term.items(): + for e2, c2 in subs[i].items(): + key = tuple(s + t for s, t in zip(e1, e2)) + new[key] = new.get(key, Dual(0)) + c1 * c2 + term = new + for key, c in term.items(): + phys[key] = phys.get(key, Dual(0)) + c + Td = {e: phys.get(e, Dual(0)) * math.prod(factorial(x) for x in e) for e in cubic_labels} + outputs = [ad] + vd + [Dd[i][j] for i in range(n) for j in range(i, n)] + [Td[e] for e in cubic_labels] + J = [[o.g.get(nm, F(0)) for nm in names] for o in outputs] + ok_jac &= len(J) == len(names) and det(J) == 1 + # xxx decouples: no output depends on it and it is not an input (it is pinned in U_0). + out["raw_chart_full_jacobian_is_one_d3_d4"] = ok_jac + + # Rotated-lattice unisolvence for degree <= 3 (Cayley rational orthogonal frames). + ok_uni = True + for d in (2, 3): + labels = [e for deg in range(4) for e in multi(d, deg)] + for s in ((F(1, 2),), (F(1, 3), F(2, 5), F(-1, 7))): + K = [[F(0)] * d for _ in range(d)] + idx = 0 + for i in range(d): + for j in range(i + 1, d): + K[i][j] = s[idx % len(s)] + K[j][i] = -K[i][j] + idx += 1 + I = [[F(int(i == j)) for j in range(d)] for i in range(d)] + IpK = [[I[i][j] + K[i][j] for j in range(d)] for i in range(d)] + ImK = [[I[i][j] - K[i][j] for j in range(d)] for i in range(d)] + # R = (I - K)^{-1}(I + K) + cols = [solve(ImK, [IpK[i][j] for i in range(d)]) for j in range(d)] + R = transpose(cols) + ok_uni &= matmul(transpose(R), R) == I + pts = [[sum(R[i][j] * p[j] for j in range(d)) for i in range(d)] for p in product(range(4), repeat=d)] + rows = [[math.prod(x ** a for x, a in zip(pt, e)) for e in labels] for pt in pts] + ok_uni &= rank(rows) == len(labels) == comb(d + 3, 3) + out["rotated_lattice_unisolvence_degree3"] = ok_uni + return out + + +# --------------------------------------------------------------------------------------------------------------- +# PHYSICAL group (exact cubic fields) +# --------------------------------------------------------------------------------------------------------------- + +def check_physical(): + out = {} + rng = random.Random(125002) + k, b = F(6, 5), F(1, 3) + res = {key: True for key in ("pins", "shear_recovers_sigma_D_tau", "normal_form_A17_exact", "endpoint_blocks_A20", + "schur_det_inertia_A21_A22", "gradient_pin_average_A24", "Hu_order_r", + "weight_order_r4")} + for d in (3, 4, 5): + n = d - 2 + for r in (F(1, 8), F(1, 32)): + sigma, v, D, tau = sample_chart(d, rng, r, k) + f, A, T, q, a = build_physical_cubic(d, sigma, v, D, tau, r, k, b) + M = [-r / 2] + [F(0)] * (d - 1) + S = [r / 2] + [F(0)] * (d - 1) + res["pins"] &= (peval(f, M) == b and peval(f, S) == b - k * r ** 3 + and all(g == 0 for g in gradient_at(f, M, d) + gradient_at(f, S, d))) + ft = pcompose(f, shear_subs(d, q, sign=+1 if MUT == "shear-sign" else -1), d) + Ht0 = hessian_at(ft, [F(0)] * d, d) + rec = (Ht0[1][1] == sigma and all(Ht0[1][j + 2] == 0 for j in range(n)) + and all(Ht0[i + 2][j + 2] == D[i][j] for i in range(n) for j in range(n)) + and all(pderiv_at0(ft, e) == tau[e] for e in multi(d, 3))) + res["shear_recovers_sigma_D_tau"] &= rec + # (A17): exact for cubic fields. + s_coef = (a if MUT == "raw-a-in-plane" else Ht0[1][1]) / r + x, z = unit(d, 0), unit(d, 1) + a3, beta, c3 = pderiv_at0(ft, eplus(x, x, z)), pderiv_at0(ft, eplus(x, z, z)), pderiv_at0(ft, eplus(z, z, z)) + Fr = scaled_plane(ft, d, r, b) + res["normal_form_A17_exact"] &= Fr == planar_normal_form(k, s_coef, a3, beta, c3) + # Endpoint blocks in the (x, z; w) shear frame. + P = planar_normal_form(k, Ht0[1][1] / r, a3, beta, c3) + dets = [] + for sgn, pt in ((-1, M), (1, S)): + H = hessian_at(ft, pt, d) + Xs = F(sgn, 2) + Pi = [[peval(pdiff(pdiff(P, i), j), [Xs, F(0)]) for j in range(2)] for i in range(2)] + soft = [[H[i][j] for j in range(2)] for i in range(2)] + C = [[H[i][j + 2] for j in range(n)] for i in range(2)] + Di = [[H[i + 2][j + 2] for j in range(n)] for i in range(n)] + ok20 = soft == [[r * Pi[i][j] for j in range(2)] for i in range(2)] + xxw = [pderiv_at0(ft, eplus(x, x, unit(d, j + 2))) for j in range(n)] + xzw = [pderiv_at0(ft, eplus(x, z, unit(d, j + 2))) for j in range(n)] + ok20 &= C == [[sgn * r / 2 * c for c in xxw], [sgn * r / 2 * c for c in xzw]] + ok20 &= all(Di[i][j] == D[i][j] + sgn * r / 2 * pderiv_at0(ft, eplus(x, unit(d, i + 2), unit(d, j + 2))) + for i in range(n) for j in range(n)) + res["endpoint_blocks_A20"] &= ok20 + # Schur complement K_i = soft - C D_i^{-1} C^T + DinvCT = transpose([solve(Di, [C[i][j] for j in range(n)]) for i in range(2)]) + corr = matmul(C, DinvCT) + if MUT == "no-cross-schur": + corr = [[F(0)] * 2 for _ in range(2)] + K = [[soft[i][j] - corr[i][j] for j in range(2)] for i in range(2)] + Hphys = hessian_at(f, pt, d) + ok22 = det(Hphys) == det(H) == det(Di) * det(K) + negD, _, _ = inertia(Di) + negK, posK, zK = inertia(K) + negH, posH, zH = inertia(Hphys) + ok22 &= negD == n and zK == 0 and zH == 0 and negH == negD + negK + ok22 &= (negH == d) if sgn < 0 else (negH == d - 1) + # K/r - P_i = O(r): exact size check against the explicit bound |C|^2 |D_i^{-1}| / r + ok22 &= max(abs(K[i][j] / r - Pi[i][j]) for i in range(2) for j in range(2)) <= r * k + res["schur_det_inertia_A21_A22"] &= ok22 + dets.append(abs(det(Hphys))) + # H_i u = O(r): H(0) u = 0 exactly by pins, so H_i u = sgn (r/2) (f_xxx, f_xxy...). + Hu = [Hphys[i][0] for i in range(d)] + third = [pderiv_at0(f, eplus(x, x, unit(d, i))) for i in range(d)] + res["Hu_order_r"] &= Hu == [sgn * r / 2 * c for c in third] + res["weight_order_r4"] &= (dets[0] * dets[1] / r ** (8 if MUT == "weight-2d" else 4)) > F(1, 1000) + # Gradient-pin average: r * int_{-1/2}^{1/2} H(t r u) u dt = grad f(S) - grad f(M) = 0. + t = pvar(0, 1) + line = [pscale(t, r)] + [{} for _ in range(d - 1)] + avg = [] + for i in range(d): + col = pcompose(pdiff(pdiff(f, i), 0), line, 1) + prim = {(e[0] + 1,): c / (e[0] + 1) for e, c in col.items()} + avg.append(r * (peval(prim, [F(1, 2)]) - peval(prim, [F(-1, 2)]))) + res["gradient_pin_average_A24"] &= all(v_ == 0 for v_ in avg) + out.update(res) + return out + + +# --------------------------------------------------------------------------------------------------------------- +# QUARTIC group: pins re-solved through the contact frame, O(r) remainder +# --------------------------------------------------------------------------------------------------------------- + +def build_quartic(d, rng, r, k, b, sigma, v, D, tau, quartic): + """Physical quartic field: free jets (transverse Hessian, third derivatives except xxx) from the chart, a fixed + quartic part, and the 2(d+1) U_0 jets (f, f_x, f_xx, f_xxx, f_y, f_xy) solved from the pins.""" + n = d - 2 + q = solve(D, v) if n else [] + a = sigma + sum(vi * qi for vi, qi in zip(v, q)) + x = unit(d, 0) + tau_free = {e: c for e, c in tau.items() if e != eplus(x, x, x)} + cubic_phys = pcompose(from_jets(tau_free, d), shear_subs(d, q, sign=+1), d) + base = padd(cubic_phys, quartic) + A = [[a] + list(v)] + [[v[i]] + list(D[i]) for i in range(n)] + for i in range(d - 1): + for j in range(i, d - 1): + e = eplus(unit(d, i + 1), unit(d, j + 1)) + base = padd(base, {e: A[i][j] / math.prod(factorial(t) for t in e)}) + U0 = [(0,) * d, x, eplus(x, x), eplus(x, x, x)] + for j in range(1, d): + U0 += [unit(d, j), eplus(x, unit(d, j))] + basis = [from_jets({e: 1}, d) for e in U0] + M = [-r / 2] + [F(0)] * (d - 1) + S = [r / 2] + [F(0)] * (d - 1) + rows, rhs = [], [] + for pt, val in ((M, b), (S, b - k * r ** 3)): + rows.append([peval(p, pt) for p in basis]) + rhs.append(val - peval(base, pt)) + for pt in (M, S): + for i in range(d): + rows.append([peval(pdiff(p, i), pt) for p in basis]) + rhs.append(-peval(pdiff(base, i), pt)) + frame_det = det(rows) + coeffs = solve(rows, rhs) + f = padd(base, *[pscale(p, c) for p, c in zip(basis, coeffs)]) + return f, q, frame_det + + +def random_quartic(d, rng, size): + return {e: rat(rng, -size, size) for e in multi(d, 4)} + + +def check_quartic(): + out = {} + rng = random.Random(125003) + k, b = F(6, 5), F(1, 3) + ok_frame = ok_pins = True + rates = {} + hu_rates = {} + grid = [F(i, 4) for i in range(-8, 9)] + for d in (3, 4): + quartic = random_quartic(d, rng, F(1, 2)) + base_rng_state = rng.getstate() + errs, hus = [], [] + for r in (F(1, 8), F(1, 16), F(1, 32), F(1, 64)): + rng.setstate(base_rng_state) + sigma, v, D, tau = sample_chart(d, rng, r, k) + f, q, frame_det = build_quartic(d, rng, r, k, b, sigma, v, D, tau, quartic) + ok_frame &= frame_det != 0 + M = [-r / 2] + [F(0)] * (d - 1) + S = [r / 2] + [F(0)] * (d - 1) + ok_pins &= (peval(f, M) == b and peval(f, S) == b - k * r ** 3 + and all(g == 0 for g in gradient_at(f, M, d) + gradient_at(f, S, d))) + ft = pcompose(f, shear_subs(d, q), d) + x, z = unit(d, 0), unit(d, 1) + s_coef = hessian_at(ft, [F(0)] * d, d)[1][1] / r + P = planar_normal_form(k, s_coef, pderiv_at0(ft, eplus(x, x, z)), pderiv_at0(ft, eplus(x, z, z)), + pderiv_at0(ft, eplus(z, z, z))) + Fr = scaled_plane(ft, d, r, b) + diff = padd(Fr, pscale(P, -1)) + errs.append(max(abs(peval(diff, [X, Z])) for X in grid for Z in grid if X * X + Z * Z <= 9)) + Hs = hessian_at(f, S, d) + hus.append(max(abs(Hs[i][0]) for i in range(d))) + rates[d] = [float(errs[i] / errs[i + 1]) for i in range(3)] + hu_rates[d] = [float(hus[i] / hus[i + 1]) for i in range(3)] + out["contact_frame_nonsingular"] = ok_frame + out["pins_exact_after_solve"] = ok_pins + out["A17_remainder_halves_with_r"] = all(1.6 < x_ < 2.4 for rs in rates.values() for x_ in rs) + out["Hu_halves_with_r"] = all(1.6 < x_ < 2.4 for rs in hu_rates.values() for x_ in rs) + out["_rates"] = {"A17_remainder": {str(d_): [round(x_, 4) for x_ in v_] for d_, v_ in rates.items()}, + "H_S_u": {str(d_): [round(x_, 4) for x_ in v_] for d_, v_ in hu_rates.items()}} + return out + + +# --------------------------------------------------------------------------------------------------------------- +# SADDLES group (NUMERIC) +# --------------------------------------------------------------------------------------------------------------- + +def to_float_poly(p): + return {e: float(c) for e, c in p.items()} + + +def fl_eval(p, pt): + return sum(c * math.prod(x ** k_ for x, k_ in zip(pt, e)) for e, c in p.items()) + + +def lin_solve_float(A, b): + n = len(A) + W = [list(A[i]) + [b[i]] for i in range(n)] + for j in range(n): + p = max(range(j, n), key=lambda i: abs(W[i][j])) + W[j], W[p] = W[p], W[j] + for i in range(n): + if i != j: + f = W[i][j] / W[j][j] + W[i] = [x - f * y for x, y in zip(W[i], W[j])] + return [W[i][-1] / W[i][i] for i in range(n)] + + +def float_inertia(A): + n = len(A) + W = [list(r) for r in A] + neg = 0 + for j in range(n): + piv = W[j][j] + if piv == 0: + return None + neg += piv < 0 + for i in range(j + 1, n): + f = W[i][j] / piv + for l in range(j, n): + W[i][l] -= f * W[j][l] + return neg + + +def newton(grad, hess, x0, steps=60): + x = list(x0) + for _ in range(steps): + g = [fl_eval(p, x) for p in grad] + H = [[fl_eval(p, x) for p in row] for row in hess] + dx = lin_solve_float(H, [-t for t in g]) + x = [a + b for a, b in zip(x, dx)] + if max(abs(t) for t in dx) < 1e-15: + break + return x + + +def check_saddles(): + out = {} + rng = random.Random(125004) + k, b = F(6, 5), F(1, 3) + ok_exist = ok_index = ok_height = ok_distinct = ok_not_planar = True + conv = {} + for d in (3, 4): + n = d - 2 + quartic = random_quartic(d, rng, F(1, 2)) + state = rng.getstate() + errs = [] + for r in (F(1, 16), F(1, 32), F(1, 64), F(1, 128)): + rng.setstate(state) + sigma, v, D, tau = sample_chart(d, rng, r, k) + f, q, _ = build_quartic(d, rng, r, k, b, sigma, v, D, tau, quartic) + ft = pcompose(f, shear_subs(d, q), d) + x, z = unit(d, 0), unit(d, 1) + s_coef = hessian_at(ft, [F(0)] * d, d)[1][1] / r + P = planar_normal_form(k, s_coef, pderiv_at0(ft, eplus(x, x, z)), pderiv_at0(ft, eplus(x, z, z)), + pderiv_at0(ft, eplus(z, z, z))) + Pf = to_float_poly(P) + gP = [to_float_poly(pdiff(P, i)) for i in range(2)] + hP = [[to_float_poly(pdiff(pdiff(P, i), j)) for j in range(2)] for i in range(2)] + ftf = to_float_poly(ft) + g = [to_float_poly(pdiff(ft, i)) for i in range(d)] + h = [[to_float_poly(pdiff(pdiff(ft, i), j)) for j in range(d)] for i in range(d)] + # stable quadratic Q(X, Z) of (A28) from the actual sheared third derivatives + Qs = [] + for j in range(n): + wj = unit(d, j + 2) + t_xx, t_xz, t_zz = (pderiv_at0(ft, eplus(x, x, wj)), pderiv_at0(ft, eplus(x, z, wj)), + pderiv_at0(ft, eplus(z, z, wj))) + Qs.append((float(t_xx), float(t_xz), float(t_zz))) + Df = [[float(D[i][j]) for j in range(n)] for i in range(n)] + rf = float(r) + pts = [] + for sgnZ in (1, -1): + p = newton(gP, hP, [-0.75, sgnZ * math.sqrt(15 / 8)]) + Qp = [t0 / 2 * (p[0] ** 2 - 0.25) + t1 * p[0] * p[1] + t2 / 2 * p[1] ** 2 for (t0, t1, t2) in Qs] + Wstar = lin_solve_float(Df, [-t for t in Qp]) + # the planar restriction's critical point is not a full critical point + grad_w_planar = [fl_eval(g[j + 2], [rf * p[0], rf * p[1]] + [0.0] * n) / rf ** 2 for j in range(n)] + if MUT == "planar-point-is-critical": + ok_not_planar &= max(abs(t) for t in grad_w_planar) < 1e-12 + else: + ok_not_planar &= max(abs(t) for t in grad_w_planar) > 1e-4 + scale_w = rf if MUT == "stable-scale-r" else rf ** 2 + x0 = [rf * p[0], rf * p[1]] + [rf ** 2 * t for t in Wstar] + sol = newton(g, h, x0) + gn = max(abs(fl_eval(gi, sol)) for gi in g) + ok_exist &= gn < 1e-15 and math.dist(sol[:2], x0[:2]) < 8 * rf ** 2 # O(r) shift in scaled units + H = [[fl_eval(hij, sol) for hij in row] for row in h] + ok_index &= float_inertia(H) == d - 1 + height = fl_eval(ftf, sol) + ok_height &= float(b) - float(k) * rf ** 3 < height < float(b) + Wn = [t / scale_w for t in sol[2:]] + errs.append(max(abs(a_ - b_) for a_, b_ in zip(Wn, Wstar)) / rf) + pts.append(sol) + ok_distinct &= math.dist(pts[0], pts[1]) > 0.5 * rf and all( + math.dist(pp, [s_ * rf / 2] + [0.0] * (d - 1)) > 0.5 * rf for pp in pts for s_ in (-1, 1)) + conv[d] = errs + # |w/r^2 - W*| = O(r): the normalized error |w/r^2 - W*| / r stays within a factor 2 over r = 1/16 ... 1/128, + # separately for the + and - saddle (entries alternate + / - per r). + ratios = {d_: [max(e[i::2]) / min(e[i::2]) for i in (0, 1)] for d_, e in conv.items()} + out["two_extra_critical_points_exist"] = ok_exist + out["index_d_minus_1"] = ok_index + out["heights_inside_window"] = ok_height + out["distinct_from_each_other_and_pins"] = ok_distinct + out["planar_critical_point_not_full_critical"] = ok_not_planar + out["stable_displacement_W_converges_at_rate_r"] = all(x_ < 2 for rs in ratios.values() for x_ in rs) + out["_ratios"] = {str(d_): [round(x_, 4) for x_ in rs] for d_, rs in ratios.items()} + return out + + +# --------------------------------------------------------------------------------------------------------------- +# PATH and LEDGER groups +# --------------------------------------------------------------------------------------------------------------- + +def check_path(): + k = F(1) + G = planar_normal_form(k, F(-3, 2), F(0), F(-2), F(0)) + t = pvar(0, 1) + segs = [((F(-1, 2), F(0)), (F(-3, 4), F(0))), ((F(-3, 4), F(0)), (F(-3, 4), F(9, 4))), + ((F(-3, 4), F(9, 4)), (F(-1), F(9, 4)))] + want = [{(2,): F(-3, 16), (3,): F(-1, 32)}, {(0,): F(-7, 32)}, + {(0,): F(-7, 32), (1,): F(51, 64), (2,): F(-9, 32), (3,): F(-1, 32)}] + ok = True + for (p0, p1), w in zip(segs, want): + line = [padd(pconst(p0[i], 1), pscale(t, p1[i] - p0[i])) for i in range(2)] + ok &= pcompose(G, line, 1) == w + ok &= max(p0[0] ** 2 + p0[1] ** 2, p1[0] ** 2 + p1[1] ** 2) <= F(97, 16) < 9 + d3 = {(0,): F(51, 64), (1,): F(-9, 16), (2,): F(-3, 32)} + ok &= min(peval(d3, [F(i, 64)]) for i in range(65)) >= F(9, 64) and peval(d3, [F(1)]) == F(9, 64) + ok &= F(-7, 32) - F(1, 64) > F(-1, 4) and F(17, 64) - F(1, 64) == F(1, 4) + ok &= peval(G, [F(-1, 2), F(0)]) == 0 and peval(G, [F(1, 2), F(0)]) == -1 + # extra saddles of G + Z2 = F(15, 8) + gx = pdiff(G, 0) + ok &= peval(gx, [F(-3, 4), F(0)]) + (-Z2) == 0 # G_X = 6X^2 - 3/2 - Z^2 at X=-3/4 vanishes iff Z^2 = 15/8 + ok &= F(3, 2) + 2 * F(-3, 4) == 0 # G_Z = -Z(3/2 + 2X) vanishes at X = -3/4 + ok &= 2 * F(-3, 4) ** 3 - F(3, 2) * F(-3, 4) - F(1, 2) - (F(3, 4) + F(-3, 4)) * Z2 == F(-7, 32) + ok &= 12 * F(-3, 4) * 0 - 4 * Z2 == F(-15, 2) # det [[-9, -2Z], [-2Z, 0]] = -4 Z^2 + ok &= F(9, 16) + Z2 < 9 + hm = [[peval(pdiff(pdiff(G, i), j), [F(-1, 2), F(0)]) for j in range(2)] for i in range(2)] + hs = [[peval(pdiff(pdiff(G, i), j), [F(1, 2), F(0)]) for j in range(2)] for i in range(2)] + ok &= hm == [[-6, 0], [0, F(-1, 2)]] and hs == [[6, 0], [0, F(-5, 2)]] + return {"path_segments_margins_and_saddle_data": ok} + + +def check_ledger(): + out = {} + ok = True + for d in range(2, 13): + m = d - 1 + U = 2 * (d + 1) + J = m * (m + 1) // 2 + comb(d + 2, 3) - 1 + ok &= U + J == comb(d + 3, 3) + out["jet_count_U0_plus_J_is_binom_d3_3"] = ok + rare, weight, norm = 1, (2 * 4 if MUT == "weight-2d" else 4), 2 + out["ledger_r_r4_over_r2_is_r3_all_d"] = rare + weight - norm == 3 + # ell = k r^3 at fixed k: r dr = (1/3) ell^(-1/3) k^(-2/3) d ell; times (1 - p) ~ r^3 = ell/k. + r_exp = F(1, 3) # r = ell^(1/3) k^(-1/3) + jac_exp_ell = r_exp - 1 + jac_exp_k = -r_exp + measure_ell = (0 if MUT == "density-dr" else r_exp) + jac_exp_ell + measure_k = (0 if MUT == "density-dr" else -r_exp) + jac_exp_k + loss_ell, loss_k = measure_ell + 1, measure_k - 1 + out["density_loss_ell_2_3_k_minus_5_3"] = (measure_ell, measure_k, loss_ell, loss_k) == ( + F(-1, 3), F(-2, 3), F(2, 3), F(-5, 3)) + threshold = F(2, 3) if MUT == "threshold-two-thirds" else loss_ell + 1 + ok_t = threshold == F(5, 3) + for p in (F(1), F(3, 2), F(8, 5)): + ok_t &= (loss_ell - p) > -1 # integrable at 0 + for p in (F(5, 3), F(2)): + ok_t &= (loss_ell - p) <= -1 # not integrable at 0 (log at 5/3) + out["inverse_moment_threshold_5_3"] = ok_t + return out + + +def flatten(d): + for k_, v_ in d.items(): + if k_.startswith("_"): + continue + if isinstance(v_, dict): + yield from flatten(v_) + else: + yield v_ + + +def main(): + global MUT + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + MUT = ap.parse_args().mutant + checks = {"CHART": check_chart(), "PHYSICAL": check_physical(), "QUARTIC": check_quartic(), + "SADDLES": check_saddles(), "PATH": check_path(), "LEDGER": check_ledger()} + passed = all(flatten(checks)) + print(json.dumps({"object": "CLAUDE-REVIEW-ELDER-DIMENSION-LIFT-20260928-v1", "checks": checks, + "passed": passed, + "scope": "exact chart/field identities and one labelled numerical saddle group; " + "not an analytic proof"}, indent=2, sort_keys=True)) + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main()) From 32bec6a9384632b1d8da345674c014c7fb1cae37 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 23:57:36 +0000 Subject: [PATCH 2/3] review record: nonauthor review of #116 C3 remote factorial-pair law (scientific effect NONE) Anthropic nonauthor analytic review of OA-WINDOW-MULTIPLICITY-REMOTE-20260928-v1 (REMOTE_PAIR_LAW.md blob 3fb60204, SHA256 b818a11f) at exact head 0507e3a. Verdict: ACCEPT at the stated fixed-E, fixed-rho existential scope for Theorem R (R4)-(R5) and Theorem H2 (R12)-(R15). No defect found. The reviewer authored RC, whose Lemmas 1, 2, 3, 5 and (3.1) C3 imports; that exposure is disclosed. Independent stdlib checker: exact pair fields with both critical points, congruence limits with exactly linear error, orientation rule vs exact inertia, windows, overlap integral, coefficient, Beta(2/3,2) moments; 5 rejected mutants; output identical in -O. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .github/workflows/remote-pair-law-review.yml | 60 +++++ .../RESULTS.json | 37 +++ .../remote_pair_law_claude_20260928/REVIEW.md | 176 +++++++++++++ .../SOURCE_FILES.json | 37 +++ .../remote_pair_review_check.py | 247 ++++++++++++++++++ 5 files changed, 557 insertions(+) create mode 100644 .github/workflows/remote-pair-law-review.yml create mode 100644 reviews/remote_pair_law_claude_20260928/RESULTS.json create mode 100644 reviews/remote_pair_law_claude_20260928/REVIEW.md create mode 100644 reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json create mode 100644 reviews/remote_pair_law_claude_20260928/remote_pair_review_check.py diff --git a/.github/workflows/remote-pair-law-review.yml b/.github/workflows/remote-pair-law-review.yml new file mode 100644 index 000000000..9a4c5c2d9 --- /dev/null +++ b/.github/workflows/remote-pair-law-review.yml @@ -0,0 +1,60 @@ +name: Remote pair-law nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/remote_pair_law_claude_20260928/**' + - '.github/workflows/remote-pair-law-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/remote_pair_law_claude_20260928').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 / 'remote_pair_review_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['exponent-d', 'chi-orientation', 'coefficient-power', 'beta-normalizer', + 'overlap-exponent'] + 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/remote_pair_law_claude_20260928/RESULTS.json b/reviews/remote_pair_law_claude_20260928/RESULTS.json new file mode 100644 index 000000000..efa24bfa6 --- /dev/null +++ b/reviews/remote_pair_law_claude_20260928/RESULTS.json @@ -0,0 +1,37 @@ +{ + "checks": { + "COEFF": { + "coefficient_54_over_5_times_12_minus_4_3_is_3_40_12_2_3": true + }, + "HEIGHT": { + "beta_normalizer_9_over_10": true, + "gap_moments_R15": true, + "h_integrates_to_one": true, + "independent_uniform_mean_gap_is_one_third": true, + "marginal_and_correlation_R15": true, + "pushforward_jacobian": true, + "triangle_density_integrates_to_one": true + }, + "LEDGER": { + "delta_exponent_is_one_all_d": true, + "r_power_is_five_all_d": true + }, + "OVERLAP": { + "R10_overlap_integral_exact": true, + "envelope_s_min_1_s_minus3_is_3_over_2": true + }, + "PAIR": { + "R2_orientation_matches_exact_inertia": true, + "R8_congruence_limits_with_O_delta_error": true, + "e_to_minus_e_exchanges_ordered_indices": true, + "pair_fields_have_both_critical_points": true, + "same_index_pairs_only_at_order_delta_squared": true + }, + "WINDOW": { + "R9_z_length_is_k_minus_s3_abs_t": true + } + }, + "object": "CLAUDE-REVIEW-REMOTE-PAIR-LAW-20260928-v1", + "passed": true, + "scope": "exact finite identities only; not an analytic proof" +} diff --git a/reviews/remote_pair_law_claude_20260928/REVIEW.md b/reviews/remote_pair_law_claude_20260928/REVIEW.md new file mode 100644 index 000000000..5c4d30ca3 --- /dev/null +++ b/reviews/remote_pair_law_claude_20260928/REVIEW.md @@ -0,0 +1,176 @@ +# Nonauthor analytic review: the leading remote factorial-pair measure and its height-gap law (Math-#116, C3) + +Scientific effect: **NONE**. This file changes no register, status, graph node, lemma flag, prize or author source. +It records a verdict on candidate C3 of `reviews/candidates_pending_20260928/CANDIDATES.md`. Integration is a +separate act. + +## Object + +| Field | Value | +|---|---| +| Object | OA-WINDOW-MULTIPLICITY-REMOTE-20260928-v1 (OpenAI / ChatGPT) | +| Branch / head | `chatgpt/window-multiplicity-laws-20260928` / `0507e3a1dbd3dede84cbeb805947c70aa16ebc36` ([Math-#116](https://github.com/d6g8k5htny-coder/Math-/pull/116)) | +| `REMOTE_PAIR_LAW.md` | Git blob `3fb602040b37158b16ba61bdfc62cc8df1ccc616`, 15878 B, SHA256 `b818a11f1abcf37616d592ecda6341b0d99365cf3ac5047bc2dbaede95da4c5e`, 325 lines | +| Consumed, on main | [RC] `frontiers/remote_collision_20260928/PROOF.md` (blob `7b48a88e…`): (3.1), (4.1)–(4.3), Lemmas 1, 2, 3, 5. [RM] `frontiers/remote_window_20260924/PROOF.md` (blob `b383bfcc…`): contact frame, (8), §4. The D1 normalizer `Z_r/r² → z_0` (reconciled in Math-#126, merged at `8224783`). | +| Request | [Owner comment 5880152796](https://github.com/d6g8k5htny-coder/Math-/pull/116#issuecomment-5880152796); claimed in [5880826796](https://github.com/d6g8k5htny-coder/Math-/pull/116#issuecomment-5880826796) | + +## Provenance and exposure + +| Field | Value | +|---|---| +| Reviewer | Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3` | +| Relation | Different provider from the OpenAI author. Same GitHub account as every lane, so no organizational independence is claimed. | +| Exposure | **I authored [RC]**, whose Lemmas 1, 2 and 5 and formula (3.1) C3 imports verbatim. I also reviewed LP Theorem A (#106), IW (#109) and C1/C2 (#123), and I reconciled D1 (#126). This review therefore checks that C3 uses [RC] correctly. It is not independent evidence for [RC] itself. [RC]'s nonauthor review is the xAI/Harper review 5342481786 on #110, which accepted its finite identities, the (3.1) mark and the Lemma 1 mechanism. | +| Author code | `algebra.py` is absent from the tree, as `PUBLICATION.json` discloses. I did not run, request or reconstruct it. | +| Independent checks | `remote_pair_review_check.py` is my own exact-rational suite, written from the markdown. It covers finite identities only. | + +## Verdicts + +| Interface (lines) | Verdict | +|---|---| +| §1 (8–26): ordered-pair count `T_ij`, `Σ T_ij = N(N−1)`; no event asymptotic inferred | **ACCEPT** | +| §3 (81–121): coupled regression on `(U_r, V_δ)`; convergence to the `(U_0, V_0)` regression; full conditional support of `(B_0, A, T)` | **ACCEPT**; see §1 below. | +| §4 (123–159): (R7) and the congruence limits (R8); `W_r/r² → w_0`; adjacency; same-index pairs are higher order | **ACCEPT**; see §2 below. | +| §5 (161–233): blow-up ledger, windows (R9), domination, fixed-Borel translation, (R10), coefficient (R11) = (R3), separated pairs, positivity and symmetry | **ACCEPT**; see §3 below. | +| **Theorem R (R4)–(R5)**: `E T_ij(E) = r⁵ ∫_E K_ij + o(r⁵)`; `K_ij > 0` iff `|i−j| = 1`; `E N_j(N_j−1) = o(r⁵)` | **ACCEPT** at the stated fixed-`E`, fixed-`ρ`, existential scope | +| **Theorem H2 (R12)–(R15)**: TV convergence of the factorial-pair height measure to `(5/9)|a−b|^{−1/3}`; Beta(2/3, 2) gap; moments | **ACCEPT**; see §4 below. | +| §7 (306–325) exclusions | **ACCEPT** as stated. They are needed: see N2. | + +No defect was found. Notes N1–N4 delimit the result without changing it. + +--- + +## §1 — the coupled conditional frame (§3) + +`V_δ` is exactly [RC] (4.1). Its `δ = 0` extension (R6) follows from the Peano form [RC] (4.2), where +`D3_δ → −(1/12)∂_e³f(x)`. + +[RC] Lemma 1 gives the covariance sandwich for `(U_r, V_δ)` on the compact parameter set, including +`r = δ = 0`. [RC] Lemma 2 gives conditional moments polynomial in `t` and a target density decaying faster than any +power of `t`. + +C3's extra step: regress one smooth field on `O_{r,δ} = (U_r, V_δ)` and let `(r, δ) → 0`. This is sound. The +regression coefficients `Cov(F(z), O)Cov(O)⁻¹` converge because every entry is an integral derivative average +against kernels that tend to point masses, and the inverse is uniformly bounded by the floor. The targets +`a_{r,δ} → (v_0, 0, 0, b, t)`. Hence convergence holds in `L^p(C^q)` on compact target sets. The mean need not +vanish, and C3 does not claim it does (line 114). + +**Full conditional support.** The functionals `(U_0, B_0)` at `0` and `(Y, A, T)` at `x`, with `|x| ≥ ρ`, are +distinct jets of order ≤ 3 at two distinct torus points. They are jointly nondegenerate. A null combination gives +`P(ω) + Q(ω)e^{iω·x} = 0` on the dual lattice. Choose a lattice direction `v` with `v·x ∉ 2πℤ`. Along each lattice +line in direction `v`, a polynomial in `n` would equal a polynomial times `e^{in v·x}`. That forces both polynomials +to vanish, so `P = Q = 0`. + +This argument is mine; the manuscript cites [RM]'s distributional argument. It gives full support of `(B_0, A, T)` +given `(U_0, Y)`. `H ↦ He` is onto `ℝ^d`, and `He` together with `A` exhausts the Hessian entries at `x`. + +## §2 — determinant limits without inverses (§4) + +(R7): on `∇f(x) = ∇f(x+δe) = 0`, +`0 = ∫_0^δ H(x+τe)e dτ = δH_x e + (δ²/2)D³f(x)[e,e,·] + O(δ³‖f‖_{C⁴})`, which is the first line. The second follows +from `H_{x'}e = H_x e + δD³f[e,e,·] + O(δ²)`. + +In a frame beginning with `e`, conjugate by `diag(δ^{−1/2}, I)`: +- the `ee` entry becomes `∓T/2 + O(δ)`; +- the cross entries are `O(√δ)`; +- the lower block is exactly `A` at `x` and `A + O(δ)` at `x'`. + +Congruence preserves inertia and multiplies determinants by `δ^{−1}`. `F_j` is continuous everywhere, including on +singular matrices: it is `|det|` times an index indicator, and `|det| → 0` at the index boundaries. Polynomial moments +then give (R8) in `L^p`. The limit product `(T²/4)(det A)²χ_ij` has index `a+1` at `x` and `a` at `x'` when `T > 0`, +which is (R2). The normalizer `W_r/r² → w_0` and `Z_r/r² → z_0` are the D1 normalizer (I), read with the congruence +erratum `D_r = diag(r^{−1/2}, I)`. + +Exact checks (`PAIR`) use the explicit field +`f(u,v) = (T/6)u³ − (T/4)δu² + ½vᵀAv + (u² − δu)c·v` in d = 2, 3, 4: +- `∇f` vanishes at `0` and `δe`; +- `det H/δ ∓ (T/2)det A = −δ·cᵀadj(A)c` exactly; +- the orientation rule (R2) matches the exact inertia for both signs of `T` and every index of `A`. + +The same-index remark (lines 156–159) is confirmed: `f = c·v(u² − δu) + (λ/2)v²` has `T = 0`, two saddles, and +`det = −c²δ²`, which is order `δ²`. + +## §3 — blow-up, domination, translation, coefficient (§5) + +**Ledger.** The factors are: +- polar coordinates: `δ^{d−1}`; +- the value-gradient change of variables [RC] (4.3): `δ^{−d−3}`; +- the second height `dy' = δ³dt`; +- the determinants: `δ²`. + +The δ-exponent is `(d−1) − (d+3) + 3 + 2 = 1` for every d. With `δ = rs`, `y = b − r³z` and `W/Z → w_0/z_0`, the +r-power is `d + 3 + 3 − (d+3) + 2 = 5` (`LEDGER`, d = 2…10). + +**Windows (R9).** Both heights in `(b − kr³, b)` means `0 < z < k` and `s³t < z < k + s³t`. The `z`-length is +`(k − s³|t|)_+`. This is checked exactly on 400 rational instances (`WINDOW`). + +**Domination.** [RC] Lemmas 3–4 give `W_r ≤ r²K^{2d}` and `|det H_x det H_{x'}| ≤ δ²K^{2d}/4`. [RC] Lemma 2 gives +the envelope `Cs(1+|t|)^{−p}1_{(R9)}`. Integrating over `z` and `t` gives `≤ Cs·min(1, s^{−3})`, whose integral is +finite (`∫_0^∞ s·min(1,s^{−3})ds = 3/2`). The envelope is uniform in `r` and in the compact parameters, and +zero-extension beyond `s < η_0/r` is harmless. Dominated convergence applies. + +**Fixed Borel E.** The factor `1_E(x+rse)` is removed by continuity of translation in `L¹(torus)`. On bounded `s` the +shifts are at most `rS_0`, and the envelope controls `s > S_0`. No boundary regularity is used, and none is claimed +for `r`-dependent `E_r`. The argument is correct as written (lines 193–203). + +**Coefficient.** Integrating `z` gives `(k − s³|t|)_+`. Then +`∫_0^{s_max} s(k − s³|t|) ds = (3/10)k·s_max² = (3/10)k^{5/3}|t|^{−2/3}` (R10), checked exactly (`OVERLAP`). +Multiplying by `36t²` gives `(54/5)k^{5/3}|t|^{4/3}`. With `t = −T/12`, this becomes +`(54/5)·12^{−4/3} = (3/40)·12^{2/3}`, since `54/5 = (3/40)·144` (`COEFF`). The conditional density of `t` given `Y` +converts to `E[·|Y]` with no extra Jacobian. The surface measure and the ordered-pair convention match (R3). Tonelli +away from `t = 0` is the right way to handle the `|t|^{−2/3}` factor. + +**Separated pairs.** [RC] Lemma 5 gives `O(r⁶)|E|²`, which is `o(r⁵)` for fixed `E`. + +**Positivity and symmetry.** The integrand is positive on an open set by §1. Under `e ↦ −e`, `T ↦ −T` while `A` and +`w_0` are unchanged, and the linear map on `Y` has `|det| = 1` at the symmetric target `(0,0,b)`. So +`χ_ij(A,−T) = χ_ji(A,T)` (checked), and `∫_S K_ij = ∫_S K_ji`. Hence (R5). + +## §4 — the factorial-pair height law (§6) + +(R12) is a normalized factorial-moment measure. §6 says explicitly that it is not the event-conditioned pair law, and +this review accepts only the former. + +The dominated convergence of §3 is `L¹` convergence of the blown-up nonnegative densities, not only of their masses. +Pushforward to `(θ, θ') = (z/k, (z − s³t)/k)` contracts TV, and dividing by the converging positive total mass +preserves TV convergence. + +**Jacobian.** With `g = s³|t|/k`, `s ds = (1/3)(k/|t|)^{2/3}g^{−1/3}dg`. This is checked as the exact identity +`s/(dg/ds) = k/(3s|t|)` (`HEIGHT`). With `dz = k dθ` and `θ ∈ (0, 1−g)`, each sign of `T` gives a density +proportional to `g^{−1/3}` on its triangle, of mass `∫_0^1 g^{−1/3}(1−g)dg = 9/10`. The two triangles carry equal +mass by `e ↦ −e`. + +This gives `h = (5/9)|a−b|^{−1/3}`. The index-resolved density is `(10/9)(b−a)^{−1/3}` on `a < b` for `i = j+1`: the +index-`(a+1)` point lies above its adjacent partner. The gap is Beta(2/3, 2), and the following are all exact +(`HEIGHT`): +- the CDF (R14); +- `E g^n = 10/((3n+2)(3n+5))`; +- `E g = 1/4` and `Var g = 9/176`; +- the marginal `(5/6)(a^{2/3} + (1−a)^{2/3})`; +- `E a² = 29/88`, `E ab = 3/11` and `Corr = 2/7`. + +## Notes + +- **N1.** (R3) has hidden `k`-dependence beyond `k^{5/3}`, because `Q_0` conditions on `f_xxx = 12k`. Nothing in + C3 claims otherwise. The coefficient should be read as "`k^{5/3}` times a `k`-dependent Gaussian conditional + integral". +- **N2.** The fixed exclusion `ρ` is load-bearing. [RC] Lemma 1's floor is not uniform as `ρ → 0` ([RC] §8). + LOCAL_MULTIPLICITY shows that pairs near the pins have order `r³`. §7's exclusions are therefore required, not + cosmetic. +- **N3.** A factorial-moment asymptotic does not give `Q(N ≥ 2) ~ (r⁵/2)∫ΣK` without higher factorial moments. + §7 says so, and this review adds nothing there. +- **N4.** Novelty boundary: generic adjacent-index attraction of critical points in the unconditioned isotropic + setting is prior work (Azaïs–Delmas, arXiv:1911.02300). What this review accepts is the pinned, tilted, fixed-`ρ` + coefficient (R3) and the factorial-pair height law (R13), at existential scope. + +## What this review does not do + +It does not review C4 (`REMOTE_DISTANCE_MOMENTS.md`), C5 or C6. It does not accept an event-conditioned pair law, a +global factorial upper bound, uniformity in `ρ → 0` or in oscillating `E_r`, or any numerical coefficient. It does +not run or reconstruct `algebra.py`, and it changes no register. + +## Reproduce + + python -B -S remote_pair_review_check.py # prints RESULTS.json byte for byte + python -B -O -S remote_pair_review_check.py # identical + python -B -S remote_pair_review_check.py --mutant M # exit 1 for each of the 5 mutants diff --git a/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json b/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..61bcc9c1e --- /dev/null +++ b/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json @@ -0,0 +1,37 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW", + "reviewed_object": { + "pr": "d6g8k5htny-coder/Math-#116", + "head": "0507e3a1dbd3dede84cbeb805947c70aa16ebc36", + "paths": [ + { + "path": "frontiers/window_multiplicity_laws_20260928/REMOTE_PAIR_LAW.md", + "git_blob": "3fb602040b37158b16ba61bdfc62cc8df1ccc616", + "bytes": 15878, + "sha256": "b818a11f1abcf37616d592ecda6341b0d99365cf3ac5047bc2dbaede95da4c5e" + } + ] + }, + "files": [ + { + "path": "REVIEW.md", + "bytes": 11936, + "sha256": "c6837a64e5883ed102f346de9f38425d34a813081396cf96aab8434ee0e6fa1d", + "git_blob": "5c4d30ca33a4c5eb66cfe211f72d460b7433003c" + }, + { + "path": "RESULTS.json", + "bytes": 1153, + "sha256": "cab1fe5b10031de837bd8064090db7f276328940fe17d668ec5b6c3645b19fa4", + "git_blob": "efa24bfa60d576063c841c4c9794761a0dbf3b71" + }, + { + "path": "remote_pair_review_check.py", + "bytes": 11665, + "sha256": "2cd9b7f06d15aa26d0c3305294ed95f210689bda52ef149e8d6a43b637dbf9ad", + "git_blob": "20bc1ae2ba45b57143a89344c2f1e6289b159526" + } + ] +} diff --git a/reviews/remote_pair_law_claude_20260928/remote_pair_review_check.py b/reviews/remote_pair_law_claude_20260928/remote_pair_review_check.py new file mode 100644 index 000000000..20bc1ae2b --- /dev/null +++ b/reviews/remote_pair_law_claude_20260928/remote_pair_review_check.py @@ -0,0 +1,247 @@ +"""Independent nonauthor checks for OA-WINDOW-MULTIPLICITY-REMOTE-20260928-v1 (Math-#116, REMOTE_PAIR_LAW.md). + +Python standard library only; exact rational arithmetic throughout. Written from the markdown; the author's absent +algebra.py is neither run nor reconstructed. Groups: + + LEDGER radial and r-power ledgers of the blown-up pair Kac-Rice integral: (d-1)-(d+3)+3+2 = 1 and r^5, d = 2..10. + WINDOW (R9): for rational (z-range, s, t) the admissible z-length is exactly (k - s^3|t|)_+. + OVERLAP (R10) on exact instances with k/|t| a rational cube; the envelope integral of s*min(1, s^-3) is 3/2. + COEFF 36*(3/10) = 54/5 and (54/5)*12^(-4/3) = (3/40)*12^(2/3), i.e. 54/5 = (3/40)*144. + PAIR explicit polynomial fields in d = 2, 3, 4 with critical points at x and x + delta*e: exact congruence limits + F_i(H_x)/delta -> F_i(diag(-T/2, A)), F_j(H_x')/delta -> F_j(diag(T/2, A)) with O(delta) error, the + orientation rule (R2) for both signs of T and every index of A, the e -> -e exchange, and the negative + control: T = 0 with a mixed cubic gives two same-index points with determinants of order delta^2. + HEIGHT the pushforward Jacobian s ds = (1/3)(k/|t|)^(2/3) g^(-1/3) dg; the Beta(2/3, 2) normalization 9/10; h + integrates to 1; the index-resolved triangle density (10/9)(b-a)^(-1/3); moments (R15) and Corr = 2/7. + +Mutants (each must fail): exponent-d, chi-orientation, coefficient-power, beta-normalizer, overlap-exponent. +Not an analytic proof: the Gaussian limit, domination and translation steps are reviewed in REVIEW.md. +""" +import argparse +import json +import random +import sys +from fractions import Fraction as F + +MUTANTS = ("exponent-d", "chi-orientation", "coefficient-power", "beta-normalizer", "overlap-exponent") +MUT = None + + +def det(A): + n = len(A) + M = [list(map(F, r)) for r in A] + d = F(1) + for c in range(n): + p = next((i for i in range(c, n) if M[i][c] != 0), None) + if p is None: + return F(0) + if p != c: + M[c], M[p] = M[p], M[c] + d = -d + d *= M[c][c] + for i in range(c + 1, n): + f = M[i][c] / M[c][c] + M[i] = [x - f * y for x, y in zip(M[i], M[c])] + return d + + +def negatives(A): + """Number of negative eigenvalues of a symmetric rational matrix (sign changes of leading minors, generic).""" + n = len(A) + minors = [F(1)] + [det([row[:k] for row in A[:k]]) for k in range(1, n + 1)] + if any(m == 0 for m in minors): + return None + return sum(1 for a, b in zip(minors, minors[1:]) if (a > 0) != (b > 0)) + + +def chi(i, j, neg_a, T): + """(R2): orientation of the adjacent pair; zero on T = 0.""" + if T == 0: + return 0 + sign = 1 if (T > 0) != (MUT == "chi-orientation") else -1 + return int((i, j) == ((neg_a + 1, neg_a) if sign > 0 else (neg_a, neg_a + 1))) + + +# --------------------------------------------------------------------------------------------------------------- + +def check_ledger(): + ok_delta = ok_r = True + for d in range(2, 11): + polar, density, second_height, dets = d - 1, -(d + 3), 3, 2 + if MUT == "exponent-d": + polar = d + ok_delta &= polar + density + second_height + dets == 1 + # r-powers with delta = r s, y = b - r^3 z: polar r^d, dy r^3, dy' = r^3 s^3 dt, density r^(-d-3), dets r^2, + # W/Z -> w0/z0 (r^2 / r^2). + ok_r &= d + 3 + 3 - (d + 3) + 2 == 5 + return {"delta_exponent_is_one_all_d": ok_delta, "r_power_is_five_all_d": ok_r} + + +def check_window(): + rng = random.Random(116301) + ok = True + for _ in range(400): + k = F(rng.randint(1, 40), rng.randint(1, 9)) + s = F(rng.randint(1, 30), rng.randint(1, 9)) + t = F(rng.randint(-60, 60), rng.randint(1, 9)) + # z in (0,k) and (z-k)/s^3 < t < z/s^3 <=> s^3 t < z < k + s^3 t + lo, hi = max(F(0), s ** 3 * t), min(k, k + s ** 3 * t) + length = max(F(0), hi - lo) + ok &= length == max(F(0), k - s ** 3 * abs(t)) + return {"R9_z_length_is_k_minus_s3_abs_t": ok} + + +def check_overlap(): + ok = True + for m in (1, 2, 3, 5): + for tt in (F(1), F(2), F(1, 3), F(7, 5)): + k = F(m) ** 3 * tt # then s_max = (k/|t|)^(1/3) = m + smax = F(m) + integral = k * smax ** 2 / 2 - tt * smax ** 5 / 5 + expo = F(1, 3) if MUT == "overlap-exponent" else F(2, 3) + # (3/10) k^(5/3) |t|^(-2/3) = (3/10) k (k/|t|)^(2/3) = (3/10) k smax^(3*expo) + ok &= integral == F(3, 10) * k * smax ** (3 * expo) + envelope = F(1, 2) + F(1) # int_0^1 s ds + int_1^inf s^-2 ds + return {"R10_overlap_integral_exact": ok, "envelope_s_min_1_s_minus3_is_3_over_2": envelope == F(3, 2)} + + +def check_coeff(): + # (54/5) 12^(-4/3) = c 12^(2/3) <=> 54/5 = c 12^2 ; mutant uses 12^(-2/3) on the right, i.e. 54/5 = c 12^(2/3+2/3) + power = F(2) if MUT != "coefficient-power" else F(4, 3) + c = F(3, 40) + ok = F(36) * F(3, 10) == F(54, 5) and (power.denominator == 1 and F(54, 5) == c * 12 ** int(power)) + return {"coefficient_54_over_5_times_12_minus_4_3_is_3_40_12_2_3": ok} + + +def pair_field_hessians(T, A, c, delta): + """f(u, v) = (T/6)u^3 - (T/4)delta u^2 + (1/2) v^T A v + (u^2 - delta u) c.v on R x R^(d-1). + grad f vanishes at (0,0) and (delta,0); returns the two Hessians and the gradients there.""" + n = len(A) + def hess(u): + Huu = T * u - T * delta / 2 + Huv = [(2 * u - delta) * ci for ci in c] + return [[Huu] + Huv] + [[Huv[i]] + list(A[i]) for i in range(n)] + def grad(u): + return [T / 2 * u * u - T / 2 * delta * u] + [(u * u - delta * u) * ci for ci in c] + return hess(F(0)), hess(delta), grad(F(0)), grad(delta) + + +def check_pair(): + rng = random.Random(116302) + ok_crit = ok_limit = ok_orient = ok_swap = True + for d in (2, 3, 4): + n = d - 1 + for trial in range(12): + # A diagonal-dominant with a chosen number of negative eigenvalues + a_neg = trial % (n + 1) + A = [[F(0)] * n for _ in range(n)] + for i in range(n): + A[i][i] = F(-(i + 2)) if i < a_neg else F(i + 2) + for j in range(i): + A[i][j] = A[j][i] = F(rng.randint(-2, 2), 10) + if negatives(A) != a_neg: + continue + c = [F(rng.randint(-9, 9), 7) for _ in range(n)] + T = F(rng.choice([-1, 1]) * rng.randint(1, 20), 3) + detA = det(A) + errs = [] + for delta in (F(1, 10), F(1, 100), F(1, 1000)): + Hx, Hy, gx, gy = pair_field_hessians(T, A, c, delta) + ok_crit &= all(v == 0 for v in gx + gy) + # exact: det H / delta -/+ (T/2) det A = -delta c^T adj(A) c, so (error / delta) is delta-independent + errs.append(((det(Hx) / delta - (-T / 2) * detA) / delta, (det(Hy) / delta - (T / 2) * detA) / delta)) + nx, ny = negatives(Hx), negatives(Hy) + if nx is not None and ny is not None: + ok_orient &= all(chi(i, j, a_neg, T) == int((i, j) == (nx, ny)) + for i in range(d + 1) for j in range(d + 1)) + # the limit error is exactly linear in delta, with the same slope at both witnesses + ok_limit &= len(set(errs)) == 1 and errs[0][0] == errs[0][1] + # e -> -e flips T and exchanges the ordered indices + ok_swap &= all(chi(i, j, a_neg, -T) == chi(j, i, a_neg, T) for i in range(d + 1) for j in range(d + 1)) + # Negative control: T = 0 and a mixed cubic give two same-index points with det of order delta^2. + ok_neg = True + for lam, cc in ((F(3), F(2)), (F(-5, 2), F(1, 3))): + for delta in (F(1, 10), F(1, 100)): + H0 = [[F(0), -cc * delta], [-cc * delta, lam]] + H1 = [[F(0), cc * delta], [cc * delta, lam]] + ok_neg &= det(H0) == det(H1) == -(cc * delta) ** 2 + ok_neg &= det(H0) / delta ** 2 == -cc * cc # order delta^2, so zero at the delta^1 scale of (R8) + return {"pair_fields_have_both_critical_points": ok_crit, + "R8_congruence_limits_with_O_delta_error": ok_limit, + "R2_orientation_matches_exact_inertia": ok_orient, + "e_to_minus_e_exchanges_ordered_indices": ok_swap, + "same_index_pairs_only_at_order_delta_squared": ok_neg} + + +def check_height(): + out = {} + # pushforward Jacobian on rational points: s ds/dg = k/(3 s |t|) equals (1/3)(k/|t|)^(2/3) g^(-1/3), g = s^3|t|/k. + ok = True + for s, tt, k in ((F(2), F(1), F(8)), (F(3, 2), F(4, 3), F(9, 4)), (F(1, 2), F(5), F(5, 8))): + g = s ** 3 * tt / k + lhs = s / (3 * s * s * tt / k) # s / (dg/ds) + # (k/|t|)^(2/3) g^(-1/3) = (k/|t|)^(2/3) (k/(s^3 |t|))^(1/3) = (k/|t|) / s + rhs = F(1, 3) * (k / tt) / s + ok &= lhs == rhs + out["pushforward_jacobian"] = ok + # int_0^1 g^(-1/3) (1-g) dg = 3/2 - 3/5 = 9/10 + norm = F(3, 2) - F(3, 5) + target = F(1) if MUT == "beta-normalizer" else F(9, 10) + out["beta_normalizer_9_over_10"] = norm == F(9, 10) and norm == target + # h(a,b) = (5/9)|a-b|^(-1/3) integrates to 1: 2 * int_0^1 int_0^b (b-a)^(-1/3) da db = 2 * (3/2)(3/5) + out["h_integrates_to_one"] = F(5, 9) * 2 * F(3, 2) * F(3, 5) == 1 + # index-resolved triangle density (10/9)(b-a)^(-1/3) on a= 1 and rational q > 0: B(p,q) = (p-1)! / (q (q+1) ... (q+p-1)).""" + assert p.denominator == 1 and p >= 1 + out = F(1) + for i in range(int(p) - 1): + out *= F(i + 1) + den = F(1) + for i in range(int(p)): + den *= (q + i) + return out / den + + +def flatten(d): + for v in d.values(): + if isinstance(v, dict): + yield from flatten(v) + else: + yield v + + +def main(): + global MUT + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + MUT = ap.parse_args().mutant + checks = {"LEDGER": check_ledger(), "WINDOW": check_window(), "OVERLAP": check_overlap(), "COEFF": check_coeff(), + "PAIR": check_pair(), "HEIGHT": check_height()} + passed = all(flatten(checks)) + print(json.dumps({"object": "CLAUDE-REVIEW-REMOTE-PAIR-LAW-20260928-v1", "checks": checks, "passed": passed, + "scope": "exact finite identities only; not an analytic proof"}, indent=2, sort_keys=True)) + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main()) From a18bd244b132df3b512c60636bc4af5514b2522f Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 29 Sep 2026 00:08:33 +0000 Subject: [PATCH 3/3] review records: dependency and wording clarifications requested in 5881054670 (scientific effect NONE) - #125 record, section 5: the floating-point SADDLES group is described as a numerical illustration (numerical roots with residual below 1e-15; the factor-2 band is consistent with the O(r) estimate proved analytically, not established by finite samples). Existence comes from the uniform inverse-function argument. - C3 record, Object row and section 2: Z_r is RM's full endpoint-only normalizer; W_r/r^2 -> w_0 under the additional pair conditioning follows from C3 section 3's coupled moment bounds plus RM section 4's endpoint identities, not from the unconditioned D1 normalizer limit alone. N2 now says the planar local result gives an r^3 lower obstruction (and a factorial lower bound), not an all-dimensional exact factorial asymptotic. Checker programs, RESULTS.json bytes and scoped verdicts are unchanged; the two SOURCE_FILES.json manifests are regenerated. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../REVIEW.md | 14 ++++++++------ .../SOURCE_FILES.json | 6 +++--- .../remote_pair_law_claude_20260928/REVIEW.md | 16 +++++++++++----- .../SOURCE_FILES.json | 6 +++--- 4 files changed, 25 insertions(+), 17 deletions(-) diff --git a/reviews/elder_dimension_lift_claude_20260928/REVIEW.md b/reviews/elder_dimension_lift_claude_20260928/REVIEW.md index e5984338e..e2b9fcdc8 100644 --- a/reviews/elder_dimension_lift_claude_20260928/REVIEW.md +++ b/reviews/elder_dimension_lift_claude_20260928/REVIEW.md @@ -145,12 +145,14 @@ The rescaling `x = rX, z = rZ, w = r²W` is the right one. I rederived (A27) ter Heights are `b + r³(F_r(p) + O(r))`, strictly inside the window. The index is `n + 1 = d − 1`, by the same Schur argument as §4. -`SADDLES` checks this in floating point on quartic fields in d = 3, 4 for `r = 1/16 … 1/128`: - -- Both extra critical points exist, with gradient residual below `1e−15`, index d − 1 and heights in `(b − kr³, b)`. - They are distinct from each other and from the pins. -- `|w/r² − W*|/r` stays within a factor 2 across the range, so the stable correction is `O(r)`. Scaling `w` by `r` - instead of `r²` is rejected. +`SADDLES` illustrates this in floating point on quartic fields in d = 3, 4 for `r = 1/16 … 1/128`. It is a numerical +illustration only: existence and the `O(r)` estimate come from the uniform inverse-function argument above, not from +the solver or finite samples. + +- Newton finds two numerical roots of the full gradient near `(rP_±, r²W*)`, with gradient residual below `1e−15`, + index d − 1 and heights in `(b − kr³, b)`. They are distinct from each other and from the pins. +- `|w/r² − W*|/r` stays within a factor 2 across the range. This is consistent with the `O(r)` estimate proved + analytically above; finite samples do not establish it. Scaling `w` by `r` instead of `r²` is rejected. - At the planar restriction's critical point, `∂_w f̃/r²` is nonzero. This confirms the manuscript's warning (line 365) that a planar critical point is not a full critical point. diff --git a/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json b/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json index f5a8f9024..4fce098c6 100644 --- a/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json +++ b/reviews/elder_dimension_lift_claude_20260928/SOURCE_FILES.json @@ -17,9 +17,9 @@ "files": [ { "path": "REVIEW.md", - "bytes": 16746, - "sha256": "a937a36813faff5afb9b6ed135cb838d14dde8ddfbdbc7e6ad37534a2b5c9c62", - "git_blob": "e5984338eb48cd496d3e9b6c0ddc9322dcc1465b" + "bytes": 17030, + "sha256": "032bb4c79e4a985e5b53f5abb6bb06da4d643ec7345e4df9591e2046fb287e12", + "git_blob": "e2b9fcdc8d24f6a4d532afb7d02627e4716158d1" }, { "path": "RESULTS.json", diff --git a/reviews/remote_pair_law_claude_20260928/REVIEW.md b/reviews/remote_pair_law_claude_20260928/REVIEW.md index 5c4d30ca3..d45accbbc 100644 --- a/reviews/remote_pair_law_claude_20260928/REVIEW.md +++ b/reviews/remote_pair_law_claude_20260928/REVIEW.md @@ -11,7 +11,7 @@ separate act. | Object | OA-WINDOW-MULTIPLICITY-REMOTE-20260928-v1 (OpenAI / ChatGPT) | | Branch / head | `chatgpt/window-multiplicity-laws-20260928` / `0507e3a1dbd3dede84cbeb805947c70aa16ebc36` ([Math-#116](https://github.com/d6g8k5htny-coder/Math-/pull/116)) | | `REMOTE_PAIR_LAW.md` | Git blob `3fb602040b37158b16ba61bdfc62cc8df1ccc616`, 15878 B, SHA256 `b818a11f1abcf37616d592ecda6341b0d99365cf3ac5047bc2dbaede95da4c5e`, 325 lines | -| Consumed, on main | [RC] `frontiers/remote_collision_20260928/PROOF.md` (blob `7b48a88e…`): (3.1), (4.1)–(4.3), Lemmas 1, 2, 3, 5. [RM] `frontiers/remote_window_20260924/PROOF.md` (blob `b383bfcc…`): contact frame, (8), §4. The D1 normalizer `Z_r/r² → z_0` (reconciled in Math-#126, merged at `8224783`). | +| Consumed, on main | [RC] `frontiers/remote_collision_20260928/PROOF.md` (blob `7b48a88e…`): (3.1), (4.1)–(4.3), Lemmas 1, 2, 3, 5. [RM] `frontiers/remote_window_20260924/PROOF.md` (blob `b383bfcc…`): contact frame, (8), the §4 deterministic endpoint identities, and its full endpoint-only normalizer `Z_r/r² → z_0` (the same limit as D1 (I), reconciled in Math-#126, merged at `8224783`). | | Request | [Owner comment 5880152796](https://github.com/d6g8k5htny-coder/Math-/pull/116#issuecomment-5880152796); claimed in [5880826796](https://github.com/d6g8k5htny-coder/Math-/pull/116#issuecomment-5880826796) | ## Provenance and exposure @@ -78,8 +78,13 @@ In a frame beginning with `e`, conjugate by `diag(δ^{−1/2}, I)`: Congruence preserves inertia and multiplies determinants by `δ^{−1}`. `F_j` is continuous everywhere, including on singular matrices: it is `|det|` times an index indicator, and `|det| → 0` at the index boundaries. Polynomial moments then give (R8) in `L^p`. The limit product `(T²/4)(det A)²χ_ij` has index `a+1` at `x` and `a` at `x'` when `T > 0`, -which is (R2). The normalizer `W_r/r² → w_0` and `Z_r/r² → z_0` are the D1 normalizer (I), read with the congruence -erratum `D_r = diag(r^{−1/2}, I)`. +which is (R2). + +The weight and normalizer limits have two separate sources. `Z_r` is [RM]'s full endpoint-only normalizer, so +`Z_r/r² → z_0` is unconditioned; it is the same limit as D1 (I). The weight limit `W_r/r² → w_0` is needed *under the +additional pair conditioning* on `V_δ`. It follows from C3 §3's coupled conditional moment bounds together with +[RM] §4's deterministic endpoint identities, which use the congruence `D_r = diag(r^{−1/2}, I)`. The unconditioned D1 +normalizer limit alone would not establish this extra-conditioned weight limit. Exact checks (`PAIR`) use the explicit field `f(u,v) = (T/6)u³ − (T/4)δu² + ½vᵀAv + (u² − δu)c·v` in d = 2, 3, 4: @@ -155,8 +160,9 @@ index-`(a+1)` point lies above its adjacent partner. The gap is Beta(2/3, 2), an C3 claims otherwise. The coefficient should be read as "`k^{5/3}` times a `k`-dependent Gaussian conditional integral". - **N2.** The fixed exclusion `ρ` is load-bearing. [RC] Lemma 1's floor is not uniform as `ρ → 0` ([RC] §8). - LOCAL_MULTIPLICITY shows that pairs near the pins have order `r³`. §7's exclusions are therefore required, not - cosmetic. + Near the pins, the integrated planar LOCAL_MULTIPLICITY result gives an `r³` lower obstruction for the probability + of multiple occurrences (and a factorial *lower* bound). It does not establish an all-dimensional or global exact + `r³` factorial asymptotic. §7's exclusions are therefore required, not cosmetic. - **N3.** A factorial-moment asymptotic does not give `Q(N ≥ 2) ~ (r⁵/2)∫ΣK` without higher factorial moments. §7 says so, and this review adds nothing there. - **N4.** Novelty boundary: generic adjacent-index attraction of critical points in the unconditioned isotropic diff --git a/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json b/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json index 61bcc9c1e..05948195f 100644 --- a/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json +++ b/reviews/remote_pair_law_claude_20260928/SOURCE_FILES.json @@ -17,9 +17,9 @@ "files": [ { "path": "REVIEW.md", - "bytes": 11936, - "sha256": "c6837a64e5883ed102f346de9f38425d34a813081396cf96aab8434ee0e6fa1d", - "git_blob": "5c4d30ca33a4c5eb66cfe211f72d460b7433003c" + "bytes": 12618, + "sha256": "b08f1cdca8e179d9910be89e37e4a03a864b8c1cbcbc6e71cd1fdc359d2a391f", + "git_blob": "d45accbbc92756c24e7eada96ddd0bea0a703c22" }, { "path": "RESULTS.json",