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
|