| import Mathlib |
| import OAI.Geometry.CubicTorus.Curvature.TorusC2CMCAt |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalGraph_metric {n : Cover} (hn : ‖n‖=1) {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (y v w : Plane) : |
| ⟪fderiv ℝ (normalGraph n g) y v,fderiv ℝ (normalGraph n g) y w⟫= |
| ⟪v,w⟫+⟪gradient g y,v⟫*⟪gradient g y,w⟫ := by |
| rw [normalGraph_fderiv_apply hg,normalGraph_fderiv_apply hg] |
| simp only [inner_add_left,inner_add_right,real_inner_smul_left,real_inner_smul_right, |
| normalPlaneEmbedding_inner hn,real_inner_self_eq_norm_sq,hn,one_pow,mul_zero,add_zero] |
| have ho : ⟪normalPlaneEmbedding n v,n⟫=0 := by rw [real_inner_comm] |
| have hi := (normalPlaneLinearIsometry n).inner_map_map v w |
| change ⟪normalPlaneEmbedding n v,normalPlaneEmbedding n w⟫=⟪v,w⟫ at hi |
| simp only [hi,ho,mul_zero,zero_add,mul_one] |
| ring |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma normalGraph_projection_differential {n : Cover} (hn : ‖n‖=1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) (y : Plane) : |
| (normalPlaneCoordinates n).comp (fderiv ℝ (normalGraph n g) y)= |
| ContinuousLinearMap.id ℝ Plane := by |
| apply ContinuousLinearMap.ext |
| intro v |
| rw [ContinuousLinearMap.comp_apply,normalGraph_fderiv_apply hg,map_add,map_smul, |
| normalPlaneCoordinates_embedding,normalPlaneCoordinates_normal hn,smul_zero,add_zero] |
| rfl |
|
|
| lemma graphUnitNormalExtension_fderiv (a : Cover) {n : Cover} (hn : ‖n‖=1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) (x : Cover) : |
| fderiv ℝ (graphUnitNormalExtension a n g) x= |
| -((fderiv ℝ (normalGraph n g) (normalPlaneCoordinates n (x-a))).comp |
| ((graphShapeOperator g (normalPlaneCoordinates n (x-a))).comp |
| (normalPlaneCoordinates n))) := by |
| have hN : Differentiable ℝ (fun y ↦ graphSlopeNormal n (gradient g y)) := |
| ((graphSlopeNormal_contDiff hn).comp (plane_gradient_contDiff hg)).differentiable (by simp) |
| have hp := (normalPlaneCoordinates n).hasFDerivAt.comp x |
| ((hasFDerivAt_id x).sub_const a) |
| have hd := ((hN _).hasFDerivAt.comp x hp).fderiv |
| change fderiv ℝ (graphUnitNormalExtension a n g) x=_ at hd |
| rw [hd] |
| apply ContinuousLinearMap.ext |
| intro v |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.id_apply,neg_apply] |
| exact graph_weingarten hn hg _ _ |
|
|
| theorem graphUnitNormalExtension_curvature (a : Cover) {n : Cover} (hn : ‖n‖=1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) (x : Cover) : |
| coverTrace ((fderiv ℝ (graphUnitNormalExtension a n g) x).comp |
| (fderiv ℝ (graphUnitNormalExtension a n g) x))= |
| graphSquaredSecondFundamentalForm g (normalPlaneCoordinates n (x-a)) := by |
| let y := normalPlaneCoordinates n (x-a) |
| let J := fderiv ℝ (normalGraph n g) y |
| let S := graphShapeOperator g y |
| let P := normalPlaneCoordinates n |
| have hPJ : P.comp J=ContinuousLinearMap.id ℝ Plane := normalGraph_projection_differential hn hg y |
| rw [graphUnitNormalExtension_fderiv a hn hg] |
| change coverTrace ((-(J.comp (S.comp P))).comp (-(J.comp (S.comp P))))=planeTraceSquare S |
| have he : ((-(J.comp (S.comp P))).comp (-(J.comp (S.comp P))))= |
| J.comp ((S.comp S).comp P) := by |
| apply ContinuousLinearMap.ext |
| intro v |
| have h := congrArg (fun L : Plane →L[ℝ] Plane ↦ L (S (P v))) hPJ |
| simp only [ContinuousLinearMap.comp_apply,neg_apply,map_neg,neg_neg, |
| ContinuousLinearMap.id_apply] at h ⊢ |
| rw [h] |
| rw [he,rectangular_trace,ContinuousLinearMap.comp_assoc,hPJ, |
| ContinuousLinearMap.comp_id,planeTrace_square] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma planeDivergence_eq_trace (F : Plane → Plane) (y : Plane) : |
| planeDivergence F y=planeTrace (fderiv ℝ F y) := by |
| simp only [planeDivergence,planeTrace,Fin.sum_univ_two] |
|
|
| lemma cmcFlux_gradient_fderiv {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (y : Plane) : |
| fderiv ℝ (fun z ↦ cmcFlux (gradient g z)) y=graphShapeOperator g y := by |
| exact ((cmcFlux_hasFDerivAt (gradient g y)).comp y |
| (((plane_gradient_contDiff hg).differentiable (by simp) y).hasFDerivAt)).fderiv |
|
|
| theorem graphUnitNormalExtension_divergence (a : Cover) {n : Cover} (hn : ‖n‖=1) |
| {g : Plane → ℝ} (hg : ContDiff ℝ (⊤ : ℕ∞) g) (x : Cover) : |
| divergence (graphUnitNormalExtension a n g) x= |
| -planeDivergence (fun z ↦ cmcFlux (gradient g z)) |
| (normalPlaneCoordinates n (x-a)) := by |
| rw [divergence_eq_coverTrace,graphUnitNormalExtension_fderiv a hn hg] |
| have hneg (L : Cover →L[ℝ] Cover) : coverTrace (-L)= -coverTrace L := by |
| simp [coverTrace,Finset.sum_neg_distrib] |
| rw [hneg,rectangular_trace,ContinuousLinearMap.comp_assoc, |
| normalGraph_projection_differential hn hg,ContinuousLinearMap.comp_id, |
| planeDivergence_eq_trace,cmcFlux_gradient_fderiv hg] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma planeTrace_comp_comm (A B : Plane →L[ℝ] Plane) : |
| planeTrace (A.comp B)=planeTrace (B.comp A) := by |
| simp only [planeTrace,Fin.sum_univ_two,ContinuousLinearMap.comp_apply] |
| rw [plane_decompose (B (EuclideanSpace.single 0 1)), |
| plane_decompose (B (EuclideanSpace.single 1 1)), |
| plane_decompose (A (EuclideanSpace.single 0 1)), |
| plane_decompose (A (EuclideanSpace.single 1 1))] |
| simp only [map_add,map_smul,PiLp.add_apply,PiLp.smul_apply,smul_eq_mul] |
| ring |
|
|
| lemma planeTraceSquare_comp_comm (A B : Plane →L[ℝ] Plane) : |
| planeTraceSquare (A.comp B)=planeTraceSquare (B.comp A) := by |
| rw [← planeTrace_square,← planeTrace_square] |
| calc |
| _ = planeTrace (A.comp ((B.comp A).comp B)) := by |
| congr 1 |
| _ = planeTrace (((B.comp A).comp B).comp A) := planeTrace_comp_comm _ _ |
| _ = _ := by congr 1 |
|
|
| lemma planeTraceSquare_symmetric {L : Plane →L[ℝ] Plane} |
| (hL : ∀ v w : Plane,⟪L v,w⟫=⟪v,L w⟫) : |
| 0≤planeTraceSquare L ∧ (planeTrace L)^2≤2*planeTraceSquare L := by |
| have hc : L (EuclideanSpace.single 0 1) 1=L (EuclideanSpace.single 1 1) 0 := by |
| simpa only [EuclideanSpace.inner_single_right,EuclideanSpace.inner_single_left, |
| conj_trivial,one_mul] using hL (EuclideanSpace.single 0 1) (EuclideanSpace.single 1 1) |
| simp only [planeTraceSquare,planeTrace,Fin.sum_univ_two,hc] |
| constructor |
| · nlinarith [sq_nonneg (L (EuclideanSpace.single 0 1) 0), |
| sq_nonneg (L (EuclideanSpace.single 1 1) 0),sq_nonneg (L (EuclideanSpace.single 1 1) 1)] |
| · nlinarith [sq_nonneg (L (EuclideanSpace.single 0 1) 0-L (EuclideanSpace.single 1 1) 1), |
| sq_nonneg (L (EuclideanSpace.single 1 1) 0)] |
|
|
| theorem graph_curvature_nonnegative {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (y : Plane) : |
| 0≤graphSquaredSecondFundamentalForm g y ∧ |
| (planeDivergence (fun z ↦ cmcFlux (gradient g z)) y)^2≤ |
| 2*graphSquaredSecondFundamentalForm g y := by |
| let p := gradient g y |
| let L := fderiv ℝ (gradient g) y |
| let C := cmcCompress p |
| let D := (cmcWeight p)⁻¹ • (C.comp L) |
| have hS : graphShapeOperator g y=C.comp D := by |
| apply ContinuousLinearMap.ext |
| intro v |
| change cmcJacobian p (L v)=C (D v) |
| change cmcJacobian p (L v)=C ((cmcWeight p)⁻¹ • C (L v)) |
| rw [map_smul] |
| exact cmcJacobian_compress p (L v) |
| have hB : ∀ v w : Plane,⟪(D.comp C) v,w⟫=⟪v,(D.comp C) w⟫ := by |
| intro v w |
| change ⟪(cmcWeight p)⁻¹ • C (L (C v)),w⟫= |
| ⟪v,(cmcWeight p)⁻¹ • C (L (C w))⟫ |
| rw [real_inner_smul_left,real_inner_smul_right] |
| congr 1 |
| rw [cmcCompress_symm,plane_hessian_symmetric hg, |
| ← cmcCompress_symm] |
| have hh := planeTraceSquare_symmetric hB |
| unfold graphSquaredSecondFundamentalForm |
| rw [hS,planeTraceSquare_comp_comm] |
| refine ⟨hh.1,?_⟩ |
| rw [planeDivergence_eq_trace,cmcFlux_gradient_fderiv hg,hS,planeTrace_comp_comm] |
| exact hh.2 |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma planeTraceSquare_symmetric_eq_zero {L : Plane →L[ℝ] Plane} |
| (hL : ∀ v w : Plane,⟪L v,w⟫=⟪v,L w⟫) (hz : planeTraceSquare L=0) : L=0 := by |
| have hc : L (EuclideanSpace.single 0 1) 1=L (EuclideanSpace.single 1 1) 0 := by |
| simpa only [EuclideanSpace.inner_single_right,EuclideanSpace.inner_single_left, |
| conj_trivial,one_mul] using hL (EuclideanSpace.single 0 1) (EuclideanSpace.single 1 1) |
| simp only [planeTraceSquare,hc] at hz |
| have h00 : L (EuclideanSpace.single 0 1) 0=0 := by nlinarith [sq_nonneg (L (EuclideanSpace.single 1 1) 0),sq_nonneg (L (EuclideanSpace.single 1 1) 1)] |
| have h10 : L (EuclideanSpace.single 1 1) 0=0 := by nlinarith [sq_nonneg (L (EuclideanSpace.single 0 1) 0),sq_nonneg (L (EuclideanSpace.single 1 1) 1)] |
| have h11 : L (EuclideanSpace.single 1 1) 1=0 := by nlinarith [sq_nonneg (L (EuclideanSpace.single 0 1) 0),sq_nonneg (L (EuclideanSpace.single 1 1) 0)] |
| apply ContinuousLinearMap.ext |
| intro v |
| rw [plane_decompose v,map_add,map_smul,map_smul] |
| ext i |
| fin_cases i < |
|
|
| theorem graph_curvature_zero_fderiv_gradient {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (y : Plane) |
| (hz : graphSquaredSecondFundamentalForm g y=0) : |
| fderiv ℝ (gradient g) y=0 := by |
| let p := gradient g y |
| let L := fderiv ℝ (gradient g) y |
| let C := cmcCompress p |
| let D := (cmcWeight p)⁻¹ • (C.comp L) |
| have hS : graphShapeOperator g y=C.comp D := by |
| apply ContinuousLinearMap.ext |
| intro v |
| change cmcJacobian p (L v)=C ((cmcWeight p)⁻¹ • C (L v)) |
| rw [map_smul] |
| exact cmcJacobian_compress p (L v) |
| have hB : ∀ v w : Plane,⟪(D.comp C) v,w⟫=⟪v,(D.comp C) w⟫ := by |
| intro v w |
| change ⟪(cmcWeight p)⁻¹ • C (L (C v)),w⟫=⟪v,(cmcWeight p)⁻¹ • C (L (C w))⟫ |
| rw [real_inner_smul_left,real_inner_smul_right] |
| congr 1 |
| rw [cmcCompress_symm,plane_hessian_symmetric hg,← cmcCompress_symm] |
| have hzB : D.comp C=0 := by |
| apply planeTraceSquare_symmetric_eq_zero hB |
| change planeTraceSquare (graphShapeOperator g y)=0 at hz |
| rwa [hS,planeTraceSquare_comp_comm] at hz |
| apply ContinuousLinearMap.ext |
| intro v |
| have hv := congrArg (fun A : Plane →L[ℝ] Plane ↦ A (cmcStretch p v)) hzB |
| change (cmcWeight p)⁻¹ • cmcCompress p (L (cmcCompress p (cmcStretch p v)))=0 at hv |
| rw [cmcCompress_stretch] at hv |
| have hv' : cmcCompress p (L v)=0 := (smul_eq_zero.mp hv).resolve_left (inv_ne_zero (cmcWeight_pos p).ne') |
| have hh := congrArg (cmcStretch p) hv' |
| simpa only [cmcStretch_compress,map_zero,zero_apply] using hh |
| |
| theorem graph_curvature_zero_affine {g : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) {r : ℝ} (hr : 0<r) |
| (hz : ∀ y∈Metric.ball (0 : Plane) r,graphSquaredSecondFundamentalForm g y=0) : |
| ∀ y∈Metric.ball (0 : Plane) r,g y=g 0+⟪gradient g 0,y⟫ := by |
| have h0 : (0 : Plane)∈Metric.ball (0 : Plane) r := Metric.mem_ball_self hr |
| have hd := (plane_gradient_contDiff hg).differentiable (by simp) |
| have hgrad (y : Plane) (hy : y∈Metric.ball (0 : Plane) r) : gradient g y=gradient g 0 := by |
| apply (convex_ball (0 : Plane) r).is_const_of_fderivWithin_eq_zero hd.differentiableOn _ hy h0 |
| intro z hz' |
| rw [fderivWithin_of_isOpen Metric.isOpen_ball hz'] |
| exact graph_curvature_zero_fderiv_gradient hg z (hz z hz') |
| let F : Plane → ℝ := fun y ↦ g 0+⟪gradient g 0,y⟫ |
| have hF : Differentiable ℝ F := fun _ ↦ ((innerSL ℝ (gradient g 0)).hasFDerivAt.const_add (g 0)).differentiableAt |
| refine Metric.isOpen_ball.eqOn_of_fderiv_eq (convex_ball (0 : Plane) r).isPreconnected |
| (hg.differentiable (by simp)).differentiableOn hF.differentiableOn ?_ h0 ?_ |
| · intro z hz' |
| change fderiv ℝ g z=fderiv ℝ (fun y ↦ g 0+(innerSL ℝ (gradient g 0)) y) z |
| rw [((innerSL ℝ (gradient g 0)).hasFDerivAt.const_add (g 0)).fderiv] |
| apply ContinuousLinearMap.ext |
| intro v |
| change fderiv ℝ g z v=⟪gradient g 0,v⟫ |
| rw [← inner_gradient_left,hgrad z hz'] |
| · simp only [inner_zero_right,add_zero] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem normalMeasure_graph_normal_ae {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {U : Set Cover} (a : Cover) {n : Cover} (hn : ‖n‖=1) |
| {g : Plane → ℝ} {K : ℝ≥0} (hg : LipschitzWith K g) {R : ℝ} |
| (hc : ∀ y∈Metric.closedBall (0 : Plane) R,ContinuousAt (fderiv ℝ g) y) |
| (hgraph : ∀ᵐ x : Cover ∂volume,x∈U → |
| (quotientMap x∈E ↔ ⟪n,x-a⟫<graphHeightExtension a n g x)) |
| {φ : Cover → ℝ} (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) (hsφ : HasCompactSupport φ) |
| (hφU : tsupport φ⊆U) (hφO : tsupport φ⊆{x | ∀ i,0<x i ∧ x i<1}) |
| (hφR : tsupport φ⊆Metric.closedBall a R) (hφb : ∀ x,φ x∈Icc 0 1) : |
| ∀ᵐ z ∂(μ : Measure NormalBundle),0<φ z.1 → |
| (z.2 : Cover)=graphUnitNormalExtension a n g z.1 := by |
| have hflux (F : Cover → Cover) (hF : ContDiff ℝ (⊤ : ℕ∞) F) |
| (hs : HasCompactSupport F) (hO : tsupport F⊆{x | ∀ i,0<x i ∧ x i<1}) |
| (_hb : ∀ x,‖F x‖≤1) := normalCoverMeasure_local_flux hE hμ hF hs hO |
| have h := cutoff_graph_patch_normal_ae (hE.preimage measurable_quotientMap) a hn hg hc |
| hgraph (normalMeasure_cutoff_saturation hμ _) hflux hφ hsφ hφU hφO hφR hφb |
| have hO : MeasurableSet {z : BlowupNormalBundle | ∀ i,0<z.1 i ∧ z.1 i<1} := by |
| simp only [Set.ofPred_forall] |
| apply MeasurableSet.iInter |
| intro i |
| have hm : Measurable (fun z : BlowupNormalBundle ↦ z.1 i) := by fun_prop |
| exact (measurableSet_lt measurable_const hm).inter |
| (measurableSet_lt hm measurable_const) |
| have h' : ∀ᵐ z ∂(normalCoverMeasure μ : Measure BlowupNormalBundle), |
| 0<φ z.1 → (z.2 : Cover)=graphUnitNormalExtension a n g z.1 := by |
| have hh := (ae_restrict_iff' hO).mp h |
| filter_upwards [hh] with z hz hpos |
| exact hz (hφO (subset_tsupport _ (show φ z.1≠0 from hpos.ne'))) hpos |
| have hm : (normalCoverMeasure μ : Measure BlowupNormalBundle)= |
| Measure.map normalCoverMap (μ : Measure NormalBundle) := FiniteMeasure.toMeasure_map μ normalCoverMap |
| rw [hm] at h' |
| exact ae_of_ae_map continuous_normalCoverMap.measurable.aemeasurable h' |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| |
| def translateNormal (a : Cover) (z : NormalBundle) : NormalBundle := |
| (cubeRepresentative (quotientMap z.1-quotientMap a),z.2) |
| |
| lemma measurable_translateNormal (a : Cover) : Measurable (translateNormal a) := by |
| exact (measurable_cubeRepresentative.comp ((measurable_quotientMap.comp |
| (measurable_subtype_coe.comp measurable_fst)).sub measurable_const)).prodMk measurable_snd |
| |
| lemma translateNormal_periodic_eval {Y : Type*} {F : Cover → Y} |
| (hp : ∀ m x,F (x+latticeVector m)=F x) (a : Cover) (z : NormalBundle) : |
| F (translateNormal a z).1=F ((z.1 : Cover)-a) := by |
| change F (representative (quotientMap z.1-quotientMap a))=F ((z.1 : Cover)-a) |
| rw [← quotientMap_sub] |
| exact periodic_representative hp _ |
| |
| theorem isNormalMeasure_translation {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (a : Cover) : |
| IsNormalMeasure ((fun z ↦ z+quotientMap a) ⁻¹' E) (μ.map (translateNormal a)) := by |
| constructor |
| · have hm : ((μ.map (translateNormal a)).mass : ℝ)=(μ.mass : ℝ) := by |
| have hh := congrArg ENNReal.toReal (Measure.map_apply (measurable_translateNormal a) |
| 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,perimeter_translation_measurable hE] |
| · intro F hF |
| change (∫ z,normalTest F hF.1.continuous z |
| ∂Measure.map (translateNormal a) (μ : Measure NormalBundle))=_ |
| rw [integral_map (measurable_translateNormal a).aemeasurable |
| (normalTest F hF.1.continuous).continuous.aestronglyMeasurable, |
| flux_translation hF a hE] |
| have hG : AdmissibleField (fun x ↦ F (x-a)) := by |
| simpa only [sub_eq_add_neg] using admissible_translate hF (-a) |
| rw [← hμ.2 _ hG] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun z ↦ by |
| change ⟪(z.2 : Cover),F (translateNormal a z).1⟫=⟪(z.2 : Cover),F ((z.1 : Cover)-a)⟫ |
| rw [translateNormal_periodic_eval hF.2.1] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def cmcGraphJacobi (g φ ψ : Plane → ℝ) : ℝ := |
| graphJacobiForm (fun y ↦ cmcJacobian (gradient g y)) |
| (fun y ↦ cmcWeight (gradient g y)) φ ψ |
|
|
| lemma cmcGraphJacobi_div_transform {g f ψ : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hc : HasCompactSupport ψ) : |
| cmcGraphJacobi g (fun y ↦ f y/cmcWeight (gradient g y)) ψ= |
| ∫ y,⟪gradient f y,cmcJacobian (gradient g y) |
| (gradient (fun z ↦ cmcWeight (gradient g z)*ψ z) y)⟫ := by |
| have hp := plane_gradient_contDiff hg |
| have hq := cmcWeight_contDiff.comp hp |
| have he (y : Plane) : cmcWeight (gradient g y)*(f y/cmcWeight (gradient g y))=f y := by |
| exact mul_div_cancel₀ _ (cmcWeight_pos _).ne' |
| have hA : ContDiff ℝ (⊤ : ℕ∞) (fun y ↦ cmcJacobian (gradient g y)) := |
| cmcJacobian_contDiff.comp hp |
| have hq' : ContDiff ℝ (⊤ : ℕ∞) (fun y ↦ cmcWeight (gradient g y)) := hq |
| have hquot : ContDiff ℝ (⊤ : ℕ∞) (fun y ↦ f y/cmcWeight (gradient g y)) := |
| hf.div hq (fun y ↦ (cmcWeight_pos _).ne') |
| have ht := graphJacobiForm_transform hA |
| (fun y v w ↦ (cmcJacobian_symmetric (gradient g y) v w).trans (real_inner_comm _ _)) hq' |
| hquot hψ hc |
| have hefun : (fun z ↦ cmcWeight (gradient g z)*(f z/cmcWeight (gradient g z)))=f := funext he |
| rw [hefun] at ht |
| exact ht |
|
|
| theorem LinearCMCEquation.normal_jacobi {g f : Plane → ℝ} {U : Set Plane} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (hw : LinearCMCEquation f (gradient g) (fun _ ↦ 0) U) |
| {ψ : Plane → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) |
| (hc : HasCompactSupport ψ) (hs : tsupport ψ⊆U) : |
| cmcGraphJacobi g (fun y ↦ f y/cmcWeight (gradient g y)) ψ=0 := by |
| rw [cmcGraphJacobi_div_transform hg hf hψ hc] |
| have hq := cmcWeight_contDiff.comp (plane_gradient_contDiff hg) |
| have hh := hw (fun y ↦ cmcWeight (gradient g y)*ψ y) (hq.mul hψ) hc.mul_left |
| (tsupport_mul_subset_right.trans hs) |
| simp only [sub_zero,← inner_gradient_left] at hh |
| convert hh using 1 |
| congr 1 |
| funext y |
| rw [cmcJacobian_symmetric,real_inner_comm] |
|
|
| theorem cmcGraphJacobi_vertical {g ψ : Plane → ℝ} |
| (hg : ContDiff ℝ (⊤ : ℕ∞) g) (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) |
| (hc : HasCompactSupport ψ) : |
| cmcGraphJacobi g (fun y ↦ 1/cmcWeight (gradient g y)) ψ=0 := by |
| rw [cmcGraphJacobi_div_transform hg contDiff_const hψ hc] |
| simp [gradient] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma smooth_graph_extension {g : Plane → ℝ} {R : ℝ} (hR : 0<R) |
| (hg : ContDiffOn ℝ (⊤ : ℕ∞) g (Metric.ball 0 R)) : |
| ∃ f : Plane → ℝ,ContDiff ℝ (⊤ : ℕ∞) f ∧ EqOn f g (Metric.ball 0 (R/2)) := by |
| let b : ContDiffBump (0 : Plane) := ⟨R/2,3*R/4,by linarith,by linarith⟩ |
| have hs : tsupport b⊆Metric.ball 0 R := by |
| rw [b.tsupport_eq] |
| exact Metric.closedBall_subset_ball (by dsimp [b] |
| refine ⟨fun y ↦ b y*g y,?_,?_⟩ |
| · exact contDiff_local_vector_cutoff Metric.isOpen_ball hg b.contDiff hs |
| · intro y hy |
| change b y*g y=g y |
| rw [b.one_of_mem_closedBall (Metric.ball_subset_closedBall hy),one_mul] |
|
|
| theorem WeakCMCGraph.coordinate_jacobi_chart {g : Plane → ℝ} {K : ℝ≥0} |
| (hg : LipschitzWith K g) (hK : (K:ℝ)≤1) {H R : ℝ} (hR : 0<R) |
| (hgc : ContDiffOn ℝ (⊤ : ℕ∞) g (Metric.ball 0 R)) |
| (hw : WeakCMCGraph g H (Metric.ball 0 R)) : |
| ∃ (f : Plane → ℝ) (r : ℝ),0<r ∧ r≤R ∧ ContDiff ℝ (⊤ : ℕ∞) f ∧ |
| EqOn f g (Metric.ball 0 r) ∧ |
| (∀ i : Fin 2,LinearCMCEquation (fun y ↦ fderiv ℝ f y (EuclideanSpace.single i 1)) |
| (gradient f) (fun _ ↦ 0) (Metric.ball 0 r)) ∧ |
| ∀ i : Fin 2,∀ ψ : Plane → ℝ,ContDiff ℝ (⊤ : ℕ∞) ψ → |
| HasCompactSupport ψ → tsupport ψ⊆Metric.ball 0 r → |
| cmcGraphJacobi f (fun y ↦ fderiv ℝ f y (EuclideanSpace.single i 1)/ |
| cmcWeight (gradient f y)) ψ=0 := by |
| obtain ⟨f,hfc,hfe⟩ := smooth_graph_extension hR hgc |
| have he : f=ᶠ[𝓝 0]g := by |
| filter_upwards [Metric.isOpen_ball.mem_nhds (show (0 : Plane)∈Metric.ball 0 (R/2) by simp |
| exact hfe hy |
| have hgc0 : ContDiffAt ℝ (⊤ : ℕ∞) g 0 := hgc.contDiffAt |
| (Metric.isOpen_ball.mem_nhds (by simpa using hR)) |
| have hnear (i : Fin 2) : LinearCMCEquationNear |
| (fun y ↦ fderiv ℝ f y (EuclideanSpace.single i 1)) (gradient f) (fun _ ↦ 0) := by |
| have hh := hw.directional_linear_near hg hK hR (hgc.of_le (by simp)) |
| (ContDiffAt.holderJet (n := 2) (hgc0.of_le (by |
| change ((3 : ℕ∞) : WithTop ℕ∞)≤↑(⊤ : ℕ∞) |
| exact WithTop.coe_le_coe.mpr le_top))) |
| (EuclideanSpace.single i 1) (by simp) |
| apply hh.congr |
| · exact (he.fderiv (𝕜 := ℝ)).mono fun _ hy ↦ congrArg (fun L : Plane →L[ℝ] ℝ ↦ L (EuclideanSpace.single i 1)) hy |
| · exact (he.fderiv (𝕜 := ℝ)).mono fun _ hy ↦ by simp only [gradient,hy] |
| · exact EventuallyEq.rfl |
| obtain ⟨r0,hr0,h0⟩ := hnear 0 |
| obtain ⟨r1,hr1,h1⟩ := hnear 1 |
| let r := min (R/2) (min r0 r1) |
| have hr : 0<r := lt_min (by linarith) (lt_min hr0 hr1) |
| have hrR : r≤R/2 := min_le_left _ _ |
| have hlin (i : Fin 2) : LinearCMCEquation (fun y ↦ fderiv ℝ f y (EuclideanSpace.single i 1)) |
| (gradient f) (fun _ ↦ 0) (Metric.ball 0 r) := by |
| fin_cases i |
| · exact h0.mono (Metric.ball_subset_ball ((min_le_right _ _).trans (min_le_left _ _))) |
| · exact h1.mono (Metric.ball_subset_ball ((min_le_right _ _).trans (min_le_right _ _))) |
| refine ⟨f,r,hr,by linarith,hfc,hfe.mono (Metric.ball_subset_ball hrR),hlin,?_⟩ |
| intro i ψ hψ hc hs |
| exact (hlin i).normal_jacobi hfc |
| ((hfc.fderiv_right (by simp)).clm_apply contDiff_const) hψ hc hs |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem actual_centered_normal_patch {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) |
| (hcenter : quotientMap cubeCenter∈frontier (openRepresentative E)) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) : |
| ∃ (χ : Cover → ℝ) (N : Cover → Cover), |
| ContDiff ℝ (⊤ : ℕ∞) χ ∧ ContDiff ℝ (⊤ : ℕ∞) N ∧ |
| (∀ m x,χ (x+latticeVector m)=χ x) ∧ |
| (∀ m x,N (x+latticeVector m)=N x) ∧ |
| (∀ x,0≤χ x) ∧ (∀ᶠ x in 𝓝 cubeCenter,χ x=1) ∧ |
| ∀ᵐ z ∂(μ : Measure NormalBundle),0<χ z.1 → N z.1=(z.2 : Cover) := by |
| obtain ⟨n,g,r,H,hn,hr,hg,hg0,hgc,_,hcover,_,_⟩ := |
| isMinimizerAt_smooth_CMC hV hE hmin (quotientMap cubeCenter) hcenter |
| obtain ⟨f,hf,hfg⟩ := smooth_graph_extension hr hgc |
| have hcover' (x : Cover) (hx : x∈Metric.ball (0 : Cover) (r/2)) : |
| quotientMap (cubeCenter+x)∈frontier (openRepresentative E) ↔ |
| normalGraph n g (normalPlaneCoordinates n x)=x := by |
| rw [quotientMap_add] |
| exact hcover x ((Metric.ball_subset_ball (by linarith)) hx) |
| obtain ⟨R,ρ,U,hRr,_,_,_,hR,hρ,hgC,hU,hρU,hUR,hUO,_,hphase⟩ := |
| actual_centered_graph_phase_patch hV hE hmin hcenter hn (by linarith : 0<r/2) |
| hg hg0 ((hgc.of_le (by simp)).mono (Metric.ball_subset_ball (by linarith))) hcover' |
| let φ := radialHeightCutoff cubeCenter ρ |
| have hφ : ContDiff ℝ (⊤ : ℕ∞) φ := radialDensityWeight_contDiff _ _ _ |
| have hsφ : HasCompactSupport φ := radialDensityWeight_hasCompactSupport (by positivity) (by positivity) |
| have hφs : tsupport φ⊆Metric.closedBall cubeCenter (2*ρ) := |
| radialDensityWeight_tsupport (by positivity) (by positivity) |
| have hφU := hφs.trans hρU |
| have hφO := hφU.trans hUO |
| have hφR := hφU.trans (hUR.trans Metric.ball_subset_closedBall) |
| have hφb (x : Cover) : φ x∈Icc 0 1 := |
| ⟨radialDensityWeight_nonneg _ _ _ _,radialDensityWeight_le_one _ _ _ _⟩ |
| have hdc (y : Plane) (hy : y∈Metric.closedBall (0 : Plane) R) : ContinuousAt (fderiv ℝ g) y := |
| (hgC y hy).continuousAt_fderiv (by norm_num) |
| have hNfg (x : Cover) (hx : x∈tsupport φ) : |
| graphUnitNormalExtension cubeCenter n f x=graphUnitNormalExtension cubeCenter n g x := by |
| have hp : normalPlaneCoordinates n (x-cubeCenter)∈Metric.ball (0 : Plane) (r/2) := by |
| rw [Metric.mem_ball,dist_zero_right] |
| have hnorm : ‖x-cubeCenter‖<R := by |
| simpa only [Metric.mem_ball,dist_eq_norm] using hUR (hφU hx) |
| exact (normalPlaneCoordinates_norm_le _ _).trans_lt (hnorm.trans hRr) |
| have he : f=ᶠ[𝓝 (normalPlaneCoordinates n (x-cubeCenter))]g := by |
| filter_upwards [Metric.isOpen_ball.mem_nhds hp] with y hy |
| exact hfg hy |
| simp only [graphUnitNormalExtension,gradient,he.fderiv_eq] |
| have hsign : ∃ N0 : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) N0 ∧ |
| ∀ᵐ z ∂(μ : Measure NormalBundle),0<φ z.1 → N0 z.1=(z.2 : Cover) := by |
| rcases hphase with hphase|hphase |
| · have hp : ∀ᵐ x : Cover ∂volume,x∈U → |
| (quotientMap x∈E ↔ ⟪n,x-cubeCenter⟫<graphHeightExtension cubeCenter n g x) := by |
| simpa only [graphSignedHeight,sub_neg] using hphase |
| refine ⟨graphUnitNormalExtension cubeCenter n f,graphUnitNormalExtension_contDiff _ hn hf,?_⟩ |
| filter_upwards [normalMeasure_graph_normal_ae hE hμ cubeCenter hn hg hdc hp |
| hφ hsφ hφU hφO hφR hφb] with z hz hpos |
| rw [hNfg _ (subset_tsupport _ hpos.ne')] |
| exact (hz hpos).symm |
| · have hp : ∀ᵐ x : Cover ∂volume,x∈U → |
| (x∈quotientMap ⁻¹' E ↔ graphHeightExtension cubeCenter n g x<⟪n,x-cubeCenter⟫) := by |
| simpa only [graphSignedHeight,sub_pos,mem_preimage] using hphase |
| have hp' := graph_superlevel_compl_ae cubeCenter hn hg.continuous hp |
| have hh := normalMeasure_graph_normal_ae hE.compl (isNormalMeasure_compl hE hμ) |
| cubeCenter hn hg hdc hp' hφ hsφ hφU hφO hφR hφb |
| have hm : ∀ᵐ z ∂(μ : Measure NormalBundle),0<φ z.1 → |
| -(z.2 : Cover)=graphUnitNormalExtension cubeCenter n g z.1 := |
| ae_of_ae_map continuous_reverseNormal.measurable.aemeasurable hh |
| refine ⟨fun x ↦ -graphUnitNormalExtension cubeCenter n f x, |
| (graphUnitNormalExtension_contDiff _ hn hf).neg,?_⟩ |
| filter_upwards [hm] with z hz hpos |
| rw [hNfg _ (subset_tsupport _ hpos.ne'),← hz hpos,neg_neg] |
| obtain ⟨N0,hN0,hNae⟩ := hsign |
| let ψ := radialHeightCutoff cubeCenter (ρ/4) |
| have hψ : ContDiff ℝ (⊤ : ℕ∞) ψ := radialDensityWeight_contDiff _ _ _ |
| have hsψ : HasCompactSupport ψ := radialDensityWeight_hasCompactSupport (by positivity) (by positivity) |
| have hψs : tsupport ψ⊆Metric.closedBall cubeCenter (ρ/2) := by |
| have hh := radialDensityWeight_tsupport (a := cubeCenter) |
| (by positivity : 0≤2*(ρ/4)) (by positivity : 0<3*(ρ/4)^2) |
| convert hh using 1 |
| congr 1 |
| ring_nf |
| have hψφ (x : Cover) (hx : x∈tsupport ψ) : φ x=1 := |
| radialHeightCutoff_one hρ ((Metric.closedBall_subset_closedBall (by linarith)) (hψs hx)) |
| have hψO : tsupport ψ⊆{x | ∀ i,0<x i ∧ x i<1} := |
| hψs.trans ((Metric.closedBall_subset_closedBall (by linarith)).trans (hρU.trans hUO)) |
| let F : Cover → Cover := fun x ↦ φ x • N0 x |
| have hF : ContDiff ℝ (⊤ : ℕ∞) F := hφ.smul hN0 |
| have hsF : HasCompactSupport F := hsφ.smul_right |
| have hFO : tsupport F⊆{x | ∀ i,0<x i ∧ x i<1} := |
| (tsupport_smul_subset_left _ _).trans hφO |
| refine ⟨latticePeriodize ψ,latticePeriodize F,latticePeriodize_contDiff hψ hsψ, |
| latticePeriodize_contDiff hF hsF,latticePeriodize_periodic ψ,latticePeriodize_periodic F,?_,?_,?_⟩ |
| · intro x |
| apply tsum_nonneg |
| intro m |
| exact radialDensityWeight_nonneg _ _ _ _ |
| · have he := latticePeriodize_eventuallyEq hsψ hψO |
| (show ∀ i,0≤cubeCenter i ∧ cubeCenter i≤1 by intro i; norm_num [cubeCenter]) |
| filter_upwards [he,Metric.ball_mem_nhds cubeCenter (by positivity : 0<ρ/4)] with x hx hb |
| rw [hx] |
| exact radialHeightCutoff_one (by positivity) (Metric.ball_subset_closedBall hb) |
| · filter_upwards [hNae] with z hz hpos |
| have he := (latticePeriodize_eventuallyEq hsψ hψO (compactCell_coordinates z.1)).eq_of_nhds |
| rw [he] at hpos |
| have hone := hψφ _ (subset_tsupport _ hpos.ne') |
| rw [(latticePeriodize_eventuallyEq hsF hFO (compactCell_coordinates z.1)).eq_of_nhds] |
| change φ z.1 • N0 z.1=(z.2 : Cover) |
| rw [hone,one_smul] |
| exact hz (by rw [hone] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def cofactorOperator : (Cover →L[ℝ] Cover) →L[ℝ] (Cover →L[ℝ] Cover) := |
| ({toFun := fun L ↦ coverTrace L • ContinuousLinearMap.id ℝ Cover-L.adjoint, |
| map_add' := by intro L M; simp only [coverTrace_add,map_add]; module, |
| map_smul' := by intro a L |
| (Cover →L[ℝ] Cover) →ₗ[ℝ] (Cover →L[ℝ] Cover)).toContinuousLinearMap |
|
|
| @[simp] lemma cofactorOperator_apply (L : Cover →L[ℝ] Cover) (n : Cover) : |
| cofactorOperator L n=cofactorLinear L n := rfl |
|
|
| lemma cofactorLinear_smul (c : ℝ) (L : Cover →L[ℝ] Cover) (n : Cover) : |
| cofactorLinear (c • L) n=c • cofactorLinear L n := by |
| change cofactorOperator (c • L) n=c • cofactorOperator L n |
| rw [map_smul] |
| rfl |
|
|
| lemma cofactorLinear_inner (L : Cover →L[ℝ] Cover) {n : Cover} (hn : ‖n‖=1) : |
| ⟪n,cofactorLinear L n⟫=coverTrace L-⟪n,L n⟫ := by |
| simp only [cofactorLinear,inner_sub_right,real_inner_smul_right, |
| real_inner_self_eq_norm_sq,hn,one_pow,mul_one,ContinuousLinearMap.adjoint_inner_right] |
| rw [real_inner_comm] |
|
|
| lemma cofactorQuadratic_smulRight (l : Cover →L[ℝ] ℝ) (v n : Cover) : |
| cofactorQuadratic (l.smulRight v) n=0 := by |
| have hc : (l.smulRight v).comp (l.smulRight v)=l v • l.smulRight v := by |
| apply ContinuousLinearMap.ext |
| intro x |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.smulRight_apply, |
| map_smul,smul_apply] |
| module |
| have ha : (l.smulRight v).adjoint ((l.smulRight v).adjoint n)= |
| l v • (l.smulRight v).adjoint n := by |
| have hh := congrArg (fun L : Cover →L[ℝ] Cover ↦ L.adjoint n) hc |
| simpa only [ContinuousLinearMap.adjoint_comp,ContinuousLinearMap.comp_apply, |
| map_smul,starRingEnd_apply,star_trivial,smul_apply] using hh |
| simp only [cofactorQuadratic,hc,coverTrace_smulRight,coverTrace_smul,ha] |
| module |
|
|
| lemma cofactorLinear_coordinate {f : Cover → ℝ} {point : Cover} |
| (hf : DifferentiableAt ℝ f point) |
| (i : Fin 3) (n : Cover) : |
| cofactorLinear (fderiv ℝ (fun y ↦ f y • EuclideanSpace.single i 1) point) n= |
| coordinateNormalVelocity i f point n := by |
| rw [fderiv_smul_const hf] |
| have ha : ((fderiv ℝ f point).smulRight (EuclideanSpace.single i (1 : ℝ))).adjoint n= |
| ⟪n,EuclideanSpace.single i 1⟫ • gradient f point := by |
| apply ext_inner_right ℝ |
| intro v |
| rw [ContinuousLinearMap.adjoint_inner_left,ContinuousLinearMap.smulRight_apply, |
| real_inner_smul_right,real_inner_smul_left,inner_gradient_left] |
| ring |
| simp only [cofactorLinear,coverTrace_smulRight,ha,coordinateNormalVelocity] |
|
|
| lemma cofactor_field_derivative {G : Cover → Cover} (hG : ContDiff ℝ (⊤ : ℕ∞) G) |
| (x n u v : Cover) : |
| fderiv ℝ (fun p : Cover×Cover ↦ cofactorLinear (fderiv ℝ G p.1) p.2) (x,n) (u,v)= |
| cofactorLinear (fderiv ℝ (fderiv ℝ G) x u) n+ |
| cofactorLinear (fderiv ℝ G x) v := by |
| have hg : ContDiff ℝ (⊤ : ℕ∞) (fderiv ℝ G) := hG.fderiv_right (by simp) |
| have hfst : HasFDerivAt (fun p : Cover×Cover ↦ p.1) (ContinuousLinearMap.fst ℝ Cover Cover) (x,n) := hasFDerivAt_fst |
| have hsnd : HasFDerivAt (fun p : Cover×Cover ↦ p.2) (ContinuousLinearMap.snd ℝ Cover Cover) (x,n) := hasFDerivAt_snd |
| have hd := ((cofactorOperator.hasFDerivAt.comp (x,n) |
| ((hg.differentiable (by simp) x).hasFDerivAt.comp (x,n) hfst)).clm_apply |
| hsnd).fderiv |
| change fderiv ℝ (fun p : Cover×Cover ↦ cofactorOperator (fderiv ℝ G p.1) p.2) (x,n) (u,v)=_ |
| simp only [Function.comp_def] at hd |
| rw [hd] |
| simp only [add_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.flip_apply,cofactorOperator_apply] |
| rw [add_comm] |
| rfl |
|
|
| lemma derivative_transport {F G : Cover → Cover} |
| (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hG : ContDiff ℝ (⊤ : ℕ∞) G) (x : Cover) : |
| fderiv ℝ (fun y ↦ fderiv ℝ G y (F y)) x= |
| fderiv ℝ (fderiv ℝ G) x (F x)+(fderiv ℝ G x).comp (fderiv ℝ F x) := by |
| have hg : ContDiff ℝ (⊤ : ℕ∞) (fderiv ℝ G) := hG.fderiv_right (by simp) |
| rw [fderiv_clm_apply (hg.differentiable (by simp) x) |
| (hF.differentiable (by simp) x)] |
| have hs : (fderiv ℝ (fderiv ℝ G) x).flip (F x)=fderiv ℝ (fderiv ℝ G) x (F x) := by |
| apply ContinuousLinearMap.ext |
| intro v |
| exact (hG.contDiffAt.isSymmSndFDerivAt (by |
| simp only [minSmoothness_of_isRCLikeNormedField] |
| rw [hs,add_comm] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
| namespace Periodic |
|
|
| def variationField (a : Variation) (x : Cover) : Cover := |
| a.function x • EuclideanSpace.single a.coordinate 1 |
|
|
| lemma variationField_smooth (a : Variation) : ContDiff ℝ (⊤ : ℕ∞) (variationField a) := |
| a.smooth.smul contDiff_const |
|
|
| lemma variationField_periodic (a : Variation) (m : Fin 3 → ℤ) (x : Cover) : |
| variationField a (x+latticeVector m)=variationField a x := by |
| simp only [variationField,a.periodic] |
|
|
| lemma chainVelocity_append (l : List Variation) (a : Variation) : |
| chainVelocity (l++[a])=fun x ↦ chainVelocity l x+variationField a x := by |
| funext x |
| simp [chainVelocity,variationField,List.map_append] |
|
|
| lemma chainVelocity_smooth (l : List Variation) : ContDiff ℝ (⊤ : ℕ∞) (chainVelocity l) := by |
| induction l using List.reverseRecOn with |
| | nil => exact contDiff_const |
| | append_singleton l a ih => rw [chainVelocity_append] |
|
|
| lemma chainVelocity_periodic (l : List Variation) (m : Fin 3 → ℤ) (x : Cover) : |
| chainVelocity l (x+latticeVector m)=chainVelocity l x := by |
| unfold chainVelocity |
| congr 1 |
| apply List.map_congr_left |
| intro a _ |
| rw [a.periodic] |
|
|
| def motionJet (l : List Variation) (x : Cover) : Cover×Cover := |
| l.foldl (fun j a ↦ (j.1+variationField a x, |
| j.2+2 • fderiv ℝ (variationField a) x j.1)) (0,0) |
|
|
| lemma motionJet_append (l : List Variation) (a : Variation) (x : Cover) : |
| motionJet (l++[a]) x=((motionJet l x).1+variationField a x, |
| (motionJet l x).2+2 • fderiv ℝ (variationField a) x (motionJet l x).1) := by |
| simp only [motionJet,List.foldl_append,List.foldl_cons,List.foldl_nil] |
|
|
| lemma motionJet_first (l : List Variation) (x : Cover) : (motionJet l x).1=chainVelocity l x := by |
| induction l using List.reverseRecOn with |
| | nil => rfl |
| | append_singleton l a ih => simp only [motionJet_append,chainVelocity_append,ih] |
|
|
| lemma motionJet_smooth (l : List Variation) : ContDiff ℝ (⊤ : ℕ∞) (motionJet l) := by |
| induction l using List.reverseRecOn with |
| | nil => exact contDiff_const |
| | append_singleton l a ih => |
| have hd : ContDiff ℝ (⊤ : ℕ∞) (fderiv ℝ (variationField a)) := |
| (variationField_smooth a).fderiv_right (by simp) |
| simp_rw [show motionJet (l++[a])=(fun x ↦ ((motionJet l x).1+variationField a x, |
| (motionJet l x).2+2 • fderiv ℝ (variationField a) x (motionJet l x).1)) from funext (motionJet_append l a)] |
| exact (ih.fst.add (variationField_smooth a)).prodMk (ih.snd.add ((hd.clm_apply ih.fst).const_smul 2)) |
|
|
| lemma motionJet_periodic (l : List Variation) (m : Fin 3 → ℤ) (x : Cover) : |
| motionJet l (x+latticeVector m)=motionJet l x := by |
| induction l using List.reverseRecOn with |
| | nil => rfl |
| | append_singleton l a ih => |
| simp only [motionJet_append,ih,variationField_periodic, |
| fderiv_periodic (variationField_periodic a)] |
|
|
| lemma simultaneousMove_second_deriv (l : List Variation) (x : Cover) : |
| deriv (deriv (fun t ↦ chainMove (simultaneousChain l t) x)) 0=(motionJet l x).2 := by |
| induction l using List.reverseRecOn with |
| | nil => simp [simultaneousChain,chainMove,motionJet] |
| | append_singleton l a ih => |
| have hm : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainMove (simultaneousChain l t) x) := |
| (simultaneousMove_smooth l).comp (contDiff_id.prodMk contDiff_const) |
| have hf : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ variationField a (chainMove (simultaneousChain l t) x)) := (variationField_smooth a).comp hm |
| have he : (fun t ↦ chainMove (simultaneousChain (l++[a]) t) x)= |
| (fun t ↦ chainMove (simultaneousChain l t) x+t • variationField a (chainMove (simultaneousChain l t) x)) := by |
| funext t |
| simp [simultaneousChain,List.map_append,chainMove_append,chainMove,coordinateMove,variationField,smul_smul] |
| rw [he,second_deriv_add_time_smul hm hf,ih,motionJet_append] |
| dsimp only |
| congr 2 |
| have hd : HasFDerivAt (variationField a) (fderiv ℝ (variationField a) x) |
| (chainMove (simultaneousChain l 0) x) := by |
| simpa only [simultaneousMove_zero] using |
| ((variationField_smooth a).differentiable (by simp) x).hasFDerivAt |
| simpa only [Function.comp_def,simultaneousMove_deriv,motionJet_first] using |
| (hd.comp_hasDerivAt 0 (hm.differentiable (by simp) 0).hasDerivAt).deriv |
|
|
| lemma chainNormalVelocity_eq_cofactor (l : List Variation) (x n : Cover) : |
| chainNormalVelocity l x n=cofactorLinear (fderiv ℝ (chainVelocity l) x) n := by |
| induction l using List.reverseRecOn with |
| | nil => |
| change 0=cofactorLinear (fderiv ℝ (fun _ : Cover ↦ (0 : Cover)) x) n |
| simp [cofactorLinear] |
| | append_singleton l a ih => |
| rw [chainVelocity_append,fderiv_fun_add ((chainVelocity_smooth l).differentiable (by simp) x) |
| ((variationField_smooth a).differentiable (by simp) x),cofactorLinear_add,← ih] |
| rw [show cofactorLinear (fderiv ℝ (variationField a) x) n= |
| coordinateNormalVelocity a.coordinate a.function x n from |
| cofactorLinear_coordinate (a.smooth.differentiable (by simp) x) a.coordinate n] |
| simp [chainNormalVelocity,List.map_append] |
|
|
| end Periodic |
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def volumeQuadratic (L : Cover →L[ℝ] Cover) : ℝ := |
| (coverTrace L)^2-coverTrace (L.comp L) |
|
|
| lemma volumeQuadratic_add (L M : Cover →L[ℝ] Cover) : |
| volumeQuadratic (L+M)=volumeQuadratic L+volumeQuadratic M+ |
| 2*(coverTrace L*coverTrace M-coverTrace (M.comp L)) := by |
| simp only [volumeQuadratic,ContinuousLinearMap.add_comp,ContinuousLinearMap.comp_add, |
| coverTrace_add,coverTrace_comp_comm L M] |
| ring |
|
|
| end CubicTorus |
| end |
| end |
| end |
|
|
| end OAI |
|
|
