internlm/Lean-Github huggingface dataset:
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
have l6 : Continuous fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by
  apply ((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8
Proof state after:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
have l4 : Integrable fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by
  exact l6.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right
Proof state after:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
have e2 (u : ℝ) : σ' + u * I - 1 ≠ 0 := by
  intro h ; have := congr_arg Complex.re h ; simp at this ; linarith
Proof state after:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
have l7 : Continuous fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by
  simp [← mul_assoc]
  refine ((continuous_const.mul <| Continuous.inv₀ ?_ e2).mul ψ.h1.continuous).mul l8
  continuity
Proof state after:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
have l5 : Integrable fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by
  apply l7.integrable_of_hasCompactSupport
  exact ψ.h2.mul_left.mul_right.mul_left.mul_left
Proof state after:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
      ↑A * ↑(x ^ (1 - σ')) * ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
simp_rw [l1 σ' hσ', l2 σ' hσ', ← integral_mul_left, ← integral_sub l4 l5]
Proof state after:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ ∫ (a : ℝ),
      LSeries f (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I) -
        ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Theorem: limiting_fourier_aux
Proof state before:
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ ∫ (a : ℝ),
      LSeries f (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I) -
        ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))) =
    ∫ (t : ℝ), G (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
apply integral_congr_ae
Proof state after:
case h
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ (fun a =>
      LSeries f (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I) -
        ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))) =ᶠ[ae volume]
    fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)
Theorem: limiting_fourier_aux
Proof state before:
case h
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ (fun a =>
      LSeries f (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I) -
        ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))) =ᶠ[ae volume]
    fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)
Tactic:
apply eventually_of_forall
Proof state after:
case h.hp
n : ℕ
A a b c d u x y t σ'✝ : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
ψ : CS 2 ℂ
hx : 1 ≤ x
σ' : ℝ
hσ' : 1 < σ'
hint : Integrable ψ.toFun volume
l3 : 0 < x
l1 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∑' (n : ℕ), term f (↑σ') n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) =
        ∫ (t : ℝ), LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l2 :
  ∀ (σ' : ℝ),
    1 < σ' →
      ∫ (u : ℝ) in Ici (-x.log), ↑(rexp (-u * (σ' - 1))) * 𝓕 ψ.toFun (u / (2 * π)) =
        ↑(x ^ (σ' - 1)) * ∫ (t : ℝ), 1 / (↑σ' + ↑t * I - 1) * ψ.toFun t * ↑x ^ (↑t * I)
l8 : Continuous fun t => ↑x ^ (↑t * I)
l6 : Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
l4 : Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
e2 : ∀ (u : ℝ), ↑σ' + ↑u * I - 1 ≠ 0
l7 : Continuous fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I)))
l5 :
  Integrable (fun a => ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
    volume
⊢ ∀ (x_1 : ℝ),
    (fun a =>
          LSeries f (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I) -
            ↑A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑a * I - 1) * ψ.toFun a * ↑x ^ (↑a * I))))
        x_1 =
      (fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)) x_1