Documentation

Mathlib.Algebra.Group.Submonoid.Operations

Operations on Submonoids #

In this file we define various operations on Submonoids and MonoidHoms.

Main definitions #

Conversion between multiplicative and additive definitions #

(Commutative) monoid structure on a submonoid #

Group actions by submonoids #

Operations on submonoids #

Monoid homomorphisms between submonoid #

Operations on MonoidHoms #

Tags #

submonoid, range, product, map, comap

Conversion to/from Additive/Multiplicative #

Submonoids of monoid M are isomorphic to additive submonoids of Additive M.

Equations
    Instances For
      @[reducible, inline]

      Additive submonoids of an additive monoid Additive M are isomorphic to submonoids of M.

      Equations
        Instances For

          Additive submonoids of an additive monoid A are isomorphic to multiplicative submonoids of Multiplicative A.

          Equations
            Instances For
              @[reducible, inline]

              Submonoids of a monoid Multiplicative A are isomorphic to additive submonoids of A.

              Equations
                Instances For

                  comap and map #

                  def Submonoid.comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid N) :

                  The preimage of a submonoid along a monoid homomorphism is a submonoid.

                  Equations
                    Instances For
                      def AddSubmonoid.comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid N) :

                      The preimage of an AddSubmonoid along an AddMonoid homomorphism is an AddSubmonoid.

                      Equations
                        Instances For
                          @[simp]
                          theorem Submonoid.coe_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (S : Submonoid N) (f : F) :
                          (comap f S) = f ⁻¹' S
                          @[simp]
                          theorem AddSubmonoid.coe_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (S : AddSubmonoid N) (f : F) :
                          (comap f S) = f ⁻¹' S
                          @[simp]
                          theorem Submonoid.mem_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {S : Submonoid N} {f : F} {x : M} :
                          x comap f S f x S
                          @[simp]
                          theorem AddSubmonoid.mem_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {S : AddSubmonoid N} {f : F} {x : M} :
                          x comap f S f x S
                          theorem Submonoid.comap_comap {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [MulOneClass P] (S : Submonoid P) (g : N →* P) (f : M →* N) :
                          comap f (comap g S) = comap (g.comp f) S
                          theorem AddSubmonoid.comap_comap {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (S : AddSubmonoid P) (g : N →+ P) (f : M →+ N) :
                          comap f (comap g S) = comap (g.comp f) S
                          @[simp]
                          theorem Submonoid.comap_id {P : Type u_3} [MulOneClass P] (S : Submonoid P) :
                          @[simp]
                          def Submonoid.map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid M) :

                          The image of a submonoid along a monoid homomorphism is a submonoid.

                          Equations
                            Instances For
                              def AddSubmonoid.map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M) :

                              The image of an AddSubmonoid along an AddMonoid homomorphism is an AddSubmonoid.

                              Equations
                                Instances For
                                  @[simp]
                                  theorem Submonoid.coe_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid M) :
                                  (map f S) = f '' S
                                  @[simp]
                                  theorem AddSubmonoid.coe_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M) :
                                  (map f S) = f '' S
                                  @[simp]
                                  theorem Submonoid.map_coe_toMonoidHom {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid M) :
                                  map (↑f) S = map f S
                                  @[simp]
                                  theorem AddSubmonoid.map_coe_toAddMonoidHom {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M) :
                                  map (↑f) S = map f S
                                  @[simp]
                                  theorem Submonoid.map_coe_toMulEquiv {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [EquivLike F M N] [MulEquivClass F M N] (f : F) (S : Submonoid M) :
                                  map (↑f) S = map f S
                                  @[simp]
                                  theorem AddSubmonoid.map_coe_toAddEquiv {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [EquivLike F M N] [AddEquivClass F M N] (f : F) (S : AddSubmonoid M) :
                                  map (↑f) S = map f S
                                  @[simp]
                                  theorem Submonoid.mem_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {y : N} :
                                  y map f S xS, f x = y
                                  @[simp]
                                  theorem AddSubmonoid.mem_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {S : AddSubmonoid M} {y : N} :
                                  y map f S xS, f x = y
                                  theorem Submonoid.mem_map_of_mem {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) {S : Submonoid M} {x : M} (hx : x S) :
                                  f x map f S
                                  theorem AddSubmonoid.mem_map_of_mem {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) {S : AddSubmonoid M} {x : M} (hx : x S) :
                                  f x map f S
                                  theorem Submonoid.apply_coe_mem_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid M) (x : S) :
                                  f x map f S
                                  theorem AddSubmonoid.apply_coe_mem_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M) (x : S) :
                                  f x map f S
                                  theorem Submonoid.map_map {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [MulOneClass P] (S : Submonoid M) (g : N →* P) (f : M →* N) :
                                  map g (map f S) = map (g.comp f) S
                                  theorem AddSubmonoid.map_map {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (S : AddSubmonoid M) (g : N →+ P) (f : M →+ N) :
                                  map g (map f S) = map (g.comp f) S
                                  @[simp]
                                  theorem Submonoid.mem_map_iff_mem {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) {S : Submonoid M} {x : M} :
                                  f x map f S x S
                                  @[simp]
                                  theorem AddSubmonoid.mem_map_iff_mem {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) {S : AddSubmonoid M} {x : M} :
                                  f x map f S x S
                                  theorem Submonoid.map_le_iff_le_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {T : Submonoid N} :
                                  map f S T S comap f T
                                  theorem AddSubmonoid.map_le_iff_le_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {S : AddSubmonoid M} {T : AddSubmonoid N} :
                                  map f S T S comap f T
                                  theorem Submonoid.gc_map_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                  theorem AddSubmonoid.gc_map_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                  theorem Submonoid.map_le_of_le_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {T : Submonoid N} {f : F} :
                                  S comap f Tmap f S T
                                  theorem AddSubmonoid.map_le_of_le_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {T : AddSubmonoid N} {f : F} :
                                  S comap f Tmap f S T
                                  theorem Submonoid.le_comap_of_map_le {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {T : Submonoid N} {f : F} :
                                  map f S TS comap f T
                                  theorem AddSubmonoid.le_comap_of_map_le {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {T : AddSubmonoid N} {f : F} :
                                  map f S TS comap f T
                                  theorem Submonoid.le_comap_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} :
                                  S comap f (map f S)
                                  theorem AddSubmonoid.le_comap_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} :
                                  S comap f (map f S)
                                  theorem Submonoid.map_comap_le {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {S : Submonoid N} {f : F} :
                                  map f (comap f S) S
                                  theorem AddSubmonoid.map_comap_le {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {S : AddSubmonoid N} {f : F} :
                                  map f (comap f S) S
                                  theorem Submonoid.monotone_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} :
                                  theorem AddSubmonoid.monotone_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} :
                                  theorem Submonoid.monotone_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} :
                                  theorem AddSubmonoid.monotone_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} :
                                  @[simp]
                                  theorem Submonoid.map_comap_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} :
                                  map f (comap f (map f S)) = map f S
                                  @[simp]
                                  theorem AddSubmonoid.map_comap_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} :
                                  map f (comap f (map f S)) = map f S
                                  @[simp]
                                  theorem Submonoid.comap_map_comap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {S : Submonoid N} {f : F} :
                                  comap f (map f (comap f S)) = comap f S
                                  @[simp]
                                  theorem AddSubmonoid.comap_map_comap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {S : AddSubmonoid N} {f : F} :
                                  comap f (map f (comap f S)) = comap f S
                                  theorem Submonoid.map_sup {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (S T : Submonoid M) (f : F) :
                                  map f (ST) = map f Smap f T
                                  theorem AddSubmonoid.map_sup {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (S T : AddSubmonoid M) (f : F) :
                                  map f (ST) = map f Smap f T
                                  theorem Submonoid.map_iSup {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Sort u_5} (f : F) (s : ιSubmonoid M) :
                                  map f (iSup s) = ⨆ (i : ι), map f (s i)
                                  theorem AddSubmonoid.map_iSup {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Sort u_5} (f : F) (s : ιAddSubmonoid M) :
                                  map f (iSup s) = ⨆ (i : ι), map f (s i)
                                  theorem Submonoid.map_inf {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (S T : Submonoid M) (f : F) (hf : Function.Injective f) :
                                  map f (ST) = map f Smap f T
                                  theorem AddSubmonoid.map_inf {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (S T : AddSubmonoid M) (f : F) (hf : Function.Injective f) :
                                  map f (ST) = map f Smap f T
                                  theorem Submonoid.map_iInf {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Sort u_5} [Nonempty ι] (f : F) (hf : Function.Injective f) (s : ιSubmonoid M) :
                                  map f (iInf s) = ⨅ (i : ι), map f (s i)
                                  theorem AddSubmonoid.map_iInf {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Sort u_5} [Nonempty ι] (f : F) (hf : Function.Injective f) (s : ιAddSubmonoid M) :
                                  map f (iInf s) = ⨅ (i : ι), map f (s i)
                                  theorem Submonoid.comap_inf {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (S T : Submonoid N) (f : F) :
                                  comap f (ST) = comap f Scomap f T
                                  theorem AddSubmonoid.comap_inf {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (S T : AddSubmonoid N) (f : F) :
                                  comap f (ST) = comap f Scomap f T
                                  theorem Submonoid.comap_iInf {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Sort u_5} (f : F) (s : ιSubmonoid N) :
                                  comap f (iInf s) = ⨅ (i : ι), comap f (s i)
                                  theorem AddSubmonoid.comap_iInf {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Sort u_5} (f : F) (s : ιAddSubmonoid N) :
                                  comap f (iInf s) = ⨅ (i : ι), comap f (s i)
                                  @[simp]
                                  theorem Submonoid.map_bot {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                  @[simp]
                                  theorem AddSubmonoid.map_bot {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                  @[simp]
                                  theorem Submonoid.comap_top {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                  @[simp]
                                  theorem AddSubmonoid.comap_top {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                  @[simp]
                                  theorem Submonoid.map_id {M : Type u_1} [MulOneClass M] (S : Submonoid M) :
                                  @[simp]
                                  theorem AddSubmonoid.map_id {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M) :
                                  def Submonoid.gciMapComap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) :

                                  map f and comap f form a GaloisCoinsertion when f is injective.

                                  Equations
                                    Instances For
                                      def AddSubmonoid.gciMapComap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) :

                                      map f and comap f form a GaloisCoinsertion when f is injective.

                                      Equations
                                        Instances For
                                          theorem Submonoid.comap_map_eq_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) (S : Submonoid M) :
                                          comap f (map f S) = S
                                          theorem AddSubmonoid.comap_map_eq_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) (S : AddSubmonoid M) :
                                          comap f (map f S) = S
                                          theorem Submonoid.comap_surjective_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) :
                                          theorem AddSubmonoid.comap_surjective_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) :
                                          theorem Submonoid.map_injective_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) :
                                          theorem AddSubmonoid.map_injective_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) :
                                          theorem Submonoid.comap_inf_map_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) (S T : Submonoid M) :
                                          comap f (map f Smap f T) = ST
                                          theorem AddSubmonoid.comap_inf_map_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) (S T : AddSubmonoid M) :
                                          comap f (map f Smap f T) = ST
                                          theorem Submonoid.comap_iInf_map_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Injective f) (S : ιSubmonoid M) :
                                          comap f (⨅ (i : ι), map f (S i)) = iInf S
                                          theorem AddSubmonoid.comap_iInf_map_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Injective f) (S : ιAddSubmonoid M) :
                                          comap f (⨅ (i : ι), map f (S i)) = iInf S
                                          theorem Submonoid.comap_sup_map_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) (S T : Submonoid M) :
                                          comap f (map f Smap f T) = ST
                                          theorem AddSubmonoid.comap_sup_map_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) (S T : AddSubmonoid M) :
                                          comap f (map f Smap f T) = ST
                                          theorem Submonoid.comap_iSup_map_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Injective f) (S : ιSubmonoid M) :
                                          comap f (⨆ (i : ι), map f (S i)) = iSup S
                                          theorem AddSubmonoid.comap_iSup_map_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Injective f) (S : ιAddSubmonoid M) :
                                          comap f (⨆ (i : ι), map f (S i)) = iSup S
                                          theorem Submonoid.map_le_map_iff_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) {S T : Submonoid M} :
                                          map f S map f T S T
                                          theorem AddSubmonoid.map_le_map_iff_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) {S T : AddSubmonoid M} :
                                          map f S map f T S T
                                          theorem Submonoid.map_strictMono_of_injective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Injective f) :
                                          theorem AddSubmonoid.map_strictMono_of_injective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective f) :
                                          def Submonoid.giMapComap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :

                                          map f and comap f form a GaloisInsertion when f is surjective.

                                          Equations
                                            Instances For
                                              def AddSubmonoid.giMapComap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :

                                              map f and comap f form a GaloisInsertion when f is surjective.

                                              Equations
                                                Instances For
                                                  theorem Submonoid.map_comap_eq_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) (S : Submonoid N) :
                                                  map f (comap f S) = S
                                                  theorem AddSubmonoid.map_comap_eq_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) (S : AddSubmonoid N) :
                                                  map f (comap f S) = S
                                                  theorem Submonoid.map_surjective_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :
                                                  theorem AddSubmonoid.map_surjective_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :
                                                  theorem Submonoid.comap_injective_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :
                                                  theorem AddSubmonoid.comap_injective_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :
                                                  theorem Submonoid.map_inf_comap_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) (S T : Submonoid N) :
                                                  map f (comap f Scomap f T) = ST
                                                  theorem AddSubmonoid.map_inf_comap_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) (S T : AddSubmonoid N) :
                                                  map f (comap f Scomap f T) = ST
                                                  theorem Submonoid.map_iInf_comap_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Surjective f) (S : ιSubmonoid N) :
                                                  map f (⨅ (i : ι), comap f (S i)) = iInf S
                                                  theorem AddSubmonoid.map_iInf_comap_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Surjective f) (S : ιAddSubmonoid N) :
                                                  map f (⨅ (i : ι), comap f (S i)) = iInf S
                                                  theorem Submonoid.map_sup_comap_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) (S T : Submonoid N) :
                                                  map f (comap f Scomap f T) = ST
                                                  theorem AddSubmonoid.map_sup_comap_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) (S T : AddSubmonoid N) :
                                                  map f (comap f Scomap f T) = ST
                                                  theorem Submonoid.map_iSup_comap_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Surjective f) (S : ιSubmonoid N) :
                                                  map f (⨆ (i : ι), comap f (S i)) = iSup S
                                                  theorem AddSubmonoid.map_iSup_comap_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {ι : Type u_5} {f : F} (hf : Function.Surjective f) (S : ιAddSubmonoid N) :
                                                  map f (⨆ (i : ι), comap f (S i)) = iSup S
                                                  theorem Submonoid.comap_le_comap_iff_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) {S T : Submonoid N} :
                                                  comap f S comap f T S T
                                                  theorem AddSubmonoid.comap_le_comap_iff_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) {S T : AddSubmonoid N} :
                                                  comap f S comap f T S T
                                                  theorem Submonoid.comap_strictMono_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :
                                                  theorem AddSubmonoid.comap_strictMono_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Surjective f) :
                                                  def Submonoid.topEquiv {M : Type u_5} [MulOneClass M] :
                                                  ≃* M

                                                  The top submonoid is isomorphic to the monoid.

                                                  Equations
                                                    Instances For

                                                      The top additive submonoid is isomorphic to the additive monoid.

                                                      Equations
                                                        Instances For
                                                          @[simp]
                                                          theorem AddSubmonoid.topEquiv_apply {M : Type u_5} [AddZeroClass M] (x : ) :
                                                          topEquiv x = x
                                                          @[simp]
                                                          theorem Submonoid.topEquiv_apply {M : Type u_5} [MulOneClass M] (x : ) :
                                                          topEquiv x = x
                                                          @[simp]
                                                          theorem Submonoid.topEquiv_symm_apply_coe {M : Type u_5} [MulOneClass M] (x : M) :
                                                          (topEquiv.symm x) = x
                                                          @[simp]
                                                          theorem AddSubmonoid.topEquiv_symm_apply_coe {M : Type u_5} [AddZeroClass M] (x : M) :
                                                          (topEquiv.symm x) = x
                                                          noncomputable def Submonoid.equivMapOfInjective {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (S : Submonoid M) (f : M →* N) (hf : Function.Injective f) :
                                                          S ≃* (map f S)

                                                          A subgroup is isomorphic to its image under an injective function. If you have an isomorphism, use MulEquiv.submonoidMap for better definitional equalities.

                                                          Equations
                                                            Instances For
                                                              noncomputable def AddSubmonoid.equivMapOfInjective {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (S : AddSubmonoid M) (f : M →+ N) (hf : Function.Injective f) :
                                                              S ≃+ (map f S)

                                                              An additive subgroup is isomorphic to its image under an injective function. If you have an isomorphism, use AddEquiv.addSubmonoidMap for better definitional equalities.

                                                              Equations
                                                                Instances For
                                                                  @[simp]
                                                                  theorem Submonoid.coe_equivMapOfInjective_apply {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (S : Submonoid M) (f : M →* N) (hf : Function.Injective f) (x : S) :
                                                                  ((S.equivMapOfInjective f hf) x) = f x
                                                                  @[simp]
                                                                  theorem AddSubmonoid.coe_equivMapOfInjective_apply {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (S : AddSubmonoid M) (f : M →+ N) (hf : Function.Injective f) (x : S) :
                                                                  ((S.equivMapOfInjective f hf) x) = f x
                                                                  def Submonoid.prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid M) (t : Submonoid N) :

                                                                  Given submonoids s, t of monoids M, N respectively, s × t as a submonoid of M × N.

                                                                  Equations
                                                                    Instances For
                                                                      def AddSubmonoid.prod {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : AddSubmonoid M) (t : AddSubmonoid N) :

                                                                      Given AddSubmonoids s, t of AddMonoids A, B respectively, s × t as an AddSubmonoid of A × B.

                                                                      Equations
                                                                        Instances For
                                                                          theorem Submonoid.coe_prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid M) (t : Submonoid N) :
                                                                          (s.prod t) = s ×ˢ t
                                                                          theorem AddSubmonoid.coe_prod {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : AddSubmonoid M) (t : AddSubmonoid N) :
                                                                          (s.prod t) = s ×ˢ t
                                                                          theorem Submonoid.mem_prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] {s : Submonoid M} {t : Submonoid N} {p : M × N} :
                                                                          p s.prod t p.1 s p.2 t
                                                                          theorem AddSubmonoid.mem_prod {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] {s : AddSubmonoid M} {t : AddSubmonoid N} {p : M × N} :
                                                                          p s.prod t p.1 s p.2 t
                                                                          theorem Submonoid.prod_mono {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] {s₁ s₂ : Submonoid M} {t₁ t₂ : Submonoid N} (hs : s₁ s₂) (ht : t₁ t₂) :
                                                                          s₁.prod t₁ s₂.prod t₂
                                                                          theorem AddSubmonoid.prod_mono {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] {s₁ s₂ : AddSubmonoid M} {t₁ t₂ : AddSubmonoid N} (hs : s₁ s₂) (ht : t₁ t₂) :
                                                                          s₁.prod t₁ s₂.prod t₂
                                                                          theorem Submonoid.prod_top {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid M) :
                                                                          theorem Submonoid.top_prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid N) :
                                                                          @[simp]
                                                                          theorem Submonoid.top_prod_top {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] :
                                                                          @[simp]
                                                                          def Submonoid.prodEquiv {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid M) (t : Submonoid N) :
                                                                          (s.prod t) ≃* s × t

                                                                          The product of submonoids is isomorphic to their product as monoids.

                                                                          Equations
                                                                            Instances For
                                                                              def AddSubmonoid.prodEquiv {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : AddSubmonoid M) (t : AddSubmonoid N) :
                                                                              (s.prod t) ≃+ s × t

                                                                              The product of additive submonoids is isomorphic to their product as additive monoids

                                                                              Equations
                                                                                Instances For
                                                                                  theorem Submonoid.map_inl {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid M) :
                                                                                  theorem AddSubmonoid.map_inl {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : AddSubmonoid M) :
                                                                                  theorem Submonoid.map_inr {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid N) :
                                                                                  theorem AddSubmonoid.map_inr {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : AddSubmonoid N) :
                                                                                  @[simp]
                                                                                  theorem Submonoid.prod_bot_sup_bot_prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Submonoid M) (t : Submonoid N) :
                                                                                  s.prod .prod t = s.prod t
                                                                                  @[simp]
                                                                                  theorem AddSubmonoid.prod_bot_sup_bot_prod {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : AddSubmonoid M) (t : AddSubmonoid N) :
                                                                                  s.prod .prod t = s.prod t
                                                                                  theorem Submonoid.mem_map_equiv {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] {f : M ≃* N} {K : Submonoid M} {x : N} :
                                                                                  theorem AddSubmonoid.mem_map_equiv {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] {f : M ≃+ N} {K : AddSubmonoid M} {x : N} :
                                                                                  theorem Submonoid.map_equiv_eq_comap_symm {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (f : M ≃* N) (K : Submonoid M) :
                                                                                  map f K = comap f.symm K
                                                                                  theorem AddSubmonoid.map_equiv_eq_comap_symm {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (f : M ≃+ N) (K : AddSubmonoid M) :
                                                                                  map f K = comap f.symm K
                                                                                  theorem Submonoid.comap_equiv_eq_map_symm {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (f : N ≃* M) (K : Submonoid M) :
                                                                                  comap f K = map f.symm K
                                                                                  theorem AddSubmonoid.comap_equiv_eq_map_symm {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (f : N ≃+ M) (K : AddSubmonoid M) :
                                                                                  comap f K = map f.symm K
                                                                                  @[simp]
                                                                                  theorem Submonoid.map_equiv_top {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (f : M ≃* N) :
                                                                                  @[simp]
                                                                                  theorem AddSubmonoid.map_equiv_top {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (f : M ≃+ N) :
                                                                                  theorem Submonoid.le_prod_iff {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)} :
                                                                                  u s.prod t map (MonoidHom.fst M N) u s map (MonoidHom.snd M N) u t
                                                                                  theorem AddSubmonoid.le_prod_iff {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] {s : AddSubmonoid M} {t : AddSubmonoid N} {u : AddSubmonoid (M × N)} :
                                                                                  theorem Submonoid.prod_le_iff {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)} :
                                                                                  s.prod t u map (MonoidHom.inl M N) s u map (MonoidHom.inr M N) t u
                                                                                  theorem AddSubmonoid.prod_le_iff {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] {s : AddSubmonoid M} {t : AddSubmonoid N} {u : AddSubmonoid (M × N)} :
                                                                                  theorem Submonoid.closure_prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] {s : Set M} {t : Set N} (hs : 1 s) (ht : 1 t) :
                                                                                  theorem AddSubmonoid.closure_prod {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] {s : Set M} {t : Set N} (hs : 0 s) (ht : 0 t) :
                                                                                  @[simp]
                                                                                  theorem Submonoid.closure_prod_one {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (s : Set M) :
                                                                                  @[simp]
                                                                                  theorem AddSubmonoid.closure_prod_zero {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (s : Set M) :
                                                                                  @[simp]
                                                                                  theorem Submonoid.closure_one_prod {N : Type u_2} [MulOneClass N] {M : Type u_5} [MulOneClass M] (t : Set N) :
                                                                                  @[simp]
                                                                                  theorem AddSubmonoid.closure_zero_prod {N : Type u_2} [AddZeroClass N] {M : Type u_5} [AddZeroClass M] (t : Set N) :
                                                                                  def MonoidHom.mrange {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :

                                                                                  The range of a monoid homomorphism is a submonoid. See Note [range copy pattern].

                                                                                  Equations
                                                                                    Instances For
                                                                                      def AddMonoidHom.mrange {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :

                                                                                      The range of an AddMonoidHom is an AddSubmonoid.

                                                                                      Equations
                                                                                        Instances For
                                                                                          @[simp]
                                                                                          theorem MonoidHom.coe_mrange {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                                                                          (mrange f) = Set.range f
                                                                                          @[simp]
                                                                                          theorem AddMonoidHom.coe_mrange {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                                                                          (mrange f) = Set.range f
                                                                                          @[simp]
                                                                                          theorem MonoidHom.mem_mrange {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {y : N} :
                                                                                          y mrange f ∃ (x : M), f x = y
                                                                                          @[simp]
                                                                                          theorem AddMonoidHom.mem_mrange {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {y : N} :
                                                                                          y mrange f ∃ (x : M), f x = y
                                                                                          theorem MonoidHom.mrange_comp {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {O : Type u_5} [MulOneClass O] (f : N →* O) (g : M →* N) :
                                                                                          theorem AddMonoidHom.mrange_comp {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {O : Type u_5} [AddZeroClass O] (f : N →+ O) (g : M →+ N) :
                                                                                          theorem MonoidHom.mrange_eq_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                                                                          theorem AddMonoidHom.mrange_eq_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                                                                          @[simp]
                                                                                          theorem MonoidHom.mrange_id {M : Type u_1} [MulOneClass M] :
                                                                                          @[simp]
                                                                                          theorem MonoidHom.map_mrange {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [MulOneClass P] (g : N →* P) (f : M →* N) :
                                                                                          theorem AddMonoidHom.map_mrange {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (g : N →+ P) (f : M →+ N) :
                                                                                          theorem MonoidHom.mrange_eq_top {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} :
                                                                                          theorem AddMonoidHom.mrange_eq_top {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} :
                                                                                          @[deprecated MonoidHom.mrange_eq_top (since := "2024-11-11")]
                                                                                          theorem MonoidHom.mrange_top_iff_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} :

                                                                                          Alias of MonoidHom.mrange_eq_top.

                                                                                          @[simp]
                                                                                          theorem MonoidHom.mrange_eq_top_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (hf : Function.Surjective f) :

                                                                                          The range of a surjective monoid hom is the whole of the codomain.

                                                                                          @[simp]
                                                                                          theorem AddMonoidHom.mrange_eq_top_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (hf : Function.Surjective f) :

                                                                                          The range of a surjective AddMonoid hom is the whole of the codomain.

                                                                                          @[deprecated MonoidHom.mrange_eq_top_of_surjective (since := "2024-11-11")]
                                                                                          theorem MonoidHom.mrange_top_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (hf : Function.Surjective f) :

                                                                                          Alias of MonoidHom.mrange_eq_top_of_surjective.


                                                                                          The range of a surjective monoid hom is the whole of the codomain.

                                                                                          theorem MonoidHom.mclosure_preimage_le {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (s : Set N) :
                                                                                          theorem MonoidHom.map_mclosure {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (s : Set M) :

                                                                                          The image under a monoid hom of the submonoid generated by a set equals the submonoid generated by the image of the set.

                                                                                          theorem AddMonoidHom.map_mclosure {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (s : Set M) :

                                                                                          The image under an AddMonoid hom of the AddSubmonoid generated by a set equals the AddSubmonoid generated by the image of the set.

                                                                                          @[simp]
                                                                                          theorem MonoidHom.mclosure_range {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                                                                          @[simp]
                                                                                          theorem AddMonoidHom.mclosure_range {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                                                                          def MonoidHom.restrict {M : Type u_1} [MulOneClass M] {N : Type u_5} {S : Type u_6} [MulOneClass N] [SetLike S M] [SubmonoidClass S M] (f : M →* N) (s : S) :
                                                                                          s →* N

                                                                                          Restriction of a monoid hom to a submonoid of the domain.

                                                                                          Equations
                                                                                            Instances For
                                                                                              def AddMonoidHom.restrict {M : Type u_1} [AddZeroClass M] {N : Type u_5} {S : Type u_6} [AddZeroClass N] [SetLike S M] [AddSubmonoidClass S M] (f : M →+ N) (s : S) :
                                                                                              s →+ N

                                                                                              Restriction of an AddMonoid hom to an AddSubmonoid of the domain.

                                                                                              Equations
                                                                                                Instances For
                                                                                                  @[simp]
                                                                                                  theorem MonoidHom.restrict_apply {M : Type u_1} [MulOneClass M] {N : Type u_5} {S : Type u_6} [MulOneClass N] [SetLike S M] [SubmonoidClass S M] (f : M →* N) (s : S) (x : s) :
                                                                                                  (f.restrict s) x = f x
                                                                                                  @[simp]
                                                                                                  theorem AddMonoidHom.restrict_apply {M : Type u_1} [AddZeroClass M] {N : Type u_5} {S : Type u_6} [AddZeroClass N] [SetLike S M] [AddSubmonoidClass S M] (f : M →+ N) (s : S) (x : s) :
                                                                                                  (f.restrict s) x = f x
                                                                                                  @[simp]
                                                                                                  theorem MonoidHom.restrict_mrange {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) (f : M →* N) :
                                                                                                  @[simp]
                                                                                                  theorem AddMonoidHom.restrict_mrange {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) (f : M →+ N) :
                                                                                                  def MonoidHom.codRestrict {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {S : Type u_5} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x s) :
                                                                                                  M →* s

                                                                                                  Restriction of a monoid hom to a submonoid of the codomain.

                                                                                                  Equations
                                                                                                    Instances For
                                                                                                      def AddMonoidHom.codRestrict {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {S : Type u_5} [SetLike S N] [AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x s) :
                                                                                                      M →+ s

                                                                                                      Restriction of an AddMonoid hom to an AddSubmonoid of the codomain.

                                                                                                      Equations
                                                                                                        Instances For
                                                                                                          @[simp]
                                                                                                          theorem MonoidHom.codRestrict_apply {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {S : Type u_5} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x s) (n : M) :
                                                                                                          (f.codRestrict s h) n = f n,
                                                                                                          @[simp]
                                                                                                          theorem AddMonoidHom.codRestrict_apply {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {S : Type u_5} [SetLike S N] [AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x s) (n : M) :
                                                                                                          (f.codRestrict s h) n = f n,
                                                                                                          @[simp]
                                                                                                          theorem MonoidHom.injective_codRestrict {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {S : Type u_5} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x s) :
                                                                                                          @[simp]
                                                                                                          theorem AddMonoidHom.injective_codRestrict {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {S : Type u_5} [SetLike S N] [AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x s) :
                                                                                                          def MonoidHom.mrangeRestrict {M : Type u_1} [MulOneClass M] {N : Type u_5} [MulOneClass N] (f : M →* N) :
                                                                                                          M →* (mrange f)

                                                                                                          Restriction of a monoid hom to its range interpreted as a submonoid.

                                                                                                          Equations
                                                                                                            Instances For
                                                                                                              def AddMonoidHom.mrangeRestrict {M : Type u_1} [AddZeroClass M] {N : Type u_5} [AddZeroClass N] (f : M →+ N) :
                                                                                                              M →+ (mrange f)

                                                                                                              Restriction of an AddMonoid hom to its range interpreted as a submonoid.

                                                                                                              Equations
                                                                                                                Instances For
                                                                                                                  @[simp]
                                                                                                                  theorem MonoidHom.coe_mrangeRestrict {M : Type u_1} [MulOneClass M] {N : Type u_5} [MulOneClass N] (f : M →* N) (x : M) :
                                                                                                                  (f.mrangeRestrict x) = f x
                                                                                                                  @[simp]
                                                                                                                  theorem AddMonoidHom.coe_mrangeRestrict {M : Type u_1} [AddZeroClass M] {N : Type u_5} [AddZeroClass N] (f : M →+ N) (x : M) :
                                                                                                                  (f.mrangeRestrict x) = f x
                                                                                                                  def MonoidHom.mker {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :

                                                                                                                  The multiplicative kernel of a monoid hom is the submonoid of elements x : G such that f x = 1

                                                                                                                  Equations
                                                                                                                    Instances For
                                                                                                                      def AddMonoidHom.mker {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :

                                                                                                                      The additive kernel of an AddMonoid hom is the AddSubmonoid of elements such that f x = 0

                                                                                                                      Equations
                                                                                                                        Instances For
                                                                                                                          @[simp]
                                                                                                                          theorem MonoidHom.mem_mker {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {x : M} :
                                                                                                                          x mker f f x = 1
                                                                                                                          @[simp]
                                                                                                                          theorem AddMonoidHom.mem_mker {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {x : M} :
                                                                                                                          x mker f f x = 0
                                                                                                                          theorem MonoidHom.coe_mker {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                                                                                                          (mker f) = f ⁻¹' {1}
                                                                                                                          theorem AddMonoidHom.coe_mker {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                                                                                                          (mker f) = f ⁻¹' {0}
                                                                                                                          instance MonoidHom.decidableMemMker {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] [DecidableEq N] (f : F) :
                                                                                                                          DecidablePred fun (x : M) => x mker f
                                                                                                                          Equations
                                                                                                                            instance AddMonoidHom.decidableMemMker {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] [DecidableEq N] (f : F) :
                                                                                                                            DecidablePred fun (x : M) => x mker f
                                                                                                                            Equations
                                                                                                                              theorem MonoidHom.comap_mker {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [MulOneClass P] (g : N →* P) (f : M →* N) :
                                                                                                                              theorem AddMonoidHom.comap_mker {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (g : N →+ P) (f : M →+ N) :
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.comap_bot' {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) :
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.comap_bot' {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) :
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.restrict_mker {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) (f : M →* N) :
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.restrict_mker {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) (f : M →+ N) :
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.mker_one {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.mker_zero {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                                                                                                              theorem MonoidHom.prod_map_comap_prod' {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {M' : Type u_5} {N' : Type u_6} [MulOneClass M'] [MulOneClass N'] (f : M →* N) (g : M' →* N') (S : Submonoid N) (S' : Submonoid N') :
                                                                                                                              theorem AddMonoidHom.prod_map_comap_prod' {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {M' : Type u_5} {N' : Type u_6} [AddZeroClass M'] [AddZeroClass N'] (f : M →+ N) (g : M' →+ N') (S : AddSubmonoid N) (S' : AddSubmonoid N') :
                                                                                                                              theorem MonoidHom.mker_prod_map {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {M' : Type u_5} {N' : Type u_6} [MulOneClass M'] [MulOneClass N'] (f : M →* N) (g : M' →* N') :
                                                                                                                              mker (f.prodMap g) = (mker f).prod (mker g)
                                                                                                                              theorem AddMonoidHom.mker_prod_map {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {M' : Type u_5} {N' : Type u_6} [AddZeroClass M'] [AddZeroClass N'] (f : M →+ N) (g : M' →+ N') :
                                                                                                                              mker (f.prodMap g) = (mker f).prod (mker g)
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.mker_inl {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                                                                                                              mker (inl M N) =
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.mker_inl {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                                                                                                              mker (inl M N) =
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.mker_inr {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                                                                                                              mker (inr M N) =
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.mker_inr {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                                                                                                              mker (inr M N) =
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.mker_fst {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.mker_fst {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                                                                                                              @[simp]
                                                                                                                              theorem MonoidHom.mker_snd {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                                                                                                              @[simp]
                                                                                                                              theorem AddMonoidHom.mker_snd {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                                                                                                              def MonoidHom.submonoidComap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (N' : Submonoid N) :
                                                                                                                              (Submonoid.comap f N') →* N'

                                                                                                                              The MonoidHom from the preimage of a submonoid to itself.

                                                                                                                              Equations
                                                                                                                                Instances For
                                                                                                                                  def AddMonoidHom.addSubmonoidComap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (N' : AddSubmonoid N) :
                                                                                                                                  (AddSubmonoid.comap f N') →+ N'

                                                                                                                                  the AddMonoidHom from the preimage of an additive submonoid to itself.

                                                                                                                                  Equations
                                                                                                                                    Instances For
                                                                                                                                      @[simp]
                                                                                                                                      theorem AddMonoidHom.addSubmonoidComap_apply_coe {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (N' : AddSubmonoid N) (x : (AddSubmonoid.comap f N')) :
                                                                                                                                      ((f.addSubmonoidComap N') x) = f x
                                                                                                                                      @[simp]
                                                                                                                                      theorem MonoidHom.submonoidComap_apply_coe {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (N' : Submonoid N) (x : (Submonoid.comap f N')) :
                                                                                                                                      ((f.submonoidComap N') x) = f x
                                                                                                                                      def MonoidHom.submonoidMap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (M' : Submonoid M) :
                                                                                                                                      M' →* (Submonoid.map f M')

                                                                                                                                      The MonoidHom from a submonoid to its image. See MulEquiv.SubmonoidMap for a variant for MulEquivs.

                                                                                                                                      Equations
                                                                                                                                        Instances For
                                                                                                                                          def AddMonoidHom.addSubmonoidMap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (M' : AddSubmonoid M) :
                                                                                                                                          M' →+ (AddSubmonoid.map f M')

                                                                                                                                          the AddMonoidHom from an additive submonoid to its image. See AddEquiv.AddSubmonoidMap for a variant for AddEquivs.

                                                                                                                                          Equations
                                                                                                                                            Instances For
                                                                                                                                              @[simp]
                                                                                                                                              theorem AddMonoidHom.addSubmonoidMap_apply_coe {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (M' : AddSubmonoid M) (x : M') :
                                                                                                                                              ((f.addSubmonoidMap M') x) = f x
                                                                                                                                              @[simp]
                                                                                                                                              theorem MonoidHom.submonoidMap_apply_coe {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (M' : Submonoid M) (x : M') :
                                                                                                                                              ((f.submonoidMap M') x) = f x
                                                                                                                                              theorem Submonoid.prod_eq_bot_iff {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Submonoid M} {t : Submonoid N} :
                                                                                                                                              s.prod t = s = t =
                                                                                                                                              theorem AddSubmonoid.prod_eq_bot_iff {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : AddSubmonoid M} {t : AddSubmonoid N} :
                                                                                                                                              s.prod t = s = t =
                                                                                                                                              theorem Submonoid.prod_eq_top_iff {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Submonoid M} {t : Submonoid N} :
                                                                                                                                              s.prod t = s = t =
                                                                                                                                              theorem AddSubmonoid.prod_eq_top_iff {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : AddSubmonoid M} {t : AddSubmonoid N} :
                                                                                                                                              s.prod t = s = t =
                                                                                                                                              def Submonoid.inclusion {M : Type u_1} [MulOneClass M] {S T : Submonoid M} (h : S T) :
                                                                                                                                              S →* T

                                                                                                                                              The monoid hom associated to an inclusion of submonoids.

                                                                                                                                              Equations
                                                                                                                                                Instances For
                                                                                                                                                  def AddSubmonoid.inclusion {M : Type u_1} [AddZeroClass M] {S T : AddSubmonoid M} (h : S T) :
                                                                                                                                                  S →+ T

                                                                                                                                                  The AddMonoid hom associated to an inclusion of submonoids.

                                                                                                                                                  Equations
                                                                                                                                                    Instances For
                                                                                                                                                      @[deprecated Submonoid.mrange_subtype (since := "2024-11-25")]

                                                                                                                                                      Alias of Submonoid.mrange_subtype.

                                                                                                                                                      @[deprecated AddSubmonoid.mrange_subtype (since := "2024-11-25")]
                                                                                                                                                      theorem Submonoid.eq_top_iff' {M : Type u_1} [MulOneClass M] (S : Submonoid M) :
                                                                                                                                                      S = ∀ (x : M), x S
                                                                                                                                                      theorem AddSubmonoid.eq_top_iff' {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M) :
                                                                                                                                                      S = ∀ (x : M), x S
                                                                                                                                                      theorem Submonoid.eq_bot_iff_forall {M : Type u_1} [MulOneClass M] (S : Submonoid M) :
                                                                                                                                                      S = xS, x = 1
                                                                                                                                                      theorem AddSubmonoid.eq_bot_iff_forall {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M) :
                                                                                                                                                      S = xS, x = 0
                                                                                                                                                      theorem Submonoid.nontrivial_iff_exists_ne_one {M : Type u_1} [MulOneClass M] (S : Submonoid M) :
                                                                                                                                                      Nontrivial S xS, x 1

                                                                                                                                                      A submonoid is either the trivial submonoid or nontrivial.

                                                                                                                                                      An additive submonoid is either the trivial additive submonoid or nontrivial.

                                                                                                                                                      theorem Submonoid.bot_or_exists_ne_one {M : Type u_1} [MulOneClass M] (S : Submonoid M) :
                                                                                                                                                      S = xS, x 1

                                                                                                                                                      A submonoid is either the trivial submonoid or contains a nonzero element.

                                                                                                                                                      theorem AddSubmonoid.bot_or_exists_ne_zero {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M) :
                                                                                                                                                      S = xS, x 0

                                                                                                                                                      An additive submonoid is either the trivial additive submonoid or contains a nonzero element.

                                                                                                                                                      def MulEquiv.submonoidCongr {M : Type u_1} [MulOneClass M] {S T : Submonoid M} (h : S = T) :
                                                                                                                                                      S ≃* T

                                                                                                                                                      Makes the identity isomorphism from a proof that two submonoids of a multiplicative monoid are equal.

                                                                                                                                                      Equations
                                                                                                                                                        Instances For
                                                                                                                                                          def AddEquiv.addSubmonoidCongr {M : Type u_1} [AddZeroClass M] {S T : AddSubmonoid M} (h : S = T) :
                                                                                                                                                          S ≃+ T

                                                                                                                                                          Makes the identity additive isomorphism from a proof two submonoids of an additive monoid are equal.

                                                                                                                                                          Equations
                                                                                                                                                            Instances For
                                                                                                                                                              def MulEquiv.ofLeftInverse' {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) {g : NM} (h : Function.LeftInverse g f) :

                                                                                                                                                              A monoid homomorphism f : M →* N with a left-inverse g : N → M defines a multiplicative equivalence between M and f.mrange. This is a bidirectional version of MonoidHom.mrange_restrict.

                                                                                                                                                              Equations
                                                                                                                                                                Instances For
                                                                                                                                                                  def AddEquiv.ofLeftInverse' {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) {g : NM} (h : Function.LeftInverse g f) :

                                                                                                                                                                  An additive monoid homomorphism f : M →+ N with a left-inverse g : N → M defines an additive equivalence between M and f.mrange. This is a bidirectional version of AddMonoidHom.mrange_restrict.

                                                                                                                                                                  Equations
                                                                                                                                                                    Instances For
                                                                                                                                                                      @[simp]
                                                                                                                                                                      theorem MulEquiv.ofLeftInverse'_apply {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) {g : NM} (h : Function.LeftInverse g f) (a : M) :
                                                                                                                                                                      @[simp]
                                                                                                                                                                      theorem MulEquiv.ofLeftInverse'_symm_apply {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) {g : NM} (h : Function.LeftInverse g f) (a✝ : (MonoidHom.mrange f)) :
                                                                                                                                                                      (ofLeftInverse' f h).symm a✝ = g a✝
                                                                                                                                                                      @[simp]
                                                                                                                                                                      theorem AddEquiv.ofLeftInverse'_apply {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) {g : NM} (h : Function.LeftInverse g f) (a : M) :
                                                                                                                                                                      @[simp]
                                                                                                                                                                      theorem AddEquiv.ofLeftInverse'_symm_apply {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) {g : NM} (h : Function.LeftInverse g f) (a✝ : (AddMonoidHom.mrange f)) :
                                                                                                                                                                      (ofLeftInverse' f h).symm a✝ = g a✝
                                                                                                                                                                      def MulEquiv.submonoidMap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (e : M ≃* N) (S : Submonoid M) :
                                                                                                                                                                      S ≃* (Submonoid.map e S)

                                                                                                                                                                      A MulEquiv φ between two monoids M and N induces a MulEquiv between a submonoid S ≤ M and the submonoid φ(S) ≤ N. See MonoidHom.submonoidMap for a variant for MonoidHoms.

                                                                                                                                                                      Equations
                                                                                                                                                                        Instances For
                                                                                                                                                                          def AddEquiv.addSubmonoidMap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (e : M ≃+ N) (S : AddSubmonoid M) :
                                                                                                                                                                          S ≃+ (AddSubmonoid.map e S)

                                                                                                                                                                          An AddEquiv φ between two additive monoids M and N induces an AddEquiv between a submonoid S ≤ M and the submonoid φ(S) ≤ N. See AddMonoidHom.addSubmonoidMap for a variant for AddMonoidHoms.

                                                                                                                                                                          Equations
                                                                                                                                                                            Instances For
                                                                                                                                                                              @[simp]
                                                                                                                                                                              theorem MulEquiv.coe_submonoidMap_apply {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (e : M ≃* N) (S : Submonoid M) (g : S) :
                                                                                                                                                                              ((e.submonoidMap S) g) = e g
                                                                                                                                                                              @[simp]
                                                                                                                                                                              theorem AddEquiv.coe_addSubmonoidMap_apply {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (e : M ≃+ N) (S : AddSubmonoid M) (g : S) :
                                                                                                                                                                              ((e.addSubmonoidMap S) g) = e g
                                                                                                                                                                              @[simp]
                                                                                                                                                                              theorem MulEquiv.submonoidMap_symm_apply {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (e : M ≃* N) (S : Submonoid M) (g : (Submonoid.map (↑e) S)) :
                                                                                                                                                                              (e.submonoidMap S).symm g = e.symm g,
                                                                                                                                                                              @[simp]
                                                                                                                                                                              theorem AddEquiv.add_submonoid_map_symm_apply {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (e : M ≃+ N) (S : AddSubmonoid M) (g : (AddSubmonoid.map (↑e) S)) :
                                                                                                                                                                              (e.addSubmonoidMap S).symm g = e.symm g,
                                                                                                                                                                              @[simp]
                                                                                                                                                                              theorem Submonoid.equivMapOfInjective_coe_mulEquiv {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) (e : M ≃* N) :
                                                                                                                                                                              instance Submonoid.faithfulSMul {M' : Type u_4} {α : Type u_5} [MulOneClass M'] [SMul M' α] {S : Submonoid M'} [FaithfulSMul M' α] :
                                                                                                                                                                              FaithfulSMul (↥S) α
                                                                                                                                                                              instance AddSubmonoid.faithfulVAdd {M' : Type u_4} {α : Type u_5} [AddZeroClass M'] [VAdd M' α] {S : AddSubmonoid M'} [FaithfulVAdd M' α] :
                                                                                                                                                                              FaithfulVAdd (↥S) α

                                                                                                                                                                              The multiplicative equivalence between the type of units of M and the submonoid of unit elements of M.

                                                                                                                                                                              Equations
                                                                                                                                                                                Instances For

                                                                                                                                                                                  The additive equivalence between the type of additive units of M and the additive submonoid whose elements are the additive units of M.

                                                                                                                                                                                  Equations
                                                                                                                                                                                    Instances For
                                                                                                                                                                                      theorem Submonoid.map_comap_eq {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid N) :
                                                                                                                                                                                      map f (comap f S) = SMonoidHom.mrange f
                                                                                                                                                                                      theorem AddSubmonoid.map_comap_eq {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid N) :
                                                                                                                                                                                      map f (comap f S) = SAddMonoidHom.mrange f
                                                                                                                                                                                      theorem Submonoid.map_comap_eq_self {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {S : Submonoid N} (h : S MonoidHom.mrange f) :
                                                                                                                                                                                      map f (comap f S) = S
                                                                                                                                                                                      theorem AddSubmonoid.map_comap_eq_self {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {S : AddSubmonoid N} (h : S AddMonoidHom.mrange f) :
                                                                                                                                                                                      map f (comap f S) = S
                                                                                                                                                                                      theorem Submonoid.map_comap_eq_self_of_surjective {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} (h : Function.Surjective f) {S : Submonoid N} :
                                                                                                                                                                                      map f (comap f S) = S
                                                                                                                                                                                      theorem AddSubmonoid.map_comap_eq_self_of_surjective {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (h : Function.Surjective f) {S : AddSubmonoid N} :
                                                                                                                                                                                      map f (comap f S) = S