Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec111aPredictors.BandScaleSumAssembly

Trilinear Hilbert transform: band_scale_sum_assembly #

theorem TrilinearHT.Auto.band_scale_sum_assembly (κ : LocalKernelClass) {d : ℕ} (hd : 1 ≤ d) (A : QuadraticChartData d) (hAb : IsBoundedQuadraticChart A) (D J1 m : ℕ) {Lh : ℝ} (hLh : 0 ≤ Lh) (G : RealDyadicGrid) (J : ℤ × ℤ) (S : Finset (ℤ × ℤ)) (hSJ : ∀ I ∈ S, dyadicGridCell G I.1 I.2 ⊆ dyadicGridCell G J.1 J.2) (w : ℤ × ℤ → ℝ × ℝ → ℂ) (hw : ∀ I ∈ S, IsAdmissibleLocalKernel κ (dyadicGridLeft G I.1 I.2) (dyadicGridLength G I.1) (w I)) {a b : Fin 4} (hab : a ≠ b) {ψa ψb : ℝ → ℂ} (hψam : Measurable ψa) (hψbm : Measurable ψb) (hψa : ∀ (y : ℝ), ‖ψa y‖ ≤ 1) (hψb : ∀ (y : ℝ), ‖ψb y‖ ≤ 1) {Fa Fb : ℝ → ℂ} {za zb : ℤ × ℤ → ℝ → ℂ} {Ka Kb : ℝ} (hKa : 0 ≤ Ka) (hKb : 0 ≤ Kb) (hza : IsAdmissibleOpponent G J Fa za Ka) (hzb : IsAdmissibleOpponent G J Fb zb Kb) (hEa : HasDepthEnergy G J Fa za Ka) (hEb : HasDepthEnergy G J Fb zb Kb) (hzam : ∀ (I : ℤ × ℤ), Measurable (za I)) (hzbm : ∀ (I : ℤ × ℤ), Measurable (zb I)) (hza2 : ∀ (I : ℤ × ℤ), MeasureTheory.MemLp (za I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) (hzb2 : ∀ (I : ℤ × ℤ), MeasureTheory.MemLp (zb I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) (hband : ∀ I ∈ S, ∀ (ξ : ℝ), bandAmplitude (quadraticChartAtom A) (dyadicGridLength G I.1) ξ ≤ Real.exp (-↑m)) (lamf : ℤ → ℝ) (Mf : ℤ → Matrix (Fin d) (Fin d) ℚ) (σf : ℤ → ℕ × (Fin (d + d) → ℤ) → Fin d → ℚ) (coeff : ℤ → ℕ × (Fin (d + d) → ℤ) → ℂ) (hprops : ∀ s ∈ Finset.image Prod.fst S, (∀ (i j : Fin d), ↑(rationalHeight (Mf s i j)) ≤ bsE D m Lh) ∧ lamf s = A.quadratic + ∑ i : Fin d, ∑ j : Fin d, A.horizontal i * ↑(Mf s i j) * A.horizontal j ∧ |lamf s| * dyadicGridLength G s ^ 2 ≤ bsE D m Lh ∧ (∀ (p : ℕ × (Fin (d + d) → ℤ)) (i : Fin d), ↑(rationalHeight (σf s p i)) ≤ bsE D m Lh * (1 + frequencyLength p.2)) ∧ (∀ (t : ℝ), |t| ≤ 2 * dyadicGridLength G s → HasSum (fun (p : ℕ × (Fin (d + d) → ℤ)) => coeff s p * quadPhase (lamf s) (A.linear + ∑ i : Fin d, ↑(σf s p i) * A.horizontal i) t) (quadraticChartAtom A t)) ∧ (Summable fun (p : ℕ × (Fin (d + d) → ℤ)) => ‖coeff s p‖) ∧ ∑' (p : ℕ × (Fin (d + d) → ℤ)), ‖coeff s p‖ ≤ bsE D m Lh ∧ (∀ (p : ℕ × (Fin (d + d) → ℤ)), ⌊bsE D m Lh⌋₊ ≤ p.1 → coeff s p = 0) ∧ ∀ (p : ℕ × (Fin (d + d) → ℤ)), ‖coeff s p‖ * (1 + frequencyLength p.2) ^ (d + 1) ^ 2 ≤ bsE1 J1 m Lh) (hzero : ∀ s ∉ Finset.image Prod.fst S, coeff s = 0) :
∑ I ∈ S, dyadicGridLength G I.1 * ‖separatedLocalForm (dyadicGridLength G I.1) (w I) (quadraticChartAtom A) a b (fun (y : ℝ) => ψa y * za I y) fun (y : ℝ) => ψb y * zb I y‖ ≤ Real.exp (-↑m) * bandBracket κ d D J1 m Lh * Ka * Kb * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fa y‖ ^ 2) * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fb y‖ ^ 2)

Assembly of eq:band-scale-sum from per-depth chart expansions with the explicit parameters (blueprint lem:predictors, proof lines 1517–1542).

theorem TrilinearHT.Auto.band_scale_sum_param (c₀ : ℕ) (hc : 1 ≤ c₀) (κ : LocalKernelClass) :
∃ (D : ℕ) (J1 : ℕ), 1 ≤ D ∧ ∀ {d : ℕ} (H : ℝ) (A : QuadraticChartData d), 1 ≤ d → QuadraticChartComplexity c₀ H A → IsBoundedQuadraticChart A → ∀ (m : ℕ) (G : RealDyadicGrid) (J : ℤ × ℤ) (S : Finset (ℤ × ℤ)), (∀ I ∈ S, dyadicGridCell G I.1 I.2 ⊆ dyadicGridCell G J.1 J.2) → ∀ (w : ℤ × ℤ → ℝ × ℝ → ℂ), (∀ I ∈ S, IsAdmissibleLocalKernel κ (dyadicGridLeft G I.1 I.2) (dyadicGridLength G I.1) (w I)) → ∀ {a b : Fin 4}, a ≠ b → ∀ {ψa ψb : ℝ → ℂ}, Measurable ψa → Measurable ψb → (∀ (y : ℝ), ‖ψa y‖ ≤ 1) → (∀ (y : ℝ), ‖ψb y‖ ≤ 1) → ∀ {Fa Fb : ℝ → ℂ} {za zb : ℤ × ℤ → ℝ → ℂ} {Ka Kb : ℝ}, 0 ≤ Ka → 0 ≤ Kb → IsAdmissibleOpponent G J Fa za Ka → IsAdmissibleOpponent G J Fb zb Kb → HasDepthEnergy G J Fa za Ka → HasDepthEnergy G J Fb zb Kb → (∀ (I : ℤ × ℤ), Measurable (za I)) → (∀ (I : ℤ × ℤ), Measurable (zb I)) → (∀ (I : ℤ × ℤ), MeasureTheory.MemLp (za I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) → (∀ (I : ℤ × ℤ), MeasureTheory.MemLp (zb I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) → (∀ I ∈ S, InScaleBand (quadraticChartAtom A) m (dyadicGridLength G I.1)) → ∑ I ∈ S, dyadicGridLength G I.1 * ‖separatedLocalForm (dyadicGridLength G I.1) (w I) (quadraticChartAtom A) a b (fun (y : ℝ) => ψa y * za I y) fun (y : ℝ) => ψb y * zb I y‖ ≤ Real.exp (-↑m) * bandBracket κ d D J1 m (Real.log (max H (bandLip + 1))) * Ka * Kb * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fa y‖ ^ 2) * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fb y‖ ^ 2)

Blueprint lem:predictors, eq:band-scale-sum with explicit parameters: for one separated time factor Q (a bounded chart of complexity H) and admissible opponents, the absolute length-weighted sum over the cells of the m-th Fourier-supremum band is at most e^{-m} times the explicit bracket bandBracket (a polynomial in 1 + m, log H; see band_scale_sum).

noncomputable def TrilinearHT.Auto.bsOmega (D J1 m : ℕ) (Lh : ℝ) :

The master size Ω = (D + J₁ + 1) W^{D+J₁+1}, W = 2 + m + Lh, dominating all the logarithmic budgets of the band scale sum.

Equations
Instances For
    theorem TrilinearHT.Auto.bsOmega_ge_W {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
    2 + ↑m + Lh ≤ bsOmega D J1 m Lh
    theorem TrilinearHT.Auto.one_le_bsOmega {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
    1 ≤ bsOmega D J1 m Lh
    theorem TrilinearHT.Auto.bsOmega_ge_lE {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
    ↑D * bsX m Lh ^ D ≤ bsOmega D J1 m Lh
    theorem TrilinearHT.Auto.bsOmega_ge_lE1 {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
    ↑J1 * bsX m Lh ^ J1 ≤ bsOmega D J1 m Lh
    theorem TrilinearHT.Auto.log_bsE (D m : ℕ) (Lh : ℝ) :
    Real.log (bsE D m Lh) = ↑D * bsX m Lh ^ D
    theorem TrilinearHT.Auto.log_two_bsB1_le {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
    Real.log (2 * bsB1 D m Lh) ≤ 3 * bsOmega D J1 m Lh
    theorem TrilinearHT.Auto.log_two_bsE_div_bsEps_le {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
    Real.log (2 * bsE D m Lh / bsEps D m Lh) ≤ 11 * bsOmega D J1 m Lh
    noncomputable def TrilinearHT.Auto.bsLConst :

    A uniform numeric constant bounding log(128π (3 + 8 C_ζ)).

    Equations
    Instances For
      theorem TrilinearHT.Auto.log_two_bsL2_div_bsEps_le {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) :
      Real.log (2 * bsL2 D m Lh / bsEps D m Lh) ≤ (bsLConst + 4) * bsOmega D J1 m Lh
      theorem TrilinearHT.Auto.bsOmega_ge_d {D J1 m : ℕ} {Lh : ℝ} {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
      ↑d ≤ bsOmega D J1 m Lh
      theorem TrilinearHT.Auto.log_le_two_of_le_six {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 6) :
      noncomputable def TrilinearHT.Auto.bsCCT (κ : LocalKernelClass) :

      The explicit constant controlling log(1 + C_T).

      Equations
      Instances For
        theorem TrilinearHT.Auto.bsCT_add_one_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        bsCT κ d D m Lh + 1 ≤ bsCCT κ * bsOmega D J1 m Lh ^ 9 * bsE D m Lh
        theorem TrilinearHT.Auto.log_le_of_le_exp_one_pow {x : ℝ} {n : ℕ} (hx0 : 0 < x) (hx : x ≤ 2.7 ^ n) :
        Real.log x ≤ ↑n
        theorem TrilinearHT.Auto.bsK0_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        ↑(bsK0 κ d D J1 m Lh) ≤ (2 * bsCCT κ + 41) * bsOmega D J1 m Lh ^ 9
        theorem TrilinearHT.Auto.log_bsBσ_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        Real.log (bsBσ κ d D J1 m Lh) ≤ (2 * bsCCT κ + 42) * bsOmega D J1 m Lh ^ 9
        theorem TrilinearHT.Auto.log_two_bsB2_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        Real.log (2 * bsB2 κ d D J1 m Lh) ≤ (8 * bsCCT κ + 171) * bsOmega D J1 m Lh ^ 9
        theorem TrilinearHT.Auto.log_two_bsBc_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        Real.log (2 * bsBc κ d D J1 m Lh) ≤ (4 * bsCCT κ + 88) * bsOmega D J1 m Lh ^ 9
        theorem TrilinearHT.Auto.bsOmega_pow_mono {D J1 m : ℕ} {Lh : ℝ} (hLh : 0 ≤ Lh) {a b : ℕ} (hab : a ≤ b) :
        bsOmega D J1 m Lh ^ a ≤ bsOmega D J1 m Lh ^ b
        theorem TrilinearHT.Auto.bracket_d1_le {D J1 m : ℕ} {Lh : ℝ} {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        (↑d + 1) ^ 4 ≤ 16 * bsOmega D J1 m Lh ^ 4
        theorem TrilinearHT.Auto.bracket_dd_le {D J1 m : ℕ} {Lh : ℝ} {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        (↑(d * d + 1) + 1) ^ 4 ≤ 81 * bsOmega D J1 m Lh ^ 8
        theorem TrilinearHT.Auto.bracket_t1_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        32 * (↑d + 1) ^ 4 * (Real.log (2 * bsB2 κ d D J1 m Lh) + Real.log (2 * bsL2 D m Lh / bsEps D m Lh)) ≤ 512 * (8 * bsCCT κ + 175 + bsLConst) * bsOmega D J1 m Lh ^ 13
        theorem TrilinearHT.Auto.bracket_t2_le {D J1 m : ℕ} {Lh : ℝ} {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        32 * (↑(d * d + 1) + 1) ^ 4 * (Real.log (2 * bsB1 D m Lh) + Real.log (2 * bsE D m Lh / bsEps D m Lh)) ≤ 36288 * bsOmega D J1 m Lh ^ 13
        theorem TrilinearHT.Auto.bracket_t3_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        clumpMultiplicity (d + 1) (bsBc κ d D J1 m Lh) ≤ 24 * (2 * Real.pi) ^ 2 * 32768 * (4 * bsCCT κ + 90) * bsOmega D J1 m Lh ^ 13
        theorem TrilinearHT.Auto.bracket_t4_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
        (↑(d * d + 1) + 1) ^ 4 * Real.log (2 * bsB1 D m Lh) + (↑d + 1) ^ 4 * Real.log (2 * bsB2 κ d D J1 m Lh) ≤ (243 + 16 * (8 * bsCCT κ + 171)) * bsOmega D J1 m Lh ^ 13
        noncomputable def TrilinearHT.Auto.bsKfin (κ : LocalKernelClass) :

        The explicit constant of the final polynomial bound of the band bracket.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          theorem TrilinearHT.Auto.bandBracket_le {D J1 m : ℕ} {Lh : ℝ} (κ : LocalKernelClass) {d : ℕ} (hLh : 0 ≤ Lh) (hdL : ↑d ≤ Lh) :
          bandBracket κ d D J1 m Lh ≤ bsKfin κ * bsOmega D J1 m Lh ^ 13
          theorem TrilinearHT.Auto.bandBracket_poly (κ : LocalKernelClass) (D J1 : ℕ) :
          ∃ (C : ℕ), ∀ (d m : ℕ) (Lh : ℝ), 0 ≤ Lh → ↑d ≤ Lh → bandBracket κ d D J1 m Lh ≤ ↑C * (2 + ↑m + Lh) ^ C

          The eq:band-scale-sum bracket is polynomial in W = 2 + m + log H.

          theorem TrilinearHT.Auto.band_scale_sum (c₀ : ℕ) (hc : 1 ≤ c₀) (κ : LocalKernelClass) :
          ∃ (C : ℕ), ∀ {d : ℕ} (H : ℝ) (A : QuadraticChartData d), 1 ≤ d → QuadraticChartComplexity c₀ H A → IsBoundedQuadraticChart A → ∀ (m : ℕ) (G : RealDyadicGrid) (J : ℤ × ℤ) (S : Finset (ℤ × ℤ)), (∀ I ∈ S, dyadicGridCell G I.1 I.2 ⊆ dyadicGridCell G J.1 J.2) → ∀ (w : ℤ × ℤ → ℝ × ℝ → ℂ), (∀ I ∈ S, IsAdmissibleLocalKernel κ (dyadicGridLeft G I.1 I.2) (dyadicGridLength G I.1) (w I)) → ∀ {a b : Fin 4}, a ≠ b → ∀ {ψa ψb : ℝ → ℂ}, Measurable ψa → Measurable ψb → (∀ (y : ℝ), ‖ψa y‖ ≤ 1) → (∀ (y : ℝ), ‖ψb y‖ ≤ 1) → ∀ {Fa Fb : ℝ → ℂ} {za zb : ℤ × ℤ → ℝ → ℂ} {Ka Kb : ℝ}, 0 ≤ Ka → 0 ≤ Kb → IsAdmissibleOpponent G J Fa za Ka → IsAdmissibleOpponent G J Fb zb Kb → HasDepthEnergy G J Fa za Ka → HasDepthEnergy G J Fb zb Kb → (∀ (I : ℤ × ℤ), Measurable (za I)) → (∀ (I : ℤ × ℤ), Measurable (zb I)) → (∀ (I : ℤ × ℤ), MeasureTheory.MemLp (za I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) → (∀ (I : ℤ × ℤ), MeasureTheory.MemLp (zb I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) → (∀ I ∈ S, InScaleBand (quadraticChartAtom A) m (dyadicGridLength G I.1)) → ∑ I ∈ S, dyadicGridLength G I.1 * ‖separatedLocalForm (dyadicGridLength G I.1) (w I) (quadraticChartAtom A) a b (fun (y : ℝ) => ψa y * za I y) fun (y : ℝ) => ψb y * zb I y‖ ≤ Real.exp (-↑m) * (↑C * (2 + ↑m + Real.log H) ^ C) * Ka * Kb * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fa y‖ ^ 2) * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fb y‖ ^ 2)

          Blueprint lem:predictors, eq:band-scale-sum: for one separated time factor Q = quadraticChartAtom A, a bounded chart of complexity H (fixed Gevrey order c₀), and admissible opponents with transfer constants K_a, K_b, the absolute length-weighted sum over the cells of the m-th Fourier-supremum band e^{-m-1} < A_{|I|} ≤ e^{-m} is at most e^{-m} C (2 + m + log H)^C K_a K_b ‖1_J F_a‖₂ ‖1_J F_b‖₂, with C depending only on the Gevrey order and the kernel class.

          theorem TrilinearHT.Auto.separatedLocalForm_phase_distribute (r : ℝ) (w : ℝ × ℝ → ℂ) (lam γ : ℝ) {a b : Fin 4} (hab : a ≠ b) (Fa Fb : ℝ → ℂ) :
          separatedLocalForm r w (quadPhase lam γ) a b Fa Fb = separatedLocalForm r w (fun (t : ℝ) => ↑(Real.fourierChar (lam * t ^ 2))) a b (fun (y : ℝ) => ↑(Real.fourierChar (-(γ / (↑↑b - ↑↑a) * y))) * Fa y) fun (y : ℝ) => ↑(Real.fourierChar (γ / (↑↑b - ↑↑a) * y)) * Fb y

          Blueprint lem:predictors, proof line 1543 ("distribute each e(γt) between the two remaining slots"): on the progression t = (y_b - y_a)/(b - a).

          noncomputable def TrilinearHT.Auto.bandSup (Q : ℝ → ℂ) (r : ℝ) :

          The Fourier-supremum A_r = sup_ξ |∫ Q(ru) ζ(u) e(-ξu) du| of a time factor.

          Equations
          Instances For
            theorem TrilinearHT.Auto.bandAmplitude_le_of_bound {Q : ℝ → ℂ} {c : ℝ} (hQ : ∀ (t : ℝ), ‖Q t‖ ≤ c) (r ξ : ℝ) :
            bandAmplitude Q r ξ ≤ 4 * c
            theorem TrilinearHT.Auto.bandAmplitude_bddAbove {Q : ℝ → ℂ} {c : ℝ} (hQ : ∀ (t : ℝ), ‖Q t‖ ≤ c) (r : ℝ) :
            theorem TrilinearHT.Auto.bandAmplitude_le_bandSup {Q : ℝ → ℂ} {c : ℝ} (hQ : ∀ (t : ℝ), ‖Q t‖ ≤ c) (r ξ : ℝ) :
            theorem TrilinearHT.Auto.bandSup_le {Q : ℝ → ℂ} {c : ℝ} (hQ : ∀ (t : ℝ), ‖Q t‖ ≤ c) (r : ℝ) :
            bandSup Q r ≤ 4 * c
            theorem TrilinearHT.Auto.inScaleBand_of_bandSup {Q : ℝ → ℂ} {c : ℝ} (hQ : ∀ (t : ℝ), ‖Q t‖ ≤ c) {r : ℝ} (hpos : 0 < bandSup Q r) (hle : bandSup Q r ≤ 1) :

            A positive band supremum at most one lies in exactly one band e^{-m-1} < A_r ≤ e^{-m}.

            theorem TrilinearHT.Auto.separatedLocalForm_eq_zero_of_bandSup {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) {a b : Fin 4} (hab : a ≠ b) {Q : ℝ → ℂ} (hQm : Measurable Q) (hQ1 : ∀ (t : ℝ), ‖Q t‖ ≤ 1) (h0 : bandSup Q r = 0) {Fa Fb : ℝ → ℂ} (hFam : Measurable Fa) (hFbm : Measurable Fb) (hFa : MeasureTheory.MemLp Fa 2 (MeasureTheory.volume.restrict (Set.Ico a₀ (a₀ + r)))) (hFb : MeasureTheory.MemLp Fb 2 (MeasureTheory.volume.restrict (Set.Ico a₀ (a₀ + r)))) :
            separatedLocalForm r w Q a b Fa Fb = 0

            The separated form vanishes at scales whose band supremum vanishes (blueprint lem:predictors, line 1495: "the term vanishes when A_{|I|} = 0").

            theorem TrilinearHT.Auto.summable_band_series (C : ℕ) :
            Summable fun (m : ℕ) => (1 + ↑m) ^ C * Real.exp (-↑m / 2)
            noncomputable def TrilinearHT.Auto.bandSeriesConst (C : ℕ) :

            The constant Σ_m (1 + m)^C e^{-m/2} for summing band estimates.

            Equations
            Instances For
              theorem TrilinearHT.Auto.band_series_term_le (C m M₀ : ℕ) (hm : M₀ ≤ m) {L : ℝ} (hL : 0 ≤ L) :
              Real.exp (-↑m) * (2 + ↑m + L) ^ C ≤ Real.exp (-↑M₀ / 2) * (2 + L) ^ C * ((1 + ↑m) ^ C * Real.exp (-↑m / 2))
              theorem TrilinearHT.Auto.band_sum_le (C M₀ : ℕ) (Ms : Finset ℕ) (hMs : ∀ m ∈ Ms, M₀ ≤ m) {L : ℝ} (hL : 0 ≤ L) :
              ∑ m ∈ Ms, Real.exp (-↑m) * (2 + ↑m + L) ^ C ≤ Real.exp (-↑M₀ / 2) * (2 + L) ^ C * bandSeriesConst C

              Finite sums of band estimates above a threshold.

              theorem TrilinearHT.Auto.chart_band_range_scale_sum (c₀ : ℕ) (hc : 1 ≤ c₀) (κ : LocalKernelClass) :
              ∃ (C : ℕ), ∀ {d : ℕ} (H : ℝ) (A : QuadraticChartData d), 1 ≤ d → QuadraticChartComplexity c₀ H A → IsBoundedQuadraticChart A → ∀ (M₀ : ℕ) (G : RealDyadicGrid) (J : ℤ × ℤ) (S : Finset (ℤ × ℤ)), (∀ I ∈ S, dyadicGridCell G I.1 I.2 ⊆ dyadicGridCell G J.1 J.2) → ∀ (w : ℤ × ℤ → ℝ × ℝ → ℂ), (∀ I ∈ S, IsAdmissibleLocalKernel κ (dyadicGridLeft G I.1 I.2) (dyadicGridLength G I.1) (w I)) → ∀ {a b : Fin 4}, a ≠ b → ∀ {ψa ψb : ℝ → ℂ}, Measurable ψa → Measurable ψb → (∀ (y : ℝ), ‖ψa y‖ ≤ 1) → (∀ (y : ℝ), ‖ψb y‖ ≤ 1) → ∀ {Fa Fb : ℝ → ℂ} {za zb : ℤ × ℤ → ℝ → ℂ} {Ka Kb : ℝ}, 0 ≤ Ka → 0 ≤ Kb → IsAdmissibleOpponent G J Fa za Ka → IsAdmissibleOpponent G J Fb zb Kb → HasDepthEnergy G J Fa za Ka → HasDepthEnergy G J Fb zb Kb → (∀ (I : ℤ × ℤ), Measurable (za I)) → (∀ (I : ℤ × ℤ), Measurable (zb I)) → (∀ (I : ℤ × ℤ), MeasureTheory.MemLp (za I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) → (∀ (I : ℤ × ℤ), MeasureTheory.MemLp (zb I) 2 (MeasureTheory.volume.restrict (dyadicGridCell G I.1 I.2))) → (∀ I ∈ S, bandSup (quadraticChartAtom (scaleQuadraticChartAmplitude (1 / 4) A)) (dyadicGridLength G I.1) ≤ Real.exp (-↑M₀)) → ∑ I ∈ S, dyadicGridLength G I.1 * ‖separatedLocalForm (dyadicGridLength G I.1) (w I) (quadraticChartAtom A) a b (fun (y : ℝ) => ψa y * za I y) fun (y : ℝ) => ψb y * zb I y‖ ≤ Real.exp (-↑M₀ / 2) * (↑C * (2 + Real.log H) ^ C) * Ka * Kb * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fa y‖ ^ 2) * √(∫ (y : ℝ) in dyadicGridCell G J.1 J.2, ‖Fb y‖ ^ 2)

              Blueprint lem:predictors, proof lines 1544-1546: the band scale sums of one separated time factor summed over all bands m ≥ M₀ of the normalized factor Q/4.

              noncomputable def TrilinearHT.Auto.tailAlpha (d : ℕ) (E : ℝ) :

              The tail multiplicity growth constant at coefficient budget E.

              Equations
              Instances For
                noncomputable def TrilinearHT.Auto.tailLam (d : ℕ) (E : ℝ) :

                The quadratic total at coefficient budget E.

                Equations
                Instances For
                  noncomputable def TrilinearHT.Auto.tailCT (κ : LocalKernelClass) (d : ℕ) (E : ℝ) :

                  The catalog tail constant at coefficient budget E.

                  Equations
                  Instances For
                    theorem TrilinearHT.Auto.tailCT_nonneg (κ : LocalKernelClass) (d : ℕ) {E : ℝ} (hE : 1 ≤ E) :
                    0 ≤ tailCT κ d E
                    theorem TrilinearHT.Auto.clumpMultiplicity_tail_le' (d : ℕ) {E u : ℝ} (hE : 1 ≤ E) (hu : 1 ≤ u) :
                    clumpMultiplicity (d + 1) (6 * (E * u) ^ 2 + 6) ≤ tailAlpha d E * u