ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Comonad.Coalgebra.Hom.h
-- Porting note(#5171): linter not ported yet
--@[ext, nolint has_nonempty_instance]
@[ext]
structure Hom (A B : Coalgebra G) where
    f : A.A ⟶ B.A
    h : A.a ≫ (G : C ⥤ C).map f = f ≫ B.a := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} {A B : G.Coalgebra} (self : A.Hom B)
Goal: CategoryTheory.CategoryStruct.comp A.a (G.map self.f) = CategoryTheory.CategoryStruct.comp self.f B.a
-- CategoryTheory.Comonad.Coalgebra.Hom.ext'
@[ext]
lemma Hom.ext' (X Y : Coalgebra G) (f g : X ⟶ Y) (h : f.f = g.f) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (X Y : G.Coalgebra) (f g : X ⟶ Y) (h : f.f = g.f)
Goal: f = g
-- CategoryTheory.Comonad.Coalgebra.comp_eq_comp
@[simp]
theorem comp_eq_comp {A A' A'' : Coalgebra G} (f : A ⟶ A') (g : A' ⟶ A'') :
    Coalgebra.Hom.comp f g = f ≫ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} {A A' A'' : G.Coalgebra} (f : A ⟶ A') (g : A' ⟶ A'')
Goal: CategoryTheory.Comonad.Coalgebra.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.Comonad.Coalgebra.id_eq_id
@[simp]
theorem id_eq_id (A : Coalgebra G) : Coalgebra.Hom.id A = 𝟙 A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (A : G.Coalgebra)
Goal: CategoryTheory.Comonad.Coalgebra.Hom.id A = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.Comonad.Coalgebra.id_f
@[simp]
theorem id_f (A : Coalgebra G) : (𝟙 A : A ⟶ A).f = 𝟙 A.A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (A : G.Coalgebra)
Goal: (CategoryTheory.CategoryStruct.id A).f = CategoryTheory.CategoryStruct.id A.A
-- CategoryTheory.Comonad.Coalgebra.comp_f
@[simp]
theorem comp_f {A A' A'' : Coalgebra G} (f : A ⟶ A') (g : A' ⟶ A'') : (f ≫ g).f = f.f ≫ g.f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} {A A' A'' : G.Coalgebra} (f : A ⟶ A') (g : A' ⟶ A'')
Goal: (CategoryTheory.CategoryStruct.comp f g).f = CategoryTheory.CategoryStruct.comp f.f g.f
-- CategoryTheory.Comonad.Coalgebra.isoMk_hom_f
@[simps]
def isoMk {A B : Coalgebra G} (h : A.A ≅ B.A)
    (w : A.a ≫ (G : C ⥤ C).map h.hom = h.hom ≫ B.a := by aesop_cat) : A ≅ B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} {A B : G.Coalgebra} (h : A.A ≅ B.A) (w : CategoryTheory.CategoryStruct.comp A.a (G.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom B.a := by
  aesop_cat)
Goal: (CategoryTheory.Comonad.Coalgebra.isoMk h w).hom.f = h.hom
-- CategoryTheory.Comonad.Coalgebra.isoMk_inv_f
@[simps]
def isoMk {A B : Coalgebra G} (h : A.A ≅ B.A)
    (w : A.a ≫ (G : C ⥤ C).map h.hom = h.hom ≫ B.a := by aesop_cat) : A ≅ B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} {A B : G.Coalgebra} (h : A.A ≅ B.A) (w : CategoryTheory.CategoryStruct.comp A.a (G.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom B.a := by
  aesop_cat)
Goal: (CategoryTheory.Comonad.Coalgebra.isoMk h w).inv.f = h.inv
-- CategoryTheory.Comonad.forget_map
@[simps]
def forget : Coalgebra G ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C)
Goal: ∀ {X Y : G.Coalgebra} (f : X ⟶ Y), G.forget.map f = f.f
-- CategoryTheory.Comonad.forget_obj
@[simps]
def forget : Coalgebra G ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) (A : G.Coalgebra)
Goal: G.forget.obj A = A.A
-- CategoryTheory.Comonad.cofree_map_f
@[simps]
def cofree : C ⥤ Coalgebra G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C)
Goal: ∀ {X Y : C} (f : X ⟶ Y), (G.cofree.map f).f = G.map f
-- CategoryTheory.Comonad.cofree_obj_A
@[simps]
def cofree : C ⥤ Coalgebra G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) (X : C)
Goal: (G.cofree.obj X).A = G.obj X
-- CategoryTheory.Comonad.cofree_obj_a
@[simps]
def cofree : C ⥤ Coalgebra G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) (X : C)
Goal: (G.cofree.obj X).a = G.δ.app X
-- CategoryTheory.Comonad.adj_counit
@[simps! unit counit]
def adj : G.forget ⊣ G.cofree 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C)
Goal: G.adj.counit = { app := fun Y => G.ε.app Y, naturality := ⋯ }
-- CategoryTheory.Comonad.adj_unit
@[simps! unit counit]
def adj : G.forget ⊣ G.cofree 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C)
Goal: G.adj.unit = { app := fun X => { f := X.a, h := ⋯ }, naturality := ⋯ }
-- CategoryTheory.Comonad.coalgebra_iso_of_iso
theorem coalgebra_iso_of_iso {A B : Coalgebra G} (f : A ⟶ B) [IsIso f.f] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) {A B : G.Coalgebra} (f : A ⟶ B) [CategoryTheory.IsIso f.f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Comonad.algebra_epi_of_epi
theorem algebra_epi_of_epi {X Y : Coalgebra G} (f : X ⟶ Y) [h : Epi f.f] : Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) {X Y : G.Coalgebra} (f : X ⟶ Y) [h : CategoryTheory.Epi f.f]
Goal: CategoryTheory.Epi f
-- CategoryTheory.Comonad.algebra_mono_of_mono
theorem algebra_mono_of_mono {X Y : Coalgebra G} (f : X ⟶ Y) [h : Mono f.f] : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) {X Y : G.Coalgebra} (f : X ⟶ Y) [h : CategoryTheory.Mono f.f]
Goal: CategoryTheory.Mono f
-- CategoryTheory.Monad.right_unit
structure Monad extends C ⥤ C where
    η : 𝟭 _ ⟶ toFunctor
    μ : toFunctor ⋙ toFunctor ⟶ toFunctor
  assoc : ∀ X, toFunctor.map (NatTrans.app μ X) ≫ μ.app _ = μ.app _ ≫ μ.app _ := by aesop_cat
  left_unit : ∀ X : C, η.app (toFunctor.obj X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
  right_unit : ∀ X : C, toFunctor.map (η.app X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Monad C) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.map (self.η.app X)) (self.μ.app X) =
  CategoryTheory.CategoryStruct.id (self.obj ((CategoryTheory.Functor.id C).obj X))
-- CategoryTheory.Monad.left_unit
structure Monad extends C ⥤ C where
    η : 𝟭 _ ⟶ toFunctor
    μ : toFunctor ⋙ toFunctor ⟶ toFunctor
  assoc : ∀ X, toFunctor.map (NatTrans.app μ X) ≫ μ.app _ = μ.app _ ≫ μ.app _ := by aesop_cat
  left_unit : ∀ X : C, η.app (toFunctor.obj X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
  right_unit : ∀ X : C, toFunctor.map (η.app X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Monad C) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.η.app (self.obj X)) (self.μ.app X) =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id C).obj (self.obj X))
-- CategoryTheory.Monad.assoc
structure Monad extends C ⥤ C where
    η : 𝟭 _ ⟶ toFunctor
    μ : toFunctor ⋙ toFunctor ⟶ toFunctor
  assoc : ∀ X, toFunctor.map (NatTrans.app μ X) ≫ μ.app _ = μ.app _ ≫ μ.app _ := by aesop_cat
  left_unit : ∀ X : C, η.app (toFunctor.obj X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
  right_unit : ∀ X : C, toFunctor.map (η.app X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Monad C) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.map (self.μ.app X)) (self.μ.app X) =
  CategoryTheory.CategoryStruct.comp (self.μ.app (self.obj X)) (self.μ.app X)
-- CategoryTheory.Comonad.right_counit
structure Comonad extends C ⥤ C where
    ε : toFunctor ⟶ 𝟭 _
    δ : toFunctor ⟶ toFunctor ⋙ toFunctor
  coassoc : ∀ X, NatTrans.app δ _ ≫ toFunctor.map (δ.app X) = δ.app _ ≫ δ.app _ := by
    aesop_cat
  left_counit : ∀ X : C, δ.app X ≫ ε.app (toFunctor.obj X) = 𝟙 _ := by aesop_cat
  right_counit : ∀ X : C, δ.app X ≫ toFunctor.map (ε.app X) = 𝟙 _ := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Comonad C) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.δ.app X) (self.map (self.ε.app X)) =
  CategoryTheory.CategoryStruct.id (self.obj X)
-- CategoryTheory.Comonad.coassoc
structure Comonad extends C ⥤ C where
    ε : toFunctor ⟶ 𝟭 _
    δ : toFunctor ⟶ toFunctor ⋙ toFunctor
  coassoc : ∀ X, NatTrans.app δ _ ≫ toFunctor.map (δ.app X) = δ.app _ ≫ δ.app _ := by
    aesop_cat
  left_counit : ∀ X : C, δ.app X ≫ ε.app (toFunctor.obj X) = 𝟙 _ := by aesop_cat
  right_counit : ∀ X : C, δ.app X ≫ toFunctor.map (ε.app X) = 𝟙 _ := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Comonad C) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.δ.app X) (self.map (self.δ.app X)) =
  CategoryTheory.CategoryStruct.comp (self.δ.app X) (self.δ.app (self.obj X))
-- CategoryTheory.Comonad.left_counit
structure Comonad extends C ⥤ C where
    ε : toFunctor ⟶ 𝟭 _
    δ : toFunctor ⟶ toFunctor ⋙ toFunctor
  coassoc : ∀ X, NatTrans.app δ _ ≫ toFunctor.map (δ.app X) = δ.app _ ≫ δ.app _ := by
    aesop_cat
  left_counit : ∀ X : C, δ.app X ≫ ε.app (toFunctor.obj X) = 𝟙 _ := by aesop_cat
  right_counit : ∀ X : C, δ.app X ≫ toFunctor.map (ε.app X) = 𝟙 _ := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Comonad C) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.δ.app X) (self.ε.app (self.obj X)) =
  CategoryTheory.CategoryStruct.id (self.obj X)
-- CategoryTheory.MonadHom.app_η
@[ext]
structure MonadHom (T₁ T₂ : Monad C) extends NatTrans (T₁ : C ⥤ C) T₂ where
  app_η : ∀ X, T₁.η.app X ≫ app X = T₂.η.app X := by aesop_cat
  app_μ : ∀ X, T₁.μ.app X ≫ app X = (T₁.map (app X) ≫ app _) ≫ T₂.μ.app X := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (self : CategoryTheory.MonadHom T₁ T₂) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (T₁.η.app X) (self.app X) = T₂.η.app X
-- CategoryTheory.MonadHom.app_μ
@[ext]
structure MonadHom (T₁ T₂ : Monad C) extends NatTrans (T₁ : C ⥤ C) T₂ where
  app_η : ∀ X, T₁.η.app X ≫ app X = T₂.η.app X := by aesop_cat
  app_μ : ∀ X, T₁.μ.app X ≫ app X = (T₁.map (app X) ≫ app _) ≫ T₂.μ.app X := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (self : CategoryTheory.MonadHom T₁ T₂) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (T₁.μ.app X) (self.app X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (T₁.map (self.app X)) (self.app (T₂.obj X)))
    (T₂.μ.app X)
-- CategoryTheory.ComonadHom.app_δ
@[ext]
structure ComonadHom (M N : Comonad C) extends NatTrans (M : C ⥤ C) N where
  app_ε : ∀ X, app X ≫ N.ε.app X = M.ε.app X := by aesop_cat
  app_δ : ∀ X, app X ≫ N.δ.app X = M.δ.app X ≫ app _ ≫ N.map (app X) := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (self : CategoryTheory.ComonadHom M N) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.app X) (N.δ.app X) =
  CategoryTheory.CategoryStruct.comp (M.δ.app X)
    (CategoryTheory.CategoryStruct.comp (self.app (M.obj X)) (N.map (self.app X)))
-- CategoryTheory.ComonadHom.app_ε
@[ext]
structure ComonadHom (M N : Comonad C) extends NatTrans (M : C ⥤ C) N where
  app_ε : ∀ X, app X ≫ N.ε.app X = M.ε.app X := by aesop_cat
  app_δ : ∀ X, app X ≫ N.δ.app X = M.δ.app X ≫ app _ ≫ N.map (app X) := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (self : CategoryTheory.ComonadHom M N) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (self.app X) (N.ε.app X) = M.ε.app X
-- CategoryTheory.MonadHom.ext'
@[ext]
lemma MonadHom.ext' {T₁ T₂ : Monad C} (f g : T₁ ⟶ T₂) (h : f.app = g.app) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (f g : T₁ ⟶ T₂) (h : f.app = g.app)
Goal: f = g
-- CategoryTheory.ComonadHom.ext'
@[ext]
lemma ComonadHom.ext' {T₁ T₂ : Comonad C} (f g : T₁ ⟶ T₂) (h : f.app = g.app) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Comonad C} (f g : T₁ ⟶ T₂) (h : f.app = g.app)
Goal: f = g
-- CategoryTheory.MonadHom.id_toNatTrans
@[simp]
theorem MonadHom.id_toNatTrans (T : Monad C) : (𝟙 T : T ⟶ T).toNatTrans = 𝟙 (T : C ⥤ C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C)
Goal: (CategoryTheory.CategoryStruct.id T).toNatTrans = CategoryTheory.CategoryStruct.id T.toFunctor
-- CategoryTheory.MonadHom.comp_toNatTrans
@[simp]
theorem MonadHom.comp_toNatTrans {T₁ T₂ T₃ : Monad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) :
    (f ≫ g).toNatTrans = ((f.toNatTrans : _ ⟶ (T₂ : C ⥤ C)) ≫ g.toNatTrans : (T₁ : C ⥤ C) ⟶ T₃) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ T₃ : CategoryTheory.Monad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃)
Goal: (CategoryTheory.CategoryStruct.comp f g).toNatTrans = CategoryTheory.CategoryStruct.comp f.toNatTrans g.toNatTrans
-- CategoryTheory.ComonadHom.id_toNatTrans
@[simp]
theorem ComonadHom.id_toNatTrans (T : Comonad C) : (𝟙 T : T ⟶ T).toNatTrans = 𝟙 (T : C ⥤ C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Comonad C)
Goal: (CategoryTheory.CategoryStruct.id T).toNatTrans = CategoryTheory.CategoryStruct.id T.toFunctor
-- CategoryTheory.comp_toNatTrans
@[simp]
theorem comp_toNatTrans {T₁ T₂ T₃ : Comonad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) :
    (f ≫ g).toNatTrans = ((f.toNatTrans : _ ⟶ (T₂ : C ⥤ C)) ≫ g.toNatTrans : (T₁ : C ⥤ C) ⟶ T₃) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ T₃ : CategoryTheory.Comonad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃)
Goal: (CategoryTheory.CategoryStruct.comp f g).toNatTrans = CategoryTheory.CategoryStruct.comp f.toNatTrans g.toNatTrans
-- CategoryTheory.MonadIso.mk_hom_toNatTrans
@[simps]
def MonadIso.mk {M N : Monad C} (f : (M : C ⥤ C) ≅ N)
    (f_η : ∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X := by aesop_cat)
    (f_μ : ∀ (X : C), M.μ.app X ≫ f.hom.app X =
    (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X := by aesop_cat) : M ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Monad C} (f : M.toFunctor ≅ N.toFunctor) (f_η : ∀ (X : C), CategoryTheory.CategoryStruct.comp (M.η.app X) (f.hom.app X) = N.η.app X := by aesop_cat) (f_μ :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (M.μ.app X) (f.hom.app X) =
      CategoryTheory.CategoryStruct.comp
        (CategoryTheory.CategoryStruct.comp (M.map (f.hom.app X)) (f.hom.app (N.obj X))) (N.μ.app X) := by
  aesop_cat)
Goal: (CategoryTheory.MonadIso.mk f f_η f_μ).hom.toNatTrans = f.hom
-- CategoryTheory.MonadIso.mk_inv_toNatTrans
@[simps]
def MonadIso.mk {M N : Monad C} (f : (M : C ⥤ C) ≅ N)
    (f_η : ∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X := by aesop_cat)
    (f_μ : ∀ (X : C), M.μ.app X ≫ f.hom.app X =
    (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X := by aesop_cat) : M ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Monad C} (f : M.toFunctor ≅ N.toFunctor) (f_η : ∀ (X : C), CategoryTheory.CategoryStruct.comp (M.η.app X) (f.hom.app X) = N.η.app X := by aesop_cat) (f_μ :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (M.μ.app X) (f.hom.app X) =
      CategoryTheory.CategoryStruct.comp
        (CategoryTheory.CategoryStruct.comp (M.map (f.hom.app X)) (f.hom.app (N.obj X))) (N.μ.app X) := by
  aesop_cat)
Goal: (CategoryTheory.MonadIso.mk f f_η f_μ).inv.toNatTrans = f.inv
-- CategoryTheory.ComonadIso.mk_hom_toNatTrans
@[simps]
def ComonadIso.mk {M N : Comonad C} (f : (M : C ⥤ C) ≅ N)
    (f_ε : ∀ (X : C), f.hom.app X ≫ N.ε.app X = M.ε.app X := by aesop_cat)
    (f_δ : ∀ (X : C), f.hom.app X ≫ N.δ.app X =
    M.δ.app X ≫ f.hom.app (M.obj X) ≫ N.map (f.hom.app X) := by aesop_cat) : M ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (f : M.toFunctor ≅ N.toFunctor) (f_ε : ∀ (X : C), CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.ε.app X) = M.ε.app X := by aesop_cat) (f_δ :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.δ.app X) =
      CategoryTheory.CategoryStruct.comp (M.δ.app X)
        (CategoryTheory.CategoryStruct.comp (f.hom.app (M.obj X)) (N.map (f.hom.app X))) := by
  aesop_cat)
Goal: (CategoryTheory.ComonadIso.mk f f_ε f_δ).hom.toNatTrans = f.hom
-- CategoryTheory.ComonadIso.mk_inv_toNatTrans
@[simps]
def ComonadIso.mk {M N : Comonad C} (f : (M : C ⥤ C) ≅ N)
    (f_ε : ∀ (X : C), f.hom.app X ≫ N.ε.app X = M.ε.app X := by aesop_cat)
    (f_δ : ∀ (X : C), f.hom.app X ≫ N.δ.app X =
    M.δ.app X ≫ f.hom.app (M.obj X) ≫ N.map (f.hom.app X) := by aesop_cat) : M ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (f : M.toFunctor ≅ N.toFunctor) (f_ε : ∀ (X : C), CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.ε.app X) = M.ε.app X := by aesop_cat) (f_δ :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.δ.app X) =
      CategoryTheory.CategoryStruct.comp (M.δ.app X)
        (CategoryTheory.CategoryStruct.comp (f.hom.app (M.obj X)) (N.map (f.hom.app X))) := by
  aesop_cat)
Goal: (CategoryTheory.ComonadIso.mk f f_ε f_δ).inv.toNatTrans = f.inv
-- CategoryTheory.monadToFunctor_map
@[simps!]
def monadToFunctor : Monad C ⥤ C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.Monad C} (f : X ⟶ Y), (CategoryTheory.monadToFunctor C).map f = f.toNatTrans
-- CategoryTheory.monadToFunctor_obj
@[simps!]
def monadToFunctor : Monad C ⥤ C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C)
Goal: (CategoryTheory.monadToFunctor C).obj T = T.toFunctor
-- CategoryTheory.monadToFunctor_mapIso_monad_iso_mk
theorem monadToFunctor_mapIso_monad_iso_mk {M N : Monad C} (f : (M : C ⥤ C) ≅ N) (f_η f_μ) :
    (monadToFunctor _).mapIso (MonadIso.mk f f_η f_μ) = f 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Monad C} (f : M.toFunctor ≅ N.toFunctor) (f_η : ∀ (X : C), CategoryTheory.CategoryStruct.comp (M.η.app X) (f.hom.app X) = N.η.app X) (f_μ :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (M.μ.app X) (f.hom.app X) =
      CategoryTheory.CategoryStruct.comp
        (CategoryTheory.CategoryStruct.comp (M.map (f.hom.app X)) (f.hom.app (N.obj X))) (N.μ.app X))
Goal: (CategoryTheory.monadToFunctor C).mapIso (CategoryTheory.MonadIso.mk f f_η f_μ) = f
-- CategoryTheory.comonadToFunctor_obj
@[simps!]
def comonadToFunctor : Comonad C ⥤ C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C)
Goal: (CategoryTheory.comonadToFunctor C).obj G = G.toFunctor
-- CategoryTheory.comonadToFunctor_map
@[simps!]
def comonadToFunctor : Comonad C ⥤ C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.Comonad C} (f : X ⟶ Y), (CategoryTheory.comonadToFunctor C).map f = f.toNatTrans
-- CategoryTheory.comonadToFunctor_mapIso_comonad_iso_mk
theorem comonadToFunctor_mapIso_comonad_iso_mk {M N : Comonad C} (f : (M : C ⥤ C) ≅ N) (f_ε f_δ) :
    (comonadToFunctor _).mapIso (ComonadIso.mk f f_ε f_δ) = f 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (f : M.toFunctor ≅ N.toFunctor) (f_ε : ∀ (X : C), CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.ε.app X) = M.ε.app X) (f_δ :
  ∀ (X : C),
    CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.δ.app X) =
      CategoryTheory.CategoryStruct.comp (M.δ.app X)
        (CategoryTheory.CategoryStruct.comp (f.hom.app (M.obj X)) (N.map (f.hom.app X))))
Goal: (CategoryTheory.comonadToFunctor C).mapIso (CategoryTheory.ComonadIso.mk f f_ε f_δ) = f
-- CategoryTheory.MonadIso.toNatIso_inv
/- Porting note: removed
`@[simps (config := { rhsMd := semireducible })]`
and replaced with `@[simps]` in the two declarations below-/
@[simps!]
def MonadIso.toNatIso {M N : Monad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Monad C} (h : M ≅ N)
Goal: (CategoryTheory.MonadIso.toNatIso h).inv = h.inv.toNatTrans
-- CategoryTheory.MonadIso.toNatIso_hom
/- Porting note: removed
`@[simps (config := { rhsMd := semireducible })]`
and replaced with `@[simps]` in the two declarations below-/
@[simps!]
def MonadIso.toNatIso {M N : Monad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Monad C} (h : M ≅ N)
Goal: (CategoryTheory.MonadIso.toNatIso h).hom = h.hom.toNatTrans
-- CategoryTheory.ComonadIso.toNatIso_inv
@[simps!]
def ComonadIso.toNatIso {M N : Comonad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (h : M ≅ N)
Goal: (CategoryTheory.ComonadIso.toNatIso h).inv = h.inv.toNatTrans
-- CategoryTheory.ComonadIso.toNatIso_hom
@[simps!]
def ComonadIso.toNatIso {M N : Comonad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C} (h : M ≅ N)
Goal: (CategoryTheory.ComonadIso.toNatIso h).hom = h.hom.toNatTrans
-- CategoryTheory.Monad.id_obj
@[simps!]
def id : Monad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Monad.id C).obj X = X
-- CategoryTheory.Monad.id_η_app
@[simps!]
def id : Monad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Monad.id C).η.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Monad.id_μ_app
@[simps!]
def id : Monad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Monad.id C).μ.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Monad.id_map
@[simps!]
def id : Monad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.Monad.id C).map f = f
-- CategoryTheory.Comonad.id_δ_app
@[simps!]
def id : Comonad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Comonad.id C).δ.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Comonad.id_ε_app
@[simps!]
def id : Comonad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Comonad.id C).ε.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Comonad.id_obj
@[simps!]
def id : Comonad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Comonad.id C).obj X = X
-- CategoryTheory.Comonad.id_map
@[simps!]
def id : Comonad C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.Comonad.id C).map f = f
-- CategoryTheory.MorphismProperty.le_def
lemma MorphismProperty.le_def {P Q : MorphismProperty C} :
    P ≤ Q ↔ ∀ {X Y : C} (f : X ⟶ Y), P f → Q f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.MorphismProperty C}
Goal: P ≤ Q ↔ ∀ {X Y : C} (f : X ⟶ Y), P f → Q f
-- CategoryTheory.MorphismProperty.top_eq
lemma MorphismProperty.top_eq : (⊤ : MorphismProperty C) = fun _ _ _ => True 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ⊤ = fun x x_1 x => True
-- CategoryTheory.MorphismProperty.ext
@[ext]
lemma ext (W W' : MorphismProperty C) (h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f) :
    W = W' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W W' : CategoryTheory.MorphismProperty C) (h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f)
Goal: W = W'
-- CategoryTheory.MorphismProperty.top_apply
@[simp]
lemma top_apply {X Y : C} (f : X ⟶ Y) : (⊤ : MorphismProperty C) f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: ⊤ f
-- CategoryTheory.MorphismProperty.unop_op
theorem unop_op (P : MorphismProperty C) : P.op.unop = P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
Goal: P.op.unop = P