ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.colimit.hom_ext
@[ext]
theorem colimit.hom_ext {F : J ⥤ C} [HasColimit F] {X : C} {f f' : colimit F ⟶ X}
    (w : ∀ j, colimit.ι F j ≫ f = colimit.ι F j ≫ f') : f = 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] {X : C} {f f' : CategoryTheory.Limits.colimit F ⟶ X} (w : ∀ (j : J), CategoryTheory.Limits.colimit.ι F j ≫ f = CategoryTheory.Limits.colimit.ι F j ≫ f')
Goal: f = f'
-- CategoryTheory.Limits.colimit.desc_cocone
@[simp]
theorem colimit.desc_cocone {F : J ⥤ C} [HasColimit F] :
    colimit.desc F (colimit.cocone F) = 𝟙 (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.desc F (CategoryTheory.Limits.colimit.cocone F) = 𝟙 (CategoryTheory.Limits.colimit F)
-- CategoryTheory.Limits.colimit.homIso_hom
@[simp]
theorem colimit.homIso_hom (F : J ⥤ C) [HasColimit F] {W : C} (f : ULift (colimit F ⟶ W)) :
    (colimit.homIso F W).hom f = (colimit.cocone F).ι ≫ (const J).map f.down 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasColimit F] {W : C} (f : ULift.{u₁, v} (CategoryTheory.Limits.colimit F ⟶ W))
Goal: (CategoryTheory.Limits.colimit.homIso F W).hom f =
  (CategoryTheory.Limits.colimit.cocone F).ι ≫ (CategoryTheory.Functor.const J).map f.down
-- CategoryTheory.Limits.colimit.desc_extend
theorem colimit.desc_extend (F : J ⥤ C) [HasColimit F] (c : Cocone F) {X : C} (f : c.pt ⟶ X) :
    colimit.desc F (c.extend f) = colimit.desc F c ≫ 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] (c : CategoryTheory.Limits.Cocone F) {X : C} (f : c.pt ⟶ X)
Goal: CategoryTheory.Limits.colimit.desc F (c.extend f) = CategoryTheory.Limits.colimit.desc F c ≫ f
-- CategoryTheory.Limits.hasColimitOfIso
theorem hasColimitOfIso {F G : J ⥤ C} [HasColimit F] (α : G ≅ F) : HasColimit G 
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] (α : G ≅ F)
Goal: CategoryTheory.Limits.HasColimit G
-- CategoryTheory.Limits.HasColimit.ofCoconesIso
theorem HasColimit.ofCoconesIso {K : Type u₁} [Category.{v₂} K] (F : J ⥤ C) (G : K ⥤ C)
    (h : F.cocones ≅ G.cocones) [HasColimit F] : HasColimit G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {K : Type u₁} [CategoryTheory.Category.{v₂, u₁} K] (F : J ⥤ C) (G : K ⥤ C) (h : F.cocones ≅ G.cocones) [CategoryTheory.Limits.HasColimit F]
Goal: CategoryTheory.Limits.HasColimit G
-- CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_hom
@[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_ι_hom {F G : J ⥤ C} [HasColimit F] [HasColimit G] (w : F ≅ G)
    (j : J) : colimit.ι F j ≫ (HasColimit.isoOfNatIso w).hom = w.hom.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] (w : F ≅ G) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.HasColimit.isoOfNatIso w).hom =
  w.hom.app j ≫ CategoryTheory.Limits.colimit.ι G j
-- CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_inv
@[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_ι_inv {F G : J ⥤ C} [HasColimit F] [HasColimit G] (w : F ≅ G)
    (j : J) : colimit.ι G j ≫ (HasColimit.isoOfNatIso w).inv = w.inv.app j ≫ colimit.ι F 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] (w : F ≅ G) (j : J)
Goal: CategoryTheory.Limits.colimit.ι G j ≫ (CategoryTheory.Limits.HasColimit.isoOfNatIso w).inv =
  w.inv.app j ≫ CategoryTheory.Limits.colimit.ι F j
-- CategoryTheory.Limits.HasColimit.isoOfNatIso_hom_desc
@[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_hom_desc {F G : J ⥤ C} [HasColimit F] [HasColimit G] (t : Cocone G)
    (w : F ≅ G) :
    (HasColimit.isoOfNatIso w).hom ≫ colimit.desc G t =
      colimit.desc F ((Cocones.precompose 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.HasColimit F] [CategoryTheory.Limits.HasColimit G] (t : CategoryTheory.Limits.Cocone G) (w : F ≅ G)
Goal: (CategoryTheory.Limits.HasColimit.isoOfNatIso w).hom ≫ CategoryTheory.Limits.colimit.desc G t =
  CategoryTheory.Limits.colimit.desc F ((CategoryTheory.Limits.Cocones.precompose w.hom).obj t)
-- CategoryTheory.Limits.HasColimit.isoOfNatIso_inv_desc
@[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_inv_desc {F G : J ⥤ C} [HasColimit F] [HasColimit G] (t : Cocone F)
    (w : F ≅ G) :
    (HasColimit.isoOfNatIso w).inv ≫ colimit.desc F t =
      colimit.desc G ((Cocones.precompose 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.HasColimit F] [CategoryTheory.Limits.HasColimit G] (t : CategoryTheory.Limits.Cocone F) (w : F ≅ G)
Goal: (CategoryTheory.Limits.HasColimit.isoOfNatIso w).inv ≫ CategoryTheory.Limits.colimit.desc F t =
  CategoryTheory.Limits.colimit.desc G ((CategoryTheory.Limits.Cocones.precompose w.inv).obj t)
-- CategoryTheory.Limits.HasColimit.isoOfEquivalence_hom_π
@[simp]
theorem HasColimit.isoOfEquivalence_hom_π {F : J ⥤ C} [HasColimit F] {G : K ⥤ C} [HasColimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J) :
    colimit.ι F j ≫ (HasColimit.isoOfEquivalence e w).hom =
      F.map (e.unit.app j) ≫ w.inv.app _ ≫ colimit.ι G _ 
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.HasColimit F] {G : K ⥤ C} [CategoryTheory.Limits.HasColimit G] (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.HasColimit.isoOfEquivalence e w).hom =
  F.map (e.unit.app j) ≫
    w.inv.app ((e.functor ⋙ e.inverse).obj j) ≫
      CategoryTheory.Limits.colimit.ι G (e.functor.obj ((e.functor ⋙ e.inverse).obj j))
-- CategoryTheory.Limits.HasColimit.isoOfEquivalence_inv_π
@[simp]
theorem HasColimit.isoOfEquivalence_inv_π {F : J ⥤ C} [HasColimit F] {G : K ⥤ C} [HasColimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K) :
    colimit.ι G k ≫ (HasColimit.isoOfEquivalence e w).inv =
      G.map (e.counitInv.app k) ≫ w.hom.app (e.inverse.obj k) ≫ colimit.ι F (e.inverse.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.HasColimit F] {G : K ⥤ C} [CategoryTheory.Limits.HasColimit G] (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K)
Goal: CategoryTheory.Limits.colimit.ι G k ≫ (CategoryTheory.Limits.HasColimit.isoOfEquivalence e w).inv =
  G.map (e.counitInv.app k) ≫ w.hom.app (e.inverse.obj k) ≫ CategoryTheory.Limits.colimit.ι F (e.inverse.obj k)
-- CategoryTheory.Limits.colimit.ι_pre
@[reassoc (attr := simp)]
theorem colimit.ι_pre (k : K) : colimit.ι (E ⋙ F) k ≫ colimit.pre F E = colimit.ι 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.HasColimit F] (E : K ⥤ J) [CategoryTheory.Limits.HasColimit (E ⋙ F)] (k : K)
Goal: CategoryTheory.Limits.colimit.ι (E ⋙ F) k ≫ CategoryTheory.Limits.colimit.pre F E =
  CategoryTheory.Limits.colimit.ι F (E.obj k)
-- CategoryTheory.Limits.colimit.pre_desc
@[reassoc (attr := simp)]
theorem colimit.pre_desc (c : Cocone F) :
    colimit.pre F E ≫ colimit.desc F c = colimit.desc (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.HasColimit F] (E : K ⥤ J) [CategoryTheory.Limits.HasColimit (E ⋙ F)] (c : CategoryTheory.Limits.Cocone F)
Goal: CategoryTheory.Limits.colimit.pre F E ≫ CategoryTheory.Limits.colimit.desc F c =
  CategoryTheory.Limits.colimit.desc (E ⋙ F) (CategoryTheory.Limits.Cocone.whisker E c)
-- CategoryTheory.Limits.colimit.pre_pre
@[simp]
theorem colimit.pre_pre [h : HasColimit (D ⋙ E ⋙ F)] :
    haveI : HasColimit ((D ⋙ E) ⋙ F) := h
    colimit.pre (E ⋙ F) D ≫ colimit.pre F E = colimit.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.HasColimit F] (E : K ⥤ J) [CategoryTheory.Limits.HasColimit (E ⋙ F)] {L : Type u₃} [CategoryTheory.Category.{v₃, u₃} L] (D : L ⥤ K) [h : CategoryTheory.Limits.HasColimit (D ⋙ E ⋙ F)]
Goal: CategoryTheory.Limits.colimit.pre (E ⋙ F) D ≫ CategoryTheory.Limits.colimit.pre F E =
  CategoryTheory.Limits.colimit.pre F (D ⋙ E)
-- CategoryTheory.Limits.colimit.pre_eq
theorem colimit.pre_eq (s : ColimitCocone (E ⋙ F)) (t : ColimitCocone F) :
    colimit.pre F E =
      (colimit.isoColimitCocone s).hom ≫
        s.isColimit.desc (t.cocone.whisker E) ≫ (colimit.isoColimitCocone t).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.HasColimit F] {E : K ⥤ J} [CategoryTheory.Limits.HasColimit (E ⋙ F)] (s : CategoryTheory.Limits.ColimitCocone (E ⋙ F)) (t : CategoryTheory.Limits.ColimitCocone F)
Goal: CategoryTheory.Limits.colimit.pre F E =
  (CategoryTheory.Limits.colimit.isoColimitCocone s).hom ≫
    s.isColimit.desc (CategoryTheory.Limits.Cocone.whisker E t.cocone) ≫
      (CategoryTheory.Limits.colimit.isoColimitCocone t).inv
-- CategoryTheory.Limits.colimit.ι_post
@[reassoc (attr := simp)]
theorem colimit.ι_post (j : J) :
    colimit.ι (F ⋙ G) j ≫ colimit.post F G = G.map (colimit.ι F j) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasColimit F] (G : C ⥤ D) [CategoryTheory.Limits.HasColimit (F ⋙ G)] (j : J)
Goal: CategoryTheory.Limits.colimit.ι (F ⋙ G) j ≫ CategoryTheory.Limits.colimit.post F G =
  G.map (CategoryTheory.Limits.colimit.ι F j)
-- CategoryTheory.Limits.colimit.post_desc
@[simp]
theorem colimit.post_desc (c : Cocone F) :
    colimit.post F G ≫ G.map (colimit.desc F c) = colimit.desc (F ⋙ G) (G.mapCocone c) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasColimit F] (G : C ⥤ D) [CategoryTheory.Limits.HasColimit (F ⋙ G)] (c : CategoryTheory.Limits.Cocone F)
Goal: CategoryTheory.Limits.colimit.post F G ≫ G.map (CategoryTheory.Limits.colimit.desc F c) =
  CategoryTheory.Limits.colimit.desc (F ⋙ G) (G.mapCocone c)
-- CategoryTheory.Limits.colimit.post_post
@[simp]
theorem colimit.post_post {E : Type u''} [Category.{v''} E] (H : D ⥤ E)
    -- H G (colimit F) ⟶ H (colimit (F ⋙ G)) ⟶ colimit ((F ⋙ G) ⋙ H) equals
    -- H G (colimit F) ⟶ colimit (F ⋙ (G ⋙ H))
    [h : HasColimit ((F ⋙ G) ⋙ H)] : haveI : HasColimit (F ⋙ G ⋙ H) := h
    colimit.post (F ⋙ G) H ≫ H.map (colimit.post F G) = colimit.post F (G ⋙ H) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasColimit F] (G : C ⥤ D) [CategoryTheory.Limits.HasColimit (F ⋙ G)] {E : Type u''} [CategoryTheory.Category.{v'', u''} E] (H : D ⥤ E) [h : CategoryTheory.Limits.HasColimit ((F ⋙ G) ⋙ H)]
Goal: CategoryTheory.Limits.colimit.post (F ⋙ G) H ≫ H.map (CategoryTheory.Limits.colimit.post F G) =
  CategoryTheory.Limits.colimit.post F (G ⋙ H)
-- CategoryTheory.Limits.colimit.pre_post
theorem colimit.pre_post {D : Type u'} [Category.{v'} D] (E : K ⥤ J) (F : J ⥤ C) (G : C ⥤ D)
    [HasColimit F] [HasColimit (E ⋙ F)] [HasColimit (F ⋙ G)] [h : HasColimit ((E ⋙ F) ⋙ G)] :
    -- G (colimit F) ⟶ G (colimit (E ⋙ F)) ⟶ colimit ((E ⋙ F) ⋙ G) vs
    -- G (colimit F) ⟶ colimit F ⋙ G ⟶ colimit (E ⋙ (F ⋙ G)) or
    haveI : HasColimit (E ⋙ F ⋙ G) := h
    colimit.post (E ⋙ F) G ≫ G.map (colimit.pre F E) =
      colimit.pre (F ⋙ G) E ≫ colimit.post F G 
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.HasColimit F] [CategoryTheory.Limits.HasColimit (E ⋙ F)] [CategoryTheory.Limits.HasColimit (F ⋙ G)] [h : CategoryTheory.Limits.HasColimit ((E ⋙ F) ⋙ G)]
Goal: CategoryTheory.Limits.colimit.post (E ⋙ F) G ≫ G.map (CategoryTheory.Limits.colimit.pre F E) =
  CategoryTheory.Limits.colimit.pre (F ⋙ G) E ≫ CategoryTheory.Limits.colimit.post F G
-- CategoryTheory.Limits.hasColimit_of_equivalence_comp
theorem hasColimit_of_equivalence_comp (e : K ≌ J) [HasColimit (e.functor ⋙ F)] : HasColimit 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.HasColimit (e.functor ⋙ F)]
Goal: CategoryTheory.Limits.HasColimit F
-- CategoryTheory.Limits.colim_obj
@[simps] -- Porting note: simps on all fields now
def colim : (J ⥤ C) ⥤ C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ C)
Goal: CategoryTheory.Limits.colim.obj F = CategoryTheory.Limits.colimit F
-- CategoryTheory.Limits.colim_map
@[simps] -- Porting note: simps on all fields now
def colim : (J ⥤ C) ⥤ C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimitsOfShape J C]
Goal: ∀ {X Y : J ⥤ C} (α : X ⟶ Y), CategoryTheory.Limits.colim.map α = CategoryTheory.Limits.colimMap α
-- CategoryTheory.Limits.colimit.ι_map
@[reassoc]
theorem colimit.ι_map (j : J) : colimit.ι F j ≫ colim.map α = α.app j ≫ colimit.ι G j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimitsOfShape J C] {G : J ⥤ C} (α : F ⟶ G) (j : J)
Goal: CategoryTheory.Limits.colimit.ι F j ≫ CategoryTheory.Limits.colim.map α = α.app j ≫ CategoryTheory.Limits.colimit.ι G j
-- CategoryTheory.Limits.colimit.map_desc
@[simp] -- Porting note: proof adjusted to account for @[simps] on all fields of colim
theorem colimit.map_desc (c : Cocone G) :
    colimMap α ≫ colimit.desc G c = colimit.desc F ((Cocones.precompose α).obj c) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimitsOfShape J C] {G : J ⥤ C} (α : F ⟶ G) (c : CategoryTheory.Limits.Cocone G)
Goal: CategoryTheory.Limits.colimMap α ≫ CategoryTheory.Limits.colimit.desc G c =
  CategoryTheory.Limits.colimit.desc F ((CategoryTheory.Limits.Cocones.precompose α).obj c)
-- CategoryTheory.Limits.colimit.pre_map
theorem colimit.pre_map [HasColimitsOfShape K C] (E : K ⥤ J) :
    colimit.pre F E ≫ colim.map α = colim.map (whiskerLeft E α) ≫ colimit.pre 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] {F : J ⥤ C} [CategoryTheory.Limits.HasColimitsOfShape J C] {G : J ⥤ C} (α : F ⟶ G) [CategoryTheory.Limits.HasColimitsOfShape K C] (E : K ⥤ J)
Goal: CategoryTheory.Limits.colimit.pre F E ≫ CategoryTheory.Limits.colim.map α =
  CategoryTheory.Limits.colim.map (CategoryTheory.whiskerLeft E α) ≫ CategoryTheory.Limits.colimit.pre G E
-- CategoryTheory.Limits.colimit.pre_map'
theorem colimit.pre_map' [HasColimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂) :
    colimit.pre F E₁ = colim.map (whiskerRight α F) ≫ colimit.pre F 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] [CategoryTheory.Limits.HasColimitsOfShape J C] [CategoryTheory.Limits.HasColimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂)
Goal: CategoryTheory.Limits.colimit.pre F E₁ =
  CategoryTheory.Limits.colim.map (CategoryTheory.whiskerRight α F) ≫ CategoryTheory.Limits.colimit.pre F E₂
-- CategoryTheory.Limits.colimit.pre_id
theorem colimit.pre_id (F : J ⥤ C) :
    colimit.pre F (𝟭 _) = colim.map (Functor.leftUnitor F).hom 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ C)
Goal: CategoryTheory.Limits.colimit.pre F (𝟭 J) = CategoryTheory.Limits.colim.map F.leftUnitor.hom
-- CategoryTheory.Limits.colimit.map_post
theorem colimit.map_post {D : Type u'} [Category.{v'} D] [HasColimitsOfShape J D]
    (H : C ⥤ D) :/- H (colimit F) ⟶ H (colimit G) ⟶ colimit (G ⋙ H) vs
             H (colimit F) ⟶ colimit (F ⋙ H) ⟶ colimit (G ⋙ H) -/
          colimit.post
          F H ≫
        H.map (colim.map α) =
      colim.map (whiskerRight α H) ≫ colimit.post G H 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasColimitsOfShape J C] {G : J ⥤ C} (α : F ⟶ G) {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasColimitsOfShape J D] (H : C ⥤ D)
Goal: CategoryTheory.Limits.colimit.post F H ≫ H.map (CategoryTheory.Limits.colim.map α) =
  CategoryTheory.Limits.colim.map (CategoryTheory.whiskerRight α H) ≫ CategoryTheory.Limits.colimit.post G H
-- CategoryTheory.Limits.hasColimitsOfShape_of_equivalence
theorem hasColimitsOfShape_of_equivalence {J' : Type u₂} [Category.{v₂} J'] (e : J ≌ J')
    [HasColimitsOfShape J C] : HasColimitsOfShape 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.HasColimitsOfShape J C]
Goal: CategoryTheory.Limits.HasColimitsOfShape J' C
-- CategoryTheory.Limits.hasColimitsOfSizeOfUnivLE
theorem hasColimitsOfSizeOfUnivLE [UnivLE.{v₂, v₁}] [UnivLE.{u₂, u₁}]
    [HasColimitsOfSize.{v₁, u₁} C] : HasColimitsOfSize.{v₂, u₂} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [UnivLE.{v₂, v₁}] [UnivLE.{u₂, u₁}] [CategoryTheory.Limits.HasColimitsOfSize.{v₁, u₁, v, u} C]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, v, u} C
-- CategoryTheory.Limits.hasColimitsOfSizeShrink
theorem hasColimitsOfSizeShrink [HasColimitsOfSize.{max v₁ v₂, max u₁ u₂} C] :
    HasColimitsOfSize.{v₁, u₁} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimitsOfSize.{max v₁ v₂, max u₁ u₂, v, u} C]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{v₁, u₁, v, u} C
-- CategoryTheory.Limits.HasFiniteProducts.out
class HasFiniteProducts : Prop where
    out (n : ℕ) : HasLimitsOfShape (Discrete (Fin n)) C
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasFiniteProducts C] (n : ℕ)
Goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete (Fin n)) C
-- CategoryTheory.Limits.hasFiniteProducts_of_hasProducts
theorem hasFiniteProducts_of_hasProducts [HasProducts.{w} C] : HasFiniteProducts C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasProducts C]
Goal: CategoryTheory.Limits.HasFiniteProducts C
-- CategoryTheory.Limits.HasFiniteCoproducts.out
class HasFiniteCoproducts : Prop where
    out (n : ℕ) : HasColimitsOfShape (Discrete (Fin n)) C
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasFiniteCoproducts C] (n : ℕ)
Goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (Fin n)) C
-- CategoryTheory.Limits.hasFiniteCoproducts_of_hasCoproducts
theorem hasFiniteCoproducts_of_hasCoproducts [HasCoproducts.{w} C] : HasFiniteCoproducts C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasCoproducts C]
Goal: CategoryTheory.Limits.HasFiniteCoproducts C
-- CategoryTheory.Limits.PullbackCone.mono_snd_of_is_pullback_of_mono
theorem mono_snd_of_is_pullback_of_mono {t : PullbackCone f g} (ht : IsLimit t) [Mono f] :
    Mono t.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) [CategoryTheory.Mono f]
Goal: CategoryTheory.Mono t.snd
-- CategoryTheory.Limits.PullbackCone.mono_fst_of_is_pullback_of_mono
theorem mono_fst_of_is_pullback_of_mono {t : PullbackCone f g} (ht : IsLimit t) [Mono g] :
    Mono t.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) [CategoryTheory.Mono g]
Goal: CategoryTheory.Mono t.fst
-- CategoryTheory.Limits.PullbackCone.mono_of_isLimitMkIdId
theorem mono_of_isLimitMkIdId (f : X ⟶ Y) (t : IsLimit (mk (𝟙 X) (𝟙 X) rfl : PullbackCone f f)) :
    Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (t : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk (𝟙 X) (𝟙 X) ⋯))
Goal: CategoryTheory.Mono f
-- CategoryTheory.Limits.fst_eq_snd_of_mono_eq
theorem fst_eq_snd_of_mono_eq [Mono f] : pullback.fst f f = pullback.snd f f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.Limits.pullback.fst f f = CategoryTheory.Limits.pullback.snd f f
-- CategoryTheory.Limits.pullbackSymmetry_hom_of_mono_eq
@[simp]
theorem pullbackSymmetry_hom_of_mono_eq [Mono f] : (pullbackSymmetry f f).hom = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Limits.pullbackSymmetry f f).hom = 𝟙 (CategoryTheory.Limits.pullback f f)
-- CategoryTheory.Limits.PushoutCocone.epi_inr_of_is_pushout_of_epi
theorem epi_inr_of_is_pushout_of_epi {t : PushoutCocone f g} (ht : IsColimit t) [Epi f] :
    Epi t.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {t : CategoryTheory.Limits.PushoutCocone f g} (ht : CategoryTheory.Limits.IsColimit t) [CategoryTheory.Epi f]
Goal: CategoryTheory.Epi t.inr
-- CategoryTheory.Limits.PushoutCocone.epi_inl_of_is_pushout_of_epi
theorem epi_inl_of_is_pushout_of_epi {t : PushoutCocone f g} (ht : IsColimit t) [Epi g] :
    Epi t.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} {t : CategoryTheory.Limits.PushoutCocone f g} (ht : CategoryTheory.Limits.IsColimit t) [CategoryTheory.Epi g]
Goal: CategoryTheory.Epi t.inl
-- CategoryTheory.Limits.PushoutCocone.epi_of_isColimitMkIdId
theorem epi_of_isColimitMkIdId (f : X ⟶ Y)
    (t : IsColimit (mk (𝟙 Y) (𝟙 Y) rfl : PushoutCocone f f)) : Epi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (t : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk (𝟙 Y) (𝟙 Y) ⋯))
Goal: CategoryTheory.Epi f
-- CategoryTheory.Limits.inl_eq_inr_of_epi_eq
theorem inl_eq_inr_of_epi_eq [Epi f] : (pushout.inl _ _ : _ ⟶ pushout f f) = pushout.inr _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f]
Goal: CategoryTheory.Limits.pushout.inl f f = CategoryTheory.Limits.pushout.inr f f