Theorem: HurwitzZeta.hasSum_int_completedHurwitzZetaOdd
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
tactic: let r (n : ℤ) : ℝ := n + a
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
tactic: let c (n : ℤ) : ℂ := 1 / 2
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
tactic: have hF t (ht : 0 < t) : HasSum (fun n ↦ c n * r n * rexp (-π * (r n) ^ 2 * t))
      (oddKernel a t / 2) := by
    refine ((hasSum_ofReal.mpr (hasSum_int_oddKernel a ht)).div_const 2).congr_fun fun n ↦ ?_
    simp only [r, c, push_cast, div_mul_eq_mul_div, one_mul]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
h_sum : Summable fun i => ‖c i‖ / |r i| ^ s.re
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
tactic: have h_sum : Summable fun i ↦ ‖c i‖ / |r i| ^ s.re := by
    simp_rw [c, ← mul_one_div ‖_‖]
    apply Summable.mul_left
    rwa [summable_one_div_int_add_rpow]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
h_sum : Summable fun i => ‖c i‖ / |r i| ^ s.re
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
h_sum : Summable fun i => ‖c i‖ / |r i| ^ s.re
this :
  HasSum (fun i => (s + 1).Gammaℝ * c i * ↑(SignType.sign (r i)) / ↑|r i| ^ s)
    (mellin (fun t => ↑(oddKernel (↑a) t)) ((s + 1) / 2) / 2)
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
tactic: have := mellin_div_const .. ▸ hasSum_mellin_pi_mul_sq' (zero_lt_one.trans hs) hF h_sum
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
h_sum : Summable fun i => ‖c i‖ / |r i| ^ s.re
this :
  HasSum (fun i => (s + 1).Gammaℝ * c i * ↑(SignType.sign (r i)) / ↑|r i| ^ s)
    (mellin (fun t => ↑(oddKernel (↑a) t)) ((s + 1) / 2) / 2)
⊢ HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (completedHurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
h_sum : Summable fun i => ‖c i‖ / |r i| ^ s.re
this :
  HasSum (fun i => (s + 1).Gammaℝ * c i * ↑(SignType.sign (r i)) / ↑|r i| ^ s)
    (mellin (fun t => ↑(oddKernel (↑a) t)) ((s + 1) / 2) / 2)
n : ℤ
⊢ (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 =
    (s + 1).Gammaℝ * c n * ↑(SignType.sign (r n)) / ↑|r n| ^ s
tactic: refine this.congr_fun fun n ↦ ?_
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
hF : ∀ (t : ℝ), 0 < t → HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
h_sum : Summable fun i => ‖c i‖ / |r i| ^ s.re
this :
  HasSum (fun i => (s + 1).Gammaℝ * c i * ↑(SignType.sign (r i)) / ↑|r i| ^ s)
    (mellin (fun t => ↑(oddKernel (↑a) t)) ((s + 1) / 2) / 2)
n : ℤ
⊢ (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 =
    (s + 1).Gammaℝ * c n * ↑(SignType.sign (r n)) / ↑|r n| ^ s
state_after: no goals
tactic: simp only [c, mul_one_div, div_mul_eq_mul_div, div_right_comm]