| import Mathlib | |
| import OAI.Geometry.BallPacking.BallMaps.CubicBubbleSeparated | |
| import OAI.Geometry.BallPacking.Models.LiouvilleRadialCalculus | |
| import OAI.Geometry.BallPacking.Normal.TailLineCoordinates | |
| namespace OAI | |
| noncomputable section | |
| namespace PackingSufficiencySupport.DiagonalQuadrics | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold | |
| open Hamiltonian | |
| open scoped BigOperators | |
| section | |
| variable {m : ℕ} (a : Fin m → ℂ) [Fact (Injective a)] [Fact (∀ j,a j≠0)] | |
| abbrev ConeModel (m : ℕ) := RealModel × (Fin m → ℂ) | |
| abbrev ConeSpace := locus a × (Fin m → ℂ) | |
| abbrev ConeTarget (m : ℕ) := PlanePhase (Option (Fin m)) × PlanePhase (Fin m) | |
| def movingConeCoordinates (Ψ : ℝ × ConeSpace a → Affine m) (p : ℝ × ConeSpace a) : ConeTarget m := | |
| (affinePhase m (Ψ p),complexCartesian p.2.2) | |
| theorem movingConeCoordinates_smooth {Ψ : ℝ × ConeSpace a → Affine m} | |
| (hΨ : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,ConeModel m)) 𝓘(ℝ,Affine m) ∞ Ψ) : | |
| ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,ConeModel m)) 𝓘(ℝ,ConeTarget m) ∞ | |
| (movingConeCoordinates a Ψ) := by | |
| apply ContMDiff.prodMk_space | |
| · exact (affinePhase m).contDiff.contMDiff.comp hΨ | |
| · have hs : ContMDiff 𝓘(ℝ,ConeModel m) 𝓘(ℝ,Fin m → ℂ) ∞ | |
| (Prod.snd : ConeSpace a → Fin m → ℂ) := by | |
| simpa only [modelWithCornersSelf_prod] using | |
| (contMDiff_snd : ContMDiff ((𝓘(ℝ,RealModel)).prod 𝓘(ℝ,Fin m → ℂ)) | |
| 𝓘(ℝ,Fin m → ℂ) ∞ (Prod.snd : ConeSpace a → Fin m → ℂ)) | |
| exact (complexCartesian (ι := Fin m)).contDiff.contMDiff.comp (hs.comp contMDiff_snd) | |
| def centralConeCoordinates (p : ConeSpace a) : ConeTarget m := | |
| (affinePhase m p.1.val,complexCartesian p.2) | |
| def centralConePrimitive (c d : ℝ) : ManifoldOneForm (ConeModel m) (ConeSpace a) := | |
| manifoldPullbackOneForm (fun _ => conePrimitive c d) (centralConeCoordinates a) 0 | |
| omit [Fact (Injective a)] [Fact (∀ j,a j≠0)] in | |
| theorem movingConeCoordinates_zero {Ψ : ℝ × ConeSpace a → Affine m} | |
| (hΨ : ∀ p,Ψ (0,p)=p.1.val) : | |
| (fun p => movingConeCoordinates a Ψ (0,p))=centralConeCoordinates a := by | |
| funext p | |
| simp only [movingConeCoordinates,centralConeCoordinates,hΨ] | |
| omit [Fact (Injective a)] [Fact (∀ j,a j≠0)] in | |
| theorem movingConeCoordinates_nonzero {Ψ : ℝ × ConeSpace a → Affine m} | |
| {t : ℝ} (ht : t≠0) {p : ConeSpace a} (he : equations a (Ψ (t,p))=t•p.2) : | |
| movingConeCoordinates a Ψ (t,p)=normalConeCoordinates a t (Ψ (t,p)) := by | |
| apply Prod.ext | |
| · rfl | |
| apply congrArg (complexCartesian (ι := Fin m)) | |
| change p.2=fun j => (t:ℂ)⁻¹*equations a (Ψ (t,p)) j | |
| funext j | |
| rw [he] | |
| simp only [Pi.smul_apply,Complex.real_smul] | |
| rw [← mul_assoc,inv_mul_cancel₀ (Complex.ofReal_ne_zero.mpr ht),one_mul] | |
| theorem exists_actual_normal_exact_family {K : Set (locus a)} {H : Set (Fin m → ℂ)} | |
| (hK : IsCompact K) (hH : IsCompact H) (c d : ℝ) : | |
| ∃ Ψ : ℝ × ConeSpace a → Affine m, ∃ Γ : ℝ → ManifoldOneForm (ConeModel m) (ConeSpace a), | |
| ∃ ε : ℝ,0<ε ∧ ∃ U : Set (ConeSpace a),IsOpen U ∧ K×ˢH⊆U ∧ | |
| ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,ConeModel m)) 𝓘(ℝ,Affine m) ∞ Ψ ∧ | |
| SmoothOneFormFamily Γ ∧ Γ 0=centralConePrimitive a c d ∧ | |
| (∀ t∈Icc (-ε) ε,t≠0 → Topology.IsEmbedding (fun p : U => Ψ (t,p.val))) ∧ | |
| (∀ t∈Icc (-ε) ε,t≠0 → ∀ p∈U, | |
| manifoldExteriorOneForm (Γ t) p= | |
| (normalAmbientForm a c d t (Ψ (t,p))).bilinearComp | |
| (manifoldMapDifferential (E := Affine m) (F := ConeModel m) (fun q => Ψ (t,q)) p) | |
| (manifoldMapDifferential (E := Affine m) (F := ConeModel m) (fun q => Ψ (t,q)) p)) := by | |
| obtain ⟨Ψ,ε,hε,U,hU,hKU,hΨ,hΨ0,hEQ,hemb⟩ := exists_actual_normal_tube a hK hH | |
| have hs : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,ConeModel m)) 𝓘(ℝ,Affine m) ∞ Ψ := by | |
| simpa only [modelWithCornersSelf_prod] using hΨ | |
| let g := movingConeCoordinates a Ψ | |
| have hg := movingConeCoordinates_smooth a hs | |
| let Γ := movingPrimitivePullback (E := ConeModel m) (conePrimitive c d) g | |
| refine ⟨Ψ,Γ,ε,hε,U,hU,hKU,hs,movingPrimitivePullback_smooth (conePrimitive_smooth c d) hg,?_,hemb,?_⟩ | |
| · change manifoldPullbackOneForm (fun _ => conePrimitive c d) | |
| (fun p => movingConeCoordinates a Ψ (0,p)) 0=centralConePrimitive a c d | |
| rw [movingConeCoordinates_zero a hΨ0] | |
| rfl | |
| · intro t ht ht0 p hp | |
| have he : (fun q => g (t,q)) =ᶠ[𝓝 p] normalConeCoordinates a t ∘ (fun q => Ψ (t,q)) := by | |
| filter_upwards [hU.mem_nhds hp] with q hq | |
| exact movingConeCoordinates_nonzero a ht0 (hEQ q hq t ht) | |
| have hh := movingPrimitivePullback_exterior_comp (conePrimitive_smooth c d) hg | |
| (normalConeCoordinates_smooth a t) (hs.comp (contMDiff_const.prodMk contMDiff_id)) he | |
| rw [← normalAmbientPrimitive_eq_cone a c d t] at hh | |
| exact hh | |
| abbrev NormalModel (m : ℕ) := RealModel × PlanePhase (Fin m) | |
| abbrev NormalSpace := locus a × PlanePhase (Fin m) | |
| def normalCouplingPrimitive : ManifoldOneForm (NormalModel m) (NormalSpace a) := | |
| productHorizontalLift (normalHorizontalPrimitive (q := m) a 2 ∘ planeMoments)+verticalLiouville | |
| theorem normalCouplingPrimitive_smooth : | |
| SmoothOneFormFamily (fun _ : ℝ => normalCouplingPrimitive a) := by | |
| have hh : SmoothOneFormFamily (fun _ : ℝ => productHorizontalLift | |
| (normalHorizontalPrimitive (q := m) a 2 ∘ planeMoments)) := by | |
| apply productHorizontalLift_smooth (Γ := fun p : ℝ × PlanePhase (Fin m) => | |
| normalHorizontalPrimitive (q := m) a 2 (planeMoments p.2)) | |
| exact ((normalHorizontalPrimitive_smooth (q := m) a 2).comp planeMoments_smooth).comp contDiff_snd | |
| exact hh.add verticalLiouville_smooth | |
| theorem normalCouplingPrimitive_exterior (x : NormalSpace a) : | |
| manifoldExteriorOneForm (normalCouplingPrimitive a) x= | |
| globalHorizontalCoupling phaseArea (normalHorizontalPrimitive (q := m) a 2 ∘ planeMoments) x := by | |
| have hh : SmoothOneFormFamily (fun _ : ℝ => productHorizontalLift | |
| (normalHorizontalPrimitive (q := m) a 2 ∘ planeMoments)) := by | |
| apply productHorizontalLift_smooth (Γ := fun p : ℝ × PlanePhase (Fin m) => | |
| normalHorizontalPrimitive (q := m) a 2 (planeMoments p.2)) | |
| exact ((normalHorizontalPrimitive_smooth (q := m) a 2).comp planeMoments_smooth).comp contDiff_snd | |
| rw [normalCouplingPrimitive,manifoldExteriorOneForm_add_at | |
| (hh.spatial_smooth 0 x (mem_extChartAt_target _)) | |
| (verticalLiouville_smooth.spatial_smooth 0 x (mem_extChartAt_target _)),verticalLiouville_exterior] | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| apply ContinuousLinearMap.ext | |
| intro w | |
| change (_ : ℝ)+_=_+_ | |
| exact add_comm _ _ | |
| theorem normalCoupling_invertible {d : ℝ} (hd : d<1/2) {x : NormalSpace a} | |
| (hx : Real.pi*phaseSq x.2≤d) : | |
| (manifoldExteriorOneForm (normalCouplingPrimitive a) x).IsInvertible := by | |
| rw [normalCouplingPrimitive_exterior] | |
| apply globalToricCoupling_isInvertible (normalHorizontalPrimitive_smooth (q := m) a 2) x | |
| have hex : manifoldExteriorOneForm (normalHorizontalPrimitive (q := m) a 2 (planeMoments x.2))= | |
| equalNormalCoefficient m 2 (planeMoments x.2) • curveFSForm a (1/Real.pi) := | |
| funext (normalHorizontalPrimitive_exterior a 2 (planeMoments x.2)) | |
| rw [hex] | |
| have hc : 0<equalNormalCoefficient m 2 (planeMoments x.2) := by | |
| change 0<1-2*(∑ j,planeMoments x.2 j) | |
| have he : (∑ j,planeMoments x.2 j)=Real.pi*phaseSq x.2 := by | |
| simp only [planeMoments,radialArea,radiusSq,phaseSq,phaseDot_apply,pow_two,← Finset.mul_sum] | |
| rw [he] | |
| linarith | |
| change 0<equalNormalCoefficient m 2 (planeMoments x.2)* | |
| chartTwoForm (curveFSForm a (1/Real.pi)) x.1 (extChartAt 𝓘(ℝ,RealModel) x.1 x.1) (1,0) (0,1) | |
| exact mul_pos hc (curveFSForm_positive a (one_div_pos.mpr Real.pi_pos) x.1 (mem_extChartAt_target _)) | |
| def normalPhaseCoordinates (x : NormalSpace a) : ConeTarget m := | |
| (phaseInclusion a x.1,x.2) | |
| theorem normalPhaseCoordinates_smooth : | |
| ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,ConeTarget m) ∞ (normalPhaseCoordinates a) := | |
| ((phaseInclusion_smooth a).comp flatProduct_fst_smooth).prodMk_space flatProduct_snd_smooth | |
| theorem normalPhaseCoordinates_derivative (x : NormalSpace a) : | |
| manifoldMapDifferential (E := ConeTarget m) (F := NormalModel m) (normalPhaseCoordinates a) x= | |
| (manifoldMapDifferential (E := PlanePhase (Option (Fin m))) (F := RealModel) | |
| (phaseInclusion a) x.1).prodMap (ContinuousLinearMap.id ℝ (PlanePhase (Fin m))) := by | |
| have hf := (((phaseInclusion_smooth a).comp flatProduct_fst_smooth).mdifferentiable (by simp) x).hasMFDerivAt | |
| have hs := ((flatProduct_snd_smooth (E := RealModel) (M := locus a) (V := PlanePhase (Fin m))).mdifferentiable (by simp) x).hasMFDerivAt | |
| have hd : HasMFDerivAt 𝓘(ℝ,NormalModel m) 𝓘(ℝ,ConeTarget m) (normalPhaseCoordinates a) x | |
| ((mfderiv 𝓘(ℝ,NormalModel m) 𝓘(ℝ,PlanePhase (Option (Fin m))) | |
| (phaseInclusion a ∘ Prod.fst) x).prod | |
| (mfderiv 𝓘(ℝ,NormalModel m) 𝓘(ℝ,PlanePhase (Fin m)) Prod.snd x)) := | |
| ⟨hf.1.prodMk hs.1,hf.2.prodMk hs.2⟩ | |
| apply hd.mfderiv.trans | |
| erw [mfderiv_comp x ((phaseInclusion_smooth a).mdifferentiable (by simp) x.1) | |
| (flatProduct_fst_smooth.mdifferentiable (by simp) x),flatProduct_fst_derivative,flatProduct_snd_derivative] | |
| rfl | |
| theorem centralConeCoordinates_smooth : | |
| ContMDiff 𝓘(ℝ,ConeModel m) 𝓘(ℝ,ConeTarget m) ∞ (centralConeCoordinates a) := | |
| ((phaseInclusion_smooth a).comp flatProduct_fst_smooth).prodMk_space | |
| ((complexCartesian (ι := Fin m)).contDiff.contMDiff.comp flatProduct_snd_smooth) | |
| theorem cone_radial_primitive {d : ℝ} (hd : 0<d) | |
| {Ξ : NormalSpace a → ConeSpace a} | |
| (hΞ : ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,ConeModel m) ∞ Ξ) | |
| {x : NormalSpace a} (hx : phaseSq x.2<d/Real.pi) | |
| (he : centralConeCoordinates a ∘ Ξ =ᶠ[𝓝 x] | |
| normalRadial (d/Real.pi) ∘ normalPhaseCoordinates a) : | |
| manifoldPullbackOneForm (fun _ => centralConePrimitive a (1/Real.pi) d) Ξ 0 x= | |
| normalCouplingPrimitive a x := by | |
| have hD := manifoldMapDifferential_comp | |
| ((centralConeCoordinates_smooth a).mdifferentiable (by simp) (Ξ x)) | |
| (hΞ.mdifferentiable (by simp) x) | |
| have hr := ((normalRadial_smoothOn (d/Real.pi)).contDiffAt | |
| ((isOpen_univ.prod (phaseOpenBall_open (d/Real.pi))).mem_nhds | |
| (show normalPhaseCoordinates a x∈univ×ˢphaseOpenBall (d/Real.pi) from ⟨mem_univ _,hx⟩))) | |
| have hDr := manifoldMapDifferential_comp (hr.contMDiffAt.mdifferentiableAt (by simp)) | |
| ((normalPhaseCoordinates_smooth a).mdifferentiable (by simp) x) | |
| have heD : manifoldMapDifferential (E := ConeTarget m) (F := NormalModel m) | |
| (centralConeCoordinates a ∘ Ξ) x= | |
| manifoldMapDifferential (E := ConeTarget m) (F := NormalModel m) | |
| (normalRadial (d/Real.pi) ∘ normalPhaseCoordinates a) x := he.mfderiv_eq | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| change conePrimitive (1/Real.pi) d (centralConeCoordinates a (Ξ x)) | |
| (((manifoldMapDifferential (E := ConeTarget m) (F := ConeModel m) (centralConeCoordinates a) (Ξ x)).comp | |
| (manifoldMapDifferential (E := ConeModel m) (F := NormalModel m) Ξ x)) v)=_ | |
| rw [← hD,heD,hDr] | |
| have hep := he.eq_of_nhds | |
| change centralConeCoordinates a (Ξ x)=normalRadial (d/Real.pi) (normalPhaseCoordinates a x) at hep | |
| rw [hep] | |
| change conePrimitive (1/Real.pi) d (normalRadial (d/Real.pi) (normalPhaseCoordinates a x)) | |
| (mfderiv 𝓘(ℝ,ConeTarget m) 𝓘(ℝ,ConeTarget m) (normalRadial (d/Real.pi)) | |
| (normalPhaseCoordinates a x) (manifoldMapDifferential (E := ConeTarget m) (F := NormalModel m) | |
| (normalPhaseCoordinates a) x v))=_ | |
| erw [mfderiv_eq_fderiv,conePrimitive_radial_pullback hd (p := normalPhaseCoordinates a x) ⟨mem_univ _,hx⟩,normalPhaseCoordinates_derivative] | |
| simp only [normalCouplingPrimitive,Pi.add_apply,add_apply,productHorizontalLift_apply,verticalLiouville_apply, | |
| normalHorizontalPrimitive,normalPhaseCoordinates,Function.comp_apply,Pi.smul_apply,smul_apply,smul_eq_mul] | |
| congr 1 | |
| change (1-2*Real.pi*phaseSq x.2)*curveFSPrimitive a (1/Real.pi) x.1 v.1= | |
| equalNormalCoefficient m 2 (planeMoments x.2)*curveFSPrimitive a (1/Real.pi) x.1 v.1 | |
| congr 1 | |
| simp only [equalNormalCoefficient,planeMoments,radialArea,radiusSq,phaseSq,phaseDot_apply,pow_two,← Finset.mul_sum] | |
| ring | |
| abbrev LargeNormalModel (m : ℕ) := RealModel × PlanePhase (Fin (m+1)) | |
| abbrev LargeNormalSpace := locus a × PlanePhase (Fin (m+1)) | |
| def largeCouplingPrimitive : ManifoldOneForm (LargeNormalModel m) (LargeNormalSpace a) := | |
| productCouplingPrimitive phaseArea (largeHorizontalPrimitive (q := m) a ∘ planeMoments) | |
| theorem largeHorizontal_lift_smooth : | |
| SmoothOneFormFamily (fun _ : ℝ => productHorizontalLift | |
| (largeHorizontalPrimitive (q := m) a ∘ planeMoments)) := by | |
| apply productHorizontalLift_smooth (Γ := fun p : ℝ × PlanePhase (Fin (m+1)) => | |
| largeHorizontalPrimitive (q := m) a (planeMoments p.2)) | |
| exact ((largeHorizontalPrimitive_smooth (q := m) a).comp planeMoments_smooth).comp contDiff_snd | |
| theorem largeCouplingPrimitive_smooth : | |
| SmoothOneFormFamily (fun _ : ℝ => largeCouplingPrimitive a) := by | |
| have hv := productVerticalLiouville_smooth (E := RealModel) (M := locus a) | |
| (V := PlanePhase (Fin (m+1))) (phaseArea (ι := Fin (m+1))) | |
| have hh := largeHorizontal_lift_smooth a | |
| have ht := SmoothOneFormFamily.add hv hh | |
| convert! ht using 1 | |
| theorem largeCouplingPrimitive_exterior (x : LargeNormalSpace a) : | |
| manifoldExteriorOneForm (largeCouplingPrimitive a) x= | |
| globalHorizontalCoupling phaseArea (largeHorizontalPrimitive (q := m) a ∘ planeMoments) x := | |
| productCouplingPrimitive_exterior (E := RealModel) (M := locus a) | |
| (V := PlanePhase (Fin (m+1))) phaseArea phaseArea_skew | |
| ((largeHorizontalPrimitive_smooth (q := m) a).comp planeMoments_smooth) x | |
| theorem phaseMoments_sum {q : ℕ} (z : PlanePhase (Fin q)) : | |
| (∑ j,planeMoments z j)=Real.pi*phaseSq z := by | |
| simp only [planeMoments,radialArea,radiusSq,phaseSq,phaseDot_apply,pow_two,← Finset.mul_sum] | |
| theorem normalCouplingPrimitive_apply (x : NormalSpace a) (v : NormalModel m) : | |
| normalCouplingPrimitive a x v=standardLiouville x.2 v.2+ | |
| (1-2*Real.pi*phaseSq x.2)*curveFSPrimitive a (1/Real.pi) x.1 v.1 := by | |
| simp only [normalCouplingPrimitive,Pi.add_apply,add_apply,productHorizontalLift_apply, | |
| Function.comp_apply,normalHorizontalPrimitive,Pi.smul_apply,smul_apply,smul_eq_mul, | |
| equalNormalCoefficient,phaseMoments_sum,verticalLiouville_apply,standardLiouville] | |
| ring | |
| theorem largeCouplingPrimitive_apply (x : LargeNormalSpace a) (v : LargeNormalModel m) : | |
| largeCouplingPrimitive a x v=standardLiouville x.2 v.2+ | |
| (1-radialArea (normalHead m x.2)-2*Real.pi*phaseSq (normalTail m x.2))* | |
| curveFSPrimitive a (1/Real.pi) x.1 v.1 := by | |
| simp only [largeCouplingPrimitive,productCouplingPrimitive,Pi.add_apply,add_apply, | |
| productVerticalLiouville_apply,productHorizontalLift_apply,Function.comp_apply, | |
| largeHorizontalPrimitive,largeNormalCoefficient,Pi.smul_apply,smul_apply,smul_eq_mul] | |
| have he : (∑ j : Fin m,planeMoments x.2 j.succ)=Real.pi*phaseSq (normalTail m x.2) := | |
| phaseMoments_sum (normalTail m x.2) | |
| rw [he] | |
| change (1/2:ℝ)*phaseArea x.2 v.2+(1-radialArea (normalHead m x.2)-2*(Real.pi*phaseSq (normalTail m x.2)))* | |
| curveFSPrimitive a (1/Real.pi) x.1 v.1=_ | |
| simp only [standardLiouville,smul_apply,smul_eq_mul] | |
| ring | |
| theorem firstTailMap_primitive {s : PlanePhase (Fin (m+1)) → ℝ} (hs : ContDiff ℝ ∞ s) | |
| (x : LargeNormalSpace a) (hc : (1-radialArea (normalHead m x.2))*(s x.2)^2=1) : | |
| manifoldPullbackOneForm (fun _ => firstLinePrimitive (normalCouplingPrimitive a)) | |
| (firstTailMap s) 0 x=largeCouplingPrimitive a x := by | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| change firstLinePrimitive (normalCouplingPrimitive a) (firstTailMap s x) | |
| (manifoldMapDifferential (E := NormalModel m × Plane) (F := LargeNormalModel m) (firstTailMap s) x v)=_ | |
| rw [firstTailMap_derivative hs,firstLinePrimitive_apply,normalCouplingPrimitive_apply, | |
| largeCouplingPrimitive_apply] | |
| change linearLiouville planarArea (normalHead m x.2) (normalHead m v.2)+ | |
| (1-radialArea (normalHead m x.2))*(standardLiouville (s x.2 • normalTail m x.2) | |
| (fderiv ℝ (fun z => s z • normalTail m z) x.2 v.2)+ | |
| (1-2*Real.pi*phaseSq (s x.2 • normalTail m x.2))*curveFSPrimitive a (1/Real.pi) x.1 v.1)=_ | |
| have hL := linearLiouville_variable_smul phaseArea phaseArea_self (hs.differentiable (by simp) x.2) | |
| (normalTail m).differentiableAt v.2 | |
| change standardLiouville (s x.2 • normalTail m x.2) | |
| (fderiv ℝ (fun z => s z • normalTail m z) x.2 v.2)=_ at hL | |
| rw [(normalTail m).fderiv] at hL | |
| change standardLiouville (s x.2 • normalTail m x.2) | |
| (fderiv ℝ (fun z => s z • normalTail m z) x.2 v.2)= | |
| (s x.2)^2*standardLiouville (normalTail m x.2) (normalTail m v.2) at hL | |
| rw [hL,phaseSq_smul,normalSplit_liouville] | |
| change _=standardLiouville (normalTail m x.2) (normalTail m v.2)+ | |
| linearLiouville planarArea (normalHead m x.2) (normalHead m v.2)+_ | |
| linear_combination | |
| (standardLiouville (normalTail m x.2) (normalTail m v.2)- | |
| 2*Real.pi*phaseSq (normalTail m x.2)*curveFSPrimitive a (1/Real.pi) x.1 v.1)*hc | |
| theorem largeCouplingPrimitive_invertible {x : LargeNormalSpace a} | |
| (hx : 0<1-radialArea (normalHead m x.2)-2*Real.pi*phaseSq (normalTail m x.2)) : | |
| (manifoldExteriorOneForm (largeCouplingPrimitive a) x).IsInvertible := by | |
| rw [largeCouplingPrimitive_exterior] | |
| apply globalToricCoupling_isInvertible (largeHorizontalPrimitive_smooth (q := m) a) x | |
| have hex : manifoldExteriorOneForm (largeHorizontalPrimitive (q := m) a (planeMoments x.2))= | |
| largeNormalCoefficient m (planeMoments x.2) • curveFSForm a (1/Real.pi) := | |
| funext (largeHorizontalPrimitive_exterior a (planeMoments x.2)) | |
| rw [hex] | |
| have he : largeNormalCoefficient m (planeMoments x.2)= | |
| 1-radialArea (normalHead m x.2)-2*Real.pi*phaseSq (normalTail m x.2) := by | |
| have ht : (∑ j : Fin m,planeMoments x.2 j.succ)=Real.pi*phaseSq (normalTail m x.2) := | |
| phaseMoments_sum (normalTail m x.2) | |
| simp only [largeNormalCoefficient,ht] | |
| change 1-radialArea (normalHead m x.2)-2*(Real.pi*phaseSq (normalTail m x.2))=_ | |
| ring | |
| change 0<largeNormalCoefficient m (planeMoments x.2)* | |
| chartTwoForm (curveFSForm a (1/Real.pi)) x.1 (extChartAt 𝓘(ℝ,RealModel) x.1 x.1) (1,0) (0,1) | |
| rw [he] | |
| exact mul_pos hx (curveFSForm_positive a (one_div_pos.mpr Real.pi_pos) x.1 (mem_extChartAt_target _)) | |
| end | |
| variable {m : ℕ} (a : Fin m → ℂ) [Fact (Injective a)] [Fact (∀ j,a j≠0)] | |
| theorem exists_compact_first_tail_bridge {b d : ℝ} (hb : b<1) | |
| {K : Set (LargeNormalSpace a)} (hK : IsCompact K) | |
| (hKb : ∀ x∈K,radialArea (normalHead m x.2)<b) | |
| (hKd : ∀ x∈K,Real.pi*phaseSq (normalTail m x.2)<d*(1-radialArea (normalHead m x.2))) : | |
| ∃ H : LargeNormalSpace a → NormalSpace a × Plane, | |
| ContMDiff 𝓘(ℝ,LargeNormalModel m) 𝓘(ℝ,NormalModel m × Plane) ∞ H ∧ | |
| ∃ D : Set (LargeNormalSpace a),IsOpen D ∧ K⊆D ∧ | |
| Topology.IsEmbedding (fun x : D => H x.val) ∧ | |
| (∀ x,radialArea (H x).2=radialArea (normalHead m x.2)) ∧ | |
| (∀ x∈D,radialArea (H x).2<b ∧ phaseSq (H x).1.2<d/Real.pi) ∧ | |
| (∀ x∈D,manifoldPullbackOneForm (fun _ => firstLinePrimitive (normalCouplingPrimitive a)) H 0 x= | |
| largeCouplingPrimitive a x) := by | |
| let U : Set (PlanePhase (Fin (m+1))) := {z | radialArea (normalHead m z)<b ∧ | |
| Real.pi*phaseSq (normalTail m z)<d*(1-radialArea (normalHead m z))} | |
| have hU : IsOpen U := | |
| (isOpen_lt (radialArea_smooth.continuous.comp (normalHead m).continuous) continuous_const).inter | |
| (isOpen_lt (continuous_const.mul (phaseSq_smooth.continuous.comp (normalTail m).continuous)) | |
| (continuous_const.mul (continuous_const.sub (radialArea_smooth.continuous.comp (normalHead m).continuous)))) | |
| let σ : PlanePhase (Fin (m+1)) → ℝ := fun z => (Real.sqrt (1-radialArea (normalHead m z)))⁻¹ | |
| have hσ : ContDiffOn ℝ ∞ σ U := | |
| (((contDiffOn_const.sub ((radialArea_smooth.comp (normalHead m).contDiff).contDiffOn)).sqrt | |
| (fun z hz => (sub_pos.mpr (hz.1.trans hb)).ne')).inv | |
| (fun z hz => (Real.sqrt_pos.mpr (sub_pos.mpr (hz.1.trans hb))).ne')) | |
| obtain ⟨χ,_hχ,_hχc,_hχU,_hχr,_hχ1,hs,_hsc,hse⟩ := exists_smooth_compact_extension | |
| (hK.image continuous_snd) hU (by rintro z ⟨x,hx,rfl⟩; exact ⟨hKb x hx,hKd x hx⟩) hσ | |
| let s : PlanePhase (Fin (m+1)) → ℝ := fun z => χ z • σ z | |
| obtain ⟨O,hO,hKO,hOs⟩ := mem_nhdsSet_iff_exists.mp hse | |
| let D : Set (LargeNormalSpace a) := Prod.snd ⁻¹' (O∩U) | |
| have hD : IsOpen D := (hO.inter hU).preimage continuous_snd | |
| let H : LargeNormalSpace a → NormalSpace a × Plane := firstTailMap s | |
| have hH := firstTailMap_smooth (M := locus a) (E := RealModel) hs | |
| have hratio (x : LargeNormalSpace a) (hx : x∈D) : | |
| (1-radialArea (normalHead m x.2))*(s x.2)^2=1 := by | |
| have he : s x.2=σ x.2 := hOs hx.1 | |
| rw [he] | |
| change (1-radialArea (normalHead m x.2))*((Real.sqrt (1-radialArea (normalHead m x.2)))⁻¹)^2=1 | |
| rw [inv_pow,Real.sq_sqrt (sub_pos.mpr (hx.2.1.trans hb)).le, | |
| mul_inv_cancel₀ (sub_pos.mpr (hx.2.1.trans hb)).ne'] | |
| let G : NormalSpace a × Plane → LargeNormalSpace a := fun y => | |
| (y.1.1,(normalSplit m).symm (Real.sqrt (1-radialArea y.2) • y.1.2,y.2)) | |
| have hG : Continuous G := by | |
| exact continuous_fst.fst.prodMk ((normalSplit m).symm.continuous.comp | |
| (((Real.continuous_sqrt.comp (continuous_const.sub (radialArea_smooth.continuous.comp continuous_snd))).smul | |
| continuous_fst.snd).prodMk continuous_snd)) | |
| have hGH (x : LargeNormalSpace a) (hx : x∈D) : G (H x)=x := by | |
| apply Prod.ext | |
| · rfl | |
| have he : s x.2=σ x.2 := hOs hx.1 | |
| change (normalSplit m).symm | |
| (Real.sqrt (1-radialArea (normalHead m x.2)) • (s x.2 • normalTail m x.2),normalHead m x.2)=x.2 | |
| rw [he,smul_smul] | |
| change (normalSplit m).symm | |
| ((Real.sqrt (1-radialArea (normalHead m x.2))* | |
| (Real.sqrt (1-radialArea (normalHead m x.2)))⁻¹) • normalTail m x.2,normalHead m x.2)=x.2 | |
| rw [mul_inv_cancel₀ (Real.sqrt_pos.mpr (sub_pos.mpr (hx.2.1.trans hb))).ne',one_smul] | |
| exact (normalSplit m).symm_apply_apply x.2 | |
| have hemb : Topology.IsEmbedding (fun x : D => H x.val) := by | |
| apply Topology.IsEmbedding.of_comp (hH.continuous.comp continuous_subtype_val) hG | |
| convert Topology.IsEmbedding.subtypeVal (p := fun x => x∈D) using 1 | |
| funext x | |
| exact hGH x.val x.property | |
| refine ⟨H,hH,D,hD,fun x hx => ⟨hKO ⟨x,hx,rfl⟩,hKb x hx,hKd x hx⟩,hemb, | |
| fun _ => rfl,?_,fun x hx => firstTailMap_primitive a hs x (hratio x hx)⟩ | |
| intro x hx | |
| refine ⟨hx.2.1,?_⟩ | |
| change phaseSq (s x.2 • normalTail m x.2)<d/Real.pi | |
| rw [phaseSq_smul] | |
| apply (lt_div_iff₀ Real.pi_pos).mpr | |
| have hu : 0<1-radialArea (normalHead m x.2) := sub_pos.mpr (hx.2.1.trans hb) | |
| apply (mul_lt_mul_iff_of_pos_left hu).mp | |
| calc | |
| (1-radialArea (normalHead m x.2))*((s x.2)^2*phaseSq (normalTail m x.2)*Real.pi)= | |
| Real.pi*phaseSq (normalTail m x.2) := by rw [← mul_assoc,← mul_assoc,hratio x hx]; ring | |
| _<d*(1-radialArea (normalHead m x.2)) := hx.2.2 | |
| _=(1-radialArea (normalHead m x.2))*d := mul_comm _ _ | |
| theorem exists_compact_radial_bridge {d : ℝ} (hd : 0<d) | |
| {K : Set (NormalSpace a)} (hK : IsCompact K) | |
| (hKd : ∀ p∈K,phaseSq p.2<d/Real.pi) : | |
| ∃ Ξ : NormalSpace a → ConeSpace a, | |
| ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,ConeModel m) ∞ Ξ ∧ | |
| ∃ D : Set (NormalSpace a),IsOpen D ∧ K⊆D ∧ | |
| (∀ p∈D,phaseSq p.2<d/Real.pi) ∧ | |
| Topology.IsEmbedding (fun p : D => Ξ p.val) ∧ | |
| EqOn (centralConeCoordinates a ∘ Ξ) | |
| (normalRadial (d/Real.pi) ∘ normalPhaseCoordinates a) D := by | |
| let H := Prod.snd '' K | |
| have hH : IsCompact H := hK.image continuous_snd | |
| have hHd : H⊆phaseOpenBall (d/Real.pi) := by | |
| rintro _ ⟨p,hp,rfl⟩ | |
| exact hKd p hp | |
| obtain ⟨χ,_hχ,_hχc,_hχs,_hχr,_hχ1,hF,_hFc,hFe⟩ := | |
| exists_smooth_compact_extension hH (phaseOpenBall_open (d/Real.pi)) hHd | |
| (fsAffineMap_smoothOn (d/Real.pi)) | |
| let F : PlanePhase (Fin m) → PlanePhase (Fin m) := fun u => χ u • fsAffineMap (d/Real.pi) u | |
| obtain ⟨O,hO,hHO,hOF⟩ := mem_nhdsSet_iff_exists.mp hFe | |
| let D : Set (NormalSpace a) := Prod.snd ⁻¹' (O∩phaseOpenBall (d/Real.pi)) | |
| have hD : IsOpen D := (hO.inter (phaseOpenBall_open (d/Real.pi))).preimage continuous_snd | |
| let A : NormalSpace a → ℝ := fun p => 1+phaseSq (phaseInclusion a p.1) | |
| have hA : ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,ℝ) ∞ A := | |
| contMDiff_const.add (phaseSq_smooth.contMDiff.comp | |
| ((phaseInclusion_smooth a).comp flatProduct_fst_smooth)) | |
| let Ξ : NormalSpace a → ConeSpace a := | |
| fun p => (p.1,complexCartesian.symm (A p • F p.2)) | |
| have hΞ : ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,ConeModel m) ∞ Ξ := by | |
| have hs := (complexCartesian (ι := Fin m)).symm.contDiff.contMDiff.comp | |
| (hA.smul (hF.contMDiff.comp flatProduct_snd_smooth)) | |
| rw [show 𝓘(ℝ,ConeModel m)=(𝓘(ℝ,RealModel)).prod 𝓘(ℝ,Fin m → ℂ) from modelWithCornersSelf_prod] | |
| exact (flatProduct_fst_smooth (E := RealModel) (M := locus a) (V := PlanePhase (Fin m))).prodMk hs | |
| let R : ConeSpace a → NormalSpace a := fun p => (p.1,fsBallMap (d/Real.pi) | |
| ((1+phaseSq (phaseInclusion a p.1))⁻¹ • complexCartesian p.2)) | |
| have hR : Continuous R := by | |
| apply continuous_fst.prodMk | |
| apply (fsBallMap_smooth (d/Real.pi)).continuous.comp | |
| exact (((continuous_const.add (phaseSq_smooth.continuous.comp | |
| ((phaseInclusion_smooth a).continuous.comp continuous_fst))).inv₀ | |
| (fun p => (fs_den_pos (phaseInclusion a p.1)).ne')).smul | |
| ((complexCartesian (ι := Fin m)).continuous.comp continuous_snd)) | |
| have hRI (p : NormalSpace a) (hp : p∈D) : R (Ξ p)=p := by | |
| have hFp : F p.2=fsAffineMap (d/Real.pi) p.2 := hOF hp.1 | |
| simp only [R,Ξ,ContinuousLinearEquiv.apply_symm_apply,A,hFp,smul_smul, | |
| inv_mul_cancel₀ (fs_den_pos (phaseInclusion a p.1)).ne',one_smul, | |
| fsBallMap_fsAffineMap (div_pos hd Real.pi_pos) hp.2] | |
| refine ⟨Ξ,hΞ,D,hD,?_,fun _ hp => hp.2,?_,?_⟩ | |
| · intro p hp | |
| exact ⟨hHO ⟨p,hp,rfl⟩,hKd p hp⟩ | |
| · apply Topology.IsEmbedding.of_comp (hΞ.continuous.comp continuous_subtype_val) hR | |
| have he : R ∘ (fun p : D => Ξ p.val)=Subtype.val := funext fun p => hRI p.val p.property | |
| change Topology.IsEmbedding (R ∘ (fun p : D => Ξ p.val)) | |
| rw [he] | |
| exact Topology.IsEmbedding.subtypeVal | |
| · intro p hp | |
| have hFp : F p.2=fsAffineMap (d/Real.pi) p.2 := hOF hp.1 | |
| simp only [Function.comp_apply,centralConeCoordinates,Ξ,ContinuousLinearEquiv.apply_symm_apply, | |
| normalRadial,normalPhaseCoordinates,phaseInclusion,A,hFp] | |
| end PackingSufficiencySupport.DiagonalQuadrics | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold | |
| variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] | |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] | |
| {M : Type*} [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M] | |
| omit [IsManifold 𝓘(ℝ,E) ∞ M] in | |
| theorem movingPrimitivePullback_comp_eq | |
| {α : F → F →L[ℝ] ℝ} {g : ℝ × M → F} {A : G → F} {h : M → G} | |
| (hA : ContDiff ℝ ∞ A) (hh : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,G) ∞ h) | |
| {t : ℝ} {x : M} (he : (fun y => g (t,y)) =ᶠ[𝓝 x] A ∘ h) : | |
| movingPrimitivePullback (E := E) α g t x= | |
| (primitivePullback α A (h x)).comp (manifoldMapDifferential (E := G) (F := E) h x) := by | |
| have hd : manifoldMapDifferential (E := F) (F := E) (fun y => g (t,y)) x= | |
| (fderiv ℝ A (h x)).comp (manifoldMapDifferential (E := G) (F := E) h x) := by | |
| unfold manifoldMapDifferential | |
| rw [he.mfderiv_eq] | |
| rw [mfderiv_comp x (hA.contMDiff.mdifferentiable (by simp) (h x)) | |
| (hh.mdifferentiable (by simp) x)] | |
| rw [mfderiv_eq_fderiv] | |
| ext tangent | |
| rfl | |
| simp only [movingPrimitivePullback,manifoldPullbackOneForm,hd,he.eq_of_nhds, | |
| primitivePullback,ContinuousLinearMap.comp_assoc,Function.comp_apply] | |
| end PackingSufficiencySupport.Hamiltonian | |
| namespace PackingSufficiencySupport.DiagonalQuadrics | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold | |
| open Hamiltonian | |
| variable {m : ℕ} (a : Fin m → ℂ) [Fact (Injective a)] [Fact (∀ j,a j≠0)] | |
| theorem exists_actual_normal_primitive_family {K : Set (locus a)} {H : Set (Fin m → ℂ)} | |
| (hK : IsCompact K) (hH : IsCompact H) (c d : ℝ) : | |
| ∃ Ψ : ℝ × ConeSpace a → Affine m, ∃ Γ : ℝ → ManifoldOneForm (ConeModel m) (ConeSpace a), | |
| ∃ ε : ℝ,0<ε ∧ ∃ U : Set (ConeSpace a),IsOpen U ∧ K×ˢH⊆U ∧ | |
| ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,ConeModel m)) 𝓘(ℝ,Affine m) ∞ Ψ ∧ | |
| SmoothOneFormFamily Γ ∧ Γ 0=centralConePrimitive a c d ∧ | |
| (∀ t∈Icc (-ε) ε,t≠0 → Topology.IsEmbedding (fun p : U => Ψ (t,p.val))) ∧ | |
| (∀ t∈Icc (-ε) ε,t≠0 → ∀ p∈U, | |
| Γ t p=(normalAmbientPrimitive a c d t (Ψ (t,p))).comp | |
| (manifoldMapDifferential (E := Affine m) (F := ConeModel m) (fun q => Ψ (t,q)) p)) := by | |
| obtain ⟨Ψ,ε,hε,U,hU,hKU,hΨ,hΨ0,hEQ,hemb⟩ := exists_actual_normal_tube a hK hH | |
| have hs : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,ConeModel m)) 𝓘(ℝ,Affine m) ∞ Ψ := by | |
| simpa only [modelWithCornersSelf_prod] using hΨ | |
| let g := movingConeCoordinates a Ψ | |
| have hg := movingConeCoordinates_smooth a hs | |
| let Γ := movingPrimitivePullback (E := ConeModel m) (conePrimitive c d) g | |
| refine ⟨Ψ,Γ,ε,hε,U,hU,hKU,hs,movingPrimitivePullback_smooth (conePrimitive_smooth c d) hg,?_,hemb,?_⟩ | |
| · change manifoldPullbackOneForm (fun _ => conePrimitive c d) | |
| (fun p => movingConeCoordinates a Ψ (0,p)) 0=centralConePrimitive a c d | |
| rw [movingConeCoordinates_zero a hΨ0] | |
| rfl | |
| · intro t ht ht0 p hp | |
| have he : (fun q => g (t,q)) =ᶠ[𝓝 p] normalConeCoordinates a t ∘ (fun q => Ψ (t,q)) := by | |
| filter_upwards [hU.mem_nhds hp] with q hq | |
| exact movingConeCoordinates_nonzero a ht0 (hEQ q hq t ht) | |
| have hh := movingPrimitivePullback_comp_eq (α := conePrimitive c d) | |
| (normalConeCoordinates_smooth a t) (hs.comp (contMDiff_const.prodMk contMDiff_id)) he | |
| rw [← normalAmbientPrimitive_eq_cone a c d t] at hh | |
| exact hh | |
| theorem exists_actual_radial_primitive_family {d : ℝ} (hd : 0<d) | |
| {K : Set (NormalSpace a)} (hK : IsCompact K) | |
| (hKd : ∀ x∈K,phaseSq x.2<d/Real.pi) : | |
| ∃ A : ℝ × NormalSpace a → Affine m,∃ Γ : ℝ → ManifoldOneForm (NormalModel m) (NormalSpace a), | |
| ∃ ε : ℝ,0<ε ∧ ∃ U : Set (NormalSpace a),IsOpen U ∧ K⊆U ∧ | |
| ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,NormalModel m)) 𝓘(ℝ,Affine m) ∞ A ∧ | |
| SmoothOneFormFamily Γ ∧ EqOn (Γ 0) (normalCouplingPrimitive a) U ∧ | |
| (∀ t∈Ioc (0:ℝ) ε,Topology.IsEmbedding (fun x : U => A (t,x.val))) ∧ | |
| (∀ t∈Ioc (0:ℝ) ε,∀ x∈U,Γ t x= | |
| (normalAmbientPrimitive a (1/Real.pi) d t (A (t,x))).comp | |
| (manifoldMapDifferential (E := Affine m) (F := NormalModel m) (fun y => A (t,y)) x)) := by | |
| obtain ⟨Ξ,hΞ,D,hD,hKD,hDd,hΞemb,hΞeq⟩ := exists_compact_radial_bridge a hd hK hKd | |
| have hIK : IsCompact (Ξ '' K) := hK.image hΞ.continuous | |
| obtain ⟨Ψ,Γ,ε,hε,V,hV,hVK,hΨ,hΓ,hΓ0,hΨemb,hΓprim⟩ := | |
| exists_actual_normal_primitive_family a (hIK.image continuous_fst) (hIK.image continuous_snd) (1/Real.pi) d | |
| have hKV : MapsTo Ξ K V := by | |
| intro x hx | |
| exact hVK ⟨⟨Ξ x,⟨x,hx,rfl⟩,rfl⟩,⟨Ξ x,⟨x,hx,rfl⟩,rfl⟩⟩ | |
| let Δ : ℝ → ManifoldOneForm (NormalModel m) (NormalSpace a) := | |
| manifoldPullbackOneForm (E := ConeModel m) (F := NormalModel m) Γ Ξ | |
| let A : ℝ × NormalSpace a → Affine m := fun p => Ψ (p.1,Ξ p.2) | |
| let U := D∩Ξ ⁻¹' V | |
| have hU : IsOpen U := hD.inter (hV.preimage hΞ.continuous) | |
| have hA : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,NormalModel m)) 𝓘(ℝ,Affine m) ∞ A := | |
| hΨ.comp (contMDiff_fst.prodMk (hΞ.comp contMDiff_snd)) | |
| have htI {t : ℝ} (ht : t∈Ioc (0:ℝ) ε) : t∈Icc (-ε) ε := ⟨by linarith [ht.1],ht.2⟩ | |
| refine ⟨A,Δ,ε,hε,U,hU,fun x hx => ⟨hKD hx,hKV hx⟩,hA, | |
| manifoldPullbackOneForm_smooth hΞ hΓ,?_,?_,?_⟩ | |
| · intro x hx | |
| have he := cone_radial_primitive a hd hΞ (hDd x hx.1) | |
| (hΞeq.eventuallyEq_of_mem (hD.mem_nhds hx.1)) | |
| simpa only [Δ,manifoldPullbackOneForm,hΓ0] using he | |
| · intro t ht | |
| exact (hΨemb t (htI ht) (ne_of_gt ht.1)).comp | |
| (((hΞemb.comp (Topology.IsEmbedding.inclusion inter_subset_left)).codRestrict V) | |
| (fun x : U => x.property.2)) | |
| · intro t ht x hx | |
| have hs : ContMDiff 𝓘(ℝ,ConeModel m) 𝓘(ℝ,Affine m) ∞ (fun p => Ψ (t,p)) := | |
| hΨ.comp (contMDiff_const.prodMk contMDiff_id) | |
| change (Γ t (Ξ x)).comp (manifoldMapDifferential (E := ConeModel m) (F := NormalModel m) Ξ x)=_ | |
| rw [hΓprim t (htI ht) (ne_of_gt ht.1) (Ξ x) hx.2] | |
| have hdiff := manifoldMapDifferential_comp | |
| (hs.mdifferentiable (by simp) (Ξ x)) (hΞ.mdifferentiable (by simp) x) | |
| change manifoldMapDifferential (E := Affine m) (F := NormalModel m) (fun y => A (t,y)) x=_ at hdiff | |
| rw [hdiff,ContinuousLinearMap.comp_assoc] | |
| end PackingSufficiencySupport.DiagonalQuadrics | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped Manifold ContDiff Topology | |
| open Set Function Manifold | |
| variable {E F : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] | |
| [NormedAddCommGroup F] [NormedSpace ℝ F] | |
| {M N : Type} [TopologicalSpace M] [ChartedSpace E M] | |
| [TopologicalSpace N] [ChartedSpace F N] | |
| theorem firstLineBaseMap_isEmbedding_on {g : M → N} {U : Set M} | |
| (hg : Topology.IsEmbedding (fun x : U => g x.val)) : | |
| Topology.IsEmbedding (fun x : Prod.fst ⁻¹' U => firstLineBaseMap g x.val) := by | |
| let j : (Prod.fst ⁻¹' U : Set (M × Plane)) → U × Plane := | |
| fun x => (⟨x.val.1,x.property⟩,x.val.2) | |
| have hjc : Continuous j := | |
| (continuous_subtype_val.fst.subtype_mk _).prodMk continuous_subtype_val.snd | |
| let k : U × Plane → M × Plane := Prod.map Subtype.val id | |
| have hkc : Continuous k := continuous_subtype_val.prodMap continuous_id | |
| have hj : Topology.IsEmbedding j := by | |
| apply Topology.IsEmbedding.of_comp hjc hkc | |
| exact Topology.IsEmbedding.subtypeVal | |
| exact (hg.prodMap Topology.IsEmbedding.id).comp hj | |
| theorem firstLineMoving_smooth {A : ℝ × M → N} | |
| (hA : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,E)) 𝓘(ℝ,F) ∞ A) : | |
| ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,E × Plane)) 𝓘(ℝ,F × Plane) ∞ | |
| (fun p : ℝ × (M × Plane) => firstLineBaseMap (fun x => A (p.1,x)) p.2) := by | |
| rw [show 𝓘(ℝ,F × Plane)=(𝓘(ℝ,F)).prod 𝓘(ℝ,Plane) from modelWithCornersSelf_prod] | |
| exact (hA.comp (contMDiff_fst.prodMk | |
| ((flatProduct_fst_smooth (E := E) (M := M) (V := Plane)).comp contMDiff_snd))).prodMk | |
| ((flatProduct_snd_smooth (E := E) (M := M) (V := Plane)).comp contMDiff_snd) | |
| theorem firstLineBaseMap_primitive_eq {g : M → N} | |
| (hg : ContMDiff 𝓘(ℝ,E) 𝓘(ℝ,F) ∞ g) (α : ManifoldOneForm F N) | |
| (β : ManifoldOneForm E M) {x : M × Plane} | |
| (he : (α (g x.1)).comp (manifoldMapDifferential (E := F) (F := E) g x.1)=β x.1) : | |
| manifoldPullbackOneForm (fun _ => firstLinePrimitive α) (firstLineBaseMap g) 0 x= | |
| firstLinePrimitive β x := by | |
| rw [firstLineBaseMap_primitive hg] | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| rw [firstLinePrimitive_apply,firstLinePrimitive_apply] | |
| change linearLiouville planarArea x.2 v.2+(1-radialArea x.2)* | |
| ((α (g x.1)).comp (manifoldMapDifferential (E := F) (F := E) g x.1)) v.1=_ | |
| rw [he] | |
| end PackingSufficiencySupport.Hamiltonian | |
| namespace PackingSufficiencySupport.DiagonalQuadrics | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold | |
| open Hamiltonian | |
| variable {m : ℕ} (a : Fin m → ℂ) [Fact (Injective a)] [Fact (∀ j,a j≠0)] | |
| theorem exists_actual_large_normal_transfer {b d : ℝ} (hb : b<1) | |
| (hd : 0<d) (hdhalf : d<1/2) {K : Set (LargeNormalSpace a)} (hK : IsCompact K) | |
| (hKb : ∀ x∈K,radialArea (normalHead m x.2)<b) | |
| (hKd : ∀ x∈K,Real.pi*phaseSq (normalTail m x.2)<d*(1-radialArea (normalHead m x.2))) : | |
| ∃ t : ℝ,0<t ∧ ∃ g : LargeNormalSpace a → Affine m × Plane, | |
| ∃ W : Set (LargeNormalSpace a),IsOpen W ∧ K⊆W ∧ | |
| ContMDiff 𝓘(ℝ,LargeNormalModel m) 𝓘(ℝ,Affine m × Plane) ∞ g ∧ | |
| Topology.IsEmbedding (fun x : W => g x.val) ∧ | |
| (∀ x∈W,radialArea (g x).2<b) ∧ | |
| ∀ x∈W,∀ v w, | |
| euclideanExteriorOneForm (firstLinePrimitive (normalAmbientPrimitive a (1/Real.pi) d t)) (g x) | |
| (mfderiv 𝓘(ℝ,LargeNormalModel m) 𝓘(ℝ,Affine m × Plane) g x v) | |
| (mfderiv 𝓘(ℝ,LargeNormalModel m) 𝓘(ℝ,Affine m × Plane) g x w)= | |
| globalHorizontalCoupling phaseArea (largeHorizontalPrimitive (q := m) a ∘ planeMoments) x v w := by | |
| let : SigmaCompactSpace (locus a) := IsClosed.sigmaCompactSpace (locus_isClosed a) | |
| obtain ⟨H,hH,D,hD,hKD,hHemb,_hHu,hHD,hHprim⟩ := exists_compact_first_tail_bridge a hb hK hKb hKd | |
| have hHK : IsCompact (Prod.fst '' (H '' K)) := (hK.image hH.continuous).image continuous_fst | |
| obtain ⟨A,Γ,δ,hδ,U,hU,hUK,hA,hΓ,hΓ0,hAemb,hΓprim⟩ := | |
| exists_actual_radial_primitive_family a hd hHK (by | |
| rintro y ⟨z,⟨x,hx,rfl⟩,rfl⟩ | |
| exact (hHD x (hKD hx)).2) | |
| let V : Set (LargeNormalSpace a) := D∩(fun x => (H x).1) ⁻¹' U | |
| have hV : IsOpen V := hD.inter (hU.preimage hH.continuous.fst) | |
| have hKV : K⊆V := fun x hx => ⟨hKD hx,hUK ⟨H x,⟨x,hx,rfl⟩,rfl⟩⟩ | |
| let Δ : ℝ → ManifoldOneForm (LargeNormalModel m) (LargeNormalSpace a) := | |
| manifoldPullbackOneForm (fun t => firstLinePrimitive (Γ t)) H | |
| have hΔ : SmoothOneFormFamily Δ := | |
| manifoldPullbackOneForm_smooth hH (firstLinePrimitive_family_smooth hΓ) | |
| have hΔ0 (x : LargeNormalSpace a) (hx : x∈V) : Δ 0 x=largeCouplingPrimitive a x := by | |
| have he : firstLinePrimitive (Γ 0) (H x)=firstLinePrimitive (normalCouplingPrimitive a) (H x) := by | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| rw [firstLinePrimitive_apply,firstLinePrimitive_apply,hΓ0 hx.2] | |
| change (firstLinePrimitive (Γ 0) (H x)).comp | |
| (manifoldMapDifferential (E := NormalModel m × Plane) (F := LargeNormalModel m) H x)=_ | |
| rw [he] | |
| exact hHprim x hx.1 | |
| have hΔext (x : LargeNormalSpace a) (hx : x∈V) : | |
| manifoldExteriorOneForm (Δ 0) x=manifoldExteriorOneForm (largeCouplingPrimitive a) x := | |
| manifoldExteriorOneForm_congr_germ (Filter.eventually_of_mem (hV.mem_nhds hx) hΔ0) | |
| have hinv (x : LargeNormalSpace a) (hx : x∈K) : (manifoldExteriorOneForm (Δ 0) x).IsInvertible := by | |
| rw [hΔext x (hKV hx)] | |
| apply largeCouplingPrimitive_invertible | |
| have hu : 0<1-radialArea (normalHead m x.2) := sub_pos.mpr ((hKb x hx).trans hb) | |
| have hm := hKd x hx | |
| have hp := mul_pos (show 0<1-2*d by linarith) hu | |
| nlinarith | |
| let J : ℝ × LargeNormalSpace a → Affine m × Plane := | |
| fun p => firstLineBaseMap (fun x => A (p.1,x)) (H p.2) | |
| have hJ : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,LargeNormalModel m)) 𝓘(ℝ,Affine m × Plane) ∞ J := | |
| by | |
| have hh := firstLineMoving_smooth hA | |
| simp +instances only [flatProduct_chartedSpace,chartedSpaceSelf_prod] at hh | |
| exact hh.comp (contMDiff_fst.prodMk (hH.comp contMDiff_snd)) | |
| have hJs (t : ℝ) : ContMDiff 𝓘(ℝ,LargeNormalModel m) 𝓘(ℝ,Affine m × Plane) ∞ (fun x => J (t,x)) := | |
| hJ.comp (contMDiff_const.prodMk contMDiff_id) | |
| have hJemb (t : ℝ) (ht : t∈Ioc (0:ℝ) δ) : Topology.IsEmbedding (fun x : V => J (t,x.val)) := by | |
| exact (firstLineBaseMap_isEmbedding_on (g := fun y => A (t,y)) (hAemb t ht)).comp | |
| ((hHemb.comp (Topology.IsEmbedding.inclusion inter_subset_left)).codRestrict | |
| (Prod.fst ⁻¹' U) (fun x : V => x.property.2)) | |
| let α : ℝ → (Affine m × Plane) → (Affine m × Plane) →L[ℝ] ℝ := | |
| fun t => firstLinePrimitive (normalAmbientPrimitive a (1/Real.pi) d t) | |
| have hα (t : ℝ) : ContDiff ℝ ∞ (α t) := | |
| firstLinePrimitive_smooth (normalAmbientPrimitive_smooth a _ d t) | |
| have hJprim (t : ℝ) (ht : t∈Ioc (0:ℝ) δ) (x : LargeNormalSpace a) (hx : x∈V) : | |
| Δ t x=manifoldPullbackOneForm (fun _ => α t) (fun y => J (t,y)) 0 x := by | |
| have hs : ContMDiff 𝓘(ℝ,NormalModel m) 𝓘(ℝ,Affine m) ∞ (fun y => A (t,y)) := | |
| hA.comp (contMDiff_const.prodMk contMDiff_id) | |
| have he := firstLineBaseMap_primitive_eq hs (normalAmbientPrimitive a (1/Real.pi) d t) | |
| (Γ t) (x := H x) (hΓprim t ht (H x).1 hx.2).symm | |
| simp +instances only [flatProduct_chartedSpace,chartedSpaceSelf_prod] at he | |
| have hc := congrArg (fun L : (NormalModel m × Plane) →L[ℝ] ℝ => | |
| L.comp (manifoldMapDifferential (E := NormalModel m × Plane) (F := LargeNormalModel m) H x)) he | |
| have hb := firstLineBaseMap_smooth hs | |
| simp +instances only [flatProduct_chartedSpace,chartedSpaceSelf_prod] at hb | |
| have hdif := manifoldMapDifferential_comp | |
| (hb.mdifferentiable (by simp) (H x)) (hH.mdifferentiable (by simp) x) | |
| change manifoldMapDifferential (E := Affine m × Plane) (F := LargeNormalModel m) | |
| (fun y => J (t,y)) x=_ at hdif | |
| simp only [manifoldPullbackOneForm] at hc | |
| change (firstLinePrimitive (Γ t) (H x)).comp | |
| (manifoldMapDifferential (E := NormalModel m × Plane) (F := LargeNormalModel m) H x)=_ | |
| rw [← hc,ContinuousLinearMap.comp_assoc] | |
| exact congrArg (fun L => (α t (J (t,x))).comp L) hdif.symm | |
| have hJform (t : ℝ) (ht : t∈Ioc (0:ℝ) δ) (x : LargeNormalSpace a) (hx : x∈V) : | |
| manifoldExteriorOneForm (Δ t) x=(euclideanExteriorOneForm (α t) (J (t,x))).bilinearComp | |
| (manifoldMapDifferential (E := Affine m × Plane) (F := LargeNormalModel m) (fun y => J (t,y)) x) | |
| (manifoldMapDifferential (E := Affine m × Plane) (F := LargeNormalModel m) (fun y => J (t,y)) x) := by | |
| rw [manifoldExteriorOneForm_congr_germ (Filter.eventually_of_mem (hV.mem_nhds hx) (hJprim t ht))] | |
| have ha' : ∀ c : Affine m × Plane, ContDiffOn ℝ ∞ (chartOneForm (α t) c) | |
| (extChartAt 𝓘(ℝ,Affine m × Plane) c).target := by | |
| intro c y _hy | |
| rw [show chartOneForm (α t) c=α t from funext (chartOneForm_model _ _)] | |
| exact (hα t).contDiffAt.contDiffWithinAt | |
| have he := manifold_pullback_exterior ha' (hJs t) x | |
| simpa only [manifoldPullbackTwoForm,manifoldExteriorOneForm_model] using he | |
| have hinto (t : ℝ) (_ht : t∈Ioc (0:ℝ) δ) : | |
| MapsTo (fun x => J (t,x)) V {y | radialArea y.2<b} := | |
| fun x hx => (hHD x hx.1).1 | |
| obtain ⟨t,ht,g,W,hW,hKW,hg,hgemb,hginto,hgform⟩ := exists_compact_exact_fibre_embedding_into | |
| hΔ hK hinv hV hKV hδ hJ hJemb hinto (fun t => euclideanExteriorOneForm (α t)) hJform | |
| refine ⟨t,ht.1,g,W∩V,hW.inter hV,fun x hx => ⟨hKW hx,hKV hx⟩,hg, | |
| hgemb.comp (Topology.IsEmbedding.inclusion inter_subset_left), | |
| fun x hx => hginto hx.1,?_⟩ | |
| intro x hx v w | |
| have he := hgform x hx.1 v w | |
| rw [hΔext x hx.2,largeCouplingPrimitive_exterior] at he | |
| exact he | |
| end PackingSufficiencySupport.DiagonalQuadrics | |
| end | |
| end OAI | |