l3lab/ntp-mathlib huggingface dataset:
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    

Proof state:
case h.e'_2.e_f.h
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ cexp (↑(-2 * π * x * t) * I) * cexp (-↑π * b * ↑x ^ 2) = cexp (I * (-2 * ↑π * ↑t) * ↑x) * cexp (-(↑π * b) * ↑x ^ 2)

Next tactic:
congr 2
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    

Proof state:
case h.e'_2.e_f.h.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ ↑(-2 * π * x * t) * I = I * (-2 * ↑π * ↑t) * ↑x
case h.e'_2.e_f.h.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ -↑π * b * ↑x ^ 2 = -(↑π * b) * ↑x ^ 2

Next tactic:
any_goals push_cast; ring
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals 

Proof state:
case h.e'_2.e_f.h.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ ↑(-2 * π * x * t) * I = I * (-2 * ↑π * ↑t) * ↑x

Next tactic:
push_cast
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; 

Proof state:
case h.e'_2.e_f.h.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ -2 * ↑π * ↑x * ↑t * I = I * (-2 * ↑π * ↑t) * ↑x

Next tactic:
ring
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals 

Proof state:
case h.e'_2.e_f.h.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ -↑π * b * ↑x ^ 2 = -(↑π * b) * ↑x ^ 2

Next tactic:
push_cast
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; 

Proof state:
case h.e'_2.e_f.h.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
x : ℝ
⊢ -↑π * b * ↑x ^ 2 = -(↑π * b) * ↑x ^ 2

Next tactic:
ring
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · 

Proof state:
case h.e'_3
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ 1 / b ^ (1 / 2) * cexp (-↑π / b * ↑t ^ 2) = cexp (-(-2 * ↑π * ↑t) ^ 2 / (4 * (↑π * b))) * (↑π / (↑π * b)) ^ (1 / 2)

Next tactic:
conv_lhs => rw [mul_comm]
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => 

Proof state:
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
| 1 / b ^ (1 / 2) * cexp (-↑π / b * ↑t ^ 2)

Next tactic:
rw [mul_comm]
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => rw [mul_comm]
    

Proof state:
case h.e'_3
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ cexp (-↑π / b * ↑t ^ 2) * (1 / b ^ (1 / 2)) = cexp (-(-2 * ↑π * ↑t) ^ 2 / (4 * (↑π * b))) * (↑π / (↑π * b)) ^ (1 / 2)

Next tactic:
congr 2
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => rw [mul_comm]
    congr 2
    · 

Proof state:
case h.e'_3.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ -↑π / b * ↑t ^ 2 = -(-2 * ↑π * ↑t) ^ 2 / (4 * (↑π * b))

Next tactic:
field_simp [ofReal_ne_zero.mpr pi_ne_zero]
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => rw [mul_comm]
    congr 2
    · field_simp [ofReal_ne_zero.mpr pi_ne_zero]; 

Proof state:
case h.e'_3.e_a.e_z
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ ↑π * ↑t ^ 2 * (4 * (↑π * b)) = (2 * ↑π * ↑t) ^ 2 * b

Next tactic:
ring
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => rw [mul_comm]
    congr 2
    · field_simp [ofReal_ne_zero.mpr pi_ne_zero]; ring
    · 

Proof state:
case h.e'_3.e_a
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ 1 / b ^ (1 / 2) = (↑π / (↑π * b)) ^ (1 / 2)

Next tactic:
rw [← div_div, div_self (ofReal_ne_zero.mpr pi_ne_zero), one_div, one_div b, inv_cpow]
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => rw [mul_comm]
    congr 2
    · field_simp [ofReal_ne_zero.mpr pi_ne_zero]; ring
    · rw [← div_div, div_self (ofReal_ne_zero.mpr pi_ne_zero), one_div, one_div b, inv_cpow]
      

Proof state:
case h.e'_3.e_a.hx
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ arg b ≠ π

Next tactic:
rw [Ne.def, arg_eq_pi_iff, not_and_or, not_lt]
theorem _root_.fourier_transform_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun x : ℝ => cexp (-π * b * (x : ℂ) ^ 2)) = fun t : ℝ =>
      (1 : ℂ) / b ^ (1 / 2 : ℂ) * cexp (-π / b * (t : ℂ) ^ 2) := by
  ext1 t
  simp_rw [fourierIntegral_eq_integral_exp_smul, smul_eq_mul]
  have h1 : 0 < re (π * b) := by rw [ofReal_mul_re]; exact mul_pos pi_pos hb
  have h2 : b ≠ 0 := by contrapose! hb; rw [hb, zero_re]
  convert _root_.fourier_transform_gaussian h1 (-2 * π * t) using 1
  · congr 1 with x : 1
    congr 2
    any_goals push_cast; ring
  · conv_lhs => rw [mul_comm]
    congr 2
    · field_simp [ofReal_ne_zero.mpr pi_ne_zero]; ring
    · rw [← div_div, div_self (ofReal_ne_zero.mpr pi_ne_zero), one_div, one_div b, inv_cpow]
      rw [Ne.def, arg_eq_pi_iff, not_and_or, not_lt]
      

Proof state:
case h.e'_3.e_a.hx
b : ℂ
hb : 0 < b.re
t : ℝ
h1 : 0 < (↑π * b).re
h2 : b ≠ 0
⊢ 0 ≤ b.re ∨ ¬b.im = 0

Next tactic:
exact Or.inl hb.le
theorem tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact {a : ℝ} (ha : 0 < a) (s : ℝ) :
    Tendsto (fun x : ℝ => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0) := by
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun x => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0)

Next tactic:
conv in rexp _ => rw [← sq_abs]
theorem tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact {a : ℝ} (ha : 0 < a) (s : ℝ) :
    Tendsto (fun x : ℝ => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0) := by
  conv in rexp _ => 

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s x : ℝ
| rexp (-a * x ^ 2)

Next tactic:
rw [← sq_abs]
theorem tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact {a : ℝ} (ha : 0 < a) (s : ℝ) :
    Tendsto (fun x : ℝ => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0) := by
  conv in rexp _ => rw [← sq_abs]
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun x => |x| ^ s * rexp (-a * |x| ^ 2)) (cocompact ℝ) (𝓝 0)

Next tactic:
erw [cocompact_eq, ← comap_abs_atTop,
    @tendsto_comap'_iff _ _ _ (fun y => y ^ s * rexp (-a * y ^ 2)) _ _ _
      (mem_atTop_sets.mpr ⟨0, fun b hb => ⟨b, abs_of_nonneg hb⟩⟩)]
theorem tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact {a : ℝ} (ha : 0 < a) (s : ℝ) :
    Tendsto (fun x : ℝ => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0) := by
  conv in rexp _ => rw [← sq_abs]
  erw [cocompact_eq, ← comap_abs_atTop,
    @tendsto_comap'_iff _ _ _ (fun y => y ^ s * rexp (-a * y ^ 2)) _ _ _
      (mem_atTop_sets.mpr ⟨0, fun b hb => ⟨b, abs_of_nonneg hb⟩⟩)]
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun y => y ^ s * rexp (-a * y ^ 2)) atTop (𝓝 0)

Next tactic:
exact
    (rpow_mul_exp_neg_mul_sq_isLittleO_exp_neg ha s).tendsto_zero_of_tendsto
      (tendsto_exp_atBot.comp <| tendsto_id.neg_const_mul_atTop (neg_lt_zero.mpr one_half_pos))
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ (fun x => cexp (-a * ↑x ^ 2)) =o[cocompact ℝ] fun x => |x| ^ s

Next tactic:
rw [← isLittleO_norm_left]
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ (fun x => ‖cexp (-a * ↑x ^ 2)‖) =o[cocompact ℝ] fun x => |x| ^ s

Next tactic:
simp_rw [norm_cexp_neg_mul_sq]
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ (fun x => rexp (-a.re * x ^ 2)) =o[cocompact ℝ] fun x => |x| ^ s

Next tactic:
apply isLittleO_of_tendsto'
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · 

Proof state:
case hgf
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ ∀ᶠ (x : ℝ) in cocompact ℝ, |x| ^ s = 0 → rexp (-a.re * x ^ 2) = 0

Next tactic:
refine' Eventually.filter_mono cocompact_le_cofinite _
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · refine' Eventually.filter_mono cocompact_le_cofinite _
    

Proof state:
case hgf
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ ∀ᶠ (x : ℝ) in cofinite, |x| ^ s = 0 → rexp (-a.re * x ^ 2) = 0

Next tactic:
refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x hx h => _)
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · refine' Eventually.filter_mono cocompact_le_cofinite _
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x hx h => _)
    

Proof state:
case hgf
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s x : ℝ
hx : x ≠ 0
h : |x| ^ s = 0
⊢ rexp (-a.re * x ^ 2) = 0

Next tactic:
exact ((rpow_pos_of_pos (abs_pos.mpr hx) _).ne' h).elim
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · refine' Eventually.filter_mono cocompact_le_cofinite _
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x hx h => _)
    exact ((rpow_pos_of_pos (abs_pos.mpr hx) _).ne' h).elim
  · 

Proof state:
case a
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ Tendsto (fun x => rexp (-a.re * x ^ 2) / |x| ^ s) (cocompact ℝ) (𝓝 0)

Next tactic:
refine'
      Tendsto.congr' (Eventually.filter_mono cocompact_le_cofinite _)
        (tendsto_zero_iff_norm_tendsto_zero.mp <|
          tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact ha (-s))
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · refine' Eventually.filter_mono cocompact_le_cofinite _
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x hx h => _)
    exact ((rpow_pos_of_pos (abs_pos.mpr hx) _).ne' h).elim
  · refine'
      Tendsto.congr' (Eventually.filter_mono cocompact_le_cofinite _)
        (tendsto_zero_iff_norm_tendsto_zero.mp <|
          tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact ha (-s))
    

Proof state:
case a
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s : ℝ
⊢ ∀ᶠ (x : ℝ) in cofinite, ‖|x| ^ (-s) * rexp (-a.re * x ^ 2)‖ = (fun x => rexp (-a.re * x ^ 2) / |x| ^ s) x

Next tactic:
refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x _ => _)
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · refine' Eventually.filter_mono cocompact_le_cofinite _
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x hx h => _)
    exact ((rpow_pos_of_pos (abs_pos.mpr hx) _).ne' h).elim
  · refine'
      Tendsto.congr' (Eventually.filter_mono cocompact_le_cofinite _)
        (tendsto_zero_iff_norm_tendsto_zero.mp <|
          tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact ha (-s))
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x _ => _)
    

Proof state:
case a
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s x : ℝ
x✝ : x ≠ 0
⊢ ‖|x| ^ (-s) * rexp (-a.re * x ^ 2)‖ = (fun x => rexp (-a.re * x ^ 2) / |x| ^ s) x

Next tactic:
dsimp only
theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * (x : ℂ) ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s := by
  rw [← isLittleO_norm_left]
  simp_rw [norm_cexp_neg_mul_sq]
  apply isLittleO_of_tendsto'
  · refine' Eventually.filter_mono cocompact_le_cofinite _
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x hx h => _)
    exact ((rpow_pos_of_pos (abs_pos.mpr hx) _).ne' h).elim
  · refine'
      Tendsto.congr' (Eventually.filter_mono cocompact_le_cofinite _)
        (tendsto_zero_iff_norm_tendsto_zero.mp <|
          tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact ha (-s))
    refine' (eventually_cofinite_ne 0).mp (eventually_of_forall fun x _ => _)
    dsimp only
    

Proof state:
case a
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
s x : ℝ
x✝ : x ≠ 0
⊢ ‖|x| ^ (-s) * rexp (-a.re * x ^ 2)‖ = rexp (-a.re * x ^ 2) / |x| ^ s

Next tactic:
rw [norm_mul, norm_of_nonneg (rpow_nonneg_of_nonneg (abs_nonneg _) _), mul_comm,
      rpow_neg (abs_nonneg x), div_eq_mul_inv, norm_of_nonneg (exp_pos _).le]
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
⊢ ∑' (n : ℤ), cexp (-↑π * a * ↑n ^ 2) = 1 / a ^ (1 / 2) * ∑' (n : ℤ), cexp (-↑π / a * ↑n ^ 2)

Next tactic:
let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
⊢ ∑' (n : ℤ), cexp (-↑π * a * ↑n ^ 2) = 1 / a ^ (1 / 2) * ∑' (n : ℤ), cexp (-↑π / a * ↑n ^ 2)

Next tactic:
have h1 : 0 < (↑π * a).re := by
    rw [ofReal_mul_re]
    exact mul_pos pi_pos ha
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  have h1 : 0 < (↑π * a).re := by
    

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
⊢ 0 < (↑π * a).re

Next tactic:
rw [ofReal_mul_re]
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  have h1 : 0 < (↑π * a).re := by
    rw [ofReal_mul_re]
    

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
⊢ 0 < π * a.re

Next tactic:
exact mul_pos pi_pos ha
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  have h1 : 0 < (↑π * a).re := by
    rw [ofReal_mul_re]
    exact mul_pos pi_pos ha
  

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
h1 : 0 < (↑π * a).re
⊢ ∑' (n : ℤ), cexp (-↑π * a * ↑n ^ 2) = 1 / a ^ (1 / 2) * ∑' (n : ℤ), cexp (-↑π / a * ↑n ^ 2)

Next tactic:
have h2 : 0 < (↑π / a).re := by
    rw [div_eq_mul_inv, ofReal_mul_re, inv_re]
    refine' mul_pos pi_pos (div_pos ha <| normSq_pos.mpr _)
    contrapose! ha
    rw [ha, zero_re]
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  have h1 : 0 < (↑π * a).re := by
    rw [ofReal_mul_re]
    exact mul_pos pi_pos ha
  have h2 : 0 < (↑π / a).re := by
    

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
h1 : 0 < (↑π * a).re
⊢ 0 < (↑π / a).re

Next tactic:
rw [div_eq_mul_inv, ofReal_mul_re, inv_re]
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  have h1 : 0 < (↑π * a).re := by
    rw [ofReal_mul_re]
    exact mul_pos pi_pos ha
  have h2 : 0 < (↑π / a).re := by
    rw [div_eq_mul_inv, ofReal_mul_re, inv_re]
    

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
h1 : 0 < (↑π * a).re
⊢ 0 < π * (a.re / normSq a)

Next tactic:
refine' mul_pos pi_pos (div_pos ha <| normSq_pos.mpr _)
theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      (1 : ℂ) / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) := by
  let f := fun x : ℝ => cexp (-π * a * (x : ℂ) ^ 2)
  have h1 : 0 < (↑π * a).re := by
    rw [ofReal_mul_re]
    exact mul_pos pi_pos ha
  have h2 : 0 < (↑π / a).re := by
    rw [div_eq_mul_inv, ofReal_mul_re, inv_re]
    refine' mul_pos pi_pos (div_pos ha <| normSq_pos.mpr _)
    

Proof state:
E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℂ
ha : 0 < a.re
f : ℝ → ℂ := fun x => cexp (-↑π * a * ↑x ^ 2)
h1 : 0 < (↑π * a).re
⊢ a ≠ 0

Next tactic:
contrapose! ha