ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

full_name: CategoryTheory.preserves_mono_of_preservesLimit
code: /-- If `F` preserves pullbacks, then it preserves monomorphisms. -/
theorem preserves_mono_of_preservesLimit {X Y : C} (f : X ⟶ Y) [PreservesLimit (cospan f f) F]
    [Mono f] : Mono (F.map f) 
goal: CategoryTheory.Mono (F.map f)

full_name: CategoryTheory.preservesMonomorphisms_of_preservesLimitsOfShape
code: instance (priority := 100) preservesMonomorphisms_of_preservesLimitsOfShape
    [PreservesLimitsOfShape WalkingCospan F] : F.PreservesMonomorphisms 
goal: F.PreservesMonomorphisms

full_name: CategoryTheory.reflects_mono_of_reflectsLimit
code: /-- If `F` reflects pullbacks, then it reflects monomorphisms. -/
theorem reflects_mono_of_reflectsLimit {X Y : C} (f : X ⟶ Y) [ReflectsLimit (cospan f f) F]
    [Mono (F.map f)] : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.reflectsMonomorphisms_of_reflectsLimitsOfShape
code: instance (priority := 100) reflectsMonomorphisms_of_reflectsLimitsOfShape
    [ReflectsLimitsOfShape WalkingCospan F] : F.ReflectsMonomorphisms 
goal: F.ReflectsMonomorphisms

full_name: CategoryTheory.preserves_epi_of_preservesColimit
code: /-- If `F` preserves pushouts, then it preserves epimorphisms. -/
theorem preserves_epi_of_preservesColimit {X Y : C} (f : X ⟶ Y) [PreservesColimit (span f f) F]
    [Epi f] : Epi (F.map f) 
goal: CategoryTheory.Epi (F.map f)

full_name: CategoryTheory.preservesEpimorphisms_of_preservesColimitsOfShape
code: instance (priority := 100) preservesEpimorphisms_of_preservesColimitsOfShape
    [PreservesColimitsOfShape WalkingSpan F] : F.PreservesEpimorphisms 
goal: F.PreservesEpimorphisms

full_name: CategoryTheory.reflects_epi_of_reflectsColimit
code: /-- If `F` reflects pushouts, then it reflects epimorphisms. -/
theorem reflects_epi_of_reflectsColimit {X Y : C} (f : X ⟶ Y) [ReflectsColimit (span f f) F]
    [Epi (F.map f)] : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.reflectsEpimorphisms_of_reflectsColimitsOfShape
code: instance (priority := 100) reflectsEpimorphisms_of_reflectsColimitsOfShape
    [ReflectsColimitsOfShape WalkingSpan F] : F.ReflectsEpimorphisms 
goal: F.ReflectsEpimorphisms
File: Mathlib/CategoryTheory/Limits/Constructions/WeaklyInitial.lean

full_name: CategoryTheory.has_weakly_initial_of_weakly_initial_set_and_hasProducts
code: /--
If `C` has (small) products and a small weakly initial set of objects, then it has a weakly initial
object.
-/
theorem has_weakly_initial_of_weakly_initial_set_and_hasProducts [HasProducts.{v} C] {ι : Type v}
    {B : ι → C} (hB : ∀ A : C, ∃ i, Nonempty (B i ⟶ A)) : ∃ T : C, ∀ X, Nonempty (T ⟶ X) 
goal: ∃ T, ∀ (X : C), Nonempty (T ⟶ X)

full_name: CategoryTheory.hasInitial_of_weakly_initial_and_hasWideEqualizers
code: /-- If `C` has (small) wide equalizers and a weakly initial object, then it has an initial object.

The initial object is constructed as the wide equalizer of all endomorphisms on the given weakly
initial object.
-/
theorem hasInitial_of_weakly_initial_and_hasWideEqualizers [HasWideEqualizers.{v} C] {T : C}
    (hT : ∀ X, Nonempty (T ⟶ X)) : HasInitial C 
goal: CategoryTheory.Limits.HasInitial C
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Basic.lean

full_name: CategoryTheory.Over.instHasPullbacks
code: /-- Make sure we can derive pullbacks in `Over B`. -/
instance {B : C} [HasPullbacks C] : HasPullbacks (Over B) 
goal: CategoryTheory.Limits.HasPullbacks (CategoryTheory.Over B)

full_name: CategoryTheory.Over.instHasEqualizers
code: /-- Make sure we can derive equalizers in `Over B`. -/
instance {B : C} [HasEqualizers C] : HasEqualizers (Over B) 
goal: CategoryTheory.Limits.HasEqualizers (CategoryTheory.Over B)

full_name: CategoryTheory.Over.hasFiniteLimits
code: instance hasFiniteLimits {B : C} [HasFiniteWidePullbacks C] : HasFiniteLimits (Over B) 
goal: CategoryTheory.Limits.HasFiniteLimits (CategoryTheory.Over B)

full_name: CategoryTheory.Over.hasLimits
code: instance hasLimits {B : C} [HasWidePullbacks.{w} C] : HasLimitsOfSize.{w, w} (Over B) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, w, v, max u v} (CategoryTheory.Over B)
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Connected.lean

full_name: CategoryTheory.Over.CreatesConnected.natTransInOver
code: /-- (Impl) Given a diagram in the over category, produce a natural transformation from the
diagram legs to the specific object.
-/
def natTransInOver {B : C} (F : J ⥤ Over B) :
    F ⋙ forget B ⟶ (CategoryTheory.Functor.const J).obj B 
goal: F ⋙ CategoryTheory.Over.forget B ⟶ (CategoryTheory.Functor.const J).obj B

full_name: CategoryTheory.Over.CreatesConnected.raiseCone
code: /-- (Impl) Given a cone in the base category, raise it to a cone in the over category. Note this is
where the connected assumption is used.
-/
@[simps]
def raiseCone [IsConnected J] {B : C} {F : J ⥤ Over B} (c : Cone (F ⋙ forget B)) :
    Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Over.CreatesConnected.raiseCone_pt
code: /-- (Impl) Given a cone in the base category, raise it to a cone in the over category. Note this is
where the connected assumption is used.
-/
@[simps]
def raiseCone [IsConnected J] {B : C} {F : J ⥤ Over B} (c : Cone (F ⋙ forget B)) :
    Cone F 
goal: (CategoryTheory.Over.CreatesConnected.raiseCone c).pt =
  CategoryTheory.Over.mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom)

full_name: CategoryTheory.Over.CreatesConnected.raiseCone_π_app
code: /-- (Impl) Given a cone in the base category, raise it to a cone in the over category. Note this is
where the connected assumption is used.
-/
@[simps]
def raiseCone [IsConnected J] {B : C} {F : J ⥤ Over B} (c : Cone (F ⋙ forget B)) :
    Cone F 
goal: (CategoryTheory.Over.CreatesConnected.raiseCone c).π.app j = CategoryTheory.Over.homMk (c.π.app j) ⋯

full_name: CategoryTheory.Over.CreatesConnected.raised_cone_lowers_to_original
code: theorem raised_cone_lowers_to_original [IsConnected J] {B : C} {F : J ⥤ Over B}
    (c : Cone (F ⋙ forget B)) :
    (forget B).mapCone (raiseCone c) = c 
goal: (CategoryTheory.Over.forget B).mapCone (CategoryTheory.Over.CreatesConnected.raiseCone c) = c

full_name: CategoryTheory.Over.CreatesConnected.raisedConeIsLimit
code: /-- (Impl) Show that the raised cone is a limit. -/
def raisedConeIsLimit [IsConnected J] {B : C} {F : J ⥤ Over B} {c : Cone (F ⋙ forget B)}
    (t : IsLimit c) : IsLimit (raiseCone c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Over.CreatesConnected.raiseCone c)

full_name: CategoryTheory.Over.forgetCreatesConnectedLimits
code: /-- The forgetful functor from the over category creates any connected limit. -/
instance forgetCreatesConnectedLimits [IsConnected J] {B : C} :
    CreatesLimitsOfShape J (forget B) 
goal: CategoryTheory.CreatesLimitsOfShape J (CategoryTheory.Over.forget B)

full_name: CategoryTheory.Over.has_connected_limits
code: /-- The over category has any connected limit which the original category has. -/
instance has_connected_limits {B : C} [IsConnected J] [HasLimitsOfShape J C] :
    HasLimitsOfShape J (Over B) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Over B)
File: Mathlib/CategoryTheory/Limits/Unit.lean

full_name: CategoryTheory.Limits.punitCone
code: /-- A trivial cone for a functor into `PUnit`. `punitConeIsLimit` shows it is a limit. -/
def punitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.punitCocone
code: /-- A trivial cocone for a functor into `PUnit`. `punitCoconeIsLimit` shows it is a colimit. -/
def punitCocone : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.punitConeIsLimit
code: /-- Any cone over a functor into `PUnit` is a limit cone.
-/
def punitConeIsLimit {c : Cone F} : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.punitCoconeIsColimit
code: /-- Any cocone over a functor into `PUnit` is a colimit cocone.
-/
def punitCoconeIsColimit {c : Cocone F} : IsColimit c 
goal: CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.instHasLimitsOfSizeDiscretePUnit
code: instance : HasLimitsOfSize.{v', v} (Discrete PUnit) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v', v, u_1, u_1} (CategoryTheory.Discrete PUnit.{u_1 + 1})

full_name: CategoryTheory.Limits.instHasColimitsOfSizeDiscretePUnit
code: instance : HasColimitsOfSize.{v', v} (Discrete PUnit) 
goal: CategoryTheory.Limits.HasColimitsOfSize.{v', v, u_1, u_1} (CategoryTheory.Discrete PUnit.{u_1 + 1})
File: Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean

full_name: CategoryTheory.Limits.hasLimit_cospan_of_hasLimit_pair_of_hasLimit_parallelPair
code: /-- If the product `X ⨯ Y` and the equalizer of `π₁ ≫ f` and `π₂ ≫ g` exist, then the
    pullback of `f` and `g` exists: It is given by composing the equalizer with the projections. -/
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) 
goal: CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan f g)

full_name: CategoryTheory.Limits.hasPullbacks_of_hasBinaryProducts_of_hasEqualizers
code: /-- If a category has all binary products and all equalizers, then it also has all pullbacks.
    As usual, this is not an instance, since there may be a more direct way to construct
    pullbacks. -/
theorem hasPullbacks_of_hasBinaryProducts_of_hasEqualizers (C : Type u) [Category.{v} C]
    [HasBinaryProducts C] [HasEqualizers C] : HasPullbacks C 
goal: CategoryTheory.Limits.HasPullbacks C

full_name: CategoryTheory.Limits.hasColimit_span_of_hasColimit_pair_of_hasColimit_parallelPair
code: /-- If the coproduct `Y ⨿ Z` and the coequalizer of `f ≫ ι₁` and `g ≫ ι₂` exist, then the
    pushout of `f` and `g` exists: It is given by composing the inclusions with the coequalizer. -/
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) 
goal: CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.span f g)

full_name: CategoryTheory.Limits.hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers
code: /-- If a category has all binary coproducts and all coequalizers, then it also has all pushouts.
    As usual, this is not an instance, since there may be a more direct way to construct
    pushouts. -/
theorem hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers (C : Type u) [Category.{v} C]
    [HasBinaryCoproducts C] [HasCoequalizers C] : HasPushouts C 
goal: CategoryTheory.Limits.HasPushouts C
File: Mathlib/CategoryTheory/Limits/FunctorToTypes.lean

full_name: CategoryTheory.FunctorToTypes.jointly_surjective
code: 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 
goal: ∃ j y, x = (t.ι.app j).app k y

full_name: CategoryTheory.FunctorToTypes.jointly_surjective'
code: theorem jointly_surjective' (k : K) (x : (colimit F).obj k) : ∃ j y, x = (colimit.ι F j).app k y 
goal: ∃ j y, x = (CategoryTheory.Limits.colimit.ι F j).app k y
File: Mathlib/CategoryTheory/Limits/Pi.lean

full_name: CategoryTheory.pi.coneCompEval
code: /-- A cone over `F : J ⥤ Π i, C i` has as its components cones over each of the `F ⋙ Pi.eval C i`.
-/
def coneCompEval (c : Cone F) (i : I) : Cone (F ⋙ Pi.eval C i) 
goal: CategoryTheory.Limits.Cone (F ⋙ CategoryTheory.Pi.eval C i)

full_name: CategoryTheory.pi.coconeCompEval
code: /--
A cocone over `F : J ⥤ Π i, C i` has as its components cocones over each of the `F ⋙ Pi.eval C i`.
-/
def coconeCompEval (c : Cocone F) (i : I) : Cocone (F ⋙ Pi.eval C i) 
goal: CategoryTheory.Limits.Cocone (F ⋙ CategoryTheory.Pi.eval C i)

full_name: CategoryTheory.pi.coneOfConeCompEval
code: /--
Given a family of cones over the `F ⋙ Pi.eval C i`, we can assemble these together as a `Cone F`.
-/
def coneOfConeCompEval (c : ∀ i, Cone (F ⋙ Pi.eval C i)) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.pi.coconeOfCoconeCompEval
code: /-- Given a family of cocones over the `F ⋙ Pi.eval C i`,
we can assemble these together as a `Cocone F`.
-/
def coconeOfCoconeCompEval (c : ∀ i, Cocone (F ⋙ Pi.eval C i)) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.pi.coneOfConeEvalIsLimit
code: /-- Given a family of limit cones over the `F ⋙ Pi.eval C i`,
assembling them together as a `Cone F` produces a limit cone.
-/
def coneOfConeEvalIsLimit {c : ∀ i, Cone (F ⋙ Pi.eval C i)} (P : ∀ i, IsLimit (c i)) :
    IsLimit (coneOfConeCompEval c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.pi.coneOfConeCompEval c)

full_name: CategoryTheory.pi.coconeOfCoconeEvalIsColimit
code: /-- Given a family of colimit cocones over the `F ⋙ Pi.eval C i`,
assembling them together as a `Cocone F` produces a colimit cocone.
-/
def coconeOfCoconeEvalIsColimit {c : ∀ i, Cocone (F ⋙ Pi.eval C i)} (P : ∀ i, IsColimit (c i)) :
    IsColimit (coconeOfCoconeCompEval c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.pi.coconeOfCoconeCompEval c)

full_name: CategoryTheory.pi.hasLimit_of_hasLimit_comp_eval
code: /-- If we have a functor `F : J ⥤ Π i, C i` into a category of indexed families,
and we have limits for each of the `F ⋙ Pi.eval C i`,
then `F` has a limit.
-/
theorem hasLimit_of_hasLimit_comp_eval : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.pi.hasColimit_of_hasColimit_comp_eval
code: /-- If we have a functor `F : J ⥤ Π i, C i` into a category of indexed families,
and colimits exist for each of the `F ⋙ Pi.eval C i`,
there is a colimit for `F`.
-/
theorem hasColimit_of_hasColimit_comp_eval : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F
File: Mathlib/CategoryTheory/Limits/Shapes/Equivalence.lean

full_name: CategoryTheory.hasInitial_of_equivalence
code: theorem hasInitial_of_equivalence (e : D ⥤ C) [e.IsEquivalence] [HasInitial C] : HasInitial D 
goal: CategoryTheory.Limits.HasInitial D

full_name: CategoryTheory.Equivalence.hasInitial_iff
code: theorem Equivalence.hasInitial_iff (e : C ≌ D) : HasInitial C ↔ HasInitial D 
goal: CategoryTheory.Limits.HasInitial C ↔ CategoryTheory.Limits.HasInitial D

full_name: CategoryTheory.hasTerminal_of_equivalence
code: theorem hasTerminal_of_equivalence (e : D ⥤ C) [e.IsEquivalence] [HasTerminal C] : HasTerminal D 
goal: CategoryTheory.Limits.HasTerminal D

full_name: CategoryTheory.Equivalence.hasTerminal_iff
code: theorem Equivalence.hasTerminal_iff (e : C ≌ D) : HasTerminal C ↔ HasTerminal D 
goal: CategoryTheory.Limits.HasTerminal C ↔ CategoryTheory.Limits.HasTerminal D
File: Mathlib/CategoryTheory/Limits/Shapes/CombinedProducts.lean

full_name: CategoryTheory.Limits.Fan.combPairHoms
code: /-- For fans on maps `f₁ : ι₁ → C`, `f₂ : ι₂ → C` and a binary fan on their
cone points, construct one family of morphisms indexed by `ι₁ ⊕ ι₂` -/
@[simp]
abbrev combPairHoms : (i : ι₁ ⊕ ι₂) → bc.pt ⟶ Sum.elim f₁ f₂ i
  
goal: bc.pt ⟶ Sum.elim f₁ f₂ i

full_name: CategoryTheory.Limits.Fan.combPairIsLimit
code: /-- If `c₁` and `c₂` are limit fans and `bc` is a limit binary fan on their cone
points, then the fan constructed from `combPairHoms` is a limit cone.  -/
def combPairIsLimit : IsLimit (Fan.mk bc.pt (combPairHoms c₁ c₂ bc)) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fan.mk bc.pt (c₁.combPairHoms c₂ bc))

full_name: CategoryTheory.Limits.Cofan.combPairHoms
code: /-- For cofans on maps `f₁ : ι₁ → C`, `f₂ : ι₂ → C` and a binary cofan on their
cocone points, construct one family of morphisms indexed by `ι₁ ⊕ ι₂` -/
@[simp]
abbrev combPairHoms : (i : ι₁ ⊕ ι₂) → Sum.elim f₁ f₂ i ⟶ bc.pt
  
goal: Sum.elim f₁ f₂ i ⟶ bc.pt

full_name: CategoryTheory.Limits.Cofan.combPairIsColimit
code: /-- If `c₁` and `c₂` are colimit cofans and `bc` is a colimit binary cofan on their cocone
points, then the cofan constructed from `combPairHoms` is a colimit cocone.  -/
def combPairIsColimit : IsColimit (Cofan.mk bc.pt (combPairHoms c₁ c₂ bc)) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofan.mk bc.pt (c₁.combPairHoms c₂ bc))
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorCategory.lean

full_name: CategoryTheory.Limits.functor_category_hasFiniteLimits
code: instance functor_category_hasFiniteLimits [HasFiniteLimits D] : HasFiniteLimits (C ⥤ D) 
goal: CategoryTheory.Limits.HasFiniteLimits (C ⥤ D)

full_name: CategoryTheory.Limits.functor_category_hasFiniteColimits
code: instance functor_category_hasFiniteColimits [HasFiniteColimits D] : HasFiniteColimits (C ⥤ D) 
goal: CategoryTheory.Limits.HasFiniteColimits (C ⥤ D)
File: Mathlib/CategoryTheory/Limits/Preserves/Filtered.lean

full_name: CategoryTheory.Limits.PreservesFilteredColimits
code: /--
A functor is said to preserve filtered colimits, if it preserves all colimits of shape `J`, where
`J` is a filtered category.
-/
class PreservesFilteredColimits (F : C ⥤ D) : Type max u₁ u₂ (v + 1) where
  preserves_filtered_colimits :
    ∀ (J : Type v) [SmallCategory J] [IsFiltered J], PreservesColimitsOfShape J F
goal: Type (max u₁ u₂ (v + 1))

full_name: CategoryTheory.Limits.PreservesFilteredColimits.preserves_filtered_colimits
code: /--
A functor is said to preserve filtered colimits, if it preserves all colimits of shape `J`, where
`J` is a filtered category.
-/
class PreservesFilteredColimits (F : C ⥤ D) : Type max u₁ u₂ (v + 1) where
  preserves_filtered_colimits :
    ∀ (J : Type v) [SmallCategory J] [IsFiltered J], PreservesColimitsOfShape J F
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Limits.PreservesColimits.preservesFilteredColimits
code: instance (priority := 100) PreservesColimits.preservesFilteredColimits (F : C ⥤ D)
    [PreservesColimits F] : PreservesFilteredColimits F 
goal: CategoryTheory.Limits.PreservesFilteredColimits F

full_name: CategoryTheory.Limits.compPreservesFilteredColimits
code: instance compPreservesFilteredColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFilteredColimits F]
    [PreservesFilteredColimits G] : PreservesFilteredColimits (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesFilteredColimits (F ⋙ G)

full_name: CategoryTheory.Limits.PreservesCofilteredLimits
code: /-- A functor is said to preserve cofiltered limits, if it preserves all limits of shape `J`, where
`J` is a cofiltered category.
-/
class PreservesCofilteredLimits (F : C ⥤ D) : Type max u₁ u₂ (v + 1) where
  preserves_cofiltered_limits :
    ∀ (J : Type v) [SmallCategory J] [IsCofiltered J], PreservesLimitsOfShape J F
goal: Type (max u₁ u₂ (v + 1))

full_name: CategoryTheory.Limits.PreservesCofilteredLimits.preserves_cofiltered_limits
code: /-- A functor is said to preserve cofiltered limits, if it preserves all limits of shape `J`, where
`J` is a cofiltered category.
-/
class PreservesCofilteredLimits (F : C ⥤ D) : Type max u₁ u₂ (v + 1) where
  preserves_cofiltered_limits :
    ∀ (J : Type v) [SmallCategory J] [IsCofiltered J], PreservesLimitsOfShape J F
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Limits.PreservesLimits.preservesCofilteredLimits
code: instance (priority := 100) PreservesLimits.preservesCofilteredLimits (F : C ⥤ D)
    [PreservesLimits F] : PreservesCofilteredLimits F 
goal: CategoryTheory.Limits.PreservesCofilteredLimits F

full_name: CategoryTheory.Limits.compPreservesCofilteredLimits
code: instance compPreservesCofilteredLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesCofilteredLimits F]
    [PreservesCofilteredLimits G] : PreservesCofilteredLimits (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesCofilteredLimits (F ⋙ G)
File: Mathlib/CategoryTheory/Limits/Final/ParallelPair.lean

full_name: CategoryTheory.Limits.parallelPair_initial_mk'
code: lemma parallelPair_initial_mk' {X Y : C} (f g : X ⟶ Y)
    (h₁ : ∀ Z, Nonempty (X ⟶ Z))
    (h₂ : ∀ ⦃Z : C⦄ (i j : X ⟶ Z),
      Zigzag (J := CostructuredArrow (parallelPair f g) Z)
        (mk (Y := zero) i) (mk (Y := zero) j)) :
    (parallelPair f g).Initial 
goal: (CategoryTheory.Limits.parallelPair f g).Initial

full_name: CategoryTheory.Limits.parallelPair_initial_mk
code: lemma parallelPair_initial_mk {X Y : C} (f g : X ⟶ Y)
    (h₁ : ∀ Z, Nonempty (X ⟶ Z))
    (h₂ : ∀ ⦃Z : C⦄ (i j : X ⟶ Z), ∃ (a : Y ⟶ Z), i = f ≫ a ∧ j = g ≫ a) :
    (parallelPair f g).Initial 
goal: (CategoryTheory.Limits.parallelPair f g).Initial
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Square.lean

full_name: CategoryTheory.Square.IsPullback.map
code: lemma IsPullback.map (h : sq.IsPullback) (F : C ⥤ D) [PreservesLimit (cospan sq.f₂₄ sq.f₃₄) F] :
    (sq.map F).IsPullback 
goal: (sq.map F).IsPullback

full_name: CategoryTheory.Square.IsPushout.map
code: lemma IsPushout.map (h : sq.IsPushout) (F : C ⥤ D) [PreservesColimit (span sq.f₁₂ sq.f₁₃) F] :
    (sq.map F).IsPushout 
goal: (sq.map F).IsPushout

full_name: CategoryTheory.Square.isPullback_iff_map_coyoneda_isPullback
code: lemma isPullback_iff_map_coyoneda_isPullback :
    sq.IsPullback ↔ ∀ (X : Cᵒᵖ), (sq.map (coyoneda.obj X)).IsPullback 
goal: sq.IsPullback ↔ ∀ (X : Cᵒᵖ), (sq.map (CategoryTheory.coyoneda.obj X)).IsPullback

full_name: CategoryTheory.Square.isPushout_iff_op_map_yoneda_isPullback
code: lemma isPushout_iff_op_map_yoneda_isPullback :
    sq.IsPushout ↔ ∀ (X : C), (sq.op.map (yoneda.obj X)).IsPullback 
goal: sq.IsPushout ↔ ∀ (X : C), (sq.op.map (CategoryTheory.yoneda.obj X)).IsPullback
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean

full_name: CategoryTheory.PreservesImage.iso
code: /-- If a functor preserves span and cospan, then it preserves images.
-/
@[simps!]
def iso {X Y : A} (f : X ⟶ Y) : image (L.map f) ≅ L.obj (image f) 
goal: CategoryTheory.Limits.image (L.map f) ≅ L.obj (CategoryTheory.Limits.image f)

full_name: CategoryTheory.PreservesImage.iso_hom
code: /-- If a functor preserves span and cospan, then it preserves images.
-/
@[simps!]
def iso {X Y : A} (f : X ⟶ Y) : image (L.map f) ≅ L.obj (image f) 
goal: (CategoryTheory.PreservesImage.iso L f).hom =
  CategoryTheory.Limits.image.lift
    (CategoryTheory.Limits.MonoFactorisation.mk (L.obj (CategoryTheory.Limits.image f))
      (L.map (CategoryTheory.Limits.image.ι f)) (L.map (CategoryTheory.Limits.factorThruImage f)) ⋯)

full_name: CategoryTheory.PreservesImage.iso_inv
code: /-- If a functor preserves span and cospan, then it preserves images.
-/
@[simps!]
def iso {X Y : A} (f : X ⟶ Y) : image (L.map f) ≅ L.obj (image f) 
goal: (CategoryTheory.PreservesImage.iso L f).inv =
  (CategoryTheory.Limits.StrongEpiMonoFactorisation.mk
          (CategoryTheory.Limits.MonoFactorisation.mk (L.obj (CategoryTheory.Limits.image f))
            (L.map (CategoryTheory.Limits.image.ι f)) (L.map (CategoryTheory.Limits.factorThruImage f))
            ⋯)).toMonoIsImage.lift
    (CategoryTheory.Limits.Image.monoFactorisation (L.map f))

full_name: CategoryTheory.PreservesImage.factorThruImage_comp_hom
code: @[reassoc]
theorem factorThruImage_comp_hom {X Y : A} (f : X ⟶ Y) :
    factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage (L.map f))
    (CategoryTheory.PreservesImage.iso L f).hom =
  L.map (CategoryTheory.Limits.factorThruImage f)

full_name: CategoryTheory.PreservesImage.hom_comp_map_image_ι
code: @[reassoc]
theorem hom_comp_map_image_ι {X Y : A} (f : X ⟶ Y) :
    (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.PreservesImage.iso L f).hom
    (L.map (CategoryTheory.Limits.image.ι f)) =
  CategoryTheory.Limits.image.ι (L.map f)

full_name: CategoryTheory.PreservesImage.inv_comp_image_ι_map
code: @[reassoc]
theorem inv_comp_image_ι_map {X Y : A} (f : X ⟶ Y) :
    (iso L f).inv ≫ image.ι (L.map f) = L.map (image.ι f) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.PreservesImage.iso L f).inv
    (CategoryTheory.Limits.image.ι (L.map f)) =
  L.map (CategoryTheory.Limits.image.ι f)