Struct MeasureJetRangeBracket 

pub struct MeasureJetRangeBracket {
    pub nodes: Vec<f64>,
    pub log_step: f64,
    pub node_diameter: f64,
    pub feasibility_ceiling: f64,
}

The deterministic bracket the representer range ℓ is SCREENED over before the outer ψ search refines it, in the STANDARDIZED frame the basis is realized in (gam#2750).

Why a bracket exists at all

ℓ is a design-moving coordinate: it decides WHICH span the representers occupy, and the outer search reaches it by local descent from the seed. The profiled criterion in ln ℓ is not unimodal — as ℓ grows past a few center spacings the Gaussian columns become collinear, the rank-revealing identifiability section drops columns, and the criterion steps. Measured on measure_jet_formula_fit_robustness_sweep seed 1 (n = 200, one sine cycle): a local minimum at the auto range ℓ = 0.020 (V = −234.5), a barrier at ℓ = 0.035 (V = −231.1), and the GLOBAL minimum at ℓ = 0.80 (V = −256.3) — 21.7 log units deeper, with held-out RMSE 0.0084 against 0.0175, i.e. the same basis fitting 2.1× better and beating tp on both the criterion and the truth instead of losing on both. A local descent seeded inside the first basin cannot cross that barrier, and the frozen coefficient chart the ψ trials rebuild in stops being evaluable ~1.6× past the seed, so the search terminates essentially where it started. The λ that comes back is then a faithful readout of a range nothing could move — which is the “1-D fits select a too-large λ” this bracket exists to end.

Why THIS bracket

The nodes are the term’s own realized scale band, verbatim. That is not a coincidence of convenience: the energy’s ε and the representer range ℓ are the same physical quantity — a length in the chart — and the band is already derived, not chosen: its floor is the median nearest-node spacing (below it neighbouring representers stop overlapping and the design is a bump-per-node indicator with no partition of unity) and its ceiling is half the node bounding-box diagonal, at the band’s own auto-clamped resolution. So the screen introduces no length, no count and no step of its own.

Where a walk past the top node stops (#2761)

MeasureJetRangeBracket::feasibility_ceiling — the range at which the closest node pair stops being distinguishable in the chart’s own arithmetic, measure_jet_range_feasibility_ceiling. It is the SAME wall measure_jet_ln_range_window gives the outer search, and it is the same wall for the same reason: a stopping rule may not be tighter than the model.

It used to be MeasureJetRangeBracket::node_diameter, on the argument that at ℓ that long every pair of representers overlaps at ≥ exp(−1/2) so “there is no distinct model past it”. That argument is measurably wrong, and the tree said so in two places before this: measure_jet_ln_range_window records that “the profiled criterion genuinely prefers a range AT or ABOVE the node diameter” on three fixtures, and the_search_window_reaches_past_where_the_screen_stops_walking pins the search window as strictly wider. Those reconcile only while something else keeps searching past the stopping rule. On a term whose ℓ dial is FROZEN — the BMS marginal/log-slope pair, or any learn_length_scale=false — nothing does, and the stopping rule becomes the wall.

Measured on the #1041 parity fixture (m = 10, extent [2.671, 2.726]): band [1.08074, 1.43607, 1.90823], log_step = 0.284265, node diameter 3.81645. The screen’s chosen range for the marginal surface was 3.36930 — walk node 2 to every printed digit, with walk node 3 at 4.47708 past the diameter. The walk pushes a node and only then breaks if it failed to improve, so an argmin that IS the last pushed node improved: the walk left through the ceiling test with the criterion still descending.

What raising the stop was actually worth here, measured after the change, because it is less than the shape of the defect suggests. The walk now scores 4.47708, which does NOT improve — so the criterion has an interior optimum on this fixture and the old ceiling happened to cut just past it. What the extra node buys is the PARABOLIC REFINEMENT, which cannot fire on an argmin that is the last element: with a neighbour on both sides the refinement lands at ℓ = 3.10543 with a better criterion value, and held-out marginal RMSE goes 0.04185 → 0.04179. A rule that cannot be stepped past also cannot be refined at, and that is the part of the cost that was invisible.

The larger held-out number on the same sweep — 0.03788 at ℓ = 68.5, where the block still carries edf = 7.47 and is not degenerate — is NOT what this change recovers, and attributing it to the ceiling would be wrong: the criterion does not want to go there. That gap is a statement about the screening CRITERION (a profiled Gaussian REML of the term alone against a binary response) disagreeing with held-out truth at long ranges, and it belongs to whoever takes that question next.

Raising the stop is safe by the walk’s own rule, which only continues while the criterion improves: on the gam#2750 fixture, where the criterion drops from −256.3 to −198.5 just past the diameter, the walk stops on the first non-improving node exactly as it does today. The ceiling only ever binds where the criterion is still descending — which is precisely the case where stopping is wrong.

Fields

nodes: Vec<f64>

Geometric grid of candidate ranges, ascending. The realized scale band.

log_step: f64

The band’s own log step, so an endpoint walk keeps its resolution.

node_diameter: f64

The node bounding-box diagonal. A geometric fact about the cloud, reported because the band’s own ceiling is half of it; NOT a stopping rule (see the type docs).

feasibility_ceiling: f64

Hard upper end for any walk past the top node: the feasibility wall measure_jet_range_feasibility_ceiling, the same one the outer search’s measure_jet_ln_range_window stops at.

Trait Implementations

impl Clone for MeasureJetRangeBracket

fn clone(&self) -> MeasureJetRangeBracket

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MeasureJetRangeBracket

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.