File size: 9,296 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
152
153
154
155
156
157
import OAI.Analysis.Fourier.SquareFunction.CubeOscillation
import OAI.Analysis.Fourier.SquareFunction.EnvelopeLp

open OAI.Analysis.Fourier.Wave

/-! Global bounds for the four actual envelopes in the combining-dilates
argument. -/

namespace OAI.Analysis.Fourier.SquareFunction

open _root_.MeasureTheory Set
open scoped ENNReal

noncomputable def maximalLpConstant (n : β„•) (p : ℝ) : ℝβ‰₯0∞ :=
  2 * ENNReal.ofReal ((5 : ℝ) ^ n * p / (p - 1)) ^ (1 / p)

noncomputable def squareMaximalLpConstant (n : β„•) (p : ℝ) : ℝβ‰₯0∞ :=
  ((2 : ℝβ‰₯0∞) ^ (p / 2) * ENNReal.ofReal ((5 : ℝ) ^ n * (p / 2) / (p / 2 - 1))) ^ (1 / p)

noncomputable def convolutionEnvelopeConstant (n : β„•) (p q C : ℝ)
    (Bβ‚‚ Bβ‚š : ℝβ‰₯0∞) (L : β„€) : ℝβ‰₯0∞ :=
  ENNReal.ofReal (scaleKernelConstant n q q C L) * maximalLpConstant n p +
    (cubeBallRatio n ^ (1 / 2 : ℝ) * ((2 * L).toNat : ℝβ‰₯0∞) ^ (1 / 2 - 1 / p)) *
      (squareMaximalLpConstant n p * Bβ‚š) +
    (Bβ‚‚ * cubeBallRatio n ^ (1 / 2 : ℝ)) * squareMaximalLpConstant n p +
    ENNReal.ofReal (scaleKernelConstant n q (q - 1) C L) * maximalLpConstant n p

theorem ofReal_norm_sq {H : Type*} [NormedAddCommGroup H] (v : H) :
    ENNReal.ofReal (β€–vβ€– ^ 2) = β€–vβ€–β‚‘ ^ (2 : ℝ) := by
  rw [ENNReal.ofReal_pow (norm_nonneg _), ofReal_norm, ENNReal.rpow_two]

theorem eLpNorm_vector_middle_envelope {n : β„•} {I H : Type*} [Fintype I]
    [NormedAddCommGroup H] [MeasurableSpace H] [BorelSpace H] [SecondCountableTopology H]
    (u : I β†’ Space n β†’ H) (f : I β†’ Space n β†’ β„‚)
    (hu : βˆ€ i, Measurable (u i)) (hf : βˆ€ i, Measurable (f i)) {p : ℝ} (hp : 2 < p)
    {B : ℝβ‰₯0∞} (hB : βˆ€ i, eLpNorm (u i) (ENNReal.ofReal p) volume ≀
      B * eLpNorm (f i) (ENNReal.ofReal p) volume) :
    eLpNorm (fun x => (βˆ‘ i, ballMaximal volume (fun y => β€–u i yβ€–β‚‘ ^ (2 : ℝ)) x ^
      (p / 2)) ^ (1 / p)) (ENNReal.ofReal p) volume ≀
      (squareMaximalLpConstant n p * B) *
        eLpNorm (fun x => vectorNorm (fun i => f i x)) (ENNReal.ofReal p) volume := by
  have h := eLpNorm_middle_envelope_le Finset.univ (fun i x => β€–u i xβ€–) (fun i x => β€–f i xβ€–)
    (fun i _ => (hu i).norm) (fun i _ x => norm_nonneg _) (fun i _ => (hf i).norm)
    (fun i _ x => norm_nonneg _) hp (B := B) (fun i _ => ?_)
  Β· simp only [ofReal_norm_sq, ofReal_norm, ← ofReal_vectorNorm] at h
    rwa [eLpNorm_ofReal_eq volume (measurable_vectorNorm f hf) (fun x => vectorNorm_nonneg _)] at h
  Β· rw [eLpNorm_norm _ (hu i).aestronglyMeasurable, eLpNorm_norm _ (hf i).aestronglyMeasurable]
    exact hB i

theorem measurable_convolutionEnvelope {n : β„•} {H : Type*}
    [NormedAddCommGroup H] [NormedSpace β„‚ H]
    (s : Finset β„€) (K : s β†’ Space n β†’ H) (f : s β†’ Space n β†’ β„‚)
    (p q C : ℝ) (B : ℝβ‰₯0∞) (L : β„€) :
    Measurable (convolutionEnvelope s K f p q C B L) := by
  have hm := measurable_ballMaximal volume (fun y => ENNReal.ofReal (vectorNorm (fun i => f i y)))
  have hmid : Measurable (fun z => (βˆ‘ i,
      ballMaximal volume (fun y => β€–convolveKernel (K i) (f i) yβ€–β‚‘ ^ (2 : ℝ)) z ^ (p / 2)) ^ (1 / p)) :=
    (Finset.measurable_sum _ (fun i _ => (measurable_ballMaximal volume _).pow_const _)).pow_const _
  have hhi : Measurable (fun z => B * (cubeBallRatio n *
      ballMaximal volume (fun y => βˆ‘ i, β€–f i yβ€–β‚‘ ^ (2 : ℝ)) z) ^ (1 / 2 : ℝ)) :=
    (((measurable_ballMaximal volume _).const_mul _).pow_const _).const_mul _
  exact (((hm.const_mul _).add (hmid.const_mul _)).add hhi).add (hm.const_mul _)

theorem eLpNorm_convolutionEnvelope_le {n : β„•} {H : Type*}
    [NormedAddCommGroup H] [NormedSpace β„‚ H]
    [MeasurableSpace H] [BorelSpace H] [SecondCountableTopology H]
    (s : Finset β„€) (K : s β†’ Space n β†’ H) (f : s β†’ Space n β†’ β„‚)
    (hu : βˆ€ i, Measurable (convolveKernel (K i) (f i))) (hf : βˆ€ i, Measurable (f i))
    {p : ℝ} (hp : 2 < p) (q C : ℝ) (Bβ‚‚ Bβ‚š : ℝβ‰₯0∞) (L : β„€)
    (hBβ‚š : βˆ€ i, eLpNorm (convolveKernel (K i) (f i)) (ENNReal.ofReal p) volume ≀
      Bβ‚š * eLpNorm (f i) (ENNReal.ofReal p) volume) :
    eLpNorm (convolutionEnvelope s K f p q C Bβ‚‚ L) (ENNReal.ofReal p) volume ≀
      convolutionEnvelopeConstant n p q C Bβ‚‚ Bβ‚š L *
        eLpNorm (fun x => vectorNorm (fun i => f i x)) (ENNReal.ofReal p) volume := by
  have hp0 : 0 < p := by linarith
  have hp1 : 1 ≀ ENNReal.ofReal p := by
    simpa only [ENNReal.ofReal_one] using ENNReal.ofReal_le_ofReal (show (1 : ℝ) ≀ p by linarith)
  let W := fun x => vectorNorm (fun i => f i x)
  let M := ballMaximal volume (fun y => ENNReal.ofReal (W y))
  let F := fun x => (βˆ‘ i, ballMaximal volume (fun y => β€–convolveKernel (K i) (f i) yβ€–β‚‘ ^ (2 : ℝ)) x ^
    (p / 2)) ^ (1 / p)
  let V := fun x => ballMaximal volume (fun y => ENNReal.ofReal ((W y) ^ 2)) x ^ (1 / 2 : ℝ)
  let A := ENNReal.ofReal (scaleKernelConstant n q q C L)
  let D := cubeBallRatio n ^ (1 / 2 : ℝ) * ((2 * L).toNat : ℝβ‰₯0∞) ^ (1 / 2 - 1 / p)
  let E := Bβ‚‚ * cubeBallRatio n ^ (1 / 2 : ℝ)
  let T := ENNReal.ofReal (scaleKernelConstant n q (q - 1) C L)
  have hW : Measurable W := measurable_vectorNorm f hf
  have hM : Measurable M := measurable_ballMaximal volume _
  have hF : Measurable F :=
    (Finset.measurable_sum _ (fun i _ => (measurable_ballMaximal volume _).pow_const _)).pow_const _
  have hV : Measurable V := (measurable_ballMaximal volume _).pow_const _
  have hMl := eLpNorm_euclidean_ballMaximal_le hW (fun x => vectorNorm_nonneg _) (by linarith : 1 < p)
  have hFl := eLpNorm_vector_middle_envelope (fun i => convolveKernel (K i) (f i)) f hu hf hp hBβ‚š
  have hVl := eLpNorm_square_maximal_le hW (fun x => vectorNorm_nonneg _) hp
  have hwβ‚‚ (y : Space n) : ENNReal.ofReal ((vectorNorm (fun i => f i y)) ^ 2) =
      βˆ‘ i, β€–f i yβ€–β‚‘ ^ (2 : ℝ) := by
    rw [ENNReal.ofReal_pow (vectorNorm_nonneg _), ← ENNReal.rpow_two, enorm_vectorNorm_sq]
  have he : convolutionEnvelope s K f p q C Bβ‚‚ L = fun x => A * M x + D * F x + E * V x + T * M x := by
    funext x
    dsimp only [convolutionEnvelope, A, M, D, F, E, V, T, W]
    simp_rw [hwβ‚‚]
    rw [ENNReal.mul_rpow_of_nonneg _ _ (by norm_num : (0 : ℝ) ≀ 1 / 2), mul_assoc]
    ac_rfl
  rw [he]
  apply (eLpNorm_ennreal_four_add_le volume _ _ _ _ hp1).trans
  rw [eLpNorm_ennreal_const_mul volume hM A hp0, eLpNorm_ennreal_const_mul volume hF D hp0,
    eLpNorm_ennreal_const_mul volume hV E hp0, eLpNorm_ennreal_const_mul volume hM T hp0]
  calc
    _ ≀ A * (maximalLpConstant n p * eLpNorm W (ENNReal.ofReal p) volume) +
        D * ((squareMaximalLpConstant n p * Bβ‚š) * eLpNorm W (ENNReal.ofReal p) volume) +
        E * (squareMaximalLpConstant n p * eLpNorm W (ENNReal.ofReal p) volume) +
        T * (maximalLpConstant n p * eLpNorm W (ENNReal.ofReal p) volume) := by
      exact add_le_add (add_le_add (add_le_add (mul_le_mul_right hMl _) (mul_le_mul_right hFl _))
        (mul_le_mul_right hVl _)) (mul_le_mul_right hMl _)
    _ = _ := by dsimp only [convolutionEnvelopeConstant, A, D, E, T, W]; ring

theorem convolutionEnvelope_ne_top {n : β„•} {H : Type*}
    [NormedAddCommGroup H] [NormedSpace β„‚ H]
    (s : Finset β„€) (K : s β†’ Space n β†’ H) (f : s β†’ Space n β†’ β„‚)
    (hfb : βˆ€ i, BddAbove (range fun x => β€–f i xβ€–))
    (hub : βˆ€ i, BddAbove (range fun x => β€–convolveKernel (K i) (f i) xβ€–))
    {p : ℝ} (hp : 2 < p) (q C : ℝ) {B : ℝβ‰₯0∞} (hB : B β‰  ∞) (L : β„€) (z : Space n) :
    convolutionEnvelope s K f p q C B L z β‰  ∞ := by
  have hp0 : 0 < p := by linarith
  have hm : ballMaximal volume (fun y => ENNReal.ofReal (vectorNorm (fun i => f i y))) z β‰  ∞ :=
    ballMaximal_ofReal_ne_top_of_bounded (bounded_vectorNorm f hfb) z
  have hmid : (βˆ‘ i, ballMaximal volume (fun y => β€–convolveKernel (K i) (f i) yβ€–β‚‘ ^ (2 : ℝ)) z ^
      (p / 2)) ^ (1 / p) β‰  ∞ := by
    apply ENNReal.rpow_ne_top_of_nonneg (by positivity)
    apply ENNReal.sum_ne_top.mpr
    intro i hi
    exact ENNReal.rpow_ne_top_of_nonneg (by positivity) (ballMaximal_enorm_sq_ne_top (hub i) z)
  have hWb : BddAbove (range fun y => β€–vectorNorm (fun i => f i y)β€–) := by
    simpa only [Real.norm_eq_abs, abs_of_nonneg (vectorNorm_nonneg _)] using bounded_vectorNorm f hfb
  have hmβ‚‚ : ballMaximal volume (fun y => βˆ‘ i, β€–f i yβ€–β‚‘ ^ (2 : ℝ)) z β‰  ∞ := by
    have h := ballMaximal_enorm_sq_ne_top hWb z
    simpa only [Real.enorm_eq_ofReal (vectorNorm_nonneg _), enorm_vectorNorm_sq] using h
  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
  unfold convolutionEnvelope
  apply ENNReal.add_ne_top.mpr
  constructor
  Β· apply ENNReal.add_ne_top.mpr
    constructor
    Β· apply ENNReal.add_ne_top.mpr
      constructor
      Β· exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top hm
      Β· exact ENNReal.mul_ne_top (ENNReal.mul_ne_top
          (ENNReal.rpow_ne_top_of_nonneg (by norm_num) (cubeBallRatio_lt_top n).ne)
          (ENNReal.rpow_ne_top_of_nonneg hΞΈ (by simp))) hmid
    Β· exact ENNReal.mul_ne_top hB (ENNReal.rpow_ne_top_of_nonneg (by norm_num)
        (ENNReal.mul_ne_top (cubeBallRatio_lt_top n).ne hmβ‚‚))
  Β· exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top hm

end OAI.Analysis.Fourier.SquareFunction