internlm/Lean-Github huggingface dataset:
Theorem: bound_I2
Proof state before:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ ∫ (a : ℝ) in Ici (-x.log), (1 + (a / (2 * π)) ^ 2)⁻¹ ∂volume ≤ 2 * π ^ 2
Tactic:
refine (setIntegral_le_integral l3 l5).trans ?_
Proof state after:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ ∫ (x : ℝ), (1 + (x / (2 * π)) ^ 2)⁻¹ ≤ 2 * π ^ 2
Theorem: bound_I2
Proof state before:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ ∫ (x : ℝ), (1 + (x / (2 * π)) ^ 2)⁻¹ ≤ 2 * π ^ 2
Tactic:
rw [Measure.integral_comp_div (fun x => (1 + x ^ 2)⁻¹) (2 * π)]
Proof state after:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ |2 * π| • ∫ (y : ℝ), (1 + y ^ 2)⁻¹ ≤ 2 * π ^ 2
Theorem: bound_I2
Proof state before:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ |2 * π| • ∫ (y : ℝ), (1 + y ^ 2)⁻¹ ≤ 2 * π ^ 2
Tactic:
simp [abs_eq_self.mpr twopi]
Proof state after:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ 2 * π * π ≤ 2 * π ^ 2
Theorem: bound_I2
Proof state before:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ 2 * π * π ≤ 2 * π ^ 2
Tactic:
ring_nf
Proof state after:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ π ^ 2 * 2 ≤ π ^ 2 * 2
Theorem: bound_I2
Proof state before:
case h
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
l5 : 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ π ^ 2 * 2 ≤ π ^ 2 * 2
Tactic:
rfl
Proof state after:
no goals
Theorem: bound_I2
Proof state before:
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
⊢ 0 ≤ 2 * π
Tactic:
simp [pi_nonneg]
Proof state after:
no goals
Theorem: bound_I2
Proof state before:
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
⊢ 2 * π ≠ 0
Tactic:
norm_num [pi_ne_zero]
Proof state after:
no goals
Theorem: bound_I2
Proof state before:
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
⊢ IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
Tactic:
exact (l3.const_mul _).integrableOn
Proof state after:
no goals
Theorem: bound_I2
Proof state before:
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
Tactic:
refine ((l3.const_mul (W21.norm ψ)).mono' ?_ ?_).integrableOn
Proof state after:
case refine_1
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ AEStronglyMeasurable (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) volume

case refine_2
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ ∀ᵐ (a : ℝ), ‖‖𝓕 ψ.toFun (a / (2 * π))‖‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
Theorem: bound_I2
Proof state before:
case refine_1
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ AEStronglyMeasurable (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) volume
Tactic:
apply Continuous.aestronglyMeasurable
Proof state after:
case refine_1.hf
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ Continuous fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖
Theorem: bound_I2
Proof state before:
case refine_1.hf
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ Continuous fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖
Tactic:
continuity
Proof state after:
no goals
Theorem: bound_I2
Proof state before:
case refine_2
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ ∀ᵐ (a : ℝ), ‖‖𝓕 ψ.toFun (a / (2 * π))‖‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
Tactic:
simp only [norm_norm, key]
Proof state after:
case refine_2
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ ∀ᵐ (a : ℝ), True
Theorem: bound_I2
Proof state before:
case refine_2
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
⊢ ∀ᵐ (a : ℝ), True
Tactic:
simp
Proof state after:
no goals
Theorem: bound_I2
Proof state before:
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
⊢ 0 ≤ᶠ[ae volume] fun a => (1 + (a / (2 * π)) ^ 2)⁻¹
Tactic:
apply eventually_of_forall
Proof state after:
case hp
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
⊢ ∀ (x : ℝ), 0 x ≤ (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) x
Theorem: bound_I2
Proof state before:
case hp
n : ℕ
A a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x.log)) volume
⊢ ∀ (x : ℝ), 0 x ≤ (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) x
Tactic:
intro x
Proof state after:
case hp
n : ℕ
A a b c d u x✝¹ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x✝ : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x✝.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x✝.log)) volume
x : ℝ
⊢ 0 x ≤ (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) x
Theorem: bound_I2
Proof state before:
case hp
n : ℕ
A a b c d u x✝¹ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
x✝ : ℝ
ψ : W21
key : ∀ (a : ℝ), ‖𝓕 ψ.toFun (a / (2 * π))‖ ≤ W21.norm ψ.toFun * (1 + (a / (2 * π)) ^ 2)⁻¹
twopi : 0 ≤ 2 * π
l3 : Integrable (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) volume
l2 : IntegrableOn (fun i => W21.norm ψ.toFun * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-x✝.log)) volume
l1 : IntegrableOn (fun i => ‖𝓕 ψ.toFun (i / (2 * π))‖) (Ici (-x✝.log)) volume
x : ℝ
⊢ 0 x ≤ (fun a => (1 + (a / (2 * π)) ^ 2)⁻¹) x
Tactic:
positivity
Proof state after:
no goals
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Tactic:
have l1 := bound_I1' x hx ψ hcheby
Proof state after:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Tactic:
have l2 := mul_le_mul (le_refl ‖A‖) (bound_I2 x ψ) (by positivity) (by positivity)
Proof state after:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Tactic:
apply norm_sub_le _ _ |>.trans
Proof state after:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ +
      ‖A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ +
      ‖A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Tactic:
rw [norm_mul]
Proof state after:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ +
      ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ +
      ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤
    W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2))
Tactic:
convert _root_.add_le_add l1 l2 using 1
Proof state after:
case h.e'_4
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2)) =
    W21.norm ψ.toFun * C * (1 + 2 * π ^ 2) + ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
Theorem: bound_main
Proof state before:
case h.e'_4
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
l2 : ‖A‖ * ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖ ≤ ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
⊢ W21.norm ψ.toFun * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2)) =
    W21.norm ψ.toFun * C * (1 + 2 * π ^ 2) + ‖A‖ * (W21.norm ψ.toFun * (2 * π ^ 2))
Tactic:
ring
Proof state after:
no goals
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
⊢ 0 ≤ ‖∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π))‖
Tactic:
positivity
Proof state after:
no goals
Theorem: bound_main
Proof state before:
n : ℕ
A✝ a b c d u x✝ y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
C : ℝ
A : ℂ
x : ℝ
hx : 1 ≤ x
ψ : W21
hcheby : chebyWith C f
l1 : ‖∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log)‖ ≤ W21.norm ψ.toFun * C * (1 + 2 * π ^ 2)
⊢ 0 ≤ ‖A‖
Tactic:
positivity
Proof state after:
no goals
Theorem: limiting_cor_W21
Proof state before:
n : ℕ
A a b c d u x y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
ψ : W21
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
hcheby : cheby f
hG : ContinuousOn G {s | 1 ≤ s.re}
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
⊢ Tendsto
    (fun x =>
      ∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        ↑A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π)))
    atTop (𝓝 0)
Tactic:
let S1 x (ψ : ℝ → ℂ) := ∑' (n : ℕ), f n / ↑n * 𝓕 ψ (1 / (2 * π) * Real.log (↑n / x))
Proof state after:
n : ℕ
A a b c d u x y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
ψ : W21
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
hcheby : cheby f
hG : ContinuousOn G {s | 1 ≤ s.re}
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
S1 : ℝ → (ℝ → ℂ) → ℂ := fun x ψ => ∑' (n : ℕ), f n / ↑n * 𝓕 ψ (1 / (2 * π) * (↑n / x).log)
⊢ Tendsto
    (fun x =>
      ∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        ↑A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π)))
    atTop (𝓝 0)
Theorem: limiting_cor_W21
Proof state before:
n : ℕ
A a b c d u x y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
ψ : W21
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
hcheby : cheby f
hG : ContinuousOn G {s | 1 ≤ s.re}
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
S1 : ℝ → (ℝ → ℂ) → ℂ := fun x ψ => ∑' (n : ℕ), f n / ↑n * 𝓕 ψ (1 / (2 * π) * (↑n / x).log)
⊢ Tendsto
    (fun x =>
      ∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        ↑A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π)))
    atTop (𝓝 0)
Tactic:
let S2 x (ψ : ℝ → ℂ) := ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 ψ (u / (2 * π))
Proof state after:
n : ℕ
A a b c d u x y t σ' : ℝ
ψ✝ Ψ : ℝ → ℂ
F G : ℂ → ℂ
f : ℕ → ℂ
𝕜 : Type
inst✝ : _root_.RCLike 𝕜
ψ : W21
hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')
hcheby : cheby f
hG : ContinuousOn G {s | 1 ≤ s.re}
hG' : EqOn G (fun s => LSeries f s - ↑A / (s - 1)) {s | 1 < s.re}
S1 : ℝ → (ℝ → ℂ) → ℂ := fun x ψ => ∑' (n : ℕ), f n / ↑n * 𝓕 ψ (1 / (2 * π) * (↑n / x).log)
S2 : ℝ → (ℝ → ℂ) → ℂ := fun x ψ => ↑A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ (u / (2 * π))
⊢ Tendsto
    (fun x =>
      ∑' (n : ℕ), f n / ↑n * 𝓕 ψ.toFun (1 / (2 * π) * (↑n / x).log) -
        ↑A * ∫ (u : ℝ) in Ici (-x.log), 𝓕 ψ.toFun (u / (2 * π)))
    atTop (𝓝 0)