ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_unitIso_inv
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).unitIso.inv =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.CategoryOfElements.toCostructuredArrow F).comp
          (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp).leftUnitor.inv
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.whiskerRight (CategoryTheory.NatTrans.op (CategoryTheory.eqToHom ⋯))
        ((CategoryTheory.CategoryOfElements.toCostructuredArrow F).comp
          (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp))
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.CategoryOfElements.toCostructuredArrow F).associator
            (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp
            ((CategoryTheory.CategoryOfElements.toCostructuredArrow F).comp
              (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp)).hom
        (CategoryTheory.CategoryStruct.comp
          (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toCostructuredArrow F)
            ((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp.associator
                (CategoryTheory.CategoryOfElements.toCostructuredArrow F)
                (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp).inv)
          (CategoryTheory.CategoryStruct.comp
            (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toCostructuredArrow F)
              (CategoryTheory.whiskerRight (CategoryTheory.eqToHom ⋯)
                (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp))
            (CategoryTheory.CategoryStruct.comp
              (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toCostructuredArrow F)
                (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp.leftUnitor.hom)
              (CategoryTheory.NatTrans.op (CategoryTheory.eqToHom ⋯)))))))
-- CategoryTheory.CategoryOfElements.costructuredArrow_yoneda_equivalence_naturality
theorem costructuredArrow_yoneda_equivalence_naturality {F₁ F₂ : Cᵒᵖ ⥤ Type v} (α : F₁ ⟶ F₂) :
    (map α).op ⋙ toCostructuredArrow F₂ = toCostructuredArrow F₁ ⋙ CostructuredArrow.map α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor Cᵒᵖ (Type v)} (α : F₁ ⟶ F₂)
Goal: (CategoryTheory.CategoryOfElements.map α).op.comp (CategoryTheory.CategoryOfElements.toCostructuredArrow F₂) =
  (CategoryTheory.CategoryOfElements.toCostructuredArrow F₁).comp (CategoryTheory.CostructuredArrow.map α)
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceFunctorProj_hom_app
@[simps!]
def costructuredArrowYonedaEquivalenceFunctorProj (F : Cᵒᵖ ⥤ Type v) :
    (costructuredArrowYonedaEquivalence F).functor ⋙ CostructuredArrow.proj _ _ ≅ (π F).leftOp 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : F.Elementsᵒᵖ)
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceFunctorProj F).hom.app X =
  CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.unop X).1)
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceFunctorProj_inv_app
@[simps!]
def costructuredArrowYonedaEquivalenceFunctorProj (F : Cᵒᵖ ⥤ Type v) :
    (costructuredArrowYonedaEquivalence F).functor ⋙ CostructuredArrow.proj _ _ ≅ (π F).leftOp 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : F.Elementsᵒᵖ)
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceFunctorProj F).inv.app X =
  CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.unop X).1)
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceInverseπ_inv_app
@[simps!]
def costructuredArrowYonedaEquivalenceInverseπ (F : Cᵒᵖ ⥤ Type v) :
    (costructuredArrowYonedaEquivalence F).inverse ⋙ (π F).leftOp ≅ CostructuredArrow.proj _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceInverseπ F).inv.app X =
  CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceInverseπ_hom_app
@[simps!]
def costructuredArrowYonedaEquivalenceInverseπ (F : Cᵒᵖ ⥤ Type v) :
    (costructuredArrowYonedaEquivalence F).inverse ⋙ (π F).leftOp ≅ CostructuredArrow.proj _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalenceInverseπ F).hom.app X =
  CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.whiskerLeft_app
@[simps]
def whiskerLeft (F : C ⥤ D) {G H : D ⥤ E} (α : G ⟶ H) :
    F ⋙ G ⟶ F ⋙ H 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) {G H : CategoryTheory.Functor D E} (α : G ⟶ H) (X : C)
Goal: (CategoryTheory.whiskerLeft F α).app X = α.app (F.obj X)
-- CategoryTheory.whiskerRight_app
@[simps]
def whiskerRight {G H : C ⥤ D} (α : G ⟶ H) (F : D ⥤ E) :
    G ⋙ F ⟶ H ⋙ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G H : CategoryTheory.Functor C D} (α : G ⟶ H) (F : CategoryTheory.Functor D E) (X : C)
Goal: (CategoryTheory.whiskerRight α F).app X = F.map (α.app X)
-- CategoryTheory.whiskeringLeft_map_app_app
@[simps]
def whiskeringLeft : (C ⥤ D) ⥤ (D ⥤ E) ⥤ C ⥤ E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E]
Goal: ∀ {X Y : CategoryTheory.Functor C D} (τ : X ⟶ Y) (H : CategoryTheory.Functor D E) (c : C),
  (((CategoryTheory.whiskeringLeft C D E).map τ).app H).app c = H.map (τ.app c)
-- CategoryTheory.whiskeringLeft_obj_obj
@[simps]
def whiskeringLeft : (C ⥤ D) ⥤ (D ⥤ E) ⥤ C ⥤ E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E)
Goal: ((CategoryTheory.whiskeringLeft C D E).obj F).obj G = F.comp G
-- CategoryTheory.whiskeringLeft_obj_map
@[simps]
def whiskeringLeft : (C ⥤ D) ⥤ (D ⥤ E) ⥤ C ⥤ E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Functor D E} (α : X ⟶ Y),
  ((CategoryTheory.whiskeringLeft C D E).obj F).map α = CategoryTheory.whiskerLeft F α
-- CategoryTheory.whiskeringRight_obj_obj
@[simps]
def whiskeringRight : (D ⥤ E) ⥤ (C ⥤ D) ⥤ C ⥤ E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E] (H : CategoryTheory.Functor D E) (F : CategoryTheory.Functor C D)
Goal: ((CategoryTheory.whiskeringRight C D E).obj H).obj F = F.comp H
-- CategoryTheory.whiskeringRight_obj_map
@[simps]
def whiskeringRight : (D ⥤ E) ⥤ (C ⥤ D) ⥤ C ⥤ E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E] (H : CategoryTheory.Functor D E)
Goal: ∀ {X Y : CategoryTheory.Functor C D} (α : X ⟶ Y),
  ((CategoryTheory.whiskeringRight C D E).obj H).map α = CategoryTheory.whiskerRight α H
-- CategoryTheory.whiskeringRight_map_app_app
@[simps]
def whiskeringRight : (D ⥤ E) ⥤ (C ⥤ D) ⥤ C ⥤ E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E]
Goal: ∀ {X Y : CategoryTheory.Functor D E} (τ : X ⟶ Y) (F : CategoryTheory.Functor C D) (c : C),
  (((CategoryTheory.whiskeringRight C D E).map τ).app F).app c = τ.app (F.obj c)
-- CategoryTheory.Functor.FullyFaithful.whiskeringRight_preimage_app
@[simps]
def Functor.FullyFaithful.whiskeringRight {F : D ⥤ E} (hF : F.FullyFaithful)
    (C : Type*) [Category C] :
    ((whiskeringRight C D E).obj F).FullyFaithful 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor D E} (hF : F.FullyFaithful) (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: ∀ {X Y : CategoryTheory.Functor C D}
  (f : ((CategoryTheory.whiskeringRight C D E).obj F).obj X ⟶ ((CategoryTheory.whiskeringRight C D E).obj F).obj Y)
  (X_1 : C), ((hF.whiskeringRight C).preimage f).app X_1 = hF.preimage (f.app X_1)
-- CategoryTheory.whiskerLeft_id
@[simp]
theorem whiskerLeft_id (F : C ⥤ D) {G : D ⥤ E} :
    whiskerLeft F (NatTrans.id G) = NatTrans.id (F.comp G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) {G : CategoryTheory.Functor D E}
Goal: CategoryTheory.whiskerLeft F (CategoryTheory.NatTrans.id G) = CategoryTheory.NatTrans.id (F.comp G)
-- CategoryTheory.whiskerLeft_id'
@[simp]
theorem whiskerLeft_id' (F : C ⥤ D) {G : D ⥤ E} : whiskerLeft F (𝟙 G) = 𝟙 (F.comp G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) {G : CategoryTheory.Functor D E}
Goal: CategoryTheory.whiskerLeft F (CategoryTheory.CategoryStruct.id G) = CategoryTheory.CategoryStruct.id (F.comp G)
-- CategoryTheory.whiskerRight_id
@[simp]
theorem whiskerRight_id {G : C ⥤ D} (F : D ⥤ E) :
    whiskerRight (NatTrans.id G) F = NatTrans.id (G.comp F) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor C D} (F : CategoryTheory.Functor D E)
Goal: CategoryTheory.whiskerRight (CategoryTheory.NatTrans.id G) F = CategoryTheory.NatTrans.id (G.comp F)
-- CategoryTheory.whiskerRight_id'
@[simp]
theorem whiskerRight_id' {G : C ⥤ D} (F : D ⥤ E) : whiskerRight (𝟙 G) F = 𝟙 (G.comp F) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor C D} (F : CategoryTheory.Functor D E)
Goal: CategoryTheory.whiskerRight (CategoryTheory.CategoryStruct.id G) F = CategoryTheory.CategoryStruct.id (G.comp F)
-- CategoryTheory.whiskerLeft_comp
@[simp, reassoc]
theorem whiskerLeft_comp (F : C ⥤ D) {G H K : D ⥤ E} (α : G ⟶ H) (β : H ⟶ K) :
    whiskerLeft F (α ≫ β) = whiskerLeft F α ≫ whiskerLeft F β 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) {G H K : CategoryTheory.Functor D E} (α : G ⟶ H) (β : H ⟶ K)
Goal: CategoryTheory.whiskerLeft F (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft F α) (CategoryTheory.whiskerLeft F β)
-- CategoryTheory.whiskerRight_comp
@[simp, reassoc]
theorem whiskerRight_comp {G H K : C ⥤ D} (α : G ⟶ H) (β : H ⟶ K) (F : D ⥤ E) :
    whiskerRight (α ≫ β) F = whiskerRight α F ≫ whiskerRight β F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G H K : CategoryTheory.Functor C D} (α : G ⟶ H) (β : H ⟶ K) (F : CategoryTheory.Functor D E)
Goal: CategoryTheory.whiskerRight (CategoryTheory.CategoryStruct.comp α β) F =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight α F) (CategoryTheory.whiskerRight β F)
-- CategoryTheory.isoWhiskerLeft_hom
@[simp]
theorem isoWhiskerLeft_hom (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
    (isoWhiskerLeft F α).hom = whiskerLeft F α.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) {G H : CategoryTheory.Functor D E} (α : G ≅ H)
Goal: (CategoryTheory.isoWhiskerLeft F α).hom = CategoryTheory.whiskerLeft F α.hom
-- CategoryTheory.isoWhiskerLeft_inv
@[simp]
theorem isoWhiskerLeft_inv (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
    (isoWhiskerLeft F α).inv = whiskerLeft F α.inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) {G H : CategoryTheory.Functor D E} (α : G ≅ H)
Goal: (CategoryTheory.isoWhiskerLeft F α).inv = CategoryTheory.whiskerLeft F α.inv
-- CategoryTheory.isoWhiskerRight_hom
@[simp]
theorem isoWhiskerRight_hom {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) :
    (isoWhiskerRight α F).hom = whiskerRight α.hom F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G H : CategoryTheory.Functor C D} (α : G ≅ H) (F : CategoryTheory.Functor D E)
Goal: (CategoryTheory.isoWhiskerRight α F).hom = CategoryTheory.whiskerRight α.hom F
-- CategoryTheory.isoWhiskerRight_inv
@[simp]
theorem isoWhiskerRight_inv {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) :
    (isoWhiskerRight α F).inv = whiskerRight α.inv F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {G H : CategoryTheory.Functor C D} (α : G ≅ H) (F : CategoryTheory.Functor D E)
Goal: (CategoryTheory.isoWhiskerRight α F).inv = CategoryTheory.whiskerRight α.inv F
-- CategoryTheory.whiskerLeft_twice
@[simp]
theorem whiskerLeft_twice (F : B ⥤ C) (G : C ⥤ D) {H K : D ⥤ E} (α : H ⟶ K) :
    whiskerLeft F (whiskerLeft G α) = whiskerLeft (F ⋙ G) α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) {H K : CategoryTheory.Functor D E} (α : H ⟶ K)
Goal: CategoryTheory.whiskerLeft F (CategoryTheory.whiskerLeft G α) = CategoryTheory.whiskerLeft (F.comp G) α
-- CategoryTheory.whiskerRight_twice
@[simp]
theorem whiskerRight_twice {H K : B ⥤ C} (F : C ⥤ D) (G : D ⥤ E) (α : H ⟶ K) :
    whiskerRight (whiskerRight α F) G = whiskerRight α (F ⋙ G) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] {H K : CategoryTheory.Functor B C} (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (α : H ⟶ K)
Goal: CategoryTheory.whiskerRight (CategoryTheory.whiskerRight α F) G = CategoryTheory.whiskerRight α (F.comp G)
-- CategoryTheory.whiskerRight_left
theorem whiskerRight_left (F : B ⥤ C) {G H : C ⥤ D} (α : G ⟶ H) (K : D ⥤ E) :
    whiskerRight (whiskerLeft F α) K = whiskerLeft F (whiskerRight α K) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄} [CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) {G H : CategoryTheory.Functor C D} (α : G ⟶ H) (K : CategoryTheory.Functor D E)
Goal: CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft F α) K =
  CategoryTheory.whiskerLeft F (CategoryTheory.whiskerRight α K)
-- CategoryTheory.Functor.leftUnitor_inv_app
@[simps]
def leftUnitor (F : A ⥤ B) :
    𝟭 A ⋙ F ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] (F : CategoryTheory.Functor A B) (X : A)
Goal: F.leftUnitor.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.leftUnitor_hom_app
@[simps]
def leftUnitor (F : A ⥤ B) :
    𝟭 A ⋙ F ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] (F : CategoryTheory.Functor A B) (X : A)
Goal: F.leftUnitor.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.rightUnitor_hom_app
@[simps]
def rightUnitor (F : A ⥤ B) :
    F ⋙ 𝟭 B ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] (F : CategoryTheory.Functor A B) (X : A)
Goal: F.rightUnitor.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.rightUnitor_inv_app
@[simps]
def rightUnitor (F : A ⥤ B) :
    F ⋙ 𝟭 B ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] (F : CategoryTheory.Functor A B) (X : A)
Goal: F.rightUnitor.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.associator_hom_app
@[simps]
def associator (F : A ⥤ B) (G : B ⥤ C) (H : C ⥤ D) :
    (F ⋙ G) ⋙ H ≅ F ⋙ G ⋙ H 
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 B C) (H : CategoryTheory.Functor C D)
Goal: ∀ (x : A), (F.associator G H).hom.app x = CategoryTheory.CategoryStruct.id (((F.comp G).comp H).obj x)
-- CategoryTheory.Functor.associator_inv_app
@[simps]
def associator (F : A ⥤ B) (G : B ⥤ C) (H : C ⥤ D) :
    (F ⋙ G) ⋙ H ≅ F ⋙ G ⋙ H 
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 B C) (H : CategoryTheory.Functor C D)
Goal: ∀ (x : A), (F.associator G H).inv.app x = CategoryTheory.CategoryStruct.id ((F.comp (G.comp H)).obj x)
-- CategoryTheory.Functor.assoc
protected theorem assoc (F : A ⥤ B) (G : B ⥤ C) (H : C ⥤ D) : (F ⋙ G) ⋙ H = F ⋙ G ⋙ H 
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 B C) (H : CategoryTheory.Functor C D)
Goal: (F.comp G).comp H = F.comp (G.comp H)
-- CategoryTheory.Functor.triangle
theorem triangle (F : A ⥤ B) (G : B ⥤ C) :
    (associator F (𝟭 B) G).hom ≫ whiskerLeft F (leftUnitor G).hom =
      whiskerRight (rightUnitor F).hom 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 B) (G : CategoryTheory.Functor B C)
Goal: CategoryTheory.CategoryStruct.comp (F.associator (CategoryTheory.Functor.id B) G).hom
    (CategoryTheory.whiskerLeft F G.leftUnitor.hom) =
  CategoryTheory.whiskerRight F.rightUnitor.hom G
-- CategoryTheory.Functor.pentagon
theorem pentagon :
    whiskerRight (associator F G H).hom K ≫
        (associator F (G ⋙ H) K).hom ≫ whiskerLeft F (associator G H K).hom =
      (associator (F ⋙ G) H K).hom ≫ (associator F G (H ⋙ K)).hom 
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 : Type u₅} [CategoryTheory.Category.{v₅, u₅} E] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor B C) (H : CategoryTheory.Functor C D) (K : CategoryTheory.Functor D E)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight (F.associator G H).hom K)
    (CategoryTheory.CategoryStruct.comp (F.associator (G.comp H) K).hom
      (CategoryTheory.whiskerLeft F (G.associator H K).hom)) =
  CategoryTheory.CategoryStruct.comp ((F.comp G).associator H K).hom (F.associator G (H.comp K)).hom
-- CategoryTheory.eqToHom_refl
@[simp]
theorem eqToHom_refl (X : C) (p : X = X) : eqToHom p = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) (p : X = X)
Goal: CategoryTheory.eqToHom p = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.eqToHom_trans
@[reassoc (attr := simp)]
theorem eqToHom_trans {X Y Z : C} (p : X = Y) (q : Y = Z) :
    eqToHom p ≫ eqToHom q = eqToHom (p.trans q) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y = Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) (CategoryTheory.eqToHom q) = CategoryTheory.eqToHom ⋯
-- CategoryTheory.comp_eqToHom_iff
theorem comp_eqToHom_iff {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y') :
    f ≫ eqToHom p = g ↔ f = g ≫ eqToHom p.symm 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y')
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom p) = g ↔
  f = CategoryTheory.CategoryStruct.comp g (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.eqToHom_comp_iff
theorem eqToHom_comp_iff {X X' Y : C} (p : X = X') (f : X ⟶ Y) (g : X' ⟶ Y) :
    eqToHom p ≫ g = f ↔ g = eqToHom p.symm ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X X' Y : C} (p : X = X') (f : X ⟶ Y) (g : X' ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) g = f ↔
  g = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) f
-- CategoryTheory.eqToHom_naturality
-- The simpNF linter incorrectly claims that this will never apply.
-- https://github.com/leanprover-community/mathlib4/issues/5049
@[reassoc (attr := simp, nolint simpNF)]
theorem eqToHom_naturality {f g : β → C} (z : ∀ b, f b ⟶ g b) {j j' : β} (w : j = j') :
    z j ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ z j' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {β : Sort u_1} {f g : β → C} (z : (b : β) → f b ⟶ g b) {j j' : β} (w : j = j')
Goal: CategoryTheory.CategoryStruct.comp (z j) (CategoryTheory.eqToHom ⋯) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (z j')
-- CategoryTheory.eqToHom_iso_hom_naturality
-- The simpNF linter incorrectly claims that this will never apply.
-- https://github.com/leanprover-community/mathlib4/issues/5049
@[reassoc (attr := simp, nolint simpNF)]
theorem eqToHom_iso_hom_naturality {f g : β → C} (z : ∀ b, f b ≅ g b) {j j' : β} (w : j = j') :
    (z j).hom ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ (z j').hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {β : Sort u_1} {f g : β → C} (z : (b : β) → f b ≅ g b) {j j' : β} (w : j = j')
Goal: CategoryTheory.CategoryStruct.comp (z j).hom (CategoryTheory.eqToHom ⋯) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (z j').hom
-- CategoryTheory.eqToHom_iso_inv_naturality
-- The simpNF linter incorrectly claims that this will never apply.
-- https://github.com/leanprover-community/mathlib4/issues/5049
@[reassoc (attr := simp, nolint simpNF)]
theorem eqToHom_iso_inv_naturality {f g : β → C} (z : ∀ b, f b ≅ g b) {j j' : β} (w : j = j') :
    (z j).inv ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ (z j').inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {β : Sort u_1} {f g : β → C} (z : (b : β) → f b ≅ g b) {j j' : β} (w : j = j')
Goal: CategoryTheory.CategoryStruct.comp (z j).inv (CategoryTheory.eqToHom ⋯) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (z j').inv