ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Tactic/Linarith/Oracle/SimplexAlgorithm/SimplexAlgorithm.lean

full_name: Linarith.SimplexAlgorithm.SimplexAlgorithmException.infeasible
code: /-- An exception in the `SimplexAlgorithmM` monad. -/
inductive SimplexAlgorithmException
  /-- The solution is infeasible. -/
| infeasible : SimplexAlgorithmException
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmException

full_name: Linarith.SimplexAlgorithm.SimplexAlgorithmException
code: /-- An exception in the `SimplexAlgorithmM` monad. -/
inductive SimplexAlgorithmException
  /-- The solution is infeasible. -/
| infeasible : SimplexAlgorithmException
goal: Type

full_name: Linarith.SimplexAlgorithm.SimplexAlgorithmM
code: /-- The monad for the Simplex Algorithm. -/
abbrev SimplexAlgorithmM (matType : Nat → Nat → Type) [UsableInSimplexAlgorithm matType] 
goal: Type

full_name: Linarith.SimplexAlgorithm.doPivotOperation
code: /--
Given indexes `exitIdx` and `enterIdx` of exiting and entering variables in the `basic` and `free`
arrays, performs pivot operation, i.e. expresses one through the other and makes the free one basic
and vice versa.
-/
def doPivotOperation (exitIdx enterIdx : Nat) : SimplexAlgorithmM matType Unit 
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Unit

full_name: Linarith.SimplexAlgorithm.checkSuccess
code: /--
Check if the solution is found: the objective function is positive and all basic variables are
nonnegative.
-/
def checkSuccess : SimplexAlgorithmM matType Bool 
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Bool

full_name: Linarith.SimplexAlgorithm.chooseEnteringVar
code: /--
Chooses an entering variable: among the variables with a positive coefficient in the objective
function, the one with the smallest index (in the initial indexing).
-/
def chooseEnteringVar : SimplexAlgorithmM matType Nat 
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Nat

full_name: Linarith.SimplexAlgorithm.chooseExitingVar
code: /--
Chooses an exiting variable: the variable imposing the strictest limit on the increase of the
entering variable, breaking ties by choosing the variable with smallest index.
-/
def chooseExitingVar (enterIdx : Nat) : SimplexAlgorithmM matType Nat 
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Nat

full_name: Linarith.SimplexAlgorithm.choosePivots
code: /--
Chooses entering and exiting variables using
(Bland's rule)[(https://en.wikipedia.org/wiki/Bland%27s_rule)] that guarantees that the Simplex
Algorithm terminates.
-/
def choosePivots : SimplexAlgorithmM matType (Nat × Nat) 
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmM matType (Nat × Nat)

full_name: Linarith.SimplexAlgorithm.runSimplexAlgorithm
code: /--
Runs the Simplex Algorithm inside the `SimplexAlgorithmM`. It always terminates, finding solution if
such exists.
-/
def runSimplexAlgorithm : SimplexAlgorithmM matType Unit 
goal: Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Unit
File: Mathlib/Tactic/Linarith/Oracle/SimplexAlgorithm.lean

full_name: Linarith.SimplexAlgorithm.preprocess
code: /-- Preprocess the goal to pass it to `Linarith.SimplexAlgorithm.findPositiveVector`. -/
def preprocess (matType : ℕ → ℕ → Type) [UsableInSimplexAlgorithm matType] (hyps : List Comp)
    (maxVar : ℕ) : matType (maxVar + 1) (hyps.length) × List Nat 
goal: matType (maxVar + 1) hyps.length × List ℕ

full_name: Linarith.SimplexAlgorithm.postprocess
code: /--
Extract the certificate from the `vec` found by `Linarith.SimplexAlgorithm.findPositiveVector`.
-/
def postprocess (vec : Array ℚ) : HashMap ℕ ℕ 
goal: Batteries.HashMap ℕ ℕ

full_name: Linarith.CertificateOracle.simplexAlgorithmSparse
code: /-- An oracle that uses the Simplex Algorithm. -/
def CertificateOracle.simplexAlgorithmSparse : CertificateOracle 
goal: Linarith.CertificateOracle

full_name: Linarith.CertificateOracle.simplexAlgorithmDense
code: /--
The same oracle as `CertificateOracle.simplexAlgorithmSparse`, but uses dense matrices. Works faster
on dense states.
-/
def CertificateOracle.simplexAlgorithmDense : CertificateOracle 
goal: Linarith.CertificateOracle
File: Mathlib/Topology/OmegaCompletePartialOrder.lean

full_name: Scott.IsωSup
code: /-- `x` is an `ω`-Sup of a chain `c` if it is the least upper bound of the range of `c`. -/
def IsωSup {α : Type u} [Preorder α] (c : Chain α) (x : α) : Prop 
goal: Prop

full_name: Scott.isωSup_iff_isLUB
code: theorem isωSup_iff_isLUB {α : Type u} [Preorder α] {c : Chain α} {x : α} :
    IsωSup c x ↔ IsLUB (range c) x 
goal: Scott.IsωSup c x ↔ IsLUB (Set.range ⇑c) x

full_name: Scott.IsOpen
code: /-- The characteristic function of open sets is monotone and preserves
the limits of chains. -/
def IsOpen (s : Set α) : Prop 
goal: Prop

full_name: Scott.isOpen_univ
code: theorem isOpen_univ : IsOpen α univ 
goal: Scott.IsOpen α Set.univ

full_name: Scott.IsOpen.inter
code: theorem IsOpen.inter (s t : Set α) : IsOpen α s → IsOpen α t → IsOpen α (s ∩ t) 
goal: Scott.IsOpen α s → Scott.IsOpen α t → Scott.IsOpen α (s ∩ t)

full_name: Scott.isOpen_sUnion
code: theorem isOpen_sUnion (s : Set (Set α)) (hs : ∀ t ∈ s, IsOpen α t) : IsOpen α (⋃₀ s) 
goal: Scott.IsOpen α (⋃₀ s)

full_name: Scott.IsOpen.isUpperSet
code: theorem IsOpen.isUpperSet {s : Set α} (hs : IsOpen α s) : IsUpperSet s 
goal: IsUpperSet s

full_name: Scott
code: /-- A Scott topological space is defined on preorders
such that their open sets, seen as a function `α → Prop`,
preserves the joins of ω-chains  -/
abbrev Scott (α : Type u) 
goal: Type u

full_name: Scott.topologicalSpace
code: instance Scott.topologicalSpace (α : Type u) [OmegaCompletePartialOrder α] :
    TopologicalSpace (Scott α) 
goal: TopologicalSpace (Scott α)

full_name: notBelow
code: /-- `notBelow` is an open set in `Scott α` used
to prove the monotonicity of continuous functions -/
def notBelow 
goal: Set (Scott α)

full_name: notBelow_isOpen
code: theorem notBelow_isOpen : IsOpen (notBelow y) 
goal: IsOpen (notBelow y)

full_name: isωSup_ωSup
code: theorem isωSup_ωSup {α} [OmegaCompletePartialOrder α] (c : Chain α) : IsωSup c (ωSup c) 
goal: Scott.IsωSup c (OmegaCompletePartialOrder.ωSup c)

full_name: scottContinuous_of_continuous
code: theorem scottContinuous_of_continuous {α β} [OmegaCompletePartialOrder α]
    [OmegaCompletePartialOrder β] (f : Scott α → Scott β) (hf : Continuous f) :
    OmegaCompletePartialOrder.Continuous' f 
goal: OmegaCompletePartialOrder.Continuous' f

full_name: continuous_of_scottContinuous
code: theorem continuous_of_scottContinuous {α β} [OmegaCompletePartialOrder α]
    [OmegaCompletePartialOrder β] (f : Scott α → Scott β)
    (hf : OmegaCompletePartialOrder.Continuous' f) : Continuous f 
goal: Continuous f
File: Mathlib/Topology/Order/Filter.lean

full_name: Filter.tendsto_nhds_atTop
code: protected theorem tendsto_nhds_atTop [NoMaxOrder X] : Tendsto 𝓝 (atTop : Filter X) (𝓝 atTop) 
goal: Filter.Tendsto 𝓝 Filter.atTop (𝓝 Filter.atTop)

full_name: Filter.tendsto_nhds_atBot
code: protected theorem tendsto_nhds_atBot [NoMinOrder X] : Tendsto 𝓝 (atBot : Filter X) (𝓝 atBot) 
goal: Filter.Tendsto 𝓝 Filter.atBot (𝓝 Filter.atBot)

full_name: Filter.Tendsto.nhds_atTop
code: theorem Tendsto.nhds_atTop [NoMaxOrder X] {f : α → X} {l : Filter α} (h : Tendsto f l atTop) :
    Tendsto (𝓝 ∘ f) l (𝓝 atTop) 
goal: Filter.Tendsto (𝓝 ∘ f) l (𝓝 Filter.atTop)

full_name: Filter.Tendsto.nhds_atBot
code: theorem Tendsto.nhds_atBot [NoMinOrder X] {f : α → X} {l : Filter α} (h : Tendsto f l atBot) :
    Tendsto (𝓝 ∘ f) l (𝓝 atBot) 
goal: Filter.Tendsto (𝓝 ∘ f) l (𝓝 Filter.atBot)
File: Mathlib/Topology/Order/Bounded.lean

full_name: Filter.isBounded_le_map_of_bounded_range
code: @[deprecated isBoundedUnder_of (since := "2024-06-07")]
lemma Filter.isBounded_le_map_of_bounded_range {ι : Type*} (F : Filter ι) {f : ι → ℝ}
    (h : Bornology.IsBounded (Set.range f)) :
    (F.map f).IsBounded (· ≤ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) (Filter.map f F)

full_name: Filter.isBounded_ge_map_of_bounded_range
code: @[deprecated isBoundedUnder_of (since := "2024-06-07")]
lemma Filter.isBounded_ge_map_of_bounded_range {ι : Type*} (F : Filter ι) {f : ι → ℝ}
    (h : Bornology.IsBounded (Set.range f)) :
    (F.map f).IsBounded (· ≥ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) (Filter.map f F)
File: Mathlib/Topology/Order/PartialSups.lean

full_name: Filter.Tendsto.partialSups
code: protected lemma partialSups (hf : ∀ k ≤ n, Tendsto (f k) l (𝓝 (g k))) :
    Tendsto (partialSups f n) l (𝓝 (partialSups g n)) 
goal: Filter.Tendsto ((partialSups f) n) l (𝓝 ((partialSups g) n))

full_name: Filter.Tendsto.partialSups_apply
code: protected lemma partialSups_apply (hf : ∀ k ≤ n, Tendsto (f k) l (𝓝 (g k))) :
    Tendsto (fun a ↦ partialSups (f · a) n) l (𝓝 (partialSups g n)) 
goal: Filter.Tendsto (fun a => (partialSups fun x => f x a) n) l (𝓝 ((partialSups g) n))

full_name: ContinuousAt.partialSups_apply
code: protected lemma ContinuousAt.partialSups_apply (hf : ∀ k ≤ n, ContinuousAt (f k) x) :
    ContinuousAt (fun a ↦ partialSups (f · a) n) x 
goal: ContinuousAt (fun a => (partialSups fun x => f x a) n) x

full_name: ContinuousAt.partialSups
code: protected lemma ContinuousAt.partialSups (hf : ∀ k ≤ n, ContinuousAt (f k) x) :
    ContinuousAt (partialSups f n) x 
goal: ContinuousAt ((partialSups f) n) x

full_name: ContinuousWithinAt.partialSups_apply
code: protected lemma ContinuousWithinAt.partialSups_apply (hf : ∀ k ≤ n, ContinuousWithinAt (f k) s x) :
    ContinuousWithinAt (fun a ↦ partialSups (f · a) n) s x 
goal: ContinuousWithinAt (fun a => (partialSups fun x => f x a) n) s x

full_name: ContinuousWithinAt.partialSups
code: protected lemma ContinuousWithinAt.partialSups (hf : ∀ k ≤ n, ContinuousWithinAt (f k) s x) :
    ContinuousWithinAt (partialSups f n) s x 
goal: ContinuousWithinAt ((partialSups f) n) s x

full_name: ContinuousOn.partialSups_apply
code: protected lemma ContinuousOn.partialSups_apply (hf : ∀ k ≤ n, ContinuousOn (f k) s) :
    ContinuousOn (fun a ↦ partialSups (f · a) n) s 
goal: ContinuousOn (fun a => (partialSups fun x => f x a) n) s

full_name: ContinuousOn.partialSups
code: protected lemma ContinuousOn.partialSups (hf : ∀ k ≤ n, ContinuousOn (f k) s) :
    ContinuousOn (partialSups f n) s 
goal: ContinuousOn ((partialSups f) n) s

full_name: Continuous.partialSups_apply
code: protected lemma Continuous.partialSups_apply (hf : ∀ k ≤ n, Continuous (f k)) :
    Continuous (fun a ↦ partialSups (f · a) n) 
goal: Continuous fun a => (partialSups fun x => f x a) n

full_name: Continuous.partialSups
code: protected lemma Continuous.partialSups (hf : ∀ k ≤ n, Continuous (f k)) :
    Continuous (partialSups f n) 
goal: Continuous ((partialSups f) n)
File: Mathlib/Topology/Order/ExtendFrom.lean

full_name: continuousOn_Icc_extendFrom_Ioo
code: theorem continuousOn_Icc_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [RegularSpace β] {f : α → β} {a b : α} {la lb : β}
    (hab : a ≠ b) (hf : ContinuousOn f (Ioo a b)) (ha : Tendsto f (𝓝[>] a) (𝓝 la))
    (hb : Tendsto f (𝓝[<] b) (𝓝 lb)) : ContinuousOn (extendFrom (Ioo a b) f) (Icc a b) 
goal: ContinuousOn (extendFrom (Set.Ioo a b) f) (Set.Icc a b)

full_name: eq_lim_at_left_extendFrom_Ioo
code: theorem eq_lim_at_left_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [T2Space β] {f : α → β} {a b : α} {la : β} (hab : a < b)
    (ha : Tendsto f (𝓝[>] a) (𝓝 la)) : extendFrom (Ioo a b) f a = la 
goal: extendFrom (Set.Ioo a b) f a = la

full_name: eq_lim_at_right_extendFrom_Ioo
code: theorem eq_lim_at_right_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [T2Space β] {f : α → β} {a b : α} {lb : β} (hab : a < b)
    (hb : Tendsto f (𝓝[<] b) (𝓝 lb)) : extendFrom (Ioo a b) f b = lb 
goal: extendFrom (Set.Ioo a b) f b = lb

full_name: continuousOn_Ico_extendFrom_Ioo
code: theorem continuousOn_Ico_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [RegularSpace β] {f : α → β} {a b : α} {la : β}
    (hab : a < b) (hf : ContinuousOn f (Ioo a b)) (ha : Tendsto f (𝓝[>] a) (𝓝 la)) :
    ContinuousOn (extendFrom (Ioo a b) f) (Ico a b) 
goal: ContinuousOn (extendFrom (Set.Ioo a b) f) (Set.Ico a b)

full_name: continuousOn_Ioc_extendFrom_Ioo
code: theorem continuousOn_Ioc_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [RegularSpace β] {f : α → β} {a b : α} {lb : β}
    (hab : a < b) (hf : ContinuousOn f (Ioo a b)) (hb : Tendsto f (𝓝[<] b) (𝓝 lb)) :
    ContinuousOn (extendFrom (Ioo a b) f) (Ioc a b) 
goal: ContinuousOn (extendFrom (Set.Ioo a b) f) (Set.Ioc a b)
File: Mathlib/Topology/Order/ExtrClosure.lean

full_name: IsMaxOn.closure
code: protected theorem IsMaxOn.closure (h : IsMaxOn f s a) (hc : ContinuousOn f (closure s)) :
    IsMaxOn f (closure s) a 
goal: IsMaxOn f (closure s) a

full_name: IsMinOn.closure
code: protected theorem IsMinOn.closure (h : IsMinOn f s a) (hc : ContinuousOn f (closure s)) :
    IsMinOn f (closure s) a 
goal: IsMinOn f (closure s) a

full_name: IsExtrOn.closure
code: protected theorem IsExtrOn.closure (h : IsExtrOn f s a) (hc : ContinuousOn f (closure s)) :
    IsExtrOn f (closure s) a 
goal: IsExtrOn f (closure s) a

full_name: IsLocalMaxOn.closure
code: protected theorem IsLocalMaxOn.closure (h : IsLocalMaxOn f s a) (hc : ContinuousOn f (closure s)) :
    IsLocalMaxOn f (closure s) a 
goal: IsLocalMaxOn f (closure s) a

full_name: IsLocalMinOn.closure
code: protected theorem IsLocalMinOn.closure (h : IsLocalMinOn f s a) (hc : ContinuousOn f (closure s)) :
    IsLocalMinOn f (closure s) a 
goal: IsLocalMinOn f (closure s) a

full_name: IsLocalExtrOn.closure
code: protected theorem IsLocalExtrOn.closure (h : IsLocalExtrOn f s a)
    (hc : ContinuousOn f (closure s)) : IsLocalExtrOn f (closure s) a 
goal: IsLocalExtrOn f (closure s) a
File: Mathlib/Topology/Order/ProjIcc.lean

full_name: Filter.Tendsto.IccExtend
code: protected theorem Filter.Tendsto.IccExtend (f : γ → Icc a b → β) {la : Filter α} {lb : Filter β}
    {lc : Filter γ} (hf : Tendsto (↿f) (lc ×ˢ la.map (projIcc a b h)) lb) :
    Tendsto (↿(IccExtend h ∘ f)) (lc ×ˢ la) lb 
goal: Filter.Tendsto (↿(Set.IccExtend h ∘ f)) (lc ×ˢ la) lb

full_name: continuous_projIcc
code: @[continuity]
theorem continuous_projIcc : Continuous (projIcc a b h) 
goal: Continuous (Set.projIcc a b h)

full_name: quotientMap_projIcc
code: theorem quotientMap_projIcc : QuotientMap (projIcc a b h) 
goal: QuotientMap (Set.projIcc a b h)

full_name: continuous_IccExtend_iff
code: @[simp]
theorem continuous_IccExtend_iff {f : Icc a b → β} : Continuous (IccExtend h f) ↔ Continuous f 
goal: Continuous (Set.IccExtend h f) ↔ Continuous f

full_name: Continuous.IccExtend
code: /-- See Note [continuity lemma statement]. -/
protected theorem Continuous.IccExtend {f : γ → Icc a b → β} {g : γ → α} (hf : Continuous ↿f)
    (hg : Continuous g) : Continuous fun a => IccExtend h (f a) (g a) 
goal: Continuous fun a_1 => Set.IccExtend h (f a_1) (g a_1)

full_name: Continuous.Icc_extend'
code: /-- A useful special case of `Continuous.IccExtend`. -/
@[continuity]
protected theorem Continuous.Icc_extend' {f : Icc a b → β} (hf : Continuous f) :
    Continuous (IccExtend h f) 
goal: Continuous (Set.IccExtend h f)

full_name: ContinuousAt.IccExtend
code: theorem ContinuousAt.IccExtend {x : γ} (f : γ → Icc a b → β) {g : γ → α}
    (hf : ContinuousAt (↿f) (x, projIcc a b h (g x))) (hg : ContinuousAt g x) :
    ContinuousAt (fun a => IccExtend h (f a) (g a)) x 
goal: ContinuousAt (fun a_1 => Set.IccExtend h (f a_1) (g a_1)) x
File: Mathlib/Topology/Order/Priestley.lean

full_name: PriestleySpace
code: /-- A Priestley space is an ordered topological space such that any two distinct points can be
separated by a clopen upper set. Compactness is often assumed, but we do not include it here. -/
class PriestleySpace (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
  priestley {x y : α} : ¬x ≤ y → ∃ U : Set α, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U
goal: Prop

full_name: PriestleySpace.priestley
code: /-- A Priestley space is an ordered topological space such that any two distinct points can be
separated by a clopen upper set. Compactness is often assumed, but we do not include it here. -/
class PriestleySpace (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
  priestley {x y : α} : ¬x ≤ y → ∃ U : Set α, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U
goal: ¬x ≤ y → ∃ U, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U

full_name: exists_isClopen_upper_of_not_le
code: theorem exists_isClopen_upper_of_not_le :
    ¬x ≤ y → ∃ U : Set α, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U 
goal: ¬x ≤ y → ∃ U, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U

full_name: exists_isClopen_lower_of_not_le
code: theorem exists_isClopen_lower_of_not_le (h : ¬x ≤ y) :
    ∃ U : Set α, IsClopen U ∧ IsLowerSet U ∧ x ∉ U ∧ y ∈ U 
goal: ∃ U, IsClopen U ∧ IsLowerSet U ∧ x ∉ U ∧ y ∈ U

full_name: exists_isClopen_upper_or_lower_of_ne
code: theorem exists_isClopen_upper_or_lower_of_ne (h : x ≠ y) :
    ∃ U : Set α, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ y ∉ U 
goal: ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ y ∉ U

full_name: PriestleySpace.toT2Space
code: instance (priority := 100) PriestleySpace.toT2Space : T2Space α 
goal: T2Space α
File: Mathlib/Topology/RestrictGenTopology.lean

full_name: RestrictGenTopology.isOpen_iff
code: protected theorem isOpen_iff (hS : RestrictGenTopology S) :
    IsOpen t ↔ ∀ s ∈ S, IsOpen ((↑) ⁻¹' t : Set s) 
goal: IsOpen t ↔ ∀ s ∈ S, IsOpen (Subtype.val ⁻¹' t)

full_name: RestrictGenTopology.isClosed_iff
code: protected theorem isClosed_iff (hS : RestrictGenTopology S) :
    IsClosed t ↔ ∀ s ∈ S, IsClosed ((↑) ⁻¹' t : Set s) 
goal: IsClosed t ↔ ∀ s ∈ S, IsClosed (Subtype.val ⁻¹' t)

full_name: RestrictGenTopology.continuous_iff
code: protected theorem continuous_iff {Y : Type*} [TopologicalSpace Y] {f : X → Y}
    (hS : RestrictGenTopology S) :
    Continuous f ↔ ∀ s ∈ S, ContinuousOn f s 
goal: Continuous f ↔ ∀ s ∈ S, ContinuousOn f s

full_name: RestrictGenTopology.of_continuous_prop
code: theorem of_continuous_prop (h : ∀ f : X → Prop, (∀ s ∈ S, ContinuousOn f s) → Continuous f) :
    RestrictGenTopology S 
goal: RestrictGenTopology S

full_name: RestrictGenTopology.of_isClosed
code: theorem of_isClosed (h : ∀ t : Set X, (∀ s ∈ S, IsClosed ((↑) ⁻¹' t : Set s)) → IsClosed t) :
    RestrictGenTopology S 
goal: RestrictGenTopology S

full_name: RestrictGenTopology.enlarge
code: protected theorem enlarge {T} (hS : RestrictGenTopology S) (hT : ∀ s ∈ S, ∃ t ∈ T, s ⊆ t) :
    RestrictGenTopology T 
goal: RestrictGenTopology T

full_name: RestrictGenTopology.mono
code: protected theorem mono {T} (hS : RestrictGenTopology S) (hT : S ⊆ T) : RestrictGenTopology T 
goal: RestrictGenTopology T

full_name: RestrictGenTopology.of_seq
code: /-- If `X` is a sequential space
and `S` contains each set of the form `insert x (Set.range u)`
where `u : ℕ → X` is a sequence and `x` is its limit,
then topology on `X` is generated by its restrictions to the sets of `S`. -/
lemma of_seq [SequentialSpace X]
    (h : ∀ ⦃u : ℕ → X⦄ ⦃x : X⦄, Tendsto u atTop (𝓝 x) → insert x (range u) ∈ S) :
    RestrictGenTopology S 
goal: RestrictGenTopology S

full_name: RestrictGenTopology.isCompact_of_seq
code: /-- A sequential space is compactly generated. -/
lemma isCompact_of_seq [SequentialSpace X] : RestrictGenTopology {K : Set X | IsCompact K} 
goal: RestrictGenTopology {K | IsCompact K}
File: Mathlib/Topology/Order/Category/FrameAdjunction.lean

full_name: Locale.PT
code: /-- The type of points of a complete lattice `L`, where a *point* of a complete lattice is,
by definition, a frame homomorphism from `L` to `Prop`. -/
abbrev PT 
goal: Type u_1

full_name: Locale.openOfElementHom_toFun
code: /-- The frame homomorphism from a complete lattice `L` to the complete lattice of sets of
points of `L`. -/
@[simps]
def openOfElementHom : FrameHom L (Set (PT L)) 
goal: (Locale.openOfElementHom L) u = {x | x u}

full_name: Locale.openOfElementHom
code: /-- The frame homomorphism from a complete lattice `L` to the complete lattice of sets of
points of `L`. -/
@[simps]
def openOfElementHom : FrameHom L (Set (PT L)) 
goal: FrameHom L (Set (Locale.PT L))

full_name: Locale.PT.instTopologicalSpace
code: /-- The topology on the set of points of the complete lattice `L`. -/
instance instTopologicalSpace : TopologicalSpace (PT L) 
goal: TopologicalSpace (Locale.PT L)

full_name: Locale.PT.isOpen_iff
code: /-- Characterization of when a subset of the space of points is open. -/
lemma isOpen_iff (U : Set (PT L)) : IsOpen U ↔ ∃ u : L, {x | x u} = U 
goal: IsOpen U ↔ ∃ u, {x | x u} = U

full_name: Locale.pt
code: /-- The covariant functor `pt` from the category of locales to the category of
topological spaces, which sends a locale `L` to the topological space `PT L` of homomorphisms
from `L` to `Prop` and a locale homomorphism `f` to a continuous function between the spaces
of points. -/
def pt : Locale ⥤ TopCat 
goal: Locale ⥤ TopCat

full_name: Locale.localePointOfSpacePoint_toFun
code: /-- The unit of the adjunction between locales and topological spaces, which associates with
a point `x` of the space `X` a point of the locale of opens of `X`. -/
@[simps]
def localePointOfSpacePoint (x : X) : PT (Opens X) 
goal: ∀ (x_1 : TopologicalSpace.Opens X), (Locale.localePointOfSpacePoint X x) x_1 = (x ∈ x_1)

full_name: Locale.localePointOfSpacePoint
code: /-- The unit of the adjunction between locales and topological spaces, which associates with
a point `x` of the space `X` a point of the locale of opens of `X`. -/
@[simps]
def localePointOfSpacePoint (x : X) : PT (Opens X) 
goal: Locale.PT (TopologicalSpace.Opens X)

full_name: Locale.counitAppCont
code: /-- The counit is a frame homomorphism. -/
def counitAppCont : FrameHom L (Opens <| PT L) 
goal: FrameHom (↑(Opposite.unop L)) (TopologicalSpace.Opens (Locale.PT ↑(Opposite.unop L)))

full_name: Locale.adjunctionTopToLocalePT
code: /-- The forgetful functor `topToLocale` is left adjoint to the functor `pt`. -/
def adjunctionTopToLocalePT : topToLocale ⊣ pt 
goal: topToLocale ⊣ Locale.pt
File: Mathlib/Topology/Order/T5.lean

full_name: Set.ordConnectedComponent_mem_nhds
code: @[simp]
theorem ordConnectedComponent_mem_nhds : ordConnectedComponent s a ∈ 𝓝 a ↔ s ∈ 𝓝 a 
goal: s.ordConnectedComponent a ∈ 𝓝 a ↔ s ∈ 𝓝 a

full_name: Set.compl_section_ordSeparatingSet_mem_nhdsWithin_Ici
code: theorem compl_section_ordSeparatingSet_mem_nhdsWithin_Ici (hd : Disjoint s (closure t))
    (ha : a ∈ s) : (ordConnectedSection (ordSeparatingSet s t))ᶜ ∈ 𝓝[≥] a 
goal: (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝[≥] a

full_name: Set.compl_section_ordSeparatingSet_mem_nhdsWithin_Iic
code: theorem compl_section_ordSeparatingSet_mem_nhdsWithin_Iic (hd : Disjoint s (closure t))
    (ha : a ∈ s) : (ordConnectedSection <| ordSeparatingSet s t)ᶜ ∈ 𝓝[≤] a 
goal: (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝[≤] a

full_name: Set.compl_section_ordSeparatingSet_mem_nhds
code: theorem compl_section_ordSeparatingSet_mem_nhds (hd : Disjoint s (closure t)) (ha : a ∈ s) :
    (ordConnectedSection <| ordSeparatingSet s t)ᶜ ∈ 𝓝 a 
goal: (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝 a

full_name: Set.ordT5Nhd_mem_nhdsSet
code: theorem ordT5Nhd_mem_nhdsSet (hd : Disjoint s (closure t)) : ordT5Nhd s t ∈ 𝓝ˢ s 
goal: s.ordT5Nhd t ∈ 𝓝ˢ s

full_name: OrderTopology.completelyNormalSpace
code: /-- A linear order with order topology is a completely normal Hausdorff topological space. -/
instance (priority := 100) OrderTopology.completelyNormalSpace : CompletelyNormalSpace X 
goal: CompletelyNormalSpace X

full_name: OrderTopology.t5Space
code: instance (priority := 100) OrderTopology.t5Space : T5Space X 
goal: T5Space X