File size: 7,496 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
import OAI.Analysis.Fourier.SquareFunction.CubeVectors

open OAI.Analysis.Fourier.Wave

/-! The complete cube oscillation estimate in the combining-dilates lemma.
The hypotheses below are scalar operator bounds and pointwise bounds on the
actual kernels; there is no vector-valued or sharp-function hypothesis. -/

namespace OAI.Analysis.Fourier.SquareFunction

open _root_.MeasureTheory Set Metric
open scoped ENNReal

noncomputable def scaleKernelConstant (n : β„•) (q r C : ℝ) (L : β„€) : ℝ :=
  Real.sqrt (4 / 3) * (2 : ℝ) ^ (-L) * (C * 2 ^ q * (polynomialKernelMass n r).toReal)

theorem scaleKernelConstant_nonneg {n : β„•} {q r C : ℝ} {L : β„€} (hC : 0 ≀ C) :
    0 ≀ scaleKernelConstant n q r C L := by unfold scaleKernelConstant; positivity

noncomputable def 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 : β„€) (z : Space n) : ℝβ‰₯0∞ :=
  ENNReal.ofReal (scaleKernelConstant n q q C L) *
      ballMaximal volume (fun y => ENNReal.ofReal (vectorNorm (fun i => f i y))) z +
    (cubeBallRatio n ^ (1 / 2 : ℝ) * ((2 * L).toNat : ℝβ‰₯0∞) ^ (1 / 2 - 1 / p)) *
      (βˆ‘ i, ballMaximal volume (fun y => β€–convolveKernel (K i) (f i) yβ€–β‚‘ ^ (2 : ℝ)) z ^
        (p / 2)) ^ (1 / p) +
    B * (cubeBallRatio n * ballMaximal volume (fun y => βˆ‘ i, β€–f i yβ€–β‚‘ ^ (2 : ℝ)) z) ^
      (1 / 2 : ℝ) +
    ENNReal.ofReal (scaleKernelConstant n q (q - 1) C L) *
      ballMaximal volume (fun y => ENNReal.ofReal (vectorNorm (fun i => f i y))) z

theorem convolution_cube_oscillation {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)
    (hKd : βˆ€ i, Differentiable ℝ (K i))
    (hK : βˆ€ i u, β€–K i uβ€– ≀ C * ((2 : ℝ) ^ i.val) ^ n *
      ((2 : ℝ) ^ i.val * β€–uβ€– + 1) ^ (-q))
    (hK' : βˆ€ i u, β€–fderiv ℝ (K i) uβ€– ≀ C * (((2 : ℝ) ^ i.val) ^ n * (2 : ℝ) ^ i.val) *
      ((2 : ℝ) ^ i.val * β€–uβ€– + 1) ^ (-q))
    (hfm : βˆ€ i, Measurable (f i)) (hfi : βˆ€ i, Integrable (f i))
    (hf2 : βˆ€ i, MemLp (f i) 2 volume) {B : ℝβ‰₯0∞}
    (h2 : βˆ€ i (g : Space n β†’ β„‚), Integrable g β†’ MemLp g 2 volume β†’
      eLpNorm (convolveKernel (K i) g) 2 volume ≀ B * eLpNorm g 2 volume)
    {L : β„€} (hL : 0 < L)
    (hM : βˆ€ z, ballMaximal volume (fun y => ENNReal.ofReal (vectorNorm (fun i => f i y))) z β‰  ∞)
    (Q : BoxIntegral.Box (Fin n)) (hQ : IsCubeBox Q) :
    βˆƒ c : ℝ, βˆ€ z ∈ euclideanBox Q,
      (∫⁻ x in euclideanBox Q, β€–vectorNorm (fun i => convolveKernel (K i) (f i) x) - cβ€–β‚‘) /
        volume (euclideanBox Q) ≀ convolutionEnvelope s K f p q C B L z := by
  classical
  let iβ‚€ : Fin n := Classical.arbitrary (Fin n)
  let d := Q.upper iβ‚€ - Q.lower iβ‚€
  have hd : 0 < d := sub_pos.mpr (Q.lower_lt_upper iβ‚€)
  have hside : βˆ€ i, Q.upper i - Q.lower i = d := fun i => hQ i iβ‚€
  obtain ⟨j, hjlo, hjhi⟩ := exists_dyadic_reference
    (show 0 < 2 * (((n : ℝ) + 1) * d) by positivity)
  let P := ball (cubeCorner Q) (8 * (((n : ℝ) + 1) * d))
  have hP : MeasurableSet P := isOpen_ball.measurableSet
  have hq0 : 0 ≀ q := by linarith [Nat.cast_nonneg (Ξ± := ℝ) n]
  have hB (i : s) : BddAbove (range fun x => β€–K i xβ€–) := by
    refine ⟨C * ((2 : ℝ) ^ i.val) ^ n, ?_⟩
    rintro _ ⟨x, rfl⟩
    exact bounded_of_polynomial_decay (by positivity) hq0 hC (hK i) x
  let u := fun i x => convolveKernel (K i) (f i) x
  let a := fun i x => lowScaleDifference Subtype.val j L (fun i => u i x)
    (fun i => u i (cubeCorner Q)) i
  let b := fun i x => middleScaleTerm Subtype.val j L (fun i => u i x) i
  let c := fun i x => highScaleTerm Subtype.val j L
    (fun i => convolveKernel (K i) (P.indicator (f i)) x) i
  let t := fun i x => highScaleTerm Subtype.val j L
    (fun i => convolveKernel (K i) (Pᢜ.indicator (f i)) x) i
  let w := lowScaleCenter Subtype.val j L (fun i => u i (cubeCorner Q))
  have hu (i : s) : Measurable (u i) :=
    (continuous_convolveKernel (hfi i) (hKd i).continuous (hB i)).measurable
  have ha (i : s) : Measurable (a i) := by
    dsimp only [a, lowScaleDifference]
    split_ifs
    Β· exact (hu i).sub measurable_const
    Β· exact measurable_const
  have hb (i : s) : Measurable (b i) := by
    dsimp only [b, middleScaleTerm]
    split_ifs
    Β· exact hu i
    Β· exact measurable_const
  have hc (i : s) : Measurable (c i) := by
    dsimp only [c, highScaleTerm]
    split_ifs
    Β· exact (continuous_convolveKernel ((hfi i).indicator hP) (hKd i).continuous (hB i)).measurable
    Β· exact measurable_const
  have ht (i : s) : Measurable (t i) := by
    dsimp only [t, highScaleTerm]
    split_ifs
    Β· exact (continuous_convolveKernel ((hfi i).indicator hP.compl) (hKd i).continuous (hB i)).measurable
    Β· exact measurable_const
  have hdecomp (x : Space n) (i : s) : u i x - w i = a i x + b i x + c i x + t i x := by
    exact scale_decomposition Subtype.val (j := j) hL (fun i => u i x)
      (fun i => u i (cubeCorner Q))
      (fun i => convolveKernel (K i) (P.indicator (f i)) x)
      (fun i => convolveKernel (K i) (Pᢜ.indicator (f i)) x)
      (fun i _ => convolveKernel_indicator_add_compl (hfi i) (hKd i).continuous (hB i) hP x) i
  refine ⟨vectorNorm w, ?_⟩
  intro z hz
  have havg := centered_vector_average_le_four volume (measurable_euclideanBox Q)
    u a b c t w ha hb hc ht (fun x hx => hdecomp x)
  apply havg.trans
  unfold convolutionEnvelope
  apply add_le_add
  Β· apply add_le_add
    Β· apply add_le_add
      Β· apply set_average_le_const volume (measurable_euclideanBox Q)
          (by rw [volume_euclideanBox]; exact volume_box_ne_zero Q)
          (by rw [volume_euclideanBox]; exact (Q.measure_coe_lt_top volume).ne)
        intro x hx
        have hh := ENNReal.ofReal_le_ofReal (low_cube_vector s Q hd hside
          (by linarith : (n : ℝ) < q) hC K f hKd hK' hB hfm hfi hL.le hjhi hx hz (hM z))
        convert hh using 1
        rw [← ENNReal.ofReal_toReal (hM z), ← ENNReal.ofReal_mul (scaleKernelConstant_nonneg hC)]
        congr 1
        unfold scaleKernelConstant
        simp only [ENNReal.toReal_ofReal ENNReal.toReal_nonneg]
        ring
      Β· exact middle_cube_vector_average s Q hd hside u hu j L hp hz
    Β· apply localized_cube_vector_average Q hd hside c f hc hfm (z := z) (hz := hz)
      intro i
      dsimp only [c, highScaleTerm]
      split_ifs
      Β· exact h2 i _ ((hfi i).indicator hP) ((hf2 i).indicator hP)
      Β· change eLpNorm (0 : Space n β†’ H) 2 volume ≀ _
        rw [eLpNorm_zero]
        exact bot_le
  Β· apply set_average_le_const volume (measurable_euclideanBox Q)
      (by rw [volume_euclideanBox]; exact volume_box_ne_zero Q)
      (by rw [volume_euclideanBox]; exact (Q.measure_coe_lt_top volume).ne)
    intro x hx
    have hh := ENNReal.ofReal_le_ofReal (high_cube_vector s Q hd hside hq hC K f hK hfm
      hjlo (L := L) hx hz (hM z))
    convert hh using 1
    rw [← ENNReal.ofReal_toReal (hM z), ← ENNReal.ofReal_mul (scaleKernelConstant_nonneg hC)]
    congr 1
    unfold scaleKernelConstant
    simp only [ENNReal.toReal_ofReal ENNReal.toReal_nonneg]
    ring

end OAI.Analysis.Fourier.SquareFunction