| import Mathlib |
| import OAI.Geometry.CubicTorus.Regularity.BVColumnHeight |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma plane_gradient_norm (g : Plane → ℝ) (y : Plane) : |
| ‖gradient g y‖ = ‖fderiv ℝ g y‖ := by |
| exact (InnerProductSpace.toDual ℝ Plane).symm.norm_map _ |
|
|
| lemma graphAreaVector_norm_sq {n : Cover} (hn : ‖n‖ = 1) (g : Plane → ℝ) (y : Plane) : |
| ‖graphAreaVector n g y‖ ^ 2 = 1 + ‖fderiv ℝ g y‖ ^ 2 := by |
| rw [graphAreaVector, norm_sub_sq_real, hn, one_pow, |
| normalPlaneEmbedding_norm, normalPlaneEmbedding_inner hn, plane_gradient_norm] |
| ring |
|
|
| lemma graphAreaVector_norm_le {n : Cover} (hn : ‖n‖ = 1) (g : Plane → ℝ) (y : Plane) : |
| ‖graphAreaVector n g y‖ ≤ 1 + ‖fderiv ℝ g y‖ ^ 2 / 2 := by |
| have he := graphAreaVector_norm_sq hn g y |
| nlinarith [norm_nonneg (graphAreaVector n g y), sq_nonneg ‖fderiv ℝ g y‖, |
| sq_nonneg (‖fderiv ℝ g y‖ ^ 2)] |
|
|
| lemma graph_trace_compactSupport {X : Type*} [Zero X] |
| (a : Cover) {n : Cover} (hn : ‖n‖ = 1) {g : Plane → ℝ} (hg : Continuous g) |
| {F : Cover → X} (hs : HasCompactSupport F) : |
| HasCompactSupport (fun y : Plane ↦ F (a+normalGraph n g y)) := by |
| have hc := (hs.comp_homeomorph (graphShearHomeomorph a hn hg)).comp_isClosedEmbedding |
| (normalColumnChart_plane_isometry a hn 0).isClosedEmbedding |
| have he (y : Plane) : graphShearHomeomorph a hn hg (normalColumnChart a n (0,y)) = |
| a+normalGraph n g y := by |
| change graphShear a n g (normalColumnChart a n (0,y)) = _ |
| rw [graphShear_columnChart a hn, zero_add, normalColumnChart_apply a hn] |
| rfl |
| simpa only [Function.comp_def, he] using hc |
|
|
| lemma graph_trace_continuous {X : Type*} [TopologicalSpace X] |
| (a n : Cover) {g : Plane → ℝ} (hg : Continuous g) |
| {F : Cover → X} (hF : Continuous F) : Continuous (fun y : Plane ↦ F (a+normalGraph n g y)) := by |
| apply hF.comp |
| exact continuous_const.add ((normalPlaneLinearIsometry n).continuous.add (hg.smul continuous_const)) |
|
|
| lemma graphAreaVector_continuous (n : Cover) {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) : Continuous (graphAreaVector n g) := by |
| have hd := (hg.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous |
| exact continuous_const.sub ((normalPlaneLinearIsometry n).continuous.comp |
| ((InnerProductSpace.toDual ℝ Plane).symm.continuous.comp hd)) |
|
|
| lemma graph_trace_flux_integrable (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| {F : Cover → Cover} (hF : Continuous F) (hs : HasCompactSupport F) : |
| Integrable (fun y : Plane ↦ ⟪graphAreaVector n g y, F (a+normalGraph n g y)⟫) := by |
| have hc := graph_trace_compactSupport a hn hg.continuous hs |
| have hs' : HasCompactSupport (fun y : Plane ↦ ⟪graphAreaVector n g y, F (a+normalGraph n g y)⟫) := by |
| apply hc.mono |
| intro x hx |
| simp only [Function.mem_support] at hx ⊢ |
| intro he |
| apply hx |
| rw [he, inner_zero_right] |
| exact ((graphAreaVector_continuous n hg).inner |
| (graph_trace_continuous a n hg.continuous hF)).integrable_of_hasCompactSupport hs' |
|
|
| theorem integral_graphSublevel_divergence_le (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) |
| {w : Cover → ℝ} (hw : Continuous w) (hws : HasCompactSupport w) |
| (hbound : ∀ x, ‖F x‖ ≤ w x) : |
| (∫ x : Cover, graphSublevelIndicator a n g x * divergence F x) ≤ |
| ∫ y : Plane, w (a+normalGraph n g y) * (1+‖fderiv ℝ g y‖ ^ 2 / 2) := by |
| rw [integral_graphSublevel_divergence a hn hg hF hs] |
| have hcw := graph_trace_continuous a n hg.continuous hw |
| have hwc := graph_trace_compactSupport a hn hg.continuous hws |
| have hd := (hg.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous |
| have hi : Integrable (fun y : Plane ↦ w (a+normalGraph n g y) * (1+‖fderiv ℝ g y‖ ^ 2 / 2)) := |
| (hcw.mul (continuous_const.add ((hd.norm.pow 2).div_const 2))).integrable_of_hasCompactSupport |
| hwc.mul_right |
| apply integral_mono (graph_trace_flux_integrable a hn hg hF.continuous hs) hi |
| intro y |
| calc |
| _ ≤ ‖graphAreaVector n g y‖ * ‖F (a+normalGraph n g y)‖ := real_inner_le_norm _ _ |
| _ ≤ (1+‖fderiv ℝ g y‖ ^ 2 / 2) * w (a+normalGraph n g y) := |
| mul_le_mul (graphAreaVector_norm_le hn g y) (hbound _) (norm_nonneg _) (by positivity) |
| _ = _ := mul_comm _ _ |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| theorem cutoff_gluing_local_flux_le {E F : Set Torus} |
| (hE : MeasurableSet E) (hF : MeasurableSet F) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {w : Cover → ℝ} (hw : ContDiff ℝ (⊤ : ℕ∞) w) |
| (hp : ∀ n x, w (x + latticeVector n) = w x) (hb : ∀ x, w x ∈ Icc 0 1) |
| {X : Cover → Cover} (hX : AdmissibleField X) |
| {A : ℝ} (hlocal : (∫ x in fundamentalCube, characteristic F (quotientMap x) * |
| divergence (fun y ↦ w y • X y) x) ≤ A) : |
| (∫ x in fundamentalCube, |
| ((1 - w x) * characteristic E (quotientMap x) + w x * characteristic F (quotientMap x)) * |
| divergence X x) ≤ |
| (∫ z, 1 - w z.1 ∂(μ : Measure NormalBundle)) + |
| A + |
| ∫ x in fundamentalCube ∩ quotientMap ⁻¹' (E ∆ F), ‖gradient w x‖ := by |
| let Y : Cover → Cover := fun x ↦ (1 - w x) • X x |
| let Z : Cover → Cover := fun x ↦ w x • X x |
| have hY : AdmissibleField Y := admissible_cutoff (contDiff_const.sub hw) |
| (fun n x ↦ by rw [hp]) (fun x ↦ by constructor <;> linarith [(hb x).1, (hb x).2]) hX |
| have hZ : AdmissibleField Z := admissible_cutoff hw hp hb hX |
| let a : Cover → ℝ := fun x ↦ characteristic E (quotientMap x) * divergence Y x |
| let b : Cover → ℝ := fun x ↦ characteristic F (quotientMap x) * divergence Z x |
| let c : Cover → ℝ := fun x ↦ (characteristic F (quotientMap x) - characteristic E (quotientMap x)) * |
| ⟪gradient w x, X x⟫ |
| have ha : IntegrableOn a fundamentalCube := integrableOn_characteristic_mul hE.nullMeasurableSet |
| (integrableOn_divergence hY.1) |
| have hb' : IntegrableOn b fundamentalCube := integrableOn_characteristic_mul hF.nullMeasurableSet |
| (integrableOn_divergence hZ.1) |
| have hi : IntegrableOn (fun x ↦ ⟪gradient w x, X x⟫) fundamentalCube := |
| integrableOn_periodic_continuous ((gradient_contDiff hw).continuous.inner hX.1.continuous) |
| (fun n x ↦ by rw [gradient_periodic hp, hX.2.1]) |
| have hc : IntegrableOn c fundamentalCube := by |
| have hh := (integrableOn_characteristic_mul hF.nullMeasurableSet hi).sub |
| (integrableOn_characteristic_mul hE.nullMeasurableSet hi) |
| simpa only [Pi.sub_def, ← sub_mul, c] using hh |
| have hgn : IntegrableOn (fun x ↦ ‖gradient w x‖) fundamentalCube := |
| integrableOn_periodic_continuous (gradient_contDiff hw).continuous.norm |
| (fun n x ↦ by rw [gradient_periodic hp]) |
| have heq (x : Cover) : |
| ((1 - w x) * characteristic E (quotientMap x) + w x * characteristic F (quotientMap x)) * |
| divergence X x = a x + b x - c x := by |
| dsimp [a, b, c, Y, Z] |
| rw [divergence_smul_function ((contDiff_const.sub hw).differentiable (by simp)).differentiableAt |
| (hX.1.differentiable (by simp)).differentiableAt, |
| divergence_smul_function (hw.differentiable (by simp)).differentiableAt |
| (hX.1.differentiable (by simp)).differentiableAt, |
| gradient_const_sub, inner_neg_left] |
| ring |
| simp_rw [heq] |
| have hab : IntegrableOn (fun x ↦ a x + b x) fundamentalCube := by |
| simpa only [Pi.add_def] using ha.add hb' |
| rw [integral_sub hab hc, integral_add ha hb'] |
| have hmassE : (∫ x in fundamentalCube, a x) ≤ ∫ z, 1 - w z.1 ∂(μ : Measure NormalBundle) := by |
| dsimp only [a] |
| simp_rw [characteristic_mul] |
| rw [lift_indicator_integral hE.nullMeasurableSet, |
| ← normalMeasure_weighted_flux hμ (contDiff_const.sub hw) (fun n x ↦ by rw [hp]) hX] |
| have hh : Continuous (fun z : NormalBundle ↦ 1 - w z.1) := by fun_prop |
| apply integral_mono ((hh.mul (normalTest X hX.1.continuous).continuous).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _)) |
| (hh.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)) |
| intro z |
| exact mul_le_of_le_one_right (by linarith [(hb z.1).2]) (normalTest_le_one hX z) |
| have hmassF : (∫ x in fundamentalCube, b x) ≤ A := hlocal |
| have herr : -(∫ x in fundamentalCube, c x) ≤ |
| ∫ x in fundamentalCube ∩ quotientMap ⁻¹' (E ∆ F), ‖gradient w x‖ := by |
| rw [← integral_neg, ← lift_indicator_integral (hE.symmDiff hF).nullMeasurableSet] |
| have hci := integrableOn_characteristic_mul (hE.symmDiff hF).nullMeasurableSet hgn |
| simp_rw [← characteristic_mul] at ⊢ hci |
| apply integral_mono hc.neg hci |
| intro x |
| calc |
| -c x ≤ |c x| := neg_le_abs _ |
| _ = characteristic (E ∆ F) (quotientMap x) * |⟪gradient w x, X x⟫| := by |
| dsimp only [c] |
| rw [abs_mul, characteristic_symmDiff_abs] |
| _ ≤ characteristic (E ∆ F) (quotientMap x) * ‖gradient w x‖ := by |
| apply mul_le_mul_of_nonneg_left _ (characteristic_nonneg _ _) |
| exact (abs_real_inner_le_norm _ _).trans |
| (mul_le_of_le_one_right (norm_nonneg _) (hX.2.2 x)) |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| def torusGraphRegion (a n : Cover) (g : Plane → ℝ) : Set Torus := |
| {z | ⟪n, representative z - a⟫ < graphHeightExtension a n g (representative z)} |
|
|
| lemma measurableSet_torusGraphRegion (a n : Cover) {g : Plane → ℝ} (hg : Continuous g) : |
| MeasurableSet (torusGraphRegion a n g) := by |
| apply measurableSet_lt |
| · exact measurable_const.inner (measurable_representative.sub_const a) |
| · exact (hg.comp ((normalPlaneCoordinates n).continuous.comp |
| (continuous_id.sub continuous_const))).measurable.comp measurable_representative |
|
|
| lemma characteristic_torusGraphRegion {x : Cover} (hx : x ∈ fundamentalCube) |
| (a n : Cover) (g : Plane → ℝ) : |
| characteristic (torusGraphRegion a n g) (quotientMap x) = graphSublevelIndicator a n g x := by |
| simp only [characteristic, torusGraphRegion, Set.indicator, Set.mem_ofPred_eq, |
| representative_quotientMap_of_mem hx, graphSublevelIndicator] |
|
|
| lemma latticePeriodize_mem_Icc {w : Cover → ℝ} (hc : HasCompactSupport w) |
| (hs : tsupport w ⊆ {x | ∀ i, 0 < x i ∧ x i < 1}) |
| (hb : ∀ x, w x ∈ Icc 0 1) (x : Cover) : latticePeriodize w x ∈ Icc 0 1 := by |
| rw [← periodic_representative (latticePeriodize_periodic w) x] |
| have hx := representative_mem_fundamentalCube (quotientMap x) |
| rw [(latticePeriodize_eventuallyEq hc hs (fun i ↦ ⟨(hx i).1, (hx i).2.le⟩)).eq_of_nhds] |
| exact hb _ |
|
|
| lemma interior_cutoff_flux_eq (a n : Cover) (g : Plane → ℝ) |
| {w : Cover → ℝ} (hc : HasCompactSupport w) |
| (hs : tsupport w ⊆ {x | ∀ i, 0 < x i ∧ x i < 1}) (X : Cover → Cover) : |
| (∫ x in fundamentalCube, characteristic (torusGraphRegion a n g) (quotientMap x) * |
| divergence (fun y ↦ latticePeriodize w y • X y) x) = |
| ∫ x : Cover, graphSublevelIndicator a n g x * divergence (fun y ↦ w y • X y) x := by |
| rw [← integral_indicator measurableSet_fundamentalCube] |
| apply integral_congr_ae |
| filter_upwards [] with x |
| by_cases hx : x ∈ fundamentalCube |
| · rw [indicator_of_mem hx, characteristic_torusGraphRegion hx] |
| have he := (latticePeriodize_eventuallyEq hc hs (fun i ↦ ⟨(hx i).1, (hx i).2.le⟩)).smul |
| (EventuallyEq.rfl : X =ᶠ[𝓝 x] X) |
| have hd := he.fderiv_eq (𝕜 := ℝ) |
| simp only [divergence] at hd ⊢ |
| rw [hd] |
| · rw [indicator_of_notMem hx] |
| have hsup : tsupport (fun y ↦ w y • X y) ⊆ tsupport w := tsupport_smul_subset_left w X |
| have hdiv : divergence (fun y ↦ w y • X y) x = 0 := by |
| apply divergence_of_notMem_tsupport |
| intro hh |
| exact hx (fun i ↦ ⟨(hs (hsup hh) i).1.le, (hs (hsup hh) i).2⟩) |
| rw [hdiv, mul_zero] |
|
|
| theorem torusGraphRegion_cutoff_flux_le (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| {w : Cover → ℝ} (hw : ContDiff ℝ (⊤ : ℕ∞) w) (hc : HasCompactSupport w) |
| (hs : tsupport w ⊆ {x | ∀ i, 0 < x i ∧ x i < 1}) (hb : ∀ x, w x ∈ Icc 0 1) |
| {X : Cover → Cover} (hX : AdmissibleField X) : |
| (∫ x in fundamentalCube, characteristic (torusGraphRegion a n g) (quotientMap x) * |
| divergence (fun y ↦ latticePeriodize w y • X y) x) ≤ |
| ∫ y : Plane, w (a+normalGraph n g y) * (1+‖fderiv ℝ g y‖ ^ 2 / 2) := by |
| rw [interior_cutoff_flux_eq a n g hc hs] |
| apply integral_graphSublevel_divergence_le a hn hg (hw.smul hX.1) |
| (hc.smul_right) hw.continuous hc |
| intro x |
| change ‖w x • X x‖ ≤ w x |
| rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (hb x).1] |
| exact mul_le_of_le_one_right (hb x).1 (hX.2.2 x) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| theorem perimeter_glued_local_flux_le {E F : Set Torus} |
| (hE : MeasurableSet E) (hF : MeasurableSet F) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {q : Cover → ℝ} (hq : ContDiff ℝ (⊤ : ℕ∞) q) |
| (hp : ∀ n x, q (x + latticeVector n) = q x) |
| {K M t d : ℝ} (hK : ∀ u, ‖deriv Real.smoothTransition u‖ ≤ K) |
| (hgrad : ∀ x, q x < t → ‖gradient q x‖ ≤ M) |
| (hd : HasDerivAt (sublevelVolume (E ∆ F) q) d t) |
| {L : ℕ → ℝ} {L₀ : ℝ} (hLlim : Tendsto L atTop (𝓝 L₀)) |
| (hlocal : ∀ i : ℕ, ∀ X : Cover → Cover, AdmissibleField X → |
| (∫ x in fundamentalCube, characteristic F (quotientMap x) * |
| divergence (fun y ↦ sublevelCutoff q t (1 / ((i : ℝ)+1)) y • X y) x) ≤ L i) : |
| FinitePerimeter (gluedRegion E F (sublevelRegion q t)) ∧ |
| (perimeter (gluedRegion E F (sublevelRegion q t))).toReal ≤ |
| (μ.mass : ℝ) - (μ : Measure NormalBundle).real {z | q z.1 < t} + |
| L₀ + K * M * d := by |
| let ε : ℕ → ℝ := fun i ↦ 1 / ((i : ℝ) + 1) |
| have he : ∀ i, 0 < ε i := fun i ↦ by dsimp [ε]; positivity |
| have helim : Tendsto ε atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat |
| let w : ℕ → Cover → ℝ := fun i ↦ sublevelCutoff q t (ε i) |
| have hw (i : ℕ) : ContDiff ℝ (⊤ : ℕ∞) (w i) := sublevelCutoff_contDiff hq t (ε i) |
| have hwp (i : ℕ) : ∀ n x, w i (x + latticeVector n) = w i x := sublevelCutoff_periodic hp t (ε i) |
| have hwb (i : ℕ) (x : Cover) : w i x ∈ Icc (0 : ℝ) 1 := sublevelCutoff_mem_Icc q t (ε i) x |
| have hB := measurableSet_sublevelRegion hq.continuous.measurable t |
| have hG := measurableSet_gluedRegion hE hF hB |
| let A : ℝ := (μ.mass : ℝ) - (μ : Measure NormalBundle).real {z | q z.1 < t} + |
| L₀ + K * M * d |
| have hμlim : Tendsto (fun i ↦ ∫ z : NormalBundle, 1 - w i z.1 ∂(μ : Measure NormalBundle)) |
| atTop (𝓝 ((μ.mass : ℝ) - (μ : Measure NormalBundle).real {z | q z.1 < t})) := by |
| have hh := (tendsto_const_nhds (x := (μ.mass : ℝ)) (f := atTop)).sub |
| (normalMeasure_sublevelCutoff_tendsto μ hq.continuous hp he helim t) |
| convert hh using 1 |
| funext i |
| have hi : Integrable (fun z : NormalBundle ↦ w i z.1) (μ : Measure NormalBundle) := |
| (show Continuous (fun z : NormalBundle ↦ w i z.1) from by fun_prop).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _) |
| rw [integral_sub (integrable_const 1) hi, normalMeasure_integral_one] |
| have hdlim := tendsto_backward_quotient_of_hasDerivAt hd he helim |
| have hright : Tendsto (fun i ↦ |
| (∫ z : NormalBundle, 1 - w i z.1 ∂(μ : Measure NormalBundle)) + |
| L i + |
| K * M * ((sublevelVolume (E ∆ F) q t - sublevelVolume (E ∆ F) q (t - ε i)) / ε i)) |
| atTop (𝓝 A) := (hμlim.add hLlim).add (tendsto_const_nhds.mul hdlim) |
| have hbound (X : Cover → Cover) (hX : AdmissibleField X) : |
| (∫ x in fundamentalCube ∩ quotientMap ⁻¹' gluedRegion E F (sublevelRegion q t), divergence X x) ≤ A := by |
| have hleft := cutoff_gluing_flux_tendsto hE hF hB (fun i ↦ (hw i).continuous) hwb |
| (sublevelCutoff_tendsto hp he helim t) hX |
| apply le_of_tendsto_of_tendsto' hleft hright |
| intro i |
| exact (cutoff_gluing_local_flux_le hE hF hμ (hw i) (hwp i) (hwb i) hX (hlocal i X hX)).trans |
| (add_le_add_right (sublevelCutoff_gradient_integral_le (hE.symmDiff hF) hq hp hK hgrad (he i)) _) |
| have hA : 0 ≤ A := by |
| simpa only [divergence_zero, integral_zero] using hbound (fun _ ↦ 0) admissible_zero |
| have hb : perimeter (gluedRegion E F (sublevelRegion q t)) ≤ ENNReal.ofReal A := by |
| apply iSup_le |
| intro X |
| apply iSup_le |
| intro hX |
| exact ENNReal.ofReal_le_ofReal (hbound X hX) |
| refine ⟨⟨hG.nullMeasurableSet, hb.trans_lt ENNReal.ofReal_lt_top⟩, ?_⟩ |
| simpa only [ENNReal.toReal_ofReal hA] using ENNReal.toReal_mono ENNReal.ofReal_ne_top hb |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma radialDensityWeight_cell_support {r ε : ℝ} (hr : 0 ≤ r) (hs : r < 1/2) (hε : 0 < ε) : |
| tsupport (radialDensityWeight cubeCenter r ε) ⊆ {x | ∀ i, 0 < x i ∧ x i < 1} := by |
| intro x hx i |
| have hh := radialDensityWeight_tsupport hr hε hx |
| have hd : ‖x-cubeCenter‖ ≤ r := by simpa only [Metric.mem_closedBall, dist_eq_norm] using hh |
| have hi := (PiLp.norm_apply_le (x-cubeCenter) i).trans hd |
| change ‖x i - (1/2 : ℝ)‖ ≤ r at hi |
| rw [Real.norm_eq_abs, abs_le] at hi |
| constructor <;> linarith |
|
|
| lemma radialDensityWeight_periodize {r ε : ℝ} (hr : 0 ≤ r) (hs : r < 1/4) (hε : 0 < ε) : |
| latticePeriodize (radialDensityWeight cubeCenter r ε) = sublevelCutoff radialSquared (r^2) ε := by |
| funext x |
| rw [← periodic_representative (latticePeriodize_periodic _) x, |
| ← periodic_representative (sublevelCutoff_periodic radialSquared_periodic (r^2) ε) x] |
| let z := representative (quotientMap x) |
| have hz : z ∈ fundamentalCube := representative_mem_fundamentalCube _ |
| rw [(latticePeriodize_eventuallyEq (radialDensityWeight_hasCompactSupport hr hε) |
| (radialDensityWeight_cell_support hr (by linarith) hε) |
| (fun i ↦ ⟨(hz i).1, (hz i).2.le⟩)).eq_of_nhds] |
| change radialDensityWeight cubeCenter r ε z = sublevelCutoff radialSquared (r^2) ε z |
| by_cases hz' : ‖z-cubeCenter‖ < r |
| · have he := (radialSquared_eventuallyEq_norm_sq (hz'.trans hs)).eq_of_nhds |
| simp only [radialDensityWeight, sublevelCutoff, he] |
| · have hh : ¬ radialSquared z < r^2 := by |
| rw [radialSquared_sublevel_iff hz (by nlinarith)] |
| have hb : r ≤ ‖z-cubeCenter‖ := le_of_not_gt hz' |
| nlinarith [norm_nonneg (z-cubeCenter)] |
| rw [radialDensityWeight_zero hr hε (le_of_not_gt hz')] |
| exact (Real.smoothTransition.zero_of_nonpos (div_nonpos_of_nonpos_of_nonneg |
| (sub_nonpos.mpr (le_of_not_gt hh)) hε.le)).symm |
|
|
| lemma graph_trace_energy_integrable (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| {w : Cover → ℝ} (hw : Continuous w) (hs : HasCompactSupport w) : |
| Integrable (fun y : Plane ↦ w (a+normalGraph n g y) * (1+‖fderiv ℝ g y‖^2/2)) := by |
| have hd := (hg.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous |
| exact ((graph_trace_continuous a n hg.continuous hw).mul |
| (continuous_const.add ((hd.norm.pow 2).div_const 2))).integrable_of_hasCompactSupport |
| (graph_trace_compactSupport a hn hg.continuous hs).mul_right |
|
|
| def graphBallQuadraticArea (a n : Cover) (g : Plane → ℝ) (r : ℝ) : ℝ := |
| ∫ y in {y : Plane | a+normalGraph n g y ∈ Metric.ball a r}, 1+‖fderiv ℝ g y‖^2/2 |
|
|
| lemma graphBallQuadraticArea_tendsto (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) {r : ℝ} (hr : 0 < r) |
| {ε : ℕ → ℝ} (hε : ∀ i, 0 < ε i) (hεlim : Tendsto ε atTop (𝓝 0)) : |
| Tendsto (fun i ↦ ∫ y : Plane, radialDensityWeight a r (ε i) (a+normalGraph n g y) * |
| (1+‖fderiv ℝ g y‖^2/2)) atTop (𝓝 (graphBallQuadraticArea a n g r)) := by |
| have hm : MeasurableSet {y : Plane | a+normalGraph n g y ∈ Metric.ball a r} := |
| Metric.isOpen_ball.measurableSet.preimage (graph_trace_continuous a n hg.continuous |
| continuous_id).measurable |
| have heps : Tendsto ε atTop (𝓝[>] 0) := tendsto_nhdsWithin_iff.mpr |
| ⟨hεlim, Eventually.of_forall hε⟩ |
| have hh := tendsto_integral_of_dominated_convergence |
| (bound := fun y : Plane ↦ radialHeightCutoff a r (a+normalGraph n g y) * (1+‖fderiv ℝ g y‖^2/2)) |
| (F := fun i y ↦ radialDensityWeight a r (ε i) (a+normalGraph n g y) * (1+‖fderiv ℝ g y‖^2/2)) |
| (f := fun y ↦ (Metric.ball a r).indicator (fun _ : Cover ↦ (1 : ℝ)) (a+normalGraph n g y) * |
| (1+‖fderiv ℝ g y‖^2/2)) |
| (fun i ↦ (graph_trace_energy_integrable a hn hg |
| (radialDensityWeight_contDiff a r (ε i)).continuous |
| (radialDensityWeight_hasCompactSupport hr.le (hε i))).aestronglyMeasurable) |
| (graph_trace_energy_integrable a hn hg (radialDensityWeight_contDiff a (2*r) (3*r^2)).continuous |
| (radialDensityWeight_hasCompactSupport (by positivity : 0 ≤ 2*r) (by positivity : 0 < 3*r^2))) |
| (fun i ↦ Eventually.of_forall fun y ↦ ?_) |
| (Eventually.of_forall fun y ↦ ((radialDensityWeight_tendsto a (a+normalGraph n g y) hr).comp heps).mul |
| tendsto_const_nhds) |
| · convert hh using 1 |
| rw [graphBallQuadraticArea, ← integral_indicator hm] |
| congr 1 |
| apply integral_congr_ae |
| filter_upwards [] with y |
| by_cases hy : a+normalGraph n g y ∈ Metric.ball a r <;> simp only [Set.indicator, Set.mem_ofPred_eq, hy, ite_true, ite_false, one_mul, zero_mul] |
| · rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (radialDensityWeight_nonneg _ _ _ _) (by positivity))] |
| apply mul_le_mul_of_nonneg_right _ (by positivity) |
| by_cases hy : a+normalGraph n g y ∈ Metric.closedBall a r |
| · rw [radialHeightCutoff_one hr hy] |
| exact radialDensityWeight_le_one _ _ _ _ |
| · have hd : r ≤ ‖(a+normalGraph n g y)-a‖ := le_of_lt (by |
| simpa only [Metric.mem_closedBall, dist_eq_norm, not_le] using hy) |
| rw [radialDensityWeight_zero hr.le (hε i) hd] |
| exact Real.smoothTransition.nonneg _ |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma normalMeasure_radial_sublevel (μ : FiniteMeasure NormalBundle) {r : ℝ} |
| (hr : 0 ≤ r) (hs : r ≤ 1/4) : |
| (μ : Measure NormalBundle).real {z | radialSquared z.1 < r^2} = |
| (spatialNormalMeasure μ : Measure Torus).real (Metric.ball (quotientMap cubeCenter) r) := by |
| rw [← cubeBall_eq_metricBall, ← sublevelRegion_radialSquared hr hs] |
| change _ = (Measure.map normalProjection (μ : Measure NormalBundle) |
| (sublevelRegion radialSquared (r^2))).toReal |
| rw [Measure.map_apply normalProjection_continuous.measurable |
| (measurableSet_sublevelRegion radialSquared_contDiff.continuous.measurable _)] |
| congr 1 |
| ext z |
| exact (mem_sublevelRegion_quotient radialSquared_periodic (r^2) z.1).symm |
|
|
| theorem isMinimizerAt_graph_replacement {V : ℝ} (hV : V ∈ Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) : |
| ∃ η C : ℝ, 0 < η ∧ 0 ≤ C ∧ ∀ (n : Cover), ‖n‖ = 1 → |
| ∀ (g : Plane → ℝ), ContDiff ℝ (⊤ : ℕ∞) g → |
| ∀ r K d : ℝ, 0 < r → r < 1/4 → (∀ u, ‖deriv Real.smoothTransition u‖ ≤ K) → |
| HasDerivAt (sublevelVolume (E ∆ torusGraphRegion cubeCenter n g) radialSquared) d (r^2) → |
| sublevelVolume (E ∆ torusGraphRegion cubeCenter n g) radialSquared (r^2) < η → |
| (spatialNormalMeasure μ : Measure Torus).real (Metric.ball (quotientMap cubeCenter) r) ≤ |
| graphBallQuadraticArea cubeCenter n g r + K * (2*r) * d + |
| C * sublevelVolume (E ∆ torusGraphRegion cubeCenter n g) radialSquared (r^2) := by |
| obtain ⟨η, C, hη, hC, hc⟩ := isMinimizerAt_local_quasiminimal hV hmin |
| refine ⟨η, C, hη, hC, ?_⟩ |
| intro n hn g hg r K d hr hs hK hd ht |
| let F := torusGraphRegion cubeCenter n g |
| have hF : MeasurableSet F := measurableSet_torusGraphRegion _ _ hg.continuous |
| let ε : ℕ → ℝ := fun i ↦ 1 / ((i : ℝ)+1) |
| have he : ∀ i, 0 < ε i := fun i ↦ by dsimp [ε]; positivity |
| let L : ℕ → ℝ := fun i ↦ ∫ y : Plane, radialDensityWeight cubeCenter r (ε i) |
| (cubeCenter+normalGraph n g y) * (1+‖fderiv ℝ g y‖^2/2) |
| have hlocal (i : ℕ) (X : Cover → Cover) (hX : AdmissibleField X) : |
| (∫ x in fundamentalCube, characteristic F (quotientMap x) * |
| divergence (fun y ↦ sublevelCutoff radialSquared (r^2) (1/((i : ℝ)+1)) y • X y) x) ≤ L i := by |
| rw [← radialDensityWeight_periodize hr.le hs (he i)] |
| exact torusGraphRegion_cutoff_flux_le cubeCenter hn hg |
| (radialDensityWeight_contDiff _ _ _) (radialDensityWeight_hasCompactSupport hr.le (he i)) |
| (radialDensityWeight_cell_support hr.le (by linarith) (he i)) |
| (fun x ↦ ⟨radialDensityWeight_nonneg _ _ _ _, radialDensityWeight_le_one _ _ _ _⟩) hX |
| have hlim : Tendsto L atTop (𝓝 (graphBallQuadraticArea cubeCenter n g r)) := |
| graphBallQuadraticArea_tendsto cubeCenter hn hg hr he tendsto_one_div_add_atTop_nhds_zero_nat |
| obtain ⟨hG, hb⟩ := perimeter_glued_local_flux_le hE hF hμ radialSquared_contDiff |
| radialSquared_periodic hK (norm_gradient_radialSquared hr.le hs.le) hd hlim hlocal |
| have hdist : regionDistance E (gluedRegion E F (sublevelRegion radialSquared (r^2))) = |
| sublevelVolume (E ∆ F) radialSquared (r^2) := |
| regionDistance_gluedRegion hE.nullMeasurableSet hF.nullMeasurableSet |
| (measurableSet_sublevelRegion radialSquared_contDiff.continuous.measurable _).nullMeasurableSet |
| have hcomp := hc _ hG (hdist ▸ ht) |
| rw [hdist] at hcomp |
| rw [hμ.1, normalMeasure_radial_sublevel μ hr.le hs.le] at hb |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma lipschitz_probability_average_integrable {ν : Measure Plane} [IsProbabilityMeasure ν] |
| {f : Plane → ℝ} {K : ℝ≥0} (hf : LipschitzWith K f) |
| {δ : ℝ} (_hδ : 0 ≤ δ) (hb : ∀ᵐ y ∂ν, ‖y‖ ≤ δ) (x : Plane) : |
| Integrable (fun y ↦ f (x-y)) ν := by |
| apply (integrable_const (|f x|+(K : ℝ)*δ)).mono' |
| (hf.continuous.comp (continuous_const.sub continuous_id)).aestronglyMeasurable |
| filter_upwards [hb] with y hy |
| have hh := hf.dist_le_mul (x-y) x |
| rw [Real.dist_eq, dist_eq_norm, sub_sub_cancel_left, norm_neg] at hh |
| rw [Real.norm_eq_abs] |
| have ht := abs_add_le (f (x-y)-f x) (f x) |
| rw [sub_add_cancel] at ht |
| exact ht.trans (by nlinarith [mul_le_mul_of_nonneg_left hy K.coe_nonneg]) |
|
|
| lemma lipschitz_probability_average_error {ν : Measure Plane} [IsProbabilityMeasure ν] |
| {f : Plane → ℝ} {K : ℝ≥0} (hf : LipschitzWith K f) |
| {δ : ℝ} (hδ : 0 ≤ δ) (hb : ∀ᵐ y ∂ν, ‖y‖ ≤ δ) (x : Plane) : |
| |(∫ y, f (x-y) ∂ν)-f x| ≤ (K : ℝ)*δ := by |
| have hi := lipschitz_probability_average_integrable hf hδ hb x |
| have he : f x = ∫ _y : Plane, f x ∂ν := by simp |
| rw [he, ← integral_sub hi (integrable_const _)] |
| rw [← Real.norm_eq_abs] |
| apply (norm_integral_le_integral_norm _).trans |
| change (∫ y, ‖f (x-y)-f x‖ ∂ν) ≤ _ |
| calc |
| _ ≤ ∫ _y : Plane, (K : ℝ)*δ ∂ν := by |
| apply integral_mono_ae (hi.sub (integrable_const _)).norm (integrable_const _) |
| filter_upwards [hb] with y hy |
| have hh := hf.dist_le_mul (x-y) x |
| rw [Real.dist_eq, dist_eq_norm, sub_sub_cancel_left, norm_neg] at hh |
| rw [Real.norm_eq_abs] |
| exact hh.trans (mul_le_mul_of_nonneg_left hy K.coe_nonneg) |
| _ = _ := by simp |
|
|
| lemma lipschitz_probability_average_hasFDerivAt {ν : Measure Plane} [IsProbabilityMeasure ν] |
| (hν : ν ≪ (volume : Measure Plane)) {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {δ : ℝ} (hδ : 0 ≤ δ) (hb : ∀ᵐ y ∂ν, ‖y‖ ≤ δ) (x : Plane) : |
| Integrable (fun y ↦ fderiv ℝ f (x-y)) ν ∧ |
| HasFDerivAt (fun z ↦ ∫ y, f (z-y) ∂ν) (∫ y, fderiv ℝ f (x-y) ∂ν) x := by |
| refine hasFDerivAt_integral_of_dominated_loc_of_lip |
| (F := fun z y : Plane ↦ f (z-y)) (F' := fun y ↦ fderiv ℝ f (x-y)) |
| (x₀ := x) (s := univ) (bound := fun _ ↦ (K : ℝ)) (Filter.univ_mem) |
| (Eventually.of_forall fun z ↦ (hf.continuous.comp |
| (continuous_const.sub continuous_id)).aestronglyMeasurable) |
| (lipschitz_probability_average_integrable hf hδ hb x) |
| ((measurable_fderiv ℝ f).comp (measurable_const.sub measurable_id)).aestronglyMeasurable |
| ?_ (integrable_const _) ?_ |
| · exact Eventually.of_forall fun y ↦ by |
| have hl : LipschitzWith K (fun z : Plane ↦ f (z-y)) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro z w |
| simpa only [dist_sub_right] using hf.dist_le_mul (z-y) (w-y) |
| simpa only [Real.nnabs_of_nonneg K.coe_nonneg, Real.toNNReal_coe] using hl.lipschitzOnWith |
| · have hd : ∀ᵐ y ∂ν, DifferentiableAt ℝ f (x-y) := hν.ae_le |
| ((volume.measurePreserving_sub_left x).quasiMeasurePreserving.ae hf.ae_differentiableAt) |
| filter_upwards [hd] with y hy |
| simpa only [Function.comp_def, id_eq, ContinuousLinearMap.comp_id] using |
| hy.hasFDerivAt.comp x ((hasFDerivAt_id x).sub_const y) |
|
|
| lemma lipschitz_probability_average_gradient_sq {ν : Measure Plane} [IsProbabilityMeasure ν] |
| (hν : ν ≪ (volume : Measure Plane)) {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {δ : ℝ} (hδ : 0 ≤ δ) (hb : ∀ᵐ y ∂ν, ‖y‖ ≤ δ) (x : Plane) : |
| ‖fderiv ℝ (fun z ↦ ∫ y, f (z-y) ∂ν) x‖^2 ≤ ∫ y, ‖fderiv ℝ f (x-y)‖^2 ∂ν := by |
| have hh := lipschitz_probability_average_hasFDerivAt hν hf hδ hb x |
| rw [hh.2.fderiv] |
| have hi : Integrable (fun y ↦ ‖fderiv ℝ f (x-y)‖^2) ν := by |
| apply (integrable_const ((K : ℝ)^2)).mono' |
| (((measurable_fderiv ℝ f).comp (measurable_const.sub measurable_id)).norm.pow_const 2).aestronglyMeasurable |
| filter_upwards [] with y |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| change ‖fderiv ℝ f (x-y)‖^2 ≤ (K : ℝ)^2 |
| have hb' := norm_fderiv_le_of_lipschitz ℝ hf (x₀ := x-y) |
| nlinarith [norm_nonneg (fderiv ℝ f (x-y))] |
| have hs := integral_square_le_mass hh.1.norm hi |
| simp only [probReal_univ, one_mul] at hs |
| have hn := norm_integral_le_integral_norm (μ := ν) (fun y ↦ fderiv ℝ f (x-y)) |
| have hi0 : 0 ≤ ∫ y, ‖fderiv ℝ f (x-y)‖ ∂ν := integral_nonneg (fun y ↦ norm_nonneg _) |
| nlinarith [norm_nonneg (∫ y, fderiv ℝ f (x-y) ∂ν)] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma lipschitz_gradient_sq_integrable_ball {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (R : ℝ) : |
| IntegrableOn (fun x ↦ ‖fderiv ℝ f x‖^2) (Metric.ball (0 : Plane) R) := by |
| apply (integrableOn_const (C := (K : ℝ)^2) measure_ball_lt_top.ne).mono' |
| ((measurable_fderiv ℝ f).norm.pow_const 2).aestronglyMeasurable.restrict |
| filter_upwards [] with x |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| exact pow_le_pow_left₀ (norm_nonneg _) (norm_fderiv_le_of_lipschitz ℝ hf) 2 |
|
|
| lemma lipschitz_gradient_sq_shift_ball_le {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (R δ : ℝ) {y : Plane} (hy : ‖y‖ ≤ δ) : |
| (∫ x in Metric.ball (0 : Plane) R, ‖fderiv ℝ f (x-y)‖^2) ≤ |
| ∫ x in Metric.ball (0 : Plane) (R+δ), ‖fderiv ℝ f x‖^2 := by |
| let G : Plane → ℝ := (Metric.ball (0 : Plane) (R+δ)).indicator (fun x ↦ ‖fderiv ℝ f x‖^2) |
| have hi : Integrable G := (lipschitz_gradient_sq_integrable_ball hf (R+δ)).integrable_indicator |
| measurableSet_ball |
| have hit : Integrable (fun x ↦ G (x-y)) := by |
| simpa only [sub_eq_add_neg, Function.comp_def] using |
| ((measurePreserving_add_right volume (-y)).integrable_comp hi.aestronglyMeasurable).mpr hi |
| have hil : IntegrableOn (fun x ↦ ‖fderiv ℝ f (x-y)‖^2) (Metric.ball (0 : Plane) R) := by |
| apply (integrableOn_const (C := (K : ℝ)^2) measure_ball_lt_top.ne).mono' |
| (((measurable_fderiv ℝ f).comp (measurable_id.sub_const y)).norm.pow_const 2).aestronglyMeasurable.restrict |
| filter_upwards [] with x |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| change ‖fderiv ℝ f (x-y)‖^2 ≤ (K : ℝ)^2 |
| exact pow_le_pow_left₀ (norm_nonneg _) (norm_fderiv_le_of_lipschitz ℝ hf) 2 |
| rw [← integral_indicator measurableSet_ball] |
| calc |
| _ ≤ ∫ x : Plane, G (x-y) := by |
| apply integral_mono (hil.integrable_indicator measurableSet_ball) hit |
| intro x |
| by_cases hx : x ∈ Metric.ball (0 : Plane) R |
| · have hxy : x-y ∈ Metric.ball (0 : Plane) (R+δ) := by |
| rw [Metric.mem_ball, dist_zero_right] at hx ⊢ |
| exact (norm_sub_le x y).trans_lt (add_lt_add_of_lt_of_le hx hy) |
| simp only [indicator_of_mem hx, G, indicator_of_mem hxy, le_refl] |
| · rw [indicator_of_notMem hx] |
| exact indicator_nonneg (fun _ _ ↦ sq_nonneg _) _ |
| _ = _ := by |
| rw [show (fun x : Plane ↦ G (x-y)) = (fun x ↦ G (x+(-y))) from rfl, |
| integral_add_right_eq_self G (-y)] |
| exact integral_indicator measurableSet_ball |
|
|
| theorem lipschitz_probability_average_local_energy {ν : Measure Plane} [IsProbabilityMeasure ν] |
| (hν : ν ≪ (volume : Measure Plane)) {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {δ : ℝ} (hδ : 0 ≤ δ) (hb : ∀ᵐ y ∂ν, ‖y‖ ≤ δ) (R : ℝ) : |
| IntegrableOn (fun x ↦ ‖fderiv ℝ (fun z ↦ ∫ y, f (z-y) ∂ν) x‖^2) (Metric.ball (0 : Plane) R) ∧ |
| (∫ x in Metric.ball (0 : Plane) R, ‖fderiv ℝ (fun z ↦ ∫ y, f (z-y) ∂ν) x‖^2) ≤ |
| ∫ x in Metric.ball (0 : Plane) (R+δ), ‖fderiv ℝ f x‖^2 := by |
| let μ : Measure Plane := volume.restrict (Metric.ball (0 : Plane) R) |
| let : IsFiniteMeasure μ := isFiniteMeasure_restrict.mpr measure_ball_lt_top.ne |
| let H : Plane × Plane → ℝ := fun p ↦ ‖fderiv ℝ f (p.2-p.1)‖^2 |
| have hHm : Measurable H := ((measurable_fderiv ℝ f).comp (measurable_snd.sub measurable_fst)).norm.pow_const 2 |
| have hH : Integrable H (ν.prod μ) := by |
| apply (integrable_const ((K : ℝ)^2)).mono' hHm.aestronglyMeasurable |
| filter_upwards [] with p |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| exact pow_le_pow_left₀ (norm_nonneg _) (norm_fderiv_le_of_lipschitz ℝ hf) 2 |
| have hpoint (x : Plane) : ‖fderiv ℝ (fun z ↦ ∫ y, f (z-y) ∂ν) x‖^2 ≤ ∫ y, H (y,x) ∂ν := |
| lipschitz_probability_average_gradient_sq hν hf hδ hb x |
| have hI : Integrable (fun x ↦ ‖fderiv ℝ (fun z ↦ ∫ y, f (z-y) ∂ν) x‖^2) μ := by |
| apply hH.integral_prod_right.mono' |
| ((measurable_fderiv ℝ _).norm.pow_const 2).aestronglyMeasurable |
| filter_upwards [] with x |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| exact hpoint x |
| refine ⟨hI, ?_⟩ |
| calc |
| _ ≤ ∫ x, ∫ y, H (y,x) ∂ν ∂μ := integral_mono hI hH.integral_prod_right hpoint |
| _ = ∫ y, ∫ x, H (y,x) ∂μ ∂ν := integral_integral_swap hH.swap |
| _ ≤ ∫ _y : Plane, (∫ x in Metric.ball (0 : Plane) (R+δ), ‖fderiv ℝ f x‖^2) ∂ν := by |
| apply integral_mono_ae hH.integral_prod_left (integrable_const _) |
| filter_upwards [hb] with y hy |
| exact lipschitz_gradient_sq_shift_ball_le hf R δ hy |
| _ = _ := by simp |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology Convolution |
| namespace CubicTorus |
|
|
| def graphSmoothingMeasure (b : ContDiffBump (0 : Plane)) : Measure Plane := |
| volume.withDensity (fun y ↦ ENNReal.ofReal (b.normed volume y)) |
|
|
| instance graphSmoothingMeasure_probability (b : ContDiffBump (0 : Plane)) : |
| IsProbabilityMeasure (graphSmoothingMeasure b) := by |
| constructor |
| rw [graphSmoothingMeasure, withDensity_apply _ MeasurableSet.univ, |
| Measure.restrict_univ, ← ofReal_integral_eq_lintegral_ofReal b.integrable_normed |
| (Eventually.of_forall b.nonneg_normed), b.integral_normed] |
| norm_num |
|
|
| lemma graphSmoothingMeasure_ac (b : ContDiffBump (0 : Plane)) : |
| graphSmoothingMeasure b ≪ volume := withDensity_absolutelyContinuous _ _ |
|
|
| lemma graphSmoothingMeasure_radius (b : ContDiffBump (0 : Plane)) : |
| ∀ᵐ y ∂graphSmoothingMeasure b, ‖y‖ ≤ b.rOut := by |
| rw [graphSmoothingMeasure, ae_withDensity_iff b.continuous_normed.measurable.ennreal_ofReal] |
| filter_upwards [] with y hy |
| have hh : y ∈ Function.support (b.normed volume) := by |
| change b.normed volume y ≠ 0 |
| intro he |
| simp [he] at hy |
| rw [b.support_normed_eq, Metric.mem_ball, dist_zero_right] at hh |
| exact hh.le |
|
|
| def graphSmooth (b : ContDiffBump (0 : Plane)) (f : Plane → ℝ) : Plane → ℝ := |
| fun x ↦ ∫ y, f (x-y) ∂graphSmoothingMeasure b |
|
|
| lemma graphSmooth_eq_convolution (b : ContDiffBump (0 : Plane)) (f : Plane → ℝ) : |
| graphSmooth b f = b.normed volume ⋆ f := by |
| funext x |
| rw [graphSmooth, graphSmoothingMeasure, |
| integral_withDensity_eq_integral_toReal_smul b.continuous_normed.measurable.ennreal_ofReal |
| (Eventually.of_forall fun _ ↦ ENNReal.ofReal_lt_top)] |
| simp only [ENNReal.toReal_ofReal (b.nonneg_normed _), convolution_def, |
| ContinuousLinearMap.lsmul_apply, smul_eq_mul] |
|
|
| lemma graphSmooth_contDiff (b : ContDiffBump (0 : Plane)) {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) : ContDiff ℝ (⊤ : ℕ∞) (graphSmooth b f) := by |
| rw [graphSmooth_eq_convolution] |
| exact b.hasCompactSupport_normed.contDiff_convolution_left |
| (ContinuousLinearMap.lsmul ℝ ℝ) b.contDiff_normed hf.continuous.locallyIntegrable |
|
|
| lemma graphSmooth_error (b : ContDiffBump (0 : Plane)) {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (x : Plane) : |
| |graphSmooth b f x-f x| ≤ (K : ℝ)*b.rOut := |
| lipschitz_probability_average_error hf b.rOut_pos.le (graphSmoothingMeasure_radius b) x |
|
|
| lemma graphSmooth_local_energy (b : ContDiffBump (0 : Plane)) {f : Plane → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (R : ℝ) : |
| IntegrableOn (fun x ↦ ‖fderiv ℝ (graphSmooth b f) x‖^2) (Metric.ball (0 : Plane) R) ∧ |
| (∫ x in Metric.ball (0 : Plane) R, ‖fderiv ℝ (graphSmooth b f) x‖^2) ≤ |
| ∫ x in Metric.ball (0 : Plane) (R+b.rOut), ‖fderiv ℝ f x‖^2 := |
| lipschitz_probability_average_local_energy (graphSmoothingMeasure_ac b) hf b.rOut_pos.le |
| (graphSmoothingMeasure_radius b) R |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalGraph_norm_ge {n : Cover} (hn : ‖n‖ = 1) (g : Plane → ℝ) (y : Plane) : |
| ‖y‖ ≤ ‖normalGraph n g y‖ := by |
| have hh := (normalPlaneCoordinates_lipschitz n).dist_le_mul (normalGraph n g y) 0 |
| simpa only [normalPlaneCoordinates_graph hn, map_zero, dist_zero_right, |
| NNReal.coe_one, one_mul] using hh |
|
|
| lemma graphBallQuadraticArea_le_disk (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Continuous g) {r : ℝ} (hr : 0 ≤ r) |
| (hi : IntegrableOn (fun y ↦ ‖fderiv ℝ g y‖^2) (Metric.ball (0 : Plane) r)) : |
| graphBallQuadraticArea a n g r ≤ Real.pi*r^2 + |
| (∫ y in Metric.ball (0 : Plane) r, ‖fderiv ℝ g y‖^2)/2 := by |
| let S : Set Plane := {y | a+normalGraph n g y ∈ Metric.ball a r} |
| have hS : MeasurableSet S := measurableSet_ball.preimage |
| (graph_trace_continuous a n hg continuous_id).measurable |
| have hsub : S ⊆ Metric.ball (0 : Plane) r := by |
| intro y hy |
| have hh : ‖normalGraph n g y‖ < r := by |
| simpa only [S, mem_ofPred_eq, Metric.mem_ball, dist_eq_norm, add_sub_cancel_left] using hy |
| simpa only [Metric.mem_ball, dist_zero_right] using (normalGraph_norm_ge hn g y).trans_lt hh |
| have hii : IntegrableOn (fun y ↦ 1+‖fderiv ℝ g y‖^2/2) (Metric.ball (0 : Plane) r) := |
| (integrableOn_const (C := (1 : ℝ)) measure_ball_lt_top.ne).add (hi.div_const 2) |
| calc |
| _ ≤ ∫ y in Metric.ball (0 : Plane) r, 1+‖fderiv ℝ g y‖^2/2 := by |
| apply setIntegral_mono_set hii |
| · exact Eventually.of_forall fun y ↦ by positivity |
| · exact hsub.eventuallyLE |
| _ = _ := by |
| rw [integral_add (integrableOn_const (C := (1 : ℝ)) measure_ball_lt_top.ne) (hi.div_const 2), |
| integral_const, smul_eq_mul, mul_one, integral_div] |
| rw [show (volume.restrict (Metric.ball (0 : Plane) r)).real univ = volume.real (Metric.ball (0 : Plane) r) by simp [Measure.real], plane_ball_real hr] |
|
|
| theorem graphSmooth_ball_area_le (b : ContDiffBump (0 : Plane)) |
| {f : Plane → ℝ} {K : ℝ≥0} (hf : LipschitzWith K f) |
| (a : Cover) {n : Cover} (hn : ‖n‖ = 1) {r : ℝ} (hr : 0 ≤ r) : |
| graphBallQuadraticArea a n (graphSmooth b f) r ≤ Real.pi*r^2 + |
| (∫ y in Metric.ball (0 : Plane) (r+b.rOut), ‖fderiv ℝ f y‖^2)/2 := by |
| have hh := graphSmooth_local_energy b hf r |
| exact (graphBallQuadraticArea_le_disk a hn (graphSmooth_contDiff b hf).continuous hr hh.1).trans |
| (add_le_add le_rfl (div_le_div_of_nonneg_right hh.2 (by norm_num : (0 : ℝ) ≤ 2))) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter Metric |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma smooth_graph_energy_integrable {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) (r : ℝ) : |
| IntegrableOn (fun y ↦ ‖fderiv ℝ g y‖ ^ 2) (Metric.ball (0 : Plane) r) := by |
| apply (ContinuousOn.integrableOn_compact (isCompact_closedBall (0 : Plane) r) |
| (((hg.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).continuous.norm).pow 2).continuousOn).mono_set |
| Metric.ball_subset_closedBall |
|
|
| theorem isMinimizerAt_graph_low_slice {V : ℝ} (hV : V ∈ Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) : |
| ∃ η C : ℝ, 0 < η ∧ 0 ≤ C ∧ ∀ (n : Cover), ‖n‖ = 1 → |
| ∀ (g : Plane → ℝ), ContDiff ℝ (⊤ : ℕ∞) g → |
| ∀ a b B K : ℝ, 0 < a → a < b → b < 1/4 → B < η → |
| (∀ u, ‖deriv Real.smoothTransition u‖ ≤ K) → |
| torusVolume.real ((E ∆ torusGraphRegion cubeCenter n g) ∩ |
| Metric.ball (quotientMap cubeCenter) b) < B → |
| ∃ ρ ∈ Ioo a b, |
| (spatialNormalMeasure μ : Measure Torus).real (Metric.ball (quotientMap cubeCenter) ρ) ≤ |
| Real.pi*ρ^2 + (∫ y in Metric.ball (0 : Plane) b, ‖fderiv ℝ g y‖^2)/2 + |
| (2*K*b/(b^2-a^2)+C)*B := by |
| obtain ⟨η,C,hη,hC,hcomp⟩ := isMinimizerAt_graph_replacement hV hE hmin hμ |
| refine ⟨η,C,hη,hC,?_⟩ |
| intro n hn g hg a b B K ha hab hbs hB hK he |
| let m := sublevelVolume (E ∆ torusGraphRegion cubeCenter n g) radialSquared |
| have hm : Monotone m := sublevelVolume_mono _ _ |
| have ha2b2 : a^2 < b^2 := by nlinarith |
| have hmb : m (b^2) < B := by |
| dsimp [m, sublevelVolume] |
| rw [sublevelRegion_radialSquared (by linarith) hbs.le, cubeBall_eq_metricBall] |
| exact he |
| have hmb0 : 0 ≤ m (b^2) := measureReal_nonneg |
| have hB0 : 0 < B := hmb0.trans_lt hmb |
| have hden : 0 < b^2-a^2 := sub_pos.mpr ha2b2 |
| have hbound : m (b^2)-m (a^2) < (B/(b^2-a^2))*(b^2-a^2) := by |
| rw [div_mul_cancel₀ _ hden.ne'] |
| have hh : 0 ≤ m (a^2) := measureReal_nonneg |
| linarith |
| obtain ⟨t,ht,hd,hder⟩ := monotone_exists_deriv_le hm ha2b2 hbound |
| let ρ := Real.sqrt t |
| have ht0 : 0 < t := (sq_nonneg a).trans_lt ht.1 |
| have hρ0 : 0 < ρ := Real.sqrt_pos.mpr ht0 |
| have hρsq : ρ^2 = t := Real.sq_sqrt ht0.le |
| have hρa : a < ρ := (sq_lt_sq₀ ha.le hρ0.le).mp (by rw [hρsq]; exact ht.1) |
| have hρb : ρ < b := (sq_lt_sq₀ hρ0.le (ha.trans hab).le).mp (by rw [hρsq]; exact ht.2) |
| have hmt : m t < B := (hm ht.2.le).trans_lt hmb |
| have hcompare := hcomp n hn g hg ρ K (deriv m t) hρ0 (hρb.trans hbs) hK |
| (hρsq ▸ hd.hasDerivAt) (by simpa only [hρsq] using hmt.trans hB) |
| have har := graphBallQuadraticArea_le_disk cubeCenter hn hg.continuous hρ0.le |
| (smooth_graph_energy_integrable hg ρ) |
| have henergy : (∫ y in Metric.ball (0 : Plane) ρ, ‖fderiv ℝ g y‖^2) ≤ |
| ∫ y in Metric.ball (0 : Plane) b, ‖fderiv ℝ g y‖^2 := |
| setIntegral_mono_set (smooth_graph_energy_integrable hg b) |
| (Eventually.of_forall fun y ↦ sq_nonneg _) (Metric.ball_subset_ball hρb.le).eventuallyLE |
| have hK0 : 0 ≤ K := (norm_nonneg _).trans (hK 0) |
| have hd1 : K*(2*ρ)*deriv m t ≤ K*(2*ρ)*(B/(b^2-a^2)) := |
| mul_le_mul_of_nonneg_left hder (by positivity) |
| have hd2 : K*(2*ρ)*(B/(b^2-a^2)) ≤ K*(2*b)*(B/(b^2-a^2)) := by |
| gcongr |
| have hc1 : C*m t ≤ C*B := mul_le_mul_of_nonneg_left hmt.le hC |
| refine ⟨ρ,⟨hρa,hρb⟩,?_⟩ |
| change _ ≤ _ at hcompare |
| rw [hρsq] at hcompare |
| have heq : (2*K*b/(b^2-a^2)+C)*B = K*(2*b)*(B/(b^2-a^2))+C*B := by ring |
| rw [heq] |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
