| import Mathlib |
| import OAI.Geometry.BallPacking.Holder.HolderTaylor |
| import OAI.Geometry.BallPacking.Rigidity.RadialForm |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace SymplecticBallPacking.Hamiltonian |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
|
|
| theorem plane_deriv_first {F : Plane → ℝ} (hF : Differentiable ℝ F) (p : Plane) : |
| deriv (fun x => F (x,p.2)) p.1 = fderiv ℝ F p (1,0) := by |
| exact ((hF p).hasFDerivAt.comp_hasDerivAt p.1 |
| ((hasDerivAt_id p.1).prodMk (hasDerivAt_const p.1 p.2))).deriv |
|
|
| theorem plane_deriv_second {F : Plane → ℝ} (hF : Differentiable ℝ F) (p : Plane) : |
| deriv (fun t => F (p.1,t)) p.2 = fderiv ℝ F p (0,1) := by |
| exact ((hF p).hasFDerivAt.comp_hasDerivAt p.2 |
| ((hasDerivAt_const p.2 p.1).prodMk (hasDerivAt_id p.2))).deriv |
|
|
| def pullbackForm (phi : Plane → Plane) (alpha : Plane → Plane →L[ℝ] ℝ) |
| (p : Plane) : Plane →L[ℝ] ℝ := (alpha (phi p)).comp (fderiv ℝ phi p) |
|
|
| theorem bilinear_skew_plane (B : Plane →L[ℝ] Plane →L[ℝ] ℝ) (u v : Plane) : |
| B u v - B v u = (B (1,0) (0,1)-B (0,1) (1,0))*planarArea u v := by |
| have hu : u = u.1 • ((1:ℝ),(0:ℝ)) + u.2 • ((0:ℝ),(1:ℝ)) := by ext <;> simp |
| have hv : v = v.1 • ((1:ℝ),(0:ℝ)) + v.2 • ((0:ℝ),(1:ℝ)) := by ext <;> simp |
| conv_lhs => rw [hu,hv] |
| simp only [map_add,map_smul,add_apply,smul_apply, |
| smul_eq_mul,planarArea_apply] |
| ring |
|
|
| theorem pullbackForm_smooth {phi : Plane → Plane} (hp : ContDiff ℝ ∞ phi) |
| {alpha : Plane → Plane →L[ℝ] ℝ} (ha : ContDiff ℝ ∞ alpha) : |
| ContDiff ℝ ∞ (pullbackForm phi alpha) := |
| (ha.comp hp).clm_comp (hp.fderiv_right (by simp)) |
|
|
| theorem pullbackForm_curl {phi : Plane → Plane} (hp : ContDiff ℝ ∞ phi) |
| {alpha : Plane → Plane →L[ℝ] ℝ} (ha : ContDiff ℝ ∞ alpha) (p : Plane) : |
| planarCurl (pullbackForm phi alpha) p = planarCurl alpha (phi p) * |
| planarArea (fderiv ℝ phi p (1,0)) (fderiv ℝ phi p (0,1)) := by |
| have hd := (((ha.differentiable (by simp)) (phi p)).hasFDerivAt.comp p |
| (((hp.differentiable (by simp)) p).hasFDerivAt)).clm_comp |
| (((hp.fderiv_right (by simp : (∞ : ℕ∞ω)+1 ≤ ∞)).differentiable (by simp) p).hasFDerivAt) |
| have hs := (hp.contDiffAt (x := p)).isSymmSndFDerivAt (by |
| rw [minSmoothness_of_isRCLikeNormedField] |
| change ((2 : ℕ∞) : WithTop ℕ∞) ≤ ↑(⊤ : ℕ∞) |
| exact WithTop.coe_le_coe.mpr le_top) |
| dsimp only [Function.comp_def] at hd |
| unfold planarCurl pullbackForm |
| rw [hd.fderiv] |
| simp only [add_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.compL_apply,ContinuousLinearMap.flip_apply] |
| rw [hs.eq (1,0) (0,1)] |
| have hb := bilinear_skew_plane (fderiv ℝ alpha (phi p)) |
| (fderiv ℝ phi p (1,0)) (fderiv ℝ phi p (0,1)) |
| linear_combination hb |
|
|
| theorem integral_curl_rectangle {alpha : Plane → Plane →L[ℝ] ℝ} |
| (ha : ContDiff ℝ ∞ alpha) (a b : Plane) (hab : a ≤ b) : |
| (∫ p in Icc a b, planarCurl alpha p) = |
| ((∫ t in a.2..b.2, alpha (b.1,t) (0,1)) - ∫ t in a.2..b.2, alpha (a.1,t) (0,1)) - |
| ((∫ r in a.1..b.1, alpha (r,b.2) (1,0)) - ∫ r in a.1..b.1, alpha (r,a.2) (1,0)) := by |
| let F : Plane → ℝ := fun p => alpha p (0,1) |
| let G : Plane → ℝ := fun p => -alpha p (1,0) |
| have hF : ContDiff ℝ ∞ F := ha.clm_apply contDiff_const |
| have hG : ContDiff ℝ ∞ G := (ha.clm_apply contDiff_const).neg |
| have hFd (p : Plane) : fderiv ℝ F p = |
| (ContinuousLinearMap.apply ℝ ℝ (0,1)).comp (fderiv ℝ alpha p) := |
| ((ContinuousLinearMap.apply ℝ ℝ (0,1) : (Plane →L[ℝ] ℝ) →L[ℝ] ℝ).hasFDerivAt.comp p |
| ((ha.differentiable (by simp)) p).hasFDerivAt).fderiv |
| have hGd (p : Plane) : fderiv ℝ G p = |
| -((ContinuousLinearMap.apply ℝ ℝ (1,0)).comp (fderiv ℝ alpha p)) := |
| (((ContinuousLinearMap.apply ℝ ℝ (1,0) : (Plane →L[ℝ] ℝ) →L[ℝ] ℝ).hasFDerivAt.comp p |
| ((ha.differentiable (by simp)) p).hasFDerivAt).neg).fderiv |
| have he (p : Plane) : fderiv ℝ F p (1,0)+fderiv ℝ G p (0,1) = planarCurl alpha p := by |
| rw [hFd,hGd] |
| rfl |
| have hi : IntegrableOn (fun p => fderiv ℝ F p (1,0)+fderiv ℝ G p (0,1)) (Icc a b) := |
| (((hF.continuous_fderiv (by simp)).clm_apply continuous_const).add |
| ((hG.continuous_fderiv (by simp)).clm_apply continuous_const)).continuousOn.integrableOn_compact isCompact_Icc |
| have hg := integral_divergence_prod_Icc_of_hasFDerivAt_of_le F G |
| (fderiv ℝ F) (fderiv ℝ G) a b hab hF.continuous.continuousOn hG.continuous.continuousOn |
| (fun p _ => ((hF.differentiable (by simp)) p).hasFDerivAt) |
| (fun p _ => ((hG.differentiable (by simp)) p).hasFDerivAt) hi |
| simp_rw [he] at hg |
| simp only [F,G,intervalIntegral.integral_neg] at hg |
| linear_combination hg |
|
|
| @[fun_prop] theorem polar_smooth : ContDiff ℝ ∞ (polarCoord.symm : Plane → Plane) := by |
| change ContDiff ℝ ∞ (fun p : Plane => (p.1*Real.cos p.2,p.1*Real.sin p.2)) |
| fun_prop |
|
|
| theorem polar_deriv_first (p : Plane) : |
| fderiv ℝ polarCoord.symm p (1,0) = (Real.cos p.2,Real.sin p.2) := by |
| rw [(hasFDerivAt_polarCoord_symm p).fderiv] |
| simp [fderivPolarCoordSymm,Matrix.toLin_finTwoProd_toContinuousLinearMap] |
|
|
| theorem polar_deriv_second (p : Plane) : |
| fderiv ℝ polarCoord.symm p (0,1) = (-p.1*Real.sin p.2,p.1*Real.cos p.2) := by |
| rw [(hasFDerivAt_polarCoord_symm p).fderiv] |
| simp [fderivPolarCoordSymm,Matrix.toLin_finTwoProd_toContinuousLinearMap] |
|
|
| theorem polar_area (p : Plane) : |
| planarArea (fderiv ℝ polarCoord.symm p (1,0)) (fderiv ℝ polarCoord.symm p (0,1)) = p.1 := by |
| rw [polar_deriv_first,polar_deriv_second,planarArea_apply] |
| have ht := Real.cos_sq_add_sin_sq p.2 |
| dsimp |
| linear_combination p.1 * ht |
|
|
| theorem integral_curl_polar_rectangle {alpha : Plane → Plane →L[ℝ] ℝ} |
| (ha : ContDiff ℝ ∞ alpha) {R : ℝ} (hR : 0 ≤ R) : |
| (∫ p in Icc ((0:ℝ),-Real.pi) (R,Real.pi), p.1*planarCurl alpha (polarCoord.symm p)) = |
| ∫ t in -Real.pi..Real.pi, |
| alpha (polarCoord.symm (R,t)) (-R*Real.sin t,R*Real.cos t) := by |
| let eta := pullbackForm polarCoord.symm alpha |
| have he (p : Plane) : planarCurl eta p = p.1*planarCurl alpha (polarCoord.symm p) := by |
| rw [pullbackForm_curl polar_smooth ha,polar_area,mul_comm] |
| have h := integral_curl_rectangle (pullbackForm_smooth polar_smooth ha) |
| ((0:ℝ),-Real.pi) (R,Real.pi) ⟨hR,by linarith [Real.pi_pos]⟩ |
| change (∫ p in Icc ((0:ℝ),-Real.pi) (R,Real.pi), planarCurl eta p) = _ at h |
| simp_rw [he] at h |
| have hside (r : ℝ) : eta (r,Real.pi) (1,0) = eta (r,-Real.pi) (1,0) := by |
| simp [eta,pullbackForm,polar_deriv_first,polarCoord_symm_apply] |
| have hin (t : ℝ) : eta (0,t) (0,1) = 0 := by |
| simp [eta,pullbackForm,polar_deriv_second,Prod.mk_zero_zero] |
| have hout (t : ℝ) : eta (R,t) (0,1) = |
| alpha (polarCoord.symm (R,t)) (-R*Real.sin t,R*Real.cos t) := by |
| simp [eta,pullbackForm,polar_deriv_second] |
| change _ = ((∫ t in -Real.pi..Real.pi, eta (R,t) (0,1)) - |
| ∫ t in -Real.pi..Real.pi, eta (0,t) (0,1)) - |
| ((∫ r in (0:ℝ)..R, eta (r,Real.pi) (1,0)) - ∫ r in (0:ℝ)..R, eta (r,-Real.pi) (1,0)) at h |
| simp_rw [hside,hin,hout] at h |
| simpa using h |
|
|
| def roundDisk (R : ℝ) : Set Plane := {p | p.1^2+p.2^2 < R^2} |
|
|
| theorem polar_mem_roundDisk {R : ℝ} (hR : 0 < R) {p : Plane} (hp : 0 < p.1) : |
| polarCoord.symm p ∈ roundDisk R ↔ p.1 < R := by |
| have hn : (polarCoord.symm p).1^2+(polarCoord.symm p).2^2 = p.1^2 := by |
| simp only [polarCoord_symm_apply] |
| linear_combination p.1^2 * Real.cos_sq_add_sin_sq p.2 |
| change (polarCoord.symm p).1^2+(polarCoord.symm p).2^2 < R^2 ↔ _ |
| rw [hn] |
| constructor <;> intro h <;> nlinarith |
|
|
| theorem integral_roundDisk_polar (f : Plane → ℝ) {R : ℝ} (hR : 0 < R) : |
| (∫ p in roundDisk R, f p) = |
| ∫ p in Icc ((0:ℝ),-Real.pi) (R,Real.pi), p.1*f (polarCoord.symm p) := by |
| have hm : MeasurableSet (roundDisk R) := |
| (isOpen_lt ((continuous_fst.pow 2).add (continuous_snd.pow 2)) continuous_const).measurableSet |
| let S : Set Plane := {p | p.1 < R} |
| have hS : MeasurableSet S := (isOpen_lt continuous_fst continuous_const).measurableSet |
| have he (p : Plane) (hp : p ∈ polarCoord.target) : |
| p.1 * (roundDisk R).indicator f (polarCoord.symm p) = |
| S.indicator (fun p => p.1*f (polarCoord.symm p)) p := by |
| have hi := polar_mem_roundDisk hR hp.1 |
| by_cases ht : p.1 < R |
| · simp only [indicator_of_mem (hi.mpr ht),indicator_of_mem (show p ∈ S from ht)] |
| · simp only [indicator_of_notMem (mt hi.mp ht),indicator_of_notMem (show p ∉ S from ht),mul_zero] |
| have hinter : polarCoord.target ∩ S = Ioo (0:ℝ) R ×ˢ Ioo (-Real.pi) Real.pi := by |
| ext p |
| simp only [polarCoord_target,mem_inter_iff,mem_prod,mem_Ioi,mem_Ioo,S,mem_ofPred_eq] |
| tauto |
| calc |
| (∫ p in roundDisk R, f p) = ∫ p in polarCoord.target, |
| p.1 * (roundDisk R).indicator f (polarCoord.symm p) := by |
| rw [← integral_indicator hm] |
| exact (integral_comp_polarCoord_symm ((roundDisk R).indicator f)).symm |
| _ = ∫ p in polarCoord.target, S.indicator (fun p => p.1*f (polarCoord.symm p)) p := |
| setIntegral_congr_fun polarCoord.open_target.measurableSet he |
| _ = ∫ p in Ioo (0:ℝ) R ×ˢ Ioo (-Real.pi) Real.pi, p.1*f (polarCoord.symm p) := by |
| rw [setIntegral_indicator hS,hinter] |
| _ = ∫ p in Icc ((0:ℝ),-Real.pi) (R,Real.pi), p.1*f (polarCoord.symm p) := by |
| apply setIntegral_congr_set |
| rw [Icc_prod_eq] |
| exact MeasureTheory.Measure.set_prod_ae_eq MeasureTheory.Ioo_ae_eq_Icc MeasureTheory.Ioo_ae_eq_Icc |
|
|
| theorem integral_curl_roundDisk {alpha : Plane → Plane →L[ℝ] ℝ} |
| (ha : ContDiff ℝ ∞ alpha) {R : ℝ} (hR : 0 < R) : |
| (∫ p in roundDisk R, planarCurl alpha p) = |
| ∫ t in -Real.pi..Real.pi, |
| alpha (polarCoord.symm (R,t)) (-R*Real.sin t,R*Real.cos t) := by |
| rw [integral_roundDisk_polar _ hR] |
| exact integral_curl_polar_rectangle ha hR.le |
|
|
| def coordinateForm (U V : Plane → ℝ) (p : Plane) : Plane →L[ℝ] ℝ := |
| U p • ContinuousLinearMap.fst ℝ ℝ ℝ + V p • ContinuousLinearMap.snd ℝ ℝ ℝ |
|
|
| @[simp] theorem coordinateForm_apply (U V : Plane → ℝ) (p v : Plane) : |
| coordinateForm U V p v = U p*v.1+V p*v.2 := rfl |
|
|
| theorem coordinateForm_smooth {U V : Plane → ℝ} (hU : ContDiff ℝ ∞ U) |
| (hV : ContDiff ℝ ∞ V) : ContDiff ℝ ∞ (coordinateForm U V) := |
| (hU.smul contDiff_const).add (hV.smul contDiff_const) |
|
|
| theorem coordinateForm_compact {U V : Plane → ℝ} (hU : HasCompactSupport U) |
| (hV : HasCompactSupport V) : HasCompactSupport (coordinateForm U V) := by |
| apply HasCompactSupport.intro (hU.union hV) |
| intro p hp |
| have hu : U p = 0 := image_eq_zero_of_notMem_tsupport (fun h => hp (Or.inl h)) |
| have hv : V p = 0 := image_eq_zero_of_notMem_tsupport (fun h => hp (Or.inr h)) |
| simp only [coordinateForm,hu,hv,zero_smul,zero_add] |
|
|
| theorem form_eval_fderiv {alpha : Plane → Plane →L[ℝ] ℝ} (ha : ContDiff ℝ ∞ alpha) |
| (p v w : Plane) : fderiv ℝ (fun q => alpha q w) p v = fderiv ℝ alpha p v w := by |
| have he := ((ContinuousLinearMap.apply ℝ ℝ w : (Plane →L[ℝ] ℝ) →L[ℝ] ℝ).hasFDerivAt.comp p |
| ((ha.differentiable (by simp)) p).hasFDerivAt).fderiv |
| exact congrArg (fun D : Plane →L[ℝ] ℝ => D v) he |
|
|
| theorem coordinateForm_curl {U V : Plane → ℝ} (hU : ContDiff ℝ ∞ U) |
| (hV : ContDiff ℝ ∞ V) (p : Plane) : |
| planarCurl (coordinateForm U V) p = |
| deriv (fun x => V (x,p.2)) p.1 - deriv (fun y => U (p.1,y)) p.2 := by |
| rw [plane_deriv_first (hV.differentiable (by simp)), |
| plane_deriv_second (hU.differentiable (by simp))] |
| unfold planarCurl |
| rw [← form_eval_fderiv (coordinateForm_smooth hU hV), |
| ← form_eval_fderiv (coordinateForm_smooth hU hV)] |
| simp only [coordinateForm_apply,mul_zero,mul_one,zero_add,add_zero] |
|
|
| end SymplecticBallPacking.Hamiltonian |
|
|
| namespace HigherDimensionalBallPacking.Rigidity |
| open scoped ContDiff Topology |
| open Set Function Filter MeasureTheory |
| open SymplecticBallPacking.Hamiltonian |
|
|
| theorem polar_complex_eq_circleMap (R t : ℝ) : |
| Complex.equivRealProdCLM.symm (polarCoord.symm (R,t)) = circleMap 0 R t := by |
| apply Complex.ext <;> simp [Complex.equivRealProdCLM_symm_apply,polarCoord_symm_apply, |
| circleMap_zero_re,circleMap_zero_im,Complex.cos_ofReal_re,Complex.sin_ofReal_re] |
|
|
| theorem angular_complex_eq_circleMap (R t : ℝ) : |
| Complex.equivRealProdCLM.symm (-R*Real.sin t,R*Real.cos t) = |
| Complex.I*circleMap 0 R t := by |
| apply Complex.ext <;> simp [Complex.equivRealProdCLM_symm_apply, |
| circleMap_zero_re,circleMap_zero_im,Complex.cos_ofReal_re,Complex.sin_ofReal_re] |
|
|
| theorem roundDisk_measurable (R : ℝ) : MeasurableSet (roundDisk R) := |
| (isOpen_lt ((continuous_fst.pow 2).add (continuous_snd.pow 2)) continuous_const).measurableSet |
|
|
| def cauchyCurl (f : ℂ → ℂ) (z : ℂ) : ℂ := |
| Complex.I * fderiv ℝ f z 1 - fderiv ℝ f z Complex.I |
|
|
| theorem cauchyCurl_smooth {f : ℂ → ℂ} (hf : ContDiff ℝ ∞ f) : |
| ContDiff ℝ ∞ (cauchyCurl f) := |
| (contDiff_const.mul ((hf.fderiv_right (by simp)).clm_apply contDiff_const)).sub |
| ((hf.fderiv_right (by simp)).clm_apply contDiff_const) |
|
|
| theorem cauchyCurl_compact {f : ℂ → ℂ} (hf : HasCompactSupport f) : |
| HasCompactSupport (cauchyCurl f) := |
| ((hf.fderiv_apply (𝕜 := ℝ) 1).comp_left (g := fun z : ℂ => Complex.I*z) (by simp)).sub |
| (hf.fderiv_apply (𝕜 := ℝ) Complex.I) |
|
|
| def projectedCauchyForm (L : ℂ →L[ℝ] ℝ) (f : ℂ → ℂ) : Plane → Plane →L[ℝ] ℝ := |
| coordinateForm (fun p => L (f (Complex.equivRealProdCLM.symm p))) |
| (fun p => L (Complex.I*f (Complex.equivRealProdCLM.symm p))) |
|
|
| theorem projectedCauchyForm_smooth (L : ℂ →L[ℝ] ℝ) {f : ℂ → ℂ} |
| (hf : ContDiff ℝ ∞ f) : ContDiff ℝ ∞ (projectedCauchyForm L f) := by |
| exact coordinateForm_smooth |
| (L.contDiff.comp (hf.comp Complex.equivRealProdCLM.symm.contDiff)) |
| (L.contDiff.comp (contDiff_const.mul (hf.comp Complex.equivRealProdCLM.symm.contDiff))) |
|
|
| theorem projectedCauchyForm_compact (L : ℂ →L[ℝ] ℝ) {f : ℂ → ℂ} |
| (hf : HasCompactSupport f) : HasCompactSupport (projectedCauchyForm L f) := by |
| have hc := hf.comp_homeomorph Complex.equivRealProdCLM.symm.toHomeomorph |
| exact coordinateForm_compact (hc.comp_left L.map_zero) |
| (hc.comp_left (g := fun z : ℂ => L (Complex.I*z)) (by simp)) |
|
|
| theorem projectedCauchyForm_apply (L : ℂ →L[ℝ] ℝ) (f : ℂ → ℂ) (p v : Plane) : |
| projectedCauchyForm L f p v = |
| L (f (Complex.equivRealProdCLM.symm p)*Complex.equivRealProdCLM.symm v) := by |
| have h (z : ℂ) : z*Complex.equivRealProdCLM.symm v = |
| v.1 • z + v.2 • (Complex.I*z) := by |
| apply Complex.ext <;> simp [Complex.equivRealProdCLM_symm_apply] <;> ring |
| rw [h,map_add,map_smul,map_smul] |
| simp only [projectedCauchyForm,coordinateForm_apply,smul_eq_mul] |
| ring |
|
|
| theorem projectedCauchyForm_curl (L : ℂ →L[ℝ] ℝ) {f : ℂ → ℂ} |
| (hf : ContDiff ℝ ∞ f) (p : Plane) : |
| planarCurl (projectedCauchyForm L f) p = |
| L (cauchyCurl f (Complex.equivRealProdCLM.symm p)) := by |
| have hb := (hf.differentiable (by simp) (Complex.equivRealProdCLM.symm p)).hasFDerivAt.comp |
| p Complex.equivRealProdCLM.symm.hasFDerivAt |
| have hu := L.hasFDerivAt.comp p hb |
| have hv := L.hasFDerivAt.comp p (hb.const_mul Complex.I) |
| have hU : ContDiff ℝ ∞ (fun p => L (f (Complex.equivRealProdCLM.symm p))) := |
| L.contDiff.comp (hf.comp Complex.equivRealProdCLM.symm.contDiff) |
| have hV : ContDiff ℝ ∞ (fun p => L (Complex.I*f (Complex.equivRealProdCLM.symm p))) := |
| L.contDiff.comp (contDiff_const.mul (hf.comp Complex.equivRealProdCLM.symm.contDiff)) |
| rw [projectedCauchyForm,coordinateForm_curl hU hV, |
| plane_deriv_first (hV.differentiable (by simp)), |
| plane_deriv_second (hU.differentiable (by simp))] |
| simp only [Function.comp_def] at hu hv |
| rw [hu.fderiv,hv.fderiv] |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearEquiv.coe_coe, |
| smul_apply,smul_eq_mul,Complex.equivRealProdCLM_symm_apply, |
| Complex.ofReal_one,Complex.ofReal_zero,zero_mul,one_mul,zero_add,add_zero] |
| exact (map_sub L _ _).symm |
|
|
| theorem complex_compact_stokes {f : ℂ → ℂ} (hf : ContDiff ℝ ∞ f) |
| (hc : HasCompactSupport f) : |
| (∫ p : Plane, cauchyCurl f (Complex.equivRealProdCLM.symm p)) = 0 := by |
| have hi : Integrable (fun p : Plane => cauchyCurl f (Complex.equivRealProdCLM.symm p)) := |
| ((cauchyCurl_smooth hf).continuous.comp Complex.equivRealProdCLM.symm.continuous).integrable_of_hasCompactSupport |
| ((cauchyCurl_compact hc).comp_homeomorph Complex.equivRealProdCLM.symm.toHomeomorph) |
| have hh (L : ℂ →L[ℝ] ℝ) : L (∫ p : Plane, |
| cauchyCurl f (Complex.equivRealProdCLM.symm p))=0 := by |
| rw [←L.integral_comp_comm hi] |
| simp_rw [←projectedCauchyForm_curl L hf] |
| exact compact_planar_stokes (projectedCauchyForm_smooth L hf) |
| (projectedCauchyForm_compact L hc) |
| exact Complex.ext (hh Complex.reCLM) (hh Complex.imCLM) |
|
|
| theorem complex_disk_stokes {f : ℂ → ℂ} (hf : ContDiff ℝ ∞ f) |
| (hc : HasCompactSupport f) {R : ℝ} (hR : 0<R) : |
| (∫ p in roundDisk R, cauchyCurl f (Complex.equivRealProdCLM.symm p)) = |
| ∫ t in -Real.pi..Real.pi, f (circleMap 0 R t)*(Complex.I*circleMap 0 R t) := by |
| have hi : Integrable (fun p : Plane => cauchyCurl f (Complex.equivRealProdCLM.symm p)) := |
| ((cauchyCurl_smooth hf).continuous.comp Complex.equivRealProdCLM.symm.continuous).integrable_of_hasCompactSupport |
| ((cauchyCurl_compact hc).comp_homeomorph Complex.equivRealProdCLM.symm.toHomeomorph) |
| have hb : IntervalIntegrable (fun t => f (circleMap 0 R t)*(Complex.I*circleMap 0 R t)) |
| volume (-Real.pi) Real.pi := |
| ((hf.continuous.comp (continuous_circleMap 0 R)).mul |
| (continuous_const.mul (continuous_circleMap 0 R))).intervalIntegrable _ _ |
| have hh (L : ℂ →L[ℝ] ℝ) : |
| L (∫ p in roundDisk R, cauchyCurl f (Complex.equivRealProdCLM.symm p)) = |
| L (∫ t in -Real.pi..Real.pi, f (circleMap 0 R t)*(Complex.I*circleMap 0 R t)) := by |
| rw [←L.integral_comp_comm hi.integrableOn,←L.intervalIntegral_comp_comm hb] |
| simp_rw [←projectedCauchyForm_curl L hf] |
| rw [integral_curl_roundDisk (projectedCauchyForm_smooth L hf) hR] |
| apply intervalIntegral.integral_congr |
| intro t _ |
| dsimp only |
| rw [projectedCauchyForm_apply,polar_complex_eq_circleMap,angular_complex_eq_circleMap] |
| exact Complex.ext (hh Complex.reCLM) (hh Complex.imCLM) |
|
|
| def cauchyInnerBump (R : ℝ) (hR : 0<R) : ContDiffBump (0:ℂ) where |
| rIn := R/4 |
| rOut := R/2 |
| rIn_pos := by linarith |
| rIn_lt_rOut := by linarith |
|
|
| def cauchyPuncture (b : ContDiffBump (0:ℂ)) (f : ℂ → ℂ) (z : ℂ) : ℂ := |
| (1-b z) • (f z/z) |
|
|
| theorem cauchyPuncture_compact (b : ContDiffBump (0:ℂ)) {f : ℂ → ℂ} |
| (hc : HasCompactSupport f) : HasCompactSupport (cauchyPuncture b f) := by |
| apply HasCompactSupport.intro hc |
| intro z hz |
| simp only [cauchyPuncture,image_eq_zero_of_notMem_tsupport hz,zero_div,smul_zero] |
|
|
| theorem cauchyPuncture_smooth (b : ContDiffBump (0:ℂ)) {f : ℂ → ℂ} |
| (hf : ContDiff ℝ ∞ f) : ContDiff ℝ ∞ (cauchyPuncture b f) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro z |
| by_cases hz : z=0 |
| · subst z |
| apply (contDiffAt_const (c := (0:ℂ))).congr_of_eventuallyEq |
| filter_upwards [b.eventuallyEq_one] with z hz |
| simp only [cauchyPuncture,hz,Pi.one_apply,sub_self,zero_smul] |
| · apply (contDiffAt_const.sub b.contDiff.contDiffAt).smul |
| simpa only [div_eq_mul_inv] using hf.contDiffAt.mul (contDiffAt_inv (𝕜 := ℝ) hz) |
|
|
| theorem cauchyPuncture_eventuallyEq (b : ContDiffBump (0:ℂ)) (f : ℂ → ℂ) |
| {z : ℂ} (hz : b.rOut<‖z‖) : |
| cauchyPuncture b f =ᶠ[𝓝 z] (fun w => f w/w) := by |
| have hh : ∀ᶠ w in 𝓝 z, b.rOut<‖w‖ := |
| (isOpen_lt continuous_const continuous_norm).mem_nhds hz |
| filter_upwards [hh] with w hw |
| have hb : b w=0 := b.zero_of_le_dist (by simpa only [dist_zero_right] using hw.le) |
| simp only [cauchyPuncture,hb,sub_zero,one_smul] |
|
|
| theorem cauchyCurl_div {f : ℂ → ℂ} {z : ℂ} (hf : DifferentiableAt ℝ f z) |
| (hz : z≠0) : cauchyCurl (fun w => f w/w) z = cauchyCurl f z/z := by |
| have hd := hf.hasFDerivAt.mul ((hasDerivAt_inv hz).hasFDerivAt.restrictScalars ℝ) |
| have he : (fun w => f w/w) = (fun w => f w*w⁻¹) := by |
| funext w |
| exact div_eq_mul_inv _ _ |
| change HasFDerivAt (fun w => f w*w⁻¹) _ z at hd |
| rw [he,cauchyCurl,hd.fderiv] |
| change Complex.I * (f z * (1 * (-(z^2)⁻¹)) + z⁻¹ * fderiv ℝ f z 1) - |
| (f z * (Complex.I * (-(z^2)⁻¹)) + z⁻¹ * fderiv ℝ f z Complex.I) = |
| (Complex.I * fderiv ℝ f z 1 - fderiv ℝ f z Complex.I) / z |
| rw [div_eq_mul_inv] |
| ring |
|
|
| theorem cauchyPuncture_curl (b : ContDiffBump (0:ℂ)) {f : ℂ → ℂ} |
| (hf : ContDiff ℝ ∞ f) {z : ℂ} (hz : b.rOut<‖z‖) : |
| cauchyCurl (cauchyPuncture b f) z = cauchyCurl f z/z := by |
| have he := (cauchyPuncture_eventuallyEq b f hz).fderiv_eq (𝕜 := ℝ) |
| unfold cauchyCurl |
| rw [he] |
| exact cauchyCurl_div (hf.differentiable (by simp) z) |
| (fun h => by simp only [h,norm_zero,not_lt_of_ge b.rOut_pos.le] at hz) |
|
|
| theorem complexCartesian_norm_sq (p : Plane) : |
| ‖Complex.equivRealProdCLM.symm p‖^2 = p.1^2+p.2^2 := by |
| rw [Complex.sq_norm] |
| simp [Complex.normSq_apply,Complex.equivRealProdCLM_symm_apply,pow_two] |
|
|
| theorem complexCartesian_norm_ge_of_notMem {R : ℝ} (hR : 0<R) {p : Plane} |
| (hp : p ∉ roundDisk R) : R≤‖Complex.equivRealProdCLM.symm p‖ := by |
| have hn := norm_nonneg (Complex.equivRealProdCLM.symm p) |
| have he := complexCartesian_norm_sq p |
| change ¬p.1^2+p.2^2<R^2 at hp |
| push Not at hp |
| nlinarith |
|
|
| theorem cauchy_exterior_integral {f : ℂ → ℂ} (hf : ContDiff ℝ ∞ f) |
| (hc : HasCompactSupport f) {R : ℝ} (hR : 0<R) : |
| (∫ p in (roundDisk R)ᶜ, |
| cauchyCurl f (Complex.equivRealProdCLM.symm p)/Complex.equivRealProdCLM.symm p) = |
| -(Complex.I * ∫ t in -Real.pi..Real.pi, f (circleMap 0 R t)) := by |
| let b := cauchyInnerBump R hR |
| let g := cauchyPuncture b f |
| have hg : ContDiff ℝ ∞ g := cauchyPuncture_smooth b hf |
| have hgc : HasCompactSupport g := cauchyPuncture_compact b hc |
| have hi : Integrable (fun p : Plane => cauchyCurl g (Complex.equivRealProdCLM.symm p)) := |
| ((cauchyCurl_smooth hg).continuous.comp Complex.equivRealProdCLM.symm.continuous).integrable_of_hasCompactSupport |
| ((cauchyCurl_compact hgc).comp_homeomorph Complex.equivRealProdCLM.symm.toHomeomorph) |
| have hs := integral_add_compl (roundDisk_measurable R) hi |
| rw [complex_compact_stokes hg hgc,complex_disk_stokes hg hgc hR] at hs |
| have he : (∫ p in (roundDisk R)ᶜ, cauchyCurl g (Complex.equivRealProdCLM.symm p)) = |
| ∫ p in (roundDisk R)ᶜ, |
| cauchyCurl f (Complex.equivRealProdCLM.symm p)/Complex.equivRealProdCLM.symm p := by |
| apply setIntegral_congr_fun (roundDisk_measurable R).compl |
| intro p hp |
| apply cauchyPuncture_curl b hf |
| have hh := complexCartesian_norm_ge_of_notMem hR hp |
| change R/2 < _ |
| linarith |
| have hb : (∫ t in -Real.pi..Real.pi, g (circleMap 0 R t)*(Complex.I*circleMap 0 R t)) = |
| Complex.I * ∫ t in -Real.pi..Real.pi, f (circleMap 0 R t) := by |
| rw [←intervalIntegral.integral_const_mul] |
| apply intervalIntegral.integral_congr |
| intro t _ |
| dsimp only |
| have hn : b.rOut<‖circleMap 0 R t‖ := by |
| rw [norm_circleMap_zero,abs_of_pos hR] |
| change R/2<R |
| linarith |
| rw [show g (circleMap 0 R t)=f (circleMap 0 R t)/circleMap 0 R t from |
| (cauchyPuncture_eventuallyEq b f hn).eq_of_nhds] |
| field_simp [circleMap_ne_center hR.ne' (θ := t)] |
| rw [he,hb] at hs |
| exact eq_neg_of_add_eq_zero_right hs |
|
|
| theorem cauchyCurl_div_integrable {f : ℂ → ℂ} (hf : ContDiff ℝ ∞ f) |
| (hc : HasCompactSupport f) : Integrable (fun z => cauchyCurl f z/z) := by |
| simpa only [smul_eq_mul,div_eq_mul_inv,mul_comm] using |
| locallyIntegrable_complex_inv.integrable_smul_right_of_hasCompactSupport |
| (cauchyCurl_smooth hf).continuous (cauchyCurl_compact hc) |
|
|
| theorem shrinking_exterior_aecover : |
| AECover (volume : Measure Plane) (𝓝[>] (0:ℝ)) (fun R => (roundDisk R)ᶜ) := by |
| refine ⟨?_,fun R => (roundDisk_measurable R).compl⟩ |
| filter_upwards [volume.ae_ne (0:Plane)] with p hp |
| have hpos : 0<p.1^2+p.2^2 := by |
| by_contra! hh |
| have hx : p.1=0 := by nlinarith [sq_nonneg p.1,sq_nonneg p.2] |
| have hy : p.2=0 := by nlinarith [sq_nonneg p.1,sq_nonneg p.2] |
| exact hp (Prod.ext hx hy) |
| have hsq : ContinuousAt (fun R : ℝ => R^2) 0 := by fun_prop |
| have ht : Tendsto (fun R : ℝ => R^2) (𝓝[>] (0:ℝ)) (𝓝 (0:ℝ)) := by |
| simpa only [zero_pow (by decide : (2:ℕ)≠0)] using |
| hsq.tendsto.mono_left (nhdsWithin_le_nhds (s := Ioi (0:ℝ))) |
| filter_upwards [ht.eventually (Iio_mem_nhds hpos)] with R hR |
| change ¬p.1^2+p.2^2<R^2 |
| exact not_lt_of_ge (le_of_lt hR) |
|
|
| theorem circle_mean_integral_limit {f : ℂ → ℂ} (hf : Continuous f) : |
| Tendsto (fun R : ℝ => ∫ t in -Real.pi..Real.pi, f (circleMap 0 R t)) |
| (𝓝 (0:ℝ)) (𝓝 ((2*Real.pi : ℝ) • f 0)) := by |
| have hh : Continuous (fun p : ℝ×ℝ => f (circleMap 0 p.1 p.2)) := by |
| apply hf.comp |
| unfold circleMap |
| fun_prop |
| have hi := intervalIntegral.continuous_parametric_intervalIntegral_of_continuous' |
| (μ := volume) (f := fun R t : ℝ => f (circleMap 0 R t)) hh (-Real.pi) Real.pi |
| convert (hi.continuousAt (x := (0:ℝ))).tendsto using 1 |
| simp only [circleMap,Complex.ofReal_zero,zero_mul,zero_add,intervalIntegral.integral_const] |
| congr 1 |
| congr 1 |
| ring |
|
|
| theorem cauchy_green_fundamental {f : ℂ → ℂ} (hf : ContDiff ℝ ∞ f) |
| (hc : HasCompactSupport f) : |
| (∫ z : ℂ, cauchyCurl f z/z) = -(2*Real.pi*Complex.I)*f 0 := by |
| have hp := Complex.volume_preserving_equiv_real_prod.symm |
| have hi : Integrable (fun p : Plane => |
| cauchyCurl f (Complex.equivRealProdCLM.symm p)/Complex.equivRealProdCLM.symm p) := |
| hp.integrable_comp_of_integrable (cauchyCurl_div_integrable hf hc) |
| have hl := ((circle_mean_integral_limit hf.continuous).const_mul Complex.I).neg |
| have hl' : Tendsto (fun R : ℝ => ∫ p in (roundDisk R)ᶜ, |
| cauchyCurl f (Complex.equivRealProdCLM.symm p)/Complex.equivRealProdCLM.symm p) |
| (𝓝[>] (0:ℝ)) (𝓝 (-(2*Real.pi*Complex.I)*f 0)) := by |
| have hh := hl.mono_left (nhdsWithin_le_nhds (s := Ioi (0:ℝ))) |
| have heval : -(Complex.I * ((2*Real.pi:ℝ) • f 0)) = |
| -(2*Real.pi*Complex.I)*f 0 := by |
| rw [Complex.real_smul] |
| push_cast |
| ring |
| rw [heval] at hh |
| apply hh.congr' |
| have hR : ∀ᶠ R in 𝓝[>] (0:ℝ), 0<R := self_mem_nhdsWithin |
| filter_upwards [hR] with R hR |
| exact (cauchy_exterior_integral hf hc hR).symm |
| have he := shrinking_exterior_aecover.integral_eq_of_tendsto _ hi hl' |
| rw [← hp.integral_comp' (fun z : ℂ => cauchyCurl f z/z)] |
| exact he |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance : NormedAddCommGroup (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance : NormedSpace ℝ (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
|
|
| def curlJet : (ℂ →L[ℝ] E) →L[ℝ] E := |
| Complex.I • ContinuousLinearMap.apply ℝ E (1:ℂ) - ContinuousLinearMap.apply ℝ E Complex.I |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma curlJet_apply (A : ℂ →L[ℝ] E) : |
| curlJet A = Complex.I • A 1 - A Complex.I := rfl |
|
|
| omit [CompleteSpace E] in |
| lemma curlJet_smul (c : ℂ) (A : ℂ →L[ℝ] E) : curlJet (c • A) = c • curlJet A := by |
| simp only [curlJet_apply, smul_apply, smul_sub] |
| rw [smul_comm c Complex.I] |
|
|
| lemma smoothCauchyKernel_zero (z : ℂ) : smoothCauchyKernel 0 z = z⁻¹ := by |
| rw [smoothCauchyKernel, add_zero, Complex.inv_def,Complex.normSq_eq_norm_sq] |
| simp only [Complex.real_smul,Complex.ofReal_inv] |
| exact mul_comm _ _ |
|
|
| lemma regularizedCauchyJet_zero_fderiv {z : ℂ} (hz : z ≠ 0) : |
| regularizedCauchyJet 0 z = fderiv ℝ (fun w : ℂ => w⁻¹) z := by |
| have hd := ((hasDerivAt_inv (pow_ne_zero 2 (norm_ne_zero_iff.mpr hz))).comp_hasFDerivAt z |
| (hasStrictFDerivAt_norm_sq z).hasFDerivAt).smul |
| (starL ℝ : ℂ ≃L[ℝ] ℂ).hasFDerivAt |
| have he : (fun w : ℂ => (‖w‖^2)⁻¹ • star w) = fun w : ℂ => w⁻¹ := by |
| funext w |
| simpa only [smoothCauchyKernel, add_zero] using smoothCauchyKernel_zero w |
| change HasFDerivAt (fun w : ℂ => (‖w‖^2)⁻¹ • star w) _ z at hd |
| rw [he] at hd |
| rw [hd.fderiv] |
| ext v |
| simp only [regularizedCauchyJet, add_zero, sub_apply,smul_apply, |
| ContinuousLinearMap.smulRight_apply,innerSL_apply_apply,starL'_apply, |
| ContinuousLinearEquiv.coe_coe,add_apply,smul_smul,two_smul,Function.comp_apply] |
| change (‖z‖^2)⁻¹ • star v - ((2/(‖z‖^2)^2)*(inner ℝ z v)) • star z = |
| (‖z‖^2)⁻¹ • star v + (-((‖z‖^2)^2)⁻¹*(inner ℝ z v+inner ℝ z v)) • star z |
| rw [sub_eq_add_neg, ← neg_smul] |
| congr 2 |
| simp only [div_eq_mul_inv] |
| ring |
|
|
| lemma regularizedCauchyJet_curl_zero {z : ℂ} (hz : z ≠ 0) : |
| curlJet (regularizedCauchyJet 0 z) = (0:ℂ) := by |
| rw [regularizedCauchyJet_zero_fderiv hz, curlJet_apply] |
| have hd := (hasDerivAt_inv hz).hasFDerivAt.restrictScalars ℝ |
| rw [hd.fderiv] |
| change Complex.I * ((1:ℂ) * (-(z^2)⁻¹)) - Complex.I * (-(z^2)⁻¹) = 0 |
| ring |
|
|
| omit [CompleteSpace E] in |
| lemma cancellationJetIntegrand_integrable (b : ContDiffBump (0:ℂ)) |
| {g : ℂ → E} (hgC : Continuous g) {H : ℝ} (hH : 0 ≤ H) |
| (hg : ∀ x y, ‖g x-g y‖ ≤ H*‖x-y‖^((1:ℝ)/3)) (x : ℂ) : |
| Integrable (cancellationJetIntegrand b 0 g x) := by |
| obtain ⟨C,hC,hCb⟩ := cutoff_smoothCauchyKernel_bound b |
| let δ : ℕ → ℝ := fun n => 1/(n+1) |
| have hδ (n : ℕ) : 0<δ n := by dsimp [δ]; positivity |
| have hδt : Tendsto δ atTop (𝓝[>] (0:ℝ)) := |
| tendsto_nhdsWithin_iff.mpr ⟨tendsto_one_div_add_atTop_nhds_zero_nat, |
| Eventually.of_forall hδ⟩ |
| have hm : AEStronglyMeasurable (cancellationJetIntegrand b 0 g x) := |
| aestronglyMeasurable_of_tendsto_ae atTop |
| (fun n => (cancellationJetIntegrand_continuous b (hδ n) hgC x).aestronglyMeasurable) |
| (Eventually.of_forall fun w => (cancellationJetIntegrand_tendsto b g x w).comp hδt) |
| apply ((cauchySchauderWeight_integrable b.rOut).const_mul ((C+3)*H)).mono' hm |
| apply Eventually.of_forall |
| intro w |
| apply le_of_tendsto (cancellationJetIntegrand_tendsto b g x w).norm |
| filter_upwards [self_mem_nhdsWithin] with d hd |
| exact cancellationJetIntegrand_bound b hC hCb hH hg hd x w |
|
|
| def bumpCurlKernel (b : ContDiffBump (0:ℂ)) (w : ℂ) : ℂ := |
| cauchyCurl (fun z : ℂ => (b z : ℂ)) w / w |
|
|
| lemma bump_complex_smooth (b : ContDiffBump (0:ℂ)) : |
| ContDiff ℝ ∞ (fun z : ℂ => (b z : ℂ)) := Complex.ofRealCLM.contDiff.comp b.contDiff |
|
|
| lemma bump_complex_compact (b : ContDiffBump (0:ℂ)) : |
| HasCompactSupport (fun z : ℂ => (b z : ℂ)) := b.hasCompactSupport.comp_left (g := (Complex.ofReal : ℝ → ℂ)) (by simp) |
|
|
| lemma bumpCurlKernel_apply (b : ContDiffBump (0:ℂ)) (z : ℂ) : |
| bumpCurlKernel b z = |
| (Complex.I * (fderiv ℝ b z 1 : ℂ) - (fderiv ℝ b z Complex.I : ℂ)) * z⁻¹ := by |
| have hd := Complex.ofRealCLM.hasFDerivAt.comp z (((b.contDiff : ContDiff ℝ ∞ b).differentiable (by simp)) z).hasFDerivAt |
| change HasFDerivAt (fun w : ℂ => (b w : ℂ)) _ z at hd |
| rw [bumpCurlKernel,cauchyCurl,hd.fderiv,div_eq_mul_inv] |
| rfl |
|
|
| lemma bumpCurlKernel_integrable (b : ContDiffBump (0:ℂ)) : Integrable (bumpCurlKernel b) := |
| cauchyCurl_div_integrable (bump_complex_smooth b) (bump_complex_compact b) |
|
|
| lemma bumpCurlKernel_integral (b : ContDiffBump (0:ℂ)) : |
| (∫ w : ℂ, bumpCurlKernel b w) = -(2*Real.pi*Complex.I) := by |
| have h := cauchy_green_fundamental (bump_complex_smooth b) (bump_complex_compact b) |
| simpa only [bumpCurlKernel, b.one_of_mem_closedBall (Metric.mem_closedBall_self b.rIn_pos.le), Complex.ofReal_one, mul_one] using h |
|
|
| lemma cutoffCauchyJet_curl (b : ContDiffBump (0:ℂ)) {z : ℂ} (hz : z ≠ 0) : |
| curlJet (cutoffCauchyJet b 0 z) = bumpCurlKernel b z := by |
| rw [cutoffCauchyJet, map_add, map_smul,regularizedCauchyJet_curl_zero hz,smul_zero,zero_add] |
| rw [curlJet_apply, smoothCauchyKernel_zero,bumpCurlKernel_apply] |
| simp only [ContinuousLinearMap.smulRight_apply, Complex.real_smul,smul_eq_mul] |
| ring |
|
|
| lemma tailCauchyJet_curl {z : ℂ} (hz : z ≠ 0) : |
| curlJet (tailCauchyJet 0 z) = -bumpCurlKernel schauderBump z := by |
| have he : scaledSchauderBump 1 = schauderBump := by funext w; simp [scaledSchauderBump] |
| rw [tailCauchyJet,he,map_sub,map_smul,regularizedCauchyJet_curl_zero hz,smul_zero,zero_sub] |
| rw [curlJet_apply,smoothCauchyKernel_zero,bumpCurlKernel_apply] |
| simp only [ContinuousLinearMap.smulRight_apply, Complex.real_smul,smul_eq_mul] |
| ring |
|
|
| omit [CompleteSpace E] in |
| lemma curlJet_smulComp (A : ℂ →L[ℝ] ℂ) (v : E) : |
| curlJet (((ContinuousLinearMap.lsmul ℝ ℂ).flip v).comp A) = curlJet A • v := by |
| simp only [curlJet_apply, ContinuousLinearMap.comp_apply,ContinuousLinearMap.flip_apply, |
| ContinuousLinearMap.lsmul_apply, smul_smul,sub_smul,smul_eq_mul] |
|
|
| lemma cutoffCauchyDerivative_curl (b : ContDiffBump (0:ℂ)) {g : ℂ → E} |
| (hgC : Continuous g) {H : ℝ} (hH : 0 ≤ H) |
| (hg : ∀ x y, ‖g x-g y‖ ≤ H*‖x-y‖^((1:ℝ)/3)) (x : ℂ) : |
| curlJet (cutoffCauchyDerivative b g x) = |
| ∫ w : ℂ, bumpCurlKernel b w • (g (x-w)-g x) := by |
| rw [cutoffCauchyDerivative, ← (curlJet (E := E)).integral_comp_comm |
| (cancellationJetIntegrand_integrable b hgC hH hg x)] |
| apply integral_congr_ae |
| filter_upwards [volume.ae_ne (0:ℂ)] with w hw |
| rw [cancellationJetIntegrand,curlJet_smulComp,cutoffCauchyJet_curl b hw] |
|
|
| omit [CompleteSpace E] in |
| lemma tailIntegralJet_integrable {g : ℂ → E} (hgC : Continuous g) (hi : Integrable g) (x : ℂ) : |
| Integrable (tailIntegralJet g x) := by |
| obtain ⟨A,B,hA,hB,hjet,hL⟩ := tailCauchyKernel_bounds |
| exact (hi.norm.const_mul A).mono' (tailIntegralJet_continuous hgC x).aestronglyMeasurable |
| (Eventually.of_forall fun w => tailIntegralJet_bound hA (fun z => (hjet z).2) g x w) |
|
|
| lemma tailCauchyDerivative_curl {g : ℂ → E} (hgC : Continuous g) (hi : Integrable g) (x : ℂ) : |
| curlJet (tailCauchyDerivative g x) = -(∫ w : ℂ, bumpCurlKernel schauderBump w • g (x-w)) := by |
| rw [tailCauchyDerivative, ← (curlJet (E := E)).integral_comp_comm (tailIntegralJet_integrable hgC hi x)] |
| rw [← integral_sub_left_eq_self _ volume x] |
| rw [← integral_neg] |
| apply integral_congr_ae |
| filter_upwards [volume.ae_ne (0:ℂ)] with w hw |
| rw [tailIntegralJet,curlJet_smulComp,sub_sub_cancel,tailCauchyJet_curl hw,neg_smul] |
|
|
| omit [CompleteSpace E] in |
| lemma bumpCurlKernel_smul_integrable (b : ContDiffBump (0:ℂ)) {g : ℂ → E} |
| (hgC : Continuous g) (x : ℂ) : Integrable (fun w : ℂ => bumpCurlKernel b w • g (x-w)) := by |
| have hc := cauchyCurl_compact (bump_complex_compact b) |
| have hs := cauchyCurl_smooth (bump_complex_smooth b) |
| have hi := locallyIntegrable_complex_inv.integrable_smul_right_of_hasCompactSupport |
| (hs.continuous.smul (hgC.comp (continuous_const.sub continuous_id))) |
| (hc.smul_right (f' := fun w => g (x-w))) |
| convert! hi using 1 |
| funext w |
| change (cauchyCurl (fun z : ℂ => (b z : ℂ)) w / w) • g (x-w) = |
| w⁻¹ • (cauchyCurl (fun z : ℂ => (b z : ℂ)) w • g (x-w)) |
| rw [div_eq_mul_inv,smul_smul,mul_comm] |
|
|
| lemma globalCauchyDerivative_curl {g : ℂ → E} (hgC : Continuous g) (hi : Integrable g) |
| {H : ℝ} (hH : 0 ≤ H) (hg : ∀ x y, ‖g x-g y‖ ≤ H*‖x-y‖^((1:ℝ)/3)) (x : ℂ) : |
| curlJet (globalCauchyDerivative g x) = (2*Complex.I) • g x := by |
| rw [globalCauchyDerivative,curlJet_smul,map_add, |
| cutoffCauchyDerivative_curl schauderBump hgC hH hg x,tailCauchyDerivative_curl hgC hi x] |
| simp_rw [smul_sub] |
| rw [integral_sub (bumpCurlKernel_smul_integrable schauderBump hgC x) |
| ((bumpCurlKernel_integrable schauderBump).smul_const (g x)),integral_smul_const, |
| bumpCurlKernel_integral] |
| have he : (∫ w : ℂ, bumpCurlKernel schauderBump w • g (x-w)) - |
| (-(2*Real.pi*Complex.I)) • g x + -(∫ w : ℂ, bumpCurlKernel schauderBump w • g (x-w)) = |
| (2*Real.pi*Complex.I) • g x := by rw [neg_smul]; abel |
| rw [he,smul_smul] |
| congr 1 |
| field_simp [Real.pi_ne_zero] |
|
|
| lemma cauchyTransform_holder_curl {g : ℂ → E} (hgC : Continuous g) (hi : Integrable g) |
| {H : ℝ} (hH : 0 ≤ H) (hg : ∀ x y, ‖g x-g y‖ ≤ H*‖x-y‖^((1:ℝ)/3)) (x : ℂ) : |
| Complex.I • fderiv ℝ (cauchyTransform g) x 1 - |
| fderiv ℝ (cauchyTransform g) x Complex.I = (2*Complex.I) • g x := by |
| rw [(cauchyTransform_holder_hasFDerivAt hgC hi hH hg x).fderiv] |
| exact globalCauchyDerivative_curl hgC hi hH hg x |
|
|
| end HigherDimensionalBallPacking.Rigidity |
| end |
|
|
| end OAI |
|
|
