ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd
@[simp]
theorem pullbackZeroZeroIso_hom_snd (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).hom ≫ prod.snd = pullback.snd 0 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).hom ≫ CategoryTheory.Limits.prod.snd =
  CategoryTheory.Limits.pullback.snd 0 0
-- CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom
@[simp]
theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
    pushout.inl _ _ ≫ (pushoutZeroZeroIso X Y).hom = coprod.inl 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y]
Goal: CategoryTheory.Limits.pushout.inl 0 0 ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).hom =
  CategoryTheory.Limits.coprod.inl
-- CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom
@[simp]
theorem inr_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
    pushout.inr _ _ ≫ (pushoutZeroZeroIso X Y).hom = coprod.inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y]
Goal: CategoryTheory.Limits.pushout.inr 0 0 ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).hom =
  CategoryTheory.Limits.coprod.inr
-- CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv
@[simp]
theorem inl_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
    coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y]
Goal: CategoryTheory.Limits.coprod.inl ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).inv =
  CategoryTheory.Limits.pushout.inl 0 0
-- CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv
@[simp]
theorem inr_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
    coprod.inr ≫ (pushoutZeroZeroIso X Y).inv = pushout.inr _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y]
Goal: CategoryTheory.Limits.coprod.inr ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).inv =
  CategoryTheory.Limits.pushout.inr 0 0
-- CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset_map
@[simps!]
def liftToFinset [HasFiniteCoproducts C] (F : Discrete α ⥤ C) : Finset (Discrete α) ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {α : Type w} [CategoryTheory.Limits.HasFiniteCoproducts C] (F : CategoryTheory.Discrete α ⥤ C)
Goal: ∀ {x Y : Finset (CategoryTheory.Discrete α)} (h : x ⟶ Y),
  (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset F).map h =
    CategoryTheory.Limits.Sigma.desc fun y => CategoryTheory.Limits.Sigma.ι (fun x => F.obj ↑x) ⟨↑y, ⋯⟩
-- CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset_obj
@[simps!]
def liftToFinset [HasFiniteCoproducts C] (F : Discrete α ⥤ C) : Finset (Discrete α) ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {α : Type w} [CategoryTheory.Limits.HasFiniteCoproducts C] (F : CategoryTheory.Discrete α ⥤ C) (s : Finset (CategoryTheory.Discrete α))
Goal: (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset F).obj s = ∐ fun x => F.obj ↑x
-- CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone_cocone_ι_app
@[simps!]
def liftToFinsetColimitCocone [HasFiniteCoproducts C] [HasFilteredColimitsOfSize.{w, w} C]
    (F : Discrete α ⥤ C) : ColimitCocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {α : Type w} [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C] (F : CategoryTheory.Discrete α ⥤ C) (j : CategoryTheory.Discrete α)
Goal: (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone F).cocone.ι.app j =
  CategoryTheory.Limits.Sigma.ι (fun x => F.obj ↑x) ⟨j, ⋯⟩ ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset F) {j}
-- CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone_cocone_pt
@[simps!]
def liftToFinsetColimitCocone [HasFiniteCoproducts C] [HasFilteredColimitsOfSize.{w, w} C]
    (F : Discrete α ⥤ C) : ColimitCocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {α : Type w} [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C] (F : CategoryTheory.Discrete α ⥤ C)
Goal: (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone F).cocone.pt =
  CategoryTheory.Limits.colimit (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset F)
-- CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone_isColimit_desc
@[simps!]
def liftToFinsetColimitCocone [HasFiniteCoproducts C] [HasFilteredColimitsOfSize.{w, w} C]
    (F : Discrete α ⥤ C) : ColimitCocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {α : Type w} [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C] (F : CategoryTheory.Discrete α ⥤ C) (s : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone F).isColimit.desc s =
  CategoryTheory.Limits.colimit.desc (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset F)
    { pt := s.pt, ι := { app := fun t => CategoryTheory.Limits.Sigma.desc fun x => s.ι.app ↑x, naturality := ⋯ } }
-- CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered
theorem hasCoproducts_of_finite_and_filtered [HasFiniteCoproducts C]
    [HasFilteredColimitsOfSize.{w, w} C] : HasCoproducts.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C]
Goal: CategoryTheory.Limits.HasCoproducts C
-- CategoryTheory.Limits.has_colimits_of_finite_and_filtered
theorem has_colimits_of_finite_and_filtered [HasFiniteColimits C]
    [HasFilteredColimitsOfSize.{w, w} C] : HasColimitsOfSize.{w, w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteColimits C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C
-- CategoryTheory.Limits.hasProducts_of_finite_and_cofiltered
theorem hasProducts_of_finite_and_cofiltered [HasFiniteProducts C]
    [HasCofilteredLimitsOfSize.{w, w} C] : HasProducts.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasCofilteredLimitsOfSize.{w, w, v, u} C]
Goal: CategoryTheory.Limits.HasProducts C
-- CategoryTheory.Limits.has_limits_of_finite_and_cofiltered
theorem has_limits_of_finite_and_cofiltered [HasFiniteLimits C]
    [HasCofilteredLimitsOfSize.{w, w} C] : HasLimitsOfSize.{w, w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C] [CategoryTheory.Limits.HasCofilteredLimitsOfSize.{w, w, v, u} C]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{w, w, v, u} C
-- CategoryTheory.FinallySmall.final_smallCategory
class FinallySmall : Prop where
    final_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Final F
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] [self : CategoryTheory.FinallySmall J]
Goal: ∃ S x F, F.Final
-- CategoryTheory.FinallySmall.mk'
theorem FinallySmall.mk' {J : Type u} [Category.{v} J] {S : Type w} [SmallCategory S]
    (F : S ⥤ J) [Final F] : FinallySmall.{w} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {S : Type w} [CategoryTheory.SmallCategory S] (F : S ⥤ J) [F.Final]
Goal: CategoryTheory.FinallySmall J
-- CategoryTheory.finallySmall_of_essentiallySmall
theorem finallySmall_of_essentiallySmall [EssentiallySmall.{w} J] : FinallySmall.{w} J 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.EssentiallySmall.{w, v, u} J]
Goal: CategoryTheory.FinallySmall J
-- CategoryTheory.finallySmall_of_final_of_finallySmall
theorem finallySmall_of_final_of_finallySmall [FinallySmall.{w} K] : FinallySmall.{w} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {K : Type u₁} [CategoryTheory.Category.{v₁, u₁} K] (F : K ⥤ J) [F.Final] [CategoryTheory.FinallySmall K]
Goal: CategoryTheory.FinallySmall J
-- CategoryTheory.finallySmall_of_final_of_essentiallySmall
theorem finallySmall_of_final_of_essentiallySmall [EssentiallySmall.{w} K] : FinallySmall.{w} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {K : Type u₁} [CategoryTheory.Category.{v₁, u₁} K] (F : K ⥤ J) [F.Final] [CategoryTheory.EssentiallySmall.{w, v₁, u₁} K]
Goal: CategoryTheory.FinallySmall J
-- CategoryTheory.InitiallySmall.initial_smallCategory
class InitiallySmall : Prop where
    initial_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Initial F
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] [self : CategoryTheory.InitiallySmall J]
Goal: ∃ S x F, F.Initial
-- CategoryTheory.InitiallySmall.mk'
theorem InitiallySmall.mk' {J : Type u} [Category.{v} J] {S : Type w} [SmallCategory S]
    (F : S ⥤ J) [Initial F] : InitiallySmall.{w} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {S : Type w} [CategoryTheory.SmallCategory S] (F : S ⥤ J) [F.Initial]
Goal: CategoryTheory.InitiallySmall J
-- CategoryTheory.initiallySmall_of_essentiallySmall
theorem initiallySmall_of_essentiallySmall [EssentiallySmall.{w} J] : InitiallySmall.{w} J 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.EssentiallySmall.{w, v, u} J]
Goal: CategoryTheory.InitiallySmall J
-- CategoryTheory.initiallySmall_of_initial_of_initiallySmall
theorem initiallySmall_of_initial_of_initiallySmall [InitiallySmall.{w} K] : InitiallySmall.{w} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {K : Type u₁} [CategoryTheory.Category.{v₁, u₁} K] (F : K ⥤ J) [F.Initial] [CategoryTheory.InitiallySmall K]
Goal: CategoryTheory.InitiallySmall J
-- CategoryTheory.initiallySmall_of_initial_of_essentiallySmall
theorem initiallySmall_of_initial_of_essentiallySmall [EssentiallySmall.{w} K] :
    InitiallySmall.{w} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {K : Type u₁} [CategoryTheory.Category.{v₁, u₁} K] (F : K ⥤ J) [F.Initial] [CategoryTheory.EssentiallySmall.{w, v₁, u₁} K]
Goal: CategoryTheory.InitiallySmall J
-- CategoryTheory.FinallySmall.exists_small_weakly_terminal_set
theorem FinallySmall.exists_small_weakly_terminal_set [FinallySmall.{w} J] :
    ∃ (s : Set J) (_ : Small.{w} s), ∀ i, ∃ j ∈ s, Nonempty (i ⟶ j) 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.FinallySmall J]
Goal: ∃ s, ∃ (_ : Small.{w, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
-- CategoryTheory.finallySmall_of_small_weakly_terminal_set
theorem finallySmall_of_small_weakly_terminal_set [IsFilteredOrEmpty J] (s : Set J) [Small.{v} s]
    (hs : ∀ i, ∃ j ∈ s, Nonempty (i ⟶ j)) : FinallySmall.{v} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] [CategoryTheory.IsFilteredOrEmpty J] (s : Set J) [Small.{v, u} ↑s] (hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j))
Goal: CategoryTheory.FinallySmall J
-- CategoryTheory.finallySmall_iff_exists_small_weakly_terminal_set
theorem finallySmall_iff_exists_small_weakly_terminal_set [IsFilteredOrEmpty J] :
    FinallySmall.{v} J ↔ ∃ (s : Set J) (_ : Small.{v} s), ∀ i, ∃ j ∈ s, Nonempty (i ⟶ j) 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.IsFilteredOrEmpty J]
Goal: CategoryTheory.FinallySmall J ↔ ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
-- CategoryTheory.InitiallySmall.exists_small_weakly_initial_set
theorem InitiallySmall.exists_small_weakly_initial_set [InitiallySmall.{w} J] :
    ∃ (s : Set J) (_ : Small.{w} s), ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i) 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.InitiallySmall J]
Goal: ∃ s, ∃ (_ : Small.{w, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
-- CategoryTheory.initiallySmall_of_small_weakly_initial_set
theorem initiallySmall_of_small_weakly_initial_set [IsCofilteredOrEmpty J] (s : Set J) [Small.{v} s]
    (hs : ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i)) : InitiallySmall.{v} J 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] [CategoryTheory.IsCofilteredOrEmpty J] (s : Set J) [Small.{v, u} ↑s] (hs : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i))
Goal: CategoryTheory.InitiallySmall J
-- CategoryTheory.initiallySmall_iff_exists_small_weakly_initial_set
theorem initiallySmall_iff_exists_small_weakly_initial_set [IsCofilteredOrEmpty J] :
    InitiallySmall.{v} J ↔ ∃ (s : Set J) (_ : Small.{v} s), ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i) 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.IsCofilteredOrEmpty J]
Goal: CategoryTheory.InitiallySmall J ↔ ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
-- CategoryTheory.Limits.hasColimitsOfShape_of_finallySmall
theorem hasColimitsOfShape_of_finallySmall (J : Type u) [Category.{v} J] [FinallySmall.{w} J]
    (C : Type u₁) [Category.{v₁} C] [HasColimitsOfSize.{w, w} C] : HasColimitsOfShape J C 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.FinallySmall J] (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasColimitsOfSize.{w, w, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.Limits.hasLimitsOfShape_of_initiallySmall
theorem hasLimitsOfShape_of_initiallySmall (J : Type u) [Category.{v} J] [InitiallySmall.{w} J]
    (C : Type u₁) [Category.{v₁} C] [HasLimitsOfSize.{w, w} C] : HasLimitsOfShape J C 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] [CategoryTheory.InitiallySmall J] (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasLimitsOfSize.{w, w, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasLimitsOfShape J C
-- CategoryTheory.Limits.hasLimit_cospan_of_hasLimit_pair_of_hasLimit_parallelPair
theorem hasLimit_cospan_of_hasLimit_pair_of_hasLimit_parallelPair {C : Type u} [𝒞 : Category.{v} C]
    {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasLimit (pair X Y)]
    [HasLimit (parallelPair (prod.fst ≫ f) (prod.snd ≫ g))] : HasLimit (cospan f g) 
Arguments: {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.pair X Y)] [CategoryTheory.Limits.HasLimit
    (CategoryTheory.Limits.parallelPair (CategoryTheory.Limits.prod.fst ≫ f) (CategoryTheory.Limits.prod.snd ≫ g))]
Goal: CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan f g)
-- CategoryTheory.Limits.hasPullbacks_of_hasBinaryProducts_of_hasEqualizers
theorem hasPullbacks_of_hasBinaryProducts_of_hasEqualizers (C : Type u) [Category.{v} C]
    [HasBinaryProducts C] [HasEqualizers C] : HasPullbacks C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryProducts C] [CategoryTheory.Limits.HasEqualizers C]
Goal: CategoryTheory.Limits.HasPullbacks C
-- CategoryTheory.Limits.hasColimit_span_of_hasColimit_pair_of_hasColimit_parallelPair
theorem hasColimit_span_of_hasColimit_pair_of_hasColimit_parallelPair {C : Type u}
    [𝒞 : Category.{v} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasColimit (pair Y Z)]
    [HasColimit (parallelPair (f ≫ coprod.inl) (g ≫ coprod.inr))] : HasColimit (span f g) 
Arguments: {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.pair Y Z)] [CategoryTheory.Limits.HasColimit
    (CategoryTheory.Limits.parallelPair (f ≫ CategoryTheory.Limits.coprod.inl) (g ≫ CategoryTheory.Limits.coprod.inr))]
Goal: CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.span f g)
-- CategoryTheory.Limits.hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers
theorem hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers (C : Type u) [Category.{v} C]
    [HasBinaryCoproducts C] [HasCoequalizers C] : HasPushouts C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C] [CategoryTheory.Limits.HasCoequalizers C]
Goal: CategoryTheory.Limits.HasPushouts C
-- CategoryTheory.LeftExactFunctor.ofExact_obj
@[simp]
theorem LeftExactFunctor.ofExact_obj (F : C ⥤ₑ D) :
    (LeftExactFunctor.ofExact C D).obj F = ⟨F.1, F.2.1⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ₑ D)
Goal: (CategoryTheory.LeftExactFunctor.ofExact C D).obj F = { obj := F.obj, property := ⋯ }
-- CategoryTheory.RightExactFunctor.ofExact_obj
@[simp]
theorem RightExactFunctor.ofExact_obj (F : C ⥤ₑ D) :
    (RightExactFunctor.ofExact C D).obj F = ⟨F.1, F.2.2⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ₑ D)
Goal: (CategoryTheory.RightExactFunctor.ofExact C D).obj F = { obj := F.obj, property := ⋯ }
-- CategoryTheory.LeftExactFunctor.ofExact_map
@[simp]
theorem LeftExactFunctor.ofExact_map {F G : C ⥤ₑ D} (α : F ⟶ G) :
    (LeftExactFunctor.ofExact C D).map α = α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G)
Goal: (CategoryTheory.LeftExactFunctor.ofExact C D).map α = α
-- CategoryTheory.RightExactFunctor.ofExact_map
@[simp]
theorem RightExactFunctor.ofExact_map {F G : C ⥤ₑ D} (α : F ⟶ G) :
    (RightExactFunctor.ofExact C D).map α = α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G)
Goal: (CategoryTheory.RightExactFunctor.ofExact C D).map α = α
-- CategoryTheory.LeftExactFunctor.forget_obj
@[simp]
theorem LeftExactFunctor.forget_obj (F : C ⥤ₗ D) : (LeftExactFunctor.forget C D).obj F = F.1 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ₗ D)
Goal: (CategoryTheory.LeftExactFunctor.forget C D).obj F = F.obj
-- CategoryTheory.RightExactFunctor.forget_obj
@[simp]
theorem RightExactFunctor.forget_obj (F : C ⥤ᵣ D) : (RightExactFunctor.forget C D).obj F = F.1 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ᵣ D)
Goal: (CategoryTheory.RightExactFunctor.forget C D).obj F = F.obj
-- CategoryTheory.ExactFunctor.forget_obj
@[simp]
theorem ExactFunctor.forget_obj (F : C ⥤ₑ D) : (ExactFunctor.forget C D).obj F = F.1 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ₑ D)
Goal: (CategoryTheory.ExactFunctor.forget C D).obj F = F.obj
-- CategoryTheory.LeftExactFunctor.forget_map
@[simp]
theorem LeftExactFunctor.forget_map {F G : C ⥤ₗ D} (α : F ⟶ G) :
    (LeftExactFunctor.forget C D).map α = α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ₗ D} (α : F ⟶ G)
Goal: (CategoryTheory.LeftExactFunctor.forget C D).map α = α
-- CategoryTheory.RightExactFunctor.forget_map
@[simp]
theorem RightExactFunctor.forget_map {F G : C ⥤ᵣ D} (α : F ⟶ G) :
    (RightExactFunctor.forget C D).map α = α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ᵣ D} (α : F ⟶ G)
Goal: (CategoryTheory.RightExactFunctor.forget C D).map α = α
-- CategoryTheory.ExactFunctor.forget_map
@[simp]
theorem ExactFunctor.forget_map {F G : C ⥤ₑ D} (α : F ⟶ G) : (ExactFunctor.forget C D).map α = α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G)
Goal: (CategoryTheory.ExactFunctor.forget C D).map α = α
-- CategoryTheory.LeftExactFunctor.of_fst
@[simp]
theorem LeftExactFunctor.of_fst (F : C ⥤ D) [PreservesFiniteLimits F] :
    (LeftExactFunctor.of F).obj = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteLimits F]
Goal: (CategoryTheory.LeftExactFunctor.of F).obj = F
-- CategoryTheory.RightExactFunctor.of_fst
@[simp]
theorem RightExactFunctor.of_fst (F : C ⥤ D) [PreservesFiniteColimits F] :
    (RightExactFunctor.of F).obj = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: (CategoryTheory.RightExactFunctor.of F).obj = F
-- CategoryTheory.ExactFunctor.of_fst
@[simp]
theorem ExactFunctor.of_fst (F : C ⥤ D) [PreservesFiniteLimits F] [PreservesFiniteColimits F] :
    (ExactFunctor.of F).obj = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteLimits F] [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: (CategoryTheory.ExactFunctor.of F).obj = F
-- CategoryTheory.LeftExactFunctor.forget_obj_of
theorem LeftExactFunctor.forget_obj_of (F : C ⥤ D) [PreservesFiniteLimits F] :
    (LeftExactFunctor.forget C D).obj (LeftExactFunctor.of F) = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteLimits F]
Goal: (CategoryTheory.LeftExactFunctor.forget C D).obj (CategoryTheory.LeftExactFunctor.of F) = F
-- CategoryTheory.RightExactFunctor.forget_obj_of
theorem RightExactFunctor.forget_obj_of (F : C ⥤ D) [PreservesFiniteColimits F] :
    (RightExactFunctor.forget C D).obj (RightExactFunctor.of F) = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: (CategoryTheory.RightExactFunctor.forget C D).obj (CategoryTheory.RightExactFunctor.of F) = F
-- CategoryTheory.ExactFunctor.forget_obj_of
theorem ExactFunctor.forget_obj_of (F : C ⥤ D) [PreservesFiniteLimits F]
    [PreservesFiniteColimits F] : (ExactFunctor.forget C D).obj (ExactFunctor.of F) = F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteLimits F] [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: (CategoryTheory.ExactFunctor.forget C D).obj (CategoryTheory.ExactFunctor.of F) = F
-- hasBinaryProducts_of_hasTerminal_and_pullbacks
theorem hasBinaryProducts_of_hasTerminal_and_pullbacks [HasTerminal C] [HasPullbacks C] :
    HasBinaryProducts C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasTerminal C] [CategoryTheory.Limits.HasPullbacks C]
Goal: CategoryTheory.Limits.HasBinaryProducts C
-- hasBinaryCoproducts_of_hasInitial_and_pushouts
theorem hasBinaryCoproducts_of_hasInitial_and_pushouts [HasInitial C] [HasPushouts C] :
    HasBinaryCoproducts C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
Goal: CategoryTheory.Limits.HasBinaryCoproducts C
-- CategoryTheory.FunctorToTypes.jointly_surjective
theorem jointly_surjective (k : K) {t : Cocone F} (h : IsColimit t) (x : t.pt.obj k) :
    ∃ j y, x = (t.ι.app j).app k y 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : CategoryTheory.Functor J (CategoryTheory.Functor K TypeMax)) (k : K) {t : CategoryTheory.Limits.Cocone F} (h : CategoryTheory.Limits.IsColimit t) (x : t.pt.obj k)
Goal: ∃ j y, x = (t.ι.app j).app k y