ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.GradedObject.Monoidal.leftUnitor_naturality
@[reassoc (attr := simp)]
lemma leftUnitor_naturality (φ : X ⟶ X') :
    tensorHom (𝟙 (tensorUnit)) φ ≫ (leftUnitor X').hom =
      (leftUnitor X).hom ≫ φ 
Arguments: {I : Type u} [AddMonoid I] {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] [DecidableEq I] [CategoryTheory.Limits.HasInitial C] [(X₂ : C) →
    CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C)
      ((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj X₂)] {X X' : CategoryTheory.GradedObject I C} (φ : X ⟶ X')
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.GradedObject.Monoidal.tensorHom
      (CategoryTheory.CategoryStruct.id CategoryTheory.GradedObject.Monoidal.tensorUnit) φ)
    (CategoryTheory.GradedObject.Monoidal.leftUnitor X').hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.Monoidal.leftUnitor X).hom φ
-- CategoryTheory.GradedObject.Monoidal.rightUnitor_inv_apply
lemma rightUnitor_inv_apply (i : I) :
    (rightUnitor X).inv i = (ρ_ (X i)).inv ≫ (X i) ◁ tensorUnit₀.inv ≫
      ιTensorObj X tensorUnit i 0 i (add_zero i) 
Arguments: {I : Type u} [AddMonoid I] {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] [DecidableEq I] [CategoryTheory.Limits.HasInitial C] [(X₁ : C) →
    CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C)
      ((CategoryTheory.MonoidalCategory.curriedTensor C).obj X₁)] (X : CategoryTheory.GradedObject I C) (i : I)
Goal: (CategoryTheory.GradedObject.Monoidal.rightUnitor X).inv i =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.rightUnitor (X i)).inv
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.MonoidalCategory.whiskerLeft (X i) CategoryTheory.GradedObject.Monoidal.tensorUnit₀.inv)
      (CategoryTheory.GradedObject.Monoidal.ιTensorObj X CategoryTheory.GradedObject.Monoidal.tensorUnit i 0 i ⋯))
-- CategoryTheory.GradedObject.Monoidal.rightUnitor_naturality
@[reassoc (attr := simp)]
lemma rightUnitor_naturality (φ : X ⟶ X') :
    tensorHom φ (𝟙 (tensorUnit)) ≫ (rightUnitor X').hom =
      (rightUnitor X).hom ≫ φ 
Arguments: {I : Type u} [AddMonoid I] {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] [DecidableEq I] [CategoryTheory.Limits.HasInitial C] [(X₁ : C) →
    CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C)
      ((CategoryTheory.MonoidalCategory.curriedTensor C).obj X₁)] {X X' : CategoryTheory.GradedObject I C} (φ : X ⟶ X')
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.GradedObject.Monoidal.tensorHom φ
      (CategoryTheory.CategoryStruct.id CategoryTheory.GradedObject.Monoidal.tensorUnit))
    (CategoryTheory.GradedObject.Monoidal.rightUnitor X').hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.Monoidal.rightUnitor X).hom φ
-- CategoryTheory.GradedObject.Monoidal.triangle
lemma triangle :
    (associator X₁ tensorUnit X₃).hom ≫ tensorHom (𝟙 X₁) (leftUnitor X₃).hom =
      tensorHom (rightUnitor X₁).hom (𝟙 X₃) 
Arguments: {I : Type u} [AddMonoid I] {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] [DecidableEq I] [CategoryTheory.Limits.HasInitial C] [(X₁ : C) →
    CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C)
      ((CategoryTheory.MonoidalCategory.curriedTensor C).obj X₁)] [(X₂ : C) →
    CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C)
      ((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj X₂)] (X₁ X₃ : CategoryTheory.GradedObject I C) [X₁.HasTensor X₃] [(CategoryTheory.GradedObject.Monoidal.tensorObj X₁ CategoryTheory.GradedObject.Monoidal.tensorUnit).HasTensor X₃] [X₁.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj CategoryTheory.GradedObject.Monoidal.tensorUnit X₃)] [X₁.HasGoodTensor₁₂Tensor CategoryTheory.GradedObject.Monoidal.tensorUnit X₃] [X₁.HasGoodTensorTensor₂₃ CategoryTheory.GradedObject.Monoidal.tensorUnit X₃]
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.GradedObject.Monoidal.associator X₁ CategoryTheory.GradedObject.Monoidal.tensorUnit X₃).hom
    (CategoryTheory.GradedObject.Monoidal.tensorHom (CategoryTheory.CategoryStruct.id X₁)
      (CategoryTheory.GradedObject.Monoidal.leftUnitor X₃).hom) =
  CategoryTheory.GradedObject.Monoidal.tensorHom (CategoryTheory.GradedObject.Monoidal.rightUnitor X₁).hom
    (CategoryTheory.CategoryStruct.id X₃)
-- CategoryTheory.NatTrans.equifibered_of_isIso
theorem NatTrans.equifibered_of_isIso {F G : J ⥤ C} (α : F ⟶ G) [IsIso α] : Equifibered α 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor J C} (α : F ⟶ G) [CategoryTheory.IsIso α]
Goal: CategoryTheory.NatTrans.Equifibered α
-- CategoryTheory.NatTrans.Equifibered.comp
theorem NatTrans.Equifibered.comp {F G H : J ⥤ C} {α : F ⟶ G} {β : G ⟶ H} (hα : Equifibered α)
    (hβ : Equifibered β) : Equifibered (α ≫ β) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G H : CategoryTheory.Functor J C} {α : F ⟶ G} {β : G ⟶ H} (hα : CategoryTheory.NatTrans.Equifibered α) (hβ : CategoryTheory.NatTrans.Equifibered β)
Goal: CategoryTheory.NatTrans.Equifibered (CategoryTheory.CategoryStruct.comp α β)
-- CategoryTheory.NatTrans.Equifibered.whiskerRight
theorem NatTrans.Equifibered.whiskerRight {F G : J ⥤ C} {α : F ⟶ G} (hα : Equifibered α)
    (H : C ⥤ D) [∀ (i j : J) (f : j ⟶ i), PreservesLimit (cospan (α.app i) (G.map f)) H] :
    Equifibered (whiskerRight α H) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] {F G : CategoryTheory.Functor J C} {α : F ⟶ G} (hα : CategoryTheory.NatTrans.Equifibered α) (H : CategoryTheory.Functor C D) [(i j : J) → (f : j ⟶ i) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (α.app i) (G.map f)) H]
Goal: CategoryTheory.NatTrans.Equifibered (CategoryTheory.whiskerRight α H)
-- CategoryTheory.NatTrans.Equifibered.whiskerLeft
theorem NatTrans.Equifibered.whiskerLeft {K : Type*} [Category K]  {F G : J ⥤ C} {α : F ⟶ G}
    (hα : Equifibered α) (H : K ⥤ J) : Equifibered (whiskerLeft H α) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {K : Type u_3} [CategoryTheory.Category.{u_4, u_3} K] {F G : CategoryTheory.Functor J C} {α : F ⟶ G} (hα : CategoryTheory.NatTrans.Equifibered α) (H : CategoryTheory.Functor K J)
Goal: CategoryTheory.NatTrans.Equifibered (CategoryTheory.whiskerLeft H α)
-- CategoryTheory.mapPair_equifibered
theorem mapPair_equifibered {F F' : Discrete WalkingPair ⥤ C} (α : F ⟶ F') :
    NatTrans.Equifibered α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C} (α : F ⟶ F')
Goal: CategoryTheory.NatTrans.Equifibered α
-- CategoryTheory.NatTrans.equifibered_of_discrete
theorem NatTrans.equifibered_of_discrete {ι : Type*} {F G : Discrete ι ⥤ C}
    (α : F ⟶ G) : NatTrans.Equifibered α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type u_3} {F G : CategoryTheory.Functor (CategoryTheory.Discrete ι) C} (α : F ⟶ G)
Goal: CategoryTheory.NatTrans.Equifibered α
-- CategoryTheory.IsVanKampenColimit.isUniversal
theorem IsVanKampenColimit.isUniversal {F : J ⥤ C} {c : Cocone F} (H : IsVanKampenColimit c) :
    IsUniversalColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} (H : CategoryTheory.IsVanKampenColimit c)
Goal: CategoryTheory.IsUniversalColimit c
-- CategoryTheory.IsInitial.isVanKampenColimit
theorem IsInitial.isVanKampenColimit [HasStrictInitialObjects C] {X : C} (h : IsInitial X) :
    IsVanKampenColimit (asEmptyCocone X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {X : C} (h : CategoryTheory.Limits.IsInitial X)
Goal: CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.asEmptyCocone X)
-- CategoryTheory.IsUniversalColimit.of_iso
theorem IsUniversalColimit.of_iso {F : J ⥤ C} {c c' : Cocone F} (hc : IsUniversalColimit c)
    (e : c ≅ c') : IsUniversalColimit c' 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor J C} {c c' : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.IsUniversalColimit c) (e : c ≅ c')
Goal: CategoryTheory.IsUniversalColimit c'
-- CategoryTheory.IsVanKampenColimit.of_iso
theorem IsVanKampenColimit.of_iso {F : J ⥤ C} {c c' : Cocone F} (H : IsVanKampenColimit c)
    (e : c ≅ c') : IsVanKampenColimit c' 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor J C} {c c' : CategoryTheory.Limits.Cocone F} (H : CategoryTheory.IsVanKampenColimit c) (e : c ≅ c')
Goal: CategoryTheory.IsVanKampenColimit c'
-- CategoryTheory.IsVanKampenColimit.precompose_isIso
theorem IsVanKampenColimit.precompose_isIso {F G : J ⥤ C} (α : F ⟶ G) [IsIso α]
    {c : Cocone G} (hc : IsVanKampenColimit c) :
    IsVanKampenColimit ((Cocones.precompose α).obj c) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor J C} (α : F ⟶ G) [CategoryTheory.IsIso α] {c : CategoryTheory.Limits.Cocone G} (hc : CategoryTheory.IsVanKampenColimit c)
Goal: CategoryTheory.IsVanKampenColimit ((CategoryTheory.Limits.Cocones.precompose α).obj c)
-- CategoryTheory.IsUniversalColimit.precompose_isIso
theorem IsUniversalColimit.precompose_isIso {F G : J ⥤ C} (α : F ⟶ G) [IsIso α]
    {c : Cocone G} (hc : IsUniversalColimit c) :
    IsUniversalColimit ((Cocones.precompose α).obj c) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor J C} (α : F ⟶ G) [CategoryTheory.IsIso α] {c : CategoryTheory.Limits.Cocone G} (hc : CategoryTheory.IsUniversalColimit c)
Goal: CategoryTheory.IsUniversalColimit ((CategoryTheory.Limits.Cocones.precompose α).obj c)
-- CategoryTheory.IsVanKampenColimit.precompose_isIso_iff
theorem IsVanKampenColimit.precompose_isIso_iff {F G : J ⥤ C} (α : F ⟶ G) [IsIso α]
    {c : Cocone G} : IsVanKampenColimit ((Cocones.precompose α).obj c) ↔ IsVanKampenColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor J C} (α : F ⟶ G) [CategoryTheory.IsIso α] {c : CategoryTheory.Limits.Cocone G}
Goal: CategoryTheory.IsVanKampenColimit ((CategoryTheory.Limits.Cocones.precompose α).obj c) ↔
  CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.IsUniversalColimit.of_mapCocone
theorem IsUniversalColimit.of_mapCocone (G : C ⥤ D) {F : J ⥤ C} {c : Cocone F}
    [PreservesLimitsOfShape WalkingCospan G] [ReflectsColimitsOfShape J G]
    (hc : IsUniversalColimit (G.mapCocone c)) : IsUniversalColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] (G : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} [CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingCospan G] [CategoryTheory.Limits.ReflectsColimitsOfShape J G] (hc : CategoryTheory.IsUniversalColimit (G.mapCocone c))
Goal: CategoryTheory.IsUniversalColimit c
-- CategoryTheory.IsVanKampenColimit.of_mapCocone
theorem IsVanKampenColimit.of_mapCocone (G : C ⥤ D) {F : J ⥤ C} {c : Cocone F}
    [∀ (i j : J) (X : C) (f : X ⟶ F.obj j) (g : i ⟶ j), PreservesLimit (cospan f (F.map g)) G]
    [∀ (i : J) (X : C) (f : X ⟶ c.pt), PreservesLimit (cospan f (c.ι.app i)) G]
    [ReflectsLimitsOfShape WalkingCospan G]
    [PreservesColimitsOfShape J G]
    [ReflectsColimitsOfShape J G]
    (H : IsVanKampenColimit (G.mapCocone c)) : IsVanKampenColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] (G : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} [(i j : J) →
    (X : C) →
      (f : X ⟶ F.obj j) →
        (g : i ⟶ j) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f (F.map g)) G] [(i : J) →
    (X : C) → (f : X ⟶ c.pt) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f (c.ι.app i)) G] [CategoryTheory.Limits.ReflectsLimitsOfShape CategoryTheory.Limits.WalkingCospan G] [CategoryTheory.Limits.PreservesColimitsOfShape J G] [CategoryTheory.Limits.ReflectsColimitsOfShape J G] (H : CategoryTheory.IsVanKampenColimit (G.mapCocone c))
Goal: CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.IsVanKampenColimit.mapCocone_iff
theorem IsVanKampenColimit.mapCocone_iff (G : C ⥤ D) {F : J ⥤ C} {c : Cocone F}
    [G.IsEquivalence] : IsVanKampenColimit (G.mapCocone c) ↔ IsVanKampenColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] (G : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} [G.IsEquivalence]
Goal: CategoryTheory.IsVanKampenColimit (G.mapCocone c) ↔ CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.IsUniversalColimit.whiskerEquivalence
theorem IsUniversalColimit.whiskerEquivalence {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} (hc : IsUniversalColimit c) :
    IsUniversalColimit (c.whisker e.functor) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {K : Type u_3} [CategoryTheory.Category.{u_4, u_3} K] (e : J ≌ K) {F : CategoryTheory.Functor K C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.IsUniversalColimit c)
Goal: CategoryTheory.IsUniversalColimit (CategoryTheory.Limits.Cocone.whisker e.functor c)
-- CategoryTheory.IsUniversalColimit.whiskerEquivalence_iff
theorem IsUniversalColimit.whiskerEquivalence_iff {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} :
    IsUniversalColimit (c.whisker e.functor) ↔ IsUniversalColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {K : Type u_3} [CategoryTheory.Category.{u_4, u_3} K] (e : J ≌ K) {F : CategoryTheory.Functor K C} {c : CategoryTheory.Limits.Cocone F}
Goal: CategoryTheory.IsUniversalColimit (CategoryTheory.Limits.Cocone.whisker e.functor c) ↔
  CategoryTheory.IsUniversalColimit c
-- CategoryTheory.IsVanKampenColimit.whiskerEquivalence
theorem IsVanKampenColimit.whiskerEquivalence {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} (hc : IsVanKampenColimit c) :
    IsVanKampenColimit (c.whisker e.functor) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {K : Type u_3} [CategoryTheory.Category.{u_4, u_3} K] (e : J ≌ K) {F : CategoryTheory.Functor K C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.IsVanKampenColimit c)
Goal: CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.Cocone.whisker e.functor c)
-- CategoryTheory.IsVanKampenColimit.whiskerEquivalence_iff
theorem IsVanKampenColimit.whiskerEquivalence_iff {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} :
    IsVanKampenColimit (c.whisker e.functor) ↔ IsVanKampenColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {K : Type u_3} [CategoryTheory.Category.{u_4, u_3} K] (e : J ≌ K) {F : CategoryTheory.Functor K C} {c : CategoryTheory.Limits.Cocone F}
Goal: CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.Cocone.whisker e.functor c) ↔
  CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.isVanKampenColimit_of_evaluation
theorem isVanKampenColimit_of_evaluation [HasPullbacks D] [HasColimitsOfShape J D] (F : J ⥤ C ⥤ D)
    (c : Cocone F) (hc : ∀ x : C, IsVanKampenColimit (((evaluation C D).obj x).mapCocone c)) :
    IsVanKampenColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Limits.HasPullbacks D] [CategoryTheory.Limits.HasColimitsOfShape J D] (F : CategoryTheory.Functor J (CategoryTheory.Functor C D)) (c : CategoryTheory.Limits.Cocone F) (hc : ∀ (x : C), CategoryTheory.IsVanKampenColimit (((CategoryTheory.evaluation C D).obj x).mapCocone c))
Goal: CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.IsUniversalColimit.map_reflective
theorem IsUniversalColimit.map_reflective
    {Gl : C ⥤ D} {Gr : D ⥤ C} (adj : Gl ⊣ Gr) [Gr.Full] [Gr.Faithful]
    {F : J ⥤ D} {c : Cocone (F ⋙ Gr)}
    (H : IsUniversalColimit c)
    [∀ X (f : X ⟶ Gl.obj c.pt), HasPullback (Gr.map f) (adj.unit.app c.pt)]
    [∀ X (f : X ⟶ Gl.obj c.pt), PreservesLimit (cospan (Gr.map f) (adj.unit.app c.pt)) Gl] :
    IsUniversalColimit (Gl.mapCocone c) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] {Gl : CategoryTheory.Functor C D} {Gr : CategoryTheory.Functor D C} (adj : Gl ⊣ Gr) [Gr.Full] [Gr.Faithful] {F : CategoryTheory.Functor J D} {c : CategoryTheory.Limits.Cocone (F.comp Gr)} (H : CategoryTheory.IsUniversalColimit c) [∀ (X : D) (f : X ⟶ Gl.obj c.pt), CategoryTheory.Limits.HasPullback (Gr.map f) (adj.unit.app c.pt)] [(X : D) →
    (f : X ⟶ Gl.obj c.pt) →
      CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (Gr.map f) (adj.unit.app c.pt)) Gl]
Goal: CategoryTheory.IsUniversalColimit (Gl.mapCocone c)
-- CategoryTheory.IsVanKampenColimit.map_reflective
theorem IsVanKampenColimit.map_reflective [HasColimitsOfShape J C]
    {Gl : C ⥤ D} {Gr : D ⥤ C} (adj : Gl ⊣ Gr) [Gr.Full] [Gr.Faithful]
    {F : J ⥤ D} {c : Cocone (F ⋙ Gr)} (H : IsVanKampenColimit c)
    [∀ X (f : X ⟶ Gl.obj c.pt), HasPullback (Gr.map f) (adj.unit.app c.pt)]
    [∀ X (f : X ⟶ Gl.obj c.pt), PreservesLimit (cospan (Gr.map f) (adj.unit.app c.pt)) Gl]
    [∀ X i (f : X ⟶ c.pt), PreservesLimit (cospan f (c.ι.app i)) Gl] :
    IsVanKampenColimit (Gl.mapCocone c) 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Limits.HasColimitsOfShape J C] {Gl : CategoryTheory.Functor C D} {Gr : CategoryTheory.Functor D C} (adj : Gl ⊣ Gr) [Gr.Full] [Gr.Faithful] {F : CategoryTheory.Functor J D} {c : CategoryTheory.Limits.Cocone (F.comp Gr)} (H : CategoryTheory.IsVanKampenColimit c) [∀ (X : D) (f : X ⟶ Gl.obj c.pt), CategoryTheory.Limits.HasPullback (Gr.map f) (adj.unit.app c.pt)] [(X : D) →
    (f : X ⟶ Gl.obj c.pt) →
      CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (Gr.map f) (adj.unit.app c.pt)) Gl] [(X : C) →
    (i : J) → (f : X ⟶ c.pt) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f (c.ι.app i)) Gl]
Goal: CategoryTheory.IsVanKampenColimit (Gl.mapCocone c)
-- CategoryTheory.hasStrictInitial_of_isUniversal
theorem hasStrictInitial_of_isUniversal [HasInitial C]
    (H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))) : HasStrictInitialObjects C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasInitial C] (H :
  CategoryTheory.IsUniversalColimit
    (CategoryTheory.Limits.BinaryCofan.mk (CategoryTheory.CategoryStruct.id (⊥_ C))
      (CategoryTheory.CategoryStruct.id (⊥_ C))))
Goal: CategoryTheory.Limits.HasStrictInitialObjects C
-- CategoryTheory.isVanKampenColimit_of_isEmpty
theorem isVanKampenColimit_of_isEmpty [HasStrictInitialObjects C] [IsEmpty J] {F : J ⥤ C}
    (c : Cocone F) (hc : IsColimit c) : IsVanKampenColimit c 
Arguments: {J : Type v'} [CategoryTheory.Category.{u', v'} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] [IsEmpty J] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (hc : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.BinaryCofan.isVanKampen_iff
theorem BinaryCofan.isVanKampen_iff (c : BinaryCofan X Y) :
    IsVanKampenColimit c ↔
      ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt)
        (_ : αX ≫ c.inl = c'.inl ≫ f) (_ : αY ≫ c.inr = c'.inr ≫ f),
        Nonempty (IsColimit c') ↔ IsPullback c'.inl αX f c.inl ∧ IsPullback c'.inr αY f c.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (c : CategoryTheory.Limits.BinaryCofan X Y)
Goal: CategoryTheory.IsVanKampenColimit c ↔
  ∀ {X' Y' : C} (c' : CategoryTheory.Limits.BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
    CategoryTheory.CategoryStruct.comp αX c.inl = CategoryTheory.CategoryStruct.comp c'.inl f →
      CategoryTheory.CategoryStruct.comp αY c.inr = CategoryTheory.CategoryStruct.comp c'.inr f →
        (Nonempty (CategoryTheory.Limits.IsColimit c') ↔
          CategoryTheory.IsPullback c'.inl αX f c.inl ∧ CategoryTheory.IsPullback c'.inr αY f c.inr)
-- CategoryTheory.BinaryCofan.isVanKampen_mk
theorem BinaryCofan.isVanKampen_mk {X Y : C} (c : BinaryCofan X Y)
    (cofans : ∀ X Y : C, BinaryCofan X Y) (colimits : ∀ X Y, IsColimit (cofans X Y))
    (cones : ∀ {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z), PullbackCone f g)
    (limits : ∀ {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z), IsLimit (cones f g))
    (h₁ : ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt)
      (_ : αX ≫ c.inl = (cofans X' Y').inl ≫ f) (_ : αY ≫ c.inr = (cofans X' Y').inr ≫ f),
      IsPullback (cofans X' Y').inl αX f c.inl ∧ IsPullback (cofans X' Y').inr αY f c.inr)
    (h₂ : ∀ {Z : C} (f : Z ⟶ c.pt),
      IsColimit (BinaryCofan.mk (cones f c.inl).fst (cones f c.inr).fst)) :
    IsVanKampenColimit c 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (c : CategoryTheory.Limits.BinaryCofan X Y) (cofans : (X Y : C) → CategoryTheory.Limits.BinaryCofan X Y) (colimits : (X Y : C) → CategoryTheory.Limits.IsColimit (cofans X Y)) (cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.PullbackCone f g) (limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.IsLimit (cones f g)) (h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    CategoryTheory.CategoryStruct.comp αX c.inl = CategoryTheory.CategoryStruct.comp (cofans X' Y').inl f →
      CategoryTheory.CategoryStruct.comp αY c.inr = CategoryTheory.CategoryStruct.comp (cofans X' Y').inr f →
        CategoryTheory.IsPullback (cofans X' Y').inl αX f c.inl ∧
          CategoryTheory.IsPullback (cofans X' Y').inr αY f c.inr) (h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk (cones f c.inl).fst (cones f c.inr).fst))
Goal: CategoryTheory.IsVanKampenColimit c
-- CategoryTheory.BinaryCofan.mono_inr_of_isVanKampen
theorem BinaryCofan.mono_inr_of_isVanKampen [HasInitial C] {X Y : C} {c : BinaryCofan X Y}
    (h : IsVanKampenColimit c) : Mono c.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasInitial C] {X Y : C} {c : CategoryTheory.Limits.BinaryCofan X Y} (h : CategoryTheory.IsVanKampenColimit c)
Goal: CategoryTheory.Mono c.inr