| import Mathlib |
| import OAI.Geometry.CubicTorus.Regularity.BVC1Patch |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| instance finiteMeasure_cover_closedBall (a : Cover) (R : ℝ) : |
| IsFiniteMeasure (volume.restrict (Metric.closedBall a R)) := |
| isFiniteMeasure_restrict.mpr Metric.isBounded_closedBall.measure_lt_top.ne |
| |
| lemma blowupCharacteristic_translation_density {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| (c : Cover) {r : ℝ} (hr : 0 < r) {R : ℝ} (hR : 0 ≤ R) |
| (hc : Metric.ball c (r*R) ⊆ {x | ∀ i, 0 < x i ∧ x i < 1}) |
| {A : ℝ} (hA : 0 ≤ A) |
| (harea : (spatialNormalMeasure μ : Measure Torus).real |
| (Metric.ball (quotientMap c) (r*(R+2))) ≤ A*(r*(R+2))^2) |
| (y : Cover) (hy : ‖y‖ ≤ 1) : |
| (∫ x in Metric.ball (0 : Cover) R, |
| |blowupCharacteristic E c r (x-y)-blowupCharacteristic E c r x|) ≤ |
| ‖y‖ * (A*(R+2)^2) := by |
| have hq : ‖quotientMap (r • y)‖ ≤ r*‖y‖ := by |
| simpa only [norm_smul,Real.norm_of_nonneg hr.le] using norm_quotientMap_le (r • y) |
| have hqr : ‖quotientMap (r • y)‖ ≤ r := |
| hq.trans (by simpa using mul_le_mul_of_nonneg_left hy hr.le) |
| have hb : r*R+r+‖quotientMap (r • y)‖ ≤ r*(R+2) := by nlinarith |
| have hm := (measureReal_mono (μ := (spatialNormalMeasure μ : Measure Torus)) |
| (Metric.ball_subset_ball hb)).trans harea |
| have h := (blowupCharacteristic_translation_bound hE hμ c hr R hr hc y).trans |
| (mul_le_mul_of_nonneg_left hm (mul_nonneg (pow_nonneg (inv_nonneg.mpr hr.le) 3) (norm_nonneg _))) |
| have h' := mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_left hq (pow_nonneg (inv_nonneg.mpr hr.le) 3)) |
| (mul_nonneg hA (sq_nonneg (r*(R+2)))) |
| apply h.trans (h'.trans_eq _) |
| field_simp |
| |
| theorem totallyBounded_blowupCharacteristic {ι : Type*} {E : Set Torus} |
| (hE : MeasurableSet E) {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| (c : Cover) (r : ι → ℝ) (hr : ∀ i, 0 < r i) {R : ℝ} (hR : 0 < R) |
| (hc : ∀ i, Metric.ball c (r i*(R+1)) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) |
| {A : ℝ} (hA : 0 ≤ A) |
| (harea : ∀ i, (spatialNormalMeasure μ : Measure Torus).real |
| (Metric.ball (quotientMap c) (r i*((R+1)+2))) ≤ A*(r i*((R+1)+2))^2) : |
| TotallyBounded (range fun i ↦ boundedFunctionL1 |
| (volume.restrict (Metric.closedBall (0 : Cover) R)) (blowupCharacteristic E c (r i)) |
| (measurable_blowupCharacteristic hE c (r i)) (blowupCharacteristic_bound E c (r i))) := by |
| apply totallyBounded_local_translation (η := volume) (isCompact_closedBall _ _) |
| (fun i ↦ blowupCharacteristic E c (r i)) |
| (fun i ↦ measurable_blowupCharacteristic hE c (r i)) |
| (fun i ↦ blowupCharacteristic_bound E c (r i)) |
| (A := A*((R+1)+2)^2) (ε₀ := 1) (by positivity) (by norm_num) |
| intro i y hy |
| have htrans := blowupCharacteristic_translation_density hE hμ c (hr i) |
| (by linarith : 0 ≤ R+1) (hc i) hA (harea i) y hy |
| apply le_trans _ htrans |
| apply setIntegral_mono_set _ (ae_of_all _ fun _ ↦ abs_nonneg _) |
| (ae_of_all _ fun _ hx ↦ Metric.closedBall_subset_ball (by linarith : R < R+1) hx) |
| let : IsFiniteMeasure (volume.restrict (Metric.ball (0 : Cover) (R+1))) := |
| isFiniteMeasure_restrict.mpr Metric.isBounded_ball.measure_lt_top.ne |
| have hf := measurable_blowupCharacteristic hE c (r i) |
| have hbound := blowupCharacteristic_bound E c (r i) |
| apply Integrable.of_bound (μ := volume.restrict (Metric.ball (0 : Cover) (R+1))) |
| (((hf.comp (measurable_id.sub_const y)).sub hf).abs.aestronglyMeasurable) 2 |
| apply ae_of_all |
| intro x |
| simp only [Real.norm_eq_abs,abs_abs,Function.comp_apply,id_eq,Pi.sub_apply] |
| exact (abs_sub _ _).trans (by linarith [hbound (x-y),hbound x]) |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| abbrev BlowupNormalBundle := Cover × NormalSphere |
| |
| def blowupNormalMap (c : Cover) (r : ℝ) (z : NormalBundle) : BlowupNormalBundle := |
| (r⁻¹ • ((z.1 : Cover)-c),z.2) |
| |
| lemma continuous_blowupNormalMap (c : Cover) (r : ℝ) : |
| Continuous (blowupNormalMap c r) := by |
| have hx : Continuous (fun z : NormalBundle ↦ (z.1 : Cover)) := |
| continuous_subtype_val.comp continuous_fst |
| exact ((hx.sub continuous_const).const_smul r⁻¹).prodMk continuous_snd |
| |
| def blowupNormalMeasure (μ : FiniteMeasure NormalBundle) (c : Cover) (r R : ℝ) : |
| FiniteMeasure BlowupNormalBundle := |
| Real.toNNReal (r⁻¹^2) • |
| (μ.restrict {z | (z.1 : Cover) ∈ Metric.ball c (r*R)}).map (blowupNormalMap c r) |
| |
| lemma blowupNormalMeasure_mass (μ : FiniteMeasure NormalBundle) (c : Cover) (r R : ℝ) : |
| ((blowupNormalMeasure μ c r R).mass : ℝ) = r⁻¹^2*cellBallMass μ c (r*R) := by |
| change (((Real.toNNReal (r⁻¹^2) • |
| (μ.restrict {z | (z.1 : Cover) ∈ Metric.ball c (r*R)}).map (blowupNormalMap c r)) univ) : ℝ) = _ |
| rw [FiniteMeasure.smul_apply,FiniteMeasure.map_apply _ |
| (continuous_blowupNormalMap c r).measurable MeasurableSet.univ] |
| rw [Set.preimage_univ,FiniteMeasure.restrict_apply _ _ MeasurableSet.univ,univ_inter] |
| change (Real.toNNReal (r⁻¹^2) : ℝ) * |
| (((μ : Measure NormalBundle) {z | (z.1 : Cover) ∈ Metric.ball c (r*R)}).toNNReal : ℝ) = _ |
| rw [Real.coe_toNNReal _ (sq_nonneg _)] |
| rfl |
| |
| lemma blowupNormalMap_mem (c : Cover) {r : ℝ} (hr : 0 < r) (R : ℝ) |
| (z : NormalBundle) : |
| (blowupNormalMap c r z).1 ∈ Metric.ball (0 : Cover) R ↔ |
| (z.1 : Cover) ∈ Metric.ball c (r*R) := by |
| simp only [blowupNormalMap,Metric.mem_ball,dist_eq_norm,sub_zero,norm_smul, |
| Real.norm_of_nonneg (inv_nonneg.mpr hr.le)] |
| rw [← div_eq_inv_mul,div_lt_iff₀ hr] |
| rw [mul_comm R r] |
| |
| lemma blowupNormalMeasure_supported (μ : FiniteMeasure NormalBundle) (c : Cover) |
| {r : ℝ} (hr : 0 < r) (R : ℝ) : |
| blowupNormalMeasure μ c r R ((Metric.closedBall (0 : Cover) R ×ˢ univ)ᶜ) = 0 := by |
| have hm : MeasurableSet ((Metric.closedBall (0 : Cover) R ×ˢ (univ : Set NormalSphere))ᶜ) := |
| (Metric.isClosed_closedBall.measurableSet.prod MeasurableSet.univ).compl |
| have he : (blowupNormalMap c r ⁻¹' ((Metric.closedBall (0 : Cover) R ×ˢ univ)ᶜ)) ∩ |
| {z : NormalBundle | (z.1 : Cover) ∈ Metric.ball c (r*R)} = ∅ := by |
| apply Set.eq_empty_iff_forall_notMem.mpr |
| intro z hz |
| exact hz.1 ⟨Metric.ball_subset_closedBall ((blowupNormalMap_mem c hr R z).mpr hz.2),mem_univ _⟩ |
| unfold blowupNormalMeasure |
| rw [FiniteMeasure.smul_apply, |
| FiniteMeasure.map_apply _ (continuous_blowupNormalMap c r).measurable hm, |
| FiniteMeasure.restrict_apply _ _ (hm.preimage (continuous_blowupNormalMap c r).measurable),he] |
| simp [FiniteMeasure.coeFn_def] |
| |
| theorem blowupNormalMeasure_cluster {μ : FiniteMeasure NormalBundle} |
| (c : Cover) (r : ℕ → ℝ) (hr : ∀ i, 0 < r i) {R A : ℝ} (hA : 0 ≤ A) |
| (hb : ∀ i, cellBallMass μ c (r i*R) ≤ A*(r i)^2) : |
| ∃ ν : FiniteMeasure BlowupNormalBundle, |
| (ν.mass : ℝ) ≤ A ∧ ν ((Metric.closedBall (0 : Cover) R ×ˢ univ)ᶜ) = 0 ∧ |
| MapClusterPt ν atTop (fun i ↦ blowupNormalMeasure μ c (r i) R) := by |
| have hm (i) : (blowupNormalMeasure μ c (r i) R).mass ≤ Real.toNNReal A := by |
| rw [← NNReal.coe_le_coe,Real.coe_toNNReal _ hA,blowupNormalMeasure_mass] |
| calc |
| _ ≤ (r i)⁻¹^2*(A*(r i)^2) := mul_le_mul_of_nonneg_left (hb i) (sq_nonneg _) |
| _ = A := by field_simp [(hr i).ne'] |
| have hK : IsCompact (Metric.closedBall (0 : Cover) R ×ˢ (univ : Set NormalSphere)) := |
| (isCompact_closedBall _ _).prod isCompact_univ |
| obtain ⟨ν,hν,hcl⟩ := (isCompact_setOfPred_finiteMeasure_le_of_isCompact |
| (Real.toNNReal A) hK).exists_mapClusterPt |
| (show Filter.map (fun i ↦ blowupNormalMeasure μ c (r i) R) atTop ≤ |
| 𝓟 {ν | ν.mass ≤ Real.toNNReal A ∧ |
| ν ((Metric.closedBall (0 : Cover) R ×ˢ univ)ᶜ) = 0} from |
| tendsto_principal.mpr (Eventually.of_forall fun i ↦ |
| ⟨hm i,blowupNormalMeasure_supported μ c (hr i) R⟩)) |
| refine ⟨ν,?_,hν.2,hcl⟩ |
| simpa only [Real.coe_toNNReal _ hA] using (NNReal.coe_le_coe.mpr hν.1) |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace BoundedContinuousFunction |
| namespace CubicTorus |
| |
| lemma integral_blowupNormalMeasure (μ : FiniteMeasure NormalBundle) (c : Cover) |
| (r R : ℝ) {g : BlowupNormalBundle → ℝ} (hg : Continuous g) : |
| (∫ z, g z ∂(blowupNormalMeasure μ c r R : Measure BlowupNormalBundle)) = |
| r⁻¹^2 * ∫ z in {z : NormalBundle | (z.1 : Cover) ∈ Metric.ball c (r*R)}, |
| g (blowupNormalMap c r z) ∂(μ : Measure NormalBundle) := by |
| rw [blowupNormalMeasure,FiniteMeasure.toMeasure_smul,integral_smul_nnreal_measure, |
| FiniteMeasure.toMeasure_map,integral_map |
| (continuous_blowupNormalMap c r).measurable.aemeasurable hg.measurable.aestronglyMeasurable] |
| change (Real.toNNReal (r⁻¹^2) : ℝ) * _ = _ |
| rw [Real.coe_toNNReal _ (sq_nonneg _)] |
| rfl |
| |
| lemma tangentialDivergence_zero_of_notMem_tsupport {F : Cover → Cover} {x : Cover} |
| (hx : x ∉ tsupport F) (n : Cover) : tangentialDivergence F x n = 0 := by |
| simp [tangentialDivergence,divergence_of_notMem_tsupport hx,fderiv_of_notMem_tsupport ℝ hx] |
| |
| lemma hasCompactSupport_normalBundle_test {F : Cover → Cover} (hF : HasCompactSupport F) |
| {g : BlowupNormalBundle → ℝ} (hg : ∀ z, z.1 ∉ tsupport F → g z = 0) : |
| HasCompactSupport g := by |
| apply (hF.prod (isCompact_univ : IsCompact (univ : Set NormalSphere))).of_isClosed_subset |
| isClosed_closure |
| apply closure_minimal _ (isClosed_closure.prod isClosed_univ) |
| intro z hz |
| refine ⟨?_,mem_univ _⟩ |
| by_contra hh |
| exact hz (hg z hh) |
| |
| lemma continuous_blowupFluxTest {F : Cover → Cover} (hF : Continuous F) : |
| Continuous (fun z : BlowupNormalBundle ↦ ⟪(z.2 : Cover),F z.1⟫) := |
| (continuous_subtype_val.comp continuous_snd).inner (hF.comp continuous_fst) |
| |
| lemma continuous_blowupTangentTest {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) : |
| Continuous (fun z : BlowupNormalBundle ↦ tangentialDivergence F z.1 z.2) := |
| ((continuous_divergence hF).comp continuous_fst).sub |
| ((continuous_subtype_val.comp continuous_snd).inner |
| (((hF.continuous_fderiv (by simp)).comp continuous_fst).clm_apply |
| (continuous_subtype_val.comp continuous_snd))) |
| |
| def blowupFluxTest {F : Cover → Cover} (hF : Continuous F) (hs : HasCompactSupport F) : |
| BlowupNormalBundle →ᵇ ℝ := |
| ofCompactSupport _ (continuous_blowupFluxTest hF) |
| (hasCompactSupport_normalBundle_test hs (fun z hz ↦ by |
| simp [image_eq_zero_of_notMem_tsupport hz])) |
| |
| def blowupTangentTest {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) |
| (hs : HasCompactSupport F) : BlowupNormalBundle →ᵇ ℝ := |
| ofCompactSupport _ (continuous_blowupTangentTest hF) |
| (hasCompactSupport_normalBundle_test hs (fun z hz ↦ |
| tangentialDivergence_zero_of_notMem_tsupport hz z.2)) |
| |
| lemma integral_blowup_test (μ : FiniteMeasure NormalBundle) (c : Cover) |
| {r R : ℝ} (hr : 0 < r) {g : BlowupNormalBundle → ℝ} (hg : Continuous g) |
| (hzero : ∀ z, z.1 ∉ Metric.ball (0 : Cover) R → g z = 0) : |
| (∫ z, g z ∂(blowupNormalMeasure μ c r R : Measure BlowupNormalBundle)) = |
| r⁻¹^2 * ∫ z, g (blowupNormalMap c r z) ∂(μ : Measure NormalBundle) := by |
| rw [integral_blowupNormalMeasure μ c r R hg] |
| congr 1 |
| apply setIntegral_eq_integral_of_forall_compl_eq_zero |
| intro z hz |
| exact hzero _ (by rwa [blowupNormalMap_mem c hr R z]) |
| |
| lemma tangentialDivergence_scaledTestField {F : Cover → Cover} |
| (hF : Differentiable ℝ F) (c x n : Cover) {r : ℝ} (hr : r ≠ 0) : |
| tangentialDivergence (scaledTestField c r F) x n = |
| tangentialDivergence F (r⁻¹ • (x-c)) n := by |
| simp only [tangentialDivergence,divergence_scaledTestField hF c x hr, |
| fderiv_scaledTestField hF c x hr] |
| |
| theorem weakCMC_blowup_identity {E : Set Torus} {μ : FiniteMeasure NormalBundle} |
| (hμ : IsNormalMeasure E μ) {H : ℝ} |
| (hH : ∀ D : WallVariation, normalFirstVariation μ D = |
| H * directionalFlux E D.coordinate D.function) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) |
| (hs : tsupport F ⊆ Metric.closedBall (0 : Cover) 1) |
| (c : Cover) {r R : ℝ} (hr : 0 < r) (hR : 1 < R) |
| (hc : Metric.closedBall c r ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) : |
| (∫ z, tangentialDivergence F z.1 z.2 |
| ∂(blowupNormalMeasure μ c r R : Measure BlowupNormalBundle)) = |
| (r*H) * ∫ z, ⟪(z.2 : Cover),F z.1⟫ |
| ∂(blowupNormalMeasure μ c r R : Measure BlowupNormalBundle) := by |
| have ht (z : BlowupNormalBundle) (hz : z.1 ∉ Metric.ball (0 : Cover) R) : |
| z.1 ∉ tsupport F := fun hh ↦ hz (Metric.closedBall_subset_ball hR (hs hh)) |
| rw [integral_blowup_test μ c hr (continuous_blowupTangentTest hF) |
| (fun z hz ↦ tangentialDivergence_zero_of_notMem_tsupport (ht z hz) z.2), |
| integral_blowup_test μ c hr (continuous_blowupFluxTest hF.continuous) |
| (fun z hz ↦ by simp [image_eq_zero_of_notMem_tsupport (ht z hz)])] |
| have hid := weakCMC_local_identity hμ hH (scaledTestField_contDiff hF c r) |
| (scaledTestField_hasCompactSupport hs c hr) ((scaledTestField_tsupport hs c hr).trans hc) |
| simp only [tangentialDivergence_scaledTestField (hF.differentiable (by simp)) c _ _ hr.ne', |
| scaledTestField,inner_smul_right,integral_const_mul] at hid |
| change r⁻¹^2*(∫ z, tangentialDivergence F (r⁻¹ • ((z.1 : Cover)-c)) z.2 |
| ∂(μ : Measure NormalBundle)) = _ |
| rw [hid] |
| simp only [blowupNormalMap] |
| ring |
| |
| theorem weakCMC_blowup_limit_stationary {E : Set Torus} {μ : FiniteMeasure NormalBundle} |
| (hμ : IsNormalMeasure E μ) {H : ℝ} |
| (hH : ∀ D : WallVariation, normalFirstVariation μ D = |
| H * directionalFlux E D.coordinate D.function) |
| (c : Cover) (r : ℕ → ℝ) (hr : ∀ i, 0 < r i) {R : ℝ} (hR : 1 < R) |
| (hc : ∀ i, Metric.closedBall c (r i) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) |
| {l : Filter ℕ} [NeBot l] (hrlim : Tendsto r l (𝓝 0)) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (hlim : Tendsto (fun i ↦ blowupNormalMeasure μ c (r i) R) l (𝓝 ν)) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) |
| (hs : tsupport F ⊆ Metric.closedBall (0 : Cover) 1) : |
| (∫ z, tangentialDivergence F z.1 z.2 ∂(ν : Measure BlowupNormalBundle)) = 0 := by |
| have hFs : HasCompactSupport F := (isCompact_closedBall _ _).of_isClosed_subset isClosed_closure hs |
| have ht := (FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp hlim) (blowupTangentTest hF hFs) |
| have hf := (FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp hlim) (blowupFluxTest hF.continuous hFs) |
| have hh := (hrlim.mul_const H).mul hf |
| simp only [zero_mul] at hh |
| have he (i) := weakCMC_blowup_identity hμ hH hF hs c (hr i) hR (hc i) |
| exact tendsto_nhds_unique ht (hh.congr (fun i ↦ (he i).symm)) |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| lemma cover_indicator_bound (F : Set Cover) (x : Cover) : |
| |F.indicator (fun _ ↦ (1 : ℝ)) x| ≤ 1 := by |
| classical |
| by_cases hx : x ∈ F <;> simp [hx] |
| |
| lemma boundedFunctionL1_ae {η : Measure Cover} [IsFiniteMeasure η] |
| {g : Cover → ℝ} (hg : Measurable g) (hb : ∀ x, |g x| ≤ 1) : |
| boundedFunctionL1 η g hg hb =ᵐ[η] g := (integrable_bounded_one hg hb).coeFn_toL1 |
| |
| theorem exists_cover_indicator_limit {η : Measure Cover} [IsFiniteMeasure η] |
| (g : ℕ → Cover → ℝ) (hg : ∀ i, Measurable (g i)) |
| (hgb : ∀ i x, |g i x| ≤ 1) (hphase : ∀ i x, g i x = 0 ∨ g i x = 1) |
| (ht : TotallyBounded (range fun i ↦ boundedFunctionL1 η (g i) (hg i) (hgb i))) : |
| ∃ F : Set Cover, ∃ hF : MeasurableSet F, ∃ φ : ℕ → ℕ, StrictMono φ ∧ |
| Tendsto (fun i ↦ boundedFunctionL1 η (g (φ i)) (hg (φ i)) (hgb (φ i))) atTop |
| (𝓝 (boundedFunctionL1 η (F.indicator (fun _ ↦ (1 : ℝ))) |
| (measurable_const.indicator hF) (cover_indicator_bound F))) ∧ |
| ∀ᵐ x ∂η, Tendsto (fun i ↦ g (φ i) x) atTop |
| (𝓝 (F.indicator (fun _ ↦ (1 : ℝ)) x)) := by |
| let gs (i) := boundedFunctionL1 η (g i) (hg i) (hgb i) |
| obtain ⟨f,_,ns,hns,hconv⟩ := (ht.closure.isCompact_of_isClosed isClosed_closure).tendsto_subseq |
| (fun i ↦ subset_closure (mem_range_self i)) |
| obtain ⟨ms,hms,hae⟩ := (tendstoInMeasure_of_tendsto_Lp hconv).exists_seq_tendsto_ae |
| have hcoe : ∀ᵐ x ∂η, ∀ i, gs (ns (ms i)) x = g (ns (ms i)) x := |
| ae_all_iff.mpr (fun i ↦ boundedFunctionL1_ae (hg _) (hgb _)) |
| have hlim : ∀ᵐ x ∂η, Tendsto (fun i ↦ g (ns (ms i)) x) atTop (𝓝 (f x)) := by |
| filter_upwards [hae,hcoe] with x hx hh |
| convert hx using 1 |
| ext i |
| exact (hh i).symm |
| let F : Set Cover := {x | f x = 1} |
| have hF : MeasurableSet F := (Lp.stronglyMeasurable f).measurable (measurableSet_singleton 1) |
| have hchar : f =ᵐ[η] F.indicator (fun _ ↦ (1 : ℝ)) := by |
| filter_upwards [hlim] with x hx |
| have hf : f x ∈ ({0,1} : Set ℝ) := by |
| apply ((finite_singleton (1 : ℝ)).insert 0).isClosed.mem_of_tendsto hx |
| exact Eventually.of_forall fun i ↦ by |
| rcases hphase (ns (ms i)) x with h|h <;> simp [h] |
| rcases mem_insert_iff.mp hf with h0|h1 |
| · have hxF : x ∉ F := by simp [F,h0] |
| simp [hxF,h0] |
| · have hxF : x ∈ F := h1 |
| simp [hxF,show f x = 1 from h1] |
| have heq : f = boundedFunctionL1 η (F.indicator (fun _ ↦ (1 : ℝ))) |
| (measurable_const.indicator hF) (cover_indicator_bound F) := |
| Lp.ext (hchar.trans (boundedFunctionL1_ae (measurable_const.indicator hF) |
| (cover_indicator_bound F)).symm) |
| refine ⟨F,hF,ns ∘ ms,hns.comp hms,?_,?_⟩ |
| · simpa only [Function.comp_def,heq] using hconv.comp hms.tendsto_atTop |
| · filter_upwards [hlim,hchar] with x hx hh |
| simpa only [Function.comp_apply,← hh] using hx |
| |
| lemma boundedFunctionL1_integral_tendsto {η : Measure Cover} [IsFiniteMeasure η] |
| (g : ℕ → Cover → ℝ) (hg : ∀ i, Measurable (g i)) (hgb : ∀ i x, |g i x| ≤ 1) |
| {f : Cover → ℝ} (hf : Measurable f) (hfb : ∀ x, |f x| ≤ 1) |
| (hlim : Tendsto (fun i ↦ boundedFunctionL1 η (g i) (hg i) (hgb i)) atTop |
| (𝓝 (boundedFunctionL1 η f hf hfb))) : |
| Tendsto (fun i ↦ ∫ x, |g i x-f x| ∂η) atTop (𝓝 0) := by |
| have h := hlim.dist (tendsto_const_nhds (x := boundedFunctionL1 η f hf hfb)) |
| simpa only [dist_self,boundedFunctionL1_dist] using h |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| theorem isMinimizerAt_blowup_limit {V : ℝ} (hV : V ∈ Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (c : Cover) {d : ℝ} (hd : 0 < d) |
| (hc : Metric.ball c d ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) |
| (r : ℕ → ℝ) (hr : ∀ i, 0 < r i) (hrlim : Tendsto r atTop (𝓝 0)) |
| {R : ℝ} (hR : 0 < R) : |
| ∃ F : Set Cover, MeasurableSet F ∧ ∃ φ : ℕ → ℕ, StrictMono φ ∧ |
| Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |
| |blowupCharacteristic E c (r (φ i)) x-F.indicator (fun _ ↦ (1 : ℝ)) x|) |
| atTop (𝓝 0) ∧ |
| ∀ᵐ x ∂volume.restrict (Metric.closedBall (0 : Cover) R), |
| Tendsto (fun i ↦ blowupCharacteristic E c (r (φ i)) x) atTop |
| (𝓝 (F.indicator (fun _ ↦ (1 : ℝ)) x)) := by |
| obtain ⟨S,A,hS,hA,harea⟩ := isMinimizerAt_perimeter_upper_density hV hE hmin |
| obtain ⟨μ,hμ⟩ := exists_normalMeasure hE hmin.1.2.ne |
| have hsmall : 0 < min (d/(R+1)) (S/((R+1)+2)) := by positivity |
| obtain ⟨k,hk⟩ := eventually_atTop.mp (hrlim.eventually (gt_mem_nhds hsmall)) |
| let s : ℕ → ℝ := fun i ↦ r (i+k) |
| have hs (i) : 0 < s i := hr _ |
| have hsb (i) : s i < min (d/(R+1)) (S/((R+1)+2)) := hk _ (by omega) |
| have hchart (i) : Metric.ball c (s i*(R+1)) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1} := by |
| apply (Metric.ball_subset_ball _).trans hc |
| exact ((lt_div_iff₀ (by linarith : 0 < R+1)).mp |
| ((hsb i).trans_le (min_le_left _ _))).le |
| have hb (i) : (spatialNormalMeasure μ : Measure Torus).real |
| (Metric.ball (quotientMap c) (s i*((R+1)+2))) ≤ A*(s i*((R+1)+2))^2 := by |
| apply harea μ hμ _ _ (by have hh := hs i; positivity) |
| exact ((lt_div_iff₀ (by linarith : 0 < (R+1)+2)).mp |
| ((hsb i).trans_le (min_le_right _ _))).le |
| have ht := totallyBounded_blowupCharacteristic hE hμ c s hs hR hchart hA.le hb |
| obtain ⟨F,hF,φ,hφ,hconv,hae⟩ := exists_cover_indicator_limit |
| (fun i ↦ blowupCharacteristic E c (s i)) |
| (fun i ↦ measurable_blowupCharacteristic hE c (s i)) |
| (fun i ↦ blowupCharacteristic_bound E c (s i)) |
| (fun i x ↦ characteristic_dichotomy E (quotientMap (c+s i • x))) ht |
| refine ⟨F,hF,fun i ↦ φ i+k,fun i j hij ↦ Nat.add_lt_add_right (hφ hij) k,?_,hae⟩ |
| exact boundedFunctionL1_integral_tendsto |
| (fun i ↦ blowupCharacteristic E c (s (φ i))) |
| (fun i ↦ measurable_blowupCharacteristic hE c (s (φ i))) |
| (fun i ↦ blowupCharacteristic_bound E c (s (φ i))) |
| (measurable_const.indicator hF) (cover_indicator_bound F) hconv |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| lemma integral_blowupCharacteristic_ball {E : Set Torus} (hE : MeasurableSet E) |
| (c : Cover) {r : ℝ} (hr : 0 < r) (R : ℝ) |
| (hc : Metric.ball c (r*R) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) : |
| torusVolume.real (E ∩ Metric.ball (quotientMap c) (r*R)) = |
| r^3 * ∫ x in Metric.ball (0 : Cover) R, blowupCharacteristic E c r x := by |
| rw [← setIntegral_characteristic hE _ Metric.isOpen_ball.measurableSet, |
| integral_quotient_ball _ (measurable_characteristic hE) c _ hc, |
| integral_ball_affine_scaling _ c hr R] |
| rfl |
| |
| lemma localL1_integral_tendsto {η : Measure Cover} [IsFiniteMeasure η] |
| (g : ℕ → Cover → ℝ) (hg : ∀ i, Measurable (g i)) |
| (hgb : ∀ i x, |g i x| ≤ 1) {f : Cover → ℝ} (hf : Measurable f) |
| (hfb : ∀ x, |f x| ≤ 1) |
| (hlim : Tendsto (fun i ↦ ∫ x, |g i x-f x| ∂η) atTop (𝓝 0)) |
| (s : Set Cover) : |
| Tendsto (fun i ↦ ∫ x in s, g i x ∂η) atTop (𝓝 (∫ x in s, f x ∂η)) := by |
| have hi (i) : Integrable (fun x ↦ |g i x-f x|) η := |
| ((integrable_bounded_one (hg i) (hgb i)).sub (integrable_bounded_one hf hfb)).abs |
| have hl : Tendsto (fun i ↦ ∫ x in s, |g i x-f x| ∂η) atTop (𝓝 0) := by |
| apply squeeze_zero (fun i ↦ integral_nonneg (fun x ↦ abs_nonneg _)) _ hlim |
| intro i |
| exact setIntegral_le_integral (hi i) (ae_of_all _ (fun x ↦ abs_nonneg _)) |
| apply tendsto_integral_of_L1 f hf.aestronglyMeasurable |
| (Eventually.of_forall (fun i ↦ integrable_bounded_one (η := η.restrict s) (hg i) (hgb i))) |
| have ho := ENNReal.continuous_ofReal.continuousAt.tendsto.comp hl |
| simp only [ENNReal.ofReal_zero] at ho |
| convert ho using 1 |
| funext i |
| symm |
| simpa only [Real.norm_eq_abs,Pi.sub_apply,Function.comp_apply] using ofReal_integral_norm_eq_lintegral_enorm |
| (((integrable_bounded_one (hg i) (hgb i)).sub (integrable_bounded_one hf hfb)).restrict (s := s)) |
| |
| lemma localL1_ball_integral_tendsto {R ρ : ℝ} (hρ : ρ ≤ R) |
| (g : ℕ → Cover → ℝ) (hg : ∀ i, Measurable (g i)) |
| (hgb : ∀ i x, |g i x| ≤ 1) {f : Cover → ℝ} (hf : Measurable f) |
| (hfb : ∀ x, |f x| ≤ 1) |
| (hlim : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |
| |g i x-f x|) atTop (𝓝 0)) : |
| Tendsto (fun i ↦ ∫ x in Metric.ball (0 : Cover) ρ, g i x) atTop |
| (𝓝 (∫ x in Metric.ball (0 : Cover) ρ, f x)) := by |
| have h := localL1_integral_tendsto g hg hgb hf hfb hlim (Metric.ball (0 : Cover) ρ) |
| simpa only [Measure.restrict_restrict Metric.isOpen_ball.measurableSet, |
| inter_eq_left.mpr ((Metric.ball_subset_ball hρ).trans Metric.ball_subset_closedBall)] using h |
| |
| theorem isMinimizerAt_blowup_limit_density {V : ℝ} (hV : V ∈ Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (c : Cover) (hb : quotientMap c ∈ volumeSupport E ∩ volumeSupport Eᶜ) |
| {d : ℝ} (hd : 0 < d) |
| (hc : Metric.ball c d ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) |
| (r : ℕ → ℝ) (hr : ∀ i, 0 < r i) (hrlim : Tendsto r atTop (𝓝 0)) |
| {R : ℝ} (hR : 0 < R) {F : Set Cover} (hF : MeasurableSet F) |
| (hlim : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |
| |blowupCharacteristic E c (r i) x-F.indicator (fun _ ↦ (1 : ℝ)) x|) |
| atTop (𝓝 0)) : |
| ∃ b : ℝ, 0 < b ∧ ∀ ρ : ℝ, 0 < ρ → ρ ≤ R → |
| b*ρ^3 ≤ volume.real (F ∩ Metric.ball (0 : Cover) ρ) ∧ |
| b*ρ^3 ≤ volume.real (Fᶜ ∩ Metric.ball (0 : Cover) ρ) := by |
| obtain ⟨S,b,hS,hbpos,hden⟩ := isMinimizerAt_two_sided_density hV hE hmin |
| refine ⟨b,hbpos,?_⟩ |
| intro ρ hρ hρR |
| have hsmall : 0 < min d S / R := div_pos (lt_min hd hS) hR |
| have hevent : ∀ᶠ i in atTop, r i*ρ < min d S := by |
| filter_upwards [hrlim.eventually (gt_mem_nhds hsmall)] with i hi |
| exact (mul_le_mul_of_nonneg_left hρR (hr i).le).trans_lt ((lt_div_iff₀ hR).mp hi) |
| have hint := localL1_ball_integral_tendsto hρR |
| (fun i ↦ blowupCharacteristic E c (r i)) |
| (fun i ↦ measurable_blowupCharacteristic hE c (r i)) |
| (fun i ↦ blowupCharacteristic_bound E c (r i)) |
| (measurable_const.indicator hF) (cover_indicator_bound F) hlim |
| have hcomp (i x) : blowupCharacteristic Eᶜ c (r i) x = |
| 1-blowupCharacteristic E c (r i) x := by |
| classical |
| by_cases hx : quotientMap (c+r i • x) ∈ E <;> |
| simp [blowupCharacteristic,characteristic,hx] |
| have hfcomp (x : Cover) : Fᶜ.indicator (fun _ ↦ (1 : ℝ)) x = |
| 1-F.indicator (fun _ ↦ (1 : ℝ)) x := by |
| classical |
| by_cases hx : x ∈ F <;> simp [hx] |
| have hlimc : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |
| |blowupCharacteristic Eᶜ c (r i) x-Fᶜ.indicator (fun _ ↦ (1 : ℝ)) x|) |
| atTop (𝓝 0) := by |
| convert hlim using 2 |
| rename_i i |
| apply integral_congr_ae |
| apply ae_of_all |
| intro x |
| change |blowupCharacteristic Eᶜ c (r i) x-Fᶜ.indicator (fun _ ↦ (1 : ℝ)) x| = _ |
| rw [hcomp,hfcomp,show 1-blowupCharacteristic E c (r i) x - |
| (1-F.indicator (fun _ ↦ (1 : ℝ)) x) = |
| -(blowupCharacteristic E c (r i) x-F.indicator (fun _ ↦ (1 : ℝ)) x) by ring, |
| abs_neg] |
| have hintc := localL1_ball_integral_tendsto hρR |
| (fun i ↦ blowupCharacteristic Eᶜ c (r i)) |
| (fun i ↦ measurable_blowupCharacteristic hE.compl c (r i)) |
| (fun i ↦ blowupCharacteristic_bound Eᶜ c (r i)) |
| (measurable_const.indicator hF.compl) (cover_indicator_bound Fᶜ) hlimc |
| have hlow : ∀ᶠ i in atTop, |
| b*ρ^3 ≤ ∫ x in Metric.ball (0 : Cover) ρ, blowupCharacteristic E c (r i) x ∧ |
| b*ρ^3 ≤ ∫ x in Metric.ball (0 : Cover) ρ, blowupCharacteristic Eᶜ c (r i) x := by |
| filter_upwards [hevent] with i hi |
| have hchart : Metric.ball c (r i*ρ) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1} := |
| (Metric.ball_subset_ball (hi.trans_le (min_le_left _ _)).le).trans hc |
| have hh := hden _ hb (r i*ρ) (mul_pos (hr i) hρ) |
| (hi.trans_le (min_le_right _ _)).le |
| rw [integral_blowupCharacteristic_ball hE c (hr i) ρ hchart, |
| integral_blowupCharacteristic_ball hE.compl c (hr i) ρ hchart] at hh |
| constructor |
| · apply (mul_le_mul_iff_right₀ (pow_pos (hr i) 3)).mp |
| calc |
| _ = b*(r i*ρ)^3 := by ring |
| _ ≤ _ := hh.1 |
| · apply (mul_le_mul_iff_right₀ (pow_pos (hr i) 3)).mp |
| calc |
| _ = b*(r i*ρ)^3 := by ring |
| _ ≤ _ := hh.2 |
| have heq (A : Set Cover) (hA : MeasurableSet A) : |
| (∫ x in Metric.ball (0 : Cover) ρ, A.indicator (fun _ ↦ (1 : ℝ)) x) = |
| volume.real (A ∩ Metric.ball (0 : Cover) ρ) := by |
| rw [integral_indicator hA,Measure.restrict_restrict hA,integral_const, |
| smul_eq_mul,mul_one,Measure.real_def,Measure.restrict_apply_univ] |
| rfl |
| rw [← heq F hF,← heq Fᶜ hF.compl] |
| exact ⟨ge_of_tendsto hint (hlow.mono (fun _ hi ↦ hi.1)), |
| ge_of_tendsto hintc (hlow.mono (fun _ hi ↦ hi.2))⟩ |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace BoundedContinuousFunction |
| namespace CubicTorus |
| |
| lemma localL1_weighted_integral_tendsto {η : Measure Cover} [IsFiniteMeasure η] |
| {l : Filter ℕ} (g : ℕ → Cover → ℝ) (hg : ∀ i, Measurable (g i)) |
| (hgb : ∀ i x, |g i x| ≤ 1) {f : Cover → ℝ} (hf : Measurable f) |
| (hfb : ∀ x, |f x| ≤ 1) |
| (hlim : Tendsto (fun i ↦ ∫ x, |g i x-f x| ∂η) l (𝓝 0)) |
| (k : Cover →ᵇ ℝ) : |
| Tendsto (fun i ↦ ∫ x, g i x*k x ∂η) l (𝓝 (∫ x, f x*k x ∂η)) := by |
| have hi (i) : Integrable (fun x ↦ g i x*k x) η := |
| Integrable.of_bound ((hg i).mul k.continuous.measurable).aestronglyMeasurable ‖k‖ |
| (ae_of_all _ (fun x ↦ by |
| simpa only [Real.norm_eq_abs,abs_mul,one_mul] using |
| mul_le_mul (hgb i x) (k.norm_coe_le_norm x) (norm_nonneg _) (by norm_num : (0 : ℝ) ≤ 1))) |
| have hfi : Integrable (fun x ↦ f x*k x) η := |
| Integrable.of_bound (hf.mul k.continuous.measurable).aestronglyMeasurable ‖k‖ |
| (ae_of_all _ (fun x ↦ by |
| simpa only [Real.norm_eq_abs,abs_mul,one_mul] using |
| mul_le_mul (hfb x) (k.norm_coe_le_norm x) (norm_nonneg _) (by norm_num : (0 : ℝ) ≤ 1))) |
| have hdiff (i) : Integrable (fun x ↦ |g i x-f x|) η := |
| ((integrable_bounded_one (hg i) (hgb i)).sub (integrable_bounded_one hf hfb)).abs |
| have hbound (i) : ‖(∫ x, g i x*k x ∂η)-(∫ x, f x*k x ∂η)‖ ≤ |
| ‖k‖ * ∫ x, |g i x-f x| ∂η := by |
| rw [← integral_sub (hi i) hfi,← integral_const_mul] |
| apply (norm_integral_le_integral_norm _).trans |
| apply integral_mono ((hi i).sub hfi).norm ((hdiff i).const_mul ‖k‖) |
| intro x |
| change ‖g i x*k x-f x*k x‖ ≤ ‖k‖*|g i x-f x| |
| rw [← sub_mul,Real.norm_eq_abs,abs_mul] |
| exact (mul_comm _ _).trans_le (mul_le_mul_of_nonneg_right (k.norm_coe_le_norm x) (abs_nonneg _)) |
| apply tendsto_iff_norm_sub_tendsto_zero.mpr |
| exact squeeze_zero (fun i ↦ norm_nonneg _) hbound (by simpa using hlim.const_mul ‖k‖) |
| |
| theorem blowup_limit_flux {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| (c : Cover) (r : ℕ → ℝ) (hr : ∀ i, 0 < r i) {R : ℝ} (hR : 1 < R) |
| (hc : ∀ i, Metric.closedBall c (r i) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1}) |
| {l : Filter ℕ} [NeBot l] {ν : FiniteMeasure BlowupNormalBundle} |
| (hν : Tendsto (fun i ↦ blowupNormalMeasure μ c (r i) R) l (𝓝 ν)) |
| {A : Set Cover} (hA : MeasurableSet A) |
| (hAconv : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |
| |blowupCharacteristic E c (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|) l (𝓝 0)) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) |
| (hs : tsupport F ⊆ Metric.closedBall (0 : Cover) 1) : |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x := by |
| have hFs : HasCompactSupport F := (isCompact_closedBall _ _).of_isClosed_subset isClosed_closure hs |
| have hd : HasCompactSupport (divergence F) := hFs.of_isClosed_subset isClosed_closure (divergence_tsupport_subset F) |
| let k : Cover →ᵇ ℝ := ofCompactSupport _ (continuous_divergence hF) hd |
| have hstri := localL1_weighted_integral_tendsto |
| (fun i ↦ blowupCharacteristic E c (r i)) |
| (fun i ↦ measurable_blowupCharacteristic hE c (r i)) |
| (fun i ↦ blowupCharacteristic_bound E c (r i)) |
| (measurable_const.indicator hA) |
| (fun x ↦ by by_cases hx : x ∈ A <;> simp [hx]) hAconv k |
| have hzero (x : Cover) (hx : x ∉ Metric.closedBall (0 : Cover) R) : divergence F x = 0 := |
| divergence_of_notMem_tsupport (fun hh ↦ hx (Metric.closedBall_subset_closedBall hR.le (hs hh))) |
| have heg (i) : (∫ x in Metric.closedBall (0 : Cover) R, blowupCharacteristic E c (r i) x*k x) = |
| ∫ x, blowupCharacteristic E c (r i) x*divergence F x := |
| setIntegral_eq_integral_of_forall_compl_eq_zero (fun x hx ↦ by change _*divergence F x = 0; rw [hzero x hx,mul_zero]) |
| have hef : (∫ x in Metric.closedBall (0 : Cover) R, A.indicator (fun _ ↦ (1 : ℝ)) x*k x) = |
| ∫ x in A, divergence F x := by |
| rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun x hx ↦ by change _*divergence F x = 0; rw [hzero x hx,mul_zero])] |
| change (∫ x, A.indicator (fun _ ↦ (1 : ℝ)) x*divergence F x) = _ |
| simp only [← indicator_mul_left,one_mul] |
| exact integral_indicator hA |
| simp_rw [heg] at hstri |
| rw [hef] at hstri |
| have hweak := (FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp hν) (blowupFluxTest hF.continuous hFs) |
| have he (i) : (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(blowupNormalMeasure μ c (r i) R : Measure BlowupNormalBundle)) = |
| ∫ x, blowupCharacteristic E c (r i) x*divergence F x := by |
| rw [integral_blowup_test μ c (hr i) (continuous_blowupFluxTest hF.continuous) |
| (fun z hz ↦ by |
| have hn : z.1 ∉ tsupport F := fun hh ↦ hz (Metric.closedBall_subset_ball hR (hs hh)) |
| simp [image_eq_zero_of_notMem_tsupport hn])] |
| change (r i)⁻¹^2*(∫ z, ⟪(z.2 : Cover),F ((r i)⁻¹ • ((z.1 : Cover)-c))⟫ ∂(μ : Measure NormalBundle)) = _ |
| rw [show (r i)⁻¹^2 = ((r i)^2)⁻¹ by ring] |
| rw [← div_eq_inv_mul,normalMeasure_scaled_flux hE hμ hF hs c (hr i) (hc i)] |
| simp only [blowupCharacteristic,add_comm c] |
| exact tendsto_nhds_unique (hweak.congr fun i ↦ he i) hstri |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| def coverLocalPerimeter (A O : Set Cover) : ℝ≥0∞ := |
| ⨆ (F : Cover → Cover) (_ : ContDiff ℝ (⊤ : ℕ∞) F) |
| (_ : HasCompactSupport F) (_ : tsupport F ⊆ O) (_ : ∀ x, ‖F x‖ ≤ 1), |
| ENNReal.ofReal (∫ x in A, divergence F x) |
| |
| lemma coverLocalPerimeter_mono (A : Set Cover) {O P : Set Cover} (hOP : O ⊆ P) : |
| coverLocalPerimeter A O ≤ coverLocalPerimeter A P := by |
| apply iSup_le |
| intro F |
| apply iSup_le |
| intro hF |
| apply iSup_le |
| intro hs |
| apply iSup_le |
| intro hO |
| apply iSup_le |
| intro hb |
| exact le_iSup_of_le F (le_iSup_of_le hF (le_iSup_of_le hs |
| (le_iSup_of_le (hO.trans hOP) (le_iSup_of_le hb le_rfl)))) |
| |
| lemma integral_divergence_le_coverLocalPerimeter {A O : Set Cover} {L : ℝ} |
| (hL : coverLocalPerimeter A O ≤ ENNReal.ofReal L) (hL0 : 0 ≤ L) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) |
| (hO : tsupport F ⊆ O) (hb : ∀ x, ‖F x‖ ≤ 1) : |
| (∫ x in A, divergence F x) ≤ L := by |
| apply (ENNReal.ofReal_le_ofReal_iff hL0).mp |
| have hh : ENNReal.ofReal (∫ x in A, divergence F x) ≤ coverLocalPerimeter A O := |
| le_iSup_of_le F (le_iSup_of_le hF (le_iSup_of_le hs |
| (le_iSup_of_le hO (le_iSup_of_le hb le_rfl)))) |
| exact hh.trans hL |
| |
| theorem coverLocalPerimeter_le_normal {A O : Set Cover} |
| {ν : FiniteMeasure BlowupNormalBundle} (hO : MeasurableSet O) |
| (hO1 : O ⊆ Metric.closedBall (0 : Cover) 1) |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → |
| tsupport F ⊆ Metric.closedBall (0 : Cover) 1 → |
| (∫ z, ⟪(z.2 : Cover), F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) : |
| coverLocalPerimeter A O ≤ (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O} := by |
| apply iSup_le |
| intro F |
| apply iSup_le |
| intro hF |
| apply iSup_le |
| intro hs |
| apply iSup_le |
| intro hFO |
| apply iSup_le |
| intro hb |
| have hm : MeasurableSet {z : BlowupNormalBundle | z.1 ∈ O} := hO.preimage measurable_fst |
| have hc : Continuous (fun z : BlowupNormalBundle ↦ ⟪(z.2 : Cover),F z.1⟫) := |
| (continuous_subtype_val.comp continuous_snd).inner (hF.continuous.comp continuous_fst) |
| have hbd (z : BlowupNormalBundle) : ‖⟪(z.2 : Cover),F z.1⟫‖ ≤ 1 := by |
| calc |
| _ ≤ ‖(z.2 : Cover)‖*‖F z.1‖ := norm_inner_le_norm _ _ |
| _ ≤ 1 := by rw [z.2.property,one_mul]; exact hb _ |
| have hi : Integrable (fun z : BlowupNormalBundle ↦ ⟪(z.2 : Cover),F z.1⟫) ν := |
| Integrable.of_bound hc.aestronglyMeasurable 1 (ae_of_all _ hbd) |
| have hri : Integrable ({z : BlowupNormalBundle | z.1 ∈ O}.indicator (fun _ ↦ (1 : ℝ))) ν := |
| (integrable_const 1).indicator hm |
| have he : (∫ x in A, divergence F x) ≤ (ν : Measure BlowupNormalBundle).real {z | z.1 ∈ O} := by |
| rw [← hflux F hF (hFO.trans hO1)] |
| have hh := integral_mono_ae hi hri (ae_of_all _ fun z ↦ ?_) |
| · simpa only [integral_indicator hm,integral_const,smul_eq_mul,mul_one, |
| measureReal_restrict_apply_univ] using hh |
| · by_cases hz : z.1 ∈ O |
| · simpa [Set.indicator,hz] using (le_abs_self _).trans (hbd z) |
| · have hzero : F z.1 = 0 := image_eq_zero_of_notMem_tsupport (fun hh ↦ hz (hFO hh)) |
| simp [Set.indicator,hz,hzero] |
| exact (ENNReal.ofReal_le_ofReal he).trans_eq (ENNReal.ofReal_toReal (measure_ne_top _ _)) |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
| |
| def coverPrismCoordinates : Cover ≃L[ℝ] PrismCoordinates := |
| (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin 3 ↦ ℝ)).trans |
| { toLinearEquiv := |
| { toFun := fun v ↦ (v 0,(v 1,v 2)) |
| invFun := fun z ↦ ![z.1,z.2.1,z.2.2] |
| left_inv := by intro v; ext i; fin_cases i <;> rfl |
| right_inv := by intro z; rfl |
| map_add' := by intros; rfl |
| map_smul' := by intros; rfl } |
| continuous_toFun := by fun_prop |
| continuous_invFun := by fun_prop } |
| |
| lemma coverPrismCoordinates_apply (x : Cover) : |
| coverPrismCoordinates x = (x 0,(x 1,x 2)) := rfl |
| |
| lemma coverPrismCoordinates_symm_apply (z : PrismCoordinates) : |
| coverPrismCoordinates.symm z = WithLp.toLp 2 ![z.1,z.2.1,z.2.2] := rfl |
| |
| lemma coverPrismCoordinates_measurePreserving : MeasurePreserving coverPrismCoordinates := by |
| have h1 : MeasurePreserving (WithLp.ofLp : Cover → Fin 3 → ℝ) := |
| PiLp.volume_preserving_ofLp (Fin 3) |
| have h2 := (volume_preserving_piFinSuccAbove (fun _ : Fin 3 ↦ ℝ) 0).comp h1 |
| have h3 : MeasurePreserving |
| (Prod.map (id : ℝ → ℝ) (MeasurableEquiv.finTwoArrow : (Fin 2 → ℝ) ≃ᵐ ℝ × ℝ)) |
| volume volume := by |
| simpa only [Measure.volume_eq_prod] using |
| (MeasurePreserving.id (volume : Measure ℝ)).prod (volume_preserving_finTwoArrow ℝ) |
| convert! h3.comp h2 using 1 |
| |
| lemma coverPrismCoordinates_symm_measurePreserving : |
| MeasurePreserving coverPrismCoordinates.symm := |
| coverPrismCoordinates_measurePreserving.symm coverPrismCoordinates.toHomeomorph.toMeasurableEquiv |
| |
| lemma prism_component_contDiff {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) (i : Fin 3) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun z : PrismCoordinates ↦ F (coverPrismCoordinates.symm z) i) := |
| (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff.comp (hF.comp coverPrismCoordinates.symm.contDiff) |
| |
| lemma prism_component_compactSupport {F : Cover → Cover} |
| (hF : HasCompactSupport F) (i : Fin 3) : |
| HasCompactSupport (fun z : PrismCoordinates ↦ F (coverPrismCoordinates.symm z) i) := by |
| have hh := hF.comp_isClosedEmbedding coverPrismCoordinates.symm.toHomeomorph.isClosedEmbedding |
| apply hh.of_isClosed_subset isClosed_closure |
| apply closure_mono |
| intro z hz |
| contrapose! hz |
| simp only [Function.mem_support,not_not] at hz ⊢ |
| change F (coverPrismCoordinates.symm z) = 0 at hz |
| rw [hz] |
| rfl |
| |
| lemma prism_component_fderiv {F : Cover → Cover} (hF : Differentiable ℝ F) |
| (i : Fin 3) (z v : PrismCoordinates) : |
| fderiv ℝ (fun w : PrismCoordinates ↦ F (coverPrismCoordinates.symm w) i) z v = |
| (fderiv ℝ F (coverPrismCoordinates.symm z) (coverPrismCoordinates.symm v)) i := by |
| exact (((EuclideanSpace.proj i).hasFDerivAt.comp _ |
| ((hF _).hasFDerivAt.comp z coverPrismCoordinates.symm.hasFDerivAt)).fderiv |> congrArg (fun L ↦ L v)) |
| |
| lemma prism_coordinate_divergence {F : Cover → Cover} (hF : Differentiable ℝ F) |
| (z : PrismCoordinates) : |
| prismCoordinateDivergence (fun w ↦ F (coverPrismCoordinates.symm w) 0) |
| (fun w ↦ F (coverPrismCoordinates.symm w) 1) |
| (fun w ↦ F (coverPrismCoordinates.symm w) 2) z = |
| divergence F (coverPrismCoordinates.symm z) := by |
| simp only [prismCoordinateDivergence,prism_component_fderiv hF,divergence, |
| Fin.sum_univ_three] |
| have he0 : coverPrismCoordinates.symm (1,(0,0)) = EuclideanSpace.single 0 1 := by |
| ext i; fin_cases i <;> simp [coverPrismCoordinates_symm_apply] |
| have he1 : coverPrismCoordinates.symm (0,(1,0)) = EuclideanSpace.single 1 1 := by |
| ext i; fin_cases i <;> simp [coverPrismCoordinates_symm_apply] |
| have he2 : coverPrismCoordinates.symm (0,(0,1)) = EuclideanSpace.single 2 1 := by |
| ext i; fin_cases i <;> simp [coverPrismCoordinates_symm_apply] |
| rw [he0,he1,he2] |
| |
| def euclideanPrism (a c b l u : ℝ) : Set Cover := |
| coverPrismCoordinates ⁻¹' coordinatePrism a c b l u |
| |
| lemma measurableSet_euclideanPrism (a c b l u : ℝ) : MeasurableSet (euclideanPrism a c b l u) := |
| (measurableSet_Ioc.prod (measurableSet_coordinateTriangle b l u)).preimage |
| coverPrismCoordinates.continuous.measurable |
| |
| theorem integral_euclideanPrism_divergence {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) |
| {a c b l u : ℝ} (hac : a ≤ c) (hb : 0 ≤ b) (hlu : l ≤ u) : |
| (∫ x in euclideanPrism a c b l u, divergence F x) = |
| prismRadialFlux (fun w ↦ F (coverPrismCoordinates.symm w) 1) |
| (fun w ↦ F (coverPrismCoordinates.symm w) 2) a c b l u + |
| prismClosingFlux (fun w ↦ F (coverPrismCoordinates.symm w) 0) |
| (fun w ↦ F (coverPrismCoordinates.symm w) 2) a c b l u := by |
| have hmeas : MeasurableSet (coordinatePrism a c b l u) := |
| measurableSet_Ioc.prod (measurableSet_coordinateTriangle b l u) |
| have hm := coverPrismCoordinates_symm_measurePreserving.restrict_preimage |
| (measurableSet_euclideanPrism a c b l u) |
| have he : coverPrismCoordinates.symm ⁻¹' euclideanPrism a c b l u = coordinatePrism a c b l u := by |
| ext x; simp [euclideanPrism] |
| rw [he] at hm |
| rw [← hm.integral_comp coverPrismCoordinates.symm.toHomeomorph.measurableEmbedding] |
| simp_rw [← prism_coordinate_divergence (hF.differentiable (by simp))] |
| exact integral_coordinatePrism_divergence_split |
| (prism_component_contDiff hF 0) (prism_component_contDiff hF 1) (prism_component_contDiff hF 2) |
| (prism_component_compactSupport hs 0) (prism_component_compactSupport hs 1) |
| (prism_component_compactSupport hs 2) hac hb hlu |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| end |
| |
| end OAI |
| |
