Download data/lean/OAI/Analysis/Fourier/SquareFunction/CombiningEnvelopes.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/Fourier/SquareFunction/CombiningEnvelopes.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/Fourier/SquareFunction/CombiningEnvelopes.lean
-
curl -L -o CombiningEnvelopes.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/Fourier/SquareFunction/CombiningEnvelopes.lean
9.3 kB
| 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 | |