Download data/lean/OAI/Analysis/DiskMaximal/Potentials.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 47.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/DiskMaximal/Potentials.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/DiskMaximal/Potentials.lean
-
curl -L -o Potentials.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/DiskMaximal/Potentials.lean
47.2 kB
| import OAI.Analysis.DiskMaximal.Envelopes | |
| namespace OAI | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal Topology ContDiff | |
| open scoped RealInnerProductSpace | |
| open MeasureTheory Set Filter | |
| open scoped Topology ENNReal | |
| open scoped Real RealInnerProductSpace | |
| open MeasureTheory Set Filter | |
| open scoped Topology RealInnerProductSpace ContDiff | |
| open MeasureTheory Set Filter | |
| open scoped Topology Interval NNReal | |
| open MeasureTheory Set Filter | |
| open scoped Topology NNReal Real | |
| open MeasureTheory Set Metric | |
| open scoped ENNReal NNReal Topology | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal Topology | |
| open MeasureTheory Set Metric | |
| open scoped ENNReal NNReal | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal | |
| open Finset | |
| open scoped RealInnerProductSpace | |
| open MeasureTheory Set Metric | |
| open scoped ENNReal NNReal Topology | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal RealInnerProductSpace | |
| open MeasureTheory Set | |
| open scoped ENNReal NNReal Topology | |
| open MeasureTheory Set Metric | |
| open scoped ENNReal NNReal RealInnerProductSpace | |
| open scoped RealInnerProductSpace | |
| open scoped RealInnerProductSpace | |
| open scoped ContDiff | |
| open Finset | |
| open MeasureTheory Set Metric Filter | |
| open scoped ENNReal NNReal RealInnerProductSpace ContDiff Topology | |
| open MeasureTheory MeasureTheory.Measure Set Filter | |
| open scoped ENNReal NNReal Topology RealInnerProductSpace ContDiff | |
| open MeasureTheory Set Metric Filter Finset | |
| open scoped ENNReal NNReal RealInnerProductSpace ContDiff Topology | |
| open MeasureTheory Set | |
| open scoped RealInnerProductSpace | |
| noncomputable section | |
| namespace PlanePotential | |
| open LocalCancellation | |
| lemma green_restrict_density {Ο : β β β} {R X : β} | |
| (hΟs : β z, Ο z β 0 β βzβ β€ R) (hRX : R β€ X) | |
| (Ξ² : β β β) {x : β} (hx : βxβ β€ X) (y : β) : | |
| βͺgreen Ο x y, ({y : β | βyβ β€ X}.indicator Ξ²) yβ« = βͺgreen Ο x y,Ξ² yβ« := by | |
| by_cases hy : βyβ β€ X | |
| Β· simp [hy] | |
| Β· rw [green_eq_zero_of_outside hΟs hRX hx (lt_of_not_ge hy)] | |
| simp | |
| lemma green_root_lp_local {Ο : β β β} {Ξ² : β β β} | |
| (hΟm : Measurable Ο) {R X B : β} | |
| (hΟs : β z, Ο z β 0 β βzβ β€ R) (hΟB : β z, |Ο z| β€ B) | |
| (hRX : R β€ X) (hM : 0 < R+X) (hB : 0 β€ B) (hX : 0 < X) | |
| (hΞ² : Integrable Ξ²) : | |
| (β«β» x in {x : β | βxβ β€ X}, (ENNReal.ofReal |β« y, βͺgreen Ο x y,Ξ² yβ«|)^(3/2:β)) β€ | |
| ENNReal.ofReal ((2*B*(R+X)^2)^(3/2:β)*(4*Real.pi*(4*X)^(1/2:β))) * | |
| (ENNReal.ofReal (β« y, βΞ² yβ))^(3/2:β) := by | |
| let Ξ²' := {y : β | βyβ β€ X}.indicator Ξ² | |
| have hi : Integrable Ξ²' := hΞ².indicator (measurableSet_le measurable_norm measurable_const) | |
| have hs : β y, Ξ²' y β 0 β βyβ β€ X := by | |
| intro y hy | |
| by_contra hn | |
| exact hy (by simp [Ξ²',hn]) | |
| have h := green_root_lp hΟm hΟs hΟB hM hB (show 0 < X+X by linarith) hi hs | |
| have he : (fun x => (ENNReal.ofReal |β« y, βͺgreen Ο x y,Ξ²' yβ«|)^(3/2:β)) =α΅[volume.restrict {x : β | βxβ β€ X}] | |
| (fun x => (ENNReal.ofReal |β« y, βͺgreen Ο x y,Ξ² yβ«|)^(3/2:β)) := by | |
| filter_upwards [ae_restrict_mem (measurableSet_le measurable_norm measurable_const)] with x hx | |
| congr 3 | |
| exact integral_congr_ae (ae_of_all _ (green_restrict_density hΟs hRX Ξ² hx)) | |
| rw [lintegral_congr_ae he] at h | |
| have hm : (β« y, βΞ²' yβ) β€ β« y, βΞ² yβ := | |
| integral_mono hi.norm hΞ².norm (fun y => norm_indicator_le_norm_self Ξ² y) | |
| have hm' := ENNReal.rpow_le_rpow (ENNReal.ofReal_le_ofReal hm) (by norm_num : (0:β) β€ 3/2) | |
| have h' := h.trans (mul_le_mul_right hm' _) | |
| simpa only [show 2*(X+X)=4*X by ring] using h' | |
| lemma green_zero_piece_lp_ae {Ο : β β β} {Ξ² : β β β} | |
| (hΟm : Measurable Ο) {R X B L a : β} | |
| (hΟs : β z, Ο z β 0 β βzβ β€ R) (hΟB : β z, |Ο z| β€ B) | |
| (hΟL : β u v, |Ο u-Ο v| β€ L*βu-vβ) | |
| (hM : 0 < R+X) (hB : 0 β€ B) (hL : 0 β€ L) (ha : 0 < a) | |
| (z : β) (hΞ² : Integrable Ξ²) (hzero : β« y, Ξ² y = 0) | |
| (hΞ²s : βα΅ y, Ξ² y β 0 β βy-zβ β€ a) : | |
| (β«β» x in {x : β | βxβ β€ X}, | |
| (ENNReal.ofReal |β« y, βͺgreen Ο x y,Ξ² yβ«|)^(3/2:β)) β€ | |
| ENNReal.ofReal ((8*Real.pi*(2*B*(R+X)^2)^(3/2:β)+ | |
| Real.pi*(8*B*(R+X)^2+(64/3:β)*L*(R+X)^3)^(3/2:β))*a^(1/2:β)) * | |
| (ENNReal.ofReal (β« y, βΞ² yβ))^(3/2:β) := by | |
| let Ξ²' := {y : β | βy-zβ β€ a}.indicator Ξ² | |
| have he : Ξ²' =α΅[volume] Ξ² := by | |
| filter_upwards [hΞ²s] with y hy | |
| by_cases hs : βy-zβ β€ a | |
| Β· simp [Ξ²',hs] | |
| Β· have hz : Ξ² y = 0 := by by_contra hn; exact hs (hy hn) | |
| simp [Ξ²',hs,hz] | |
| have hi : Integrable Ξ²' := hΞ².congr he.symm | |
| have hz : β« y, Ξ²' y = 0 := (integral_congr_ae he).trans hzero | |
| have hs : β y, Ξ²' y β 0 β βy-zβ β€ a := by | |
| intro y hy | |
| by_contra hn | |
| exact hy (by simp [Ξ²',hn]) | |
| have hp (x : β) : (β« y, βͺgreen Ο x y,Ξ²' yβ«) = β« y, βͺgreen Ο x y,Ξ² yβ« := | |
| integral_congr_ae (he.mono (fun y hy => by simpa only using congrArg (fun z => βͺgreen Ο x y,zβ«) hy)) | |
| have hm : (β« y, βΞ²' yβ) = β« y, βΞ² yβ := integral_congr_ae (he.mono (fun y hy => by simpa only using congrArg norm hy)) | |
| simpa only [hp,hm] using green_zero_piece_lp hΟm hΟs hΟB hΟL hM hB hL ha z hi hz hs | |
| /-- The local decomposition theorem does not demand artificial bounded support | |
| of the original densities: the actual Green kernel vanishes outside the | |
| observation ball. -/ | |
| theorem green_decomposition_norm_local {ΞΉ : Type*} [Fintype ΞΉ] | |
| {Ο g : β β β} (hΟ : Continuous Ο) (hΟc : HasCompactSupport Ο) | |
| (hg : ContDiff β 1 g) {D R X B : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (hΟ1 : β« z, Ο z = 1) | |
| (hΟs : β z, Ο z β 0 β βzβ β€ R) (hΟB : β z, |Ο z| β€ B) | |
| (hRX : R β€ X) (hM : 0 < R+X) (hB : 0 β€ B) (hX : 0 < X) | |
| (Ξ² : ΞΉ β β β β) (hΞ² : β i, Integrable (Ξ² i)) | |
| (hdecomp : βα΅ y, βyβ β€ X β gradient g y = β i, Ξ² i y) : | |
| eLpNorm (fun x => g x-β« z, Ο z*g z) (3/2) (volume.restrict {x : β | βxβ β€ X}) β€ | |
| β i, eLpNorm (fun x => β« y, βͺgreen Ο x y,Ξ² i yβ«) (3/2) | |
| (volume.restrict {x : β | βxβ β€ X}) := by | |
| let Ξ²' := fun i => {y : β | βyβ β€ X}.indicator (Ξ² i) | |
| have hi (i : ΞΉ) : Integrable (Ξ²' i) := (hΞ² i).indicator (measurableSet_le measurable_norm measurable_const) | |
| have hs (i : ΞΉ) (y : β) (hy : Ξ²' i y β 0) : βyβ β€ X := by | |
| by_contra hn | |
| exact hy (by simp [Ξ²',hn]) | |
| have hd : βα΅ y, βyβ β€ X β gradient g y = β i, Ξ²' i y := by | |
| filter_upwards [hdecomp] with y hy hY | |
| simpa [Ξ²',hY] using hy hY | |
| have h := green_decomposition_norm hΟ hΟc hg hD hΟ1 hΟs hΟB hRX hM hB | |
| (show 0 < X+X by linarith) Ξ²' hi hs hd | |
| apply h.trans_eq | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| apply eLpNorm_congr_ae | |
| filter_upwards [ae_restrict_mem (measurableSet_le measurable_norm measurable_const)] with x hx | |
| exact integral_congr_ae (ae_of_all _ (green_restrict_density hΟs hRX (Ξ² i) hx)) | |
| /-- Uniform fractional small-support gain expressed in the common price | |
| exponent 1/100, including the unrestricted unit-size terms. -/ | |
| theorem exists_green_price : β (Ο : β β β) (C : β), 0 < C β§ | |
| ContDiff β β Ο β§ HasCompactSupport Ο β§ (β« z, Ο z) = 1 β§ | |
| (β z, Ο z β 0 β βzβ β€ 1) β§ | |
| β b : ErrorPiece 2, | |
| eLpNorm (fun x => β« y, βͺgreen Ο x y,b.density yβ«) (3/2) | |
| (volume.restrict {x : β | βxβ β€ 8}) β€ | |
| ENNReal.ofReal (C*b.size^(1/100:β)*b.mass) := by | |
| obtain β¨Ο,B,L,hB,hL,hΟ,hΟc,hΟ1,hΟs,hΟB,hΟLβ© := exists_kernel_cutoff | |
| let A : β := (2*B*(1+8)^2)^(3/2:β)*(4*Real.pi*(4*8)^(1/2:β)) | |
| let Z : β := 8*Real.pi*(2*B*(1+8)^2)^(3/2:β)+ | |
| Real.pi*(8*B*(1+8)^2+(64/3:β)*L*(1+8)^3)^(3/2:β) | |
| have hA : 0 β€ A := by dsimp [A]; positivity | |
| have hZ : 0 β€ Z := by dsimp [Z]; positivity | |
| let C : β := A^(2/3:β)+Z^(2/3:β)*2^(1/3:β)+1 | |
| have hC : 0 < C := by dsimp [C]; positivity | |
| refine β¨Ο,C,hC,hΟ,hΟc,hΟ1,hΟs,?_β© | |
| intro b | |
| have hb0 := b.size_pos.le | |
| have hm0 := b.mass_nonneg | |
| rw [eLpNorm_eq_eLpNorm' (by norm_num : (3/2:ββ₯0β) β 0) | |
| (ENNReal.div_ne_top (by norm_num) (by norm_num)) | |
| (potential_aestronglyMeasurable _ (green_measurable Ο hΟ.continuous.measurable) b.integrable)] | |
| norm_num only [ENNReal.toReal_div, ENNReal.toReal_ofNat] | |
| by_cases hb : b.size < 1 | |
| Β· have ha : 0 < 2*b.size := mul_pos (by norm_num) b.size_pos | |
| have hp := green_zero_piece_lp_ae hΟ.continuous.measurable hΟs hΟB hΟL (by norm_num : (0:β) < 1+8) | |
| hB hL ha b.center b.integrable (b.zero_mass hb) (b.support hb) | |
| have hn := eLpNorm_three_halves_bound _ hp | |
| change _ β€ (ENNReal.ofReal (Z*(2*b.size)^(1/2:β)))^(2/3:β)*ENNReal.ofReal b.mass at hn | |
| have he : (ENNReal.ofReal (Z*(2*b.size)^(1/2:β)))^(2/3:β)*ENNReal.ofReal b.mass = | |
| ENNReal.ofReal (Z^(2/3:β)*2^(1/3:β)*b.size^(1/3:β)*b.mass) := by | |
| rw [ENNReal.ofReal_rpow_of_nonneg (by positivity) (by norm_num),β ENNReal.ofReal_mul (by positivity)] | |
| congr 1 | |
| rw [Real.mul_rpow hZ (by positivity),β Real.rpow_mul (by positivity),show (1/2:β)*(2/3)=1/3 by norm_num, | |
| Real.mul_rpow (by norm_num : (0:β) β€ 2) b.size_pos.le] | |
| ring | |
| rw [he] at hn | |
| apply hn.trans (ENNReal.ofReal_le_ofReal _) | |
| have hbpow : b.size^(1/3:β) β€ b.size^(1/100:β) := | |
| Real.rpow_le_rpow_of_exponent_ge b.size_pos b.size_le_one (by norm_num) | |
| have hZC : Z^(2/3:β)*2^(1/3:β) β€ C := by dsimp [C]; linarith [Real.rpow_nonneg hA (2/3)] | |
| exact mul_le_mul_of_nonneg_right | |
| (le_trans (mul_le_mul_of_nonneg_left hbpow (by positivity)) | |
| (mul_le_mul_of_nonneg_right hZC (by positivity))) b.mass_nonneg | |
| Β· have hb1 : b.size = 1 := le_antisymm b.size_le_one (le_of_not_gt hb) | |
| have hp := green_root_lp_local hΟ.continuous.measurable hΟs hΟB (by norm_num : (1:β) β€ 8) | |
| (by norm_num : (0:β) < 1+8) hB (by norm_num : (0:β) < 8) b.integrable | |
| have hn := eLpNorm_three_halves_bound _ hp | |
| change _ β€ (ENNReal.ofReal A)^(2/3:β)*ENNReal.ofReal b.mass at hn | |
| rw [ENNReal.ofReal_rpow_of_nonneg hA (by norm_num),β ENNReal.ofReal_mul (by positivity)] at hn | |
| simp only [hb1,Real.one_rpow,mul_one] | |
| apply hn.trans (ENNReal.ofReal_le_ofReal _) | |
| apply mul_le_mul_of_nonneg_right _ b.mass_nonneg | |
| dsimp [C] | |
| linarith [mul_nonneg (Real.rpow_nonneg hZ (2/3)) (Real.rpow_nonneg (by norm_num : (0:β) β€ 2) (1/3))] | |
| end PlanePotential | |
| namespace DiskMaximalTools | |
| lemma strong_three_halves_norm {f : β β β} (hf : Measurable f) | |
| (hf0 : β x, 0 β€ f x) [IsFiniteMeasure (volume.withDensity (fun x => ENNReal.ofReal (f x)))] : | |
| eLpNorm (fun x => (rationalMaximal (volume.withDensity (fun x => ENNReal.ofReal (f x))) x).toReal) | |
| (3/2) volume β€ ENNReal.ofReal ((150*2^(1/2:β))^(2/3:β))*eLpNorm f (3/2) volume := by | |
| have h := strong_rationalMaximal hf hf0 (by norm_num : (1:β) < 3/2) | |
| have hs := ENNReal.rpow_le_rpow h (by norm_num : (0:β) β€ 2/3) | |
| rw [ENNReal.mul_rpow_of_nonneg _ _ (by norm_num : (0:β) β€ 2/3)] at hs | |
| have hp : (50*(3/2:β)*2^((3/2:β)-1)/((3/2:β)-1)) = 150*2^(1/2:β) := by | |
| norm_num | |
| ring | |
| rw [hp,ENNReal.ofReal_rpow_of_nonneg (by positivity) (by norm_num)] at hs | |
| rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num : (3/2:ββ₯0β) β 0) | |
| (ENNReal.div_ne_top (by norm_num) (by norm_num)) | |
| (measurable_rationalMaximal _).ennreal_toReal.aestronglyMeasurable, | |
| eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num : (3/2:ββ₯0β) β 0) | |
| (ENNReal.div_ne_top (by norm_num) (by norm_num)) hf.aestronglyMeasurable] | |
| norm_num only [ENNReal.toReal_div,ENNReal.toReal_ofNat,one_div_div] | |
| simp only [β ofReal_norm,Real.norm_eq_abs,abs_of_nonneg ENNReal.toReal_nonneg, | |
| abs_of_nonneg (hf0 _),ENNReal.ofReal_rpow_of_nonneg (hf0 _) (by norm_num : (0:β) β€ 3/2), | |
| ENNReal.ofReal_rpow_of_nonneg ENNReal.toReal_nonneg (by norm_num : (0:β) β€ 3/2)] at hs β’ | |
| exact hs | |
| lemma lintegral_le_three_halves_norm {f : β β β} (hf : AEStronglyMeasurable f volume) | |
| (hf0 : β x, 0 β€ f x) {Q : Set β} (hQ : volume Q β€ 1) : | |
| (β«β» x in Q, ENNReal.ofReal (f x)) β€ eLpNorm f (3/2) volume := by | |
| have h := eLpNorm_le_eLpNorm_mul_rpow_measure_univ | |
| (show (1:ββ₯0β) β€ 3/2 by rw [ENNReal.le_div_iff_mul_le (by norm_num) (by norm_num)]; norm_num) hf.restrict (ΞΌ := volume.restrict Q) | |
| have he : (1 / ENNReal.toReal 1 - 1 / ENNReal.toReal (3/2)) = (1/3:β) := by norm_num | |
| rw [he,Measure.restrict_apply_univ] at h | |
| have hpow : (volume Q)^(1/3:β) β€ 1 := by | |
| simpa using ENNReal.rpow_le_rpow hQ (by norm_num : (0:β) β€ 1/3) | |
| calc | |
| _ = eLpNorm f 1 (volume.restrict Q) := by | |
| rw [eLpNorm_one_eq_lintegral_enorm hf.restrict] | |
| simp only [β ofReal_norm,Real.norm_eq_abs,abs_of_nonneg (hf0 _)] | |
| _ β€ eLpNorm f (3/2) (volume.restrict Q)*(volume Q)^(1/3:β) := h | |
| _ β€ eLpNorm f (3/2) (volume.restrict Q) := by simpa using mul_le_mul_right hpow _ | |
| _ β€ _ := eLpNorm_mono_measure _ Measure.restrict_le_self | |
| end DiskMaximalTools | |
| namespace PlanePotential | |
| open LocalCancellation | |
| /-- The complete local L^(3/2) value estimate for a genuine finite vector | |
| cancellation decomposition, with the common 1/100 price. -/ | |
| theorem local_value_lp : β C : β, 0 < C β§ | |
| β {ΞΉ : Type} [Fintype ΞΉ] (b : ΞΉ β ErrorPiece 2) {g : β β β}, | |
| ContDiff β 1 g β (β D : β, β y, βfderiv β g yβ β€ D) β | |
| (βα΅ y, βyβ β€ 8 β gradient g y = β i, (b i).density y) β | |
| β c : β, eLpNorm (fun x => g x-c) (3/2) (volume.restrict {x : β | βxβ β€ 8}) β€ | |
| ENNReal.ofReal (C * errorPrice b (1/100)) := by | |
| obtain β¨Ο,C,hC,hΟ,hΟc,hΟ1,hΟs,hpriceβ© := exists_green_price | |
| obtain β¨B,hBβ© := hΟc.exists_bound_of_continuous hΟ.continuous | |
| have hB0 : 0 β€ B := (norm_nonneg (Ο 0)).trans (hB 0) | |
| have hΟB (z : β) : |Ο z| β€ B := by simpa only [Real.norm_eq_abs] using hB z | |
| refine β¨C,hC,?_β© | |
| intro ΞΉ _ b g hg hD hdecomp | |
| obtain β¨D,hDβ© := hD | |
| refine β¨β« z, Ο z*g z,?_β© | |
| apply (green_decomposition_norm_local hΟ.continuous hΟc hg hD hΟ1 hΟs hΟB | |
| (by norm_num : (1:β) β€ 8) (by norm_num : (0:β) < 1+8) hB0 (by norm_num : (0:β) < 8) | |
| (fun i => (b i).density) (fun i => (b i).integrable) hdecomp).trans | |
| apply (Finset.sum_le_sum (fun i (_ : i β Finset.univ) => hprice (b i))).trans_eq | |
| rw [β ENNReal.ofReal_sum_of_nonneg (fun i _ => mul_nonneg (mul_nonneg hC.le (Real.rpow_nonneg (b i).size_pos.le _)) (b i).mass_nonneg)] | |
| congr 1 | |
| rw [errorPrice,Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| end PlanePotential | |
| namespace DiskMoments | |
| open DiskMaximalTools | |
| lemma signedAverage_sub_const {g : β β β} (hg : Continuous g) (c : β) (x : β) {t : β} (ht : 0 < t) : | |
| signedAverage (fun y => g y-c) x t = signedAverage g x t-c := by | |
| have hi : IntegrableOn g (Metric.ball x t) := | |
| (hg.continuousOn.integrableOn_compact (isCompact_closedBall x t)).mono_set Metric.ball_subset_closedBall | |
| have hc : IntegrableOn (fun _ : β => c) (Metric.ball x t) := integrableOn_const measure_ball_lt_top.ne | |
| unfold signedAverage | |
| rw [integral_sub hi hc,integral_const] | |
| have hv : (volume (Metric.ball x t)).toReal = Real.pi*t^2 := by | |
| rw [volume_disk_real x ht.le,ENNReal.toReal_ofReal (by positivity)] | |
| simp only [Measure.real,Measure.restrict_apply_univ,hv,smul_eq_mul] | |
| field_simp | |
| /-- A true disk average of a continuous function is controlled by the local | |
| absolute-density maximal function. No maximizing-radius selection is used. -/ | |
| lemma local_average_le {g : β β β} (hg : Continuous g) (c : β) | |
| {x : β} (hx : βxβ β€ 2) {t : β} (ht : 0 < t) (ht4 : t β€ 4) : | |
| ENNReal.ofReal |signedAverage g x t-c| β€ | |
| rationalMaximal (volume.withDensity (fun y => ENNReal.ofReal | |
| (({y : β | βyβ β€ 8}.indicator (fun y => |g y-c|)) y))) x := by | |
| let f : β β β := {y : β | βyβ β€ 8}.indicator (fun y => |g y-c|) | |
| have hf : Measurable f := ((hg.measurable.sub measurable_const).abs).indicator | |
| (measurableSet_le measurable_norm measurable_const) | |
| have hfi : Integrable f := by | |
| apply IntegrableOn.integrable_indicator _ (measurableSet_le measurable_norm measurable_const) | |
| apply ContinuousOn.integrableOn_compact | |
| (show IsCompact {y : β | βyβ β€ 8} by simpa only [Metric.closedBall,dist_zero_right] using isCompact_closedBall (0:β) 8) | |
| exact (hg.sub continuous_const).abs.continuousOn | |
| have hsub (y : β) (hy : y β Metric.ball x t) : βyβ β€ 8 := by | |
| have hy' : βy-xβ < t := by simpa only [Metric.mem_ball,dist_eq_norm] using hy | |
| have hh := norm_add_le (y-x) x | |
| rw [sub_add_cancel] at hh | |
| linarith | |
| have he : (β« y in Metric.ball x t, f y) = β« y in Metric.ball x t, |g y-c| := by | |
| apply setIntegral_congr_fun measurableSet_ball | |
| intro y hy | |
| simp [f,hsub y hy] | |
| have hav : |signedAverage g x t-c| β€ (β« y in Metric.ball x t, f y)/(Real.pi*t^2) := by | |
| rw [β signedAverage_sub_const hg c x ht,signedAverage,abs_div,abs_of_pos (by positivity : 0 < Real.pi*t^2),he] | |
| apply div_le_div_of_nonneg_right _ (by positivity) | |
| simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm (fun y => g y-c) (ΞΌ := volume.restrict (Metric.ball x t)) | |
| have hΞ½ : (volume.withDensity (fun y => ENNReal.ofReal (f y))) (Metric.ball x t) = | |
| ENNReal.ofReal (β« y in Metric.ball x t, f y) := by | |
| rw [withDensity_apply _ measurableSet_ball] | |
| exact (ofReal_integral_eq_lintegral_ofReal hfi.integrableOn | |
| (ae_of_all _ (fun y => by dsimp [f]; exact Set.indicator_nonneg (fun _ _ => abs_nonneg _ ) y))).symm | |
| apply (ENNReal.ofReal_le_ofReal hav).trans | |
| rw [ENNReal.ofReal_div_of_pos (by positivity : 0 < Real.pi*t^2),β hΞ½,β volume_disk_real x ht.le] | |
| exact disk_average_le_rationalMaximal_exact _ x ht | |
| end DiskMoments | |
| namespace PlanePotential | |
| open LocalCancellation DiskMaximalTools DiskMoments | |
| /-- Full local value-oscillation price, for every pair of positive radii at | |
| most four. The measurable majorant is an actual centered Euclidean disk | |
| maximal function, not an assumed analytic input. -/ | |
| theorem local_value_majorant : β C : β, 0 < C β§ | |
| β {ΞΉ : Type} [Fintype ΞΉ] (b : ΞΉ β ErrorPiece 2) {g : β β β}, | |
| ContDiff β 1 g β (β D : β, β y, βfderiv β g yβ β€ D) β | |
| (βα΅ y, βyβ β€ 8 β gradient g y = β i, (b i).density y) β | |
| β Q : Set β, volume Q β€ ENNReal.ofReal 1 β | |
| β F : β β ββ₯0β, Measurable F β§ | |
| (β«β» x in Q, F x) β€ ENNReal.ofReal (C*errorPrice b (1/100)) β§ | |
| β x, βxβ β€ 2 β β t t', 0 < t β t β€ 4 β 0 < t' β t' β€ 4 β | |
| ENNReal.ofReal |signedAverage g x t-signedAverage g x t'| β€ F x := by | |
| obtain β¨C,hC,hlocalβ© := local_value_lp | |
| let K : β := (150*2^(1/2:β))^(2/3:β) | |
| have hK : 0 < K := by dsimp [K]; positivity | |
| refine β¨2*K*C,by positivity,?_β© | |
| intro ΞΉ _ b g hg hD hdecomp Q hQ | |
| obtain β¨c,hcβ© := hlocal b hg hD hdecomp | |
| let f : β β β := {y : β | βyβ β€ 8}.indicator (fun y => |g y-c|) | |
| have hf : Measurable f := ((hg.continuous.measurable.sub measurable_const).abs).indicator | |
| (measurableSet_le measurable_norm measurable_const) | |
| have hf0 (y : β) : 0 β€ f y := Set.indicator_nonneg (fun _ _ => abs_nonneg _) y | |
| have hfi : Integrable f := by | |
| apply IntegrableOn.integrable_indicator _ (measurableSet_le measurable_norm measurable_const) | |
| apply ContinuousOn.integrableOn_compact | |
| (show IsCompact {y : β | βyβ β€ 8} by simpa only [Metric.closedBall,dist_zero_right] using isCompact_closedBall (0:β) 8) | |
| exact (hg.continuous.sub continuous_const).abs.continuousOn | |
| let Ξ½ := volume.withDensity (fun y => ENNReal.ofReal (f y)) | |
| have hΞ½ : Ξ½ univ = ENNReal.ofReal (β« y, f y) := by | |
| rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ] | |
| exact (ofReal_integral_eq_lintegral_ofReal hfi (ae_of_all _ hf0)).symm | |
| have : IsFiniteMeasure Ξ½ := β¨by rw [hΞ½]; exact ENNReal.ofReal_lt_topβ© | |
| let M : β β β := fun x => (rationalMaximal Ξ½ x).toReal | |
| have hM : Measurable M := (measurable_rationalMaximal Ξ½).ennreal_toReal | |
| have hMf : β x, rationalMaximal Ξ½ x β β€ := by | |
| obtain β¨B,hBβ© := (isCompact_closedBall (0:β) 8).exists_bound_of_continuousOn | |
| (hg.continuous.sub (continuous_const (y := c))).continuousOn | |
| have hbnd (y : β) : f y β€ max B 0 := by | |
| by_cases hy : βyβ β€ 8 | |
| Β· have hby := hB y (by simpa only [Metric.mem_closedBall,dist_zero_right] using hy) | |
| simpa [f, hy, Real.norm_eq_abs] using hby.trans (le_max_left B 0) | |
| Β· simp [f, hy] | |
| intro x | |
| exact ne_of_lt ((rationalMaximal_le_of_density_le (fun y => ENNReal.ofReal_le_ofReal (hbnd y)) x).trans_lt ENNReal.ofReal_lt_top) | |
| have hfnorm : eLpNorm f (3/2) volume = eLpNorm (fun x => g x-c) (3/2) (volume.restrict {x : β | βxβ β€ 8}) := by | |
| rw [eLpNorm_indicator_eq_eLpNorm_restrict (measurableSet_le measurable_norm measurable_const)] | |
| simpa only [Real.norm_eq_abs] using eLpNorm_norm (fun x => g x-c) (p := (3/2:ββ₯0β)) (ΞΌ := volume.restrict {x : β | βxβ β€ 8}) | |
| (hg.continuous.measurable.sub measurable_const).aestronglyMeasurable | |
| have hn : eLpNorm M (3/2) volume β€ ENNReal.ofReal K*ENNReal.ofReal (C*errorPrice b (1/100)) := by | |
| apply (strong_three_halves_norm hf hf0).trans | |
| apply mul_le_mul_right _ _ | |
| simpa only [hfnorm] using hc | |
| refine β¨fun x => ENNReal.ofReal 2*ENNReal.ofReal (M x),measurable_const.mul hM.ennreal_ofReal,?_,?_β© | |
| Β· rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top] | |
| apply (mul_le_mul_right (lintegral_le_three_halves_norm hM.aestronglyMeasurable | |
| (fun _ => ENNReal.toReal_nonneg) (by simpa using hQ)) _).trans | |
| apply (mul_le_mul_right hn _).trans_eq | |
| rw [β ENNReal.ofReal_mul hK.le,β ENNReal.ofReal_mul (by norm_num : (0:β) β€ 2)] | |
| congr 1 | |
| ring | |
| Β· intro x hx t t' ht ht4 ht' ht4' | |
| have ha : |signedAverage g x t-c| β€ M x := | |
| (ENNReal.ofReal_le_iff_le_toReal (hMf x)).mp (local_average_le hg.continuous c hx ht ht4) | |
| have hb : |signedAverage g x t'-c| β€ M x := | |
| (ENNReal.ofReal_le_iff_le_toReal (hMf x)).mp (local_average_le hg.continuous c hx ht' ht4') | |
| change ENNReal.ofReal _ β€ ENNReal.ofReal 2 * ENNReal.ofReal (M x) | |
| rw [β ENNReal.ofReal_mul (by norm_num : (0:β) β€ 2)] | |
| apply ENNReal.ofReal_le_ofReal | |
| have hh := abs_sub_le (signedAverage g x t) c (signedAverage g x t') | |
| rw [abs_sub_comm c] at hh | |
| linarith | |
| end PlanePotential | |
| namespace AffineDensities | |
| lemma fderiv_affine_bound {g : β β β} (hg : Differentiable β g) (p : β) (r : β) | |
| {D : β} (hD : β y, βfderiv β g yβ β€ D) : | |
| β B : β, β X, βfderiv β (fun Y => g (p+r β’ Y)) Xβ β€ B := by | |
| refine β¨D*|r|,?_β© | |
| intro X | |
| have hA : HasFDerivAt (fun Y : β => p+r β’ Y) | |
| (r β’ ContinuousLinearMap.id β β) X := by | |
| simpa using ((hasFDerivAt_id X).const_smul r).const_add p | |
| have hd := (hg (p+r β’ X)).hasFDerivAt.comp X hA | |
| simp only [Function.comp_def] at hd | |
| rw [hd.fderiv] | |
| apply (ContinuousLinearMap.opNorm_comp_le _ _).trans | |
| simp only [norm_smul,Real.norm_eq_abs,ContinuousLinearMap.norm_id, mul_one] | |
| exact mul_le_mul_of_nonneg_right (hD _) (abs_nonneg _) | |
| end AffineDensities | |
| namespace CommonPrices | |
| open DyadicHats ConeCoordinates LocalCancellation AffineDensities DirectionNeighbors Finset DiskMoments PricePieces | |
| /-- The actual common-price value estimate, including every terminal error and | |
| all roots. This is the third local analytic input to signed run assembly. -/ | |
| theorem value_cell_price : β C : β, 0 < C β§ | |
| β {N : β} {r R : β} (hr : 0 < r) (hR : 0 β€ R) (hN : R/r+1 β€ (N:β)) | |
| {g : β β β}, ContDiff β 1 g β Integrable (gradient g) β | |
| (β y, gradient g y β 0 β βyβ β€ R) β | |
| (β D : β, β y, βfderiv β g yβ β€ D) β β (k : β) (p : β€ Γ β€) | |
| {n : β}, n β fixedPalette.labels β β Q : Set β, volume Q β€ ENNReal.ofReal 1 β | |
| β F : β β ββ₯0β, Measurable F β§ | |
| (β«β» X in Q, F X) β€ ENNReal.ofReal (C*(scale r k)β»ΒΉ* | |
| (rootMass (gradient g) r k (cellRoots N p)+cellPrice N r (gradient g) k (cellRoots N p))) β§ | |
| β X, βXβ β€ 2 β β t t', 0 < t β t β€ 4 β 0 < t' β t' β€ 4 β | |
| ENNReal.ofReal |signedAverage (fun Y => g (point (scale r k) p+scale r k β’ Y)) X t- | |
| signedAverage (fun Y => g (point (scale r k) p+scale r k β’ Y)) X t'| β€ F X := by | |
| obtain β¨C,hC,hmajorβ© := PlanePotential.local_value_majorant | |
| refine β¨4*C,by positivity,?_β© | |
| intro N r R hr hR hN g hg hh hsupp hD k p n hn Q hQ | |
| let b := sizeErrors hr hh k (point (scale r k) p) (cellRoots N p) n | |
| have hg' : ContDiff β 1 (fun Y => g (point (scale r k) p+scale r k β’ Y)) := hg.comp (by fun_prop) | |
| obtain β¨D,hDβ© := hD | |
| have hD' := fderiv_affine_bound (hg.differentiable one_ne_zero) (point (scale r k) p) (scale r k) hD | |
| have hd : βα΅ X, βXβ β€ 8 β | |
| gradient (fun Y => g (point (scale r k) p+scale r k β’ Y)) X = β i, (b i).density X := by | |
| filter_upwards with X hX | |
| exact (sizeErrors_gradient hr hR hN (hg.differentiable one_ne_zero) hh hsupp k p | |
| (fixedPalette.unit n hn) X (by linarith)).symm | |
| obtain β¨F,hFm,hFi,hFbβ© := hmajor b hg' hD' hd Q hQ | |
| refine β¨F,hFm,?_,hFbβ© | |
| apply hFi.trans | |
| apply ENNReal.ofReal_le_ofReal | |
| have hb := sizeErrors_price hr hR hN hh hsupp k (point (scale r k) p) (cellRoots N p) hn | |
| have hDp : 0 β€ cellPrice N r (gradient g) k (cellRoots N p) := | |
| sum_nonneg (fun q _ => rootPrice_nonneg hr hR hN hh hsupp k q) | |
| change errorPrice b (1/100) β€ _ at hb | |
| have hrk := scale_pos hr k | |
| nlinarith [mul_le_mul_of_nonneg_left hb hC.le,inv_nonneg.mpr hrk.le, | |
| mul_nonneg (inv_nonneg.mpr hrk.le) hDp] | |
| end CommonPrices | |
| namespace PhysicalCells | |
| open MeasureTheory Set | |
| def unitCell : Set β := {X | X.re β Ico (0:β) 1 β§ X.im β Ico (0:β) 1} | |
| def toUnit (p : β) (r : β) (y : β) : β := rβ»ΒΉ β’ (y-p) | |
| def cell (p : β) (r : β) : Set β := toUnit p r β»ΒΉ' unitCell | |
| lemma unitCell_measurable : MeasurableSet unitCell := | |
| (Complex.measurable_re measurableSet_Ico).inter (Complex.measurable_im measurableSet_Ico) | |
| lemma toUnit_continuous (p : β) (r : β) : Continuous (toUnit p r) := by unfold toUnit; fun_prop | |
| lemma cell_measurable (p : β) (r : β) : MeasurableSet (cell p r) := | |
| (toUnit_continuous p r).measurable unitCell_measurable | |
| lemma volume_unitCell : volume unitCell = 1 := by | |
| have he := Complex.volume_preserving_equiv_real_prod.measure_preimage | |
| (s := Ico (0:β) 1 ΓΛ’ Ico (0:β) 1) (measurableSet_Ico.prod measurableSet_Ico).nullMeasurableSet | |
| change volume unitCell = _ at he | |
| rw [he] | |
| change (volume.prod volume) (Ico (0:β) 1 ΓΛ’ Ico (0:β) 1) = 1 | |
| rw [Measure.prod_prod] | |
| norm_num | |
| lemma norm_unitCell {X : β} (hX : X β unitCell) : βXβ β€ 2 := by | |
| have h := Complex.norm_le_abs_re_add_abs_im X | |
| rw [abs_of_nonneg hX.1.1,abs_of_nonneg hX.2.1] at h | |
| linarith [hX.1.2,hX.2.2] | |
| lemma toUnit_affine (p : β) {r : β} (hr : r β 0) (X : β) : toUnit p r (p+r β’ X) = X := by | |
| simp [toUnit,hr] | |
| lemma affine_toUnit (p : β) {r : β} (hr : r β 0) (y : β) : p+r β’ toUnit p r y = y := by | |
| simp [toUnit,hr] | |
| lemma lintegral_smul (F : β β ββ₯0β) {r : β} (hr : r β 0) : | |
| (β«β» X : β, F (r β’ X)) = ENNReal.ofReal ((r^2)β»ΒΉ)*(β«β» y, F y) := by | |
| have he := (lintegral_map_equiv (ΞΌ := volume) F | |
| (Homeomorph.smul (isUnit_iff_ne_zero.mpr hr).unit).toMeasurableEquiv).symm | |
| change (β«β» X : β, F (r β’ X)) = β«β» y, F y βMeasure.map (fun X : β => r β’ X) volume at he | |
| rw [he,Measure.map_addHaar_smul volume hr,lintegral_smul_measure] | |
| simp only [Complex.finrank_real_complex,abs_of_nonneg (inv_nonneg.mpr (sq_nonneg r)),smul_eq_mul] | |
| lemma lintegral_toUnit (F : β β ββ₯0β) (p : β) {r : β} (hr : r β 0) : | |
| (β«β» y : β, F (toUnit p r y)) = ENNReal.ofReal (r^2)*(β«β» X, F X) := by | |
| calc | |
| (β«β» y : β, F (rβ»ΒΉ β’ (y-p))) = β«β» y : β, F (rβ»ΒΉ β’ y) := | |
| lintegral_sub_right_eq_self (ΞΌ := (volume : Measure β)) (fun y : β => F (rβ»ΒΉ β’ y)) p | |
| _ = _ := by rw [lintegral_smul _ (inv_ne_zero hr),inv_pow,inv_inv] | |
| /-- Exact physical-space change of variables, with the two-dimensional volume | |
| factor and no integrability or measurability assumptions on the majorant. -/ | |
| lemma lintegral_cell (F : β β ββ₯0β) (p : β) {r : β} (hr : r β 0) : | |
| (β«β» y in cell p r, F y) = ENNReal.ofReal (r^2)*β«β» X in unitCell, F (p+r β’ X) := by | |
| rw [β lintegral_indicator (cell_measurable p r),β lintegral_indicator unitCell_measurable] | |
| have he (y : β) : (cell p r).indicator F y = | |
| unitCell.indicator (fun X => F (p+r β’ X)) (toUnit p r y) := by | |
| by_cases hy : y β cell p r | |
| Β· rw [Set.indicator_of_mem hy,Set.indicator_of_mem (show toUnit p r y β unitCell from hy),affine_toUnit p hr] | |
| Β· rw [Set.indicator_of_notMem hy,Set.indicator_of_notMem (show toUnit p r y β unitCell from hy)] | |
| simp_rw [he] | |
| exact lintegral_toUnit _ p hr | |
| lemma cell_majorant {F : β β ββ₯0β} (p : β) {r : β} (hr : r β 0) : | |
| (β«β» y in cell p r, F (toUnit p r y)) = ENNReal.ofReal (r^2)*β«β» X in unitCell, F X := by | |
| rw [lintegral_cell _ p hr] | |
| simp only [toUnit_affine p hr] | |
| end PhysicalCells | |
| namespace DiskMoments | |
| lemma signedAverage_affine (g : β β β) (p X : β) {r t : β} (hr : 0 < r) (ht : 0 < t) : | |
| signedAverage (fun Y => g (p+r β’ Y)) X t = signedAverage g (p+r β’ X) (r*t) := by | |
| rw [signedAverage_fixedDomain _ _ ht,signedAverage_fixedDomain _ _ (mul_pos hr ht)] | |
| congr 1 | |
| apply setIntegral_congr_fun measurableSet_ball | |
| intro Z _ | |
| change g (p+r β’ (X+t β’ Z)) = g (p+r β’ X+(r*t) β’ Z) | |
| congr 1 | |
| rw [smul_add,smul_smul] | |
| abel | |
| lemma gradient_signedAverage {g : β β β} (hg : ContDiff β 1 g) {D : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (x : β) {t : β} (ht : 0 < t) : | |
| gradient (fun y => signedAverage g y t) x = | |
| (Real.pi*t^2)β»ΒΉ β’ β« y in Metric.ball x t, gradient g y := by | |
| have hi : IntegrableOn (fun z : β => fderiv β g (x+t β’ z)) (Metric.ball 0 1) := | |
| (((hg.continuous_fderiv one_ne_zero).comp (by fun_prop)).continuousOn.integrableOn_compact | |
| (isCompact_closedBall (0:β) 1)).mono_set Metric.ball_subset_closedBall | |
| rw [gradient,(hasFDerivAt_signedAverage hg hD x ht).fderiv,map_smul] | |
| have he := (InnerProductSpace.toDual β β).symm.toContinuousLinearMap.integral_comp_comm hi | |
| change (β« z in Metric.ball (0:β) 1, (InnerProductSpace.toDual β β).symm (fderiv β g (x+t β’ z))) = | |
| (InnerProductSpace.toDual β β).symm (β« z in Metric.ball (0:β) 1, fderiv β g (x+t β’ z)) at he | |
| rw [β he] | |
| change (1/Real.pi) β’ (β« z in Metric.ball (0:β) 1, gradient g (x+t β’ z)) = _ | |
| rw [integral_scale_ball (fun z => gradient g (x+z)) ht,integral_translate_ball,smul_smul] | |
| congr 1 | |
| ring | |
| lemma gradient_average_affine {g : β β β} (hg : ContDiff β 1 g) {D : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (p X : β) {r t : β} (hr : 0 < r) (ht : 0 < t) : | |
| gradient (fun Y => signedAverage (fun Z => g (p+r β’ Z)) Y t) X = | |
| r β’ gradient (fun y => signedAverage g y (r*t)) (p+r β’ X) := by | |
| have he : (fun Y => signedAverage (fun Z => g (p+r β’ Z)) Y t) = | |
| (fun Y => signedAverage g (p+r β’ Y) (r*t)) := by | |
| funext Y | |
| exact signedAverage_affine g p Y hr ht | |
| rw [he] | |
| exact AffineDensities.gradient_affine (fun y => | |
| (hasFDerivAt_signedAverage hg hD y (mul_pos hr ht)).differentiableAt) p r X | |
| def PhysicalNeighborhoodRadius (g : β β β) (r : β) (x : β) (t : β) : Prop := | |
| t β Icc r (2*r) β§ β s, 0 < s β |s-t| β€ r/4 β signedAverage g x s β€ signedAverage g x t | |
| def PhysicalEndpointRadius (g : β β β) (r : β) (x : β) (t : β) : Prop := | |
| t β Icc r (2*r) β§ (t = r β¨ t = 2*r β¨ β s β Icc r (2*r), signedAverage g x s β€ signedAverage g x t) | |
| lemma neighborhoodRadius_affine {g : β β β} (p X : β) {r t : β} (hr : 0 < r) | |
| (ht : PhysicalNeighborhoodRadius g r (p+r β’ X) (r*t)) : | |
| NeighborhoodRadius (fun Y => g (p+r β’ Y)) X t := by | |
| have ht1 : 1 β€ t := (le_of_mul_le_mul_left (by simpa only [mul_one] using ht.1.1) hr) | |
| have ht2 : t β€ 2 := (le_of_mul_le_mul_left (by simpa only [mul_comm 2 r] using ht.1.2) hr) | |
| refine β¨β¨ht1,ht2β©,?_β© | |
| intro s hs habs | |
| rw [signedAverage_affine _ _ _ hr hs,signedAverage_affine _ _ _ hr (by linarith)] | |
| apply ht.2 (r*s) (mul_pos hr hs) | |
| rw [β mul_sub,abs_mul,abs_of_pos hr] | |
| nlinarith | |
| lemma endpointRadius_affine {g : β β β} (p X : β) {r t : β} (hr : 0 < r) | |
| (ht : PhysicalEndpointRadius g r (p+r β’ X) (r*t)) : | |
| EndpointRadius (fun Y => g (p+r β’ Y)) X t := by | |
| have ht1 : 1 β€ t := (le_of_mul_le_mul_left (by simpa only [mul_one] using ht.1.1) hr) | |
| have ht2 : t β€ 2 := (le_of_mul_le_mul_left (by simpa only [mul_comm 2 r] using ht.1.2) hr) | |
| refine β¨β¨ht1,ht2β©,?_β© | |
| rcases ht.2 with he | he | he | |
| Β· left | |
| nlinarith | |
| Β· right; left | |
| nlinarith | |
| Β· right; right | |
| intro s hs | |
| rw [signedAverage_affine _ _ _ hr (by linarith [hs.1]),signedAverage_affine _ _ _ hr (by linarith)] | |
| exact he (r*s) β¨by nlinarith [hs.1],by nlinarith [hs.2]β© | |
| end DiskMoments | |
| namespace PhysicalCells | |
| lemma derivative_majorant_integral {F : β β ββ₯0β} {C P : β} (p : β) {r : β} | |
| (hr : 0 < r) (hF : (β«β» X in unitCell, F X) β€ ENNReal.ofReal (C*rβ»ΒΉ*P)) : | |
| (β«β» y in cell p r, ENNReal.ofReal rβ»ΒΉ*F (toUnit p r y)) β€ ENNReal.ofReal (C*P) := by | |
| rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top,cell_majorant p hr.ne'] | |
| apply (mul_le_mul' le_rfl (mul_le_mul' le_rfl hF)).trans_eq | |
| rw [β ENNReal.ofReal_mul (sq_nonneg r),β ENNReal.ofReal_mul (inv_nonneg.mpr hr.le)] | |
| congr 1 | |
| field_simp | |
| lemma value_majorant_integral {F : β β ββ₯0β} {C P : β} (p : β) {r : β} | |
| (hr : 0 < r) (hF : (β«β» X in unitCell, F X) β€ ENNReal.ofReal (C*rβ»ΒΉ*P)) : | |
| (β«β» y in cell p r, F (toUnit p r y)) β€ ENNReal.ofReal (C*r*P) := by | |
| rw [cell_majorant p hr.ne'] | |
| apply (mul_le_mul' le_rfl hF).trans_eq | |
| rw [β ENNReal.ofReal_mul (sq_nonneg r)] | |
| congr 1 | |
| field_simp | |
| end PhysicalCells | |
| namespace DiskMoments | |
| lemma average_gradient_norm_le {g : β β β} (hg : ContDiff β 1 g) {D : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (x : β) {t : β} (ht : 1 β€ t) : | |
| βgradient (fun y => signedAverage g y t) xβ β€ ββ« y in Metric.ball x t, gradient g yβ := by | |
| have hp : 0 < Real.pi*t^2 := mul_pos Real.pi_pos (sq_pos_of_pos (by linarith)) | |
| have h1 : 1 β€ Real.pi*t^2 := by nlinarith [Real.pi_gt_three,sq_nonneg (t-1)] | |
| rw [gradient_signedAverage hg hD x (by linarith),norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hp)] | |
| exact mul_le_of_le_one_left (norm_nonneg _) ((inv_le_oneβ hp).mpr h1) | |
| lemma average_gradient_negative_le {g : β β β} (hg : ContDiff β 1 g) {D : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (x n : β) {t : β} (ht : 1 β€ t) : | |
| max 0 (-inner β n (gradient (fun y => signedAverage g y t) x)) β€ | |
| max 0 (-inner β n (β« y in Metric.ball x t, gradient g y)) := by | |
| have hp : 0 < Real.pi*t^2 := mul_pos Real.pi_pos (sq_pos_of_pos (by linarith)) | |
| have h1 : 1 β€ Real.pi*t^2 := by nlinarith [Real.pi_gt_three,sq_nonneg (t-1)] | |
| rw [gradient_signedAverage hg hD x (by linarith),inner_smul_right,β mul_neg, | |
| β mul_zero (Real.pi*t^2)β»ΒΉ,β mul_max_of_nonneg _ _ (inv_nonneg.mpr hp.le)] | |
| simp only [mul_zero] | |
| exact mul_le_of_le_one_left (le_max_left _ _) ((inv_le_oneβ hp).mpr h1) | |
| lemma physical_gradient_norm_majorant {g : β β β} (hg : ContDiff β 1 g) {D : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (p X : β) {r t : β} (hr : 0 < r) (ht : 0 < t) | |
| {F : ββ₯0β} | |
| (hF : ENNReal.ofReal βgradient (fun Y => signedAverage (fun Z => g (p+r β’ Z)) Y t) Xβ β€ F) : | |
| ENNReal.ofReal βgradient (fun y => signedAverage g y (r*t)) (p+r β’ X)β β€ | |
| ENNReal.ofReal rβ»ΒΉ*F := by | |
| have h : ENNReal.ofReal rβ»ΒΉ*_ β€ ENNReal.ofReal rβ»ΒΉ*F := mul_le_mul' le_rfl hF | |
| rw [gradient_average_affine hg hD p X hr ht,norm_smul,Real.norm_eq_abs,abs_of_pos hr, | |
| β ENNReal.ofReal_mul (inv_nonneg.mpr hr.le),inv_mul_cancel_leftβ hr.ne'] at h | |
| exact h | |
| lemma physical_gradient_negative_majorant {g : β β β} (hg : ContDiff β 1 g) {D : β} | |
| (hD : β y, βfderiv β g yβ β€ D) (p X n : β) {r t : β} (hr : 0 < r) (ht : 0 < t) | |
| {F : ββ₯0β} | |
| (hF : ENNReal.ofReal (max 0 (-inner β n | |
| (gradient (fun Y => signedAverage (fun Z => g (p+r β’ Z)) Y t) X))) β€ F) : | |
| ENNReal.ofReal (max 0 (-inner β n (gradient (fun y => signedAverage g y (r*t)) (p+r β’ X)))) β€ | |
| ENNReal.ofReal rβ»ΒΉ*F := by | |
| have h : ENNReal.ofReal rβ»ΒΉ*_ β€ ENNReal.ofReal rβ»ΒΉ*F := mul_le_mul' le_rfl hF | |
| rw [gradient_average_affine hg hD p X hr ht,inner_smul_right,β mul_neg, | |
| β mul_zero r,β mul_max_of_nonneg _ _ hr.le, | |
| β ENNReal.ofReal_mul (inv_nonneg.mpr hr.le),inv_mul_cancel_leftβ hr.ne'] at h | |
| simpa only [mul_zero] using h | |
| end DiskMoments | |
| namespace CommonPrices | |
| open DyadicHats ConeCoordinates LocalCancellation AffineDensities DirectionNeighbors Finset DiskMoments PricePieces PhysicalCells | |
| theorem physical_directional_price : β C : β, 0 < C β§ | |
| β {N : β} {r R : β} (hr : 0 < r) (hR : 0 β€ R) (hN : R/r+1 β€ (N:β)) | |
| {g : β β β}, ContDiff β 1 g β Integrable (gradient g) β | |
| (β y, gradient g y β 0 β βyβ β€ R) β | |
| (β D : β, β y, βfderiv β g yβ β€ D) β β (k : β) (p : β€ Γ β€) | |
| {n : β}, n β fixedPalette.labels β β {s : β}, (s = 1 β¨ s = -1) β | |
| β F : β β ββ₯0β, Measurable F β§ | |
| (β«β» y in cell (point (scale r k) p) (scale r k), F y) β€ ENNReal.ofReal | |
| (C*(badPrice (gradient g) r k (cellRoots N p) n+cellPrice N r (gradient g) k (cellRoots N p))) β§ | |
| β y β cell (point (scale r k) p) (scale r k), β t, | |
| PhysicalNeighborhoodRadius g (scale r k) y t β | |
| ENNReal.ofReal (max 0 (-inner β (axis n s) (gradient (fun z => signedAverage g z t) y))) β€ F y := by | |
| obtain β¨C,hC,hmajorβ© := directional_cell_price | |
| refine β¨C,hC,?_β© | |
| intro N r R hr hR hN g hg hh hsupp hD k p n hn s hs | |
| obtain β¨D,hDβ© := hD | |
| obtain β¨D',hD'β© := fderiv_affine_bound (hg.differentiable one_ne_zero) (point (scale r k) p) (scale r k) hD | |
| obtain β¨F,hFm,hFi,hFbβ© := hmajor hr hR hN hg hh hsupp k p hn hs unitCell (by rw [volume_unitCell]; norm_num) | |
| refine β¨fun y => ENNReal.ofReal (scale r k)β»ΒΉ*F (toUnit (point (scale r k) p) (scale r k) y), | |
| measurable_const.mul (hFm.comp (toUnit_continuous _ _).measurable), | |
| derivative_majorant_integral _ (scale_pos hr k) hFi,?_β© | |
| intro y hy t ht | |
| let X := toUnit (point (scale r k) p) (scale r k) y | |
| have hX : βXβ β€ 2 := norm_unitCell hy | |
| have he : point (scale r k) p+scale r k β’ X = y := affine_toUnit _ (scale_pos hr k).ne' y | |
| have ht' : PhysicalNeighborhoodRadius g (scale r k) | |
| (point (scale r k) p+scale r k β’ X) (scale r k*(t/scale r k)) := by | |
| simpa only [he,mul_div_cancelβ _ (scale_pos hr k).ne'] using ht | |
| have htn := neighborhoodRadius_affine _ X (scale_pos hr k) ht' | |
| have hg' : ContDiff β 1 (fun Z => g (point (scale r k) p+scale r k β’ Z)) := hg.comp (by fun_prop) | |
| have hb := (ENNReal.ofReal_le_ofReal (average_gradient_negative_le hg' hD' X (axis n s) htn.1.1)).trans | |
| (hFb X hX _ htn) | |
| have hf := physical_gradient_negative_majorant hg hD (point (scale r k) p) X (axis n s) | |
| (scale_pos hr k) (by linarith [htn.1.1]) hb | |
| simpa only [he,mul_div_cancelβ _ (scale_pos hr k).ne'] using hf | |
| theorem physical_size_price : β C : β, 0 < C β§ | |
| β {N : β} {r R : β} (hr : 0 < r) (hR : 0 β€ R) (hN : R/r+1 β€ (N:β)) | |
| {g : β β β}, ContDiff β 1 g β Integrable (gradient g) β | |
| (β y, gradient g y β 0 β βyβ β€ R) β | |
| (β D : β, β y, βfderiv β g yβ β€ D) β β (k : β) (p : β€ Γ β€) | |
| {n : β}, n β fixedPalette.labels β | |
| β F : β β ββ₯0β, Measurable F β§ | |
| (β«β» y in cell (point (scale r k) p) (scale r k), F y) β€ ENNReal.ofReal | |
| (C*(rootMass (gradient g) r k (cellRoots N p)+cellPrice N r (gradient g) k (cellRoots N p))) β§ | |
| β y β cell (point (scale r k) p) (scale r k), β t, | |
| PhysicalEndpointRadius g (scale r k) y t β | |
| ENNReal.ofReal βgradient (fun z => signedAverage g z t) yβ β€ F y := by | |
| obtain β¨C,hC,hmajorβ© := size_cell_price | |
| refine β¨C,hC,?_β© | |
| intro N r R hr hR hN g hg hh hsupp hD k p n hn | |
| obtain β¨D,hDβ© := hD | |
| obtain β¨D',hD'β© := fderiv_affine_bound (hg.differentiable one_ne_zero) (point (scale r k) p) (scale r k) hD | |
| obtain β¨F,hFm,hFi,hFbβ© := hmajor hr hR hN hg hh hsupp k p hn unitCell (by rw [volume_unitCell]; norm_num) | |
| refine β¨fun y => ENNReal.ofReal (scale r k)β»ΒΉ*F (toUnit (point (scale r k) p) (scale r k) y), | |
| measurable_const.mul (hFm.comp (toUnit_continuous _ _).measurable), | |
| derivative_majorant_integral _ (scale_pos hr k) hFi,?_β© | |
| intro y hy t ht | |
| let X := toUnit (point (scale r k) p) (scale r k) y | |
| have hX : βXβ β€ 2 := norm_unitCell hy | |
| have he : point (scale r k) p+scale r k β’ X = y := affine_toUnit _ (scale_pos hr k).ne' y | |
| have ht' : PhysicalEndpointRadius g (scale r k) | |
| (point (scale r k) p+scale r k β’ X) (scale r k*(t/scale r k)) := by | |
| simpa only [he,mul_div_cancelβ _ (scale_pos hr k).ne'] using ht | |
| have htn := endpointRadius_affine _ X (scale_pos hr k) ht' | |
| have hg' : ContDiff β 1 (fun Z => g (point (scale r k) p+scale r k β’ Z)) := hg.comp (by fun_prop) | |
| have hb := (ENNReal.ofReal_le_ofReal (average_gradient_norm_le hg' hD' X htn.1.1)).trans | |
| (hFb X hX _ htn) | |
| have hf := physical_gradient_norm_majorant hg hD (point (scale r k) p) X | |
| (scale_pos hr k) (by linarith [htn.1.1]) hb | |
| simpa only [he,mul_div_cancelβ _ (scale_pos hr k).ne'] using hf | |
| theorem physical_value_price : β C : β, 0 < C β§ | |
| β {N : β} {r R : β} (hr : 0 < r) (hR : 0 β€ R) (hN : R/r+1 β€ (N:β)) | |
| {g : β β β}, ContDiff β 1 g β Integrable (gradient g) β | |
| (β y, gradient g y β 0 β βyβ β€ R) β | |
| (β D : β, β y, βfderiv β g yβ β€ D) β β (k : β) (p : β€ Γ β€) | |
| {n : β}, n β fixedPalette.labels β | |
| β F : β β ββ₯0β, Measurable F β§ | |
| (β«β» y in cell (point (scale r k) p) (scale r k), F y) β€ ENNReal.ofReal | |
| (C*scale r k*(rootMass (gradient g) r k (cellRoots N p)+cellPrice N r (gradient g) k (cellRoots N p))) β§ | |
| β y β cell (point (scale r k) p) (scale r k), β t t', | |
| 0 < t β t β€ 4*scale r k β 0 < t' β t' β€ 4*scale r k β | |
| ENNReal.ofReal |signedAverage g y t-signedAverage g y t'| β€ F y := by | |
| obtain β¨C,hC,hmajorβ© := value_cell_price | |
| refine β¨C,hC,?_β© | |
| intro N r R hr hR hN g hg hh hsupp hD k p n hn | |
| obtain β¨F,hFm,hFi,hFbβ© := hmajor hr hR hN hg hh hsupp hD k p hn unitCell (by rw [volume_unitCell]; norm_num) | |
| refine β¨fun y => F (toUnit (point (scale r k) p) (scale r k) y), | |
| hFm.comp (toUnit_continuous _ _).measurable, | |
| value_majorant_integral _ (scale_pos hr k) hFi,?_β© | |
| intro y hy t t' ht hb ht' hb' | |
| let X := toUnit (point (scale r k) p) (scale r k) y | |
| have he : point (scale r k) p+scale r k β’ X = y := affine_toUnit _ (scale_pos hr k).ne' y | |
| have hrk := scale_pos hr k | |
| have hf := hFb X (norm_unitCell hy) (t/scale r k) (t'/scale r k) | |
| (div_pos ht hrk) ((div_le_iffβ hrk).mpr hb) (div_pos ht' hrk) ((div_le_iffβ hrk).mpr hb') | |
| simpa only [signedAverage_affine _ _ _ hrk (div_pos ht hrk), | |
| signedAverage_affine _ _ _ hrk (div_pos ht' hrk),he,mul_div_cancelβ _ hrk.ne'] using hf | |
| end CommonPrices | |
| namespace DiskMoments | |
| lemma signedAverage_abs_le {g : β β β} {M : β} (hM : β y, |g y| β€ M) | |
| (x : β) {t : β} (ht : 0 < t) : |signedAverage g x t| β€ M := by | |
| rw [signedAverage_fixedDomain g x ht,abs_div,abs_of_pos Real.pi_pos] | |
| have : IsFiniteMeasure (volume.restrict (Metric.ball (0:β) 1)) := β¨by simpβ© | |
| have hi := norm_integral_le_of_norm_le_const (ΞΌ := volume.restrict (Metric.ball (0:β) 1)) | |
| (C := M) (f := fun z : β => g (x+t β’ z)) (ae_of_all _ (fun z => by simpa only [Real.norm_eq_abs] using hM (x+t β’ z))) | |
| have hv : (volume.restrict (Metric.ball (0:β) 1)).real univ = Real.pi := by | |
| simp [measureReal_def,Complex.volume_ball] | |
| rw [hv,Real.norm_eq_abs] at hi | |
| exact (div_le_iffβ Real.pi_pos).mpr hi | |
| def oscillationSet (g : β β β) (r : β) (x : β) : Set β := | |
| {a | β t t', 0 < t β§ t β€ 4*r β§ 0 < t' β§ t' β€ 4*r β§ a = |signedAverage g x t-signedAverage g x t'|} | |
| def oscillation (g : β β β) (r : β) (x : β) : β := sSup (oscillationSet g r x) | |
| lemma oscillationSet_zero (g : β β β) {r : β} (hr : 0 < r) (x : β) : | |
| 0 β oscillationSet g r x := β¨r,r,hr,by linarith,hr,by linarith,by simpβ© | |
| lemma oscillationSet_bdd {g : β β β} (hg : Continuous g) (hc : HasCompactSupport g) (r : β) (x : β) : | |
| BddAbove (oscillationSet g r x) := by | |
| obtain β¨M,hMβ© := hc.exists_bound_of_continuous hg | |
| refine β¨2*M,?_β© | |
| rintro a β¨t,t',ht,_,ht',_,rflβ© | |
| have hb : β y, |g y| β€ M := by simpa only [Real.norm_eq_abs] using hM | |
| have h1 := signedAverage_abs_le hb x ht | |
| have h2 := signedAverage_abs_le hb x ht' | |
| linarith [abs_sub (signedAverage g x t) (signedAverage g x t')] | |
| lemma oscillation_nonneg {g : β β β} (hg : Continuous g) (hc : HasCompactSupport g) {r : β} | |
| (hr : 0 < r) (x : β) : 0 β€ oscillation g r x := | |
| le_csSup (oscillationSet_bdd hg hc r x) (oscillationSet_zero g hr x) | |
| lemma le_oscillation {g : β β β} (hg : Continuous g) (hc : HasCompactSupport g) {r : β} | |
| (x : β) {t t' : β} (ht : 0 < t) (hb : t β€ 4*r) (ht' : 0 < t') (hb' : t' β€ 4*r) : | |
| |signedAverage g x t-signedAverage g x t'| β€ oscillation g r x := | |
| le_csSup (oscillationSet_bdd hg hc r x) β¨t,t',ht,hb,ht',hb',rflβ© | |
| lemma oscillation_majorant {g : β β β} {r : β} (hr : 0 < r) (x : β) {F : ββ₯0β} | |
| (hF : β t t', 0 < t β t β€ 4*r β 0 < t' β t' β€ 4*r β | |
| ENNReal.ofReal |signedAverage g x t-signedAverage g x t'| β€ F) : | |
| ENNReal.ofReal (oscillation g r x) β€ F := by | |
| by_cases htop : F = β€ | |
| Β· simp only [htop,le_top] | |
| Β· apply (ENNReal.ofReal_le_iff_le_toReal htop).mpr | |
| apply csSup_le β¨0,oscillationSet_zero g hr xβ© | |
| rintro a β¨t,t',ht,hb,ht',hb',rflβ© | |
| exact (ENNReal.ofReal_le_iff_le_toReal htop).mp (hF t t' ht hb ht' hb') | |
| end DiskMoments | |
| end | |
| end OAI | |