ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.hasLimits_of_reflective
theorem hasLimits_of_reflective (R : D ⥤ C) [HasLimitsOfSize.{v, u} C] [Reflective R] :
    HasLimitsOfSize.{v, u} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (R : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₁, u₁} C] [CategoryTheory.Reflective R]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₂, u₂} D
-- CategoryTheory.hasColimitsOfShape_of_reflective
theorem hasColimitsOfShape_of_reflective (R : D ⥤ C) [Reflective R] [HasColimitsOfShape J C] :
    HasColimitsOfShape J D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (R : CategoryTheory.Functor D C) [CategoryTheory.Reflective R] [CategoryTheory.Limits.HasColimitsOfShape J C]
Goal: CategoryTheory.Limits.HasColimitsOfShape J D
-- CategoryTheory.hasColimits_of_reflective
theorem hasColimits_of_reflective (R : D ⥤ C) [Reflective R] [HasColimitsOfSize.{v, u} C] :
    HasColimitsOfSize.{v, u} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (R : CategoryTheory.Functor D C) [CategoryTheory.Reflective R] [CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₂, u₂} D
-- CategoryTheory.Comonad.ForgetCreatesColimits'.γ_app
@[simps]
def γ : D ⋙ T.forget ⟶ D ⋙ T.forget ⋙ ↑T  
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (j : J)
Goal: (CategoryTheory.Comonad.ForgetCreatesColimits'.γ D).app j = (D.obj j).a
-- CategoryTheory.Comonad.ForgetCreatesColimits'.newCocone_ι_app
@[simps! ι_app]
def newCocone : Cocone (D ⋙ forget T) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (X : J)
Goal: (CategoryTheory.Comonad.ForgetCreatesColimits'.newCocone D c).ι.app X =
  CategoryTheory.CategoryStruct.comp (D.obj X).a (T.map (c.ι.app X))
-- CategoryTheory.Comonad.ForgetCreatesColimits'.coconePoint_A
@[simps]
def coconePoint : Coalgebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
Goal: (CategoryTheory.Comonad.ForgetCreatesColimits'.coconePoint D c t).A = c.pt
-- CategoryTheory.Comonad.ForgetCreatesColimits'.coconePoint_a
@[simps]
def coconePoint : Coalgebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
Goal: (CategoryTheory.Comonad.ForgetCreatesColimits'.coconePoint D c t).a =
  t.desc (CategoryTheory.Comonad.ForgetCreatesColimits'.newCocone D c)
-- CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone_pt
@[simps]
def liftedCocone : Cocone D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
Goal: (CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone D c t).pt =
  CategoryTheory.Comonad.ForgetCreatesColimits'.coconePoint D c t
-- CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone_ι_app_f
@[simps]
def liftedCocone : Cocone D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c) (j : J)
Goal: ((CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone D c t).ι.app j).f = c.ι.app j
-- CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCoconeIsColimit_desc_f
@[simps]
def liftedCoconeIsColimit : IsColimit (liftedCocone D c t) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cocone D)
Goal: ((CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCoconeIsColimit D c t).desc s).f = t.desc (T.forget.mapCocone s)
-- CategoryTheory.Comonad.hasColimit_of_comp_forget_hasColimit
theorem hasColimit_of_comp_forget_hasColimit (D : J ⥤ Coalgebra T) [HasColimit (D ⋙ forget T)] :
    HasColimit D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} (D : CategoryTheory.Functor J T.Coalgebra) [CategoryTheory.Limits.HasColimit (D.comp T.forget)]
Goal: CategoryTheory.Limits.HasColimit D
-- CategoryTheory.Comonad.ForgetCreatesLimits'.γ_app
@[simps]
def γ : D ⋙ forget T ⟶ (D ⋙ forget T) ⋙ ↑T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (j : J)
Goal: CategoryTheory.Comonad.ForgetCreatesLimits'.γ.app j = (D.obj j).a
-- CategoryTheory.Comonad.ForgetCreatesLimits'.newCone_pt
@[simps]
def newCone : Cone ((D ⋙ forget T) ⋙ (T : C ⥤ C)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget))
Goal: (CategoryTheory.Comonad.ForgetCreatesLimits'.newCone c).pt = c.pt
-- CategoryTheory.Comonad.ForgetCreatesLimits'.newCone_π
@[simps]
def newCone : Cone ((D ⋙ forget T) ⋙ (T : C ⥤ C)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget))
Goal: (CategoryTheory.Comonad.ForgetCreatesLimits'.newCone c).π =
  CategoryTheory.CategoryStruct.comp c.π CategoryTheory.Comonad.ForgetCreatesLimits'.γ
-- CategoryTheory.Comonad.ForgetCreatesLimits'.commuting
theorem commuting (j : J) : lambda c t ≫ (T : C ⥤ C).map (c.π.app j) = c.π.app j ≫ (D.obj j).a 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] (j : J)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Comonad.ForgetCreatesLimits'.lambda c t) (T.map (c.π.app j)) =
  CategoryTheory.CategoryStruct.comp (c.π.app j) (D.obj j).a
-- CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint_a
@[simps]
def conePoint : Coalgebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] [CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor]
Goal: (CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint c t).a = CategoryTheory.Comonad.ForgetCreatesLimits'.lambda c t
-- CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint_A
@[simps]
def conePoint : Coalgebra T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] [CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor]
Goal: (CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint c t).A = c.pt
-- CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone_pt
@[simps]
def liftedCone : Cone D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] [CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor]
Goal: (CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone c t).pt =
  CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint c t
-- CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone_π_app_f
@[simps]
def liftedCone : Cone D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] [CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor] (j : J)
Goal: ((CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone c t).π.app j).f = c.π.app j
-- CategoryTheory.Comonad.ForgetCreatesLimits'.liftedConeIsLimit_lift_f
@[simps]
def liftedConeIsLimit : IsLimit (liftedCone c t) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] [CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor] (s : CategoryTheory.Limits.Cone D)
Goal: ((CategoryTheory.Comonad.ForgetCreatesLimits'.liftedConeIsLimit c t).lift s).f = t.lift (T.forget.mapCone s)
-- CategoryTheory.Comonad.forget_creates_limits_of_comonad_preserves
theorem forget_creates_limits_of_comonad_preserves [PreservesLimitsOfShape J (T : C ⥤ C)]
    (D : J ⥤ Coalgebra T) [HasLimit (D ⋙ forget T)] : HasLimit D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {T : CategoryTheory.Comonad C} [CategoryTheory.Limits.PreservesLimitsOfShape J T.toFunctor] (D : CategoryTheory.Functor J T.Coalgebra) [CategoryTheory.Limits.HasLimit (D.comp T.forget)]
Goal: CategoryTheory.Limits.HasLimit D
-- CategoryTheory.hasColimit_of_coreflective
theorem hasColimit_of_coreflective (F : J ⥤ D) (R : D ⥤ C) [HasColimit (F ⋙ R)] [Coreflective R] :
    HasColimit F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J D) (R : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasColimit (F.comp R)] [CategoryTheory.Coreflective R]
Goal: CategoryTheory.Limits.HasColimit F
-- CategoryTheory.hasColimitsOfShape_of_coreflective
theorem hasColimitsOfShape_of_coreflective [HasColimitsOfShape J C] (R : D ⥤ C) [Coreflective R] :
    HasColimitsOfShape J D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] [CategoryTheory.Limits.HasColimitsOfShape J C] (R : CategoryTheory.Functor D C) [CategoryTheory.Coreflective R]
Goal: CategoryTheory.Limits.HasColimitsOfShape J D
-- CategoryTheory.hasColimits_of_coreflective
theorem hasColimits_of_coreflective (R : D ⥤ C) [HasColimitsOfSize.{v, u} C] [Coreflective R] :
    HasColimitsOfSize.{v, u} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (R : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₁, u₁} C] [CategoryTheory.Coreflective R]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₂, u₂} D
-- CategoryTheory.hasLimitsOfShape_of_coreflective
theorem hasLimitsOfShape_of_coreflective (R : D ⥤ C) [Coreflective R] [HasLimitsOfShape J C] :
    HasLimitsOfShape J D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (R : CategoryTheory.Functor D C) [CategoryTheory.Coreflective R] [CategoryTheory.Limits.HasLimitsOfShape J C]
Goal: CategoryTheory.Limits.HasLimitsOfShape J D
-- CategoryTheory.hasLimits_of_coreflective
theorem hasLimits_of_coreflective (R : D ⥤ C) [Coreflective R] [HasLimitsOfSize.{v, u} C] :
    HasLimitsOfSize.{v, u} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (R : CategoryTheory.Functor D C) [CategoryTheory.Coreflective R] [CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₂, u₂} D
-- CategoryTheory.FinCategory.categoryAsType_comp
@[simps (config := .lemmasOnly) id comp]
noncomputable instance categoryAsType : SmallCategory (AsType α) 
Arguments: (α : Type u_1) [Fintype α] [CategoryTheory.SmallCategory α] [CategoryTheory.FinCategory α]
Goal: ∀ {X Y Z : CategoryTheory.FinCategory.AsType α} (f : X ⟶ Y) (g : Y ⟶ Z),
  CategoryTheory.CategoryStruct.comp f g =
    (Fintype.equivFin (X ⟶ Z))
      (CategoryTheory.CategoryStruct.comp ((Fintype.equivFin (X ⟶ Y)).symm f) ((Fintype.equivFin (Y ⟶ Z)).symm g))
-- CategoryTheory.FinCategory.categoryAsType_id
@[simps (config := .lemmasOnly) id comp]
noncomputable instance categoryAsType : SmallCategory (AsType α) 
Arguments: (α : Type u_1) [Fintype α] [CategoryTheory.SmallCategory α] [CategoryTheory.FinCategory α] (i : CategoryTheory.FinCategory.AsType α)
Goal: CategoryTheory.CategoryStruct.id i = (Fintype.equivFin (i ⟶ i)) (CategoryTheory.CategoryStruct.id i)
-- CategoryTheory.FinCategory.asTypeToObjAsType_map
@[simps]
noncomputable def asTypeToObjAsType : AsType α ⥤ ObjAsType α 
Arguments: (α : Type u_1) [Fintype α] [CategoryTheory.SmallCategory α] [CategoryTheory.FinCategory α] {X Y : CategoryTheory.FinCategory.AsType α} (a : Fin (Fintype.card (X ⟶ Y)))
Goal: (CategoryTheory.FinCategory.asTypeToObjAsType α).map a = (Fintype.equivFin (X ⟶ Y)).symm a
-- CategoryTheory.FinCategory.asTypeToObjAsType_obj
@[simps]
noncomputable def asTypeToObjAsType : AsType α ⥤ ObjAsType α 
Arguments: (α : Type u_1) [Fintype α] [CategoryTheory.SmallCategory α] [CategoryTheory.FinCategory α] (a : CategoryTheory.FinCategory.AsType α)
Goal: (CategoryTheory.FinCategory.asTypeToObjAsType α).obj a = id a
-- CategoryTheory.FinCategory.objAsTypeToAsType_map
@[simps]
noncomputable def objAsTypeToAsType : ObjAsType α ⥤ AsType α 
Arguments: (α : Type u_1) [Fintype α] [CategoryTheory.SmallCategory α] [CategoryTheory.FinCategory α] {X Y : CategoryTheory.FinCategory.ObjAsType α} (a : X ⟶ Y)
Goal: (CategoryTheory.FinCategory.objAsTypeToAsType α).map a = (Fintype.equivFin (X ⟶ Y)) a
-- CategoryTheory.FinCategory.objAsTypeToAsType_obj
@[simps]
noncomputable def objAsTypeToAsType : ObjAsType α ⥤ AsType α 
Arguments: (α : Type u_1) [Fintype α] [CategoryTheory.SmallCategory α] [CategoryTheory.FinCategory α] (a : CategoryTheory.FinCategory.ObjAsType α)
Goal: (CategoryTheory.FinCategory.objAsTypeToAsType α).obj a = id a
-- CategoryTheory.GradedObject.singleObjApplyIsoOfEq_inv_single_map
lemma singleObjApplyIsoOfEq_inv_single_map (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j) :
    (singleObjApplyIsoOfEq j X i h).inv ≫ (single j).map f i =
      f ≫ (singleObjApplyIsoOfEq j Y i h).inv 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Limits.HasInitial C] [DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j X i h).inv
    ((CategoryTheory.GradedObject.single j).map f i) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j Y i h).inv
-- CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom
lemma single_map_singleObjApplyIsoOfEq_hom (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j) :
    (single j).map f i ≫ (singleObjApplyIsoOfEq j Y i h).hom =
      (singleObjApplyIsoOfEq j X i h).hom ≫ f 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Limits.HasInitial C] [DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y) (i : J) (h : i = j)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f i)
    (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j Y i h).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIsoOfEq j X i h).hom f
-- CategoryTheory.GradedObject.singleObjApplyIso_inv_single_map
@[reassoc (attr := simp)]
lemma singleObjApplyIso_inv_single_map (j : J) {X Y : C} (f : X ⟶ Y) :
    (singleObjApplyIso j X).inv ≫ (single j).map f j = f ≫ (singleObjApplyIso j Y).inv 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Limits.HasInitial C] [DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIso j X).inv
    ((CategoryTheory.GradedObject.single j).map f j) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.GradedObject.singleObjApplyIso j Y).inv
-- CategoryTheory.GradedObject.single_map_singleObjApplyIso_hom
@[reassoc (attr := simp)]
lemma single_map_singleObjApplyIso_hom (j : J) {X Y : C} (f : X ⟶ Y) :
    (single j).map f j ≫ (singleObjApplyIso j Y).hom = (singleObjApplyIso j X).hom ≫ f 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Limits.HasInitial C] [DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f j)
    (CategoryTheory.GradedObject.singleObjApplyIso j Y).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.singleObjApplyIso j X).hom f
-- CategoryTheory.GradedObject.singleCompEval_inv_app
@[simps!]
noncomputable def singleCompEval (j : J) : single j ⋙ eval j ≅ 𝟭 C 
Arguments: {J : Type u_1} (C : Type u_2) [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Limits.HasInitial C] [DecidableEq J] (j : J) (X : C)
Goal: (CategoryTheory.GradedObject.singleCompEval C j).inv.app X = (CategoryTheory.GradedObject.singleObjApplyIso j X).inv
-- CategoryTheory.GradedObject.singleCompEval_hom_app
@[simps!]
noncomputable def singleCompEval (j : J) : single j ⋙ eval j ≅ 𝟭 C 
Arguments: {J : Type u_1} (C : Type u_2) [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Limits.HasInitial C] [DecidableEq J] (j : J) (X : C)
Goal: (CategoryTheory.GradedObject.singleCompEval C j).hom.app X = (CategoryTheory.GradedObject.singleObjApplyIso j X).hom
-- CategoryTheory.NatTrans.naturality
@[ext]
structure NatTrans (F G : C ⥤ D) : Type max u₁ v₂ where
    app : ∀ X : C, F.obj X ⟶ G.obj X
    naturality : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (self : CategoryTheory.NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.app X) (G.map f)
-- CategoryTheory.congr_app
theorem congr_app {F G : C ⥤ D} {α β : NatTrans F G} (h : α = β) (X : C) : α.app X = β.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} {α β : CategoryTheory.NatTrans F G} (h : α = β) (X : C)
Goal: α.app X = β.app X
-- CategoryTheory.NatTrans.id_app'
@[simp]
theorem id_app' (F : C ⥤ D) (X : C) : (NatTrans.id F).app X = 𝟙 (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: (CategoryTheory.NatTrans.id F).app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.NatTrans.vcomp_app
theorem vcomp_app (α : NatTrans F G) (β : NatTrans G H) (X : C) :
    (vcomp α β).app X = α.app X ≫ β.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G H : CategoryTheory.Functor C D} (α : CategoryTheory.NatTrans F G) (β : CategoryTheory.NatTrans G H) (X : C)
Goal: (α.vcomp β).app X = CategoryTheory.CategoryStruct.comp (α.app X) (β.app X)
-- CategoryTheory.Functor.Linear.map_smul
class Functor.Linear {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  [Linear R C] [Linear R D] (F : C ⥤ D) [F.Additive] : Prop where
    map_smul : ∀ {X Y : C} (f : X ⟶ Y) (r : R), F.map (r • f) = r • F.map f := by aesop_cat
Arguments: {R : Type u_1} [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R C] [CategoryTheory.Linear R D] {F : CategoryTheory.Functor C D} [F.Additive] [self : CategoryTheory.Functor.Linear R F] {X Y : C} (f : X ⟶ Y) (r : R)
Goal: F.map (r • f) = r • F.map f
-- CategoryTheory.Functor.map_smul
@[simp]
theorem map_smul {X Y : C} (r : R) (f : X ⟶ Y) : F.map (r • f) = r • F.map f 
Arguments: {R : Type u_1} [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R C] [CategoryTheory.Linear R D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Functor.Linear R F] {X Y : C} (r : R) (f : X ⟶ Y)
Goal: F.map (r • f) = r • F.map f
-- CategoryTheory.Functor.map_units_smul
@[simp]
theorem map_units_smul {X Y : C} (r : Rˣ) (f : X ⟶ Y) : F.map (r • f) = r • F.map f 
Arguments: {R : Type u_1} [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R C] [CategoryTheory.Linear R D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Functor.Linear R F] {X Y : C} (r : Rˣ) (f : X ⟶ Y)
Goal: F.map (r • f) = r • F.map f
-- CategoryTheory.Functor.mapLinearMap_apply
@[simps]
def mapLinearMap {X Y : C} : (X ⟶ Y) →ₗ[R] F.obj X ⟶ F.obj Y 
Arguments: (R : Type u_1) [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R C] [CategoryTheory.Linear R D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Functor.Linear R F] {X Y : C}
Goal: ∀ (a : X ⟶ Y), (CategoryTheory.Functor.mapLinearMap R F) a = (↑F.mapAddHom).toFun a
-- CategoryTheory.Functor.coe_mapLinearMap
theorem coe_mapLinearMap {X Y : C} : ⇑(F.mapLinearMap R : (X ⟶ Y) →ₗ[R] _) = F.map 
Arguments: (R : Type u_1) [Semiring R] {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Linear R C] [CategoryTheory.Linear R D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Functor.Linear R F] {X Y : C}
Goal: ⇑(CategoryTheory.Functor.mapLinearMap R F) = F.map