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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: Profinite.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 : Profinite.{max u w}} (e : (a : α) → (X a ⟶ B)) :
    finiteCoproduct X ⟶ B 
goal: Profinite.finiteCoproduct X ⟶ B

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

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

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

full_name: Profinite.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) (Profinite.coproductIsoCoproduct X).inv =
  Profinite.finiteCoproduct.ι X a

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

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

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

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

full_name: Profinite.instPreservesFiniteCoproductsCompHausProfiniteToCompHaus
code: instance : PreservesFiniteCoproducts profiniteToCompHaus 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts profiniteToCompHaus

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

full_name: Profinite.instFinitaryExtensive
code: instance : FinitaryExtensive Profinite 
goal: CategoryTheory.FinitaryExtensive Profinite