File: Mathlib/Topology/Instances/Real.lean

full_name: instNoncompactSpaceReal
code: instance : NoncompactSpace ℝ 
goal: NoncompactSpace ℝ

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

full_name: Real.uniformContinuous_neg
code: theorem Real.uniformContinuous_neg : UniformContinuous (@Neg.neg ℝ _) 
goal: UniformContinuous Neg.neg

full_name: instContinuousStarReal
code: instance : ContinuousStar ℝ 
goal: ContinuousStar ℝ

full_name: instUniformAddGroupReal
code: instance : UniformAddGroup ℝ 
goal: UniformAddGroup ℝ

full_name: instTopologicalAddGroupReal
code: instance : TopologicalAddGroup ℝ 
goal: TopologicalAddGroup ℝ

full_name: instTopologicalRingReal
code: instance : TopologicalRing ℝ 
goal: TopologicalRing ℝ

full_name: instTopologicalDivisionRingReal
code: instance : TopologicalDivisionRing ℝ 
goal: TopologicalDivisionRing ℝ

full_name: instProperSpaceReal
code: instance : ProperSpace ℝ 
goal: ProperSpace ℝ

full_name: instSecondCountableTopologyReal
code: instance : SecondCountableTopology ℝ 
goal: SecondCountableTopology ℝ

full_name: Real.isTopologicalBasis_Ioo_rat
code: theorem Real.isTopologicalBasis_Ioo_rat :
    @IsTopologicalBasis ℝ _ (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo (a : ℝ) b}) 
goal: TopologicalSpace.IsTopologicalBasis (⋃ a, ⋃ b, ⋃ (_ : a < b), {Set.Ioo ↑a ↑b})

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

full_name: Real.mem_closure_iff
code: theorem Real.mem_closure_iff {s : Set ℝ} {x : ℝ} :
    x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, |y - x| < ε 
goal: x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, |y - x| < ε

full_name: Real.uniformContinuous_inv
code: theorem Real.uniformContinuous_inv (s : Set ℝ) {r : ℝ} (r0 : 0 < r) (H : ∀ x ∈ s, r ≤ |x|) :
    UniformContinuous fun p : s => p.1⁻¹ 
goal: UniformContinuous fun p => (↑p)⁻¹

full_name: Real.uniformContinuous_abs
code: theorem Real.uniformContinuous_abs : UniformContinuous (abs : ℝ → ℝ) 
goal: UniformContinuous abs

full_name: Real.continuous_inv
code: theorem Real.continuous_inv : Continuous fun a : { r : ℝ // r ≠ 0 } => a.val⁻¹ 
goal: Continuous fun a => (↑a)⁻¹

full_name: Real.uniformContinuous_const_mul
code: theorem Real.uniformContinuous_const_mul {x : ℝ} : UniformContinuous (x * ·) 
goal: UniformContinuous fun x_1 => x * x_1

full_name: Real.uniformContinuous_mul
code: theorem Real.uniformContinuous_mul (s : Set (ℝ × ℝ)) {r₁ r₂ : ℝ}
    (H : ∀ x ∈ s, |(x : ℝ × ℝ).1| < r₁ ∧ |x.2| < r₂) :
    UniformContinuous fun p : s => p.1.1 * p.1.2 
goal: UniformContinuous fun p => (↑p).1 * (↑p).2

full_name: Real.instCompleteSpace
code: instance Real.instCompleteSpace : CompleteSpace ℝ 
goal: CompleteSpace ℝ

full_name: Real.totallyBounded_ball
code: theorem Real.totallyBounded_ball (x ε : ℝ) : TotallyBounded (ball x ε) 
goal: TotallyBounded (Metric.ball x ε)

full_name: closure_of_rat_image_lt
code: theorem closure_of_rat_image_lt {q : ℚ} :
    closure (((↑) : ℚ → ℝ) '' { x | q < x }) = { r | ↑q ≤ r } 
goal: closure (Rat.cast '' {x | q < x}) = {r | ↑q ≤ r}

full_name: instIsOrderBornology
code: instance instIsOrderBornology : IsOrderBornology ℝ 
goal: IsOrderBornology ℝ

full_name: Function.Periodic.compact_of_continuous
code: /-- A continuous, periodic function has compact range. -/
theorem Periodic.compact_of_continuous [TopologicalSpace α] {f : ℝ → α} {c : ℝ} (hp : Periodic f c)
    (hc : c ≠ 0) (hf : Continuous f) : IsCompact (range f) 
goal: IsCompact (Set.range f)

full_name: Function.Periodic.isBounded_of_continuous
code: /-- A continuous, periodic function is bounded. -/
theorem Periodic.isBounded_of_continuous [PseudoMetricSpace α] {f : ℝ → α} {c : ℝ}
    (hp : Periodic f c) (hc : c ≠ 0) (hf : Continuous f) : IsBounded (range f) 
goal: Bornology.IsBounded (Set.range f)

full_name: Int.instDiscreteTopologySubtypeRealMemAddSubgroupZmultiples
code: /-- This is a special case of `NormedSpace.discreteTopology_zmultiples`. It exists only to simplify
dependencies. -/
instance {a : ℝ} : DiscreteTopology (AddSubgroup.zmultiples a) 
goal: DiscreteTopology ↥(AddSubgroup.zmultiples a)

full_name: Int.tendsto_coe_cofinite
code: /-- Under the coercion from `ℤ` to `ℝ`, inverse images of compact sets are finite. -/
theorem tendsto_coe_cofinite : Tendsto ((↑) : ℤ → ℝ) cofinite (cocompact ℝ) 
goal: Filter.Tendsto Int.cast Filter.cofinite (Filter.cocompact ℝ)

full_name: Int.tendsto_zmultiplesHom_cofinite
code: /-- For nonzero `a`, the "multiples of `a`" map `zmultiplesHom` from `ℤ` to `ℝ` is discrete, i.e.
inverse images of compact sets are finite. -/
theorem tendsto_zmultiplesHom_cofinite {a : ℝ} (ha : a ≠ 0) :
    Tendsto (zmultiplesHom ℝ a) cofinite (cocompact ℝ) 
goal: Filter.Tendsto (⇑((zmultiplesHom ℝ) a)) Filter.cofinite (Filter.cocompact ℝ)

full_name: AddSubgroup.tendsto_zmultiples_subtype_cofinite
code: /-- The subgroup "multiples of `a`" (`zmultiples a`) is a discrete subgroup of `ℝ`, i.e. its
intersection with compact sets is finite. -/
theorem tendsto_zmultiples_subtype_cofinite (a : ℝ) :
    Tendsto (zmultiples a).subtype cofinite (cocompact ℝ) 
goal: Filter.Tendsto (⇑(AddSubgroup.zmultiples a).subtype) Filter.cofinite (Filter.cocompact ℝ)