File: Mathlib/CategoryTheory/Monad/EquivMon.lean

full_name: CategoryTheory.Monad.toMon_X
code: /-- To every `Monad C` we associated a monoid object in `C ⥤ C`. -/
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
goal: M.toMon.X = M.toFunctor

full_name: CategoryTheory.Monad.toMon_mul
code: /-- To every `Monad C` we associated a monoid object in `C ⥤ C`. -/
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
goal: M.toMon.mul = M.μ

full_name: CategoryTheory.Monad.toMon_one
code: /-- To every `Monad C` we associated a monoid object in `C ⥤ C`. -/
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
goal: M.toMon.one = M.η

full_name: CategoryTheory.Monad.toMon
code: /-- To every `Monad C` we associated a monoid object in `C ⥤ C`. -/
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
goal: Mon_ (CategoryTheory.Functor C C)

full_name: CategoryTheory.Monad.monadToMon_obj
code: /-- Passing from `Monad C` to `Mon_ (C ⥤ C)` is functorial. -/
@[simps]
def monadToMon : Monad C ⥤ Mon_ (C ⥤ C) 
goal: (CategoryTheory.Monad.monadToMon C).obj M = M.toMon

full_name: CategoryTheory.Monad.monadToMon_map_hom
code: /-- Passing from `Monad C` to `Mon_ (C ⥤ C)` is functorial. -/
@[simps]
def monadToMon : Monad C ⥤ Mon_ (C ⥤ C) 
goal: ∀ {X Y : CategoryTheory.Monad C} (f : X ⟶ Y), ((CategoryTheory.Monad.monadToMon C).map f).hom = f.toNatTrans

full_name: CategoryTheory.Monad.monadToMon
code: /-- Passing from `Monad C` to `Mon_ (C ⥤ C)` is functorial. -/
@[simps]
def monadToMon : Monad C ⥤ Mon_ (C ⥤ C) 
goal: CategoryTheory.Functor (CategoryTheory.Monad C) (Mon_ (CategoryTheory.Functor C C))

full_name: CategoryTheory.Monad.ofMon
code: /-- To every monoid object in `C ⥤ C` we associate a `Monad C`. -/
@[simps η μ]
def ofMon (M : Mon_ (C ⥤ C)) : Monad C 
goal: CategoryTheory.Monad C

full_name: CategoryTheory.Monad.ofMon_μ
code: /-- To every monoid object in `C ⥤ C` we associate a `Monad C`. -/
@[simps η μ]
def ofMon (M : Mon_ (C ⥤ C)) : Monad C 
goal: (CategoryTheory.Monad.ofMon M).μ = M.mul

full_name: CategoryTheory.Monad.ofMon_η
code: /-- To every monoid object in `C ⥤ C` we associate a `Monad C`. -/
@[simps η μ]
def ofMon (M : Mon_ (C ⥤ C)) : Monad C 
goal: (CategoryTheory.Monad.ofMon M).η = M.one

full_name: CategoryTheory.Monad.ofMon_obj
code: @[simp] lemma ofMon_obj (M : Mon_ (C ⥤ C)) (X : C) : (ofMon M).obj X = M.X.obj X 
goal: (CategoryTheory.Monad.ofMon M).obj X = M.X.obj X

full_name: CategoryTheory.Monad.monToMonad
code: /-- Passing from `Mon_ (C ⥤ C)` to `Monad C` is functorial. -/
@[simps]
def monToMonad : Mon_ (C ⥤ C) ⥤ Monad C 
goal: CategoryTheory.Functor (Mon_ (CategoryTheory.Functor C C)) (CategoryTheory.Monad C)

full_name: CategoryTheory.Monad.monToMonad_map_toNatTrans
code: /-- Passing from `Mon_ (C ⥤ C)` to `Monad C` is functorial. -/
@[simps]
def monToMonad : Mon_ (C ⥤ C) ⥤ Monad C 
goal: ((CategoryTheory.Monad.monToMonad C).map f).toNatTrans = f.hom

full_name: CategoryTheory.Monad.monToMonad_obj
code: /-- Passing from `Mon_ (C ⥤ C)` to `Monad C` is functorial. -/
@[simps]
def monToMonad : Mon_ (C ⥤ C) ⥤ Monad C 
goal: (CategoryTheory.Monad.monToMonad C).obj M = CategoryTheory.Monad.ofMon M

full_name: CategoryTheory.Monad.monadMonEquiv
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: CategoryTheory.Monad C ≌ Mon_ (CategoryTheory.Functor C C)

full_name: CategoryTheory.Monad.monadMonEquiv_unitIso_hom_app_toNatTrans_app
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: ∀ (x : CategoryTheory.Monad C) (x_1 : C),
  ((CategoryTheory.Monad.monadMonEquiv C).unitIso.hom.app x).app x_1 =
    CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.id (CategoryTheory.Monad C)).obj x).obj x_1)

full_name: CategoryTheory.Monad.monadMonEquiv_counitIso_inv_app_hom
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: ∀ (x : Mon_ (CategoryTheory.Functor C C)),
  ((CategoryTheory.Monad.monadMonEquiv C).counitIso.inv.app x).hom =
    CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id (Mon_ (CategoryTheory.Functor C C))).obj x).X

full_name: CategoryTheory.Monad.monadMonEquiv_functor
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: (CategoryTheory.Monad.monadMonEquiv C).functor = CategoryTheory.Monad.monadToMon C

full_name: CategoryTheory.Monad.monadMonEquiv_counitIso_hom_app_hom
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: ∀ (x : Mon_ (CategoryTheory.Functor C C)),
  ((CategoryTheory.Monad.monadMonEquiv C).counitIso.hom.app x).hom =
    CategoryTheory.CategoryStruct.id
      (((CategoryTheory.Monad.monToMonad C).comp (CategoryTheory.Monad.monadToMon C)).obj x).X

full_name: CategoryTheory.Monad.monadMonEquiv_inverse
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: (CategoryTheory.Monad.monadMonEquiv C).inverse = CategoryTheory.Monad.monToMonad C

full_name: CategoryTheory.Monad.monadMonEquiv_unitIso_inv_app_toNatTrans_app
code: /-- Oh, monads are just monoids in the category of endofunctors (equivalence of categories). -/
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
goal: ∀ (x : CategoryTheory.Monad C) (x_1 : C),
  ((CategoryTheory.Monad.monadMonEquiv C).unitIso.inv.app x).app x_1 =
    CategoryTheory.CategoryStruct.id
      ((((CategoryTheory.Monad.monadToMon C).comp (CategoryTheory.Monad.monToMonad C)).obj x).obj x_1)