Documentation

Mathlib.Geometry.Convex.Cone.Basic

Convex cones #

In an 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 an 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
    @[implicit_reducible]
    instance ConvexCone.instSetLike {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
    @[implicit_reducible]
    instance ConvexCone.instPartialOrder {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
    @[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
    def ConvexCone.copy {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) (s : Set M) (hs : s = C) :

    Copy of a convex cone with a new carrier equal to the old one. Useful to fix definitional equalities.

    Instances For
      @[simp]
      theorem ConvexCone.copy_carrier {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) (s : Set M) (hs : s = C) :
      (C.copy s hs) = s
      theorem ConvexCone.copy_eq {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (C : ConvexCone R M) (s : Set M) (hs : s = C) :
      C.copy s hs = C
      @[implicit_reducible]
      instance ConvexCone.instInfSet {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
      @[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
      @[implicit_reducible]
      def ConvexCone.hull (R : Type u_2) {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] (s : Set M) :

      The cone hull of a set. The smallest convex cone containing that set.

      Instances For
        theorem ConvexCone.subset_hull {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {s : Set M} :
        s (hull R s)
        theorem ConvexCone.hull_min {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C : ConvexCone R M} {s : Set M} (hsC : s C) :
        hull R s C
        theorem ConvexCone.hull_le_iff {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C : ConvexCone R M} {s : Set M} :
        hull R s C s C
        def ConvexCone.gi {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :

        Galois insertion between ConvexCone and SetLike.coe.

        Instances For
          @[implicit_reducible]
          instance ConvexCone.instBot {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
          @[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
          @[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 =
          @[implicit_reducible]
          instance ConvexCone.instCompleteLattice {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
          @[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₂
          @[simp]
          theorem ConvexCone.mem_top {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {x : M} :
          x
          @[simp]
          theorem ConvexCone.coe_top {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
          @[simp]
          theorem ConvexCone.disjoint_coe {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C₁ C₂ : ConvexCone R M} :
          Disjoint C₁ C₂ Disjoint C₁ C₂
          @[implicit_reducible]
          instance ConvexCone.instInhabited {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] :
          Inhabited (ConvexCone R M)
          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 an R-linear map is a convex cone.

          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 an R-linear map is a convex cone.

            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

              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.

              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.

                Instances For
                  theorem ConvexCone.blunt_iff_not_pointed {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C : ConvexCone R M} :
                  C.Blunt ¬C.Pointed
                  theorem ConvexCone.pointed_iff_not_blunt {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [SMul R M] {C : ConvexCone R M} :
                  C.Pointed ¬C.Blunt
                  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.

                  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.

                    Instances For
                      theorem ConvexCone.salient_iff_not_flat {R : Type u_2} {G : Type u_3} [Semiring R] [PartialOrder R] [AddCommGroup G] [SMul R G] {C : ConvexCone R G} :
                      C.Salient ¬C.Flat
                      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.

                      @[implicit_reducible]
                      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.

                      Instances For
                        @[implicit_reducible]
                        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.

                        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.

                          @[implicit_reducible]
                          instance ConvexCone.instZero {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                          Zero (ConvexCone R M)
                          @[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
                          @[implicit_reducible]
                          instance ConvexCone.instAdd {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                          Add (ConvexCone R M)
                          @[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
                          @[implicit_reducible]
                          @[implicit_reducible]
                          def ConvexCone.IsReproducing {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommGroup M] [Module R M] (C : ConvexCone R M) :

                          A convex cone is reproducing if its set of element differences equals the entire module, i.e., every element of M can be written as a difference of two elements of C.

                          See also (IsGenerating).

                          Instances For
                            theorem ConvexCone.IsReproducing.of_univ_subset {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommGroup M] [Module R M] {C : ConvexCone R M} (h : Set.univ C - C) :

                            A sufficient criterion for a convex cone C to be reproducing is that Set.univ is a subset of C - C.

                            theorem ConvexCone.IsReproducing.sub_eq_univ {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommGroup M] [Module R M] {C : ConvexCone R M} (hC : C.IsReproducing) :
                            C - C = Set.univ

                            The set difference of a reproducing cone with itself equals Set.univ.

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

                            A convex cone C is generating if its linear span is the entire R-module M.

                            IsGenerating is equivalent to IsReproducing modulo some conditions. See IsReproducing.isGenerating and IsGenerating.isReproducing for details.

                            Instances For

                              A sufficient criteria for a convex cone C to be generating is that top is less than or equal to the linear span of C.

                              theorem ConvexCone.IsGenerating.span_eq_top {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C : ConvexCone R M} (hC : C.IsGenerating) :

                              The linear span of a generating convex cone equals top.

                              theorem ConvexCone.IsGenerating.top_le_span {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C : ConvexCone R M} (hC : C.IsGenerating) :

                              Top is less than or equal to the linear span of a generating convex cone.

                              The whole R-module M (viewed as the top convex cone) is generating.

                              theorem ConvexCone.isGenerating_bot_iff {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] :
                              .IsGenerating Subsingleton M

                              The empty convex cone is generating iff the module is a subsingleton.

                              theorem ConvexCone.isGenerating_bot {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] [Subsingleton M] :

                              In a subsingleton module, the empty convex cone is generating.

                              theorem ConvexCone.IsGenerating.mono {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommMonoid M] [Module R M] {C₁ C₂ : ConvexCone R M} (h : C₁ C₂) (hgen : C₁.IsGenerating) :

                              A convex cone containing a generating cone is also a generating cone.

                              theorem ConvexCone.IsReproducing.isGenerating {R : Type u_7} {M : Type u_8} [Ring R] [PartialOrder R] [AddCommGroup M] [Module R M] {C : ConvexCone R M} (h : C.IsReproducing) :

                              A reproducing cone is generating.

                              A generating cone is reproducing.

                              A convex cone is generating iff every element is a difference of cone elements.

                              theorem ConvexCone.mem_hull_of_convex {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} {x : M} (hs : Convex 𝕜 s) :
                              x hull 𝕜 s ∃ (r : 𝕜), 0 < r x r s

                              The cone hull of a convex set is simply the union of the open halflines through that set.

                              theorem ConvexCone.coe_hull_of_convex {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {s : Set M} (hs : Convex 𝕜 s) :
                              (hull 𝕜 s) = {x : M | ∃ (r : 𝕜), 0 < r x r s}

                              The cone hull of a convex set is simply the union of the open halflines through that set.

                              theorem ConvexCone.disjoint_hull_left_of_convex {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {C : ConvexCone 𝕜 M} {s : Set M} (hs : Convex 𝕜 s) :
                              Disjoint (hull 𝕜 s) C Disjoint s C
                              theorem ConvexCone.disjoint_hull_right_of_convex {𝕜 : Type u_1} {M : Type u_4} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup M] [Module 𝕜 M] {C : ConvexCone 𝕜 M} {s : Set M} (hs : Convex 𝕜 s) :
                              Disjoint C (hull 𝕜 s) Disjoint (↑C) s

                              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.

                              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} :
                                x C.toConvexCone x C
                                @[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₂
                                @[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

                                Positive cone of an ordered module #

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

                                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

                                  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.

                                  Instances For
                                    @[simp]
                                    theorem ConvexCone.mem_strictlyPositive {R : Type u_2} {M : Type u_4} [Semiring R] [PartialOrder R] [AddCommGroup M] [PartialOrder M] [IsOrderedAddMonoid M] [Module R M] [PosSMulStrictMono R M] {x : M} :
                                    x strictlyPositive R M 0 < x

                                    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.

                                    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}