Download data/lean/OAI/Geometry/CubicTorus/Regularity/BVNormalTiltMeasure.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 40.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/CubicTorus/Regularity/BVNormalTiltMeasure.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/CubicTorus/Regularity/BVNormalTiltMeasure.lean
-
curl -L -o BVNormalTiltMeasure.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/CubicTorus/Regularity/BVNormalTiltMeasure.lean
40.1 kB
| import Mathlib | |
| import OAI.Geometry.CubicTorus.Regularity.BVLipschitzGraph | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter Metric | |
| open scoped ENNReal Topology RealInnerProductSpace | |
| namespace CubicTorus | |
| lemma integral_sq_cauchy_finite {Ξ± : Type*} [MeasurableSpace Ξ±] (Ξ½ : Measure Ξ±) [IsFiniteMeasure Ξ½] | |
| {f : Ξ± β β} (hf : Integrable f Ξ½) (hf2 : Integrable (fun x β¦ f x ^ 2) Ξ½) : | |
| (β« x, f x βΞ½) ^ 2 β€ Ξ½.real univ * β« x, f x ^ 2 βΞ½ := by | |
| by_cases hzero : Ξ½ univ = 0 | |
| Β· rw [Measure.measure_univ_eq_zero.mp hzero] | |
| simp | |
| have hmass : 0 < Ξ½.real univ := ENNReal.toReal_pos hzero (measure_ne_top _ _) | |
| let m := (β« x, f x βΞ½) / Ξ½.real univ | |
| have hpoly : 0 β€ (β« x, f x ^ 2 βΞ½) - (2 * m) * (β« x, f x βΞ½) + Ξ½.real univ * m ^ 2 := by | |
| have hh : 0 β€ β« x, (f x - m) ^ 2 βΞ½ := integral_nonneg (fun _ β¦ sq_nonneg _) | |
| have he : (fun x β¦ (f x - m) ^ 2) = (fun x β¦ (f x ^ 2 - (2 * m) * f x) + m ^ 2) := by | |
| funext x | |
| ring | |
| have hip : Integrable (fun x β¦ f x ^ 2 - (2 * m) * f x) Ξ½ := hf2.sub (hf.const_mul (2 * m)) | |
| rw [he, integral_add hip (integrable_const (m ^ 2)), | |
| integral_sub hf2 (hf.const_mul (2 * m)), integral_const_mul, integral_const, smul_eq_mul] at hh | |
| exact hh | |
| have he : Ξ½.real univ * ((β« x, f x ^ 2 βΞ½) - (2 * m) * (β« x, f x βΞ½) + Ξ½.real univ * m ^ 2) = | |
| Ξ½.real univ * (β« x, f x ^ 2 βΞ½) - (β« x, f x βΞ½) ^ 2 := by | |
| dsimp [m] | |
| field_simp | |
| ring | |
| have hh := mul_nonneg hmass.le hpoly | |
| rw [he] at hh | |
| linarith | |
| lemma normalOscillation_sq_le_excess (Ο : FiniteMeasure Torus) {N : Torus β Cover} (hN : Measurable N) | |
| (hn : βα΅ x β(Ο : Measure Torus), βN xβ = 1) {n : Cover} (hnorm : βnβ = 1) | |
| (a : Torus) {r A : β} (hr : 0 < r) | |
| (hmass : (Ο : Measure Torus).real (Metric.closedBall a r) β€ A * r ^ 2) : | |
| normalOscillation Ο N a n r ^ 2 β€ A * normalExcess Ο N a n r := by | |
| have hi : Integrable (fun x β¦ βN x - nβ) (Ο : Measure Torus) := by | |
| apply Integrable.of_bound (hN.sub_const _).norm.aestronglyMeasurable 2 | |
| filter_upwards [hn] with x hx | |
| rw [Real.norm_of_nonneg (norm_nonneg _)] | |
| simpa only [hx, hnorm, one_add_one_eq_two] using norm_sub_le (N x) n | |
| have hi2 : Integrable (fun x β¦ βN x - nβ ^ 2) (Ο : Measure Torus) := by | |
| apply Integrable.of_bound ((hN.sub_const _).norm.pow_const 2).aestronglyMeasurable 4 | |
| filter_upwards [hn] with x hx | |
| rw [Real.norm_of_nonneg (sq_nonneg _)] | |
| have hb : βN x - nβ β€ 2 := by simpa only [hx, hnorm, one_add_one_eq_two] using norm_sub_le (N x) n | |
| nlinarith [norm_nonneg (N x - n)] | |
| have hc := integral_sq_cauchy_finite ((Ο : Measure Torus).restrict (Metric.closedBall a r)) | |
| hi.integrableOn hi2.integrableOn | |
| rw [Measure.real_def, Measure.restrict_apply_univ] at hc | |
| have hh := hc.trans (mul_le_mul_of_nonneg_right hmass (integral_nonneg fun _ β¦ sq_nonneg _)) | |
| rw [normalOscillation, normalExcess] | |
| apply (mul_le_mul_iff_rightβ (pow_pos hr 4)).mp | |
| convert hh using 1 <;> field_simp | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter Metric | |
| open scoped ENNReal Topology RealInnerProductSpace | |
| namespace CubicTorus | |
| lemma integrable_sq_norm_sub_normal {Ο : FiniteMeasure Torus} {N : Torus β Cover} (hN : Measurable N) | |
| (hn : βα΅ x β(Ο : Measure Torus), βN xβ = 1) (n : Cover) : | |
| Integrable (fun x β¦ βN x - nβ ^ 2) (Ο : Measure Torus) := by | |
| apply Integrable.of_bound ((hN.sub_const n).norm.pow_const 2).aestronglyMeasurable ((1 + βnβ) ^ 2) | |
| filter_upwards [hn] with x hx | |
| rw [Real.norm_of_nonneg (sq_nonneg _)] | |
| apply pow_le_pow_leftβ (norm_nonneg _) | |
| simpa only [hx] using norm_sub_le (N x) n | |
| def normalTiltMeasure (Ο : FiniteMeasure Torus) (N : Torus β Cover) (n : Cover) : Measure Torus := | |
| (Ο : Measure Torus).withDensity (fun x β¦ ENNReal.ofReal (βN x - nβ ^ 2)) | |
| lemma normalTiltMeasure_apply {Ο : FiniteMeasure Torus} {N : Torus β Cover} (hN : Measurable N) | |
| (hn : βα΅ x β(Ο : Measure Torus), βN xβ = 1) (n : Cover) {S : Set Torus} (hS : MeasurableSet S) : | |
| normalTiltMeasure Ο N n S = ENNReal.ofReal (β« x in S, βN x - nβ ^ 2 β(Ο : Measure Torus)) := by | |
| rw [normalTiltMeasure, withDensity_apply _ hS] | |
| exact (ofReal_integral_eq_lintegral_ofReal (integrable_sq_norm_sub_normal hN hn n).integrableOn | |
| (Eventually.of_forall fun _ β¦ sq_nonneg _)).symm | |
| lemma normalExcess_bad_set_measure {Ο : FiniteMeasure Torus} {N : Torus β Cover} (hN : Measurable N) | |
| (hn : βα΅ x β(Ο : Measure Torus), βN xβ = 1) (n : Cover) | |
| {R A Ξ΄ Ο : β} (hA : 0 < A) (hΞ΄ : 0 < Ξ΄) (_hΟ : 0 < Ο) (hΟR : 80 * Ο β€ R) | |
| (hu : β a : Torus, β r : β, 0 < r β r β€ R β | |
| (Ο : Measure Torus).real (Metric.ball a r) β€ A * r ^ 2) | |
| (a : Torus) (B : Set Torus) (hB : B β Metric.ball a Ο) | |
| (hbad : β c β B, β r : β, 0 < r β§ r β€ 16 * Ο β§ Ξ΄ β€ normalExcess Ο N c n r) : | |
| (Ο : Measure Torus) B β€ ENNReal.ofReal (25 * A / Ξ΄) * | |
| ENNReal.ofReal (β« x in Metric.closedBall a (17 * Ο), βN x - nβ ^ 2 β(Ο : Measure Torus)) := by | |
| let Ο := (normalTiltMeasure Ο N n).restrict (Metric.closedBall a (17 * Ο)) | |
| have hbad' : β c β B, β r : β, 0 < r β§ 5 * r β€ R β§ | |
| ENNReal.ofReal (Ξ΄ * r ^ 2) β€ Ο (Metric.closedBall c r) := by | |
| intro c hc | |
| obtain β¨r, hr, hr16, heβ© := hbad c hc | |
| refine β¨r, hr, by linarith, ?_β© | |
| have hsub : Metric.closedBall c r β Metric.closedBall a (17 * Ο) := by | |
| intro x hx | |
| have hca : dist c a < Ο := hB hc | |
| have hxc : dist x c β€ r := hx | |
| exact show dist x a β€ 17 * Ο from by linarith [dist_triangle x c a] | |
| have henergy : Ξ΄ * r ^ 2 β€ β« x in Metric.closedBall c r, βN x - nβ ^ 2 β(Ο : Measure Torus) := | |
| (le_div_iffβ (sq_pos_of_pos hr)).mp he | |
| dsimp only [Ο] | |
| rw [Measure.restrict_apply Metric.isClosed_closedBall.measurableSet, inter_eq_left.mpr hsub, | |
| normalTiltMeasure_apply hN hn n Metric.isClosed_closedBall.measurableSet] | |
| exact ENNReal.ofReal_le_ofReal henergy | |
| have hh := measure_bad_scales_le Ο Ο B hA hΞ΄ hu hbad' | |
| simpa only [Ο, Measure.restrict_apply_univ, | |
| normalTiltMeasure_apply hN hn n Metric.isClosed_closedBall.measurableSet] using hh | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter Metric | |
| open scoped ENNReal NNReal Topology RealInnerProductSpace | |
| namespace CubicTorus | |
| theorem normalMeasure_lipschitz_approximation {E B : Set Torus} (hE : MeasurableSet E) | |
| {ΞΌ : FiniteMeasure NormalBundle} (hΞΌ : IsNormalMeasure E ΞΌ) {N : Torus β Cover} (hN : Measurable N) | |
| (hpolar : βα΅ z β(ΞΌ : Measure NormalBundle), N (quotientMap z.1) = (z.2 : Cover)) | |
| (hn : βα΅ x β(spatialNormalMeasure ΞΌ : Measure Torus), βN xβ = 1) | |
| {D Ξ΄ R A : β} (hΞ΄ : 0 < Ξ΄) (hA : 0 < A) | |
| (hd : β a β B, β t : β, 0 < t β t β€ D β | |
| Ξ΄ * t ^ 3 β€ torusVolume.real (E β© Metric.ball a t) β§ | |
| Ξ΄ * t ^ 3 β€ torusVolume.real (EαΆ β© Metric.ball a t)) | |
| (hu : β a : Torus, β r : β, 0 < r β r β€ R β | |
| (spatialNormalMeasure ΞΌ : Measure Torus).real (Metric.ball a r) β€ A * r ^ 2) | |
| {Ο Ξ΅ Ξ² : β} (hΟ : 0 < Ο) (hΟsmall : Ο β€ 1 / 32) (hΟD : 2 * Ο β€ D) (hΟR : 80 * Ο β€ R) | |
| (hΞ΅ : 0 < Ξ΅) (hΞ΅half : Ξ΅ β€ 1 / 2) (hΞ² : 0 < Ξ²) | |
| (hΞ²small : (131072 : β) ^ 2 * (4 * A) * Ξ² β€ (Ξ΄ ^ 2 * (Ξ΅ / 8) ^ 6) ^ 2) | |
| (a : Torus) {n : Cover} (hnorm : βnβ = 1) : | |
| β S : Set Torus, S β B β© Metric.ball a (Ο / 2) β§ | |
| (spatialNormalMeasure ΞΌ : Measure Torus) ((B β© Metric.ball a (Ο / 2)) \ S) β€ | |
| ENNReal.ofReal (25 * A / Ξ²) * | |
| ENNReal.ofReal (β« x in Metric.closedBall a (17 * Ο), βN x - nβ ^ 2 | |
| β(spatialNormalMeasure ΞΌ : Measure Torus)) β§ | |
| β g : Cover β β, LipschitzWith β¨2 * Ξ΅, by positivityβ© g β§ | |
| β x β S, g (normalPlaneProjection n (shortestLift (x - a))) = | |
| βͺn, shortestLift (x - a)β« := by | |
| let Ο := spatialNormalMeasure ΞΌ | |
| let S := {c : Torus | c β B β© Metric.ball a (Ο / 2) β§ | |
| β s : β, 0 < s β s β€ 16 * Ο β normalExcess Ο N c n s < Ξ²} | |
| have hS : S β B β© Metric.ball a (Ο / 2) := fun _ hc β¦ hc.1 | |
| have hgood (c : Torus) (hc : c β S) : β y β B, dist y c β€ Ο β | |
| |βͺn, shortestLift (y - c)β«| β€ Ξ΅ * dist y c := by | |
| apply good_scales_boundary_cone hE hΞΌ hN hpolar hn hΞ΄ hd hc.1.1 hnorm hΟsmall hΟD hΞ΅ (by linarith) | |
| intro s hs hs16 | |
| have hmass := (measureReal_mono (Metric.closedBall_subset_ball (by linarith : s < 2 * s))).trans | |
| (hu c (2 * s) (by positivity) (by linarith)) | |
| have hmass' : (Ο : Measure Torus).real (Metric.closedBall c s) β€ (4 * A) * s ^ 2 := by | |
| change (Ο : Measure Torus).real (Metric.closedBall c s) β€ A * (2 * s) ^ 2 at hmass | |
| nlinarith | |
| have ho := normalOscillation_sq_le_excess Ο hN hn hnorm c hs hmass' | |
| have he := hc.2 s hs hs16 | |
| have hh := ho.trans_lt (mul_lt_mul_of_pos_left he (by positivity : 0 < 4 * A)) | |
| have hh' := mul_lt_mul_of_pos_left hh (by norm_num : (0 : β) < 131072 ^ 2) | |
| have hT : 0 < Ξ΄ ^ 2 * (Ξ΅ / 8) ^ 6 := by positivity | |
| have hnosc := normalOscillation_nonneg Ο N c n s | |
| nlinarith | |
| have hbad : β c β (B β© Metric.ball a (Ο / 2)) \ S, β r : β, | |
| 0 < r β§ r β€ 16 * Ο β§ Ξ² β€ normalExcess Ο N c n r := by | |
| intro c hc | |
| have hh : Β¬ β s : β, 0 < s β s β€ 16 * Ο β normalExcess Ο N c n s < Ξ² := by | |
| intro hh | |
| exact hc.2 β¨hc.1, hhβ© | |
| push Not at hh | |
| exact hh | |
| have hbadmass := normalExcess_bad_set_measure hN hn n hA hΞ² hΟ hΟR hu a | |
| ((B β© Metric.ball a (Ο / 2)) \ S) | |
| (fun c hc β¦ (Metric.ball_subset_ball (by linarith : Ο / 2 β€ Ο)) hc.1.2) hbad | |
| have hSsmall : S β Metric.ball a (1 / 4) := | |
| hS.trans (inter_subset_right.trans (Metric.ball_subset_ball (by linarith))) | |
| have hcone : β x β S, β y β S, |βͺn, shortestLift (x - y)β«| β€ Ξ΅ * dist x y := by | |
| intro x hx y hy | |
| apply hgood y hy x hx.1.1 | |
| have hxa : dist x a < Ο / 2 := hx.1.2 | |
| have hya : dist y a < Ο / 2 := hy.1.2 | |
| linarith [dist_triangle_right x y a] | |
| obtain β¨g, hg, hgeqβ© := exists_lipschitz_height_of_cone | |
| ((fun z β¦ shortestLift (z - a)) '' S) hnorm hΞ΅.le hΞ΅half (lifted_cone_of_torus_cone hSsmall hcone) | |
| exact β¨S, hS, hbadmass, g, hg, fun x hx β¦ hgeq _ β¨x, hx, rflβ©β© | |
| theorem isMinimizerAt_lipschitz_approximation {V : β} (hV : V β Ioo 0 1) | |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) | |
| {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) (hΞ΅half : Ξ΅ β€ 1 / 2) : | |
| β Οβ C : β, 0 < Οβ β§ 0 < C β§ | |
| β ΞΌ : FiniteMeasure NormalBundle, IsNormalMeasure E ΞΌ β | |
| β N : Torus β Cover, Measurable N β | |
| (βα΅ z β(ΞΌ : Measure NormalBundle), N (quotientMap z.1) = (z.2 : Cover)) β | |
| (βα΅ x β(spatialNormalMeasure ΞΌ : Measure Torus), βN xβ = 1) β | |
| β (a : Torus) (n : Cover), βnβ = 1 β β Ο : β, 0 < Ο β Ο β€ Οβ β | |
| β S : Set Torus, S β frontier (openRepresentative E) β© Metric.ball a (Ο / 2) β§ | |
| (spatialNormalMeasure ΞΌ : Measure Torus) | |
| ((frontier (openRepresentative E) β© Metric.ball a (Ο / 2)) \ S) β€ | |
| ENNReal.ofReal C * ENNReal.ofReal | |
| (β« x in Metric.closedBall a (17 * Ο), βN x - nβ ^ 2 | |
| β(spatialNormalMeasure ΞΌ : Measure Torus)) β§ | |
| β g : Cover β β, LipschitzWith β¨2 * Ξ΅, by positivityβ© g β§ | |
| β x β S, g (normalPlaneProjection n (shortestLift (x - a))) = | |
| βͺn, shortestLift (x - a)β« := by | |
| obtain β¨D, Ξ΄, hD, hΞ΄, hdβ© := isMinimizerAt_two_sided_density hV hE hmin | |
| obtain β¨R, A, hR, hA, huβ© := isMinimizerAt_perimeter_upper_density hV hE hmin | |
| let Ξ² := (Ξ΄ ^ 2 * (Ξ΅ / 8) ^ 6) ^ 2 / ((131072 : β) ^ 2 * (4 * A)) | |
| have hΞ² : 0 < Ξ² := by dsimp [Ξ²]; positivity | |
| let Οβ := min (1 / 32 : β) (min (D / 2) (R / 80)) | |
| have hΟβ : 0 < Οβ := by dsimp [Οβ]; positivity | |
| refine β¨Οβ, 25 * A / Ξ², hΟβ, by positivity, ?_β© | |
| intro ΞΌ hΞΌ N hN hp hn a n hnorm Ο hΟ hΟle | |
| have hd' : β a β frontier (openRepresentative E), β t : β, 0 < t β t β€ D β | |
| Ξ΄ * t ^ 3 β€ torusVolume.real (E β© Metric.ball a t) β§ | |
| Ξ΄ * t ^ 3 β€ torusVolume.real (EαΆ β© Metric.ball a t) := by | |
| rw [isMinimizerAt_frontier_openRepresentative hV hE hmin] | |
| exact hd | |
| apply normalMeasure_lipschitz_approximation hE hΞΌ hN hp hn hΞ΄ hA hd' (hu ΞΌ hΞΌ) | |
| hΟ (hΟle.trans (min_le_left _ _)) | |
| (by have := hΟle.trans ((min_le_right _ _).trans (min_le_left _ _)); linarith) | |
| (by have := hΟle.trans ((min_le_right _ _).trans (min_le_right _ _)); linarith) | |
| hΞ΅ hΞ΅half hΞ² | |
| Β· dsimp [Ξ²] | |
| have hden : (131072 : β) ^ 2 * (4 * A) β 0 := by positivity | |
| rw [mul_div_cancelβ _ hden] | |
| Β· exact hnorm | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter Metric | |
| open scoped ENNReal NNReal Topology RealInnerProductSpace | |
| namespace CubicTorus | |
| lemma volume_zero_of_nonzero_constant_derivative | |
| {X : Type*} [NormedAddCommGroup X] [NormedSpace β X] [FiniteDimensional β X] | |
| [MeasurableSpace X] [BorelSpace X] (Ξ½ : Measure X) [Measure.IsAddHaarMeasure Ξ½] | |
| (S : Set X) (L : X β X βL[β] β) | |
| (hL : β x β S, HasFDerivWithinAt (fun _ : X β¦ (0 : β)) (L x) S x) | |
| (hne : β x β S, L x β 0) : Ξ½ S = 0 := by | |
| classical | |
| have hex : β x : S, β v : X, L x v = 1 := by | |
| intro x | |
| have hh : β w : X, L x w β 0 := by | |
| by_contra! hh | |
| apply hne x x.property | |
| ext w | |
| exact hh w | |
| obtain β¨w, hwβ© := hh | |
| exact β¨(L x w)β»ΒΉ β’ w, by simp [hw]β© | |
| choose v hv using hex | |
| let A : X β X βL[β] X := fun x β¦ if hx : x β S then | |
| ContinuousLinearMap.id β X - (L x).smulRight (v β¨x, hxβ©) else 0 | |
| have hA : β x β S, HasFDerivWithinAt (fun y : X β¦ y) (A x) S x := by | |
| intro x hx | |
| dsimp only [A] | |
| rw [dite_eq_left hx] | |
| convert (hasFDerivWithinAt_id x S).sub ((hL x hx).smul_const (v β¨x, hxβ©)) using 1 | |
| funext y | |
| simp | |
| have hdet : β x β S, (A x).det = 0 := by | |
| intro x hx | |
| apply LinearMap.det_eq_zero_iff_ker_ne_bot.mpr | |
| intro hker | |
| have hvne : v β¨x, hxβ© β 0 := by | |
| intro hh | |
| have hh' := hv β¨x, hxβ© | |
| rw [hh, map_zero] at hh' | |
| norm_num at hh' | |
| have hmem : v β¨x, hxβ© β (A x).toLinearMap.ker := by | |
| change A x (v β¨x, hxβ©) = 0 | |
| have hvx := hv β¨x, hxβ© | |
| change L x (v β¨x, hxβ©) = 1 at hvx | |
| simp [A, hx, hvx] | |
| rw [hker] at hmem | |
| exact hvne hmem | |
| have hh := addHaar_image_eq_zero_of_det_fderivWithin_eq_zero Ξ½ hA hdet | |
| simpa only [image_id'] using hh | |
| lemma ae_constant_derivative_eq_zero | |
| {X : Type*} [NormedAddCommGroup X] [NormedSpace β X] [FiniteDimensional β X] | |
| [MeasurableSpace X] [BorelSpace X] (Ξ½ : Measure X) [Measure.IsAddHaarMeasure Ξ½] | |
| (S : Set X) (L : X β X βL[β] β) | |
| (hL : β x β S, HasFDerivWithinAt (fun _ : X β¦ (0 : β)) (L x) S x) : | |
| βα΅ x βΞ½, x β S β L x = 0 := by | |
| rw [ae_iff] | |
| have hh := volume_zero_of_nonzero_constant_derivative Ξ½ {x β S | L x β 0} L | |
| (fun x hx β¦ (hL x hx.1).mono (sep_subset _ _)) (fun _ hx β¦ hx.2) | |
| simpa only [Classical.not_imp] using hh | |
| def normalPlaneLinearIsometry (n : Cover) : Plane ββα΅’[β] Cover where | |
| toFun := normalPlaneEmbedding n | |
| map_add' y z := by | |
| simp only [normalPlaneEmbedding, normalProductChart_apply] | |
| rw [β map_add] | |
| congr 1 | |
| ext i | |
| refine Fin.cases ?_ (fun j β¦ ?_) i <;> simp | |
| map_smul' t y := by | |
| simp only [normalPlaneEmbedding, normalProductChart_apply, RingHom.id_apply] | |
| rw [β map_smul] | |
| congr 1 | |
| ext i | |
| refine Fin.cases ?_ (fun j β¦ ?_) i <;> simp | |
| norm_map' := normalPlaneEmbedding_norm n | |
| lemma normalPlaneEmbedding_inner {n : Cover} (hn : βnβ = 1) (y : Plane) : | |
| βͺn, normalPlaneEmbedding n yβ« = 0 := normalProductChart_inner hn 0 _ | |
| def normalGraph (n : Cover) (g : Plane β β) (y : Plane) : Cover := | |
| normalPlaneEmbedding n y + g y β’ n | |
| lemma normalGraph_lipschitz {n : Cover} (hn : βnβ = 1) {g : Plane β β} {K : ββ₯0} | |
| (hg : LipschitzWith K g) : LipschitzWith (1 + K) (normalGraph n g) := by | |
| apply LipschitzWith.of_dist_le_mul | |
| intro x y | |
| have he : normalGraph n g x - normalGraph n g y = | |
| normalPlaneEmbedding n (x - y) + (g x - g y) β’ n := by | |
| change normalPlaneLinearIsometry n x + g x β’ n - | |
| (normalPlaneLinearIsometry n y + g y β’ n) = _ | |
| rw [show normalPlaneEmbedding n (x - y) = | |
| normalPlaneLinearIsometry n x - normalPlaneLinearIsometry n y from (normalPlaneLinearIsometry n).map_sub x y, sub_smul] | |
| abel | |
| have hh := norm_add_le (normalPlaneEmbedding n (x - y)) ((g x - g y) β’ n) | |
| rw [normalPlaneEmbedding_norm, norm_smul, hn, mul_one] at hh | |
| have hb := hg.norm_sub_le x y | |
| rw [dist_eq_norm, he, dist_eq_norm] | |
| change βnormalPlaneEmbedding n (x - y) + (g x - g y) β’ nβ β€ (1 + (K : β)) * βx - yβ | |
| linarith | |
| lemma normalGraph_inner {n : Cover} (hn : βnβ = 1) (g : Plane β β) (y : Plane) : | |
| βͺn, normalGraph n g yβ« = g y := by | |
| simp [normalGraph, inner_add_right, normalPlaneEmbedding_inner hn, | |
| inner_smul_right, hn] | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology RealInnerProductSpace | |
| open Laplacian | |
| namespace CubicTorus | |
| lemma fderiv_gradient_inner {f : Cover β β} (hf : ContDiff β (β€ : ββ) f) | |
| (x u v : Cover) : | |
| βͺfderiv β (gradient f) x u, vβ« = fderiv β (fderiv β f) x u v := by | |
| have hd := (hf.fderiv_right (m := (β€ : ββ)) (by simp)).differentiable (by simp) | |
| have hh := ((InnerProductSpace.toDual β Cover).symm.toContinuousLinearEquiv.toContinuousLinearMap.hasFDerivAt.comp | |
| x (hd x).hasFDerivAt).fderiv | |
| change fderiv β (gradient f) x = _ at hh | |
| rw [hh] | |
| change βͺ(InnerProductSpace.toDual β Cover).symm (fderiv β (fderiv β f) x u), vβ« = _ | |
| exact InnerProductSpace.toDual_symm_apply | |
| lemma divergence_gradient_eq_laplacian {f : Cover β β} | |
| (hf : ContDiff β (β€ : ββ) f) (x : Cover) : | |
| divergence (gradient f) x = Ξ f x := by | |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis f | |
| (EuclideanSpace.basisFun (Fin 3) β)] | |
| unfold divergence | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [EuclideanSpace.basisFun_apply, iteratedFDeriv_two_apply] | |
| simpa only [Matrix.cons_val_zero, Matrix.cons_val_one, EuclideanSpace.inner_single_right, | |
| RCLike.conj_to_real, mul_one, one_mul] using | |
| fderiv_gradient_inner hf x (EuclideanSpace.single i 1) (EuclideanSpace.single i 1) | |
| lemma laplacian_comp_isometry {X Y : Type*} [NormedAddCommGroup X] | |
| [InnerProductSpace β X] [FiniteDimensional β X] | |
| [NormedAddCommGroup Y] [InnerProductSpace β Y] [FiniteDimensional β Y] | |
| (L : X ββα΅’[β] Y) {f : Y β β} (hf : ContDiff β (β€ : ββ) f) (x : X) : | |
| Ξ (f β L) x = Ξ f (L x) := by | |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis (f β L) | |
| (stdOrthonormalBasis β X), | |
| InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis f | |
| ((stdOrthonormalBasis β X).map L)] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| have hh := L.toContinuousLinearEquiv.toContinuousLinearMap.iteratedFDeriv_comp_right hf x | |
| (ENat.natCast_le_of_coe_top_le_withTop le_rfl 2) | |
| have hh' := congrArg (fun A β¦ A ![(stdOrthonormalBasis β X) i, | |
| (stdOrthonormalBasis β X) i]) hh | |
| have hv : (fun j : Fin 2 β¦ L (![ (stdOrthonormalBasis β X) i, | |
| (stdOrthonormalBasis β X) i] j)) = | |
| ![L ((stdOrthonormalBasis β X) i), L ((stdOrthonormalBasis β X) i)] := by | |
| funext j | |
| fin_cases j <;> rfl | |
| simpa [ContinuousMultilinearMap.compContinuousLinearMap_apply, Function.comp_def, hv] using hh' | |
| lemma iteratedFDeriv_two_line {X : Type*} [NormedAddCommGroup X] | |
| [NormedSpace β X] {f : X β β} (hf : ContDiff β (β€ : ββ) f) | |
| (x u : X) : | |
| iteratedFDeriv β 2 f x ![u, u] = | |
| iteratedDeriv 2 (fun t : β β¦ f (x + t β’ u)) 0 := by | |
| let L : β βL[β] X := (ContinuousLinearMap.id β β).smulRight u | |
| have ht : ContDiff β (β€ : ββ) (fun y β¦ f (x + y)) := | |
| hf.comp (contDiff_const.add contDiff_id) | |
| have hh := L.iteratedFDeriv_comp_right ht 0 | |
| (ENat.natCast_le_of_coe_top_le_withTop le_rfl 2) | |
| have hh' := congrArg (fun A β¦ A (fun _ : Fin 2 β¦ (1 : β))) hh | |
| have hv : (fun _ : Fin 2 β¦ u) = ![u, u] := by | |
| funext j | |
| fin_cases j <;> rfl | |
| simpa [iteratedDeriv, L, Function.comp_def, iteratedFDeriv_comp_add_left, | |
| ContinuousMultilinearMap.compContinuousLinearMap_apply, hv] using hh'.symm | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology RealInnerProductSpace | |
| open Laplacian | |
| namespace CubicTorus | |
| variable {X : Type*} [NormedAddCommGroup X] [InnerProductSpace β X] | |
| [FiniteDimensional β X] [MeasurableSpace X] [BorelSpace X] | |
| {ΞΌ : Measure X} [ΞΌ.IsAddHaarMeasure] | |
| lemma integral_compact_fderiv_zero {f : X β β} | |
| (hf : ContDiff β (β€ : ββ) f) (hs : HasCompactSupport f) (v : X) : | |
| (β« x, fderiv β f x v βΞΌ) = 0 := by | |
| have hi : Integrable (fun x β¦ fderiv β f x v) ΞΌ := | |
| ((hf.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport | |
| (hs.fderiv_apply β v) | |
| have hh := integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable | |
| (ΞΌ := ΞΌ) (f := fun _ : X β¦ (1 : β)) (g := f) (v := v) | |
| (by simp) | |
| (by simpa using hi) (by simpa using hf.continuous.integrable_of_hasCompactSupport hs) | |
| (fun _ _ β¦ differentiableAt_const 1) (fun _ _ β¦ hf.differentiable (by simp) |>.differentiableAt) | |
| simpa using hh | |
| omit [FiniteDimensional β X] [MeasurableSpace X] [BorelSpace X] in | |
| lemma fderiv_fderiv_apply {f : X β β} (hf : ContDiff β (β€ : ββ) f) | |
| (x u v : X) : | |
| fderiv β (fun y β¦ fderiv β f y v) x u = fderiv β (fderiv β f) x u v := by | |
| rw [fderiv_clm_apply ((hf.fderiv_right (m := (β€ : ββ)) (by simp)).differentiable | |
| (by simp) |>.differentiableAt) (differentiableAt_const v)] | |
| simp | |
| omit [MeasurableSpace X] [BorelSpace X] in | |
| lemma laplacian_eq_sum_directional {f : X β β} | |
| (hf : ContDiff β (β€ : ββ) f) (x : X) : | |
| Ξ f x = β i, fderiv β (fun y β¦ fderiv β f y ((stdOrthonormalBasis β X) i)) x | |
| ((stdOrthonormalBasis β X) i) := by | |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [iteratedFDeriv_two_apply, fderiv_fderiv_apply hf] | |
| rfl | |
| omit [MeasurableSpace X] [BorelSpace X] in | |
| lemma compact_laplacian_continuous {f : X β β} (hf : ContDiff β (β€ : ββ) f) : | |
| Continuous (Ξ f) := by | |
| have he : Ξ f = fun x β¦ β i, fderiv β (fun y β¦ fderiv β f y | |
| ((stdOrthonormalBasis β X) i)) x ((stdOrthonormalBasis β X) i) := | |
| funext (laplacian_eq_sum_directional hf) | |
| rw [he] | |
| apply continuous_finsetSum | |
| intro i _ | |
| have ht := (hf.fderiv_right (m := (β€ : ββ)) (by simp)).clm_apply (contDiff_const | |
| (c := (stdOrthonormalBasis β X) i)) | |
| exact (ht.continuous_fderiv (by simp)).clm_apply continuous_const | |
| omit [MeasurableSpace X] [BorelSpace X] in | |
| lemma laplacian_tsupport_subset {f : X β β} (hf : ContDiff β (β€ : ββ) f) : | |
| tsupport (Ξ f) β tsupport f := by | |
| apply closure_minimal _ isClosed_closure | |
| intro x hx | |
| by_contra hn | |
| apply hx | |
| rw [laplacian_eq_sum_directional hf] | |
| apply Finset.sum_eq_zero | |
| intro i _ | |
| rw [fderiv_of_notMem_tsupport β (fun hh β¦ hn ((tsupport_fderiv_apply_subset β _ ) hh))] | |
| rfl | |
| lemma integral_compact_laplacian_zero {f : X β β} | |
| (hf : ContDiff β (β€ : ββ) f) (hs : HasCompactSupport f) : | |
| (β« x, Ξ f x βΞΌ) = 0 := by | |
| have hd (i : Fin (Module.finrank β X)) : ContDiff β (β€ : ββ) | |
| (fun x β¦ fderiv β f x ((stdOrthonormalBasis β X) i)) := | |
| (hf.fderiv_right (m := (β€ : ββ)) (by simp)).clm_apply contDiff_const | |
| simp_rw [laplacian_eq_sum_directional hf] | |
| rw [integral_finsetSum] | |
| Β· apply Finset.sum_eq_zero | |
| intro i _ | |
| exact integral_compact_fderiv_zero (hd i) (hs.fderiv_apply β _) _ | |
| Β· intro i _ | |
| exact (((hd i).continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport | |
| ((hs.fderiv_apply β _).fderiv_apply β _) | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology RealInnerProductSpace Convolution | |
| open Laplacian | |
| namespace CubicTorus | |
| variable {X : Type*} [NormedAddCommGroup X] [InnerProductSpace β X] | |
| [FiniteDimensional β X] [MeasurableSpace X] [BorelSpace X] | |
| {ΞΌ : Measure X} [ΞΌ.IsAddHaarMeasure] | |
| lemma fderiv_compact_convolution {f k : X β β} (hf : LocallyIntegrable f ΞΌ) | |
| (hk : ContDiff β (β€ : ββ) k) (hs : HasCompactSupport k) (x v : X) : | |
| fderiv β (f β[ContinuousLinearMap.mul β β, ΞΌ] k) x v = | |
| (f β[ContinuousLinearMap.mul β β, ΞΌ] (fun y β¦ fderiv β k y v)) x := by | |
| rw [(hs.hasFDerivAt_convolution_right (ContinuousLinearMap.mul β β) hf | |
| (hk.of_le (by simp)) x).fderiv] | |
| exact convolution_precompR_apply (ContinuousLinearMap.mul β β) hf (hs.fderiv β) | |
| (hk.continuous_fderiv (by simp)) x v | |
| theorem laplacian_compact_convolution {f k : X β β} (hf : LocallyIntegrable f ΞΌ) | |
| (hk : ContDiff β (β€ : ββ) k) (hs : HasCompactSupport k) (x : X) : | |
| Ξ (f β[ContinuousLinearMap.mul β β, ΞΌ] k) x = | |
| (f β[ContinuousLinearMap.mul β β, ΞΌ] Ξ k) x := by | |
| have hc := hs.contDiff_convolution_right (ContinuousLinearMap.mul β β) hf hk | |
| rw [laplacian_eq_sum_directional hc, convolution_mul] | |
| simp_rw [laplacian_eq_sum_directional hk, Finset.mul_sum] | |
| rw [integral_finsetSum] | |
| Β· apply Finset.sum_congr rfl | |
| intro i _ | |
| let v := (stdOrthonormalBasis β X) i | |
| have hd : ContDiff β (β€ : ββ) (fun y β¦ fderiv β k y v) := | |
| (hk.fderiv_right (by simp)).clm_apply contDiff_const | |
| have he : (fun y β¦ fderiv β (f β[ContinuousLinearMap.mul β β, ΞΌ] k) y v) = | |
| f β[ContinuousLinearMap.mul β β, ΞΌ] (fun y β¦ fderiv β k y v) := | |
| funext (fun y β¦ fderiv_compact_convolution hf hk hs y v) | |
| change fderiv β (fun y β¦ fderiv β (f β[ContinuousLinearMap.mul β β, ΞΌ] k) y v) x v = _ | |
| rw [he, fderiv_compact_convolution hf hd (hs.fderiv_apply β v)] | |
| rfl | |
| Β· intro i _ | |
| have hd : ContDiff β (β€ : ββ) (fun y β¦ fderiv β k y ((stdOrthonormalBasis β X) i)) := | |
| (hk.fderiv_right (by simp)).clm_apply contDiff_const | |
| exact ((hs.fderiv_apply β _).fderiv_apply β _).convolutionExists_right | |
| (ContinuousLinearMap.mul β β) hf | |
| ((hd.continuous_fderiv (by simp)).clm_apply continuous_const) x | |
| omit [MeasurableSpace X] [BorelSpace X] in | |
| lemma laplacian_translate {k : X β β} (a x : X) : | |
| Ξ (fun y β¦ k (a + y)) x = Ξ k (a + x) := by | |
| simp only [InnerProductSpace.laplacian_eq_iteratedFDeriv_stdOrthonormalBasis, | |
| iteratedFDeriv_comp_add_left] | |
| omit [MeasurableSpace X] [BorelSpace X] in | |
| lemma laplacian_reflect_translate {k : X β β} | |
| (hk : ContDiff β (β€ : ββ) k) (a x : X) : | |
| Ξ (fun y β¦ k (a - y)) x = Ξ k (a - x) := by | |
| let L : X ββα΅’[β] X := LinearIsometryEquiv.neg β | |
| have hh := laplacian_comp_isometry L (hk.comp ((contDiff_const (c := a)).add contDiff_id)) x | |
| change Ξ (fun y β¦ k (a + -y)) x = Ξ (fun y β¦ k (a + y)) (-x) at hh | |
| rw [laplacian_translate] at hh | |
| simpa only [sub_eq_add_neg] using hh | |
| theorem weak_harmonic_convolution {f k : X β β} {Ξ© W : Set X} | |
| (hf : LocallyIntegrable f ΞΌ) | |
| (hweak : β Ο : X β β, ContDiff β (β€ : ββ) Ο β HasCompactSupport Ο β | |
| tsupport Ο β Ξ© β (β« y, f y * Ξ Ο y βΞΌ) = 0) | |
| (hk : ContDiff β (β€ : ββ) k) (hs : HasCompactSupport k) | |
| (hW : IsOpen W) | |
| (hkernel : β x β W, tsupport (fun y β¦ k (x - y)) β Ξ©) : | |
| InnerProductSpace.HarmonicOnNhd (f β[ContinuousLinearMap.mul β β, ΞΌ] k) W := by | |
| have hc := hs.contDiff_convolution_right (ContinuousLinearMap.mul β β) hf hk | |
| have hz (x : X) (hx : x β W) : Ξ (f β[ContinuousLinearMap.mul β β, ΞΌ] k) x = 0 := by | |
| rw [laplacian_compact_convolution hf hk hs, convolution_mul] | |
| have hp : HasCompactSupport (fun y β¦ k (x - y)) := by | |
| exact hs.comp_homeomorph (Homeomorph.subLeft x) | |
| have hh := hweak (fun y β¦ k (x - y)) (hk.comp (contDiff_const.sub contDiff_id)) hp | |
| (hkernel x hx) | |
| simpa only [laplacian_reflect_translate hk] using hh | |
| intro x hx | |
| refine β¨(hc.of_le (show (2 : WithTop ββ) β€ (β€ : ββ) from by norm_cast)).contDiffAt, ?_β© | |
| filter_upwards [hW.mem_nhds hx] with y hy | |
| exact hz y hy | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology RealInnerProductSpace Convolution | |
| open Laplacian | |
| namespace CubicTorus | |
| lemma harmonic_angular_integral {h : β β β} {c : β} {r : β} | |
| (hh : InnerProductSpace.HarmonicOnNhd h (Metric.closedBall c |r|)) : | |
| (β« ΞΈ in Ioo (-Real.pi) Real.pi, h (circleMap c r ΞΈ)) = 2 * Real.pi * h c := by | |
| have hm := hh.circleAverage_eq | |
| rw [Real.circleAverage_eq_integral_add (-Real.pi), | |
| intervalIntegral.integral_comp_add_right (fun ΞΈ β¦ h (circleMap c r ΞΈ))] at hm | |
| norm_num only [zero_add] at hm | |
| have he : 2 * Real.pi + -Real.pi = Real.pi := by ring | |
| rw [he, intervalIntegral.integral_of_le (by linarith [Real.pi_pos]), | |
| integral_Ioc_eq_integral_Ioo] at hm | |
| simp only [smul_eq_mul] at hm | |
| have hp : 2 * Real.pi β 0 := by positivity | |
| calc | |
| _ = (2 * Real.pi) * ((2 * Real.pi)β»ΒΉ * | |
| β« ΞΈ in Ioo (-Real.pi) Real.pi, h (circleMap c r ΞΈ)) := by field_simp | |
| _ = _ := by rw [hm] | |
| lemma add_polarCoord_eq_circleMap (c : β) (r ΞΈ : β) : | |
| c + Complex.polarCoord.symm (r, ΞΈ) = circleMap c r ΞΈ := by | |
| simp [circleMap, Complex.polarCoord_symm_apply, Complex.exp_mul_I, mul_add] | |
| theorem harmonic_radial_mean {h : β β β} {ΞΊ : β β β} {c : β} {R : β} | |
| (hh : Continuous h) (hk : Continuous ΞΊ) | |
| (hs : β r, R < r β ΞΊ r = 0) | |
| (harm : InnerProductSpace.HarmonicOnNhd h (Metric.closedBall c R)) : | |
| (β« z : β, ΞΊ βzβ * h (c + z)) = h c * β« z : β, ΞΊ βzβ := by | |
| let S : Set (β Γ β) := Ioc 0 R ΓΛ’ Ioo (-Real.pi) Real.pi | |
| let T : Set (β Γ β) := Ioi 0 ΓΛ’ Ioo (-Real.pi) Real.pi | |
| have hST : S β T := by intro p hp; exact β¨hp.1.1, hp.2β© | |
| have hTm : MeasurableSet T := measurableSet_Ioi.prod measurableSet_Ioo | |
| have hpcont : Continuous (Complex.polarCoord.symm) := by | |
| change Continuous (fun p : β Γ β β¦ _) | |
| simp only [Complex.polarCoord_symm_apply] | |
| fun_prop | |
| have hF : Continuous (fun p : β Γ β β¦ p.1 * (ΞΊ |p.1| * h (c + Complex.polarCoord.symm p))) := | |
| continuous_fst.mul ((hk.comp continuous_fst.abs).mul | |
| (hh.comp (continuous_const.add hpcont))) | |
| have hG : Continuous (fun p : β Γ β β¦ p.1 * ΞΊ |p.1|) := | |
| continuous_fst.mul (hk.comp continuous_fst.abs) | |
| have hSS : S β Icc (0, -Real.pi) (R, Real.pi) := by | |
| intro p hp | |
| exact β¨β¨hp.1.1.le, hp.2.1.leβ©, β¨hp.1.2, hp.2.2.leβ©β© | |
| have hFi : IntegrableOn (fun p : β Γ β β¦ p.1 * (ΞΊ |p.1| * h (c + Complex.polarCoord.symm p))) S := | |
| hF.integrableOn_Icc.mono_set hSS | |
| have hGi : IntegrableOn (fun p : β Γ β β¦ p.1 * ΞΊ |p.1|) S := | |
| hG.integrableOn_Icc.mono_set hSS | |
| have hangle (r : β) (hr : r β Ioc 0 R) : | |
| (β« ΞΈ in Ioo (-Real.pi) Real.pi, h (c + Complex.polarCoord.symm (r, ΞΈ))) = | |
| 2 * Real.pi * h c := by | |
| simp_rw [add_polarCoord_eq_circleMap] | |
| apply harmonic_angular_integral | |
| apply harm.mono | |
| exact Metric.closedBall_subset_closedBall (by simpa only [abs_of_pos hr.1] using hr.2) | |
| rw [β Complex.integral_comp_polarCoord_symm (fun z β¦ ΞΊ βzβ * h (c + z)), | |
| β Complex.integral_comp_polarCoord_symm (fun z β¦ ΞΊ βzβ)] | |
| simp only [Complex.norm_polarCoord_symm, smul_eq_mul] | |
| change (β« p in T, p.1 * (ΞΊ |p.1| * h (c + Complex.polarCoord.symm p))) = | |
| h c * β« p in T, p.1 * ΞΊ |p.1| | |
| rw [setIntegral_eq_of_subset_of_forall_sdiff_eq_zero hTm hST (fun p hp β¦ ?_), | |
| setIntegral_eq_of_subset_of_forall_sdiff_eq_zero hTm hST (fun p hp β¦ ?_)] | |
| Β· simp only [Measure.volume_eq_prod] at hFi hGi β’ | |
| dsimp only [S] at hFi hGi β’ | |
| rw [setIntegral_prod _ hFi, setIntegral_prod _ hGi, β integral_const_mul] | |
| apply setIntegral_congr_fun measurableSet_Ioc | |
| intro r hr | |
| simp_rw [β mul_assoc, integral_const_mul, hangle r hr] | |
| simp only [integral_const, Measure.real, Measure.restrict_apply_univ, Real.volume_Ioo, | |
| ENNReal.toReal_ofReal (by linarith [Real.pi_pos] : 0 β€ Real.pi - -Real.pi), | |
| smul_eq_mul] | |
| ring | |
| all_goals | |
| have hr : R < p.1 := by | |
| by_contra hn | |
| exact hp.2 β¨β¨hp.1.1, le_of_not_gt hnβ©, hp.1.2β© | |
| simp only [abs_of_pos (show 0 < p.1 from hp.1.1), hs p.1 hr, zero_mul, mul_zero] | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology RealInnerProductSpace Convolution | |
| open Laplacian | |
| namespace CubicTorus | |
| theorem exists_radial_smoothing_kernel {R : β} (hR : 0 < R) : | |
| β (k : β β β) (ΞΊ : β β β), | |
| ContDiff β (β€ : ββ) k β§ HasCompactSupport k β§ | |
| (β z, k z = ΞΊ βzβ) β§ Continuous ΞΊ β§ (β r, R < r β ΞΊ r = 0) β§ | |
| tsupport k β Metric.closedBall 0 R β§ (β« z, k z) = 1 := by | |
| let b : β β β := fun z β¦ (ContDiffBumpBase.ofInnerProductSpace β).toFun 2 ((2 / R) β’ z) | |
| have hb : ContDiff β (β€ : ββ) b := by | |
| have hg : ContDiff β (β€ : ββ) (fun z : β β¦ ((2 : β), (2 / R) β’ z)) := | |
| contDiff_const.prodMk ((contDiff_const (c := (2 / R : β))).smul contDiff_id) | |
| have ht : β z : β, ((2 : β), (2 / R) β’ z) β Ioi (1 : β) ΓΛ’ (univ : Set β) := | |
| fun _ β¦ β¨by norm_num, mem_univ _β© | |
| exact (ContDiffBumpBase.ofInnerProductSpace β).smooth.comp_contDiff hg ht | |
| have hbformula (z : β) : b z = Real.smoothTransition (2 - (2 / R) * βzβ) := by | |
| simp [b, ContDiffBumpBase.ofInnerProductSpace, Real.norm_eq_abs, abs_of_pos hR, show (2 : β) - 1 = 1 from by norm_num] | |
| have hzero (r : β) (hr : R < r) : Real.smoothTransition (2 - (2 / R) * r) = 0 := by | |
| apply Real.smoothTransition.zero_of_nonpos | |
| have hh : 2 < (2 / R) * r := by | |
| have := (mul_lt_mul_of_pos_left hr (by positivity : 0 < 2 / R)) | |
| field_simp at this β’ | |
| nlinarith | |
| linarith | |
| have hbs : tsupport b β Metric.closedBall 0 R := by | |
| apply closure_minimal _ Metric.isClosed_closedBall | |
| intro z hz | |
| by_contra hn | |
| have hr : R < βzβ := by simpa only [Metric.mem_closedBall, dist_zero_right, not_le] using hn | |
| exact hz (by rw [hbformula, hzero _ hr]) | |
| have hbc : HasCompactSupport b := (isCompact_closedBall (0 : β) R).of_isClosed_subset | |
| isClosed_closure hbs | |
| have hbpos : 0 < β« z, b z := by | |
| apply hb.continuous.integral_pos_of_hasCompactSupport_nonneg_nonzero hbc | |
| (fun _ β¦ (ContDiffBumpBase.ofInnerProductSpace β).mem_Icc _ _ |>.1) | |
| rw [hbformula 0] | |
| norm_num [Real.smoothTransition.one_of_one_le] | |
| let k : β β β := fun z β¦ b z / β« y, b y | |
| let ΞΊ : β β β := fun r β¦ Real.smoothTransition (2 - (2 / R) * r) / β« y, b y | |
| have hks : tsupport k β Metric.closedBall 0 R := by | |
| change tsupport (fun z β¦ b z * (β« y, b y)β»ΒΉ) β _ | |
| exact tsupport_mul_subset_left.trans hbs | |
| have hkc : HasCompactSupport k := (isCompact_closedBall (0 : β) R).of_isClosed_subset | |
| isClosed_closure hks | |
| refine β¨k, ΞΊ, hb.div_const _, hkc, ?_, ?_, ?_, hks, ?_β© | |
| Β· intro z | |
| exact congrArg (fun t : β β¦ t / β« y, b y) (hbformula z) | |
| Β· exact (Real.smoothTransition.continuous.comp | |
| (continuous_const.sub (continuous_const.mul continuous_id))).div_const _ | |
| Β· intro r hr | |
| simp only [ΞΊ, hzero r hr, zero_div] | |
| Β· dsimp only [k] | |
| rw [integral_div, div_self hbpos.ne'] | |
| lemma harmonic_radial_convolution {h k : β β β} {ΞΊ : β β β} {c : β} {R : β} | |
| (hh : Continuous h) (hk : β z, k z = ΞΊ βzβ) (hc : Continuous ΞΊ) | |
| (hs : β r, R < r β ΞΊ r = 0) (hi : (β« z, k z) = 1) | |
| (harm : InnerProductSpace.HarmonicOnNhd h (Metric.closedBall c R)) : | |
| (h β[ContinuousLinearMap.mul β β] k) c = h c := by | |
| rw [convolution_eq_swap, β integral_neg_eq_self] | |
| simp only [ContinuousLinearMap.mul_apply'] | |
| simp only [hk, norm_neg, sub_neg_eq_add, mul_comm (h _)] | |
| rw [harmonic_radial_mean hh hc hs harm] | |
| have hi' : (β« z : β, ΞΊ βzβ) = 1 := by simpa only [hk] using hi | |
| rw [hi', mul_one] | |
| end CubicTorus | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology RealInnerProductSpace Convolution | |
| namespace CubicTorus | |
| variable {X : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [MeasurableSpace X] [BorelSpace X] | |
| {ΞΌ : Measure X} [ΞΌ.IsAddHaarMeasure] | |
| lemma real_convolution_comm (f g : X β β) : | |
| f β[ContinuousLinearMap.mul β β, ΞΌ] g = g β[ContinuousLinearMap.mul β β, ΞΌ] f := by | |
| ext x | |
| rw [convolution_mul_swap, convolution_mul] | |
| apply integral_congr_ae | |
| exact Eventually.of_forall (fun _ β¦ mul_comm _ _) | |
| lemma compact_convolution_assoc {f g k : X β β} (hf : LocallyIntegrable f ΞΌ) | |
| (hg : Continuous g) (hgs : HasCompactSupport g) | |
| (hk : Continuous k) (hks : HasCompactSupport k) (x : X) : | |
| ((f β[ContinuousLinearMap.mul β β, ΞΌ] g) β[ContinuousLinearMap.mul β β, ΞΌ] k) x = | |
| (f β[ContinuousLinearMap.mul β β, ΞΌ] (g β[ContinuousLinearMap.mul β β, ΞΌ] k)) x := by | |
| apply convolution_assoc (ContinuousLinearMap.mul β β) (ContinuousLinearMap.mul β β) | |
| (ContinuousLinearMap.mul β β) (ContinuousLinearMap.mul β β) | |
| (fun a b c β¦ mul_assoc a b c) hf.aestronglyMeasurable | |
| hg.aestronglyMeasurable hk.aestronglyMeasurable | |
| Β· exact Eventually.of_forall (hgs.convolutionExists_right _ hf hg) | |
| Β· exact Eventually.of_forall (hks.norm.convolutionExists_right _ hg.norm.locallyIntegrable hk.norm) | |
| Β· exact (hgs.norm.convolution (ContinuousLinearMap.mul β β) hks.norm).convolutionExists_right _ | |
| (fun x β¦ (hf x).norm) (hks.norm.continuous_convolution_right _ hg.norm.locallyIntegrable hk.norm) x | |
| lemma compact_convolutions_commute {f g k : X β β} (hf : LocallyIntegrable f ΞΌ) | |
| (hg : Continuous g) (hgs : HasCompactSupport g) | |
| (hk : Continuous k) (hks : HasCompactSupport k) (x : X) : | |
| ((f β[ContinuousLinearMap.mul β β, ΞΌ] g) β[ContinuousLinearMap.mul β β, ΞΌ] k) x = | |
| ((f β[ContinuousLinearMap.mul β β, ΞΌ] k) β[ContinuousLinearMap.mul β β, ΞΌ] g) x := by | |
| rw [compact_convolution_assoc hf hg hgs hk hks, | |
| compact_convolution_assoc hf hk hks hg hgs, real_convolution_comm g k] | |
| omit [NormedSpace β X] [FiniteDimensional β X] [MeasurableSpace X] [BorelSpace X] in | |
| lemma reflected_tsupport_subset_ball {k : X β β} {c x : X} {r R : β} | |
| (hk : tsupport k β Metric.closedBall 0 r) (hx : dist x c + r < R) : | |
| tsupport (fun y β¦ k (x - y)) β Metric.ball c R := by | |
| have hs : tsupport (fun y β¦ k (x - y)) β | |
| (fun y β¦ x - y) β»ΒΉ' tsupport k := tsupport_comp_subset_preimage k (by fun_prop) | |
| intro y hy | |
| have ht := hk (hs hy) | |
| rw [Metric.mem_closedBall, dist_zero_right, β dist_eq_norm] at ht | |
| rw [Metric.mem_ball] | |
| calc | |
| dist y c β€ dist y x + dist x c := dist_triangle _ _ _ | |
| _ = dist x y + dist x c := by rw [dist_comm y x] | |
| _ β€ r + dist x c := by linarith | |
| _ < R := by linarith | |
| end CubicTorus | |
| end | |
| end | |
| end | |
| end OAI | |