Module docstring
{"# Convergence to ±infinity in ordered commutative monoids "}
{"# Convergence to ±infinity in ordered commutative monoids "}
Filter.Tendsto.one_eventuallyLE_mul_atTop
theorem
(hf : 1 ≤ᶠ[l] f) (hg : Tendsto g l atTop) : Tendsto (fun x => f x * g x) l atTop
@[to_additive]
theorem Tendsto.one_eventuallyLE_mul_atTop (hf : 1 ≤ᶠ[l] f) (hg : Tendsto g l atTop) :
Tendsto (fun x => f x * g x) l atTop :=
tendsto_atTop_mono' l (hf.mono fun _ ↦ le_mul_of_one_le_left') hg
Filter.Tendsto.eventuallyLE_one_mul_atBot
theorem
(hf : f ≤ᶠ[l] 1) (hg : Tendsto g l atBot) : Tendsto (fun x => f x * g x) l atBot
@[to_additive]
theorem Tendsto.eventuallyLE_one_mul_atBot (hf : f ≤ᶠ[l] 1) (hg : Tendsto g l atBot) :
Tendsto (fun x => f x * g x) l atBot :=
hg.one_eventuallyLE_mul_atTop (M := Mᵒᵈ) hf
Filter.Tendsto.one_le_mul_atTop
theorem
(hf : ∀ x, 1 ≤ f x) (hg : Tendsto g l atTop) : Tendsto (fun x => f x * g x) l atTop
@[to_additive]
theorem Tendsto.one_le_mul_atTop (hf : ∀ x, 1 ≤ f x) (hg : Tendsto g l atTop) :
Tendsto (fun x => f x * g x) l atTop :=
hg.one_eventuallyLE_mul_atTop (.of_forall hf)
Filter.Tendsto.le_one_mul_atBot
theorem
(hf : ∀ x, f x ≤ 1) (hg : Tendsto g l atBot) : Tendsto (fun x => f x * g x) l atBot
@[to_additive]
theorem Tendsto.le_one_mul_atBot (hf : ∀ x, f x ≤ 1) (hg : Tendsto g l atBot) :
Tendsto (fun x => f x * g x) l atBot :=
hg.eventuallyLE_one_mul_atBot (.of_forall hf)
Filter.Tendsto.atTop_mul_one_eventuallyLE
theorem
(hf : Tendsto f l atTop) (hg : 1 ≤ᶠ[l] g) : Tendsto (fun x => f x * g x) l atTop
@[to_additive]
theorem Tendsto.atTop_mul_one_eventuallyLE (hf : Tendsto f l atTop) (hg : 1 ≤ᶠ[l] g) :
Tendsto (fun x => f x * g x) l atTop :=
tendsto_atTop_mono' l (hg.mono fun _ => le_mul_of_one_le_right') hf
Filter.Tendsto.atBot_mul_eventuallyLE_one
theorem
(hf : Tendsto f l atBot) (hg : g ≤ᶠ[l] 1) : Tendsto (fun x => f x * g x) l atBot
@[to_additive]
theorem Tendsto.atBot_mul_eventuallyLE_one (hf : Tendsto f l atBot) (hg : g ≤ᶠ[l] 1) :
Tendsto (fun x => f x * g x) l atBot :=
hf.atTop_mul_one_eventuallyLE (M := Mᵒᵈ) hg
Filter.Tendsto.atTop_mul_one_le
theorem
(hf : Tendsto f l atTop) (hg : ∀ x, 1 ≤ g x) : Tendsto (fun x => f x * g x) l atTop
@[to_additive]
theorem Tendsto.atTop_mul_one_le (hf : Tendsto f l atTop) (hg : ∀ x, 1 ≤ g x) :
Tendsto (fun x => f x * g x) l atTop :=
hf.atTop_mul_one_eventuallyLE <| .of_forall hg
Filter.Tendsto.atBot_mul_le_one
theorem
(hf : Tendsto f l atBot) (hg : ∀ x, g x ≤ 1) : Tendsto (fun x => f x * g x) l atBot
@[to_additive]
theorem Tendsto.atBot_mul_le_one (hf : Tendsto f l atBot) (hg : ∀ x, g x ≤ 1) :
Tendsto (fun x => f x * g x) l atBot :=
hf.atBot_mul_eventuallyLE_one (.of_forall hg)
Filter.Tendsto.atTop_mul_atTop
theorem
(hf : Tendsto f l atTop) (hg : Tendsto g l atTop) : Tendsto (fun x => f x * g x) l atTop
/-- In an ordered multiplicative monoid, if `f` and `g` tend to `+∞`, then so does `f * g`.
Earlier, this name was used for a similar lemma about semirings,
which is now called `Filter.Tendsto.atTop_mul_atTop₀`. -/
@[to_additive]
theorem Tendsto.atTop_mul_atTop (hf : Tendsto f l atTop) (hg : Tendsto g l atTop) :
Tendsto (fun x => f x * g x) l atTop :=
hf.atTop_mul_one_eventuallyLE <| hg.eventually_ge_atTop 1
Filter.Tendsto.atBot_mul_atBot
theorem
(hf : Tendsto f l atBot) (hg : Tendsto g l atBot) : Tendsto (fun x => f x * g x) l atBot
/-- In an ordered multiplicative monoid, if `f` and `g` tend to `-∞`, then so does `f * g`.
Earlier, this name was used for a similar lemma about rings (with conclusion `f * g → +∞`),
which is now called `Filter.Tendsto.atBot_mul_atBot₀`. -/
@[to_additive]
theorem Tendsto.atBot_mul_atBot (hf : Tendsto f l atBot) (hg : Tendsto g l atBot) :
Tendsto (fun x => f x * g x) l atBot :=
hf.atTop_mul_atTop (M := Mᵒᵈ) hg
Filter.Tendsto.atTop_pow
theorem
(hf : Tendsto f l atTop) {n : ℕ} (hn : 0 < n) : Tendsto (fun x => f x ^ n) l atTop
@[to_additive nsmul_atTop]
theorem Tendsto.atTop_pow (hf : Tendsto f l atTop) {n : ℕ} (hn : 0 < n) :
Tendsto (fun x => f x ^ n) l atTop := by
refine tendsto_atTop_mono' _ ((hf.eventually_ge_atTop 1).mono fun x hx ↦ ?_) hf
simpa only [pow_one] using pow_le_pow_right' hx hn
Filter.Tendsto.atBot_pow
theorem
(hf : Tendsto f l atBot) {n : ℕ} (hn : 0 < n) : Tendsto (fun x => f x ^ n) l atBot
@[to_additive nsmul_atBot]
theorem Tendsto.atBot_pow (hf : Tendsto f l atBot) {n : ℕ} (hn : 0 < n) :
Tendsto (fun x => f x ^ n) l atBot :=
Tendsto.atTop_pow (M := Mᵒᵈ) hf hn
Filter.Tendsto.atTop_of_const_mul
theorem
(C : M) (hf : Tendsto (C * f ·) l atTop) : Tendsto f l atTop
/-- In an ordered cancellative multiplicative monoid, if `C * f x → +∞`, then `f x → +∞`.
Earlier, this name was used for a similar lemma about ordered rings,
which is now called `Filter.Tendsto.atTop_of_const_mul₀`. -/
@[to_additive]
theorem Tendsto.atTop_of_const_mul (C : M) (hf : Tendsto (C * f ·) l atTop) : Tendsto f l atTop :=
tendsto_atTop.2 fun b ↦ (tendsto_atTop.1 hf (C * b)).mono fun _ ↦ le_of_mul_le_mul_left'
Filter.Tendsto.atBot_of_const_mul
theorem
(C : M) (hf : Tendsto (C * f ·) l atBot) : Tendsto f l atBot
@[to_additive]
theorem Tendsto.atBot_of_const_mul (C : M) (hf : Tendsto (C * f ·) l atBot) : Tendsto f l atBot :=
hf.atTop_of_const_mul (M := Mᵒᵈ)
Filter.Tendsto.atTop_of_mul_const
theorem
(C : M) (hf : Tendsto (f · * C) l atTop) : Tendsto f l atTop
/-- In an ordered cancellative multiplicative monoid, if `f x * C → +∞`, then `f x → +∞`.
Earlier, this name was used for a similar lemma about ordered rings,
which is now called `Filter.Tendsto.atTop_of_mul_const₀`. -/
@[to_additive]
theorem Tendsto.atTop_of_mul_const (C : M) (hf : Tendsto (f · * C) l atTop) : Tendsto f l atTop :=
tendsto_atTop.2 fun b => (tendsto_atTop.1 hf (b * C)).mono fun _ => le_of_mul_le_mul_right'
Filter.Tendsto.atBot_of_mul_const
theorem
(C : M) (hf : Tendsto (f · * C) l atBot) : Tendsto f l atBot
@[to_additive]
theorem Tendsto.atBot_of_mul_const (C : M) (hf : Tendsto (f · * C) l atBot) : Tendsto f l atBot :=
hf.atTop_of_mul_const (M := Mᵒᵈ)
Filter.Tendsto.atTop_of_isBoundedUnder_le_mul
theorem
(hf : IsBoundedUnder (· ≤ ·) l f) (hfg : Tendsto (fun x => f x * g x) l atTop) : Tendsto g l atTop
/-- If `f` is eventually bounded from above along `l` and `f * g` tends to `+∞`,
then `g` tends to `+∞`. -/
@[to_additive "If `f` is eventually bounded from above along `l` and `f + g` tends to `+∞`,
then `g` tends to `+∞`."]
theorem Tendsto.atTop_of_isBoundedUnder_le_mul (hf : IsBoundedUnder (· ≤ ·) l f)
(hfg : Tendsto (fun x => f x * g x) l atTop) : Tendsto g l atTop := by
obtain ⟨C, hC⟩ := hf
refine .atTop_of_const_mul C <| tendsto_atTop_mono' l ?_ hfg
exact (eventually_map.mp hC).mono fun _ ↦ (mul_le_mul_right' · _)
Filter.Tendsto.atBot_of_isBoundedUnder_ge_mul
theorem
(hf : IsBoundedUnder (· ≥ ·) l f) (h : Tendsto (fun x => f x * g x) l atBot) : Tendsto g l atBot
@[to_additive]
theorem Tendsto.atBot_of_isBoundedUnder_ge_mul (hf : IsBoundedUnder (· ≥ ·) l f)
(h : Tendsto (fun x => f x * g x) l atBot) : Tendsto g l atBot :=
h.atTop_of_isBoundedUnder_le_mul (M := Mᵒᵈ) hf
Filter.Tendsto.atTop_of_le_const_mul
theorem
(hf : ∃ C, ∀ x, f x ≤ C) (hfg : Tendsto (fun x ↦ f x * g x) l atTop) : Tendsto g l atTop
@[to_additive]
theorem Tendsto.atTop_of_le_const_mul (hf : ∃ C, ∀ x, f x ≤ C)
(hfg : Tendsto (fun x ↦ f x * g x) l atTop) : Tendsto g l atTop :=
hfg.atTop_of_isBoundedUnder_le_mul <| hf.imp fun _C hC ↦ eventually_map.mpr <| .of_forall hC
Filter.Tendsto.atBot_of_const_le_mul
theorem
(hf : ∃ C, ∀ x, C ≤ f x) (hfg : Tendsto (fun x ↦ f x * g x) l atBot) : Tendsto g l atBot
@[to_additive]
theorem Tendsto.atBot_of_const_le_mul (hf : ∃ C, ∀ x, C ≤ f x)
(hfg : Tendsto (fun x ↦ f x * g x) l atBot) : Tendsto g l atBot :=
Tendsto.atTop_of_le_const_mul (M := Mᵒᵈ) hf hfg
Filter.Tendsto.atTop_of_mul_isBoundedUnder_le
theorem
(hg : IsBoundedUnder (· ≤ ·) l g) (h : Tendsto (fun x => f x * g x) l atTop) : Tendsto f l atTop
@[to_additive]
theorem Tendsto.atTop_of_mul_isBoundedUnder_le (hg : IsBoundedUnder (· ≤ ·) l g)
(h : Tendsto (fun x => f x * g x) l atTop) : Tendsto f l atTop := by
obtain ⟨C, hC⟩ := hg
refine .atTop_of_mul_const C <| tendsto_atTop_mono' l ?_ h
exact (eventually_map.mp hC).mono fun _ ↦ (mul_le_mul_left' · _)
Filter.Tendsto.atBot_of_mul_isBoundedUnder_ge
theorem
(hg : IsBoundedUnder (· ≥ ·) l g) (h : Tendsto (fun x => f x * g x) l atBot) : Tendsto f l atBot
@[to_additive]
theorem Tendsto.atBot_of_mul_isBoundedUnder_ge (hg : IsBoundedUnder (· ≥ ·) l g)
(h : Tendsto (fun x => f x * g x) l atBot) : Tendsto f l atBot :=
h.atTop_of_mul_isBoundedUnder_le (M := Mᵒᵈ) hg
Filter.Tendsto.atTop_of_mul_le_const
theorem
(hg : ∃ C, ∀ x, g x ≤ C) (hfg : Tendsto (fun x ↦ f x * g x) l atTop) : Tendsto f l atTop
@[to_additive]
theorem Tendsto.atTop_of_mul_le_const (hg : ∃ C, ∀ x, g x ≤ C)
(hfg : Tendsto (fun x ↦ f x * g x) l atTop) : Tendsto f l atTop :=
hfg.atTop_of_mul_isBoundedUnder_le <| hg.imp fun _C hC ↦ eventually_map.mpr <| .of_forall hC
Filter.Tendsto.atBot_of_mul_const_le
theorem
(hg : ∃ C, ∀ x, C ≤ g x) (hfg : Tendsto (fun x ↦ f x * g x) l atBot) : Tendsto f l atBot
@[to_additive]
theorem Tendsto.atBot_of_mul_const_le (hg : ∃ C, ∀ x, C ≤ g x)
(hfg : Tendsto (fun x ↦ f x * g x) l atBot) : Tendsto f l atBot :=
Tendsto.atTop_of_mul_le_const (M := Mᵒᵈ) hg hfg
Filter.tendsto_atTop_of_add_bdd_above_left'
theorem
(C) (hC : ∀ᶠ x in l, f x ≤ C) (h : Tendsto (fun x => f x + g x) l atTop) : Tendsto g l atTop
@[deprecated Tendsto.atTop_of_isBoundedUnder_le_add (since := "2025-02-13")]
theorem tendsto_atTop_of_add_bdd_above_left' (C) (hC : ∀ᶠ x in l, f x ≤ C)
(h : Tendsto (fun x => f x + g x) l atTop) : Tendsto g l atTop :=
.atTop_of_isBoundedUnder_le_add ⟨C, hC⟩ h
Filter.tendsto_atBot_of_add_bdd_below_left'
theorem
(C) (hC : ∀ᶠ x in l, C ≤ f x) (h : Tendsto (fun x => f x + g x) l atBot) : Tendsto g l atBot
@[deprecated Tendsto.atBot_of_isBoundedUnder_ge_add (since := "2025-02-13")]
theorem tendsto_atBot_of_add_bdd_below_left' (C) (hC : ∀ᶠ x in l, C ≤ f x)
(h : Tendsto (fun x => f x + g x) l atBot) : Tendsto g l atBot :=
.atBot_of_isBoundedUnder_ge_add ⟨C, hC⟩ h
Filter.tendsto_atTop_of_add_bdd_above_left
theorem
(C) (hC : ∀ x, f x ≤ C) : Tendsto (fun x => f x + g x) l atTop → Tendsto g l atTop
@[deprecated Tendsto.atTop_of_le_const_add (since := "2025-02-13")]
theorem tendsto_atTop_of_add_bdd_above_left (C) (hC : ∀ x, f x ≤ C) :
Tendsto (fun x => f x + g x) l atTop → Tendsto g l atTop :=
.atTop_of_le_const_add ⟨C, hC⟩
Filter.tendsto_atBot_of_add_bdd_below_left
theorem
(C) (hC : ∀ x, C ≤ f x) : Tendsto (fun x => f x + g x) l atBot → Tendsto g l atBot
@[deprecated Tendsto.atBot_of_const_le_add (since := "2025-02-13")]
theorem tendsto_atBot_of_add_bdd_below_left (C) (hC : ∀ x, C ≤ f x) :
Tendsto (fun x => f x + g x) l atBot → Tendsto g l atBot :=
.atBot_of_const_le_add ⟨C, hC⟩
Filter.tendsto_atTop_of_add_bdd_above_right'
theorem
(C) (hC : ∀ᶠ x in l, g x ≤ C) (h : Tendsto (fun x => f x + g x) l atTop) : Tendsto f l atTop
@[deprecated Tendsto.atTop_of_add_isBoundedUnder_le (since := "2025-02-13")]
theorem tendsto_atTop_of_add_bdd_above_right' (C) (hC : ∀ᶠ x in l, g x ≤ C)
(h : Tendsto (fun x => f x + g x) l atTop) : Tendsto f l atTop :=
h.atTop_of_add_isBoundedUnder_le ⟨C, hC⟩
Filter.tendsto_atBot_of_add_bdd_below_right'
theorem
(C) (hC : ∀ᶠ x in l, C ≤ g x) (h : Tendsto (fun x => f x + g x) l atBot) : Tendsto f l atBot
@[deprecated Tendsto.atBot_of_add_isBoundedUnder_ge (since := "2025-02-13")]
theorem tendsto_atBot_of_add_bdd_below_right' (C) (hC : ∀ᶠ x in l, C ≤ g x)
(h : Tendsto (fun x => f x + g x) l atBot) : Tendsto f l atBot :=
h.atBot_of_add_isBoundedUnder_ge ⟨C, hC⟩
Filter.tendsto_atTop_of_add_bdd_above_right
theorem
(C) (hC : ∀ x, g x ≤ C) : Tendsto (fun x => f x + g x) l atTop → Tendsto f l atTop
@[deprecated Tendsto.atTop_of_add_le_const (since := "2025-02-13")]
theorem tendsto_atTop_of_add_bdd_above_right (C) (hC : ∀ x, g x ≤ C) :
Tendsto (fun x => f x + g x) l atTop → Tendsto f l atTop :=
.atTop_of_add_le_const ⟨C, hC⟩
Filter.tendsto_atBot_of_add_bdd_below_right
theorem
(C) (hC : ∀ x, C ≤ g x) : Tendsto (fun x => f x + g x) l atBot → Tendsto f l atBot
@[deprecated Tendsto.atBot_of_add_const_le (since := "2025-02-13")]
theorem tendsto_atBot_of_add_bdd_below_right (C) (hC : ∀ x, C ≤ g x) :
Tendsto (fun x => f x + g x) l atBot → Tendsto f l atBot :=
.atBot_of_add_const_le ⟨C, hC⟩