ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Topology/Category/Profinite/AsLimit.lean

full_name: Profinite.fintypeDiagram
code: /-- The functor `DiscreteQuotient X ⥤ Fintype` whose limit is isomorphic to `X`. -/
def fintypeDiagram : DiscreteQuotient X ⥤ FintypeCat 
goal: DiscreteQuotient ↑X.toTop ⥤ FintypeCat

full_name: Profinite.diagram
code: /-- An abbreviation for `X.fintypeDiagram ⋙ FintypeCat.toProfinite`. -/
abbrev diagram : DiscreteQuotient X ⥤ Profinite 
goal: DiscreteQuotient ↑X.toTop ⥤ Profinite

full_name: Profinite.asLimitCone
code: /-- A cone over `X.diagram` whose cone point is `X`. -/
def asLimitCone : CategoryTheory.Limits.Cone X.diagram 
goal: CategoryTheory.Limits.Cone X.diagram

full_name: Profinite.isIso_asLimitCone_lift
code: instance isIso_asLimitCone_lift : IsIso ((limitConeIsLimit.{u, u} X.diagram).lift X.asLimitCone) 
goal: CategoryTheory.IsIso ((Profinite.limitConeIsLimit X.diagram).lift X.asLimitCone)

full_name: Profinite.isoAsLimitConeLift
code: /-- The isomorphism between `X` and the explicit limit of `X.diagram`,
induced by lifting `X.asLimitCone`.
-/
def isoAsLimitConeLift : X ≅ (limitCone.{u, u} X.diagram).pt 
goal: X ≅ (Profinite.limitCone X.diagram).pt

full_name: Profinite.asLimitConeIso
code: /-- The isomorphism of cones `X.asLimitCone` and `Profinite.limitCone X.diagram`.
The underlying isomorphism is defeq to `X.isoAsLimitConeLift`.
-/
def asLimitConeIso : X.asLimitCone ≅ limitCone.{u, u} _ 
goal: X.asLimitCone ≅ Profinite.limitCone X.diagram

full_name: Profinite.asLimit
code: /-- `X.asLimitCone` is indeed a limit cone. -/
def asLimit : CategoryTheory.Limits.IsLimit X.asLimitCone 
goal: CategoryTheory.Limits.IsLimit X.asLimitCone

full_name: Profinite.lim
code: /-- A bundled version of `X.asLimitCone` and `X.asLimit`. -/
def lim : Limits.LimitCone X.diagram 
goal: CategoryTheory.Limits.LimitCone X.diagram
File: Mathlib/Topology/Category/Stonean/Adjunctions.lean

full_name: Stonean.stoneCechObj
code: /-- The object part of the compactification functor from types to Stonean spaces. -/
def stoneCechObj (X : Type u) : Stonean 
goal: Stonean

full_name: Stonean.stoneCechEquivalence
code: /-- The equivalence of homsets to establish the adjunction between the Stone-Cech compactification
functor and the forgetful functor. -/
noncomputable def stoneCechEquivalence (X : Type u) (Y : Stonean.{u}) :
    (stoneCechObj X ⟶ Y) ≃ (X ⟶ (forget Stonean).obj Y) 
goal: (Stonean.stoneCechObj X ⟶ Y) ≃ (X ⟶ (CategoryTheory.forget Stonean).obj Y)

full_name: typeToStonean
code: /-- The Stone-Cech compactification functor from types to Stonean spaces. -/
noncomputable def typeToStonean : Type u ⥤ Stonean.{u} 
goal: Type u ⥤ Stonean

full_name: Stonean.stoneCechAdjunction
code: /-- The Stone-Cech compactification functor is left adjoint to the forgetful functor. -/
noncomputable def stoneCechAdjunction : typeToStonean ⊣ (forget Stonean) 
goal: typeToStonean ⊣ CategoryTheory.forget Stonean

full_name: Stonean.forget.preservesLimits
code: /-- The forgetful functor from Stonean spaces, being a right adjoint, preserves limits. -/
noncomputable instance forget.preservesLimits : Limits.PreservesLimits (forget Stonean) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget Stonean)
File: Mathlib/Topology/Category/Stonean/EffectiveEpi.lean

full_name: Stonean.struct
code: /--
Implementation: If `π` is a surjective morphism in `Stonean`, then it is an effective epi.
The theorem `Stonean.effectiveEpi_tfae` should be used instead.
-/
noncomputable
def struct {B X : Stonean.{u}} (π : X ⟶ B) (hπ : Function.Surjective π) : EffectiveEpiStruct π 
goal: CategoryTheory.EffectiveEpiStruct π

full_name: Stonean.effectiveEpi_tfae
code: theorem effectiveEpi_tfae
    {B X : Stonean.{u}} (π : X ⟶ B) :
    TFAE
    [ EffectiveEpi π
    , Epi π
    , Function.Surjective π
    ] 
goal: [CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π, Function.Surjective ⇑π].TFAE

full_name: Stonean.instPreservesEffectiveEpisCompHausToCompHaus
code: instance : Stonean.toCompHaus.PreservesEffectiveEpis 
goal: Stonean.toCompHaus.PreservesEffectiveEpis

full_name: Stonean.instReflectsEffectiveEpisCompHausToCompHaus
code: instance : Stonean.toCompHaus.ReflectsEffectiveEpis 
goal: Stonean.toCompHaus.ReflectsEffectiveEpis

full_name: Stonean.stoneanToCompHausEffectivePresentation
code: /--
An effective presentation of an `X : CompHaus` with respect to the inclusion functor from `Stonean`
-/
noncomputable def stoneanToCompHausEffectivePresentation (X : CompHaus) :
    Stonean.toCompHaus.EffectivePresentation X 
goal: Stonean.toCompHaus.EffectivePresentation X

full_name: Stonean.instEffectivelyEnoughCompHausToCompHaus
code: instance : Stonean.toCompHaus.EffectivelyEnough 
goal: Stonean.toCompHaus.EffectivelyEnough

full_name: Stonean.instPreregular
code: instance : Preregular Stonean 
goal: CategoryTheory.Preregular Stonean

full_name: Stonean.effectiveEpiFamily_tfae
code: theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : Stonean.{u}}
    (X : α → Stonean.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ] 
goal: [CategoryTheory.EffectiveEpiFamily X π, CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π),
    ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b].TFAE

full_name: Stonean.effectiveEpiFamily_of_jointly_surjective
code: theorem effectiveEpiFamily_of_jointly_surjective
    {α : Type} [Finite α] {B : Stonean.{u}}
    (X : α → Stonean.{u}) (π : (a : α) → (X a ⟶ B))
    (surj : ∀ b : B, ∃ (a : α) (x : X a), π a x = b) :
    EffectiveEpiFamily X π 
goal: CategoryTheory.EffectiveEpiFamily X π
File: Mathlib/Topology/Category/LightProfinite/EffectiveEpi.lean

full_name: LightProfinite.EffectiveEpi.struct
code: /--
Implementation: if `π` is a surjective morphism in `LightProfinite`, then it is an effective epi.
The theorem `LightProfinite.effectiveEpi_iff_surjective` should be used instead.
-/
noncomputable
def EffectiveEpi.struct {B X : LightProfinite.{u}} (π : X ⟶ B) (hπ : Function.Surjective π) :
    EffectiveEpiStruct π 
goal: CategoryTheory.EffectiveEpiStruct π

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

full_name: LightProfinite.instPreregular
code: instance : Preregular LightProfinite 
goal: CategoryTheory.Preregular LightProfinite

full_name: LightProfinite.instPrecoherent
code: instance : Precoherent LightProfinite.{u} 
goal: CategoryTheory.Precoherent LightProfinite
File: Mathlib/Topology/Category/Profinite/Product.lean

full_name: Profinite.IndexFunctor.obj
code: /-- The object part of the functor `indexFunctor : (Finset ι)ᵒᵖ ⥤ Profinite`. -/
def obj : Set ((i : {i : ι // J i}) → X i) 
goal: Set ((i : { i // J i }) → X ↑i)

full_name: Profinite.IndexFunctor.π_app
code: /-- The projection maps in the limit cone `indexCone`. -/
def π_app : C(C, obj C J) 
goal: C(↑C, ↑(Profinite.IndexFunctor.obj C J))

full_name: Profinite.IndexFunctor.map
code: /-- The morphism part of the functor `indexFunctor : (Finset ι)ᵒᵖ ⥤ Profinite`. -/
def map (h : ∀ i, J i → K i) : C(obj C K, obj C J) 
goal: C(↑(Profinite.IndexFunctor.obj C K), ↑(Profinite.IndexFunctor.obj C J))

full_name: Profinite.IndexFunctor.surjective_π_app
code: theorem surjective_π_app :
    Function.Surjective (π_app C J) 
goal: Function.Surjective ⇑(Profinite.IndexFunctor.π_app C J)

full_name: Profinite.IndexFunctor.map_comp_π_app
code: theorem map_comp_π_app (h : ∀ i, J i → K i) : map C h ∘ π_app C K = π_app C J 
goal: ⇑(Profinite.IndexFunctor.map C h) ∘ ⇑(Profinite.IndexFunctor.π_app C K) = ⇑(Profinite.IndexFunctor.π_app C J)

full_name: Profinite.IndexFunctor.eq_of_forall_π_app_eq
code: theorem eq_of_forall_π_app_eq (a b : C)
    (h : ∀ (J : Finset ι), π_app C (· ∈ J) a = π_app C (· ∈ J) b) : a = b 
goal: a = b

full_name: Profinite.indexFunctor
code: /-- The functor from the poset of finsets of `ι` to  `Profinite`, indexing the limit. -/
noncomputable
def indexFunctor : (Finset ι)ᵒᵖ ⥤ Profinite.{u} 
goal: CategoryTheory.Functor (Finset ι)ᵒᵖ Profinite

full_name: Profinite.indexCone
code: /-- The limit cone on `indexFunctor` -/
noncomputable
def indexCone : Cone (indexFunctor hC) 
goal: CategoryTheory.Limits.Cone (Profinite.indexFunctor hC)

full_name: Profinite.isIso_indexCone_lift
code: instance isIso_indexCone_lift :
    IsIso ((limitConeIsLimit.{u, u} (indexFunctor hC)).lift (indexCone hC)) 
goal: CategoryTheory.IsIso ((Profinite.limitConeIsLimit (Profinite.indexFunctor hC)).lift (Profinite.indexCone hC))

full_name: Profinite.isoindexConeLift
code: /-- The canonical map from `C` to the explicit limit as an isomorphism. -/
noncomputable
def isoindexConeLift :
    @Profinite.of C _ (by rwa [← isCompact_iff_compactSpace]) _ _ ≅
    (Profinite.limitCone.{u, u} (indexFunctor hC)).pt 
goal: Profinite.of ↑C ≅ (Profinite.limitCone (Profinite.indexFunctor hC)).pt

full_name: Profinite.asLimitindexConeIso
code: /-- The isomorphism of cones induced by `isoindexConeLift`. -/
noncomputable
def asLimitindexConeIso : indexCone hC ≅ Profinite.limitCone.{u, u} _ 
goal: Profinite.indexCone hC ≅ Profinite.limitCone (Profinite.indexFunctor hC)

full_name: Profinite.indexCone_isLimit
code: /-- `indexCone` is a limit cone. -/
noncomputable
def indexCone_isLimit : CategoryTheory.Limits.IsLimit (indexCone hC) 
goal: CategoryTheory.Limits.IsLimit (Profinite.indexCone hC)
File: Mathlib/Topology/Category/LightProfinite/Sequence.lean

full_name: LightProfinite.natUnionInftyEmbedding
code: /-- The continuous map from `ℕ∪{∞}` to `ℝ` sending `n` to `1/(n+1)` and `∞` to `0`. -/
noncomputable def natUnionInftyEmbedding : C(OnePoint ℕ, ℝ) 
goal: C(OnePoint ℕ, ℝ)

full_name: LightProfinite.closedEmbedding_natUnionInftyEmbedding
code: /--
The continuous map from `ℕ∪{∞}` to `ℝ` sending `n` to `1/(n+1)` and `∞` to `0` is a closed
embedding.
-/
lemma closedEmbedding_natUnionInftyEmbedding : ClosedEmbedding natUnionInftyEmbedding 
goal: ClosedEmbedding ⇑LightProfinite.natUnionInftyEmbedding

full_name: LightProfinite.instMetrizableSpaceOnePointNat
code: instance : MetrizableSpace (OnePoint ℕ) 
goal: TopologicalSpace.MetrizableSpace (OnePoint ℕ)

full_name: LightProfinite.NatUnionInfty
code: /-- The one point compactification of the natural numbers as a light profinite set. -/
abbrev NatUnionInfty : LightProfinite 
goal: LightProfinite

full_name: LightProfinite._aux_Mathlib_Topology_Category_LightProfinite_Sequence___unexpand_LightProfinite_NatUnionInfty_1
code: @[inherit_doc]
scoped notation "ℕ∪{∞}" => NatUnionInfty
goal: Lean.PrettyPrinter.Unexpander

full_name: LightProfinite.«_aux_Mathlib_Topology_Category_LightProfinite_Sequence___macroRules_LightProfinite_termℕ∪{∞}_1»
code: @[inherit_doc]
scoped notation "ℕ∪{∞}" => NatUnionInfty
goal: Lean.Macro

full_name: LightProfinite.instCoeNatαTopologicalSpaceToTopAndTotallyDisconnectedSpaceSecondCountableTopologyNatUnionInfty
code: instance : Coe ℕ ℕ∪{∞} 
goal: Coe ℕ ↑LightProfinite.NatUnionInfty.toTop

full_name: LightProfinite.continuous_iff_convergent
code: lemma continuous_iff_convergent {Y : Type*} [TopologicalSpace Y] (f : ℕ∪{∞} → Y) :
    Continuous f ↔ Tendsto (fun x : ℕ ↦ f x) atTop (𝓝 (f ∞)) 
goal: Continuous f ↔ Filter.Tendsto (fun x => f (some x)) Filter.atTop (nhds (f ∞))
File: Mathlib/Topology/Category/FinTopCat.lean

full_name: FinTopCat.toTop
code: /-- A bundled finite topological space. -/
structure FinTopCat where
  /-- carrier of a finite topological space. -/
  toTop : TopCat.{u}
  [fintype : Fintype toTop]
goal: TopCat

full_name: FinTopCat
code: /-- A bundled finite topological space. -/
structure FinTopCat where
  /-- carrier of a finite topological space. -/
  toTop : TopCat.{u}
  [fintype : Fintype toTop]
goal: Type (u + 1)

full_name: FinTopCat.fintype
code: /-- A bundled finite topological space. -/
structure FinTopCat where
  /-- carrier of a finite topological space. -/
  toTop : TopCat.{u}
  [fintype : Fintype toTop]
goal: Fintype ↑self.toTop

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

full_name: FinTopCat.instCoeSortType
code: instance : CoeSort FinTopCat (Type u) 
goal: CoeSort FinTopCat (Type u)

full_name: FinTopCat.instCategory
code: instance : Category FinTopCat 
goal: CategoryTheory.Category.{u_1, u_1 + 1} FinTopCat

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

full_name: FinTopCat.instTopologicalSpaceObjForget
code: instance (X : FinTopCat) : TopologicalSpace ((forget FinTopCat).obj X) 
goal: TopologicalSpace ((CategoryTheory.forget FinTopCat).obj X)

full_name: FinTopCat.instFintypeObjForget
code: instance (X : FinTopCat) : Fintype ((forget FinTopCat).obj X) 
goal: Fintype ((CategoryTheory.forget FinTopCat).obj X)

full_name: FinTopCat.of
code: /-- Construct a bundled `FinTopCat` from the underlying type and the appropriate typeclasses. -/
def of (X : Type u) [Fintype X] [TopologicalSpace X] : FinTopCat 
goal: FinTopCat

full_name: FinTopCat.coe_of
code: @[simp]
theorem coe_of (X : Type u) [Fintype X] [TopologicalSpace X] :
    (of X : Type u) = X 
goal: ↑(FinTopCat.of X).toTop = X

full_name: FinTopCat.instHasForget₂FintypeCat
code: /-- The forgetful functor to `FintypeCat`. -/
instance : HasForget₂ FinTopCat FintypeCat 
goal: CategoryTheory.HasForget₂ FinTopCat FintypeCat

full_name: FinTopCat.instTopologicalSpaceαFintypeObjFintypeCatForget₂
code: instance (X : FinTopCat) : TopologicalSpace ((forget₂ FinTopCat FintypeCat).obj X) 
goal: TopologicalSpace ↑((CategoryTheory.forget₂ FinTopCat FintypeCat).obj X)

full_name: FinTopCat.instHasForget₂TopCat
code: /-- The forgetful functor to `TopCat`. -/
instance : HasForget₂ FinTopCat TopCat 
goal: CategoryTheory.HasForget₂ FinTopCat TopCat

full_name: FinTopCat.instFintypeαTopologicalSpaceObjTopCatForget₂
code: instance (X : FinTopCat) : Fintype ((forget₂ FinTopCat TopCat).obj X) 
goal: Fintype ↑((CategoryTheory.forget₂ FinTopCat TopCat).obj X)
File: Mathlib/Topology/Category/CompHausLike/EffectiveEpi.lean

full_name: CompHausLike.effectiveEpiStruct
code: /--
If `π` is a surjective morphism in `CompHausLike P`, then it is an effective epi.
-/
noncomputable
def effectiveEpiStruct {B X : CompHausLike P} (π : X ⟶ B) (hπ : Function.Surjective π) :
    EffectiveEpiStruct π 
goal: CategoryTheory.EffectiveEpiStruct π

full_name: CompHausLike.preregular
code: theorem preregular [HasExplicitPullbacks P]
    (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective f) :
    Preregular (CompHausLike P) 
goal: CategoryTheory.Preregular (CompHausLike P)
File: Mathlib/Topology/Category/TopCat/Limits/Cofiltered.lean

full_name: TopCat.isTopologicalBasis_cofiltered_limit
code: /-- Given a *compatible* collection of topological bases for the factors in a cofiltered limit
which contain `Set.univ` and are closed under intersections, the induced *naive* collection
of sets in the limit is, in fact, a topological basis.
-/
theorem isTopologicalBasis_cofiltered_limit (T : ∀ j, Set (Set (F.obj j)))
    (hT : ∀ j, IsTopologicalBasis (T j)) (univ : ∀ i : J, Set.univ ∈ T i)
    (inter : ∀ (i) (U1 U2 : Set (F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i)
    (compat : ∀ (i j : J) (f : i ⟶ j) (V : Set (F.obj j)) (_hV : V ∈ T j), F.map f ⁻¹' V ∈ T i) :
    IsTopologicalBasis
      {U : Set C.pt | ∃ (j : _) (V : Set (F.obj j)), V ∈ T j ∧ U = C.π.app j ⁻¹' V} 
goal: TopologicalSpace.IsTopologicalBasis {U | ∃ j, ∃ V ∈ T j, U = ⇑(C.π.app j) ⁻¹' V}
File: Mathlib/Topology/Category/CompHaus/Projective.lean

full_name: CompHaus.projective_ultrafilter
code: instance projective_ultrafilter (X : Type*) : Projective (of <| Ultrafilter X) 
goal: CategoryTheory.Projective (CompHaus.of (Ultrafilter X))

full_name: CompHaus.projectivePresentation
code: /-- For any compact Hausdorff space `X`,
  the natural map `Ultrafilter X → X` is a projective presentation. -/
def projectivePresentation (X : CompHaus) : ProjectivePresentation X 
goal: CategoryTheory.ProjectivePresentation X

full_name: CompHaus.instEnoughProjectives
code: instance : EnoughProjectives CompHaus 
goal: CategoryTheory.EnoughProjectives CompHaus
File: Mathlib/Topology/EMetricSpace/Paracompact.lean

full_name: EMetric.instParacompactSpace
code: /-- A `PseudoEMetricSpace` is always a paracompact space.
Formalization is based on [MR0236876]. -/
instance (priority := 100) instParacompactSpace [PseudoEMetricSpace α] : ParacompactSpace α 
goal: ParacompactSpace α

full_name: EMetric.t4Space
code: theorem t4Space [EMetricSpace α] : T4Space α 
goal: T4Space α
File: Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean

full_name: IsHomeomorphicTrivialFiberBundle
code: /-- A trivial fiber bundle with fiber `F` over a base `B` is a space `Z`
projecting on `B` for which there exists a homeomorphism to `B × F` that sends `proj`
to `Prod.fst`. -/
def IsHomeomorphicTrivialFiberBundle (proj : Z → B) : Prop 
goal: Prop

full_name: IsHomeomorphicTrivialFiberBundle.proj_eq
code: protected theorem proj_eq (h : IsHomeomorphicTrivialFiberBundle F proj) :
    ∃ e : Z ≃ₜ B × F, proj = Prod.fst ∘ e 
goal: ∃ e, proj = Prod.fst ∘ ⇑e

full_name: IsHomeomorphicTrivialFiberBundle.surjective_proj
code: /-- The projection from a trivial fiber bundle to its base is surjective. -/
protected theorem surjective_proj [Nonempty F] (h : IsHomeomorphicTrivialFiberBundle F proj) :
    Function.Surjective proj 
goal: Function.Surjective proj

full_name: IsHomeomorphicTrivialFiberBundle.continuous_proj
code: /-- The projection from a trivial fiber bundle to its base is continuous. -/
protected theorem continuous_proj (h : IsHomeomorphicTrivialFiberBundle F proj) :
    Continuous proj 
goal: Continuous proj

full_name: IsHomeomorphicTrivialFiberBundle.isOpenMap_proj
code: /-- The projection from a trivial fiber bundle to its base is open. -/
protected theorem isOpenMap_proj (h : IsHomeomorphicTrivialFiberBundle F proj) :
    IsOpenMap proj 
goal: IsOpenMap proj

full_name: IsHomeomorphicTrivialFiberBundle.quotientMap_proj
code: /-- The projection from a trivial fiber bundle to its base is open. -/
protected theorem quotientMap_proj [Nonempty F] (h : IsHomeomorphicTrivialFiberBundle F proj) :
    QuotientMap proj 
goal: QuotientMap proj

full_name: isHomeomorphicTrivialFiberBundle_fst
code: /-- The first projection in a product is a trivial fiber bundle. -/
theorem isHomeomorphicTrivialFiberBundle_fst :
    IsHomeomorphicTrivialFiberBundle F (Prod.fst : B × F → B) 
goal: IsHomeomorphicTrivialFiberBundle F Prod.fst

full_name: isHomeomorphicTrivialFiberBundle_snd
code: /-- The second projection in a product is a trivial fiber bundle. -/
theorem isHomeomorphicTrivialFiberBundle_snd :
    IsHomeomorphicTrivialFiberBundle F (Prod.snd : F × B → B) 
goal: IsHomeomorphicTrivialFiberBundle F Prod.snd
File: Mathlib/Topology/Category/CompHaus/EffectiveEpi.lean

full_name: CompHaus.struct
code: /--
Implementation: If `π` is a surjective morphism in `CompHaus`, then it is an effective epi.
The theorem `CompHaus.effectiveEpi_tfae` should be used instead.
-/
noncomputable
def struct {B X : CompHaus.{u}} (π : X ⟶ B) (hπ : Function.Surjective π) :
    EffectiveEpiStruct π 
goal: CategoryTheory.EffectiveEpiStruct π

full_name: CompHaus.effectiveEpi_tfae
code: theorem effectiveEpi_tfae
    {B X : CompHaus.{u}} (π : X ⟶ B) :
    TFAE
    [ EffectiveEpi π
    , Epi π
    , Function.Surjective π
    ] 
goal: [CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π, Function.Surjective ⇑π].TFAE

full_name: CompHaus.instPreregular
code: instance : Preregular CompHaus 
goal: CategoryTheory.Preregular CompHaus

full_name: CompHaus.instPrecoherent
code: instance : Precoherent CompHaus.{u} 
goal: CategoryTheory.Precoherent CompHaus

full_name: CompHaus.effectiveEpiFamily_tfae
code: theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : CompHaus.{u}}
    (X : α → CompHaus.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ] 
goal: [CategoryTheory.EffectiveEpiFamily X π, CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π),
    ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b].TFAE

full_name: CompHaus.effectiveEpiFamily_of_jointly_surjective
code: theorem effectiveEpiFamily_of_jointly_surjective
    {α : Type} [Finite α] {B : CompHaus.{u}}
    (X : α → CompHaus.{u}) (π : (a : α) → (X a ⟶ B))
    (surj : ∀ b : B, ∃ (a : α) (x : X a), π a x = b) :
    EffectiveEpiFamily X π 
goal: CategoryTheory.EffectiveEpiFamily X π
File: Mathlib/Topology/CompletelyRegular.lean

full_name: CompletelyRegularSpace.completely_regular
code: /-- A space is completely regular if points can be separated from closed sets via
  continuous functions to the unit interval. -/
@[mk_iff]
class CompletelyRegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  completely_regular : ∀ (x : X), ∀ K : Set X, IsClosed K → x ∉ K →
    ∃ f : X → I, Continuous f ∧ f x = 0 ∧ EqOn f 1 K
goal: IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K

full_name: CompletelyRegularSpace
code: /-- A space is completely regular if points can be separated from closed sets via
  continuous functions to the unit interval. -/
@[mk_iff]
class CompletelyRegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  completely_regular : ∀ (x : X), ∀ K : Set X, IsClosed K → x ∉ K →
    ∃ f : X → I, Continuous f ∧ f x = 0 ∧ EqOn f 1 K
goal: Prop

full_name: completelyRegularSpace_iff
code: /-- A space is completely regular if points can be separated from closed sets via
  continuous functions to the unit interval. -/
@[mk_iff]
class CompletelyRegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  completely_regular : ∀ (x : X), ∀ K : Set X, IsClosed K → x ∉ K →
    ∃ f : X → I, Continuous f ∧ f x = 0 ∧ EqOn f 1 K
goal: CompletelyRegularSpace X ↔ ∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K

full_name: CompletelyRegularSpace.instRegularSpace
code: instance CompletelyRegularSpace.instRegularSpace [CompletelyRegularSpace X] : RegularSpace X 
goal: RegularSpace X

full_name: NormalSpace.instCompletelyRegularSpace
code: instance NormalSpace.instCompletelyRegularSpace [NormalSpace X] : CompletelyRegularSpace X 
goal: CompletelyRegularSpace X

full_name: t35Space_iff
code: /-- A T₃.₅ space is a completely regular space that is also T1. -/
@[mk_iff]
class T35Space (X : Type u) [TopologicalSpace X] extends T1Space X, CompletelyRegularSpace X : Prop
goal: T35Space X ↔ T1Space X ∧ CompletelyRegularSpace X

full_name: T35Space
code: /-- A T₃.₅ space is a completely regular space that is also T1. -/
@[mk_iff]
class T35Space (X : Type u) [TopologicalSpace X] extends T1Space X, CompletelyRegularSpace X : Prop
goal: Prop

full_name: T35Space.instT3space
code: instance T35Space.instT3space [T35Space X] : T3Space X 
goal: T3Space X

full_name: T4Space.instT35Space
code: instance T4Space.instT35Space [T4Space X] : T35Space X 
goal: T35Space X

full_name: separatesPoints_continuous_of_t35Space
code: lemma separatesPoints_continuous_of_t35Space [T35Space X] :
    SeparatesPoints (Continuous : Set (X → ℝ)) 
goal: Set.SeparatesPoints Continuous

full_name: separatesPoints_continuous_of_t35Space_Icc
code: lemma separatesPoints_continuous_of_t35Space_Icc [T35Space X] :
    SeparatesPoints (Continuous : Set (X → I)) 
goal: Set.SeparatesPoints Continuous

full_name: injective_stoneCechUnit_of_t35Space
code: lemma injective_stoneCechUnit_of_t35Space [T35Space X] :
    Function.Injective (stoneCechUnit : X → StoneCech X) 
goal: Function.Injective stoneCechUnit