Documentation

Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory

Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D #

When D is a monoidal category, monoid objects in C ⥤ D are the same thing as functors from C into the monoid objects of D.

This is formalised as:

The intended application is that as Ring ≌ Mon_ Ab (not yet constructed!), we have presheaf Ring X ≌ presheaf (Mon_ Ab) X ≌ Mon_ (presheaf Ab X), and we can model a module over a presheaf of rings as a module object in presheaf Ab X.

Future work #

Presumably this statement is not specific to monoids, and could be generalised to any internal algebraic objects, if the appropriate framework was available.

source
@[simp]
theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj_obj_mul {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (A : Mon_ (CategoryTheory.Functor C D)) (X : C) :
((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj A).toPrefunctor.obj X).mul = A.mul.app X
source
@[simp]
theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj_obj_X {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (A : Mon_ (CategoryTheory.Functor C D)) (X : C) :
((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj A).toPrefunctor.obj X).X = A.X.toPrefunctor.obj X
source
@[simp]
theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj_obj_one {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (A : Mon_ (CategoryTheory.Functor C D)) (X : C) :
((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj A).toPrefunctor.obj X).one = A.one.app X
source
@[simp]
theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj_map_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (A : Mon_ (CategoryTheory.Functor C D)) :
∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj A).toPrefunctor.map f).hom = A.X.toPrefunctor.map f
source
def CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (A : Mon_ (CategoryTheory.Functor C D)) :
CategoryTheory.Functor C (Mon_ D)

A monoid object in a functor category induces a functor to the category of monoid objects.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    source
    @[simp]
    theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor_map_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
    ∀ {X Y : Mon_ (CategoryTheory.Functor C D)} (f : X ⟶ Y) (X_1 : C), ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor.toPrefunctor.map f).app X_1).hom = f.hom.app X_1
    source
    @[simp]
    theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (A : Mon_ (CategoryTheory.Functor C D)) :
    CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor.toPrefunctor.obj A = CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Functor.obj A
    source
    def CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
    CategoryTheory.Functor (Mon_ (CategoryTheory.Functor C D)) (CategoryTheory.Functor C (Mon_ D))

    Functor translating a monoid object in a functor category to a functor into the category of monoid objects.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      source
      @[simp]
      theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj_X {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C (Mon_ D)) :
      (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj F).X = CategoryTheory.Functor.comp F (Mon_.forget D)
      source
      @[simp]
      theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj_mul_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C (Mon_ D)) (X : C) :
      (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj F).mul.app X = (F.toPrefunctor.obj X).mul
      source
      @[simp]
      theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj_one_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C (Mon_ D)) (X : C) :
      (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj F).one.app X = (F.toPrefunctor.obj X).one
      source
      def CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C (Mon_ D)) :
      Mon_ (CategoryTheory.Functor C D)

      A functor to the category of monoid objects can be translated as a monoid object in the functor category.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        source
        @[simp]
        theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C (Mon_ D)) :
        CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse.toPrefunctor.obj F = CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.Inverse.obj F
        source
        @[simp]
        theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse_map_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
        ∀ {X Y : CategoryTheory.Functor C (Mon_ D)} (α : X ⟶ Y) (X_1 : C), (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse.toPrefunctor.map α).hom.app X_1 = (α.app X_1).hom
        source
        def CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
        CategoryTheory.Functor (CategoryTheory.Functor C (Mon_ D)) (Mon_ (CategoryTheory.Functor C D))

        Functor translating a functor into the category of monoid objects to a monoid object in the functor category

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          source
          @[simp]
          theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso_hom_app_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (X : Mon_ (CategoryTheory.Functor C D)) :
          ∀ (x : C), (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso.hom.app X).hom.app x = CategoryTheory.CategoryStruct.id (X.X.toPrefunctor.obj x)
          source
          @[simp]
          theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso_inv_app_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (X : Mon_ (CategoryTheory.Functor C D)) :
          ∀ (x : C), (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso.inv.app X).hom.app x = CategoryTheory.CategoryStruct.id (X.X.toPrefunctor.obj x)
          source
          def CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
          CategoryTheory.Functor.id (Mon_ (CategoryTheory.Functor C D)) ≅ CategoryTheory.Functor.comp CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse

          The unit for the equivalence Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            source
            @[simp]
            theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso_hom_app_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (X : CategoryTheory.Functor C (Mon_ D)) (X : C) :
            ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso.hom.app X✝).app X).hom = CategoryTheory.CategoryStruct.id (X✝.toPrefunctor.obj X).X
            source
            @[simp]
            theorem CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso_inv_app_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (X : CategoryTheory.Functor C (Mon_ D)) (X : C) :
            ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso.inv.app X✝).app X).hom = CategoryTheory.CategoryStruct.id (X✝.toPrefunctor.obj X).X
            source
            def CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
            CategoryTheory.Functor.comp CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor ≅ CategoryTheory.Functor.id (CategoryTheory.Functor C (Mon_ D))

            The counit for the equivalence Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              source
              @[simp]
              theorem CategoryTheory.Monoidal.monFunctorCategoryEquivalence_counitIso (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
              (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).counitIso = CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso
              source
              @[simp]
              theorem CategoryTheory.Monoidal.monFunctorCategoryEquivalence_functor (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
              (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).functor = CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor
              source
              @[simp]
              theorem CategoryTheory.Monoidal.monFunctorCategoryEquivalence_inverse (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
              (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).inverse = CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse
              source
              @[simp]
              theorem CategoryTheory.Monoidal.monFunctorCategoryEquivalence_unitIso (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
              (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).unitIso = CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso
              source
              def CategoryTheory.Monoidal.monFunctorCategoryEquivalence (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] :
              Mon_ (CategoryTheory.Functor C D) ≌ CategoryTheory.Functor C (Mon_ D)

              When D is a monoidal category, monoid objects in C ⥤ D are the same thing as functors from C into the monoid objects of D.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                source
                @[simp]
                theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_mul {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (A : CommMon_ (CategoryTheory.Functor C D)) (X : C) :
                ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.toPrefunctor.obj A).toPrefunctor.obj X).mul = A.mul.app X
                source
                @[simp]
                theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_map_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (A : CommMon_ (CategoryTheory.Functor C D)) :
                ∀ {X Y : C} (a : X ⟶ Y), ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.toPrefunctor.obj A).toPrefunctor.map a).hom = A.X.toPrefunctor.map a
                source
                @[simp]
                theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_X {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (A : CommMon_ (CategoryTheory.Functor C D)) (X : C) :
                ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.toPrefunctor.obj A).toPrefunctor.obj X).X = A.X.toPrefunctor.obj X
                source
                @[simp]
                theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_one {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (A : CommMon_ (CategoryTheory.Functor C D)) (X : C) :
                ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.toPrefunctor.obj A).toPrefunctor.obj X).one = A.one.app X
                source
                @[simp]
                theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_map_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                ∀ {X Y : CommMon_ (CategoryTheory.Functor C D)} (f : X ⟶ Y) (X_1 : C), ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.toPrefunctor.map f).app X_1).hom = f.hom.app X_1
                source
                def CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                CategoryTheory.Functor (CommMon_ (CategoryTheory.Functor C D)) (CategoryTheory.Functor C (CommMon_ D))

                Functor translating a commutative monoid object in a functor category to a functor into the category of commutative monoid objects.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  source
                  @[simp]
                  theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_X_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (F : CategoryTheory.Functor C (CommMon_ D)) :
                  ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.toPrefunctor.obj F).X.toPrefunctor.map f = (F.toPrefunctor.map f).hom
                  source
                  @[simp]
                  theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mul_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (F : CategoryTheory.Functor C (CommMon_ D)) (X : C) :
                  (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.toPrefunctor.obj F).mul.app X = (F.toPrefunctor.obj X).mul
                  source
                  @[simp]
                  theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_map_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                  ∀ {X Y : CategoryTheory.Functor C (CommMon_ D)} (α : X ⟶ Y) (X_1 : C), (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.toPrefunctor.map α).hom.app X_1 = (α.app X_1).hom
                  source
                  @[simp]
                  theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_X_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (F : CategoryTheory.Functor C (CommMon_ D)) (X : C) :
                  (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.toPrefunctor.obj F).X.toPrefunctor.obj X = ((CommMon_.forget₂Mon_ D).toPrefunctor.obj (F.toPrefunctor.obj X)).X
                  source
                  @[simp]
                  theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_one_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (F : CategoryTheory.Functor C (CommMon_ D)) (X : C) :
                  (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.toPrefunctor.obj F).one.app X = (F.toPrefunctor.obj X).one
                  source
                  def CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                  CategoryTheory.Functor (CategoryTheory.Functor C (CommMon_ D)) (CommMon_ (CategoryTheory.Functor C D))

                  Functor translating a functor into the category of commutative monoid objects to a commutative monoid object in the functor category

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    source
                    @[simp]
                    theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso_inv_app_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (X : CommMon_ (CategoryTheory.Functor C D)) :
                    ∀ (x : C), (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso.inv.app X).hom.app x = CategoryTheory.CategoryStruct.id ((CommMon_.forget₂Mon_ D).toPrefunctor.obj ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.toPrefunctor.obj X).toPrefunctor.obj x)).X
                    source
                    @[simp]
                    theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso_hom_app_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (X : CommMon_ (CategoryTheory.Functor C D)) :
                    ∀ (x : C), (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso.hom.app X).hom.app x = CategoryTheory.CategoryStruct.id (X.X.toPrefunctor.obj x)
                    source
                    def CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                    CategoryTheory.Functor.id (CommMon_ (CategoryTheory.Functor C D)) ≅ CategoryTheory.Functor.comp CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse

                    The unit for the equivalence CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      source
                      @[simp]
                      theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso_hom_app_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (X : CategoryTheory.Functor C (CommMon_ D)) (X : C) :
                      ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso.hom.app X✝).app X).hom = CategoryTheory.CategoryStruct.id ((CommMon_.forget₂Mon_ D).toPrefunctor.obj (X✝.toPrefunctor.obj X)).X
                      source
                      @[simp]
                      theorem CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso_inv_app_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] (X : CategoryTheory.Functor C (CommMon_ D)) (X : C) :
                      ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso.inv.app X✝).app X).hom = CategoryTheory.CategoryStruct.id (X✝.toPrefunctor.obj X).X
                      source
                      def CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                      CategoryTheory.Functor.comp CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor ≅ CategoryTheory.Functor.id (CategoryTheory.Functor C (CommMon_ D))

                      The counit for the equivalence CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        source
                        @[simp]
                        theorem CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_counitIso (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                        (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).counitIso = CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso
                        source
                        @[simp]
                        theorem CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_inverse (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                        (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).inverse = CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse
                        source
                        @[simp]
                        theorem CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_unitIso (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                        (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).unitIso = CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso
                        source
                        @[simp]
                        theorem CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_functor (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                        (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).functor = CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor
                        source
                        def CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] [CategoryTheory.BraidedCategory D] :
                        CommMon_ (CategoryTheory.Functor C D) ≌ CategoryTheory.Functor C (CommMon_ D)

                        When D is a braided monoidal category, commutative monoid objects in C ⥤ D are the same thing as functors from C into the commutative monoid objects of D.

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