Theorem: Complex.continuousAt_cpow_zero_of_re_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: have hz₀ : z ≠ 0 := ne_of_apply_ne re hz.ne'
state_before: z : ℂ
hz : 0 < z.re
⊢ ContinuousAt (fun x => x.1 ^ x.2) (0, z)
state_after: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ ContinuousAt (fun x => x.1 ^ x.2) (0, z)

tactic: rw [ContinuousAt, zero_cpow hz₀, tendsto_zero_iff_norm_tendsto_zero]
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ ContinuousAt (fun x => x.1 ^ x.2) (0, z)
state_after: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => ‖x.1 ^ x.2‖) (𝓝 (0, z)) (𝓝 0)

tactic: refine squeeze_zero (fun _ => norm_nonneg _) (fun _ => abs_cpow_le _ _) ?_
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => ‖x.1 ^ x.2‖) (𝓝 (0, z)) (𝓝 0)
state_after: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => abs x.1 ^ x.2.re / rexp (x.1.arg * x.2.im)) (𝓝 (0, z)) (𝓝 0)

tactic: simp only [div_eq_mul_inv, ← Real.exp_neg]
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => abs x.1 ^ x.2.re / rexp (x.1.arg * x.2.im)) (𝓝 (0, z)) (𝓝 0)
state_after: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => abs x.1 ^ x.2.re * rexp (-(x.1.arg * x.2.im))) (𝓝 (0, z)) (𝓝 0)

tactic: refine Tendsto.zero_mul_isBoundedUnder_le ?_ ?_
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => abs x.1 ^ x.2.re * rexp (-(x.1.arg * x.2.im))) (𝓝 (0, z)) (𝓝 0)
state_after: case refine_1
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => abs x.1 ^ x.2.re) (𝓝 (0, z)) (𝓝 0)

case refine_2
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) ((fun x => ‖x‖) ∘ fun x => rexp (-(x.1.arg * x.2.im)))

tactic: convert
    (continuous_fst.norm.tendsto ((0 : ℂ), z)).rpow
      ((continuous_re.comp continuous_snd).tendsto _) _ <;>
  simp [hz, Real.zero_rpow hz.ne']
state_before: case refine_1
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => abs x.1 ^ x.2.re) (𝓝 (0, z)) (𝓝 0)
state_after: no goals

tactic: simp only [Function.comp, Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)]
state_before: case refine_2
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) ((fun x => ‖x‖) ∘ fun x => rexp (-(x.1.arg * x.2.im)))
state_after: case refine_2
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) fun x => rexp (-(x.1.arg * x.2.im))

tactic: rcases exists_gt |im z| with ⟨C, hC⟩
state_before: case refine_2
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) fun x => rexp (-(x.1.arg * x.2.im))
state_after: case refine_2.intro
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
C : ℝ
hC : |z.im| < C
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) fun x => rexp (-(x.1.arg * x.2.im))

tactic: refine ⟨Real.exp (π * C), eventually_map.2 ?_⟩
state_before: case refine_2.intro
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
C : ℝ
hC : |z.im| < C
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) fun x => rexp (-(x.1.arg * x.2.im))
state_after: case refine_2.intro
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
C : ℝ
hC : |z.im| < C
⊢ ∀ᶠ (a : ℂ × ℂ) in 𝓝 (0, z), (fun x x_1 => x ≤ x_1) (rexp (-(a.1.arg * a.2.im))) (rexp (π * C))

tactic: refine
  (((continuous_im.comp continuous_snd).abs.tendsto (_, z)).eventually (gt_mem_nhds hC)).mono
    fun z hz => Real.exp_le_exp.2 <| (neg_le_abs _).trans ?_
state_before: case refine_2.intro
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
C : ℝ
hC : |z.im| < C
⊢ ∀ᶠ (a : ℂ × ℂ) in 𝓝 (0, z), (fun x x_1 => x ≤ x_1) (rexp (-(a.1.arg * a.2.im))) (rexp (π * C))
state_after: case refine_2.intro
z✝ : ℂ
hz✝ : 0 < z✝.re
hz₀ : z✝ ≠ 0
C : ℝ
hC : |z✝.im| < C
z : ℂ × ℂ
hz : |(im ∘ Prod.snd) z| < C
⊢ |z.1.arg * z.2.im| ≤ π * C

tactic: rw [_root_.abs_mul]
state_before: case refine_2.intro
z✝ : ℂ
hz✝ : 0 < z✝.re
hz₀ : z✝ ≠ 0
C : ℝ
hC : |z✝.im| < C
z : ℂ × ℂ
hz : |(im ∘ Prod.snd) z| < C
⊢ |z.1.arg * z.2.im| ≤ π * C
state_after: case refine_2.intro
z✝ : ℂ
hz✝ : 0 < z✝.re
hz₀ : z✝ ≠ 0
C : ℝ
hC : |z✝.im| < C
z : ℂ × ℂ
hz : |(im ∘ Prod.snd) z| < C
⊢ |z.1.arg| * |z.2.im| ≤ π * C

tactic: exact
  mul_le_mul (abs_le.2 ⟨(neg_pi_lt_arg _).le, arg_le_pi _⟩) hz.le (_root_.abs_nonneg _)
    Real.pi_pos.le
state_before: case refine_2.intro
z✝ : ℂ
hz✝ : 0 < z✝.re
hz₀ : z✝ ≠ 0
C : ℝ
hC : |z✝.im| < C
z : ℂ × ℂ
hz : |(im ∘ Prod.snd) z| < C
⊢ |z.1.arg| * |z.2.im| ≤ π * C
state_after: no goals