Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec163SummingUpdateLevels.NormalizedAbsorptionOfActiveFinal

Trilinear Hilbert transform: normalizedAbsorption_of_activeFinal #

theorem TrilinearHT.Auto.normalizedAbsorption_of_activeFinal (κ : LocalKernelClass) (hAF : ActiveFinal κ) :
∃ (q : ℝ), 2 < q ∧ q < 3 ∧ ∀ (c : ℝ), 0 < c → ∃ (A : ℝ), 0 ≤ A ∧ ∀ (N : ℕ), NormalizedAbsorption κ q N A c

Blueprint prop:normalized (lines 2827-2904) from eq:active-final: the base reduction (activeCellReduction, every level), the depth-independent initial levels (setups_total_le), the active-final bound for the later levels, the level sums (update_levels_sum) and the cutoff limit (levels_cutoff_sum) give eq:normalized with an arbitrarily small coefficient of C_N.

theorem TrilinearHT.Auto.uniform_of_activeFinal (hAF : ∀ (κ : LocalKernelClass), ActiveFinal κ) (κ : LocalKernelClass) :
∃ (q : ℝ), 2 ≤ q ∧ q < 3 ∧ ∃ (Cst : ℝ), ∀ (N : ℕ), finiteDepthConstant κ q N ≤ Cst

Blueprint thm:uniform-local from eq:active-final: every admissible class has q ∈ (2, 3) with sup_N C_N(q) < ∞.

theorem TrilinearHT.Auto.tht_main_of_activeFinal (hAF : ∀ (κ : LocalKernelClass), ActiveFinal κ) :
∃ (C : ℝ), 0 ≤ C ∧ (∀ (f₁ f₂ f₃ : SchwartzMap ℝ ℂ), (∀ (x : ℝ), Filter.Tendsto (truncatedTransform ![⇑f₁, ⇑f₂, ⇑f₃] x) (nhdsWithin 0 (Set.Ioi 0)) (nhds (T ![⇑f₁, ⇑f₂, ⇑f₃] x))) ∧ MeasureTheory.MemLp (T ![⇑f₁, ⇑f₂, ⇑f₃]) 1 MeasureTheory.volume ∧ ∫⁻ (x : ℝ), ‖T ![⇑f₁, ⇑f₂, ⇑f₃] x‖ₑ ≤ ENNReal.ofReal C * (MeasureTheory.eLpNorm (⇑f₁) 3 MeasureTheory.volume * MeasureTheory.eLpNorm (⇑f₂) 3 MeasureTheory.volume * MeasureTheory.eLpNorm (⇑f₃) 3 MeasureTheory.volume)) ∧ ∃ (T' : ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume) →L[ℂ] ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume) →L[ℂ] ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume) →L[ℂ] ↥(MeasureTheory.Lp ℂ 1 MeasureTheory.volume)), (∀ (f₁ f₂ f₃ : SchwartzMap ℝ ℂ), ↑↑(((T' (f₁.toLp 3 MeasureTheory.volume)) (f₂.toLp 3 MeasureTheory.volume)) (f₃.toLp 3 MeasureTheory.volume)) =ᵐ[MeasureTheory.volume] T ![⇑f₁, ⇑f₂, ⇑f₃]) ∧ (∀ (x y z : ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume)), ‖((T' x) y) z‖ ≤ C * ‖x‖ * ‖y‖ * ‖z‖) ∧ ∀ (S : ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume) →L[ℂ] ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume) →L[ℂ] ↥(MeasureTheory.Lp ℂ 3 MeasureTheory.volume) →L[ℂ] ↥(MeasureTheory.Lp ℂ 1 MeasureTheory.volume)), (∀ (f₁ f₂ f₃ : SchwartzMap ℝ ℂ), ↑↑(((S (f₁.toLp 3 MeasureTheory.volume)) (f₂.toLp 3 MeasureTheory.volume)) (f₃.toLp 3 MeasureTheory.volume)) =ᵐ[MeasureTheory.volume] T ![⇑f₁, ⇑f₂, ⇑f₃]) → S = T'

Blueprint thm:main from eq:active-final for every admissible class: the trilinear Hilbert transform principal value is bounded L³ × L³ × L³ → L¹ on Schwartz functions and extends uniquely.

Blueprint eq:active-min and eq:active-final (prop:base line 1622, prop:normalized lines 2885-2888) on the active cells: for every pattern with at least three basic arguments, the weighted minima over the cells active at δ_k = e^{-k^{C_b+2}} are at most C η₀^{c_*} (1 + C_N) |R|.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    theorem TrilinearHT.Auto.inactive_error_small (Cb C : ℕ) (Cr : ℝ) (hCr : 0 ≤ Cr) :
    ∃ (K : ℕ), ∀ (k : ℕ), K ≤ k → ∀ {H Dc Lc : ℝ}, 1 ≤ H → H ≤ Real.exp (↑k ^ Cb) → 0 ≤ Dc → Dc ≤ Real.exp (↑k ^ Cb) → 0 ≤ Lc → Lc ≤ Real.exp (↑k ^ Cb) → 3 * Lc ^ 3 * (Dc ^ 3 * (2 + Lc * Dc)) * (Real.exp (-↑k ^ (Cb + 2)) * Cr * (Real.log (chartTranslationBudget H) + Real.log (Real.exp (-↑k ^ (Cb + 2)))⁻¹ + 1) ^ C) ≤ Real.exp (-↑k)

    The inactive error of the base reduction at δ_k = e^{-k^{C_b+2}} is eventually at most e^{-k} per unit length, uniformly over setups with budgets exp(k^{C_b}).

    Blueprint prop:base (lines 1655-1660) with eq:active-final: the active-cell minima of the three patterns, the two-U term η₀ k^{C_b} |R| and the inactive error e^{-k} |R| give the active-final bound for the whole setup.

    theorem TrilinearHT.Auto.ActiveSetup.LevelProps.below {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (R' : ℤ × ℤ) {k Cb : ℕ} {η₀ : ℝ} (h : A.LevelProps k Cb η₀) (hR' : dyadicGridCell A.G R'.1 R'.2 ⊆ dyadicGridCell A.G A.R.1 A.R.2) :
    (A.below R').LevelProps k Cb η₀

    Blueprint prop:normalized, lines 2840-2842 ("at each such root restart on the original base summands ... their normalized sizes and rolling bounds hold there"): the level properties pass to the cells below every dyadic sub-root of the root.

    Blueprint eq:before-absorption on one root, after the choice of q, α, P (prop:normalized, lines 2838-2888): the retained-attempt estimate. For every active setup with the level properties there are pairwise disjoint exceptional roots of total length at most |R|/4 such that the active-cell minima of each pattern over the cells below no exceptional root are at most C η₀^{c_*} (1 + C_N) |R|.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      Blueprint prop:normalized, lines 2840-2843 and 2885-2888: restarting the retained-attempt estimate at the exceptional roots, whose root packing has factor 4/3, gives eq:active-final on all active cells.

      theorem TrilinearHT.Auto.ActiveSetup.z_slot_basic {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (p : Fin 3) (I : ℤ × ℤ) {l : Fin 4} (hl : l ≠ A.mslot p) :
      A.z p.castSucc I l = A.B l I

      The slots of a pattern other than its marked slot carry the basic arguments.

      theorem TrilinearHT.Auto.ActiveSetup.active_anc_card_le {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {δ : ℝ} (T : Finset (ℤ × ℤ)) (hT : ∀ I ∈ T, I ∈ A.cells ∧ A.active δ I) (I : ℤ × ℤ) :
      {I' ∈ T | dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G I'.1 I'.2}.card ≤ {I' ∈ A.cells | dyadicGridLeft A.G I.1 I.2 ∈ dyadicGridCell A.G I'.1 I'.2 ∧ A.active δ I'}.card

      The cells of an active family containing a cell are among the active cells through its left endpoint (the path multiplicity M_p of the localization).

      theorem TrilinearHT.Auto.active_mult_bound (κ : LocalKernelClass) (c₀ : ℕ) (hc : 1 ≤ c₀) (Cb : ℕ) :
      ∃ (C : ℝ), 0 < C ∧ ∀ (k : ℕ), 1 ≤ k → ∀ (B : ActiveSetup κ c₀) (η₀ : ℝ), B.LevelProps k Cb η₀ → ∀ (y : ℝ), ↑{I ∈ B.cells | y ∈ dyadicGridCell B.G I.1 I.2 ∧ B.active (Real.exp (-↑k ^ (Cb + 2))) I}.card ≤ Real.exp (C * ↑k ^ (3 * Cb + 2))

      Blueprint prop:base (line 1655) and line 2839 (the active path multiplicity for the attempt): at the activity threshold δ_k = e^{-k^{C_b+2}}, every point lies in at most exp(C k^{3 C_b + 2}) active cells of a setup with the level properties.

      The eventual growth bounds of the parameters (blueprint lines 2869-2888) #

      theorem TrilinearHT.Auto.eventually_qpoly_le_exp (a : ℝ) {C β θ : ℝ} (hC : 0 ≤ C) (hβ : 0 < β) (hθ : 0 < θ) :
      ∀ᶠ (x : ℝ) in Filter.atTop, x ^ a * Real.exp (C * (1 + Real.log (2 * x)) ^ 2) ≤ Real.exp (β * x ^ θ)

      Quasi-polynomial factors are eventually below every stretched exponential: for C ≥ 0 and β, θ > 0, eventually x^a e^{C (1 + log 2x)²} ≤ e^{β x^θ}.

      theorem TrilinearHT.Auto.eventually_nat_qpoly_le_exp (a : ℝ) {C β θ : ℝ} (hC : 0 ≤ C) (hβ : 0 < β) (hθ : 0 < θ) :
      ∀ᶠ (k : ℕ) in Filter.atTop, ↑k ^ a * Real.exp (C * (1 + Real.log (2 * ↑k)) ^ 2) ≤ Real.exp (β * ↑k ^ θ)

      The natural-number form of eventually_qpoly_le_exp.

      theorem TrilinearHT.Auto.eventually_nat_const_qpoly_le_exp (A a : ℝ) {C β θ : ℝ} (hA : 0 ≤ A) (hC : 0 ≤ C) (hβ : 0 < β) (hθ : 0 < θ) :
      ∀ᶠ (k : ℕ) in Filter.atTop, A * ↑k ^ a * Real.exp (C * (1 + Real.log (2 * ↑k)) ^ 2) ≤ Real.exp (β * ↑k ^ θ)

      eventually_nat_qpoly_le_exp with a constant factor A ≥ 0.

      theorem TrilinearHT.Auto.eventually_nat_poly_exp_le_exp (A a B : ℝ) {s t : ℕ} (hst : s < t) {β : ℝ} (hβ : 0 < β) :
      ∀ᶠ (k : ℕ) in Filter.atTop, A * ↑k ^ a * Real.exp (B * ↑k ^ s) ≤ Real.exp (β * ↑k ^ t)

      Polynomial and lower exponential factors are eventually below a higher exponential: for natural s < t, β > 0 and real A, a, B, eventually A k^a e^{B k^s} ≤ e^{β k^t}.

      theorem TrilinearHT.Auto.eventually_nat_pow_dom (A : ℝ) {a t : ℕ} (hat : a < t) :
      ∀ᶠ (k : ℕ) in Filter.atTop, A * ↑k ^ a ≤ ↑k ^ t

      Polynomial domination: for natural a < t, eventually A k^a ≤ k^t.

      theorem TrilinearHT.Auto.eventually_nat_add_pow_le (L : ℝ) {b : ℕ} (hb : 1 ≤ b) :
      ∀ᶠ (k : ℕ) in Filter.atTop, L + 2 * ↑k ^ b ≤ 3 * ↑k ^ b

      Eventually L + 2 k^b ≤ 3 k^b for b ≥ 1.

      Eventually M ≤ log k.

      theorem TrilinearHT.Auto.retained_numeric_poly {L₄ lW cH Ca : ℝ} {b m c₃ c C a₀ cc Dg : ℕ} (hL₄ : 0 ≤ L₄) (hlW : 0 ≤ lW) (hcH : 0 ≤ cH) (hCa : 0 < Ca) (hb : 1 ≤ b) (hbc : 30 * b < c) (hmc : m < c) (hc₃ : c₃ < a₀) (hfuel : 90 * b + 100 ≤ c) (hca : c < a₀) (hCa₀ : C < a₀) (hcc1 : a₀ * Dg < cc) (hcc2 : a₀ < cc) :
      ∀ᶠ (k : ℕ) in Filter.atTop, 6000 ^ 30 * (L₄ + 2 * ↑k ^ b) ^ 30 + 1 + 6 ≤ ↑k ^ c ∧ L₄ + 2 * ↑k ^ b + 3 ≤ ↑k ^ c ∧ 2 * (Real.log (4 * (6000 ^ 30 * (L₄ + 2 * ↑k ^ b) ^ 30 + 1)) / Real.log 2) + 2 ≤ ↑c * (Real.log ↑k + 1) ∧ cH + 2 * (lW + (L₄ + 2 * ↑k ^ b)) ≤ ↑k ^ c ∧ Real.exp (Ca * ↑k ^ m) + 1 ≤ Real.exp (↑k ^ c) ∧ 2 * Real.exp (L₄ + 2 * ↑k ^ b) ≤ Real.exp (↑k ^ c) ∧ Real.log 18 + 2 * (lW + (L₄ + 2 * ↑k ^ b)) ≤ ↑k ^ cc ∧ ↑Dg * (1 + (cH + 2 * (lW + (L₄ + 2 * ↑k ^ b))) + Real.log 6 + 3 * (L₄ + 2 * ↑k ^ b + ↑k ^ C + Ca * ↑k ^ m + 2) + ↑k ^ c₃ + 2 * (L₄ + 2 * ↑k ^ b + 3)) ^ Dg ≤ ↑k ^ cc ∧ ↑k ^ C + 2 * (L₄ + 2 * ↑k ^ b) ≤ ↑k ^ (cc + 1) ∧ Real.log 20 + (L₄ + 2 * ↑k ^ b + ↑k ^ C + Ca * ↑k ^ m + 2) ≤ ↑k ^ cc ∧ Real.log 2 + (L₄ + 2 * ↑k ^ b) ≤ ↑k ^ cc ∧ 20 * (6000 ^ 30 * (L₄ + 2 * ↑k ^ b) ^ 30 + 1) + 61 ≤ ↑k ^ cc ∧ lW + (L₄ + 2 * ↑k ^ b) + 1 ≤ ↑k ^ cc ∧ cH + 2 * (lW + (L₄ + 2 * ↑k ^ b)) ≤ ↑k ^ cc ∧ 96 * (4 * (6000 ^ 30 * (L₄ + 2 * ↑k ^ b) ^ 30 + 1)) ≤ ↑k ^ cc

      The polynomial standing bounds of the retained-attempt estimate at accuracy k, for the exponent Y = L₄ + 2 k^b of the height and column budget (blueprint lines 2853-2869: all degrees are absolute): the colour count, vertex bound, fuel, source height and counts are below k^c (attempt) and k^{cc} (leaf), and the curvature thresholds below k^{cc}.

      theorem TrilinearHT.Auto.mul_exp_neg_le {X t u : ℝ} (h : 4 * X * Real.exp u ≤ Real.exp t) :
      X * Real.exp (-t) ≤ Real.exp (-u) / 4

      If 4 X e^u ≤ e^t then X e^{-t} ≤ e^{-u}/4.