ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Topology/Instances/RatLemmas.lean

full_name: _aux_Mathlib_Topology_Instances_RatLemmas___unexpand_OnePoint_1
code: local notation "ℚ∞" => OnePoint ℚ
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_Instances_RatLemmas___macroRules_termℚ∞_1»
code: local notation "ℚ∞" => OnePoint ℚ
goal: Lean.Macro

full_name: Rat.interior_compact_eq_empty
code: theorem interior_compact_eq_empty (hs : IsCompact s) : interior s = ∅ 
goal: interior s = ∅

full_name: Rat.dense_compl_compact
code: theorem dense_compl_compact (hs : IsCompact s) : Dense sᶜ 
goal: Dense sᶜ

full_name: Rat.cocompact_inf_nhds_neBot
code: instance cocompact_inf_nhds_neBot : NeBot (cocompact ℚ ⊓ 𝓝 p) 
goal: (Filter.cocompact ℚ ⊓ 𝓝 p).NeBot

full_name: Rat.not_countably_generated_cocompact
code: theorem not_countably_generated_cocompact : ¬IsCountablyGenerated (cocompact ℚ) 
goal: ¬(Filter.cocompact ℚ).IsCountablyGenerated

full_name: Rat.not_countably_generated_nhds_infty_opc
code: theorem not_countably_generated_nhds_infty_opc : ¬IsCountablyGenerated (𝓝 (∞ : ℚ∞)) 
goal: ¬(𝓝 ∞).IsCountablyGenerated

full_name: Rat.not_firstCountableTopology_opc
code: theorem not_firstCountableTopology_opc : ¬FirstCountableTopology ℚ∞ 
goal: ¬FirstCountableTopology ℚ∞

full_name: Rat.not_secondCountableTopology_opc
code: theorem not_secondCountableTopology_opc : ¬SecondCountableTopology ℚ∞ 
goal: ¬SecondCountableTopology ℚ∞

full_name: Rat.instTotallyDisconnectedSpace
code: instance : TotallyDisconnectedSpace ℚ 
goal: TotallyDisconnectedSpace ℚ
File: Mathlib/Topology/Compactness/PseudometrizableLindelof.lean

full_name: SecondCountableTopology.ofPseudoMetrizableSpaceLindelofSpace
code: instance SecondCountableTopology.ofPseudoMetrizableSpaceLindelofSpace [PseudoMetrizableSpace X]
    [LindelofSpace X] : SecondCountableTopology X 
goal: SecondCountableTopology X
File: Mathlib/Topology/Instances/Complex.lean

full_name: Complex.subfield_eq_of_closed
code: /-- The only closed subfields of `ℂ` are `ℝ` and `ℂ`. -/
theorem Complex.subfield_eq_of_closed {K : Subfield ℂ} (hc : IsClosed (K : Set ℂ)) :
    K = ofReal.fieldRange ∨ K = ⊤ 
goal: K = Complex.ofReal.fieldRange ∨ K = ⊤

full_name: Complex.uniformContinuous_ringHom_eq_id_or_conj
code: /-- Let `K` a subfield of `ℂ` and let `ψ : K →+* ℂ` a ring homomorphism. Assume that `ψ` is uniform
continuous, then `ψ` is either the inclusion map or the composition of the inclusion map with the
complex conjugation. -/
theorem Complex.uniformContinuous_ringHom_eq_id_or_conj (K : Subfield ℂ) {ψ : K →+* ℂ}
    (hc : UniformContinuous ψ) : ψ.toFun = K.subtype ∨ ψ.toFun = conj ∘ K.subtype 
goal: (↑↑ψ).toFun = ⇑K.subtype ∨ (↑↑ψ).toFun = ⇑(starRingEnd ℂ) ∘ ⇑K.subtype
File: Mathlib/Topology/DiscreteSubset.lean

full_name: tendsto_cofinite_cocompact_iff
code: lemma tendsto_cofinite_cocompact_iff :
    Tendsto f cofinite (cocompact _) ↔ ∀ K, IsCompact K → Set.Finite (f ⁻¹' K) 
goal: Filter.Tendsto f Filter.cofinite (Filter.cocompact Y) ↔ ∀ (K : Set Y), IsCompact K → (f ⁻¹' K).Finite

full_name: Continuous.discrete_of_tendsto_cofinite_cocompact
code: lemma Continuous.discrete_of_tendsto_cofinite_cocompact [T1Space X] [WeaklyLocallyCompactSpace Y]
    (hf' : Continuous f) (hf : Tendsto f cofinite (cocompact _)) :
    DiscreteTopology X 
goal: DiscreteTopology X

full_name: tendsto_cofinite_cocompact_of_discrete
code: lemma tendsto_cofinite_cocompact_of_discrete [DiscreteTopology X]
    (hf : Tendsto f (cocompact _) (cocompact _)) :
    Tendsto f cofinite (cocompact _) 
goal: Filter.Tendsto f Filter.cofinite (Filter.cocompact Y)

full_name: IsClosed.tendsto_coe_cofinite_of_discreteTopology
code: lemma IsClosed.tendsto_coe_cofinite_of_discreteTopology
    {s : Set X} (hs : IsClosed s) (_hs' : DiscreteTopology s) :
    Tendsto ((↑) : s → X) cofinite (cocompact _) 
goal: Filter.Tendsto Subtype.val Filter.cofinite (Filter.cocompact X)

full_name: IsClosed.tendsto_coe_cofinite_iff
code: lemma IsClosed.tendsto_coe_cofinite_iff [T1Space X] [WeaklyLocallyCompactSpace X]
    {s : Set X} (hs : IsClosed s) :
    Tendsto ((↑) : s → X) cofinite (cocompact _) ↔ DiscreteTopology s 
goal: Filter.Tendsto Subtype.val Filter.cofinite (Filter.cocompact X) ↔ DiscreteTopology ↑s

full_name: isClosed_and_discrete_iff
code: /-- Criterion for a subset `S ⊆ X` to be closed and discrete in terms of the punctured
neighbourhood filter at an arbitrary point of `X`. (Compare `discreteTopology_subtype_iff`.) -/
theorem isClosed_and_discrete_iff {S : Set X} :
    IsClosed S ∧ DiscreteTopology S ↔ ∀ x, Disjoint (𝓝[≠] x) (𝓟 S) 
goal: IsClosed S ∧ DiscreteTopology ↑S ↔ ∀ (x : X), Disjoint (𝓝[≠] x) (𝓟 S)

full_name: Filter.codiscrete
code: /-- In any topological space, the open sets with with discrete complement form a filter. -/
def Filter.codiscrete (X : Type*) [TopologicalSpace X] : Filter X 
goal: Filter X
File: Mathlib/Topology/UrysohnsBounded.lean

full_name: exists_bounded_zero_one_of_closed
code: /-- **Urysohn's lemma**: if `s` and `t` are two disjoint closed sets in a normal topological
space `X`, then there exists a continuous function `f : X → ℝ` such that

* `f` equals zero on `s`;
* `f` equals one on `t`;
* `0 ≤ f x ≤ 1` for all `x`.
-/
theorem exists_bounded_zero_one_of_closed {X : Type*} [TopologicalSpace X] [NormalSpace X]
    {s t : Set X} (hs : IsClosed s) (ht : IsClosed t) (hd : Disjoint s t) :
    ∃ f : X →ᵇ ℝ, EqOn f 0 s ∧ EqOn f 1 t ∧ ∀ x, f x ∈ Icc (0 : ℝ) 1 
goal: ∃ f, Set.EqOn (⇑f) 0 s ∧ Set.EqOn (⇑f) 1 t ∧ ∀ (x : X), f x ∈ Set.Icc 0 1

full_name: exists_bounded_mem_Icc_of_closed_of_le
code: /-- Urysohn's lemma: if `s` and `t` are two disjoint closed sets in a normal topological space `X`,
and `a ≤ b` are two real numbers, then there exists a continuous function `f : X → ℝ` such that

* `f` equals `a` on `s`;
* `f` equals `b` on `t`;
* `a ≤ f x ≤ b` for all `x`.
-/
theorem exists_bounded_mem_Icc_of_closed_of_le {X : Type*} [TopologicalSpace X] [NormalSpace X]
    {s t : Set X} (hs : IsClosed s) (ht : IsClosed t) (hd : Disjoint s t) {a b : ℝ} (hle : a ≤ b) :
    ∃ f : X →ᵇ ℝ, EqOn f (Function.const X a) s ∧ EqOn f (Function.const X b) t ∧
    ∀ x, f x ∈ Icc a b 
goal: ∃ f, Set.EqOn (⇑f) (Function.const X a) s ∧ Set.EqOn (⇑f) (Function.const X b) t ∧ ∀ (x : X), f x ∈ Set.Icc a b
File: Mathlib/Topology/CountableSeparatingOn.lean

full_name: instHasCountableSeparatingOnIsOpenOfT0SpaceOfSecondCountableTopologyElem
code: /-- If `X` is a topological space, `s` is a set in `X` such that the induced topology is T₀ and is
second countable, then there exists a countable family of open sets in `X` that separates points
of `s`. -/
instance [TopologicalSpace X] {s : Set X} [T0Space s] [SecondCountableTopology s] :
    HasCountableSeparatingOn X IsOpen s 
goal: HasCountableSeparatingOn X IsOpen s

full_name: instHasCountableSeparatingOnIsClosedOfIsOpen
code: /-- If there exists a countable family of open sets separating points of `s`, then there exists
a countable family of closed sets separating points of `s`. -/
instance [TopologicalSpace X] {s : Set X} [h : HasCountableSeparatingOn X IsOpen s] :
    HasCountableSeparatingOn X IsClosed s 
goal: HasCountableSeparatingOn X IsClosed s
File: Mathlib/Topology/Partial.lean

full_name: rtendsto_nhds
code: theorem rtendsto_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
    RTendsto r l (𝓝 x) ↔ ∀ s, IsOpen s → x ∈ s → r.core s ∈ l 
goal: Filter.RTendsto r l (𝓝 x) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → r.core s ∈ l

full_name: rtendsto'_nhds
code: theorem rtendsto'_nhds {r : Rel Y X} {l : Filter Y} {x : X} :
    RTendsto' r l (𝓝 x) ↔ ∀ s, IsOpen s → x ∈ s → r.preimage s ∈ l 
goal: Filter.RTendsto' r l (𝓝 x) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → r.preimage s ∈ l

full_name: ptendsto_nhds
code: theorem ptendsto_nhds {f : Y →. X} {l : Filter Y} {x : X} :
    PTendsto f l (𝓝 x) ↔ ∀ s, IsOpen s → x ∈ s → f.core s ∈ l 
goal: Filter.PTendsto f l (𝓝 x) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → f.core s ∈ l

full_name: ptendsto'_nhds
code: theorem ptendsto'_nhds {f : Y →. X} {l : Filter Y} {x : X} :
    PTendsto' f l (𝓝 x) ↔ ∀ s, IsOpen s → x ∈ s → f.preimage s ∈ l 
goal: Filter.PTendsto' f l (𝓝 x) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → f.preimage s ∈ l

full_name: PContinuous
code: /-- Continuity of a partial function -/
def PContinuous (f : X →. Y) 
goal: Prop

full_name: open_dom_of_pcontinuous
code: theorem open_dom_of_pcontinuous {f : X →. Y} (h : PContinuous f) : IsOpen f.Dom 
goal: IsOpen f.Dom

full_name: pcontinuous_iff'
code: theorem pcontinuous_iff' {f : X →. Y} :
    PContinuous f ↔ ∀ {x y} (h : y ∈ f x), PTendsto' f (𝓝 x) (𝓝 y) 
goal: PContinuous f ↔ ∀ {x : X} {y : Y}, y ∈ f x → Filter.PTendsto' f (𝓝 x) (𝓝 y)

full_name: continuousWithinAt_iff_ptendsto_res
code: theorem continuousWithinAt_iff_ptendsto_res (f : X → Y) {x : X} {s : Set X} :
    ContinuousWithinAt f s x ↔ PTendsto (PFun.res f s) (𝓝 x) (𝓝 (f x)) 
goal: ContinuousWithinAt f s x ↔ Filter.PTendsto (PFun.res f s) (𝓝 x) (𝓝 (f x))
File: Mathlib/Topology/Category/TopCat/EpiMono.lean

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

full_name: TopCat.mono_iff_injective
code: theorem mono_iff_injective {X Y : TopCat.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f 
goal: CategoryTheory.Mono f ↔ Function.Injective ⇑f
File: Mathlib/Topology/Category/TopCat/EffectiveEpi.lean

full_name: TopCat.effectiveEpiStructOfQuotientMap
code: /--
Implementation: If `π` is a morphism in `TopCat` which is a quotient map, then it is an effective
epimorphism. The theorem `TopCat.effectiveEpi_iff_quotientMap` should be used instead of
this definition.
-/
noncomputable
def effectiveEpiStructOfQuotientMap {B X : TopCat.{u}} (π : X ⟶ B) (hπ : QuotientMap π) :
    EffectiveEpiStruct π 
goal: CategoryTheory.EffectiveEpiStruct π

full_name: TopCat.effectiveEpi_iff_quotientMap
code: /-- The effective epimorphisms in `TopCat` are precisely the quotient maps. -/
theorem effectiveEpi_iff_quotientMap {B X : TopCat.{u}} (π : X ⟶ B) :
    EffectiveEpi π ↔ QuotientMap π 
goal: CategoryTheory.EffectiveEpi π ↔ QuotientMap ⇑π
File: Mathlib/Topology/Category/TopCat/Yoneda.lean

full_name: ContinuousMap.yonedaPresheaf_obj
code: /--
A universe polymorphic "Yoneda presheaf" on `C` given by continuous maps into a topoological space
`Y`.
-/
@[simps]
def yonedaPresheaf : Cᵒᵖ ⥤ Type (max w w') 
goal: (ContinuousMap.yonedaPresheaf F Y).obj X = C(↑(F.obj (Opposite.unop X)), Y)

full_name: ContinuousMap.yonedaPresheaf
code: /--
A universe polymorphic "Yoneda presheaf" on `C` given by continuous maps into a topoological space
`Y`.
-/
@[simps]
def yonedaPresheaf : Cᵒᵖ ⥤ Type (max w w') 
goal: Cᵒᵖ ⥤ Type (max w w')

full_name: ContinuousMap.yonedaPresheaf_map
code: /--
A universe polymorphic "Yoneda presheaf" on `C` given by continuous maps into a topoological space
`Y`.
-/
@[simps]
def yonedaPresheaf : Cᵒᵖ ⥤ Type (max w w') 
goal: ∀ {X Y_1 : Cᵒᵖ} (f : X ⟶ Y_1) (g : C(↑(F.obj (Opposite.unop X)), Y)),
  (ContinuousMap.yonedaPresheaf F Y).map f g = g.comp (F.map f.unop)

full_name: ContinuousMap.yonedaPresheaf'
code: /--
A universe polymorphic Yoneda presheaf on `TopCat` given by continuous maps into a topoological
space `Y`.
-/
@[simps]
def yonedaPresheaf' : TopCat.{w}ᵒᵖ ⥤ Type (max w w') 
goal: TopCatᵒᵖ ⥤ Type (max w w')

full_name: ContinuousMap.yonedaPresheaf'_obj
code: /--
A universe polymorphic Yoneda presheaf on `TopCat` given by continuous maps into a topoological
space `Y`.
-/
@[simps]
def yonedaPresheaf' : TopCat.{w}ᵒᵖ ⥤ Type (max w w') 
goal: (ContinuousMap.yonedaPresheaf' Y).obj X = C(↑(Opposite.unop X), Y)

full_name: ContinuousMap.yonedaPresheaf'_map
code: /--
A universe polymorphic Yoneda presheaf on `TopCat` given by continuous maps into a topoological
space `Y`.
-/
@[simps]
def yonedaPresheaf' : TopCat.{w}ᵒᵖ ⥤ Type (max w w') 
goal: ∀ {X Y_1 : TopCatᵒᵖ} (f : X ⟶ Y_1) (g : C(↑(Opposite.unop X), Y)),
  (ContinuousMap.yonedaPresheaf' Y).map f g = g.comp f.unop

full_name: ContinuousMap.comp_yonedaPresheaf'
code: theorem comp_yonedaPresheaf' : yonedaPresheaf F Y = F.op ⋙ yonedaPresheaf' Y 
goal: ContinuousMap.yonedaPresheaf F Y = F.op ⋙ ContinuousMap.yonedaPresheaf' Y

full_name: ContinuousMap.piComparison_fac
code: theorem piComparison_fac {α : Type} (X : α → TopCat) :
    piComparison (yonedaPresheaf'.{w, w'} Y) (fun x ↦ op (X x)) =
    (yonedaPresheaf' Y).map ((opCoproductIsoProduct X).inv ≫ (TopCat.sigmaIsoSigma X).inv.op) ≫
    (equivEquivIso (sigmaEquiv Y (fun x ↦ (X x).1))).inv ≫ (Types.productIso _).inv 
goal: (CategoryTheory.Limits.piComparison (ContinuousMap.yonedaPresheaf' Y) fun x => Opposite.op (X x)) =
  (ContinuousMap.yonedaPresheaf' Y).map
      ((CategoryTheory.Limits.opCoproductIsoProduct X).inv ≫ (TopCat.sigmaIsoSigma X).inv.op) ≫
    (equivEquivIso (ContinuousMap.sigmaEquiv Y fun x => ↑(X x))).inv ≫
      (CategoryTheory.Limits.Types.productIso fun i => C(↑(X i), Y)).inv

full_name: ContinuousMap.instPreservesFiniteProductsOppositeTopCatYonedaPresheaf'
code: /-- The universe polymorphic Yoneda presheaf on `TopCat` preserves finite products. -/
noncomputable instance : PreservesFiniteProducts (yonedaPresheaf'.{w, w'} Y) 
goal: CategoryTheory.Limits.PreservesFiniteProducts (ContinuousMap.yonedaPresheaf' Y)
File: Mathlib/Topology/Category/TopCat/Adjunctions.lean

full_name: TopCat.adj₁_unit
code: /-- Equipping a type with the discrete topology is left adjoint to the forgetful functor
`Top ⥤ Type`. -/
@[simps! unit counit]
def adj₁ : discrete ⊣ forget TopCat.{u} 
goal: TopCat.adj₁.unit = { app := fun X => id, naturality := TopCat.adj₁.proof_1 }

full_name: TopCat.adj₁_counit
code: /-- Equipping a type with the discrete topology is left adjoint to the forgetful functor
`Top ⥤ Type`. -/
@[simps! unit counit]
def adj₁ : discrete ⊣ forget TopCat.{u} 
goal: TopCat.adj₁.counit = { app := fun X => { toFun := id, continuous_toFun := ⋯ }, naturality := TopCat.adj₁.proof_3 }

full_name: TopCat.adj₁
code: /-- Equipping a type with the discrete topology is left adjoint to the forgetful functor
`Top ⥤ Type`. -/
@[simps! unit counit]
def adj₁ : discrete ⊣ forget TopCat.{u} 
goal: TopCat.discrete ⊣ CategoryTheory.forget TopCat

full_name: TopCat.adj₂
code: /-- Equipping a type with the trivial topology is right adjoint to the forgetful functor
`Top ⥤ Type`. -/
@[simps! unit counit]
def adj₂ : forget TopCat.{u} ⊣ trivial 
goal: CategoryTheory.forget TopCat ⊣ TopCat.trivial

full_name: TopCat.adj₂_counit
code: /-- Equipping a type with the trivial topology is right adjoint to the forgetful functor
`Top ⥤ Type`. -/
@[simps! unit counit]
def adj₂ : forget TopCat.{u} ⊣ trivial 
goal: TopCat.adj₂.counit = { app := fun X => id, naturality := TopCat.adj₂.proof_3 }

full_name: TopCat.adj₂_unit
code: /-- Equipping a type with the trivial topology is right adjoint to the forgetful functor
`Top ⥤ Type`. -/
@[simps! unit counit]
def adj₂ : forget TopCat.{u} ⊣ trivial 
goal: TopCat.adj₂.unit = { app := fun X => { toFun := id, continuous_toFun := ⋯ }, naturality := TopCat.adj₂.proof_2 }

full_name: TopCat.instIsRightAdjointForget
code: instance : (forget TopCat.{u}).IsRightAdjoint 
goal: (CategoryTheory.forget TopCat).IsRightAdjoint

full_name: TopCat.instIsLeftAdjointForget
code: instance : (forget TopCat.{u}).IsLeftAdjoint 
goal: (CategoryTheory.forget TopCat).IsLeftAdjoint
File: Mathlib/Topology/Category/Born.lean

full_name: Born
code: /-- The category of bornologies. -/
def Born 
goal: Type (u_1 + 1)

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

full_name: Born.instBornologyα
code: instance (X : Born) : Bornology X 
goal: Bornology ↑X

full_name: Born.of
code: /-- Construct a bundled `Born` from a `Bornology`. -/
def of (α : Type*) [Bornology α] : Born 
goal: Born

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

full_name: Born.instBundledHomBornologyLocallyBoundedMap
code: instance : BundledHom @LocallyBoundedMap 
goal: CategoryTheory.BundledHom LocallyBoundedMap

full_name: Born.instLargeCategory
code: instance : LargeCategory.{u} Born 
goal: CategoryTheory.LargeCategory Born

full_name: Born.instConcreteCategory
code: instance : ConcreteCategory Born 
goal: CategoryTheory.ConcreteCategory Born
File: Mathlib/Topology/Category/Profinite/EffectiveEpi.lean

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

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

full_name: Profinite.instPreservesEffectiveEpisCompHausProfiniteToCompHaus
code: instance : profiniteToCompHaus.PreservesEffectiveEpis 
goal: profiniteToCompHaus.PreservesEffectiveEpis

full_name: Profinite.instReflectsEffectiveEpisCompHausProfiniteToCompHaus
code: instance : profiniteToCompHaus.ReflectsEffectiveEpis 
goal: profiniteToCompHaus.ReflectsEffectiveEpis

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

full_name: Profinite.instEffectivelyEnoughCompHausProfiniteToCompHaus
code: instance : profiniteToCompHaus.EffectivelyEnough 
goal: profiniteToCompHaus.EffectivelyEnough

full_name: Profinite.instPreregular
code: instance : Preregular Profinite.{u} 
goal: CategoryTheory.Preregular Profinite

full_name: Profinite.effectiveEpiFamily_tfae
code: theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : Profinite.{u}}
    (X : α → Profinite.{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: Profinite.effectiveEpiFamily_of_jointly_surjective
code: theorem effectiveEpiFamily_of_jointly_surjective
    {α : Type} [Finite α] {B : Profinite.{u}}
    (X : α → Profinite.{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/Profinite/Projective.lean

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

full_name: Profinite.projectivePresentation
code: /-- For any profinite `X`, the natural map `Ultrafilter X → X` is a projective presentation. -/
def projectivePresentation (X : Profinite.{u}) : ProjectivePresentation X 
goal: CategoryTheory.ProjectivePresentation X

full_name: Profinite.instEnoughProjectives
code: instance : EnoughProjectives Profinite.{u} 
goal: CategoryTheory.EnoughProjectives Profinite
File: Mathlib/Topology/Category/Locale.lean

full_name: Locale
code: /-- The category of locales. -/
def Locale 
goal: Type (u_1 + 1)

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

full_name: Locale.instFrameαUnopFrm
code: instance (X : Locale) : Frame X 
goal: Order.Frame ↑(Opposite.unop X)

full_name: Locale.of
code: /-- Construct a bundled `Locale` from a `Frame`. -/
def of (α : Type*) [Frame α] : Locale 
goal: Locale

full_name: Locale.coe_of
code: @[simp]
theorem coe_of (α : Type*) [Frame α] : ↥(of α) = α 
goal: ↑(Opposite.unop (Locale.of α)) = α

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

full_name: topToLocale
code: /-- The forgetful functor from `Top` to `Locale` which forgets that the space has "enough points".
-/
@[simps!]
def topToLocale : TopCat ⥤ Locale 
goal: TopCat ⥤ Locale

full_name: topToLocale_obj
code: /-- The forgetful functor from `Top` to `Locale` which forgets that the space has "enough points".
-/
@[simps!]
def topToLocale : TopCat ⥤ Locale 
goal: topToLocale.obj X = Opposite.op (Frm.of (TopologicalSpace.Opens ↑X))

full_name: topToLocale_map
code: /-- The forgetful functor from `Top` to `Locale` which forgets that the space has "enough points".
-/
@[simps!]
def topToLocale : TopCat ⥤ Locale 
goal: ∀ {X Y : TopCat} (f : X ⟶ Y), topToLocale.map f = Quiver.Hom.op (TopologicalSpace.Opens.comap f)

full_name: CompHausToLocale.faithful
code: instance CompHausToLocale.faithful : (compHausToTop ⋙ topToLocale.{u}).Faithful 
goal: (compHausToTop ⋙ topToLocale).Faithful
File: Mathlib/Topology/Category/TopCat/Limits/Konig.lean

full_name: _private.Mathlib.Topology.Category.TopCat.Limits.Konig.0.TopCat.FiniteDiagramArrow
code: private abbrev FiniteDiagramArrow {J : Type u} [SmallCategory J] (G : Finset J) 
goal: Type u

full_name: _private.Mathlib.Topology.Category.TopCat.Limits.Konig.0.TopCat.FiniteDiagram
code: private abbrev FiniteDiagram (J : Type u) [SmallCategory J] 
goal: Type u

full_name: TopCat.partialSections
code: /-- Partial sections of a cofiltered limit are sections when restricted to
a finite subset of objects and morphisms of `J`.
-/
-- Porting note: generalized `F` to land in `v` not `u`
def partialSections {J : Type u} [SmallCategory J] (F : J ⥤ TopCat.{v}) {G : Finset J}
    (H : Finset (FiniteDiagramArrow G)) : Set (∀ j, F.obj j) 
goal: Set ((j : J) → ↑(F.obj j))

full_name: TopCat.partialSections.nonempty
code: theorem partialSections.nonempty [IsCofilteredOrEmpty J] [h : ∀ j : J, Nonempty (F.obj j)]
    {G : Finset J} (H : Finset (FiniteDiagramArrow G)) : (partialSections F H).Nonempty 
goal: (TopCat.partialSections F H).Nonempty

full_name: TopCat.partialSections.directed
code: theorem partialSections.directed :
    Directed Superset fun G : FiniteDiagram J => partialSections F G.2 
goal: Directed Superset fun G => TopCat.partialSections F G.snd

full_name: TopCat.partialSections.closed
code: theorem partialSections.closed [∀ j : J, T2Space (F.obj j)] {G : Finset J}
    (H : Finset (FiniteDiagramArrow G)) : IsClosed (partialSections F H) 
goal: IsClosed (TopCat.partialSections F H)

full_name: TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system
code: /-- Cofiltered limits of nonempty compact Hausdorff spaces are nonempty topological spaces.
-/
-- Porting note: generalized from `TopCat.{u}` to `TopCat.{max v u}`
theorem nonempty_limitCone_of_compact_t2_cofiltered_system (F : J ⥤ TopCat.{max v u})
    [IsCofilteredOrEmpty J]
    [∀ j : J, Nonempty (F.obj j)] [∀ j : J, CompactSpace (F.obj j)] [∀ j : J, T2Space (F.obj j)] :
    Nonempty (TopCat.limitCone F).pt 
goal: Nonempty ↑(TopCat.limitCone F).pt