Enum CurvatureEvidence 

pub enum CurvatureEvidence {
    Measured {
        psd: bool,
    },
    NotSpent,
    NotAvailable,
    NoEstimand,
    CriterionContradicted,
}

What curvature evidence a certificate actually has (#2561).

This was Option<bool>, and its None carried FOUR structurally different meanings that OuterCriterionCertificate::curvature_admissible accepted alike:

1. a multi-start screening pass deliberately declined to spend the order-four derivative ladder (Self::NotSpent);
2. the route exposes no analytic Hessian at all (Self::NotAvailable);
3. the EFS/fixed-point route, which has none by construction (same);
4. there is no outer estimand to have curvature (Self::NoEstimand).

Case 1 is deliberate and documented — screening is a first-order gate, and “the one order-four evaluation belongs to the winner”. But that design also promises the winner’s verdict is the one that mints, and while None meant all four things at once, nothing could check it: a Mint-fidelity refusal to measure was byte-identical to a screening pass that chose not to. Naming the states makes that promise assertable.

Acceptance is unchanged. Only Self::Measured with psd: false is a negative verdict; every other state passes, exactly as != Some(false) did.

Serialized form

Serializes as the legacy Option<bool> under the legacy key, because hessian_psd is a published Python contract (gamfit/_summary.py) whose domain is null | true | false, and because stored model bytes carry this field with no version tag. The round trip is therefore deliberately LOSSY: NotSpent and NoEstimand both reload as NotAvailable. That is sound because the three are acceptance-identical, and screening certificates are never persisted — only the winner mints.

Variants

Measured

A Hessian existed at the certified point and was tested.

Fields

psd: bool

NotSpent

A screening pass declined to spend the order-four ladder. A certificate minted at CertificationFidelity::Mint must never carry this.

NotAvailable

The route exposes no analytic Hessian, so there was nothing to test.

NoEstimand

A zero-dimensional outer problem: no estimand, so no curvature exists to be admissible or otherwise. Distinct from Self::NotAvailable, which means a curvature question existed and could not be answered.

CriterionContradicted

A Hessian was measured, reported a negative direction, and the criterion itself was then asked about that direction and did not fall (#2612).

The escape steps ρ ± αv along the reported minimum eigenvector, in both signs, from one e-fold down to the step at which the quadratic model’s own predicted decrease ½|λ_min|α² reaches the criterion’s resolution. Below that step the claim predicts nothing the criterion can represent, so that ladder covers the claim’s WHOLE falsifiable range. A direction that lowers the objective nowhere in it is not a descent direction of this criterion, whatever the matrix says.

This is a statement about the MATRIX, not about the point, and it is the reason the second-order conjunct does not refuse here: refusing would spend evidence the criterion has just contradicted. It is deliberately NOT Self::Measured with psd: true — nothing established that the point is a minimum either; what was established is that this Hessian’s negative direction has no operational content.

Reachable only where an analytic Hessian exists AND the objective can be re-evaluated at trial points, which is exactly where the escape runs.

Serializes as null under the legacy hessian_psd key and reloads as Self::NotAvailable — the same deliberate lossiness the module doc already records for NotSpent/NoEstimand, and sound for the same reason: the four are acceptance-identical, and the adjudication is a statement about a run, not a property of a stored model.

Implementations

impl CurvatureEvidence

pub fn psd(self) -> Option<bool>

The raw PSD verdict when one was measured, None otherwise — the legacy projection, and what the published hessian_psd surface shows.

pub fn was_measured(self) -> bool

Whether a curvature question was actually answered here.

Self::CriterionContradicted answers false: a Hessian was measured there, but its verdict was withdrawn by the criterion, so no curvature ANSWER survives. Reporting true would let a consumer that asked for a real second-order guarantee read a withdrawn verdict as a delivered one, which is the #2578 conflation one variant further along.

pub fn from_measurement(psd: Option<bool>) -> CurvatureEvidence

Build from a raw optional measurement: Some was measured, None means the route had no analytic Hessian to test. Sites that mean Self::NotSpent or Self::NoEstimand must say so explicitly — that is the point of the type.

Trait Implementations

impl Clone for CurvatureEvidence

fn clone(&self) -> CurvatureEvidence

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CurvatureEvidence

impl Debug for CurvatureEvidence

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CurvatureEvidence

fn deserialize<__D>( __deserializer: __D, ) -> Result<CurvatureEvidence, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CurvatureEvidence

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

Formats the value using the given formatter.

impl Eq for CurvatureEvidence

impl From<Option<bool>> for CurvatureEvidence

fn from(psd: Option<bool>) -> CurvatureEvidence

Converts to this type from the input type.

impl PartialEq for CurvatureEvidence

fn eq(&self, other: &CurvatureEvidence) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for CurvatureEvidence

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CurvatureEvidence