| import Mathlib |
| import OAI.Geometry.BallPacking.Rigidity.PlanarResidueCutoff |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace HigherDimensionalBallPacking.Rigidity |
|
|
| section |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl) |
|
|
| def realCurve {n : ℕ} (u : ℂ → Phase n) : Plane → Phase n := |
| u ∘ Complex.equivRealProdCLM.symm |
|
|
| theorem realCurve_smooth {n : ℕ} {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) : |
| ContDiff ℝ ∞ (realCurve u) := hu.comp Complex.equivRealProdCLM.symm.contDiff |
|
|
| theorem realCurve_fderiv {n : ℕ} {u : ℂ → Phase n} {z : Plane} |
| (hu : DifferentiableAt ℝ u (Complex.equivRealProdCLM.symm z)) (v : Plane) : |
| fderiv ℝ (realCurve u) z v = |
| fderiv ℝ u (Complex.equivRealProdCLM.symm z) (Complex.equivRealProdCLM.symm v) := by |
| rw [realCurve, fderiv_comp z hu Complex.equivRealProdCLM.symm.differentiableAt] |
| simp [ContinuousLinearMap.comp_apply, ContinuousLinearEquiv.fderiv] |
|
|
| theorem realCurve_CR {n : ℕ} {J : Phase n → End n} {u : ℂ → Phase n} {z : Plane} |
| (hu : PseudoHolomorphicAt J u (Complex.equivRealProdCLM.symm z)) : |
| fderiv ℝ (realCurve u) z (0,1) = |
| J (realCurve u z) (fderiv ℝ (realCurve u) z (1,0)) := by |
| rw [realCurve_fderiv hu.1,realCurve_fderiv hu.1] |
| simpa only [Complex.equivRealProdCLM_symm_apply, Complex.ofReal_zero, Complex.ofReal_one, |
| zero_mul,one_mul,add_zero,zero_add,mul_one,realCurve,Function.comp_def] using hu.2 1 |
|
|
| def planarPullback {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (v : Plane → E) (α : E → E →L[ℝ] ℝ) (z : Plane) : Plane →L[ℝ] ℝ := |
| (α (v z)).comp (fderiv ℝ v z) |
|
|
| theorem planarPullback_smooth {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {v : Plane → E} {α : E → E →L[ℝ] ℝ} |
| (hv : ContDiff ℝ ∞ v) (hα : ContDiff ℝ ∞ α) : |
| ContDiff ℝ ∞ (planarPullback v α) := |
| (hα.comp hv).clm_comp (hv.fderiv_right (by simp)) |
|
|
| def oneForm {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (α : E → E →L[ℝ] ℝ) (x : E) : E [⋀^Fin 1]→L[ℝ] ℝ := |
| ContinuousAlternatingMap.ofSubsingleton ℝ E ℝ 0 (α x) |
|
|
| theorem oneForm_smooth {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {α : E → E →L[ℝ] ℝ} (hα : ContDiff ℝ ∞ α) : ContDiff ℝ ∞ (oneForm α) := |
| (ContinuousAlternatingMap.ofSubsingletonLIE (𝕜 := ℝ) (E := E) (F := ℝ) |
| (0 : Fin 1)).toContinuousLinearEquiv.contDiff.comp hα |
|
|
| theorem planarCurl_eq_extDeriv {α : Plane → Plane →L[ℝ] ℝ} |
| (hα : ContDiff ℝ ∞ α) (z : Plane) : |
| planarCurl α z = extDeriv (oneForm α) z ![(1,0),(0,1)] := by |
| rw [extDeriv_apply ((oneForm_smooth hα).differentiable (by simp) z)] |
| rw [Fin.sum_univ_succ] |
| simp only [Fin.sum_univ_one, Fin.val_zero, pow_zero, one_smul, Fin.val_succ, |
| pow_one, neg_smul, zero_add] |
| change planarCurl α z = |
| fderiv ℝ (fun y => α y (0,1)) z (1,0) - fderiv ℝ (fun y => α y (1,0)) z (0,1) |
| rw [fderiv_clm_apply (hα.differentiable (by simp) z) (differentiableAt_const _), |
| fderiv_clm_apply (hα.differentiable (by simp) z) (differentiableAt_const _)] |
| simp only [add_apply, ContinuousLinearMap.comp_apply, ContinuousLinearMap.flip_apply, |
| fderiv_const_apply, zero_apply, map_zero, zero_add] |
| rfl |
|
|
| theorem planarPullback_curl {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {v : Plane → E} {α : E → E →L[ℝ] ℝ} |
| (hv : ContDiff ℝ ∞ v) (hα : ContDiff ℝ ∞ α) (z : Plane) : |
| planarCurl (planarPullback v α) z = |
| extDeriv (oneForm α) (v z) ![fderiv ℝ v z (1,0), fderiv ℝ v z (0,1)] := by |
| rw [planarCurl_eq_extDeriv (planarPullback_smooth hv hα)] |
| have he : oneForm (planarPullback v α) = fun y => |
| (oneForm α (v y)).compContinuousLinearMap (fderiv ℝ v y) := by |
| funext y |
| ext w |
| rfl |
| rw [he,extDeriv_pullback ((oneForm_smooth hα).differentiable (by simp) (v z)) |
| hv.contDiffAt (by |
| norm_num [minSmoothness])] |
| simp only [ContinuousAlternatingMap.compContinuousLinearMap_apply] |
| congr 1 |
| ext i |
| fin_cases i <;> rfl |
|
|
| def curveDensity {n : ℕ} (σ τ : ℝ) (u : ℂ → Phase n) (z : Plane) : ℝ := |
| radialForm σ τ (realCurve u z) |
| (fderiv ℝ (realCurve u) z (1,0)) (fderiv ℝ (realCurve u) z (0,1)) |
|
|
| def curvePrimitive {n : ℕ} (σ τ : ℝ) (u : ℂ → Phase n) : Plane → Plane →L[ℝ] ℝ := |
| planarPullback (realCurve u) (radialPrimitiveCLM σ τ) |
|
|
| theorem curvePrimitive_smooth {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) : ContDiff ℝ ∞ (curvePrimitive σ τ u) := |
| planarPullback_smooth (realCurve_smooth hu) (radialPrimitiveCLM_smooth hστ) |
|
|
| theorem curvePrimitive_curl {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (z : Plane) : |
| planarCurl (curvePrimitive σ τ u) z = curveDensity σ τ u z := by |
| rw [curvePrimitive,planarPullback_curl (realCurve_smooth hu) (radialPrimitiveCLM_smooth hστ)] |
| exact radialForm_extDeriv hστ _ _ _ |
|
|
| theorem curveDensity_smooth {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) : ContDiff ℝ ∞ (curveDensity σ τ u) := by |
| have he : curveDensity σ τ u = planarCurl (curvePrimitive σ τ u) := |
| funext fun z => (curvePrimitive_curl hστ hu z).symm |
| rw [he] |
| exact SymplecticBallPacking.Hamiltonian.planarCurl_contDiff (curvePrimitive_smooth hστ hu) |
|
|
| theorem curveDensity_nonneg {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) (hτ : τ < 1) |
| {J : Phase n → End n} (hJ : ∀ x, Compatible (J x)) |
| (houtside : ∀ x, σ < capacity x → J x = standardJ n) |
| {u : ℂ → Phase n} (hu : ∀ w, PseudoHolomorphicAt J u w) (z : Plane) : |
| 0 ≤ curveDensity σ τ u z := by |
| unfold curveDensity |
| rw [realCurve_CR (hu _)] |
| by_cases hz : fderiv ℝ (realCurve u) z (1,0) = 0 |
| · simp only [hz,map_zero,radialForm,standardForm,Pi.zero_apply, |
| Complex.zero_re,Complex.zero_im,mul_zero,sub_self,Finset.sum_const_zero, |
| add_zero] |
| exact le_refl _ |
| · exact (radialForm_adapted_pos hστ hτ hJ houtside _ hz).le |
|
|
|
|
| end |
|
|
| section |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
|
|
| def blowupSize (σ τ : ℝ) : ℝ := τ - radialOffset σ τ τ |
|
|
| def blowupMoment (σ τ t : ℝ) : ℝ := blowupSize σ τ + radialOffset σ τ t |
|
|
| theorem blowupMoment_smooth (σ τ : ℝ) : ContDiff ℝ ∞ (blowupMoment σ τ) := |
| contDiff_const.add (radialOffset_smooth σ τ) |
|
|
| theorem blowupMoment_hasDerivAt (σ τ t : ℝ) : |
| HasDerivAt (blowupMoment σ τ) (radialSwitch σ τ t) t := |
| (radialOffset_hasDerivAt σ τ t).const_add _ |
|
|
| theorem blowupMoment_before {σ τ t : ℝ} (hστ : σ < τ) (ht : t ≤ σ) : |
| blowupMoment σ τ t = blowupSize σ τ := by |
| rw [blowupMoment,radialOffset_zero hστ ht,add_zero] |
|
|
| theorem blowupMoment_after {σ τ t : ℝ} (hστ : σ < τ) (ht : τ ≤ t) : |
| blowupMoment σ τ t = t := by |
| have hh := radialOffset_after hστ ht |
| unfold radialShift at hh |
| unfold blowupMoment blowupSize |
| linarith |
|
|
| theorem radialOffset_sub_id_antitone (σ τ : ℝ) : |
| Antitone (fun t => radialOffset σ τ t - t) := by |
| apply antitone_of_hasDerivAt_nonpos |
| (fun t => (radialOffset_hasDerivAt σ τ t).sub (hasDerivAt_id t)) |
| intro t |
| change radialSwitch σ τ t - 1 ≤ 0 |
| linarith [radialSwitch_le_one σ τ t] |
|
|
| theorem blowupMoment_ge_id {σ τ : ℝ} (hστ : σ < τ) (t : ℝ) : |
| t ≤ blowupMoment σ τ t := by |
| by_cases ht : τ ≤ t |
| · rw [blowupMoment_after hστ ht] |
| · have hh := radialOffset_sub_id_antitone σ τ (le_of_not_ge ht) |
| unfold blowupMoment blowupSize |
| linarith |
|
|
| theorem blowupSize_bounds {σ τ : ℝ} (hστ : σ < τ) : |
| σ ≤ blowupSize σ τ ∧ blowupSize σ τ ≤ τ := by |
| constructor |
| · simpa only [blowupMoment_before hστ le_rfl] using blowupMoment_ge_id hστ σ |
| · unfold blowupSize |
| linarith [radialOffset_nonneg hστ τ] |
|
|
| def blowupCoefficient (σ τ t : ℝ) : ℝ := blowupMoment σ τ t / t |
|
|
| def blowupSlope (σ τ t : ℝ) : ℝ := |
| (t * radialSwitch σ τ t - blowupMoment σ τ t) / t^2 |
|
|
| theorem blowupCoefficient_smoothAt (σ τ : ℝ) {t : ℝ} (ht : t ≠ 0) : |
| ContDiffAt ℝ ∞ (blowupCoefficient σ τ) t := |
| (blowupMoment_smooth σ τ).contDiffAt.div contDiffAt_id ht |
|
|
| theorem blowupCoefficient_hasDerivAt (σ τ : ℝ) {t : ℝ} (ht : t ≠ 0) : |
| HasDerivAt (blowupCoefficient σ τ) (blowupSlope σ τ t) t := by |
| have h := (blowupMoment_hasDerivAt σ τ t).div (hasDerivAt_id t) ht |
| simpa [blowupCoefficient,blowupSlope,mul_comm] using! h |
|
|
| theorem blowupCoefficient_before {σ τ t : ℝ} (hστ : σ < τ) (ht : t ≤ σ) : |
| blowupCoefficient σ τ t = blowupSize σ τ / t := by |
| rw [blowupCoefficient,blowupMoment_before hστ ht] |
|
|
| theorem blowupCoefficient_after {σ τ t : ℝ} (hστ : σ < τ) (ht : τ ≤ t) |
| (ht0 : t ≠ 0) : blowupCoefficient σ τ t = 1 := by |
| rw [blowupCoefficient,blowupMoment_after hστ ht,div_self ht0] |
|
|
| theorem blowupSlope_nonpos {σ τ t : ℝ} (hστ : σ < τ) (ht : 0 ≤ t) : |
| blowupSlope σ τ t ≤ 0 := by |
| apply div_nonpos_of_nonpos_of_nonneg _ (sq_nonneg _) |
| have hh := mul_le_mul_of_nonneg_left (radialSwitch_le_one σ τ t) ht |
| have hq := blowupMoment_ge_id hστ t |
| linarith |
|
|
| theorem blowup_radial_derivative {σ τ t : ℝ} (ht : t ≠ 0) : |
| blowupCoefficient σ τ t + t * blowupSlope σ τ t = radialSwitch σ τ t := by |
| unfold blowupCoefficient blowupSlope |
| field_simp |
| ring |
|
|
| def weightedTwoForm {n : ℕ} (g dg : ℝ) (x v w : Phase n) : ℝ := |
| g * standardForm v w + Real.pi * dg * |
| (stdDot n x v * standardForm x w - stdDot n x w * standardForm x v) |
|
|
| theorem weightedTwoForm_J_nonneg {n : ℕ} {g dg : ℝ} (hdg : dg ≤ 0) |
| (x v : Phase n) (hr : 0 ≤ g + capacity x * dg) : |
| 0 ≤ weightedTwoForm g dg x v (standardJ n v) := by |
| have hcs := stdDot_standardForm_sq_le x v |
| have hs : Real.pi * dg ≤ 0 := mul_nonpos_of_nonneg_of_nonpos Real.pi_pos.le hdg |
| have hm := mul_le_mul_of_nonpos_left hcs hs |
| have hh := mul_nonneg hr (stdDot_nonneg v) |
| simp only [weightedTwoForm,standardForm_J_right,stdDot_J_right] |
| rw [capacity_eq_stdDot] at hh |
| nlinarith only [hm,hh] |
|
|
| theorem blowupForm_J_nonneg {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {x : Phase n} (hx : 0 < capacity x) (v : Phase n) : |
| 0 ≤ weightedTwoForm (blowupCoefficient σ τ (capacity x)) |
| (blowupSlope σ τ (capacity x)) x v (standardJ n v) := by |
| apply weightedTwoForm_J_nonneg (blowupSlope_nonpos hστ hx.le) |
| rw [blowup_radial_derivative hx.ne'] |
| exact radialSwitch_nonneg σ τ _ |
|
|
|
|
|
|
|
|
| theorem inverse_chart_analyticAt {n : ℕ} {U : Set (Phase n)} |
| {f : Phase n → Phase n} (hf : SymplecticOn U f) |
| {J : Phase n → End n} {u : ℂ → Phase n} {z : ℂ} |
| (hu : ∀ w, PseudoHolomorphicAt J u w) (hz : u z ∈ f '' U) |
| (hJ : ∀ᶠ y in 𝓝 (u z), J y = imageJ U f y) : |
| AnalyticAt ℂ (invFunOn f U ∘ u) z := by |
| apply Complex.analyticAt_iff_eventually_differentiableAt.mpr |
| have hc := (hu z).1.continuousAt |
| filter_upwards [hc.eventually hJ, |
| hc.eventually ((symplecticOn_open_image hf).mem_nhds hz)] with w hJw hw |
| apply inverse_chart_holomorphic hf _ hw |
| refine ⟨(hu w).1,?_⟩ |
| intro v |
| rw [(hu w).2, hJw] |
|
|
| theorem inverse_chart_zero_iff {n : ℕ} {U : Set (Phase n)} |
| {f : Phase n → Phase n} (hf : SymplecticOn U f) (h0 : (0 : Phase n) ∈ U) |
| {y : Phase n} (hy : y ∈ f '' U) : |
| invFunOn f U y = 0 ↔ y = f 0 := by |
| constructor |
| · intro he |
| have hi := invFunOn_eq hy |
| rw [he] at hi |
| exact hi.symm |
| · rintro rfl |
| exact (symplecticOn_injOn hf).leftInvOn_invFunOn h0 |
|
|
| theorem not_locally_constant_in_chart {n : ℕ} {U : Set (Phase n)} |
| {f : Phase n → Phase n} (hf : SymplecticOn U f) (h0 : (0 : Phase n) ∈ U) |
| {J : Phase n → End n} {u : ℂ → Phase n} |
| (hu : ∀ w, PseudoHolomorphicAt J u w) |
| (hnc : ¬ ∀ w, u w = f 0) |
| (hJ : ∀ᶠ y in 𝓝 (f 0), J y = imageJ U f y) (z : ℂ) : |
| ¬ ∀ᶠ w in 𝓝 z, u w = f 0 := by |
| let S : Set ℂ := {w | ∀ᶠ v in 𝓝 w, u v = f 0} |
| have hcont : Continuous u := continuous_iff_continuousAt.mpr fun w => (hu w).1.continuousAt |
| have hsub : S ⊆ {w | u w = f 0} := fun w hw => hw.self_of_nhds |
| have hclosed : closure S ⊆ S := by |
| intro w hw |
| by_cases hwS : w ∈ S |
| · exact hwS |
| have hew : u w = f 0 := |
| ((isClosed_eq hcont continuous_const).closure_subset_iff.mpr hsub) hw |
| have haf : AnalyticAt ℂ (invFunOn f U ∘ u) w := |
| inverse_chart_analyticAt hf hu (hew ▸ mem_image_of_mem f h0) (hew ▸ hJ) |
| have hcl : w ∈ closure ({v | u v = f 0} \ {w}) := by |
| apply closure_mono _ hw |
| intro v hv |
| refine ⟨hsub hv,?_⟩ |
| intro hvw |
| have : v = w := hvw |
| subst v |
| exact hwS hv |
| have hfreq : ∃ᶠ v in 𝓝[≠] w, (invFunOn f U ∘ u) v = 0 := by |
| apply (mem_closure_ne_iff_frequently_within.mp hcl).mono |
| intro v hv |
| change invFunOn f U (u v) = 0 |
| rw [hv] |
| exact (symplecticOn_injOn hf).leftInvOn_invFunOn h0 |
| have hzero := haf.frequently_zero_iff_eventually_zero.mp hfreq |
| have hfU : f '' U ∈ 𝓝 (u w) := |
| (symplecticOn_open_image hf).mem_nhds (hew ▸ mem_image_of_mem f h0) |
| filter_upwards [hzero, (hcont.continuousAt.eventually hfU)] with v hv hvU |
| exact (inverse_chart_zero_iff hf h0 hvU).mp hv |
| have hclopen : IsClopen S := ⟨isClosed_of_closure_subset hclosed, |
| isOpen_setOfPred_eventually_nhds⟩ |
| intro hz |
| have hall : S = univ := hclopen.eq_univ ⟨z,hz⟩ |
| apply hnc |
| intro w |
| exact hsub (hall ▸ mem_univ w) |
|
|
| theorem isolated_chart_centre {n : ℕ} {U : Set (Phase n)} |
| {f : Phase n → Phase n} (hf : SymplecticOn U f) (h0 : (0 : Phase n) ∈ U) |
| {J : Phase n → End n} {u : ℂ → Phase n} |
| (hu : ∀ w, PseudoHolomorphicAt J u w) (hnc : ¬ ∀ w, u w = f 0) |
| (hJ : ∀ᶠ y in 𝓝 (f 0), J y = imageJ U f y) |
| {z : ℂ} (hz : u z = f 0) : |
| ∀ᶠ w in 𝓝[≠] z, u w ≠ f 0 := by |
| have haf := inverse_chart_analyticAt hf hu (hz ▸ mem_image_of_mem f h0) (hz ▸ hJ) |
| have hzero : ¬ ∀ᶠ w in 𝓝 z, (invFunOn f U ∘ u) w = 0 := by |
| intro he |
| apply not_locally_constant_in_chart hf h0 hu hnc hJ z |
| have hU := (hu z).1.continuousAt.eventually |
| ((symplecticOn_open_image hf).mem_nhds (hz ▸ mem_image_of_mem f h0)) |
| filter_upwards [he,hU] with w hw hwU |
| exact (inverse_chart_zero_iff hf h0 hwU).mp hw |
| have he := haf.eventually_eq_zero_or_eventually_ne_zero.resolve_left hzero |
| filter_upwards [he] with w hw |
| intro heq |
| apply hw |
| change invFunOn f U (u w) = 0 |
| rw [heq] |
| exact (symplecticOn_injOn hf).leftInvOn_invFunOn h0 |
|
|
| theorem chart_centre_positive_order {n : ℕ} {U : Set (Phase n)} |
| {f : Phase n → Phase n} (hf : SymplecticOn U f) (h0 : (0 : Phase n) ∈ U) |
| {J : Phase n → End n} {u : ℂ → Phase n} |
| (hu : ∀ w, PseudoHolomorphicAt J u w) (hnc : ¬ ∀ w, u w = f 0) |
| (hJ : ∀ᶠ y in 𝓝 (f 0), J y = imageJ U f y) |
| {z : ℂ} (hz : u z = f 0) : |
| ∃ (m : ℕ) (v : ℂ → Phase n), 0 < m ∧ AnalyticAt ℂ v z ∧ v z ≠ 0 ∧ |
| ∀ᶠ w in 𝓝 z, (invFunOn f U ∘ u) w = (w-z)^m • v w := by |
| have haf := inverse_chart_analyticAt hf hu (hz ▸ mem_image_of_mem f h0) (hz ▸ hJ) |
| have hzero : ¬ ∀ᶠ w in 𝓝 z, (invFunOn f U ∘ u) w = 0 := by |
| intro he |
| apply not_locally_constant_in_chart hf h0 hu hnc hJ z |
| have hU := (hu z).1.continuousAt.eventually |
| ((symplecticOn_open_image hf).mem_nhds (hz ▸ mem_image_of_mem f h0)) |
| filter_upwards [he,hU] with w hw hwU |
| exact (inverse_chart_zero_iff hf h0 hwU).mp hw |
| obtain ⟨m,v,hv,hv0,he⟩ := haf.exists_eventuallyEq_pow_smul_nonzero_iff.mpr hzero |
| refine ⟨m,v,?_,hv,hv0,he⟩ |
| by_contra hm |
| have hm0 : m = 0 := by omega |
| have he0 := he.self_of_nhds |
| have hi : (invFunOn f U ∘ u) z = 0 := by |
| change invFunOn f U (u z) = 0 |
| rw [hz] |
| exact (symplecticOn_injOn hf).leftInvOn_invFunOn h0 |
| rw [hi,hm0,pow_zero,one_smul] at he0 |
| exact hv0 he0.symm |
|
|
| theorem AffineLineCurve.not_constant {n : ℕ} {J : Phase n → End n} |
| {p q : Phase n} {u : ℂ → Phase n} (hu : AffineLineCurve J p q u) |
| (y : Phase n) : ¬ ∀ z, u z = y := by |
| intro hc |
| obtain ⟨v,hv,hlim⟩ := hu.2.2.2.2 |
| have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by |
| simpa only [←Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded (α := ℂ)) |
| have ht : Tendsto (fun z : ℂ => z⁻¹ • u z) (cocompact ℂ) (𝓝 0) := by |
| simpa only [hc, zero_smul] using hi.smul_const y |
| exact hv (tendsto_nhds_unique hlim ht) |
|
|
| theorem AffineLineCurve.finite_centre_fibre {n : ℕ} {U : Set (Phase n)} |
| {f : Phase n → Phase n} (hf : SymplecticOn U f) (h0 : (0 : Phase n) ∈ U) |
| {J : Phase n → End n} {p q : Phase n} {u : ℂ → Phase n} |
| (hu : AffineLineCurve J p q u) |
| (hJ : ∀ᶠ y in 𝓝 (f 0), J y = imageJ U f y) : |
| Set.Finite {z | u z = f 0} := by |
| have hc : IsCompact {z | u z = f 0} := |
| hu.isProperMap.isCompact_preimage isCompact_singleton |
| apply hc.finite |
| rw [isDiscrete_iff_nhdsNE] |
| intro z hz |
| have he := isolated_chart_centre hf h0 hu.2.1 (hu.not_constant _) hJ hz |
| exact Filter.inf_principal_eq_bot.mpr he |
|
|
|
|
|
|
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm radiusSq planarArea planarArea_apply) |
|
|
| theorem capacity_smul_complex {n : ℕ} (c : ℂ) (x : Phase n) : |
| capacity (c • x) = Complex.normSq c * capacity x := by |
| simp only [capacity,Pi.smul_apply,smul_eq_mul,Complex.normSq_mul,Finset.mul_sum] |
| ring_nf |
|
|
| theorem standardForm_smul_complex_same {n : ℕ} (c : ℂ) (x v : Phase n) : |
| standardForm (c • x) (c • v) = Complex.normSq c * standardForm x v := by |
| simp only [standardForm,Pi.smul_apply,smul_eq_mul,Complex.mul_re,Complex.mul_im, |
| Finset.mul_sum,Complex.normSq_apply] |
| apply Finset.sum_congr rfl |
| intro i _ |
| ring |
|
|
| theorem standardForm_smul_complex_self {n : ℕ} (c d : ℂ) (x : Phase n) : |
| standardForm (c • x) (d • x) = (star c * d).im * stdDot n x x := by |
| simp only [standardForm,Pi.smul_apply,smul_eq_mul,Complex.mul_re,Complex.mul_im, |
| stdDot_apply,Finset.mul_sum,Complex.star_def,Complex.conj_re,Complex.conj_im] |
| apply Finset.sum_congr rfl |
| intro i _ |
| ring |
|
|
| def normalizedPrimitive {n : ℕ} (x : Phase n) : Phase n →L[ℝ] ℝ := |
| (1 / (2 * capacity x)) • stdOmega n x |
|
|
| @[simp] theorem normalizedPrimitive_apply {n : ℕ} (x v : Phase n) : |
| normalizedPrimitive x v = standardForm x v / (2 * capacity x) := by |
| simp only [normalizedPrimitive,smul_apply,smul_eq_mul,stdOmega_apply] |
| ring |
|
|
| theorem capacity_pos {n : ℕ} {x : Phase n} (hx : x ≠ 0) : 0 < capacity x := by |
| rw [capacity_eq_stdDot] |
| exact mul_pos Real.pi_pos (stdDot_pos hx) |
|
|
| theorem normalizedPrimitive_smoothAt {n : ℕ} {x : Phase n} (hx : x ≠ 0) : |
| ContDiffAt ℝ ∞ (@normalizedPrimitive n) x := |
| (contDiffAt_const.div (contDiffAt_const.mul (capacity_smooth n).contDiffAt) |
| (mul_ne_zero (by norm_num) (capacity_pos hx).ne')).smul (stdOmega n).contDiff.contDiffAt |
|
|
| theorem normalizedPrimitive_smul {n : ℕ} {c : ℂ} (hc : c ≠ 0) |
| {x : Phase n} (hx : x ≠ 0) (d : ℂ) (v : Phase n) : |
| normalizedPrimitive (c • x) (d • x + c • v) = |
| (c⁻¹ * d).im / (2 * Real.pi) + normalizedPrimitive x v := by |
| rw [normalizedPrimitive_apply,←stdOmega_apply,map_add,stdOmega_apply,stdOmega_apply, |
| standardForm_smul_complex_self,standardForm_smul_complex_same, |
| capacity_smul_complex,normalizedPrimitive_apply,capacity_eq_stdDot] |
| have hn : Complex.normSq c ≠ 0 := (Complex.normSq_pos.mpr hc).ne' |
| have hx' : stdDot n x x ≠ 0 := (stdDot_pos hx).ne' |
| have he : (c⁻¹ * d).im = (star c * d).im / Complex.normSq c := by |
| simp only [Complex.mul_im,Complex.inv_re,Complex.inv_im,Complex.star_def, |
| Complex.conj_re,Complex.conj_im] |
| ring |
| rw [he] |
| field_simp |
|
|
| theorem normalizedPrimitive_power {n : ℕ} {z : ℂ} (hz : z ≠ 0) |
| {x : Phase n} (hx : x ≠ 0) (m : ℕ) (w : ℂ) (v : Phase n) : |
| normalizedPrimitive (z^m • x) (((m:ℂ) * z^(m-1) * w) • x + z^m • v) = |
| (m:ℝ) * (z⁻¹ * w).im / (2 * Real.pi) + normalizedPrimitive x v := by |
| rw [normalizedPrimitive_smul (pow_ne_zero m hz) hx] |
| congr 2 |
| by_cases hm : m = 0 |
| · simp [hm] |
| · have he : (z^m)⁻¹ * ((m:ℂ) * z^(m-1) * w) = (m:ℂ) * (z⁻¹ * w) := by |
| have hm' : m = (m-1)+1 := by omega |
| conv_lhs => arg 1; rw [hm',pow_succ] |
| field_simp |
| rw [he] |
| simp |
|
|
| theorem complex_winding_eq_angular {z : Plane} (_hz : z ≠ 0) (v : Plane) : |
| ((Complex.equivRealProdCLM.symm z)⁻¹ * Complex.equivRealProdCLM.symm v).im = |
| angularOneForm z v := by |
| have hn : Complex.normSq (Complex.equivRealProdCLM.symm z) = radiusSq z := by |
| simp [Complex.normSq_apply,Complex.equivRealProdCLM_symm_apply,radiusSq,pow_two] |
| rw [angularOneForm,smul_apply,smul_eq_mul,planarArea_apply] |
| simp only [Complex.mul_im,Complex.inv_re,Complex.inv_im,hn] |
| simp only [Complex.equivRealProdCLM_symm_apply,Complex.add_re,Complex.add_im, |
| Complex.ofReal_re,Complex.ofReal_im,Complex.mul_re,Complex.mul_im, |
| Complex.I_re,Complex.I_im,mul_zero,mul_one,sub_zero,add_zero,zero_add] |
| ring |
|
|
|
|
| end |
|
|
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
|
|
| def weightedPrimitive {n : ℕ} (g : ℝ → ℝ) (x : Phase n) : Phase n →L[ℝ] ℝ := |
| (g (capacity x) / 2) • stdOmega n x |
|
|
| theorem weightedPrimitive_smoothAt {n : ℕ} {g : ℝ → ℝ} {x : Phase n} |
| (hg : ContDiffAt ℝ ∞ g (capacity x)) : |
| ContDiffAt ℝ ∞ (weightedPrimitive g) x := |
| ((hg.comp x (capacity_smooth n).contDiffAt).div_const 2).smul |
| (stdOmega n).contDiff.contDiffAt |
|
|
| theorem weightedPrimitive_differentiableAt {n : ℕ} {g : ℝ → ℝ} {x : Phase n} |
| (hg : DifferentiableAt ℝ g (capacity x)) : |
| DifferentiableAt ℝ (weightedPrimitive g) x := |
| ((hg.div_const (2 : ℝ)).comp x (capacity_hasFDerivAt x).differentiableAt).fun_smul |
| (stdOmega n).differentiableAt |
|
|
| theorem weightedPrimitive_derivative {n : ℕ} {g : ℝ → ℝ} {dg : ℝ} {x : Phase n} |
| (hg : HasDerivAt g dg (capacity x)) (v w : Phase n) : |
| fderiv ℝ (weightedPrimitive g) x v w = |
| (g (capacity x) / 2) * standardForm v w + |
| Real.pi * dg * stdDot n x v * standardForm x w := by |
| have hd := ((hg.div_const 2).comp_hasFDerivAt x (capacity_hasFDerivAt x)).smul |
| (stdOmega n).hasFDerivAt |
| change HasFDerivAt (weightedPrimitive g) _ x at hd |
| rw [hd.fderiv] |
| simp only [add_apply,smul_apply,ContinuousLinearMap.smulRight_apply,smul_eq_mul,stdOmega_apply,Function.comp_def] |
| ring |
|
|
| theorem weightedPrimitive_extDeriv {n : ℕ} {g : ℝ → ℝ} {dg : ℝ} {x : Phase n} |
| (hg : HasDerivAt g dg (capacity x)) (v w : Phase n) : |
| extDeriv (oneForm (weightedPrimitive g)) x ![v,w] = weightedTwoForm (g (capacity x)) dg x v w := by |
| have hα := weightedPrimitive_differentiableAt hg.differentiableAt |
| have hω : DifferentiableAt ℝ (oneForm (weightedPrimitive g)) x := |
| (ContinuousAlternatingMap.ofSubsingletonLIE (𝕜 := ℝ) (E := Phase n) (F := ℝ) |
| (0 : Fin 1)).toContinuousLinearEquiv.differentiableAt.comp x hα |
| rw [extDeriv_apply hω,Fin.sum_univ_succ] |
| simp only [Fin.sum_univ_one, Fin.val_zero, pow_zero, one_smul, Fin.val_succ, |
| pow_one, neg_smul, zero_add] |
| change fderiv ℝ (fun y => weightedPrimitive g y w) x v - |
| fderiv ℝ (fun y => weightedPrimitive g y v) x w = _ |
| have he (a b : Phase n) : |
| fderiv ℝ (fun y => weightedPrimitive g y a) x b = |
| fderiv ℝ (weightedPrimitive g) x b a := by |
| rw [fderiv_clm_apply hα (differentiableAt_const a)] |
| simp |
| rw [he w v,he v w,weightedPrimitive_derivative hg,weightedPrimitive_derivative hg, |
| standardForm_skew w v] |
| unfold weightedTwoForm |
| ring |
|
|
| def blowupPrimitive {n : ℕ} (σ τ : ℝ) : Phase n → Phase n →L[ℝ] ℝ := |
| weightedPrimitive (blowupCoefficient σ τ) |
|
|
| theorem blowupPrimitive_smoothAt {n : ℕ} (σ τ : ℝ) {x : Phase n} (hx : x ≠ 0) : |
| ContDiffAt ℝ ∞ (@blowupPrimitive n σ τ) x := |
| weightedPrimitive_smoothAt (blowupCoefficient_smoothAt σ τ (capacity_pos hx).ne') |
|
|
| theorem blowupPrimitive_extDeriv {n : ℕ} (σ τ : ℝ) {x : Phase n} (hx : x ≠ 0) |
| (v w : Phase n) : |
| extDeriv (oneForm (blowupPrimitive σ τ)) x ![v,w] = |
| weightedTwoForm (blowupCoefficient σ τ (capacity x)) |
| (blowupSlope σ τ (capacity x)) x v w := |
| weightedPrimitive_extDeriv (blowupCoefficient_hasDerivAt σ τ (capacity_pos hx).ne') v w |
|
|
| theorem blowupPrimitive_extDeriv_nonneg {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {x : Phase n} (hx : x ≠ 0) (v : Phase n) : |
| 0 ≤ extDeriv (oneForm (blowupPrimitive σ τ)) x ![v,standardJ n v] := by |
| rw [blowupPrimitive_extDeriv σ τ hx] |
| exact blowupForm_J_nonneg hστ (capacity_pos hx) v |
|
|
| theorem blowupPrimitive_before {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {x : Phase n} (hx : capacity x ≤ σ) : |
| blowupPrimitive σ τ x = blowupSize σ τ • normalizedPrimitive x := by |
| apply ContinuousLinearMap.ext |
| intro v |
| simp only [blowupPrimitive,weightedPrimitive,smul_apply,smul_eq_mul,stdOmega_apply, |
| blowupCoefficient_before hστ hx,normalizedPrimitive_apply] |
| ring |
|
|
| theorem blowupPrimitive_after {n : ℕ} {σ τ : ℝ} (hστ : σ < τ) |
| {x : Phase n} (hx : τ ≤ capacity x) (hx0 : x ≠ 0) : |
| blowupPrimitive σ τ x = (1/2 : ℝ) • stdOmega n x := by |
| simp only [blowupPrimitive,weightedPrimitive, |
| blowupCoefficient_after hστ hx (capacity_pos hx0).ne'] |
|
|
|
|
|
|
| end HigherDimensionalBallPacking.Rigidity |
| end |
|
|
| end OAI |
|
|
