l3lab/ntp-mathlib huggingface dataset:
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
⊢ ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)

Next tactic:
intro b' c' h
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
b' c' : ℝ
h : 0 < b'
⊢ Tendsto (fun x => x ^ n / (b' * rexp x + c')) atTop (𝓝 0)

Next tactic:
convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    

Proof state:
case h.e'_3
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
b' c' : ℝ
h : 0 < b'
⊢ (fun x => x ^ n / (b' * rexp x + c')) = (fun x => (b' * rexp x + c') / x ^ n)⁻¹

Next tactic:
ext x
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    

Proof state:
case h.e'_3.h
α : Type u_1
x✝ y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
b' c' : ℝ
h : 0 < b'
x : ℝ
⊢ x ^ n / (b' * rexp x + c') = (fun x => (b' * rexp x + c') / x ^ n)⁻¹ x

Next tactic:
simp
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)

Next tactic:
cases' lt_or_gt_of_ne hb with h h
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  cases' lt_or_gt_of_ne hb with h h
  · 

Proof state:
case inl
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 < b
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)

Next tactic:
exact H b c h
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  cases' lt_or_gt_of_ne hb with h h
  · exact H b c h
  · 

Proof state:
case inr
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)

Next tactic:
convert (H (-b) (-c) (neg_pos.mpr h)).neg using 1
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  cases' lt_or_gt_of_ne hb with h h
  · exact H b c h
  · convert (H (-b) (-c) (neg_pos.mpr h)).neg using 1
    · 

Proof state:
case h.e'_3
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ (fun x => x ^ n / (b * rexp x + c)) = fun x => -(x ^ n / (-b * rexp x + -c))

Next tactic:
ext x
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  cases' lt_or_gt_of_ne hb with h h
  · exact H b c h
  · convert (H (-b) (-c) (neg_pos.mpr h)).neg using 1
    · ext x
      

Proof state:
case h.e'_3.h
α : Type u_1
x✝ y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 > b
x : ℝ
⊢ x ^ n / (b * rexp x + c) = -(x ^ n / (-b * rexp x + -c))

Next tactic:
field_simp
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  cases' lt_or_gt_of_ne hb with h h
  · exact H b c h
  · convert (H (-b) (-c) (neg_pos.mpr h)).neg using 1
    · ext x
      field_simp
      

Proof state:
case h.e'_3.h
α : Type u_1
x✝ y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 > b
x : ℝ
⊢ x ^ n / (b * rexp x + c) = -x ^ n / (-(b * rexp x) + -c)

Next tactic:
rw [← neg_add (b * exp x) c, neg_div_neg_eq]
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0) := by
  have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
  cases' lt_or_gt_of_ne hb with h h
  · exact H b c h
  · convert (H (-b) (-c) (neg_pos.mpr h)).neg using 1
    · ext x
      field_simp
      rw [← neg_add (b * exp x) c, neg_div_neg_eq]
    · 

Proof state:
case h.e'_5
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ 𝓝 0 = 𝓝 (-0)

Next tactic:
rw [neg_zero]
/-- `Real.exp` as an order isomorphism between `ℝ` and `(0, +∞)`. -/
def expOrderIso : ℝ ≃o Ioi (0 : ℝ) :=
  StrictMono.orderIsoOfSurjective _ (exp_strictMono.codRestrict exp_pos) <|
    (continuous_exp.subtype_mk _).surjective
      (by 

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ Tendsto (fun x => { val := rexp x, property := (_ : 0 < rexp x) }) atTop atTop

Next tactic:
simp only [tendsto_Ioi_atTop, Subtype.coe_mk, tendsto_exp_atTop]
/-- `Real.exp` as an order isomorphism between `ℝ` and `(0, +∞)`. -/
def expOrderIso : ℝ ≃o Ioi (0 : ℝ) :=
  StrictMono.orderIsoOfSurjective _ (exp_strictMono.codRestrict exp_pos) <|
    (continuous_exp.subtype_mk _).surjective
      (by simp only [tendsto_Ioi_atTop, Subtype.coe_mk, tendsto_exp_atTop])
      (by 

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ Tendsto (fun x => { val := rexp x, property := (_ : 0 < rexp x) }) atBot atBot

Next tactic:
simp [tendsto_exp_atBot_nhdsWithin]
@[simp]
theorem range_exp : range exp = Set.Ioi 0 := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ Set.range rexp = Set.Ioi 0

Next tactic:
rw [← coe_comp_expOrderIso, range_comp, expOrderIso.range_eq, image_univ, Subtype.range_coe]
@[simp]
theorem map_exp_atTop : map exp atTop = atTop := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ Filter.map rexp atTop = atTop

Next tactic:
rw [← coe_comp_expOrderIso, ← Filter.map_map, OrderIso.map_atTop, map_val_Ioi_atTop]
@[simp]
theorem comap_exp_atTop : comap exp atTop = atTop := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ comap rexp atTop = atTop

Next tactic:
rw [← map_exp_atTop, comap_map exp_injective, map_exp_atTop]
@[simp]
theorem tendsto_exp_comp_atTop {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l atTop ↔ Tendsto f l atTop := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ Tendsto (fun x => rexp (f x)) l atTop ↔ Tendsto f l atTop

Next tactic:
simp_rw [← comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_atTop]
theorem tendsto_comp_exp_atTop {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atTop l ↔ Tendsto f atTop l := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : ℝ → α
⊢ Tendsto (fun x => f (rexp x)) atTop l ↔ Tendsto f atTop l

Next tactic:
simp_rw [← comp_apply (g := exp), ← tendsto_map'_iff, map_exp_atTop]
@[simp]
theorem map_exp_atBot : map exp atBot = 𝓝[>] 0 := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ Filter.map rexp atBot = 𝓝[>] 0

Next tactic:
rw [← coe_comp_expOrderIso, ← Filter.map_map, expOrderIso.map_atBot, ← map_coe_Ioi_atBot]
@[simp]
theorem comap_exp_nhdsWithin_Ioi_zero : comap exp (𝓝[>] 0) = atBot := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ comap rexp (𝓝[>] 0) = atBot

Next tactic:
rw [← map_exp_atBot, comap_map exp_injective]
theorem tendsto_comp_exp_atBot {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto f (𝓝[>] 0) l := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : ℝ → α
⊢ Tendsto (fun x => f (rexp x)) atBot l ↔ Tendsto f (𝓝[>] 0) l

Next tactic:
rw [← map_exp_atBot, tendsto_map'_iff]
theorem tendsto_comp_exp_atBot {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto f (𝓝[>] 0) l := by
  rw [← map_exp_atBot, tendsto_map'_iff]
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : ℝ → α
⊢ Tendsto (fun x => f (rexp x)) atBot l ↔ Tendsto (f ∘ rexp) atBot l

Next tactic:
rfl
@[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = atBot :=
  (comap_nhdsWithin_range exp 0).symm.trans <| by 

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
⊢ comap rexp (𝓝[Set.range rexp] 0) = atBot

Next tactic:
simp
@[simp]
theorem tendsto_exp_comp_nhds_zero {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto f l atBot := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ Tendsto (fun x => rexp (f x)) l (𝓝 0) ↔ Tendsto f l atBot

Next tactic:
simp_rw [← comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_nhds_zero]
theorem isLittleO_pow_exp_atTop {n : ℕ} : (fun x : ℝ => x ^ n) =o[atTop] Real.exp := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
n : ℕ
⊢ (fun x => x ^ n) =o[atTop] rexp

Next tactic:
simpa [isLittleO_iff_tendsto fun x hx => ((exp_pos x).ne' hx).elim] using
    tendsto_div_pow_mul_exp_add_atTop 1 0 n zero_ne_one
@[simp]
theorem isBigO_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =O[l] fun x => exp (g x)) ↔ IsBoundedUnder (· ≤ ·) l (f - g) :=
  Iff.trans (isBigO_iff_isBoundedUnder_le_div <| eventually_of_forall fun x => exp_ne_zero _) <| by
    

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f g : α → ℝ
⊢ (IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖rexp (f x)‖ / ‖rexp (g x)‖) ↔
    IsBoundedUnder (fun x x_1 => x ≤ x_1) l (f - g)

Next tactic:
simp only [norm_eq_abs, abs_exp, ← exp_sub, isBoundedUnder_le_exp_comp, Pi.sub_def]
@[simp]
theorem isTheta_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =Θ[l] fun x => exp (g x)) ↔
      IsBoundedUnder (· ≤ ·) l fun x => |f x - g x| := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f g : α → ℝ
⊢ ((fun x => rexp (f x)) =Θ[l] fun x => rexp (g x)) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |f x - g x|

Next tactic:
simp only [isBoundedUnder_le_abs, ← isBoundedUnder_le_neg, neg_sub, IsTheta,
    isBigO_exp_comp_exp_comp, Pi.sub_def]
@[simp]
theorem isLittleO_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =o[l] fun x => exp (g x)) ↔ Tendsto (fun x => g x - f x) l atTop := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f g : α → ℝ
⊢ ((fun x => rexp (f x)) =o[l] fun x => rexp (g x)) ↔ Tendsto (fun x => g x - f x) l atTop

Next tactic:
simp only [isLittleO_iff_tendsto, exp_ne_zero, ← exp_sub, ← tendsto_neg_atTop_iff, false_imp_iff,
    imp_true_iff, tendsto_exp_comp_nhds_zero, neg_sub]
theorem isLittleO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =o[l] fun x => exp (f x)) ↔ Tendsto f l atTop := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => 1) =o[l] fun x => rexp (f x)) ↔ Tendsto f l atTop

Next tactic:
simp only [← exp_zero, isLittleO_exp_comp_exp_comp, sub_zero]
/-- `Real.exp (f x)` is bounded away from zero along a filter if and only if this filter is bounded
from below under `f`. -/
@[simp]
theorem isBigO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =O[l] fun x => exp (f x)) ↔ IsBoundedUnder (· ≥ ·) l f := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => 1) =O[l] fun x => rexp (f x)) ↔ IsBoundedUnder (fun x x_1 => x ≥ x_1) l f

Next tactic:
simp only [← exp_zero, isBigO_exp_comp_exp_comp, Pi.sub_def, zero_sub, isBoundedUnder_le_neg]
/-- `Real.exp (f x)` is bounded away from zero along a filter if and only if this filter is bounded
from below under `f`. -/
theorem isBigO_exp_comp_one {f : α → ℝ} :
    (fun x => exp (f x)) =O[l] (fun _ => 1 : α → ℝ) ↔ IsBoundedUnder (· ≤ ·) l f := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => rexp (f x)) =O[l] fun x => 1) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

Next tactic:
simp only [isBigO_one_iff, norm_eq_abs, abs_exp, isBoundedUnder_le_exp_comp]
/-- `Real.exp (f x)` is bounded away from zero and infinity along a filter `l` if and only if
`|f x|` is bounded from above along this filter. -/
@[simp]
theorem isTheta_exp_comp_one {f : α → ℝ} :
    (fun x => exp (f x)) =Θ[l] (fun _ => 1 : α → ℝ) ↔ IsBoundedUnder (· ≤ ·) l fun x => |f x| := by
  

Proof state:
α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => rexp (f x)) =Θ[l] fun x => 1) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |f x|

Next tactic:
simp only [← exp_zero, isTheta_exp_comp_exp_comp, sub_zero]
@[simp]
theorem comap_exp_cobounded : comap exp (cobounded ℂ) = comap re atTop :=
  calc
    comap exp (cobounded ℂ) = comap re (comap Real.exp atTop) := by
      

Proof state:
⊢ comap cexp (cobounded ℂ) = comap re (comap Real.exp atTop)

Next tactic:
simp only [← comap_norm_atTop, Complex.norm_eq_abs, comap_comap, (· ∘ ·), abs_exp]
@[simp]
theorem comap_exp_cobounded : comap exp (cobounded ℂ) = comap re atTop :=
  calc
    comap exp (cobounded ℂ) = comap re (comap Real.exp atTop) := by
      simp only [← comap_norm_atTop, Complex.norm_eq_abs, comap_comap, (· ∘ ·), abs_exp]
    _ = comap re atTop := by 

Proof state:
⊢ comap re (comap Real.exp atTop) = comap re atTop

Next tactic:
rw [Real.comap_exp_atTop]
@[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = comap re atBot :=
  calc
    comap exp (𝓝 0) = comap re (comap Real.exp (𝓝 0)) := by
      

Proof state:
⊢ comap cexp (𝓝 0) = comap re (comap Real.exp (𝓝 0))

Next tactic:
simp only [comap_comap, ← comap_abs_nhds_zero, (· ∘ ·), abs_exp]
@[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = comap re atBot :=
  calc
    comap exp (𝓝 0) = comap re (comap Real.exp (𝓝 0)) := by
      simp only [comap_comap, ← comap_abs_nhds_zero, (· ∘ ·), abs_exp]
    _ = comap re atBot := by 

Proof state:
⊢ comap re (comap Real.exp (𝓝 0)) = comap re atBot

Next tactic:
rw [Real.comap_exp_nhds_zero]
theorem comap_exp_nhdsWithin_zero : comap exp (𝓝[≠] 0) = comap re atBot := by
  

Proof state:
⊢ comap cexp (𝓝[≠] 0) = comap re atBot

Next tactic:
have : (exp ⁻¹' {0})ᶜ = Set.univ := eq_univ_of_forall exp_ne_zero
theorem comap_exp_nhdsWithin_zero : comap exp (𝓝[≠] 0) = comap re atBot := by
  have : (exp ⁻¹' {0})ᶜ = Set.univ := eq_univ_of_forall exp_ne_zero
  

Proof state:
this : (cexp ⁻¹' {0})ᶜ = Set.univ
⊢ comap cexp (𝓝[≠] 0) = comap re atBot

Next tactic:
simp [nhdsWithin, comap_exp_nhds_zero, this]
theorem tendsto_exp_nhds_zero_iff {α : Type*} {l : Filter α} {f : α → ℂ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto (fun x => re (f x)) l atBot := by
  

Proof state:
α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (fun x => cexp (f x)) l (𝓝 0) ↔ Tendsto (fun x => (f x).re) l atBot

Next tactic:
simp_rw [← comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_nhds_zero, tendsto_comap_iff]
theorem tendsto_exp_nhds_zero_iff {α : Type*} {l : Filter α} {f : α → ℂ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto (fun x => re (f x)) l atBot := by
  simp_rw [← comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_nhds_zero, tendsto_comap_iff]
  

Proof state:
α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (re ∘ f) l atBot ↔ Tendsto (fun x => (f x).re) l atBot

Next tactic:
rfl
/-- The prod of two linear maps is a linear map. -/
@[simps]
def prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : M →ₗ[R] M₂ × M₃ where
  toFun := Pi.prod f g
  map_add' x y := by 

Proof state:
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ f : M →ₗ[R] M₂
g : M →ₗ[R] M₃
x y : M
⊢ Pi.prod (⇑f) (⇑g) (x + y) = Pi.prod (⇑f) (⇑g) x + Pi.prod (⇑f) (⇑g) y

Next tactic:
simp only [Pi.prod, Prod.mk_add_mk, map_add]
/-- The prod of two linear maps is a linear map. -/
@[simps]
def prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : M →ₗ[R] M₂ × M₃ where
  toFun := Pi.prod f g
  map_add' x y := by simp only [Pi.prod, Prod.mk_add_mk, map_add]
  map_smul' c x := by 

Proof state:
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ f : M →ₗ[R] M₂
g : M →ₗ[R] M₃
c : R
x : M
⊢ AddHom.toFun
      { toFun := Pi.prod ⇑f ⇑g, map_add' := (_ : ∀ (x y : M), (f (x + y), g (x + y)) = (f x + f y, g x + g y)) }
      (c • x) =
    (RingHom.id R) c •
      AddHom.toFun
        { toFun := Pi.prod ⇑f ⇑g, map_add' := (_ : ∀ (x y : M), (f (x + y), g (x + y)) = (f x + f y, g x + g y)) } x

Next tactic:
simp only [Pi.prod, Prod.smul_mk, map_smul, RingHom.id_apply]
/-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def prodEquiv [Module S M₂] [Module S M₃] [SMulCommClass R S M₂] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₂) × (M →ₗ[R] M₃)) ≃ₗ[S] M →ₗ[R] M₂ × M₃ where
  toFun f := f.1.prod f.2
  invFun f := ((fst _ _ _).comp f, (snd _ _ _).comp f)
  left_inv f := by 

Proof state:
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring S
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : AddCommMonoid M₅
inst✝¹⁰ : AddCommMonoid M₆
inst✝⁹ : Module R M
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : Module R M₅
inst✝⁴ : Module R M₆
f✝ : M →ₗ[R] M₂
inst✝³ : Module S M₂
inst✝² : Module S M₃
inst✝¹ : SMulCommClass R S M₂
inst✝ : SMulCommClass R S M₃
f : (M →ₗ[R] M₂) × (M →ₗ[R] M₃)
⊢ (fun f => (fst R M₂ M₃ ∘ₗ f, snd R M₂ M₃ ∘ₗ f))
      (AddHom.toFun
        {
            toAddHom :=
              { toFun := fun f => prod f.1 f.2,
                map_add' :=
                  (_ :
                    ∀ (a b : (M →ₗ[R] M₂) × (M →ₗ[R] M₃)),
                      (fun f => prod f.1 f.2) (a + b) = (fun f => prod f.1 f.2) (a + b)) },
            map_smul' :=
              (_ :
                ∀ (r : S) (a : (M →ₗ[R] M₂) × (M →ₗ[R] M₃)),
                  AddHom.toFun
                      { toFun := fun f => prod f.1 f.2,
                        map_add' :=
                          (_ :
                            ∀ (a b : (M →ₗ[R] M₂) × (M →ₗ[R] M₃)),
                              (fun f => prod f.1 f.2) (a + b) = (fun f => prod f.1 f.2) (a + b)) }
                      (r • a) =
                    AddHom.toFun
                      { toFun := fun f => prod f.1 f.2,
                        map_add' :=
                          (_ :
                            ∀ (a b : (M →ₗ[R] M₂) × (M →ₗ[R] M₃)),
                              (fun f => prod f.1 f.2) (a + b) = (fun f => prod f.1 f.2) (a + b)) }
                      (r • a)) }.toAddHom
        f) =
    f

Next tactic:
ext