Struct OuterCriterionCertificate 

pub struct OuterCriterionCertificate {
    pub stationarity: OuterStationarityCertificate,
    pub curvature: CurvatureEvidence,
    pub lambdas_railed: Vec<usize>,
    pub railed_facts: Vec<RailedCoordinateFact>,
    pub curvature_floor: Option<CurvatureFloorClearance>,
}

Fields

stationarity: OuterStationarityCertificate

curvature: CurvatureEvidence

What curvature evidence this certificate has, and why it has no more than that (#2561). Serializes as the legacy hessian_psd optional bool; read the raw verdict through Self::hessian_psd.

lambdas_railed: Vec<usize>

Leading smoothing coordinates (ρ block) pinned within CERTIFICATE_RAIL_MARGIN of either box bound at the optimum.

railed_facts: Vec<RailedCoordinateFact>

The interval and margin each railed coordinate was judged against (#2530). Empty when nothing is railed. #[serde(default)] so a certificate stored before this field existed still deserializes — those carry no facts, which is honest: none were recorded.

curvature_floor: Option<CurvatureFloorClearance>

The gradient-residue floor’s verdict on that same curvature, when it was computed. hessian_psd above stays the raw measurement; this records whether the most negative interior direction is below the instrument’s own resolution, and by how much.

Implementations

impl OuterCriterionCertificate

pub fn is_stationary(&self) -> bool

First-order (KKT) stationarity: the projected analytic gradient or root-equivalent fixed-point residual clears its declared bound.

pub fn hessian_psd(&self) -> Option<bool>

The raw PSD verdict, None when no curvature question was answered — the legacy hessian_psd projection every existing consumer wants. Ask Self::curvature directly to learn WHY there is no verdict.

pub fn curvature_verdict(&self) -> CurvatureAdmissibility

Second-order admissibility: a certified optimum must not sit on genuinely indefinite analytic curvature. A nearby box rail is only a diagnostic; it cannot waive negative curvature in unrelated free directions. If a future certificate projects onto the exact critical cone, that projected result can be recorded here instead.

Three-valued, because the question has three answers (#2578). The predicate this replaced returned bool, and its true was produced by two structurally different facts: a Hessian that was measured and found admissible, and a route that never measured one. A gate whose passing condition is satisfied by the ABSENCE of an observation cannot fail on the case it exists to catch — on the support-sparse grouped-LAML lane, which reports hessian=Unavailable, every consultation answered true without inspecting anything.

Acceptance is unchanged. CurvatureAdmissibility::Unevaluated does not refuse, exactly as != Some(false) did not. The difference is that a caller wanting a genuine second-order guarantee can now ask for CurvatureAdmissibility::Admissible and get one, instead of being handed a true that means “nobody looked”.

pub fn curvature_not_refused(&self) -> bool

Whether the second-order conjunct REFUSES this certificate — the shape Self::refusal needs. This is deliberately not named curvature_admissible: “did not refuse” and “was found admissible” are different claims, and conflating them is what #2578 was.

pub fn certifies(&self) -> bool

Whether the certificate accepts the returned point as a constrained minimum. This is the load-bearing verdict: a false here rejects the fit with typed non-convergence.

Defined as “no conjunct refused” so that this and Self::refusal cannot disagree. Two renderings of one predicate is exactly what #2550 was: the verdict string named a cause the predicate had not tested.

pub fn refusal(&self) -> Option<CertificationRefusal>

WHICH conjunct refused, or None when the certificate accepts.

certifies() is a conjunction of six independent things and its verdict string used to be a three-way branch, so the middle branch had to GUESS among four surviving culprits — and guessed curvature every time. It printed INDEFINITE CURVATURE AT INTERIOR OPTIMUM four words after printing hessian_psd=yes, on a fit whose actual refusal was a rail with a zero pencil constant (#2550, observed at #2348’s increment 2). A misdirecting refusal is worse than a vague one: it spends the reader’s attention on the one component the same line proves is not at fault.

The order is the conjunction’s own. It is reported first-failure-wins because that is what a conjunction means; a certificate failing several conjuncts is not better described by listing them than by naming the first thing that was wrong with it.

pub fn is_clean(&self) -> bool

Whether every audited fact is clean (stationary, PSD-or-untracked curvature, no railed smoothing coordinate) — the report-level verdict.

pub fn summary(&self) -> String

One-line human-readable rendering for logs and reports.

Trait Implementations

impl Certificate for OuterCriterionCertificate

fn claim(&self) -> Claim

What this certificate certifies — stable id + human sentence.

fn evidence(&self) -> BTreeMap<&'static str, EvidenceValue>

The named evidence quantities behind the claim.

fn verdict(&self) -> Verdict

The conservative verdict. MUST be derived from the certificate’s own (unchanged) decision rule, and MUST return Verdict::Unavailable / Verdict::Insufficient rather than a silent pass when the evidence is missing or below margin.

fn ledger_entry(&self) -> LedgerEntry

Fold claim + evidence + verdict into one ledger record.

impl Clone for OuterCriterionCertificate

fn clone(&self) -> OuterCriterionCertificate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OuterCriterionCertificate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OuterCriterionCertificate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for OuterCriterionCertificate

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.