File: Mathlib/Analysis/Convex/Cone/Proper.lean

full_name: ProperCone.isClosed'
code: /-- A proper cone is a pointed cone `K` that is closed. Proper cones have the nice property that
they are equal to their double dual, see `ProperCone.dual_dual`.
This makes them useful for defining cone programs and proving duality theorems. -/
structure ProperCone (𝕜 : Type*) (E : Type*) [OrderedSemiring 𝕜] [AddCommMonoid E]
    [TopologicalSpace E] [Module 𝕜 E] extends Submodule {c : 𝕜 // 0 ≤ c} E where
  isClosed' : IsClosed (carrier : Set E)
goal: IsClosed self.carrier

full_name: ProperCone
code: /-- A proper cone is a pointed cone `K` that is closed. Proper cones have the nice property that
they are equal to their double dual, see `ProperCone.dual_dual`.
This makes them useful for defining cone programs and proving duality theorems. -/
structure ProperCone (𝕜 : Type*) (E : Type*) [OrderedSemiring 𝕜] [AddCommMonoid E]
    [TopologicalSpace E] [Module 𝕜 E] extends Submodule {c : 𝕜 // 0 ≤ c} E where
  isClosed' : IsClosed (carrier : Set E)
goal: Type u_2

full_name: ProperCone.toPointedCone
code: /-- A `PointedCone` is defined as an alias of submodule. We replicate the abbreviation here and
define `toPointedCone` as an alias of `toSubmodule`. -/
abbrev toPointedCone (C : ProperCone 𝕜 E) 
goal: Submodule { c // 0 ≤ c } E

full_name: ProperCone.instCoePointedCone
code: instance : Coe (ProperCone 𝕜 E) (PointedCone 𝕜 E) 
goal: Coe (ProperCone 𝕜 E) (PointedCone 𝕜 E)

full_name: ProperCone.toPointedCone_injective
code: theorem toPointedCone_injective : Function.Injective ((↑) : ProperCone 𝕜 E → PointedCone 𝕜 E) 
goal: Function.Injective ProperCone.toPointedCone

full_name: ProperCone.instSetLike
code: instance : SetLike (ProperCone 𝕜 E) E 
goal: SetLike (ProperCone 𝕜 E) E

full_name: ProperCone.ext
code: @[ext]
theorem ext {S T : ProperCone 𝕜 E} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
goal: S = T

full_name: ProperCone.mem_coe
code: @[simp]
theorem mem_coe {x : E} {K : ProperCone 𝕜 E} : x ∈ (K : PointedCone 𝕜 E) ↔ x ∈ K 
goal: x ∈ ↑K ↔ x ∈ K

full_name: ProperCone.instZero
code: instance instZero (K : ProperCone 𝕜 E) : Zero K 
goal: Zero ↥K

full_name: ProperCone.nonempty
code: protected theorem nonempty (K : ProperCone 𝕜 E) : (K : Set E).Nonempty 
goal: (↑K).Nonempty

full_name: ProperCone.isClosed
code: protected theorem isClosed (K : ProperCone 𝕜 E) : IsClosed (K : Set E) 
goal: IsClosed ↑K

full_name: ProperCone.positive
code: /-- The positive cone is the proper cone formed by the set of nonnegative elements in an ordered
module. -/
def positive : ProperCone 𝕜 E 
goal: ProperCone 𝕜 E

full_name: ProperCone.mem_positive
code: @[simp]
theorem mem_positive {x : E} : x ∈ positive 𝕜 E ↔ 0 ≤ x 
goal: x ∈ ProperCone.positive 𝕜 E ↔ 0 ≤ x

full_name: ProperCone.coe_positive
code: @[simp]
theorem coe_positive : ↑(positive 𝕜 E) = ConvexCone.positive 𝕜 E 
goal: ↑↑(ProperCone.positive 𝕜 E) = ConvexCone.positive 𝕜 E

full_name: ProperCone.instZero_1
code: instance : Zero (ProperCone 𝕜 E) 
goal: Zero (ProperCone 𝕜 E)

full_name: ProperCone.instInhabited
code: instance : Inhabited (ProperCone 𝕜 E) 
goal: Inhabited (ProperCone 𝕜 E)

full_name: ProperCone.mem_zero
code: @[simp]
theorem mem_zero (x : E) : x ∈ (0 : ProperCone 𝕜 E) ↔ x = 0 
goal: x ∈ 0 ↔ x = 0

full_name: ProperCone.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ↑(0 : ProperCone 𝕜 E) = (0 : ConvexCone 𝕜 E) 
goal: ↑↑0 = 0

full_name: ProperCone.pointed_zero
code: theorem pointed_zero : ((0 : ProperCone 𝕜 E) : ConvexCone 𝕜 E).Pointed 
goal: (↑↑0).Pointed

full_name: ProperCone.pointed
code: protected theorem pointed (K : ProperCone ℝ E) : (K : ConvexCone ℝ E).Pointed 
goal: (↑↑K).Pointed

full_name: ProperCone.map
code: /-- The closure of image of a proper cone under a continuous `ℝ`-linear map is a proper cone. We
use continuous maps here so that the comap of f is also a map between proper cones. -/
noncomputable def map (f : E →L[ℝ] F) (K : ProperCone ℝ E) : ProperCone ℝ F 
goal: ProperCone ℝ F

full_name: ProperCone.coe_map
code: @[simp, norm_cast]
theorem coe_map (f : E →L[ℝ] F) (K : ProperCone ℝ E) :
    ↑(K.map f) = (PointedCone.map (f : E →ₗ[ℝ] F) ↑K).closure 
goal: ↑(ProperCone.map f K) = (PointedCone.map ↑f ↑K).closure

full_name: ProperCone.mem_map
code: @[simp]
theorem mem_map {f : E →L[ℝ] F} {K : ProperCone ℝ E} {y : F} :
    y ∈ K.map f ↔ y ∈ (PointedCone.map (f : E →ₗ[ℝ] F) ↑K).closure 
goal: y ∈ ProperCone.map f K ↔ y ∈ (PointedCone.map ↑f ↑K).closure

full_name: ProperCone.map_id
code: @[simp]
theorem map_id (K : ProperCone ℝ E) : K.map (ContinuousLinearMap.id ℝ E) = K 
goal: ProperCone.map (ContinuousLinearMap.id ℝ E) K = K

full_name: ProperCone.dual
code: /-- The inner dual cone of a proper cone is a proper cone. -/
def dual (K : ProperCone ℝ E) : ProperCone ℝ E 
goal: ProperCone ℝ E

full_name: ProperCone.coe_dual
code: @[simp, norm_cast]
theorem coe_dual (K : ProperCone ℝ E) : K.dual = (K : Set E).innerDualCone 
goal: ↑↑K.dual = (↑K).innerDualCone

full_name: ProperCone.mem_dual
code: @[simp]
theorem mem_dual {K : ProperCone ℝ E} {y : E} : y ∈ dual K ↔ ∀ ⦃x⦄, x ∈ K → 0 ≤ ⟪x, y⟫_ℝ 
goal: y ∈ K.dual ↔ ∀ ⦃x : E⦄, x ∈ K → 0 ≤ ⟪x, y⟫_ℝ

full_name: ProperCone.comap
code: /-- The preimage of a proper cone under a continuous `ℝ`-linear map is a proper cone. -/
noncomputable def comap (f : E →L[ℝ] F) (S : ProperCone ℝ F) : ProperCone ℝ E 
goal: ProperCone ℝ E

full_name: ProperCone.coe_comap
code: @[simp]
theorem coe_comap (f : E →L[ℝ] F) (S : ProperCone ℝ F) : (S.comap f : Set E) = f ⁻¹' S 
goal: ↑(ProperCone.comap f S) = ⇑f ⁻¹' ↑S

full_name: ProperCone.comap_id
code: @[simp]
theorem comap_id (S : ConvexCone ℝ E) : S.comap LinearMap.id = S 
goal: ConvexCone.comap LinearMap.id S = S

full_name: ProperCone.comap_comap
code: theorem comap_comap (g : F →L[ℝ] G) (f : E →L[ℝ] F) (S : ProperCone ℝ G) :
    (S.comap g).comap f = S.comap (g.comp f) 
goal: ProperCone.comap f (ProperCone.comap g S) = ProperCone.comap (g.comp f) S

full_name: ProperCone.mem_comap
code: @[simp]
theorem mem_comap {f : E →L[ℝ] F} {S : ProperCone ℝ F} {x : E} : x ∈ S.comap f ↔ f x ∈ S 
goal: x ∈ ProperCone.comap f S ↔ f x ∈ S

full_name: ProperCone.dual_dual
code: /-- The dual of the dual of a proper cone is itself. -/
@[simp]
theorem dual_dual (K : ProperCone ℝ E) : K.dual.dual = K 
goal: K.dual.dual = K

full_name: ProperCone.hyperplane_separation
code: /-- This is a relative version of
`ConvexCone.hyperplane_separation_of_nonempty_of_isClosed_of_nmem`, which we recover by setting
`f` to be the identity map. This is also a geometric interpretation of the Farkas' lemma
stated using proper cones. -/
theorem hyperplane_separation (K : ProperCone ℝ E) {f : E →L[ℝ] F} {b : F} :
    b ∈ K.map f ↔ ∀ y : F, adjoint f y ∈ K.dual → 0 ≤ ⟪y, b⟫_ℝ 
goal: b ∈ ProperCone.map f K ↔ ∀ (y : F), (ContinuousLinearMap.adjoint f) y ∈ K.dual → 0 ≤ ⟪y, b⟫_ℝ

full_name: ProperCone.hyperplane_separation_of_nmem
code: theorem hyperplane_separation_of_nmem (K : ProperCone ℝ E) {f : E →L[ℝ] F} {b : F}
    (disj : b ∉ K.map f) : ∃ y : F, adjoint f y ∈ K.dual ∧ ⟪y, b⟫_ℝ < 0 
goal: ∃ y, (ContinuousLinearMap.adjoint f) y ∈ K.dual ∧ ⟪y, b⟫_ℝ < 0