ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.HasLimit.isoOfNatIso_inv_π
@[reassoc (attr := simp)]
theorem HasLimit.isoOfNatIso_inv_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (w : F ≅ G) (j : J) :
    (HasLimit.isoOfNatIso w).inv ≫ limit.π F j = limit.π G j ≫ w.inv.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : J ⥤ C} [CategoryTheory.Limits.HasLimit F] [CategoryTheory.Limits.HasLimit G] (w : F ≅ G) (j : J)
Goal: (CategoryTheory.Limits.HasLimit.isoOfNatIso w).inv ≫ CategoryTheory.Limits.limit.π F j =
  CategoryTheory.Limits.limit.π G j ≫ w.inv.app j
-- CategoryTheory.Limits.HasLimit.lift_isoOfNatIso_hom
@[reassoc (attr := simp)]
theorem HasLimit.lift_isoOfNatIso_hom {F G : J ⥤ C} [HasLimit F] [HasLimit G] (t : Cone F)
    (w : F ≅ G) :
    limit.lift F t ≫ (HasLimit.isoOfNatIso w).hom =
      limit.lift G ((Cones.postcompose w.hom).obj _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : J ⥤ C} [CategoryTheory.Limits.HasLimit F] [CategoryTheory.Limits.HasLimit G] (t : CategoryTheory.Limits.Cone F) (w : F ≅ G)
Goal: CategoryTheory.Limits.limit.lift F t ≫ (CategoryTheory.Limits.HasLimit.isoOfNatIso w).hom =
  CategoryTheory.Limits.limit.lift G ((CategoryTheory.Limits.Cones.postcompose w.hom).obj t)
-- CategoryTheory.Limits.HasLimit.lift_isoOfNatIso_inv
@[reassoc (attr := simp)]
theorem HasLimit.lift_isoOfNatIso_inv {F G : J ⥤ C} [HasLimit F] [HasLimit G] (t : Cone G)
    (w : F ≅ G) :
    limit.lift G t ≫ (HasLimit.isoOfNatIso w).inv =
      limit.lift F ((Cones.postcompose w.inv).obj _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : J ⥤ C} [CategoryTheory.Limits.HasLimit F] [CategoryTheory.Limits.HasLimit G] (t : CategoryTheory.Limits.Cone G) (w : F ≅ G)
Goal: CategoryTheory.Limits.limit.lift G t ≫ (CategoryTheory.Limits.HasLimit.isoOfNatIso w).inv =
  CategoryTheory.Limits.limit.lift F ((CategoryTheory.Limits.Cones.postcompose w.inv).obj t)
-- CategoryTheory.Limits.HasLimit.isoOfEquivalence_hom_π
@[simp]
theorem HasLimit.isoOfEquivalence_hom_π {F : J ⥤ C} [HasLimit F] {G : K ⥤ C} [HasLimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K) :
    (HasLimit.isoOfEquivalence e w).hom ≫ limit.π G k =
      limit.π F (e.inverse.obj k) ≫ w.inv.app (e.inverse.obj k) ≫ G.map (e.counit.app k) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] {G : K ⥤ C} [CategoryTheory.Limits.HasLimit G] (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K)
Goal: (CategoryTheory.Limits.HasLimit.isoOfEquivalence e w).hom ≫ CategoryTheory.Limits.limit.π G k =
  CategoryTheory.Limits.limit.π F (e.inverse.obj k) ≫ w.inv.app (e.inverse.obj k) ≫ G.map (e.counit.app k)
-- CategoryTheory.Limits.HasLimit.isoOfEquivalence_inv_π
@[simp]
theorem HasLimit.isoOfEquivalence_inv_π {F : J ⥤ C} [HasLimit F] {G : K ⥤ C} [HasLimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J) :
    (HasLimit.isoOfEquivalence e w).inv ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] {G : K ⥤ C} [CategoryTheory.Limits.HasLimit G] (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J)
Goal: (CategoryTheory.Limits.HasLimit.isoOfEquivalence e w).inv ≫ CategoryTheory.Limits.limit.π F j =
  CategoryTheory.Limits.limit.π G (e.functor.obj j) ≫ w.hom.app j
-- CategoryTheory.Limits.limit.pre_π
@[reassoc (attr := simp)]
theorem limit.pre_π (k : K) : limit.pre F E ≫ limit.π (E ⋙ F) k = limit.π F (E.obj k) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] (E : K ⥤ J) [CategoryTheory.Limits.HasLimit (E ⋙ F)] (k : K)
Goal: CategoryTheory.Limits.limit.pre F E ≫ CategoryTheory.Limits.limit.π (E ⋙ F) k =
  CategoryTheory.Limits.limit.π F (E.obj k)
-- CategoryTheory.Limits.limit.lift_pre
@[simp]
theorem limit.lift_pre (c : Cone F) :
    limit.lift F c ≫ limit.pre F E = limit.lift (E ⋙ F) (c.whisker E) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] (E : K ⥤ J) [CategoryTheory.Limits.HasLimit (E ⋙ F)] (c : CategoryTheory.Limits.Cone F)
Goal: CategoryTheory.Limits.limit.lift F c ≫ CategoryTheory.Limits.limit.pre F E =
  CategoryTheory.Limits.limit.lift (E ⋙ F) (CategoryTheory.Limits.Cone.whisker E c)
-- CategoryTheory.Limits.limit.pre_pre
@[simp]
theorem limit.pre_pre [h : HasLimit (D ⋙ E ⋙ F)] : haveI : HasLimit ((D ⋙ E) ⋙ F) := h
    limit.pre F E ≫ limit.pre (E ⋙ F) D = limit.pre F (D ⋙ E) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] (E : K ⥤ J) [CategoryTheory.Limits.HasLimit (E ⋙ F)] {L : Type u₃} [CategoryTheory.Category.{v₃, u₃} L] (D : L ⥤ K) [h : CategoryTheory.Limits.HasLimit (D ⋙ E ⋙ F)]
Goal: CategoryTheory.Limits.limit.pre F E ≫ CategoryTheory.Limits.limit.pre (E ⋙ F) D =
  CategoryTheory.Limits.limit.pre F (D ⋙ E)
-- CategoryTheory.Limits.limit.pre_eq
theorem limit.pre_eq (s : LimitCone (E ⋙ F)) (t : LimitCone F) :
    limit.pre F E = (limit.isoLimitCone t).hom ≫ s.isLimit.lift (t.cone.whisker E) ≫
      (limit.isoLimitCone s).inv 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] {E : K ⥤ J} [CategoryTheory.Limits.HasLimit (E ⋙ F)] (s : CategoryTheory.Limits.LimitCone (E ⋙ F)) (t : CategoryTheory.Limits.LimitCone F)
Goal: CategoryTheory.Limits.limit.pre F E =
  (CategoryTheory.Limits.limit.isoLimitCone t).hom ≫
    s.isLimit.lift (CategoryTheory.Limits.Cone.whisker E t.cone) ≫ (CategoryTheory.Limits.limit.isoLimitCone s).inv
-- CategoryTheory.Limits.limit.post_π
@[reassoc (attr := simp)]
theorem limit.post_π (j : J) : limit.post F G ≫ limit.π (F ⋙ G) j = G.map (limit.π F j) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] (G : C ⥤ D) [CategoryTheory.Limits.HasLimit (F ⋙ G)] (j : J)
Goal: CategoryTheory.Limits.limit.post F G ≫ CategoryTheory.Limits.limit.π (F ⋙ G) j =
  G.map (CategoryTheory.Limits.limit.π F j)
-- CategoryTheory.Limits.limit.lift_post
@[simp]
theorem limit.lift_post (c : Cone F) :
    G.map (limit.lift F c) ≫ limit.post F G = limit.lift (F ⋙ G) (G.mapCone c) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] (G : C ⥤ D) [CategoryTheory.Limits.HasLimit (F ⋙ G)] (c : CategoryTheory.Limits.Cone F)
Goal: G.map (CategoryTheory.Limits.limit.lift F c) ≫ CategoryTheory.Limits.limit.post F G =
  CategoryTheory.Limits.limit.lift (F ⋙ G) (G.mapCone c)
-- CategoryTheory.Limits.limit.post_post
@[simp]
theorem limit.post_post {E : Type u''} [Category.{v''} E] (H : D ⥤ E) [h : HasLimit ((F ⋙ G) ⋙ H)] :
    -- H G (limit F) ⟶ H (limit (F ⋙ G)) ⟶ limit ((F ⋙ G) ⋙ H) equals
    -- H G (limit F) ⟶ limit (F ⋙ (G ⋙ H))
    haveI : HasLimit (F ⋙ G ⋙ H) := h
    H.map (limit.post F G) ≫ limit.post (F ⋙ G) H = limit.post F (G ⋙ H) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] (G : C ⥤ D) [CategoryTheory.Limits.HasLimit (F ⋙ G)] {E : Type u''} [CategoryTheory.Category.{v'', u''} E] (H : D ⥤ E) [h : CategoryTheory.Limits.HasLimit ((F ⋙ G) ⋙ H)]
Goal: H.map (CategoryTheory.Limits.limit.post F G) ≫ CategoryTheory.Limits.limit.post (F ⋙ G) H =
  CategoryTheory.Limits.limit.post F (G ⋙ H)
-- CategoryTheory.Limits.limit.pre_post
theorem limit.pre_post {D : Type u'} [Category.{v'} D] (E : K ⥤ J) (F : J ⥤ C) (G : C ⥤ D)
    [HasLimit F] [HasLimit (E ⋙ F)] [HasLimit (F ⋙ G)]
    [h : HasLimit ((E ⋙ F) ⋙ G)] :-- G (limit F) ⟶ G (limit (E ⋙ F)) ⟶ limit ((E ⋙ F) ⋙ G) vs
            -- G (limit F) ⟶ limit F ⋙ G ⟶ limit (E ⋙ (F ⋙ G)) or
    haveI : HasLimit (E ⋙ F ⋙ G) := h
    G.map (limit.pre F E) ≫ limit.post (E ⋙ F) G = limit.post F G ≫ limit.pre (F ⋙ G) E 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (E : K ⥤ J) (F : J ⥤ C) (G : C ⥤ D) [CategoryTheory.Limits.HasLimit F] [CategoryTheory.Limits.HasLimit (E ⋙ F)] [CategoryTheory.Limits.HasLimit (F ⋙ G)] [h : CategoryTheory.Limits.HasLimit ((E ⋙ F) ⋙ G)]
Goal: G.map (CategoryTheory.Limits.limit.pre F E) ≫ CategoryTheory.Limits.limit.post (E ⋙ F) G =
  CategoryTheory.Limits.limit.post F G ≫ CategoryTheory.Limits.limit.pre (F ⋙ G) E
-- CategoryTheory.Limits.hasLimitOfEquivalenceComp
theorem hasLimitOfEquivalenceComp (e : K ≌ J) [HasLimit (e.functor ⋙ F)] : HasLimit F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} (e : K ≌ J) [CategoryTheory.Limits.HasLimit (e.functor ⋙ F)]
Goal: CategoryTheory.Limits.HasLimit F
-- CategoryTheory.Limits.lim_map
@[simps]
def lim : (J ⥤ C) ⥤ C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C]
Goal: ∀ {X Y : J ⥤ C} (α : X ⟶ Y), CategoryTheory.Limits.lim.map α = CategoryTheory.Limits.limMap α
-- CategoryTheory.Limits.lim_obj
@[simps]
def lim : (J ⥤ C) ⥤ C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ C)
Goal: CategoryTheory.Limits.lim.obj F = CategoryTheory.Limits.limit F
-- CategoryTheory.Limits.limit.map_pre
theorem limit.map_pre [HasLimitsOfShape K C] (E : K ⥤ J) :
    lim.map α ≫ limit.pre G E = limit.pre F E ≫ lim.map (whiskerLeft E α) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimitsOfShape J C] {G : J ⥤ C} (α : F ⟶ G) [CategoryTheory.Limits.HasLimitsOfShape K C] (E : K ⥤ J)
Goal: CategoryTheory.Limits.lim.map α ≫ CategoryTheory.Limits.limit.pre G E =
  CategoryTheory.Limits.limit.pre F E ≫ CategoryTheory.Limits.lim.map (CategoryTheory.whiskerLeft E α)
-- CategoryTheory.Limits.limit.map_pre'
theorem limit.map_pre' [HasLimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂) :
    limit.pre F E₂ = limit.pre F E₁ ≫ lim.map (whiskerRight α F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.Limits.HasLimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂)
Goal: CategoryTheory.Limits.limit.pre F E₂ =
  CategoryTheory.Limits.limit.pre F E₁ ≫ CategoryTheory.Limits.lim.map (CategoryTheory.whiskerRight α F)
-- CategoryTheory.Limits.limit.id_pre
theorem limit.id_pre (F : J ⥤ C) : limit.pre F (𝟭 _) = lim.map (Functor.leftUnitor F).inv 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ C)
Goal: CategoryTheory.Limits.limit.pre F (𝟭 J) = CategoryTheory.Limits.lim.map F.leftUnitor.inv
-- CategoryTheory.Limits.limit.map_post
theorem limit.map_post {D : Type u'} [Category.{v'} D] [HasLimitsOfShape J D] (H : C ⥤ D) :
    /- H (limit F) ⟶ H (limit G) ⟶ limit (G ⋙ H) vs
     H (limit F) ⟶ limit (F ⋙ H) ⟶ limit (G ⋙ H) -/
    H.map (limMap α) ≫ limit.post G H = limit.post F H ≫ limMap (whiskerRight α H) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimitsOfShape J C] {G : J ⥤ C} (α : F ⟶ G) {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasLimitsOfShape J D] (H : C ⥤ D)
Goal: H.map (CategoryTheory.Limits.limMap α) ≫ CategoryTheory.Limits.limit.post G H =
  CategoryTheory.Limits.limit.post F H ≫ CategoryTheory.Limits.limMap (CategoryTheory.whiskerRight α H)
-- CategoryTheory.Limits.coneOfAdj_pt
@[simps]
noncomputable def coneOfAdj (F : J ⥤ C) : Cone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {L : (J ⥤ C) ⥤ C} (adj : CategoryTheory.Functor.const J ⊣ L) (F : J ⥤ C)
Goal: (CategoryTheory.Limits.coneOfAdj adj F).pt = L.obj F
-- CategoryTheory.Limits.coneOfAdj_π
@[simps]
noncomputable def coneOfAdj (F : J ⥤ C) : Cone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {L : (J ⥤ C) ⥤ C} (adj : CategoryTheory.Functor.const J ⊣ L) (F : J ⥤ C)
Goal: (CategoryTheory.Limits.coneOfAdj adj F).π = adj.counit.app F
-- CategoryTheory.Limits.isLimitConeOfAdj_lift
@[simps]
def isLimitConeOfAdj (F : J ⥤ C) :
    IsLimit (coneOfAdj adj F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {L : (J ⥤ C) ⥤ C} (adj : CategoryTheory.Functor.const J ⊣ L) (F : J ⥤ C) (s : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.isLimitConeOfAdj adj F).lift s = (adj.homEquiv s.pt F) s.π
-- CategoryTheory.Limits.hasLimitsOfShape_of_equivalence
theorem hasLimitsOfShape_of_equivalence {J' : Type u₂} [Category.{v₂} J'] (e : J ≌ J')
    [HasLimitsOfShape J C] : HasLimitsOfShape J' C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {J' : Type u₂} [CategoryTheory.Category.{v₂, u₂} J'] (e : J ≌ J') [CategoryTheory.Limits.HasLimitsOfShape J C]
Goal: CategoryTheory.Limits.HasLimitsOfShape J' C
-- CategoryTheory.Limits.hasLimitsOfSizeOfUnivLE
theorem hasLimitsOfSizeOfUnivLE [UnivLE.{v₂, v₁}] [UnivLE.{u₂, u₁}]
    [HasLimitsOfSize.{v₁, u₁} C] : HasLimitsOfSize.{v₂, u₂} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [UnivLE.{v₂, v₁}] [UnivLE.{u₂, u₁}] [CategoryTheory.Limits.HasLimitsOfSize.{v₁, u₁, v, u} C]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{v₂, u₂, v, u} C
-- CategoryTheory.Limits.hasLimitsOfSizeShrink
theorem hasLimitsOfSizeShrink [HasLimitsOfSize.{max v₁ v₂, max u₁ u₂} C] :
    HasLimitsOfSize.{v₁, u₁} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfSize.{max v₁ v₂, max u₁ u₂, v, u} C]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{v₁, u₁, v, u} C
-- CategoryTheory.Limits.HasColimit.exists_colimit
class HasColimit (F : J ⥤ C) : Prop where mk' ::
    exists_colimit : Nonempty (ColimitCocone F)
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [self : CategoryTheory.Limits.HasColimit F]
Goal: Nonempty (CategoryTheory.Limits.ColimitCocone F)
-- CategoryTheory.Limits.HasColimit.mk
theorem HasColimit.mk {F : J ⥤ C} (d : ColimitCocone F) : HasColimit F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} (d : CategoryTheory.Limits.ColimitCocone F)
Goal: CategoryTheory.Limits.HasColimit F
-- CategoryTheory.Limits.HasColimitsOfShape.has_colimit
class HasColimitsOfShape : Prop where
    has_colimit : ∀ F : J ⥤ C, HasColimit F := by infer_instance
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ C)
Goal: CategoryTheory.Limits.HasColimit F
-- CategoryTheory.Limits.HasColimitsOfSize.has_colimits_of_shape
@[pp_with_univ]
class HasColimitsOfSize (C : Type u) [Category.{v} C] : Prop where
    has_colimits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasColimitsOfShape J C := by
    infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasColimitsOfSize.{v₁, u₁, v, u} C] (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.Limits.HasColimits.hasColimitsOfShape
theorem HasColimits.hasColimitsOfShape {C : Type u} [Category.{v} C] [HasColimits C] (J : Type v)
    [Category.{v} J] : HasColimitsOfShape J C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] (J : Type v) [CategoryTheory.Category.{v, v} J]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.Limits.colimit.cocone_ι
@[simp]
theorem colimit.cocone_ι {F : J ⥤ C} [HasColimit F] (j : J) :
    (colimit.cocone F).ι.app j = colimit.ι _ j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (j : J)
Goal: (CategoryTheory.Limits.colimit.cocone F).ι.app j = CategoryTheory.Limits.colimit.ι F j
-- CategoryTheory.Limits.colimit.cocone_x
@[simp]
theorem colimit.cocone_x {F : J ⥤ C} [HasColimit F] : (colimit.cocone F).pt = colimit F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F]
Goal: (CategoryTheory.Limits.colimit.cocone F).pt = CategoryTheory.Limits.colimit F
-- CategoryTheory.Limits.colimit.w
@[reassoc (attr := simp)]
theorem colimit.w (F : J ⥤ C) [HasColimit F] {j j' : J} (f : j ⟶ j') :
    F.map f ≫ colimit.ι F j' = colimit.ι F j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasColimit F] {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ CategoryTheory.Limits.colimit.ι F j' = CategoryTheory.Limits.colimit.ι F j
-- CategoryTheory.Limits.colimit.isColimit_desc
@[simp]
theorem colimit.isColimit_desc {F : J ⥤ C} [HasColimit F] (c : Cocone F) :
    (colimit.isColimit F).desc c = colimit.desc F c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.colimit.isColimit F).desc c = CategoryTheory.Limits.colimit.desc F c
-- CategoryTheory.Limits.colimit.ι_desc
@[reassoc (attr := simp)]
theorem colimit.ι_desc {F : J ⥤ C} [HasColimit F] (c : Cocone F) (j : J) :
    colimit.ι F j ≫ colimit.desc F c = c.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ CategoryTheory.Limits.colimit.desc F c = c.ι.app j
-- CategoryTheory.Limits.ι_colimMap
@[reassoc (attr := simp)]
theorem ι_colimMap {F G : J ⥤ C} [HasColimit F] [HasColimit G] (α : F ⟶ G) (j : J) :
    colimit.ι F j ≫ colimMap α = α.app j ≫ colimit.ι G j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : J ⥤ C} [CategoryTheory.Limits.HasColimit F] [CategoryTheory.Limits.HasColimit G] (α : F ⟶ G) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ CategoryTheory.Limits.colimMap α = α.app j ≫ CategoryTheory.Limits.colimit.ι G j
-- CategoryTheory.Limits.colimit.coconeMorphism_hom
@[simp]
theorem colimit.coconeMorphism_hom {F : J ⥤ C} [HasColimit F] (c : Cocone F) :
    (colimit.coconeMorphism c).hom = colimit.desc F c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.colimit.coconeMorphism c).hom = CategoryTheory.Limits.colimit.desc F c
-- CategoryTheory.Limits.colimit.ι_coconeMorphism
theorem colimit.ι_coconeMorphism {F : J ⥤ C} [HasColimit F] (c : Cocone F) (j : J) :
    colimit.ι F j ≫ (colimit.coconeMorphism c).hom = c.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.colimit.coconeMorphism c).hom = c.ι.app j
-- CategoryTheory.Limits.colimit.comp_coconePointUniqueUpToIso_hom
@[reassoc (attr := simp)]
theorem colimit.comp_coconePointUniqueUpToIso_hom {F : J ⥤ C} [HasColimit F] {c : Cocone F}
    (hc : IsColimit c) (j : J) :
    colimit.ι F j ≫ (IsColimit.coconePointUniqueUpToIso (colimit.isColimit _) hc).hom = c.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ ((CategoryTheory.Limits.colimit.isColimit F).coconePointUniqueUpToIso hc).hom =
  c.ι.app j
-- CategoryTheory.Limits.colimit.comp_coconePointUniqueUpToIso_inv
@[reassoc (attr := simp)]
theorem colimit.comp_coconePointUniqueUpToIso_inv {F : J ⥤ C} [HasColimit F] {c : Cocone F}
    (hc : IsColimit c) (j : J) :
    colimit.ι F j ≫ (IsColimit.coconePointUniqueUpToIso hc (colimit.isColimit _)).inv = c.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ (hc.coconePointUniqueUpToIso (CategoryTheory.Limits.colimit.isColimit F)).inv =
  c.ι.app j
-- CategoryTheory.Limits.colimit.existsUnique
theorem colimit.existsUnique {F : J ⥤ C} [HasColimit F] (t : Cocone F) :
    ∃! d : colimit F ⟶ t.pt, ∀ j, colimit.ι F j ≫ d = t.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (t : CategoryTheory.Limits.Cocone F)
Goal: ∃! d, ∀ (j : J), CategoryTheory.Limits.colimit.ι F j ≫ d = t.ι.app j
-- CategoryTheory.Limits.colimit.isoColimitCocone_ι_hom
@[reassoc (attr := simp)]
theorem colimit.isoColimitCocone_ι_hom {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) (j : J) :
    colimit.ι F j ≫ (colimit.isoColimitCocone t).hom = t.cocone.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (t : CategoryTheory.Limits.ColimitCocone F) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.colimit.isoColimitCocone t).hom = t.cocone.ι.app j
-- CategoryTheory.Limits.colimit.isoColimitCocone_ι_inv
@[reassoc (attr := simp)]
theorem colimit.isoColimitCocone_ι_inv {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) (j : J) :
    t.cocone.ι.app j ≫ (colimit.isoColimitCocone t).inv = colimit.ι F j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimit F] (t : CategoryTheory.Limits.ColimitCocone F) (j : J)
Goal: t.cocone.ι.app j ≫ (CategoryTheory.Limits.colimit.isoColimitCocone t).inv = CategoryTheory.Limits.colimit.ι F j