| import Mathlib |
| import OAI.Geometry.BallPacking.Flows.TimeSteps |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped ContDiff Topology NNReal |
| open Set Metric |
| open MeasureTheory Function |
| open scoped Classical |
| theorem exists_compact_planar_primitive {f : ℝ × ℝ → ℝ} |
| (hf : ContDiff ℝ ∞ f) (hfc : HasCompactSupport f) (hf0 : (∫ p, f p) = 0) : |
| ∃ U V : ℝ × ℝ → ℝ, ContDiff ℝ ∞ U ∧ ContDiff ℝ ∞ V ∧ |
| HasCompactSupport U ∧ HasCompactSupport V ∧ |
| ∀ p, deriv (fun x => V (x,p.2)) p.1 - deriv (fun t => U (p.1,t)) p.2 = f p := by |
| obtain ⟨A,hA,hbound⟩ := hfc.isBounded.subset_ball_lt 1 (0 : ℝ × ℝ) |
| have hA0 : 0 < A := lt_trans zero_lt_one hA |
| have hfs (x t : ℝ) (ht : A ≤ |x| ∨ A ≤ |t|) : f (x,t) = 0 := by |
| by_contra hn |
| have hb := hbound (subset_tsupport f (show (x,t) ∈ support f from hn)) |
| simp only [Metric.mem_ball, dist_zero_right, Prod.norm_def, Real.norm_eq_abs, |
| max_lt_iff] at hb |
| rcases ht with ht | ht |
| · exact (not_lt_of_ge ht) hb.1 |
| · exact (not_lt_of_ge ht) hb.2 |
| let b : ContDiffBump (0 : ℝ) := ⟨A/2,A,by positivity,by linarith⟩ |
| let ρ := b.normed volume |
| have hρ : ContDiff ℝ ∞ ρ := b.contDiff_normed |
| have hρs (x : ℝ) (hx : A ≤ |x|) : ρ x = 0 := by |
| by_contra hn |
| have hb : x ∈ support (b.normed volume) := hn |
| rw [b.support_normed_eq] at hb |
| have hb' : |x| < A := by simpa only [Metric.mem_ball, dist_zero_right, Real.norm_eq_abs] using hb |
| exact (not_lt_of_ge hx) hb' |
| have hρ1 : (∫ x in -A..A, ρ x) = 1 := by |
| rw [integral_eq_full_of_box_support hρs] |
| exact b.integral_normed |
| have hg : ContDiff ℝ ∞ (planarMarginal A f) := planarMarginal_smooth hf A |
| have hgt (t : ℝ) (ht : A ≤ |t|) : planarMarginal A f t = 0 := by |
| unfold planarMarginal |
| have he : (fun x => f (x,t)) = fun _ => (0:ℝ) := funext (fun x => hfs x t (Or.inr ht)) |
| rw [he,intervalIntegral.integral_zero] |
| have hgm (t : ℝ) : planarMarginal A f t = ∫ x, f (x,t) := |
| integral_eq_full_of_box_support (fun x hx => hfs x t (Or.inl hx)) |
| have hgm0 : (∫ t in -A..A, planarMarginal A f t) = 0 := by |
| rw [integral_eq_full_of_box_support hgt] |
| simp_rw [hgm] |
| rw [← integral_prod_symm f] |
| · exact hf0 |
| · exact hf.continuous.integrable_of_hasCompactSupport hfc |
| obtain ⟨hU,hV⟩ := planarPrimitive_support hA0.le hf.continuous hρ.continuous |
| hfs hρs hρ1 hg.continuous hgm0 |
| refine ⟨planarPrimitiveX A f ρ,planarPrimitiveY A f ρ,?_,?_,hU,hV,?_⟩ |
| · exact (planarPrimitive_smooth hf hρ A).1 |
| · exact (planarPrimitive_smooth hf hρ A).2 |
| · exact fun p => planarPrimitive_curl hf.continuous hρ.continuous hg.continuous p |
|
|
| abbrev Plane := ℝ × ℝ |
|
|
| def planarArea : Plane →L[ℝ] Plane →L[ℝ] ℝ := |
| (ContinuousLinearMap.mul ℝ ℝ).bilinearComp (ContinuousLinearMap.fst ℝ ℝ ℝ) |
| (ContinuousLinearMap.snd ℝ ℝ ℝ) - |
| (ContinuousLinearMap.mul ℝ ℝ).bilinearComp (ContinuousLinearMap.snd ℝ ℝ ℝ) |
| (ContinuousLinearMap.fst ℝ ℝ ℝ) |
|
|
| @[simp] theorem planarArea_apply (v w : Plane) : planarArea v w = v.1*w.2-v.2*w.1 := rfl |
|
|
| theorem planarArea_trace_identity (A : Plane →L[ℝ] Plane) (v w : Plane) : |
| planarArea (A v) w + planarArea v (A w) = |
| ((A (1,0)).1+(A (0,1)).2) * planarArea v w := by |
| have hv : v = v.1 • ((1:ℝ),(0:ℝ)) + v.2 • ((0:ℝ),(1:ℝ)) := by ext <;> simp |
| have hw : w = w.1 • ((1:ℝ),(0:ℝ)) + w.2 • ((0:ℝ),(1:ℝ)) := by ext <;> simp |
| have ha : A v = v.1 • A (1,0) + v.2 • A (0,1) := by conv_lhs => rw [hv]; rw [map_add,map_smul,map_smul] |
| have hb : A w = w.1 • A (1,0) + w.2 • A (0,1) := by conv_lhs => rw [hw]; rw [map_add,map_smul,map_smul] |
| simp only [planarArea_apply,ha,hb,Prod.fst_add,Prod.snd_add,Prod.smul_def,smul_eq_mul] |
| ring |
|
|
| theorem smoothTransition_deriv_compact : HasCompactSupport (deriv Real.smoothTransition) := by |
| apply HasCompactSupport.intro (isCompact_Icc (a := (0:ℝ)) (b := 1)) |
| intro t ht |
| have hor : t < 0 ∨ 1 < t := by simpa only [mem_Icc,not_and_or,not_le] using ht |
| rcases hor with ht | ht |
| · have he : Real.smoothTransition =ᶠ[𝓝 t] fun _ => (0:ℝ) := by |
| filter_upwards [Iio_mem_nhds ht] with s hs |
| exact Real.smoothTransition.zero_of_nonpos hs.le |
| exact ((hasDerivAt_const t (0:ℝ)).congr_of_eventuallyEq he).deriv |
| · have he : Real.smoothTransition =ᶠ[𝓝 t] fun _ => (1:ℝ) := by |
| filter_upwards [Ioi_mem_nhds ht] with s hs |
| exact Real.smoothTransition.one_of_one_le hs.le |
| exact ((hasDerivAt_const t (1:ℝ)).congr_of_eventuallyEq he).deriv |
|
|
| def moserDensity (f : Plane → ℝ) (p : ℝ × Plane) : ℝ := |
| 1 + Real.smoothTransition p.1 * f p.2 |
|
|
| theorem moserDensity_positive {f : Plane → ℝ} (hf : ∀ x, 0 < 1+f x) (p : ℝ × Plane) : |
| 0 < moserDensity f p := by |
| have hb := Real.smoothTransition.nonneg p.1 |
| have hc := Real.smoothTransition.le_one p.1 |
| unfold moserDensity |
| by_cases hx : 0 ≤ f p.2 |
| · positivity |
| · have hx' : f p.2 < 0 := lt_of_not_ge hx |
| have hmul := mul_le_mul_of_nonpos_right hc hx'.le |
| nlinarith [hf p.2] |
|
|
| theorem moserDensity_smooth {f : Plane → ℝ} (hf : ContDiff ℝ ∞ f) : |
| ContDiff ℝ ∞ (moserDensity f) := |
| contDiff_const.add ((Real.smoothTransition.contDiff.comp contDiff_fst).mul (hf.comp contDiff_snd)) |
|
|
| def moserField (f U V : Plane → ℝ) (p : ℝ × Plane) : Plane := |
| (-(deriv Real.smoothTransition p.1) * V p.2 / moserDensity f p, |
| (deriv Real.smoothTransition p.1) * U p.2 / moserDensity f p) |
|
|
| theorem moserField_smooth {f U V : Plane → ℝ} (hf : ContDiff ℝ ∞ f) |
| (hU : ContDiff ℝ ∞ U) (hV : ContDiff ℝ ∞ V) (hpos : ∀ x, 0 < 1+f x) : |
| ContDiff ℝ ∞ (moserField f U V) := by |
| have hβ : ContDiff ℝ ∞ (deriv Real.smoothTransition) := |
| (contDiff_infty_iff_deriv.mp Real.smoothTransition.contDiff).2 |
| exact (((hβ.comp contDiff_fst).neg.mul (hV.comp contDiff_snd)).div |
| (moserDensity_smooth hf) (fun p => (moserDensity_positive hpos p).ne')).prodMk |
| (((hβ.comp contDiff_fst).mul (hU.comp contDiff_snd)).div |
| (moserDensity_smooth hf) (fun p => (moserDensity_positive hpos p).ne')) |
|
|
| theorem moserField_hasCompactSupport {f U V : Plane → ℝ} |
| (hU : HasCompactSupport U) (hV : HasCompactSupport V) : HasCompactSupport (moserField f U V) := by |
| apply HasCompactSupport.intro (smoothTransition_deriv_compact.prod (hU.union hV)) |
| intro p hp |
| have hn : p.1 ∉ tsupport (deriv Real.smoothTransition) ∨ p.2 ∉ tsupport U ∪ tsupport V := by |
| simpa only [mem_prod, not_and_or] using hp |
| rcases hn with ht | hx |
| · simp [moserField, image_eq_zero_of_notMem_tsupport ht] |
| · have hUx : U p.2 = 0 := image_eq_zero_of_notMem_tsupport (fun h => hx (Or.inl h)) |
| have hVx : V p.2 = 0 := image_eq_zero_of_notMem_tsupport (fun h => hx (Or.inr h)) |
| simp [moserField,hUx,hVx] |
|
|
| 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 |
|
|
| theorem hasDerivAt_horizontal_first {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : ℝ × Plane → E} (hF : Differentiable ℝ F) (p : ℝ × Plane) : |
| HasDerivAt (fun x => F (p.1,(x,p.2.2))) (fderiv ℝ F p (0,(1,0))) p.2.1 := |
| (hF p).hasFDerivAt.comp_hasDerivAt p.2.1 ((hasDerivAt_const p.2.1 p.1).prodMk |
| ((hasDerivAt_id p.2.1).prodMk (hasDerivAt_const p.2.1 p.2.2))) |
|
|
| theorem hasDerivAt_horizontal_second {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : ℝ × Plane → E} (hF : Differentiable ℝ F) (p : ℝ × Plane) : |
| HasDerivAt (fun y => F (p.1,(p.2.1,y))) (fderiv ℝ F p (0,(0,1))) p.2.2 := |
| (hF p).hasFDerivAt.comp_hasDerivAt p.2.2 ((hasDerivAt_const p.2.2 p.1).prodMk |
| ((hasDerivAt_const p.2.2 p.2.1).prodMk (hasDerivAt_id p.2.2))) |
|
|
| theorem moserField_transport {f U V : Plane → ℝ} (hf : ContDiff ℝ ∞ f) |
| (hU : ContDiff ℝ ∞ U) (hV : ContDiff ℝ ∞ V) (hpos : ∀ x, 0 < 1+f x) |
| (hcurl : ∀ p, deriv (fun x => V (x,p.2)) p.1 - deriv (fun t => U (p.1,t)) p.2 = f p) |
| (p : ℝ × Plane) (v w : Plane) : |
| fderiv ℝ (moserDensity f) p (1,moserField f U V p) * planarArea v w + |
| moserDensity f p * (planarArea (fderiv ℝ (moserField f U V) p (0,v)) w + |
| planarArea v (fderiv ℝ (moserField f U V) p (0,w))) = 0 := by |
| let X := moserField f U V |
| let ρ := moserDensity f |
| let b := deriv Real.smoothTransition p.1 |
| let d := fderiv ℝ ρ p |
| let A := (fderiv ℝ X p).comp (ContinuousLinearMap.inr ℝ ℝ Plane) |
| have hXd : Differentiable ℝ X := (moserField_smooth hf hU hV hpos).differentiable (by simp) |
| have hρd : Differentiable ℝ ρ := (moserDensity_smooth hf).differentiable (by simp) |
| have hUd : Differentiable ℝ U := hU.differentiable (by simp) |
| have hVd : Differentiable ℝ V := hV.differentiable (by simp) |
| have hflux1 : d (0,(1,0)) * (X p).1 + ρ p * (A (1,0)).1 = |
| -b * fderiv ℝ V p.2 (1,0) := by |
| have hd := (hasDerivAt_horizontal_first hρd p).mul (hasDerivAt_horizontal_first hXd p).fst |
| have he : (fun x => ρ (p.1,(x,p.2.2)) * (X (p.1,(x,p.2.2))).1) = |
| fun x => -b * V (x,p.2.2) := by |
| funext x |
| dsimp [X,ρ,moserField,b] |
| field_simp [(moserDensity_positive hpos (p.1,(x,p.2.2))).ne'] |
| change HasDerivAt (fun x => ρ (p.1,(x,p.2.2)) * (X (p.1,(x,p.2.2))).1) _ p.2.1 at hd |
| rw [he] at hd |
| have hd' := ((hVd p.2).hasFDerivAt.comp_hasDerivAt p.2.1 |
| ((hasDerivAt_id p.2.1).prodMk (hasDerivAt_const p.2.1 p.2.2))).const_mul (-b) |
| exact hd.unique hd' |
| have hflux2 : d (0,(0,1)) * (X p).2 + ρ p * (A (0,1)).2 = |
| b * fderiv ℝ U p.2 (0,1) := by |
| have hd := (hasDerivAt_horizontal_second hρd p).mul (hasDerivAt_horizontal_second hXd p).snd |
| have he : (fun y => ρ (p.1,(p.2.1,y)) * (X (p.1,(p.2.1,y))).2) = |
| fun y => b * U (p.2.1,y) := by |
| funext y |
| dsimp [X,ρ,moserField,b] |
| field_simp [(moserDensity_positive hpos (p.1,(p.2.1,y))).ne'] |
| change HasDerivAt (fun y => ρ (p.1,(p.2.1,y)) * (X (p.1,(p.2.1,y))).2) _ p.2.2 at hd |
| rw [he] at hd |
| have hd' := ((hUd p.2).hasFDerivAt.comp_hasDerivAt p.2.2 |
| ((hasDerivAt_const p.2.2 p.2.1).prodMk (hasDerivAt_id p.2.2))).const_mul b |
| exact hd.unique hd' |
| have ht : d (1,(0,0)) = b * f p.2 := by |
| have hd := (hρd p).hasFDerivAt.comp_hasDerivAt p.1 |
| ((hasDerivAt_id p.1).prodMk (hasDerivAt_const p.1 p.2)) |
| have hβ : ContDiff ℝ ∞ Real.smoothTransition := Real.smoothTransition.contDiff |
| have hb := (hβ.differentiable (by simp) p.1).hasDerivAt |
| have hd' := (hb.mul_const (f p.2)).const_add 1 |
| exact hd.unique hd' |
| have hc : fderiv ℝ V p.2 (1,0) - fderiv ℝ U p.2 (0,1) = f p.2 := by |
| simpa only [plane_deriv_first hVd,plane_deriv_second hUd] using hcurl p.2 |
| have hlin : d (1,X p) = d (1,(0,0)) + (X p).1 * d (0,(1,0)) + (X p).2 * d (0,(0,1)) := by |
| have he : ((1:ℝ),X p) = ((1:ℝ),(0:Plane)) + |
| (X p).1 • ((0:ℝ),((1:ℝ),(0:ℝ))) + (X p).2 • ((0:ℝ),((0:ℝ),(1:ℝ))) := by |
| ext <;> simp |
| conv_lhs => rw [he] |
| simp only [map_add,map_smul,smul_eq_mul] |
| rfl |
| have hdiv : d (1,X p) + ρ p * ((A (1,0)).1+(A (0,1)).2) = 0 := by |
| rw [hlin] |
| linear_combination hflux1 + hflux2 + ht - b * hc |
| change d (1,X p) * planarArea v w + ρ p * (planarArea (A v) w + planarArea v (A w)) = 0 |
| rw [planarArea_trace_identity] |
| linear_combination (planarArea v w) * hdiv |
|
|
| theorem exists_planar_moser_correction {f : Plane → ℝ} (hf : ContDiff ℝ ∞ f) |
| (hfc : HasCompactSupport f) (hf0 : (∫ p, f p) = 0) (hpos : ∀ x, 0 < 1+f x) : |
| ∃ Φ : Plane ≃ₜ Plane, ContDiff ℝ ∞ Φ ∧ ContDiff ℝ ∞ Φ.symm ∧ |
| HasCompactSupport (fun x => Φ x - x) ∧ |
| ∀ x v w, (1+f (Φ x)) * planarArea (fderiv ℝ Φ x v) (fderiv ℝ Φ x w) = planarArea v w := by |
| obtain ⟨U,V,hU,hV,hUc,hVc,hcurl⟩ := exists_compact_planar_primitive hf hfc hf0 |
| have hXs := moserField_smooth hf hU hV hpos |
| have hXc := moserField_hasCompactSupport (f := f) hUc hVc |
| obtain ⟨L,hL⟩ := ContDiff.lipschitzWith_of_hasCompactSupport hXc hXs (by simp) |
| let X : C(ℝ × Plane,Plane) := ⟨moserField f U V,hXs.continuous⟩ |
| let K := tsupport U ∪ tsupport V |
| have hK : IsCompact K := hUc.union hVc |
| have hfix (t : ℝ) (x : Plane) (hx : x ∉ K) : X (t,x) = 0 := by |
| have hu : U x = 0 := image_eq_zero_of_notMem_tsupport (fun h => hx (Or.inl h)) |
| have hv : V x = 0 := image_eq_zero_of_notMem_tsupport (fun h => hx (Or.inr h)) |
| change moserField f U V (t,x) = 0 |
| simp [moserField,hu,hv] |
| obtain ⟨Φ,hΦ,hΦi,_,hΦc,hΦarea⟩ := exists_density_transport X hL hXs |
| (moserDensity f) (moserDensity_smooth hf) planarArea |
| (moserField_transport hf hU hV hpos hcurl) K hK hfix 0 1 |
| refine ⟨Φ,hΦ,hΦi,hΦc,?_⟩ |
| intro x v w |
| simpa only [zero_add,moserDensity,Real.smoothTransition.one,Real.smoothTransition.zero, |
| one_mul,zero_mul,add_zero] using hΦarea x v w |
|
|
| def planarCurl (alpha : Plane → Plane →L[ℝ] ℝ) (p : Plane) : ℝ := |
| fderiv ℝ alpha p (1,0) (0,1) - fderiv ℝ alpha p (0,1) (1,0) |
|
|
| 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 periodicPrimitive (a : ℝ → ℝ) (t : ℝ) := ∫ s in -Real.pi..t, a s |
|
|
| theorem periodicPrimitive_hasDerivAt {a : ℝ → ℝ} (ha : Continuous a) (t : ℝ) : |
| HasDerivAt (periodicPrimitive a) (a t) t := by |
| exact intervalIntegral.integral_hasDerivAt_right (ha.intervalIntegrable _ _) |
| ha.aestronglyMeasurable.stronglyMeasurableAtFilter ha.continuousAt |
|
|
| theorem periodicPrimitive_smooth {a : ℝ → ℝ} (ha : ContDiff ℝ ∞ a) : |
| ContDiff ℝ ∞ (periodicPrimitive a) := by |
| apply contDiff_infty_iff_deriv.mpr |
| refine ⟨fun t => (periodicPrimitive_hasDerivAt ha.continuous t).differentiableAt,?_⟩ |
| have he : deriv (periodicPrimitive a) = a := funext fun t => |
| (periodicPrimitive_hasDerivAt ha.continuous t).deriv |
| rw [he] |
| exact ha |
|
|
| theorem periodicPrimitive_periodic {a : ℝ → ℝ} (ha : Continuous a) |
| (hp : Periodic a (2*Real.pi)) (hz : (∫ s in -Real.pi..Real.pi, a s) = 0) : |
| Periodic (periodicPrimitive a) (2*Real.pi) := by |
| intro t |
| unfold periodicPrimitive |
| rw [hp.intervalIntegral_add_eq_add _ _ (fun s t => ha.intervalIntegrable s t)] |
| convert add_zero (∫ s in -Real.pi..t, a s) using 1 |
| congr 1 |
| convert hz using 1 |
| congr 1 |
| ring |
|
|
| theorem periodic_arg_neg {h : ℝ → ℝ} (hp : Periodic h (2*Real.pi)) {z : ℂ} |
| (hz : z ≠ 0) : h z.arg = h ((-z).arg+Real.pi) := by |
| by_cases hi : 0 < z.im ∨ z.im = 0 ∧ z.re < 0 |
| · rw [Complex.arg_neg_eq_arg_sub_pi_iff.mpr hi,sub_add_cancel] |
| · have hj : z.im < 0 ∨ z.im = 0 ∧ 0 < z.re := by |
| by_cases him : z.im = 0 |
| · right |
| refine ⟨him,?_⟩ |
| have hn : z.re ≠ 0 := fun hn => hz (Complex.ext hn him) |
| rcases lt_or_gt_of_ne hn with hn | hn |
| · exact False.elim (hi (Or.inr ⟨him,hn⟩)) |
| · exact hn |
| · exact Or.inl (lt_of_le_of_ne (le_of_not_gt (fun h => hi (Or.inl h))) him) |
| rw [Complex.arg_neg_eq_arg_add_pi_iff.mpr hj] |
| convert (hp z.arg).symm using 1 |
| congr 1 |
| ring |
|
|
| theorem contDiffAt_arg_slit {z : ℂ} (hz : z ∈ Complex.slitPlane) : |
| ContDiffAt ℝ ∞ Complex.arg z := by |
| have h := (Complex.contDiffAt_log (n := ∞) hz).restrict_scalars ℝ |
| have ht : ContDiffAt ℝ ∞ (fun x : ℂ => (Complex.log x).im) z := |
| Complex.imCLM.contDiff.contDiffAt.comp z h |
| simpa only [Complex.log_im] using ht |
|
|
| theorem periodic_arg_smooth {h : ℝ → ℝ} (hh : ContDiff ℝ ∞ h) |
| (hp : Periodic h (2*Real.pi)) {z : ℂ} (hz : z ≠ 0) : |
| ContDiffAt ℝ ∞ (fun z : ℂ => h z.arg) z := by |
| by_cases hs : z ∈ Complex.slitPlane |
| · exact hh.contDiffAt.comp z (contDiffAt_arg_slit hs) |
| · have hsneg : -z ∈ Complex.slitPlane := |
| (Complex.mem_slitPlane_or_neg_mem_slitPlane hz).resolve_left hs |
| have hd : ContDiffAt ℝ ∞ (fun w : ℂ => h ((-w).arg+Real.pi)) z := |
| hh.contDiffAt.comp z (((contDiffAt_arg_slit hsneg).comp z contDiff_neg.contDiffAt).add contDiffAt_const) |
| apply hd.congr_of_eventuallyEq |
| filter_upwards [isOpen_compl_singleton.mem_nhds hz] with w hw |
| exact periodic_arg_neg hp hw |
|
|
| theorem periodic_arg_polar {h : ℝ → ℝ} (hp : Periodic h (2*Real.pi)) |
| {R : ℝ} (hR : 0 < R) (t : ℝ) : |
| h (Complex.arg (R*(Real.cos t+Real.sin t*Complex.I))) = h t := by |
| have he := Complex.arg_mul_cos_add_sin_mul_I_sub hR t |
| simp only [← Complex.ofReal_cos, ← Complex.ofReal_sin] at he |
| have he' : Complex.arg (R*(Real.cos t+Real.sin t*Complex.I)) = |
| t + (⌊(Real.pi-t)/(2*Real.pi)⌋ : ℤ) • (2*Real.pi) := by |
| rw [zsmul_eq_mul] |
| linarith |
| rw [he'] |
| exact hp.zsmul _ t |
|
|
| def radiusSq (p : Plane) : ℝ := p.1^2+p.2^2 |
| @[fun_prop] theorem radiusSq_smooth : ContDiff ℝ ∞ radiusSq := by unfold radiusSq; fun_prop |
|
|
| @[simp] theorem radiusSq_polar (R t : ℝ) : radiusSq (polarCoord.symm (R,t)) = R^2 := by |
| simp only [radiusSq,polarCoord_symm_apply] |
| linear_combination R^2 * Real.cos_sq_add_sin_sq t |
|
|
| def angularExtension (R delta : ℝ) (hd : 0 < delta) (h : ℝ → ℝ) (p : Plane) : ℝ := |
| let b : ContDiffBump (R^2) := ⟨delta/2,delta,by positivity,by linarith⟩ |
| b (radiusSq p) * h (Complex.arg (Complex.equivRealProdCLM.symm p)) |
|
|
| theorem angularExtension_zero {R delta : ℝ} (hd : 0 < delta) (h : ℝ → ℝ) (p : Plane) |
| (hp : delta ≤ |radiusSq p-R^2|) : angularExtension R delta hd h p = 0 := by |
| let b : ContDiffBump (R^2) := ⟨delta/2,delta,by positivity,by linarith⟩ |
| change b (radiusSq p) * h (Complex.arg (Complex.equivRealProdCLM.symm p)) = 0 |
| have hb : b (radiusSq p) = 0 := b.zero_of_le_dist (by simpa only [Real.dist_eq] using hp) |
| rw [hb,zero_mul] |
|
|
| theorem angularExtension_smooth {R delta : ℝ} (hd : 0 < delta) (hdR : delta < R^2) |
| {h : ℝ → ℝ} (hh : ContDiff ℝ ∞ h) (hp : Periodic h (2*Real.pi)) : |
| ContDiff ℝ ∞ (angularExtension R delta hd h) := by |
| let b : ContDiffBump (R^2) := ⟨delta/2,delta,by positivity,by linarith⟩ |
| apply contDiff_iff_contDiffAt.mpr |
| intro p |
| by_cases h0 : p = 0 |
| · subst p |
| have hn : ∀ᶠ p : Plane in 𝓝 0, delta < |radiusSq p-R^2| := by |
| apply (isOpen_lt continuous_const ((radiusSq_smooth.continuous.sub continuous_const).abs)).mem_nhds |
| simpa [radiusSq,abs_of_nonneg (sq_nonneg R)] using hdR |
| apply (contDiffAt_const (c := (0:ℝ))).congr_of_eventuallyEq |
| filter_upwards [hn] with p hp |
| exact angularExtension_zero hd h p hp.le |
| · have hz : Complex.equivRealProdCLM.symm p ≠ 0 := by |
| intro he |
| apply h0 |
| apply Complex.equivRealProdCLM.symm.injective |
| simpa only [map_zero] using he |
| exact (b.contDiff.comp radiusSq_smooth).contDiffAt.mul |
| ((periodic_arg_smooth hh hp hz).comp p Complex.equivRealProdCLM.symm.contDiff.contDiffAt) |
|
|
| theorem angularExtension_compact {R delta : ℝ} (hd : 0 < delta) (h : ℝ → ℝ) : |
| HasCompactSupport (angularExtension R delta hd h) := by |
| apply HasCompactSupport.intro (isCompact_closedBall (0 : Plane) (R^2+delta+1)) |
| intro p hp |
| apply angularExtension_zero hd h p |
| by_contra! ht |
| have hq : radiusSq p < R^2+delta := by linarith [(abs_lt.mp ht).2] |
| apply hp |
| rw [Metric.mem_closedBall,dist_zero_right,Prod.norm_def,max_le_iff,Real.norm_eq_abs,Real.norm_eq_abs] |
| have h1 : p.1^2 ≤ radiusSq p := by dsimp [radiusSq]; nlinarith [sq_nonneg p.2] |
| have h2 : p.2^2 ≤ radiusSq p := by dsimp [radiusSq]; nlinarith [sq_nonneg p.1] |
| have hb : 0 < R^2+delta := by positivity |
| constructor |
| · nlinarith [sq_abs p.1,abs_nonneg p.1,sq_nonneg (|p.1|-1)] |
| · nlinarith [sq_abs p.2,abs_nonneg p.2,sq_nonneg (|p.2|-1)] |
|
|
| theorem angularExtension_polar {R delta : ℝ} (hR : 0 < R) (hd : 0 < delta) |
| {h : ℝ → ℝ} (hp : Periodic h (2*Real.pi)) (t : ℝ) : |
| angularExtension R delta hd h (polarCoord.symm (R,t)) = h t := by |
| let b : ContDiffBump (R^2) := ⟨delta/2,delta,by positivity,by linarith⟩ |
| change b (radiusSq (polarCoord.symm (R,t))) * _ = h t |
| have hb : b (R^2) = 1 := b.one_of_mem_closedBall (by simp only [Metric.mem_closedBall,dist_self]; exact le_of_lt b.rIn_pos) |
| rw [radiusSq_polar,hb,one_mul] |
| have he : Complex.equivRealProdCLM.symm (polarCoord.symm (R,t)) = |
| R*(Real.cos t+Real.sin t*Complex.I) := by |
| apply Complex.ext <;> simp [Complex.equivRealProdCLM_symm_apply,polarCoord_symm_apply] |
| rw [he] |
| exact periodic_arg_polar hp hR t |
|
|
| end PackingSufficiencySupport.Hamiltonian |
| end |
|
|
| end OAI |
|
|
