Documentation

Mathlib.CategoryTheory.SingleObj

Single-object category #

Single object category with a given monoid of endomorphisms. It is defined to facilitate transferring some definitions and lemmas (e.g., conjugacy etc.) from category theory to monoids and groups.

Main definitions #

Given a type M with a monoid structure, SingleObj M is Unit type with Category structure such that End (SingleObj M).star is the monoid M. This can be extended to a functor MonCat ⥤ Cat.

If M is a group, then SingleObj M is a groupoid.

An element x : M can be reinterpreted as an element of End (SingleObj.star M) using SingleObj.toEnd.

Implementation notes #

@[reducible, inline]

Abbreviation that allows writing CategoryTheory.SingleObj rather than Quiver.SingleObj.

Equations
Instances For

    One and flip (*) become id and comp for morphisms of the single object category.

    Equations
    • One or more equations did not get rendered due to their size.

    Monoid laws become category laws for the single object category.

    Equations

    If M is finite and in universe zero, then SingleObj M is a FinCategory.

    Equations
    @[reducible, inline]

    Abbreviation that allows writing CategoryTheory.SingleObj.star rather than Quiver.SingleObj.star.

    Equations
    Instances For

      The endomorphisms monoid of the only object in SingleObj M is equivalent to the original monoid M.

      Equations
      Instances For

        There is a 1-1 correspondence between monoid homomorphisms M → N and functors between the corresponding single-object categories. It means that SingleObj is a fully faithful functor.

        See https://stacks.math.columbia.edu/tag/001F -- although we do not characterize when the functor is full or faithful.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          theorem CategoryTheory.SingleObj.mapHom_comp {M : Type u} [Monoid M] {N : Type v} [Monoid N] (f : M →* N) {P : Type w} [Monoid P] (g : N →* P) :
          @[simp]
          theorem CategoryTheory.SingleObj.differenceFunctor_map {G : Type u} [Group G] {C : Type v} [CategoryTheory.Category.{w, v} C] (f : CG) {x : C} {y : C} :
          ∀ (x_1 : x y), (CategoryTheory.SingleObj.differenceFunctor f).map x_1 = f y * (f x)⁻¹

          Given a function f : C → G from a category to a group, we get a functor C ⥤ G sending any morphism x ⟶ y to f y * (f x)⁻¹.

          Equations
          Instances For
            @[simp]

            A monoid homomorphism f: M → End X into the endomorphisms of an object X of a category C induces a functor SingleObj M ⥤ C.

            Equations
            Instances For

              Construct a natural transformation between functors SingleObj M ⥤ C by giving a compatible morphism SingleObj.star M.

              Equations
              Instances For
                @[reducible, inline]

                Reinterpret a monoid homomorphism f : M → N as a functor (single_obj M) ⥤ (single_obj N). See also CategoryTheory.SingleObj.mapHom for an equivalence between these types.

                Equations
                Instances For
                  @[simp]
                  theorem MonoidHom.comp_toFunctor {M : Type u} {N : Type v} [Monoid M] [Monoid N] (f : M →* N) {P : Type w} [Monoid P] (g : N →* P) :
                  (g.comp f).toFunctor = f.toFunctor.comp g.toFunctor
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_functor_obj {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) (a : CategoryTheory.SingleObj M) :
                  e.toSingleObjEquiv.functor.obj a = a
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_unitIso_hom {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) :
                  e.toSingleObjEquiv.unitIso.hom = CategoryTheory.eqToHom
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_unitIso_inv {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) :
                  e.toSingleObjEquiv.unitIso.inv = CategoryTheory.eqToHom
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_counitIso_hom {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) :
                  e.toSingleObjEquiv.counitIso.hom = CategoryTheory.eqToHom
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_inverse_map {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) :
                  ∀ {X Y : CategoryTheory.SingleObj N} (a : N), e.toSingleObjEquiv.inverse.map a = e.symm a
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_counitIso_inv {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) :
                  e.toSingleObjEquiv.counitIso.inv = CategoryTheory.eqToHom
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_inverse_obj {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) (a : CategoryTheory.SingleObj N) :
                  e.toSingleObjEquiv.inverse.obj a = a
                  @[simp]
                  theorem MulEquiv.toSingleObjEquiv_functor_map {M : Type u} {N : Type v} [Monoid M] [Monoid N] (e : M ≃* N) :
                  ∀ {X Y : CategoryTheory.SingleObj M} (a : M), e.toSingleObjEquiv.functor.map a = e a

                  Reinterpret a monoid isomorphism f : M ≃* N as an equivalence SingleObj M ≌ SingleObj N.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For

                    The units in a monoid are (multiplicatively) equivalent to the automorphisms of star when we think of the monoid as a single-object category.

                    Equations
                    Instances For
                      @[simp]
                      theorem Units.toAut_hom (M : Type u) [Monoid M] (x : Mˣ) :
                      @[simp]
                      theorem Units.toAut_inv (M : Type u) [Monoid M] (x : Mˣ) :

                      The fully faithful functor from MonCat to Cat.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For