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

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

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

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

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

full_name: LightProfinite.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 : LightProfinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    Z ⟶ pullback f g 
goal: Z ⟶ LightProfinite.pullback f g

full_name: LightProfinite.pullback.lift_fst
code: @[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : LightProfinite.{u}} (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 (LightProfinite.pullback.lift f g a b w) (LightProfinite.pullback.fst f g) = a

full_name: LightProfinite.pullback.lift_snd
code: @[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : LightProfinite.{u}} (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 (LightProfinite.pullback.lift f g a b w) (LightProfinite.pullback.snd f g) = b

full_name: LightProfinite.pullback.hom_ext
code: lemma pullback.hom_ext {Z : LightProfinite.{u}} (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: LightProfinite.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: LightProfinite.pullback.cone_pt
code: /-- The pullback cone whose cone point is the explicit pullback. -/
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
goal: (LightProfinite.pullback.cone f g).pt = LightProfinite.pullback f g

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

full_name: LightProfinite.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 (LightProfinite.pullback.cone f g)

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

full_name: LightProfinite.pullbackIsoPullback
code: /-- The isomorphism from the explicit pullback to the abstract pullback. -/
noncomputable
def pullbackIsoPullback : LightProfinite.pullback f g ≅ Limits.pullback f g 
goal: LightProfinite.pullback f g ≅ CategoryTheory.Limits.pullback f g

full_name: LightProfinite.pullbackHomeoPullback
code: /-- The homeomorphism from the explicit pullback to the abstract pullback. -/
noncomputable
def pullbackHomeoPullback : (LightProfinite.pullback f g).toTop ≃ₜ
    (Limits.pullback f g).toTop 
goal: ↑(LightProfinite.pullback f g).toTop ≃ₜ ↑(CategoryTheory.Limits.pullback f g).toTop

full_name: LightProfinite.pullback_fst_eq
code: theorem pullback_fst_eq :
    LightProfinite.pullback.fst f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.fst f g 
goal: LightProfinite.pullback.fst f g =
  CategoryTheory.CategoryStruct.comp (LightProfinite.pullbackIsoPullback f g).hom
    (CategoryTheory.Limits.pullback.fst f g)

full_name: LightProfinite.pullback_snd_eq
code: theorem pullback_snd_eq :
    LightProfinite.pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd f g 
goal: LightProfinite.pullback.snd f g =
  CategoryTheory.CategoryStruct.comp (LightProfinite.pullbackIsoPullback f g).hom
    (CategoryTheory.Limits.pullback.snd f g)

full_name: LightProfinite.finiteCoproduct
code: /--
The "explicit" coproduct of a finite family of objects in `LightProfinite`, whose underlying
profinite set is the disjoint union with its usual topology.
-/
def finiteCoproduct : LightProfinite 
goal: LightProfinite

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

full_name: LightProfinite.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 the universal property of the coproduct.
-/
def finiteCoproduct.desc {B : LightProfinite.{max u w}} (e : (a : α) → (X a ⟶ B)) :
    finiteCoproduct X ⟶ B 
goal: LightProfinite.finiteCoproduct X ⟶ B

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

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

full_name: LightProfinite.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: LightProfinite.finiteCoproduct.isColimit
code: /-- The explicit finite coproduct cocone is a colimit cocone. -/
def finiteCoproduct.isColimit : Limits.IsColimit (finiteCoproduct.cofan X) 
goal: CategoryTheory.Limits.IsColimit (LightProfinite.finiteCoproduct.cofan X)

full_name: LightProfinite.instHasColimitDiscreteFinFunctorCompObjMk
code: instance (n : ℕ) (F : Discrete (Fin n) ⥤ LightProfinite) :
    HasColimit (Discrete.functor (F.obj ∘ Discrete.mk) : Discrete (Fin n) ⥤ LightProfinite) 
goal: CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor (F.obj ∘ CategoryTheory.Discrete.mk))

full_name: LightProfinite.instHasFiniteCoproducts
code: instance : HasFiniteCoproducts LightProfinite 
goal: CategoryTheory.Limits.HasFiniteCoproducts LightProfinite

full_name: LightProfinite.coproductIsoCoproduct
code: /-- The isomorphism from the explicit finite coproducts to the abstract coproduct. -/
noncomputable
def coproductIsoCoproduct : finiteCoproduct X ≅ ∐ X 
goal: LightProfinite.finiteCoproduct X ≅ ∐ X

full_name: LightProfinite.Sigma.ι_comp_toFiniteCoproduct
code: theorem Sigma.ι_comp_toFiniteCoproduct (a : α) :
    (Limits.Sigma.ι X a) ≫ (coproductIsoCoproduct X).inv = finiteCoproduct.ι X a 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι X a) (LightProfinite.coproductIsoCoproduct X).inv =
  LightProfinite.finiteCoproduct.ι X a

full_name: LightProfinite.coproductHomeoCoproduct
code: /-- The homeomorphism from the explicit finite coproducts to the abstract coproduct. -/
noncomputable
def coproductHomeoCoproduct : finiteCoproduct X ≃ₜ (∐ X : _) 
goal: ↑(LightProfinite.finiteCoproduct X).toTop ≃ₜ ↑(∐ X).toTop

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

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

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

full_name: LightProfinite.instHasPullbacks
code: instance : HasPullbacks LightProfinite 
goal: CategoryTheory.Limits.HasPullbacks LightProfinite

full_name: LightProfinite.instPreservesFiniteCoproductsProfiniteLightToProfinite
code: noncomputable
instance : PreservesFiniteCoproducts lightToProfinite 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts lightToProfinite

full_name: LightProfinite.instPreservesLimitsOfShapeProfiniteWalkingCospanLightToProfinite
code: noncomputable
instance : PreservesLimitsOfShape WalkingCospan lightToProfinite 
goal: CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingCospan lightToProfinite

full_name: LightProfinite.instUniqueHomOfPUnit
code: instance (X : LightProfinite) :
    Unique (X ⟶ LightProfinite.of PUnit.{u+1}) 
goal: Unique (X ⟶ LightProfinite.of PUnit.{u + 1})

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

full_name: LightProfinite.instHasTerminal
code: instance : HasTerminal LightProfinite.{u} 
goal: CategoryTheory.Limits.HasTerminal LightProfinite

full_name: LightProfinite.terminalIsoPUnit
code: /-- The isomorphism from an arbitrary terminal object of `LightProfinite` to a one-element space. -/
noncomputable def terminalIsoPUnit : ⊤_ LightProfinite.{u} ≅ LightProfinite.of PUnit.{u+1} 
goal: ⊤_ LightProfinite ≅ LightProfinite.of PUnit.{u + 1}

full_name: LightProfinite.instPreservesFiniteCoproductsTopCatToTopCat
code: noncomputable instance : PreservesFiniteCoproducts LightProfinite.toTopCat.{u} 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts LightProfinite.toTopCat

full_name: LightProfinite.instPreservesLimitsOfShapeTopCatWalkingCospanToTopCat
code: noncomputable instance : PreservesLimitsOfShape WalkingCospan LightProfinite.toTopCat.{u} 
goal: CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingCospan LightProfinite.toTopCat

full_name: LightProfinite.instFinitaryExtensive
code: instance : FinitaryExtensive LightProfinite.{u} 
goal: CategoryTheory.FinitaryExtensive LightProfinite