ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_functor_obj_X_X
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C (ComplexShape.up α))) (n : α)
Goal: (((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).functor.obj P).X n).X = P.X.X n
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_unitIso_hom_app_f_f
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C (ComplexShape.up α))) (n : α)
Goal: ((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).unitIso.hom.app P).f.f n = P.p.f n
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_counitIso_hom
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α]
Goal: (CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).counitIso.hom = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_unitIso_inv_app_f_f
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C (ComplexShape.up α))) (n : α)
Goal: ((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).unitIso.inv.app P).f.f n = P.p.f n
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_functor_obj_X_p
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C (ComplexShape.up α))) (n : α)
Goal: (((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).functor.obj P).X n).p = P.p.f n
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_inverse_obj_X_X
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (K : HomologicalComplex (CategoryTheory.Idempotents.Karoubi C) (ComplexShape.up α)) (n : α)
Goal: ((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).inverse.obj K).X.X n = (K.X n).X
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_inverse_obj_X_d
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (K : HomologicalComplex (CategoryTheory.Idempotents.Karoubi C) (ComplexShape.up α)) (i j : α)
Goal: ((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).inverse.obj K).X.d i j = (K.d i j).f
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_functor_obj_d_f
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α] (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C (ComplexShape.up α))) (i j : α)
Goal: (((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).functor.obj P).d i j).f =
  CategoryTheory.CategoryStruct.comp (P.X.d i j) (P.p.f j)
-- CategoryTheory.Idempotents.karoubiCochainComplexEquivalence_functor_map_f_f
@[simps!]
def karoubiCochainComplexEquivalence :
    Karoubi (CochainComplex C α) ≌ CochainComplex (Karoubi C) α 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] (α : Type u_3) [AddRightCancelSemigroup α] [One α]
Goal: ∀ {X Y : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C (ComplexShape.up α))} (f : X ⟶ Y) (n : α),
  (((CategoryTheory.Idempotents.karoubiCochainComplexEquivalence C α).functor.map f).f n).f = f.f.f n
-- CategoryTheory.Monad.toMon_X
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (M : CategoryTheory.Monad C)
Goal: M.toMon.X = M.toFunctor
-- CategoryTheory.Monad.toMon_mul
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (M : CategoryTheory.Monad C)
Goal: M.toMon.mul = M.μ
-- CategoryTheory.Monad.toMon_one
@[simps]
def toMon (M : Monad C) : Mon_ (C ⥤ C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (M : CategoryTheory.Monad C)
Goal: M.toMon.one = M.η
-- CategoryTheory.Monad.monadToMon_obj
@[simps]
def monadToMon : Monad C ⥤ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (M : CategoryTheory.Monad C)
Goal: (CategoryTheory.Monad.monadToMon C).obj M = M.toMon
-- CategoryTheory.Monad.monadToMon_map_hom
@[simps]
def monadToMon : Monad C ⥤ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Monad C} (f : X ⟶ Y), ((CategoryTheory.Monad.monadToMon C).map f).hom = f.toNatTrans
-- CategoryTheory.Monad.ofMon_μ
@[simps η μ]
def ofMon (M : Mon_ (C ⥤ C)) : Monad C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (M : Mon_ (CategoryTheory.Functor C C))
Goal: (CategoryTheory.Monad.ofMon M).μ = M.mul
-- CategoryTheory.Monad.ofMon_η
@[simps η μ]
def ofMon (M : Mon_ (C ⥤ C)) : Monad C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (M : Mon_ (CategoryTheory.Functor C C))
Goal: (CategoryTheory.Monad.ofMon M).η = M.one
-- CategoryTheory.Monad.ofMon_obj
@[simp] lemma ofMon_obj (M : Mon_ (C ⥤ C)) (X : C) : (ofMon M).obj X = M.X.obj X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (M : Mon_ (CategoryTheory.Functor C C)) (X : C)
Goal: (CategoryTheory.Monad.ofMon M).obj X = M.X.obj X
-- CategoryTheory.Monad.monToMonad_map_toNatTrans
@[simps]
def monToMonad : Mon_ (C ⥤ C) ⥤ Monad C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : Mon_ (CategoryTheory.Functor C C)} (f : X ⟶ Y)
Goal: ((CategoryTheory.Monad.monToMonad C).map f).toNatTrans = f.hom
-- CategoryTheory.Monad.monToMonad_obj
@[simps]
def monToMonad : Mon_ (C ⥤ C) ⥤ Monad C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (M : Mon_ (CategoryTheory.Functor C C))
Goal: (CategoryTheory.Monad.monToMonad C).obj M = CategoryTheory.Monad.ofMon M
-- CategoryTheory.Monad.monadMonEquiv_unitIso_hom_app_toNatTrans_app
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} 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)
-- CategoryTheory.Monad.monadMonEquiv_counitIso_inv_app_hom
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} 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
-- CategoryTheory.Monad.monadMonEquiv_functor
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.Monad.monadMonEquiv C).functor = CategoryTheory.Monad.monadToMon C
-- CategoryTheory.Monad.monadMonEquiv_counitIso_hom_app_hom
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} 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
-- CategoryTheory.Monad.monadMonEquiv_inverse
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.Monad.monadMonEquiv C).inverse = CategoryTheory.Monad.monToMonad C
-- CategoryTheory.Monad.monadMonEquiv_unitIso_inv_app_toNatTrans_app
@[simps]
def monadMonEquiv : Monad C ≌ Mon_ (C ⥤ C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} 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)
-- CategoryTheory.MorphismProperty.bijective_eq_sup
theorem bijective_eq_sup :
    MorphismProperty.bijective C = MorphismProperty.injective C ⊓ MorphismProperty.surjective C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C]
Goal: CategoryTheory.MorphismProperty.bijective C =
  CategoryTheory.MorphismProperty.injective C ⊓ CategoryTheory.MorphismProperty.surjective C
-- CategoryTheory.Monad.Algebra.assoc
structure Algebra (T : Monad C) : Type max u₁ v₁ where
    A : C
    a : (T : C ⥤ C).obj A ⟶ A
    unit : T.η.app A ≫ a = 𝟙 A := by aesop_cat
    assoc : T.μ.app A ≫ a = (T : C ⥤ C).map a ≫ a := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (self : T.Algebra)
Goal: CategoryTheory.CategoryStruct.comp (T.μ.app self.A) self.a = CategoryTheory.CategoryStruct.comp (T.map self.a) self.a
-- CategoryTheory.Monad.Algebra.unit
structure Algebra (T : Monad C) : Type max u₁ v₁ where
    A : C
    a : (T : C ⥤ C).obj A ⟶ A
    unit : T.η.app A ≫ a = 𝟙 A := by aesop_cat
    assoc : T.μ.app A ≫ a = (T : C ⥤ C).map a ≫ a := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (self : T.Algebra)
Goal: CategoryTheory.CategoryStruct.comp (T.η.app self.A) self.a = CategoryTheory.CategoryStruct.id self.A
-- CategoryTheory.Monad.Algebra.Hom.h
@[ext]
structure Hom (A B : Algebra T) where
    f : A.A ⟶ B.A
    h : (T : C ⥤ C).map f ≫ B.a = A.a ≫ f := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra} (self : A.Hom B)
Goal: CategoryTheory.CategoryStruct.comp (T.map self.f) B.a = CategoryTheory.CategoryStruct.comp A.a self.f
-- CategoryTheory.Monad.Algebra.Hom.ext'
@[ext]
lemma Hom.ext' (X Y : Algebra T) (f g : X ⟶ Y) (h : f.f = g.f) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X Y : T.Algebra) (f g : X ⟶ Y) (h : f.f = g.f)
Goal: f = g
-- CategoryTheory.Monad.Algebra.comp_eq_comp
@[simp]
theorem comp_eq_comp {A A' A'' : Algebra T} (f : A ⟶ A') (g : A' ⟶ A'') :
    Algebra.Hom.comp f g = f ≫ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A A' A'' : T.Algebra} (f : A ⟶ A') (g : A' ⟶ A'')
Goal: CategoryTheory.Monad.Algebra.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.Monad.Algebra.id_eq_id
@[simp]
theorem id_eq_id (A : Algebra T) : Algebra.Hom.id A = 𝟙 A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (A : T.Algebra)
Goal: CategoryTheory.Monad.Algebra.Hom.id A = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.Monad.Algebra.id_f
@[simp]
theorem id_f (A : Algebra T) : (𝟙 A : A ⟶ A).f = 𝟙 A.A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (A : T.Algebra)
Goal: (CategoryTheory.CategoryStruct.id A).f = CategoryTheory.CategoryStruct.id A.A
-- CategoryTheory.Monad.Algebra.comp_f
@[simp]
theorem comp_f {A A' A'' : Algebra T} (f : A ⟶ A') (g : A' ⟶ A'') : (f ≫ g).f = f.f ≫ g.f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A A' A'' : T.Algebra} (f : A ⟶ A') (g : A' ⟶ A'')
Goal: (CategoryTheory.CategoryStruct.comp f g).f = CategoryTheory.CategoryStruct.comp f.f g.f
-- CategoryTheory.Monad.Algebra.isoMk_inv_f
@[simps]
def isoMk {A B : Algebra T} (h : A.A ≅ B.A)
    (w : (T : C ⥤ C).map h.hom ≫ B.a = A.a ≫ h.hom := by aesop_cat) : A ≅ B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra} (h : A.A ≅ B.A) (w : CategoryTheory.CategoryStruct.comp (T.map h.hom) B.a = CategoryTheory.CategoryStruct.comp A.a h.hom := by
  aesop_cat)
Goal: (CategoryTheory.Monad.Algebra.isoMk h w).inv.f = h.inv
-- CategoryTheory.Monad.Algebra.isoMk_hom_f
@[simps]
def isoMk {A B : Algebra T} (h : A.A ≅ B.A)
    (w : (T : C ⥤ C).map h.hom ≫ B.a = A.a ≫ h.hom := by aesop_cat) : A ≅ B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra} (h : A.A ≅ B.A) (w : CategoryTheory.CategoryStruct.comp (T.map h.hom) B.a = CategoryTheory.CategoryStruct.comp A.a h.hom := by
  aesop_cat)
Goal: (CategoryTheory.Monad.Algebra.isoMk h w).hom.f = h.hom
-- CategoryTheory.Monad.forget_map
@[simps]
def forget : Algebra T ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C)
Goal: ∀ {X Y : T.Algebra} (f : X ⟶ Y), T.forget.map f = f.f
-- CategoryTheory.Monad.forget_obj
@[simps]
def forget : Algebra T ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) (A : T.Algebra)
Goal: T.forget.obj A = A.A
-- CategoryTheory.Monad.free_obj_a
@[simps]
def free : C ⥤ Algebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) (X : C)
Goal: (T.free.obj X).a = T.μ.app X
-- CategoryTheory.Monad.free_map_f
@[simps]
def free : C ⥤ Algebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C)
Goal: ∀ {X Y : C} (f : X ⟶ Y), (T.free.map f).f = T.map f
-- CategoryTheory.Monad.free_obj_A
@[simps]
def free : C ⥤ Algebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) (X : C)
Goal: (T.free.obj X).A = T.obj X
-- CategoryTheory.Monad.adj_unit
@[simps! unit counit]
def adj : T.free ⊣ T.forget 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C)
Goal: T.adj.unit = { app := fun X => T.η.app X, naturality := ⋯ }
-- CategoryTheory.Monad.adj_counit
@[simps! unit counit]
def adj : T.free ⊣ T.forget 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C)
Goal: T.adj.counit = { app := fun Y => { f := Y.a, h := ⋯ }, naturality := ⋯ }
-- CategoryTheory.Monad.algebra_iso_of_iso
theorem algebra_iso_of_iso {A B : Algebra T} (f : A ⟶ B) [IsIso f.f] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) {A B : T.Algebra} (f : A ⟶ B) [CategoryTheory.IsIso f.f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Monad.algebra_epi_of_epi
theorem algebra_epi_of_epi {X Y : Algebra T} (f : X ⟶ Y) [h : Epi f.f] : Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) {X Y : T.Algebra} (f : X ⟶ Y) [h : CategoryTheory.Epi f.f]
Goal: CategoryTheory.Epi f
-- CategoryTheory.Monad.algebra_mono_of_mono
theorem algebra_mono_of_mono {X Y : Algebra T} (f : X ⟶ Y) [h : Mono f.f] : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) {X Y : T.Algebra} (f : X ⟶ Y) [h : CategoryTheory.Mono f.f]
Goal: CategoryTheory.Mono f
-- CategoryTheory.Monad.algebraFunctorOfMonadHom_obj_a
@[simps]
def algebraFunctorOfMonadHom {T₁ T₂ : Monad C} (h : T₂ ⟶ T₁) : Algebra T₁ ⥤ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₂ ⟶ T₁) (A : T₁.Algebra)
Goal: ((CategoryTheory.Monad.algebraFunctorOfMonadHom h).obj A).a = CategoryTheory.CategoryStruct.comp (h.app A.A) A.a
-- CategoryTheory.Monad.algebraFunctorOfMonadHom_map_f
@[simps]
def algebraFunctorOfMonadHom {T₁ T₂ : Monad C} (h : T₂ ⟶ T₁) : Algebra T₁ ⥤ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₂ ⟶ T₁)
Goal: ∀ {X Y : T₁.Algebra} (f : X ⟶ Y), ((CategoryTheory.Monad.algebraFunctorOfMonadHom h).map f).f = f.f
-- CategoryTheory.Monad.algebraFunctorOfMonadHom_obj_A
@[simps]
def algebraFunctorOfMonadHom {T₁ T₂ : Monad C} (h : T₂ ⟶ T₁) : Algebra T₁ ⥤ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₂ ⟶ T₁) (A : T₁.Algebra)
Goal: ((CategoryTheory.Monad.algebraFunctorOfMonadHom h).obj A).A = A.A
-- CategoryTheory.Monad.algebraFunctorOfMonadHomId_inv_app_f
-- Porting note: `semireducible -> default`
@[simps (config := { rhsMd := .default })]
def algebraFunctorOfMonadHomId {T₁ : Monad C} : algebraFunctorOfMonadHom (𝟙 T₁) ≅ 𝟭 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ : CategoryTheory.Monad C} (X : T₁.Algebra)
Goal: (CategoryTheory.Monad.algebraFunctorOfMonadHomId.inv.app X).f =
  (CategoryTheory.Iso.refl
      ((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).obj X).A).inv
-- CategoryTheory.Monad.algebraFunctorOfMonadHomId_hom_app_f
-- Porting note: `semireducible -> default`
@[simps (config := { rhsMd := .default })]
def algebraFunctorOfMonadHomId {T₁ : Monad C} : algebraFunctorOfMonadHom (𝟙 T₁) ≅ 𝟭 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ : CategoryTheory.Monad C} (X : T₁.Algebra)
Goal: (CategoryTheory.Monad.algebraFunctorOfMonadHomId.hom.app X).f =
  (CategoryTheory.Iso.refl
      ((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).obj X).A).hom
-- CategoryTheory.Monad.algebraFunctorOfMonadHomComp_inv_app_f
@[simps (config := { rhsMd := .default })]
def algebraFunctorOfMonadHomComp {T₁ T₂ T₃ : Monad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) :
    algebraFunctorOfMonadHom (f ≫ g) ≅ algebraFunctorOfMonadHom g ⋙ algebraFunctorOfMonadHom f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ T₃ : CategoryTheory.Monad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) (X : T₃.Algebra)
Goal: ((CategoryTheory.Monad.algebraFunctorOfMonadHomComp f g).inv.app X).f =
  (CategoryTheory.Iso.refl
      ((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.comp f g)).obj X).A).inv
-- CategoryTheory.Monad.algebraFunctorOfMonadHomComp_hom_app_f
@[simps (config := { rhsMd := .default })]
def algebraFunctorOfMonadHomComp {T₁ T₂ T₃ : Monad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) :
    algebraFunctorOfMonadHom (f ≫ g) ≅ algebraFunctorOfMonadHom g ⋙ algebraFunctorOfMonadHom f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ T₃ : CategoryTheory.Monad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) (X : T₃.Algebra)
Goal: ((CategoryTheory.Monad.algebraFunctorOfMonadHomComp f g).hom.app X).f =
  (CategoryTheory.Iso.refl
      ((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.comp f g)).obj X).A).hom
-- CategoryTheory.Monad.algebraFunctorOfMonadHomEq_hom_app_f
@[simps (config := { rhsMd := .default })]
def algebraFunctorOfMonadHomEq {T₁ T₂ : Monad C} {f g : T₁ ⟶ T₂} (h : f = g) :
    algebraFunctorOfMonadHom f ≅ algebraFunctorOfMonadHom g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} {f g : T₁ ⟶ T₂} (h : f = g) (X : T₂.Algebra)
Goal: ((CategoryTheory.Monad.algebraFunctorOfMonadHomEq h).hom.app X).f =
  (CategoryTheory.Iso.refl ((CategoryTheory.Monad.algebraFunctorOfMonadHom f).obj X).A).hom
-- CategoryTheory.Monad.algebraFunctorOfMonadHomEq_inv_app_f
@[simps (config := { rhsMd := .default })]
def algebraFunctorOfMonadHomEq {T₁ T₂ : Monad C} {f g : T₁ ⟶ T₂} (h : f = g) :
    algebraFunctorOfMonadHom f ≅ algebraFunctorOfMonadHom g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} {f g : T₁ ⟶ T₂} (h : f = g) (X : T₂.Algebra)
Goal: ((CategoryTheory.Monad.algebraFunctorOfMonadHomEq h).inv.app X).f =
  (CategoryTheory.Iso.refl ((CategoryTheory.Monad.algebraFunctorOfMonadHom f).obj X).A).inv
-- CategoryTheory.Monad.algebraEquivOfIsoMonads_counitIso
@[simps]
def algebraEquivOfIsoMonads {T₁ T₂ : Monad C} (h : T₁ ≅ T₂) : Algebra T₁ ≌ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂)
Goal: (CategoryTheory.Monad.algebraEquivOfIsoMonads h).counitIso =
  (CategoryTheory.Monad.algebraFunctorOfMonadHomComp h.inv h.hom).symm ≪≫
    CategoryTheory.Monad.algebraFunctorOfMonadHomEq ⋯ ≪≫ CategoryTheory.Monad.algebraFunctorOfMonadHomId
-- CategoryTheory.Monad.algebraEquivOfIsoMonads_unitIso
@[simps]
def algebraEquivOfIsoMonads {T₁ T₂ : Monad C} (h : T₁ ≅ T₂) : Algebra T₁ ≌ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂)
Goal: (CategoryTheory.Monad.algebraEquivOfIsoMonads h).unitIso =
  CategoryTheory.Monad.algebraFunctorOfMonadHomId.symm ≪≫
    CategoryTheory.Monad.algebraFunctorOfMonadHomEq ⋯ ≪≫ CategoryTheory.Monad.algebraFunctorOfMonadHomComp h.hom h.inv
-- CategoryTheory.Monad.algebraEquivOfIsoMonads_functor
@[simps]
def algebraEquivOfIsoMonads {T₁ T₂ : Monad C} (h : T₁ ≅ T₂) : Algebra T₁ ≌ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂)
Goal: (CategoryTheory.Monad.algebraEquivOfIsoMonads h).functor = CategoryTheory.Monad.algebraFunctorOfMonadHom h.inv
-- CategoryTheory.Monad.algebraEquivOfIsoMonads_inverse
@[simps]
def algebraEquivOfIsoMonads {T₁ T₂ : Monad C} (h : T₁ ≅ T₂) : Algebra T₁ ≌ Algebra T₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂)
Goal: (CategoryTheory.Monad.algebraEquivOfIsoMonads h).inverse = CategoryTheory.Monad.algebraFunctorOfMonadHom h.hom
-- CategoryTheory.Monad.algebra_equiv_of_iso_monads_comp_forget
@[simp]
theorem algebra_equiv_of_iso_monads_comp_forget {T₁ T₂ : Monad C} (h : T₁ ⟶ T₂) :
    algebraFunctorOfMonadHom h ⋙ forget _ = forget _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ⟶ T₂)
Goal: (CategoryTheory.Monad.algebraFunctorOfMonadHom h).comp T₁.forget = T₂.forget
-- CategoryTheory.Comonad.Coalgebra.coassoc
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure Coalgebra (G : Comonad C) : Type max u₁ v₁ where
    A : C
    a : A ⟶ (G : C ⥤ C).obj A
    counit : a ≫ G.ε.app A = 𝟙 A := by aesop_cat
    coassoc : a ≫ G.δ.app A = a ≫ G.map a := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (self : G.Coalgebra)
Goal: CategoryTheory.CategoryStruct.comp self.a (G.δ.app self.A) = CategoryTheory.CategoryStruct.comp self.a (G.map self.a)
-- CategoryTheory.Comonad.Coalgebra.counit
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure Coalgebra (G : Comonad C) : Type max u₁ v₁ where
    A : C
    a : A ⟶ (G : C ⥤ C).obj A
    counit : a ≫ G.ε.app A = 𝟙 A := by aesop_cat
    coassoc : a ≫ G.δ.app A = a ≫ G.map a := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (self : G.Coalgebra)
Goal: CategoryTheory.CategoryStruct.comp self.a (G.ε.app self.A) = CategoryTheory.CategoryStruct.id self.A