dyadic_spectral_series_bound
Let a ≥ 0, and let mu : ℕ+ → ℝ be a non-negative sequence satisfying ∑' j, mu j ≤ 1 and tail bounds ∑_{k > j} mu k ≤ (1/2)^j for all j ≥ 1. Then the series ∑' j, 2 * mu j * (j + 3)^a is bounded by 4 * K_a, where K_a = fourier_approximation_constant a.
Statement
theorem dyadic_spectral_series_bound (a : ℝ) (ha : 0 ≤ a) (mu : ℕ+ → ℝ) (hmu_nonneg : ∀ j, 0 ≤ mu j) (hmu_le_one : (∑' j, mu j) ≤ 1) (hmu_tail : ∀ j : ℕ+, (∑' k : ℕ+, if (j : ℕ) < (k : ℕ) then mu k else 0) ≤ (1 / 2 : ℝ) ^ (j : ℕ)) : (∑' j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a) ≤ 4 * fourier_approximation_constant a
- Source
- arXiv:2611.06451 Theorem 3.1 proof (eq. 18)
- Verified
- 06 Nov 2026
- Axioms
Classical.choiceQuot.soundpropext- Built on 4
- fourier_approximation_constantFor a real parameter a, the Fourier approximation constant K_a is defined as the infinite series ∑_{j=1}^∞ 2^(-j) (j+3)^a, indexed over…
- LinearOrder.toTotalPreorderEvery
LinearOrderis aTotalPreorder. - TotalPreorderA total preorder: a preorder where
≤is total (complete). This is weaker thanLinearOrder— it does NOT require antisymmetry or… - weightThe support $\mathrm{supp}(p) \subseteq \mathrm{Fin}\,n$ consists of coordinates where $p(i) \neq I$; the weight is…
Read back from the Lean
For every non-negative real number a and every sequence μ : ℕ+ → ℝ, if: 1. μ(j) ≥ 0 for all positive integers j, 2. the sum ∑' j : ℕ+, μ(j) ≤ 1, and 3. for every positive integer j, the tail sum ∑' k : ℕ+, (if j < k then μ(k) else 0) ≤ (1 / 2)^j, then: ∑' j : ℕ+, 2 * μ(j) * (j + 3)^a ≤ 4 * fourier_approximation_constant(a).
Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.
The proof, explained
The proof establishes that the series ∑' 2 μ(j) (j + 3)^a is bounded by 4 * K_a, where K_a = ∑' (1/2)^j (j + 3)^a is shown to converge by comparing it to a polynomial-geometric series. When μ is summable, each term 2 μ(j) (j + 3)^a is bounded by 4 (1/2)^j (j + 3)^a: for j = 1 this follows from μ(1) ≤ ∑ μ ≤ 1, while for j ≥ 2 the tail bound gives μ(j) ≤ ∑_{k > j-1} μ(k) ≤ (1/2)^{j-1} = 2(1/2)^j. Summing this pointwise bound gives at most 4 * K_a. If μ is not summable, the series also diverges (since (j + 3)^a ≥ 1), so its sum is 0 by definition in Lean, which is trivially bounded by 4 * K_a ≥ 0.
The geometric-polynomial majorizing series ∑_{n=0}^∞ 5^k (n + 1)^k (1/2)^{n+1} converges, where k is an integer with k ≥ a.
We pick an integer k ≥ a via exists_nat_ge. Because |1/2| < 1, the series ∑ n^k (1/2)^n converges by summable_pow_mul_geometric_of_norm_lt_one. Shifting the index by 1 preserves convergence (summable_nat_add_iff, with Nat.cast_add and Nat.cast_one), and scaling the terms by 5^k produces the convergent series ∑ 5^k (n + 1)^k (1/2)^{n+1}.
uses
exists_nat_ge,summable_pow_mul_geometric_of_norm_lt_one,summable_nat_add_iff,Nat.cast_add,Nat.cast_oneobtain ⟨k, hk⟩ := exists_nat_ge a have hs0 : Summable (fun n : ℕ => (n : ℝ) ^ k * (1 / 2 : ℝ) ^ n) := summable_pow_mul_geometric_of_norm_lt_one k (by norm_num) have hs1 : Summable (fun n : ℕ => (((n + 1 : ℕ) : ℝ)) ^ k * (1 / 2 : ℝ) ^ (n + 1)) := by have h := (summable_nat_add_iff (f := fun n : ℕ => (n : ℝ) ^ k * (1 / 2 : ℝ) ^ n) 1).mpr hs0 simpa [Nat.cast_add, Nat.cast_one] using h have hs2 : Summable (fun n : ℕ => (5 : ℝ) ^ k * ((((n + 1 : ℕ) : ℝ)) ^ k * (1 / 2 : ℝ) ^ (n + 1))) := hs1.mul_left ((5 : ℝ) ^ k)
The weight series ∑_{j=1}^∞ (1/2)^j (j + 3)^a converges.
Reindexing from ℕ+ to ℕ via j = n + 1 (Equiv.summable_iff), we apply the comparison test (Summable.of_nonneg_of_le). Each term is non-negative by mul_nonneg and Real.rpow_nonneg. For the upper bound, (n + 1) + 3 ≥ 1 (Nat.cast_nonneg) and a ≤ k imply ((n + 1) + 3)^a ≤ ((n + 1) + 3)^k by Real.rpow_le_rpow_of_exponent_le and Real.rpow_natCast. Since (n + 1) + 3 ≤ 5(n + 1), pow_le_pow_left₀ and mul_pow yield ((n + 1) + 3)^k ≤ 5^k (n + 1)^k. Thus (1/2)^{n+1} ((n + 1) + 3)^a ≤ 5^k (n + 1)^k (1/2)^{n+1}, which is summable.
uses
Equiv.summable_iff,Summable.of_nonneg_of_le,Function.comp_apply,Equiv.pnatEquivNat_symm_apply,mul_nonneg,Real.rpow_nonneg,Nat.cast_nonneg,Real.rpow_le_rpow_of_exponent_le,Real.rpow_natCast,pow_le_pow_left₀,mul_powrw [← Equiv.summable_iff (Equiv.pnatEquivNat.symm)] refine Summable.of_nonneg_of_le ?nonneg ?le hs2 · intro n simp only [Function.comp_apply, Equiv.pnatEquivNat_symm_apply] apply mul_nonneg · positivity · exact Real.rpow_nonneg (by positivity) a · intro n simp only [Function.comp_apply, Equiv.pnatEquivNat_symm_apply] have hbase : (1 : ℝ) ≤ ((n + 1 : ℕ) : ℝ) + 3 := by push_cast linarith [Nat.cast_nonneg (α := ℝ) n] have hrpow : (((n + 1 : ℕ) : ℝ) + 3) ^ a ≤ (((n + 1 : ℕ) : ℝ) + 3) ^ k := by have h := Real.rpow_le_rpow_of_exponent_le hbase hk simpa [Real.rpow_natCast] using h have h4 : (((n + 1 : ℕ) : ℝ) + 3) ≤ 5 * (((n + 1 : ℕ) : ℝ)) := by push_cast nlinarith [Nat.cast_nonneg (α := ℝ) n] have hpow : (((n + 1 : ℕ) : ℝ) + 3) ^ k ≤ (5 * (((n + 1 : ℕ) : ℝ))) ^ k := pow_le_pow_left₀ (by positivity) h4 k calc (1 / 2 : ℝ) ^ (n + 1) * (((n + 1 : ℕ) : ℝ) + 3) ^ a ≤ (1 / 2 : ℝ) ^ (n + 1) * (((n + 1 : ℕ) : ℝ) + 3) ^ k := by gcongr _ ≤ (1 / 2 : ℝ) ^ (n + 1) * (5 * (((n + 1 : ℕ) : ℝ))) ^ k := by gcongr _ = (5 : ℝ) ^ k * ((((n + 1 : ℕ) : ℝ)) ^ k * (1 / 2 : ℝ) ^ (n + 1)) := by rw [mul_pow]; ring
Assuming μ is summable, we have μ(1) ≤ 1 and the series ∑_{j=1}^∞ 4 (1/2)^j (j + 3)^a converges.
We split into cases on whether μ is summable. In the summable case, the single term μ(1) is bounded by the total sum ∑' μ ≤ 1 using Summable.sum_le_tsum. The series defining K_a converges by dyadic_spectral_series_bound_k_summable, and scaling by 4 shows that ∑ 4 (1/2)^j (j + 3)^a converges.
uses
Summable.sum_le_tsum,dyadic_spectral_series_bound_k_summableby_cases hmu_summable : Summable mu · have hmu_one_le_one : mu (1 : ℕ+) ≤ 1 := by have h := Summable.sum_le_tsum ({1} : Finset ℕ+) (fun i hi => hmu_nonneg i) hmu_summable simpa using h.trans hmu_le_one have hK_summable : Summable (fun j : ℕ+ => (1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := dyadic_spectral_series_bound_k_summable a have hG_summable : Summable (fun j : ℕ+ => 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a)) := hK_summable.mul_left 4
For every positive integer j, 2 μ(j) (j + 3)^a ≤ 4 (1/2)^j (j + 3)^a.
For j = 1, the inequality simplifies to 2 μ(1) 4^a ≤ 2 · 4^a, which holds because μ(1) ≤ 1 and 4^a ≥ 0 (Real.rpow_nonneg). For j ≥ 2, we have j - 1 < j (PNat.coe_inj.mp, PNat.sub_coe). The tail series ∑_{k > j-1} μ(k) converges by comparison (Summable.of_nonneg_of_le), so μ(j) is bounded by the tail sum (Summable.le_tsum), which is at most (1/2)^{j-1} by hypothesis. Since (1/2)^{j-1} = 2 (1/2)^j by pow_succ, we obtain 2 μ(j) (j + 3)^a ≤ 4 (1/2)^j (j + 3)^a.
uses
Real.rpow_nonneg,PNat.coe_inj.mp,PNat.sub_coe,Summable.of_nonneg_of_le,Summable.le_tsum,pow_succhave hFG : ∀ j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a ≤ 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := by intro j by_cases hj : j = 1 · subst hj norm_num have h4 : (0 : ℝ) ≤ 4 ^ a := Real.rpow_nonneg (by norm_num) a nlinarith [hmu_one_le_one] · have hj2 : 2 ≤ (j : ℕ) := by have hcoe_ne : (j : ℕ) ≠ 1 := by intro h apply hj apply PNat.coe_inj.mp simpa using h have hp : 0 < (j : ℕ) := j.pos omega have hjp_lt : (((j - 1 : ℕ+) : ℕ)) < (j : ℕ) := by rw [PNat.sub_coe] have h1j : (1 : ℕ+) < j := by exact_mod_cast (by omega : 1 < (j : ℕ)) simp [h1j] have htail_summable : Summable (fun k : ℕ+ => if (((j - 1 : ℕ+) : ℕ)) < (k : ℕ) then mu k else 0) := by refine Summable.of_nonneg_of_le ?_ ?_ hmu_summable · intro k split_ifs <;> simp [hmu_nonneg] · intro k split_ifs <;> simp [hmu_nonneg] have hterm : (if (((j - 1 : ℕ+) : ℕ)) < (j : ℕ) then mu j else 0) ≤ ∑' k : ℕ+, if (((j - 1 : ℕ+) : ℕ)) < (k : ℕ) then mu k else 0 := by refine Summable.le_tsum htail_summable j ?_ intro k hk split_ifs <;> simp [hmu_nonneg] have hmuj_le : mu j ≤ (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) := by calc mu j = (if (((j - 1 : ℕ+) : ℕ)) < (j : ℕ) then mu j else 0) := by simp [hjp_lt] _ ≤ ∑' k : ℕ+, if (((j - 1 : ℕ+) : ℕ)) < (k : ℕ) then mu k else 0 := hterm _ ≤ (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) := hmu_tail (j - 1) have hpowrel : (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) = 2 * (1 / 2 : ℝ) ^ (j : ℕ) := by have hj_eq : (j : ℕ) = (((j - 1 : ℕ+) : ℕ)) + 1 := by rw [PNat.sub_coe] have h1j : (1 : ℕ+) < j := by exact_mod_cast (by omega : 1 < (j : ℕ)) simp [h1j] omega rw [hj_eq, pow_succ] ring have hw : 0 ≤ ((j : ℝ) + 3) ^ a := Real.rpow_nonneg (by positivity) a calc 2 * mu j * ((j : ℝ) + 3) ^ a ≤ 2 * (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) * ((j : ℝ) + 3) ^ a := by gcongr _ = 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := by rw [hpowrel]; ring
When μ is summable, ∑_{j=1}^∞ 2 μ(j) (j + 3)^a converges and is bounded by 4 * K_a.
From the termwise bound and non-negativity (mul_nonneg, Real.rpow_nonneg), the series converges by Summable.of_nonneg_of_le. Summing both sides with Summable.tsum_le_tsum and pulling out the constant factor 4 via tsum_mul_left yields ∑' 2 μ(j) (j + 3)^a ≤ 4 * K_a.
uses
Summable.of_nonneg_of_le,mul_nonneg,Real.rpow_nonneg,Summable.tsum_le_tsum,tsum_mul_lefthave hF_summable : Summable (fun j : ℕ+ => 2 * mu j * ((j : ℝ) + 3) ^ a) := by refine Summable.of_nonneg_of_le ?_ hFG hG_summable intro j apply mul_nonneg · apply mul_nonneg; norm_num; exact hmu_nonneg j · exact Real.rpow_nonneg (by positivity) a have hle := Summable.tsum_le_tsum hFG hF_summable hG_summable calc (∑' j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a) ≤ ∑' j : ℕ+, 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := hle _ = 4 * fourier_approximation_constant a := by rw [tsum_mul_left] rfl
When μ is not summable, the series ∑ 2 μ(j) (j + 3)^a is also not summable, so its formal sum is 0 ≤ 4 * K_a.
If the series converged, then because (j + 3) ≥ 1 and a ≥ 0 imply (j + 3)^a ≥ 1 (Real.one_le_rpow), we would have μ(j) ≤ 2 μ(j) (j + 3)^a, forcing μ to be summable by comparison (Summable.of_nonneg_of_le), a contradiction. Thus the series diverges and its sum is 0 by tsum_eq_zero_of_not_summable. Since each term of K_a is non-negative (mul_nonneg, Real.rpow_nonneg), tsum_nonneg gives 0 ≤ 4 * K_a, which completes the bound.
uses
Real.one_le_rpow,Summable.of_nonneg_of_le,tsum_eq_zero_of_not_summable,mul_nonneg,Real.rpow_nonneg,tsum_nonneg· have hF_not_summable : ¬ Summable (fun j : ℕ+ => 2 * mu j * ((j : ℝ) + 3) ^ a) := by intro hF apply hmu_summable refine Summable.of_nonneg_of_le hmu_nonneg ?_ hF intro j have hbase : (1 : ℝ) ≤ (j : ℝ) + 3 := by have : (0 : ℝ) ≤ (j : ℝ) := by positivity linarith have hw1 : 1 ≤ ((j : ℝ) + 3) ^ a := Real.one_le_rpow hbase ha nlinarith [hmu_nonneg j, hw1] have hF_zero : (∑' j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a) = 0 := tsum_eq_zero_of_not_summable hF_not_summable rw [hF_zero] have hK_nonneg : 0 ≤ fourier_approximation_constant a := by unfold fourier_approximation_constant refine tsum_nonneg (fun j => ?_) apply mul_nonneg · positivity · exact Real.rpow_nonneg (by positivity) a nlinarith
exists_nat_ge- Every real number is bounded above by some natural number.
summable_pow_mul_geometric_of_norm_lt_one- For any natural number k and ratio r with |r| < 1, the series ∑ n^k r^n converges.
summable_nat_add_iff- A sequence on ℕ is summable if and only if any of its shifted tails is summable.
Nat.cast_add- The cast of natural addition to a ring equals the sum of the casts: ↑(m + n) = ↑m + ↑n.
Nat.cast_one- The natural number 1 coerces to 1 in any ring with one.
Equiv.summable_iff- A series converges if and only if it converges after reindexing by a bijection.
Summable.of_nonneg_of_le- Comparison test: if 0 ≤ g(b) ≤ f(b) pointwise and ∑ f(b) converges, then ∑ g(b) converges.
Function.comp_apply- Definition of function composition: (f ∘ g)(x) = f(g(x)).
Equiv.pnatEquivNat_symm_apply- The standard bijection from ℕ to ℕ+ maps n to n + 1.
mul_nonneg- The product of two non-negative real numbers is non-negative.
Real.rpow_nonneg- A non-negative base raised to any real power is non-negative.
Nat.cast_nonneg- The coercion of a natural number into an ordered ring is non-negative.
Real.rpow_le_rpow_of_exponent_le- For base x ≥ 1, x^y ≤ x^z whenever y ≤ z.
Real.rpow_natCast- Real exponentiation by a cast natural number agrees with natural power: x ^ (↑n) = x ^ n.
pow_le_pow_left₀- If 0 ≤ a ≤ b, then a^n ≤ b^n for every natural exponent n.
mul_pow- In a commutative monoid, (a * b)^n = a^n * b^n.
Summable.sum_le_tsum- For a non-negative summable sequence, any finite sum is bounded by the total sum of the series.
dyadic_spectral_series_bound_k_summable- The series ∑ (1/2)^j (j + 3)^a over positive integers j converges for any real a.
PNat.coe_inj.mp- If two positive integers are equal after coercing to ℕ, they are equal.
PNat.sub_coe- The positive integer difference a - b coerces to a - b in ℕ when b < a, and to 1 otherwise.
Summable.le_tsum- Any term of a non-negative summable series is bounded by the sum of the series.
pow_succ- Power recurrence: a^(n + 1) = a^n * a.
Summable.tsum_le_tsum- Pointwise inequality preserves infinite sums: if f ≤ g and both converge, then ∑' f ≤ ∑' g.
tsum_mul_left- A constant factor pulls out of an infinite series sum: ∑' c * f(x) = c * ∑' f(x).
Real.one_le_rpow- If x ≥ 1 and z ≥ 0, then 1 ≤ x^z.
tsum_eq_zero_of_not_summable- The infinite sum of a non-summable sequence is defined to be zero.
tsum_nonneg- The sum of a non-negative sequence is non-negative.
- In Lean, when an infinite series does not converge, its sum `∑'` is defined to be 0 by default (`tsum_eq_zero_of_not_summable`). The proof explicitly handles the case where μ is not summable by showing that the spectral series must also diverge, making its formal sum 0, which is trivially bounded by 4 * K_a ≥ 0.
Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.
Lean source view module on GitHub
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
/-- The weight series defining the Fourier approximation constant is summable. -/private lemma dyadic_spectral_series_bound_k_summable (a : ℝ) : Summable (fun j : ℕ+ => (1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := by obtain ⟨k, hk⟩ := exists_nat_ge a have hs0 : Summable (fun n : ℕ => (n : ℝ) ^ k * (1 / 2 : ℝ) ^ n) := summable_pow_mul_geometric_of_norm_lt_one k (by norm_num) have hs1 : Summable (fun n : ℕ => (((n + 1 : ℕ) : ℝ)) ^ k * (1 / 2 : ℝ) ^ (n + 1)) := by have h := (summable_nat_add_iff (f := fun n : ℕ => (n : ℝ) ^ k * (1 / 2 : ℝ) ^ n) 1).mpr hs0 simpa [Nat.cast_add, Nat.cast_one] using h have hs2 : Summable (fun n : ℕ => (5 : ℝ) ^ k * ((((n + 1 : ℕ) : ℝ)) ^ k * (1 / 2 : ℝ) ^ (n + 1))) := hs1.mul_left ((5 : ℝ) ^ k) rw [← Equiv.summable_iff (Equiv.pnatEquivNat.symm)] refine Summable.of_nonneg_of_le ?nonneg ?le hs2 · intro n simp only [Function.comp_apply, Equiv.pnatEquivNat_symm_apply] apply mul_nonneg · positivity · exact Real.rpow_nonneg (by positivity) a · intro n simp only [Function.comp_apply, Equiv.pnatEquivNat_symm_apply] have hbase : (1 : ℝ) ≤ ((n + 1 : ℕ) : ℝ) + 3 := by push_cast linarith [Nat.cast_nonneg (α := ℝ) n] have hrpow : (((n + 1 : ℕ) : ℝ) + 3) ^ a ≤ (((n + 1 : ℕ) : ℝ) + 3) ^ k := by have h := Real.rpow_le_rpow_of_exponent_le hbase hk simpa [Real.rpow_natCast] using h have h4 : (((n + 1 : ℕ) : ℝ) + 3) ≤ 5 * (((n + 1 : ℕ) : ℝ)) := by push_cast nlinarith [Nat.cast_nonneg (α := ℝ) n] have hpow : (((n + 1 : ℕ) : ℝ) + 3) ^ k ≤ (5 * (((n + 1 : ℕ) : ℝ))) ^ k := pow_le_pow_left₀ (by positivity) h4 k calc (1 / 2 : ℝ) ^ (n + 1) * (((n + 1 : ℕ) : ℝ) + 3) ^ a ≤ (1 / 2 : ℝ) ^ (n + 1) * (((n + 1 : ℕ) : ℝ) + 3) ^ k := by gcongr _ ≤ (1 / 2 : ℝ) ^ (n + 1) * (5 * (((n + 1 : ℕ) : ℝ))) ^ k := by gcongr _ = (5 : ℝ) ^ k * ((((n + 1 : ℕ) : ℝ)) ^ k * (1 / 2 : ℝ) ^ (n + 1)) := by rw [mul_pow]; ring/-- Bound on the dyadic spectral series by the Fourier approximation constant. -/theorem dyadic_spectral_series_bound (a : ℝ) (ha : 0 ≤ a) (mu : ℕ+ → ℝ) (hmu_nonneg : ∀ j, 0 ≤ mu j) (hmu_le_one : (∑' j, mu j) ≤ 1) (hmu_tail : ∀ j : ℕ+, (∑' k : ℕ+, if (j : ℕ) < (k : ℕ) then mu k else 0) ≤ (1 / 2 : ℝ) ^ (j : ℕ)) : (∑' j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a) ≤ 4 * fourier_approximation_constant a := by by_cases hmu_summable : Summable mu · have hmu_one_le_one : mu (1 : ℕ+) ≤ 1 := by have h := Summable.sum_le_tsum ({1} : Finset ℕ+) (fun i hi => hmu_nonneg i) hmu_summable simpa using h.trans hmu_le_one have hK_summable : Summable (fun j : ℕ+ => (1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := dyadic_spectral_series_bound_k_summable a have hG_summable : Summable (fun j : ℕ+ => 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a)) := hK_summable.mul_left 4 have hFG : ∀ j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a ≤ 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := by intro j by_cases hj : j = 1 · subst hj norm_num have h4 : (0 : ℝ) ≤ 4 ^ a := Real.rpow_nonneg (by norm_num) a nlinarith [hmu_one_le_one] · have hj2 : 2 ≤ (j : ℕ) := by have hcoe_ne : (j : ℕ) ≠ 1 := by intro h apply hj apply PNat.coe_inj.mp simpa using h have hp : 0 < (j : ℕ) := j.pos omega have hjp_lt : (((j - 1 : ℕ+) : ℕ)) < (j : ℕ) := by rw [PNat.sub_coe] have h1j : (1 : ℕ+) < j := by exact_mod_cast (by omega : 1 < (j : ℕ)) simp [h1j] have htail_summable : Summable (fun k : ℕ+ => if (((j - 1 : ℕ+) : ℕ)) < (k : ℕ) then mu k else 0) := by refine Summable.of_nonneg_of_le ?_ ?_ hmu_summable · intro k split_ifs <;> simp [hmu_nonneg] · intro k split_ifs <;> simp [hmu_nonneg] have hterm : (if (((j - 1 : ℕ+) : ℕ)) < (j : ℕ) then mu j else 0) ≤ ∑' k : ℕ+, if (((j - 1 : ℕ+) : ℕ)) < (k : ℕ) then mu k else 0 := by refine Summable.le_tsum htail_summable j ?_ intro k hk split_ifs <;> simp [hmu_nonneg] have hmuj_le : mu j ≤ (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) := by calc mu j = (if (((j - 1 : ℕ+) : ℕ)) < (j : ℕ) then mu j else 0) := by simp [hjp_lt] _ ≤ ∑' k : ℕ+, if (((j - 1 : ℕ+) : ℕ)) < (k : ℕ) then mu k else 0 := hterm _ ≤ (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) := hmu_tail (j - 1) have hpowrel : (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) = 2 * (1 / 2 : ℝ) ^ (j : ℕ) := by have hj_eq : (j : ℕ) = (((j - 1 : ℕ+) : ℕ)) + 1 := by rw [PNat.sub_coe] have h1j : (1 : ℕ+) < j := by exact_mod_cast (by omega : 1 < (j : ℕ)) simp [h1j] omega rw [hj_eq, pow_succ] ring have hw : 0 ≤ ((j : ℝ) + 3) ^ a := Real.rpow_nonneg (by positivity) a calc 2 * mu j * ((j : ℝ) + 3) ^ a ≤ 2 * (1 / 2 : ℝ) ^ (((j - 1 : ℕ+) : ℕ)) * ((j : ℝ) + 3) ^ a := by gcongr _ = 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := by rw [hpowrel]; ring have hF_summable : Summable (fun j : ℕ+ => 2 * mu j * ((j : ℝ) + 3) ^ a) := by refine Summable.of_nonneg_of_le ?_ hFG hG_summable intro j apply mul_nonneg · apply mul_nonneg; norm_num; exact hmu_nonneg j · exact Real.rpow_nonneg (by positivity) a have hle := Summable.tsum_le_tsum hFG hF_summable hG_summable calc (∑' j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a) ≤ ∑' j : ℕ+, 4 * ((1 / 2 : ℝ) ^ (j : ℕ) * ((j : ℝ) + 3) ^ a) := hle _ = 4 * fourier_approximation_constant a := by rw [tsum_mul_left] rfl · have hF_not_summable : ¬ Summable (fun j : ℕ+ => 2 * mu j * ((j : ℝ) + 3) ^ a) := by intro hF apply hmu_summable refine Summable.of_nonneg_of_le hmu_nonneg ?_ hF intro j have hbase : (1 : ℝ) ≤ (j : ℝ) + 3 := by have : (0 : ℝ) ≤ (j : ℝ) := by positivity linarith have hw1 : 1 ≤ ((j : ℝ) + 3) ^ a := Real.one_le_rpow hbase ha nlinarith [hmu_nonneg j, hw1] have hF_zero : (∑' j : ℕ+, 2 * mu j * ((j : ℝ) + 3) ^ a) = 0 := tsum_eq_zero_of_not_summable hF_not_summable rw [hF_zero] have hK_nonneg : 0 ≤ fourier_approximation_constant a := by unfold fourier_approximation_constant refine tsum_nonneg (fun j => ?_) apply mul_nonneg · positivity · exact Real.rpow_nonneg (by positivity) a nlinarith