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

full_name: LightProfinite
code: /-- `LightProfinite` is the category of second countable profinite spaces. -/
abbrev LightProfinite 
goal: Type (u_1 + 1)

full_name: LightProfinite.instHasPropAndTotallyDisconnectedSpaceαTopologicalSpaceSecondCountableTopology
code: instance (X : Type*) [TopologicalSpace X]
    [TotallyDisconnectedSpace X] [SecondCountableTopology X] : HasProp (fun Y ↦
      TotallyDisconnectedSpace Y ∧ SecondCountableTopology Y) X 
goal: CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y ∧ SecondCountableTopology ↑Y) X

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

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

full_name: LightProfinite.instTotallyDisconnectedSpaceαTopologicalSpaceToTopAndSecondCountableTopology
code: instance {X : LightProfinite} : TotallyDisconnectedSpace X 
goal: TotallyDisconnectedSpace ↑X.toTop

full_name: LightProfinite.instSecondCountableTopologyαTopologicalSpaceToTopAndTotallyDisconnectedSpace
code: instance {X : LightProfinite} : SecondCountableTopology X 
goal: SecondCountableTopology ↑X.toTop

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

full_name: LightProfinite.instSecondCountableTopologyObjForget
code: instance {X : LightProfinite} : SecondCountableTopology ((forget LightProfinite).obj X) 
goal: SecondCountableTopology ((CategoryTheory.forget LightProfinite).obj X)

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

full_name: lightToProfiniteFullyFaithful
code: /-- `lightToProfinite` is fully faithful. -/
abbrev lightToProfiniteFullyFaithful : lightToProfinite.FullyFaithful 
goal: lightToProfinite.FullyFaithful

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

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

full_name: FintypeCat.toLightProfinite_obj_toTop_str_IsOpen
code: /-- The natural functor from `Fintype` to `LightProfinite`, endowing a finite type with the
discrete topology. -/
@[simps!]
def FintypeCat.toLightProfinite : FintypeCat ⥤ LightProfinite 
goal: TopologicalSpace.IsOpen u = (u ∈ ⊤)

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

full_name: FintypeCat.toLightProfinite_obj_toTop_α
code: /-- The natural functor from `Fintype` to `LightProfinite`, endowing a finite type with the
discrete topology. -/
@[simps!]
def FintypeCat.toLightProfinite : FintypeCat ⥤ LightProfinite 
goal: ↑(FintypeCat.toLightProfinite.obj A).toTop = ↑A

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

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

full_name: instFaithfulFintypeCatLightProfiniteToLightProfinite
code: instance : FintypeCat.toLightProfinite.Faithful 
goal: FintypeCat.toLightProfinite.Faithful

full_name: instFullFintypeCatLightProfiniteToLightProfinite
code: instance : FintypeCat.toLightProfinite.Full 
goal: FintypeCat.toLightProfinite.Full

full_name: LightProfinite.instTotallyDisconnectedSpaceαTopologicalSpaceToTopTruePtCompHausLimitConeCompLightProfiniteToCompHaus
code: instance {J : Type v} [SmallCategory J] (F : J ⥤ LightProfinite.{max u v}) :
    TotallyDisconnectedSpace
      (CompHaus.limitCone.{v, u} (F ⋙ lightProfiniteToCompHaus)).pt.toTop 
goal: TotallyDisconnectedSpace ↑(CompHaus.limitCone (F ⋙ lightProfiniteToCompHaus)).pt.toTop

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

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

full_name: LightProfinite.createsCountableLimits
code: noncomputable instance createsCountableLimits {J : Type v} [SmallCategory J] [CountableCategory J] :
    CreatesLimitsOfShape J lightToProfinite.{max v u} 
goal: CategoryTheory.CreatesLimitsOfShape J lightToProfinite

full_name: LightProfinite.instHasCountableLimits
code: instance : HasCountableLimits LightProfinite 
goal: CategoryTheory.Limits.HasCountableLimits LightProfinite

full_name: LightProfinite.instPreservesLimitsOfShapeOppositeNatForget
code: noncomputable instance : PreservesLimitsOfShape ℕᵒᵖ (forget LightProfinite.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape ℕᵒᵖ (CategoryTheory.forget LightProfinite)

full_name: LightProfinite.isClosedMap
code: /-- Any morphism of light profinite spaces is a closed map. -/
theorem isClosedMap : IsClosedMap f 
goal: IsClosedMap ⇑f

full_name: LightProfinite.isIso_of_bijective
code: /-- Any continuous bijection of light profinite spaces induces an isomorphism. -/
theorem isIso_of_bijective (bij : Function.Bijective f) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: LightProfinite.isoOfBijective
code: /-- Any continuous bijection of light profinite spaces induces an isomorphism. -/
noncomputable def isoOfBijective (bij : Function.Bijective f) : X ≅ Y 
goal: X ≅ Y

full_name: LightProfinite.forget_reflectsIsomorphisms
code: instance forget_reflectsIsomorphisms : (forget LightProfinite).ReflectsIsomorphisms 
goal: (CategoryTheory.forget LightProfinite).ReflectsIsomorphisms

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

full_name: LightDiagram.cone
code: /-- A structure containing the data of sequential limit in `Profinite` of finite sets. -/
structure LightDiagram : Type (u+1) where
  /-- The indexing diagram. -/
  diagram : ℕᵒᵖ ⥤ FintypeCat
  /-- The limit cone. -/
  cone : Cone (diagram ⋙ FintypeCat.toProfinite.{u})
  /-- The limit cone is limiting. -/
  isLimit : IsLimit cone
goal: CategoryTheory.Limits.Cone (self.diagram ⋙ FintypeCat.toProfinite)

full_name: LightDiagram.isLimit
code: /-- A structure containing the data of sequential limit in `Profinite` of finite sets. -/
structure LightDiagram : Type (u+1) where
  /-- The indexing diagram. -/
  diagram : ℕᵒᵖ ⥤ FintypeCat
  /-- The limit cone. -/
  cone : Cone (diagram ⋙ FintypeCat.toProfinite.{u})
  /-- The limit cone is limiting. -/
  isLimit : IsLimit cone
goal: CategoryTheory.Limits.IsLimit self.cone

full_name: LightDiagram
code: /-- A structure containing the data of sequential limit in `Profinite` of finite sets. -/
structure LightDiagram : Type (u+1) where
  /-- The indexing diagram. -/
  diagram : ℕᵒᵖ ⥤ FintypeCat
  /-- The limit cone. -/
  cone : Cone (diagram ⋙ FintypeCat.toProfinite.{u})
  /-- The limit cone is limiting. -/
  isLimit : IsLimit cone
goal: Type (u + 1)

full_name: LightDiagram.diagram
code: /-- A structure containing the data of sequential limit in `Profinite` of finite sets. -/
structure LightDiagram : Type (u+1) where
  /-- The indexing diagram. -/
  diagram : ℕᵒᵖ ⥤ FintypeCat
  /-- The limit cone. -/
  cone : Cone (diagram ⋙ FintypeCat.toProfinite.{u})
  /-- The limit cone is limiting. -/
  isLimit : IsLimit cone
goal: ℕᵒᵖ ⥤ FintypeCat

full_name: LightDiagram.toProfinite
code: /-- The underlying `Profinite` of a `LightDiagram`. -/
def toProfinite (S : LightDiagram) : Profinite 
goal: Profinite

full_name: LightDiagram.instCategory_id_apply
code: @[simps!]
instance : Category LightDiagram 
goal: (𝟙 X) a = a

full_name: LightDiagram.instCategory_comp_apply
code: @[simps!]
instance : Category LightDiagram 
goal: ∀ {X Y Z : CategoryTheory.InducedCategory Profinite LightDiagram.toProfinite} (f : X ⟶ Y) (g : Y ⟶ Z)
  (a : ↑(LightDiagram.toProfinite X).toTop), (f ≫ g) a = g (f a)

full_name: LightDiagram.instCategory
code: @[simps!]
instance : Category LightDiagram 
goal: CategoryTheory.Category.{u_1, u_1 + 1} LightDiagram

full_name: LightDiagram.concreteCategory
code: instance concreteCategory : ConcreteCategory LightDiagram 
goal: CategoryTheory.ConcreteCategory LightDiagram

full_name: lightDiagramToProfinite
code: /-- The fully faithful embedding `LightDiagram ⥤ Profinite` -/
@[simps!]
def lightDiagramToProfinite : LightDiagram ⥤ Profinite 
goal: LightDiagram ⥤ Profinite

full_name: lightDiagramToProfinite_map
code: /-- The fully faithful embedding `LightDiagram ⥤ Profinite` -/
@[simps!]
def lightDiagramToProfinite : LightDiagram ⥤ Profinite 
goal: ∀ {X Y : CategoryTheory.InducedCategory Profinite LightDiagram.toProfinite} (f : X ⟶ Y),
  lightDiagramToProfinite.map f = f

full_name: lightDiagramToProfinite_obj
code: /-- The fully faithful embedding `LightDiagram ⥤ Profinite` -/
@[simps!]
def lightDiagramToProfinite : LightDiagram ⥤ Profinite 
goal: lightDiagramToProfinite.obj S = S.toProfinite

full_name: instFaithfulLightDiagramProfiniteLightDiagramToProfinite
code: instance : lightDiagramToProfinite.Faithful 
goal: lightDiagramToProfinite.Faithful

full_name: instFullLightDiagramProfiniteLightDiagramToProfinite
code: instance : lightDiagramToProfinite.Full 
goal: lightDiagramToProfinite.Full

full_name: instTopologicalSpaceObjLightDiagramForget
code: instance {X : LightDiagram} : TopologicalSpace ((forget LightDiagram).obj X) 
goal: TopologicalSpace ((CategoryTheory.forget LightDiagram).obj X)

full_name: instTotallyDisconnectedSpaceObjLightDiagramForget
code: instance {X : LightDiagram} : TotallyDisconnectedSpace ((forget LightDiagram).obj X) 
goal: TotallyDisconnectedSpace ((CategoryTheory.forget LightDiagram).obj X)

full_name: instCompactSpaceObjLightDiagramForget
code: instance {X : LightDiagram} : CompactSpace ((forget LightDiagram).obj X) 
goal: CompactSpace ((CategoryTheory.forget LightDiagram).obj X)

full_name: instT2SpaceObjLightDiagramForget
code: instance {X : LightDiagram} : T2Space ((forget LightDiagram).obj X) 
goal: T2Space ((CategoryTheory.forget LightDiagram).obj X)

full_name: LightProfinite.instCountableClopensαTopologicalSpaceToTopAndTotallyDisconnectedSpaceSecondCountableTopology
code: instance (S : LightProfinite) : Countable (Clopens S) 
goal: Countable (TopologicalSpace.Clopens ↑S.toTop)

full_name: LightProfinite.instCountableDiscreteQuotient
code: instance instCountableDiscreteQuotient (S : LightProfinite)  :
    Countable (DiscreteQuotient ((lightToProfinite.obj S))) 
goal: Countable (DiscreteQuotient ↑(lightToProfinite.obj S).toTop)

full_name: LightProfinite.toLightDiagram
code: /-- A profinite space which is light gives rise to a light profinite space. -/
noncomputable def toLightDiagram (S : LightProfinite.{u}) : LightDiagram.{u} 
goal: LightDiagram

full_name: lightProfiniteToLightDiagram_obj
code: /-- The functor part of the equivalence `LightProfinite ≌ LightDiagram` -/
@[simps]
noncomputable def lightProfiniteToLightDiagram : LightProfinite.{u} ⥤ LightDiagram.{u} 
goal: lightProfiniteToLightDiagram.obj X = X.toLightDiagram

full_name: lightProfiniteToLightDiagram_map
code: /-- The functor part of the equivalence `LightProfinite ≌ LightDiagram` -/
@[simps]
noncomputable def lightProfiniteToLightDiagram : LightProfinite.{u} ⥤ LightDiagram.{u} 
goal: ∀ {X Y : LightProfinite} (f : X ⟶ Y), lightProfiniteToLightDiagram.map f = f

full_name: lightProfiniteToLightDiagram
code: /-- The functor part of the equivalence `LightProfinite ≌ LightDiagram` -/
@[simps]
noncomputable def lightProfiniteToLightDiagram : LightProfinite.{u} ⥤ LightDiagram.{u} 
goal: LightProfinite ⥤ LightDiagram

full_name: instSecondCountableTopologyαTopologicalSpaceToTopTotallyDisconnectedSpacePtOppositeNatProfiniteCone
code: instance (S : LightDiagram.{u}) : SecondCountableTopology S.cone.pt 
goal: SecondCountableTopology ↑S.cone.pt.toTop

full_name: lightDiagramToLightProfinite
code: /-- The inverse part of the equivalence `LightProfinite ≌ LightDiagram` -/
@[simps]
def lightDiagramToLightProfinite : LightDiagram.{u} ⥤ LightProfinite.{u} 
goal: LightDiagram ⥤ LightProfinite

full_name: lightDiagramToLightProfinite_obj
code: /-- The inverse part of the equivalence `LightProfinite ≌ LightDiagram` -/
@[simps]
def lightDiagramToLightProfinite : LightDiagram.{u} ⥤ LightProfinite.{u} 
goal: lightDiagramToLightProfinite.obj X = LightProfinite.of ↑X.cone.pt.toTop

full_name: lightDiagramToLightProfinite_map
code: /-- The inverse part of the equivalence `LightProfinite ≌ LightDiagram` -/
@[simps]
def lightDiagramToLightProfinite : LightDiagram.{u} ⥤ LightProfinite.{u} 
goal: ∀ {X Y : LightDiagram} (f : X ⟶ Y), lightDiagramToLightProfinite.map f = f

full_name: LightProfinite.equivDiagram
code: /-- The equivalence of categories `LightProfinite ≌ LightDiagram` -/
noncomputable def LightProfinite.equivDiagram : LightProfinite.{u} ≌ LightDiagram.{u} 
goal: LightProfinite ≌ LightDiagram

full_name: instIsEquivalenceLightProfiniteLightDiagramLightProfiniteToLightDiagram
code: instance : lightProfiniteToLightDiagram.IsEquivalence 
goal: lightProfiniteToLightDiagram.IsEquivalence

full_name: instIsEquivalenceLightDiagramLightProfiniteLightDiagramToLightProfinite
code: instance : lightDiagramToLightProfinite.IsEquivalence 
goal: lightDiagramToLightProfinite.IsEquivalence

full_name: LightDiagram'.diagram
code: /--
This is an auxiliary definition used to show that `LightDiagram` is essentially small.

Note that below we put a category instance on this structure which is completely different from the
category instance on `ℕᵒᵖ ⥤ FintypeCat.Skeleton.{u}`. Neither the morphisms nor the objects are the
same.
-/
structure LightDiagram' : Type u where
  /-- The diagram takes values in a small category equivalent to `FintypeCat`. -/
  diagram : ℕᵒᵖ ⥤ FintypeCat.Skeleton.{u}
goal: ℕᵒᵖ ⥤ FintypeCat.Skeleton

full_name: LightDiagram'
code: /--
This is an auxiliary definition used to show that `LightDiagram` is essentially small.

Note that below we put a category instance on this structure which is completely different from the
category instance on `ℕᵒᵖ ⥤ FintypeCat.Skeleton.{u}`. Neither the morphisms nor the objects are the
same.
-/
structure LightDiagram' : Type u where
  /-- The diagram takes values in a small category equivalent to `FintypeCat`. -/
  diagram : ℕᵒᵖ ⥤ FintypeCat.Skeleton.{u}
goal: Type u

full_name: LightDiagram'.toProfinite
code: /-- A `LightDiagram'` yields a `Profinite`. -/
def LightDiagram'.toProfinite (S : LightDiagram') : Profinite 
goal: Profinite

full_name: instCategoryLightDiagram'
code: instance : Category LightDiagram' 
goal: CategoryTheory.Category.{u_1, u_1} LightDiagram'

full_name: LightDiagram'.toLightFunctor
code: /-- The functor part of the equivalence of categories `LightDiagram' ≌ LightDiagram`. -/
def LightDiagram'.toLightFunctor : LightDiagram'.{u} ⥤ LightDiagram.{u} 
goal: LightDiagram' ⥤ LightDiagram

full_name: instFaithfulLightDiagram'LightDiagramToLightFunctor
code: instance : LightDiagram'.toLightFunctor.{u}.Faithful 
goal: LightDiagram'.toLightFunctor.Faithful

full_name: instFullLightDiagram'LightDiagramToLightFunctor
code: instance : LightDiagram'.toLightFunctor.{u}.Full 
goal: LightDiagram'.toLightFunctor.Full

full_name: instEssSurjLightDiagram'LightDiagramToLightFunctor
code: instance : LightDiagram'.toLightFunctor.{u}.EssSurj 
goal: LightDiagram'.toLightFunctor.EssSurj

full_name: instIsEquivalenceLightDiagram'LightDiagramToLightFunctor
code: instance : LightDiagram'.toLightFunctor.IsEquivalence 
goal: LightDiagram'.toLightFunctor.IsEquivalence

full_name: LightDiagram.equivSmall
code: /-- The equivalence beween `LightDiagram` and a small category. -/
def LightDiagram.equivSmall : LightDiagram.{u} ≌ LightDiagram'.{u} 
goal: LightDiagram ≌ LightDiagram'

full_name: instEssentiallySmallLightDiagram
code: instance : EssentiallySmall.{u} LightDiagram.{u} 
goal: CategoryTheory.EssentiallySmall.{u, u, u + 1} LightDiagram

full_name: instEssentiallySmallLightProfinite
code: instance : EssentiallySmall.{u} LightProfinite.{u} 
goal: CategoryTheory.EssentiallySmall.{u, u, u + 1} LightProfinite