File: Mathlib/Topology/Algebra/Order/Field.lean

full_name: TopologicalRing.of_norm
code: /-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R 
goal: TopologicalRing R

full_name: LinearOrderedField.topologicalRing
code: instance (priority := 100) LinearOrderedField.topologicalRing : TopologicalRing 𝕜 
goal: TopologicalRing 𝕜

full_name: Filter.Tendsto.atTop_mul
code: /-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atTop` and `g`
tends to a positive constant `C` then `f * g` tends to `Filter.atTop`. -/
theorem Filter.Tendsto.atTop_mul {C : 𝕜} (hC : 0 < C) (hf : Tendsto f l atTop)
    (hg : Tendsto g l (𝓝 C)) : Tendsto (fun x => f x * g x) l atTop 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atTop

full_name: Filter.Tendsto.mul_atTop
code: /-- In a linearly ordered field with the order topology, if `f` tends to a positive constant `C` and
`g` tends to `Filter.atTop` then `f * g` tends to `Filter.atTop`. -/
theorem Filter.Tendsto.mul_atTop {C : 𝕜} (hC : 0 < C) (hf : Tendsto f l (𝓝 C))
    (hg : Tendsto g l atTop) : Tendsto (fun x => f x * g x) l atTop 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atTop

full_name: Filter.Tendsto.atTop_mul_neg
code: /-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atTop` and `g`
tends to a negative constant `C` then `f * g` tends to `Filter.atBot`. -/
theorem Filter.Tendsto.atTop_mul_neg {C : 𝕜} (hC : C < 0) (hf : Tendsto f l atTop)
    (hg : Tendsto g l (𝓝 C)) : Tendsto (fun x => f x * g x) l atBot 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atBot

full_name: Filter.Tendsto.neg_mul_atTop
code: /-- In a linearly ordered field with the order topology, if `f` tends to a negative constant `C` and
`g` tends to `Filter.atTop` then `f * g` tends to `Filter.atBot`. -/
theorem Filter.Tendsto.neg_mul_atTop {C : 𝕜} (hC : C < 0) (hf : Tendsto f l (𝓝 C))
    (hg : Tendsto g l atTop) : Tendsto (fun x => f x * g x) l atBot 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atBot

full_name: Filter.Tendsto.atBot_mul
code: /-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atBot` and `g`
tends to a positive constant `C` then `f * g` tends to `Filter.atBot`. -/
theorem Filter.Tendsto.atBot_mul {C : 𝕜} (hC : 0 < C) (hf : Tendsto f l atBot)
    (hg : Tendsto g l (𝓝 C)) : Tendsto (fun x => f x * g x) l atBot 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atBot

full_name: Filter.Tendsto.atBot_mul_neg
code: /-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atBot` and `g`
tends to a negative constant `C` then `f * g` tends to `Filter.atTop`. -/
theorem Filter.Tendsto.atBot_mul_neg {C : 𝕜} (hC : C < 0) (hf : Tendsto f l atBot)
    (hg : Tendsto g l (𝓝 C)) : Tendsto (fun x => f x * g x) l atTop 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atTop

full_name: Filter.Tendsto.mul_atBot
code: /-- In a linearly ordered field with the order topology, if `f` tends to a positive constant `C` and
`g` tends to `Filter.atBot` then `f * g` tends to `Filter.atBot`. -/
theorem Filter.Tendsto.mul_atBot {C : 𝕜} (hC : 0 < C) (hf : Tendsto f l (𝓝 C))
    (hg : Tendsto g l atBot) : Tendsto (fun x => f x * g x) l atBot 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atBot

full_name: Filter.Tendsto.neg_mul_atBot
code: /-- In a linearly ordered field with the order topology, if `f` tends to a negative constant `C` and
`g` tends to `Filter.atBot` then `f * g` tends to `Filter.atTop`. -/
theorem Filter.Tendsto.neg_mul_atBot {C : 𝕜} (hC : C < 0) (hf : Tendsto f l (𝓝 C))
    (hg : Tendsto g l atBot) : Tendsto (fun x => f x * g x) l atTop 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atTop

full_name: inv_atTop₀
code: @[simp]
lemma inv_atTop₀ : (atTop : Filter 𝕜)⁻¹ = 𝓝[>] 0 
goal: Filter.atTop⁻¹ = 𝓝[>] 0

full_name: inv_nhdsWithin_Ioi_zero
code: @[simp] lemma inv_nhdsWithin_Ioi_zero : (𝓝[>] (0 : 𝕜))⁻¹ = atTop 
goal: (𝓝[>] 0)⁻¹ = Filter.atTop

full_name: tendsto_inv_zero_atTop
code: /-- The function `x ↦ x⁻¹` tends to `+∞` on the right of `0`. -/
theorem tendsto_inv_zero_atTop : Tendsto (fun x : 𝕜 => x⁻¹) (𝓝[>] (0 : 𝕜)) atTop 
goal: Filter.Tendsto (fun x => x⁻¹) (𝓝[>] 0) Filter.atTop

full_name: tendsto_inv_atTop_zero'
code: /-- The function `r ↦ r⁻¹` tends to `0` on the right as `r → +∞`. -/
theorem tendsto_inv_atTop_zero' : Tendsto (fun r : 𝕜 => r⁻¹) atTop (𝓝[>] (0 : 𝕜)) 
goal: Filter.Tendsto (fun r => r⁻¹) Filter.atTop (𝓝[>] 0)

full_name: tendsto_inv_atTop_zero
code: theorem tendsto_inv_atTop_zero : Tendsto (fun r : 𝕜 => r⁻¹) atTop (𝓝 0) 
goal: Filter.Tendsto (fun r => r⁻¹) Filter.atTop (𝓝 0)

full_name: Filter.Tendsto.div_atTop
code: theorem Filter.Tendsto.div_atTop {a : 𝕜} (h : Tendsto f l (𝓝 a)) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x / g x) l (𝓝 0) 
goal: Filter.Tendsto (fun x => f x / g x) l (𝓝 0)

full_name: Filter.Tendsto.inv_tendsto_atTop
code: theorem Filter.Tendsto.inv_tendsto_atTop (h : Tendsto f l atTop) : Tendsto f⁻¹ l (𝓝 0) 
goal: Filter.Tendsto f⁻¹ l (𝓝 0)

full_name: Filter.Tendsto.inv_tendsto_zero
code: theorem Filter.Tendsto.inv_tendsto_zero (h : Tendsto f l (𝓝[>] 0)) : Tendsto f⁻¹ l atTop 
goal: Filter.Tendsto f⁻¹ l Filter.atTop

full_name: tendsto_pow_neg_atTop
code: /-- The function `x^(-n)` tends to `0` at `+∞` for any positive natural `n`.
A version for positive real powers exists as `tendsto_rpow_neg_atTop`. -/
theorem tendsto_pow_neg_atTop {n : ℕ} (hn : n ≠ 0) :
    Tendsto (fun x : 𝕜 => x ^ (-(n : ℤ))) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => x ^ (-↑n)) Filter.atTop (𝓝 0)

full_name: tendsto_zpow_atTop_zero
code: theorem tendsto_zpow_atTop_zero {n : ℤ} (hn : n < 0) :
    Tendsto (fun x : 𝕜 => x ^ n) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => x ^ n) Filter.atTop (𝓝 0)

full_name: tendsto_const_mul_zpow_atTop_zero
code: theorem tendsto_const_mul_zpow_atTop_zero {n : ℤ} {c : 𝕜} (hn : n < 0) :
    Tendsto (fun x => c * x ^ n) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop (𝓝 0)

full_name: tendsto_const_mul_pow_nhds_iff'
code: theorem tendsto_const_mul_pow_nhds_iff' {n : ℕ} {c d : 𝕜} :
    Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

full_name: tendsto_const_mul_pow_nhds_iff
code: theorem tendsto_const_mul_pow_nhds_iff {n : ℕ} {c d : 𝕜} (hc : c ≠ 0) :
    Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ n = 0 ∧ c = d 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop (𝓝 d) ↔ n = 0 ∧ c = d

full_name: tendsto_const_mul_zpow_atTop_nhds_iff
code: theorem tendsto_const_mul_zpow_atTop_nhds_iff {n : ℤ} {c d : 𝕜} (hc : c ≠ 0) :
    Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ n = 0 ∧ c = d ∨ n < 0 ∧ d = 0 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop (𝓝 d) ↔ n = 0 ∧ c = d ∨ n < 0 ∧ d = 0

full_name: LinearOrderedSemifield.toHasContinuousInv₀
code: instance (priority := 100) LinearOrderedSemifield.toHasContinuousInv₀ {𝕜}
    [LinearOrderedSemifield 𝕜] [TopologicalSpace 𝕜] [OrderTopology 𝕜] [ContinuousMul 𝕜] :
    HasContinuousInv₀ 𝕜 
goal: HasContinuousInv₀ 𝕜

full_name: LinearOrderedField.toTopologicalDivisionRing
code: instance (priority := 100) LinearOrderedField.toTopologicalDivisionRing :
    TopologicalDivisionRing 𝕜 
goal: TopologicalDivisionRing 𝕜

full_name: nhdsWithin_pos_comap_mul_left
code: theorem nhdsWithin_pos_comap_mul_left {x : 𝕜} (hx : 0 < x) :
    comap (x * ·) (𝓝[>] 0) = 𝓝[>] 0 
goal: Filter.comap (fun x_1 => x * x_1) (𝓝[>] 0) = 𝓝[>] 0

full_name: eventually_nhdsWithin_pos_mul_left
code: theorem eventually_nhdsWithin_pos_mul_left {x : 𝕜} (hx : 0 < x) {p : 𝕜 → Prop}
    (h : ∀ᶠ ε in 𝓝[>] 0, p ε) : ∀ᶠ ε in 𝓝[>] 0, p (x * ε) 
goal: ∀ᶠ (ε : 𝕜) in 𝓝[>] 0, p (x * ε)