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

tactic: suffices EqOn (f - g) 0 {z : ℂ | 0 ≤ z.re} by
  simpa only [EqOn, Pi.sub_apply, Pi.zero_apply, sub_eq_zero] using this
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
⊢ EqOn f g {z | 0 ≤ z.re}

tactic: refine' eq_zero_on_right_half_plane_of_superexponential_decay (hfd.sub hgd) _ hre _
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
⊢ EqOn (f - g) 0 {z | 0 ≤ z.re}

tactic: simpa only [EqOn, Pi.sub_apply, Pi.zero_apply, sub_eq_zero] using this
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
this : EqOn (f - g) 0 {z | 0 ≤ z.re}
⊢ EqOn f g {z | 0 ≤ z.re}

tactic: set l : Filter ℂ := comap Complex.abs atTop ⊓ 𝓟 {z : ℂ | 0 < z.re}
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
⊢ ∃ c, c < 2 ∧ ∃ B, (f - g) =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)

tactic: suffices ∀ {c₁ c₂ B₁ B₂ : ℝ}, c₁ ≤ c₂ → B₁ ≤ B₂ → 0 ≤ B₂ →
    (fun z => expR (B₁ * abs z ^ c₁)) =O[l] fun z => expR (B₂ * abs z ^ c₂) by
  rcases hfexp with ⟨cf, hcf, Bf, hOf⟩; rcases hgexp with ⟨cg, hcg, Bg, hOg⟩
  refine' ⟨max cf cg, max_lt hcf hcg, max 0 (max Bf Bg), _⟩
  refine' .sub (hOf.trans <| this _ _ _) (hOg.trans <| this _ _ _) <;> simp
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
⊢ ∃ c, c < 2 ∧ ∃ B, (f - g) =O[l] fun z => expR (B * ↑Complex.abs z ^ c)

tactic: intro c₁ c₂ B₁ B₂ hc hB hB₂
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
⊢ ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      B₁ ≤ B₂ → 0 ≤ B₂ → (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)

tactic: have : ∀ᶠ z : ℂ in l, 1 ≤ abs z := ((eventually_ge_atTop 1).comap _).filter_mono inf_le_left
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
c₁ c₂ B₁ B₂ : ℝ
hc : c₁ ≤ c₂
hB : B₁ ≤ B₂
hB₂ : 0 ≤ B₂
⊢ (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)

tactic: refine' .of_bound 1 (this.mono fun z hz => _)
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
c₁ c₂ B₁ B₂ : ℝ
hc : c₁ ≤ c₂
hB : B₁ ≤ B₂
hB₂ : 0 ≤ B₂
this : ∀ᶠ (z : ℂ) in l, 1 ≤ ↑Complex.abs z
⊢ (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)

tactic: simp only [Real.norm_of_nonneg (Real.exp_pos _).le, Real.exp_le_exp, one_mul]
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z✝ : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
c₁ c₂ B₁ B₂ : ℝ
hc : c₁ ≤ c₂
hB : B₁ ≤ B₂
hB₂ : 0 ≤ B₂
this : ∀ᶠ (z : ℂ) in l, 1 ≤ ↑Complex.abs z
z : ℂ
hz : 1 ≤ ↑Complex.abs z
⊢ ‖expR (B₁ * ↑Complex.abs z ^ c₁)‖ ≤ 1 * ‖expR (B₂ * ↑Complex.abs z ^ c₂)‖

tactic: have := Real.rpow_le_rpow_of_exponent_le hz hc
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z✝ : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
c₁ c₂ B₁ B₂ : ℝ
hc : c₁ ≤ c₂
hB : B₁ ≤ B₂
hB₂ : 0 ≤ B₂
this : ∀ᶠ (z : ℂ) in l, 1 ≤ ↑Complex.abs z
z : ℂ
hz : 1 ≤ ↑Complex.abs z
⊢ B₁ * ↑Complex.abs z ^ c₁ ≤ B₂ * ↑Complex.abs z ^ c₂

tactic: gcongr
state_before: case refine'_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z✝ : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
c₁ c₂ B₁ B₂ : ℝ
hc : c₁ ≤ c₂
hB : B₁ ≤ B₂
hB₂ : 0 ≤ B₂
this✝ : ∀ᶠ (z : ℂ) in l, 1 ≤ ↑Complex.abs z
z : ℂ
hz : 1 ≤ ↑Complex.abs z
this : ↑Complex.abs z ^ c₁ ≤ ↑Complex.abs z ^ c₂
⊢ B₁ * ↑Complex.abs z ^ c₁ ≤ B₂ * ↑Complex.abs z ^ c₂

tactic: rcases hfexp with ⟨cf, hcf, Bf, hOf⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      B₁ ≤ B₂ → 0 ≤ B₂ → (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)
⊢ ∃ c, c < 2 ∧ ∃ B, (f - g) =O[l] fun z => expR (B * ↑Complex.abs z ^ c)

tactic: rcases hgexp with ⟨cg, hcg, Bg, hOg⟩
state_before: case intro.intro.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[l] fun z => expR (B * ↑Complex.abs z ^ c)
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      B₁ ≤ B₂ → 0 ≤ B₂ → (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)
cf : ℝ
hcf : cf < 2
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * ↑Complex.abs z ^ cf)
⊢ ∃ c, c < 2 ∧ ∃ B, (f - g) =O[l] fun z => expR (B * ↑Complex.abs z ^ c)

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
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      B₁ ≤ B₂ → 0 ≤ B₂ → (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)
cf : ℝ
hcf : cf < 2
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * ↑Complex.abs z ^ cf)
cg : ℝ
hcg : cg < 2
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * ↑Complex.abs z ^ cg)
⊢ ∃ c, c < 2 ∧ ∃ B, (f - g) =O[l] fun z => expR (B * ↑Complex.abs z ^ c)

tactic: refine' .sub (hOf.trans <| this _ _ _) (hOg.trans <| this _ _ _) <;> simp
state_before: case intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
l : Filter ℂ := comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}
this :
  ∀ {c₁ c₂ B₁ B₂ : ℝ},
    c₁ ≤ c₂ →
      B₁ ≤ B₂ → 0 ≤ B₂ → (fun z => expR (B₁ * ↑Complex.abs z ^ c₁)) =O[l] fun z => expR (B₂ * ↑Complex.abs z ^ c₂)
cf : ℝ
hcf : cf < 2
Bf : ℝ
hOf : f =O[l] fun z => expR (Bf * ↑Complex.abs z ^ cf)
cg : ℝ
hcg : cg < 2
Bg : ℝ
hOg : g =O[l] fun z => expR (Bg * ↑Complex.abs z ^ cg)
⊢ (f - g) =O[l] fun z => expR (max 0 (max Bf Bg) * ↑Complex.abs z ^ max cf cg)

tactic: rcases hfim with ⟨Cf, hCf⟩
state_before: case refine'_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ C
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
⊢ ∃ C, ∀ (x : ℝ), ‖(f - g) (↑x * I)‖ ≤ C

tactic: rcases hgim with ⟨Cg, hCg⟩
state_before: case refine'_2.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ C
Cf : ℝ
hCf : ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ Cf
⊢ ∃ C, ∀ (x : ℝ), ‖(f - g) (↑x * I)‖ ≤ C

tactic: exact ⟨Cf + Cg, fun x => norm_sub_le_of_le (hCf x) (hCg x)⟩
state_before: case refine'_2.intro.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
a b C : ℝ
f g✝ : ℂ → E
z : ℂ
g : ℂ → E
hfd : DiffContOnCl ℂ f {z | 0 < z.re}
hgd : DiffContOnCl ℂ g {z | 0 < z.re}
hfexp : ∃ c, c < 2 ∧ ∃ B, f =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hgexp : ∃ c, c < 2 ∧ ∃ B, g =O[comap (↑Complex.abs) atTop ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * ↑Complex.abs z ^ c)
hre : SuperpolynomialDecay atTop expR fun x => ‖f ↑x - g ↑x‖
Cf : ℝ
hCf : ∀ (x : ℝ), ‖f (↑x * I)‖ ≤ Cf
Cg : ℝ
hCg : ∀ (x : ℝ), ‖g (↑x * I)‖ ≤ Cg
⊢ ∃ C, ∀ (x : ℝ), ‖(f - g) (↑x * I)‖ ≤ C