| import Mathlib |
| import OAI.Geometry.CubicTorus.Profiles.SiblingCmcSecant |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem sibling_normalGraph_regraph_normal {n m : Cover} (hn : ‖n‖=1) (hm : ‖m‖=1) |
| {g h : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) |
| (hh : ContDiff ℝ (⊤ : ℕ∞) h) (_hg0 : g 0=0) (hh0 : h 0=0) |
| {I : Plane → Plane} (hIc : ContinuousAt I 0) (hI0 : I 0=0) |
| (he : ∀ᶠ y in 𝓝 (0 : Plane),normalGraph m h y=normalGraph n g (I y)) |
| {a : Cover} {N : Cover → Cover} (hN : Continuous N) (hNm : N a=m) |
| {σ : ℝ} (hσ : σ=1 ∨ σ= -1) |
| (hmatch : ∀ᶠ y in 𝓝 (0 : Plane),N (a+normalGraph n g y)=σ • graphSlopeNormal n (gradient g y)) : |
| gradient h 0=0 ∧ |
| ∀ᶠ y in 𝓝 (0 : Plane),N (a+normalGraph m h y)=graphSlopeNormal m (gradient h y) := by |
| let G := normalGraph n g |
| let K := normalGraph m h |
| have hG := normalGraph_contDiff hg (n := n) |
| have hK := normalGraph_contDiff hh (n := m) |
| have hK0 : K 0=0 := by |
| change (normalPlaneLinearIsometry m) 0+h 0 • m=0 |
| rw [map_zero,hh0,zero_smul,add_zero] |
| have hi : Tendsto I (𝓝 (0 : Plane)) (𝓝 (0 : Plane)) := by simpa only [hI0] using hIc.tendsto |
| have he' : ∀ᶠ y in 𝓝 (0 : Plane),G (normalPlaneCoordinates n (K y))=K y := by |
| filter_upwards [he] with y hy |
| change normalGraph n g (normalPlaneCoordinates n (normalGraph m h y))=normalGraph m h y |
| rw [hy,normalPlaneCoordinates_graph hn] |
| have hmt : ∀ᶠ y in 𝓝 (0 : Plane),‖N (a+K y)‖=1 ∧ |
| ∀ w : Plane,⟪N (a+K y),fderiv ℝ K y w⟫=0 := by |
| filter_upwards [he,hi.eventually hmatch,he'.eventually_nhds] with y hy hmy hye |
| have hNy : N (a+K y)=σ • graphSlopeNormal n (gradient g (I y)) := by change N (a+normalGraph m h y)=_; rw [hy]; exact hmy |
| refine ⟨?_,?_⟩ |
| · rw [hNy]; rcases hσ with rfl|rfl <;> simpa only [one_smul,neg_one_smul,norm_neg] using graphSlopeNormal_unit hn _ |
| · intro w |
| have hye' : (fun z ↦ G (normalPlaneCoordinates n (K z)))=ᶠ[𝓝 y] K := hye |
| have hd := hye'.fderiv_eq (𝕜 := ℝ) |
| have hdP := (normalPlaneCoordinates n).hasFDerivAt.comp y (hK.differentiable (by simp) y).hasFDerivAt |
| have hdG := ((hG.differentiable (by simp) _).hasFDerivAt.comp y hdP).fderiv |
| change fderiv ℝ (normalGraph n g ∘ normalPlaneCoordinates n ∘ normalGraph m h) y=fderiv ℝ K y at hd |
| rw [hdG] at hd |
| have hc : normalPlaneCoordinates n (K y)=I y := by change normalPlaneCoordinates n (normalGraph m h y)=_; rw [hy,normalPlaneCoordinates_graph hn] |
| change (fderiv ℝ G (normalPlaneCoordinates n (K y))).comp ((normalPlaneCoordinates n).comp (fderiv ℝ K y)) = fderiv ℝ K y at hd |
| rw [← hd,ContinuousLinearMap.comp_apply,hc,hNy,real_inner_smul_left] |
| rw [normalGraph_tangent_normal hn hg,mul_zero] |
| have htan0 := hmt.self_of_nhds.2 |
| rw [hK0,add_zero,hNm] at htan0 |
| have hgrad := normalGraph_gradient_zero_of_normal hm hh 0 htan0 |
| have hnormal0 : graphSlopeNormal m (gradient h 0)=m := by |
| rw [hgrad,graphSlopeNormal_weight hm] |
| change (cmcWeight 0)⁻¹ • (m-(normalPlaneLinearIsometry m) 0)=m |
| simp [cmcWeight] |
| have hpos : ∀ᶠ y in 𝓝 (0 : Plane),0<⟪graphSlopeNormal m (gradient h y),N (a+K y)⟫ := by |
| have hc : Continuous (fun y : Plane ↦ ⟪graphSlopeNormal m (gradient h y),N (a+K y)⟫) := |
| (((graphSlopeNormal_contDiff hm).comp (plane_gradient_contDiff hh)).continuous.inner |
| (hN.comp (continuous_const.add hK.continuous))) |
| apply hc.continuousAt.eventually (lt_mem_nhds ?_) |
| change 0 < ⟪graphSlopeNormal m (gradient h 0),N (a+K 0)⟫ |
| rw [hK0,add_zero,hNm,hnormal0,real_inner_self_eq_norm_sq,hm,one_pow]; norm_num |
| refine ⟨hgrad,?_⟩ |
| filter_upwards [hmt,hpos] with y hy hpy |
| exact graph_normal_tangent_positive hm hh y hy.1 hy.2 hpy |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem isMinimizerAt_normalized_CMC_chart {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (hae : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| {H : ℝ} (hboundary : ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) → |
| (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H) |
| (a : Cover) (ha : quotientMap a∈frontier (openRepresentative E)) : |
| ∃ f : Plane → ℝ,ContDiff ℝ (⊤ : ℕ∞) f ∧ f 0=0 ∧ gradient f 0=0 ∧ |
| (∀ᶠ y in 𝓝 (0 : Plane), |
| N (a+normalGraph (N a) f y)=graphSlopeNormal (N a) (gradient f y) ∧ |
| quotientMap (a+normalGraph (N a) f y)∈frontier (openRepresentative E) ∧ |
| planeCMC f y= -H) ∧ |
| ∀ᶠ v in 𝓝 (0 : Cover),quotientMap (a+v)∈frontier (openRepresentative E) ↔ |
| normalGraph (N a) f (normalPlaneCoordinates (N a) v)=v := by |
| obtain ⟨n,g,σ,hn,hg,hg0,hσ,hmatch,hcover⟩ := |
| isMinimizerAt_normal_graph_chart hV hE hmin hμ hN hp hae a ha |
| have hm : ‖N a‖=1 := (hboundary a ha).1.self_of_nhds |
| have hgG0 : normalGraph n g 0=0 := by |
| change (normalPlaneLinearIsometry n) 0+g 0 • n=0 |
| rw [map_zero,hg0,zero_smul,add_zero] |
| have hNa : N a=σ • graphSlopeNormal n (gradient g 0) := by |
| simpa only [hgG0,add_zero] using hmatch.self_of_nhds.1 |
| have ht : ⟪graphSlopeNormal n (gradient g 0),N a⟫≠0 := by |
| rw [hNa,real_inner_smul_right,real_inner_self_eq_norm_sq,graphSlopeNormal_unit hn, |
| one_pow,mul_one] |
| rcases hσ with rfl|rfl <;> norm_num |
| obtain ⟨f,I,hf,hf0,hIc,hI0,heq,hcov⟩ := sibling_normalGraph_regraph hn hm hg hg0 ht |
| have hnorm := sibling_normalGraph_regraph_normal hn hm hg hf hg0 hf0 hIc hI0 heq hN.continuous rfl |
| hσ (hmatch.mono (fun _ hy ↦ hy.1)) |
| have hi : Tendsto I (𝓝 (0 : Plane)) (𝓝 (0 : Plane)) := by simpa only [hI0] using hIc.tendsto |
| have hmem : ∀ᶠ y in 𝓝 (0 : Plane), |
| quotientMap (a+normalGraph (N a) f y)∈frontier (openRepresentative E) := by |
| filter_upwards [heq,hi.eventually hmatch] with y hy hm |
| rw [hy] |
| exact hm.2 |
| refine ⟨f,hf,hf0,hnorm.1,?_,?_⟩ |
| · filter_upwards [hnorm.2,hmem,hnorm.2.eventually_nhds] with y hy hmy hny |
| refine ⟨hy,hmy,?_⟩ |
| have hny' : ∀ᶠ z in 𝓝 y,N (a+normalGraph (N a) f z)= |
| (1 : ℝ) • graphSlopeNormal (N a) (gradient f z) := by simpa only [one_smul] using hny |
| have hd := graph_normal_extension_divergence a hm hf y (Or.inl rfl) hN |
| (hboundary _ hmy).1 hny' |
| rw [(hboundary _ hmy).2] at hd |
| change H= -(1 : ℝ)*planeCMC f y at hd |
| linarith |
| · filter_upwards [hcover,hcov] with v hv hc |
| exact hv.trans hc.symm |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalGraph_injective {m : Cover} (hm : ‖m‖=1) (g : Plane → ℝ) : |
| Function.Injective (normalGraph m g) := by |
| intro x y he |
| have hh := congrArg (normalPlaneCoordinates m) he |
| simpa only [normalPlaneCoordinates_graph hm] using hh |
|
|
| lemma normalGraph_height_eq {m : Cover} (hm : ‖m‖=1) {f g : Plane → ℝ} |
| {y : Plane} (he : normalGraph m f y=normalGraph m g y) : f y=g y := by |
| have hh := congrArg (fun v : Cover ↦ ⟪m,v⟫) he |
| simp only [normalGraph,inner_add_right,normalPlaneEmbedding_inner hm, |
| real_inner_smul_right,real_inner_self_eq_norm_sq,hm,one_pow,mul_one,zero_add] at hh |
| exact hh |
|
|
| theorem normal_graph_germ_coincidence {m : Cover} (hm : ‖m‖=1) |
| {f g : Plane → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (hf0 : f 0=0) (hg0 : g 0=0) |
| {B C : Set Cover} |
| (hB : ∀ᶠ v in 𝓝 (0 : Cover),v∈B ↔ normalGraph m f (normalPlaneCoordinates m v)=v) |
| (hC : ∀ᶠ v in 𝓝 (0 : Cover),v∈C ↔ normalGraph m g (normalPlaneCoordinates m v)=v) |
| (hcmc : ∀ᶠ y in 𝓝 (0 : Plane),planeCMC f y=planeCMC g y) |
| (hcl : (0 : Cover)∈closure (B∩{v | ∀ᶠ w in 𝓝 v,w∈B ↔ w∈C})) : |
| f=ᶠ[𝓝 (0 : Plane)]g := by |
| have hF := normalGraph_contDiff hf (n := m) |
| have hG := normalGraph_contDiff hg (n := m) |
| have hF0 : normalGraph m f 0=0 := by |
| change (normalPlaneLinearIsometry m) 0+f 0 • m=0 |
| rw [map_zero,hf0,zero_smul,add_zero] |
| have hG0 : normalGraph m g 0=0 := by |
| change (normalPlaneLinearIsometry m) 0+g 0 • m=0 |
| rw [map_zero,hg0,zero_smul,add_zero] |
| have hFt : Tendsto (normalGraph m f) (𝓝 0) (𝓝 0) := by simpa only [hF0] using (hF.continuous.continuousAt (x := 0)).tendsto |
| have hBC : ∀ᶠ y in 𝓝 (0 : Plane),normalGraph m f y∈B ∧ |
| (normalGraph m f y∈C ↔ normalGraph m g y=normalGraph m f y) := by |
| filter_upwards [hFt.eventually hB,hFt.eventually hC] with y hyB hyC |
| rw [normalPlaneCoordinates_graph hm] at hyB hyC |
| exact ⟨hyB.mpr rfl,hyC⟩ |
| obtain ⟨r,hr,hball⟩ := Metric.mem_nhds_iff.mp (hcmc.and hBC) |
| have hP0 : normalPlaneCoordinates m (0 : Cover)=0 := map_zero _ |
| have hnh : {v : Cover | normalPlaneCoordinates m v∈Metric.ball (0 : Plane) r}∈𝓝 0 := by |
| exact (normalPlaneCoordinates m).continuous.continuousAt.preimage_mem_nhds |
| (by simpa only [hP0] using Metric.ball_mem_nhds (normalPlaneCoordinates m 0) hr) |
| have hex : ((B∩{v | ∀ᶠ w in 𝓝 v,w∈B ↔ w∈C})∩ |
| {v | (v∈B ↔ normalGraph m f (normalPlaneCoordinates m v)=v) ∧ |
| normalPlaneCoordinates m v∈Metric.ball (0 : Plane) r}).Nonempty := by |
| obtain ⟨v,hv₁,hv₂⟩ := mem_closure_iff_nhds.mp hcl _ (hB.and hnh) |
| exact ⟨v,hv₂,hv₁⟩ |
| obtain ⟨v,⟨hvB,hvag⟩,hvch,hvy⟩ := hex |
| let y := normalPlaneCoordinates m v |
| have hFy : normalGraph m f y=v := hvch.mp hvB |
| have hev : ∀ᶠ z in 𝓝 y,normalGraph m f z∈B ↔ normalGraph m f z∈C := |
| (show Tendsto (normalGraph m f) (𝓝 y) (𝓝 v) from by |
| simpa only [hFy] using (hF.continuous.continuousAt (x := y)).tendsto).eventually hvag |
| have hyeq : y∈interior {z | f z=g z} := by |
| apply mem_interior_iff_mem_nhds.mpr |
| filter_upwards [hev,Metric.isOpen_ball.mem_nhds hvy] with z hz hzball |
| have hmem := (hball hzball).2 |
| apply normalGraph_height_eq hm |
| exact ((hmem.2.mp (hz.mp hmem.1))).symm |
| have heq := smooth_CMC_graph_coincidence hf hg Metric.isOpen_ball |
| (convex_ball (0 : Plane) r).isPreconnected (fun _ hz ↦ (hball hz).1) ⟨y,hvy,hyeq⟩ |
| exact Filter.mem_of_superset (Metric.ball_mem_nhds 0 hr) heq |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma isOpenMap_quotientMap : IsOpenMap quotientMap := by |
| have ho : IsOpenMap (Pi.map (fun _ : Fin 3 ↦ fun t : ℝ ↦ (t : AddCircle (1 : ℝ)))) := |
| IsOpenMap.piMap (fun _ ↦ QuotientAddGroup.isOpenMap_coe) |
| (Eventually.of_forall (fun _ ↦ QuotientAddGroup.mk_surjective)) |
| exact (PiLp.homeomorph 2 (fun _ : Fin 3 ↦ AddCircle (1 : ℝ))).symm.isOpenMap.comp |
| (ho.comp (PiLp.homeomorph 2 (fun _ : Fin 3 ↦ ℝ)).isOpenMap) |
|
|
| lemma isOpenMap_shiftedQuotient (a : Cover) : IsOpenMap (fun v ↦ quotientMap (a+v)) := |
| isOpenMap_quotientMap.comp (Homeomorph.addLeft a).isOpenMap |
|
|
| lemma shiftedQuotient_nhds (a : Cover) : |
| Filter.map (fun v ↦ quotientMap (a+v)) (𝓝 (0 : Cover))=𝓝 (quotientMap a) := by |
| simpa only [add_zero] using (isOpenMap_shiftedQuotient a).map_nhds_eq |
| ((continuous_quotientMap.comp (continuous_const.add continuous_id)).continuousAt (x := 0)) |
|
|
| def HasNormalizedCMCCharts (B : Set Torus) (N : Cover → Cover) (H : ℝ) : Prop := |
| ∀ a : Cover,quotientMap a∈B → ‖N a‖=1 ∧ |
| ∃ f : Plane → ℝ,ContDiff ℝ (⊤ : ℕ∞) f ∧ f 0=0 ∧ gradient f 0=0 ∧ |
| (∀ᶠ y in 𝓝 (0 : Plane), |
| N (a+normalGraph (N a) f y)=graphSlopeNormal (N a) (gradient f y) ∧ |
| quotientMap (a+normalGraph (N a) f y)∈B ∧ planeCMC f y= -H) ∧ |
| ∀ᶠ v in 𝓝 (0 : Cover),quotientMap (a+v)∈B ↔ |
| normalGraph (N a) f (normalPlaneCoordinates (N a) v)=v |
|
|
| lemma isMinimizerAt_hasNormalizedCMCCharts {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (hae : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| {H : ℝ} (hboundary : ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) → |
| (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H) : |
| HasNormalizedCMCCharts (frontier (openRepresentative E)) N H := by |
| intro a ha |
| exact ⟨(hboundary a ha).1.self_of_nhds, |
| isMinimizerAt_normalized_CMC_chart hV hE hmin hμ hN hp hae hboundary a ha⟩ |
|
|
| def orientedSurfaceAgreement (B C : Set Torus) (N M : Cover → Cover) : Set Torus := |
| {x | ∀ᶠ y in 𝓝 x,(y∈B ↔ y∈C) ∧ (y∈B → N (representative y)=M (representative y))} |
|
|
| lemma isOpen_orientedSurfaceAgreement (B C : Set Torus) (N M : Cover → Cover) : |
| IsOpen (orientedSurfaceAgreement B C N M) := isOpen_setOfPred_eventually_nhds |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem cmc_strong_minimum {p : Plane → Plane} {f : Plane → ℝ} |
| (hp : ContDiff ℝ (⊤ : ℕ∞) p) (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| {Ω : Set Plane} (hΩ : IsOpen Ω) (hc : IsPreconnected Ω) |
| (hpb : ∀ y∈Ω,‖p y‖≤1) (hpos : ∀ y∈Ω,0≤f y) |
| (hL : ∀ y∈Ω,planeDivergence (fun z ↦ cmcJacobian (p z) (gradient f z)) y=0) |
| {z : Plane} (hz : z∈Ω) (hfz : f z=0) : ∀ y∈Ω,f y=0 := by |
| let O : Set Plane := Ω∩{x | 0<f x} |
| have hO : IsOpen O := hΩ.inter (isOpen_lt continuous_const hf.continuous) |
| by_cases hn : O.Nonempty |
| · have hsub : Ω⊆O := hc.subset_of_closure_inter_subset hO |
| (by obtain ⟨x,hx⟩ := hn; exact ⟨x,hx.1,hx⟩) (by |
| rintro x ⟨hxcl,hxΩ⟩ |
| by_contra hxO |
| obtain ⟨s,hs,hsΩ⟩ := Metric.isOpen_iff.mp hΩ x hxΩ |
| obtain ⟨a,b,R,hR,hbR,hbcl,hbO,hball,hclosed⟩ := |
| plane_interior_tangent_ball_at hO hxcl hxO hs |
| have hbΩ : b∈Ω := hsΩ (hclosed (by |
| simp only [Metric.mem_closedBall,dist_eq_norm,hbR,le_refl])) |
| have hfb : f b=0 := le_antisymm (le_of_not_gt (fun hh ↦ hbO ⟨hbΩ,hh⟩)) (hpos b hbΩ) |
| have hd := cmc_hopf_inward_derivative hp hf hR hbR hfb |
| (fun y hy ↦ hpb y (hsΩ (hclosed hy))) |
| (fun y hy ↦ (hball hy).2) |
| (fun y hy ↦ hL y (hsΩ (hclosed (Metric.ball_subset_closedBall hy)))) |
| have hm : IsLocalMin f b := by |
| filter_upwards [hΩ.mem_nhds hbΩ] with y hy |
| rw [hfb] |
| exact hpos y hy |
| have hzero := hm.fderiv_eq_zero |
| rw [hzero] at hd |
| exact (lt_irrefl (0:ℝ)) hd) |
| have hh := (hsub hz).2 |
| change 0<f z at hh |
| rw [hfz] at hh |
| exact (lt_irrefl (0:ℝ) hh).elim |
| · intro y hy |
| exact le_antisymm (le_of_not_gt (fun hh ↦ hn ⟨y,hy,hh⟩)) (hpos y hy) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def boundaryZeroGerm (S : Set Torus) (F : Torus → ℝ) : Set Torus := |
| {x | ∀ᶠ y in 𝓝 x,y∈S → F y=0} |
|
|
| lemma boundaryZeroGerm_open (S : Set Torus) (F : Torus → ℝ) : |
| IsOpen (boundaryZeroGerm S F) := isOpen_setOfPred_eventually_nhds |
|
|
| lemma CenteredJacobiChart.zero_trace_germ |
| {E : Set Torus} {μ : FiniteMeasure NormalBundle} {N : Cover → Cover} |
| (c : CenteredJacobiChart E μ N) (f : smoothPeriodicScalars) |
| (hz : ∀ᶠ y in 𝓝 (0 : Plane),f.val (c.parameter y)=0) : |
| quotientMap cubeCenter∈boundaryZeroGerm (frontier (openRepresentative E)) |
| (fun x ↦ f.val (representative x)) := by |
| change ∀ᶠ x in 𝓝 (quotientMap cubeCenter),x∈frontier (openRepresentative E) → |
| f.val (representative x)=0 |
| rw [←shiftedQuotient_nhds cubeCenter] |
| change ∀ᶠ v in 𝓝 (0 : Cover),quotientMap (cubeCenter+v)∈frontier (openRepresentative E) → |
| f.val (representative (quotientMap (cubeCenter+v)))=0 |
| have hP : Tendsto (normalPlaneCoordinates c.n) (𝓝 (0 : Cover)) (𝓝 (0 : Plane)) := by |
| simpa only [map_zero] using ((normalPlaneCoordinates c.n).continuous.continuousAt (x := 0)).tendsto |
| filter_upwards [c.cover_germ,hP.eventually hz] with v hv hzv hB |
| rw [periodic_representative f.property.2] |
| have he := hv.mp hB |
| change f.val (cubeCenter+normalGraph c.n c.g (normalPlaneCoordinates c.n v))=0 at hzv |
| rwa [he] at hzv |
|
|
| theorem CenteredJacobiChart.zero_germ_closed |
| {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (haeN : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| (c : CenteredJacobiChart E μ N) |
| (q : Lp ℝ ∞ (μ : Measure NormalBundle)) (f : smoothPeriodicScalars) |
| (hjf : ∀ v∈surfaceH1 μ,surfaceJacobiB μ q (surfaceSmoothJet μ f) v=0) |
| (hjw : ∀ v∈surfaceH1 μ,surfaceJacobiB μ q |
| (surfaceSmoothJet μ (directionalNormalScalar N hN hp c.n)) v=0) |
| (hcl : quotientMap cubeCenter∈closure (frontier (openRepresentative E)∩ |
| boundaryZeroGerm (frontier (openRepresentative E)) (fun x ↦ f.val (representative x)))) : |
| quotientMap cubeCenter∈boundaryZeroGerm (frontier (openRepresentative E)) |
| (fun x ↦ f.val (representative x)) := by |
| let F : Plane → ℝ := fun y ↦ c.weight y*f.val (c.parameter y) |
| let A : Plane → Plane →L[ℝ] Plane := fun y ↦ cmcJacobian (gradient c.g y) |
| let r := c.r/2 |
| have hr : 0<r := half_pos c.r_pos |
| have hF : ContDiff ℝ (⊤ : ℕ∞) F := c.weight_smooth.mul (f.property.1.comp c.parameter_smooth) |
| have hA : ContDiff ℝ (⊤ : ℕ∞) A := cmcJacobian_contDiff.comp (plane_gradient_contDiff c.smooth) |
| have hL := c.classical_ground_state hE hμ hN hp haeN q f hjf hjw |
| have hzero : (Metric.ball (0 : Plane) r∩interior {y | F y=0}).Nonempty := by |
| have hc := c.closure_pullback inter_subset_left hcl hr |
| obtain ⟨y,hy,hy0⟩ := Metric.mem_closure_iff.mp hc r hr |
| refine ⟨y,hy.1,mem_interior_iff_mem_nhds.mpr ?_⟩ |
| have hz := (continuous_quotientMap.comp c.parameter_smooth.continuous).continuousAt.eventually hy.2.2 |
| filter_upwards [hz,Metric.isOpen_ball.mem_nhds hy.1] with z hz hzball |
| have hB := c.boundary_disk z (Metric.ball_subset_closedBall |
| (Metric.ball_subset_ball (by dsimp [r]; linarith [c.r_pos]) hzball)) |
| have he := hz hB |
| simp only [Function.comp_apply,periodic_representative f.property.2] at he |
| change c.weight z*f.val (c.parameter z)=0 |
| rw [he,mul_zero] |
| have hz := plane_elliptic_unique_continuation hA |
| (fun y v w ↦ (cmcJacobian_symmetric _ v w).trans (real_inner_comm _ _)) hF |
| Metric.isOpen_ball (convex_ball (0 : Plane) r).isPreconnected |
| (fun y hy ↦ ⟨1/8,by norm_num,fun v ↦ by |
| have hs := (c.slope_disk y (Metric.ball_subset_closedBall |
| (Metric.ball_subset_ball (by dsimp [r]; linarith [c.r_pos]) hy))).trans (by norm_num : (1/4:ℝ)≤1) |
| simpa only [A,real_inner_comm] using cmcJacobian_coercive hs v⟩) |
| (fun y hy ↦ hL y hy) hzero |
| apply c.zero_trace_germ f |
| filter_upwards [Metric.ball_mem_nhds (0 : Plane) hr] with y hy |
| have he := hz y hy |
| exact (mul_eq_zero.mp he).resolve_left (cmcWeight_pos _).ne' |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def sibling_smoothScalarTranslate (a : Cover) (f : smoothPeriodicScalars) : smoothPeriodicScalars := |
| ⟨fun x ↦ f.val (x+a),f.property.1.comp (contDiff_id.add contDiff_const),by |
| intro m x |
| dsimp |
| rw [add_right_comm,f.property.2]⟩ |
|
|
| lemma smoothScalarTranslate_gradient (a : Cover) (f : smoothPeriodicScalars) (x : Cover) : |
| gradient (sibling_smoothScalarTranslate a f).val x=gradient f.val (x+a) := by |
| have he : fderiv ℝ (sibling_smoothScalarTranslate a f).val x=fderiv ℝ f.val (x+a) := by |
| have hd := (f.property.1.differentiable (by simp) (x+a)).hasFDerivAt.comp x |
| ((hasFDerivAt_id x).add_const a) |
| simpa only [ContinuousLinearMap.comp_id,Function.comp_def,id_eq,sibling_smoothScalarTranslate] using hd.fderiv |
| simp only [gradient,he] |
|
|
| lemma sibling_translateNormal_measurePreserving (μ : FiniteMeasure NormalBundle) (a : Cover) : |
| MeasurePreserving (translateNormal a) (μ : Measure NormalBundle) |
| (μ.map (translateNormal a) : Measure NormalBundle) := |
| ⟨measurable_translateNormal a,rfl⟩ |
|
|
| def normalTranslatePullback (μ : FiniteMeasure NormalBundle) (a : Cover) (W : Type*) |
| [NormedAddCommGroup W] [NormedSpace ℝ W] : |
| Lp W 2 (μ.map (translateNormal a) : Measure NormalBundle) →ₗᵢ[ℝ] |
| Lp W 2 (μ : Measure NormalBundle) := |
| Lp.compMeasurePreservingₗᵢ ℝ (translateNormal a) (sibling_translateNormal_measurePreserving μ a) |
|
|
| def normalTranslateJet (μ : FiniteMeasure NormalBundle) (a : Cover) : |
| SurfaceJet (μ.map (translateNormal a)) →L[ℝ] SurfaceJet μ := |
| (normalTranslatePullback μ a ℝ).toContinuousLinearMap.prodMap |
| (normalTranslatePullback μ a Cover).toContinuousLinearMap |
|
|
| lemma normalTranslateJet_ae (μ : FiniteMeasure NormalBundle) (a : Cover) |
| (u : SurfaceJet (μ.map (translateNormal a))) : |
| ∀ᵐ z ∂(μ : Measure NormalBundle), |
| (normalTranslateJet μ a u).1 z=u.1 (translateNormal a z) ∧ |
| (normalTranslateJet μ a u).2 z=u.2 (translateNormal a z) := |
| (Lp.coeFn_compMeasurePreserving u.1 (sibling_translateNormal_measurePreserving μ a)).and |
| (Lp.coeFn_compMeasurePreserving u.2 (sibling_translateNormal_measurePreserving μ a)) |
|
|
| lemma normalTranslateJet_smooth (μ : FiniteMeasure NormalBundle) (a : Cover) |
| (f : smoothPeriodicScalars) : |
| normalTranslateJet μ a (surfaceSmoothJet (μ.map (translateNormal a)) f)= |
| surfaceSmoothJet μ (sibling_smoothScalarTranslate (-a) f) := by |
| have hscalar := ae_of_ae_map (measurable_translateNormal a).aemeasurable |
| ((smoothScalarValue f).coeFn_toLp (p := 2) (𝕜 := ℝ) |
| (μ.map (translateNormal a) : Measure NormalBundle)) |
| have hgrad := ae_of_ae_map (measurable_translateNormal a).aemeasurable |
| ((smoothScalarGradient f).coeFn_toLp (p := 2) (𝕜 := ℝ) |
| (μ.map (translateNormal a) : Measure NormalBundle)) |
| apply Prod.ext |
| · apply Lp.ext |
| filter_upwards [normalTranslateJet_ae μ a (surfaceSmoothJet (μ.map (translateNormal a)) f), |
| hscalar,(smoothScalarValue (sibling_smoothScalarTranslate (-a) f)).coeFn_toLp |
| (p := 2) (𝕜 := ℝ) (μ : Measure NormalBundle)] with z hz h₁ h₂ |
| rw [hz.1] |
| change (surfaceSmoothJet (μ.map (translateNormal a)) f).1 (translateNormal a z)= |
| f.val (translateNormal a z).1 at h₁ |
| change (surfaceSmoothJet μ (sibling_smoothScalarTranslate (-a) f)).1 z=f.val ((z.1 : Cover)+(-a)) at h₂ |
| rw [h₁,h₂,translateNormal_periodic_eval f.property.2] |
| rfl |
| · apply Lp.ext |
| filter_upwards [normalTranslateJet_ae μ a (surfaceSmoothJet (μ.map (translateNormal a)) f), |
| hgrad,(smoothScalarGradient (sibling_smoothScalarTranslate (-a) f)).coeFn_toLp |
| (p := 2) (𝕜 := ℝ) (μ : Measure NormalBundle)] with z hz h₁ h₂ |
| rw [hz.2] |
| change (surfaceSmoothJet (μ.map (translateNormal a)) f).2 (translateNormal a z)= |
| smoothScalarGradient f (translateNormal a z) at h₁ |
| change (surfaceSmoothJet μ (sibling_smoothScalarTranslate (-a) f)).2 z= |
| smoothScalarGradient (sibling_smoothScalarTranslate (-a) f) z at h₂ |
| rw [h₁,h₂] |
| change gradient f.val (translateNormal a z).1- |
| ⟪(z.2 : Cover),gradient f.val (translateNormal a z).1⟫ • (z.2 : Cover)=_ |
| rw [translateNormal_periodic_eval (gradient_periodic f.property.2)] |
| change _=gradient (sibling_smoothScalarTranslate (-a) f).val z.1- |
| ⟪(z.2 : Cover),gradient (sibling_smoothScalarTranslate (-a) f).val z.1⟫ • (z.2 : Cover) |
| rw [smoothScalarTranslate_gradient] |
| rfl |
|
|
| lemma normalTranslateJet_mem_surfaceH1 (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {u : SurfaceJet (μ.map (translateNormal a))} (hu : u∈surfaceH1 (μ.map (translateNormal a))) : |
| normalTranslateJet μ a u∈surfaceH1 μ := by |
| have hc : IsClosed ((normalTranslateJet μ a) ⁻¹' (surfaceH1 μ : Set (SurfaceJet μ))) := |
| (show IsClosed (surfaceH1 μ : Set (SurfaceJet μ)) from isClosed_closure).preimage |
| (normalTranslateJet μ a).continuous |
| apply closure_minimal (t := (normalTranslateJet μ a) ⁻¹' (surfaceH1 μ : Set (SurfaceJet μ))) ?_ hc hu |
| rintro _ ⟨f,rfl⟩ |
| change normalTranslateJet μ a (surfaceSmoothJet (μ.map (translateNormal a)) f)∈surfaceH1 μ |
| rw [normalTranslateJet_smooth] |
| exact subset_closure (LinearMap.mem_range_self _ _) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalTranslate_multiplier (μ : FiniteMeasure NormalBundle) (a : Cover) |
| (q : Lp ℝ ∞ (μ : Measure NormalBundle)) |
| (q' : Lp ℝ ∞ (μ.map (translateNormal a) : Measure NormalBundle)) |
| (hq : ∀ᵐ z ∂(μ : Measure NormalBundle),q' (translateNormal a z)=q z) |
| (u : Lp ℝ 2 (μ.map (translateNormal a) : Measure NormalBundle)) : |
| normalTranslatePullback μ a ℝ (surfaceMultiplier _ q' u)= |
| surfaceMultiplier μ q (normalTranslatePullback μ a ℝ u) := by |
| apply Lp.ext |
| have hm := ae_of_ae_map (measurable_translateNormal a).aemeasurable |
| (Lp.coeFn_lpSMul (r := 2) q' u) |
| filter_upwards [Lp.coeFn_compMeasurePreserving (surfaceMultiplier _ q' u) |
| (sibling_translateNormal_measurePreserving μ a), |
| Lp.coeFn_compMeasurePreserving u (sibling_translateNormal_measurePreserving μ a), |
| Lp.coeFn_lpSMul (r := 2) q (normalTranslatePullback μ a ℝ u),hm,hq] with z hz hu hv hm hq |
| change (normalTranslatePullback μ a ℝ (surfaceMultiplier _ q' u)) z=_ at hz |
| change (normalTranslatePullback μ a ℝ u) z=_ at hu |
| change (surfaceMultiplier _ q (normalTranslatePullback μ a ℝ u)) z=_ at hv |
| change (surfaceMultiplier _ q' u) (translateNormal a z)=_ at hm |
| rw [hz] |
| simp only [Function.comp_apply] |
| rw [hm,hv] |
| simp only [smul_eq_mul,Pi.mul_apply,hq,hu,Function.comp_apply] |
|
|
| lemma normalTranslate_Jacobi (μ : FiniteMeasure NormalBundle) (a : Cover) |
| (q : Lp ℝ ∞ (μ : Measure NormalBundle)) |
| (q' : Lp ℝ ∞ (μ.map (translateNormal a) : Measure NormalBundle)) |
| (hq : ∀ᵐ z ∂(μ : Measure NormalBundle),q' (translateNormal a z)=q z) |
| (u v : SurfaceJet (μ.map (translateNormal a))) : |
| surfaceJacobiB μ q (normalTranslateJet μ a u) (normalTranslateJet μ a v)= |
| surfaceJacobiB (μ.map (translateNormal a)) q' u v := by |
| change ⟪normalTranslatePullback μ a Cover u.2,normalTranslatePullback μ a Cover v.2⟫- |
| ⟪surfaceMultiplier μ q (normalTranslatePullback μ a ℝ u.1), |
| normalTranslatePullback μ a ℝ v.1⟫=_ |
| rw [← normalTranslate_multiplier μ a q q' hq u.1, |
| (normalTranslatePullback μ a Cover).inner_map_map, |
| (normalTranslatePullback μ a ℝ).inner_map_map] |
| rfl |
|
|
| lemma normalTranslate_one (μ : FiniteMeasure NormalBundle) (a : Cover) : |
| normalTranslateJet μ a (surfaceOne (μ.map (translateNormal a)))=surfaceOne μ := by |
| rw [surfaceOne,normalTranslateJet_smooth] |
| rfl |
|
|
| lemma normalTranslate_mean (μ : FiniteMeasure NormalBundle) (a : Cover) |
| (u : SurfaceJet (μ.map (translateNormal a))) : |
| surfaceMean μ (normalTranslateJet μ a u)=surfaceMean (μ.map (translateNormal a)) u := by |
| change ⟪(surfaceOne μ).1,normalTranslatePullback μ a ℝ u.1⟫=_ |
| have h := congrArg Prod.fst (normalTranslate_one μ a) |
| change normalTranslatePullback μ a ℝ (surfaceOne (μ.map (translateNormal a))).1=(surfaceOne μ).1 at h |
| rw [← h,(normalTranslatePullback μ a ℝ).inner_map_map] |
| rfl |
|
|
| def normalTranslateField (a : Cover) (N : Cover → Cover) : Cover → Cover := fun x ↦ N (x+a) |
|
|
| lemma normalTranslateField_smooth (a : Cover) {N : Cover → Cover} |
| (hN : ContDiff ℝ (⊤ : ℕ∞) N) : ContDiff ℝ (⊤ : ℕ∞) (normalTranslateField a N) := |
| hN.comp (contDiff_id.add contDiff_const) |
|
|
| lemma normalTranslateField_periodic (a : Cover) {N : Cover → Cover} |
| (hp : ∀ m x,N (x+latticeVector m)=N x) : |
| ∀ m x,normalTranslateField a N (x+latticeVector m)=normalTranslateField a N x := by |
| intro m x |
| dsimp [normalTranslateField] |
| rw [add_right_comm,hp] |
|
|
| lemma normalTranslateField_fderiv (a : Cover) {N : Cover → Cover} |
| (hN : ContDiff ℝ (⊤ : ℕ∞) N) (x : Cover) : |
| fderiv ℝ (normalTranslateField a N) x=fderiv ℝ N (x+a) := by |
| have hd := (hN.differentiable (by simp) (x+a)).hasFDerivAt.comp x |
| ((hasFDerivAt_id x).add_const a) |
| change fderiv ℝ (fun y : Cover ↦ N (y+a)) x=_ |
| simpa only [ContinuousLinearMap.comp_id,Function.comp_def,id_eq] using hd.fderiv |
|
|
| lemma normalTranslate_curvature (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) : |
| ∀ᵐ z ∂(μ : Measure NormalBundle), |
| surfaceCurvatureLp (μ.map (translateNormal a)) (normalTranslateField a N) |
| (normalTranslateField_smooth a hN) (translateNormal a z)=surfaceCurvatureLp μ N hN z := by |
| have hq := (show C(NormalBundle,ℝ) from ⟨_, |
| (normal_curvature_continuous hN).comp (continuous_subtype_val.comp continuous_fst)⟩).coeFn_toLp |
| (p := ∞) (𝕜 := ℝ) (μ : Measure NormalBundle) |
| have hq' := (show C(NormalBundle,ℝ) from ⟨_, |
| (normal_curvature_continuous (normalTranslateField_smooth a hN)).comp |
| (continuous_subtype_val.comp continuous_fst)⟩).coeFn_toLp |
| (p := ∞) (𝕜 := ℝ) (μ.map (translateNormal a) : Measure NormalBundle) |
| have he := ae_of_ae_map (measurable_translateNormal a).aemeasurable hq' |
| filter_upwards [hq,he] with z hz hz' |
| change surfaceCurvatureLp μ N hN z=_ at hz |
| change surfaceCurvatureLp (μ.map (translateNormal a)) (normalTranslateField a N) |
| (normalTranslateField_smooth a hN) (translateNormal a z)=_ at hz' |
| rw [hz,hz'] |
| change coverTrace ((fderiv ℝ (normalTranslateField a N) (translateNormal a z).1).comp |
| (fderiv ℝ (normalTranslateField a N) (translateNormal a z).1))= |
| coverTrace ((fderiv ℝ N z.1).comp (fderiv ℝ N z.1)) |
| have hper := fderiv_periodic (normalTranslateField_periodic a hp) |
| rw [translateNormal_periodic_eval hper,normalTranslateField_fderiv a hN] |
| simp only [sub_add_cancel] |
|
|
| lemma normalTranslate_smooth_inverse (a : Cover) (f : smoothPeriodicScalars) : |
| sibling_smoothScalarTranslate (-a) (sibling_smoothScalarTranslate a f)=f := by |
| apply Subtype.ext |
| funext x |
| simp only [sibling_smoothScalarTranslate,neg_add_cancel_right] |
|
|
| lemma normalTranslate_directional (a : Cover) {N : Cover → Cover} |
| (hN : ContDiff ℝ (⊤ : ℕ∞) N) (hp : ∀ m x,N (x+latticeVector m)=N x) (v : Cover) : |
| directionalNormalScalar (normalTranslateField a N) (normalTranslateField_smooth a hN) |
| (normalTranslateField_periodic a hp) v=sibling_smoothScalarTranslate a (directionalNormalScalar N hN hp v) := by |
| apply Subtype.ext |
| funext x |
| change _=(directionalNormalScalar N hN hp v).val (x+a) |
| rw [directionalNormalScalar_apply,directionalNormalScalar_apply] |
| rfl |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalTranslateJet_isometry (μ : FiniteMeasure NormalBundle) (a : Cover) : |
| Isometry (normalTranslateJet μ a) := by |
| apply AddMonoidHomClass.isometry_of_norm (normalTranslateJet μ a) |
| intro u |
| change max ‖normalTranslatePullback μ a ℝ u.1‖ ‖normalTranslatePullback μ a Cover u.2‖= |
| max ‖u.1‖ ‖u.2‖ |
| rw [(normalTranslatePullback μ a ℝ).norm_map,(normalTranslatePullback μ a Cover).norm_map] |
|
|
| lemma normalTranslateJet_surjective_H1 (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {u : SurfaceJet μ} (hu : u∈surfaceH1 μ) : |
| ∃ u' : SurfaceJet (μ.map (translateNormal a)),u'∈surfaceH1 (μ.map (translateNormal a)) ∧ |
| normalTranslateJet μ a u'=u := by |
| have hc : IsClosed ((normalTranslateJet μ a) '' |
| (surfaceH1 (μ.map (translateNormal a)) : Set (SurfaceJet (μ.map (translateNormal a))))) := |
| (normalTranslateJet_isometry μ a).isClosedEmbedding.isClosedMap _ isClosed_closure |
| apply closure_minimal (t := (normalTranslateJet μ a) '' |
| (surfaceH1 (μ.map (translateNormal a)) : Set (SurfaceJet (μ.map (translateNormal a))))) ?_ hc hu |
| rintro _ ⟨f,rfl⟩ |
| refine ⟨surfaceSmoothJet (μ.map (translateNormal a)) (sibling_smoothScalarTranslate a f), |
| subset_closure (LinearMap.mem_range_self _ _),?_⟩ |
| rw [normalTranslateJet_smooth,normalTranslate_smooth_inverse] |
|
|
| lemma sibling_normalProjection_translate (a : Cover) (z : NormalBundle) : |
| normalProjection (translateNormal a z)+quotientMap a=normalProjection z := by |
| change quotientMap (representative (quotientMap z.1-quotientMap a))+quotientMap a=quotientMap z.1 |
| rw [quotientMap_representative,sub_add_cancel] |
|
|
| lemma normalTranslateField_ae (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {N : Cover → Cover} (hN : Continuous N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (hae : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) : |
| ∀ᵐ z ∂(μ.map (translateNormal a) : Measure NormalBundle), |
| normalTranslateField a N z.1=(z.2 : Cover) := by |
| apply (ae_map_iff (measurable_translateNormal a).aemeasurable |
| (measurableSet_eq_fun ((hN.comp (continuous_id.add continuous_const)).measurable.comp |
| (measurable_subtype_coe.comp measurable_fst)) |
| (measurable_subtype_coe.comp measurable_snd))).mpr |
| filter_upwards [hae] with z hz |
| change normalTranslateField a N (translateNormal a z).1=(z.2 : Cover) |
| rw [translateNormal_periodic_eval (normalTranslateField_periodic a hp)] |
| simpa only [normalTranslateField,sub_add_cancel] using hz |
|
|
| lemma normalTranslateJet_scalar_representative (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {u : SurfaceJet μ} {u' : SurfaceJet (μ.map (translateNormal a))} |
| (he : normalTranslateJet μ a u'=u) {F : Torus → ℝ} (hF : Measurable F) |
| (hae : ∀ᵐ z ∂(μ : Measure NormalBundle),u.1 z=F (normalProjection z)) : |
| ∀ᵐ z ∂(μ.map (translateNormal a) : Measure NormalBundle), |
| u'.1 z=F (normalProjection z+quotientMap a) := by |
| apply (ae_map_iff (measurable_translateNormal a).aemeasurable |
| (measurableSet_eq_fun (Lp.stronglyMeasurable u'.1).measurable |
| (hF.comp (normalProjection_continuous.measurable.add measurable_const)))).mpr |
| filter_upwards [normalTranslateJet_ae μ a u',hae] with z hz hf |
| rw [he] at hz |
| change u'.1 (translateNormal a z)=F (normalProjection (translateNormal a z)+quotientMap a) |
| rw [← hz.1,hf,sibling_normalProjection_translate] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma smoothScalarTranslate_descent (a : Cover) (f : smoothPeriodicScalars) (b : Torus) : |
| (sibling_smoothScalarTranslate a f).val (representative b)= |
| f.val (representative (b+quotientMap a)) := by |
| have h := periodic_representative f.property.2 (representative b+a) |
| rw [quotientMap_add,quotientMap_representative] at h |
| exact h.symm |
|
|
| lemma positiveNodalPiece_translation (a : Cover) (f : smoothPeriodicScalars) |
| {S D : Set Torus} (hD : IsPositiveNodalPiece f S D) : |
| IsPositiveNodalPiece (sibling_smoothScalarTranslate a f) |
| ((fun b ↦ b+quotientMap a) ⁻¹' S) ((fun b ↦ b+quotientMap a) ⁻¹' D) := by |
| obtain ⟨⟨U,hU,hDU⟩,⟨C,hC,hDC⟩⟩ := hD |
| constructor |
| · refine ⟨(fun b ↦ b+quotientMap a) ⁻¹' U,hU.preimage (continuous_id.add continuous_const),?_⟩ |
| ext b |
| simp only [mem_preimage,hDU,mem_inter_iff,mem_ofPred_eq,smoothScalarTranslate_descent] |
| · refine ⟨(fun b ↦ b+quotientMap a) ⁻¹' C,hC.preimage (continuous_id.add continuous_const),?_⟩ |
| ext b |
| simp only [mem_preimage,hDC,mem_inter_iff,mem_ofPred_eq,smoothScalarTranslate_descent] |
|
|
| lemma normalTranslate_weakJacobi (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| {u : SurfaceJet μ} (hju : ∀ v∈surfaceH1 μ,surfaceJacobiB μ (surfaceCurvatureLp μ N hN) u v=0) |
| {u' : SurfaceJet (μ.map (translateNormal a))} (he : normalTranslateJet μ a u'=u) : |
| ∀ v∈surfaceH1 (μ.map (translateNormal a)),surfaceJacobiB (μ.map (translateNormal a)) |
| (surfaceCurvatureLp _ (normalTranslateField a N) (normalTranslateField_smooth a hN)) u' v=0 := by |
| intro v hv |
| rw [← normalTranslate_Jacobi μ a _ _ (normalTranslate_curvature μ a hN hp),he] |
| exact hju _ (normalTranslateJet_mem_surfaceH1 μ a hv) |
|
|
| lemma normalTranslate_smooth_weakJacobi (μ : FiniteMeasure NormalBundle) (a : Cover) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) (f : smoothPeriodicScalars) |
| (hj : ∀ v∈surfaceH1 μ,surfaceJacobiB μ (surfaceCurvatureLp μ N hN) |
| (surfaceSmoothJet μ f) v=0) : |
| ∀ v∈surfaceH1 (μ.map (translateNormal a)),surfaceJacobiB (μ.map (translateNormal a)) |
| (surfaceCurvatureLp _ (normalTranslateField a N) (normalTranslateField_smooth a hN)) |
| (surfaceSmoothJet _ (sibling_smoothScalarTranslate a f)) v=0 := by |
| apply normalTranslate_weakJacobi μ a hN hp hj |
| rw [normalTranslateJet_smooth,normalTranslate_smooth_inverse] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem orientedSurfaceAgreement_closed_at {B C : Set Torus} (hC : IsClosed C) |
| {N M : Cover → Cover} (hN : Continuous N) (hM : Continuous M) |
| (hpN : ∀ m x,N (x+latticeVector m)=N x) |
| (hpM : ∀ m x,M (x+latticeVector m)=M x) |
| {H : ℝ} (hBch : HasNormalizedCMCCharts B N H) (hCch : HasNormalizedCMCCharts C M H) |
| {x : Torus} (hxB : x∈B) (hx : x∈closure (B∩orientedSurfaceAgreement B C N M)) : |
| x∈orientedSurfaceAgreement B C N M := by |
| have hclosed : IsClosed {y : Torus | y∈C ∧ N (representative y)=M (representative y)} := |
| hC.inter (isClosed_eq (continuous_periodic_descent hN hpN) (continuous_periodic_descent hM hpM)) |
| have hxc : x∈C ∧ N (representative x)=M (representative x) := |
| closure_minimal (fun y hy ↦ by |
| have hy' := hy.2.self_of_nhds |
| exact ⟨hy'.1.mp hy.1,hy'.2 hy.1⟩) hclosed hx |
| obtain ⟨a,rfl⟩ := quotientMap_surjective x |
| have hNM : N a=M a := by simpa only [periodic_representative hpN,periodic_representative hpM] using hxc.2 |
| obtain ⟨hn,f,hf,hf0,hdf0,hfm,hfc⟩ := hBch a hxB |
| obtain ⟨_,g,hg,hg0,hdg0,hgm,hgc⟩ := hCch a hxc.1 |
| rw [←hNM] at hgm hgc |
| let q : Cover → Torus := fun v ↦ quotientMap (a+v) |
| have hq : Continuous q := continuous_quotientMap.comp (continuous_const.add continuous_id) |
| have hq0 : q 0=quotientMap a := by simp only [q,add_zero] |
| have hcl : (0 : Cover)∈closure |
| (q ⁻¹' B∩{v : Cover | ∀ᶠ w in 𝓝 v,w∈q ⁻¹' B ↔ w∈q ⁻¹' C}) := by |
| apply closure_mono (show q ⁻¹' (B∩orientedSurfaceAgreement B C N M)⊆ |
| q ⁻¹' B∩{v : Cover | ∀ᶠ w in 𝓝 v,w∈q ⁻¹' B ↔ w∈q ⁻¹' C} from ?_) ?_ |
| · intro v hv |
| refine ⟨hv.1,?_⟩ |
| exact (hq.continuousAt.eventually hv.2).mono (fun _ hy ↦ hy.1) |
| · exact (isOpenMap_shiftedQuotient a).preimage_closure_subset_closure_preimage |
| (by change q 0∈closure (B∩orientedSurfaceAgreement B C N M); rwa [hq0]) |
| have hfg : f=ᶠ[𝓝 (0 : Plane)]g := normal_graph_germ_coincidence hn hf hg hf0 hg0 hfc hgc |
| (by filter_upwards [hfm,hgm] with y hfy hgy; exact hfy.2.2.trans hgy.2.2.symm) hcl |
| have hPc : Tendsto (normalPlaneCoordinates (N a)) (𝓝 (0 : Cover)) (𝓝 (0 : Plane)) := by |
| simpa only [map_zero] using ((normalPlaneCoordinates (N a)).continuous.continuousAt (x := 0)).tendsto |
| change ∀ᶠ y in 𝓝 (quotientMap a),(y∈B ↔ y∈C) ∧ |
| (y∈B → N (representative y)=M (representative y)) |
| rw [← shiftedQuotient_nhds a] |
| change ∀ᶠ v in 𝓝 (0 : Cover), |
| (quotientMap (a+v)∈B ↔ quotientMap (a+v)∈C) ∧ |
| (quotientMap (a+v)∈B → N (representative (quotientMap (a+v)))=M (representative (quotientMap (a+v)))) |
| filter_upwards [hfc,hgc,hPc.eventually hfg,hPc.eventually hfg.gradient, |
| hPc.eventually hfm,hPc.eventually hgm] with v hvB hvC hvfg hvgrad hvN hvM |
| have hgraphs : normalGraph (N a) f (normalPlaneCoordinates (N a) v)= |
| normalGraph (N a) g (normalPlaneCoordinates (N a) v) := by |
| simp only [normalGraph,hvfg] |
| refine ⟨hvB.trans ((congrArg (fun z : Cover ↦ z=v) hgraphs).to_iff.trans hvC.symm),?_⟩ |
| intro hv |
| rw [periodic_representative hpN,periodic_representative hpM] |
| have hFv := hvB.mp hv |
| have hGv := hgraphs.symm.trans hFv |
| calc N (a+v)=graphSlopeNormal (N a) (gradient f (normalPlaneCoordinates (N a) v)) := by |
| simpa only [hFv] using hvN.1 |
| _=graphSlopeNormal (N a) (gradient g (normalPlaneCoordinates (N a) v)) := congrArg _ hvgrad |
| _=M (a+v) := by simpa only [hGv] using hvM.1.symm |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma preconnected_subset_of_relative_germ_closed {X : Type*} [TopologicalSpace X] |
| {B O : Set X} (hB : IsPreconnected B) (hO : IsOpen O) (hne : (B∩O).Nonempty) |
| (hc : closure (B∩O)∩B⊆O) : B⊆O := by |
| let : PreconnectedSpace B := isPreconnected_iff_preconnectedSpace.mp hB |
| let U : Set B := Subtype.val ⁻¹' O |
| have hUo : IsOpen U := hO.preimage continuous_subtype_val |
| have hUc : IsClosed U := isClosed_of_closure_subset (by |
| intro x hx |
| have hx' : (x : X)∈closure (B∩O) := closure_mono |
| (by rintro y ⟨z,hz,rfl⟩; exact ⟨z.property,hz⟩) (closure_subtype.mp hx) |
| exact hc ⟨hx',x.property⟩) |
| have hUn : U.Nonempty := by obtain ⟨x,hxB,hxO⟩ := hne; exact ⟨⟨x,hxB⟩,hxO⟩ |
| have he := (show IsClopen U from ⟨hUc,hUo⟩).eq_univ hUn |
| intro x hx |
| exact show (⟨x,hx⟩ : B)∈U by rw [he]; trivial |
|
|
| lemma orientedSurfaceAgreement_symm {B C : Set Torus} {N M : Cover → Cover} |
| {x : Torus} (hx : x∈orientedSurfaceAgreement B C N M) : |
| x∈orientedSurfaceAgreement C B M N := by |
| filter_upwards [hx] with y hy |
| exact ⟨hy.1.symm,fun hyC ↦ (hy.2 (hy.1.mpr hyC)).symm⟩ |
|
|
| end CubicTorus |
| end |
| end |
| end |
|
|
| end OAI |
|
|
