ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Topology/Sets/Order.lean

full_name: ClopenUpperSet.upper'
code: /-- The type of clopen upper sets of a topological space. -/
structure ClopenUpperSet (α : Type*) [TopologicalSpace α] [LE α] extends Clopens α where
  upper' : IsUpperSet carrier
goal: IsUpperSet self.carrier

full_name: ClopenUpperSet
code: /-- The type of clopen upper sets of a topological space. -/
structure ClopenUpperSet (α : Type*) [TopologicalSpace α] [LE α] extends Clopens α where
  upper' : IsUpperSet carrier
goal: Type u_3

full_name: ClopenUpperSet.instSetLike
code: instance : SetLike (ClopenUpperSet α) α 
goal: SetLike (ClopenUpperSet α) α

full_name: ClopenUpperSet.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (s : ClopenUpperSet α) : Set α 
goal: Set α

full_name: ClopenUpperSet.upper
code: theorem upper (s : ClopenUpperSet α) : IsUpperSet (s : Set α) 
goal: IsUpperSet ↑s

full_name: ClopenUpperSet.isClopen
code: theorem isClopen (s : ClopenUpperSet α) : IsClopen (s : Set α) 
goal: IsClopen ↑s

full_name: ClopenUpperSet.toUpperSet
code: /-- Reinterpret an upper clopen as an upper set. -/
@[simps]
def toUpperSet (s : ClopenUpperSet α) : UpperSet α 
goal: UpperSet α

full_name: ClopenUpperSet.toUpperSet_coe
code: /-- Reinterpret an upper clopen as an upper set. -/
@[simps]
def toUpperSet (s : ClopenUpperSet α) : UpperSet α 
goal: ↑s.toUpperSet = ↑s

full_name: ClopenUpperSet.ext
code: @[ext]
protected theorem ext {s t : ClopenUpperSet α} (h : (s : Set α) = t) : s = t 
goal: s = t

full_name: ClopenUpperSet.coe_mk
code: @[simp]
theorem coe_mk (s : Clopens α) (h) : (mk s h : Set α) = s 
goal: ↑{ toClopens := s, upper' := h } = ↑s

full_name: ClopenUpperSet.instSup
code: instance : Sup (ClopenUpperSet α) 
goal: Sup (ClopenUpperSet α)

full_name: ClopenUpperSet.instInf
code: instance : Inf (ClopenUpperSet α) 
goal: Inf (ClopenUpperSet α)

full_name: ClopenUpperSet.instTop
code: instance : Top (ClopenUpperSet α) 
goal: Top (ClopenUpperSet α)

full_name: ClopenUpperSet.instBot
code: instance : Bot (ClopenUpperSet α) 
goal: Bot (ClopenUpperSet α)

full_name: ClopenUpperSet.instLattice
code: instance : Lattice (ClopenUpperSet α) 
goal: Lattice (ClopenUpperSet α)

full_name: ClopenUpperSet.instBoundedOrder
code: instance : BoundedOrder (ClopenUpperSet α) 
goal: BoundedOrder (ClopenUpperSet α)

full_name: ClopenUpperSet.coe_sup
code: @[simp]
theorem coe_sup (s t : ClopenUpperSet α) : (↑(s ⊔ t) : Set α) = ↑s ∪ ↑t 
goal: ↑(s ⊔ t) = ↑s ∪ ↑t

full_name: ClopenUpperSet.coe_inf
code: @[simp]
theorem coe_inf (s t : ClopenUpperSet α) : (↑(s ⊓ t) : Set α) = ↑s ∩ ↑t 
goal: ↑(s ⊓ t) = ↑s ∩ ↑t

full_name: ClopenUpperSet.coe_top
code: @[simp]
theorem coe_top : (↑(⊤ : ClopenUpperSet α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: ClopenUpperSet.coe_bot
code: @[simp]
theorem coe_bot : (↑(⊥ : ClopenUpperSet α) : Set α) = ∅ 
goal: ↑⊥ = ∅

full_name: ClopenUpperSet.instInhabited
code: instance : Inhabited (ClopenUpperSet α) 
goal: Inhabited (ClopenUpperSet α)
File: Mathlib/Topology/Maps/Proper/UniversallyClosed.lean

full_name: isProperMap_iff_isClosedMap_ultrafilter
code: /-- A map `f : X → Y` is proper if and only if it is continuous and the map
`(Prod.map f id : X × Ultrafilter X → Y × Ultrafilter X)` is closed. This is stronger than
`isProperMap_iff_universally_closed` since it shows that there's only one space to check to get
properness, but in most cases it doesn't matter. -/
theorem isProperMap_iff_isClosedMap_ultrafilter {X : Type u} {Y : Type v} [TopologicalSpace X]
    [TopologicalSpace Y] {f : X → Y} :
    IsProperMap f ↔ Continuous f ∧ IsClosedMap
      (Prod.map f id : X × Ultrafilter X → Y × Ultrafilter X) 
goal: IsProperMap f ↔ Continuous f ∧ IsClosedMap (Prod.map f id)

full_name: isProperMap_iff_universally_closed
code: /-- A map `f : X → Y` is proper if and only if it is continuous and **universally closed**, in the
sense that for any topological space `Z`, the map `Prod.map f id : X × Z → Y × Z` is closed. Note
that `Z` lives in the same universe as `X` here, but `IsProperMap.universally_closed` does not
have this restriction.

This is taken as the definition of properness in
[N. Bourbaki, *General Topology*][bourbaki1966]. -/
theorem isProperMap_iff_universally_closed {X : Type u} {Y : Type v} [TopologicalSpace X]
    [TopologicalSpace Y] {f : X → Y} :
    IsProperMap f ↔ Continuous f ∧ ∀ (Z : Type u) [TopologicalSpace Z],
      IsClosedMap (Prod.map f id : X × Z → Y × Z) 
goal: IsProperMap f ↔ Continuous f ∧ ∀ (Z : Type u) [inst : TopologicalSpace Z], IsClosedMap (Prod.map f id)
File: Mathlib/Topology/KrullDimension.lean

full_name: topologicalKrullDim
code: /--
The Krull dimension of a topological space is the supremum of lengths of chains of
closed irreducible sets.
-/
noncomputable def topologicalKrullDim (T : Type _) [TopologicalSpace T] :
    WithBot (WithTop ℕ) 
goal: WithBot (WithTop ℕ)
File: Mathlib/Topology/ExtendFrom.lean

full_name: extendFrom
code: /-- Extend a function from a set `A`. The resulting function `g` is such that
at any `x₀`, if `f` converges to some `y` as `x` tends to `x₀` within `A`,
then `g x₀` is defined to be one of these `y`. Else, `g x₀` could be anything. -/
def extendFrom (A : Set X) (f : X → Y) : X → Y 
goal: X → Y

full_name: tendsto_extendFrom
code: /-- If `f` converges to some `y` as `x` tends to `x₀` within `A`,
then `f` tends to `extendFrom A f x` as `x` tends to `x₀`. -/
theorem tendsto_extendFrom {A : Set X} {f : X → Y} {x : X} (h : ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)) :
    Tendsto f (𝓝[A] x) (𝓝 <| extendFrom A f x) 
goal: Filter.Tendsto f (𝓝[A] x) (𝓝 (extendFrom A f x))

full_name: extendFrom_eq
code: theorem extendFrom_eq [T2Space Y] {A : Set X} {f : X → Y} {x : X} {y : Y} (hx : x ∈ closure A)
    (hf : Tendsto f (𝓝[A] x) (𝓝 y)) : extendFrom A f x = y 
goal: extendFrom A f x = y

full_name: extendFrom_extends
code: theorem extendFrom_extends [T2Space Y] {f : X → Y} {A : Set X} (hf : ContinuousOn f A) :
    ∀ x ∈ A, extendFrom A f x = f x 
goal: x ∈ A → extendFrom A f x = f x

full_name: continuousOn_extendFrom
code: /-- If `f` is a function to a T₃ space `Y` which has a limit within `A` at any
point of a set `B ⊆ closure A`, then `extendFrom A f` is continuous on `B`. -/
theorem continuousOn_extendFrom [RegularSpace Y] {f : X → Y} {A B : Set X} (hB : B ⊆ closure A)
    (hf : ∀ x ∈ B, ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)) : ContinuousOn (extendFrom A f) B 
goal: ContinuousOn (extendFrom A f) B

full_name: continuous_extendFrom
code: /-- If a function `f` to a T₃ space `Y` has a limit within a
dense set `A` for any `x`, then `extendFrom A f` is continuous. -/
theorem continuous_extendFrom [RegularSpace Y] {f : X → Y} {A : Set X} (hA : Dense A)
    (hf : ∀ x, ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)) : Continuous (extendFrom A f) 
goal: Continuous (extendFrom A f)
File: Mathlib/Topology/Instances/Int.lean

full_name: Int.instDist
code: instance : Dist ℤ 
goal: Dist ℤ

full_name: Int.dist_eq
code: theorem dist_eq (x y : ℤ) : dist x y = |(x : ℝ) - y| 
goal: dist x y = |↑x - ↑y|

full_name: Int.dist_eq'
code: theorem dist_eq' (m n : ℤ) : dist m n = |m - n| 
goal: dist m n = ↑|m - n|

full_name: Int.dist_cast_real
code: @[norm_cast, simp]
theorem dist_cast_real (x y : ℤ) : dist (x : ℝ) y = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: Int.pairwise_one_le_dist
code: theorem pairwise_one_le_dist : Pairwise fun m n : ℤ => 1 ≤ dist m n 
goal: Pairwise fun m n => 1 ≤ dist m n

full_name: Int.uniformEmbedding_coe_real
code: theorem uniformEmbedding_coe_real : UniformEmbedding ((↑) : ℤ → ℝ) 
goal: UniformEmbedding Int.cast

full_name: Int.closedEmbedding_coe_real
code: theorem closedEmbedding_coe_real : ClosedEmbedding ((↑) : ℤ → ℝ) 
goal: ClosedEmbedding Int.cast

full_name: Int.instMetricSpace
code: instance : MetricSpace ℤ 
goal: MetricSpace ℤ

full_name: Int.preimage_ball
code: theorem preimage_ball (x : ℤ) (r : ℝ) : (↑) ⁻¹' ball (x : ℝ) r = ball x r 
goal: Int.cast ⁻¹' Metric.ball (↑x) r = Metric.ball x r

full_name: Int.preimage_closedBall
code: theorem preimage_closedBall (x : ℤ) (r : ℝ) : (↑) ⁻¹' closedBall (x : ℝ) r = closedBall x r 
goal: Int.cast ⁻¹' Metric.closedBall (↑x) r = Metric.closedBall x r

full_name: Int.ball_eq_Ioo
code: theorem ball_eq_Ioo (x : ℤ) (r : ℝ) : ball x r = Ioo ⌊↑x - r⌋ ⌈↑x + r⌉ 
goal: Metric.ball x r = Set.Ioo ⌊↑x - r⌋ ⌈↑x + r⌉

full_name: Int.closedBall_eq_Icc
code: theorem closedBall_eq_Icc (x : ℤ) (r : ℝ) : closedBall x r = Icc ⌈↑x - r⌉ ⌊↑x + r⌋ 
goal: Metric.closedBall x r = Set.Icc ⌈↑x - r⌉ ⌊↑x + r⌋

full_name: Int.instProperSpace
code: instance : ProperSpace ℤ 
goal: ProperSpace ℤ

full_name: Int.cobounded_eq
code: @[simp]
theorem cobounded_eq : Bornology.cobounded ℤ = atBot ⊔ atTop 
goal: Bornology.cobounded ℤ = Filter.atBot ⊔ Filter.atTop

full_name: Int.cofinite_eq
code: @[simp]
theorem cofinite_eq : (cofinite : Filter ℤ) = atBot ⊔ atTop 
goal: Filter.cofinite = Filter.atBot ⊔ Filter.atTop
File: Mathlib/Topology/Instances/Nat.lean

full_name: Nat.instDist
code: noncomputable instance : Dist ℕ 
goal: Dist ℕ

full_name: Nat.dist_eq
code: theorem dist_eq (x y : ℕ) : dist x y = |(x : ℝ) - y| 
goal: dist x y = |↑x - ↑y|

full_name: Nat.dist_coe_int
code: theorem dist_coe_int (x y : ℕ) : dist (x : ℤ) (y : ℤ) = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: Nat.dist_cast_real
code: @[norm_cast, simp]
theorem dist_cast_real (x y : ℕ) : dist (x : ℝ) y = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: Nat.pairwise_one_le_dist
code: theorem pairwise_one_le_dist : Pairwise fun m n : ℕ => 1 ≤ dist m n 
goal: Pairwise fun m n => 1 ≤ dist m n

full_name: Nat.uniformEmbedding_coe_real
code: theorem uniformEmbedding_coe_real : UniformEmbedding ((↑) : ℕ → ℝ) 
goal: UniformEmbedding Nat.cast

full_name: Nat.closedEmbedding_coe_real
code: theorem closedEmbedding_coe_real : ClosedEmbedding ((↑) : ℕ → ℝ) 
goal: ClosedEmbedding Nat.cast

full_name: Nat.instMetricSpace
code: instance : MetricSpace ℕ 
goal: MetricSpace ℕ

full_name: Nat.preimage_ball
code: theorem preimage_ball (x : ℕ) (r : ℝ) : (↑) ⁻¹' ball (x : ℝ) r = ball x r 
goal: Nat.cast ⁻¹' Metric.ball (↑x) r = Metric.ball x r

full_name: Nat.preimage_closedBall
code: theorem preimage_closedBall (x : ℕ) (r : ℝ) : (↑) ⁻¹' closedBall (x : ℝ) r = closedBall x r 
goal: Nat.cast ⁻¹' Metric.closedBall (↑x) r = Metric.closedBall x r

full_name: Nat.closedBall_eq_Icc
code: theorem closedBall_eq_Icc (x : ℕ) (r : ℝ) : closedBall x r = Icc ⌈↑x - r⌉₊ ⌊↑x + r⌋₊ 
goal: Metric.closedBall x r = Set.Icc ⌈↑x - r⌉₊ ⌊↑x + r⌋₊

full_name: Nat.instProperSpace
code: instance : ProperSpace ℕ 
goal: ProperSpace ℕ

full_name: Nat.instNoncompactSpace
code: instance : NoncompactSpace ℕ 
goal: NoncompactSpace ℕ
File: Mathlib/Topology/Instances/CantorSet.lean

full_name: preCantorSet
code: /-- The order `n` pre-Cantor set, defined starting from `[0, 1]` and successively removing the
    middle third of each interval. Formally, the order `n + 1` pre-Cantor set is the
    union of the images under the functions `(· / 3)` and `((2 + ·) / 3)` of `preCantorSet n`.
-/
def preCantorSet : ℕ → Set ℝ
  
goal: ℕ → Set ℝ

full_name: preCantorSet_zero
code: @[simp] lemma preCantorSet_zero : preCantorSet 0 = Set.Icc 0 1 
goal: preCantorSet 0 = Set.Icc 0 1

full_name: preCantorSet_succ
code: @[simp] lemma preCantorSet_succ (n : ℕ) :
    preCantorSet (n + 1) = (· / 3) '' preCantorSet n ∪ (fun x ↦ (2 + x) / 3) '' preCantorSet n 
goal: preCantorSet (n + 1) = (fun x => x / 3) '' preCantorSet n ∪ (fun x => (2 + x) / 3) '' preCantorSet n

full_name: cantorSet
code: /-- The Cantor set is the subset of the unit interval obtained as the intersection of all
    pre-Cantor sets. This means that the Cantor set is obtained by iteratively removing the
    open middle third of each subinterval, starting from the unit interval `[0, 1]`.
-/
def cantorSet : Set ℝ 
goal: Set ℝ

full_name: quarters_mem_preCantorSet
code: lemma quarters_mem_preCantorSet (n : ℕ) : 1/4 ∈ preCantorSet n ∧ 3/4 ∈ preCantorSet n 
goal: 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n

full_name: quarter_mem_preCantorSet
code: lemma quarter_mem_preCantorSet (n : ℕ) : 1/4 ∈ preCantorSet n 
goal: 1 / 4 ∈ preCantorSet n

full_name: quarter_mem_cantorSet
code: theorem quarter_mem_cantorSet : 1/4 ∈ cantorSet 
goal: 1 / 4 ∈ cantorSet

full_name: zero_mem_preCantorSet
code: lemma zero_mem_preCantorSet (n : ℕ) : 0 ∈ preCantorSet n 
goal: 0 ∈ preCantorSet n

full_name: zero_mem_cantorSet
code: theorem zero_mem_cantorSet : 0 ∈ cantorSet 
goal: 0 ∈ cantorSet

full_name: cantorSet_subset_unitInterval
code: /-- The ternary Cantor set is a subset of [0,1]. -/
lemma cantorSet_subset_unitInterval : cantorSet ⊆ Set.Icc 0 1 
goal: cantorSet ⊆ Set.Icc 0 1

full_name: isClosed_preCantorSet
code: /-- The preCantor sets are closed. -/
lemma isClosed_preCantorSet (n : ℕ) : IsClosed (preCantorSet n) 
goal: IsClosed (preCantorSet n)

full_name: isClosed_cantorSet
code: /-- The ternary Cantor set is closed. -/
lemma isClosed_cantorSet : IsClosed cantorSet 
goal: IsClosed cantorSet

full_name: isCompact_cantorSet
code: /-- The ternary Cantor set is compact. -/
lemma isCompact_cantorSet : IsCompact cantorSet 
goal: IsCompact cantorSet
File: Mathlib/Topology/Instances/Rat.lean

full_name: Rat.instMetricSpace
code: instance : MetricSpace ℚ 
goal: MetricSpace ℚ

full_name: Rat.dist_eq
code: theorem dist_eq (x y : ℚ) : dist x y = |(x : ℝ) - y| 
goal: dist x y = |↑x - ↑y|

full_name: Rat.dist_cast
code: @[norm_cast, simp]
theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: Rat.uniformContinuous_coe_real
code: theorem uniformContinuous_coe_real : UniformContinuous ((↑) : ℚ → ℝ) 
goal: UniformContinuous Rat.cast

full_name: Rat.uniformEmbedding_coe_real
code: theorem uniformEmbedding_coe_real : UniformEmbedding ((↑) : ℚ → ℝ) 
goal: UniformEmbedding Rat.cast

full_name: Rat.denseEmbedding_coe_real
code: theorem denseEmbedding_coe_real : DenseEmbedding ((↑) : ℚ → ℝ) 
goal: DenseEmbedding Rat.cast

full_name: Rat.embedding_coe_real
code: theorem embedding_coe_real : Embedding ((↑) : ℚ → ℝ) 
goal: Embedding Rat.cast

full_name: Rat.continuous_coe_real
code: theorem continuous_coe_real : Continuous ((↑) : ℚ → ℝ) 
goal: Continuous Rat.cast

full_name: Nat.dist_cast_rat
code: @[norm_cast, simp]
theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: Nat.uniformEmbedding_coe_rat
code: theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding ((↑) : ℕ → ℚ) 
goal: UniformEmbedding Nat.cast

full_name: Nat.closedEmbedding_coe_rat
code: theorem Nat.closedEmbedding_coe_rat : ClosedEmbedding ((↑) : ℕ → ℚ) 
goal: ClosedEmbedding Nat.cast

full_name: Int.dist_cast_rat
code: @[norm_cast, simp]
theorem Int.dist_cast_rat (x y : ℤ) : dist (x : ℚ) y = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: Int.uniformEmbedding_coe_rat
code: theorem Int.uniformEmbedding_coe_rat : UniformEmbedding ((↑) : ℤ → ℚ) 
goal: UniformEmbedding Int.cast

full_name: Int.closedEmbedding_coe_rat
code: theorem Int.closedEmbedding_coe_rat : ClosedEmbedding ((↑) : ℤ → ℚ) 
goal: ClosedEmbedding Int.cast

full_name: Rat.instNoncompactSpace
code: instance : NoncompactSpace ℚ 
goal: NoncompactSpace ℚ

full_name: Rat.uniformContinuous_add
code: theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.2 
goal: UniformContinuous fun p => p.1 + p.2

full_name: Rat.uniformContinuous_neg
code: theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) 
goal: UniformContinuous Neg.neg

full_name: Rat.instUniformAddGroup
code: instance : UniformAddGroup ℚ 
goal: UniformAddGroup ℚ

full_name: Rat.instTopologicalAddGroup
code: instance : TopologicalAddGroup ℚ 
goal: TopologicalAddGroup ℚ

full_name: Rat.instOrderTopology
code: instance : OrderTopology ℚ 
goal: OrderTopology ℚ

full_name: Rat.uniformContinuous_abs
code: theorem uniformContinuous_abs : UniformContinuous (abs : ℚ → ℚ) 
goal: UniformContinuous abs

full_name: Rat.instTopologicalRing
code: instance : TopologicalRing ℚ 
goal: TopologicalRing ℚ

full_name: Rat.totallyBounded_Icc
code: nonrec theorem totallyBounded_Icc (a b : ℚ) : TotallyBounded (Icc a b) 
goal: TotallyBounded (Set.Icc a b)
File: Mathlib/Topology/Instances/Irrational.lean

full_name: IsGδ.setOf_irrational
code: protected theorem IsGδ.setOf_irrational : IsGδ { x | Irrational x } 
goal: IsGδ {x | Irrational x}

full_name: dense_irrational
code: theorem dense_irrational : Dense { x : ℝ | Irrational x } 
goal: Dense {x | Irrational x}

full_name: eventually_residual_irrational
code: theorem eventually_residual_irrational : ∀ᶠ x in residual ℝ, Irrational x 
goal: ∀ᶠ (x : ℝ) in residual ℝ, Irrational x

full_name: Irrational.instOrderTopologySubtypeReal
code: instance : OrderTopology { x // Irrational x } 
goal: OrderTopology { x // Irrational x }

full_name: Irrational.instNoMaxOrderSubtypeReal
code: instance : NoMaxOrder { x // Irrational x } 
goal: NoMaxOrder { x // Irrational x }

full_name: Irrational.instNoMinOrderSubtypeReal
code: instance : NoMinOrder { x // Irrational x } 
goal: NoMinOrder { x // Irrational x }

full_name: Irrational.instDenselyOrderedSubtypeReal
code: instance : DenselyOrdered { x // Irrational x } 
goal: DenselyOrdered { x // Irrational x }

full_name: Irrational.eventually_forall_le_dist_cast_div
code: theorem eventually_forall_le_dist_cast_div (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ m : ℤ, ε ≤ dist x (m / n) 
goal: ∀ᶠ (ε : ℝ) in 𝓝 0, ∀ (m : ℤ), ε ≤ dist x (↑m / ↑n)

full_name: Irrational.eventually_forall_le_dist_cast_div_of_denom_le
code: theorem eventually_forall_le_dist_cast_div_of_denom_le (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ k ≤ n, ∀ (m : ℤ), ε ≤ dist x (m / k) 
goal: ∀ᶠ (ε : ℝ) in 𝓝 0, ∀ k ≤ n, ∀ (m : ℤ), ε ≤ dist x (↑m / ↑k)

full_name: Irrational.eventually_forall_le_dist_cast_rat_of_den_le
code: theorem eventually_forall_le_dist_cast_rat_of_den_le (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ r : ℚ, r.den ≤ n → ε ≤ dist x r 
goal: ∀ᶠ (ε : ℝ) in 𝓝 0, ∀ (r : ℚ), r.den ≤ n → ε ≤ dist x ↑r
File: Mathlib/Topology/Instances/PNat.lean

full_name: PNat.instMetricSpace
code: instance : MetricSpace ℕ+ 
goal: MetricSpace ℕ+

full_name: PNat.dist_eq
code: theorem dist_eq (x y : ℕ+) : dist x y = |(↑x : ℝ) - ↑y| 
goal: dist x y = |↑↑x - ↑↑y|

full_name: PNat.dist_coe
code: @[simp, norm_cast]
theorem dist_coe (x y : ℕ+) : dist (↑x : ℕ) (↑y : ℕ) = dist x y 
goal: dist ↑x ↑y = dist x y

full_name: PNat.uniformEmbedding_coe
code: theorem uniformEmbedding_coe : UniformEmbedding ((↑) : ℕ+ → ℕ) 
goal: UniformEmbedding PNat.val

full_name: PNat.instDiscreteTopology
code: instance : DiscreteTopology ℕ+ 
goal: DiscreteTopology ℕ+

full_name: PNat.instProperSpace
code: instance : ProperSpace ℕ+ 
goal: ProperSpace ℕ+

full_name: PNat.instNoncompactSpace
code: instance : NoncompactSpace ℕ+ 
goal: NoncompactSpace ℕ+
File: Mathlib/Topology/Instances/Sign.lean

full_name: instTopologicalSpaceSignType
code: instance : TopologicalSpace SignType 
goal: TopologicalSpace SignType

full_name: instDiscreteTopologySignType
code: instance : DiscreteTopology SignType 
goal: DiscreteTopology SignType

full_name: continuousAt_sign_of_pos
code: theorem continuousAt_sign_of_pos {a : α} (h : 0 < a) : ContinuousAt SignType.sign a 
goal: ContinuousAt (⇑SignType.sign) a

full_name: continuousAt_sign_of_neg
code: theorem continuousAt_sign_of_neg {a : α} (h : a < 0) : ContinuousAt SignType.sign a 
goal: ContinuousAt (⇑SignType.sign) a

full_name: continuousAt_sign_of_ne_zero
code: theorem continuousAt_sign_of_ne_zero {a : α} (h : a ≠ 0) : ContinuousAt SignType.sign a 
goal: ContinuousAt (⇑SignType.sign) a
File: Mathlib/Topology/Instances/Discrete.lean

full_name: DiscreteTopology.firstCountableTopology
code: instance (priority := 100) DiscreteTopology.firstCountableTopology [DiscreteTopology α] :
    FirstCountableTopology α 
goal: FirstCountableTopology α

full_name: DiscreteTopology.secondCountableTopology_of_countable
code: instance (priority := 100) DiscreteTopology.secondCountableTopology_of_countable
    [hd : DiscreteTopology α] [Countable α] : SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: DiscreteTopology.secondCountableTopology_of_encodable
code: @[deprecated DiscreteTopology.secondCountableTopology_of_countable (since := "2024-03-11")]
theorem DiscreteTopology.secondCountableTopology_of_encodable {α : Type*}
    [TopologicalSpace α] [DiscreteTopology α] [Countable α] : SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: bot_topologicalSpace_eq_generateFrom_of_pred_succOrder
code: theorem bot_topologicalSpace_eq_generateFrom_of_pred_succOrder [PartialOrder α] [PredOrder α]
    [SuccOrder α] [NoMinOrder α] [NoMaxOrder α] :
    (⊥ : TopologicalSpace α) = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a } 
goal: ⊥ = TopologicalSpace.generateFrom {s | ∃ a, s = Set.Ioi a ∨ s = Set.Iio a}

full_name: discreteTopology_iff_orderTopology_of_pred_succ'
code: theorem discreteTopology_iff_orderTopology_of_pred_succ' [PartialOrder α] [PredOrder α]
    [SuccOrder α] [NoMinOrder α] [NoMaxOrder α] : DiscreteTopology α ↔ OrderTopology α 
goal: DiscreteTopology α ↔ OrderTopology α

full_name: DiscreteTopology.orderTopology_of_pred_succ'
code: instance (priority := 100) DiscreteTopology.orderTopology_of_pred_succ' [h : DiscreteTopology α]
    [PartialOrder α] [PredOrder α] [SuccOrder α] [NoMinOrder α] [NoMaxOrder α] : OrderTopology α 
goal: OrderTopology α

full_name: LinearOrder.bot_topologicalSpace_eq_generateFrom
code: theorem LinearOrder.bot_topologicalSpace_eq_generateFrom [LinearOrder α] [PredOrder α]
    [SuccOrder α] : (⊥ : TopologicalSpace α) = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a } 
goal: ⊥ = TopologicalSpace.generateFrom {s | ∃ a, s = Set.Ioi a ∨ s = Set.Iio a}

full_name: discreteTopology_iff_orderTopology_of_pred_succ
code: theorem discreteTopology_iff_orderTopology_of_pred_succ [LinearOrder α] [PredOrder α]
    [SuccOrder α] : DiscreteTopology α ↔ OrderTopology α 
goal: DiscreteTopology α ↔ OrderTopology α

full_name: DiscreteTopology.orderTopology_of_pred_succ
code: instance (priority := 100) DiscreteTopology.orderTopology_of_pred_succ [h : DiscreteTopology α]
    [LinearOrder α] [PredOrder α] [SuccOrder α] : OrderTopology α 
goal: OrderTopology α

full_name: DiscreteTopology.metrizableSpace
code: instance (priority := 100) DiscreteTopology.metrizableSpace [DiscreteTopology α] :
    MetrizableSpace α 
goal: TopologicalSpace.MetrizableSpace α
File: Mathlib/Topology/Instances/ZMod.lean

full_name: ZMod.instTopologicalSpace
code: /-- The discrete topology (every set is open). -/
instance : TopologicalSpace (ZMod N) 
goal: TopologicalSpace (ZMod N)

full_name: ZMod.instDiscreteTopology
code: instance : DiscreteTopology (ZMod N) 
goal: DiscreteTopology (ZMod N)
File: Mathlib/Topology/Instances/RealVectorSpace.lean

full_name: map_real_smul
code: /-- A continuous additive map between two vector spaces over `ℝ` is `ℝ`-linear. -/
theorem map_real_smul {G} [FunLike G E F] [AddMonoidHomClass G E F] (f : G) (hf : Continuous f)
    (c : ℝ) (x : E) :
    f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: AddMonoidHom.toRealLinearMap
code: /-- Reinterpret a continuous additive homomorphism between two real vector spaces
as a continuous real-linear map. -/
def toRealLinearMap (f : E →+ F) (hf : Continuous f) : E →L[ℝ] F 
goal: E →L[ℝ] F

full_name: AddMonoidHom.coe_toRealLinearMap
code: @[simp]
theorem coe_toRealLinearMap (f : E →+ F) (hf : Continuous f) : ⇑(f.toRealLinearMap hf) = f 
goal: ⇑(f.toRealLinearMap hf) = ⇑f

full_name: AddEquiv.toRealLinearEquiv
code: /-- Reinterpret a continuous additive equivalence between two real vector spaces
as a continuous real-linear map. -/
def AddEquiv.toRealLinearEquiv (e : E ≃+ F) (h₁ : Continuous e) (h₂ : Continuous e.symm) :
    E ≃L[ℝ] F 
goal: E ≃L[ℝ] F

full_name: Real.isScalarTower
code: /-- A topological group carries at most one structure of a topological `ℝ`-module, so for any
topological `ℝ`-algebra `A` (e.g. `A = ℂ`) and any topological group that is both a topological
`ℝ`-module and a topological `A`-module, these structures agree. -/
instance (priority := 900) Real.isScalarTower [T2Space E] {A : Type*} [TopologicalSpace A] [Ring A]
    [Algebra ℝ A] [Module A E] [ContinuousSMul ℝ A] [ContinuousSMul A E] : IsScalarTower ℝ A E 
goal: IsScalarTower ℝ A E