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/.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/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..e2b9fcdc8 --- /dev/null +++ b/reviews/elder_dimension_lift_claude_20260928/REVIEW.md @@ -0,0 +1,200 @@ +# 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` 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. + +## §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..4fce098c6 --- /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": 17030, + "sha256": "032bb4c79e4a985e5b53f5abb6bb06da4d643ec7345e4df9591e2046fb287e12", + "git_blob": "e2b9fcdc8d24f6a4d532afb7d02627e4716158d1" + }, + { + "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()) 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..d45accbbc --- /dev/null +++ b/reviews/remote_pair_law_claude_20260928/REVIEW.md @@ -0,0 +1,182 @@ +# 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), 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 + +| 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 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: +- `∇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). + 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 + 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..05948195f --- /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": 12618, + "sha256": "b08f1cdca8e179d9910be89e37e4a03a864b8c1cbcbc6e71cd1fdc359d2a391f", + "git_blob": "d45accbbc92756c24e7eada96ddd0bea0a703c22" + }, + { + "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())