ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Idempotents.KaroubiKaroubi.p_comm_f
@[reassoc]
lemma p_comm_f {P Q : Karoubi (Karoubi C)} (f : P ⟶ Q) : P.p.f ≫ f.f.f = f.f.f ≫ Q.p.f 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C)} (f : P ⟶ Q)
Goal: CategoryTheory.CategoryStruct.comp P.p.f f.f.f = CategoryTheory.CategoryStruct.comp f.f.f Q.p.f
-- CategoryTheory.Idempotents.KaroubiKaroubi.inverse_obj_p
@[simps]
def inverse : Karoubi (Karoubi C) ⥤ Karoubi C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C))
Goal: ((CategoryTheory.Idempotents.KaroubiKaroubi.inverse C).obj P).p = P.p.f
-- CategoryTheory.Idempotents.KaroubiKaroubi.inverse_obj_X
@[simps]
def inverse : Karoubi (Karoubi C) ⥤ Karoubi C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C))
Goal: ((CategoryTheory.Idempotents.KaroubiKaroubi.inverse C).obj P).X = P.X.X
-- CategoryTheory.Idempotents.KaroubiKaroubi.inverse_map_f
@[simps]
def inverse : Karoubi (Karoubi C) ⥤ Karoubi C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: ∀ {X Y : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C)} (f : X ⟶ Y),
  ((CategoryTheory.Idempotents.KaroubiKaroubi.inverse C).map f).f = f.f.f
-- CategoryTheory.Idempotents.KaroubiKaroubi.unitIso_inv_app_f
@[simps!]
def unitIso : 𝟭 (Karoubi C) ≅ toKaroubi (Karoubi C) ⋙ inverse C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.Idempotents.Karoubi C)
Goal: ((CategoryTheory.Idempotents.KaroubiKaroubi.unitIso C).inv.app X).f = X.p
-- CategoryTheory.Idempotents.KaroubiKaroubi.unitIso_hom_app_f
@[simps!]
def unitIso : 𝟭 (Karoubi C) ≅ toKaroubi (Karoubi C) ⋙ inverse C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.Idempotents.Karoubi C)
Goal: ((CategoryTheory.Idempotents.KaroubiKaroubi.unitIso C).hom.app X).f = X.p
-- CategoryTheory.Idempotents.KaroubiKaroubi.counitIso_hom_app_f_f
@[simps]
def counitIso : inverse C ⋙ toKaroubi (Karoubi C) ≅ 𝟭 (Karoubi (Karoubi C)) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C))
Goal: ((CategoryTheory.Idempotents.KaroubiKaroubi.counitIso C).hom.app P).f.f = P.p.f
-- CategoryTheory.Idempotents.KaroubiKaroubi.counitIso_inv_app_f_f
@[simps]
def counitIso : inverse C ⋙ toKaroubi (Karoubi C) ≅ 𝟭 (Karoubi (Karoubi C)) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C))
Goal: ((CategoryTheory.Idempotents.KaroubiKaroubi.counitIso C).inv.app P).f.f = P.p.f
-- CategoryTheory.Idempotents.KaroubiKaroubi.equivalence_functor
@[simps]
def equivalence : Karoubi C ≌ Karoubi (Karoubi C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: (CategoryTheory.Idempotents.KaroubiKaroubi.equivalence C).functor =
  CategoryTheory.Idempotents.toKaroubi (CategoryTheory.Idempotents.Karoubi C)
-- CategoryTheory.Idempotents.KaroubiKaroubi.equivalence_inverse
@[simps]
def equivalence : Karoubi C ≌ Karoubi (Karoubi C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: (CategoryTheory.Idempotents.KaroubiKaroubi.equivalence C).inverse = CategoryTheory.Idempotents.KaroubiKaroubi.inverse C
-- CategoryTheory.Idempotents.KaroubiKaroubi.equivalence_counitIso
@[simps]
def equivalence : Karoubi C ≌ Karoubi (Karoubi C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: (CategoryTheory.Idempotents.KaroubiKaroubi.equivalence C).counitIso =
  CategoryTheory.Idempotents.KaroubiKaroubi.counitIso C
-- CategoryTheory.Idempotents.KaroubiKaroubi.equivalence_unitIso
@[simps]
def equivalence : Karoubi C ≌ Karoubi (Karoubi C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: (CategoryTheory.Idempotents.KaroubiKaroubi.equivalence C).unitIso = CategoryTheory.Idempotents.KaroubiKaroubi.unitIso C
-- CategoryTheory.MorphismProperty.ContainsIdentities.id_mem
class ContainsIdentities (W : MorphismProperty C) : Prop :=
    id_mem : ∀ (X : C), W (𝟙 X)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} [self : W.ContainsIdentities] (X : C)
Goal: W (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.MorphismProperty.id_mem
lemma id_mem (W : MorphismProperty C) [W.ContainsIdentities] (X : C) :
    W (𝟙 X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.ContainsIdentities] (X : C)
Goal: W (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.MorphismProperty.ContainsIdentities.of_op
lemma of_op (W : MorphismProperty C) [W.op.ContainsIdentities] :
    W.ContainsIdentities 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.op.ContainsIdentities]
Goal: W.ContainsIdentities
-- CategoryTheory.MorphismProperty.ContainsIdentities.of_unop
lemma of_unop (W : MorphismProperty Cᵒᵖ) [W.unop.ContainsIdentities] :
    W.ContainsIdentities 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty Cᵒᵖ) [W.unop.ContainsIdentities]
Goal: W.ContainsIdentities
-- CategoryTheory.MorphismProperty.IsStableUnderComposition.comp_mem
class IsStableUnderComposition (P : MorphismProperty C) : Prop :=
  comp_mem {X Y Z} (f : X ⟶ Y) (g : Y ⟶ Z) : P f → P g → P (f ≫ g)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} [self : P.IsStableUnderComposition] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: P f → P g → P (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.MorphismProperty.comp_mem
lemma comp_mem (W : MorphismProperty C) [W.IsStableUnderComposition]
    {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hg : W g) : W (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.IsStableUnderComposition] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hg : W g)
Goal: W (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.MorphismProperty.StableUnderInverse.op
theorem StableUnderInverse.op {P : MorphismProperty C} (h : StableUnderInverse P) :
    StableUnderInverse P.op 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} (h : P.StableUnderInverse)
Goal: P.op.StableUnderInverse
-- CategoryTheory.MorphismProperty.StableUnderInverse.unop
theorem StableUnderInverse.unop {P : MorphismProperty Cᵒᵖ} (h : StableUnderInverse P) :
    StableUnderInverse P.unop 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty Cᵒᵖ} (h : P.StableUnderInverse)
Goal: P.unop.StableUnderInverse
-- CategoryTheory.MorphismProperty.respectsIso_of_isStableUnderComposition
theorem respectsIso_of_isStableUnderComposition {P : MorphismProperty C}
    [P.IsStableUnderComposition] (hP : isomorphisms C ≤ P) :
    RespectsIso P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} [P.IsStableUnderComposition] (hP : CategoryTheory.MorphismProperty.isomorphisms C ≤ P)
Goal: P.RespectsIso
-- CategoryTheory.MorphismProperty.naturalityProperty.stableUnderInverse
theorem stableUnderInverse {F₁ F₂ : C ⥤ D} (app : ∀ X, F₁.obj X ⟶ F₂.obj X) :
    (naturalityProperty app).StableUnderInverse 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {F₁ F₂ : CategoryTheory.Functor C D} (app : (X : C) → F₁.obj X ⟶ F₂.obj X)
Goal: (CategoryTheory.MorphismProperty.naturalityProperty app).StableUnderInverse
-- CategoryTheory.MorphismProperty.IsMultiplicative.of_op
lemma of_op (W : MorphismProperty C) [IsMultiplicative W.op] : IsMultiplicative W 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.op.IsMultiplicative]
Goal: W.IsMultiplicative
-- CategoryTheory.MorphismProperty.IsMultiplicative.of_unop
lemma of_unop (W : MorphismProperty Cᵒᵖ) [IsMultiplicative W.unop] : IsMultiplicative W 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty Cᵒᵖ) [W.unop.IsMultiplicative]
Goal: W.IsMultiplicative
-- CategoryTheory.MorphismProperty.HasTwoOutOfThreeProperty.of_precomp
class HasTwoOutOfThreeProperty (W : MorphismProperty C)
    extends W.IsStableUnderComposition : Prop where
  of_postcomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : W g → W (f ≫ g) → W f
  of_precomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : W f → W (f ≫ g) → W g
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} [self : W.HasTwoOutOfThreeProperty] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: W f → W (CategoryTheory.CategoryStruct.comp f g) → W g
-- CategoryTheory.MorphismProperty.HasTwoOutOfThreeProperty.of_postcomp
class HasTwoOutOfThreeProperty (W : MorphismProperty C)
    extends W.IsStableUnderComposition : Prop where
  of_postcomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : W g → W (f ≫ g) → W f
  of_precomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : W f → W (f ≫ g) → W g
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} [self : W.HasTwoOutOfThreeProperty] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: W g → W (CategoryTheory.CategoryStruct.comp f g) → W f
-- CategoryTheory.MorphismProperty.of_postcomp
lemma of_postcomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hg : W g) (hfg : W (f ≫ g)) :
    W f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.HasTwoOutOfThreeProperty] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hg : W g) (hfg : W (CategoryTheory.CategoryStruct.comp f g))
Goal: W f
-- CategoryTheory.MorphismProperty.of_precomp
lemma of_precomp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hfg : W (f ≫ g)) :
    W g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.HasTwoOutOfThreeProperty] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hfg : W (CategoryTheory.CategoryStruct.comp f g))
Goal: W g
-- CategoryTheory.MorphismProperty.postcomp_iff
lemma postcomp_iff {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hg : W g) :
    W (f ≫ g) ↔ W f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.HasTwoOutOfThreeProperty] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hg : W g)
Goal: W (CategoryTheory.CategoryStruct.comp f g) ↔ W f
-- CategoryTheory.MorphismProperty.precomp_iff
lemma precomp_iff {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) :
    W (f ≫ g) ↔ W g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) [W.HasTwoOutOfThreeProperty] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f)
Goal: W (CategoryTheory.CategoryStruct.comp f g) ↔ W g
-- CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv_apply_f
@[simps!]
def comparisonLeftAdjointHomEquiv (A : adj.toMonad.Algebra) (B : D)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (comparisonLeftAdjointObj adj A ⟶ B) ≃ (A ⟶ (comparison adj).obj B) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G) (A : adj.toMonad.Algebra) (B : D) [CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
Goal: ∀ (a : CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointObj adj A ⟶ B),
  ((CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv adj A B) a).f =
    CategoryTheory.CategoryStruct.comp (adj.unit.app A.A)
      (G.map
        ↑((CategoryTheory.Limits.Cofork.IsColimit.homIso
              (CategoryTheory.Limits.colimit.isColimit
                (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))))
              B)
            a))
-- CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv_symm_apply
@[simps!]
def comparisonLeftAdjointHomEquiv (A : adj.toMonad.Algebra) (B : D)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (comparisonLeftAdjointObj adj A ⟶ B) ≃ (A ⟶ (comparison adj).obj B) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G) (A : adj.toMonad.Algebra) (B : D) [CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
Goal: ∀ (a : A ⟶ (CategoryTheory.Monad.comparison adj).obj B),
  (CategoryTheory.Monad.MonadicityInternal.comparisonLeftAdjointHomEquiv adj A B).symm a =
    (CategoryTheory.Limits.Cofork.IsColimit.homIso
          (CategoryTheory.Limits.colimit.isColimit
            (CategoryTheory.Limits.parallelPair (F.map A.a) (adj.counit.app (F.obj A.A))))
          B).symm
      ⟨CategoryTheory.CategoryStruct.comp (F.map a.f) (adj.counit.app B), ⋯⟩
-- CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_counit
@[simps! counit]
def comparisonAdjunction
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))] :
    leftAdjointComparison adj ⊣ comparison adj 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G) [∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
Goal: (CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).counit =
  {
    app := fun Y =>
      (CategoryTheory.Limits.Cofork.IsColimit.homIso
            (CategoryTheory.Limits.colimit.isColimit
              (CategoryTheory.Limits.parallelPair (F.map (G.map (adj.counit.app Y)))
                (adj.counit.app (F.obj (G.obj Y)))))
            Y).symm
        ⟨adj.counit.app Y, ⋯⟩,
    naturality := ⋯ }
-- CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_unit_f_aux
theorem comparisonAdjunction_unit_f_aux
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))]
    (A : adj.toMonad.Algebra) :
    ((comparisonAdjunction adj).unit.app A).f =
      adj.homEquiv A.A _
        (coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A))) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} {adj : F ⊣ G} [∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (A : adj.toMonad.Algebra)
Goal: ((CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).unit.app A).f =
  (adj.homEquiv A.A (CategoryTheory.Limits.coequalizer (F.map A.a) (adj.counit.app (F.obj A.A))))
    (CategoryTheory.Limits.coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A)))
-- CategoryTheory.Monad.MonadicityInternal.unitCofork_pt
@[simps! pt]
def unitCofork (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    Cofork (G.map (F.map A.a)) (G.map (adj.counit.app (F.obj A.A))) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} {adj : F ⊣ G} (A : adj.toMonad.Algebra) [CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
Goal: (CategoryTheory.Monad.MonadicityInternal.unitCofork A).pt =
  G.obj (CategoryTheory.Limits.coequalizer (F.map A.a) (adj.counit.app (F.obj A.A)))
-- CategoryTheory.Monad.MonadicityInternal.unitCofork_π
@[simp]
theorem unitCofork_π (A : adj.toMonad.Algebra)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (unitCofork A).π = G.map (coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A))) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} {adj : F ⊣ G} (A : adj.toMonad.Algebra) [CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))]
Goal: (CategoryTheory.Monad.MonadicityInternal.unitCofork A).π =
  G.map (CategoryTheory.Limits.coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A)))
-- CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_unit_f
theorem comparisonAdjunction_unit_f
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))]
    (A : adj.toMonad.Algebra) :
    ((comparisonAdjunction adj).unit.app A).f = (beckCoequalizer A).desc (unitCofork A) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} {adj : F ⊣ G} [∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (A : adj.toMonad.Algebra)
Goal: ((CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).unit.app A).f =
  (CategoryTheory.Monad.beckCoequalizer A).desc (CategoryTheory.Monad.MonadicityInternal.unitCofork A)
-- CategoryTheory.Monad.MonadicityInternal.counitCofork_pt
@[simps!]
def counitCofork (B : D) :
    Cofork (F.map (G.map (adj.counit.app B)))
      (adj.counit.app (F.obj (G.obj B))) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G) (B : D)
Goal: (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B).pt = B
-- CategoryTheory.Monad.MonadicityInternal.counitCofork_ι_app
@[simps!]
def counitCofork (B : D) :
    Cofork (F.map (G.map (adj.counit.app B)))
      (adj.counit.app (F.obj (G.obj B))) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G) (B : D) (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B).ι.app X =
  CategoryTheory.Limits.WalkingParallelPair.rec
    (CategoryTheory.CategoryStruct.comp (adj.counit.app (F.obj (G.obj B))) (adj.counit.app B)) (adj.counit.app B) X
-- CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_counit_app
theorem comparisonAdjunction_counit_app
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D) :
    (comparisonAdjunction adj).counit.app B = colimit.desc _ (counitCofork adj B) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G) [∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D)
Goal: (CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction adj).counit.app B =
  CategoryTheory.Limits.colimit.desc
    (CategoryTheory.Limits.parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
    (CategoryTheory.Monad.MonadicityInternal.counitCofork adj B)
-- CategoryTheory.Monad.HasCoequalizerOfIsSplitPair.out
class HasCoequalizerOfIsSplitPair (G : D ⥤ C) : Prop where
  out : ∀ {A B} (f g : A ⟶ B) [G.IsSplitPair f g], HasCoequalizer f g
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₁, u₂} D] (G : CategoryTheory.Functor D C) [self : CategoryTheory.Monad.HasCoequalizerOfIsSplitPair G] {A B : D} (f g : A ⟶ B) [G.IsSplitPair f g]
Goal: CategoryTheory.Limits.HasCoequalizer f g
-- CategoryTheory.prodComonad_obj
@[simps!]
def prodComonad : Comonad C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] (Y : C)
Goal: (CategoryTheory.prodComonad X).obj Y = (X ⨯ Y)
-- CategoryTheory.prodComonad_map
@[simps!]
def prodComonad : Comonad C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] {Y Z : C} (g : Y ⟶ Z)
Goal: (CategoryTheory.prodComonad X).map g = CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) g
-- CategoryTheory.prodComonad_ε_app
@[simps!]
def prodComonad : Comonad C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] (Y : C)
Goal: (CategoryTheory.prodComonad X).ε.app Y = CategoryTheory.Limits.prod.snd
-- CategoryTheory.prodComonad_δ_app
@[simps!]
def prodComonad : Comonad C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] (Y : C)
Goal: (CategoryTheory.prodComonad X).δ.app Y =
  CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst (CategoryTheory.CategoryStruct.id (X ⨯ Y))
-- CategoryTheory.coalgebraToOver_obj
@[simps]
def coalgebraToOver : Coalgebra (prodComonad X) ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] (A : (CategoryTheory.prodComonad X).Coalgebra)
Goal: (CategoryTheory.coalgebraToOver X).obj A =
  CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.comp A.a CategoryTheory.Limits.prod.fst)
-- CategoryTheory.coalgebraToOver_map
@[simps]
def coalgebraToOver : Coalgebra (prodComonad X) ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: ∀ {X_1 Y : (CategoryTheory.prodComonad X).Coalgebra} (f : X_1 ⟶ Y),
  (CategoryTheory.coalgebraToOver X).map f = CategoryTheory.Over.homMk f.f ⋯
-- CategoryTheory.overToCoalgebra_obj_a
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] (f : CategoryTheory.Over X)
Goal: ((CategoryTheory.overToCoalgebra X).obj f).a =
  CategoryTheory.Limits.prod.lift f.hom (CategoryTheory.CategoryStruct.id f.left)
-- CategoryTheory.overToCoalgebra_map_f
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: ∀ {X_1 Y : CategoryTheory.Over X} (g : X_1 ⟶ Y), ((CategoryTheory.overToCoalgebra X).map g).f = g.left
-- CategoryTheory.overToCoalgebra_obj_A
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C] (f : CategoryTheory.Over X)
Goal: ((CategoryTheory.overToCoalgebra X).obj f).A = f.left
-- CategoryTheory.coalgebraEquivOver_counitIso
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: (CategoryTheory.coalgebraEquivOver X).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun f =>
      CategoryTheory.Over.isoMk
        (CategoryTheory.Iso.refl
          (((CategoryTheory.overToCoalgebra X).comp (CategoryTheory.coalgebraToOver X)).obj f).left)
        ⋯)
    ⋯
-- CategoryTheory.coalgebraEquivOver_functor
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: (CategoryTheory.coalgebraEquivOver X).functor = CategoryTheory.coalgebraToOver X
-- CategoryTheory.coalgebraEquivOver_unitIso
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: (CategoryTheory.coalgebraEquivOver X).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun A =>
      CategoryTheory.Comonad.Coalgebra.isoMk
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.prodComonad X).Coalgebra).obj A).A) ⋯)
    ⋯