Exact CROWN output-query checks

Recompute affine bounds for dense/ReLU networks and prove strict or non-strict output inequalities over an input box. The arithmetic is rational; the conclusion uses TorchLean's existing real module semantics. Every transfer and final query check is proved here, with no external soundness premise.

def NN.Verification.CROWNQuery.checkUpper {n m : ℕ} (strict : Bool) (upper : MLTheory.CROWN.AffineVec ℚ n m) (input : MLTheory.CROWN.Box ℚ [n]) : Bool

Check all upper endpoints against zero, using strict inequalities when requested.

theorem NN.Verification.CROWNQuery.checkUpper_sound {n m : ℕ} (strict : Bool) (upper : MLTheory.CROWN.AffineVec ℚ n m) (input : MLTheory.CROWN.Box ℚ [n]) (h : checkUpper strict upper input = true) (x : TorchLean.Tensor ℝ [n]) (hx : MLTheory.CROWN.Graph.Theorems.Semantics.encloses { dim := n, lo := Cert.RationalReflection.realTensor input.lo, hi := Cert.RationalReflection.realTensor input.hi } x) (i : Fin m) : if strict = true then (MLTheory.CROWN.Graph.CrownCertSoundness.affineEvalAt (Cert.RationalReflection.realAffine upper) x).getScalar i < 0 else (MLTheory.CROWN.Graph.CrownCertSoundness.affineEvalAt (Cert.RationalReflection.realAffine upper) x).getScalar i ≤ 0

Every accepted upper form is below zero throughout the real input box.

structure NN.Verification.CROWNQuery.Bounds (n m : ℕ) : Type

Affine bounds with their input and output dimensions checked by Lean.

• lo : MLTheory.CROWN.AffineVec ℚ n m
• hi : MLTheory.CROWN.AffineVec ℚ n m

def NN.Verification.CROWNQuery.Bounds.flat {n m : ℕ} (b : Bounds n m) : MLTheory.CROWN.Graph.FlatAffineBounds ℚ

def NN.Verification.CROWNQuery.Bounds.Encloses {n m : ℕ} (b : Bounds n m) (x : TorchLean.Tensor ℝ [n]) (y : TorchLean.Tensor ℝ [m]) : Prop

The bounds enclose a value at a particular real input.

def NN.Verification.CROWNQuery.Bounds.identity (n : ℕ) : Bounds n n

def NN.Verification.CROWNQuery.Bounds.linear {n m k : ℕ} (b : Bounds n m) (w : TorchLean.Tensor ℚ [k, m]) (bias : TorchLean.Tensor ℚ [k]) : Bounds n k

def NN.Verification.CROWNQuery.Bounds.interval {n m : ℕ} (b : Bounds n m) (input : MLTheory.CROWN.Box ℚ [n]) : MLTheory.CROWN.Box ℚ [m]

Bound each affine form over the original input box.

def NN.Verification.CROWNQuery.Bounds.relu {n m : ℕ} (b : Bounds n m) (input : MLTheory.CROWN.Box ℚ [n]) (alpha : TorchLean.Tensor ℚ [m]) : Bounds n m

theorem NN.Verification.CROWNQuery.Bounds.identity_encloses {n : ℕ} (x : TorchLean.Tensor ℝ [n]) : (identity n).Encloses x x

theorem NN.Verification.CROWNQuery.Bounds.linear_encloses {n m k : ℕ} (b : Bounds n m) (w : TorchLean.Tensor ℚ [k, m]) (bias : TorchLean.Tensor ℚ [k]) (x : TorchLean.Tensor ℝ [n]) (y : TorchLean.Tensor ℝ [m]) (h : b.Encloses x y) : (b.linear w bias).Encloses x ((Spec.matVecMulSpec (Cert.RationalReflection.realTensor w) y).addSpec (Cert.RationalReflection.realTensor bias))

theorem NN.Verification.CROWNQuery.affine_interval_encloses {n m : ℕ} (a : MLTheory.CROWN.AffineVec ℚ n m) (input : MLTheory.CROWN.Box ℚ [n]) (x : TorchLean.Tensor ℝ [n]) (hx : MLTheory.CROWN.Graph.Theorems.Semantics.encloses { dim := n, lo := Cert.RationalReflection.realTensor input.lo, hi := Cert.RationalReflection.realTensor input.hi } x) (i : Fin m) : (Cert.RationalReflection.realTensor (MLTheory.CROWN.IBP.linear a.A input { lo := a.c, hi := a.c }).lo).getScalar i ≤ (MLTheory.CROWN.Graph.CrownCertSoundness.affineEvalAt (Cert.RationalReflection.realAffine a) x).getScalar i ∧ (MLTheory.CROWN.Graph.CrownCertSoundness.affineEvalAt (Cert.RationalReflection.realAffine a) x).getScalar i ≤ (Cert.RationalReflection.realTensor (MLTheory.CROWN.IBP.linear a.A input { lo := a.c, hi := a.c }).hi).getScalar i

theorem NN.Verification.CROWNQuery.Bounds.interval_encloses {n m : ℕ} (b : Bounds n m) (input : MLTheory.CROWN.Box ℚ [n]) (x : TorchLean.Tensor ℝ [n]) (y : TorchLean.Tensor ℝ [m]) (hx : MLTheory.CROWN.Graph.Theorems.Semantics.encloses { dim := n, lo := Cert.RationalReflection.realTensor input.lo, hi := Cert.RationalReflection.realTensor input.hi } x) (hy : b.Encloses x y) (i : Fin m) : (Cert.RationalReflection.realTensor (b.interval input).lo).getScalar i ≤ y.getScalar i ∧ y.getScalar i ≤ (Cert.RationalReflection.realTensor (b.interval input).hi).getScalar i

def NN.Verification.CROWNQuery.checkAlpha {m : ℕ} (alpha : TorchLean.Tensor ℚ [m]) : Bool

theorem NN.Verification.CROWNQuery.checkAlpha_sound {m : ℕ} (alpha : TorchLean.Tensor ℚ [m]) (h : checkAlpha alpha = true) (i : Fin m) : 0 ≤ (Cert.RationalReflection.realTensor alpha).getScalar i ∧ (Cert.RationalReflection.realTensor alpha).getScalar i ≤ 1

theorem NN.Verification.CROWNQuery.Bounds.relu_encloses {n m : ℕ} (b : Bounds n m) (input : MLTheory.CROWN.Box ℚ [n]) (alpha : TorchLean.Tensor ℚ [m]) (ha : checkAlpha alpha = true) (x : TorchLean.Tensor ℝ [n]) (y : TorchLean.Tensor ℝ [m]) (hx : MLTheory.CROWN.Graph.Theorems.Semantics.encloses { dim := n, lo := Cert.RationalReflection.realTensor input.lo, hi := Cert.RationalReflection.realTensor input.hi } x) (hy : b.Encloses x y) : (b.relu input alpha).Encloses x (Activation.reluSpec y)

inductive NN.Verification.CROWNQuery.Network : ℕ → ℕ → Type

Dense/ReLU networks with a proposed lower-relaxation slope at each ReLU.

• linear {n m : ℕ} (layer : Spec.LinearSpec ℚ n m) : Network n m
• relu {n : ℕ} (alpha : TorchLean.Tensor ℚ [n]) : Network n n
• comp {n m k : ℕ} : Network n m → Network m k → Network n k

noncomputable def NN.Verification.CROWNQuery.Network.model {n m : ℕ} : Network n m → Spec.Module.Chain ℝ [n] [m]

Use the same linear and activation modules as ordinary TorchLean models.

def NN.Verification.CROWNQuery.Network.propagate {n m k : ℕ} (net : Network m k) (b : Bounds n m) (input : MLTheory.CROWN.Box ℚ [n]) : Option (Bounds n k)

Recompute affine bounds with existing CROWN transfers and exact rational arithmetic.

theorem NN.Verification.CROWNQuery.Network.propagate_sound {n m k : ℕ} (net : Network m k) (b : Bounds n m) (input : MLTheory.CROWN.Box ℚ [n]) (out : Bounds n k) (h : net.propagate b input = some out) (x : TorchLean.Tensor ℝ [n]) (y : TorchLean.Tensor ℝ [m]) (hx : MLTheory.CROWN.Graph.Theorems.Semantics.encloses { dim := n, lo := Cert.RationalReflection.realTensor input.lo, hi := Cert.RationalReflection.realTensor input.hi } x) (hy : b.Encloses x y) : out.Encloses x (net.model.forward y)

Replayed bounds enclose the whole network, not just individual certificate entries.

structure NN.Verification.CROWNQuery.Query (n m : ℕ) : Type

A conjunction of affine output inequalities, interpreted as weights * output + bias.

• network : Network n m
• input : MLTheory.CROWN.Box ℚ [n]
• numConstraints : ℕ
• inequalities : Spec.LinearSpec ℚ m self.numConstraints
• strict : Bool

def NN.Verification.CROWNQuery.Query.wellFormed {n m : ℕ} (q : Query n m) : Bool

Reject reversed boxes and empty input, output, or query dimensions.

def NN.Verification.CROWNQuery.Query.check {n m : ℕ} (q : Query n m) : Bool

An executable safety check; no externally supplied affine bounds are trusted.

def NN.Verification.CROWNQuery.Query.Safe {n m : ℕ} (q : Query n m) : Prop

Every real input in the decoded box satisfies every decoded output inequality.

theorem NN.Verification.CROWNQuery.Query.check_sound {n m : ℕ} (q : Query n m) (h : q.check = true) : q.Safe

Acceptance implies query-level soundness with no unproved transfer or coverage premise.