Theorem: PhragmenLindelof.isBigO_sub_exp_exp
File: Mathlib/Analysis/Complex/PhragmenLindelof.lean

tactic: have : ∀ {c₁ c₂ B₁ B₂}, c₁ ≤ c₂ → 0 ≤ B₂ → B₁ ≤ B₂ → ∀ z,
    ‖expR (B₁ * expR (c₁ * |u z|))‖ ≤ ‖expR (B₂ * expR (c₂ * |u z|))‖ := fun hc hB₀ hB z ↦ by
  rw [Real.norm_eq_abs, Real.norm_eq_abs, Real.abs_exp, Real.abs_exp, Real.exp_le_exp]
  exact
    mul_le_mul hB (Real.exp_le_exp.2 <| mul_le_mul_of_nonneg_right hc <| abs_nonneg _)
      (Real.exp_pos _).le hB₀
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
hBf : ∃ c, c < a ∧ ∃ B, f =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
hBg : ∃ c, c < a ∧ ∃ B, g =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
⊢ ∃ c, c < a ∧ ∃ B, (f - g) =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))

tactic: rcases hBf with ⟨cf, hcf, Bf, hOf⟩
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
hBf : ∃ c, c < a ∧ ∃ B, f =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
hBg : ∃ c, c < a ∧ ∃ B, g =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
⊢ ∃ c, c < a ∧ ∃ B, (f - g) =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))

tactic: rcases hBg with ⟨cg, hcg, Bg, hOg⟩
state_before: case intro.intro.intro
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
hBg : ∃ c, c < a ∧ ∃ B, g =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
⊢ ∃ c, c < a ∧ ∃ B, (f - g) =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))

tactic: refine' ⟨max cf cg, max_lt hcf hcg, max 0 (max Bf Bg), _⟩
state_before: case intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ ∃ c, c < a ∧ ∃ B, (f - g) =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))

tactic: refine' (hOf.trans_le <| this _ _ _).sub (hOg.trans_le <| this _ _ _)
state_before: case intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ (f - g) =O[l] fun z => expR (max 0 (max Bf Bg) * expR (max cf cg * Abs.abs (u z)))

tactic: exacts [le_max_left _ _, le_max_left _ _, (le_max_left _ _).trans (le_max_right _ _),
  le_max_right _ _, le_max_left _ _, (le_max_right _ _).trans (le_max_right _ _)]
state_before: case intro.intro.intro.intro.intro.intro.refine'_1
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ cf ≤ max cf cg

case intro.intro.intro.intro.intro.intro.refine'_2
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ 0 ≤ max 0 (max Bf Bg)

case intro.intro.intro.intro.intro.intro.refine'_3
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ Bf ≤ max 0 (max Bf Bg)

case intro.intro.intro.intro.intro.intro.refine'_4
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ cg ≤ max cf cg

case intro.intro.intro.intro.intro.intro.refine'_5
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ 0 ≤ max 0 (max Bf Bg)

case intro.intro.intro.intro.intro.intro.refine'_6
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      0 ≤ B₂ → B₁ ≤ B₂ → ∀ (z : ℂ), ‖expR (B₁ * expR (c₁ * Abs.abs (u z)))‖ ≤ ‖expR (B₂ * expR (c₂ * Abs.abs (u z)))‖
cf : ℝ
hcf : cf < a
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * expR (cf * Abs.abs (u z)))
cg : ℝ
hcg : cg < a
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * expR (cg * Abs.abs (u z)))
⊢ Bg ≤ max 0 (max Bf Bg)

tactic: rw [Real.norm_eq_abs, Real.norm_eq_abs, Real.abs_exp, Real.abs_exp, Real.exp_le_exp]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
hBf : ∃ c, c < a ∧ ∃ B, f =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
hBg : ∃ c, c < a ∧ ∃ B, g =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
c₁✝ c₂✝ B₁✝ B₂✝ : ℝ
hc : c₁✝ ≤ c₂✝
hB₀ : 0 ≤ B₂✝
hB : B₁✝ ≤ B₂✝
z : ℂ
⊢ ‖expR (B₁✝ * expR (c₁✝ * Abs.abs (u z)))‖ ≤ ‖expR (B₂✝ * expR (c₂✝ * Abs.abs (u z)))‖

tactic: exact
  mul_le_mul hB (Real.exp_le_exp.2 <| mul_le_mul_of_nonneg_right hc <| abs_nonneg _)
    (Real.exp_pos _).le hB₀
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
f g : ℂ → E
l : Filter ℂ
u : ℂ → ℝ
hBf : ∃ c, c < a ∧ ∃ B, f =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
hBg : ∃ c, c < a ∧ ∃ B, g =O[l] fun z => expR (B * expR (c * Abs.abs (u z)))
c₁✝ c₂✝ B₁✝ B₂✝ : ℝ
hc : c₁✝ ≤ c₂✝
hB₀ : 0 ≤ B₂✝
hB : B₁✝ ≤ B₂✝
z : ℂ
⊢ B₁✝ * expR (c₁✝ * Abs.abs (u z)) ≤ B₂✝ * expR (c₂✝ * Abs.abs (u z))