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⟩