File: Mathlib/Topology/Category/CompHausLike/Limits.lean

full_name: CompHausLike.HasExplicitFiniteCoproduct
code: /--
A typeclass describing the property that forming the disjoint union is stable under the
property `P`.
-/
abbrev HasExplicitFiniteCoproduct 
goal: Prop

full_name: CompHausLike.finiteCoproduct
code: /--
The coproduct of a finite family of objects in `CompHaus`, constructed as the disjoint
union with its usual topology.
-/
def finiteCoproduct : CompHausLike P 
goal: CompHausLike P

full_name: CompHausLike.finiteCoproduct.ι
code: /--
The inclusion of one of the factors into the explicit finite coproduct.
-/
def finiteCoproduct.ι (a : α) : X a ⟶ finiteCoproduct X 
goal: X a ⟶ CompHausLike.finiteCoproduct X

full_name: CompHausLike.finiteCoproduct.desc
code: /--
To construct a morphism from the explicit finite coproduct, it suffices to
specify a morphism from each of its factors.
This is essentially the universal property of the coproduct.
-/
def finiteCoproduct.desc {B : CompHausLike P} (e : (a : α) → (X a ⟶ B)) :
    finiteCoproduct X ⟶ B 
goal: CompHausLike.finiteCoproduct X ⟶ B

full_name: CompHausLike.finiteCoproduct.ι_desc
code: @[reassoc (attr := simp)]
lemma finiteCoproduct.ι_desc {B : CompHausLike P} (e : (a : α) → (X a ⟶ B)) (a : α) :
    finiteCoproduct.ι X a ≫ finiteCoproduct.desc X e = e a 
goal: CategoryTheory.CategoryStruct.comp (CompHausLike.finiteCoproduct.ι X a) (CompHausLike.finiteCoproduct.desc X e) = e a

full_name: CompHausLike.finiteCoproduct.hom_ext
code: lemma finiteCoproduct.hom_ext {B : CompHausLike P} (f g : finiteCoproduct X ⟶ B)
    (h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g 
goal: f = g

full_name: CompHausLike.finiteCoproduct.cofan
code: /-- The coproduct cocone associated to the explicit finite coproduct. -/
abbrev finiteCoproduct.cofan : Limits.Cofan X 
goal: CategoryTheory.Limits.Cofan X

full_name: CompHausLike.finiteCoproduct.isColimit
code: /-- The explicit finite coproduct cocone is a colimit cocone. -/
def finiteCoproduct.isColimit : Limits.IsColimit (finiteCoproduct.cofan X) 
goal: CategoryTheory.Limits.IsColimit (CompHausLike.finiteCoproduct.cofan X)

full_name: CompHausLike.finiteCoproduct.ι_injective
code: lemma finiteCoproduct.ι_injective (a : α) : Function.Injective (finiteCoproduct.ι X a) 
goal: Function.Injective ⇑(CompHausLike.finiteCoproduct.ι X a)

full_name: CompHausLike.finiteCoproduct.ι_jointly_surjective
code: lemma finiteCoproduct.ι_jointly_surjective (R : finiteCoproduct X) :
    ∃ (a : α) (r : X a), R = finiteCoproduct.ι X a r 
goal: ∃ a r, R = (CompHausLike.finiteCoproduct.ι X a) r

full_name: CompHausLike.finiteCoproduct.ι_desc_apply
code: lemma finiteCoproduct.ι_desc_apply {B : CompHausLike P} {π : (a : α) → X a ⟶ B} (a : α) :
    ∀ x, finiteCoproduct.desc X π (finiteCoproduct.ι X a x) = π a x 
goal: (CompHausLike.finiteCoproduct.desc X π) ((CompHausLike.finiteCoproduct.ι X a) x) = (π a) x

full_name: CompHausLike.instHasCoproduct
code: instance : HasCoproduct X 
goal: CategoryTheory.Limits.HasCoproduct X

full_name: CompHausLike.HasExplicitFiniteCoproducts
code: /--
A typeclass describing the property that forming all finite disjoint unions is stable under the
property `P`.
-/
class HasExplicitFiniteCoproducts : Prop where
  hasProp {α : Type w} [Finite α] (X : α → CompHausLike.{max u w} P) : HasExplicitFiniteCoproduct X
goal: Prop

full_name: CompHausLike.HasExplicitFiniteCoproducts.hasProp
code: /--
A typeclass describing the property that forming all finite disjoint unions is stable under the
property `P`.
-/
class HasExplicitFiniteCoproducts : Prop where
  hasProp {α : Type w} [Finite α] (X : α → CompHausLike.{max u w} P) : HasExplicitFiniteCoproduct X
goal: CompHausLike.HasExplicitFiniteCoproduct X

full_name: CompHausLike.instHasColimitsOfShapeDiscreteOfHasExplicitFiniteCoproductsOfFinite
code: instance [HasExplicitFiniteCoproducts.{w} P] (α : Type w) [Finite α] :
    HasColimitsOfShape (Discrete α) (CompHausLike P) 
goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete α) (CompHausLike P)

full_name: CompHausLike.instHasFiniteCoproductsOfHasExplicitFiniteCoproducts
code: instance [HasExplicitFiniteCoproducts.{w} P] : HasFiniteCoproducts (CompHausLike.{max u w} P) 
goal: CategoryTheory.Limits.HasFiniteCoproducts (CompHausLike P)

full_name: CompHausLike.finiteCoproduct.openEmbedding_ι
code: /-- The inclusion maps into the explicit finite coproduct are open embeddings. -/
lemma finiteCoproduct.openEmbedding_ι (a : α) :
    OpenEmbedding (finiteCoproduct.ι X a) 
goal: OpenEmbedding ⇑(CompHausLike.finiteCoproduct.ι X a)

full_name: CompHausLike.Sigma.openEmbedding_ι
code: /-- The inclusion maps into the abstract finite coproduct are open embeddings. -/
lemma Sigma.openEmbedding_ι (a : α) :
    OpenEmbedding (Sigma.ι X a) 
goal: OpenEmbedding ⇑(CategoryTheory.Limits.Sigma.ι X a)

full_name: CompHausLike.instPreservesFiniteCoproductsTopCatCompHausLikeToTopOfHasExplicitFiniteCoproducts
code: /-- The functor to `TopCat` preserves finite coproducts if they exist. -/
instance (P) [HasExplicitFiniteCoproducts.{0} P] :
    PreservesFiniteCoproducts (compHausLikeToTop P) 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts (CompHausLike.compHausLikeToTop P)

full_name: CompHausLike.instPreservesFiniteCoproductsToCompHausLike
code: /-- The functor to another `CompHausLike` preserves finite coproducts if they exist. -/
noncomputable instance {P' : TopCat.{u} → Prop}
    (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
    PreservesFiniteCoproducts (toCompHausLike h) 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts (CompHausLike.toCompHausLike h)

full_name: CompHausLike.HasExplicitPullback
code: /--
A typeclass describing the property that an explicit pullback is stable under the property `P`.
-/
abbrev HasExplicitPullback 
goal: Prop

full_name: CompHausLike.pullback
code: /--
The pullback of two morphisms `f,g` in `CompHaus`, constructed explicitly as the set of
pairs `(x,y)` such that `f x = g y`, with the topology induced by the product.
-/
def pullback : CompHausLike P 
goal: CompHausLike P

full_name: CompHausLike.pullback.fst
code: /--
The projection from the pullback to the first component.
-/
def pullback.fst : pullback f g ⟶ X 
goal: CompHausLike.pullback f g ⟶ X

full_name: CompHausLike.pullback.snd
code: /--
The projection from the pullback to the second component.
-/
def pullback.snd : pullback f g ⟶ Y 
goal: CompHausLike.pullback f g ⟶ Y

full_name: CompHausLike.pullback.condition
code: @[reassoc]
lemma pullback.condition : pullback.fst f g ≫ f = pullback.snd f g ≫ g 
goal: CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.fst f g) f =
  CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.snd f g) g

full_name: CompHausLike.pullback.lift
code: /--
Construct a morphism to the explicit pullback given morphisms to the factors
which are compatible with the maps to the base.
This is essentially the universal property of the pullback.
-/
def pullback.lift {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    Z ⟶ pullback f g 
goal: Z ⟶ CompHausLike.pullback f g

full_name: CompHausLike.pullback.lift_fst
code: @[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a 
goal: CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.lift f g a b w) (CompHausLike.pullback.fst f g) = a

full_name: CompHausLike.pullback.lift_snd
code: @[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.snd f g = b 
goal: CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.lift f g a b w) (CompHausLike.pullback.snd f g) = b

full_name: CompHausLike.pullback.hom_ext
code: lemma pullback.hom_ext {Z : CompHausLike P} (a b : Z ⟶ pullback f g)
    (hfst : a ≫ pullback.fst f g = b ≫ pullback.fst f g)
    (hsnd : a ≫ pullback.snd f g = b ≫ pullback.snd f g) : a = b 
goal: a = b

full_name: CompHausLike.pullback.cone_π
code: /--
The pullback cone whose cone point is the explicit pullback.
-/
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
goal: (CompHausLike.pullback.cone f g).π =
  {
    app := fun j =>
      Option.rec (CategoryTheory.CategoryStruct.comp (CompHausLike.pullback.fst f g) f)
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CompHausLike.pullback.fst f g) (CompHausLike.pullback.snd f g) val)
        j,
    naturality := ⋯ }

full_name: CompHausLike.pullback.cone_pt
code: /--
The pullback cone whose cone point is the explicit pullback.
-/
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
goal: (CompHausLike.pullback.cone f g).pt = CompHausLike.pullback f g

full_name: CompHausLike.pullback.cone
code: /--
The pullback cone whose cone point is the explicit pullback.
-/
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
goal: CategoryTheory.Limits.PullbackCone f g

full_name: CompHausLike.pullback.isLimit
code: /--
The explicit pullback cone is a limit cone.
-/
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) 
goal: CategoryTheory.Limits.IsLimit (CompHausLike.pullback.cone f g)

full_name: CompHausLike.pullback.isLimit_lift
code: /--
The explicit pullback cone is a limit cone.
-/
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) 
goal: (CompHausLike.pullback.isLimit f g).lift s = CompHausLike.pullback.lift f g s.fst s.snd ⋯

full_name: CompHausLike.instHasLimitWalkingCospanCospan
code: instance : HasLimit (cospan f g) 
goal: CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan f g)

full_name: CompHausLike.instCreatesLimitTopCatWalkingCospanCospanCompHausLikeToTop
code: /-- The functor to `TopCat` creates pullbacks if they exist. -/
noncomputable instance : CreatesLimit (cospan f g) (compHausLikeToTop P) 
goal: CategoryTheory.CreatesLimit (CategoryTheory.Limits.cospan f g) (CompHausLike.compHausLikeToTop P)

full_name: CompHausLike.instPreservesLimitTopCatWalkingCospanCospanCompHausLikeToTop
code: /-- The functor to `TopCat` preserves pullbacks. -/
noncomputable instance : PreservesLimit (cospan f g) (compHausLikeToTop P) 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) (CompHausLike.compHausLikeToTop P)

full_name: CompHausLike.instPreservesLimitWalkingCospanCospanToCompHausLike
code: /-- The functor to another `CompHausLike` preserves pullbacks. -/
noncomputable instance {P' : TopCat → Prop}
    (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
    PreservesLimit (cospan f g) (toCompHausLike h) 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) (CompHausLike.toCompHausLike h)

full_name: CompHausLike.HasExplicitPullbacks
code: /--
A typeclass describing the property that forming all explicit pullbacks is stable under the
property `P`.
-/
class HasExplicitPullbacks : Prop where
  hasProp {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) : HasExplicitPullback f g
goal: Prop

full_name: CompHausLike.HasExplicitPullbacks.hasProp
code: /--
A typeclass describing the property that forming all explicit pullbacks is stable under the
property `P`.
-/
class HasExplicitPullbacks : Prop where
  hasProp {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) : HasExplicitPullback f g
goal: CompHausLike.HasExplicitPullback f g

full_name: CompHausLike.instHasPullbacksOfHasExplicitPullbacks
code: instance [HasExplicitPullbacks P] : HasPullbacks (CompHausLike P) 
goal: CategoryTheory.Limits.HasPullbacks (CompHausLike P)

full_name: CompHausLike.HasExplicitPullbacksOfInclusions.hasProp
code: /--
A typeclass describing the property that explicit pullbacks along inclusion maps into disjoint
unions is stable under the property `P`.
-/
class HasExplicitPullbacksOfInclusions [HasExplicitFiniteCoproducts.{0} P] : Prop where
  hasProp : ∀ {X Y Z : CompHausLike P} (f : Z ⟶ X ⨿ Y), HasExplicitPullback coprod.inl f
goal: CompHausLike.HasExplicitPullback CategoryTheory.Limits.coprod.inl f

full_name: CompHausLike.HasExplicitPullbacksOfInclusions
code: /--
A typeclass describing the property that explicit pullbacks along inclusion maps into disjoint
unions is stable under the property `P`.
-/
class HasExplicitPullbacksOfInclusions [HasExplicitFiniteCoproducts.{0} P] : Prop where
  hasProp : ∀ {X Y Z : CompHausLike P} (f : Z ⟶ X ⨿ Y), HasExplicitPullback coprod.inl f
goal: Prop

full_name: CompHausLike.instHasExplicitPullbacksOfInclusionsOfHasExplicitPullbacks
code: instance [HasExplicitPullbacks P] [HasExplicitFiniteCoproducts.{0} P] :
    HasExplicitPullbacksOfInclusions P 
goal: CompHausLike.HasExplicitPullbacksOfInclusions P

full_name: CompHausLike.instHasPullbacksOfInclusionsOfHasExplicitPullbacksOfInclusions
code: instance [HasExplicitPullbacksOfInclusions P] : HasPullbacksOfInclusions (CompHausLike P) 
goal: CategoryTheory.HasPullbacksOfInclusions (CompHausLike P)

full_name: CompHausLike.hasPullbacksOfInclusions
code: theorem hasPullbacksOfInclusions
    (hP' : ∀ ⦃X Y B : CompHausLike.{u} P⦄ (f : X ⟶ B) (g : Y ⟶ B)
      (_ : OpenEmbedding f), HasExplicitPullback f g) :
    HasExplicitPullbacksOfInclusions P 
goal: CompHausLike.HasExplicitPullbacksOfInclusions P

full_name: CompHausLike.instPreservesPullbacksOfInclusionsTopCatCompHausLikeToTopOfHasExplicitPullbacksOfInclusions
code: /-- The functor to `TopCat` preserves pullbacks of inclusions if they exist. -/
noncomputable instance [HasExplicitPullbacksOfInclusions P] :
    PreservesPullbacksOfInclusions (compHausLikeToTop P) 
goal: CategoryTheory.PreservesPullbacksOfInclusions (CompHausLike.compHausLikeToTop P)

full_name: CompHausLike.instFinitaryExtensiveOfHasExplicitPullbacksOfInclusions
code: instance [HasExplicitPullbacksOfInclusions P] : FinitaryExtensive (CompHausLike P) 
goal: CategoryTheory.FinitaryExtensive (CompHausLike P)

full_name: CompHausLike.finitaryExtensive
code: theorem finitaryExtensive (hP' : ∀ ⦃X Y B : CompHausLike.{u} P⦄ (f : X ⟶ B) (g : Y ⟶ B)
    (_ : OpenEmbedding f), HasExplicitPullback f g) :
      FinitaryExtensive (CompHausLike P) 
goal: CategoryTheory.FinitaryExtensive (CompHausLike P)

full_name: CompHausLike.isTerminalPUnit
code: /-- A one-element space is terminal in `CompHaus` -/
def isTerminalPUnit [HasProp P PUnit.{u+1}] :
    IsTerminal (CompHausLike.of P PUnit.{u + 1}) 
goal: CategoryTheory.Limits.IsTerminal (CompHausLike.of P PUnit.{u + 1})