internlm/Lean-Github huggingface dataset:
Theorem: limiting_fourier_aux
Proof state before:
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
Tactic:
intro u
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
u : ℝ
⊢ (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))))
      u =
    (fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)) u
Theorem: limiting_fourier_aux
Proof state before:
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
u : ℝ
⊢ (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))))
      u =
    (fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)) u
Tactic:
have e1 : 1 < ((σ' : ℂ) + (u : ℂ) * I).re := by simp [hσ']
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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ (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))))
      u =
    (fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)) u
Theorem: limiting_fourier_aux
Proof state before:
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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ (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))))
      u =
    (fun a => G (↑σ' + ↑a * I) * ψ.toFun a * ↑x ^ (↑a * I)) u
Tactic:
simp_rw [hG' e1, sub_mul, ← mul_assoc]
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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ LSeries f (↑σ' + ↑u * I) * ψ.toFun u * ↑x ^ (↑u * I) -
      ↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑u * I - 1)) * ψ.toFun u * ↑x ^ (↑u * I) =
    LSeries f (↑σ' + ↑u * I) * ψ.toFun u * ↑x ^ (↑u * I) - ↑A / (↑σ' + ↑u * I - 1) * ψ.toFun u * ↑x ^ (↑u * I)
Theorem: limiting_fourier_aux
Proof state before:
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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ LSeries f (↑σ' + ↑u * I) * ψ.toFun u * ↑x ^ (↑u * I) -
      ↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) * (1 / (↑σ' + ↑u * I - 1)) * ψ.toFun u * ↑x ^ (↑u * I) =
    LSeries f (↑σ' + ↑u * I) * ψ.toFun u * ↑x ^ (↑u * I) - ↑A / (↑σ' + ↑u * I - 1) * ψ.toFun u * ↑x ^ (↑u * I)
Tactic:
field_simp [e2]
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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ (↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) = ↑A ∨ ψ.toFun u = 0) ∨ x = 0 ∧ ¬↑u * I = 0
Theorem: limiting_fourier_aux
Proof state before:
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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ (↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) = ↑A ∨ ψ.toFun u = 0) ∨ x = 0 ∧ ¬↑u * I = 0
Tactic:
left
Proof state after:
case h.hp.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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ ↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) = ↑A ∨ ψ.toFun u = 0
Theorem: limiting_fourier_aux
Proof state before:
case h.hp.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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ ↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) = ↑A ∨ ψ.toFun u = 0
Tactic:
left
Proof state after:
case h.hp.h.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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ ↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) = ↑A
Theorem: limiting_fourier_aux
Proof state before:
case h.hp.h.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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ ↑A * ↑(x ^ (1 - σ')) * ↑(x ^ (σ' - 1)) = ↑A
Tactic:
norm_cast
Proof state after:
case h.hp.h.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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ A * x ^ (1 - σ') * x ^ (σ' - 1) = A
Theorem: limiting_fourier_aux
Proof state before:
case h.hp.h.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
u : ℝ
e1 : 1 < (↑σ' + ↑u * I).re
⊢ A * x ^ (1 - σ') * x ^ (σ' - 1) = A
Tactic:
simp [mul_assoc, ← rpow_add l3]
Proof state after:
no goals
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)
⊢ ℝ → ↑x ∈ slitPlane
Tactic:
simp [l3]
Proof state after:
no goals
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)
⊢ Continuous fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)
Tactic:
apply ((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8
Proof state after:
no goals
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)
⊢ Integrable (fun t => LSeries f (↑σ' + ↑t * I) * ψ.toFun t * ↑x ^ (↑t * I)) volume
Tactic:
exact l6.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right
Proof state after:
no goals