| import Mathlib |
| import OAI.Geometry.CubicTorus.Regularity.BVPlaneAreaCoordinates |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma prismRadialFlux_eq_sub {X Y : PrismCoordinates → ℝ} |
| (hX : Continuous X) (hY : Continuous Y) (a c b l u : ℝ) : |
| prismRadialFlux X Y a c b l u = |
| (∫ t in a..c, ∫ s in (0 : ℝ)..b, X (t,(s*u,s))-u*Y (t,(s*u,s))) - |
| (∫ t in a..c, ∫ s in (0 : ℝ)..b, X (t,(s*l,s))-l*Y (t,(s*l,s))) := by |
| have hc (k : ℝ) : Continuous (fun t : ℝ ↦ ∫ s in (0 : ℝ)..b, |
| X (t,(s*k,s))-k*Y (t,(s*k,s))) := |
| intervalIntegral.continuous_parametric_intervalIntegral_of_continuous' (by fun_prop) _ _ |
| have he (t : ℝ) : (∫ s in (0 : ℝ)..b, |
| (X (t,(s*u,s))-u*Y (t,(s*u,s)))-(X (t,(s*l,s))-l*Y (t,(s*l,s)))) = |
| (∫ s in (0 : ℝ)..b, X (t,(s*u,s))-u*Y (t,(s*u,s))) - |
| (∫ s in (0 : ℝ)..b, X (t,(s*l,s))-l*Y (t,(s*l,s))) := |
| intervalIntegral.integral_sub ((by fun_prop : Continuous (fun s : ℝ ↦ |
| X (t,(s*u,s))-u*Y (t,(s*u,s)))).intervalIntegrable _ _) |
| ((by fun_prop : Continuous (fun s : ℝ ↦ |
| X (t,(s*l,s))-l*Y (t,(s*l,s)))).intervalIntegrable _ _) |
| simp only [prismRadialFlux,he] |
| exact intervalIntegral.integral_sub ((hc u).intervalIntegrable _ _) ((hc l).intervalIntegrable _ _) |
|
|
| theorem blowup_radial_faces_remainder_le |
| {a c b l u l₀ l₁ u₀ u₁ : ℝ} (hac : a ≤ c) (hb : 0 ≤ b) |
| (hl₀ : l₀ < l) (hl₁ : l < l₁) (hu₀ : u₀ < u) (hu₁ : u < u₁) (hsep : l₁ ≤ u₀) |
| {A O : Set Cover} (hA : MeasurableSet A) |
| (hflatL : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c b l₀ l₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) |
| (hflatU : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c b u₀ u₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) |
| (hLO : strictPatchOpen (radialPatchInequalities a c b l₀ l₁) ⊆ O) |
| (hUO : strictPatchOpen (radialPatchInequalities a c b u₀ u₁) ⊆ O) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O}) |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F → |
| tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) → |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) |
| (hO : tsupport F ⊆ O) (hnF : ∀ x, ‖F x‖ ≤ 1) : |
| (∫ x in A, divergence F x) - |
| prismRadialFlux (fun w ↦ F (coverPrismCoordinates.symm w) 1) |
| (fun w ↦ F (coverPrismCoordinates.symm w) 2) a c b l u ≤ |
| (coverLocalPerimeter A O).toReal - |
| (c-a)*b*(Real.sqrt (1+l^2)+Real.sqrt (1+u^2)) := by |
| have hnL : ‖-radialFaceNormal l‖ = 1 := by rw [norm_neg,radialFaceNormal_norm] |
| have hpL (y : Plane) : ⟪-radialFaceNormal l,radialFaceIsometry l y⟫ = 0 := by |
| rw [inner_neg_left,radialFaceIsometry_perp,neg_zero] |
| have hmL := measurableSet_strictPatchOpen |
| (fun i ↦ (radialPatchInequalities_contDiff a c b l₀ l₁ i).continuous) |
| have hmU := measurableSet_strictPatchOpen |
| (fun i ↦ (radialPatchInequalities_contDiff a c b u₀ u₁ i).continuous) |
| have h := blowup_two_polytope_patches_remainder_le |
| (radialPatchInequalities_contDiff a c b l₀ l₁) |
| (radialPatchInequalities_contDiff a c b u₀ u₁) |
| (radialPatchClosed_isCompact a c b l₀ l₁) (radialPatchClosed_isCompact a c b u₀ u₁) |
| (radialPatchOpen_disjoint hsep) hA hnL (radialFaceNormal_norm u) |
| hflatL hflatU hLO hUO heq hflux hF hs hO hnF |
| rw [neg_radial_face_flux hac hb hl₀ hl₁ hF.continuous, |
| radial_face_flux hac hb hu₀ hu₁ hF.continuous, |
| real_volume_normalPlane_eq_isometry hnL (radialFaceIsometry l) hpL hmL, |
| real_volume_normalPlane_eq_isometry (radialFaceNormal_norm u) |
| (radialFaceIsometry u) (radialFaceIsometry_perp u) hmU, |
| radial_face_patch_area hac hb hl₀ hl₁,radial_face_patch_area hac hb hu₀ hu₁] at h |
| rw [prismRadialFlux_eq_sub (prism_component_contDiff hF 1).continuous |
| (prism_component_contDiff hF 2).continuous] |
| simp only [coverPrismCoordinates_symm_apply] at ⊢ |
| have he (t s k : ℝ) : WithLp.toLp 2 ![t,s*k,s] = WithLp.toLp 2 ![t,k*s,s] := by rw [mul_comm s k] |
| simp_rw [he] |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| theorem coverLocalPerimeter_prism_surgery_lt |
| {a c b l u l₀ l₁ u₀ u₁ : ℝ} (hac : a < c) (hb : 0 < b) |
| (hl₀ : l₀ < l) (hl₁ : l < l₁) (hu₀ : u₀ < u) (hu₁ : u < u₁) (hsep : l₁ ≤ u₀) |
| (hsmall : (c-a)*b*(u-l)+b^2*(u-l) < |
| (c-a)*b*(Real.sqrt (1+l^2)+Real.sqrt (1+u^2))) |
| {A O : Set Cover} (hA : MeasurableSet A) |
| (hPA : ∀ᵐ x : Cover ∂volume, x ∈ euclideanPrism a c b l u → x ∈ A) |
| (hflatL : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c b l₀ l₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) |
| (hflatU : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c b u₀ u₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) |
| (hLO : strictPatchOpen (radialPatchInequalities a c b l₀ l₁) ⊆ O) |
| (hUO : strictPatchOpen (radialPatchInequalities a c b u₀ u₁) ⊆ O) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O}) |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F → |
| tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) → |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) : |
| coverLocalPerimeter (A \ euclideanPrism a c b l u) O < coverLocalPerimeter A O := by |
| have hlu : l ≤ u := (hl₁.trans_le hsep).trans hu₀ |>.le |
| let area := (c-a)*b*(Real.sqrt (1+l^2)+Real.sqrt (1+u^2)) |
| have harea : 0 < area := by |
| dsimp [area] |
| have hlp : 0 < Real.sqrt (1+l^2) := Real.sqrt_pos.mpr (by positivity) |
| have hup : 0 < Real.sqrt (1+u^2) := Real.sqrt_pos.mpr (by positivity) |
| exact mul_pos (mul_pos (sub_pos.mpr hac) hb) (add_pos hlp hup) |
| have hrem (F : Cover → Cover) (hF : ContDiff ℝ (⊤ : ℕ∞) F) |
| (hs : HasCompactSupport F) (hO : tsupport F ⊆ O) (hn : ∀ x, ‖F x‖ ≤ 1) := |
| blowup_radial_faces_remainder_le hac.le hb.le hl₀ hl₁ hu₀ hu₁ hsep hA hflatL hflatU |
| hLO hUO heq hflux hF hs hO hn |
| have hpa : area ≤ (coverLocalPerimeter A O).toReal := by |
| have hz := hrem (fun _ ↦ 0) contDiff_const (by simp [HasCompactSupport]) |
| (by simp) (by simp) |
| simp [area,divergence,prismRadialFlux] at hz ⊢ |
| linarith |
| have hp : 0 < (coverLocalPerimeter A O).toReal := harea.trans_le hpa |
| have hfin : coverLocalPerimeter A O ≠ ⊤ := by rw [heq]; exact measure_ne_top _ _ |
| have hbound := coverLocalPerimeter_prism_surgery_le hac.le hb.le hlu hPA hrem |
| apply hbound.trans_lt |
| apply lt_of_lt_of_eq ?_ (ENNReal.ofReal_toReal hfin) |
| apply (ENNReal.ofReal_lt_ofReal_iff hp).mpr |
| dsimp [area] at * |
| linarith |
|
|
| theorem no_minimizing_strict_prism_sector |
| {a c b l u l₀ l₁ u₀ u₁ : ℝ} (hac : a < c) (hb : 0 < b) |
| (hl₀ : l₀ < l) (hl₁ : l < l₁) (hu₀ : u₀ < u) (hu₁ : u < u₁) (hsep : l₁ ≤ u₀) |
| (hsmall : (c-a)*b*(u-l)+b^2*(u-l) < |
| (c-a)*b*(Real.sqrt (1+l^2)+Real.sqrt (1+u^2))) |
| {A O K : Set Cover} (hA : MeasurableSet A) |
| (hmin : ∀ D : Set Cover, MeasurableSet D → A ∆ D ⊆ K → |
| coverLocalPerimeter A O ≤ coverLocalPerimeter D O) |
| (hPK : euclideanPrism a c b l u ⊆ K) |
| (hPA : ∀ᵐ x : Cover ∂volume, x ∈ euclideanPrism a c b l u → x ∈ A) |
| (hflatL : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c b l₀ l₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) |
| (hflatU : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c b u₀ u₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) |
| (hLO : strictPatchOpen (radialPatchInequalities a c b l₀ l₁) ⊆ O) |
| (hUO : strictPatchOpen (radialPatchInequalities a c b u₀ u₁) ⊆ O) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O}) |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F → |
| tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) → |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) : False := by |
| have hlt := coverLocalPerimeter_prism_surgery_lt hac hb hl₀ hl₁ hu₀ hu₁ hsep hsmall hA |
| hPA hflatL hflatU hLO hUO heq hflux |
| have hle := hmin (A \ euclideanPrism a c b l u) |
| (hA.diff (measurableSet_euclideanPrism a c b l u)) |
| ((prism_surgery_symmDiff_subset A a c b l u).trans hPK) |
| exact not_lt_of_ge hle hlt |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma exists_normal_sphere_null_radius (ν : FiniteMeasure BlowupNormalBundle) |
| {a b : ℝ} (hab : a < b) : |
| ∃ r : ℝ, a < r ∧ r < b ∧ (ν : Measure BlowupNormalBundle) {z | ‖z.1‖ = r} = 0 := by |
| have hc := Measure.countable_meas_level_set_pos |
| (μ := (ν : Measure BlowupNormalBundle)) (g := fun z : BlowupNormalBundle ↦ ‖z.1‖) |
| (by fun_prop) |
| obtain ⟨r,hr,hrab⟩ := (hc.dense_compl ℝ).exists_mem_open isOpen_Ioo (nonempty_Ioo.mpr hab) |
| refine ⟨r,hrab.1,hrab.2,?_⟩ |
| exact le_antisymm (not_lt.mp hr) bot_le |
|
|
| lemma normal_closedBall_ae_eq_ball {ν : FiniteMeasure BlowupNormalBundle} {r : ℝ} |
| (hr : (ν : Measure BlowupNormalBundle) {z | ‖z.1‖ = r} = 0) : |
| {z : BlowupNormalBundle | z.1 ∈ Metric.closedBall (0 : Cover) r} =ᵐ[(ν : Measure BlowupNormalBundle)] |
| {z : BlowupNormalBundle | z.1 ∈ Metric.ball (0 : Cover) r} := by |
| filter_upwards [measure_eq_zero_iff_ae_notMem.mp hr] with z hz |
| apply propext |
| simp only [Metric.mem_closedBall,Metric.mem_ball,dist_zero_right] |
| exact ⟨fun h ↦ lt_of_le_of_ne h hz,le_of_lt⟩ |
|
|
| theorem coverLocalPerimeter_closedBall_eq_ball_of_normal |
| {A : Set Cover} {ν : FiniteMeasure BlowupNormalBundle} {r : ℝ} (hr1 : r ≤ 1) |
| (hr : (ν : Measure BlowupNormalBundle) {z | ‖z.1‖ = r} = 0) |
| (heq : coverLocalPerimeter A (Metric.ball (0 : Cover) r) = |
| (ν : Measure BlowupNormalBundle) {z | z.1 ∈ Metric.ball (0 : Cover) r}) |
| (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 (Metric.closedBall (0 : Cover) r) = |
| coverLocalPerimeter A (Metric.ball (0 : Cover) r) := by |
| apply le_antisymm |
| · have hh := coverLocalPerimeter_le_normal Metric.isClosed_closedBall.measurableSet |
| (Metric.closedBall_subset_closedBall hr1) hflux |
| exact hh.trans_eq ((measure_congr (normal_closedBall_ae_eq_ball hr)).trans heq.symm) |
| · exact coverLocalPerimeter_mono A Metric.ball_subset_closedBall |
|
|
| theorem normal_radius_local_minimizing {A : Set Cover} {ν : FiniteMeasure BlowupNormalBundle} |
| {a r : ℝ} (ha : 0 < a) (har : a < r) (hr1 : r ≤ 1) |
| (hr : (ν : Measure BlowupNormalBundle) {z | ‖z.1‖ = r} = 0) |
| (heq : coverLocalPerimeter A (Metric.ball (0 : Cover) r) = |
| (ν : Measure BlowupNormalBundle) {z | z.1 ∈ Metric.ball (0 : Cover) r}) |
| (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) |
| (hmin : ∀ D : Set Cover, MeasurableSet D → ∀ a b : ℝ, 0 < a → a < b → b ≤ 1 → |
| A ∆ D ⊆ Metric.ball (0 : Cover) a → |
| coverLocalPerimeter A (Metric.ball (0 : Cover) b) ≤ |
| coverLocalPerimeter D (Metric.closedBall (0 : Cover) b)) : |
| ∀ D : Set Cover, MeasurableSet D → A ∆ D ⊆ Metric.ball (0 : Cover) a → |
| coverLocalPerimeter A (Metric.closedBall (0 : Cover) r) ≤ |
| coverLocalPerimeter D (Metric.closedBall (0 : Cover) r) := by |
| intro D hD hAD |
| rw [coverLocalPerimeter_closedBall_eq_ball_of_normal hr1 hr heq hflux] |
| exact hmin D hD a r ha har hr1 hAD |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma euclideanPrism_mono_height {a c b d l u : ℝ} (hbd : b ≤ d) : |
| euclideanPrism a c b l u ⊆ euclideanPrism a c d l u := by |
| intro x hx |
| exact ⟨hx.1,⟨hx.2.1.1,hx.2.1.2.trans hbd⟩,hx.2.2⟩ |
|
|
| lemma radialPatchOpen_mono_height {a c b d l u : ℝ} (hbd : b ≤ d) : |
| strictPatchOpen (radialPatchInequalities a c b l u) ⊆ |
| strictPatchOpen (radialPatchInequalities a c d l u) := by |
| intro x hx |
| obtain ⟨ha,hc,h0,hb,hl,hu⟩ := (mem_radialPatchOpen a c b l u x).mp hx |
| exact (mem_radialPatchOpen a c d l u x).mpr ⟨ha,hc,h0,hb.trans_le hbd,hl,hu⟩ |
|
|
| theorem no_minimizing_small_radial_sector |
| {a c ε l u l₀ l₁ u₀ u₁ : ℝ} (hac : a < c) (hε : 0 < ε) |
| (hl₀ : l₀ < l) (hl₁ : l < l₁) (hu₀ : u₀ < u) (hu₁ : u < u₁) (hsep : l₁ ≤ u₀) |
| {A O K : Set Cover} (hA : MeasurableSet A) |
| (hmin : ∀ D : Set Cover, MeasurableSet D → A ∆ D ⊆ K → |
| coverLocalPerimeter A O ≤ coverLocalPerimeter D O) |
| (hPK : euclideanPrism a c ε l u ⊆ K) |
| (hPA : ∀ᵐ x : Cover ∂volume, x ∈ euclideanPrism a c ε l u → x ∈ A) |
| (hflatL : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c ε l₀ l₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) |
| (hflatU : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c ε u₀ u₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) |
| (hLO : strictPatchOpen (radialPatchInequalities a c ε l₀ l₁) ⊆ O) |
| (hUO : strictPatchOpen (radialPatchInequalities a c ε u₀ u₁) ⊆ O) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O}) |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F → |
| tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) → |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) : False := by |
| have hlu : l < u := (hl₁.trans_le hsep).trans hu₀ |
| obtain ⟨b,hb,hbε,hsmall⟩ := exists_strict_prism_replacement_scale hac hlu hε |
| have hPL := radialPatchOpen_mono_height (a := a) (c := c) (l := l₀) (u := l₁) hbε.le |
| have hPU := radialPatchOpen_mono_height (a := a) (c := c) (l := u₀) (u := u₁) hbε.le |
| have hP := euclideanPrism_mono_height (a := a) (c := c) (l := l) (u := u) hbε.le |
| exact no_minimizing_strict_prism_sector hac hb hl₀ hl₁ hu₀ hu₁ hsep hsmall hA hmin |
| (hP.trans hPK) (hPA.mono (fun _ hx hy ↦ hx (hP hy))) |
| (hflatL.mono (fun _ hx hy ↦ hx (hPL hy))) |
| (hflatU.mono (fun _ hx hy ↦ hx (hPU hy))) (hPL.trans hLO) (hPU.trans hUO) heq hflux |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma integral_cover_divergence_zero {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) : |
| (∫ x : Cover, divergence F x) = 0 := 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] |
| rw [integral_finsetSum] |
| · apply Finset.sum_eq_zero |
| intro i _ |
| exact integral_compact_fderiv_zero (hp i) (hps i) _ |
| · intro i _ |
| exact (((hp i).continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport |
| ((hps i).fderiv_apply ℝ _) |
|
|
| lemma integral_cover_divergence_compl {A : Set Cover} (hA : MeasurableSet A) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) : |
| (∫ x in Aᶜ, divergence F x) = -(∫ x in A, divergence F x) := by |
| have hi : Integrable (divergence F) (volume : Measure Cover) := |
| (continuous_divergence hF).integrable_of_hasCompactSupport |
| (hs.of_isClosed_subset isClosed_closure (divergence_tsupport_subset F)) |
| have hh := integral_add_compl hA hi |
| rw [integral_cover_divergence_zero hF hs] at hh |
| linarith |
|
|
| theorem coverLocalPerimeter_compl {A : Set Cover} (hA : MeasurableSet A) (O : Set Cover) : |
| coverLocalPerimeter Aᶜ O = coverLocalPerimeter A O := by |
| have hle {A : Set Cover} (hA : MeasurableSet A) : |
| coverLocalPerimeter Aᶜ O ≤ coverLocalPerimeter A O := 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 hnorm |
| have hFn : ContDiff ℝ (⊤ : ℕ∞) (fun x ↦ -F x) := hF.neg |
| have hsFn : HasCompactSupport (fun x ↦ -F x) := hs.neg |
| have hOFn : tsupport (fun x ↦ -F x) ⊆ O := by |
| change tsupport (-F) ⊆ O |
| simpa only [tsupport_neg] using hO |
| have hnFn (x) : ‖-F x‖ ≤ 1 := by simpa using hnorm x |
| have he : (∫ x in Aᶜ, divergence F x) = ∫ x in A, divergence (fun y ↦ -F y) x := by |
| rw [integral_cover_divergence_compl hA hF hs] |
| simp only [divergence_neg,integral_neg] |
| rw [he] |
| exact le_iSup_of_le (fun x ↦ -F x) (le_iSup_of_le hFn (le_iSup_of_le hsFn |
| (le_iSup_of_le hOFn (le_iSup_of_le hnFn le_rfl)))) |
| exact le_antisymm (hle hA) (by simpa only [compl_compl] using hle hA.compl) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| def reverseBlowupNormal (z : BlowupNormalBundle) : BlowupNormalBundle := |
| (z.1,⟨-(z.2 : Cover),by simpa only [norm_neg] using z.2.property⟩) |
|
|
| lemma continuous_reverseBlowupNormal : Continuous reverseBlowupNormal := |
| continuous_fst.prodMk ((continuous_subtype_val.comp continuous_snd).neg.subtype_mk _) |
|
|
| lemma reverseBlowupNormal_spatial_mass (ν : FiniteMeasure BlowupNormalBundle) |
| {O : Set Cover} (hO : MeasurableSet O) : |
| (ν.map reverseBlowupNormal : Measure BlowupNormalBundle) {z | z.1 ∈ O} = |
| (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O} := by |
| rw [FiniteMeasure.toMeasure_map,Measure.map_apply continuous_reverseBlowupNormal.measurable |
| (show MeasurableSet {z : BlowupNormalBundle | z.1 ∈ O} from hO.preimage measurable_fst)] |
| rfl |
|
|
| lemma reverseBlowupNormal_flux {A O : Set Cover} (hA : MeasurableSet A) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F → |
| tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) → |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) |
| {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) |
| (hFO : tsupport F ⊆ O) (hFn : ∀ x, ‖F x‖ ≤ 1) : |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν.map reverseBlowupNormal : Measure BlowupNormalBundle)) = |
| ∫ x in Aᶜ, divergence F x := by |
| rw [FiniteMeasure.toMeasure_map,integral_map continuous_reverseBlowupNormal.measurable.aemeasurable |
| (continuous_blowupFluxTest hF.continuous).aestronglyMeasurable] |
| change (∫ z, ⟪-(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = _ |
| simp_rw [inner_neg_left,integral_neg] |
| rw [integral_cover_divergence_compl hA hF hs,hflux F hF hs hFO hFn] |
|
|
| lemma coverLocalPerimeter_normal_compl {A O : Set Cover} (hA : MeasurableSet A) |
| (hO : MeasurableSet O) {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O}) : |
| coverLocalPerimeter Aᶜ O = |
| (ν.map reverseBlowupNormal : Measure BlowupNormalBundle) {z | z.1 ∈ O} := by |
| rw [coverLocalPerimeter_compl hA,reverseBlowupNormal_spatial_mass ν hO,heq] |
|
|
| lemma coverLocalPerimeter_compl_minimizing {A O K : Set Cover} (hA : MeasurableSet A) |
| (hmin : ∀ D : Set Cover, MeasurableSet D → A ∆ D ⊆ K → |
| coverLocalPerimeter A O ≤ coverLocalPerimeter D O) : |
| ∀ D : Set Cover, MeasurableSet D → Aᶜ ∆ D ⊆ K → |
| coverLocalPerimeter Aᶜ O ≤ coverLocalPerimeter D O := by |
| intro D hD hAD |
| rw [coverLocalPerimeter_compl hA] |
| have hsub : A ∆ Dᶜ ⊆ K := by |
| intro x hx |
| apply hAD |
| simp only [mem_symmDiff,mem_compl_iff] at hx ⊢ |
| tauto |
| simpa only [coverLocalPerimeter_compl hD] using hmin Dᶜ hD.compl hsub |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| theorem no_minimizing_small_empty_radial_sector |
| {a c ε l u l₀ l₁ u₀ u₁ : ℝ} (hac : a < c) (hε : 0 < ε) |
| (hl₀ : l₀ < l) (hl₁ : l < l₁) (hu₀ : u₀ < u) (hu₁ : u < u₁) (hsep : l₁ ≤ u₀) |
| {A O K : Set Cover} (hA : MeasurableSet A) (hO : MeasurableSet O) |
| (hmin : ∀ D : Set Cover, MeasurableSet D → A ∆ D ⊆ K → |
| coverLocalPerimeter A O ≤ coverLocalPerimeter D O) |
| (hPK : euclideanPrism a c ε l u ⊆ K) |
| (hPA : ∀ᵐ x : Cover ∂volume, x ∈ euclideanPrism a c ε l u → x ∉ A) |
| (hflatL : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c ε l₀ l₁) → |
| (x ∉ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) |
| (hflatU : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c ε u₀ u₁) → |
| (x ∉ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) |
| (hLO : strictPatchOpen (radialPatchInequalities a c ε l₀ l₁) ⊆ O) |
| (hUO : strictPatchOpen (radialPatchInequalities a c ε u₀ u₁) ⊆ O) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O}) |
| (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F → |
| tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) → |
| (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = |
| ∫ x in A, divergence F x) : False := by |
| exact no_minimizing_small_radial_sector hac hε hl₀ hl₁ hu₀ hu₁ hsep hA.compl |
| (coverLocalPerimeter_compl_minimizing hA hmin) hPK hPA hflatL hflatU hLO hUO |
| (coverLocalPerimeter_normal_compl hA hO heq) |
| (fun F hF hs hFO hFn ↦ reverseBlowupNormal_flux hA hflux hF hs hFO hFn) |
|
|
| theorem no_moving_tangent_small_radial_sector |
| {a c ε l u l₀ l₁ u₀ u₁ ρ : ℝ} (hac : a < c) (hε : 0 < ε) |
| (hl₀ : l₀ < l) (hl₁ : l < l₁) (hu₀ : u₀ < u) (hu₁ : u < u₁) (hsep : l₁ ≤ u₀) |
| (hρ : 0 < ρ) (hρ1 : ρ < 1) |
| {A : Set Cover} (hA : MeasurableSet A) |
| (hmin : ∀ D : Set Cover, MeasurableSet D → ∀ a b : ℝ, 0 < a → a < b → b ≤ 1 → |
| A ∆ D ⊆ Metric.ball (0 : Cover) a → |
| coverLocalPerimeter A (Metric.ball (0 : Cover) b) ≤ |
| coverLocalPerimeter D (Metric.closedBall (0 : Cover) b)) |
| (hPK : euclideanPrism a c ε l u ⊆ Metric.ball (0 : Cover) ρ) |
| (hPA : ∀ᵐ x : Cover ∂volume, x ∈ euclideanPrism a c ε l u → x ∈ A) |
| (hflatL : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c ε l₀ l₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) |
| (hflatU : ∀ᵐ x : Cover ∂volume, x ∈ strictPatchOpen (radialPatchInequalities a c ε u₀ u₁) → |
| (x ∈ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) |
| (hLO : strictPatchOpen (radialPatchInequalities a c ε l₀ l₁) ⊆ Metric.ball (0 : Cover) ρ) |
| (hUO : strictPatchOpen (radialPatchInequalities a c ε u₀ u₁) ⊆ Metric.ball (0 : Cover) ρ) |
| {ν : FiniteMeasure BlowupNormalBundle} |
| (heq : ∀ r : ℝ, 0 < r → r ≤ 1 → coverLocalPerimeter A (Metric.ball (0 : Cover) r) = |
| (ν : Measure BlowupNormalBundle) {z | z.1 ∈ Metric.ball (0 : Cover) r}) |
| (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) : False := by |
| obtain ⟨r,hρr,hr1,hr⟩ := exists_normal_sphere_null_radius ν hρ1 |
| have hr0 : 0 < r := hρ.trans hρr |
| have hpr := heq r hr0 hr1.le |
| have hclosed := coverLocalPerimeter_closedBall_eq_ball_of_normal hr1.le hr hpr hflux |
| have hmass : coverLocalPerimeter A (Metric.closedBall (0 : Cover) r) = |
| (ν : Measure BlowupNormalBundle) {z | z.1 ∈ Metric.closedBall (0 : Cover) r} := by |
| rw [hclosed,hpr,measure_congr (normal_closedBall_ae_eq_ball hr)] |
| have hinner : Metric.ball (0 : Cover) ρ ⊆ Metric.closedBall (0 : Cover) r := |
| (Metric.ball_subset_ball hρr.le).trans Metric.ball_subset_closedBall |
| exact no_minimizing_small_radial_sector hac hε hl₀ hl₁ hu₀ hu₁ hsep hA |
| (normal_radius_local_minimizing hρ hρr hr1.le hr hpr hflux hmin) |
| hPK hPA hflatL hflatU (hLO.trans hinner) (hUO.trans hinner) hmass |
| (fun F hF _ hFO _ ↦ hflux F hF (hFO.trans (Metric.closedBall_subset_closedBall hr1.le))) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace symmDiff |
| namespace CubicTorus |
|
|
| lemma prismSlope_quasiMeasurePreserving : |
| Measure.QuasiMeasurePreserving (fun x : Cover ↦ (x 2)⁻¹*x 1) volume volume := by |
| have hp := (Measure.quasiMeasurePreserving_snd (μ := (volume : Measure ℝ))).comp |
| prismColumnCoordinates_measurePreserving.quasiMeasurePreserving |
| have hw := planarWedgeCoordinates_quasiMeasurePreserving.comp hp |
| have hs := (Measure.quasiMeasurePreserving_snd (μ := (volume : Measure ℝ))).comp hw |
| convert! hs using 1 |
| ext x |
| simp [planarWedgeCoordinates] |
|
|
| lemma mem_negative_radial_halfspace {v : ℝ} {x : Cover} (hx : 0 < x 2) : |
| x ∈ coverHalfspace (-radialFaceNormal v) ↔ v < (x 2)⁻¹*x 1 := by |
| change ⟪-radialFaceNormal v,x⟫ < 0 ↔ _ |
| rw [inner_neg_left,inner_radialFaceNormal] |
| have hd : 0 < Real.sqrt (1+v^2) := Real.sqrt_pos.mpr (by positivity) |
| rw [neg_lt_zero,div_pos_iff_of_pos_right hd,sub_pos,← div_eq_inv_mul,lt_div_iff₀ hx] |
|
|
| lemma mem_radial_halfspace {v : ℝ} {x : Cover} (hx : 0 < x 2) : |
| x ∈ coverHalfspace (radialFaceNormal v) ↔ (x 2)⁻¹*x 1 < v := by |
| change ⟪radialFaceNormal v,x⟫ < 0 ↔ _ |
| rw [inner_radialFaceNormal] |
| have hd : 0 < Real.sqrt (1+v^2) := Real.sqrt_pos.mpr (by positivity) |
| rw [div_lt_iff₀ hd,zero_mul,sub_lt_zero,← div_eq_inv_mul,div_lt_iff₀ hx] |
|
|
| theorem slope_interval_radial_models |
| {A : Set Cover} {a c ε l u δ : ℝ} (hδ : 0 < δ) (hgap : 3*δ < u-l) |
| (hmodel : ∀ᵐ x : Cover ∂volume, x 0 ∈ Ioc a c → x 2 ∈ Ioc 0 ε → |
| (x 2)⁻¹*x 1 ∈ Ioo (l-δ) (u+δ) → |
| (x ∈ A ↔ (x 2)⁻¹*x 1 ∈ Ioo l u)) : |
| (∀ᵐ x : Cover ∂volume, x ∈ euclideanPrism a c ε l u → x ∈ A) ∧ |
| (∀ᵐ x : Cover ∂volume, |
| x ∈ strictPatchOpen (radialPatchInequalities a c ε (l-δ) (l+δ)) → |
| (x ∈ A ↔ x ∈ coverHalfspace (-radialFaceNormal l))) ∧ |
| (∀ᵐ x : Cover ∂volume, |
| x ∈ strictPatchOpen (radialPatchInequalities a c ε (u-δ) (u+δ)) → |
| (x ∈ A ↔ x ∈ coverHalfspace (radialFaceNormal u))) := by |
| have hne : ∀ᵐ t : ℝ ∂volume, t ≠ l ∧ t ≠ u := by |
| filter_upwards [show ∀ᵐ t : ℝ ∂volume, t ≠ l by rw [ae_iff]; simp, |
| show ∀ᵐ t : ℝ ∂volume, t ≠ u by rw [ae_iff]; simp] with t hl hu |
| exact ⟨hl,hu⟩ |
| refine ⟨?_,?_,?_⟩ |
| · filter_upwards [hmodel,prismSlope_quasiMeasurePreserving.ae hne] with x hm hn hx |
| change x 0 ∈ Ioc a c ∧ x 2 ∈ Ioc 0 ε ∧ x 1 ∈ Ioc (x 2*l) (x 2*u) at hx |
| have ht : (x 2)⁻¹*x 1 ∈ Ioo l u := by |
| rw [← div_eq_inv_mul] |
| constructor |
| · apply lt_of_le_of_ne ((le_div_iff₀ hx.2.1.1).mpr (by nlinarith [hx.2.2.1])) |
| simpa only [div_eq_inv_mul] using hn.1.symm |
| · apply lt_of_le_of_ne ((div_le_iff₀ hx.2.1.1).mpr (by nlinarith [hx.2.2.2])) |
| simpa only [div_eq_inv_mul] using hn.2 |
| exact (hm hx.1 hx.2.1 ⟨by linarith [ht.1],by linarith [ht.2]⟩).mpr ht |
| · filter_upwards [hmodel] with x hm hx |
| obtain ⟨ha,hc,h0,hε,hl,hu⟩ := (mem_radialPatchOpen a c ε (l-δ) (l+δ) x).mp hx |
| have htL : l-δ < (x 2)⁻¹*x 1 := by rw [← div_eq_inv_mul,lt_div_iff₀ h0]; exact hl |
| have htU : (x 2)⁻¹*x 1 < l+δ := by rw [← div_eq_inv_mul,div_lt_iff₀ h0]; exact hu |
| rw [hm ⟨ha,hc.le⟩ ⟨h0,hε.le⟩ ⟨htL,by linarith⟩,mem_negative_radial_halfspace h0] |
| exact and_iff_left (by linarith) |
| · filter_upwards [hmodel] with x hm hx |
| obtain ⟨ha,hc,h0,hε,hl,hu⟩ := (mem_radialPatchOpen a c ε (u-δ) (u+δ) x).mp hx |
| have htL : u-δ < (x 2)⁻¹*x 1 := by rw [← div_eq_inv_mul,lt_div_iff₀ h0]; exact hl |
| have htU : (x 2)⁻¹*x 1 < u+δ := by rw [← div_eq_inv_mul,div_lt_iff₀ h0]; exact hu |
| rw [hm ⟨ha,hc.le⟩ ⟨h0,hε.le⟩ ⟨by linarith,htU⟩,mem_radial_halfspace h0] |
| exact and_iff_right (by linarith) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma cover_norm_le_coordinates (x : Cover) : ‖x‖ ≤ |x 0|+|x 1|+|x 2| := by |
| have he : x = (EuclideanSpace.single 0 (x 0) : Cover)+(EuclideanSpace.single 1 (x 1) : Cover)+(EuclideanSpace.single 2 (x 2) : Cover) := by |
| ext i |
| fin_cases i <;> simp |
| calc |
| ‖x‖ = ‖(EuclideanSpace.single 0 (x 0) : Cover)+(EuclideanSpace.single 1 (x 1) : Cover)+(EuclideanSpace.single 2 (x 2) : Cover)‖ := congrArg norm he |
| _ ≤ ‖(EuclideanSpace.single 0 (x 0) : Cover)‖+‖(EuclideanSpace.single 1 (x 1) : Cover)‖+‖(EuclideanSpace.single 2 (x 2) : Cover)‖ := |
| (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl) |
| _ = _ := by simp |
|
|
| lemma radialPatchClosed_coordinate_bounds {h b l u : ℝ} (hb : 0 ≤ b) {x : Cover} |
| (hx : x ∈ strictPatchClosed (radialPatchInequalities (-h) h b l u)) : |
| |x 0| ≤ h ∧ |x 1| ≤ b*(|l|+|u|) ∧ |x 2| ≤ b := by |
| obtain ⟨ha,hc,h0,hb',hl,hu⟩ := (mem_radialPatchClosed (-h) h b l u x).mp hx |
| refine ⟨abs_le.mpr ⟨ha,hc⟩,abs_le.mpr ⟨?_,?_⟩,by rwa [abs_of_nonneg h0]⟩ |
| · have hp := mul_le_mul_of_nonneg_left hb' (abs_nonneg l) |
| have hq := mul_le_mul_of_nonneg_right (neg_abs_le l) h0 |
| have hr := mul_nonneg hb (abs_nonneg u) |
| nlinarith |
| · have hp := mul_le_mul_of_nonneg_left hb' (abs_nonneg u) |
| have hq := mul_le_mul_of_nonneg_right (le_abs_self u) h0 |
| have hr := mul_nonneg hb (abs_nonneg l) |
| nlinarith |
|
|
| lemma radialPatchClosed_norm_le {h b l u : ℝ} (hb : 0 ≤ b) {x : Cover} |
| (hx : x ∈ strictPatchClosed (radialPatchInequalities (-h) h b l u)) : |
| ‖x‖ ≤ h+b*(|l|+|u|+1) := by |
| obtain ⟨h0,h1,h2⟩ := radialPatchClosed_coordinate_bounds hb hx |
| have hn := cover_norm_le_coordinates x |
| nlinarith |
|
|
| lemma euclideanPrism_subset_radialPatchClosed (a c b l u : ℝ) : |
| euclideanPrism a c b l u ⊆ strictPatchClosed (radialPatchInequalities a c b l u) := by |
| intro x hx |
| change x 0 ∈ Ioc a c ∧ x 2 ∈ Ioc 0 b ∧ x 1 ∈ Ioc (x 2*l) (x 2*u) at hx |
| apply (mem_radialPatchClosed a c b l u x).mpr |
| exact ⟨hx.1.1.le,hx.1.2,hx.2.1.1.le,hx.2.1.2,by nlinarith [hx.2.2.1],by nlinarith [hx.2.2.2]⟩ |
|
|
| lemma radialPatchOpen_subset_closed (a c b l u : ℝ) : |
| strictPatchOpen (radialPatchInequalities a c b l u) ⊆ |
| strictPatchClosed (radialPatchInequalities a c b l u) := by |
| intro x hx i |
| exact (hx i).le |
|
|
| theorem exists_small_sector_geometry {ρ η b l u δ : ℝ} |
| (hρ : 0 < ρ) (hη : 0 < η) (hb : 0 < b) (hδ : 0 < δ) : |
| ∃ h ε : ℝ, 0 < h ∧ h < η ∧ 0 < ε ∧ ε < b ∧ |
| (∀ s t : ℝ, |s|+|t| ≤ 2*(|l|+|u|+δ) → |
| strictPatchClosed (radialPatchInequalities (-h) h ε s t) ⊆ Metric.ball (0 : Cover) ρ) ∧ |
| (∀ x : Cover, x 2 ∈ Ioc 0 ε → (x 2)⁻¹*x 1 ∈ Ioo (l-δ) (u+δ) → |
| ‖planeProductCoordinates.symm (x 2,x 1)‖ < η) := by |
| let N : ℝ := ‖planeProductCoordinates.symm.toContinuousLinearMap‖ |
| let M : ℝ := |l|+|u|+δ+1 |
| let h : ℝ := min (η/2) (ρ/4) |
| let ε : ℝ := min (b/2) (min (ρ/(8*M)) (η/(4*(N+1)*M))) |
| have hM : 0 < M := by dsimp [M]; positivity |
| have hN : 0 ≤ N := norm_nonneg _ |
| have hh : 0 < h := lt_min (by positivity) (by positivity) |
| have he : 0 < ε := lt_min (by positivity) (lt_min (by positivity) (by positivity)) |
| have heρ : ε ≤ ρ/(8*M) := (min_le_right _ _).trans (min_le_left _ _) |
| have heη : ε ≤ η/(4*(N+1)*M) := (min_le_right _ _).trans (min_le_right _ _) |
| have heρ' := (le_div_iff₀ (show 0 < 8*M by positivity)).mp heρ |
| have heη' := (le_div_iff₀ (show 0 < 4*(N+1)*M by positivity)).mp heη |
| refine ⟨h,ε,hh,(min_le_left _ _).trans_lt (by linarith),he, |
| (min_le_left _ _).trans_lt (by linarith),?_,?_⟩ |
| · intro s t hst x hx |
| have hn := radialPatchClosed_norm_le he.le hx |
| have hcoeff : |s|+|t|+1 ≤ 2*M := by dsimp [M]; linarith |
| have hecoeff := mul_le_mul_of_nonneg_left hcoeff he.le |
| rw [Metric.mem_ball,dist_zero_right] |
| have hhr : h ≤ ρ/4 := min_le_right _ _ |
| nlinarith |
| · intro x hx ht |
| have hx0 : 0 < x 2 := hx.1 |
| have hlo : (l-δ)*x 2 < x 1 := by |
| have hh := ht.1 |
| rw [← div_eq_inv_mul,lt_div_iff₀ hx0] at hh |
| exact hh |
| have hup : x 1 < (u+δ)*x 2 := by |
| have hh := ht.2 |
| rw [← div_eq_inv_mul,div_lt_iff₀ hx0] at hh |
| exact hh |
| have hx1 : |x 1| ≤ M*ε := by |
| apply abs_le.mpr |
| constructor |
| · have hs : -M ≤ l-δ := by dsimp [M]; linarith [neg_abs_le l,abs_nonneg u] |
| have hs' := mul_le_mul_of_nonneg_right hs hx0.le |
| have hm := mul_le_mul_of_nonneg_left hx.2 hM.le |
| nlinarith |
| · have hs : u+δ ≤ M := by dsimp [M]; linarith [le_abs_self u,abs_nonneg l] |
| have hs' := mul_le_mul_of_nonneg_right hs hx0.le |
| have hm := mul_le_mul_of_nonneg_left hx.2 hM.le |
| nlinarith |
| have hx2 : |x 2| ≤ M*ε := by |
| rw [abs_of_pos hx0] |
| have hM1 : 1 ≤ M := by dsimp [M]; linarith [abs_nonneg l,abs_nonneg u] |
| exact hx.2.trans (by nlinarith) |
| have hpn : ‖((x 2,x 1) : ℝ × ℝ)‖ ≤ M*ε := by |
| rw [Prod.norm_def,Real.norm_eq_abs,Real.norm_eq_abs] |
| exact max_le hx2 hx1 |
| have hp := planeProductCoordinates.symm.toContinuousLinearMap.le_opNorm (x 2,x 1) |
| have hmult := mul_le_mul_of_nonneg_left hpn hN |
| change ‖planeProductCoordinates.symm (x 2,x 1)‖ ≤ N*‖((x 2,x 1) : ℝ × ℝ)‖ at hp |
| have hex := mul_pos hM he |
| nlinarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma prismRotatedColumn_measurePreserving (R : Plane ≃ₗᵢ[ℝ] Plane) : |
| MeasurePreserving (fun x : Cover ↦ (x 0,R (planeProductCoordinates.symm (x 2,x 1)))) volume volume := by |
| have hp := (MeasurePreserving.id (volume : Measure ℝ)).prod R.measurePreserving |
| convert! hp.comp prismColumnCoordinates_measurePreserving using 1 |
|
|
| lemma prismPlanarProjection_quasiMeasurePreserving : |
| Measure.QuasiMeasurePreserving (fun x : Cover ↦ planeProductCoordinates.symm (x 2,x 1)) volume volume := by |
| have hh := (Measure.quasiMeasurePreserving_snd (μ := (volume : Measure ℝ))).comp |
| prismColumnCoordinates_measurePreserving.quasiMeasurePreserving |
| convert! hh using 1 |
|
|
| theorem prismFrame_product_model {B : Set Cover} {C : Set Plane} {n : Cover} {η : ℝ} |
| (hprod : ∀ᵐ z : ℝ × Plane ∂volume, |z.1| < η → ‖z.2‖ < η → |
| (normalColumnChart 0 n z ∈ B ↔ z.2 ∈ C)) (R : Plane ≃ₗᵢ[ℝ] Plane) : |
| ∀ᵐ x : Cover ∂volume, |x 0| < η → ‖planeProductCoordinates.symm (x 2,x 1)‖ < η → |
| (x ∈ (prismFrame n R) ⁻¹' B ↔ planeProductCoordinates.symm (x 2,x 1) ∈ R ⁻¹' C) := by |
| filter_upwards [(prismRotatedColumn_measurePreserving R).quasiMeasurePreserving.ae hprod] |
| with x hx ha hp |
| change prismFrame n R x ∈ B ↔ R (planeProductCoordinates.symm (x 2,x 1)) ∈ C |
| rw [prismFrame_apply] |
| exact hx ha (by simpa only [R.norm_map] using hp) |
|
|
| theorem prismFrame_angular_sector_model |
| {B : Set Cover} {C : Set Plane} {n : Cover} {η b l u δ : ℝ} |
| (hprod : ∀ᵐ z : ℝ × Plane ∂volume, |z.1| < η → ‖z.2‖ < η → |
| (normalColumnChart 0 n z ∈ B ↔ z.2 ∈ C)) (R : Plane ≃ₗᵢ[ℝ] Plane) |
| (hangular : ∀ᵐ y : Plane ∂volume, (planarWedgeCoordinates y).1 ∈ Ioo 0 b → |
| (planarWedgeCoordinates y).2 ∈ Ioo (l-δ) (u+δ) → |
| (y ∈ R ⁻¹' C ↔ (planarWedgeCoordinates y).2 ∈ Ioo l u)) : |
| ∀ᵐ x : Cover ∂volume, |x 0| < η → ‖planeProductCoordinates.symm (x 2,x 1)‖ < η → |
| x 2 ∈ Ioo 0 b → (x 2)⁻¹*x 1 ∈ Ioo (l-δ) (u+δ) → |
| (x ∈ (prismFrame n R) ⁻¹' B ↔ (x 2)⁻¹*x 1 ∈ Ioo l u) := by |
| filter_upwards [prismFrame_product_model hprod R, |
| prismPlanarProjection_quasiMeasurePreserving.ae hangular] with x hp ha hax hpn hr hs |
| have he : planarWedgeCoordinates (planeProductCoordinates.symm (x 2,x 1)) = |
| (x 2,(x 2)⁻¹*x 1) := by simp [planarWedgeCoordinates] |
| simp only [he] at ha |
| exact (hp hax hpn).trans (ha hr hs) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma divergence_eq_trace (F : Cover → Cover) (x : Cover) : |
| divergence F x = LinearMap.trace ℝ Cover (fderiv ℝ F x).toLinearMap := by |
| rw [LinearMap.trace_eq_matrix_trace ℝ (EuclideanSpace.basisFun (Fin 3) ℝ).toBasis] |
| simp [divergence,Matrix.trace,LinearMap.toMatrix_apply] |
|
|
| lemma divergence_isometry_pullback (R : Cover ≃ₗᵢ[ℝ] Cover) {F : Cover → Cover} |
| (hF : Differentiable ℝ F) (x : Cover) : |
| divergence (fun y ↦ R.symm (F (R y))) x = divergence F (R x) := by |
| rw [divergence_eq_trace,divergence_eq_trace] |
| have hd := R.symm.toContinuousLinearEquiv.hasFDerivAt.comp x |
| ((hF (R x)).hasFDerivAt.comp x R.toContinuousLinearEquiv.hasFDerivAt) |
| change HasFDerivAt (fun y ↦ R.symm (F (R y))) _ x at hd |
| rw [hd.fderiv] |
| have he : (R.symm.toContinuousLinearEquiv.toContinuousLinearMap.comp |
| ((fderiv ℝ F (R x)).comp R.toContinuousLinearEquiv.toContinuousLinearMap)).toLinearMap = |
| R.symm.toLinearEquiv.conj (fderiv ℝ F (R x)).toLinearMap := rfl |
| rw [he,LinearMap.trace_conj'] |
|
|
| lemma isometry_pullback_contDiff (R : Cover ≃ₗᵢ[ℝ] Cover) {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun x ↦ R.symm (F (R x))) := |
| R.symm.toContinuousLinearEquiv.contDiff.comp (hF.comp R.toContinuousLinearEquiv.contDiff) |
|
|
| lemma isometry_pullback_compactSupport (R : Cover ≃ₗᵢ[ℝ] Cover) {F : Cover → Cover} |
| (hs : HasCompactSupport F) : HasCompactSupport (fun x ↦ R.symm (F (R x))) := |
| (hs.comp_isClosedEmbedding R.toHomeomorph.isClosedEmbedding).comp_left (map_zero R.symm) |
|
|
| lemma isometry_pullback_tsupport (R : Cover ≃ₗᵢ[ℝ] Cover) (F : Cover → Cover) : |
| tsupport (fun x ↦ R.symm (F (R x))) = R ⁻¹' tsupport F := by |
| have h0 : Function.support (fun x ↦ R.symm (F (R x))) = R ⁻¹' Function.support F := by |
| ext x |
| change (R.symm (F (R x)) ≠ 0) ↔ (F (R x) ≠ 0) |
| have he : (R.symm (F (R x)) = 0) ↔ (F (R x) = 0) := by |
| constructor |
| · intro hh |
| simpa only [R.apply_symm_apply,map_zero] using congrArg R hh |
| · intro hh |
| rw [hh,map_zero] |
| exact not_congr he |
| change closure (Function.support (fun x ↦ R.symm (F (R x)))) = R ⁻¹' closure (Function.support F) |
| rw [h0] |
| exact (R.toHomeomorph.preimage_closure _).symm |
|
|
| lemma setIntegral_divergence_isometry_preimage (R : Cover ≃ₗᵢ[ℝ] Cover) |
| {A : Set Cover} (hA : MeasurableSet A) {F : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) : |
| (∫ x in R ⁻¹' A, divergence (fun y ↦ R.symm (F (R y))) x) = |
| ∫ x in A, divergence F x := by |
| simp_rw [divergence_isometry_pullback R (hF.differentiable (by simp))] |
| exact (R.measurePreserving.restrict_preimage hA).integral_comp R.toHomeomorph.measurableEmbedding _ |
|
|
| theorem coverLocalPerimeter_isometry_preimage (R : Cover ≃ₗᵢ[ℝ] Cover) |
| {A : Set Cover} (hA : MeasurableSet A) (O : Set Cover) : |
| coverLocalPerimeter (R ⁻¹' A) (R ⁻¹' O) = coverLocalPerimeter A O := by |
| have hle (R : Cover ≃ₗᵢ[ℝ] Cover) {A : Set Cover} (hA : MeasurableSet A) (O : Set Cover) : |
| coverLocalPerimeter A O ≤ coverLocalPerimeter (R ⁻¹' A) (R ⁻¹' O) := 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 hn |
| let G : Cover → Cover := fun x ↦ R.symm (F (R x)) |
| have hG := isometry_pullback_contDiff R hF |
| have hsG := isometry_pullback_compactSupport R hs |
| have hOG : tsupport G ⊆ R ⁻¹' O := by |
| rw [isometry_pullback_tsupport R F] |
| exact preimage_mono hO |
| have hnG (x) : ‖G x‖ ≤ 1 := by |
| rw [R.symm.norm_map]; exact hn _ |
| have he := setIntegral_divergence_isometry_preimage R hA hF |
| rw [← he] |
| exact le_iSup_of_le G (le_iSup_of_le hG (le_iSup_of_le hsG |
| (le_iSup_of_le hOG (le_iSup_of_le hnG le_rfl)))) |
| refine le_antisymm ?_ (hle R hA O) |
| have hh := hle R.symm (hA.preimage R.continuous.measurable) (R ⁻¹' O) |
| simpa only [preimage_preimage,R.apply_symm_apply,preimage_id'] using hh |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
