ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.IsSplitCoequalizer.map_rightSection
@[simps]
def IsSplitCoequalizer.map {Z : C} {π : Y ⟶ Z} (q : IsSplitCoequalizer f g π) (F : C ⥤ D) :
    IsSplitCoequalizer (F.map f) (F.map g) (F.map π) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D)
Goal: (q.map F).rightSection = F.map q.rightSection
-- CategoryTheory.IsSplitCoequalizer.asCofork_pt
@[simps! pt]
def IsSplitCoequalizer.asCofork {Z : C} {h : Y ⟶ Z} (t : IsSplitCoequalizer f g h) :
    Cofork f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {h : Y ⟶ Z} (t : CategoryTheory.IsSplitCoequalizer f g h)
Goal: t.asCofork.pt = Z
-- CategoryTheory.IsSplitCoequalizer.asCofork_π
@[simp]
theorem IsSplitCoequalizer.asCofork_π {Z : C} {h : Y ⟶ Z} (t : IsSplitCoequalizer f g h) :
    t.asCofork.π = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {h : Y ⟶ Z} (t : CategoryTheory.IsSplitCoequalizer f g h)
Goal: t.asCofork.π = h
-- CategoryTheory.HasSplitCoequalizer.splittable
class HasSplitCoequalizer : Prop where
    splittable : ∃ (Z : C) (h : Y ⟶ Z), Nonempty (IsSplitCoequalizer f g h)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [self : CategoryTheory.HasSplitCoequalizer f g]
Goal: ∃ Z h, Nonempty (CategoryTheory.IsSplitCoequalizer f g h)
-- CategoryTheory.Limits.DiagramOfCones.id
structure DiagramOfCones where
    obj : ∀ j : J, Cone (F.obj j)
    map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (self : CategoryTheory.Limits.DiagramOfCones F) (j : J)
Goal: (self.map (𝟙 j)).hom = 𝟙 ((CategoryTheory.Limits.Cones.postcompose (F.map (𝟙 j))).obj (self.obj j)).pt
-- CategoryTheory.Limits.DiagramOfCones.comp
structure DiagramOfCones where
    obj : ∀ j : J, Cone (F.obj j)
    map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (self : CategoryTheory.Limits.DiagramOfCones F) {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃)
Goal: (self.map (f ≫ g)).hom = (self.map f).hom ≫ (self.map g).hom
-- CategoryTheory.Limits.DiagramOfCocones.comp
structure DiagramOfCocones where
    obj : ∀ j : J, Cocone (F.obj j)
    map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (self : CategoryTheory.Limits.DiagramOfCocones F) {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃)
Goal: (self.map (f ≫ g)).hom = (self.map f).hom ≫ (self.map g).hom
-- CategoryTheory.Limits.DiagramOfCocones.id
structure DiagramOfCocones where
    obj : ∀ j : J, Cocone (F.obj j)
    map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (self : CategoryTheory.Limits.DiagramOfCocones F) (j : J)
Goal: (self.map (𝟙 j)).hom = 𝟙 (self.obj j).pt
-- CategoryTheory.Limits.DiagramOfCones.conePoints_map
@[simps]
def DiagramOfCones.conePoints (D : DiagramOfCones F) : J ⥤ C 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (D : CategoryTheory.Limits.DiagramOfCones F)
Goal: ∀ {X Y : J} (f : X ⟶ Y), D.conePoints.map f = (D.map f).hom
-- CategoryTheory.Limits.DiagramOfCones.conePoints_obj
@[simps]
def DiagramOfCones.conePoints (D : DiagramOfCones F) : J ⥤ C 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (D : CategoryTheory.Limits.DiagramOfCones F) (j : J)
Goal: D.conePoints.obj j = (D.obj j).pt
-- CategoryTheory.Limits.DiagramOfCocones.coconePoints_obj
@[simps]
def DiagramOfCocones.coconePoints (D : DiagramOfCocones F) : J ⥤ C 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (D : CategoryTheory.Limits.DiagramOfCocones F) (j : J)
Goal: D.coconePoints.obj j = (D.obj j).pt
-- CategoryTheory.Limits.DiagramOfCocones.coconePoints_map
@[simps]
def DiagramOfCocones.coconePoints (D : DiagramOfCocones F) : J ⥤ C 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} (D : CategoryTheory.Limits.DiagramOfCocones F)
Goal: ∀ {X Y : J} (f : X ⟶ Y), D.coconePoints.map f = (D.map f).hom
-- CategoryTheory.Limits.coneOfConeUncurry_pt
@[simps]
def coneOfConeUncurry {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    (c : Cone (uncurry.obj F)) : Cone D.conePoints 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} {D : CategoryTheory.Limits.DiagramOfCones F} (Q : (j : J) → CategoryTheory.Limits.IsLimit (D.obj j)) (c : CategoryTheory.Limits.Cone (CategoryTheory.uncurry.obj F))
Goal: (CategoryTheory.Limits.coneOfConeUncurry Q c).pt = c.pt
-- CategoryTheory.Limits.coneOfConeUncurry_π_app
@[simps]
def coneOfConeUncurry {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    (c : Cone (uncurry.obj F)) : Cone D.conePoints 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} {D : CategoryTheory.Limits.DiagramOfCones F} (Q : (j : J) → CategoryTheory.Limits.IsLimit (D.obj j)) (c : CategoryTheory.Limits.Cone (CategoryTheory.uncurry.obj F)) (j : J)
Goal: (CategoryTheory.Limits.coneOfConeUncurry Q c).π.app j =
  (Q j).lift { pt := c.pt, π := { app := fun k => c.π.app (j, k), naturality := ⋯ } }
-- CategoryTheory.Limits.coconeOfCoconeUncurry_pt
@[simps]
def coconeOfCoconeUncurry {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    (c : Cocone (uncurry.obj F)) : Cocone D.coconePoints 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} {D : CategoryTheory.Limits.DiagramOfCocones F} (Q : (j : J) → CategoryTheory.Limits.IsColimit (D.obj j)) (c : CategoryTheory.Limits.Cocone (CategoryTheory.uncurry.obj F))
Goal: (CategoryTheory.Limits.coconeOfCoconeUncurry Q c).pt = c.pt
-- CategoryTheory.Limits.coconeOfCoconeUncurry_ι_app
@[simps]
def coconeOfCoconeUncurry {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    (c : Cocone (uncurry.obj F)) : Cocone D.coconePoints 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ K ⥤ C} {D : CategoryTheory.Limits.DiagramOfCocones F} (Q : (j : J) → CategoryTheory.Limits.IsColimit (D.obj j)) (c : CategoryTheory.Limits.Cocone (CategoryTheory.uncurry.obj F)) (j : J)
Goal: (CategoryTheory.Limits.coconeOfCoconeUncurry Q c).ι.app j =
  (Q j).desc { pt := c.pt, ι := { app := fun k => c.ι.app (j, k), naturality := ⋯ } }
-- CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits_obj
@[simps]
noncomputable def DiagramOfCones.mkOfHasLimits : DiagramOfCones F 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C] (j : J)
Goal: (CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits F).obj j = CategoryTheory.Limits.limit.cone (F.obj j)
-- CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits_map_hom
@[simps]
noncomputable def DiagramOfCones.mkOfHasLimits : DiagramOfCones F 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C]
Goal: ∀ {j j' : J} (f : j ⟶ j'),
  ((CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits F).map f).hom = CategoryTheory.Limits.lim.map (F.map f)
-- CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits_conePoints
@[simp]
theorem DiagramOfCones.mkOfHasLimits_conePoints :
    (DiagramOfCones.mkOfHasLimits F).conePoints = F ⋙ lim 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C]
Goal: (CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits F).conePoints = F ⋙ CategoryTheory.Limits.lim
-- CategoryTheory.Limits.limitUncurryIsoLimitCompLim_hom_π_π
@[simp, reassoc]
theorem limitUncurryIsoLimitCompLim_hom_π_π {j} {k} :
    (limitUncurryIsoLimitCompLim F).hom ≫ limit.π _ j ≫ limit.π _ k = limit.π _ (j, k) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C] [CategoryTheory.Limits.HasLimit (CategoryTheory.uncurry.obj F)] [CategoryTheory.Limits.HasLimit (F ⋙ CategoryTheory.Limits.lim)] {j : J} {k : K}
Goal: (CategoryTheory.Limits.limitUncurryIsoLimitCompLim F).hom ≫
    CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k =
  CategoryTheory.Limits.limit.π (CategoryTheory.uncurry.obj F) (j, k)
-- CategoryTheory.Limits.limitUncurryIsoLimitCompLim_inv_π
@[simp, reassoc]
theorem limitUncurryIsoLimitCompLim_inv_π {j} {k} :
    (limitUncurryIsoLimitCompLim F).inv ≫ limit.π _ (j, k) =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C] [CategoryTheory.Limits.HasLimit (CategoryTheory.uncurry.obj F)] [CategoryTheory.Limits.HasLimit (F ⋙ CategoryTheory.Limits.lim)] {j : J} {k : K}
Goal: (CategoryTheory.Limits.limitUncurryIsoLimitCompLim F).inv ≫
    CategoryTheory.Limits.limit.π (CategoryTheory.uncurry.obj F) (j, k) =
  CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k
-- CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits_map_hom
@[simps]
noncomputable def DiagramOfCocones.mkOfHasColimits : DiagramOfCocones F 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C]
Goal: ∀ {j j' : J} (f : j ⟶ j'),
  ((CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits F).map f).hom = CategoryTheory.Limits.colim.map (F.map f)
-- CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits_obj
@[simps]
noncomputable def DiagramOfCocones.mkOfHasColimits : DiagramOfCocones F 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C] (j : J)
Goal: (CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits F).obj j = CategoryTheory.Limits.colimit.cocone (F.obj j)
-- CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits_coconePoints
@[simp]
theorem DiagramOfCocones.mkOfHasColimits_coconePoints :
    (DiagramOfCocones.mkOfHasColimits F).coconePoints = F ⋙ colim 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C]
Goal: (CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits F).coconePoints = F ⋙ CategoryTheory.Limits.colim
-- CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_ι_inv
@[simp, reassoc]
theorem colimitUncurryIsoColimitCompColim_ι_ι_inv {j} {k} :
    colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j ≫ (colimitUncurryIsoColimitCompColim F).inv =
      colimit.ι (uncurry.obj F) (j, k) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.HasColimit (CategoryTheory.uncurry.obj F)] [CategoryTheory.Limits.HasColimit (F ⋙ CategoryTheory.Limits.colim)] {j : J} {k : K}
Goal: CategoryTheory.Limits.colimit.ι (F.obj j) k ≫
    CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitUncurryIsoColimitCompColim F).inv =
  CategoryTheory.Limits.colimit.ι (CategoryTheory.uncurry.obj F) (j, k)
-- CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_hom
@[simp, reassoc]
theorem colimitUncurryIsoColimitCompColim_ι_hom {j} {k} :
    colimit.ι _ (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom =
      (colimit.ι _ k ≫ colimit.ι (F ⋙ colim) j : _ ⟶ (colimit (F ⋙ colim))) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.HasColimit (CategoryTheory.uncurry.obj F)] [CategoryTheory.Limits.HasColimit (F ⋙ CategoryTheory.Limits.colim)] {j : J} {k : K}
Goal: CategoryTheory.Limits.colimit.ι (CategoryTheory.uncurry.obj F) (j, k) ≫
    (CategoryTheory.Limits.colimitUncurryIsoColimitCompColim F).hom =
  CategoryTheory.Limits.colimit.ι (F.obj j) k ≫ CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j
-- CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_hom_π_π
@[simp, reassoc]
theorem limitFlipCompLimIsoLimitCompLim_hom_π_π (j) (k) :
    (limitFlipCompLimIsoLimitCompLim F).hom ≫ limit.π _ j ≫ limit.π _ k =
      (limit.π _ k ≫ limit.π _ j : limit (_ ⋙ lim) ⟶ _) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.Limits.HasLimitsOfShape K C] [CategoryTheory.Limits.HasLimitsOfShape (J × K) C] [CategoryTheory.Limits.HasLimitsOfShape (K × J) C] (j : J) (k : K)
Goal: (CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim F).hom ≫
    CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k =
  CategoryTheory.Limits.limit.π (F.flip ⋙ CategoryTheory.Limits.lim) k ≫ CategoryTheory.Limits.limit.π (F.flip.obj k) j
-- CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_inv_π_π
@[simp, reassoc]
theorem limitFlipCompLimIsoLimitCompLim_inv_π_π (k) (j) :
    (limitFlipCompLimIsoLimitCompLim F).inv ≫ limit.π _ k ≫ limit.π _ j =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.Limits.HasLimitsOfShape K C] [CategoryTheory.Limits.HasLimitsOfShape (J × K) C] [CategoryTheory.Limits.HasLimitsOfShape (K × J) C] (k : K) (j : J)
Goal: (CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim F).inv ≫
    CategoryTheory.Limits.limit.π (F.flip ⋙ CategoryTheory.Limits.lim) k ≫
      CategoryTheory.Limits.limit.π (F.flip.obj k) j =
  CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k
-- CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim_ι_ι_hom
@[simp, reassoc]
theorem colimitFlipCompColimIsoColimitCompColim_ι_ι_hom (j) (k) :
    colimit.ι (F.flip.obj k) j ≫ colimit.ι (F.flip ⋙ colim) k ≫
      (colimitFlipCompColimIsoColimitCompColim F).hom =
        (colimit.ι _ k ≫ colimit.ι (F ⋙ colim) j : _ ⟶ colimit (F⋙ colim)) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape J C] [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.HasColimitsOfShape (J × K) C] [CategoryTheory.Limits.HasColimitsOfShape (K × J) C] (j : J) (k : K)
Goal: CategoryTheory.Limits.colimit.ι (F.flip.obj k) j ≫
    CategoryTheory.Limits.colimit.ι (F.flip ⋙ CategoryTheory.Limits.colim) k ≫
      (CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim F).hom =
  CategoryTheory.Limits.colimit.ι (F.obj j) k ≫ CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j
-- CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim_ι_ι_inv
@[simp, reassoc]
theorem colimitFlipCompColimIsoColimitCompColim_ι_ι_inv (k) (j) :
    colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j ≫
      (colimitFlipCompColimIsoColimitCompColim F).inv =
        (colimit.ι _ j ≫ colimit.ι (F.flip ⋙ colim) k : _ ⟶ colimit (F.flip ⋙ colim)) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape J C] [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.HasColimitsOfShape (J × K) C] [CategoryTheory.Limits.HasColimitsOfShape (K × J) C] (k : K) (j : J)
Goal: CategoryTheory.Limits.colimit.ι (F.obj j) k ≫
    CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim F).inv =
  CategoryTheory.Limits.colimit.ι (F.flip.obj k) j ≫
    CategoryTheory.Limits.colimit.ι (F.flip ⋙ CategoryTheory.Limits.colim) k
-- CategoryTheory.Limits.limitIsoLimitCurryCompLim_hom_π_π
@[simp, reassoc]
theorem limitIsoLimitCurryCompLim_hom_π_π {j} {k} :
    (limitIsoLimitCurryCompLim G).hom ≫ limit.π _ j ≫ limit.π _ k = limit.π _ (j, k) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C] [CategoryTheory.Limits.HasLimit G] [CategoryTheory.Limits.HasLimit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim)] {j : J} {k : K}
Goal: (CategoryTheory.Limits.limitIsoLimitCurryCompLim G).hom ≫
    CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
      CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k =
  CategoryTheory.Limits.limit.π G (j, k)
-- CategoryTheory.Limits.limitIsoLimitCurryCompLim_inv_π
@[simp, reassoc]
theorem limitIsoLimitCurryCompLim_inv_π {j} {k} :
    (limitIsoLimitCurryCompLim G).inv ≫ limit.π _ (j, k) =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasLimitsOfShape K C] [CategoryTheory.Limits.HasLimit G] [CategoryTheory.Limits.HasLimit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim)] {j : J} {k : K}
Goal: (CategoryTheory.Limits.limitIsoLimitCurryCompLim G).inv ≫ CategoryTheory.Limits.limit.π G (j, k) =
  CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k
-- CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_ι_inv
@[simp, reassoc]
theorem colimitIsoColimitCurryCompColim_ι_ι_inv {j} {k} :
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j ≫
      (colimitIsoColimitCurryCompColim G).inv  = colimit.ι _ (j, k) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.HasColimit G] [CategoryTheory.Limits.HasColimit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim)] {j : J} {k : K}
Goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitIsoColimitCurryCompColim G).inv =
  CategoryTheory.Limits.colimit.ι G (j, k)
-- CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_hom
@[simp, reassoc]
theorem colimitIsoColimitCurryCompColim_ι_hom {j} {k} :
    colimit.ι _ (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom =
      (colimit.ι (_) k ≫ colimit.ι (curry.obj G ⋙ colim) j : _ ⟶ colimit (_ ⋙ colim)) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.HasColimit G] [CategoryTheory.Limits.HasColimit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim)] {j : J} {k : K}
Goal: CategoryTheory.Limits.colimit.ι G (j, k) ≫ (CategoryTheory.Limits.colimitIsoColimitCurryCompColim G).hom =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j
-- CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim_hom_π_π
@[simp]
theorem limitCurrySwapCompLimIsoLimitCurryCompLim_hom_π_π {j} {k} :
    (limitCurrySwapCompLimIsoLimitCurryCompLim G).hom ≫ limit.π _ j ≫ limit.π _ k =
      (limit.π _ k ≫ limit.π _ j : limit (_ ⋙ lim) ⟶ _) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasLimits C] {j : J} {k : K}
Goal: (CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim G).hom ≫
    CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
      CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k =
  CategoryTheory.Limits.limit.π
      (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.lim) k ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j
-- CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim_inv_π_π
@[simp]
theorem limitCurrySwapCompLimIsoLimitCurryCompLim_inv_π_π {j} {k} :
    (limitCurrySwapCompLimIsoLimitCurryCompLim G).inv ≫ limit.π _ k ≫ limit.π _ j =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasLimits C] {j : J} {k : K}
Goal: (CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim G).inv ≫
    CategoryTheory.Limits.limit.π
        (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.lim) k ≫
      CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j =
  CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k