File size: 8,678 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
import OAI.Analysis.Fourier.SquareFunction.CombiningScales
import OAI.Analysis.Fourier.SquareFunction.LogWindow

open OAI.Analysis.Fourier.Wave

/-! The geometric and logarithmic constants in combining dilates. -/

namespace OAI.Analysis.Fourier.SquareFunction

open scoped ENNReal
open _root_.MeasureTheory Set

theorem scaleKernelConstant_small {n : ℕ} {q r C δ : ℝ} {L : ℤ}
    (hC : 0 ≤ C) (hδ : 0 < δ) (hL : (2 : ℝ) ^ (-L) ≤ δ ^ (q + 1)) :
    scaleKernelConstant n q r (C * δ ^ (-q)) L ≤
      scaleKernelConstant n q r 1 0 * (C * δ) := by
  have hprod : δ ^ (-q) * δ ^ (q + 1) = δ := by
    rw [← Real.rpow_add hδ, show -q + (q + 1) = 1 by ring, Real.rpow_one]
  have hs : C * δ ^ (-q) * (2 : ℝ) ^ (-L) ≤ C * δ := by
    calc
      _ ≤ C * δ ^ (-q) * δ ^ (q + 1) := mul_le_mul_of_nonneg_left hL (by positivity)
      _ = _ := by rw [mul_assoc, hprod]
  calc
    _ = (Real.sqrt (4 / 3) * 2 ^ q * (polynomialKernelMass n r).toReal) *
        (C * δ ^ (-q) * (2 : ℝ) ^ (-L)) := by unfold scaleKernelConstant; ring
    _ ≤ (Real.sqrt (4 / 3) * 2 ^ q * (polynomialKernelMass n r).toReal) * (C * δ) :=
      mul_le_mul_of_nonneg_left hs (by positivity)
    _ = _ := by simp only [scaleKernelConstant, neg_zero, zpow_zero, mul_one, one_mul]; ring

theorem ennreal_four_linear_le (a b c d x y z : ℝ≥0∞) :
    a * x + b * y + c * z + d * x ≤ (a + b + c + d) * (x + y + z) := by
  have hx : x ≤ x + y + z := (le_add_right le_rfl).trans (le_add_right le_rfl)
  have hy : y ≤ x + y + z := (le_add_left le_rfl).trans (le_add_right le_rfl)
  have hz : z ≤ x + y + z := le_add_left le_rfl
  calc
    _ ≤ a * (x + y + z) + b * (x + y + z) + c * (x + y + z) + d * (x + y + z) :=
      add_le_add (add_le_add (add_le_add (mul_le_mul_right hx _) (mul_le_mul_right hy _))
        (mul_le_mul_right hz _)) (mul_le_mul_right hx _)
    _ = _ := by ring

noncomputable def combiningLogConstant (n : ℕ) (p q : ℝ) : ℝ≥0∞ :=
  sharpLpConstant n p *
    (ENNReal.ofReal (scaleKernelConstant n q q 1 0) * maximalLpConstant n p +
      (cubeBallRatio n ^ (1 / 2 : ℝ) *
        ENNReal.ofReal (2 * (q + 1) / Real.log 2 + 4) ^ (1 / 2 - 1 / p)) * squareMaximalLpConstant n p +
      cubeBallRatio n ^ (1 / 2 : ℝ) * squareMaximalLpConstant n p +
      ENNReal.ofReal (scaleKernelConstant n q (q - 1) 1 0) * maximalLpConstant n p)

theorem convolutionEnvelopeConstant_log_bound {n : ℕ} {p q C δ : ℝ} {L : ℤ}
    (hp : 2 < p) (hq : 0 ≤ q) (hC : 0 ≤ C) (hδ : 0 < δ) (_ : δ ≤ 1)
    (hL : (2 : ℝ) ^ (-L) ≤ δ ^ (q + 1))
    (hcard : ((2 * L).toNat : ℝ) ≤
      (2 * (q + 1) / Real.log 2 + 4) * (1 + Real.log (1 / δ)))
    (B₂ Bₚ : ℝ≥0∞) :
    sharpLpConstant n p * convolutionEnvelopeConstant n p q (C * δ ^ (-q)) B₂ Bₚ L ≤
      combiningLogConstant n p q *
        (ENNReal.ofReal (C * δ) +
          ENNReal.ofReal (1 + Real.log (1 / δ)) ^ (1 / 2 - 1 / p) * Bₚ + B₂) := by
  have hθ : 0 ≤ 1 / 2 - 1 / p := by
    have hdiv := one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 2) hp.le
    linarith
  have hk : 0 ≤ 2 * (q + 1) / Real.log 2 + 4 := by
    have : 0 < Real.log 2 := Real.log_pos (by norm_num)
    positivity
  have hc : ((2 * L).toNat : ℝ≥0∞) ^ (1 / 2 - 1 / p) ≤
      ENNReal.ofReal (2 * (q + 1) / Real.log 2 + 4) ^ (1 / 2 - 1 / p) *
        ENNReal.ofReal (1 + Real.log (1 / δ)) ^ (1 / 2 - 1 / p) := by
    have hh := ENNReal.ofReal_le_ofReal hcard
    rw [ENNReal.ofReal_natCast, ENNReal.ofReal_mul hk] at hh
    exact (ENNReal.rpow_le_rpow hh hθ).trans_eq (ENNReal.mul_rpow_of_nonneg _ _ hθ)
  have hlo := ENNReal.ofReal_le_ofReal (scaleKernelConstant_small (n := n) (r := q) hC hδ hL)
  have hhi := ENNReal.ofReal_le_ofReal (scaleKernelConstant_small (n := n) (r := q - 1) hC hδ hL)
  rw [ENNReal.ofReal_mul (scaleKernelConstant_nonneg (by norm_num))] at hlo hhi
  apply le_trans (mul_le_mul_right (show convolutionEnvelopeConstant n p q (C * δ ^ (-q)) B₂ Bₚ L ≤
    (ENNReal.ofReal (scaleKernelConstant n q q 1 0) * maximalLpConstant n p) * ENNReal.ofReal (C * δ) +
      ((cubeBallRatio n ^ (1 / 2 : ℝ) * ENNReal.ofReal (2 * (q + 1) / Real.log 2 + 4) ^
          (1 / 2 - 1 / p)) * squareMaximalLpConstant n p) *
        (ENNReal.ofReal (1 + Real.log (1 / δ)) ^ (1 / 2 - 1 / p) * Bₚ) +
      (cubeBallRatio n ^ (1 / 2 : ℝ) * squareMaximalLpConstant n p) * B₂ +
      (ENNReal.ofReal (scaleKernelConstant n q (q - 1) 1 0) * maximalLpConstant n p) * ENNReal.ofReal (C * δ) from ?_) _)
  · unfold combiningLogConstant
    conv_rhs => rw [mul_assoc]
    exact mul_le_mul_right (ennreal_four_linear_le _ _ _ _ _ _ _) _
  · unfold convolutionEnvelopeConstant
    apply add_le_add
    · apply add_le_add
      · apply add_le_add
        · exact (mul_le_mul_left hlo _).trans_eq (by ring)
        · exact (mul_le_mul_left (mul_le_mul_right hc _) _).trans_eq (by ring)
      · apply le_of_eq
        ring
    · exact (mul_le_mul_left hhi _).trans_eq (by ring)

theorem combiningLogConstant_ne_top {n : ℕ} {p q : ℝ} (hp : 2 < p) :
    combiningLogConstant n p q ≠ ∞ := by
  have hp0 : 0 < p := by linarith
  have hθ : 0 ≤ 1 / 2 - 1 / p := by
    have hdiv := one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 2) hp.le
    linarith
  have hm : maximalLpConstant n p ≠ ∞ := ENNReal.mul_ne_top (by norm_num)
    (ENNReal.rpow_ne_top_of_nonneg (by positivity) ENNReal.ofReal_ne_top)
  have hs : squareMaximalLpConstant n p ≠ ∞ := ENNReal.rpow_ne_top_of_nonneg (by positivity)
    (ENNReal.mul_ne_top (ENNReal.rpow_ne_top_of_nonneg (by positivity) (by norm_num)) ENNReal.ofReal_ne_top)
  have hd : cubeBallRatio n ^ (1 / 2 : ℝ) ≠ ∞ :=
    ENNReal.rpow_ne_top_of_nonneg (by norm_num) (cubeBallRatio_lt_top n).ne
  have hk : ENNReal.ofReal (2 * (q + 1) / Real.log 2 + 4) ^ (1 / 2 - 1 / p) ≠ ∞ :=
    ENNReal.rpow_ne_top_of_nonneg hθ ENNReal.ofReal_ne_top
  have ht : sharpLpConstant n p ≠ ∞ := ENNReal.mul_ne_top (by norm_num)
    (ENNReal.mul_ne_top (ENNReal.rpow_ne_top_of_nonneg (by positivity) ENNReal.ofReal_ne_top) ENNReal.ofReal_ne_top)
  exact ENNReal.mul_ne_top ht (ENNReal.add_ne_top.mpr ⟨ENNReal.add_ne_top.mpr
    ⟨ENNReal.add_ne_top.mpr ⟨ENNReal.mul_ne_top ENNReal.ofReal_ne_top hm,
      ENNReal.mul_ne_top (ENNReal.mul_ne_top hd hk) hs⟩, ENNReal.mul_ne_top hd hs⟩,
    ENNReal.mul_ne_top ENNReal.ofReal_ne_top hm⟩)

/-- The logarithmic combining-dilates estimate for a finite family of
dyadically scaled kernels. The constant depends only on dimension, the
Lebesgue exponent and the decay exponent; in particular not on `δ` or the
number of scales. -/
theorem combining_dyadic_kernels {n : ℕ} [NeZero n] {H : Type*}
    [NormedAddCommGroup H] [NormedSpace ℂ H] [CompleteSpace H]
    [MeasurableSpace H] [BorelSpace H] [SecondCountableTopology H]
    (s : Finset ℤ) (K : s → Space n → H) (f : s → Space n → ℂ)
    {p q C δ : ℝ} (hp : 2 < p) (hq : (n : ℝ) + 1 < q) (hC : 0 ≤ C)
    (hδ : 0 < δ) (hδ1 : δ ≤ 1)
    (hKd : ∀ i, Differentiable ℝ (K i))
    (hK : ∀ i u, ‖K i u‖ ≤ (C * δ ^ (-q)) * ((2 : ℝ) ^ i.val) ^ n *
      ((2 : ℝ) ^ i.val * ‖u‖ + 1) ^ (-q))
    (hK' : ∀ i u, ‖fderiv ℝ (K i) u‖ ≤ (C * δ ^ (-q)) *
      (((2 : ℝ) ^ i.val) ^ n * (2 : ℝ) ^ i.val) * ((2 : ℝ) ^ i.val * ‖u‖ + 1) ^ (-q))
    (hfm : ∀ i, Measurable (f i)) (hfi : ∀ i, Integrable (f i))
    (hfb : ∀ i, BddAbove (range fun x => ‖f i x‖))
    (hf2 : ∀ i, MemLp (f i) 2 volume) {B₂ Bₚ : ℝ≥0∞} (hB₂ : B₂ ≠ ∞)
    (h2 : ∀ i (g : Space n → ℂ), Integrable g → MemLp g 2 volume →
      eLpNorm (convolveKernel (K i) g) 2 volume ≤ B₂ * eLpNorm g 2 volume)
    (hBₚ : ∀ i, eLpNorm (convolveKernel (K i) (f i)) (ENNReal.ofReal p) volume ≤
      Bₚ * eLpNorm (f i) (ENNReal.ofReal p) volume) :
    eLpNorm (fun x => vectorNorm (fun i => convolveKernel (K i) (f i) x))
      (ENNReal.ofReal p) volume ≤
      (combiningLogConstant n p q *
        (ENNReal.ofReal (C * δ) + ENNReal.ofReal (1 + Real.log (1 / δ)) ^
          (1 / 2 - 1 / p) * Bₚ + B₂)) *
        eLpNorm (fun x => vectorNorm (fun i => f i x)) (ENNReal.ofReal p) volume := by
  have hq0 : 0 ≤ q := by linarith [Nat.cast_nonneg (α := ℝ) n]
  obtain ⟨L, hL, hpow, hcard⟩ := exists_logarithmic_window hq0 hδ hδ1
  have h := combining_scale_family s K f hp hq (by positivity : 0 ≤ C * δ ^ (-q))
    hKd hK hK' hfm hfi hfb hf2 hB₂ h2 hBₚ hL
  exact h.trans (mul_le_mul_left
    (convolutionEnvelopeConstant_log_bound hp hq0 hC hδ hδ1 hpow hcard B₂ Bₚ) _)

end OAI.Analysis.Fourier.SquareFunction