| import Mathlib |
| import OAI.Geometry.CubicTorus.Estimates.BVGraphEnergy |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter Metric |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def normalColumnHeight (U : Set Torus) (a : Torus) (n : Cover) (r : ℝ) (y : Plane) : ℝ := |
| (∫ t in Icc (-r / 4) (r / 4), |
| characteristic U (a + quotientMap (normalPlaneEmbedding n y + t • n))) - r / 4 |
|
|
| lemma measurable_normalColumnHeight {U : Set Torus} (hU : MeasurableSet U) |
| (a : Torus) (n : Cover) (r : ℝ) : Measurable (normalColumnHeight U a n r) := by |
| have hc : Continuous (fun p : Plane × ℝ ↦ |
| a + quotientMap (normalPlaneEmbedding n p.1 + p.2 • n)) := |
| continuous_const.add (continuous_quotientMap.comp |
| (((normalPlaneLinearIsometry n).continuous.comp continuous_fst).add |
| (continuous_snd.smul continuous_const))) |
| exact (((measurable_characteristic hU).comp hc.measurable).stronglyMeasurable.integral_prod_right').measurable.sub_const _ |
|
|
| lemma normalColumn_integrable {U : Set Torus} (hU : MeasurableSet U) |
| (a : Torus) (n : Cover) (r : ℝ) (y : Plane) : |
| IntegrableOn (fun t ↦ characteristic U |
| (a + quotientMap (normalPlaneEmbedding n y + t • n))) (Icc (-r / 4) (r / 4)) := by |
| apply (integrable_const (1 : ℝ)).mono' |
| · exact ((measurable_characteristic hU).comp |
| (continuous_const.add (continuous_quotientMap.comp |
| (continuous_const.add (continuous_id.smul continuous_const)))).measurable).aestronglyMeasurable |
| · exact ae_of_all _ fun t ↦ by simpa only [Real.norm_eq_abs] using characteristic_bound U _ |
|
|
| lemma normalColumnHeight_bound {U : Set Torus} (hU : MeasurableSet U) |
| (a : Torus) (n : Cover) {r : ℝ} (hr : 0 ≤ r) (y : Plane) : |
| |normalColumnHeight U a n r y| ≤ r / 4 := by |
| have hi := normalColumn_integrable hU a n r y |
| have hlo : 0 ≤ ∫ t in Icc (-r / 4) (r / 4), |
| characteristic U (a + quotientMap (normalPlaneEmbedding n y + t • n)) := |
| integral_nonneg (fun t ↦ characteristic_nonneg U _) |
| have hhi := integral_mono hi (integrable_const (1 : ℝ)) (fun t ↦ |
| (le_abs_self _).trans (characteristic_bound U _)) |
| rw [integral_const, smul_eq_mul, mul_one, measureReal_def, Measure.restrict_apply_univ, |
| Real.volume_Icc, ENNReal.toReal_ofReal (by linarith : 0 ≤ r / 4 - -r / 4)] at hhi |
| dsimp [normalColumnHeight] |
| exact abs_le.mpr ⟨by linarith, by linarith⟩ |
|
|
| lemma trapped_frontier_torus_height {U : Set Torus} (hU : IsOpen U) |
| {a c : Torus} {n : Cover} {r ε : ℝ} |
| (htrap : normalCap a n r (ε * r) ⊆ (closure U)ᶜ ∧ |
| normalCap a (-n) r (ε * r) ⊆ U) |
| (hc : c ∈ frontier U ∩ Metric.ball a r) : |
| |⟪n, shortestLift (c - a)⟫| ≤ ε * r := by |
| apply abs_le.mpr |
| constructor |
| · by_contra! hh |
| have hmem := htrap.2 (show c ∈ normalCap a (-n) r (ε * r) from |
| ⟨hc.2, by rw [inner_neg_left]; linarith⟩) |
| have hb := hc.1 |
| rw [frontier, hU.interior_eq] at hb |
| exact hb.2 hmem |
| · by_contra! hh |
| exact htrap.1 ⟨hc.2, hh⟩ (frontier_subset_closure hc.1) |
|
|
| theorem normalColumnHeight_eq_good_height {U : Set Torus} (hU : IsOpen U) |
| {a c : Torus} {n : Cover} (hn : ‖n‖ = 1) {r ε η : ℝ} |
| (hr : 0 < r) (hrsmall : r < 1 / 2) (hε : ε < 1 / 4) (hη : η ≤ 1 / 2) |
| (htrap : normalCap a n r (ε * r) ⊆ (closure U)ᶜ ∧ |
| normalCap a (-n) r (ε * r) ⊆ U) |
| (hc : c ∈ frontier U ∩ Metric.ball a (r / 2)) |
| (hcone : ∀ x ∈ frontier U, dist x c ≤ r → |
| |⟪n, shortestLift (x - c)⟫| ≤ η * dist x c) |
| (hy : normalPlaneCoordinates n (shortestLift (c - a)) ∈ Metric.ball (0 : Plane) (r / 4)) : |
| normalColumnHeight U a n r (normalPlaneCoordinates n (shortestLift (c - a))) = |
| ⟪n, shortestLift (c - a)⟫ := by |
| let y := normalPlaneCoordinates n (shortestLift (c - a)) |
| let q := ⟪n, shortestLift (c - a)⟫ |
| let f : ℝ → Torus := fun t ↦ a + quotientMap (normalPlaneEmbedding n y + t • n) |
| have hphase := trapped_good_column_phases hU hn hr hrsmall hε hη htrap hc hcone hy |
| have hq : |q| ≤ ε * r := trapped_frontier_torus_height hU htrap |
| ⟨hc.1, (Metric.ball_subset_ball (by linarith : r / 2 ≤ r)) hc.2⟩ |
| have hqlo : -r / 4 ≤ q := by |
| have hh := (abs_le.mp hq).1 |
| nlinarith [mul_lt_mul_of_pos_right hε hr] |
| have hqhi : q ≤ r / 4 := by |
| have hh := (abs_le.mp hq).2 |
| nlinarith [mul_lt_mul_of_pos_right hε hr] |
| have hfc : f q = c := by |
| dsimp [f, q, y] |
| rw [normalPlaneCoordinates_reconstruct hn, quotientMap_shortestLift, add_sub_cancel] |
| have heq : ∀ t ∈ Icc (-r / 4) (r / 4), |
| characteristic U (f t) = (Iio q).indicator (fun _ : ℝ ↦ (1 : ℝ)) t := by |
| intro t ht |
| by_cases htq : t < q |
| · have htU : f t ∈ U := hphase.1 t ht htq |
| simp [characteristic, htU, htq] |
| · have htU : f t ∉ U := by |
| rcases lt_or_eq_of_le (le_of_not_gt htq) with hlt | he |
| · exact fun hh ↦ hphase.2 t ht hlt (subset_closure hh) |
| · rw [← he, hfc] |
| have hb := hc.1 |
| rw [frontier, hU.interior_eq] at hb |
| exact hb.2 |
| simp [characteristic, htU, htq] |
| have hset : Icc (-r / 4) (r / 4) ∩ Iio q = Ico (-r / 4) q := by |
| ext t |
| simp only [mem_inter_iff, mem_Icc, mem_Iio, mem_Ico] |
| constructor |
| · exact fun h ↦ ⟨h.1.1, h.2⟩ |
| · exact fun h ↦ ⟨⟨h.1, h.2.le.trans hqhi⟩, h.2⟩ |
| change (∫ t in Icc (-r / 4) (r / 4), characteristic U (f t)) - r / 4 = q |
| rw [setIntegral_congr_fun measurableSet_Icc heq, setIntegral_indicator measurableSet_Iio, |
| hset, integral_const, smul_eq_mul, mul_one, measureReal_def, Measure.restrict_apply_univ, |
| Real.volume_Ico, ENNReal.toReal_ofReal (sub_nonneg.mpr hqlo)] |
| ring |
|
|
| theorem normalColumnHeight_disagreement_volume_le {U : Set Torus} (hU : IsOpen U) |
| (σ : FiniteMeasure Torus) {R c₀ : ℝ} (hR : 0 < R) (hc₀ : 0 < c₀) |
| (hl : ∀ x ∈ frontier U, ∀ ρ : ℝ, 0 < ρ → ρ ≤ R → |
| c₀ * ρ ^ 2 ≤ (σ : Measure Torus).real (Metric.ball x ρ)) |
| (a : Torus) {n : Cover} (hn : ‖n‖ = 1) {r ε η : ℝ} |
| (hr : 0 < r) (hrsmall : r < 1 / 2) (hε : ε < 1 / 4) (hη : η ≤ 1 / 2) |
| (htrap : normalCap a n r (ε * r) ⊆ (closure U)ᶜ ∧ |
| normalCap a (-n) r (ε * r) ⊆ U) |
| (S : Set Torus) (g : Plane → ℝ) |
| (hS : ∀ x ∈ S, g (normalPlaneCoordinates n (shortestLift (x - a))) = |
| ⟪n, shortestLift (x - a)⟫) |
| (hcone : ∀ c ∈ S, ∀ x ∈ frontier U, dist x c ≤ r → |
| |⟪n, shortestLift (x - c)⟫| ≤ η * dist x c) : |
| (volume : Measure Plane) {y ∈ Metric.ball (0 : Plane) (r / 4) | |
| normalColumnHeight U a n r y ≠ g y} ≤ |
| ((planeAreaFactor : ℝ≥0∞) * ENNReal.ofReal (64 / c₀)) * |
| (σ : Measure Torus) ((frontier U ∩ Metric.ball a (r / 2)) \ S) := by |
| let Q : Torus → Plane := fun x ↦ normalPlaneCoordinates n (shortestLift (x - a)) |
| have hcover : {y ∈ Metric.ball (0 : Plane) (r / 4) | |
| normalColumnHeight U a n r y ≠ g y} ⊆ |
| Q '' ((frontier U ∩ Metric.ball a (r / 2)) \ S) := by |
| intro y hy |
| obtain ⟨x, hx, hxy⟩ := trapped_boundary_projects_disk hU a hn hr hrsmall hε htrap hy.1 |
| have hxS : x ∉ S := by |
| intro hm |
| apply hy.2 |
| rw [← hxy, hS x hm] |
| exact normalColumnHeight_eq_good_height hU hn hr hrsmall hε hη htrap hx |
| (hcone x hm) (by simpa only [hxy] using hy.1) |
| exact ⟨x, ⟨hx, hxS⟩, hxy⟩ |
| apply (measure_mono hcover).trans |
| apply plane_projection_volume_le_perimeter σ (frontier U) hR hc₀ hl n a _ |
| (fun x hx ↦ hx.1.1) |
| intro x hx |
| exact (Metric.ball_subset_ball (by linarith : r / 2 ≤ 1 / 4)) hx.1.2 |
|
|
| theorem normalColumnHeight_graph_L1_le {U : Set Torus} (hU : IsOpen U) |
| (σ : FiniteMeasure Torus) {R c₀ : ℝ} (hR : 0 < R) (hc₀ : 0 < c₀) |
| (hl : ∀ x ∈ frontier U, ∀ ρ : ℝ, 0 < ρ → ρ ≤ R → |
| c₀ * ρ ^ 2 ≤ (σ : Measure Torus).real (Metric.ball x ρ)) |
| (a : Torus) {n : Cover} (hn : ‖n‖ = 1) {r ε η : ℝ} |
| (hr : 0 < r) (hrsmall : r < 1 / 2) (hε : ε < 1 / 4) (hη : η ≤ 1 / 2) |
| (htrap : normalCap a n r (ε * r) ⊆ (closure U)ᶜ ∧ |
| normalCap a (-n) r (ε * r) ⊆ U) |
| (S : Set Torus) (g : Plane → ℝ) (hg : Measurable g) |
| (hheight : ∀ y ∈ Metric.ball (0 : Plane) (r / 4), |g y| ≤ r / 4) |
| (hS : ∀ x ∈ S, g (normalPlaneCoordinates n (shortestLift (x - a))) = |
| ⟪n, shortestLift (x - a)⟫) |
| (hcone : ∀ c ∈ S, ∀ x ∈ frontier U, dist x c ≤ r → |
| |⟪n, shortestLift (x - c)⟫| ≤ η * dist x c) : |
| (∫⁻ y in Metric.ball (0 : Plane) (r / 4), |
| ENNReal.ofReal |normalColumnHeight U a n r y - g y| ∂(volume : Measure Plane)) ≤ |
| ENNReal.ofReal (r / 2) * |
| (((planeAreaFactor : ℝ≥0∞) * ENNReal.ofReal (64 / c₀)) * |
| (σ : Measure Torus) ((frontier U ∩ Metric.ball a (r / 2)) \ S)) := by |
| let D : Set Plane := {y ∈ Metric.ball (0 : Plane) (r / 4) | |
| normalColumnHeight U a n r y ≠ g y} |
| have hD : MeasurableSet D := measurableSet_ball.inter |
| (measurableSet_eq_fun (measurable_normalColumnHeight hU.measurableSet a n r) hg).compl |
| have hbound : ∀ y ∈ Metric.ball (0 : Plane) (r / 4), |
| ENNReal.ofReal |normalColumnHeight U a n r y - g y| ≤ |
| D.indicator (fun _ ↦ ENNReal.ofReal (r / 2)) y := by |
| intro y hy |
| by_cases he : normalColumnHeight U a n r y = g y |
| · simp [he] |
| · rw [Set.indicator_of_mem (show y ∈ D from ⟨hy, he⟩)] |
| apply ENNReal.ofReal_le_ofReal |
| have hh := abs_sub_le (normalColumnHeight U a n r y) 0 (g y) |
| simp only [sub_zero, zero_sub, abs_neg] at hh |
| linarith [normalColumnHeight_bound hU.measurableSet a n hr.le y, hheight y hy] |
| calc |
| _ ≤ ∫⁻ y in Metric.ball (0 : Plane) (r / 4), |
| D.indicator (fun _ ↦ ENNReal.ofReal (r / 2)) y := |
| setLIntegral_mono' measurableSet_ball hbound |
| _ = ENNReal.ofReal (r / 2) * (volume : Measure Plane) D := by |
| rw [lintegral_indicator hD, lintegral_const, Measure.restrict_restrict hD] |
| simp only [Measure.restrict_apply_univ, Set.inter_eq_left.mpr (show D ⊆ |
| Metric.ball (0 : Plane) (r / 4) from fun _ h ↦ h.1)] |
| _ ≤ _ := mul_le_mul_right (normalColumnHeight_disagreement_volume_le hU σ hR hc₀ hl |
| a hn hr hrsmall hε hη htrap S g hS hcone) _ |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| open Laplacian |
| namespace CubicTorus |
|
|
| def normalScalarTest (a n : Cover) (χ : ℝ → ℝ) (φ : Plane → ℝ) (x : Cover) : ℝ := |
| χ ⟪n, x - a⟫ * φ (normalPlaneCoordinates n (x - a)) |
|
|
| lemma normalScalarTest_contDiff (a n : Cover) {χ : ℝ → ℝ} {φ : Plane → ℝ} |
| (hχ : ContDiff ℝ (⊤ : ℕ∞) χ) (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) : |
| ContDiff ℝ (⊤ : ℕ∞) (normalScalarTest a n χ φ) := by |
| exact (hχ.comp (contDiff_const.inner ℝ (contDiff_id.sub contDiff_const))).mul |
| (hφ.comp ((normalPlaneCoordinates n).contDiff.comp (contDiff_id.sub contDiff_const))) |
|
|
| lemma normalRotation_single_succ (n : Cover) (i : Fin 2) : |
| normalRotation n (EuclideanSpace.single i.succ 1) = |
| normalPlaneEmbedding n (EuclideanSpace.single i 1) := by |
| rw [normalPlaneEmbedding, normalProductChart_apply] |
| congr 1 |
| ext j |
| refine Fin.cases ?_ (fun k ↦ ?_) j |
| · simp |
| · simp [Pi.single_apply] |
|
|
| lemma normalScalarTest_normal_line (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (χ : ℝ → ℝ) (φ : Plane → ℝ) (x : Cover) (t : ℝ) : |
| normalScalarTest a n χ φ (x + t • n) = |
| χ (⟪n, x - a⟫ + t) * φ (normalPlaneCoordinates n (x - a)) := by |
| have he : x + t • n - a = (x - a) + t • n := by abel |
| rw [normalScalarTest, he, inner_add_right, inner_smul_right, real_inner_self_eq_norm_sq, |
| hn, one_pow, mul_one, map_add, map_smul, normalPlaneCoordinates_normal hn, |
| smul_zero, add_zero] |
|
|
| lemma normalScalarTest_plane_line (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (χ : ℝ → ℝ) (φ : Plane → ℝ) (x : Cover) (u : Plane) (t : ℝ) : |
| normalScalarTest a n χ φ (x + t • normalPlaneEmbedding n u) = |
| χ ⟪n, x - a⟫ * φ (normalPlaneCoordinates n (x - a) + t • u) := by |
| have he : x + t • normalPlaneEmbedding n u - a = |
| (x - a) + t • normalPlaneEmbedding n u := by abel |
| rw [normalScalarTest, he, inner_add_right, inner_smul_right, |
| normalPlaneEmbedding_inner hn, mul_zero, add_zero, map_add, map_smul, |
| normalPlaneCoordinates_embedding] |
|
|
| theorem laplacian_normalScalarTest (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {χ : ℝ → ℝ} {φ : Plane → ℝ} |
| (hχ : ContDiff ℝ (⊤ : ℕ∞) χ) (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) (x : Cover) : |
| Δ (normalScalarTest a n χ φ) x = |
| iteratedDeriv 2 χ ⟪n, x - a⟫ * φ (normalPlaneCoordinates n (x - a)) + |
| χ ⟪n, x - a⟫ * Δ φ (normalPlaneCoordinates n (x - a)) := by |
| have htest := normalScalarTest_contDiff a n hχ hφ |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis _ |
| ((EuclideanSpace.basisFun (Fin 3) ℝ).map (normalRotation n))] |
| simp only [OrthonormalBasis.map_apply, EuclideanSpace.basisFun_apply] |
| rw [Fin.sum_univ_succ, normalRotation_axis hn] |
| have hv : iteratedFDeriv ℝ 2 (normalScalarTest a n χ φ) x ![n, n] = |
| iteratedDeriv 2 χ ⟪n, x - a⟫ * φ (normalPlaneCoordinates n (x - a)) := by |
| rw [iteratedFDeriv_two_line htest] |
| simp_rw [normalScalarTest_normal_line a hn] |
| rw [iteratedDeriv_mul_const_field, iteratedDeriv_comp_const_add] |
| simp |
| rw [hv] |
| congr 1 |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis φ |
| (EuclideanSpace.basisFun (Fin 2) ℝ), Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [normalRotation_single_succ, iteratedFDeriv_two_line htest] |
| simp_rw [normalScalarTest_plane_line a hn] |
| rw [iteratedDeriv_const_mul_field, EuclideanSpace.basisFun_apply, |
| iteratedFDeriv_two_line hφ] |
|
|
| lemma fderiv_normalScalarTest_normal (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {χ : ℝ → ℝ} {φ : Plane → ℝ} |
| (hχ : ContDiff ℝ (⊤ : ℕ∞) χ) (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) (x : Cover) : |
| fderiv ℝ (normalScalarTest a n χ φ) x n = |
| deriv χ ⟪n, x - a⟫ * φ (normalPlaneCoordinates n (x - a)) := by |
| have htest := normalScalarTest_contDiff a n hχ hφ |
| have hl : HasDerivAt (fun t : ℝ ↦ x + t • n) n 0 := by |
| simpa using ((hasDerivAt_id (0 : ℝ)).smul_const n).const_add x |
| have hh := (((htest.differentiable (by simp)) (x + (0 : ℝ) • n)).hasFDerivAt.comp_hasDerivAt 0 |
| (show HasDerivAt (fun t : ℝ ↦ x + t • n) n 0 from hl)) |
| have hh' : deriv (fun t : ℝ ↦ normalScalarTest a n χ φ (x + t • n)) 0 = |
| fderiv ℝ (normalScalarTest a n χ φ) x n := by |
| simpa [Function.comp_def] using hh.deriv |
| rw [← hh'] |
| have he := funext (normalScalarTest_normal_line a hn χ φ x) |
| rw [he, deriv_mul_const, deriv_comp_const_add] |
| · simp |
| · exact (hχ.comp (contDiff_const.add contDiff_id)).differentiable (by simp) |>.differentiableAt |
|
|
| lemma normalScalarTest_tsupport (a n : Cover) (χ : ℝ → ℝ) (φ : Plane → ℝ) : |
| tsupport (normalScalarTest a n χ φ) ⊆ |
| {x | ⟪n, x - a⟫ ∈ tsupport χ} ∩ |
| {x | normalPlaneCoordinates n (x - a) ∈ tsupport φ} := by |
| apply closure_minimal _ |
| ((isClosed_closure.preimage (continuous_const.inner (continuous_id.sub continuous_const))).inter |
| (isClosed_closure.preimage ((normalPlaneCoordinates n).continuous.comp |
| (continuous_id.sub continuous_const)))) |
| intro x hx |
| have hnz : χ ⟪n, x - a⟫ * φ (normalPlaneCoordinates n (x - a)) ≠ 0 := hx |
| exact ⟨subset_tsupport _ (left_ne_zero_of_mul hnz), |
| subset_tsupport _ (right_ne_zero_of_mul hnz)⟩ |
|
|
| lemma normalScalarTest_tsupport_ball (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {χ : ℝ → ℝ} {φ : Plane → ℝ} {r : ℝ} (hr : 0 < r) |
| (hχ : tsupport χ ⊆ Icc (-r / 3) (r / 3)) |
| (hφ : tsupport φ ⊆ Metric.closedBall (0 : Plane) (r / 3)) : |
| tsupport (normalScalarTest a n χ φ) ⊆ Metric.ball a r := by |
| intro x hx |
| have hh := normalScalarTest_tsupport a n χ φ hx |
| have hv : |⟪n, x - a⟫| ≤ r / 3 := by |
| have ht := hχ hh.1 |
| exact abs_le.mpr ⟨by linarith [ht.1], ht.2⟩ |
| have hp : ‖normalPlaneCoordinates n (x - a)‖ ≤ r / 3 := by |
| simpa using hφ hh.2 |
| have htri := norm_add_le (normalPlaneEmbedding n (normalPlaneCoordinates n (x - a))) |
| (⟪n, x - a⟫ • n) |
| rw [normalPlaneCoordinates_reconstruct hn, normalPlaneEmbedding_norm, norm_smul, |
| Real.norm_eq_abs, hn, mul_one] at htri |
| change dist x a < r |
| rw [dist_eq_norm] |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def normalColumnChart (a n : Cover) : (ℝ × Plane) ≃ᵐ Cover := |
| (((MeasurableEquiv.refl ℝ).prodCongr (MeasurableEquiv.toLp 2 (Fin 2 → ℝ)).symm).trans |
| (normalProductChart n)).trans (MeasurableEquiv.addLeft a) |
|
|
| lemma normalColumnChart_apply (a : Cover) {n : Cover} (hn : ‖n‖ = 1) (t : ℝ) (y : Plane) : |
| normalColumnChart a n (t, y) = a + (normalPlaneEmbedding n y + t • n) := by |
| change a + normalProductChart n (t, WithLp.ofLp y) = _ |
| rw [normalProductChart_decompose hn] |
| congr 1 |
| exact add_comm _ _ |
|
|
| lemma normalColumnChart_measurePreserving (a n : Cover) : |
| MeasurePreserving (normalColumnChart a n) := by |
| apply MeasurePreserving.trans _ (measurePreserving_add_left volume a) |
| apply MeasurePreserving.trans _ (normalProductChart_measurePreserving n) |
| change MeasurePreserving |
| (Prod.map id (MeasurableEquiv.toLp 2 (Fin 2 → ℝ)).symm) volume volume |
| simpa only [Measure.volume_eq_prod] using |
| (MeasurePreserving.id (volume : Measure ℝ)).prod |
| (EuclideanSpace.volume_preserving_symm_measurableEquiv_toLp (Fin 2)) |
|
|
| lemma integral_normalColumnChart (a n : Cover) {f : Cover → ℝ} (hf : Integrable f) : |
| (∫ x : Cover, f x) = ∫ y : Plane, ∫ t : ℝ, f (normalColumnChart a n (t, y)) := by |
| rw [← (normalColumnChart_measurePreserving a n).integral_comp' f] |
| have hi := (normalColumnChart_measurePreserving a n).integrable_comp |
| hf.aestronglyMeasurable |>.mpr hf |
| exact integral_prod_symm (f := fun z : ℝ × Plane ↦ f (normalColumnChart a n z)) |
| (by simpa only [Measure.volume_eq_prod, Function.comp_def] using hi) |
|
|
| lemma normalColumnChart_height (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (t : ℝ) (y : Plane) : ⟪n, normalColumnChart a n (t, y) - a⟫ = t := by |
| rw [normalColumnChart_apply a hn, add_sub_cancel_left, inner_add_right, |
| normalPlaneEmbedding_inner hn, inner_smul_right, real_inner_self_eq_norm_sq, |
| hn, one_pow, mul_one, zero_add] |
|
|
| lemma normalColumnChart_projection (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (t : ℝ) (y : Plane) : |
| normalPlaneCoordinates n (normalColumnChart a n (t, y) - a) = y := by |
| rw [normalColumnChart_apply a hn, add_sub_cancel_left, map_add, map_smul, |
| normalPlaneCoordinates_embedding, normalPlaneCoordinates_normal hn, smul_zero, add_zero] |
|
|
| lemma normalColumnChart_characteristic (U : Set Torus) (a : Cover) {n : Cover} |
| (hn : ‖n‖ = 1) (t : ℝ) (y : Plane) : |
| characteristic U (quotientMap (normalColumnChart a n (t, y))) = |
| characteristic U (quotientMap a + quotientMap (normalPlaneEmbedding n y + t • n)) := by |
| rw [normalColumnChart_apply a hn, quotientMap_add] |
|
|
| lemma normalColumnChart_ball (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {r t : ℝ} (hr : 0 < r) {y : Plane} (ht : |t| ≤ r / 2) |
| (hy : ‖y‖ ≤ r / 3) : normalColumnChart a n (t, y) ∈ Metric.ball a r := by |
| rw [Metric.mem_ball, dist_eq_norm, normalColumnChart_apply a hn, add_sub_cancel_left] |
| have hh := norm_add_le (normalPlaneEmbedding n y) (t • n) |
| rw [normalPlaneEmbedding_norm, norm_smul, Real.norm_eq_abs, hn, mul_one] at hh |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalColumnChart_line_isometry (a : Cover) {n : Cover} (hn : ‖n‖ = 1) (y : Plane) : |
| Isometry (fun t : ℝ ↦ normalColumnChart a n (t, y)) := by |
| apply Isometry.of_dist_eq |
| intro s t |
| rw [dist_eq_norm, normalColumnChart_apply a hn, normalColumnChart_apply a hn] |
| have he : a + (normalPlaneEmbedding n y + s • n) - |
| (a + (normalPlaneEmbedding n y + t • n)) = (s - t) • n := by rw [sub_smul]; abel |
| rw [he, norm_smul, Real.norm_eq_abs, hn, mul_one, Real.dist_eq] |
|
|
| lemma normalColumnChart_plane_isometry (a : Cover) {n : Cover} (hn : ‖n‖ = 1) (t : ℝ) : |
| Isometry (fun y : Plane ↦ normalColumnChart a n (t, y)) := by |
| apply Isometry.of_dist_eq |
| intro y z |
| rw [dist_eq_norm, normalColumnChart_apply a hn, normalColumnChart_apply a hn] |
| have he : a + (normalPlaneEmbedding n y + t • n) - |
| (a + (normalPlaneEmbedding n z + t • n)) = normalPlaneEmbedding n (y - z) := by |
| rw [show normalPlaneEmbedding n (y - z) = normalPlaneEmbedding n y - normalPlaneEmbedding n z from |
| (normalPlaneLinearIsometry n).map_sub y z]; abel |
| rw [he, normalPlaneEmbedding_norm, dist_eq_norm] |
|
|
| lemma halfspace_directional_integrable {ψ : Cover → ℝ} |
| (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hs : HasCompactSupport ψ) (a n v : Cover) : |
| Integrable (fun x ↦ halfspaceIndicator n (x - a) * fderiv ℝ ψ x v) := by |
| exact (((hψ.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport |
| (hs.fderiv_apply ℝ v)).bdd_mul |
| ((measurable_halfspaceIndicator n).comp (measurable_id.sub_const a)).aestronglyMeasurable |
| (Eventually.of_forall fun x ↦ by simpa only [Real.norm_eq_abs] using halfspaceIndicator_bound n (x-a)) |
|
|
| lemma integral_halfspace_normal_derivative (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {ψ : Cover → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hs : HasCompactSupport ψ) : |
| (∫ x : Cover, halfspaceIndicator n (x-a) * fderiv ℝ ψ x n) = |
| ∫ y : Plane, ψ (a + normalPlaneEmbedding n y) := by |
| rw [integral_normalColumnChart a n (halfspace_directional_integrable hψ hs a n n)] |
| apply integral_congr_ae |
| filter_upwards [] with y |
| let f : ℝ → ℝ := fun t ↦ ψ (normalColumnChart a n (t,y)) |
| have hc : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ normalColumnChart a n (t,y)) := by |
| simp_rw [normalColumnChart_apply a hn] |
| fun_prop |
| have hf : ContDiff ℝ (⊤ : ℕ∞) f := hψ.comp hc |
| have hfs : HasCompactSupport f := hs.comp_isClosedEmbedding |
| (normalColumnChart_line_isometry a hn y).isClosedEmbedding |
| have hd (t : ℝ) : deriv f t = fderiv ℝ ψ (normalColumnChart a n (t,y)) n := by |
| have hh : HasDerivAt (fun s : ℝ ↦ normalColumnChart a n (s,y)) n t := by |
| simp_rw [normalColumnChart_apply a hn] |
| simpa only [one_smul, add_zero, zero_add, id_eq, add_assoc] using |
| ((hasDerivAt_id t).smul_const n).const_add (a + normalPlaneEmbedding n y) |
| exact (((hψ.differentiable (by simp)) _).hasFDerivAt.comp_hasDerivAt t hh).deriv |
| have he (t : ℝ) : halfspaceIndicator n (normalColumnChart a n (t,y)-a) * |
| fderiv ℝ ψ (normalColumnChart a n (t,y)) n = (Iio (0 : ℝ)).indicator (deriv f) t := by |
| by_cases ht : t < 0 <;> simp [halfspaceIndicator, normalColumnChart_height a hn, ht, hd] |
| simp_rw [he] |
| rw [integral_indicator measurableSet_Iio, ← integral_Iic_eq_integral_Iio, |
| hfs.integral_Iic_deriv_eq (hf.of_le (by simp)) 0] |
| simp [f, normalColumnChart_apply a hn] |
|
|
| lemma integral_halfspace_tangent_derivative (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {ψ : Cover → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hs : HasCompactSupport ψ) (v : Plane) : |
| (∫ x : Cover, halfspaceIndicator n (x-a) * fderiv ℝ ψ x (normalPlaneEmbedding n v)) = 0 := by |
| let f : Cover → ℝ := fun x ↦ halfspaceIndicator n (x-a) * fderiv ℝ ψ x (normalPlaneEmbedding n v) |
| have hi := halfspace_directional_integrable hψ hs a n (normalPlaneEmbedding n v) |
| rw [← (normalColumnChart_measurePreserving a n).integral_comp' f, Measure.volume_eq_prod] |
| have hic := (normalColumnChart_measurePreserving a n).integrable_comp hi.aestronglyMeasurable |>.mpr hi |
| rw [integral_prod (f := fun z : ℝ × Plane ↦ f (normalColumnChart a n z)) (by |
| simpa only [Measure.volume_eq_prod, Function.comp_def] using hic)] |
| have he (t : ℝ) : (∫ y : Plane, f (normalColumnChart a n (t,y))) = 0 := by |
| let g : Plane → ℝ := fun y ↦ ψ (normalColumnChart a n (t,y)) |
| have hc : ContDiff ℝ (⊤ : ℕ∞) (fun y : Plane ↦ normalColumnChart a n (t,y)) := by |
| simp_rw [normalColumnChart_apply a hn] |
| exact contDiff_const.add ((normalPlaneLinearIsometry n).contDiff.add contDiff_const) |
| have hg : ContDiff ℝ (⊤ : ℕ∞) g := hψ.comp hc |
| have hs' : HasCompactSupport g := hs.comp_isClosedEmbedding |
| (normalColumnChart_plane_isometry a hn t).isClosedEmbedding |
| have hd (y : Plane) : fderiv ℝ g y v = |
| fderiv ℝ ψ (normalColumnChart a n (t,y)) (normalPlaneEmbedding n v) := by |
| have hline := ((normalPlaneLinearIsometry n).toContinuousLinearMap.hasFDerivAt (x := y)).add_const (t • n) |>.const_add a |
| have hh := ((hψ.differentiable (by simp) _).hasFDerivAt.comp y hline).fderiv |
| have he : g = ψ ∘ (fun z : Plane ↦ a + ((normalPlaneLinearIsometry n).toContinuousLinearMap z + t • n)) := by |
| funext z |
| simp only [g, Function.comp_def, normalColumnChart_apply a hn] |
| rfl |
| rw [he, hh, normalColumnChart_apply a hn] |
| rfl |
| have hh : (fun y : Plane ↦ f (normalColumnChart a n (t,y))) = |
| fun y ↦ (if t < 0 then (1 : ℝ) else 0) * fderiv ℝ g y v := by |
| ext y |
| by_cases ht : t < 0 <;> simp [f, halfspaceIndicator, normalColumnChart_height a hn, ht, hd] |
| rw [hh, integral_const_mul, integral_compact_fderiv_zero hg hs', mul_zero] |
| simp_rw [he] |
| simp |
|
|
| lemma integral_halfspace_directional_derivative (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {ψ : Cover → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hs : HasCompactSupport ψ) (v : Cover) : |
| (∫ x : Cover, halfspaceIndicator n (x-a) * fderiv ℝ ψ x v) = |
| ⟪n,v⟫ * ∫ y : Plane, ψ (a + normalPlaneEmbedding n y) := by |
| have he (x : Cover) : halfspaceIndicator n (x-a) * fderiv ℝ ψ x v = |
| halfspaceIndicator n (x-a) * fderiv ℝ ψ x |
| (normalPlaneEmbedding n (normalPlaneCoordinates n v)) + |
| ⟪n,v⟫ * (halfspaceIndicator n (x-a) * fderiv ℝ ψ x n) := by |
| conv_lhs => arg 2; arg 2; rw [← normalPlaneCoordinates_reconstruct hn v] |
| rw [map_add, map_smul] |
| ring |
| simp_rw [he] |
| rw [integral_add (halfspace_directional_integrable hψ hs a n _) |
| ((halfspace_directional_integrable hψ hs a n n).const_mul ⟪n,v⟫), |
| integral_const_mul, integral_halfspace_tangent_derivative a hn hψ hs, |
| integral_halfspace_normal_derivative a hn hψ hs, zero_add] |
|
|
| theorem integral_halfspace_divergence (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) : |
| (∫ x : Cover, halfspaceIndicator n (x-a) * divergence F x) = |
| ∫ y : Plane, ⟪n, F (a + normalPlaneEmbedding n y)⟫ := by |
| let ψ : Fin 3 → Cover → ℝ := fun i x ↦ F x i |
| have hp (i : Fin 3) : ContDiff ℝ (⊤ : ℕ∞) (ψ i) := |
| (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff.comp hF |
| have hps (i : Fin 3) : HasCompactSupport (ψ i) := hs.comp_left |
| (show (EuclideanSpace.proj i) (0 : Cover) = 0 by simp) |
| have hd (x : Cover) : divergence F x = ∑ i : Fin 3, |
| fderiv ℝ (ψ i) x (EuclideanSpace.single i 1) := by |
| unfold divergence |
| apply Finset.sum_congr rfl |
| intro i _ |
| have hh := (((EuclideanSpace.proj i).hasFDerivAt).comp x |
| ((hF.differentiable (by simp)) x).hasFDerivAt).fderiv |
| change fderiv ℝ (ψ i) x = _ at hh |
| rw [hh] |
| rfl |
| simp_rw [hd, Finset.mul_sum] |
| rw [integral_finsetSum _ (fun i _ ↦ halfspace_directional_integrable (hp i) (hps i) a n _)] |
| simp_rw [integral_halfspace_directional_derivative a hn (hp _) (hps _)] |
| have hg (i : Fin 3) : Integrable (fun y : Plane ↦ ⟪n, EuclideanSpace.single i 1⟫ * |
| ψ i (a + normalPlaneEmbedding n y)) := by |
| have hc := (hp i).continuous.comp (normalColumnChart_plane_isometry a hn 0).continuous |
| have hcc := (hps i).comp_isClosedEmbedding (normalColumnChart_plane_isometry a hn 0).isClosedEmbedding |
| have hi := (hc.integrable_of_hasCompactSupport (μ := volume) hcc).const_mul ⟪n, EuclideanSpace.single i 1⟫ |
| simpa only [Function.comp_def, normalColumnChart_apply a hn, zero_smul, add_zero] using hi |
| simp_rw [← integral_const_mul] |
| rw [← integral_finsetSum _ (fun i _ ↦ hg i)] |
| apply integral_congr_ae |
| filter_upwards [] with y |
| simp only [EuclideanSpace.inner_single_right, ψ] |
| simp [PiLp.inner_apply, mul_comm] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def normalMove (n : Cover) (f : Cover → ℝ) (x : Cover) : Cover := x + f x • n |
|
|
| def normalJacobian (n : Cover) (f : Cover → ℝ) (x : Cover) : ℝ := |
| 1 + fderiv ℝ f x n |
|
|
| def normalPullback (n : Cover) (f : Cover → ℝ) (F : Cover → Cover) (x : Cover) : Cover := |
| normalJacobian n f x • F (normalMove n f x) - |
| fderiv ℝ f x (F (normalMove n f x)) • n |
|
|
| lemma normalMove_hasFDerivAt (n : Cover) {f : Cover → ℝ} {x : Cover} |
| (hf : DifferentiableAt ℝ f x) : |
| HasFDerivAt (normalMove n f) |
| (ContinuousLinearMap.id ℝ Cover + (fderiv ℝ f x).smulRight n) x := by |
| exact (hasFDerivAt_id x).add (hf.hasFDerivAt.smul_const n) |
|
|
| lemma normalMove_contDiff (n : Cover) {f : Cover → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) : |
| ContDiff ℝ (⊤ : ℕ∞) (normalMove n f) := contDiff_id.add (hf.smul_const n) |
|
|
| lemma normalPullback_contDiff (n : Cover) {f : Cover → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) : |
| ContDiff ℝ (⊤ : ℕ∞) (normalPullback n f F) := by |
| have hd := hf.fderiv_right (m := (⊤ : ℕ∞)) (by simp) |
| have hG := hF.comp (normalMove_contDiff n hf) |
| exact (contDiff_const.add (hd.clm_apply contDiff_const)).smul hG |>.sub |
| ((hd.clm_apply hG).smul contDiff_const) |
|
|
| lemma divergence_comp_normalMove (n : Cover) {f : Cover → ℝ} {x : Cover} |
| (hf : DifferentiableAt ℝ f x) {F : Cover → Cover} |
| (hF : DifferentiableAt ℝ F (normalMove n f x)) : |
| divergence (fun y ↦ F (normalMove n f y)) x = |
| divergence F (normalMove n f x) + |
| fderiv ℝ f x (fderiv ℝ F (normalMove n f x) n) := by |
| have hd := (hF.hasFDerivAt.comp x (normalMove_hasFDerivAt n hf)).fderiv |
| change fderiv ℝ (fun y ↦ F (normalMove n f y)) x = _ at hd |
| simp only [divergence, hd, ContinuousLinearMap.comp_apply, add_apply, |
| ContinuousLinearMap.id_apply, ContinuousLinearMap.smulRight_apply, |
| map_add, map_smul, PiLp.add_apply, PiLp.smul_apply, smul_eq_mul, |
| Finset.sum_add_distrib] |
| congr 1 |
| rw [linearForm_apply_basis] |
| apply Finset.sum_congr rfl |
| intro i _ |
| ring |
|
|
| theorem normalPullback_divergence (n : Cover) {f : Cover → ℝ} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) (x : Cover) : |
| divergence (normalPullback n f F) x = |
| normalJacobian n f x * divergence F (normalMove n f x) := by |
| have hfd := (hf.differentiable (by simp)).differentiableAt (x := x) |
| have hdf := ((hf.fderiv_right (m := (⊤ : ℕ∞)) (by simp)).differentiable |
| (by simp)).differentiableAt (x := x) |
| have hm := normalMove_hasFDerivAt n hfd |
| have hg := (hF.differentiable (by simp)).differentiableAt (x := normalMove n f x) |
| have hu := hg.hasFDerivAt.comp x hm |
| have hj := (hdf.hasFDerivAt.clm_apply (hasFDerivAt_const n x)).const_add 1 |
| have hb := hdf.hasFDerivAt.clm_apply hu |
| have he := ((hf.contDiffAt (x := x)).isSymmSndFDerivAt (by |
| simp only [minSmoothness_of_isRCLikeNormedField] |
| change ((2 : ℕ∞) : WithTop ℕ∞) ≤ ((⊤ : ℕ∞) : WithTop ℕ∞) |
| exact WithTop.coe_le_coe.mpr le_top)) n (F (normalMove n f x)) |
| change divergence (fun y ↦ normalJacobian n f y • F (normalMove n f y) - |
| fderiv ℝ f y (F (normalMove n f y)) • n) x = _ |
| have hjf := hj.fderiv |
| change fderiv ℝ (normalJacobian n f) x = _ at hjf |
| dsimp only [Function.comp_def] at hb |
| have hJ : DifferentiableAt ℝ (normalJacobian n f) x := hj.differentiableAt |
| have hU : DifferentiableAt ℝ (fun y ↦ F (normalMove n f y)) x := hu.differentiableAt |
| have hB : DifferentiableAt ℝ (fun y ↦ fderiv ℝ f y (F (normalMove n f y))) x := hb.differentiableAt |
| have hA : DifferentiableAt ℝ |
| (fun y ↦ normalJacobian n f y • F (normalMove n f y)) x := hJ.smul hU |
| have hC : DifferentiableAt ℝ |
| (fun y ↦ fderiv ℝ f y (F (normalMove n f y)) • n) x := hB.smul_const n |
| rw [divergence_sub_fields hA hC, |
| divergence_smul_function hJ hU, divergence_smul_const hB, inner_gradient_left, |
| hjf, hb.fderiv, divergence_comp_normalMove n hfd hg] |
| simp only [add_apply, ContinuousLinearMap.comp_apply, zero_apply, |
| ContinuousLinearMap.flip_apply, zero_add, |
| ContinuousLinearMap.id_apply, ContinuousLinearMap.smulRight_apply, |
| map_add, map_smul, map_zero, smul_eq_mul] |
| dsimp only [normalJacobian, Function.comp_def] |
| rw [← he] |
| ring |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def graphHeightExtension (a n : Cover) (g : Plane → ℝ) (x : Cover) : ℝ := |
| g (normalPlaneCoordinates n (x-a)) |
|
|
| def graphShear (a n : Cover) (g : Plane → ℝ) : Cover → Cover := |
| normalMove n (graphHeightExtension a n g) |
|
|
| lemma graphShear_projection (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (g : Plane → ℝ) (x : Cover) : |
| normalPlaneCoordinates n (graphShear a n g x - a) = normalPlaneCoordinates n (x-a) := by |
| rw [graphShear, normalMove, add_sub_right_comm, map_add, map_smul, |
| normalPlaneCoordinates_normal hn, smul_zero, add_zero] |
|
|
| lemma graphShear_inverse (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (g : Plane → ℝ) : Function.LeftInverse (graphShear a n (-g)) (graphShear a n g) := by |
| intro x |
| change graphShear a n g x + (-g) (normalPlaneCoordinates n (graphShear a n g x-a)) • n = x |
| rw [graphShear_projection a hn] |
| simp only [Pi.neg_apply, neg_smul, graphShear, normalMove, graphHeightExtension] |
| abel |
|
|
| lemma graphShear_continuous (a n : Cover) {g : Plane → ℝ} (hg : Continuous g) : |
| Continuous (graphShear a n g) := by |
| unfold graphShear normalMove graphHeightExtension |
| exact continuous_id.add ((hg.comp ((normalPlaneCoordinates n).continuous.comp |
| (continuous_id.sub continuous_const))).smul continuous_const) |
|
|
| def graphShearHomeomorph (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Continuous g) : Cover ≃ₜ Cover where |
| toFun := graphShear a n g |
| invFun := graphShear a n (-g) |
| left_inv := graphShear_inverse a hn g |
| right_inv := by |
| intro x |
| simpa only [neg_neg] using graphShear_inverse a hn (-g) x |
| continuous_toFun := graphShear_continuous a n hg |
| continuous_invFun := graphShear_continuous a n hg.neg |
|
|
| lemma graphShear_columnChart (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (g : Plane → ℝ) (t : ℝ) (y : Plane) : |
| graphShear a n g (normalColumnChart a n (t,y)) = normalColumnChart a n (t+g y,y) := by |
| change normalColumnChart a n (t,y) + |
| g (normalPlaneCoordinates n (normalColumnChart a n (t,y)-a)) • n = _ |
| rw [normalColumnChart_projection a hn, normalColumnChart_apply a hn, |
| normalColumnChart_apply a hn, add_smul] |
| abel |
|
|
| lemma columnShear_measurePreserving {g : Plane → ℝ} (hg : Measurable g) : |
| MeasurePreserving (fun p : ℝ × Plane ↦ (p.1+g p.2, p.2)) := by |
| have hs : MeasurePreserving (fun p : Plane × ℝ ↦ (p.1, p.2+g p.1)) |
| ((volume : Measure Plane).prod volume) ((volume : Measure Plane).prod volume) := |
| (MeasurePreserving.id (volume : Measure Plane)).skew_product |
| (measurable_snd.add (hg.comp measurable_fst)) |
| (Eventually.of_forall fun y ↦ (measurePreserving_add_right volume (g y)).map_eq) |
| have hh := (Measure.measurePreserving_swap (μ := (volume : Measure Plane)) |
| (ν := (volume : Measure ℝ))).comp (hs.comp (Measure.measurePreserving_swap |
| (μ := (volume : Measure ℝ)) (ν := (volume : Measure Plane)))) |
| simpa only [Function.comp_def, Prod.swap, Measure.volume_eq_prod] using hh |
|
|
| lemma graphShear_measurePreserving (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Measurable g) : MeasurePreserving (graphShear a n g) := by |
| have hi : MeasurePreserving (normalColumnChart a n).symm := |
| MeasurePreserving.symm (normalColumnChart a n) (normalColumnChart_measurePreserving a n) |
| have hh := (normalColumnChart_measurePreserving a n).comp |
| ((columnShear_measurePreserving hg).comp hi) |
| convert hh using 1 |
| funext x |
| obtain ⟨⟨t,y⟩,rfl⟩ := (normalColumnChart a n).surjective x |
| simp only [Function.comp_def, MeasurableEquiv.symm_apply_apply] |
| exact graphShear_columnChart a hn g t y |
|
|
| lemma graphHeightExtension_contDiff (a n : Cover) {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) : ContDiff ℝ (⊤ : ℕ∞) (graphHeightExtension a n g) := |
| hg.comp ((normalPlaneCoordinates n).contDiff.comp (contDiff_id.sub contDiff_const)) |
|
|
| lemma graphHeightExtension_fderiv (a n : Cover) {g : Plane → ℝ} (hg : Differentiable ℝ g) |
| (x : Cover) : fderiv ℝ (graphHeightExtension a n g) x = |
| (fderiv ℝ g (normalPlaneCoordinates n (x-a))).comp (normalPlaneCoordinates n) := by |
| unfold graphHeightExtension |
| have hp := (normalPlaneCoordinates n).hasFDerivAt.comp x ((hasFDerivAt_id x).sub_const a) |
| simpa only [ContinuousLinearMap.comp_id, Function.comp_def, id_eq, graphHeightExtension] using |
| ((hg _).hasFDerivAt.comp x hp).fderiv |
|
|
| lemma graphHeightExtension_normal (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Differentiable ℝ g) (x : Cover) : |
| fderiv ℝ (graphHeightExtension a n g) x n = 0 := by |
| rw [graphHeightExtension_fderiv a n hg, ContinuousLinearMap.comp_apply, |
| normalPlaneCoordinates_normal hn, map_zero] |
|
|
| lemma graphShear_jacobian (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Differentiable ℝ g) (x : Cover) : |
| normalJacobian n (graphHeightExtension a n g) x = 1 := by |
| rw [normalJacobian, graphHeightExtension_normal a hn hg, add_zero] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def graphSublevelIndicator (a n : Cover) (g : Plane → ℝ) (x : Cover) : ℝ := |
| {z : Cover | ⟪n,z-a⟫ < graphHeightExtension a n g z}.indicator (fun _ ↦ 1) x |
|
|
| def graphAreaVector (n : Cover) (g : Plane → ℝ) (y : Plane) : Cover := |
| n - normalPlaneEmbedding n (gradient g y) |
|
|
| lemma graphSublevelIndicator_shear (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| (g : Plane → ℝ) (x : Cover) : |
| graphSublevelIndicator a n g (graphShear a n g x) = halfspaceIndicator n (x-a) := by |
| have hheight : ⟪n, graphShear a n g x - a⟫ = ⟪n,x-a⟫ + graphHeightExtension a n g x := by |
| simp only [graphShear, normalMove, add_sub_right_comm, inner_add_right, |
| inner_smul_right, real_inner_self_eq_norm_sq, hn, one_pow, mul_one] |
| have hp : graphHeightExtension a n g (graphShear a n g x) = graphHeightExtension a n g x := |
| congrArg g (graphShear_projection a hn g x) |
| simp only [graphSublevelIndicator, Set.indicator, Set.mem_ofPred_eq, hheight, hp, |
| add_lt_iff_neg_right, halfspaceIndicator] |
|
|
| lemma normalPullback_graph_compactSupport (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Continuous g) {F : Cover → Cover} (hs : HasCompactSupport F) : |
| HasCompactSupport (normalPullback n (graphHeightExtension a n g) F) := by |
| have hc := hs.comp_homeomorph (graphShearHomeomorph a hn hg) |
| apply hc.mono |
| intro x hx |
| contrapose! hx |
| simp only [Function.mem_support, not_not] at hx |
| dsimp only [Function.comp_def, graphShearHomeomorph] at hx |
| have hh : F (graphShear a n g x) = 0 := hx |
| simp only [Function.mem_support, not_not] |
| change normalPullback n (graphHeightExtension a n g) F x = 0 |
| change F (normalMove n (graphHeightExtension a n g) x) = 0 at hh |
| simp only [normalPullback, hh, smul_zero, map_zero, zero_smul, sub_self] |
|
|
| lemma graphAreaVector_pullback (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : Differentiable ℝ g) (F : Cover → Cover) (y : Plane) : |
| ⟪n, normalPullback n (graphHeightExtension a n g) F (a+normalPlaneEmbedding n y)⟫ = |
| ⟪graphAreaVector n g y, F (a+normalGraph n g y)⟫ := by |
| have hs : graphShear a n g (a+normalPlaneEmbedding n y) = a+normalGraph n g y := by |
| simp only [graphShear, normalMove, graphHeightExtension, add_sub_cancel_left, |
| normalPlaneCoordinates_embedding, normalGraph] |
| abel |
| rw [normalPullback, graphShear_jacobian a hn hg, one_smul, ← graphShear, hs, |
| inner_sub_right, inner_smul_right, real_inner_self_eq_norm_sq, hn, one_pow, |
| mul_one, graphHeightExtension_fderiv a n hg, ContinuousLinearMap.comp_apply, |
| add_sub_cancel_left, normalPlaneCoordinates_embedding] |
| rw [graphAreaVector, inner_sub_left] |
| congr 1 |
| rw [show normalPlaneEmbedding n (gradient g y) = |
| (normalPlaneLinearIsometry n).toContinuousLinearMap (gradient g y) from rfl, |
| ← ContinuousLinearMap.adjoint_inner_right, inner_gradient_left] |
| rfl |
|
|
| lemma graphSublevel_flux_integrable (a n : Cover) {g : Plane → ℝ} (hg : Continuous g) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) : |
| Integrable (fun x : Cover ↦ graphSublevelIndicator a n g x * divergence F x) := by |
| have hm : MeasurableSet {z : Cover | ⟪n,z-a⟫ < graphHeightExtension a n g z} := |
| isOpen_lt (by fun_prop) (hg.comp ((normalPlaneCoordinates n).continuous.comp |
| (continuous_id.sub continuous_const))) |>.measurableSet |
| have hc : HasCompactSupport (divergence F) := |
| hs.of_isClosed_subset isClosed_closure (divergence_tsupport_subset F) |
| have hi := (continuous_divergence hF).integrable_of_hasCompactSupport (μ := volume) hc |
| apply (hi.indicator hm).congr |
| filter_upwards [] with x |
| by_cases hx : ⟪n,x-a⟫ < graphHeightExtension a n g x <;> simp [graphSublevelIndicator, hx] |
|
|
| theorem integral_graphSublevel_divergence (a : Cover) {n : Cover} (hn : ‖n‖ = 1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) : |
| (∫ x : Cover, graphSublevelIndicator a n g x * divergence F x) = |
| ∫ y : Plane, ⟪graphAreaVector n g y, F (a+normalGraph n g y)⟫ := by |
| have hmp : MeasurePreserving (graphShearHomeomorph a hn hg.continuous).toMeasurableEquiv := |
| graphShear_measurePreserving a hn hg.continuous.measurable |
| rw [← hmp.integral_comp' (fun x : Cover ↦ graphSublevelIndicator a n g x * divergence F x)] |
| have he (x : Cover) : graphSublevelIndicator a n g (graphShearHomeomorph a hn hg.continuous x) * |
| divergence F (graphShearHomeomorph a hn hg.continuous x) = |
| halfspaceIndicator n (x-a) * divergence (normalPullback n (graphHeightExtension a n g) F) x := by |
| change graphSublevelIndicator a n g (graphShear a n g x) * divergence F (graphShear a n g x) = _ |
| rw [graphSublevelIndicator_shear a hn, normalPullback_divergence n |
| (graphHeightExtension_contDiff a n hg) hF, |
| graphShear_jacobian a hn (hg.differentiable (by simp)), one_mul] |
| rfl |
| change (∫ x : Cover, graphSublevelIndicator a n g (graphShearHomeomorph a hn hg.continuous x) * |
| divergence F (graphShearHomeomorph a hn hg.continuous x)) = _ |
| simp_rw [he] |
| rw [integral_halfspace_divergence a hn |
| (normalPullback_contDiff n (graphHeightExtension_contDiff a n hg) hF) |
| (normalPullback_graph_compactSupport a hn hg.continuous hs)] |
| apply integral_congr_ae |
| exact Eventually.of_forall (graphAreaVector_pullback a hn (hg.differentiable (by simp)) F) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
