| import Mathlib |
| import OAI.Geometry.BallPacking.Moments.RearrangementBounds |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace PackingSufficiencySupport.Hamiltonian |
|
|
| section |
| open scoped ContDiff Topology |
| open Set Function |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| theorem smooth_fderiv_apply_const {D G : Type*} [NormedAddCommGroup D] |
| [NormedSpace ℝ D] [NormedAddCommGroup G] [NormedSpace ℝ G] {f : D → G} |
| (hf : ContDiff ℝ ∞ f) (p v w : D) : |
| fderiv ℝ (fun q => fderiv ℝ f q v) p w = fderiv ℝ (fderiv ℝ f) p w v := by |
| have hfd : ContDiff ℝ ∞ (fderiv ℝ f) := hf.fderiv_right (by simp) |
| have hh := (hfd.differentiable (by simp) p).hasFDerivAt.clm_apply |
| (hasFDerivAt_const v p) |
| rw [hh.fderiv] |
| simp |
|
|
| theorem joint_spatial_fderiv {F : ℝ × E → E} (hF : ContDiff ℝ ∞ F) (t : ℝ) (x v : E) : |
| fderiv ℝ (fun y => F (t,y)) x v = fderiv ℝ F (t,x) (0,v) := by |
| have hd := (hF.differentiable (by simp) (t,x)).hasFDerivAt.comp x |
| ((hasFDerivAt_const (c := t) x).prodMk (hasFDerivAt_id (𝕜 := ℝ) x)) |
| exact congrArg (fun A : E →L[ℝ] E => A v) hd.fderiv |
|
|
| theorem joint_time_fderiv {F X : ℝ × E → E} (hF : ContDiff ℝ ∞ F) |
| (hflow : ∀ t x, HasDerivAt (fun s => F (s,x)) (X (t,F (t,x))) t) (p : ℝ × E) : |
| fderiv ℝ F p (1,0) = X (p.1,F p) := by |
| have hd := (hF.differentiable (by simp) p).hasFDerivAt.comp_hasDerivAt p.1 |
| ((hasDerivAt_id p.1).prodMk (hasDerivAt_const p.1 p.2)) |
| exact hd.unique (hflow p.1 p.2) |
|
|
| theorem joint_flow_variation {F X : ℝ × E → E} (hF : ContDiff ℝ ∞ F) |
| (hX : ContDiff ℝ ∞ X) |
| (hflow : ∀ t x, HasDerivAt (fun s => F (s,x)) (X (t,F (t,x))) t) |
| (t : ℝ) (x v : E) : |
| HasDerivAt (fun s => fderiv ℝ F (s,x) (0,v)) |
| (fderiv ℝ X (t,F (t,x)) (0,fderiv ℝ F (t,x) (0,v))) t := by |
| have hFd : ContDiff ℝ ∞ (fderiv ℝ F) := hF.fderiv_right (by simp) |
| have hV : ContDiff ℝ ∞ (fun p => fderiv ℝ F p (0,v)) := hFd.clm_apply contDiff_const |
| have hd := (hV.differentiable (by simp) (t,x)).hasFDerivAt.comp_hasDerivAt t |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t x)) |
| have he : (fun p => fderiv ℝ F p (1,0)) = fun p => X (p.1,F p) := |
| funext (joint_time_fderiv hF hflow) |
| have hchain := (hX.differentiable (by simp) (t,F (t,x))).hasFDerivAt.comp (t,x) |
| ((hasFDerivAt_fst (𝕜 := ℝ) (p := (t,x))).prodMk |
| (hF.differentiable (by simp) (t,x)).hasFDerivAt) |
| have hc := congrArg (fun A : (ℝ × E) →L[ℝ] E => A (0,v)) hchain.fderiv |
| change fderiv ℝ (fun p => X (p.1,F p)) (t,x) (0,v) = _ at hc |
| have he' := congrArg (fun g : ℝ × E → E => fderiv ℝ g (t,x) (0,v)) he |
| rw [smooth_fderiv_apply_const hF] at he' |
| rw [hc] at he' |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.prod_apply] at he' |
| have hs := (hF.contDiffAt (x := (t,x))).isSymmSndFDerivAt (by |
| rw [minSmoothness_of_isRCLikeNormedField] |
| change ((2 : ℕ∞) : WithTop ℕ∞) ≤ ↑(⊤ : ℕ∞) |
| exact WithTop.coe_le_coe.mpr le_top) |
| apply hd.congr_deriv |
| rw [smooth_fderiv_apply_const hF,hs.eq (1,0) (0,v)] |
| exact he' |
| |
| theorem smooth_flow_form_transport_on {F X : ℝ × E → E} (hF : ContDiff ℝ ∞ F) |
| (hX : ContDiff ℝ ∞ X) |
| (hflow : ∀ t x, HasDerivAt (fun s => F (s,x)) (X (t,F (t,x))) t) |
| {Ω : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} (hΩ : ContDiff ℝ ∞ Ω) |
| {a b : ℝ} (hab : a ≤ b) (x v w : E) |
| (hPDE : ∀ t ∈ Ioo a b, ∀ u z, |
| fderiv ℝ Ω (t,F (t,x)) (1,X (t,F (t,x))) u z + |
| Ω (t,F (t,x)) (fderiv ℝ X (t,F (t,x)) (0,u)) z + |
| Ω (t,F (t,x)) u (fderiv ℝ X (t,F (t,x)) (0,z)) = 0) : |
| Ω (b,F (b,x)) (fderiv ℝ (fun y => F (b,y)) x v) |
| (fderiv ℝ (fun y => F (b,y)) x w) = |
| Ω (a,F (a,x)) (fderiv ℝ (fun y => F (a,y)) x v) |
| (fderiv ℝ (fun y => F (a,y)) x w) := by |
| let V (s : ℝ) := fderiv ℝ F (s,x) (0,v) |
| let W (s : ℝ) := fderiv ℝ F (s,x) (0,w) |
| let G (s : ℝ) := Ω (s,F (s,x)) (V s) (W s) |
| have hpath : Continuous (fun s => (s,F (s,x))) := |
| continuous_id.prodMk (hF.continuous.comp (continuous_id.prodMk continuous_const)) |
| have hFd : ContDiff ℝ ∞ (fderiv ℝ F) := hF.fderiv_right (by simp) |
| have hVc : Continuous V := ((hFd.continuous.comp |
| (continuous_id.prodMk continuous_const)).clm_apply continuous_const) |
| have hWc : Continuous W := ((hFd.continuous.comp |
| (continuous_id.prodMk continuous_const)).clm_apply continuous_const) |
| have hGc : Continuous G := ((hΩ.continuous.comp hpath).clm_apply hVc).clm_apply hWc |
| have hGd (s : ℝ) (hs : s ∈ Ioo a b) : HasDerivAt G 0 s := by |
| have hdΩ := (hΩ.differentiable (by simp) (s,F (s,x))).hasFDerivAt.comp_hasDerivAt s |
| ((hasDerivAt_id s).prodMk (hflow s x)) |
| have hd := (hdΩ.clm_apply (joint_flow_variation hF hX hflow s x v)).clm_apply |
| (joint_flow_variation hF hX hflow s x w) |
| apply hd.congr_deriv |
| simpa only [add_apply,Function.comp_apply,id_eq,V,W] using hPDE s hs (V s) (W s) |
| have hi := intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le hab |
| hGc.continuousOn hGd (intervalIntegrable_const (c := (0:ℝ))) |
| have he : G b = G a := sub_eq_zero.mp (by simpa using hi.symm) |
| simpa only [G,V,W,joint_spatial_fderiv hF] using he |
| |
| |
| end |
| |
| section |
| open scoped ContDiff BigOperators |
| open Set Function |
| |
| @[simp] theorem planeRotate_comp (s t : ℝ) (z : Plane) : |
| planeRotate s (planeRotate t z) = planeRotate (s+t) z := by |
| apply Prod.ext <;> dsimp [planeRotate] <;> rw [Real.cos_add,Real.sin_add] <;> ring |
| |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| |
| def toricFlow (F : (ι → ℝ) → ℝ) (t : ℝ) (z : PlanePhase ι) : PlanePhase ι := |
| fun i => planeRotate (t*toricAngularSpeed F z i) (z i) |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricFlow_zero (F : (ι → ℝ) → ℝ) (z : PlanePhase ι) : toricFlow F 0 z = z := by |
| funext i |
| simp [toricFlow] |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricFlow_moments (F : (ι → ℝ) → ℝ) (t : ℝ) (z : PlanePhase ι) : |
| planeMoments (toricFlow F t z) = planeMoments z := by |
| funext i |
| exact radialArea_planeRotate _ _ |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricAngularSpeed_flow (F : (ι → ℝ) → ℝ) (t : ℝ) (z : PlanePhase ι) (i : ι) : |
| toricAngularSpeed F (toricFlow F t z) i = toricAngularSpeed F z i := by |
| simp [toricAngularSpeed] |
| |
| omit [Fintype ι] in |
| theorem toricFlow_add (F : (ι → ℝ) → ℝ) (s t : ℝ) (z : PlanePhase ι) : |
| toricFlow F s (toricFlow F t z) = toricFlow F (s+t) z := by |
| funext i |
| change planeRotate (s*toricAngularSpeed F (toricFlow F t z) i) |
| (planeRotate (t*toricAngularSpeed F z i) (z i)) = _ |
| rw [toricAngularSpeed_flow,planeRotate_comp] |
| simp only [toricFlow,add_mul] |
| |
| omit [DecidableEq ι] in |
| |
| theorem phase_rotation_smooth {a : ℝ × PlanePhase ι → (ι → ℝ)} |
| (ha : ContDiff ℝ ∞ a) : |
| ContDiff ℝ ∞ (fun p : ℝ × PlanePhase ι => fun i => planeRotate (a p i) (p.2 i)) := by |
| apply contDiff_pi.mpr |
| intro i |
| have hi : ContDiff ℝ ∞ (fun p : ℝ × PlanePhase ι => a p i) := |
| (contDiff_apply ℝ ℝ i).comp ha |
| have hz : ContDiff ℝ ∞ (fun p : ℝ × PlanePhase ι => p.2 i) := |
| (contDiff_apply ℝ Plane i).comp contDiff_snd |
| convert! planeRotate_smooth.comp (hi.prodMk hz) using 1 |
| |
| theorem toric_flow_angles_smooth {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) : |
| ContDiff ℝ ∞ (fun p : ℝ × PlanePhase ι => fun i => p.1*toricAngularSpeed F p.2 i) := by |
| apply contDiff_pi.mpr |
| intro i |
| have ha : ContDiff ℝ ∞ (fun p : ℝ × PlanePhase ι => toricAngularSpeed F p.2 i) := |
| (toricAngularSpeed_smooth hF i).comp contDiff_snd |
| exact contDiff_fst.mul ha |
| |
| @[fun_prop] theorem toricFlow_smooth {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) : |
| ContDiff ℝ ∞ (fun p : ℝ × PlanePhase ι => toricFlow F p.1 p.2) := by |
| exact phase_rotation_smooth (toric_flow_angles_smooth hF) |
| |
| theorem toricFlow_time_smooth {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) (t : ℝ) : |
| ContDiff ℝ ∞ (toricFlow F t) := by |
| convert! (toricFlow_smooth hF).comp (contDiff_const.prodMk contDiff_id) using 1 |
| |
| def toricFlowHomeomorph {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) (t : ℝ) : |
| PlanePhase ι ≃ₜ PlanePhase ι where |
| toFun := toricFlow F t |
| invFun := toricFlow F (-t) |
| left_inv z := by rw [toricFlow_add,neg_add_cancel,toricFlow_zero] |
| right_inv z := by rw [toricFlow_add,add_neg_cancel,toricFlow_zero] |
| continuous_toFun := (toricFlow_time_smooth hF t).continuous |
| continuous_invFun := (toricFlow_time_smooth hF (-t)).continuous |
| |
| theorem toricFlow_hasDerivAt {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) |
| (t : ℝ) (z : PlanePhase ι) : |
| HasDerivAt (fun s => toricFlow F s z) |
| (hamiltonianField phaseArea (toricHamiltonian F) (t,toricFlow F t z)) t := by |
| apply hasDerivAt_pi.mpr |
| intro i |
| have hd := planeRotate_hasDerivAt ((hasDerivAt_id t).mul_const (toricAngularSpeed F z i)) (z i) |
| apply hd.congr_deriv |
| rw [toricHamiltonian_field hF,toricAngularSpeed_flow] |
| simp only [one_mul,toricFlow,id_eq] |
| |
| theorem toricFlow_symplectic {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) |
| (t : ℝ) (z v w : PlanePhase ι) : |
| phaseArea (fderiv ℝ (toricFlow F t) z v) (fderiv ℝ (toricFlow F t) z w) = phaseArea v w := by |
| have hHs := toricHamiltonian_smooth hF |
| have hXs := hamiltonianField_smooth phaseArea_isInvertible hHs |
| have he (a b : ℝ) (hab : a ≤ b) : |
| phaseArea (fderiv ℝ (toricFlow F b) z v) (fderiv ℝ (toricFlow F b) z w) = |
| phaseArea (fderiv ℝ (toricFlow F a) z v) (fderiv ℝ (toricFlow F a) z w) := by |
| apply smooth_flow_form_transport_on (toricFlow_smooth hF) hXs (toricFlow_hasDerivAt hF) |
| (Ω := fun _ => phaseArea) contDiff_const hab z v w |
| intro s _ u q |
| simpa only [fderiv_const_apply,zero_apply,zero_add] using |
| hamiltonianField_transport_equation phaseArea_isInvertible phaseArea_skew hHs |
| (s,toricFlow F s z) u q |
| have hzero : toricFlow F 0 = id := funext (toricFlow_zero F) |
| by_cases ht : 0 ≤ t |
| · simpa only [hzero,fderiv_id,ContinuousLinearMap.id_apply] using he 0 t ht |
| · simpa only [hzero,fderiv_id,ContinuousLinearMap.id_apply] using (he t 0 (le_of_not_ge ht)).symm |
| |
| |
| end |
| |
| section |
| open scoped ContDiff |
| open Set Function |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| |
| theorem joint_flow_fderiv {F X : ℝ × E → E} (hF : ContDiff ℝ ∞ F) |
| (hflow : ∀ t x, HasDerivAt (fun s => F (s,x)) (X (t,F (t,x))) t) |
| (t τ : ℝ) (x v : E) : |
| fderiv ℝ F (t,x) (τ,v) = τ • X (t,F (t,x)) + |
| fderiv ℝ (fun y => F (t,y)) x v := by |
| rw [show (τ,v) = τ • ((1,0) : ℝ × E) + (0,v) by ext <;> simp, |
| map_add,map_smul,joint_time_fderiv hF hflow,joint_spatial_fderiv hF] |
| |
| theorem suspension_form_identity {A : E →L[ℝ] E →L[ℝ] ℝ} |
| (hskew : ∀ v w, A v w = -A w v) {D : E →L[ℝ] E} {X : E} {η : E →L[ℝ] ℝ} |
| (hsp : ∀ v w, A (D v) (D w) = A v w) |
| (hX : ∀ v, A X (D v) = -η v) (v w : Plane × E) : |
| productForm A (v.1,v.1.2 • X + D v.2) (w.1,w.1.2 • X + D w.2) = |
| oneCovectorForm A 1 η v w := by |
| have hXX : A X X = 0 := by have hh := hskew X X; linarith |
| have hright : A (D v.2) X = η v.2 := by rw [hskew,hX,neg_neg] |
| simp only [productForm_apply,oneCovectorForm_apply,planarArea_apply,map_add,map_smul, |
| add_apply,smul_apply,smul_eq_mul,hXX,hsp,hX,hright] |
| ring |
| |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| |
| def toricFunction (F : (ι → ℝ) → ℝ) (z : PlanePhase ι) : ℝ := F (planeMoments z) |
| |
| omit [DecidableEq ι] in |
| @[fun_prop] theorem toricFunction_smooth {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) : |
| ContDiff ℝ ∞ (toricFunction F) := hF.comp planeMoments_smooth |
| |
| theorem toricFlow_energy_differential {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) |
| (t : ℝ) (z v : PlanePhase ι) : |
| fderiv ℝ (toricFunction F) (toricFlow F t z) (fderiv ℝ (toricFlow F t) z v) = |
| fderiv ℝ (toricFunction F) z v := by |
| have hs : ContDiff ℝ ∞ (toricFlow F t) := toricFlow_time_smooth hF t |
| have he : toricFunction F ∘ toricFlow F t = toricFunction F := by |
| funext z; simp [toricFunction] |
| have hd := fderiv_comp z ((toricFunction_smooth hF).differentiable (by simp) _) |
| (hs.differentiable (by simp) _) |
| rw [he] at hd |
| exact (congrArg (fun L : PlanePhase ι →L[ℝ] ℝ => L v) hd).symm |
| |
| def toricSuspension (F : (ι → ℝ) → ℝ) (p : Plane × PlanePhase ι) : Plane × PlanePhase ι := |
| (p.1,toricFlow F p.1.2 p.2) |
| |
| @[fun_prop] theorem toricSuspension_smooth {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) : |
| ContDiff ℝ ∞ (toricSuspension F) := by |
| have ht : ContDiff ℝ ∞ (fun p : Plane × PlanePhase ι => p.1.2) := |
| contDiff_snd.comp contDiff_fst |
| have hz : ContDiff ℝ ∞ (fun p : Plane × PlanePhase ι => toricFlow F p.1.2 p.2) := by |
| convert! (toricFlow_smooth hF).comp (ht.prodMk contDiff_snd) using 1 |
| exact contDiff_fst.prodMk hz |
| |
| theorem toricSuspension_fderiv {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) |
| (p v : Plane × PlanePhase ι) : |
| fderiv ℝ (toricSuspension F) p v = |
| (v.1,v.1.2 • hamiltonianField phaseArea (toricHamiltonian F) |
| (p.1.2,toricFlow F p.1.2 p.2) + fderiv ℝ (toricFlow F p.1.2) p.2 v.2) := by |
| have hg := (toricFlow_smooth hF).differentiable (by simp) |
| have hc := (hg (p.1.2,p.2)).hasFDerivAt.comp p |
| (((hasFDerivAt_snd (𝕜 := ℝ) (p := p.1)).comp p |
| (hasFDerivAt_fst (𝕜 := ℝ) (p := p))).prodMk |
| (hasFDerivAt_snd (𝕜 := ℝ) (p := p))) |
| have hd := (hasFDerivAt_fst (𝕜 := ℝ) (p := p)).prodMk hc |
| change HasFDerivAt (toricSuspension F) _ p at hd |
| rw [hd.fderiv] |
| change (v.1,fderiv ℝ (fun q : ℝ × PlanePhase ι => toricFlow F q.1 q.2) |
| (p.1.2,p.2) (v.1.2,v.2)) = _ |
| rw [joint_flow_fderiv (toricFlow_smooth hF) (toricFlow_hasDerivAt hF)] |
| |
| theorem toricSuspension_pullback {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) |
| (p v w : Plane × PlanePhase ι) : |
| productForm phaseArea (fderiv ℝ (toricSuspension F) p v) |
| (fderiv ℝ (toricSuspension F) p w) = |
| oneCovectorForm phaseArea 1 (fderiv ℝ (toricFunction F) p.2) v w := by |
| rw [toricSuspension_fderiv hF,toricSuspension_fderiv hF] |
| apply suspension_form_identity phaseArea_skew (toricFlow_symplectic hF p.1.2 p.2) |
| intro u |
| rw [hamiltonianField_contraction phaseArea_isInvertible] |
| have hh : fderiv ℝ (toricHamiltonian F) (p.1.2,toricFlow F p.1.2 p.2) |
| (0,fderiv ℝ (toricFlow F p.1.2) p.2 u) = |
| fderiv ℝ (toricFunction F) (toricFlow F p.1.2 p.2) |
| (fderiv ℝ (toricFlow F p.1.2) p.2 u) := by |
| have hd := ((toricFunction_smooth hF).differentiable (by simp) _).hasFDerivAt.comp |
| (p.1.2,toricFlow F p.1.2 p.2) (hasFDerivAt_snd (𝕜 := ℝ)) |
| exact congrArg (fun L : (ℝ × PlanePhase ι) →L[ℝ] ℝ => |
| L (0,fderiv ℝ (toricFlow F p.1.2) p.2 u)) hd.fderiv |
| rw [hh,toricFlow_energy_differential hF] |
| |
| |
| end |
| |
| section |
| open scoped ContDiff |
| open Set Function |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| |
| def toricSuspensionInverse (F : (ι → ℝ) → ℝ) (p : Plane × PlanePhase ι) : Plane × PlanePhase ι := |
| (p.1,toricFlow F (-p.1.2) p.2) |
| |
| @[fun_prop] theorem toricSuspensionInverse_smooth {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) : |
| ContDiff ℝ ∞ (toricSuspensionInverse F) := by |
| have ht : ContDiff ℝ ∞ (fun p : Plane × PlanePhase ι => -p.1.2) := |
| (contDiff_snd.comp contDiff_fst).neg |
| have hz : ContDiff ℝ ∞ (fun p : Plane × PlanePhase ι => toricFlow F (-p.1.2) p.2) := by |
| convert! (toricFlow_smooth hF).comp (ht.prodMk contDiff_snd) using 1 |
| exact contDiff_fst.prodMk hz |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricSuspensionInverse_left (F : (ι → ℝ) → ℝ) (p : Plane × PlanePhase ι) : |
| toricSuspensionInverse F (toricSuspension F p) = p := by |
| simp only [toricSuspensionInverse,toricSuspension,toricFlow_add,neg_add_cancel,toricFlow_zero] |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricSuspensionInverse_right (F : (ι → ℝ) → ℝ) (p : Plane × PlanePhase ι) : |
| toricSuspension F (toricSuspensionInverse F p) = p := by |
| simp only [toricSuspensionInverse,toricSuspension,toricFlow_add,add_neg_cancel,toricFlow_zero] |
| |
| def toricSuspensionHomeomorph {F : (ι → ℝ) → ℝ} (hF : ContDiff ℝ ∞ F) : |
| (Plane × PlanePhase ι) ≃ₜ (Plane × PlanePhase ι) where |
| toFun := toricSuspension F |
| invFun := toricSuspensionInverse F |
| left_inv := toricSuspensionInverse_left F |
| right_inv := toricSuspensionInverse_right F |
| continuous_toFun := (toricSuspension_smooth hF).continuous |
| continuous_invFun := (toricSuspensionInverse_smooth hF).continuous |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricSuspension_moments (F : (ι → ℝ) → ℝ) (p : Plane × PlanePhase ι) : |
| planeMoments (toricSuspension F p).2 = planeMoments p.2 := toricFlow_moments F _ _ |
| |
| omit [Fintype ι] in |
| @[simp] theorem toricSuspensionInverse_moments (F : (ι → ℝ) → ℝ) (p : Plane × PlanePhase ι) : |
| planeMoments (toricSuspensionInverse F p).2 = planeMoments p.2 := toricFlow_moments F _ _ |
| |
| |
| end |
| |
| section |
| open scoped ContDiff Topology |
| open Set Function |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
| |
| def layerOrder : (Plane × E) ≃L[ℝ] ((ℝ × E) × ℝ) := |
| (ContinuousLinearEquiv.prodAssoc ℝ ℝ ℝ E).trans (ContinuousLinearEquiv.prodComm ℝ ℝ (ℝ × E)) |
| |
| omit [CompleteSpace E] in |
| @[simp] theorem layerOrder_apply (p : Plane × E) : layerOrder p = ((p.1.2,p.2),p.1.1) := rfl |
| omit [CompleteSpace E] in |
| @[simp] theorem layerOrder_symm_apply (p : (ℝ × E) × ℝ) : layerOrder.symm p = ((p.2,p.1.1),p.1.2) := rfl |
| |
| def stripChart (f : Plane × E → ℝ) (p : Plane × E) : Plane × E := ((f p,p.1.2),p.2) |
| |
| omit [CompleteSpace E] in |
| @[fun_prop] theorem stripChart_smooth {f : Plane × E → ℝ} (hf : ContDiff ℝ ∞ f) : |
| ContDiff ℝ ∞ (stripChart f) := (hf.prodMk (contDiff_snd.comp contDiff_fst)).prodMk contDiff_snd |
| |
| theorem stripChart_inverse {f : Plane × E → ℝ} (hf : ContDiff ℝ ∞ f) |
| {V : Set E} (hV : IsOpen V) {a b : ℝ} (hab : a < b) (H : E → ℝ) |
| (hderiv : ∀ T ∈ Ioo (0:ℝ) 1, ∀ v ∈ V, ∀ s ∈ Ioo a b, |
| 0 < deriv (fun r => f ((r,T),v)) s) |
| (hlo : ∀ T ∈ Ioo (0:ℝ) 1, ∀ v ∈ V, f ((a,T),v) = 0) |
| (hhi : ∀ T ∈ Ioo (0:ℝ) 1, ∀ v ∈ V, H v < f ((b,T),v)) : |
| ∃ (W : Set (Plane × E)) (g : Plane × E → Plane × E), |
| IsOpen W ∧ ContDiffOn ℝ ∞ g W ∧ |
| W = stripChart f '' ((Ioo a b ×ˢ Ioo (0:ℝ) 1) ×ˢ V) ∧ |
| (∀ p, p.1.2 ∈ Ioo (0:ℝ) 1 → p.2 ∈ V → 0 < p.1.1 → p.1.1 < H p.2 → p ∈ W) ∧ |
| (∀ p ∈ (Ioo a b ×ˢ Ioo (0:ℝ) 1) ×ˢ V, g (stripChart f p) = p) ∧ |
| (∀ p ∈ W, g p ∈ (Ioo a b ×ˢ Ioo (0:ℝ) 1) ×ˢ V ∧ stripChart f (g p) = p) := by |
| let e : (Plane × E) ≃L[ℝ] ((ℝ × E) × ℝ) := layerOrder |
| let f' : (ℝ × E) × ℝ → ℝ := f ∘ e.symm |
| have hf' : ContDiff ℝ ∞ f' := hf.comp e.symm.contDiff |
| obtain ⟨W,g,hWo,hgs,hWe,havailable,hleft,hright⟩ := monotone_strip_inverse hf' |
| (isOpen_Ioo.prod hV) hab (h := fun q : ℝ × E => H q.2) |
| (fun q hq s hs => hderiv q.1 hq.1 q.2 hq.2 s hs) |
| (fun q hq => hlo q.1 hq.1 q.2 hq.2) |
| (fun q hq => hhi q.1 hq.1 q.2 hq.2) |
| let G : Plane × E → Plane × E := fun p => ((g (e p),p.1.2),p.2) |
| refine ⟨e ⁻¹' W,G,hWo.preimage e.continuous,?_,?_,?_,?_,?_⟩ |
| · have hg : ContDiffOn ℝ ∞ (fun p => g (e p)) (e ⁻¹' W) := |
| hgs.comp e.contDiff.contDiffOn (fun _ hp => hp) |
| exact (hg.prodMk (contDiff_snd.comp contDiff_fst).contDiffOn).prodMk contDiff_snd.contDiffOn |
| · ext p |
| constructor |
| · intro hp |
| obtain ⟨q,hq,hqe⟩ := by simpa only [hWe] using hp |
| refine ⟨e.symm q,⟨⟨hq.2,hq.1.1⟩,hq.1.2⟩,?_⟩ |
| apply e.injective |
| change (q.1,f' q) = e p |
| exact hqe |
| · rintro ⟨q,hq,rfl⟩ |
| change e (stripChart f q) ∈ W |
| rw [hWe] |
| exact ⟨e q,⟨⟨hq.1.2,hq.2⟩,hq.1.1⟩,rfl⟩ |
| · intro p hpT hpV hp0 hpH |
| exact havailable (p.1.2,p.2) ⟨hpT,hpV⟩ p.1.1 hp0 hpH |
| · intro p hp |
| have hh := hleft (p.1.2,p.2) ⟨hp.1.2,hp.2⟩ p.1.1 hp.1.1 |
| change ((g ((p.1.2,p.2),f p),p.1.2),p.2) = p |
| change g ((p.1.2,p.2),f p) = p.1.1 at hh |
| rw [hh] |
| · intro p hp |
| have hh := hright (e p) hp |
| refine ⟨⟨⟨hh.2.1,hh.1.1⟩,hh.1.2⟩,?_⟩ |
| change ((f ((g (e p),p.1.2),p.2),p.1.2),p.2) = p |
| have he : f ((g (e p),p.1.2),p.2) = p.1.1 := hh.2.2 |
| rw [he] |
|
|
|
|
| end |
|
|
| open scoped ContDiff Topology |
| open Set Function |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
|
|
| def layerChart (F : (ι → ℝ) → ℝ) (f : Plane × PlanePhase ι → ℝ) : |
| Plane × PlanePhase ι → Plane × PlanePhase ι := toricSuspension F ∘ stripChart f |
|
|
| @[fun_prop] theorem layerChart_smooth {F : (ι → ℝ) → ℝ} {f : Plane × PlanePhase ι → ℝ} |
| (hF : ContDiff ℝ ∞ F) (hf : ContDiff ℝ ∞ f) : ContDiff ℝ ∞ (layerChart F f) := |
| (toricSuspension_smooth hF).comp (stripChart_smooth hf) |
|
|
| def layerForm (F : (ι → ℝ) → ℝ) (f : Plane × PlanePhase ι → ℝ) |
| (p : Plane × PlanePhase ι) : |
| (Plane × PlanePhase ι) →L[ℝ] (Plane × PlanePhase ι) →L[ℝ] ℝ := |
| let dt := (ContinuousLinearMap.snd ℝ ℝ ℝ).comp (ContinuousLinearMap.fst ℝ Plane (PlanePhase ι)) |
| let β := fderiv ℝ f p + (fderiv ℝ (toricFunction F) p.2).comp (ContinuousLinearMap.snd ℝ Plane (PlanePhase ι)) |
| phaseArea.bilinearComp (ContinuousLinearMap.snd ℝ Plane (PlanePhase ι)) |
| (ContinuousLinearMap.snd ℝ Plane (PlanePhase ι)) + β.smulRight dt - dt.smulRight β |
|
|
| omit [DecidableEq ι] in |
| theorem layerForm_apply (F : (ι → ℝ) → ℝ) (f : Plane × PlanePhase ι → ℝ) |
| (p v w : Plane × PlanePhase ι) : |
| layerForm F f p v w = phaseArea v.2 w.2 + |
| (fderiv ℝ f p v + fderiv ℝ (toricFunction F) p.2 v.2)*w.1.2 - |
| v.1.2*(fderiv ℝ f p w + fderiv ℝ (toricFunction F) p.2 w.2) := by |
| simp [layerForm,ContinuousLinearMap.smulRight_apply,smul_eq_mul,mul_add] |
|
|
| omit [DecidableEq ι] in |
| theorem stripChart_fderiv {f : Plane × PlanePhase ι → ℝ} (hf : ContDiff ℝ ∞ f) |
| (p v : Plane × PlanePhase ι) : fderiv ℝ (stripChart f) p v = ((fderiv ℝ f p v,v.1.2),v.2) := by |
| have hd := (((hf.differentiable (by simp) p).hasFDerivAt).prodMk |
| ((hasFDerivAt_snd (𝕜 := ℝ) (p := p.1)).comp p (hasFDerivAt_fst (𝕜 := ℝ) (p := p)))).prodMk |
| (hasFDerivAt_snd (𝕜 := ℝ) (p := p)) |
| change HasFDerivAt (stripChart f) _ p at hd |
| rw [hd.fderiv] |
| rfl |
|
|
| theorem layerChart_pullback {F : (ι → ℝ) → ℝ} {f : Plane × PlanePhase ι → ℝ} |
| (hF : ContDiff ℝ ∞ F) (hf : ContDiff ℝ ∞ f) (p v w : Plane × PlanePhase ι) : |
| productForm phaseArea (fderiv ℝ (layerChart F f) p v) |
| (fderiv ℝ (layerChart F f) p w) = layerForm F f p v w := by |
| rw [layerChart,fderiv_comp p ((toricSuspension_smooth hF).differentiable (by simp) _) |
| ((stripChart_smooth hf).differentiable (by simp) _)] |
| simp only [ContinuousLinearMap.comp_apply] |
| rw [toricSuspension_pullback hF,stripChart_fderiv hf,stripChart_fderiv hf, |
| oneCovectorForm_apply,layerForm_apply] |
| change phaseArea v.2 w.2 + 1*(fderiv ℝ f p v*w.1.2-v.1.2*fderiv ℝ f p w) + |
| fderiv ℝ (toricFunction F) p.2 v.2*w.1.2-v.1.2*fderiv ℝ (toricFunction F) p.2 w.2 = _ |
| ring |
|
|
| theorem layerChart_inverse {F : (ι → ℝ) → ℝ} {f : Plane × PlanePhase ι → ℝ} |
| (hF : ContDiff ℝ ∞ F) (hf : ContDiff ℝ ∞ f) |
| {V : Set (ι → ℝ)} (hV : IsOpen (planeMoments ⁻¹' V)) {a b : ℝ} (hab : a < b) |
| (H : (ι → ℝ) → ℝ) |
| (hderiv : ∀ T ∈ Ioo (0:ℝ) 1, ∀ v, planeMoments v ∈ V → ∀ s ∈ Ioo a b, |
| 0 < deriv (fun r => f ((r,T),v)) s) |
| (hlo : ∀ T ∈ Ioo (0:ℝ) 1, ∀ v, planeMoments v ∈ V → f ((a,T),v) = 0) |
| (hhi : ∀ T ∈ Ioo (0:ℝ) 1, ∀ v, planeMoments v ∈ V → H (planeMoments v) < f ((b,T),v)) : |
| ∃ (W : Set (Plane × PlanePhase ι)) (g : Plane × PlanePhase ι → Plane × PlanePhase ι), |
| IsOpen W ∧ ContDiffOn ℝ ∞ g W ∧ |
| W = layerChart F f '' ((Ioo a b ×ˢ Ioo (0:ℝ) 1) ×ˢ (planeMoments ⁻¹' V)) ∧ |
| (∀ p, p.1.2 ∈ Ioo (0:ℝ) 1 → planeMoments p.2 ∈ V → |
| 0 < p.1.1 → p.1.1 < H (planeMoments p.2) → p ∈ W) ∧ |
| (∀ p ∈ (Ioo a b ×ˢ Ioo (0:ℝ) 1) ×ˢ (planeMoments ⁻¹' V), g (layerChart F f p) = p) ∧ |
| (∀ p ∈ W, g p ∈ (Ioo a b ×ˢ Ioo (0:ℝ) 1) ×ˢ (planeMoments ⁻¹' V) ∧ layerChart F f (g p) = p) := by |
| obtain ⟨W,g,hWo,hgs,hWe,hav,hl,hr⟩ := stripChart_inverse hf hV hab (H ∘ planeMoments) hderiv hlo hhi |
| let e := toricSuspensionHomeomorph hF |
| let G := g ∘ toricSuspensionInverse F |
| have hpre : e.symm ⁻¹' W = e '' W := by |
| ext p |
| exact ⟨fun hp => ⟨e.symm p,hp,e.apply_symm_apply p⟩,by rintro ⟨p,hp,rfl⟩; simpa using hp⟩ |
| refine ⟨e '' W,G,e.isOpen_image.mpr hWo,?_,?_,?_,?_,?_⟩ |
| · apply hgs.comp (toricSuspensionInverse_smooth hF).contDiffOn |
| intro p hp |
| change p ∈ e.symm ⁻¹' W |
| rw [hpre] |
| exact hp |
| · rw [hWe,←image_comp] |
| rfl |
| · intro p hpT hpV hp0 hpH |
| refine ⟨e.symm p,?_,e.apply_symm_apply p⟩ |
| apply hav (e.symm p) hpT |
| · change planeMoments (toricSuspensionInverse F p).2 ∈ V |
| simpa only [toricSuspensionInverse_moments] using hpV |
| · exact hp0 |
| · change p.1.1 < H (planeMoments (toricSuspensionInverse F p).2) |
| simpa using hpH |
| · intro p hp |
| change g (toricSuspensionInverse F (toricSuspension F (stripChart f p))) = p |
| rw [toricSuspensionInverse_left] |
| exact hl p hp |
| · rintro p ⟨z,hz,rfl⟩ |
| have hge : G (e z) = g z := by |
| change g (toricSuspensionInverse F (toricSuspension F z)) = g z |
| rw [toricSuspensionInverse_left] |
| rw [hge] |
| refine ⟨(hr z hz).1,?_⟩ |
| change toricSuspension F (stripChart f (g z)) = toricSuspension F z |
| rw [(hr z hz).2] |
|
|
|
|
|
|
| end PackingSufficiencySupport.Hamiltonian |
| end |
|
|
| end OAI |
|
|
