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

tactic: let r (n : ℤ) : ℝ := n + a
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 c (n : ℤ) : ℂ := 1 / 2
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: 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
⊢ 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 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)
⊢ 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 := 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
⊢ 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: 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)
⊢ 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: simp only [c, mul_one_div, div_mul_eq_mul_div, div_right_comm]
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: refine ((hasSum_ofReal.mpr (hasSum_int_oddKernel a ht)).div_const 2).congr_fun fun n ↦ ?_
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
t : ℝ
ht : 0 < t
⊢ HasSum (fun n => c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t))) (↑(oddKernel (↑a) t) / 2)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
r : ℤ → ℝ := fun n => ↑n + a
c : ℤ → ℂ := fun n => 1 / 2
t : ℝ
ht : 0 < t
n : ℤ
⊢ c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t)) = ↑((↑n + a) * rexp (-π * (↑n + a) ^ 2 * t)) / 2

tactic: 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
t : ℝ
ht : 0 < t
n : ℤ
⊢ c n * ↑(r n) * ↑(rexp (-π * r n ^ 2 * t)) = ↑((↑n + a) * rexp (-π * (↑n + a) ^ 2 * t)) / 2
state_after: no goals

tactic: simp_rw [c, ← mul_one_div ‖_‖]
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)
⊢ Summable fun i => ‖c i‖ / |r i| ^ s.re
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)
⊢ Summable fun i => ‖1 / 2‖ * (1 / |r i| ^ s.re)

tactic: apply Summable.mul_left
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)
⊢ Summable fun i => ‖1 / 2‖ * (1 / |r i| ^ s.re)
state_after: case hf
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)
⊢ Summable fun i => 1 / |r i| ^ s.re

tactic: rwa [summable_one_div_int_add_rpow]
state_before: case hf
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)
⊢ Summable fun i => 1 / |r i| ^ s.re
state_after: no goals