| import Mathlib |
| import OAI.Geometry.CubicTorus.Profiles.TransverseTorus |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| namespace LatticeIsometry |
|
|
| lemma volumeSupport_preimage (e : LatticeIsometry) {E : Set Torus} (hE : MeasurableSet E) : |
| volumeSupport (e.torus ⁻¹' E)=e.torus ⁻¹' volumeSupport E := by |
| ext a |
| rw [mem_preimage,mem_volumeSupport_iff,mem_volumeSupport_iff] |
| apply forall_congr' |
| intro r |
| apply imp_congr_right |
| intro _ |
| have he : (e.torus ⁻¹' E)∩Metric.ball a r=e.torus ⁻¹' (E∩Metric.ball (e.torus a) r) := by |
| ext z |
| simp only [mem_inter_iff,mem_preimage,Metric.mem_ball,e.torus.dist_eq] |
| rw [he,Measure.real_def,Measure.real_def,e.measurePreserving.measure_preimage |
| (hE.inter Metric.isOpen_ball.measurableSet).nullMeasurableSet] |
|
|
| lemma openRepresentative_preimage (e : LatticeIsometry) {E : Set Torus} (hE : MeasurableSet E) : |
| openRepresentative (e.torus ⁻¹' E)=e.torus ⁻¹' openRepresentative E := by |
| unfold openRepresentative |
| rw [←preimage_compl,e.volumeSupport_preimage hE.compl] |
| rfl |
|
|
| lemma frontier_openRepresentative_preimage (e : LatticeIsometry) {E : Set Torus} |
| (hE : MeasurableSet E) : |
| frontier (openRepresentative (e.torus ⁻¹' E))=e.torus ⁻¹' frontier (openRepresentative E) := by |
| rw [e.openRepresentative_preimage hE] |
| exact (e.torus.toHomeomorph.preimage_frontier _).symm |
|
|
| def normalMap (e : LatticeIsometry) (z : NormalBundle) : NormalBundle := |
| (cubeRepresentative (e.torus (quotientMap z.1)), |
| ⟨e.cover (z.2 : Cover),by rw [LinearIsometryEquiv.norm_map,z.2.property]⟩) |
|
|
| lemma measurable_normalMap (e : LatticeIsometry) : Measurable e.normalMap := by |
| apply Measurable.prodMk |
| · exact measurable_cubeRepresentative.comp (e.torus.continuous.measurable.comp |
| (measurable_quotientMap.comp (measurable_subtype_coe.comp measurable_fst))) |
| · exact (e.cover.continuous.measurable.comp |
| (measurable_subtype_coe.comp measurable_snd)).subtype_mk |
|
|
| lemma normalMap_periodic_eval (e : LatticeIsometry) {Y : Type*} {F : Cover → Y} |
| (hp : ∀ m x,F (x+latticeVector m)=F x) (z : NormalBundle) : |
| F (e.normalMap z).1=F (e.cover z.1) := by |
| change F (representative (e.torus (quotientMap z.1)))=_ |
| rw [←e.commute,periodic_representative hp] |
|
|
| lemma isNormalMeasure_preimage (e : LatticeIsometry) {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) : |
| IsNormalMeasure (e.torus ⁻¹' E) (μ.map e.symm.normalMap) := by |
| constructor |
| · have hm : ((μ.map e.symm.normalMap).mass : ℝ)=(μ.mass : ℝ) := by |
| have hh := congrArg ENNReal.toReal (Measure.map_apply e.symm.measurable_normalMap |
| MeasurableSet.univ (μ := (μ : Measure NormalBundle))) |
| simpa only [preimage_univ,FiniteMeasure.mass,FiniteMeasure.coeFn_def, |
| FiniteMeasure.toMeasure_map,Measure.real,ENNReal.toReal] using hh |
| rw [hm,hμ.1,e.perimeter_eq hE.nullMeasurableSet] |
| · intro F hF |
| change (∫ z,normalTest F hF.1.continuous z |
| ∂Measure.map e.symm.normalMap (μ : Measure NormalBundle))=_ |
| rw [integral_map e.symm.measurable_normalMap.aemeasurable |
| (normalTest F hF.1.continuous).continuous.aestronglyMeasurable, |
| e.flux hF hE,←hμ.2 _ (e.symm.pullback_admissible hF)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun z ↦ by |
| change ⟪e.cover.symm (z.2 : Cover),F (e.symm.normalMap z).1⟫= |
| ⟪(z.2 : Cover),e.cover (F (e.cover.symm z.1))⟫ |
| rw [e.symm.normalMap_periodic_eval hF.2.1] |
| exact (e.cover.inner_map_map (e.cover.symm (z.2 : Cover)) (F (e.cover.symm z.1))).symm.trans |
| (by rw [e.cover.apply_symm_apply]) |
|
|
| lemma pullback_normal_ae (e : LatticeIsometry) {μ : FiniteMeasure NormalBundle} |
| {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)) : |
| ∀ᵐ z ∂((μ.map e.symm.normalMap) : Measure NormalBundle),e.pullback N z.1=(z.2 : Cover) := by |
| rw [FiniteMeasure.toMeasure_map] |
| have hc : Continuous (fun z : NormalBundle ↦ e.pullback N z.1) := |
| (e.pullback_contDiff hN).continuous.comp normalEmbedding_continuous.fst |
| apply (ae_map_iff e.symm.measurable_normalMap.aemeasurable |
| (isClosed_eq hc continuous_normalUnit).measurableSet).mpr |
| filter_upwards [hae] with z hz |
| change e.pullback N (e.symm.normalMap z).1=e.cover.symm (z.2 : Cover) |
| rw [e.symm.normalMap_periodic_eval (e.pullback_periodic hp)] |
| change e.cover.symm (N (e.cover (e.cover.symm z.1)))=_ |
| rw [e.cover.apply_symm_apply,hz] |
|
|
| theorem normal_equivariant (e : LatticeIsometry) {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (he : E=ᵐ[torusVolume](e.torus ⁻¹' 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)) |
| (x : Cover) (hx : quotientMap x∈frontier (openRepresentative E)) : |
| N (e.cover x)=e.cover (N x) := by |
| have hμ' := (e.isNormalMeasure_preimage hE hμ).congr_ae he.symm |
| obtain ⟨w,hw⟩ := isMinimizerAt_normal_unique hV hE hmin x hx |
| have hh := (hw μ hμ N hN hp hae).trans |
| (hw _ hμ' _ (e.pullback_contDiff hN) (e.pullback_periodic hp) (e.pullback_normal_ae hN hp hae)).symm |
| change N x=e.cover.symm (N (e.cover x)) at hh |
| have hh' := congrArg e.cover hh |
| simpa only [e.cover.apply_symm_apply] using hh'.symm |
|
|
| end LatticeIsometry |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def axisReflection (i : Fin 3) : LatticeIsometry where |
| cover := ((sibling_coverCoordinatePermute (Equiv.swap 0 i)).trans firstReflection).trans |
| (sibling_coverCoordinatePermute (Equiv.swap 0 i)) |
| torus := ((torusCoordinatePermute (Equiv.swap 0 i)).trans torusFirstReflection).trans |
| (torusCoordinatePermute (Equiv.swap 0 i)) |
| commute x := by |
| change quotientMap (sibling_coverCoordinatePermute (Equiv.swap 0 i) |
| (firstReflection (sibling_coverCoordinatePermute (Equiv.swap 0 i) x)))=_ |
| rw [coverCoordinatePermute_quotient,firstReflection_quotient,coverCoordinatePermute_quotient] |
| rfl |
|
|
| lemma axisReflection_cover_apply (i j : Fin 3) (x : Cover) : |
| (axisReflection i).cover x j=if j=i then -x j else x j := by |
| classical |
| change (sibling_coverCoordinatePermute (Equiv.swap 0 i) |
| (firstReflection (sibling_coverCoordinatePermute (Equiv.swap 0 i) x))) j=_ |
| simp only [sibling_coverCoordinatePermute_apply,firstReflection_apply,Equiv.swap_apply_self] |
| by_cases h : j=i |
| · subst j |
| simp |
| · have : Equiv.swap (0 : Fin 3) i j≠0 := by |
| intro he |
| have := congrArg (Equiv.swap (0 : Fin 3) i) he |
| exact h (by simpa using this) |
| simp [h,this] |
|
|
| lemma axisReflection_torus_apply (i j : Fin 3) (x : Torus) : |
| (axisReflection i).torus x j=if j=i then -x j else x j := by |
| classical |
| change (torusCoordinatePermute (Equiv.swap 0 i) |
| (torusFirstReflection (torusCoordinatePermute (Equiv.swap 0 i) x))) j=_ |
| simp only [sibling_torusCoordinatePermute_apply,torusFirstReflection_apply,Equiv.swap_apply_self] |
| by_cases h : j=i |
| · subst j |
| simp |
| · have : Equiv.swap (0 : Fin 3) i j≠0 := by |
| intro he |
| have := congrArg (Equiv.swap (0 : Fin 3) i) he |
| exact h (by simpa using this) |
| simp [h,this] |
|
|
| lemma axisReflection_conjugate (i : Fin 3) (x : Torus) : |
| (axisReflection i).torus (torusCoordinatePermute (Equiv.swap 0 i) x)= |
| torusCoordinatePermute (Equiv.swap 0 i) (torusFirstReflection x) := by |
| ext j |
| simp only [axisReflection_torus_apply,sibling_torusCoordinatePermute_apply,torusFirstReflection_apply] |
| have he : (j=i) ↔ Equiv.swap (0 : Fin 3) i j=0 := by |
| constructor |
| · rintro rfl; simp |
| · intro h |
| have hh := congrArg (Equiv.swap (0 : Fin 3) i) h |
| simpa using hh |
| simp only [he] |
|
|
| def centeredAxisReflection (i : Fin 3) (a : Torus) : Torus ≃ᵢ Torus := |
| ((IsometryEquiv.addRight (-a)).trans (axisReflection i).torus).trans |
| (IsometryEquiv.addRight a) |
|
|
| lemma centeredAxisReflection_apply (i j : Fin 3) (a x : Torus) : |
| centeredAxisReflection i a x j=if j=i then -x j+(a j+a j) else x j := by |
| change ((axisReflection i).torus (x+ -a)+a) j=_ |
| rw [PiLp.add_apply,axisReflection_torus_apply] |
| simp only [PiLp.add_apply,PiLp.neg_apply] |
| split_ifs <;> abel |
| |
| lemma centeredAxisReflection_eq (i : Fin 3) {a b : Torus} (h : a i=b i) : |
| centeredAxisReflection i a=centeredAxisReflection i b := by |
| ext x j |
| simp only [centeredAxisReflection_apply] |
| split_ifs with hj |
| · subst j; rw [h] |
| · rfl |
| |
| lemma translated_axis_symmetry_iff (i : Fin 3) (a : Torus) (E : Set Torus) : |
| ((fun z : Torus ↦ z+a) ⁻¹' E)=ᵐ[torusVolume] |
| ((axisReflection i).torus ⁻¹' ((fun z : Torus ↦ z+a) ⁻¹' E)) ↔ |
| E=ᵐ[torusVolume](centeredAxisReflection i a ⁻¹' E) := by |
| constructor |
| · intro h |
| have hh := (measurePreserving_add_right torusVolume (-a)).quasiMeasurePreserving.preimage_ae_eq h |
| filter_upwards [hh] with x hx |
| change (x∈E)=((axisReflection i).torus (x+ -a)+a∈E) |
| change ((x+ -a)+a∈E)=((axisReflection i).torus (x+ -a)+a∈E) at hx |
| simpa only [neg_add_cancel_right] using hx |
| · intro h |
| have hh := (measurePreserving_add_right torusVolume a).quasiMeasurePreserving.preimage_ae_eq h |
| filter_upwards [hh] with x hx |
| change (x+a∈E)=((axisReflection i).torus x+a∈E) |
| change (x+a∈E)=((axisReflection i).torus ((x+a)+ -a)+a∈E) at hx |
| simpa only [add_neg_cancel_right] using hx |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma axisReflection_zero_torus : (axisReflection 0).torus=torusFirstReflection := by |
| ext x j |
| simp only [axisReflection_torus_apply,torusFirstReflection_apply] |
|
|
| lemma torusCoordinateSwap_involutive (i : Fin 3) : |
| Function.Involutive (torusCoordinatePermute (Equiv.swap 0 i)) := by |
| intro x |
| ext j |
| simp only [sibling_torusCoordinatePermute_apply,Equiv.swap_apply_self] |
|
|
| lemma centeredAxisReflection_conjugate (i : Fin 3) (a x : Torus) : |
| centeredAxisReflection i (torusCoordinatePermute (Equiv.swap 0 i) a) |
| (torusCoordinatePermute (Equiv.swap 0 i) x)= |
| torusCoordinatePermute (Equiv.swap 0 i) (centeredAxisReflection 0 a x) := by |
| ext j |
| simp only [centeredAxisReflection_apply,sibling_torusCoordinatePermute_apply] |
| have he : (j=i) ↔ Equiv.swap (0 : Fin 3) i j=0 := by |
| constructor |
| · rintro rfl; simp |
| · intro h |
| have hh := congrArg (Equiv.swap (0 : Fin 3) i) h |
| simpa using hh |
| simp only [he] |
|
|
| theorem isMinimizerAt_exists_axis_reflection {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative E))) (i : Fin 3) : |
| ∃ a : Torus,E=ᵐ[torusVolume](centeredAxisReflection i a ⁻¹' E) := by |
| let P := torusCoordinatePermute (Equiv.swap 0 i) |
| let F := P ⁻¹' E |
| have hmF : IsMinimizerAt V F := isMinimizerAt_coordinatePermutation hmin _ |
| have hcF : IsPreconnected (frontier (openRepresentative F)) := by |
| change IsPreconnected (frontier (openRepresentative ((coordinatePermutation (Equiv.swap 0 i)).torus ⁻¹' E))) |
| rw [(coordinatePermutation (Equiv.swap 0 i)).frontier_openRepresentative_preimage hE] |
| exact P.toHomeomorph.isPreconnected_preimage.mpr hc |
| obtain ⟨a,ha⟩ := isMinimizerAt_exists_first_reflection hV hmF hcF |
| have ha' : F=ᵐ[torusVolume](centeredAxisReflection 0 a ⁻¹' F) := by |
| apply (translated_axis_symmetry_iff 0 a F).mp |
| rw [axisReflection_zero_torus] |
| exact ha |
| have hh := (coordinatePermutation (Equiv.swap 0 i)).measurePreserving.quasiMeasurePreserving.preimage_ae_eq ha' |
| refine ⟨P a,?_⟩ |
| filter_upwards [hh] with x hx |
| change (P (P x)∈E)=(P (centeredAxisReflection 0 a (P x))∈E) at hx |
| have hleft : P (P x)=x := torusCoordinateSwap_involutive i x |
| have hright : P (centeredAxisReflection 0 a (P x))=centeredAxisReflection i (P a) x := by |
| rw [←centeredAxisReflection_conjugate i a (P x),hleft] |
| change (x∈E)=(centeredAxisReflection i (P a) x∈E) |
| rwa [hleft,hright] at hx |
|
|
| theorem isMinimizerAt_common_reflection_origin {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative E))) : |
| ∃ a : Torus,∀ i : Fin 3,let E' := (fun z : Torus ↦ z+a) ⁻¹' E |
| E'=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E') := by |
| classical |
| let F := toMeasurable torusVolume E |
| have hF : MeasurableSet F := measurableSet_toMeasurable _ _ |
| have hae : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq |
| have hmF := (isMinimizerAt_congr_ae hae).mpr hmin |
| have hcF : IsPreconnected (frontier (openRepresentative F)) := by |
| rwa [openRepresentative_congr_ae hae] |
| choose b hb using isMinimizerAt_exists_axis_reflection hV hF hmF hcF |
| let a : Torus := WithLp.toLp 2 (fun i ↦ b i i) |
| refine ⟨a,fun i ↦ ?_⟩ |
| have hf : F=ᵐ[torusVolume](centeredAxisReflection i a ⁻¹' F) := by |
| rw [centeredAxisReflection_eq i (a := a) (b := b i) rfl] |
| exact hb i |
| have hf' := (translated_axis_symmetry_iff i a F).mpr hf |
| have htAE := (measurePreserving_add_right torusVolume a).quasiMeasurePreserving.preimage_ae_eq hae |
| refine htAE.symm.trans (hf'.trans ?_) |
| exact (axisReflection i).measurePreserving.quasiMeasurePreserving.preimage_ae_eq htAE |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma representative_coordinatePermute (e : Fin 3 ≃ Fin 3) (x : Torus) : |
| representative (torusCoordinatePermute e x)=sibling_coverCoordinatePermute e (representative x) := by |
| ext j |
| rfl |
|
|
| lemma LatticeIsometry.pullback_representative (e : LatticeIsometry) {N : Cover → Cover} |
| (hp : ∀ m x,N (x+latticeVector m)=N x) (x : Torus) : |
| e.pullback N (representative x)=e.cover.symm (N (representative (e.torus x))) := by |
| have he := periodic_representative hp (e.cover (representative x)) |
| rw [e.commute,quotientMap_representative] at he |
| change e.cover.symm (N (e.cover (representative x)))=_ |
| rw [he] |
|
|
| lemma coordinateSwap_pullback_scalar (i : Fin 3) {N : Cover → Cover} |
| (hp : ∀ m x,N (x+latticeVector m)=N x) (x : Torus) : |
| (coordinatePermutation (Equiv.swap 0 i)).pullback N |
| (representative (torusCoordinatePermute (Equiv.swap 0 i) x)) 0=N (representative x) i := by |
| rw [LatticeIsometry.pullback_representative _ hp] |
| change (sibling_coverCoordinatePermute (Equiv.swap 0 i)).symm |
| (N (representative (torusCoordinatePermute (Equiv.swap 0 i) |
| (torusCoordinatePermute (Equiv.swap 0 i) x)))) 0=_ |
| rw [torusCoordinateSwap_involutive,coverCoordinatePermute_symm] |
| simp only [sibling_coverCoordinatePermute_apply,Equiv.symm_swap,Equiv.swap_apply_left] |
|
|
| theorem isMinimizerAt_axis_strict_normal_sign {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative E))) (i : Fin 3) |
| (hR : E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' 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)) : |
| (∀ x∈frontier (openRepresentative E),N (representative x) i=0) ∨ |
| (∀ x∈frontier (openRepresentative E),Real.sin (2*Real.pi*representative x i)<0 → |
| N (representative x) i<0) ∨ |
| (∀ x∈frontier (openRepresentative E),Real.sin (2*Real.pi*representative x i)<0 → |
| 0<N (representative x) i) := by |
| let e := coordinatePermutation (Equiv.swap 0 i) |
| let F := e.torus ⁻¹' E |
| have hF : MeasurableSet F := hE.preimage e.torus.continuous.measurable |
| have hmF : IsMinimizerAt V F := e.isMinimizerAt hmin |
| have hcF : IsPreconnected (frontier (openRepresentative F)) := by |
| change IsPreconnected (frontier (openRepresentative (e.torus ⁻¹' E))) |
| rw [e.frontier_openRepresentative_preimage hE] |
| exact e.torus.toHomeomorph.isPreconnected_preimage.mpr hc |
| have hRF : F=ᵐ[torusVolume](torusFirstReflection ⁻¹' F) := by |
| have hh := e.measurePreserving.quasiMeasurePreserving.preimage_ae_eq hR |
| filter_upwards [hh] with x hx |
| change (e.torus x∈E)=((axisReflection i).torus (e.torus x)∈E) at hx |
| change (e.torus x∈E)=(e.torus (torusFirstReflection x)∈E) |
| change (torusCoordinatePermute (Equiv.swap 0 i) x∈E)= |
| ((axisReflection i).torus (torusCoordinatePermute (Equiv.swap 0 i) x)∈E) at hx |
| rwa [axisReflection_conjugate] at hx |
| have hpoint (x : Torus) (hx : x∈frontier (openRepresentative E)) : |
| e.torus x∈frontier (openRepresentative F) := by |
| change e.torus x∈frontier (openRepresentative (e.torus ⁻¹' E)) |
| rw [e.frontier_openRepresentative_preimage hE] |
| change e.torus (e.torus x)∈frontier (openRepresentative E) |
| change torusCoordinatePermute (Equiv.swap 0 i) |
| (torusCoordinatePermute (Equiv.swap 0 i) x)∈frontier (openRepresentative E) |
| rwa [torusCoordinateSwap_involutive] |
| have hseam (x : Torus) : firstSeamFunction (representative (e.torus x))= |
| Real.sin (2*Real.pi*representative x i) := by |
| change Real.sin (2*Real.pi*representative (torusCoordinatePermute (Equiv.swap 0 i) x) 0)=_ |
| rw [representative_coordinatePermute,sibling_coverCoordinatePermute_apply,Equiv.swap_apply_left] |
| rcases isMinimizerAt_reflection_strict_normal_sign hV hF hmF hcF hRF |
| (e.isNormalMeasure_preimage hE hμ) (e.pullback_contDiff hN) (e.pullback_periodic hp) |
| (e.pullback_normal_ae hN hp hae) with hz|hn|hpos |
| · left |
| intro x hx |
| have hh := hz (e.torus x) (hpoint x hx) |
| dsimp only [e] at hh |
| change (coordinatePermutation (Equiv.swap 0 i)).pullback N |
| (representative (torusCoordinatePermute (Equiv.swap 0 i) x)) 0=0 at hh |
| rwa [coordinateSwap_pullback_scalar i hp x] at hh |
| · right; left |
| intro x hx hs |
| have hh := hn (e.torus x) (hpoint x hx) (by rwa [hseam]) |
| dsimp only [e] at hh |
| change (coordinatePermutation (Equiv.swap 0 i)).pullback N |
| (representative (torusCoordinatePermute (Equiv.swap 0 i) x)) 0<0 at hh |
| rwa [coordinateSwap_pullback_scalar i hp x] at hh |
| · right; right |
| intro x hx hs |
| have hh := hpos (e.torus x) (hpoint x hx) (by rwa [hseam]) |
| dsimp only [e] at hh |
| change 0<(coordinatePermutation (Equiv.swap 0 i)).pullback N |
| (representative (torusCoordinatePermute (Equiv.swap 0 i) x)) 0 at hh |
| rwa [coordinateSwap_pullback_scalar i hp x] at hh |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem isMinimizerAt_zero_axis_standard {V : ℝ} (hV : V∈Ioc 0 (1/2)) |
| {E : Set Torus} (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative 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 : ℝ} (hb : ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) → |
| (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H) |
| (i : Fin 3) |
| (hz : ∀ x∈frontier (openRepresentative E),N (representative x) i=0) : |
| 4*Real.pi/81≤V ∧ V≤1/Real.pi ∧ CongruentAE E (canonicalTube V) := by |
| let F := toMeasurable torusVolume E |
| have hF : MeasurableSet F := measurableSet_toMeasurable _ _ |
| have hFE : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq |
| have hmF := (isMinimizerAt_congr_ae hFE).mpr hmin |
| have hbd : frontier (openRepresentative F)=frontier (openRepresentative E) := |
| congrArg frontier (openRepresentative_congr_ae hFE) |
| have hcF : IsPreconnected (frontier (openRepresentative F)) := by rwa [hbd] |
| have hμF : IsNormalMeasure F μ := hμ.congr_ae hFE.symm |
| have hbF : ∀ x : Cover,quotientMap x∈frontier (openRepresentative F) → |
| (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H := by rwa [hbd] |
| have hzF (x : Cover) (hx : quotientMap x∈frontier (openRepresentative F)) : N x i=0 := by |
| have hh := hz _ (show quotientMap x∈frontier (openRepresentative E) by rwa [hbd] at hx) |
| rwa [periodic_representative hp x] at hh |
| obtain ⟨hr0,hr,c,hc,hcyl⟩ := isMinimizerAt_zero_axis_cylindrical_boundary |
| ⟨hV.1,by linarith [hV.2]⟩ hF hmF hcF hμF hN hp hae hbF i hzF |
| obtain ⟨hlo,hhi,φ,hφ⟩ := isMinimizerAt_coordinate_cylinder_standard hV hF hmF i hc hr0 hr hcyl |
| exact ⟨hlo,hhi,φ,hFE.symm.trans hφ⟩ |
|
|
| theorem isMinimizerAt_nonstandard_axis_strict_normal_sign {V : ℝ} (hV : V∈Ioc 0 (1/2)) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative E))) |
| (hstd : ¬StandardRegionAt V E) (i : Fin 3) |
| (hR : E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' 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 : ℝ} (hb : ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) → |
| (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H) : |
| (∀ x∈frontier (openRepresentative E),Real.sin (2*Real.pi*representative x i)<0 → |
| N (representative x) i<0) ∨ |
| (∀ x∈frontier (openRepresentative E),Real.sin (2*Real.pi*representative x i)<0 → |
| 0<N (representative x) i) := by |
| rcases isMinimizerAt_axis_strict_normal_sign ⟨hV.1,by linarith [hV.2]⟩ hE hmin hc i hR hμ hN hp hae with hz|hn|hp' |
| · exfalso |
| obtain ⟨hlo,hhi,hcong⟩ := isMinimizerAt_zero_axis_standard hV hmin hc hμ hN hp hae hb i hz |
| apply hstd |
| unfold StandardRegionAt SmallStandardRegion |
| rw [ite_eq_left hV.2] |
| exact Or.inr (Or.inl ⟨hlo,hhi,hcong⟩) |
| · exact Or.inl hn |
| · exact Or.inr hp' |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem normalMeasure_signed_translation {E : Set Torus} {μ : FiniteMeasure NormalBundle} |
| (hμ : IsNormalMeasure E μ) {f : Cover → ℝ} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (hp : ∀ m x,f (x+latticeVector m)=f x) (a : Cover) |
| (hsign : ∀ t∈Icc (0 : ℝ) 1,∀ᵐ z ∂(μ : Measure NormalBundle), |
| 0≤f ((z.1 : Cover)+t • a)*⟪(z.2 : Cover),a⟫) : |
| 0≤∫ x in fundamentalCube∩quotientMap ⁻¹' E,f (x+a)-f x := by |
| have hdc := hf.continuous_fderiv (by simp) |
| have hd := hf.differentiable (by simp) |
| have hderiv (x t) : HasDerivAt (fun s : ℝ ↦ f (x+s • a)) |
| (fderiv ℝ f (x+t • a) a) t := by |
| simpa only [Function.comp_def,Pi.add_apply,id_eq,one_smul,zero_add] using |
| (hd (x+t • a)).hasFDerivAt.comp_hasDerivAt t |
| ((hasDerivAt_const t x).add ((hasDerivAt_id t).smul_const a)) |
| have hFTC (x : Cover) : (∫ t in Ioc (0 : ℝ) 1,fderiv ℝ f (x+t • a) a)=f (x+a)-f x := by |
| rw [←intervalIntegral.integral_of_le (by norm_num : (0 : ℝ)≤1)] |
| have hc : Continuous (fun t : ℝ ↦ fderiv ℝ f (x+t • a) a) := |
| (hdc.comp (continuous_const.add (continuous_id.smul continuous_const))).clm_apply continuous_const |
| simpa using intervalIntegral.integral_eq_sub_of_hasDerivAt |
| (fun t _ ↦ hderiv x t) (hc.intervalIntegrable 0 1) |
| obtain ⟨M,_,hM⟩ := periodic_bounded hdc (fderiv_periodic hp) |
| have hc : Continuous (fun z : Cover×ℝ ↦ fderiv ℝ f (z.1+z.2 • a) a) := |
| (hdc.comp (continuous_fst.add (continuous_snd.smul continuous_const))).clm_apply continuous_const |
| have hi : Integrable (fun z : Cover×ℝ ↦ fderiv ℝ f (z.1+z.2 • a) a) |
| ((volume.restrict (fundamentalCube∩quotientMap ⁻¹' E)).prod |
| (volume.restrict (Ioc (0 : ℝ) 1))) := by |
| apply Integrable.of_bound hc.aestronglyMeasurable (M*‖a‖) |
| exact Eventually.of_forall fun z ↦ ((fderiv ℝ f (z.1+z.2 • a)).le_opNorm a).trans |
| (mul_le_mul_of_nonneg_right (hM _) (norm_nonneg a)) |
| have hflux (t : ℝ) (ht : t∈Icc (0 : ℝ) 1) : |
| 0≤∫ x in fundamentalCube∩quotientMap ⁻¹' E,fderiv ℝ f (x+t • a) a := by |
| let g := fun x : Cover ↦ f (x+t • a) |
| have hg : ContDiff ℝ (⊤ : ℕ∞) g := hf.comp (contDiff_id.add contDiff_const) |
| have hgp : ∀ m x,g (x+latticeVector m)=g x := by |
| intro m x; dsimp [g]; rw [add_right_comm,hp] |
| have hF : ContDiff ℝ (⊤ : ℕ∞) (fun x ↦ g x • a) := hg.smul contDiff_const |
| have hFp : ∀ m x,g (x+latticeVector m) • a=g x • a := by simp only [hgp]; simp |
| obtain ⟨K,hK,hbd⟩ := periodic_bounded hF.continuous hFp |
| have he := normalMeasure_flux hμ hF hFp (show 0<K+1 by linarith) |
| (fun x ↦ (hbd x).trans (by linarith)) |
| simp only [normalTest,ContinuousMap.coe_mk,real_inner_smul_right] at he |
| rw [show (fun x ↦ fderiv ℝ f (x+t • a) a)=divergence (fun x ↦ g x • a) from by |
| funext x |
| rw [divergence_smul_const (hg.differentiable (by simp)).differentiableAt] |
| dsimp [g] |
| rw [fderiv_comp_add_right]] |
| rw [←he] |
| exact integral_nonneg_of_ae (hsign t ht) |
| calc |
| _ = ∫ t in Ioc (0 : ℝ) 1,∫ x in fundamentalCube∩quotientMap ⁻¹' E, |
| fderiv ℝ f (x+t • a) a := by |
| rw [←integral_integral_swap hi] |
| simp_rw [hFTC] |
| _ ≥ 0 := integral_nonneg_of_ae (by |
| filter_upwards [ae_restrict_mem measurableSet_Ioc] with t ht |
| exact hflux t ⟨ht.1.le,ht.2⟩) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma periodic_descent_translate {f : Cover → ℝ} |
| (hp : ∀ m x,f (x+latticeVector m)=f x) (a : Cover) (x : Torus) : |
| f (representative x+a)=f (representative (x+quotientMap a)) := by |
| have hh := periodic_representative hp (representative x+a) |
| rw [quotientMap_add,quotientMap_representative] at hh |
| exact hh.symm |
|
|
| theorem isMinimizerAt_test_phase_propagation {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {f : Cover → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (hp : ∀ m x,f (x+latticeVector m)=f x) (hf0 : ∀ x,0≤f x) |
| (hsupport : ∀ x,f x≠0 → quotientMap x∈openRepresentative E) |
| (a : Cover) |
| (hsign : ∀ t∈Icc (0 : ℝ) 1,∀ᵐ z ∂(μ : Measure NormalBundle), |
| 0≤f ((z.1 : Cover)+t • a)*⟪(z.2 : Cover),a⟫) |
| (x : Cover) (hx : 0<f (x+a)) : quotientMap x∈openRepresentative E := by |
| let g : Torus → ℝ := fun z ↦ f (representative z) |
| let k : Torus → ℝ := fun z ↦ f (representative z+a) |
| have hfp : ∀ m x,f (x+latticeVector m+a)=f (x+a) := by |
| intro m x; rw [add_right_comm,hp] |
| have hg : Continuous g := continuous_periodic_descent hf.continuous hp |
| have hk : Continuous k := continuous_periodic_descent |
| (hf.continuous.comp (continuous_id.add continuous_const)) hfp |
| obtain ⟨M,hM,hbd⟩ := periodic_bounded hf.continuous hp |
| have hi : Integrable g torusVolume := Integrable.of_bound hg.aestronglyMeasurable M |
| (Eventually.of_forall fun z ↦ hbd _) |
| have hki : Integrable k torusVolume := Integrable.of_bound hk.aestronglyMeasurable M |
| (Eventually.of_forall fun z ↦ hbd _) |
| have hgae : g=ᵐ[torusVolume.restrict Eᶜ]0 := by |
| filter_upwards [ae_restrict_of_ae (isMinimizerAt_openRepresentative_ae hV hE hmin), |
| ae_restrict_mem hE.compl] with z hz hzE |
| change g z=0 |
| by_contra hne |
| have hO := hsupport (representative z) hne |
| rw [quotientMap_representative] at hO |
| exact hzE (hz.mp hO) |
| have hgz : (∫ z in Eᶜ,g z ∂torusVolume)=0 := integral_eq_zero_of_ae hgae |
| have htotal : (∫ z,k z ∂torusVolume)=∫ z,g z ∂torusVolume := by |
| change (∫ z,f (representative z+a) ∂torusVolume)=_ |
| simp_rw [periodic_descent_translate hp] |
| exact integral_add_right_eq_self g (quotientMap a) |
| have hdf : Continuous (fun x ↦ f (x+a)-f x) := |
| (hf.continuous.comp (continuous_id.add continuous_const)).sub hf.continuous |
| have hdp : ∀ m x,f (x+latticeVector m+a)-f (x+latticeVector m)=f (x+a)-f x := by |
| intro m x; rw [hfp,hp] |
| have hm := normalMeasure_signed_translation hμ hf hp a hsign |
| rw [←setIntegral_lift hdf hdp hE] at hm |
| change 0≤∫ z in E,k z-g z ∂torusVolume at hm |
| rw [integral_sub hki.integrableOn hi.integrableOn] at hm |
| have hz : (∫ z in Eᶜ,k z ∂torusVolume)=0 := by |
| have hk0 : 0≤∫ z in Eᶜ,k z ∂torusVolume := integral_nonneg fun z ↦ hf0 _ |
| have ha := integral_add_compl hE hi |
| have hb := integral_add_compl hE hki |
| rw [hgz] at ha |
| rw [htotal] at hb |
| linarith |
| have hkae : k=ᵐ[torusVolume.restrict Eᶜ]0 := |
| (integral_eq_zero_iff_of_nonneg (fun z ↦ hf0 _) hki.integrableOn).mp hz |
| have hs : (torusVolume.restrict Eᶜ).support⊆{z | k z=0} := |
| Measure.support_subset_of_isClosed (isClosed_eq hk continuous_const) hkae |
| change quotientMap x∉(torusVolume.restrict Eᶜ).support |
| intro hmem |
| have he := hs hmem |
| change f (representative (quotientMap x)+a)=0 at he |
| have heq := periodic_representative (f := fun w ↦ f (w+a)) hfp x |
| rw [heq] at he |
| exact hx.ne' he |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma latticePeriodize_ne_zero {f : Cover → ℝ} {x : Cover} |
| (h : latticePeriodize f x≠0) : ∃ m : Fin 3 → ℤ,f (x+latticeVector m)≠0 := by |
| by_contra hn |
| push Not at hn |
| exact h (by simp only [latticePeriodize,hn,tsum_zero]) |
|
|
| theorem isMinimizerAt_convex_phase_monotone {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (hae : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| {U : Set Cover} (hU : IsOpen U) (hc : Convex ℝ U) |
| (hcell : U⊆{x | ∀ i,0<x i ∧ x i<1}) |
| {x y : Cover} (hx : x∈U) (hy : y∈U) |
| (hyO : quotientMap y∈openRepresentative E) |
| (hsign : ∀ z∈U,quotientMap z∈frontier (openRepresentative E) → |
| 0≤⟪N z,y-x⟫) : quotientMap x∈openRepresentative E := by |
| obtain ⟨r,hr,hrU⟩ := Metric.isOpen_iff.mp hU x hx |
| have hO : IsOpen (U∩quotientMap ⁻¹' openRepresentative E) := |
| hU.inter ((isOpen_openRepresentative E).preimage continuous_quotientMap) |
| obtain ⟨s,hs,hsU⟩ := Metric.isOpen_iff.mp hO y ⟨hy,hyO⟩ |
| let ρ : ℝ := min r s/4 |
| have hρ : 0<ρ := by dsimp [ρ]; positivity |
| have hρr : 2*ρ<r := by |
| have hh := min_le_left r s |
| have hp := lt_min hr hs |
| dsimp [ρ]; linarith |
| have hρs : 2*ρ<s := by |
| have hh := min_le_right r s |
| have hp := lt_min hr hs |
| dsimp [ρ]; linarith |
| let φ := radialHeightCutoff y ρ |
| have hφ : ContDiff ℝ (⊤ : ℕ∞) φ := radialDensityWeight_contDiff _ _ _ |
| have hφc : HasCompactSupport φ := radialDensityWeight_hasCompactSupport (by positivity) (by positivity) |
| have hφb (z : Cover) : 0≤φ z := radialDensityWeight_nonneg _ _ _ _ |
| have hφs : tsupport φ⊆Metric.closedBall y (2*ρ) := |
| radialDensityWeight_tsupport (by positivity) (by positivity) |
| have hφU : tsupport φ⊆U := fun z hz ↦ (hsU (by |
| exact (Metric.mem_closedBall.mp (hφs hz)).trans_lt hρs)).1 |
| have hφO : tsupport φ⊆quotientMap ⁻¹' openRepresentative E := fun z hz ↦ |
| (hsU (by exact (Metric.mem_closedBall.mp (hφs hz)).trans_lt hρs)).2 |
| let f := latticePeriodize φ |
| have hf : ContDiff ℝ (⊤ : ℕ∞) f := latticePeriodize_contDiff hφ hφc |
| have hfp : ∀ m z,f (z+latticeVector m)=f z := latticePeriodize_periodic φ |
| have hf0 : ∀ z,0≤f z := fun z ↦ tsum_nonneg (fun m ↦ hφb _) |
| have hfs (z : Cover) (hz : f z≠0) : quotientMap z∈openRepresentative E := by |
| obtain ⟨m,hm⟩ := latticePeriodize_ne_zero hz |
| have hh := hφO (subset_tsupport φ hm) |
| simpa only [mem_preimage,quotientMap_add,quotientMap_latticeVector,add_zero] using hh |
| have hfy : f y=1 := by |
| change latticePeriodize φ y=1 |
| rw [(latticePeriodize_eventuallyEq hφc (hφU.trans hcell) |
| (fun i ↦ ⟨(hcell hy i).1.le,(hcell hy i).2.le⟩)).eq_of_nhds] |
| exact radialHeightCutoff_one hρ (by simpa using hρ.le) |
| have hseg (z : Cover) (hz : z∈tsupport φ) (t : ℝ) (ht : t∈Icc (0 : ℝ) 1) : |
| z-t • (y-x)∈U := by |
| have hzy : dist z y≤2*ρ := hφs hz |
| have hzx : dist (z-(y-x)) x=dist z y := by |
| simp only [dist_eq_norm] |
| congr 1 |
| abel |
| have hx' : z-(y-x)∈U := hrU (by rw [Metric.mem_ball,hzx]; exact hzy.trans_lt hρr) |
| have hy' : z∈U := hφU hz |
| have hh := hc hx' hy' ht.1 (sub_nonneg.mpr ht.2) (by ring : t+(1-t)=1) |
| convert hh using 1 |
| module |
| have hμO : IsNormalMeasure (openRepresentative E) μ := |
| hμ.congr_ae (isMinimizerAt_openRepresentative_ae hV hE hmin).symm |
| have hsg (t : ℝ) (ht : t∈Icc (0 : ℝ) 1) : |
| ∀ᵐ z ∂(μ : Measure NormalBundle), |
| 0≤f ((z.1 : Cover)+t • (y-x))*⟪(z.2 : Cover),y-x⟫ := by |
| filter_upwards [hae,normalMeasure_frontier_ae (isOpen_openRepresentative E).measurableSet hμO] |
| with z hz hb |
| by_cases he : f ((z.1 : Cover)+t • (y-x))=0 |
| · simp only [he,zero_mul,le_refl] |
| obtain ⟨m,hm⟩ := latticePeriodize_ne_zero he |
| have hu : (z.1 : Cover)+latticeVector m∈U := by |
| have hh := hseg _ (subset_tsupport φ hm) t ht |
| convert hh using 1 |
| module |
| have hbound : quotientMap ((z.1 : Cover)+latticeVector m)∈frontier (openRepresentative E) := by |
| simpa only [quotientMap_add,quotientMap_latticeVector,add_zero] using hb |
| have hn := hsign _ hu hbound |
| rw [hp,hz] at hn |
| exact mul_nonneg (hf0 _) hn |
| apply isMinimizerAt_test_phase_propagation hV hE hmin hμ hf hfp hf0 hfs (y-x) hsg x |
| rw [add_sub_cancel,hfy] |
| norm_num |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def upperOctant : Set Cover := {x | ∀ i : Fin 3,(1/2 : ℝ)<x i ∧ x i<1} |
|
|
| lemma isOpen_upperOctant : IsOpen upperOctant := by |
| have he : upperOctant=⋂ i : Fin 3,(fun x : Cover ↦ x i) ⁻¹' Ioo (1/2 : ℝ) 1 := by |
| ext x; simp [upperOctant] |
| rw [he] |
| exact isOpen_iInter_of_finite fun i ↦ isOpen_Ioo.preimage (EuclideanSpace.proj i).continuous |
| |
| lemma convex_upperOctant : Convex ℝ upperOctant := by |
| have he : upperOctant=⋂ i : Fin 3,(fun x : Cover ↦ x i) ⁻¹' Ioo (1/2 : ℝ) 1 := by |
| ext x; simp [upperOctant] |
| rw [he] |
| exact convex_iInter fun i ↦ (convex_Ioo (1/2 : ℝ) 1).linear_preimage |
| (EuclideanSpace.proj i).toLinearMap |
|
|
| def OrientedCoordinateLE (b : Fin 3 → Bool) (x y : Cover) : Prop := |
| ∀ i,if b i then x i≤y i else y i≤x i |
|
|
| lemma isMinimizerAt_octant_normal_orientation {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative E))) |
| (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' 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)) : |
| ∃ b : Fin 3 → Bool,∀ i : Fin 3,∀ x∈upperOctant, |
| quotientMap x∈frontier (openRepresentative E) → |
| if b i then 0≤N x i else N x i≤0 := by |
| classical |
| have hh (i : Fin 3) : ∃ b : Bool,∀ x∈upperOctant, |
| quotientMap x∈frontier (openRepresentative E) → |
| if b then 0≤N x i else N x i≤0 := by |
| have hrep {x : Cover} (hx : x∈upperOctant) : representative (quotientMap x)=x := |
| representative_quotientMap_of_mem (fun j ↦ ⟨by linarith [(hx j).1],(hx j).2⟩) |
| rcases isMinimizerAt_axis_strict_normal_sign hV hE hmin hc i (hR i) hμ hN hp hae with hz|hn|hp' |
| · refine ⟨true,fun x hx hb ↦ ?_⟩ |
| simpa only [ite_true,hrep hx] using (hz _ hb).ge |
| · refine ⟨false,fun x hx hb ↦ ?_⟩ |
| have hs : Real.sin (2*Real.pi*representative (quotientMap x) i)<0 := by |
| rw [hrep hx] |
| exact (firstSeam_sign ⟨by linarith [(hx i).1],(hx i).2⟩).mpr (hx i).1 |
| simpa only [Bool.false_eq_true,ite_false,hrep hx] using (hn _ hb hs).le |
| · refine ⟨true,fun x hx hb ↦ ?_⟩ |
| have hs : Real.sin (2*Real.pi*representative (quotientMap x) i)<0 := by |
| rw [hrep hx] |
| exact (firstSeam_sign ⟨by linarith [(hx i).1],(hx i).2⟩).mpr (hx i).1 |
| simpa only [ite_true,hrep hx] using (hp' _ hb hs).le |
| choose b hb using hh |
| exact ⟨b,hb⟩ |
|
|
| theorem isMinimizerAt_octant_downset {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hmin : IsMinimizerAt V E) |
| (hc : IsPreconnected (frontier (openRepresentative E))) |
| (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E)) : |
| ∃ b : Fin 3 → Bool,∀ x∈upperOctant,∀ y∈upperOctant, |
| OrientedCoordinateLE b x y → quotientMap y∈openRepresentative E → |
| quotientMap x∈openRepresentative E := by |
| let F := toMeasurable torusVolume E |
| have hF : MeasurableSet F := measurableSet_toMeasurable _ _ |
| have hFE : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq |
| have hmF := (isMinimizerAt_congr_ae hFE).mpr hmin |
| have hcF : IsPreconnected (frontier (openRepresentative F)) := by |
| rwa [openRepresentative_congr_ae hFE] |
| have hRF (i : Fin 3) : F=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' F) := |
| hFE.trans ((hR i).trans ((axisReflection i).measurePreserving.quasiMeasurePreserving.preimage_ae_eq hFE.symm)) |
| obtain ⟨μ,H,N,hN,hp,hμ,haN,hb,hs,hj,hu⟩ := Periodic.isMinimizerAt_H1_translation_jacobi hV hF hmF |
| obtain ⟨b,hb⟩ := isMinimizerAt_octant_normal_orientation hV hF hmF hcF hRF hμ hN hp haN |
| refine ⟨b,fun x hx y hy hxy hyE ↦ ?_⟩ |
| rw [←openRepresentative_congr_ae hFE] at hyE ⊢ |
| apply isMinimizerAt_convex_phase_monotone hV hF hmF hμ hp haN |
| isOpen_upperOctant convex_upperOctant (fun z hz i ↦ ⟨by linarith [(hz i).1],(hz i).2⟩) |
| hx hy hyE |
| intro z hz hbound |
| simp only [PiLp.inner_apply,PiLp.sub_apply,RCLike.inner_apply,RCLike.conj_to_real] |
| apply Finset.sum_nonneg |
| intro i hi |
| have hn := hb i z hz hbound |
| have hh := hxy i |
| cases hbi : b i <;> simp only [hbi,Bool.false_eq_true,ite_false,ite_true] at hn hh |
| · exact mul_nonneg_of_nonpos_of_nonpos (sub_nonpos.mpr hh) hn |
| · exact mul_nonneg (sub_nonneg.mpr hh) hn |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| lemma isMinimizerAt_axis_fixed_normal_zero {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (i : Fin 3) (hR : E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' 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)) |
| (x : Cover) (hx : quotientMap x∈frontier (openRepresentative E)) |
| (hfix : (axisReflection i).torus (quotientMap x)=quotientMap x) : N x i=0 := by |
| have he := (axisReflection i).normal_equivariant hV hE hmin hR hμ hN hp hae x hx |
| have hq : quotientMap ((axisReflection i).cover x)=quotientMap x := by |
| rw [(axisReflection i).commute,hfix] |
| obtain ⟨m,hm⟩ := same_quotient_lattice hq |
| rw [hm,hp] at he |
| have hh := congrArg (fun v : Cover ↦ v i) he |
| simp only [axisReflection_cover_apply,ite_true] at hh |
| linarith |
|
|
| end CubicTorus |
| end |
| end |
| end |
|
|
| end OAI |
|
|
