ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Over.ConstructProducts.conesEquivFunctor_map_hom
@[simps]
def conesEquivFunctor (B : C) {J : Type w} (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ⥤ Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B)
Goal: ∀ {X Y : CategoryTheory.Limits.Cone (CategoryTheory.Over.ConstructProducts.widePullbackDiagramOfDiagramOver B F)}
  (f : X ⟶ Y),
  ((CategoryTheory.Over.ConstructProducts.conesEquivFunctor B F).map f).hom = CategoryTheory.Over.homMk f.hom ⋯
-- CategoryTheory.Over.ConstructProducts.conesEquiv_functor
@[simps]
def conesEquiv (B : C) (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ≌ Cone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquiv B F).functor =
  CategoryTheory.Over.ConstructProducts.conesEquivFunctor B F
-- CategoryTheory.Over.ConstructProducts.conesEquiv_unitIso
@[simps]
def conesEquiv (B : C) (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ≌ Cone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquiv B F).unitIso =
  CategoryTheory.Over.ConstructProducts.conesEquivUnitIso B F
-- CategoryTheory.Over.ConstructProducts.conesEquiv_inverse
@[simps]
def conesEquiv (B : C) (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ≌ Cone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquiv B F).inverse =
  CategoryTheory.Over.ConstructProducts.conesEquivInverse B F
-- CategoryTheory.Over.ConstructProducts.conesEquiv_counitIso
@[simps]
def conesEquiv (B : C) (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ≌ Cone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquiv B F).counitIso =
  CategoryTheory.Over.ConstructProducts.conesEquivCounitIso B F
-- CategoryTheory.Over.ConstructProducts.has_over_limit_discrete_of_widePullback_limit
theorem has_over_limit_discrete_of_widePullback_limit {B : C} (F : Discrete J ⥤ Over B)
    [HasLimit (widePullbackDiagramOfDiagramOver B F)] : HasLimit F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B) [CategoryTheory.Limits.HasLimit (CategoryTheory.Over.ConstructProducts.widePullbackDiagramOfDiagramOver B F)]
Goal: CategoryTheory.Limits.HasLimit F
-- CategoryTheory.Over.ConstructProducts.over_product_of_widePullback
theorem over_product_of_widePullback [HasLimitsOfShape (WidePullbackShape J) C] {B : C} :
    HasLimitsOfShape (Discrete J) (Over B) 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C] {B : C}
Goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) (CategoryTheory.Over B)
-- CategoryTheory.Over.ConstructProducts.over_binaryProduct_of_pullback
theorem over_binaryProduct_of_pullback [HasPullbacks C] {B : C} : HasBinaryProducts (Over B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {B : C}
Goal: CategoryTheory.Limits.HasBinaryProducts (CategoryTheory.Over B)
-- CategoryTheory.Over.ConstructProducts.over_products_of_widePullbacks
theorem over_products_of_widePullbacks [HasWidePullbacks.{w} C] {B : C} :
    HasProducts.{w} (Over B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasWidePullbacks C] {B : C}
Goal: CategoryTheory.Limits.HasProducts (CategoryTheory.Over B)
-- CategoryTheory.Over.ConstructProducts.over_finiteProducts_of_finiteWidePullbacks
theorem over_finiteProducts_of_finiteWidePullbacks [HasFiniteWidePullbacks C] {B : C} :
    HasFiniteProducts (Over B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteWidePullbacks C] {B : C}
Goal: CategoryTheory.Limits.HasFiniteProducts (CategoryTheory.Over B)
-- CategoryTheory.Over.over_hasTerminal
theorem over_hasTerminal (B : C) : HasTerminal (Over B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C)
Goal: CategoryTheory.Limits.HasTerminal (CategoryTheory.Over B)
-- CategoryTheory.StrongEpi.llp
class StrongEpi (f : P ⟶ Q) : Prop where
    epi : Epi f
    llp : ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [Mono z], HasLiftingProperty f z
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q} [self : CategoryTheory.StrongEpi f] ⦃X Y : C⦄ (z : X ⟶ Y) [CategoryTheory.Mono z]
Goal: CategoryTheory.HasLiftingProperty f z
-- CategoryTheory.StrongEpi.epi
class StrongEpi (f : P ⟶ Q) : Prop where
    epi : Epi f
    llp : ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [Mono z], HasLiftingProperty f z
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q} [self : CategoryTheory.StrongEpi f]
Goal: CategoryTheory.Epi f
-- CategoryTheory.StrongEpi.mk'
theorem StrongEpi.mk' {f : P ⟶ Q} [Epi f]
    (hf : ∀ (X Y : C) (z : X ⟶ Y)
      (_ : Mono z) (u : P ⟶ X) (v : Q ⟶ Y) (sq : CommSq u f z v), sq.HasLift) :
    StrongEpi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q} [CategoryTheory.Epi f] (hf :
  ∀ (X Y : C) (z : X ⟶ Y),
    CategoryTheory.Mono z → ∀ (u : P ⟶ X) (v : Q ⟶ Y) (sq : CategoryTheory.CommSq u f z v), sq.HasLift)
Goal: CategoryTheory.StrongEpi f
-- CategoryTheory.StrongMono.mono
class StrongMono (f : P ⟶ Q) : Prop where
    mono : Mono f
    rlp : ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [Epi z], HasLiftingProperty z f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q} [self : CategoryTheory.StrongMono f]
Goal: CategoryTheory.Mono f
-- CategoryTheory.StrongMono.rlp
class StrongMono (f : P ⟶ Q) : Prop where
    mono : Mono f
    rlp : ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [Epi z], HasLiftingProperty z f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q} [self : CategoryTheory.StrongMono f] ⦃X Y : C⦄ (z : X ⟶ Y) [CategoryTheory.Epi z]
Goal: CategoryTheory.HasLiftingProperty z f
-- CategoryTheory.StrongMono.mk'
theorem StrongMono.mk' {f : P ⟶ Q} [Mono f]
    (hf : ∀ (X Y : C) (z : X ⟶ Y) (_ : Epi z) (u : X ⟶ P)
      (v : Y ⟶ Q) (sq : CommSq u z f v), sq.HasLift) : StrongMono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q} [CategoryTheory.Mono f] (hf :
  ∀ (X Y : C) (z : X ⟶ Y),
    CategoryTheory.Epi z → ∀ (u : X ⟶ P) (v : Y ⟶ Q) (sq : CategoryTheory.CommSq u z f v), sq.HasLift)
Goal: CategoryTheory.StrongMono f
-- CategoryTheory.strongEpi_comp
theorem strongEpi_comp [StrongEpi f] [StrongEpi g] : StrongEpi (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) [CategoryTheory.StrongEpi f] [CategoryTheory.StrongEpi g]
Goal: CategoryTheory.StrongEpi (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.strongMono_comp
theorem strongMono_comp [StrongMono f] [StrongMono g] : StrongMono (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) [CategoryTheory.StrongMono f] [CategoryTheory.StrongMono g]
Goal: CategoryTheory.StrongMono (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.strongEpi_of_strongEpi
theorem strongEpi_of_strongEpi [StrongEpi (f ≫ g)] : StrongEpi g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) [CategoryTheory.StrongEpi (CategoryTheory.CategoryStruct.comp f g)]
Goal: CategoryTheory.StrongEpi g
-- CategoryTheory.strongMono_of_strongMono
theorem strongMono_of_strongMono [StrongMono (f ≫ g)] : StrongMono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) [CategoryTheory.StrongMono (CategoryTheory.CategoryStruct.comp f g)]
Goal: CategoryTheory.StrongMono f
-- CategoryTheory.StrongEpi.of_arrow_iso
theorem StrongEpi.of_arrow_iso {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
    (e : Arrow.mk f ≅ Arrow.mk g) [h : StrongEpi f] : StrongEpi g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g) [h : CategoryTheory.StrongEpi f]
Goal: CategoryTheory.StrongEpi g
-- CategoryTheory.StrongMono.of_arrow_iso
theorem StrongMono.of_arrow_iso {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
    (e : Arrow.mk f ≅ Arrow.mk g) [h : StrongMono f] : StrongMono g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g) [h : CategoryTheory.StrongMono f]
Goal: CategoryTheory.StrongMono g
-- CategoryTheory.StrongEpi.iff_of_arrow_iso
theorem StrongEpi.iff_of_arrow_iso {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
    (e : Arrow.mk f ≅ Arrow.mk g) : StrongEpi f ↔ StrongEpi g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g)
Goal: CategoryTheory.StrongEpi f ↔ CategoryTheory.StrongEpi g
-- CategoryTheory.StrongMono.iff_of_arrow_iso
theorem StrongMono.iff_of_arrow_iso {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
    (e : Arrow.mk f ≅ Arrow.mk g) : StrongMono f ↔ StrongMono g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g)
Goal: CategoryTheory.StrongMono f ↔ CategoryTheory.StrongMono g
-- CategoryTheory.isIso_of_mono_of_strongEpi
theorem isIso_of_mono_of_strongEpi (f : P ⟶ Q) [Mono f] [StrongEpi f] : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} (f : P ⟶ Q) [CategoryTheory.Mono f] [CategoryTheory.StrongEpi f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isIso_of_epi_of_strongMono
theorem isIso_of_epi_of_strongMono (f : P ⟶ Q) [Epi f] [StrongMono f] : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} (f : P ⟶ Q) [CategoryTheory.Epi f] [CategoryTheory.StrongMono f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.StrongEpiCategory.strongEpi_of_epi
class StrongEpiCategory : Prop where
    strongEpi_of_epi : ∀ {X Y : C} (f : X ⟶ Y) [Epi f], StrongEpi f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.StrongEpiCategory C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f]
Goal: CategoryTheory.StrongEpi f
-- CategoryTheory.StrongMonoCategory.strongMono_of_mono
class StrongMonoCategory : Prop where
    strongMono_of_mono : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], StrongMono f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.StrongMonoCategory C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.StrongMono f
-- CategoryTheory.strongEpi_of_epi
theorem strongEpi_of_epi [StrongEpiCategory C] (f : P ⟶ Q) [Epi f] : StrongEpi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} [CategoryTheory.StrongEpiCategory C] (f : P ⟶ Q) [CategoryTheory.Epi f]
Goal: CategoryTheory.StrongEpi f
-- CategoryTheory.strongMono_of_mono
theorem strongMono_of_mono [StrongMonoCategory C] (f : P ⟶ Q) [Mono f] : StrongMono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} [CategoryTheory.StrongMonoCategory C] (f : P ⟶ Q) [CategoryTheory.Mono f]
Goal: CategoryTheory.StrongMono f
-- CategoryTheory.Limits.HasLimit.exists_limit
class HasLimit (F : J ⥤ C) : Prop where mk' ::
    exists_limit : Nonempty (LimitCone F)
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [self : CategoryTheory.Limits.HasLimit F]
Goal: Nonempty (CategoryTheory.Limits.LimitCone F)
-- CategoryTheory.Limits.HasLimit.mk
theorem HasLimit.mk {F : J ⥤ C} (d : LimitCone F) : HasLimit F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} (d : CategoryTheory.Limits.LimitCone F)
Goal: CategoryTheory.Limits.HasLimit F
-- CategoryTheory.Limits.HasLimitsOfShape.has_limit
class HasLimitsOfShape : Prop where
    has_limit : ∀ F : J ⥤ C, HasLimit F := by infer_instance
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ C)
Goal: CategoryTheory.Limits.HasLimit F
-- CategoryTheory.Limits.HasLimitsOfSize.has_limits_of_shape
@[pp_with_univ]
class HasLimitsOfSize (C : Type u) [Category.{v} C] : Prop where
    has_limits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasLimitsOfShape J C := by
    infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasLimitsOfSize.{v₁, u₁, v, u} C] (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J]
Goal: CategoryTheory.Limits.HasLimitsOfShape J C
-- CategoryTheory.Limits.HasLimits.has_limits_of_shape
theorem HasLimits.has_limits_of_shape {C : Type u} [Category.{v} C] [HasLimits C] (J : Type v)
    [Category.{v} J] : HasLimitsOfShape J C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimits C] (J : Type v) [CategoryTheory.Category.{v, v} J]
Goal: CategoryTheory.Limits.HasLimitsOfShape J C
-- CategoryTheory.Limits.limit.cone_x
@[simp]
theorem limit.cone_x {F : J ⥤ C} [HasLimit F] : (limit.cone F).pt = limit F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F]
Goal: (CategoryTheory.Limits.limit.cone F).pt = CategoryTheory.Limits.limit F
-- CategoryTheory.Limits.limit.cone_π
@[simp]
theorem limit.cone_π {F : J ⥤ C} [HasLimit F] : (limit.cone F).π.app = limit.π _ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F]
Goal: (CategoryTheory.Limits.limit.cone F).π.app = CategoryTheory.Limits.limit.π F
-- CategoryTheory.Limits.limit.w
@[reassoc (attr := simp)]
theorem limit.w (F : J ⥤ C) [HasLimit F] {j j' : J} (f : j ⟶ j') :
    limit.π F j ≫ F.map f = limit.π F j' 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] {j j' : J} (f : j ⟶ j')
Goal: CategoryTheory.Limits.limit.π F j ≫ F.map f = CategoryTheory.Limits.limit.π F j'
-- CategoryTheory.Limits.limit.isLimit_lift
@[simp]
theorem limit.isLimit_lift {F : J ⥤ C} [HasLimit F] (c : Cone F) :
    (limit.isLimit F).lift c = limit.lift F c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.limit.isLimit F).lift c = CategoryTheory.Limits.limit.lift F c
-- CategoryTheory.Limits.limit.lift_π
@[reassoc (attr := simp)]
theorem limit.lift_π {F : J ⥤ C} [HasLimit F] (c : Cone F) (j : J) :
    limit.lift F c ≫ limit.π F j = 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.HasLimit F] (c : CategoryTheory.Limits.Cone F) (j : J)
Goal: CategoryTheory.Limits.limit.lift F c ≫ CategoryTheory.Limits.limit.π F j = c.π.app j
-- CategoryTheory.Limits.limMap_π
@[reassoc (attr := simp)]
theorem limMap_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (α : F ⟶ G) (j : J) :
    limMap α ≫ limit.π G j = limit.π F j ≫ α.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] (α : F ⟶ G) (j : J)
Goal: CategoryTheory.Limits.limMap α ≫ CategoryTheory.Limits.limit.π G j = CategoryTheory.Limits.limit.π F j ≫ α.app j
-- CategoryTheory.Limits.limit.coneMorphism_hom
@[simp]
theorem limit.coneMorphism_hom {F : J ⥤ C} [HasLimit F] (c : Cone F) :
    (limit.coneMorphism c).hom = limit.lift F c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.limit.coneMorphism c).hom = CategoryTheory.Limits.limit.lift F c
-- CategoryTheory.Limits.limit.coneMorphism_π
theorem limit.coneMorphism_π {F : J ⥤ C} [HasLimit F] (c : Cone F) (j : J) :
    (limit.coneMorphism c).hom ≫ limit.π F j = 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.HasLimit F] (c : CategoryTheory.Limits.Cone F) (j : J)
Goal: (CategoryTheory.Limits.limit.coneMorphism c).hom ≫ CategoryTheory.Limits.limit.π F j = c.π.app j
-- CategoryTheory.Limits.limit.conePointUniqueUpToIso_hom_comp
@[reassoc (attr := simp)]
theorem limit.conePointUniqueUpToIso_hom_comp {F : J ⥤ C} [HasLimit F] {c : Cone F} (hc : IsLimit c)
    (j : J) : (IsLimit.conePointUniqueUpToIso hc (limit.isLimit _)).hom ≫ limit.π F j = 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.HasLimit F] {c : CategoryTheory.Limits.Cone F} (hc : CategoryTheory.Limits.IsLimit c) (j : J)
Goal: (hc.conePointUniqueUpToIso (CategoryTheory.Limits.limit.isLimit F)).hom ≫ CategoryTheory.Limits.limit.π F j = c.π.app j
-- CategoryTheory.Limits.limit.conePointUniqueUpToIso_inv_comp
@[reassoc (attr := simp)]
theorem limit.conePointUniqueUpToIso_inv_comp {F : J ⥤ C} [HasLimit F] {c : Cone F} (hc : IsLimit c)
    (j : J) : (IsLimit.conePointUniqueUpToIso (limit.isLimit _) hc).inv ≫ limit.π F j = 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.HasLimit F] {c : CategoryTheory.Limits.Cone F} (hc : CategoryTheory.Limits.IsLimit c) (j : J)
Goal: ((CategoryTheory.Limits.limit.isLimit F).conePointUniqueUpToIso hc).inv ≫ CategoryTheory.Limits.limit.π F j = c.π.app j
-- CategoryTheory.Limits.limit.existsUnique
theorem limit.existsUnique {F : J ⥤ C} [HasLimit F] (t : Cone F) :
    ∃! l : t.pt ⟶ limit F, ∀ j, l ≫ limit.π F j = 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.HasLimit F] (t : CategoryTheory.Limits.Cone F)
Goal: ∃! l, ∀ (j : J), l ≫ CategoryTheory.Limits.limit.π F j = t.π.app j
-- CategoryTheory.Limits.limit.isoLimitCone_hom_π
@[reassoc (attr := simp)]
theorem limit.isoLimitCone_hom_π {F : J ⥤ C} [HasLimit F] (t : LimitCone F) (j : J) :
    (limit.isoLimitCone t).hom ≫ t.cone.π.app j = limit.π F j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] (t : CategoryTheory.Limits.LimitCone F) (j : J)
Goal: (CategoryTheory.Limits.limit.isoLimitCone t).hom ≫ t.cone.π.app j = CategoryTheory.Limits.limit.π F j
-- CategoryTheory.Limits.limit.isoLimitCone_inv_π
@[reassoc (attr := simp)]
theorem limit.isoLimitCone_inv_π {F : J ⥤ C} [HasLimit F] (t : LimitCone F) (j : J) :
    (limit.isoLimitCone t).inv ≫ limit.π F j = t.cone.π.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] (t : CategoryTheory.Limits.LimitCone F) (j : J)
Goal: (CategoryTheory.Limits.limit.isoLimitCone t).inv ≫ CategoryTheory.Limits.limit.π F j = t.cone.π.app j
-- CategoryTheory.Limits.limit.hom_ext
@[ext]
theorem limit.hom_ext {F : J ⥤ C} [HasLimit F] {X : C} {f f' : X ⟶ limit F}
    (w : ∀ j, f ≫ limit.π F j = f' ≫ limit.π F j) : f = f' 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] {X : C} {f f' : X ⟶ CategoryTheory.Limits.limit F} (w : ∀ (j : J), f ≫ CategoryTheory.Limits.limit.π F j = f' ≫ CategoryTheory.Limits.limit.π F j)
Goal: f = f'
-- CategoryTheory.Limits.limit.lift_map
@[simp]
theorem limit.lift_map {F G : J ⥤ C} [HasLimit F] [HasLimit G] (c : Cone F) (α : F ⟶ G) :
    limit.lift F c ≫ limMap α = limit.lift G ((Cones.postcompose α).obj c) 
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] (c : CategoryTheory.Limits.Cone F) (α : F ⟶ G)
Goal: CategoryTheory.Limits.limit.lift F c ≫ CategoryTheory.Limits.limMap α =
  CategoryTheory.Limits.limit.lift G ((CategoryTheory.Limits.Cones.postcompose α).obj c)
-- CategoryTheory.Limits.limit.lift_cone
@[simp]
theorem limit.lift_cone {F : J ⥤ C} [HasLimit F] : limit.lift F (limit.cone F) = 𝟙 (limit F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F]
Goal: CategoryTheory.Limits.limit.lift F (CategoryTheory.Limits.limit.cone F) = 𝟙 (CategoryTheory.Limits.limit F)
-- CategoryTheory.Limits.limit.homIso_hom
@[simp]
theorem limit.homIso_hom (F : J ⥤ C) [HasLimit F] {W : C} (f : ULift (W ⟶ limit F)) :
    (limit.homIso F W).hom f = (const J).map f.down ≫ (limit.cone F).π 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] {W : C} (f : ULift.{u₁, v} (W ⟶ CategoryTheory.Limits.limit F))
Goal: (CategoryTheory.Limits.limit.homIso F W).hom f =
  (CategoryTheory.Functor.const J).map f.down ≫ (CategoryTheory.Limits.limit.cone F).π
-- CategoryTheory.Limits.limit.lift_extend
theorem limit.lift_extend {F : J ⥤ C} [HasLimit F] (c : Cone F) {X : C} (f : X ⟶ c.pt) :
    limit.lift F (c.extend f) = f ≫ limit.lift F c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [CategoryTheory.Category.{v, u} C] {F : J ⥤ C} [CategoryTheory.Limits.HasLimit F] (c : CategoryTheory.Limits.Cone F) {X : C} (f : X ⟶ c.pt)
Goal: CategoryTheory.Limits.limit.lift F (c.extend f) = f ≫ CategoryTheory.Limits.limit.lift F c
-- CategoryTheory.Limits.hasLimitOfIso
theorem hasLimitOfIso {F G : J ⥤ C} [HasLimit F] (α : F ≅ G) : HasLimit G 
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] (α : F ≅ G)
Goal: CategoryTheory.Limits.HasLimit G
-- CategoryTheory.Limits.HasLimit.ofConesIso
theorem HasLimit.ofConesIso {J K : Type u₁} [Category.{v₁} J] [Category.{v₂} K] (F : J ⥤ C)
    (G : K ⥤ C) (h : F.cones ≅ G.cones) [HasLimit F] : HasLimit G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J K : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₁} K] (F : J ⥤ C) (G : K ⥤ C) (h : F.cones ≅ G.cones) [CategoryTheory.Limits.HasLimit F]
Goal: CategoryTheory.Limits.HasLimit G
-- CategoryTheory.Limits.HasLimit.isoOfNatIso_hom_π
@[reassoc (attr := simp)]
theorem HasLimit.isoOfNatIso_hom_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (w : F ≅ G) (j : J) :
    (HasLimit.isoOfNatIso w).hom ≫ limit.π G j = limit.π F j ≫ w.hom.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).hom ≫ CategoryTheory.Limits.limit.π G j =
  CategoryTheory.Limits.limit.π F j ≫ w.hom.app j