ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Equivalence.prod_unitIso
@[simps]
def prod (E₁ : A ≌ B) (E₂ : C ≌ D) : A × C ≌ B × D 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (E₁ : A ≌ B) (E₂ : C ≌ D)
Goal: (E₁.prod E₂).unitIso = CategoryTheory.NatIso.prod E₁.unitIso E₂.unitIso
-- CategoryTheory.Equivalence.prod_inverse
@[simps]
def prod (E₁ : A ≌ B) (E₂ : C ≌ D) : A × C ≌ B × D 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (E₁ : A ≌ B) (E₂ : C ≌ D)
Goal: (E₁.prod E₂).inverse = E₁.inverse.prod E₂.inverse
-- CategoryTheory.Equivalence.prod_counitIso
@[simps]
def prod (E₁ : A ≌ B) (E₂ : C ≌ D) : A × C ≌ B × D 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (E₁ : A ≌ B) (E₂ : C ≌ D)
Goal: (E₁.prod E₂).counitIso = CategoryTheory.NatIso.prod E₁.counitIso E₂.counitIso
-- CategoryTheory.flipCompEvaluation_hom_app
@[simps!]
def flipCompEvaluation (F : A ⥤ B ⥤ C) (a) : F.flip ⋙ (evaluation _ _).obj a ≅ F.obj a 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A (CategoryTheory.Functor B C)) (a : A) (X : B)
Goal: (CategoryTheory.flipCompEvaluation F a).hom.app X = CategoryTheory.CategoryStruct.id ((F.obj a).obj X)
-- CategoryTheory.flipCompEvaluation_inv_app
@[simps!]
def flipCompEvaluation (F : A ⥤ B ⥤ C) (a) : F.flip ⋙ (evaluation _ _).obj a ≅ F.obj a 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A (CategoryTheory.Functor B C)) (a : A) (X : B)
Goal: (CategoryTheory.flipCompEvaluation F a).inv.app X = CategoryTheory.CategoryStruct.id ((F.obj a).obj X)
-- CategoryTheory.prodFunctorToFunctorProd_map_app
@[simps]
def prodFunctorToFunctorProd : (A ⥤ B) × (A ⥤ C) ⥤ A ⥤ B × C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: ∀ {X Y : CategoryTheory.Functor A B × CategoryTheory.Functor A C} (f : X ⟶ Y) (X_1 : A),
  ((CategoryTheory.prodFunctorToFunctorProd A B C).map f).app X_1 = (f.1.app X_1, f.2.app X_1)
-- CategoryTheory.prodFunctorToFunctorProd_obj
@[simps]
def prodFunctorToFunctorProd : (A ⥤ B) × (A ⥤ C) ⥤ A ⥤ B × C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B × CategoryTheory.Functor A C)
Goal: (CategoryTheory.prodFunctorToFunctorProd A B C).obj F = F.1.prod' F.2
-- CategoryTheory.functorProdToProdFunctor_map
@[simps]
def functorProdToProdFunctor : (A ⥤ B × C) ⥤ (A ⥤ B) × (A ⥤ C) 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: ∀ {X Y : CategoryTheory.Functor A (B × C)} (α : X ⟶ Y),
  (CategoryTheory.functorProdToProdFunctor A B C).map α =
    ({ app := fun X_1 => (α.app X_1).1, naturality := ⋯ }, { app := fun X_1 => (α.app X_1).2, naturality := ⋯ })
-- CategoryTheory.functorProdToProdFunctor_obj
@[simps]
def functorProdToProdFunctor : (A ⥤ B × C) ⥤ (A ⥤ B) × (A ⥤ C) 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A (B × C))
Goal: (CategoryTheory.functorProdToProdFunctor A B C).obj F =
  (F.comp (CategoryTheory.Prod.fst B C), F.comp (CategoryTheory.Prod.snd B C))
-- CategoryTheory.functorProdFunctorEquivUnitIso_inv_app
@[simps!]
def functorProdFunctorEquivUnitIso :
    𝟭 _ ≅ prodFunctorToFunctorProd A B C ⋙ functorProdToProdFunctor A B C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (X : CategoryTheory.Functor A B × CategoryTheory.Functor A C)
Goal: (CategoryTheory.functorProdFunctorEquivUnitIso A B C).inv.app X =
  ((X.1.prod'CompFst X.2).hom, (X.1.prod'CompSnd X.2).hom)
-- CategoryTheory.functorProdFunctorEquivUnitIso_hom_app
@[simps!]
def functorProdFunctorEquivUnitIso :
    𝟭 _ ≅ prodFunctorToFunctorProd A B C ⋙ functorProdToProdFunctor A B C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (X : CategoryTheory.Functor A B × CategoryTheory.Functor A C)
Goal: (CategoryTheory.functorProdFunctorEquivUnitIso A B C).hom.app X =
  ((X.1.prod'CompFst X.2).inv, (X.1.prod'CompSnd X.2).inv)
-- CategoryTheory.functorProdFunctorEquivCounitIso_hom_app_app
@[simps!]
def functorProdFunctorEquivCounitIso :
    functorProdToProdFunctor A B C ⋙ prodFunctorToFunctorProd A B C ≅ 𝟭 _ 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (X : CategoryTheory.Functor A (B × C))
Goal: ∀ (X_1 : A),
  ((CategoryTheory.functorProdFunctorEquivCounitIso A B C).hom.app X).app X_1 =
    (CategoryTheory.CategoryStruct.id (X.obj X_1).1, CategoryTheory.CategoryStruct.id (X.obj X_1).2)
-- CategoryTheory.functorProdFunctorEquivCounitIso_inv_app_app
@[simps!]
def functorProdFunctorEquivCounitIso :
    functorProdToProdFunctor A B C ⋙ prodFunctorToFunctorProd A B C ≅ 𝟭 _ 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (X : CategoryTheory.Functor A (B × C))
Goal: ∀ (X_1 : A),
  ((CategoryTheory.functorProdFunctorEquivCounitIso A B C).inv.app X).app X_1 =
    (CategoryTheory.CategoryStruct.id (X.obj X_1).1, CategoryTheory.CategoryStruct.id (X.obj X_1).2)
-- CategoryTheory.functorProdFunctorEquiv_functor
@[simps]
def functorProdFunctorEquiv : (A ⥤ B) × (A ⥤ C) ≌ A ⥤ B × C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: (CategoryTheory.functorProdFunctorEquiv A B C).functor = CategoryTheory.prodFunctorToFunctorProd A B C
-- CategoryTheory.functorProdFunctorEquiv_unitIso
@[simps]
def functorProdFunctorEquiv : (A ⥤ B) × (A ⥤ C) ≌ A ⥤ B × C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: (CategoryTheory.functorProdFunctorEquiv A B C).unitIso = CategoryTheory.functorProdFunctorEquivUnitIso A B C
-- CategoryTheory.functorProdFunctorEquiv_counitIso
@[simps]
def functorProdFunctorEquiv : (A ⥤ B) × (A ⥤ C) ≌ A ⥤ B × C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: (CategoryTheory.functorProdFunctorEquiv A B C).counitIso = CategoryTheory.functorProdFunctorEquivCounitIso A B C
-- CategoryTheory.functorProdFunctorEquiv_inverse
@[simps]
def functorProdFunctorEquiv : (A ⥤ B) × (A ⥤ C) ≌ A ⥤ B × C 
Arguments: (A : Type u₁) [CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [CategoryTheory.Category.{v₂, u₂} B] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: (CategoryTheory.functorProdFunctorEquiv A B C).inverse = CategoryTheory.functorProdToProdFunctor A B C
-- CategoryTheory.prodOpEquiv_inverse_obj
@[simps]
def prodOpEquiv : (C × D)ᵒᵖ ≌ Cᵒᵖ × Dᵒᵖ 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D]
Goal: ∀ (x : Cᵒᵖ × Dᵒᵖ),
  (CategoryTheory.prodOpEquiv C).inverse.obj x =
    match x with
    | (X, Y) => Opposite.op (Opposite.unop X, Opposite.unop Y)
-- CategoryTheory.prodOpEquiv_functor_obj
@[simps]
def prodOpEquiv : (C × D)ᵒᵖ ≌ Cᵒᵖ × Dᵒᵖ 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (X : (C × D)ᵒᵖ)
Goal: (CategoryTheory.prodOpEquiv C).functor.obj X = (Opposite.op (Opposite.unop X).1, Opposite.op (Opposite.unop X).2)
-- CategoryTheory.prodOpEquiv_functor_map
@[simps]
def prodOpEquiv : (C × D)ᵒᵖ ≌ Cᵒᵖ × Dᵒᵖ 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D]
Goal: ∀ {X Y : (C × D)ᵒᵖ} (f : X ⟶ Y), (CategoryTheory.prodOpEquiv C).functor.map f = (f.unop.1.op, f.unop.2.op)
-- CategoryTheory.prodOpEquiv_unitIso
@[simps]
def prodOpEquiv : (C × D)ᵒᵖ ≌ Cᵒᵖ × Dᵒᵖ 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D]
Goal: (CategoryTheory.prodOpEquiv C).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (C × D)ᵒᵖ)
-- CategoryTheory.prodOpEquiv_inverse_map
@[simps]
def prodOpEquiv : (C × D)ᵒᵖ ≌ Cᵒᵖ × Dᵒᵖ 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D]
Goal: ∀ {X Y : Cᵒᵖ × Dᵒᵖ} (x : X ⟶ Y),
  (CategoryTheory.prodOpEquiv C).inverse.map x =
    match x with
    | (f, g) => Opposite.op (f.unop, g.unop)
-- CategoryTheory.prodOpEquiv_counitIso
@[simps]
def prodOpEquiv : (C × D)ᵒᵖ ≌ Cᵒᵖ × Dᵒᵖ 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D]
Goal: (CategoryTheory.prodOpEquiv C).counitIso =
  CategoryTheory.Iso.refl
    ({
          obj := fun x =>
            match x with
            | (X, Y) => Opposite.op (Opposite.unop X, Opposite.unop Y),
          map := fun {X Y} x =>
            match x with
            | (f, g) => Opposite.op (f.unop, g.unop),
          map_id := ⋯, map_comp := ⋯ }.comp
      { obj := fun X => (Opposite.op (Opposite.unop X).1, Opposite.op (Opposite.unop X).2),
        map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯, map_comp := ⋯ })
-- CategoryTheory.Monad.FreeCoequalizer.topMap_f
@[simps!]
def FreeCoequalizer.topMap : (Monad.free T).obj (T.obj X.A) ⟶ (Monad.free T).obj X.A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: (CategoryTheory.Monad.FreeCoequalizer.topMap X).f = T.map X.a
-- CategoryTheory.Monad.FreeCoequalizer.bottomMap_f
@[simps]
def FreeCoequalizer.bottomMap : (Monad.free T).obj (T.obj X.A) ⟶ (Monad.free T).obj X.A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: (CategoryTheory.Monad.FreeCoequalizer.bottomMap X).f = T.μ.app X.A
-- CategoryTheory.Monad.FreeCoequalizer.π_f
@[simps]
def FreeCoequalizer.π : (Monad.free T).obj X.A ⟶ X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: (CategoryTheory.Monad.FreeCoequalizer.π X).f = X.a
-- CategoryTheory.Monad.FreeCoequalizer.condition
theorem FreeCoequalizer.condition :
    FreeCoequalizer.topMap X ≫ FreeCoequalizer.π X =
      FreeCoequalizer.bottomMap X ≫ FreeCoequalizer.π X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Monad.FreeCoequalizer.topMap X)
    (CategoryTheory.Monad.FreeCoequalizer.π X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Monad.FreeCoequalizer.bottomMap X)
    (CategoryTheory.Monad.FreeCoequalizer.π X)
-- CategoryTheory.Monad.beckAlgebraCofork_ι_app
@[simps!]
def beckAlgebraCofork : Cofork (FreeCoequalizer.topMap X) (FreeCoequalizer.bottomMap X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Monad.beckAlgebraCofork X).ι.app X_1 =
    CategoryTheory.Limits.WalkingParallelPair.rec
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.Monad.FreeCoequalizer.topMap X)
        (CategoryTheory.Monad.FreeCoequalizer.π X))
      (CategoryTheory.Monad.FreeCoequalizer.π X) X_1
-- CategoryTheory.Monad.beckAlgebraCofork_pt
@[simps!]
def beckAlgebraCofork : Cofork (FreeCoequalizer.topMap X) (FreeCoequalizer.bottomMap X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: (CategoryTheory.Monad.beckAlgebraCofork X).pt = X
-- CategoryTheory.Monad.beckCofork_pt
@[simps! pt]
def beckCofork : Cofork (T.map X.a) (T.μ.app _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: (CategoryTheory.Monad.beckCofork X).pt = X.A
-- CategoryTheory.Monad.beckCofork_π
@[simp]
theorem beckCofork_π : (beckCofork X).π = X.a 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
Goal: (CategoryTheory.Monad.beckCofork X).π = X.a
-- CategoryTheory.Monad.beckCoequalizer_desc
@[simp]
theorem beckCoequalizer_desc (s : Cofork (T.toFunctor.map X.a) (T.μ.app X.A)) :
    (beckCoequalizer X).desc s = T.η.app _ ≫ s.π 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra) (s : CategoryTheory.Limits.Cofork (T.map X.a) (T.μ.app X.A))
Goal: (CategoryTheory.Monad.beckCoequalizer X).desc s = CategoryTheory.CategoryStruct.comp (T.η.app X.A) s.π
-- CategoryTheory.hom_inl_inr_false
@[aesop norm -10 destruct (rule_sets := [CategoryTheory])]
theorem hom_inl_inr_false {X : C} {Y : D} (f : Sum.inl X ⟶ Sum.inr Y) : False 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {X : C} {Y : D} (f : Sum.inl X ⟶ Sum.inr Y)
Goal: False
-- CategoryTheory.hom_inr_inl_false
@[aesop norm -10 destruct (rule_sets := [CategoryTheory])]
theorem hom_inr_inl_false {X : C} {Y : D} (f : Sum.inr X ⟶ Sum.inl Y) : False 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {X : C} {Y : D} (f : Sum.inr X ⟶ Sum.inl Y)
Goal: False
-- CategoryTheory.sum_comp_inl
theorem sum_comp_inl {P Q R : C} (f : (inl P : C ⊕ D) ⟶ inl Q) (g : (inl Q : C ⊕ D) ⟶ inl R) :
    @CategoryStruct.comp _ _ P Q R (f : P ⟶ Q) (g : Q ⟶ R) =
      @CategoryStruct.comp _ _ (inl P) (inl Q) (inl R) (f : P ⟶ Q) (g : Q ⟶ R) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {P Q R : C} (f : Sum.inl P ⟶ Sum.inl Q) (g : Sum.inl Q ⟶ Sum.inl R)
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.sum_comp_inr
theorem sum_comp_inr {P Q R : D} (f : (inr P : C ⊕ D) ⟶ inr Q) (g : (inr Q : C ⊕ D) ⟶ inr R) :
    @CategoryStruct.comp _ _ P Q R (f : P ⟶ Q) (g : Q ⟶ R) =
      @CategoryStruct.comp _ _ (inr P) (inr Q) (inr R) (f : P ⟶ Q) (g : Q ⟶ R) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {P Q R : D} (f : Sum.inr P ⟶ Sum.inr Q) (g : Sum.inr Q ⟶ Sum.inr R)
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.Sum.inl__map
@[simps]
def inl_ : C ⥤ C ⊕ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Sum.inl_ C D).map f = f
-- CategoryTheory.Sum.inl__obj
@[simps]
def inl_ : C ⥤ C ⊕ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] (X : C)
Goal: (CategoryTheory.Sum.inl_ C D).obj X = Sum.inl X
-- CategoryTheory.Sum.inr__map
@[simps]
def inr_ : D ⥤ C ⊕ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {X Y : D} (f : X ⟶ Y)
Goal: (CategoryTheory.Sum.inr_ C D).map f = f
-- CategoryTheory.Sum.inr__obj
@[simps]
def inr_ : D ⥤ C ⊕ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] (X : D)
Goal: (CategoryTheory.Sum.inr_ C D).obj X = Sum.inr X
-- CategoryTheory.Sum.swap_obj_inl
@[simp]
theorem swap_obj_inl (X : C) : (swap C D).obj (inl X) = inr X 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] (X : C)
Goal: (CategoryTheory.Sum.swap C D).obj (Sum.inl X) = Sum.inr X
-- CategoryTheory.Sum.swap_obj_inr
@[simp]
theorem swap_obj_inr (X : D) : (swap C D).obj (inr X) = inl X 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] (X : D)
Goal: (CategoryTheory.Sum.swap C D).obj (Sum.inr X) = Sum.inl X
-- CategoryTheory.Sum.swap_map_inl
@[simp]
theorem swap_map_inl {X Y : C} {f : inl X ⟶ inl Y} : (swap C D).map f = f 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {X Y : C} {f : Sum.inl X ⟶ Sum.inl Y}
Goal: (CategoryTheory.Sum.swap C D).map f = f
-- CategoryTheory.Sum.swap_map_inr
@[simp]
theorem swap_map_inr {X Y : D} {f : inr X ⟶ inr Y} : (swap C D).map f = f 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₁) [CategoryTheory.Category.{v₁, u₁} D] {X Y : D} {f : Sum.inr X ⟶ Sum.inr Y}
Goal: (CategoryTheory.Sum.swap C D).map f = f
-- CategoryTheory.Functor.inlCompSum'_hom_app
@[simps!]
def inlCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inl_ A B ⋙ F.sum' G ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor A C) (G : CategoryTheory.Functor B C) (X : A)
Goal: (F.inlCompSum' G).hom.app X = CategoryTheory.CategoryStruct.id ((F.sum' G).obj (Sum.inl X))
-- CategoryTheory.Functor.inlCompSum'_inv_app
@[simps!]
def inlCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inl_ A B ⋙ F.sum' G ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor A C) (G : CategoryTheory.Functor B C) (X : A)
Goal: (F.inlCompSum' G).inv.app X = CategoryTheory.CategoryStruct.id ((F.sum' G).obj (Sum.inl X))
-- CategoryTheory.Functor.inrCompSum'_hom_app
@[simps!]
def inrCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inr_ A B ⋙ F.sum' G ≅ G 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor A C) (G : CategoryTheory.Functor B C) (X : B)
Goal: (F.inrCompSum' G).hom.app X = CategoryTheory.CategoryStruct.id ((F.sum' G).obj (Sum.inr X))
-- CategoryTheory.Functor.inrCompSum'_inv_app
@[simps!]
def inrCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inr_ A B ⋙ F.sum' G ≅ G 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor A C) (G : CategoryTheory.Functor B C) (X : B)
Goal: (F.inrCompSum' G).inv.app X = CategoryTheory.CategoryStruct.id ((F.sum' G).obj (Sum.inr X))
-- CategoryTheory.Functor.sum_obj_inl
@[simp]
theorem sum_obj_inl (F : A ⥤ B) (G : C ⥤ D) (a : A) : (F.sum G).obj (inl a) = inl (F.obj a) 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D) (a : A)
Goal: (F.sum G).obj (Sum.inl a) = Sum.inl (F.obj a)
-- CategoryTheory.Functor.sum_obj_inr
@[simp]
theorem sum_obj_inr (F : A ⥤ B) (G : C ⥤ D) (c : C) : (F.sum G).obj (inr c) = inr (G.obj c) 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D) (c : C)
Goal: (F.sum G).obj (Sum.inr c) = Sum.inr (G.obj c)
-- CategoryTheory.Functor.sum_map_inl
@[simp]
theorem sum_map_inl (F : A ⥤ B) (G : C ⥤ D) {a a' : A} (f : inl a ⟶ inl a') :
    (F.sum G).map f = F.map f 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D) {a a' : A} (f : Sum.inl a ⟶ Sum.inl a')
Goal: (F.sum G).map f = F.map f
-- CategoryTheory.Functor.sum_map_inr
@[simp]
theorem sum_map_inr (F : A ⥤ B) (G : C ⥤ D) {c c' : C} (f : inr c ⟶ inr c') :
    (F.sum G).map f = G.map f 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D) {c c' : C} (f : Sum.inr c ⟶ Sum.inr c')
Goal: (F.sum G).map f = G.map f
-- CategoryTheory.NatTrans.sum_app_inl
@[simp]
theorem sum_app_inl {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (a : A) :
    (sum α β).app (inl a) = α.app a 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] {F G : CategoryTheory.Functor A B} {H I : CategoryTheory.Functor C D} (α : F ⟶ G) (β : H ⟶ I) (a : A)
Goal: (CategoryTheory.NatTrans.sum α β).app (Sum.inl a) = α.app a
-- CategoryTheory.NatTrans.sum_app_inr
@[simp]
theorem sum_app_inr {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (c : C) :
    (sum α β).app (inr c) = β.app c 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] {F G : CategoryTheory.Functor A B} {H I : CategoryTheory.Functor C D} (α : F ⟶ G) (β : H ⟶ I) (c : C)
Goal: (CategoryTheory.NatTrans.sum α β).app (Sum.inr c) = β.app c
-- CategoryTheory.Kleisli.Adjunction.toKleisli_map
@[simps]
def toKleisli : C ⥤ Kleisli T 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (T : CategoryTheory.Monad C) {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Kleisli.Adjunction.toKleisli T).map f = CategoryTheory.CategoryStruct.comp f (T.η.app Y)
-- CategoryTheory.Kleisli.Adjunction.toKleisli_obj
@[simps]
def toKleisli : C ⥤ Kleisli T 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (T : CategoryTheory.Monad C) (X : C)
Goal: (CategoryTheory.Kleisli.Adjunction.toKleisli T).obj X = X
-- CategoryTheory.Kleisli.Adjunction.fromKleisli_map
@[simps]
def fromKleisli : Kleisli T ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (T : CategoryTheory.Monad C)
Goal: ∀ {x Y : CategoryTheory.Kleisli T} (f : x ⟶ Y),
  (CategoryTheory.Kleisli.Adjunction.fromKleisli T).map f = CategoryTheory.CategoryStruct.comp (T.map f) (T.μ.app Y)
-- CategoryTheory.Kleisli.Adjunction.fromKleisli_obj
@[simps]
def fromKleisli : Kleisli T ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (T : CategoryTheory.Monad C) (X : CategoryTheory.Kleisli T)
Goal: (CategoryTheory.Kleisli.Adjunction.fromKleisli T).obj X = T.obj X
-- CategoryTheory.Cokleisli.Adjunction.toCokleisli_obj
@[simps]
def toCokleisli : C ⥤ Cokleisli U 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C) (X : C)
Goal: (CategoryTheory.Cokleisli.Adjunction.toCokleisli U).obj X = X
-- CategoryTheory.Cokleisli.Adjunction.toCokleisli_map
@[simps]
def toCokleisli : C ⥤ Cokleisli U 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C) {X : C}
Goal: ∀ {x : C} (f : X ⟶ x),
  (CategoryTheory.Cokleisli.Adjunction.toCokleisli U).map f = CategoryTheory.CategoryStruct.comp (U.ε.app X) f