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

full_name: Profinite
code: /-- The type of profinite topological spaces. -/
abbrev Profinite 
goal: Type (u_1 + 1)

full_name: Profinite.instHasPropTotallyDisconnectedSpaceαTopologicalSpace
code: instance  (X : Type*) [TopologicalSpace X]
    [TotallyDisconnectedSpace X] :  HasProp (fun Y ↦ TotallyDisconnectedSpace Y) X 
goal: CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y) X

full_name: Profinite.of
code: /-- Construct a term of `Profinite` from a type endowed with the structure of a
compact, Hausdorff and totally disconnected topological space.
-/
abbrev of (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X]
    [TotallyDisconnectedSpace X] : Profinite 
goal: Profinite

full_name: Profinite.instInhabited
code: instance : Inhabited Profinite 
goal: Inhabited Profinite

full_name: Profinite.instTotallyDisconnectedSpaceαTopologicalSpaceToTop
code: instance {X : Profinite} : TotallyDisconnectedSpace X 
goal: TotallyDisconnectedSpace ↑X.toTop

full_name: Profinite.instTotallyDisconnectedSpaceObjForget
code: instance {X : Profinite} : TotallyDisconnectedSpace ((forget Profinite).obj X) 
goal: TotallyDisconnectedSpace ((CategoryTheory.forget Profinite).obj X)

full_name: profiniteToCompHaus
code: /-- The fully faithful embedding of `Profinite` in `CompHaus`. -/
abbrev profiniteToCompHaus : Profinite ⥤ CompHaus 
goal: Profinite ⥤ CompHaus

full_name: instTotallyDisconnectedSpaceαTopologicalSpaceToTopTrueObjProfiniteCompHausProfiniteToCompHaus
code: instance {X : Profinite} : TotallyDisconnectedSpace (profiniteToCompHaus.obj X) 
goal: TotallyDisconnectedSpace ↑(profiniteToCompHaus.obj X).toTop

full_name: Profinite.toTopCat
code: /-- The fully faithful embedding of `Profinite` in `TopCat`.
This is definitionally the same as the obvious composite. -/
abbrev Profinite.toTopCat : Profinite ⥤ TopCat 
goal: Profinite ⥤ TopCat

full_name: CompHaus.toProfiniteObj
code: /--
(Implementation) The object part of the connected_components functor from compact Hausdorff spaces
to Profinite spaces, given by quotienting a space by its connected components.
See: https://stacks.math.columbia.edu/tag/0900
-/
def CompHaus.toProfiniteObj (X : CompHaus.{u}) : Profinite.{u} 
goal: Profinite

full_name: Profinite.toCompHausEquivalence
code: /-- (Implementation) The bijection of homsets to establish the reflective adjunction of Profinite
spaces in compact Hausdorff spaces.
-/
def Profinite.toCompHausEquivalence (X : CompHaus.{u}) (Y : Profinite.{u}) :
    (CompHaus.toProfiniteObj X ⟶ Y) ≃ (X ⟶ profiniteToCompHaus.obj Y) 
goal: (X.toProfiniteObj ⟶ Y) ≃ (X ⟶ profiniteToCompHaus.obj Y)

full_name: CompHaus.toProfinite
code: /-- The connected_components functor from compact Hausdorff spaces to profinite spaces,
left adjoint to the inclusion functor.
-/
def CompHaus.toProfinite : CompHaus ⥤ Profinite 
goal: CompHaus ⥤ Profinite

full_name: CompHaus.toProfinite_obj'
code: theorem CompHaus.toProfinite_obj' (X : CompHaus) :
    ↥(CompHaus.toProfinite.obj X) = ConnectedComponents X 
goal: ↑(CompHaus.toProfinite.obj X).toTop = ConnectedComponents ↑X.toTop

full_name: FintypeCat.botTopology
code: /-- Finite types are given the discrete topology. -/
def FintypeCat.botTopology (A : FintypeCat) : TopologicalSpace A 
goal: TopologicalSpace ↑A

full_name: FintypeCat.discreteTopology
code: theorem FintypeCat.discreteTopology (A : FintypeCat) : DiscreteTopology A 
goal: DiscreteTopology ↑A

full_name: FintypeCat.toProfinite_obj
code: /-- The natural functor from `Fintype` to `Profinite`, endowing a finite type with the
discrete topology. -/
@[simps]
def FintypeCat.toProfinite : FintypeCat ⥤ Profinite 
goal: FintypeCat.toProfinite.obj A = Profinite.of ↑A

full_name: FintypeCat.toProfinite
code: /-- The natural functor from `Fintype` to `Profinite`, endowing a finite type with the
discrete topology. -/
@[simps]
def FintypeCat.toProfinite : FintypeCat ⥤ Profinite 
goal: FintypeCat ⥤ Profinite

full_name: FintypeCat.toProfinite_map_apply
code: /-- The natural functor from `Fintype` to `Profinite`, endowing a finite type with the
discrete topology. -/
@[simps]
def FintypeCat.toProfinite : FintypeCat ⥤ Profinite 
goal: ∀ {X Y : FintypeCat} (f : X ⟶ Y) (a : ↑X), (FintypeCat.toProfinite.map f) a = f a

full_name: FintypeCat.toProfiniteFullyFaithful
code: /-- `FintypeCat.toLightProfinite` is fully faithful. -/
def FintypeCat.toProfiniteFullyFaithful : toProfinite.FullyFaithful 
goal: FintypeCat.toProfinite.FullyFaithful

full_name: instFaithfulFintypeCatProfiniteToProfinite
code: instance : FintypeCat.toProfinite.Faithful 
goal: FintypeCat.toProfinite.Faithful

full_name: instFullFintypeCatProfiniteToProfinite
code: instance : FintypeCat.toProfinite.Full 
goal: FintypeCat.toProfinite.Full

full_name: Profinite.limitCone
code: /-- An explicit limit cone for a functor `F : J ⥤ Profinite`, defined in terms of
`CompHaus.limitCone`, which is defined in terms of `TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ Profinite.{max u v}) : Limits.Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: Profinite.limitConeIsLimit
code: /-- The limit cone `Profinite.limitCone F` is indeed a limit cone. -/
def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ Profinite.{max u v}) :
    Limits.IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (Profinite.limitCone F)

full_name: Profinite.toProfiniteAdjToCompHaus
code: /-- The adjunction between CompHaus.to_Profinite and Profinite.to_CompHaus -/
def toProfiniteAdjToCompHaus : CompHaus.toProfinite ⊣ profiniteToCompHaus 
goal: CompHaus.toProfinite ⊣ profiniteToCompHaus

full_name: Profinite.toCompHaus.reflective
code: /-- The category of profinite sets is reflective in the category of compact Hausdorff spaces -/
instance toCompHaus.reflective : Reflective profiniteToCompHaus 
goal: CategoryTheory.Reflective profiniteToCompHaus

full_name: Profinite.toCompHaus.createsLimits
code: noncomputable instance toCompHaus.createsLimits : CreatesLimits profiniteToCompHaus 
goal: CategoryTheory.CreatesLimits profiniteToCompHaus

full_name: Profinite.toTopCat.reflective
code: noncomputable instance toTopCat.reflective : Reflective Profinite.toTopCat 
goal: CategoryTheory.Reflective Profinite.toTopCat

full_name: Profinite.toTopCat.createsLimits
code: noncomputable instance toTopCat.createsLimits : CreatesLimits Profinite.toTopCat 
goal: CategoryTheory.CreatesLimits Profinite.toTopCat

full_name: Profinite.hasLimits
code: instance hasLimits : Limits.HasLimits Profinite 
goal: CategoryTheory.Limits.HasLimits Profinite

full_name: Profinite.hasColimits
code: instance hasColimits : Limits.HasColimits Profinite 
goal: CategoryTheory.Limits.HasColimits Profinite

full_name: Profinite.forgetPreservesLimits
code: noncomputable instance forgetPreservesLimits : Limits.PreservesLimits (forget Profinite) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget Profinite)

full_name: Profinite.epi_iff_surjective
code: theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f 
goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑f