Pairwise velocity moments — `vel_m10 … vel_c22`, `vel_binned`¶

Eight central moments of the radial pairwise velocity between halo mass-bin pairs, on a radial grid — plus a derived recipe (vel_binned) that aggregates them exactly onto whole-cell mass bins within its weight-model support.

m10 = reg.predict("vel_m10", "LCDM", 0.25, [0.31, 0.677, 0.967, 0.83])   # (1, 105, 57)
art = reg.load("vel_m10", "LCDM", 0.25)
art.pair_keys   # 105 unordered mass-bin pairs
art.r           # 57 radial-bin centres; edges span [0.352, 150] Mpc/h

Keys: vel_m10, vel_c20, vel_c02, vel_c12, vel_c30, vel_c40, vel_c04, vel_c22 (trained), and vel_binned (derived).
Output: (1, 105, 57) — 105 mass-pair × 57 radial bins (trimmed columns NaN).
Mass bins: 14 adaptive bins over log₁₀M ∈ [12.5, 15.5] — 0.1 dex over [12.5, 13.5), 0.25 dex over [13.5, 14.0), [14.0, 14.2), and one broad terminal cell [14.2, 15.5) — giving 105 unordered pairs. A separate [14.7, 15.5) cell was rejected by a direct pair-count pilot (only 3 in-range pairs in the weakest design box), so the broad cell is the highest-resolution binning supported across the full design.
Radial grid: 57 bins — 26 native logarithmic 0.05-dex cells over [0.352, 7] Mpc/h, stitched exactly to the wider grid above 7 and ending at 150 Mpc/h. The native small-r cells resolve the exclusion region; the wide high-r cells reduce sampling noise.

Moments¶

Moment	Meaning	Sign	Transform
`m10`	mean radial infall	signed	arcsinh
`c20`	variance ∥	+	log
`c02`	variance ⊥	+	log
`c12`	skew cross term	signed	arcsinh
`c30`	skew ∥	signed	arcsinh
`c40`, `c04`, `c22`	4th-order	+	log

Representation & accuracy¶

Each moment is a weighted-PCA GP (n_components = 16, except 24 for f(R) c22; n_restarts = 10) under the per-moment transform above (log for positive moments, arcsinh for signed) — the transform is what holds the high-order moments at the noise floor. Every emulator carries a frozen-seed ε de-bias correction calibrated on the full 14-bin columns (vel_fine_seed_debias.py).

The honest per-emulator numbers (in-sample and interior corner-excluded LOO χ) live in the manifest: reg.entry("vel_c20", gravity, 0.25)["accuracy"]. On the current 14-bin grid, the end-to-end 5-box recipe validation is χ 0.71–1.18 (ΛCDM) and 1.15–2.26 (f(R), all eight moments and all supported bin sets). The extension-specific tests are sharper: new high-mass pairs have interior-LOO χ 1.04–1.33 / 1.14–1.61 and 5-box aggregated χ 0.82–1.19 / 0.97–1.40 (ΛCDM / f(R)). Against fresh-seed boxes, the high-mass aggregate median over moments is χ ≈ 1.0–1.4 through 15 Mpc/h, rising to 2.33 / 2.06 over 15–150 Mpc/h where the 70-box / two 27-box means have much tighter SEMs. There is no complete terminal-cell aggregate below 1.25 Mpc/h because halo exclusion leaves no pairs. Evidence: registration_massext/, validation_gates.pdf, and validation_heldout.pdf from plot_velocity_mass_extension_validation.py.

χ, not fractional error

Velocity moments cross zero, so fractional error is meaningless. Accuracy is quoted as χ = residual / SEM; χ < 1 means at or below the simulation noise floor.

`vel_binned` — whole-cell mass bins¶

The trained surfaces live on the 14-bin grid; vel_binned aggregates all eight moments onto your mass bins through the exact raw-moment pair-count algebra (weights n_a n_b (1 + ξ_hh^ab(r)) modelled from the hmf + bias/ξ emulators; weight-model error vs measured pair counts: median 2–6×10⁻⁴):

res = reg.predict("vel_binned", "LCDM", 0.25, th,
                  mass_edges=[12.5, 13.0, 13.5],   # edges ON the native grid
                  moments=("m10", "c20"))
res["moments"]["m10"]    # (Nbin, Nbin, 57); res["r"], res["validity"]

Edges must be built from whole fine-grid cells — whole-bin aggregation is what keeps the conversion exact. The weight emulators do not reach the native velocity endpoint: vel_binned is served through log₁₀M=14.2 for ΛCDM and 14.0 for f(R). Direct vel_<moment> surfaces still cover [12.5, 15.5]; res["validity"] reports both the aggregation and native limits.

f(R) — all 8 moments¶

The f(R) velocity moments are registered (z = 0.25) for all eight moments, as seed-paired boosts composed onto the ΛCDM emulator: log-ratio for the positive 4th moments (c40, c04, c22), additive-arcsinh for c20/c02/c12/c30; m10 uses the direct 5-parameter GP. The per-box seed-paired difference cancels most of the cosmic variance.

vel_c12/fRn1 was the late arrival (registered 2026-07-15): its first boost — fitted on the retired 72-bin narrow grid with a noise-scaled transform — failed the aggregation acceptance test in 2026-07 and the moment shipped ΛCDM-only for two weeks. Re-tested on the current wide bins with the family's plain additive-arcsinh transform it passes every test: interior LOO χ = 1.51 (in-family), fiducial aggregation χ = 1.24 (ceiling 2.5), independent-seed 25-box aggregation χ = 1.53 with the seed correction on (family range 1.1–2.3). Until then the recipe returned NaN for f(R) c12; that behaviour survives only as a fallback if no f(R) vel_c12 resolves from the registry.

f(R) is intrinsically harder (a fifth parameter over the same design points): on the full 14-bin grid the boosts' design-interior LOO spans χ = 1.47–3.29, while the 14 newly added high-mass pairs alone span only 1.14–1.61 (at the retired narrow binning the noisy fourth moments ran up to χ ≈ 7) — a design-sampling limit (the direct GP is worse), not a representation failure. The five signal-weighted supplemental pairs (imodel 68–72) now train the c02, c20 and c12 boosts (interior LOO 2.03→1.57, 1.89→1.59, and 1.51 for the newly admitted c12); the other four f(R) moments keep design-only training — augmenting them tests worse (blanket augmentation would take m10 from χ 1.43 to 2.58). All ΛCDM moments train on the augmented set. See f(R) gravity.

Rejected levers (don't re-explore)¶

Established on the campaign-era measurements (scripts now in git history):

Standardized moments (kurtosis c40/c20², etc.): the dimensionless ratio cancels ~4× of the across-box variance, but reconstructing the raw moment re-injects it — no deployable gain for the raw moments.
r_max trimming: trimming the large-r tail makes LOO χ worse for every moment; the full r-range carries signal and the SEM-weighted PCA already down-weights the noisy columns. (Bin-width choices, by contrast, paid off twice: the first exploration replaced the linear 2.5 Mpc/h grid, which lost 2–23× the noise floor below r = 10, with a quasi-log one; the second, 2026-07, widened the high-r backbone now used by the 57-bin small-r-stitched grid.)

Evidence scripts¶

vel_fine_lcdm_eval.py, vel_fine_frn1_eval.py, vel_fine_recon_gate.py, vel_rbin_explore.py, vel_rwidth_explore.py, vel_widea_vs_logb_fiducial.py, vel_frn1_indepseed_oos.py, vel_fine_seed_debias.py, vel_fine_register.py, velocity_mass_support_audit.py, velocity_mass_extension_register.py, plot_velocity_mass_extension_validation.py, plot_velocity_fine.py. (The retired 0.5-dex-era scripts — vel_validation.py, velocity_ablation.py, plot_velocity.py, … — live in git history.)

Pairwise velocity moments — vel_m10 … vel_c22, vel_binned¶