l3lab/ntp-mathlib huggingface dataset:
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; 

Proof state:
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
t : ℝ
ht : t ∈ Ioi 0
⊢ (zetaKernel₂ ∘ Div.div 1) t = ↑(sqrt t) * zetaKernel₂ t

Next tactic:
rw [← zetaKernel₂_one_div (le_of_lt ht)]
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; 

Proof state:
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
t : ℝ
ht : t ∈ Ioi 0
⊢ (zetaKernel₂ ∘ Div.div 1) t = zetaKernel₂ (1 / t)

Next tactic:
rfl
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  

Proof state:
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
⊢ zetaKernel₂ =O[𝓝[>] 0] fun t => rexp (-π / t) / sqrt t

Next tactic:
have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  

Proof state:
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
⊢ zetaKernel₂ =O[𝓝[>] 0] fun t => rexp (-π / t) / sqrt t

Next tactic:
have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  

Proof state:
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
⊢ zetaKernel₂ =O[𝓝[>] 0] fun t => rexp (-π / t) / sqrt t

Next tactic:
refine h4.congr' ?_ ?_
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · 

Proof state:
case refine_1
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
⊢ (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =ᶠ[𝓝[>] 0] zetaKernel₂

Next tactic:
refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    

Proof state:
case refine_1
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
x : ℝ
hx : x ∈ Ioi 0
⊢ (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) x = zetaKernel₂ x

Next tactic:
dsimp
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    dsimp
    

Proof state:
case refine_1
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
x : ℝ
hx : x ∈ Ioi 0
⊢ ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x)) = zetaKernel₂ x

Next tactic:
rw [mul_comm, ← mul_assoc, one_div_mul_cancel, one_mul]
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    dsimp
    rw [mul_comm, ← mul_assoc, one_div_mul_cancel, one_mul]
    

Proof state:
case refine_1
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
x : ℝ
hx : x ∈ Ioi 0
⊢ ↑(sqrt x) ≠ 0

Next tactic:
exact ofReal_ne_zero.mpr ((sqrt_ne_zero <| le_of_lt hx).mpr (ne_of_gt hx))
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    dsimp
    rw [mul_comm, ← mul_assoc, one_div_mul_cancel, one_mul]
    exact ofReal_ne_zero.mpr ((sqrt_ne_zero <| le_of_lt hx).mpr (ne_of_gt hx))
  · 

Proof state:
case refine_2
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
⊢ (fun x => ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖) =ᶠ[𝓝[>] 0] fun t => rexp (-π / t) / sqrt t

Next tactic:
refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    dsimp
    rw [mul_comm, ← mul_assoc, one_div_mul_cancel, one_mul]
    exact ofReal_ne_zero.mpr ((sqrt_ne_zero <| le_of_lt hx).mpr (ne_of_gt hx))
  · refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
    

Proof state:
case refine_2
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
x : ℝ
x✝ : x ∈ Ioi 0
⊢ (fun x => ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖) x = (fun t => rexp (-π / t) / sqrt t) x

Next tactic:
dsimp only
/-- Precise but awkward-to-use bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂ : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => exp (-π / t) / sqrt t := by
  have h1 := isBigO_atTop_zetaKernel₂.comp_tendsto tendsto_inv_zero_atTop
  simp_rw [← one_div] at h1
  have h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => sqrt t * zetaKernel₂ t :=
    eventually_of_mem self_mem_nhdsWithin fun t ht => by
      dsimp only; rw [← zetaKernel₂_one_div (le_of_lt ht)]; rfl
  have h3 := h1.congr' h2 (EventuallyEq.refl _ _)
  have h4 := h3.mul (isBigO_refl (fun t : ℝ => 1 / (sqrt t : ℂ)) (𝓝[>] 0)).norm_right
  refine h4.congr' ?_ ?_
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    dsimp
    rw [mul_comm, ← mul_assoc, one_div_mul_cancel, one_mul]
    exact ofReal_ne_zero.mpr ((sqrt_ne_zero <| le_of_lt hx).mpr (ne_of_gt hx))
  · refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
    dsimp only
    

Proof state:
case refine_2
h1 : (zetaKernel₂ ∘ fun x => 1 / x) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h2 : zetaKernel₂ ∘ Div.div 1 =ᶠ[𝓝[>] 0] fun t => ↑(sqrt t) * zetaKernel₂ t
h3 : (fun t => ↑(sqrt t) * zetaKernel₂ t) =O[𝓝[>] 0] ((fun t => rexp (-π * t)) ∘ fun x => 1 / x)
h4 :
  (fun x => ↑(sqrt x) * zetaKernel₂ x * (1 / ↑(sqrt x))) =O[𝓝[>] 0] fun x =>
    ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖
x : ℝ
x✝ : x ∈ Ioi 0
⊢ ((fun t => rexp (-π * t)) ∘ fun x => 1 / x) x * ‖1 / ↑(sqrt x)‖ = rexp (-π / x) / sqrt x

Next tactic:
rw [Function.comp_apply, mul_one_div, one_div (sqrt x : ℂ), norm_inv, Complex.norm_eq_abs,
      abs_ofReal, abs_of_nonneg (sqrt_nonneg _), ← div_eq_mul_inv]
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  

Proof state:
a : ℝ
⊢ zetaKernel₂ =O[𝓝[>] 0] fun t => t ^ a

Next tactic:
have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  

Proof state:
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
⊢ zetaKernel₂ =O[𝓝[>] 0] fun t => t ^ a

Next tactic:
have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    

Proof state:
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
⊢ (fun t => rexp (-π * t) * sqrt t) =O[atTop] fun t => t ^ (-a)

Next tactic:
refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    

Proof state:
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
⊢ (fun x => x ^ (-a - 1 / 2) * sqrt x) =ᶠ[atTop] fun t => t ^ (-a)

Next tactic:
refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    

Proof state:
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
t : ℝ
ht : 0 < t
⊢ (fun x => x ^ (-a - 1 / 2) * sqrt x) t = (fun t => t ^ (-a)) t

Next tactic:
simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
  

Proof state:
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
aux2 : (fun t => rexp (-π * t) * sqrt t) =O[atTop] fun t => t ^ (-a)
⊢ zetaKernel₂ =O[𝓝[>] 0] fun t => t ^ a

Next tactic:
refine isBigO_zero_zetaKernel₂.trans ((aux2.comp_tendsto tendsto_inv_zero_atTop).congr' ?_ ?_)
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
  refine isBigO_zero_zetaKernel₂.trans ((aux2.comp_tendsto tendsto_inv_zero_atTop).congr' ?_ ?_)
  · 

Proof state:
case refine_1
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
aux2 : (fun t => rexp (-π * t) * sqrt t) =O[atTop] fun t => t ^ (-a)
⊢ ((fun t => rexp (-π * t) * sqrt t) ∘ fun x => x⁻¹) =ᶠ[𝓝[>] 0] fun t => rexp (-π / t) / sqrt t

Next tactic:
refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
  refine isBigO_zero_zetaKernel₂.trans ((aux2.comp_tendsto tendsto_inv_zero_atTop).congr' ?_ ?_)
  · refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
    

Proof state:
case refine_1
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
aux2 : (fun t => rexp (-π * t) * sqrt t) =O[atTop] fun t => t ^ (-a)
x : ℝ
x✝ : x ∈ Ioi 0
⊢ ((fun t => rexp (-π * t) * sqrt t) ∘ fun x => x⁻¹) x = (fun t => rexp (-π / t) / sqrt t) x

Next tactic:
simp_rw [Function.comp_apply, sqrt_inv, ← div_eq_mul_inv]
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
  refine isBigO_zero_zetaKernel₂.trans ((aux2.comp_tendsto tendsto_inv_zero_atTop).congr' ?_ ?_)
  · refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
    simp_rw [Function.comp_apply, sqrt_inv, ← div_eq_mul_inv]
  · 

Proof state:
case refine_2
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
aux2 : (fun t => rexp (-π * t) * sqrt t) =O[atTop] fun t => t ^ (-a)
⊢ ((fun t => t ^ (-a)) ∘ fun x => x⁻¹) =ᶠ[𝓝[>] 0] fun t => t ^ a

Next tactic:
refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
/-- Weaker but more usable bound for `zetaKernel₂` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₂_rpow (a : ℝ) : IsBigO (𝓝[>] 0) zetaKernel₂ fun t => t ^ a := by
  have aux1 : IsBigO atTop (fun t => exp (-π * t)) fun t => t ^ (-a - 1 / 2) :=
    (isLittleO_exp_neg_mul_rpow_atTop pi_pos _).isBigO
  have aux2 : IsBigO atTop (fun t => exp (-π * t) * sqrt t) fun t => t ^ (-a) := by
    refine (aux1.mul (isBigO_refl sqrt _)).congr' (EventuallyEq.refl _ _) ?_
    refine (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht => ?_)
    simp_rw [sqrt_eq_rpow, ← rpow_add ht, sub_add_cancel]
  refine isBigO_zero_zetaKernel₂.trans ((aux2.comp_tendsto tendsto_inv_zero_atTop).congr' ?_ ?_)
  · refine eventually_of_mem self_mem_nhdsWithin fun x _ => ?_
    simp_rw [Function.comp_apply, sqrt_inv, ← div_eq_mul_inv]
  · refine eventually_of_mem self_mem_nhdsWithin fun x hx => ?_
    

Proof state:
case refine_2
a : ℝ
aux1 : (fun t => rexp (-π * t)) =O[atTop] fun t => t ^ (-a - 1 / 2)
aux2 : (fun t => rexp (-π * t) * sqrt t) =O[atTop] fun t => t ^ (-a)
x : ℝ
hx : x ∈ Ioi 0
⊢ ((fun t => t ^ (-a)) ∘ fun x => x⁻¹) x = (fun t => t ^ a) x

Next tactic:
simp_rw [Function.comp_apply, inv_rpow (le_of_lt hx), rpow_neg (le_of_lt hx), inv_inv]
/-- Bound for `zetaKernel₁` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₁ : IsBigO (𝓝[>] 0) zetaKernel₁ fun t => t ^ (-(1 / 2) : ℝ) := by
  

Proof state:
⊢ zetaKernel₁ =O[𝓝[>] 0] fun t => t ^ (-(1 / 2))

Next tactic:
have : zetaKernel₁ =ᶠ[𝓝[>] 0] zetaKernel₂ + fun t => ((1 / sqrt t - 1) / 2 : ℂ) := by
    refine
      eventuallyEq_of_mem (Ioc_mem_nhdsWithin_Ioi <| left_mem_Ico.mpr zero_lt_one) fun t h => ?_
    rw [Pi.add_apply, zetaKernel₂, Pi.add_apply, indicator_of_mem h]
    ring
/-- Bound for `zetaKernel₁` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₁ : IsBigO (𝓝[>] 0) zetaKernel₁ fun t => t ^ (-(1 / 2) : ℝ) := by
  have : zetaKernel₁ =ᶠ[𝓝[>] 0] zetaKernel₂ + fun t => ((1 / sqrt t - 1) / 2 : ℂ) := by
    

Proof state:
⊢ zetaKernel₁ =ᶠ[𝓝[>] 0] zetaKernel₂ + fun t => (1 / ↑(sqrt t) - 1) / 2

Next tactic:
refine
      eventuallyEq_of_mem (Ioc_mem_nhdsWithin_Ioi <| left_mem_Ico.mpr zero_lt_one) fun t h => ?_
/-- Bound for `zetaKernel₁` for `t → 0`. -/
theorem isBigO_zero_zetaKernel₁ : IsBigO (𝓝[>] 0) zetaKernel₁ fun t => t ^ (-(1 / 2) : ℝ) := by
  have : zetaKernel₁ =ᶠ[𝓝[>] 0] zetaKernel₂ + fun t => ((1 / sqrt t - 1) / 2 : ℂ) := by
    refine
      eventuallyEq_of_mem (Ioc_mem_nhdsWithin_Ioi <| left_mem_Ico.mpr zero_lt_one) fun t h => ?_
    

Proof state:
t : ℝ
h : t ∈ Ioc 0 1
⊢ zetaKernel₁ t = (zetaKernel₂ + fun t => (1 / ↑(sqrt t) - 1) / 2) t

Next tactic:
rw [Pi.add_apply, zetaKernel₂, Pi.add_apply, indicator_of_mem h]