Documentation

Mathlib.Geometry.Convex.Cone.Basic

Convex cones #

In a R-module M, we define a convex cone as a set s such that a • x + b • y ∈ s whenever x, y ∈ s and a, b > 0. We prove that convex cones form a CompleteLattice, and define their images (ConvexCone.map) and preimages (ConvexCone.comap) under linear maps.

We define pointed, blunt, flat and salient cones, and prove the correspondence between convex cones and ordered modules.

We define Convex.toCone to be the minimal cone that includes a given convex set.

Main statements #

In Mathlib/Analysis/Convex/Cone/Extension.lean we prove the M. Riesz extension theorem and a form of the Hahn-Banach theorem.

In Mathlib/Analysis/Convex/Cone/Dual.lean we prove a variant of the hyperplane separation theorem.

Implementation notes #

While Convex R is a predicate on sets, ConvexCone R M is a bundled convex cone.

References #

Definition of ConvexCone and basic properties #

structure ConvexCone (R : Type u_2) (M : Type u_4) [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
Type u_4

A convex cone is a subset s of a R-module such that a • x + b • y ∈ s whenever a, b > 0 and x, y ∈ s.

  • carrier : Set M

    The carrier set underlying this cone: the set of points contained in it

  • smul_mem' c : R : 0 < c∀ ⦃x : M⦄, x self.carrierc x self.carrier
  • add_mem' x : M : x self.carrier∀ ⦃y : M⦄, y self.carrierx + y self.carrier
Instances For
    instance ConvexCone.instSetLike {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
    Equations
      @[simp]
      theorem ConvexCone.coe_mk {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (s : Set M) (h₁ : ∀ ⦃c : R⦄, 0 < c∀ ⦃x : M⦄, x sc x s) (h₂ : ∀ ⦃x : M⦄, x s∀ ⦃y : M⦄, y sx + y s) :
      { carrier := s, smul_mem' := h₁, add_mem' := h₂ } = s
      @[simp]
      theorem ConvexCone.mem_mk {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {s : Set M} {x : M} {h₁ : ∀ ⦃c : R⦄, 0 < c∀ ⦃x : M⦄, x sc x s} {h₂ : ∀ ⦃x : M⦄, x s∀ ⦃y : M⦄, y sx + y s} :
      x { carrier := s, smul_mem' := h₁, add_mem' := h₂ } x s
      theorem ConvexCone.ext {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C₁ C₂ : ConvexCone R M} (h : ∀ (x : M), x C₁ x C₂) :
      C₁ = C₂

      Two ConvexCones are equal if they have the same elements.

      theorem ConvexCone.ext_iff {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C₁ C₂ : ConvexCone R M} :
      C₁ = C₂ ∀ (x : M), x C₁ x C₂
      theorem ConvexCone.smul_mem {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) {c : R} {x : M} (hc : 0 < c) (hx : x C) :
      c x C
      theorem ConvexCone.add_mem {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) x : M (hx : x C) y : M (hy : y C) :
      x + y C
      instance ConvexCone.instMin {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
      Equations
        @[simp]
        theorem ConvexCone.coe_inf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C₁ C₂ : ConvexCone R M) :
        (C₁C₂) = C₁ C₂
        @[simp]
        theorem ConvexCone.mem_inf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C₁ C₂ : ConvexCone R M} {x : M} :
        x C₁C₂ x C₁ x C₂
        instance ConvexCone.instInfSet {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
        Equations
          @[simp]
          theorem ConvexCone.coe_sInf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (S : Set (ConvexCone R M)) :
          (sInf S) = CS, C
          @[simp]
          theorem ConvexCone.mem_sInf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {x : M} {S : Set (ConvexCone R M)} :
          x sInf S CS, x C
          @[simp]
          theorem ConvexCone.coe_iInf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {ι : Sort u_7} (f : ιConvexCone R M) :
          (iInf f) = ⋂ (i : ι), (f i)
          @[simp]
          theorem ConvexCone.mem_iInf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {x : M} {ι : Sort u_7} {f : ιConvexCone R M} :
          x iInf f ∀ (i : ι), x f i
          instance ConvexCone.instBot {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
          Equations
            @[simp]
            theorem ConvexCone.notMem_bot {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {x : M} :
            x
            @[deprecated ConvexCone.notMem_bot (since := "2025-06-11")]
            theorem ConvexCone.mem_bot {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (x : M) :
            @[simp]
            theorem ConvexCone.coe_bot {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
            =
            @[simp]
            theorem ConvexCone.coe_eq_empty {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C : ConvexCone R M} :
            C = C =
            instance ConvexCone.instTop {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
            Equations
              @[simp]
              theorem ConvexCone.mem_top {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {x : M} :
              @[simp]
              theorem ConvexCone.coe_top {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
              Equations
                instance ConvexCone.instInhabited {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
                Equations
                  theorem ConvexCone.convex {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C : ConvexCone R M) :
                  Convex R C
                  def ConvexCone.map {R : Type u_2} {M : Type u_4} {N : Type u_5} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] (f : M →ₗ[R] N) (C : ConvexCone R M) :

                  The image of a convex cone under a R-linear map is a convex cone.

                  Equations
                    Instances For
                      @[simp]
                      theorem ConvexCone.coe_map {R : Type u_2} {M : Type u_4} {N : Type u_5} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] (C : ConvexCone R M) (f : M →ₗ[R] N) :
                      (map f C) = f '' C
                      @[simp]
                      theorem ConvexCone.mem_map {R : Type u_2} {M : Type u_4} {N : Type u_5} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] {f : M →ₗ[R] N} {C : ConvexCone R M} {y : N} :
                      y map f C xC, f x = y
                      theorem ConvexCone.map_map {R : Type u_2} {M : Type u_4} {N : Type u_5} {O : Type u_6} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid O] [Module R M] [Module R N] [Module R O] (g : N →ₗ[R] O) (f : M →ₗ[R] N) (C : ConvexCone R M) :
                      map g (map f C) = map (g ∘ₗ f) C
                      @[simp]
                      theorem ConvexCone.map_id {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C : ConvexCone R M) :
                      def ConvexCone.comap {R : Type u_2} {M : Type u_4} {N : Type u_5} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] (f : M →ₗ[R] N) (C : ConvexCone R N) :

                      The preimage of a convex cone under a R-linear map is a convex cone.

                      Equations
                        Instances For
                          @[simp]
                          theorem ConvexCone.coe_comap {R : Type u_2} {M : Type u_4} {N : Type u_5} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] (f : M →ₗ[R] N) (C : ConvexCone R N) :
                          (comap f C) = f ⁻¹' C
                          @[simp]
                          theorem ConvexCone.comap_id {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C : ConvexCone R M) :
                          theorem ConvexCone.comap_comap {R : Type u_2} {M : Type u_4} {N : Type u_5} {O : Type u_6} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid O] [Module R M] [Module R N] [Module R O] (g : N →ₗ[R] O) (f : M →ₗ[R] N) (C : ConvexCone R O) :
                          comap f (comap g C) = comap (g ∘ₗ f) C
                          @[simp]
                          theorem ConvexCone.mem_comap {R : Type u_2} {M : Type u_4} {N : Type u_5} [Semiring R] [PartialOrder R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] {f : M →ₗ[R] N} {C : ConvexCone R N} {x : M} :
                          x comap f C f x C
                          theorem ConvexCone.smul_mem_iff {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommMonoid M] [MulAction 𝕜 M] (C : ConvexCone 𝕜 M) {c : 𝕜} (hc : 0 < c) {x : M} :
                          c x C x C
                          theorem ConvexCone.to_orderedSMul {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [PartialOrder M] [Module 𝕜 M] (C : ConvexCone 𝕜 M) (h : ∀ (x y : M), x y y - x C) :

                          Constructs an ordered module given an OrderedAddCommGroup, a cone, and a proof that the order relation is the one defined by the cone.

                          Convex cones with extra properties #

                          def ConvexCone.Pointed {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) :

                          A convex cone is pointed if it includes 0.

                          Equations
                            Instances For
                              def ConvexCone.Blunt {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) :

                              A convex cone is blunt if it doesn't include 0.

                              Equations
                                Instances For
                                  theorem ConvexCone.Pointed.mono {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C₁ C₂ : ConvexCone R M} (h : C₁ C₂) :
                                  C₁.PointedC₂.Pointed
                                  theorem ConvexCone.Blunt.anti {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C₁ C₂ : ConvexCone R M} (h : C₂ C₁) :
                                  C₁.BluntC₂.Blunt
                                  def ConvexCone.Flat {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] (C : ConvexCone R G) :

                                  A convex cone is flat if it contains some nonzero vector x and its opposite -x.

                                  Equations
                                    Instances For
                                      def ConvexCone.Salient {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] (C : ConvexCone R G) :

                                      A convex cone is salient if it doesn't include x and -x for any nonzero x.

                                      Equations
                                        Instances For
                                          theorem ConvexCone.Flat.mono {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] {C₁ C₂ : ConvexCone R G} (h : C₁ C₂) :
                                          C₁.FlatC₂.Flat
                                          theorem ConvexCone.Salient.anti {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] {C₁ C₂ : ConvexCone R G} (h : C₂ C₁) :
                                          C₁.SalientC₂.Salient
                                          theorem ConvexCone.Flat.pointed {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] {C : ConvexCone R G} (hC : C.Flat) :

                                          A flat cone is always pointed (contains 0).

                                          theorem ConvexCone.Blunt.salient {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] {C : ConvexCone R G} :
                                          C.BluntC.Salient

                                          A blunt cone (one not containing 0) is always salient.

                                          def ConvexCone.toPreorder {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] (C : ConvexCone R G) (h₁ : C.Pointed) :

                                          A pointed convex cone defines a preorder.

                                          Equations
                                            Instances For
                                              def ConvexCone.toPartialOrder {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] (C : ConvexCone R G) (h₁ : C.Pointed) (h₂ : C.Salient) :

                                              A pointed and salient cone defines a partial order.

                                              Equations
                                                Instances For
                                                  theorem ConvexCone.to_isOrderedAddMonoid {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] (C : ConvexCone R G) (h₁ : C.Pointed) (h₂ : C.Salient) :
                                                  have x := C.toPartialOrder h₁ h₂; IsOrderedAddMonoid G

                                                  A pointed and salient cone defines an IsOrderedAddMonoid.

                                                  @[deprecated ConvexCone.to_isOrderedAddMonoid (since := "2025-06-11")]
                                                  theorem ConvexCone.toIsOrderedAddMonoid {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] (C : ConvexCone R G) (h₁ : C.Pointed) (h₂ : C.Salient) :
                                                  have x := C.toPartialOrder h₁ h₂; IsOrderedAddMonoid G

                                                  Alias of ConvexCone.to_isOrderedAddMonoid.


                                                  A pointed and salient cone defines an IsOrderedAddMonoid.

                                                  instance ConvexCone.instZero {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                                                  Equations
                                                    @[simp]
                                                    theorem ConvexCone.mem_zero {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {x : M} :
                                                    x 0 x = 0
                                                    @[simp]
                                                    theorem ConvexCone.coe_zero {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                                                    0 = 0
                                                    theorem ConvexCone.pointed_zero {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                                                    instance ConvexCone.instAdd {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                                                    Equations
                                                      @[simp]
                                                      theorem ConvexCone.coe_add {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C₁ C₂ : ConvexCone R M) :
                                                      ↑(C₁ + C₂) = C₁ + C₂
                                                      @[simp]
                                                      theorem ConvexCone.mem_add {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C₁ C₂ : ConvexCone R M} {x : M} :
                                                      x C₁ + C₂ yC₁, zC₂, y + z = x
                                                      Equations

                                                        Submodules are cones #

                                                        def Submodule.toConvexCone {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C : Submodule R M) :

                                                        Every submodule is trivially a convex cone.

                                                        Equations
                                                          Instances For
                                                            @[simp]
                                                            theorem Submodule.coe_toConvexCone {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C : Submodule R M) :
                                                            C.toConvexCone = C
                                                            @[simp]
                                                            theorem Submodule.mem_toConvexCone {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C : Submodule R M} {x : M} :
                                                            @[simp]
                                                            theorem Submodule.toConvexCone_le_toConvexCone {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C₁ C₂ : Submodule R M} :
                                                            C₁.toConvexCone C₂.toConvexCone C₁ C₂
                                                            @[deprecated Submodule.toConvexCone_le_toConvexCone (since := "2025-06-11")]
                                                            theorem Submodule.toConvexCone_le_iff {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C₁ C₂ : Submodule R M} :
                                                            C₁.toConvexCone C₂.toConvexCone C₁ C₂

                                                            Alias of Submodule.toConvexCone_le_toConvexCone.

                                                            @[simp]
                                                            @[simp]
                                                            theorem Submodule.toConvexCone_inf {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] (C₁ C₂ : Submodule R M) :
                                                            (C₁C₂).toConvexCone = C₁.toConvexConeC₂.toConvexCone
                                                            @[simp]
                                                            @[deprecated Submodule.pointed_toConvexCone (since := "2025-06-11")]

                                                            Alias of Submodule.pointed_toConvexCone.

                                                            Positive cone of an ordered module #

                                                            The positive cone is the convex cone formed by the set of nonnegative elements in an ordered module.

                                                            Equations
                                                              Instances For
                                                                @[simp]
                                                                theorem ConvexCone.mem_positive {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [PartialOrder M] [IsOrderedAddMonoid M] [Module R M] [PosSMulMono R M] {x : M} :
                                                                x positive R M 0 x
                                                                @[simp]

                                                                The positive cone of an ordered module is always salient.

                                                                The positive cone of an ordered module is always pointed.

                                                                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.

                                                                Equations
                                                                  Instances For
                                                                    @[deprecated ConvexCone.strictlyPositive_le_positive (since := "2025-05-29")]

                                                                    Alias of ConvexCone.strictlyPositive_le_positive.

                                                                    The strictly positive cone of an ordered module is always salient.

                                                                    The strictly positive cone of an ordered module is always blunt.

                                                                    Cone over a convex set #

                                                                    def Convex.toCone {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] (s : Set M) (hs : Convex 𝕜 s) :
                                                                    ConvexCone 𝕜 M

                                                                    The set of vectors proportional to those in a convex set forms a convex cone.

                                                                    Equations
                                                                      Instances For
                                                                        theorem Convex.mem_toCone {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} (hs : Convex 𝕜 s) {x : M} :
                                                                        x toCone s hs ∃ (c : 𝕜), 0 < c ys, c y = x
                                                                        theorem Convex.mem_toCone' {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} (hs : Convex 𝕜 s) {x : M} :
                                                                        x toCone s hs ∃ (c : 𝕜), 0 < c c x s
                                                                        theorem Convex.subset_toCone {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} (hs : Convex 𝕜 s) :
                                                                        s (toCone s hs)
                                                                        theorem Convex.toCone_isLeast {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} (hs : Convex 𝕜 s) :
                                                                        IsLeast {t : ConvexCone 𝕜 M | s t} (toCone s hs)

                                                                        hs.toCone s is the least cone that includes s.

                                                                        theorem Convex.toCone_eq_sInf {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} (hs : Convex 𝕜 s) :
                                                                        toCone s hs = sInf {t : ConvexCone 𝕜 M | s t}
                                                                        theorem convexHull_toCone_isLeast {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] (s : Set M) :
                                                                        IsLeast {t : ConvexCone 𝕜 M | s t} (Convex.toCone ((convexHull 𝕜) s) )
                                                                        theorem convexHull_toCone_eq_sInf {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] (s : Set M) :
                                                                        Convex.toCone ((convexHull 𝕜) s) = sInf {t : ConvexCone 𝕜 M | s t}