| import Mathlib |
| import OAI.Geometry.BallPacking.Energy.ResidualEnergy |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace HigherDimensionalBallPacking.Rigidity |
|
|
| section |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian |
| variable {n : ℕ} |
|
|
| def circlePlane (r θ : ℝ) : Plane := (r*Real.cos θ,r*Real.sin θ) |
|
|
| def circleTrace (u : ℂ → Phase n) (r θ : ℝ) : Phase n := realCurve u (circlePlane r θ) |
|
|
| lemma circlePlane_smooth (r : ℝ) : ContDiff ℝ ∞ (circlePlane r) := by |
| unfold circlePlane |
| fun_prop |
|
|
| lemma circleTrace_smooth {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (r : ℝ) : |
| ContDiff ℝ ∞ (circleTrace u r) := (realCurve_smooth hu).comp (circlePlane_smooth r) |
|
|
| lemma circlePlane_hasDerivAt (r θ : ℝ) : |
| HasDerivAt (circlePlane r) (planeRotation (circlePlane r θ)) θ := by |
| have hh := ((Real.hasDerivAt_cos θ).const_mul r).prodMk ((Real.hasDerivAt_sin θ).const_mul r) |
| change HasDerivAt (circlePlane r) (r * (-Real.sin θ),r * Real.cos θ) θ at hh |
| simpa only [planeRotation,circlePlane,mul_neg] using hh |
|
|
| lemma circleTrace_deriv {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (r θ : ℝ) : |
| deriv (circleTrace u r) θ=fderiv ℝ (realCurve u) (circlePlane r θ) (planeRotation (circlePlane r θ)) := by |
| exact (((realCurve_smooth hu).differentiable (by simp) _).hasFDerivAt.comp_hasDerivAt θ |
| (circlePlane_hasDerivAt r θ)).deriv |
|
|
| lemma circleTrace_closed (u : ℂ → Phase n) (r : ℝ) : circleTrace u r Real.pi=circleTrace u r (-Real.pi) := by |
| simp [circleTrace,circlePlane] |
|
|
| lemma plane_linear_energy_identity (L : Plane →L[ℝ] Phase n) (z : Plane) : |
| stdDot n (L (planeRotation z)) (L (planeRotation z))+stdDot n (L z) (L z)= |
| radiusSq z*(stdDot n (L (1,0)) (L (1,0))+stdDot n (L (0,1)) (L (0,1))) := by |
| have hz : z=z.1 • ((1,0):Plane)+z.2 • ((0,1):Plane) := by ext <;> simp |
| have hr : planeRotation z=(-z.2) • ((1,0):Plane)+z.1 • ((0,1):Plane) := by ext <;> simp [planeRotation] |
| have hLr : L (planeRotation z)=(-z.2) • L (1,0)+z.1 • L (0,1) := by |
| rw [hr,map_add,map_smul,map_smul] |
| have hLz : L z=z.1 • L (1,0)+z.2 • L (0,1) := by |
| conv_lhs => rw [hz,map_add,map_smul,map_smul] |
| rw [hLr,hLz] |
| simp only [map_add,map_smul,add_apply,smul_apply,smul_eq_mul] |
| rw [stdDot_symm (L (0,1)) (L (1,0))] |
| dsimp only [radiusSq] |
| ring |
|
|
| lemma circleTrace_energy_le {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (r θ : ℝ) : |
| stdDot n (deriv (circleTrace u r) θ) (deriv (circleTrace u r) θ)≤ |
| r^2*dirichletEnergy u (circlePlane r θ) := by |
| rw [circleTrace_deriv hu] |
| have h := plane_linear_energy_identity (fderiv ℝ (realCurve u) (circlePlane r θ)) (circlePlane r θ) |
| have hr : radiusSq (circlePlane r θ)=r^2 := by |
| have htr := Real.cos_sq_add_sin_sq θ |
| dsimp [radiusSq,circlePlane] |
| nlinarith [sq_nonneg r] |
| rw [hr] at h |
| change stdDot n _ _+stdDot n _ _=r^2*dirichletEnergy u (circlePlane r θ) at h |
| linarith [stdDot_nonneg (fderiv ℝ (realCurve u) (circlePlane r θ) (circlePlane r θ))] |
|
|
| lemma circle_pullback_flux_le {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (r : ℝ) : |
| (∫ θ in (-Real.pi)..Real.pi, |
| planarPullback (realCurve u) (stdOmega n) (circlePlane r θ) (planeRotation (circlePlane r θ)))≤ |
| ((2*Real.pi)^2+1)/2*r^2*(∫ θ in (-Real.pi)..Real.pi, dirichletEnergy u (circlePlane r θ)) := by |
| have hloop := loop_symplectic_flux_le_energy (circleTrace_smooth hu r) |
| (by linarith [Real.pi_pos] : -Real.pi≤Real.pi) (circleTrace_closed u r) |
| have hdc : Continuous (fun θ => stdDot n (deriv (circleTrace u r) θ) (deriv (circleTrace u r) θ)) := by |
| have hd := (circleTrace_smooth hu r).continuous_deriv (by simp) |
| exact ((stdDot n).continuous.comp hd).clm_apply hd |
| have hec : Continuous (fun θ => r^2*dirichletEnergy u (circlePlane r θ)) := continuous_const.mul |
| ((dirichletEnergy_continuous hu).comp (circlePlane_smooth r).continuous) |
| have hi := intervalIntegral.integral_mono (μ := volume) (by linarith [Real.pi_pos] : -Real.pi≤Real.pi) |
| (hdc.intervalIntegrable _ _) (hec.intervalIntegrable _ _) (circleTrace_energy_le hu r) |
| rw [intervalIntegral.integral_const_mul] at hi |
| have hc : 0≤((Real.pi-(-Real.pi))^2+1)/2 := by positivity |
| have hb := hloop.trans (mul_le_mul_of_nonneg_left hi hc) |
| calc |
| _ = (∫ θ in (-Real.pi)..Real.pi, stdOmega n (circleTrace u r θ) (deriv (circleTrace u r) θ)) := by |
| apply intervalIntegral.integral_congr |
| intro θ _ |
| dsimp only |
| rw [circleTrace_deriv hu] |
| rfl |
| _ ≤ _ := hb |
| _ = _ := by ring |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian |
|
|
| lemma integrable_polar_pullback {f : Plane → ℝ} (hf : Integrable f) : |
| IntegrableOn (fun p : Plane => p.1*f (polarCoord.symm p)) polarCoord.target := by |
| have hi : IntegrableOn f (polarCoord.symm '' polarCoord.target) := hf.integrableOn |
| have hp := (integrableOn_image_iff_integrableOn_abs_det_fderiv_smul volume |
| polarCoord.open_target.measurableSet |
| (fun p _ => (hasFDerivAt_polarCoord_symm p).hasFDerivWithinAt) |
| polarCoord.symm.injOn f).mp hi |
| apply hp.congr_fun _ polarCoord.open_target.measurableSet |
| intro p hp |
| dsimp only |
| rw [det_fderivPolarCoordSymm,abs_of_pos hp.1,smul_eq_mul] |
|
|
| lemma integral_polar_slices {f : Plane → ℝ} (hf : Integrable f) : |
| (∫ z, f z)=∫ r in Ioi (0:ℝ), r*(∫ θ in (-Real.pi)..Real.pi, f (circlePlane r θ)) := by |
| rw [←integral_comp_polarCoord_symm] |
| have hp := integrable_polar_pullback hf |
| rw [polarCoord_target,Measure.volume_eq_prod] at hp ⊢ |
| simp only [smul_eq_mul] |
| rw [setIntegral_prod _ hp] |
| apply setIntegral_congr_fun measurableSet_Ioi |
| intro r _ |
| dsimp only [Prod.fst] |
| rw [integral_const_mul,intervalIntegral.integral_of_le (by linarith [Real.pi_pos] : -Real.pi≤Real.pi), |
| integral_Ioc_eq_integral_Ioo] |
| rfl |
|
|
| lemma integrable_polar_slices {f : Plane → ℝ} (hf : Integrable f) : |
| IntegrableOn (fun r => r*(∫ θ in (-Real.pi)..Real.pi, f (circlePlane r θ))) (Ioi (0:ℝ)) := by |
| have hp := integrable_polar_pullback hf |
| rw [polarCoord_target,Measure.volume_eq_prod,IntegrableOn,←Measure.prod_restrict] at hp |
| have hi := hp.integral_prod_left |
| unfold IntegrableOn |
| convert hi using 1 |
| funext r |
| dsimp only [Prod.fst] |
| rw [integral_const_mul,intervalIntegral.integral_of_le (by linarith [Real.pi_pos] : -Real.pi≤Real.pi), |
| integral_Ioc_eq_integral_Ioo] |
| rfl |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian |
| variable {n : ℕ} |
|
|
| def angularCurveFlux (u : ℂ → Phase n) (z : Plane) : ℝ := |
| planarPullback (realCurve u) (stdOmega n) z (planeRotation z) |
|
|
| lemma angularCurveFlux_continuous {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) : |
| Continuous (angularCurveFlux u) := |
| (planarPullback_smooth (realCurve_smooth hu) (stdOmega n).contDiff).continuous.clm_apply |
| (continuous_snd.neg.prodMk continuous_fst) |
|
|
| lemma radiusSq_circlePlane (r θ : ℝ) : radiusSq (circlePlane r θ)=r^2 := by |
| have htr := Real.cos_sq_add_sin_sq θ |
| dsimp [radiusSq,circlePlane] |
| nlinarith [sq_nonneg r] |
|
|
| lemma integral_radial_angularFlux_le {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| {k : ℝ → ℝ} (hk : Continuous k) (hkc : HasCompactSupport k) |
| (hkn : ∀ s : ℝ, 0 ≤ s → 0 ≤ k s) : |
| (∫ z : Plane, k (radiusSq z)*angularCurveFlux u z)≤ |
| ((2*Real.pi)^2+1)/2*(∫ z : Plane, k (radiusSq z)*radiusSq z*dirichletEnergy u z) := by |
| have hkpc := hk.comp radiusSq_smooth.continuous |
| have hkps := HasCompactSupport.comp_radiusSq hkc |
| have hf : Integrable (fun z : Plane => k (radiusSq z)*angularCurveFlux u z) := |
| (hkpc.mul (angularCurveFlux_continuous hu)).integrable_of_hasCompactSupport hkps.mul_right |
| have hg : Integrable (fun z : Plane => k (radiusSq z)*radiusSq z*dirichletEnergy u z) := |
| ((hkpc.mul radiusSq_smooth.continuous).mul (dirichletEnergy_continuous hu)).integrable_of_hasCompactSupport |
| (hkps.mul_right.mul_right) |
| rw [integral_polar_slices hf,integral_polar_slices hg,←integral_const_mul] |
| apply setIntegral_mono_on (integrable_polar_slices hf) |
| ((integrable_polar_slices hg).const_mul _) measurableSet_Ioi |
| intro r hr |
| simp_rw [radiusSq_circlePlane,intervalIntegral.integral_const_mul] |
| have hn : 0≤r*k (r^2) := mul_nonneg (le_of_lt hr) (hkn _ (sq_nonneg _)) |
| have hb := mul_le_mul_of_nonneg_left (circle_pullback_flux_le hu r) hn |
| change r*(k (r^2)*(∫ θ in (-Real.pi)..Real.pi, angularCurveFlux u (circlePlane r θ)))≤_ |
| dsimp only [angularCurveFlux] |
| nlinarith only [hb] |
|
|
| lemma curveAreaDensity_continuous {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) : |
| Continuous (curveAreaDensity u) := by |
| have hd := ((realCurve_smooth hu).fderiv_right (m := ∞) (by simp)).continuous |
| exact ((stdOmega n).continuous.comp (hd.clm_apply continuous_const)).clm_apply |
| (hd.clm_apply continuous_const) |
|
|
| lemma standard_primitive_curl_area {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (z : Plane) : |
| planarCurl (planarPullback (realCurve u) (stdOmega n)) z=2*curveAreaDensity u z := by |
| rw [standard_primitive_curl hu,dirichletEnergy_eq_residual_add_area hu] |
| ring |
|
|
| lemma radial_stokes_area_eq_flux {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| {g : ℝ → ℝ} (hg : ContDiff ℝ ∞ g) (hgc : HasCompactSupport g) : |
| (∫ z : Plane, g (radiusSq z)*curveAreaDensity u z)= |
| ∫ z : Plane, (-deriv g (radiusSq z))*angularCurveFlux u z := by |
| have hβ := planarPullback_smooth (realCurve_smooth hu) (stdOmega n).contDiff |
| have he : (∫ z, cutoffWedge (fun y => g (radiusSq y)) |
| (planarPullback (realCurve u) (stdOmega n)) z)= |
| -(∫ z, g (radiusSq z)*planarCurl (planarPullback (realCurve u) (stdOmega n)) z) := |
| integral_cutoffWedge (hg.comp radiusSq_smooth) (HasCompactSupport.comp_radiusSq hgc) hβ |
| simp_rw [cutoffWedge_radial_rotation hg,standard_primitive_curl_area hu] at he |
| have hleft (z : Plane) : 2*deriv g (radiusSq z)* |
| planarPullback (realCurve u) (stdOmega n) z (planeRotation z)= |
| -2*((-deriv g (radiusSq z))*angularCurveFlux u z) := by unfold angularCurveFlux; ring |
| have hright (z : Plane) : g (radiusSq z)*(2*curveAreaDensity u z)= |
| 2*(g (radiusSq z)*curveAreaDensity u z) := by ring |
| simp_rw [hleft,hright] at he |
| rw [integral_const_mul,integral_const_mul] at he |
| linarith |
|
|
| theorem calibrated_radial_energy_bound {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| {C : ℝ} (hC : 0≤C) (hcal : ∀ z, dirichletEnergy u z≤C*curveAreaDensity u z) |
| {A : ℝ} (hA : 0<A) : |
| (∫ z : Plane, sourceRadialCutoff A z*dirichletEnergy u z)≤ |
| C*(((2*Real.pi)^2+1)/2)* |
| (∫ z : Plane, (-deriv (outerProfile A) (radiusSq z))*radiusSq z*dirichletEnergy u z) := by |
| have hi := integral_mono (smooth_cutoff_integrable_mul hA (dirichletEnergy_continuous hu)) |
| ((smooth_cutoff_integrable_mul hA (curveAreaDensity_continuous hu)).const_mul C) |
| (fun z => by |
| have h := mul_le_mul_of_nonneg_left (hcal z) (sourceRadialCutoff_nonneg A z) |
| nlinarith only [h]) |
| rw [integral_const_mul] at hi |
| change (∫ z, sourceRadialCutoff A z*dirichletEnergy u z)≤ |
| C*(∫ z, outerProfile A (radiusSq z)*curveAreaDensity u z) at hi |
| rw [radial_stokes_area_eq_flux hu (outerProfile_smooth A) (outerProfile_compact hA)] at hi |
| have hb := integral_radial_angularFlux_le hu |
| ((outerProfile_smooth A).continuous_deriv (by simp)).neg (outerProfile_compact hA).deriv.neg |
| (fun s hs => neg_nonneg.mpr (outerProfile_deriv_nonpos hA hs)) |
| exact hi.trans (by simpa only [mul_assoc,Pi.neg_apply] using mul_le_mul_of_nonneg_left hb hC) |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian |
|
|
| lemma smoothTransition_deriv_zero_outside {t : ℝ} (ht : t∉Icc (0:ℝ) 1) : |
| deriv Real.smoothTransition t=0 := by |
| rcases (show t<0 ∨ 1<t by simpa only [mem_Icc,not_and_or,not_le] using ht) with ht | ht |
| · have he : Real.smoothTransition =ᶠ[𝓝 t] fun _ => 0 := by |
| filter_upwards [isOpen_Iio.mem_nhds ht] with s hs |
| exact Real.smoothTransition.zero_of_nonpos hs.le |
| rw [he.deriv_eq,deriv_const] |
| · have he : Real.smoothTransition =ᶠ[𝓝 t] fun _ => 1 := by |
| filter_upwards [isOpen_Ioi.mem_nhds ht] with s hs |
| exact Real.smoothTransition.one_of_one_le hs.le |
| rw [he.deriv_eq,deriv_const] |
|
|
| lemma smoothTransition_deriv_le_bound : |
| ∃ M : ℝ, 0<M ∧ ∀ t : ℝ, deriv Real.smoothTransition t≤M := by |
| have hc : HasCompactSupport (deriv Real.smoothTransition) := |
| HasCompactSupport.intro isCompact_Icc (fun t ht => smoothTransition_deriv_zero_outside ht) |
| obtain ⟨B,hB⟩ := hc.exists_bound_of_continuous |
| ((Real.smoothTransition.contDiff : ContDiff ℝ ∞ Real.smoothTransition).continuous_deriv (by simp)) |
| refine ⟨|B|+1,by positivity,fun t => ?_⟩ |
| have h := hB t |
| rw [Real.norm_eq_abs] at h |
| linarith [le_abs_self (deriv Real.smoothTransition t),le_abs_self B] |
|
|
| lemma outerProfile_deriv_zero_after {A t : ℝ} (hA : 0<A) (ht : 2*A<t) : |
| deriv (outerProfile A) t=0 := by |
| have he : outerProfile A =ᶠ[𝓝 t] fun _ => 0 := by |
| filter_upwards [isOpen_Ioi.mem_nhds ht] with s hs |
| change 2*A<s at hs |
| have h : 1≤(s-A)/A := (le_div_iff₀ hA).mpr (by linarith) |
| simp only [outerProfile,Real.smoothTransition.one_of_one_le h,sub_self,mul_zero] |
| rw [he.deriv_eq,deriv_const] |
|
|
| lemma outerProfile_weight_uniform_bound : |
| ∃ B : ℝ, 0<B ∧ ∀ A : ℝ, 0<A → ∀ t : ℝ, 0≤t → |
| 0≤(-deriv (outerProfile A) t)*t ∧ (-deriv (outerProfile A) t)*t≤B := by |
| obtain ⟨M,hM,hbound⟩ := smoothTransition_deriv_le_bound |
| refine ⟨2*M,by positivity,?_⟩ |
| intro A hA t ht |
| refine ⟨mul_nonneg (neg_nonneg.mpr (outerProfile_deriv_nonpos hA ht)) ht,?_⟩ |
| by_cases htA : t≤2*A |
| · rw [outerProfile_deriv ht,neg_neg] |
| have hd : 0≤deriv Real.smoothTransition ((t-A)/A) := Real.smoothTransition.monotone.deriv_nonneg |
| have h1 := mul_le_mul_of_nonneg_right (hbound ((t-A)/A)) (div_nonneg ht hA.le) |
| have h2 : t/A≤2 := (div_le_iff₀ hA).mpr (by linarith) |
| have h3 := mul_le_mul_of_nonneg_left h2 hM.le |
| calc |
| deriv Real.smoothTransition ((t-A)/A)/A*t=deriv Real.smoothTransition ((t-A)/A)*(t/A) := by ring |
| _≤M*(t/A) := h1 |
| _≤2*M := by linarith only [h3] |
| · rw [outerProfile_deriv_zero_after hA (lt_of_not_ge htA)] |
| simpa using (le_of_lt (show 0<2*M by positivity)) |
|
|
| lemma outerProfile_weight_tendsto_zero (t : ℝ) (ht : 0≤t) : |
| Tendsto (fun A : ℝ => (-deriv (outerProfile A) t)*t) atTop (𝓝 0) := by |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_gt_atTop (max t 0)] with A hA |
| have h0 : 0<A := lt_of_le_of_lt (le_max_right _ _) hA |
| have htA : t<A := lt_of_le_of_lt (le_max_left _ _) hA |
| simp only [outerProfile_deriv_zero_before h0 ht htA,neg_zero,zero_mul] |
|
|
| lemma radial_boundary_integral_tendsto_zero {e : Plane → ℝ} (he : Continuous e) |
| (hn : ∀ z, 0≤e z) (hei : Integrable e) : |
| Tendsto (fun A : ℝ => ∫ z : Plane, (-deriv (outerProfile A) (radiusSq z))*radiusSq z*e z) |
| atTop (𝓝 0) := by |
| obtain ⟨B,hB,hbound⟩ := outerProfile_weight_uniform_bound |
| have hi : Integrable (fun z => B*e z) := hei.const_mul B |
| have hh := tendsto_integral_filter_of_dominated_convergence |
| (F := fun A z => (-deriv (outerProfile A) (radiusSq z))*radiusSq z*e z) |
| (fun z => B*e z) |
| (Eventually.of_forall fun A : ℝ => |
| (((((outerProfile_smooth A).continuous_deriv (by simp)).comp radiusSq_smooth.continuous).neg.mul |
| radiusSq_smooth.continuous).mul he).aestronglyMeasurable) |
| (by |
| filter_upwards [eventually_gt_atTop (0:ℝ)] with A hA |
| exact ae_of_all _ fun z => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (hbound A hA _ (radiusSq_nonneg z)).1 (hn z))] |
| exact mul_le_mul_of_nonneg_right (hbound A hA _ (radiusSq_nonneg z)).2 (hn z)) hi |
| (ae_of_all _ fun z => by |
| simpa only [zero_mul] using (outerProfile_weight_tendsto_zero (radiusSq z) (radiusSq_nonneg z)).mul_const (e z)) |
| simpa only [integral_zero] using hh |
|
|
| lemma radial_energy_integral_tendsto {e : Plane → ℝ} (he : Continuous e) |
| (hn : ∀ z, 0≤e z) (hei : Integrable e) : |
| Tendsto (fun A : ℝ => ∫ z, sourceRadialCutoff A z*e z) atTop (𝓝 (∫ z,e z)) := by |
| exact tendsto_integral_filter_of_dominated_convergence |
| (F := fun A z => sourceRadialCutoff A z * e z) e |
| (Eventually.of_forall fun A : ℝ => |
| ((sourceRadialCutoff_smooth A).continuous.mul he).aestronglyMeasurable) |
| (Eventually.of_forall fun A : ℝ => ae_of_all _ fun z => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (sourceRadialCutoff_nonneg _ _) (hn z))] |
| exact mul_le_of_le_one_left (hn z) (sourceRadialCutoff_le_one A z)) hei |
| (ae_of_all _ fun z => by simpa only [one_mul] using (sourceRadialCutoff_tendsto z).mul_const (e z)) |
|
|
|
|
| end |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian |
| variable {n : ℕ} |
|
|
| lemma dirichletEnergy_zero_fderiv {u : ℂ → Phase n} {z : Plane} |
| (he : dirichletEnergy u z=0) : fderiv ℝ (realCurve u) z=0 := by |
| have hx : fderiv ℝ (realCurve u) z (1,0)=0 := by |
| by_contra hn |
| have hp := stdDot_pos hn |
| have hy := stdDot_nonneg (fderiv ℝ (realCurve u) z (0,1)) |
| unfold dirichletEnergy at he |
| linarith |
| have hy : fderiv ℝ (realCurve u) z (0,1)=0 := by |
| by_contra hn |
| have hp := stdDot_pos hn |
| have hx := stdDot_nonneg (fderiv ℝ (realCurve u) z (1,0)) |
| unfold dirichletEnergy at he |
| linarith |
| apply ContinuousLinearMap.ext |
| intro v |
| have hv : v=v.1 • ((1,0) : Plane)+v.2 • (0,1) := by ext <;> simp |
| rw [hv,map_add,map_smul,map_smul,hx,hy] |
| simp |
|
|
| theorem finite_energy_calibrated_curve_constant {u : ℂ → Phase n} |
| (hu : ContDiff ℝ ∞ u) {C : ℝ} (hC : 0≤C) |
| (hcal : ∀ z, dirichletEnergy u z≤C*curveAreaDensity u z) |
| (hei : Integrable (dirichletEnergy u)) : ∀ z w : ℂ, u z=u w := by |
| have hleft := radial_energy_integral_tendsto (dirichletEnergy_continuous hu) |
| (dirichletEnergy_nonneg u) hei |
| have hright := (radial_boundary_integral_tendsto_zero (dirichletEnergy_continuous hu) |
| (dirichletEnergy_nonneg u) hei).const_mul (C*(((2*Real.pi)^2+1)/2)) |
| have hle : (∫ z, dirichletEnergy u z)≤0 := by |
| have h := le_of_tendsto_of_tendsto hleft hright (by |
| filter_upwards [eventually_gt_atTop (0:ℝ)] with A hA |
| exact calibrated_radial_energy_bound hu hC hcal hA) |
| simpa only [mul_zero] using h |
| have he : (∫ z, dirichletEnergy u z)=0 := le_antisymm hle |
| (integral_nonneg (dirichletEnergy_nonneg u)) |
| have hae := (integral_eq_zero_iff_of_nonneg (dirichletEnergy_nonneg u) hei).mp he |
| have heq : dirichletEnergy u=0 := |
| ((dirichletEnergy_continuous hu).ae_eq_iff_eq (volume : Measure Plane) continuous_zero).mp hae |
| have hd (z : Plane) : fderiv ℝ (realCurve u) z=0 := |
| dirichletEnergy_zero_fderiv (congrFun heq z) |
| intro z w |
| exact is_const_of_fderiv_eq_zero ((realCurve_smooth hu).differentiable (by simp)) hd |
| (Complex.equivRealProdCLM z) (Complex.equivRealProdCLM w) |
|
|
| theorem exact_homotopy_no_finite_energy_bubbles {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x)) {S : ℝ} |
| (hout : ∀ x, S<capacity x → J x=standardJ n) |
| {t : ℝ} (ht : t∈Icc (0:ℝ) 1) {u : ℂ → Phase n} |
| (hu : ContDiff ℝ ∞ u) (hcr : ∀ z, PseudoHolomorphicAt (lineHomotopy J t) u z) |
| (hei : Integrable (dirichletEnergy u)) : ∀ z w : ℂ, u z=u w := by |
| obtain ⟨C,hC,hcal⟩ := uniform_homotopy_pointwise_calibration hJs hJ hout |
| exact finite_energy_calibrated_curve_constant hu hC.le (hcal t ht u hu hcr) hei |
|
|
|
|
| lemma outerProfile_mono_parameter {A B t : ℝ} (hA : 0<A) (hAB : A≤B) (ht : 0≤t) : |
| outerProfile A t≤outerProfile B t := by |
| have hB : 0<B := hA.trans_le hAB |
| have harg : (t-B)/B≤(t-A)/A := by |
| rw [sub_div,sub_div,div_self hA.ne',div_self hB.ne'] |
| exact sub_le_sub_right (div_le_div_of_nonneg_left ht hA hAB) 1 |
| exact mul_le_mul_of_nonneg_left |
| (sub_le_sub_left (Real.smoothTransition.monotone harg) 1) |
| (Real.smoothTransition.nonneg _) |
|
|
| lemma outerProfile_zero_after {A t : ℝ} (hA : 0<A) (ht : 2*A≤t) : |
| outerProfile A t=0 := by |
| have ha : 1≤(t-A)/A := (le_div_iff₀ hA).mpr (by linarith) |
| simp only [outerProfile,Real.smoothTransition.one_of_one_le ha,sub_self,mul_zero] |
|
|
| lemma cutoff_weight_annulus_bound {B : ℝ} (hB : 0≤B) |
| (hbound : ∀ A : ℝ, 0<A → ∀ t : ℝ, 0≤t → (-deriv (outerProfile A) t)*t≤B) |
| {A : ℝ} (hA : 0<A) (z : Plane) : |
| (-deriv (outerProfile A) (radiusSq z))*radiusSq z≤ |
| B*(sourceRadialCutoff (4*A) z-sourceRadialCutoff (A/4) z) := by |
| have hmono : 0 ≤ sourceRadialCutoff (4*A) z-sourceRadialCutoff (A/4) z := |
| sub_nonneg.mpr (outerProfile_mono_parameter (A := A/4) (B := 4*A) (by positivity) (by linarith) (radiusSq_nonneg z)) |
| by_cases hd : deriv (outerProfile A) (radiusSq z)=0 |
| · rw [hd,neg_zero,zero_mul] |
| exact mul_nonneg hB hmono |
| have hlo : A≤radiusSq z := by |
| by_contra! h |
| exact hd (outerProfile_deriv_zero_before hA (radiusSq_nonneg z) h) |
| have hhi : radiusSq z≤2*A := by |
| by_contra! h |
| exact hd (outerProfile_deriv_zero_after hA h) |
| have h4 : sourceRadialCutoff (4*A) z=1 := |
| outerProfile_one_before (radiusSq_nonneg z) (by linarith) (by positivity) |
| have hq : sourceRadialCutoff (A/4) z=0 := |
| outerProfile_zero_after (by positivity) (by linarith) |
| rw [h4,hq,sub_zero,mul_one] |
| exact hbound A hA _ (radiusSq_nonneg z) |
|
|
| def radialCurveEnergy (u : ℂ → Phase n) (A : ℝ) : ℝ := |
| ∫ z : Plane, sourceRadialCutoff A z*dirichletEnergy u z |
|
|
| lemma radialCurveEnergy_nonneg (u : ℂ → Phase n) (A : ℝ) : 0≤radialCurveEnergy u A := |
| integral_nonneg (fun z => mul_nonneg (sourceRadialCutoff_nonneg A z) (dirichletEnergy_nonneg u z)) |
|
|
| lemma radialCurveEnergy_mono {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| {A B : ℝ} (hA : 0<A) (hAB : A≤B) : radialCurveEnergy u A≤radialCurveEnergy u B := |
| integral_mono (smooth_cutoff_integrable_mul hA (dirichletEnergy_continuous hu)) |
| (smooth_cutoff_integrable_mul (hA.trans_le hAB) (dirichletEnergy_continuous hu)) |
| (fun z => mul_le_mul_of_nonneg_right (outerProfile_mono_parameter hA hAB (radiusSq_nonneg z)) |
| (dirichletEnergy_nonneg u z)) |
|
|
| theorem calibrated_energy_hole_filling {C : ℝ} (hC : 0<C) : |
| ∃ θ : ℝ, 0<θ ∧ θ<1 ∧ ∀ (u : ℂ → Phase n), ContDiff ℝ ∞ u → |
| (∀ z, dirichletEnergy u z≤C*curveAreaDensity u z) → |
| ∀ A : ℝ, 0<A → radialCurveEnergy u A≤θ*radialCurveEnergy u (16*A) := by |
| obtain ⟨B,hB,hbound⟩ := outerProfile_weight_uniform_bound |
| let K := C*(((2*Real.pi)^2+1)/2)*B |
| have hK : 0<K := by dsimp [K]; positivity |
| refine ⟨K/(K+1),div_pos hK (by linarith), (div_lt_one (by linarith)).mpr (by linarith),?_⟩ |
| intro u hu hcal A hA |
| have hfour : 0<4*A := by positivity |
| have he := calibrated_radial_energy_bound hu hC.le hcal hfour |
| have hdi : Integrable (fun z : Plane => (-deriv (outerProfile (4*A)) (radiusSq z))*radiusSq z*dirichletEnergy u z) := by |
| exact (((((outerProfile_smooth (4*A)).continuous_deriv (by simp)).comp radiusSq_smooth.continuous).neg.mul |
| radiusSq_smooth.continuous).mul (dirichletEnergy_continuous hu)).integrable_of_hasCompactSupport |
| (((HasCompactSupport.comp_radiusSq (outerProfile_compact hfour).deriv).neg.mul_right).mul_right) |
| have hfi := smooth_cutoff_integrable_mul (show 0<16*A by positivity) (dirichletEnergy_continuous hu) |
| have hgi := smooth_cutoff_integrable_mul hA (dirichletEnergy_continuous hu) |
| have hpoint (z : Plane) := mul_le_mul_of_nonneg_right |
| (cutoff_weight_annulus_bound hB.le (fun A hA t ht => (hbound A hA t ht).2) hfour z) |
| (dirichletEnergy_nonneg u z) |
| have hid := integral_mono hdi ((hfi.sub hgi).const_mul B) (fun z => by |
| have h44 : 4*(4*A)=16*A := by ring |
| have h4q : 4*A/4=A := by ring |
| simpa only [h44,h4q,sub_mul,mul_assoc,Pi.sub_apply] using hpoint z) |
| simp only [Pi.sub_apply] at hid |
| rw [integral_const_mul,integral_sub hfi hgi] at hid |
| have hm := radialCurveEnergy_mono hu hA (show A≤4*A by linarith) |
| have hc : 0≤C*(((2*Real.pi)^2+1)/2) := by positivity |
| have hh := he.trans (mul_le_mul_of_nonneg_left hid hc) |
| change radialCurveEnergy u (4*A)≤C*(((2*Real.pi)^2+1)/2)* |
| (B*(radialCurveEnergy u (16*A)-radialCurveEnergy u A)) at hh |
| have hfin : (K+1)*radialCurveEnergy u A≤K*radialCurveEnergy u (16*A) := by |
| dsimp [K] |
| nlinarith only [hm,hh] |
| rw [div_mul_eq_mul_div] |
| exact (le_div_iff₀ (by linarith : 0<K+1)).mpr (by nlinarith only [hfin]) |
|
|
|
|
| lemma radialCurveEnergy_geometric_bound {u : ℂ → Phase n} {θ : ℝ} (hθ : 0≤θ) |
| (hstep : ∀ A : ℝ, 0<A → radialCurveEnergy u A≤θ*radialCurveEnergy u (16*A)) |
| {A : ℝ} (hA : 0<A) (k : ℕ) : |
| radialCurveEnergy u (A/16^k)≤θ^k*radialCurveEnergy u A := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| have hs := hstep (A/16^(k+1)) (by positivity) |
| have he : 16*(A/16^(k+1))=A/16^k := by |
| rw [pow_succ] |
| field_simp |
| rw [he] at hs |
| refine hs.trans ((mul_le_mul_of_nonneg_left ih hθ).trans_eq ?_) |
| rw [pow_succ] |
| ring |
|
|
| theorem exact_homotopy_geometric_energy_decay {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x)) {S : ℝ} |
| (hout : ∀ x, S<capacity x → J x=standardJ n) : |
| ∃ θ : ℝ, 0<θ ∧ θ<1 ∧ ∀ t∈Icc (0:ℝ) 1, ∀ (u : ℂ → Phase n), |
| ContDiff ℝ ∞ u → (∀ z, PseudoHolomorphicAt (lineHomotopy J t) u z) → |
| ∀ A : ℝ, 0<A → ∀ k : ℕ, |
| radialCurveEnergy u (A/16^k)≤θ^k*radialCurveEnergy u A := by |
| obtain ⟨C,hC,hcal⟩ := uniform_homotopy_pointwise_calibration hJs hJ hout |
| obtain ⟨θ,hθ,hθ1,hdec⟩ := calibrated_energy_hole_filling (n := n) hC |
| refine ⟨θ,hθ,hθ1,?_⟩ |
| intro t ht u hu hcr A hA k |
| exact radialCurveEnergy_geometric_bound hθ.le (hdec u hu (hcal t ht u hu hcr)) hA k |
|
|
|
|
| def centeredCurve (u : ℂ → Phase n) (c : ℂ) (z : ℂ) : Phase n := u (z+c) |
|
|
| lemma centeredCurve_smooth {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (c : ℂ) : |
| ContDiff ℝ ∞ (centeredCurve u c) := hu.comp (contDiff_id.add contDiff_const) |
|
|
| lemma realCurve_centered (u : ℂ → Phase n) (c : ℂ) : |
| realCurve (centeredCurve u c)=fun z => realCurve u (z+Complex.equivRealProdCLM c) := by |
| funext z |
| simp only [realCurve,centeredCurve,Function.comp_def,map_add,ContinuousLinearEquiv.symm_apply_apply] |
|
|
| lemma centeredCurve_fderiv {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (c : ℂ) (z : Plane) : |
| fderiv ℝ (realCurve (centeredCurve u c)) z= |
| fderiv ℝ (realCurve u) (z+Complex.equivRealProdCLM c) := by |
| rw [realCurve_centered] |
| have hh := ((realCurve_smooth hu).differentiable (by simp) (z+Complex.equivRealProdCLM c)).hasFDerivAt.comp z |
| ((hasFDerivAt_id (𝕜 := ℝ) z).add_const (Complex.equivRealProdCLM c)) |
| change HasFDerivAt (fun z => realCurve u (z+Complex.equivRealProdCLM c)) _ z at hh |
| simpa only [ContinuousLinearMap.comp_id] using hh.fderiv |
|
|
| lemma dirichletEnergy_centered {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (c : ℂ) (z : Plane) : |
| dirichletEnergy (centeredCurve u c) z=dirichletEnergy u (z+Complex.equivRealProdCLM c) := by |
| simp only [dirichletEnergy,centeredCurve_fderiv hu] |
|
|
| lemma curveAreaDensity_centered {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (c : ℂ) (z : Plane) : |
| curveAreaDensity (centeredCurve u c) z=curveAreaDensity u (z+Complex.equivRealProdCLM c) := by |
| simp only [curveAreaDensity,centeredCurve_fderiv hu] |
|
|
| lemma stdDot_add_self_le (v w : Phase n) : |
| stdDot n (v+w) (v+w)≤2*stdDot n v v+2*stdDot n w w := by |
| have hh := stdDot_nonneg (v-w) |
| rw [stdDot_sub_self] at hh |
| simp only [map_add,add_apply] |
| rw [stdDot_symm w v] |
| linarith |
|
|
| lemma stdDot_standardJ_self (v : Phase n) : |
| stdDot n (standardJ n v) (standardJ n v)=stdDot n v v := by |
| rw [stdDot_J_right,standardForm_skew (standardJ n v),standardForm_J_right,neg_neg] |
|
|
| lemma dirichletEnergy_add_le {u v : ℂ → Phase n} |
| (hu : ContDiff ℝ ∞ u) (hv : ContDiff ℝ ∞ v) (z : Plane) : |
| dirichletEnergy (u+v) z≤2*dirichletEnergy u z+2*dirichletEnergy v z := by |
| have hd : fderiv ℝ (realCurve (u+v)) z=fderiv ℝ (realCurve u) z+fderiv ℝ (realCurve v) z := |
| (((realCurve_smooth hu).differentiable (by simp) z).hasFDerivAt.add |
| ((realCurve_smooth hv).differentiable (by simp) z).hasFDerivAt).fderiv |
| have hx := stdDot_add_self_le (fderiv ℝ (realCurve u) z (1,0)) (fderiv ℝ (realCurve v) z (1,0)) |
| have hy := stdDot_add_self_le (fderiv ℝ (realCurve u) z (0,1)) (fderiv ℝ (realCurve v) z (0,1)) |
| simp only [dirichletEnergy,hd,add_apply] |
| nlinarith only [hx,hy] |
|
|
| lemma dirichletEnergy_linear (a : Phase n) (z : Plane) : |
| dirichletEnergy (fun w : ℂ => w • a) z=2*stdDot n a a := by |
| have hu : ContDiff ℝ ∞ (fun w : ℂ => w • a) := contDiff_id.smul contDiff_const |
| have hd := (hasFDerivAt_id (𝕜 := ℝ) (Complex.equivRealProdCLM.symm z)).smul_const a |
| change HasFDerivAt (fun w : ℂ => w • a) _ (Complex.equivRealProdCLM.symm z) at hd |
| simp only [dirichletEnergy,realCurve_fderiv (hu.differentiable (by simp) _), hd.fderiv, |
| ContinuousLinearMap.smulRight_apply,ContinuousLinearMap.id_apply] |
| simp only [show Complex.equivRealProdCLM.symm (1,0)=(1:ℂ) from rfl, |
| show Complex.equivRealProdCLM.symm (0,1)=Complex.I from rfl,one_smul] |
| change stdDot n a a+stdDot n (standardJ n a) (standardJ n a)=_ |
| rw [stdDot_standardJ_self] |
| ring |
|
|
| lemma dirichletEnergy_le_affineCorrection {u : ℂ → Phase n} |
| (hu : ContDiff ℝ ∞ u) (a : Phase n) (z : Plane) : |
| dirichletEnergy u z≤2*dirichletEnergy (affineCorrection u a) z+4*stdDot n a a := by |
| have he : u=affineCorrection u a+(fun w : ℂ => w • a) := by |
| funext w |
| simp only [Pi.add_apply,affineCorrection,sub_add_cancel] |
| have hh := dirichletEnergy_add_le (affineCorrection_smooth hu a) |
| (contDiff_id.smul (contDiff_const (c := a))) z |
| change dirichletEnergy (affineCorrection u a+(fun w : ℂ => w • a)) z≤ |
| 2*dirichletEnergy (affineCorrection u a) z+2*dirichletEnergy (fun w : ℂ => w • a) z at hh |
| rw [←he,dirichletEnergy_linear] at hh |
| linarith only [hh] |
|
|
| lemma centered_unit_energy_bound {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| (a : Phase n) (hei : Integrable (dirichletEnergy (affineCorrection u a))) (c : ℂ) : |
| radialCurveEnergy (centeredCurve u c) 1≤ |
| 2*(∫ z, dirichletEnergy (affineCorrection u a) z)+ |
| 4*stdDot n a a*(∫ z : Plane, sourceRadialCutoff 1 z) := by |
| have hec := (dirichletEnergy_continuous (affineCorrection_smooth hu a)).comp |
| (continuous_id.add (continuous_const (y := Complex.equivRealProdCLM c))) |
| have hei' : Integrable (fun z => dirichletEnergy (affineCorrection u a) (z+Complex.equivRealProdCLM c)) := |
| (measurePreserving_add_right volume (Complex.equivRealProdCLM c)).integrable_comp_of_integrable hei |
| have hcuti : Integrable (sourceRadialCutoff 1) := |
| (sourceRadialCutoff_smooth 1).continuous.integrable_of_hasCompactSupport (sourceRadialCutoff_compact (by norm_num)) |
| have hci := smooth_cutoff_integrable_mul (by norm_num : (0:ℝ)<1) hec |
| have hu1 := smooth_cutoff_integrable_mul (by norm_num : (0:ℝ)<1) |
| (dirichletEnergy_continuous (centeredCurve_smooth hu c)) |
| have hpoint (z : Plane) : sourceRadialCutoff 1 z*dirichletEnergy (centeredCurve u c) z≤ |
| 2*dirichletEnergy (affineCorrection u a) (z+Complex.equivRealProdCLM c)+ |
| (4*stdDot n a a)*sourceRadialCutoff 1 z := by |
| rw [dirichletEnergy_centered hu] |
| have hh := mul_le_mul_of_nonneg_left (dirichletEnergy_le_affineCorrection hu a |
| (z+Complex.equivRealProdCLM c)) (sourceRadialCutoff_nonneg 1 z) |
| have hb := mul_le_of_le_one_left (dirichletEnergy_nonneg (affineCorrection u a) (z+Complex.equivRealProdCLM c)) |
| (sourceRadialCutoff_le_one 1 z) |
| nlinarith only [hh,hb] |
| have hle := integral_mono hu1 ((hei'.const_mul 2).add (hcuti.const_mul (4*stdDot n a a))) hpoint |
| simp only [Pi.add_apply] at hle |
| rw [integral_add (hei'.const_mul 2) (hcuti.const_mul _),integral_const_mul,integral_const_mul, |
| integral_add_right_eq_self] at hle |
| exact hle |
|
|
|
|
| theorem AffineLineCurve.affine_correction_energy_of_slope {J : Phase n → End n} |
| {p q : Phase n} {u : ℂ → Phase n} (hu : AffineLineCurve J p q u) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) {a : Phase n} |
| (ha : Tendsto (fun z : ℂ => z⁻¹ • u z) (cocompact ℂ) (𝓝 a)) : |
| Integrable (dirichletEnergy (affineCorrection u a)) ∧ |
| (∫ z, dirichletEnergy (affineCorrection u a) z)=∫ z, lineResidualEnergy u z := by |
| have hh := analyticAt_dslope_zero (infinityGerm_analyticAt (hu.holomorphic_at_infinity hJc) ha) |
| have he := fun z hz => infinityGerm_affine_reconstruction u a (z := z) hz |
| have hv := affineCorrection_smooth hu.1 a |
| have hβ := planarPullback_smooth (realCurve_smooth hv) (stdOmega n).contDiff |
| have hlim := radial_curl_integral_tendsto hβ (affineCorrection_real_flux_zero hu.1 hh he) |
| simp only [mul_zero] at hlim |
| have hfl : Tendsto (fun A : ℝ => ∫ z, sourceRadialCutoff A z * lineResidualEnergy u z) |
| atTop (𝓝 (∫ z, lineResidualEnergy u z)) := by |
| apply tendsto_const_nhds.congr' |
| filter_upwards [compact_integral_cutoff_eventually (lineResidualEnergy_compact hu hJc)] with A hA |
| rw [hA] |
| have helim : Tendsto (fun A : ℝ => ∫ z, sourceRadialCutoff A z * |
| dirichletEnergy (affineCorrection u a) z) atTop (𝓝 (∫ z, lineResidualEnergy u z)) := by |
| have hl := hlim.add hfl |
| simp only [zero_add] at hl |
| apply hl.congr' |
| filter_upwards [eventually_gt_atTop (0:ℝ)] with A hA |
| rw [←integral_add |
| (smooth_cutoff_integrable_mul hA ((planarCurl_contDiff hβ).continuous)) |
| (smooth_cutoff_integrable_mul hA (lineResidualEnergy_continuous hu.1))] |
| apply integral_congr_ae |
| filter_upwards [] with z |
| rw [standard_primitive_curl hv,affineCorrection_residual_energy hu.1] |
| ring |
| exact integrable_of_radial_exhaustion_limit (dirichletEnergy_continuous hv) |
| (dirichletEnergy_nonneg _) helim |
|
|
|
|
| theorem exact_line_uniform_local_energy {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x, Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) |
| (hout : ∀ x, S<capacity x → J x=standardJ n) : |
| ∃ C M θ : ℝ, 0<C ∧ 0≤M ∧ 0<θ ∧ θ<1 ∧ |
| ∀ t∈Icc (0:ℝ) 1, ∀ (p q : Phase n) (u : ℂ → Phase n), |
| AffineLineCurve (lineHomotopy J t) p q u → |
| ∃ a : Phase n, a≠0 ∧ |
| Tendsto (fun z : ℂ => z⁻¹ • u z) (cocompact ℂ) (𝓝 a) ∧ |
| ∀ (c : ℂ) (k : ℕ), radialCurveEnergy (centeredCurve u c) (1/16^k)≤ |
| θ^k*(C+M*stdDot n a a) := by |
| obtain ⟨D,hD,hres⟩ := exact_line_homotopy_residual_energy_bound hJs hJ hJc hST hT hout |
| obtain ⟨L,hL,hcal⟩ := uniform_homotopy_pointwise_calibration hJs hJ hout |
| obtain ⟨θ,hθ,hθ1,hstep⟩ := calibrated_energy_hole_filling (n := n) hL |
| let M : ℝ := 4*(∫ z : Plane,sourceRadialCutoff 1 z) |
| have hM : 0≤M := mul_nonneg (by norm_num) (integral_nonneg (sourceRadialCutoff_nonneg 1)) |
| refine ⟨2*D,M,θ,by positivity,hM,hθ,hθ1,?_⟩ |
| intro t ht p q u hu |
| obtain ⟨a,ha,hlim⟩ := hu.2.2.2.2 |
| obtain ⟨hei,heiVal⟩ := hu.affine_correction_energy_of_slope (lineHomotopy_compact hJc ht) hlim |
| refine ⟨a,ha,hlim,?_⟩ |
| intro c k |
| have hcalC (z : Plane) : dirichletEnergy (centeredCurve u c) z≤L*curveAreaDensity (centeredCurve u c) z := by |
| rw [dirichletEnergy_centered hu.1,curveAreaDensity_centered hu.1] |
| exact hcal t ht u hu.1 hu.2.1 _ |
| have hgeom := radialCurveEnergy_geometric_bound hθ.le |
| (hstep (centeredCurve u c) (centeredCurve_smooth hu.1 c) hcalC) (by norm_num : (0:ℝ)<1) k |
| have hunit := centered_unit_energy_bound hu.1 a hei c |
| rw [heiVal] at hunit |
| have hres' := hres t ht p q u hu |
| have hupp : radialCurveEnergy (centeredCurve u c) 1≤2*D+M*stdDot n a a := by |
| dsimp [M] |
| nlinarith only [hunit,hres'] |
| exact hgeom.trans (mul_le_mul_of_nonneg_left hupp (pow_nonneg hθ.le _)) |
|
|
|
|
|
|
| end HigherDimensionalBallPacking.Rigidity |
| end |
|
|
| end OAI |
|
|
