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

full_name: ConvexCone
code: /-- A convex cone is a subset `s` of a `𝕜`-module such that `a • x + b • y ∈ s` whenever `a, b > 0`
and `x, y ∈ s`. -/
structure ConvexCone [AddCommMonoid E] [SMul 𝕜 E] where
  /-- The **carrier set** underlying this cone: the set of points contained in it -/
  carrier : Set E
  smul_mem' : ∀ ⦃c : 𝕜⦄, 0 < c → ∀ ⦃x : E⦄, x ∈ carrier → c • x ∈ carrier
  add_mem' : ∀ ⦃x⦄ (_ : x ∈ carrier) ⦃y⦄ (_ : y ∈ carrier), x + y ∈ carrier
goal: Type u_2

full_name: ConvexCone.add_mem'
code: /-- A convex cone is a subset `s` of a `𝕜`-module such that `a • x + b • y ∈ s` whenever `a, b > 0`
and `x, y ∈ s`. -/
structure ConvexCone [AddCommMonoid E] [SMul 𝕜 E] where
  /-- The **carrier set** underlying this cone: the set of points contained in it -/
  carrier : Set E
  smul_mem' : ∀ ⦃c : 𝕜⦄, 0 < c → ∀ ⦃x : E⦄, x ∈ carrier → c • x ∈ carrier
  add_mem' : ∀ ⦃x⦄ (_ : x ∈ carrier) ⦃y⦄ (_ : y ∈ carrier), x + y ∈ carrier
goal: x ∈ self.carrier → ∀ ⦃y : E⦄, y ∈ self.carrier → x + y ∈ self.carrier

full_name: ConvexCone.carrier
code: /-- A convex cone is a subset `s` of a `𝕜`-module such that `a • x + b • y ∈ s` whenever `a, b > 0`
and `x, y ∈ s`. -/
structure ConvexCone [AddCommMonoid E] [SMul 𝕜 E] where
  /-- The **carrier set** underlying this cone: the set of points contained in it -/
  carrier : Set E
  smul_mem' : ∀ ⦃c : 𝕜⦄, 0 < c → ∀ ⦃x : E⦄, x ∈ carrier → c • x ∈ carrier
  add_mem' : ∀ ⦃x⦄ (_ : x ∈ carrier) ⦃y⦄ (_ : y ∈ carrier), x + y ∈ carrier
goal: Set E

full_name: ConvexCone.smul_mem'
code: /-- A convex cone is a subset `s` of a `𝕜`-module such that `a • x + b • y ∈ s` whenever `a, b > 0`
and `x, y ∈ s`. -/
structure ConvexCone [AddCommMonoid E] [SMul 𝕜 E] where
  /-- The **carrier set** underlying this cone: the set of points contained in it -/
  carrier : Set E
  smul_mem' : ∀ ⦃c : 𝕜⦄, 0 < c → ∀ ⦃x : E⦄, x ∈ carrier → c • x ∈ carrier
  add_mem' : ∀ ⦃x⦄ (_ : x ∈ carrier) ⦃y⦄ (_ : y ∈ carrier), x + y ∈ carrier
goal: 0 < c → ∀ ⦃x : E⦄, x ∈ self.carrier → c • x ∈ self.carrier

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

full_name: ConvexCone.coe_mk
code: @[simp]
theorem coe_mk {s : Set E} {h₁ h₂} : ↑(@mk 𝕜 _ _ _ _ s h₁ h₂) = s 
goal: ↑{ carrier := s, smul_mem' := h₁, add_mem' := h₂ } = s

full_name: ConvexCone.mem_mk
code: @[simp]
theorem mem_mk {s : Set E} {h₁ h₂ x} : x ∈ @mk 𝕜 _ _ _ _ s h₁ h₂ ↔ x ∈ s 
goal: x ∈ { carrier := s, smul_mem' := h₁, add_mem' := h₂ } ↔ x ∈ s

full_name: ConvexCone.ext
code: /-- Two `ConvexCone`s are equal if they have the same elements. -/
@[ext]
theorem ext {S T : ConvexCone 𝕜 E} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
goal: S = T

full_name: ConvexCone.smul_mem
code: @[aesop safe apply (rule_sets := [SetLike])]
theorem smul_mem {c : 𝕜} {x : E} (hc : 0 < c) (hx : x ∈ S) : c • x ∈ S 
goal: c • x ∈ S

full_name: ConvexCone.add_mem
code: theorem add_mem ⦃x⦄ (hx : x ∈ S) ⦃y⦄ (hy : y ∈ S) : x + y ∈ S 
goal: x + y ∈ S

full_name: ConvexCone.instAddMemClass
code: instance : AddMemClass (ConvexCone 𝕜 E) E 
goal: AddMemClass (ConvexCone 𝕜 E) E

full_name: ConvexCone.instInf
code: instance : Inf (ConvexCone 𝕜 E) 
goal: Inf (ConvexCone 𝕜 E)

full_name: ConvexCone.coe_inf
code: @[simp]
theorem coe_inf : ((S ⊓ T : ConvexCone 𝕜 E) : Set E) = ↑S ∩ ↑T 
goal: ↑(S ⊓ T) = ↑S ∩ ↑T

full_name: ConvexCone.mem_inf
code: theorem mem_inf {x} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T 
goal: x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T

full_name: ConvexCone.instInfSet
code: instance : InfSet (ConvexCone 𝕜 E) 
goal: InfSet (ConvexCone 𝕜 E)

full_name: ConvexCone.coe_sInf
code: @[simp]
theorem coe_sInf (S : Set (ConvexCone 𝕜 E)) : ↑(sInf S) = ⋂ s ∈ S, (s : Set E) 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: ConvexCone.mem_sInf
code: theorem mem_sInf {x : E} {S : Set (ConvexCone 𝕜 E)} : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s 
goal: x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s

full_name: ConvexCone.coe_iInf
code: @[simp]
theorem coe_iInf {ι : Sort*} (f : ι → ConvexCone 𝕜 E) : ↑(iInf f) = ⋂ i, (f i : Set E) 
goal: ↑(iInf f) = ⋂ i, ↑(f i)

full_name: ConvexCone.mem_iInf
code: theorem mem_iInf {ι : Sort*} {x : E} {f : ι → ConvexCone 𝕜 E} : x ∈ iInf f ↔ ∀ i, x ∈ f i 
goal: x ∈ iInf f ↔ ∀ (i : ι), x ∈ f i

full_name: ConvexCone.instBot
code: instance : Bot (ConvexCone 𝕜 E) 
goal: Bot (ConvexCone 𝕜 E)

full_name: ConvexCone.mem_bot
code: theorem mem_bot (x : E) : (x ∈ (⊥ : ConvexCone 𝕜 E)) = False 
goal: (x ∈ ⊥) = False

full_name: ConvexCone.coe_bot
code: @[simp]
theorem coe_bot : ↑(⊥ : ConvexCone 𝕜 E) = (∅ : Set E) 
goal: ↑⊥ = ∅

full_name: ConvexCone.instTop
code: instance : Top (ConvexCone 𝕜 E) 
goal: Top (ConvexCone 𝕜 E)

full_name: ConvexCone.mem_top
code: theorem mem_top (x : E) : x ∈ (⊤ : ConvexCone 𝕜 E) 
goal: x ∈ ⊤

full_name: ConvexCone.coe_top
code: @[simp]
theorem coe_top : ↑(⊤ : ConvexCone 𝕜 E) = (univ : Set E) 
goal: ↑⊤ = Set.univ

full_name: ConvexCone.instCompleteLattice
code: instance : CompleteLattice (ConvexCone 𝕜 E) 
goal: CompleteLattice (ConvexCone 𝕜 E)

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

full_name: ConvexCone.convex
code: protected theorem convex : Convex 𝕜 (S : Set E) 
goal: Convex 𝕜 ↑S

full_name: ConvexCone.map
code: /-- The image of a convex cone under a `𝕜`-linear map is a convex cone. -/
def map (f : E →ₗ[𝕜] F) (S : ConvexCone 𝕜 E) : ConvexCone 𝕜 F 
goal: ConvexCone 𝕜 F

full_name: ConvexCone.coe_map
code: @[simp, norm_cast]
theorem coe_map (S : ConvexCone 𝕜 E) (f : E →ₗ[𝕜] F) : (S.map f : Set F) = f '' S 
goal: ↑(ConvexCone.map f S) = ⇑f '' ↑S

full_name: ConvexCone.mem_map
code: @[simp]
theorem mem_map {f : E →ₗ[𝕜] F} {S : ConvexCone 𝕜 E} {y : F} : y ∈ S.map f ↔ ∃ x ∈ S, f x = y 
goal: y ∈ ConvexCone.map f S ↔ ∃ x ∈ S, f x = y

full_name: ConvexCone.map_map
code: theorem map_map (g : F →ₗ[𝕜] G) (f : E →ₗ[𝕜] F) (S : ConvexCone 𝕜 E) :
    (S.map f).map g = S.map (g.comp f) 
goal: ConvexCone.map g (ConvexCone.map f S) = ConvexCone.map (g ∘ₗ f) S

full_name: ConvexCone.map_id
code: @[simp]
theorem map_id (S : ConvexCone 𝕜 E) : S.map LinearMap.id = S 
goal: ConvexCone.map LinearMap.id S = S

full_name: ConvexCone.comap
code: /-- The preimage of a convex cone under a `𝕜`-linear map is a convex cone. -/
def comap (f : E →ₗ[𝕜] F) (S : ConvexCone 𝕜 F) : ConvexCone 𝕜 E 
goal: ConvexCone 𝕜 E

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

full_name: ConvexCone.comap_id
code: @[simp] -- Porting note: was not a `dsimp` lemma
theorem comap_id (S : ConvexCone 𝕜 E) : S.comap LinearMap.id = S 
goal: ConvexCone.comap LinearMap.id S = S

full_name: ConvexCone.comap_comap
code: theorem comap_comap (g : F →ₗ[𝕜] G) (f : E →ₗ[𝕜] F) (S : ConvexCone 𝕜 G) :
    (S.comap g).comap f = S.comap (g.comp f) 
goal: ConvexCone.comap f (ConvexCone.comap g S) = ConvexCone.comap (g ∘ₗ f) S

full_name: ConvexCone.mem_comap
code: @[simp]
theorem mem_comap {f : E →ₗ[𝕜] F} {S : ConvexCone 𝕜 F} {x : E} : x ∈ S.comap f ↔ f x ∈ S 
goal: x ∈ ConvexCone.comap f S ↔ f x ∈ S

full_name: ConvexCone.smul_mem_iff
code: theorem smul_mem_iff {c : 𝕜} (hc : 0 < c) {x : E} : c • x ∈ S ↔ x ∈ S 
goal: c • x ∈ S ↔ x ∈ S

full_name: ConvexCone.to_orderedSMul
code: /-- Constructs an ordered module given an `OrderedAddCommGroup`, a cone, and a proof that
the order relation is the one defined by the cone.
-/
theorem to_orderedSMul (S : ConvexCone 𝕜 E) (h : ∀ x y : E, x ≤ y ↔ y - x ∈ S) : OrderedSMul 𝕜 E 
goal: OrderedSMul 𝕜 E

full_name: ConvexCone.Pointed
code: /-- A convex cone is pointed if it includes `0`. -/
def Pointed (S : ConvexCone 𝕜 E) : Prop 
goal: Prop

full_name: ConvexCone.Blunt
code: /-- A convex cone is blunt if it doesn't include `0`. -/
def Blunt (S : ConvexCone 𝕜 E) : Prop 
goal: Prop

full_name: ConvexCone.pointed_iff_not_blunt
code: theorem pointed_iff_not_blunt (S : ConvexCone 𝕜 E) : S.Pointed ↔ ¬S.Blunt 
goal: S.Pointed ↔ ¬S.Blunt

full_name: ConvexCone.blunt_iff_not_pointed
code: theorem blunt_iff_not_pointed (S : ConvexCone 𝕜 E) : S.Blunt ↔ ¬S.Pointed 
goal: S.Blunt ↔ ¬S.Pointed

full_name: ConvexCone.Pointed.mono
code: theorem Pointed.mono {S T : ConvexCone 𝕜 E} (h : S ≤ T) : S.Pointed → T.Pointed 
goal: S.Pointed → T.Pointed

full_name: ConvexCone.Blunt.anti
code: theorem Blunt.anti {S T : ConvexCone 𝕜 E} (h : T ≤ S) : S.Blunt → T.Blunt 
goal: S.Blunt → T.Blunt

full_name: ConvexCone.Flat
code: /-- A convex cone is flat if it contains some nonzero vector `x` and its opposite `-x`. -/
def Flat : Prop 
goal: Prop

full_name: ConvexCone.Salient
code: /-- A convex cone is salient if it doesn't include `x` and `-x` for any nonzero `x`. -/
def Salient : Prop 
goal: Prop

full_name: ConvexCone.salient_iff_not_flat
code: theorem salient_iff_not_flat (S : ConvexCone 𝕜 E) : S.Salient ↔ ¬S.Flat 
goal: S.Salient ↔ ¬S.Flat

full_name: ConvexCone.Flat.mono
code: theorem Flat.mono {S T : ConvexCone 𝕜 E} (h : S ≤ T) : S.Flat → T.Flat
  
goal: S.Flat → T.Flat

full_name: ConvexCone.Salient.anti
code: theorem Salient.anti {S T : ConvexCone 𝕜 E} (h : T ≤ S) : S.Salient → T.Salient 
goal: S.Salient → T.Salient

full_name: ConvexCone.Flat.pointed
code: /-- A flat cone is always pointed (contains `0`). -/
theorem Flat.pointed {S : ConvexCone 𝕜 E} (hS : S.Flat) : S.Pointed 
goal: S.Pointed

full_name: ConvexCone.Blunt.salient
code: /-- A blunt cone (one not containing `0`) is always salient. -/
theorem Blunt.salient {S : ConvexCone 𝕜 E} : S.Blunt → S.Salient 
goal: S.Blunt → S.Salient

full_name: ConvexCone.toPreorder
code: /-- A pointed convex cone defines a preorder. -/
def toPreorder (h₁ : S.Pointed) : Preorder E 
goal: Preorder E

full_name: ConvexCone.toPartialOrder
code: /-- A pointed and salient cone defines a partial order. -/
def toPartialOrder (h₁ : S.Pointed) (h₂ : S.Salient) : PartialOrder E 
goal: PartialOrder E

full_name: ConvexCone.toOrderedAddCommGroup
code: /-- A pointed and salient cone defines an `OrderedAddCommGroup`. -/
def toOrderedAddCommGroup (h₁ : S.Pointed) (h₂ : S.Salient) : OrderedAddCommGroup E 
goal: OrderedAddCommGroup E

full_name: ConvexCone.instZero
code: instance : Zero (ConvexCone 𝕜 E) 
goal: Zero (ConvexCone 𝕜 E)

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

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

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

full_name: ConvexCone.instAdd
code: instance instAdd : Add (ConvexCone 𝕜 E) 
goal: Add (ConvexCone 𝕜 E)

full_name: ConvexCone.mem_add
code: @[simp]
theorem mem_add {K₁ K₂ : ConvexCone 𝕜 E} {a : E} :
    a ∈ K₁ + K₂ ↔ ∃ x ∈ K₁, ∃ y ∈ K₂, x + y = a 
goal: a ∈ K₁ + K₂ ↔ ∃ x ∈ K₁, ∃ y ∈ K₂, x + y = a

full_name: ConvexCone.instAddZeroClass
code: instance instAddZeroClass : AddZeroClass (ConvexCone 𝕜 E) 
goal: AddZeroClass (ConvexCone 𝕜 E)

full_name: ConvexCone.instAddCommSemigroup
code: instance instAddCommSemigroup : AddCommSemigroup (ConvexCone 𝕜 E) 
goal: AddCommSemigroup (ConvexCone 𝕜 E)

full_name: Submodule.toConvexCone
code: /-- Every submodule is trivially a convex cone. -/
def toConvexCone (S : Submodule 𝕜 E) : ConvexCone 𝕜 E 
goal: ConvexCone 𝕜 E

full_name: Submodule.coe_toConvexCone
code: @[simp]
theorem coe_toConvexCone (S : Submodule 𝕜 E) : ↑S.toConvexCone = (S : Set E) 
goal: ↑S.toConvexCone = ↑S

full_name: Submodule.mem_toConvexCone
code: @[simp]
theorem mem_toConvexCone {x : E} {S : Submodule 𝕜 E} : x ∈ S.toConvexCone ↔ x ∈ S 
goal: x ∈ S.toConvexCone ↔ x ∈ S

full_name: Submodule.toConvexCone_le_iff
code: @[simp]
theorem toConvexCone_le_iff {S T : Submodule 𝕜 E} : S.toConvexCone ≤ T.toConvexCone ↔ S ≤ T 
goal: S.toConvexCone ≤ T.toConvexCone ↔ S ≤ T

full_name: Submodule.toConvexCone_bot
code: @[simp]
theorem toConvexCone_bot : (⊥ : Submodule 𝕜 E).toConvexCone = 0 
goal: ⊥.toConvexCone = 0

full_name: Submodule.toConvexCone_top
code: @[simp]
theorem toConvexCone_top : (⊤ : Submodule 𝕜 E).toConvexCone = ⊤ 
goal: ⊤.toConvexCone = ⊤

full_name: Submodule.toConvexCone_inf
code: @[simp]
theorem toConvexCone_inf (S T : Submodule 𝕜 E) :
    (S ⊓ T).toConvexCone = S.toConvexCone ⊓ T.toConvexCone 
goal: (S ⊓ T).toConvexCone = S.toConvexCone ⊓ T.toConvexCone

full_name: Submodule.pointed_toConvexCone
code: @[simp]
theorem pointed_toConvexCone (S : Submodule 𝕜 E) : S.toConvexCone.Pointed 
goal: S.toConvexCone.Pointed

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

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

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

full_name: ConvexCone.salient_positive
code: /-- The positive cone of an ordered module is always salient. -/
theorem salient_positive : Salient (positive 𝕜 E) 
goal: (ConvexCone.positive 𝕜 E).Salient

full_name: ConvexCone.pointed_positive
code: /-- The positive cone of an ordered module is always pointed. -/
theorem pointed_positive : Pointed (positive 𝕜 E) 
goal: (ConvexCone.positive 𝕜 E).Pointed

full_name: ConvexCone.strictlyPositive
code: /-- The cone of strictly positive elements.

Note that this naming diverges from the mathlib convention of `pos` and `nonneg` due to "positive
cone" (`ConvexCone.positive`) being established terminology for the non-negative elements. -/
def strictlyPositive : ConvexCone 𝕜 E 
goal: ConvexCone 𝕜 E

full_name: ConvexCone.mem_strictlyPositive
code: @[simp]
theorem mem_strictlyPositive {x : E} : x ∈ strictlyPositive 𝕜 E ↔ 0 < x 
goal: x ∈ ConvexCone.strictlyPositive 𝕜 E ↔ 0 < x

full_name: ConvexCone.coe_strictlyPositive
code: @[simp]
theorem coe_strictlyPositive : ↑(strictlyPositive 𝕜 E) = Set.Ioi (0 : E) 
goal: ↑(ConvexCone.strictlyPositive 𝕜 E) = Set.Ioi 0

full_name: ConvexCone.positive_le_strictlyPositive
code: theorem positive_le_strictlyPositive : strictlyPositive 𝕜 E ≤ positive 𝕜 E 
goal: ConvexCone.strictlyPositive 𝕜 E ≤ ConvexCone.positive 𝕜 E

full_name: ConvexCone.salient_strictlyPositive
code: /-- The strictly positive cone of an ordered module is always salient. -/
theorem salient_strictlyPositive : Salient (strictlyPositive 𝕜 E) 
goal: (ConvexCone.strictlyPositive 𝕜 E).Salient

full_name: ConvexCone.blunt_strictlyPositive
code: /-- The strictly positive cone of an ordered module is always blunt. -/
theorem blunt_strictlyPositive : Blunt (strictlyPositive 𝕜 E) 
goal: (ConvexCone.strictlyPositive 𝕜 E).Blunt

full_name: Convex.toCone
code: /-- The set of vectors proportional to those in a convex set forms a convex cone. -/
def toCone (s : Set E) (hs : Convex 𝕜 s) : ConvexCone 𝕜 E 
goal: ConvexCone 𝕜 E

full_name: Convex.mem_toCone
code: theorem mem_toCone : x ∈ hs.toCone s ↔ ∃ c : 𝕜, 0 < c ∧ ∃ y ∈ s, c • y = x 
goal: x ∈ Convex.toCone s hs ↔ ∃ c, 0 < c ∧ ∃ y ∈ s, c • y = x

full_name: Convex.mem_toCone'
code: theorem mem_toCone' : x ∈ hs.toCone s ↔ ∃ c : 𝕜, 0 < c ∧ c • x ∈ s 
goal: x ∈ Convex.toCone s hs ↔ ∃ c, 0 < c ∧ c • x ∈ s

full_name: Convex.subset_toCone
code: theorem subset_toCone : s ⊆ hs.toCone s 
goal: s ⊆ ↑(Convex.toCone s hs)

full_name: Convex.toCone_isLeast
code: /-- `hs.toCone s` is the least cone that includes `s`. -/
theorem toCone_isLeast : IsLeast { t : ConvexCone 𝕜 E | s ⊆ t } (hs.toCone s) 
goal: IsLeast {t | s ⊆ ↑t} (Convex.toCone s hs)

full_name: Convex.toCone_eq_sInf
code: theorem toCone_eq_sInf : hs.toCone s = sInf { t : ConvexCone 𝕜 E | s ⊆ t } 
goal: Convex.toCone s hs = sInf {t | s ⊆ ↑t}

full_name: convexHull_toCone_isLeast
code: theorem convexHull_toCone_isLeast (s : Set E) :
    IsLeast { t : ConvexCone 𝕜 E | s ⊆ t } ((convex_convexHull 𝕜 s).toCone _) 
goal: IsLeast {t | s ⊆ ↑t} (Convex.toCone ((convexHull 𝕜) s) ⋯)

full_name: convexHull_toCone_eq_sInf
code: theorem convexHull_toCone_eq_sInf (s : Set E) :
    (convex_convexHull 𝕜 s).toCone _ = sInf { t : ConvexCone 𝕜 E | s ⊆ t } 
goal: Convex.toCone ((convexHull 𝕜) s) ⋯ = sInf {t | s ⊆ ↑t}