Download data/lean/OAI/Geometry/BallPacking/Rigidity/CurveArea.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Rigidity/CurveArea.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Rigidity/CurveArea.lean
-
curl -L -o CurveArea.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Rigidity/CurveArea.lean
25.7 kB
| 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 | |