File: Mathlib/Topology/Category/Compactum.lean

full_name: _aux_Mathlib_Topology_Category_Compactum___macroRules_termβ_1
code: local notation "β" => ofTypeMonad Ultrafilter
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Category_Compactum___unexpand_CategoryTheory_ofTypeMonad_1
code: local notation "β" => ofTypeMonad Ultrafilter
goal: Lean.PrettyPrinter.Unexpander

full_name: Compactum
code: /-- The type `Compactum` of Compacta, defined as algebras for the ultrafilter monad. -/
def Compactum 
goal: Type (u_1 + 1)

full_name: Compactum.forget
code: /-- The forgetful functor to Type* -/
def forget : Compactum ⥤ Type* 
goal: Compactum ⥤ Type u_1

full_name: Compactum.instFaithfulForget
code: instance : forget.Faithful 
goal: Compactum.forget.Faithful

full_name: Compactum.instCreatesLimitsForget
code: noncomputable instance : CreatesLimits forget 
goal: CategoryTheory.CreatesLimits Compactum.forget

full_name: Compactum.free
code: /-- The "free" Compactum functor. -/
def free : Type* ⥤ Compactum 
goal: Type u_1 ⥤ Compactum

full_name: Compactum.adj
code: /-- The adjunction between `free` and `forget`. -/
def adj : free ⊣ forget 
goal: Compactum.free ⊣ Compactum.forget

full_name: Compactum.instConcreteCategory
code: instance : ConcreteCategory Compactum 
goal: CategoryTheory.ConcreteCategory Compactum

full_name: Compactum.instCoeSortType
code: instance : CoeSort Compactum Type* 
goal: CoeSort Compactum (Type u_1)

full_name: Compactum.instCoeFunHomForallA
code: instance {X Y : Compactum} : CoeFun (X ⟶ Y) fun _ => X → Y 
goal: CoeFun (X ⟶ Y) fun x => X.A → Y.A

full_name: Compactum.instHasLimits
code: instance : HasLimits Compactum 
goal: CategoryTheory.Limits.HasLimits Compactum

full_name: Compactum.str
code: /-- The structure map for a compactum, essentially sending an ultrafilter to its limit. -/
def str (X : Compactum) : Ultrafilter X → X 
goal: Ultrafilter X.A → X.A

full_name: Compactum.join
code: /-- The monadic join. -/
def join (X : Compactum) : Ultrafilter (Ultrafilter X) → Ultrafilter X 
goal: Ultrafilter (Ultrafilter X.A) → Ultrafilter X.A

full_name: Compactum.incl
code: /-- The inclusion of `X` into `Ultrafilter X`. -/
def incl (X : Compactum) : X → Ultrafilter X 
goal: X.A → Ultrafilter X.A

full_name: Compactum.str_incl
code: @[simp]
theorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x 
goal: X.str (X.incl x) = x

full_name: Compactum.str_hom_commute
code: @[simp]
theorem str_hom_commute (X Y : Compactum) (f : X ⟶ Y) (xs : Ultrafilter X) :
    f (X.str xs) = Y.str (map f xs) 
goal: f.f (X.str xs) = Y.str (Ultrafilter.map f.f xs)

full_name: Compactum.join_distrib
code: @[simp]
theorem join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :
    X.str (X.join uux) = X.str (map X.str uux) 
goal: X.str (X.join uux) = X.str (Ultrafilter.map X.str uux)

full_name: Compactum.instTopologicalSpaceA
code: instance {X : Compactum} : TopologicalSpace X.A 
goal: TopologicalSpace X.A

full_name: Compactum.isClosed_iff
code: theorem isClosed_iff {X : Compactum} (S : Set X) :
    IsClosed S ↔ ∀ F : Ultrafilter X, S ∈ F → X.str F ∈ S 
goal: IsClosed S ↔ ∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S

full_name: Compactum.instCompactSpaceA
code: instance {X : Compactum} : CompactSpace X 
goal: CompactSpace X.A

full_name: _private.Mathlib.Topology.Category.Compactum.0.Compactum.basic
code: /-- A local definition used only in the proofs. -/
private def basic {X : Compactum} (A : Set X) : Set (Ultrafilter X) 
goal: Set (Ultrafilter X.A)

full_name: _private.Mathlib.Topology.Category.Compactum.0.Compactum.cl
code: /-- A local definition used only in the proofs. -/
private def cl {X : Compactum} (A : Set X) : Set X 
goal: Set X.A

full_name: _private.Mathlib.Topology.Category.Compactum.0.Compactum.basic_inter
code: private theorem basic_inter {X : Compactum} (A B : Set X) : basic (A ∩ B) = basic A ∩ basic B 
goal: Compactum.basic (A ∩ B) = Compactum.basic A ∩ Compactum.basic B

full_name: _private.Mathlib.Topology.Category.Compactum.0.Compactum.subset_cl
code: private theorem subset_cl {X : Compactum} (A : Set X) : A ⊆ cl A 
goal: A ⊆ Compactum.cl A

full_name: _private.Mathlib.Topology.Category.Compactum.0.Compactum.cl_cl
code: private theorem cl_cl {X : Compactum} (A : Set X) : cl (cl A) ⊆ cl A 
goal: Compactum.cl (Compactum.cl A) ⊆ Compactum.cl A

full_name: Compactum.isClosed_cl
code: theorem isClosed_cl {X : Compactum} (A : Set X) : IsClosed (cl A) 
goal: IsClosed (Compactum.cl A)

full_name: Compactum.str_eq_of_le_nhds
code: theorem str_eq_of_le_nhds {X : Compactum} (F : Ultrafilter X) (x : X) : ↑F ≤ 𝓝 x → X.str F = x 
goal: ↑F ≤ 𝓝 x → X.str F = x

full_name: Compactum.le_nhds_of_str_eq
code: theorem le_nhds_of_str_eq {X : Compactum} (F : Ultrafilter X) (x : X) : X.str F = x → ↑F ≤ 𝓝 x 
goal: X.str F = x → ↑F ≤ 𝓝 x

full_name: Compactum.instT2SpaceA
code: instance {X : Compactum} : T2Space X 
goal: T2Space X.A

full_name: Compactum.lim_eq_str
code: /-- The structure map of a compactum actually computes limits. -/
theorem lim_eq_str {X : Compactum} (F : Ultrafilter X) : F.lim = X.str F 
goal: F.lim = X.str F

full_name: Compactum.cl_eq_closure
code: theorem cl_eq_closure {X : Compactum} (A : Set X) : cl A = closure A 
goal: Compactum.cl A = closure A

full_name: Compactum.continuous_of_hom
code: /-- Any morphism of compacta is continuous. -/
theorem continuous_of_hom {X Y : Compactum} (f : X ⟶ Y) : Continuous f 
goal: Continuous f.f

full_name: Compactum.ofTopologicalSpace
code: /-- Given any compact Hausdorff space, we construct a Compactum. -/
noncomputable def ofTopologicalSpace (X : Type*) [TopologicalSpace X] [CompactSpace X]
    [T2Space X] : Compactum 
goal: Compactum

full_name: Compactum.homOfContinuous
code: /-- Any continuous map between Compacta is a morphism of compacta. -/
def homOfContinuous {X Y : Compactum} (f : X → Y) (cont : Continuous f) : X ⟶ Y 
goal: X ⟶ Y

full_name: compactumToCompHaus
code: /-- The functor functor from Compactum to CompHaus. -/
def compactumToCompHaus : Compactum ⥤ CompHaus 
goal: Compactum ⥤ CompHaus

full_name: compactumToCompHaus.full
code: /-- The functor `compactumToCompHaus` is full. -/
instance full : compactumToCompHaus.{u}.Full 
goal: compactumToCompHaus.Full

full_name: compactumToCompHaus.faithful
code: /-- The functor `compactumToCompHaus` is faithful. -/
instance faithful : compactumToCompHaus.Faithful 
goal: compactumToCompHaus.Faithful

full_name: compactumToCompHaus.isoOfTopologicalSpace
code: /-- This definition is used to prove essential surjectivity of `compactumToCompHaus`. -/
def isoOfTopologicalSpace {D : CompHaus} :
    compactumToCompHaus.obj (Compactum.ofTopologicalSpace D) ≅ D 
goal: compactumToCompHaus.obj (Compactum.ofTopologicalSpace ↑D.toTop) ≅ D

full_name: compactumToCompHaus.essSurj
code: /-- The functor `compactumToCompHaus` is essentially surjective. -/
instance essSurj : compactumToCompHaus.EssSurj 
goal: compactumToCompHaus.EssSurj

full_name: compactumToCompHaus.isEquivalence
code: /-- The functor `compactumToCompHaus` is an equivalence of categories. -/
instance isEquivalence : compactumToCompHaus.IsEquivalence 
goal: compactumToCompHaus.IsEquivalence

full_name: compactumToCompHausCompForget
code: /-- The forgetful functors of `Compactum` and `CompHaus` are compatible via
`compactumToCompHaus`. -/
def compactumToCompHausCompForget :
    compactumToCompHaus ⋙ CategoryTheory.forget CompHaus ≅ Compactum.forget 
goal: compactumToCompHaus ⋙ CategoryTheory.forget CompHaus ≅ Compactum.forget

full_name: CompHaus.forgetCreatesLimits
code: noncomputable instance CompHaus.forgetCreatesLimits : CreatesLimits (forget CompHaus) 
goal: CategoryTheory.CreatesLimits (CategoryTheory.forget CompHaus)

full_name: Profinite.forgetCreatesLimits
code: noncomputable instance Profinite.forgetCreatesLimits : CreatesLimits (forget Profinite) 
goal: CategoryTheory.CreatesLimits (CategoryTheory.forget Profinite)