AFTD Auto-Formalizing Theoretical Domains

dyadic_spectral_series_bound

theoremverified

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 LinearOrder is a TotalPreorder.
  • TotalPreorderA total preorder: a preorder where ≤ is total (complete). This is weaker than LinearOrder — 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.

  1. 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}.

    lines 4–11

    uses exists_nat_ge, summable_pow_mul_geometric_of_norm_lt_one, summable_nat_add_iff, Nat.cast_add, Nat.cast_one

      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)
  2. 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.

    lines 12–38

    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_pow

      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
  3. 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.

    lines 46–53

    uses Summable.sum_le_tsum, dyadic_spectral_series_bound_k_summable

      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
  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.

    lines 54–104

    uses Real.rpow_nonneg, PNat.coe_inj.mp, PNat.sub_coe, Summable.of_nonneg_of_le, Summable.le_tsum, pow_succ

        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
  5. 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.

    lines 105–117

    uses Summable.of_nonneg_of_le, mul_nonneg, Real.rpow_nonneg, Summable.tsum_le_tsum, tsum_mul_left

        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
  6. 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.

    lines 118–137

    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.

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

/-- 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
See it in the graphDiscuss this resultChallenge it