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

full_name: «_aux_Mathlib_Analysis_Convex_Cone_Pointed___macroRules_term𝕜≥0_1»
code: local notation3 "𝕜≥0" => {c : 𝕜 // 0 ≤ c}
goal: Lean.Macro

full_name: PointedCone
code: /-- A pointed cone is a submodule of a module with scalars restricted to being nonnegative. -/
abbrev PointedCone (𝕜 E) [OrderedSemiring 𝕜] [AddCommMonoid E] [Module 𝕜 E] 
goal: Type u_6

full_name: PointedCone.toConvexCone
code: /-- Every pointed cone is a convex cone. -/
@[coe]
def toConvexCone (S : PointedCone 𝕜 E) : ConvexCone 𝕜 E 
goal: ConvexCone 𝕜 E

full_name: PointedCone.instCoeConvexCone
code: instance : Coe (PointedCone 𝕜 E) (ConvexCone 𝕜 E) 
goal: Coe (PointedCone 𝕜 E) (ConvexCone 𝕜 E)

full_name: PointedCone.toConvexCone_injective
code: theorem toConvexCone_injective : Injective ((↑) : PointedCone 𝕜 E → ConvexCone 𝕜 E) 
goal: Function.Injective PointedCone.toConvexCone

full_name: PointedCone.toConvexCone_pointed
code: @[simp]
theorem toConvexCone_pointed (S : PointedCone 𝕜 E) : (S : ConvexCone 𝕜 E).Pointed 
goal: (↑S).Pointed

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

full_name: PointedCone.instZero
code: instance instZero (S : PointedCone 𝕜 E) : Zero S 
goal: Zero ↥S

full_name: ConvexCone.toPointedCone
code: /-- The `PointedCone` constructed from a pointed `ConvexCone`. -/
def _root_.ConvexCone.toPointedCone {S : ConvexCone 𝕜 E} (hS : S.Pointed) : PointedCone 𝕜 E 
goal: PointedCone 𝕜 E

full_name: ConvexCone.mem_toPointedCone
code: @[simp]
lemma _root_.ConvexCone.mem_toPointedCone {S : ConvexCone 𝕜 E} (hS : S.Pointed) (x : E) :
    x ∈ S.toPointedCone hS ↔ x ∈ S 
goal: x ∈ ConvexCone.toPointedCone hS ↔ x ∈ S

full_name: ConvexCone.coe_toPointedCone
code: @[simp, norm_cast]
lemma _root_.ConvexCone.coe_toPointedCone {S : ConvexCone 𝕜 E} (hS : S.Pointed) :
    S.toPointedCone hS = S 
goal: ↑(ConvexCone.toPointedCone hS) = S

full_name: PointedCone.canLift
code: instance canLift : CanLift (ConvexCone 𝕜 E) (PointedCone 𝕜 E) (↑) ConvexCone.Pointed 
goal: CanLift (ConvexCone 𝕜 E) (PointedCone 𝕜 E) PointedCone.toConvexCone ConvexCone.Pointed

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

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

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

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

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

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

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

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

full_name: PointedCone.comap_id
code: @[simp]
theorem comap_id (S : PointedCone 𝕜 E) : S.comap LinearMap.id = S 
goal: PointedCone.comap LinearMap.id S = S

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

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

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

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

full_name: PointedCone.toConvexCone_positive
code: @[simp, norm_cast]
theorem toConvexCone_positive : ↑(positive 𝕜 E) = ConvexCone.positive 𝕜 E 
goal: ↑(PointedCone.positive 𝕜 E) = ConvexCone.positive 𝕜 E

full_name: PointedCone.dual
code: /-- The inner dual cone of a pointed cone is a pointed cone. -/
def dual (S : PointedCone ℝ E) : PointedCone ℝ E 
goal: PointedCone ℝ E

full_name: PointedCone.toConvexCone_dual
code: @[simp, norm_cast]
theorem toConvexCone_dual (S : PointedCone ℝ E) : ↑(dual S) = (S : Set E).innerDualCone 
goal: ↑S.dual = (↑S).innerDualCone

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