math / data /lean /OAI /Geometry /BallPacking /Rigidity /CurveArea.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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