| import Mathlib |
| import OAI.Geometry.CubicTorus.Estimates.ConeSlopeReciprocalArea |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def minimalGraphDensity (g ψ : Plane → ℝ) (y : Plane) : ℝ := |
| fderiv ℝ ψ y (gradient g y)/Real.sqrt (1+‖gradient g y‖^2) |
|
|
| lemma graphAreaVector_norm_sqrt {n : Cover} (hn : ‖n‖=1) (g : Plane → ℝ) (y : Plane) : |
| ‖graphAreaVector n g y‖ = Real.sqrt (1+‖gradient g y‖^2) := by |
| rw [plane_gradient_norm,← graphAreaVector_norm_sq hn g y,Real.sqrt_sq (norm_nonneg _)] |
|
|
| lemma minimalGraphDensity_tsupport (g ψ : Plane → ℝ) : |
| tsupport (minimalGraphDensity g ψ) ⊆ tsupport ψ := by |
| apply closure_minimal _ isClosed_closure |
| intro y hy |
| by_contra hh |
| exact hy (by simp [minimalGraphDensity,fderiv_of_notMem_tsupport ℝ hh]) |
|
|
| lemma minimalGraphDensity_integrable {g ψ : Plane → ℝ} |
| (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hsψ : HasCompactSupport ψ) |
| (hg : ∀ y ∈ tsupport ψ, ContinuousAt (fderiv ℝ g) y) : |
| Integrable (minimalGraphDensity g ψ) := by |
| have hc : Continuous (minimalGraphDensity g ψ) := by |
| apply continuous_of_tsupport |
| intro y hy |
| have hd := hg y (minimalGraphDensity_tsupport g ψ hy) |
| have hgrad : ContinuousAt (gradient g) y := |
| (InnerProductSpace.toDual ℝ Plane).symm.continuous.continuousAt.comp hd |
| exact ((hψ.continuous_fderiv (by simp)).continuousAt.clm_apply hgrad).div |
| ((hgrad.norm.pow 2).const_add 1).sqrt |
| (Real.sqrt_pos.2 (by positivity : 0<1+‖gradient g y‖^2)).ne' |
| exact hc.integrable_of_hasCompactSupport |
| (hsψ.of_isClosed_subset isClosed_closure (minimalGraphDensity_tsupport g ψ)) |
|
|
| lemma continuous_mul_on_tsupport {f ψ : ℝ → ℝ} (hψ : Continuous ψ) |
| (hf : ∀ s ∈ tsupport ψ, ContinuousAt f s) : Continuous (fun s ↦ f s*ψ s) := by |
| apply continuous_of_tsupport |
| intro s hs |
| exact (hf s (tsupport_mul_subset_right hs)).mul hψ.continuousAt |
|
|
| lemma integrable_mul_on_tsupport {f ψ : ℝ → ℝ} (hψ : Continuous ψ) |
| (hsψ : HasCompactSupport ψ) (hf : ∀ s ∈ tsupport ψ, ContinuousAt f s) : |
| Integrable (fun s ↦ f s*ψ s) := |
| (continuous_mul_on_tsupport hψ hf).integrable_of_hasCompactSupport hsψ.mul_left |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma planarWedgeChart_continuous : Continuous planarWedgeChart := |
| planeProductCoordinates.symm.continuous.comp (continuous_fst.prodMk (continuous_fst.mul continuous_snd)) |
|
|
| lemma slopeScalarTest_support_coordinates {χ ψ : ℝ → ℝ} |
| (hχ0 : 0 ∉ tsupport χ) {y : Plane} (hy : y ∈ tsupport (slopeScalarTest χ ψ)) : |
| (planeProductCoordinates y).1 ∈ tsupport χ ∧ |
| (planeProductCoordinates y).2/(planeProductCoordinates y).1 ∈ tsupport ψ := by |
| have hr : (planeProductCoordinates y).1 ∈ tsupport χ := by |
| by_contra hh |
| have heχ := notMem_tsupport_iff_eventuallyEq.mp hh |
| have he : slopeScalarTest χ ψ =ᶠ[𝓝 y] (fun _ ↦ (0 : ℝ)) := by |
| filter_upwards [(planeProductCoordinates.continuous.fst.tendsto y).eventually heχ] with z hz |
| simp only [slopeScalarTest,hz,Pi.zero_apply,zero_mul] |
| exact notMem_tsupport_iff_eventuallyEq.mpr he hy |
| refine ⟨hr,?_⟩ |
| have hr0 : (planeProductCoordinates y).1≠0 := fun hh ↦ hχ0 (hh ▸ hr) |
| by_contra hh |
| have heψ := notMem_tsupport_iff_eventuallyEq.mp hh |
| have hc : ContinuousAt (fun z : Plane ↦ (planeProductCoordinates z).2/(planeProductCoordinates z).1) y := |
| planeProductCoordinates.continuous.snd.continuousAt.div planeProductCoordinates.continuous.fst.continuousAt hr0 |
| have he : slopeScalarTest χ ψ =ᶠ[𝓝 y] (fun _ ↦ (0 : ℝ)) := by |
| filter_upwards [hc.eventually heψ] with z hz |
| simp only [slopeScalarTest,hz,Pi.zero_apply,mul_zero] |
| exact notMem_tsupport_iff_eventuallyEq.mpr he hy |
|
|
| lemma planarWedgeChart_coordinates_inverse {y : Plane} (hy : (planeProductCoordinates y).1≠0) : |
| planarWedgeChart ((planeProductCoordinates y).1, |
| (planeProductCoordinates y).2/(planeProductCoordinates y).1)=y := by |
| simp only [planarWedgeChart,mul_div_cancel₀ _ hy] |
| exact ContinuousLinearEquiv.symm_apply_apply planeProductCoordinates y |
|
|
| lemma slopeScalarTest_compactSupport {χ ψ : ℝ → ℝ} (hχ0 : 0 ∉ tsupport χ) |
| (hχ : HasCompactSupport χ) (hψ : HasCompactSupport ψ) : |
| HasCompactSupport (slopeScalarTest χ ψ) := by |
| apply ((hχ.prod hψ).image planarWedgeChart_continuous).of_isClosed_subset isClosed_closure |
| intro y hy |
| obtain ⟨hr,hs⟩ := slopeScalarTest_support_coordinates hχ0 hy |
| exact ⟨((planeProductCoordinates y).1,(planeProductCoordinates y).2/(planeProductCoordinates y).1), |
| ⟨hr,hs⟩,planarWedgeChart_coordinates_inverse (fun hh ↦ hχ0 (hh ▸ hr))⟩ |
|
|
| lemma slopeScalarTest_derivative_zero {χ ψ : ℝ → ℝ} {y : Plane} |
| (hy : (planeProductCoordinates y).1 ∉ tsupport χ ∨ |
| (planeProductCoordinates y).2/(planeProductCoordinates y).1 ∉ tsupport ψ) |
| (hχ0 : 0 ∉ tsupport χ) : fderiv ℝ (slopeScalarTest χ ψ) y=0 := by |
| apply fderiv_of_notMem_tsupport |
| intro hh |
| obtain ⟨hr,hs⟩ := slopeScalarTest_support_coordinates hχ0 hh |
| exact hy.elim (fun h ↦ h hr) (fun h ↦ h hs) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma plane_norm_sq_coordinates (v : Plane) : |
| ‖v‖^2=(planeProductCoordinates v).1^2+(planeProductCoordinates v).2^2 := by |
| rw [← real_inner_self_eq_norm_sq,plane_inner_coordinates] |
| ring |
|
|
| lemma exists_smooth_radial_test {a b : ℝ} (hab : a<b) : |
| ∃ χ : ℝ → ℝ, ContDiff ℝ (⊤ : ℕ∞) χ ∧ HasCompactSupport χ ∧ |
| tsupport χ ⊆ Ioo a b ∧ (∫ r : ℝ, χ r)=1 := by |
| let φ : ContDiffBump ((a+b)/2) := |
| ⟨(b-a)/8,(b-a)/4,by linarith,by linarith⟩ |
| refine ⟨φ.normed volume,φ.contDiff_normed,φ.hasCompactSupport_normed,?_,φ.integral_normed⟩ |
| rw [φ.tsupport_normed_eq] |
| intro r hr |
| simp only [Metric.mem_closedBall,Real.dist_eq,abs_le] at hr |
| change -( (b-a)/4) ≤ r-(a+b)/2 ∧ r-(a+b)/2 ≤ (b-a)/4 at hr |
| constructor <;> linarith |
|
|
| lemma minimalGraphDensity_slope {g : Plane → ℝ} {χ ψ f q : ℝ → ℝ} |
| (hχ : ContDiff ℝ (⊤ : ℕ∞) χ) (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) |
| (hχ0 : 0 ∉ tsupport χ) {r s : ℝ} (hr : r≠0) |
| (hg : planeProductCoordinates (gradient g (planarWedgeChart (r,s)))=(f s-s*q s,q s)) : |
| minimalGraphDensity g (slopeScalarTest χ ψ) (planarWedgeChart (r,s)) = |
| deriv χ r*((f s-s*q s)*coneSlopeReciprocalArea f q s*ψ s)+ |
| (χ r/r)*(coneSlopeFlux f q s*deriv ψ s) := by |
| rw [minimalGraphDensity,slopeScalarTest_derivative hχ hψ hχ0 hr, |
| plane_norm_sq_coordinates,hg] |
| dsimp only [Prod.fst,Prod.snd,coneSlopeReciprocalArea,coneSlopeFlux] |
| ring_nf |
|
|
| theorem stationary_euler_graph_affine {g : Plane → ℝ} {a b c d : ℝ} |
| (ha : 0<a) (hab : a<b) |
| (hg : ∀ r ∈ Ioo a b, ∀ s ∈ Ioo c d, DifferentiableAt ℝ g (planarWedgeChart (r,s))) |
| (hC : ∀ r ∈ Ioo a b, ∀ s ∈ Ioo c d, ContinuousAt (fderiv ℝ g) (planarWedgeChart (r,s))) |
| (he : ∀ r ∈ Ioo a b, ∀ s ∈ Ioo c d, |
| fderiv ℝ g (planarWedgeChart (r,s)) (planarWedgeChart (r,s))=g (planarWedgeChart (r,s))) |
| (hw : ∀ Ψ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) Ψ → |
| tsupport Ψ ⊆ planarWedgeChart '' (Ioo a b ×ˢ Ioo c d) → |
| (∫ y : Plane, minimalGraphDensity g Ψ y)=0) |
| {r₀ r x s : ℝ} (hr₀ : r₀ ∈ Ioo a b) (hr : r ∈ Ioo a b) |
| (hx : x ∈ Ioo c d) (hs : s ∈ Ioo c d) : |
| g (planarWedgeChart (r,s)) = |
| r*(g (planarWedgeChart (r₀,x))/r₀+ |
| fderiv ℝ g (planarWedgeChart (r₀,x)) slopeVerticalVector*(s-x)) := by |
| let f : ℝ → ℝ := fun t ↦ g (planarWedgeChart (r₀,t))/r₀ |
| let q : ℝ → ℝ := fun t ↦ fderiv ℝ g (planarWedgeChart (r₀,t)) slopeVerticalVector |
| have hrd : r₀≠0 := (ha.trans hr₀.1).ne' |
| have hfd (t : ℝ) (ht : t ∈ Ioo c d) : HasDerivAt f (q t) t := |
| graph_angular_slice_hasDerivAt hrd (hg r₀ hr₀ t ht) |
| have hqc (t : ℝ) (ht : t ∈ Ioo c d) : ContinuousAt q t := by |
| have hc : ContinuousAt (fun t : ℝ ↦ fderiv ℝ g (planarWedgeChart (r₀,t))) t := |
| (hC r₀ hr₀ t ht).comp (f := fun t : ℝ ↦ planarWedgeChart (r₀,t)) |
| (planarWedgeChart_hasDerivAt_angular r₀ t).continuousAt |
| exact hc.clm_apply continuousAt_const |
| have hfc : ContinuousOn f (Ioo c d) := fun t ht ↦ (hfd t ht).continuousAt.continuousWithinAt |
| have hqC : ContinuousOn q (Ioo c d) := fun t ht ↦ (hqc t ht).continuousWithinAt |
| have hcc := coneSlopeReciprocalArea_continuousOn hfc hqC |
| have hu := hfc.sub (continuousOn_id.mul hqC) |
| have hflux : ContinuousOn (coneSlopeFlux f q) (Ioo c d) := |
| (hqC.sub (continuousOn_id.mul hu)).mul hcc |
| have hweak : ∀ ψ : ℝ → ℝ, ContDiff ℝ (⊤ : ℕ∞) ψ → tsupport ψ ⊆ Ioo c d → |
| (∫ t : ℝ, coneSlopeFlux f q t*deriv ψ t)= |
| (∫ t : ℝ, (f t-t*q t)*coneSlopeReciprocalArea f q t*ψ t) := by |
| intro ψ hψ hsψ |
| obtain ⟨χ,hχ,hχc,hχs,hχi⟩ := exists_smooth_radial_test hab |
| have hχpos : tsupport χ ⊆ Ioi (0 : ℝ) := fun t ht ↦ ha.trans (hχs ht).1 |
| have hχ0 : (0 : ℝ) ∉ tsupport χ := fun hh ↦ (lt_irrefl (0 : ℝ)) (hχpos hh) |
| have hψc : HasCompactSupport ψ := |
| isCompact_Icc.of_isClosed_subset isClosed_closure (hsψ.trans Ioo_subset_Icc_self) |
| let Ψ := slopeScalarTest χ ψ |
| have hΨ := slopeScalarTest_contDiff hχ hψ hχ0 |
| have hΨc := slopeScalarTest_compactSupport hχ0 hχc hψc |
| have hΨs : tsupport Ψ ⊆ planarWedgeChart '' (Ioo a b ×ˢ Ioo c d) := by |
| intro y hy |
| obtain ⟨hr,ht⟩ := slopeScalarTest_support_coordinates hχ0 hy |
| exact ⟨((planeProductCoordinates y).1,(planeProductCoordinates y).2/(planeProductCoordinates y).1), |
| ⟨hχs hr,hsψ ht⟩,planarWedgeChart_coordinates_inverse (fun hh ↦ hχ0 (hh ▸ hr))⟩ |
| have hGi : Integrable (minimalGraphDensity g Ψ) := by |
| apply minimalGraphDensity_integrable hΨ hΨc |
| intro y hy |
| obtain ⟨⟨r,t⟩,⟨hr,ht⟩,rfl⟩ := hΨs hy |
| exact hC r hr t ht |
| have hAi : Integrable (fun t ↦ (f t-t*q t)*coneSlopeReciprocalArea f q t*ψ t) := by |
| apply integrable_mul_on_tsupport hψ.continuous hψc |
| intro t ht |
| exact (hu.mul hcc).continuousAt (isOpen_Ioo.mem_nhds (hsψ ht)) |
| have hBi : Integrable (fun t ↦ coneSlopeFlux f q t*deriv ψ t) := by |
| apply integrable_mul_on_tsupport (hψ.continuous_deriv (by simp)) hψc.deriv |
| intro t ht |
| exact hflux.continuousAt (isOpen_Ioo.mem_nhds (hsψ (tsupport_deriv_subset ht))) |
| have hzero (r : ℝ) (hr : r≤0) (y : ℝ) : |
| minimalGraphDensity g Ψ (planeProductCoordinates.symm (r,y))=0 := by |
| have hz : r ∉ tsupport χ := fun hh ↦ not_lt_of_ge hr (hχpos hh) |
| have hd := slopeScalarTest_derivative_zero (χ := χ) (ψ := ψ) |
| (y := planeProductCoordinates.symm (r,y)) (Or.inl (by simpa using hz)) hχ0 |
| simp only [minimalGraphDensity,Ψ,hd,zero_apply,zero_div] |
| have hid (r : ℝ) (hr : 0<r) (t : ℝ) : |
| minimalGraphDensity g Ψ (planarWedgeChart (r,t)) = |
| deriv χ r*((f t-t*q t)*coneSlopeReciprocalArea f q t*ψ t)+ |
| (χ r/r)*(coneSlopeFlux f q t*deriv ψ t) := by |
| by_cases hrχ : r ∈ tsupport χ |
| · by_cases htψ : t ∈ tsupport ψ |
| · exact minimalGraphDensity_slope hχ hψ hχ0 hr.ne' |
| (euler_graph_gradient ha hg he (hχs hrχ) hr₀ (hsψ htψ)) |
| · have hd := slopeScalarTest_derivative_zero (χ := χ) (ψ := ψ) |
| (y := planarWedgeChart (r,t)) (Or.inr (by simpa [planarWedgeChart,hr.ne'] using htψ)) hχ0 |
| simp only [minimalGraphDensity,Ψ,hd,zero_apply,zero_div, |
| image_eq_zero_of_notMem_tsupport htψ,deriv_of_notMem_tsupport htψ,mul_zero,add_zero] |
| · have hd := slopeScalarTest_derivative_zero (χ := χ) (ψ := ψ) |
| (y := planarWedgeChart (r,t)) (Or.inl (by simpa [planarWedgeChart] using hrχ)) hχ0 |
| simp only [minimalGraphDensity,Ψ,hd,zero_apply,zero_div, |
| image_eq_zero_of_notMem_tsupport hrχ,deriv_of_notMem_tsupport hrχ,zero_mul,zero_div,add_zero] |
| have hi := integral_slope_separated hGi hχ hχc hχpos hAi hBi hzero hid |
| rw [hw Ψ hΨ hΨs,hχi,one_mul] at hi |
| linarith |
| have haf := (weak_cone_slope_affine hfd hqC hweak hx hs).2 |
| have hh := euler_graph_homogeneous ha hg he hr hr₀ hs |
| change g (planarWedgeChart (r,s))/r=f s at hh |
| rw [haf] at hh |
| apply (div_eq_iff (ha.trans hr.1).ne').mp at hh |
| simpa only [f,q,mul_comm] using hh |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def graphReparam (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) (g : Plane → ℝ) : Plane → ℝ := |
| fun y ↦ g (R y-v)+c |
|
|
| lemma graphReparam_fderiv (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) (g : Plane → ℝ) (y : Plane) : |
| fderiv ℝ (graphReparam R v c g) y = |
| (fderiv ℝ g (R y-v)).comp R.toContinuousLinearEquiv.toContinuousLinearMap := by |
| change fderiv ℝ (fun z ↦ g (R z-v)+c) y = _ |
| rw [fderiv_add_const] |
| have he := R.toContinuousLinearEquiv.comp_right_fderiv (f := fun z ↦ g (z-v)) (x := y) |
| simp only [Function.comp_def,sub_eq_add_neg,fderiv_comp_add_right] at he ⊢ |
| exact he |
|
|
| lemma graphReparam_gradient (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) (g : Plane → ℝ) (y : Plane) : |
| gradient (graphReparam R v c g) y=R.symm (gradient g (R y-v)) := by |
| apply ext_inner_right ℝ |
| intro z |
| rw [inner_gradient_left,graphReparam_fderiv,ContinuousLinearMap.comp_apply] |
| rw [← R.inner_map_map, R.apply_symm_apply,inner_gradient_left] |
| rfl |
|
|
| lemma minimalGraphDensity_reparam (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) |
| (g ψ : Plane → ℝ) (y : Plane) : |
| minimalGraphDensity (graphReparam R v c g) (graphReparam R v 0 ψ) y = |
| minimalGraphDensity g ψ (R y-v) := by |
| rw [minimalGraphDensity,graphReparam_fderiv,graphReparam_gradient, |
| ContinuousLinearMap.comp_apply] |
| change fderiv ℝ ψ (R y-v) (R (R.symm (gradient g (R y-v)))) / _ = _ |
| rw [R.apply_symm_apply,R.symm.norm_map] |
| rfl |
|
|
| lemma integral_minimalGraphDensity_reparam (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) |
| (g ψ : Plane → ℝ) : |
| (∫ y : Plane, minimalGraphDensity (graphReparam R v c g) (graphReparam R v 0 ψ) y) = |
| ∫ y : Plane, minimalGraphDensity g ψ y := by |
| simp_rw [minimalGraphDensity_reparam] |
| calc |
| _ = ∫ y : Plane, minimalGraphDensity g ψ (y-v) := |
| R.measurePreserving.integral_comp R.toHomeomorph.toMeasurableEquiv.measurableEmbedding _ |
| _ = _ := integral_sub_right_eq_self _ _ |
|
|
| lemma graphReparam_contDiffAt (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) |
| {g : Plane → ℝ} {y : Plane} (hg : ContDiffAt ℝ 1 g (R y-v)) : |
| ContDiffAt ℝ 1 (graphReparam R v c g) y := by |
| exact (hg.comp y (R.toContinuousLinearEquiv.contDiff.contDiffAt.sub contDiffAt_const)).add contDiffAt_const |
|
|
| lemma graphReparam_contDiff (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (c : ℝ) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) : |
| ContDiff ℝ (⊤ : ℕ∞) (graphReparam R v c g) := |
| (hg.comp (R.toContinuousLinearEquiv.contDiff.sub contDiff_const)).add contDiff_const |
|
|
| lemma graphReparam_zero_tsupport (R : Plane ≃ₗᵢ[ℝ] Plane) (v : Plane) (g : Plane → ℝ) : |
| tsupport (graphReparam R v 0 g) = (fun y ↦ R y-v) ⁻¹' tsupport g := by |
| have he : graphReparam R v 0 g = g ∘ (R.toHomeomorph.trans (Homeomorph.subRight v)) := by |
| ext y |
| simp [graphReparam] |
| rw [he,tsupport_comp_eq_preimage] |
| rfl |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma positive_wedge_rectangle {U : Set Plane} (hU : IsOpen U) {z : Plane} |
| (hz : z ∈ U) (hzp : 0<(planeProductCoordinates z).1) : |
| ∃ a b c d : ℝ, 0<a ∧ |
| (planeProductCoordinates z).1 ∈ Ioo a b ∧ |
| (planeProductCoordinates z).2/(planeProductCoordinates z).1 ∈ Ioo c d ∧ |
| planarWedgeChart '' (Ioo a b ×ˢ Ioo c d) ⊆ U := by |
| let r := (planeProductCoordinates z).1 |
| let s := (planeProductCoordinates z).2/r |
| have hW : planarWedgeChart (r,s)=z := planarWedgeChart_coordinates_inverse hzp.ne' |
| have hu : planarWedgeChart ⁻¹' U ∈ 𝓝 (r,s) := by |
| apply (hU.preimage planarWedgeChart_continuous).mem_nhds |
| simpa only [mem_preimage,hW] using hz |
| obtain ⟨A,hA,B,hB,hAB⟩ := mem_nhds_prod_iff.mp hu |
| obtain ⟨a,b,hrab,hab⟩ := mem_nhds_iff_exists_Ioo_subset.mp hA |
| obtain ⟨c,d,hscd,hcd⟩ := mem_nhds_iff_exists_Ioo_subset.mp hB |
| refine ⟨max a (r/2),b,c,d,lt_max_of_lt_right (by dsimp [r]; linarith), |
| ⟨max_lt hrab.1 (by dsimp [r]; linarith),hrab.2⟩,hscd,?_⟩ |
| rintro _ ⟨⟨u,t⟩,⟨hu,ht⟩,rfl⟩ |
| exact hAB ⟨hab ⟨(le_max_left _ _).trans_lt hu.1,hu.2⟩,hcd ht⟩ |
|
|
| theorem local_euler_graph_linear {U : Set Plane} (hU : IsOpen U) {g : Plane → ℝ} |
| (hg : ∀ y ∈ U, ContDiffAt ℝ 1 g y) |
| (he : ∀ y ∈ U, fderiv ℝ g y y=g y) |
| (hw : ∀ Ψ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) Ψ → tsupport Ψ ⊆ U → |
| (∫ y : Plane, minimalGraphDensity g Ψ y)=0) |
| {z : Plane} (hz : z ∈ U) (hzp : 0<(planeProductCoordinates z).1) : |
| ∀ᶠ y in 𝓝 z, g y=fderiv ℝ g z y := by |
| obtain ⟨a,b,c,d,ha,hr,hs,hW⟩ := positive_wedge_rectangle hU hz hzp |
| let r := (planeProductCoordinates z).1 |
| let s := (planeProductCoordinates z).2/r |
| have hWz : planarWedgeChart (r,s)=z := planarWedgeChart_coordinates_inverse hzp.ne' |
| have hmem (u : ℝ) (hu : u ∈ Ioo a b) (t : ℝ) (ht : t ∈ Ioo c d) : |
| planarWedgeChart (u,t) ∈ U := hW ⟨(u,t),⟨hu,ht⟩,rfl⟩ |
| have hgd (u : ℝ) (hu : u ∈ Ioo a b) (t : ℝ) (ht : t ∈ Ioo c d) := |
| (hg _ (hmem u hu t ht)).differentiableAt (by norm_num) |
| have hgc (u : ℝ) (hu : u ∈ Ioo a b) (t : ℝ) (ht : t ∈ Ioo c d) := |
| (hg _ (hmem u hu t ht)).continuousAt_fderiv (by norm_num) |
| have helin : g z/r=fderiv ℝ g z slopeHorizontalVector+s*fderiv ℝ g z slopeVerticalVector := by |
| have hlin := congrArg (fderiv ℝ g z) (planarWedgeChart_expand r s) |
| rw [hWz,map_add,map_smul,map_smul,smul_eq_mul,smul_eq_mul,he z hz] at hlin |
| apply (div_eq_iff hzp.ne').mpr |
| linarith |
| have hc : ContinuousAt (fun y : Plane ↦ ((planeProductCoordinates y).1, |
| (planeProductCoordinates y).2/(planeProductCoordinates y).1)) z := |
| planeProductCoordinates.continuous.fst.continuousAt.prodMk |
| (planeProductCoordinates.continuous.snd.continuousAt.div |
| planeProductCoordinates.continuous.fst.continuousAt hzp.ne') |
| have hneigh := hc.eventually ((isOpen_Ioo.prod isOpen_Ioo).mem_nhds ⟨hr,hs⟩) |
| filter_upwards [hneigh] with y hy |
| let u := (planeProductCoordinates y).1 |
| let t := (planeProductCoordinates y).2/u |
| have huy : planarWedgeChart (u,t)=y := planarWedgeChart_coordinates_inverse (ha.trans hy.1.1).ne' |
| have hh := stationary_euler_graph_affine ha (hr.1.trans hr.2) hgd hgc |
| (fun u hu t ht ↦ he _ (hmem u hu t ht)) |
| (fun Ψ hΨ hsΨ ↦ hw Ψ hΨ (hsΨ.trans hW)) hr hy.1 hs hy.2 |
| rw [hWz,huy,helin] at hh |
| rw [hh] |
| have hlin := congrArg (fderiv ℝ g z) (planarWedgeChart_expand u t) |
| rw [huy,map_add,map_smul,map_smul,smul_eq_mul,smul_eq_mul] at hlin |
| rw [hlin] |
| ring |
|
|
| theorem local_euler_graph_linear_of_ne_zero {U : Set Plane} (hU : IsOpen U) {g : Plane → ℝ} |
| (hg : ∀ y ∈ U, ContDiffAt ℝ 1 g y) |
| (he : ∀ y ∈ U, fderiv ℝ g y y=g y) |
| (hw : ∀ Ψ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) Ψ → tsupport Ψ ⊆ U → |
| (∫ y : Plane, minimalGraphDensity g Ψ y)=0) |
| {z : Plane} (hz : z ∈ U) (hz0 : z≠0) : |
| ∀ᶠ y in 𝓝 z, g y=fderiv ℝ g z y := by |
| let n : Plane := ‖z‖⁻¹ • z |
| have hzn : 0<‖z‖ := norm_pos_iff.mpr hz0 |
| have hn : ‖n‖=1 := by |
| dsimp only [n] |
| rw [norm_smul,Real.norm_of_nonneg (inv_nonneg.mpr hzn.le),inv_mul_cancel₀ hzn.ne'] |
| let R := planarNormalRotation n |
| let H := graphReparam R 0 0 g |
| have hH (y : Plane) : H y=g (R y) := by simp [H,graphReparam] |
| have hHp : ∀ y ∈ R ⁻¹' U, ContDiffAt ℝ 1 H y := by |
| intro y hy |
| apply graphReparam_contDiffAt |
| simpa only [sub_zero] using hg (R y) hy |
| have hHe : ∀ y ∈ R ⁻¹' U, fderiv ℝ H y y=H y := by |
| intro y hy |
| rw [graphReparam_fderiv] |
| change fderiv ℝ g (R y-0) (R y)=H y |
| simpa only [sub_zero,hH] using he (R y) hy |
| have hHw : ∀ Ψ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) Ψ → tsupport Ψ ⊆ R ⁻¹' U → |
| (∫ y : Plane, minimalGraphDensity H Ψ y)=0 := by |
| intro Ψ hΨ hsΨ |
| let ψ := graphReparam R.symm 0 0 Ψ |
| have hψ := graphReparam_contDiff R.symm 0 0 hΨ |
| have hsψ : tsupport ψ ⊆ U := by |
| rw [graphReparam_zero_tsupport] |
| intro y hy |
| have hh := hsΨ hy |
| simpa only [mem_preimage,sub_zero,R.apply_symm_apply] using hh |
| have hrev : graphReparam R 0 0 ψ=Ψ := by |
| ext y |
| simp only [graphReparam,sub_zero,add_zero,R.symm_apply_apply,ψ] |
| rw [← hrev,integral_minimalGraphDensity_reparam] |
| exact hw ψ hψ hsψ |
| have hzR : R.symm z ∈ R ⁻¹' U := by simpa using hz |
| have hpR : 0<(planeProductCoordinates (R.symm z)).1 := by |
| change 0<(planarWedgeCoordinates ((planarNormalRotation n).symm z)).1 |
| rw [planarNormalRotation_radial hn] |
| dsimp only [n] |
| rw [real_inner_smul_left,real_inner_self_eq_norm_sq] |
| positivity |
| have hlocal := local_euler_graph_linear (hU.preimage R.continuous) hHp hHe hHw hzR hpR |
| have hi := R.symm.continuous.continuousAt.eventually hlocal |
| filter_upwards [hi] with y hy |
| rw [hH,R.apply_symm_apply,graphReparam_fderiv] at hy |
| change g y=fderiv ℝ g (R (R.symm z)-0) (R (R.symm y)) at hy |
| simpa only [R.apply_symm_apply,sub_zero] using hy |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalPlaneEmbedding_inner_coordinates {n : Cover} (hn : ‖n‖=1) (y : Plane) (x : Cover) : |
| ⟪normalPlaneEmbedding n y,x⟫ = ⟪y,normalPlaneCoordinates n x⟫ := by |
| conv_lhs => rhs; rw [← normalPlaneCoordinates_reconstruct hn x] |
| have hz : ⟪normalPlaneEmbedding n y,n⟫=0 := |
| (real_inner_comm _ _).trans (normalPlaneEmbedding_inner hn y) |
| rw [inner_add_right,inner_smul_right,hz,mul_zero,add_zero] |
| exact (normalPlaneLinearIsometry n).inner_map_map y (normalPlaneCoordinates n x) |
|
|
| lemma normalGraph_coordinates_eq_iff {n : Cover} (hn : ‖n‖=1) (g : Plane → ℝ) (x : Cover) : |
| normalGraph n g (normalPlaneCoordinates n x)=x ↔ g (normalPlaneCoordinates n x)=⟪n,x⟫ := by |
| constructor |
| · intro hh |
| simpa only [normalGraph_inner hn] using congrArg (fun v : Cover ↦ ⟪n,v⟫) hh |
| · intro hh |
| rw [normalGraph,hh,normalPlaneCoordinates_reconstruct hn x] |
|
|
| def rebasedGraph (a n : Cover) (g : Plane → ℝ) : Plane → ℝ := |
| graphReparam (LinearIsometryEquiv.refl ℝ Plane) (normalPlaneCoordinates n a) ⟪n,a⟫ g |
|
|
| lemma rebasedGraph_apply (a n : Cover) (g : Plane → ℝ) (y : Plane) : |
| rebasedGraph a n g y=g (y-normalPlaneCoordinates n a)+⟪n,a⟫ := rfl |
|
|
| lemma rebasedGraph_fderiv (a n : Cover) (g : Plane → ℝ) (y : Plane) : |
| fderiv ℝ (rebasedGraph a n g) y=fderiv ℝ g (y-normalPlaneCoordinates n a) := by |
| rw [rebasedGraph,graphReparam_fderiv] |
| ext z |
| rfl |
|
|
| lemma normalGraph_rebased (a : Cover) {n : Cover} (hn : ‖n‖=1) (g : Plane → ℝ) (y : Plane) : |
| normalGraph n (rebasedGraph a n g) y=a+normalGraph n g (y-normalPlaneCoordinates n a) := by |
| have ha := normalPlaneCoordinates_reconstruct hn a |
| simp only [normalGraph,rebasedGraph_apply,add_smul] |
| change normalPlaneLinearIsometry n y+(g (y-normalPlaneCoordinates n a) • n+⟪n,a⟫ • n)= |
| a+(normalPlaneLinearIsometry n (y-normalPlaneCoordinates n a)+g (y-normalPlaneCoordinates n a) • n) |
| rw [map_sub] |
| change normalPlaneLinearIsometry n (normalPlaneCoordinates n a)+⟪n,a⟫ • n=a at ha |
| rw [show normalPlaneLinearIsometry n (normalPlaneCoordinates n a)=a-⟪n,a⟫ • n from |
| eq_sub_iff_add_eq.mpr ha] |
| abel |
|
|
| lemma rebasedGraph_graph_eq (a : Cover) {n : Cover} (hn : ‖n‖=1) (g : Plane → ℝ) (x : Cover) : |
| normalGraph n (rebasedGraph a n g) (normalPlaneCoordinates n x)=x ↔ |
| normalGraph n g (normalPlaneCoordinates n (x-a))=x-a := by |
| rw [normalGraph_rebased a hn,map_sub,eq_sub_iff_add_eq] |
| constructor <;> intro hh <;> simpa only [add_comm] using hh |
|
|
| lemma rebasedGraph_continuous (a n : Cover) {g : Plane → ℝ} (hg : Continuous g) : |
| Continuous (rebasedGraph a n g) := |
| (hg.comp (continuous_id.sub continuous_const)).add continuous_const |
|
|
| lemma rebasedGraph_weak_equation (a : Cover) {n : Cover} (hn : ‖n‖=1) (g : Plane → ℝ) |
| {p : Cover} {ρ : ℝ} (hρ : 0<ρ) |
| (hstat : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → |
| tsupport F ⊆ Metric.closedBall p ρ → |
| (∫ y : Plane, tangentialDivergence F (a+normalGraph n g y) |
| (graphSlopeNormal n (gradient g y))*‖graphAreaVector n g y‖)=0) |
| {Ψ : Plane → ℝ} (hΨ : ContDiff ℝ (⊤ : ℕ∞) Ψ) |
| (hs : ∀ y ∈ tsupport Ψ, normalGraph n (rebasedGraph a n g) y ∈ Metric.ball p (ρ/2)) : |
| (∫ y : Plane, minimalGraphDensity (rebasedGraph a n g) Ψ y)=0 := by |
| let v := normalPlaneCoordinates n a |
| let R := LinearIsometryEquiv.refl ℝ Plane |
| let ψ := graphReparam R (-v) 0 Ψ |
| have hψ := graphReparam_contDiff R (-v) 0 hΨ |
| have hsψ (y : Plane) (hy : y ∈ tsupport ψ) : a+normalGraph n g y ∈ Metric.ball p (ρ/2) := by |
| rw [graphReparam_zero_tsupport] at hy |
| change y-(-v) ∈ tsupport Ψ at hy |
| have hh := hs (y+v) (by simpa only [sub_neg_eq_add] using hy) |
| rw [normalGraph_rebased a hn] at hh |
| simpa only [v,add_sub_cancel_right] using hh |
| have hi := stationary_graph_weak_equation a hn g hρ hstat hψ hsψ |
| simp_rw [graphAreaVector_norm_sqrt hn] at hi |
| have hh : graphReparam R v 0 ψ=Ψ := by |
| ext y |
| simp [graphReparam,ψ,R] |
| rw [← hh] |
| change (∫ y : Plane, minimalGraphDensity (graphReparam R v ⟪n,a⟫ g) (graphReparam R v 0 ψ) y)=0 |
| rw [integral_minimalGraphDensity_reparam] |
| exact hi |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem conical_stationary_patch_plane {A : Set Cover} |
| (hcone : ∀ t : ℝ, 1≤t → ∀ᵐ x ∂(volume : Measure Cover), x ∈ Metric.ball (0 : Cover) 1 → |
| (t⁻¹ • x ∈ A ↔ x ∈ A)) |
| {a n p : Cover} {g : Plane → ℝ} {R ρ : ℝ} |
| (hn : ‖n‖=1) (hg : LipschitzWith (1/4) g) (hρ : 0<ρ) |
| (hC : ∀ y ∈ Metric.closedBall (0 : Plane) R, ContDiffAt ℝ 1 g y) |
| (hRp : p ∈ Metric.ball a R) |
| (hp : p ∈ coverEssentialBoundary A) (hpn : ‖p‖<1) (hp0 : p≠0) |
| (hgraph : ∀ x ∈ Metric.closedBall p (2*ρ), x ∈ coverEssentialBoundary A ↔ |
| normalGraph n g (normalPlaneCoordinates n (x-a))=x-a) |
| (hstat : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → |
| tsupport F ⊆ Metric.closedBall p ρ → |
| (∫ y : Plane, tangentialDivergence F (a+normalGraph n g y) |
| (graphSlopeNormal n (gradient g y))*‖graphAreaVector n g y‖)=0) : |
| ∃ N : Cover, ‖N‖=1 ∧ ∀ᶠ x in 𝓝 p, x ∈ coverEssentialBoundary A ↔ ⟪N,x⟫=0 := by |
| let H := rebasedGraph a n g |
| let v := normalPlaneCoordinates n a |
| let G := normalGraph n H |
| have hHc : Continuous H := rebasedGraph_continuous a n hg.continuous |
| have hGc : Continuous G := |
| (normalPlaneLinearIsometry n).continuous.add (hHc.smul continuous_const) |
| let U : Set Plane := (fun y ↦ y-v) ⁻¹' Metric.ball (0 : Plane) R ∩ |
| G ⁻¹' (Metric.ball p (ρ/2) ∩ Metric.ball (0 : Cover) 1) |
| have hU : IsOpen U := |
| (Metric.isOpen_ball.preimage (continuous_id.sub continuous_const)).inter |
| ((Metric.isOpen_ball.inter Metric.isOpen_ball).preimage hGc) |
| have hHC (y : Plane) (hy : y ∈ U) : ContDiffAt ℝ 1 H y := by |
| apply graphReparam_contDiffAt |
| exact hC _ (Metric.ball_subset_closedBall hy.1) |
| have hbigger (x : Cover) (hx : x ∈ Metric.ball p (ρ/2)) : x ∈ Metric.ball p (2*ρ) := |
| Metric.ball_subset_ball (by linarith) hx |
| have hxp (y : Plane) : normalPlaneCoordinates n (G y)=y := normalPlaneCoordinates_graph hn H y |
| have hEuler (y : Plane) (hy : y ∈ U) : fderiv ℝ H y y=H y := by |
| have hxb := hy.2.1 |
| have hxgraph : normalGraph n g (normalPlaneCoordinates n (G y-a))=G y-a := by |
| apply (rebasedGraph_graph_eq a hn g (G y)).mp |
| rw [hxp] |
| have hxB := (hgraph (G y) (Metric.ball_subset_closedBall (hbigger _ hxb))).mpr hxgraph |
| have hproj : normalPlaneCoordinates n (G y-a)=y-v := by rw [map_sub,hxp] |
| have hgd : DifferentiableAt ℝ g (normalPlaneCoordinates n (G y-a)) := by |
| rw [hproj] |
| exact (hC _ (Metric.ball_subset_closedBall hy.1)).differentiableAt (by norm_num) |
| have hloc : ∀ᶠ x in 𝓝 (G y), x ∈ coverEssentialBoundary A → |
| normalGraph n g (normalPlaneCoordinates n (x-a))=x-a := by |
| filter_upwards [Metric.isOpen_ball.mem_nhds (hbigger _ hxb)] with x hx |
| exact (hgraph x (Metric.ball_subset_closedBall hx)).mp |
| have hr := cone_graph_radial_derivative hcone hn hxB |
| (by simpa only [Metric.mem_ball,dist_zero_right] using hy.2.2) hgd hloc |
| rw [hproj,hxp] at hr |
| rw [rebasedGraph_fderiv] |
| exact hr.trans (normalGraph_inner hn H y) |
| have hweak (Ψ : Plane → ℝ) (hΨ : ContDiff ℝ (⊤ : ℕ∞) Ψ) (hs : tsupport Ψ ⊆ U) : |
| (∫ y : Plane, minimalGraphDensity H Ψ y)=0 := |
| rebasedGraph_weak_equation a hn g hρ hstat hΨ (fun y hy ↦ (hs hy).2.1) |
| have hpclosed : p ∈ Metric.closedBall p (2*ρ) := Metric.mem_closedBall_self (by linarith) |
| have hpG : G (normalPlaneCoordinates n p)=p := |
| (rebasedGraph_graph_eq a hn g p).mpr ((hgraph p hpclosed).mp hp) |
| have hpU : normalPlaneCoordinates n p ∈ U := by |
| refine ⟨?_,?_⟩ |
| · simp only [mem_preimage,v,← map_sub,Metric.mem_ball,dist_zero_right] |
| exact (normalPlaneCoordinates_norm_le n (p-a)).trans_lt (by simpa only [Metric.mem_ball,dist_eq_norm] using hRp) |
| · change G (normalPlaneCoordinates n p) ∈ Metric.ball p (ρ/2) ∩ Metric.ball (0 : Cover) 1 |
| rw [hpG] |
| exact ⟨Metric.mem_ball_self (by positivity),by simpa using hpn⟩ |
| have hpz : normalPlaneCoordinates n p≠0 := by |
| apply cone_graph_radial_projection_ne_zero hn hp0 (L := fderiv ℝ H (normalPlaneCoordinates n p)) |
| have he := hEuler _ hpU |
| have hpheight := congrArg (fun x : Cover ↦ ⟪n,x⟫) hpG |
| rw [normalGraph_inner hn] at hpheight |
| exact he.trans hpheight |
| have hline := local_euler_graph_linear_of_ne_zero hU hHC hEuler hweak hpU hpz |
| let M := n-normalPlaneEmbedding n (gradient H (normalPlaneCoordinates n p)) |
| have hM : 0<‖M‖ := lt_of_lt_of_le (by norm_num : (0 : ℝ)<1) |
| (graphSlopeVector_norm_ge hn (gradient H (normalPlaneCoordinates n p))) |
| let N := ‖M‖⁻¹ • M |
| have hN : ‖N‖=1 := by |
| dsimp only [N] |
| rw [norm_smul,Real.norm_of_nonneg (inv_nonneg.mpr hM.le),inv_mul_cancel₀ hM.ne'] |
| refine ⟨N,hN,?_⟩ |
| have hprojline := (normalPlaneCoordinates n).continuous.continuousAt.eventually hline |
| filter_upwards [hprojline,Metric.ball_mem_nhds p (by positivity : 0<2*ρ)] with x hx hxball |
| rw [hgraph x (Metric.ball_subset_closedBall hxball),← rebasedGraph_graph_eq a hn g, |
| normalGraph_coordinates_eq_iff hn] |
| change H (normalPlaneCoordinates n x)=⟪n,x⟫ ↔ ⟪N,x⟫=0 |
| rw [hx] |
| have hinner : ⟪N,x⟫=‖M‖⁻¹*(⟪n,x⟫-fderiv ℝ H (normalPlaneCoordinates n p) (normalPlaneCoordinates n x)) := by |
| rw [show N=‖M‖⁻¹ • M from rfl,real_inner_smul_left] |
| congr 1 |
| rw [show M=n-normalPlaneEmbedding n (gradient H (normalPlaneCoordinates n p)) from rfl, |
| inner_sub_left,normalPlaneEmbedding_inner_coordinates hn,inner_gradient_left] |
| rw [hinner,mul_eq_zero,inv_eq_zero,or_iff_right hM.ne',sub_eq_zero] |
| exact eq_comm |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma coverEssentialBoundary_isClosed (A : Set Cover) : IsClosed (coverEssentialBoundary A) := by |
| rw [coverEssentialBoundary_eq_support] |
| exact Measure.isClosed_support.inter Measure.isClosed_support |
|
|
| lemma inner_kernel_mono_of_local {n m x : Cover} (hx : ⟪n,x⟫=0) |
| (hlocal : ∀ᶠ y in 𝓝 x, ⟪n,y⟫=0 → ⟪m,y⟫=0) : |
| ∀ v : Cover, ⟪n,v⟫=0 → ⟪m,v⟫=0 := by |
| intro v hv |
| have ht : Tendsto (fun t : ℝ ↦ x+t • v) (𝓝 0) (𝓝 x) := by |
| simpa only [zero_smul,add_zero] using |
| (show Continuous (fun t : ℝ ↦ x+t • v) from |
| continuous_const.add (continuous_id.smul continuous_const)).tendsto (0 : ℝ) |
| have he : (fun t : ℝ ↦ ⟪m,x+t • v⟫) =ᶠ[𝓝 0] (fun _ ↦ (0 : ℝ)) := by |
| filter_upwards [ht.eventually hlocal] with t h |
| exact h (by simp only [inner_add_right,inner_smul_right,hx,hv,mul_zero,add_zero]) |
| have hd : HasDerivAt (fun t : ℝ ↦ ⟪m,x+t • v⟫) ⟪m,v⟫ 0 := by |
| simpa only [inner_add_right,inner_smul_right,id_eq,one_mul] using |
| (((hasDerivAt_id (0 : ℝ)).mul_const ⟪m,v⟫).const_add ⟪m,x⟫) |
| exact hd.unique ((hasDerivAt_const (0 : ℝ) (0 : ℝ)).congr_of_eventuallyEq he) |
|
|
| lemma inner_kernel_eq_of_local {n m x : Cover} (hx : ⟪n,x⟫=0) |
| (hlocal : ∀ᶠ y in 𝓝 x, ⟪n,y⟫=0 ↔ ⟪m,y⟫=0) : |
| ∀ v : Cover, ⟪n,v⟫=0 ↔ ⟪m,v⟫=0 := by |
| have hmx := (hlocal.self_of_nhds).mp hx |
| exact fun v ↦ ⟨inner_kernel_mono_of_local hx (hlocal.mono fun _ h ↦ h.mp) v, |
| inner_kernel_mono_of_local hmx (hlocal.mono fun _ h ↦ h.mpr) v⟩ |
|
|
| lemma normal_plane_disk_preconnected {n : Cover} (hn : ‖n‖=1) : |
| IsPreconnected {x : Cover | ⟪n,x⟫=0 ∧ ‖x‖<1 ∧ x≠0} := by |
| have he : normalPlaneEmbedding n '' (Metric.ball (0 : Plane) 1 \ {0}) = |
| {x : Cover | ⟪n,x⟫=0 ∧ ‖x‖<1 ∧ x≠0} := by |
| ext x |
| constructor |
| · rintro ⟨z,hz,rfl⟩ |
| refine ⟨normalPlaneEmbedding_inner hn z,?_,?_⟩ |
| · rw [normalPlaneEmbedding_norm] |
| simpa only [Metric.mem_ball,dist_zero_right] using hz.1 |
| · intro hh |
| have hhz := congrArg (normalPlaneCoordinates n) hh |
| exact hz.2 (by simpa only [normalPlaneCoordinates_embedding,map_zero,mem_singleton_iff] using hhz) |
| · rintro ⟨hx,hb,h0⟩ |
| have hh : normalPlaneEmbedding n (normalPlaneCoordinates n x)=x := by |
| simpa only [hx,zero_smul,add_zero] using normalPlaneCoordinates_reconstruct hn x |
| refine ⟨normalPlaneCoordinates n x,⟨?_,?_⟩,hh⟩ |
| · simp only [Metric.mem_ball,dist_zero_right] |
| exact (normalPlaneCoordinates_norm_le n x).trans_lt hb |
| · intro hz |
| have hz' : normalPlaneCoordinates n x=0 := hz |
| rw [hz'] at hh |
| have he0 : normalPlaneEmbedding n (0 : Plane)=0 := (normalPlaneLinearIsometry n).map_zero |
| exact h0 (hh.symm.trans he0) |
| rw [← he] |
| exact (planar_punctured_ball_preconnected (by norm_num : (0 : ℝ)<1)).image _ |
| (normalPlaneLinearIsometry n).continuous.continuousOn |
|
|
| theorem local_plane_disk_continuation {B : Set Cover} (hB : IsClosed B) |
| (hloc : ∀ p ∈ B, ‖p‖<1 → p≠0 → |
| ∃ n : Cover, ‖n‖=1 ∧ ∀ᶠ x in 𝓝 p, x∈B ↔ ⟪n,x⟫=0) |
| {n p : Cover} (hn : ‖n‖=1) (hp : p∈B) (hpn : ‖p‖<1) (hp0 : p≠0) |
| (hnloc : ∀ᶠ x in 𝓝 p, x∈B ↔ ⟪n,x⟫=0) : |
| ∀ q : Cover, ⟪n,q⟫=0 → ‖q‖<1 → q≠0 → |
| ∀ᶠ x in 𝓝 q, x∈B ↔ ⟪n,x⟫=0 := by |
| let D : Set Cover := {x | ⟪n,x⟫=0 ∧ ‖x‖<1 ∧ x≠0} |
| let K : Set Cover := {q | ∀ᶠ x in 𝓝 q, x∈B ↔ ⟪n,x⟫=0} |
| have hKo : IsOpen K := isOpen_setOfPred_eventually_nhds |
| have hKc : IsClosed ((Subtype.val : D → Cover) ⁻¹' K) := by |
| rw [← isOpen_compl_iff] |
| apply isOpen_iff_mem_nhds.mpr |
| intro q hq |
| by_cases hqB : (q : Cover)∈B |
| · obtain ⟨m,hm,hmloc⟩ := hloc q hqB q.prop.2.1 q.prop.2.2 |
| let U : Set Cover := {y | ∀ᶠ x in 𝓝 y, x∈B ↔ ⟪m,x⟫=0} |
| have hUo : IsOpen U := isOpen_setOfPred_eventually_nhds |
| have hqU : (q : Cover)∈U := hmloc |
| apply Filter.mem_of_superset ((hUo.preimage continuous_subtype_val).mem_nhds hqU) |
| intro z hz hzK |
| have he : ∀ x : Cover, ⟪n,x⟫=0 ↔ ⟪m,x⟫=0 := |
| inner_kernel_eq_of_local z.prop.1 (hzK.and hz |>.mono fun _ h ↦ h.1.symm.trans h.2) |
| apply hq |
| change ∀ᶠ x in 𝓝 (q : Cover), x∈B ↔ ⟪n,x⟫=0 |
| exact hmloc.mono fun x h ↦ h.trans (he x).symm |
| · apply Filter.mem_of_superset ((hB.isOpen_compl.preimage continuous_subtype_val).mem_nhds hqB) |
| intro z hz hzK |
| exact hz ((hzK.self_of_nhds).mpr z.prop.1) |
| have : PreconnectedSpace D := |
| isPreconnected_iff_preconnectedSpace.mp (normal_plane_disk_preconnected hn) |
| have hpD : p∈D := ⟨(hnloc.self_of_nhds).mp hp,hpn,hp0⟩ |
| have he := (show IsClopen ((Subtype.val : D → Cover) ⁻¹' K) from |
| ⟨hKc,hKo.preimage continuous_subtype_val⟩).eq_univ ⟨⟨p,hpD⟩,hnloc⟩ |
| intro q hqn hqb hq0 |
| have hh : (⟨q,hqn,hqb,hq0⟩ : D)∈(Subtype.val : D → Cover) ⁻¹' K := by rw [he]; trivial |
| exact hh |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma two_cover_planes_meet {n m : Cover} (hn : ‖n‖=1) : |
| ∃ q : Cover, ⟪n,q⟫=0 ∧ ⟪m,q⟫=0 ∧ ‖q‖<1 ∧ q≠0 := by |
| let v := normalPlaneCoordinates n m |
| have hw : ∃ w : Plane, w≠0 ∧ ⟪w,v⟫=0 := by |
| by_cases hv : v=0 |
| · refine ⟨EuclideanSpace.single 0 1,?_,by simp [hv]⟩ |
| intro h |
| have hh := congrArg (fun z : Plane ↦ z 0) h |
| norm_num at hh |
| · exact exists_planar_perpendicular hv |
| obtain ⟨w,hw,hwi⟩ := hw |
| let x := normalPlaneEmbedding n w |
| have hx : 0<‖x‖ := by rw [normalPlaneEmbedding_norm]; exact norm_pos_iff.mpr hw |
| have hnxi : ⟪n,x⟫=0 := normalPlaneEmbedding_inner hn w |
| have hmxi : ⟪m,x⟫=0 := by |
| rw [real_inner_comm] |
| exact (normalPlaneEmbedding_inner_coordinates hn w m).trans hwi |
| let q := ((1/2 : ℝ)*‖x‖⁻¹) • x |
| have hqn : ‖q‖=(1/2 : ℝ) := by |
| rw [norm_smul,Real.norm_of_nonneg (by positivity : 0≤(1/2 : ℝ)*‖x‖⁻¹), |
| mul_assoc,inv_mul_cancel₀ hx.ne',mul_one] |
| refine ⟨q,?_,?_,by rw [hqn]; norm_num,?_⟩ |
| · simp only [q,inner_smul_right,hnxi,mul_zero] |
| · simp only [q,inner_smul_right,hmxi,mul_zero] |
| · intro hh |
| rw [hh,norm_zero] at hqn |
| norm_num at hqn |
|
|
| theorem closed_locally_planar_single_plane {B : Set Cover} (hB : IsClosed B) |
| (hloc : ∀ p ∈ B, ‖p‖<1 → p≠0 → |
| ∃ n : Cover, ‖n‖=1 ∧ ∀ᶠ x in 𝓝 p, x∈B ↔ ⟪n,x⟫=0) |
| {p : Cover} (hp : p∈B) (hpn : ‖p‖<1) (hp0 : p≠0) : |
| ∃ n : Cover, ‖n‖=1 ∧ ∀ x : Cover, ‖x‖<1 → x∈B → ⟪n,x⟫=0 := by |
| obtain ⟨n,hn,hnloc⟩ := hloc p hp hpn hp0 |
| have hnext := local_plane_disk_continuation hB hloc hn hp hpn hp0 hnloc |
| refine ⟨n,hn,?_⟩ |
| intro q hqb hqB |
| by_cases hq0 : q=0 |
| · simp [hq0] |
| obtain ⟨m,hm,hmloc⟩ := hloc q hqB hqb hq0 |
| have hmext := local_plane_disk_continuation hB hloc hm hqB hqb hq0 hmloc |
| obtain ⟨z,hzn,hzm,hzb,hz0⟩ := two_cover_planes_meet (m := m) hn |
| have hnz := hnext z hzn hzb hz0 |
| have hmz := hmext z hzm hzb hz0 |
| have he := inner_kernel_eq_of_local hzn (hnz.and hmz |>.mono fun _ h ↦ h.1.symm.trans h.2) |
| exact (he q).mpr ((hmloc.self_of_nhds).mp hqB) |
|
|
| lemma cover_punctured_ball_preconnected {r : ℝ} (hr : 0<r) : |
| IsPreconnected (Metric.ball (0 : Cover) r \ {0}) := by |
| let f := OpenPartialHomeomorph.univBall (0 : Cover) r |
| have hrank : 1 < Module.rank ℝ Cover := by |
| rw [← Module.finrank_eq_rank] |
| norm_num [Cover] |
| have hc := (isConnected_compl_singleton_of_one_lt_rank hrank (0 : Cover)).isPreconnected |
| have hi : f '' ({0}ᶜ : Set Cover) = Metric.ball (0 : Cover) r \ {0} := by |
| ext y |
| constructor |
| · rintro ⟨x,hx,rfl⟩ |
| refine ⟨?_,?_⟩ |
| · rw [← OpenPartialHomeomorph.univBall_target (0 : Cover) hr] |
| exact f.map_source (by simp [f]) |
| · intro he |
| have he0 : f x=0 := he |
| have hh := congrArg f.symm he0 |
| rw [f.left_inv (by simp [f]),OpenPartialHomeomorph.univBall_symm_apply_center] at hh |
| exact hx hh |
| · rintro ⟨hy,hy0⟩ |
| have hyt : y∈f.target := by rwa [OpenPartialHomeomorph.univBall_target _ hr] |
| refine ⟨f.symm y,?_,f.right_inv hyt⟩ |
| intro hz |
| have hz' : f.symm y=0 := hz |
| have hh := congrArg f hz' |
| rw [f.right_inv hyt,OpenPartialHomeomorph.univBall_apply_zero] at hh |
| exact hy0 hh |
| rw [← hi] |
| exact hc.image f (OpenPartialHomeomorph.continuous_univBall (0 : Cover) r).continuousOn |
|
|
| lemma cover_boundary_nonzero {A : Set Cover} (hA : MeasurableSet A) |
| {r : ℝ} (hr : 0<r) |
| (hpos : 0<volume (Metric.ball (0 : Cover) r ∩ A)) |
| (hneg : 0<volume (Metric.ball (0 : Cover) r ∩ Aᶜ)) : |
| ∃ p : Cover, ‖p‖<r ∧ p≠0 ∧ p∈coverEssentialBoundary A := by |
| by_contra he |
| have hd : Disjoint (Metric.ball (0 : Cover) r \ {0}) (coverEssentialBoundary A) := by |
| rw [Set.disjoint_left] |
| intro x hx hb |
| exact he ⟨x,by simpa only [Metric.mem_ball,dist_zero_right] using hx.1,hx.2,hb⟩ |
| have hnull (B : Set Cover) (h : volume ((Metric.ball (0 : Cover) r \ {0}) ∩ B)=0) : |
| volume (Metric.ball (0 : Cover) r ∩ B)=0 := by |
| apply measure_mono_null (t := ((Metric.ball (0 : Cover) r \ {0}) ∩ B) ∪ {0}) ?_ |
| (measure_union_null h (measure_singleton 0)) |
| intro x hx |
| by_cases hx0 : x=0 |
| · exact Or.inr hx0 |
| · exact Or.inl ⟨⟨hx.1,hx0⟩,hx.2⟩ |
| rcases connected_cover_phase hA (Metric.isOpen_ball.measurableSet.diff (measurableSet_singleton 0)) |
| (cover_punctured_ball_preconnected hr) hd with hh|hh |
| · exact (ne_of_gt hpos) (hnull A hh) |
| · exact (ne_of_gt hneg) (hnull Aᶜ hh) |
|
|
| end CubicTorus |
| end |
| end |
| end |
|
|
| end OAI |
|
|
