| import OAI.Analysis.HenonEmden.CapMismatch |
|
|
| namespace OAI |
|
|
| universe uE uE2 uE3 uE4 uE5 uE6 |
|
|
| section Gradients |
| open Set Filter Topology MeasureTheory MeasureTheory.Measure |
| open scoped RealInnerProductSpace ContDiff ENNReal Convolution Pointwise |
| noncomputable section |
| open HenonLaneEmden.RadialCalculus HenonLaneEmden.WeakPDE HenonLaneEmden.SphereCalculus |
|
|
| namespace HenonLaneEmden.WeakPDE |
| variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
|
|
| noncomputable def kernelDir (e x : E) : ℝ := |
| (2-(Module.finrank ℝ E:ℝ))*‖x‖^(-(Module.finrank ℝ E:ℝ))*⟪x,e⟫ |
|
|
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma hasFDerivAt_kernel {x : E} (hx : x ≠ 0) : |
| HasFDerivAt (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))) |
| (((2-(Module.finrank ℝ E:ℝ))*‖x‖^(-(Module.finrank ℝ E:ℝ))) • innerSL ℝ x) x := by |
| have hr := norm_pos_iff.mpr hx |
| have hd := RadialCalculus.hasFDerivAt_profile_norm hx |
| (Real.hasDerivAt_rpow_const (p := 2-(Module.finrank ℝ E:ℝ)) (Or.inl hr.ne')) |
| convert hd using 1 |
| congr 1 |
| rw [mul_div_assoc] |
| congr 1 |
| calc |
| _ = ‖x‖^(2-(Module.finrank ℝ E:ℝ)-1-1) := by congr 1; ring |
| _ = _ := by rw [Real.rpow_sub hr,Real.rpow_one] |
|
|
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma dir_kernel {e x : E} (hx : x ≠ 0) : |
| dir (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))) e x = kernelDir e x := by |
| rw [dir,(hasFDerivAt_kernel hx).fderiv] |
| rfl |
|
|
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma kernelDir_bound (e x : E) : |
| |kernelDir e x| ≤ |2-(Module.finrank ℝ E:ℝ)| *‖e‖*‖x‖^(1-(Module.finrank ℝ E:ℝ)) := by |
| by_cases hx : x = 0 |
| · simp only [hx,kernelDir,inner_zero_left,mul_zero,abs_zero,norm_zero] |
| positivity |
| have hr := norm_pos_iff.mpr hx |
| unfold kernelDir |
| rw [abs_mul,abs_mul,abs_of_nonneg (Real.rpow_nonneg (norm_nonneg _) _)] |
| have he : ‖x‖^(-(Module.finrank ℝ E:ℝ))*‖x‖ = ‖x‖^(1-(Module.finrank ℝ E:ℝ)) := by |
| calc |
| _ = ‖x‖^(-(Module.finrank ℝ E:ℝ)+1) := by rw [Real.rpow_add hr,Real.rpow_one] |
| _ = _ := by congr 1; ring |
| calc |
| _ ≤ (|2-(Module.finrank ℝ E:ℝ)| *‖x‖^(-(Module.finrank ℝ E:ℝ)))*(‖x‖*‖e‖) := |
| mul_le_mul_of_nonneg_left (abs_real_inner_le_norm x e) (by positivity) |
| _ = |2-(Module.finrank ℝ E:ℝ)| *‖e‖*(‖x‖^(-(Module.finrank ℝ E:ℝ))*‖x‖) := by ring |
| _ = _ := by rw [he] |
|
|
| lemma measurable_kernelDir (e : E) : Measurable (kernelDir e) := |
| (measurable_const.mul (measurable_norm.pow_const _)).mul (by fun_prop) |
|
|
| lemma locallyIntegrable_kernelDir (hn : 1 ≤ Module.finrank ℝ E) (e : E) : |
| LocallyIntegrable (kernelDir e) := by |
| apply locallyIntegrable_of_norm_le_rpow hn |
| (α := (Module.finrank ℝ E:ℝ)-1) (C := |2-(Module.finrank ℝ E:ℝ)| *‖e‖) (by linarith) |
| ?_ (measurable_kernelDir e).aestronglyMeasurable |
| apply Eventually.of_forall |
| intro x |
| simpa only [Real.norm_eq_abs,neg_sub] using kernelDir_bound e x |
|
|
| lemma integral_kernel_dir_off_zero (hn : 1 ≤ Module.finrank ℝ E) {φ : E → ℝ} |
| (hφ : ContDiff ℝ 2 φ) (hc : HasCompactSupport φ) (h0 : 0 ∉ tsupport φ) (e : E) : |
| (∫ x, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir φ e x) = -(∫ x, kernelDir e x*φ x) := by |
| have hK := locallyIntegrable_newtonKernel hn |
| have hdφ : Continuous (dir φ e) := (contDiffOn_univ.mp |
| (contDiffOn_dir (k := 1) hφ.contDiffOn isOpen_univ e)).continuous |
| have hi := (locallyIntegrable_kernelDir hn e).integrable_smul_right_of_hasCompactSupport hφ.continuous hc |
| have heq : (fun x => dir (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))) e x*φ x) = |
| (fun x => kernelDir e x*φ x) := by |
| ext x |
| by_cases hx : x = 0 |
| · simp [hx,image_eq_zero_of_notMem_tsupport h0] |
| · rw [dir_kernel hx] |
| have hh := integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable |
| (μ := volume) (v := e) (f := fun x : E => ‖x‖^(2-(Module.finrank ℝ E:ℝ))) (g := φ) |
| (by change Integrable (fun x => dir (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))) e x*φ x); rw [heq]; exact hi) |
| (hK.integrable_smul_right_of_hasCompactSupport hdφ (compactSupport_dir hc e)) |
| (hK.integrable_smul_right_of_hasCompactSupport hφ.continuous hc) |
| (fun x hx => (hasFDerivAt_kernel (fun he => h0 (he ▸ hx))).differentiableAt) |
| (fun x _ => hφ.differentiable (by norm_num) x) |
| change (∫ x, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir φ e x) = -(∫ x, dir (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))) e x*φ x) at hh |
| rwa [heq] at hh |
| end HenonLaneEmden.WeakPDE |
|
|
| namespace HenonLaneEmden.WeakPDE |
| variable {E : Type uE2} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [Nontrivial E] [MeasurableSpace E] [BorelSpace E] |
|
|
| lemma kernel_cutoff_derivative_tendsto_zero (hn : 1 ≤ Module.finrank ℝ E) {φ : E → ℝ} |
| (hφ : Continuous φ) (hc : HasCompactSupport φ) (ξ : ContDiffBump (0:E)) (e : E) : |
| Tendsto (fun R : ℝ => ∫ x : E, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*φ x* |
| (R⁻¹*dir ξ e (R⁻¹ • x))) (𝓝[>] 0) (𝓝 0) := by |
| have hdξ : Continuous (dir ξ e) := (contDiffOn_univ.mp |
| (contDiffOn_dir (k := 1) (ξ.contDiff.of_le (by exact WithTop.coe_le_coe.mpr le_top)).contDiffOn isOpen_univ e)).continuous |
| obtain ⟨M,hM⟩ := (compactSupport_dir ξ.hasCompactSupport e).exists_bound_of_continuous hdξ |
| have hM0 : 0 ≤ M := (norm_nonneg (dir ξ e 0)).trans (hM 0) |
| have hi : Integrable (fun x : E => ‖x‖^(1-(Module.finrank ℝ E:ℝ))*φ x) := |
| (locallyIntegrable_norm_power hn _ (by linarith)).integrable_smul_right_of_hasCompactSupport hφ hc |
| have hlim := tendsto_integral_filter_of_dominated_convergence |
| (μ := volume) (l := 𝓝[>] (0:ℝ)) |
| (F := fun (R : ℝ) (x : E) => ‖x‖^(2-(Module.finrank ℝ E:ℝ))*φ x*(R⁻¹*dir ξ e (R⁻¹ • x))) |
| (f := fun _ => (0:ℝ)) (fun x => (M*ξ.rOut)*‖‖x‖^(1-(Module.finrank ℝ E:ℝ))*φ x‖) |
| (Eventually.of_forall fun R => by |
| exact (((measurable_norm.pow_const _).mul hφ.measurable).mul |
| (measurable_const.mul (hdξ.measurable.comp (measurable_const.smul measurable_id)))).aestronglyMeasurable) |
| ?_ (hi.norm.const_mul (M*ξ.rOut)) ?_ |
| · simpa only [integral_zero] using hlim |
| · filter_upwards [self_mem_nhdsWithin] with R hR |
| filter_upwards [ae_iff.mpr (show volume {x : E | ¬ x ≠ 0} = 0 by simp)] with x hx |
| by_cases hd : dir ξ e (R⁻¹ • x) = 0 |
| · simp only [hd,mul_zero,norm_zero] |
| exact mul_nonneg (mul_nonneg hM0 ξ.rOut_pos.le) (norm_nonneg _) |
| have hs := tsupport_dir_subset (ξ : E → ℝ) e (subset_tsupport _ hd) |
| rw [ξ.tsupport_eq] at hs |
| have hnorm : R⁻¹*‖x‖ ≤ ξ.rOut := by |
| simpa only [Metric.mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr (show 0 < R from hR))] using hs |
| have hrx := norm_pos_iff.mpr hx |
| have hb : R⁻¹ ≤ ξ.rOut/‖x‖ := (le_div_iff₀ hrx).mpr hnorm |
| have hh : |R⁻¹*dir ξ e (R⁻¹ • x)| ≤ M*ξ.rOut/‖x‖ := by |
| rw [abs_mul,abs_of_pos (inv_pos.mpr hR)] |
| have hm' : |dir ξ e (R⁻¹ • x)| ≤ M := by simpa only [Real.norm_eq_abs] using hM (R⁻¹ • x) |
| calc |
| _ ≤ R⁻¹*M := mul_le_mul_of_nonneg_left hm' (inv_pos.mpr hR).le |
| _ ≤ (ξ.rOut/‖x‖)*M := mul_le_mul_of_nonneg_right hb hM0 |
| _ = _ := by ring |
| rw [norm_mul,Real.norm_eq_abs (R⁻¹*_),norm_mul,Real.norm_eq_abs (‖x‖^_),abs_of_nonneg (Real.rpow_nonneg (norm_nonneg _) _)] |
| apply (mul_le_mul_of_nonneg_left hh (mul_nonneg (Real.rpow_nonneg (norm_nonneg _) _) (norm_nonneg _))).trans_eq |
| rw [norm_mul,Real.norm_eq_abs (‖x‖^_),abs_of_nonneg (Real.rpow_nonneg (norm_nonneg _) _)] |
| have he : ‖x‖^(2-(Module.finrank ℝ E:ℝ))/‖x‖ = ‖x‖^(1-(Module.finrank ℝ E:ℝ)) := by |
| calc |
| _ = ‖x‖^(2-(Module.finrank ℝ E:ℝ)-1) := by rw [Real.rpow_sub hrx (2-(Module.finrank ℝ E:ℝ)) 1,Real.rpow_one] |
| _ = _ := by congr 1; ring |
| calc |
| _ = (M*ξ.rOut)*(‖x‖^(2-(Module.finrank ℝ E:ℝ))/‖x‖)*‖φ x‖ := by ring |
| _ = _ := by rw [he]; ring |
| · filter_upwards [ae_iff.mpr (show volume {x : E | ¬ x ≠ 0} = 0 by simp)] with x hx |
| have he : 0 < ‖x‖/ξ.rOut := div_pos (norm_pos_iff.mpr hx) ξ.rOut_pos |
| apply tendsto_const_nhds.congr' |
| filter_upwards [self_mem_nhdsWithin,(eventually_lt_nhds he).filter_mono nhdsWithin_le_nhds] with R hR hlt |
| have hs : R⁻¹ • x ∉ tsupport (ξ : E → ℝ) := by |
| rw [ξ.tsupport_eq,Metric.mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hR)] |
| apply not_le_of_gt |
| rw [← div_eq_inv_mul] |
| apply (lt_div_iff₀ hR).mpr |
| simpa only [mul_comm] using (lt_div_iff₀ ξ.rOut_pos).mp hlt |
| simp only [dir,fderiv_of_notMem_tsupport ℝ hs,_root_.zero_apply,mul_zero] |
| end HenonLaneEmden.WeakPDE |
|
|
| namespace HenonLaneEmden.WeakPDE |
| variable {E : Type uE3} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [Nontrivial E] [MeasurableSpace E] [BorelSpace E] |
|
|
| lemma kernel_dir_cutoff_tendsto_zero (hn : 1 ≤ Module.finrank ℝ E) {φ : E → ℝ} |
| (hφ : ContDiff ℝ 2 φ) (hc : HasCompactSupport φ) (ξ : ContDiffBump (0:E)) (e : E) : |
| Tendsto (fun R : ℝ => ∫ x : E, ‖x‖^(2-(Module.finrank ℝ E:ℝ))* |
| dir (fun y => φ y*ξ (R⁻¹ • y)) e x) (𝓝[>] 0) (𝓝 0) := by |
| have hK := locallyIntegrable_newtonKernel hn |
| have hdφ : Continuous (dir φ e) := (contDiffOn_univ.mp |
| (contDiffOn_dir (k := 1) hφ.contDiffOn isOpen_univ e)).continuous |
| have hdξ : Continuous (dir ξ e) := (contDiffOn_univ.mp |
| (contDiffOn_dir (k := 1) (ξ.contDiff.of_le (by exact WithTop.coe_le_coe.mpr le_top)).contDiffOn isOpen_univ e)).continuous |
| have heq (R : ℝ) : (∫ x : E, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir (fun y => φ y*ξ (R⁻¹ • y)) e x) = |
| (∫ x : E, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*(dir φ e x*ξ (R⁻¹ • x))) + |
| (∫ x : E, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*φ x*(R⁻¹*dir ξ e (R⁻¹ • x))) := by |
| have hξR : Differentiable ℝ (fun y : E => ξ (R⁻¹ • y)) := |
| ((ξ.contDiff : ContDiff ℝ 2 ξ).comp (contDiff_const.smul contDiff_id)).differentiable (by norm_num) |
| simp_rw [dir_mul (hφ.differentiable (by norm_num) _) (hξR _) e,dir_dilation,mul_add,← mul_assoc] |
| apply integral_add |
| · simpa only [smul_eq_mul, Pi.mul_apply, Function.comp_apply, Pi.smul_apply, id_eq, mul_assoc] using |
| hK.integrable_smul_right_of_hasCompactSupport |
| (hdφ.mul (ξ.continuous.comp (continuous_id.const_smul R⁻¹))) (compactSupport_dir hc e).mul_right |
| · simpa only [smul_eq_mul, Pi.mul_apply, Function.comp_apply, Pi.smul_apply, id_eq, mul_assoc] using |
| hK.integrable_smul_right_of_hasCompactSupport |
| (hφ.continuous.mul ((continuous_const : Continuous (fun _ : E => R⁻¹)).mul |
| (hdξ.comp (continuous_id.const_smul R⁻¹)))) hc.mul_right |
| simp_rw [heq] |
| simpa only [add_zero] using (cutoff_source_integral_tendsto_zero hK hdφ (compactSupport_dir hc e) ξ).add |
| (kernel_cutoff_derivative_tendsto_zero hn hφ.continuous hc ξ e) |
|
|
| lemma integral_kernel_dir (hn : 1 ≤ Module.finrank ℝ E) {φ : E → ℝ} |
| (hφ : ContDiff ℝ 2 φ) (hc : HasCompactSupport φ) (e : E) : |
| (∫ x, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir φ e x) = -(∫ x, kernelDir e x*φ x) := by |
| let ξ : ContDiffBump (0:E) := ⟨1,2,by norm_num,by norm_num⟩ |
| have hK := locallyIntegrable_newtonKernel hn |
| have hD := locallyIntegrable_kernelDir hn e |
| have hdφ : Continuous (dir φ e) := (contDiffOn_univ.mp |
| (contDiffOn_dir (k := 1) hφ.contDiffOn isOpen_univ e)).continuous |
| have hiK := hK.integrable_smul_right_of_hasCompactSupport hdφ (compactSupport_dir hc e) |
| have hiD := hD.integrable_smul_right_of_hasCompactSupport hφ.continuous hc |
| have hevent : ∀ᶠ R : ℝ in 𝓝[>] 0, |
| (∫ x, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir φ e x) - |
| (∫ x, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir (fun y => φ y*ξ (R⁻¹ • y)) e x) = |
| -(∫ x, kernelDir e x*φ x)+(∫ x, kernelDir e x*(φ x*ξ (R⁻¹ • x))) := by |
| filter_upwards [self_mem_nhdsWithin] with R hR |
| obtain ⟨hψ,hψc,hψ0⟩ := cutoff_test_off_origin hφ hc ξ hR |
| have hh := integral_kernel_dir_off_zero hn hψ hψc hψ0 e |
| have hχ : ContDiff ℝ 2 (fun y : E => φ y*ξ (R⁻¹ • y)) := |
| hφ.mul (ξ.contDiff.comp (contDiff_const.smul contDiff_id)) |
| have hχc : HasCompactSupport (fun y : E => φ y*ξ (R⁻¹ • y)) := hc.mul_right |
| have hdχ : Continuous (dir (fun y : E => φ y*ξ (R⁻¹ • y)) e) := (contDiffOn_univ.mp |
| (contDiffOn_dir (k := 1) hχ.contDiffOn isOpen_univ e)).continuous |
| have hiχK := hK.integrable_smul_right_of_hasCompactSupport hdχ (compactSupport_dir hχc e) |
| have hiχD := hD.integrable_smul_right_of_hasCompactSupport hχ.continuous hχc |
| simp only [smul_eq_mul] at hiK hiD hiχK hiχD |
| have hid (x : E) : dir (fun y => φ y-φ y*ξ (R⁻¹ • y)) e x = |
| dir φ e x-dir (fun y => φ y*ξ (R⁻¹ • y)) e x := by |
| unfold dir |
| exact congrArg (fun L : E →L[ℝ] ℝ => L e) |
| ((hφ.differentiable (by norm_num) x).hasFDerivAt.sub |
| (hχ.differentiable (by norm_num) x).hasFDerivAt).fderiv |
| simp_rw [hid,mul_sub] at hh |
| rw [integral_sub hiK hiχK,integral_sub hiD hiχD] at hh |
| linarith |
| have hlim₁ := (tendsto_const_nhds (x := ∫ x, ‖x‖^(2-(Module.finrank ℝ E:ℝ))*dir φ e x)).sub |
| (kernel_dir_cutoff_tendsto_zero hn hφ hc ξ e) |
| have hlim₂ := (tendsto_const_nhds (x := -(∫ x, kernelDir e x*φ x))).add |
| (cutoff_source_integral_tendsto_zero hD hφ.continuous hc ξ) |
| simpa only [sub_zero,add_zero] using tendsto_nhds_unique hlim₁ (hlim₂.congr' (hevent.mono fun _ hh => hh.symm)) |
| end HenonLaneEmden.WeakPDE |
|
|
| namespace HenonLaneEmden.WeakPDE |
| variable {E : Type uE4} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
|
|
| omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in |
| lemma kernelDir_shift_bound (hn : 3 ≤ Module.finrank ℝ E) {r : ℝ} (hr : 0 < r) |
| {x x₀ y : E} (hx : ‖x-x₀‖ < r/2) (hy : r ≤ ‖x₀-y‖) (e : E) : |
| |kernelDir e (x-y)| ≤ (|2-(Module.finrank ℝ E:ℝ)| *‖e‖*(2/r)*(1/2:ℝ)^(2-(Module.finrank ℝ E:ℝ)))* |
| ‖x₀-y‖^(2-(Module.finrank ℝ E:ℝ)) := by |
| have ht := norm_sub_le (x₀-x) (y-x) |
| simp only [sub_sub_sub_cancel_right,norm_sub_rev y x,norm_sub_rev x₀ x] at ht |
| have hl : r/2 ≤ ‖x-y‖ := by linarith |
| have hp : 0 < ‖x-y‖ := lt_of_lt_of_le (half_pos hr) hl |
| have ha : 2-(Module.finrank ℝ E:ℝ) ≤ 0 := by |
| have hh : (3:ℝ) ≤ Module.finrank ℝ E := by exact_mod_cast hn |
| linarith |
| have he : ‖x-y‖^(1-(Module.finrank ℝ E:ℝ)) = ‖x-y‖^(2-(Module.finrank ℝ E:ℝ))/‖x-y‖ := by |
| calc |
| _ = ‖x-y‖^(2-(Module.finrank ℝ E:ℝ)-1) := by congr 1; ring |
| _ = _ := by rw [Real.rpow_sub hp,Real.rpow_one] |
| have hh : ‖x-y‖^(1-(Module.finrank ℝ E:ℝ)) ≤ |
| (2/r)*((1/2:ℝ)^(2-(Module.finrank ℝ E:ℝ))*‖x₀-y‖^(2-(Module.finrank ℝ E:ℝ))) := by |
| rw [he,div_eq_inv_mul] |
| apply mul_le_mul |
| · have h := one_div_le_one_div_of_le (half_pos hr) hl |
| simpa only [one_div,inv_div] using h |
| · exact rpow_kernel_shift_bound ha hr hx hy |
| · positivity |
| · positivity |
| exact (kernelDir_bound e (x-y)).trans ((mul_le_mul_of_nonneg_left hh (by positivity)).trans_eq (by ring)) |
|
|
| lemma hasLineDerivAt_far_rawPotential (hn : 3 ≤ Module.finrank ℝ E) {g : E → ℝ} |
| (hg : Measurable g) (hgp : ∀ y, 0 ≤ g y) {x₀ : E} {r : ℝ} (hr : 0 < r) |
| (hzero : ∀ y ∈ Metric.ball x₀ r, g y = 0) |
| (hi : Integrable (fun y => ‖x₀-y‖^(2-(Module.finrank ℝ E:ℝ))*g y)) (e : E) : |
| Integrable (fun y => kernelDir e (x₀-y)*g y) ∧ |
| HasLineDerivAt ℝ (rawPotential g) (∫ y, kernelDir e (x₀-y)*g y) x₀ e := by |
| let C := |2-(Module.finrank ℝ E:ℝ)| *‖e‖*(2/r)*(1/2:ℝ)^(2-(Module.finrank ℝ E:ℝ)) |
| let s : Set ℝ := {t | ‖t • e‖ < r/2} |
| have hs : s ∈ 𝓝 (0:ℝ) := by |
| apply IsOpen.mem_nhds (isOpen_lt (continuous_id.smul continuous_const).norm continuous_const) |
| simpa [s] using half_pos hr |
| have hDmeas : Measurable (fun y : E => kernelDir e (x₀-y)*g y) := |
| ((measurable_kernelDir e).comp (measurable_const.sub measurable_id)).mul hg |
| have hh := hasDerivAt_integral_of_dominated_loc_of_deriv_le |
| (μ := (volume : Measure E)) (F := fun (t : ℝ) (y : E) => ‖(x₀+t • e)-y‖^(2-(Module.finrank ℝ E:ℝ))*g y) |
| (F' := fun (t : ℝ) (y : E) => kernelDir e ((x₀+t • e)-y)*g y) |
| (bound := fun y => C*(‖x₀-y‖^(2-(Module.finrank ℝ E:ℝ))*g y)) hs |
| (Eventually.of_forall fun t => (((measurable_const.sub measurable_id).norm.pow_const _).mul hg).aestronglyMeasurable) |
| (by simpa using hi) |
| (by simpa only [zero_smul, add_zero] using hDmeas.aestronglyMeasurable) |
| ?_ (hi.const_mul C) ?_ |
| · simpa only [zero_smul,add_zero,HasLineDerivAt,rawPotential] using hh |
| · apply Eventually.of_forall |
| intro y t ht |
| by_cases hy : y ∈ Metric.ball x₀ r |
| · simp only [hzero y hy,mul_zero,norm_zero,le_refl] |
| have hyr : r ≤ ‖x₀-y‖ := by |
| have hy' : ¬ ‖y-x₀‖ < r := by simpa only [Metric.mem_ball,dist_eq_norm] using hy |
| simpa only [norm_sub_rev] using le_of_not_gt hy' |
| have htx : ‖(x₀+t • e)-x₀‖ < r/2 := by simpa only [s,Set.mem_ofPred_eq,add_sub_cancel_left] using ht |
| rw [norm_mul,Real.norm_eq_abs,Real.norm_eq_abs,abs_of_nonneg (hgp y)] |
| exact (mul_le_mul_of_nonneg_right (kernelDir_shift_bound hn hr htx hyr e) (hgp y)).trans_eq (mul_assoc _ _ _) |
| · apply Eventually.of_forall |
| intro y t ht |
| by_cases hy : y ∈ Metric.ball x₀ r |
| · simp only [hzero y hy,mul_zero] |
| exact hasDerivAt_const t 0 |
| have hyr : r ≤ ‖x₀-y‖ := by |
| have hy' : ¬ ‖y-x₀‖ < r := by simpa only [Metric.mem_ball,dist_eq_norm] using hy |
| simpa only [norm_sub_rev] using le_of_not_gt hy' |
| have hne : (x₀+t • e)-y ≠ 0 := by |
| intro he |
| have he' : y = x₀+t • e := (sub_eq_zero.mp he).symm |
| rw [he',norm_sub_rev,add_sub_cancel_left] at hyr |
| linarith [show ‖t • e‖ < r/2 from ht] |
| have haff : HasDerivAt (fun t : ℝ => (x₀+t • e)-y) e t := by |
| simpa using (((hasDerivAt_id t).smul_const e).const_add x₀).sub_const y |
| have hd := ((hasFDerivAt_kernel hne).comp_hasDerivAt t haff).mul_const (g y) |
| simpa only [_root_.smul_apply,innerSL_apply_apply,smul_eq_mul,kernelDir,Function.comp_apply] using hd |
| end HenonLaneEmden.WeakPDE |
|
|
| namespace HenonLaneEmden.WeakPDE |
| variable {E : Type uE5} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [Nontrivial E] [MeasurableSpace E] [BorelSpace E] |
|
|
| omit [FiniteDimensional ℝ E] [Nontrivial E] [MeasurableSpace E] [BorelSpace E] in |
| lemma contDiff_mul_cutoff {g ξ : E → ℝ} {s : Set E} {k : ℕ∞ω} (hs : IsOpen s) |
| (hg : ContDiffOn ℝ k g s) (hξ : ContDiff ℝ k ξ) (hξs : tsupport ξ ⊆ s) : |
| ContDiff ℝ k (fun y => ξ y*g y) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro x |
| by_cases hx : x ∈ tsupport ξ |
| · exact hξ.contDiffAt.mul (hg.contDiffAt (hs.mem_nhds (hξs hx))) |
| · apply (contDiffAt_const (c := (0:ℝ))).congr_of_eventuallyEq |
| filter_upwards [(isClosed_tsupport ξ).isOpen_compl.mem_nhds hx] with y hy |
| simp only [image_eq_zero_of_notMem_tsupport hy,zero_mul] |
|
|
| omit [Nontrivial E] in |
| lemma rawPotential_eq_convolve (g : E → ℝ) : rawPotential g = convolve (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))) g := by |
| ext x |
| rw [rawPotential,convolve_def,← integral_sub_left_eq_self (fun y : E => ‖y‖^(2-(Module.finrank ℝ E:ℝ))*g (x-y)) volume x] |
| simp only [sub_sub_cancel] |
|
|
| omit [Nontrivial E] in |
| lemma integrable_kernelDir_local (hn : 1 ≤ Module.finrank ℝ E) {g : E → ℝ} |
| (hg : Continuous g) (hc : HasCompactSupport g) (e x : E) : |
| Integrable (fun y => kernelDir e (x-y)*g y) := by |
| have hh := (locallyIntegrable_kernelDir hn e).integrable_smul_right_of_hasCompactSupport |
| (hg.comp (continuous_const.sub continuous_id)) (hc.comp_homeomorph (Homeomorph.subLeft x)) |
| have hi := (Measure.measurePreserving_sub_left volume x).integrable_comp hh.aestronglyMeasurable |
| apply hi.mpr hh |>.congr |
| exact Eventually.of_forall fun y => by simp only [Function.comp_apply,Pi.sub_apply,id_eq,sub_sub_cancel,smul_eq_mul] |
|
|
| lemma dir_rawPotential_local (hn : 1 ≤ Module.finrank ℝ E) {g : E → ℝ} |
| (hg : ContDiff ℝ 2 g) (hc : HasCompactSupport g) (e x : E) : |
| dir (rawPotential g) e x = ∫ y, kernelDir e (x-y)*g y := by |
| let φ : E → ℝ := fun z => g (x-z) |
| have hφ : ContDiff ℝ 2 φ := hg.comp (contDiff_const.sub contDiff_id) |
| have hφc : HasCompactSupport φ := hc.comp_homeomorph (Homeomorph.subLeft x) |
| have hdφ (z : E) : dir φ e z = -dir g e (x-z) := by |
| unfold dir φ |
| have hd := (hg.differentiable (by norm_num) (x-z)).hasFDerivAt.comp z |
| ((hasFDerivAt_id z).const_sub x) |
| have hfd : fderiv ℝ (fun z => g (x-z)) z = _ := hd.fderiv |
| rw [hfd] |
| simp |
| have hh := integral_kernel_dir hn hφ hφc e |
| simp_rw [hdφ,mul_neg,integral_neg] at hh |
| have hh' := neg_injective hh |
| rw [rawPotential_eq_convolve,dir_convolve (locallyIntegrable_newtonKernel hn) (hg.of_le (by norm_num)) hc,convolve_def,hh'] |
| rw [← integral_sub_left_eq_self (fun z => kernelDir e z*g (x-z)) volume x] |
| simp only [sub_sub_cancel] |
|
|
| lemma hasLineDerivAt_rawPotential_local (hn : 1 ≤ Module.finrank ℝ E) {g : E → ℝ} |
| (hg : ContDiff ℝ 2 g) (hc : HasCompactSupport g) (e x : E) : |
| HasLineDerivAt ℝ (rawPotential g) (∫ y, kernelDir e (x-y)*g y) x e := by |
| have hd : Differentiable ℝ (rawPotential g) := by |
| rw [rawPotential_eq_convolve] |
| exact (contDiff_convolve (locallyIntegrable_newtonKernel hn) hg hc).differentiable (by norm_num) |
| rw [← dir_rawPotential_local hn hg hc] |
| exact (hd x).hasFDerivAt.hasLineDerivAt e |
| end HenonLaneEmden.WeakPDE |
|
|
| namespace HenonLaneEmden.WeakPDE |
| variable {E : Type uE6} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [Nontrivial E] [MeasurableSpace E] [BorelSpace E] |
|
|
| lemma hasLineDerivAt_rawPotential (hn : 3 ≤ Module.finrank ℝ E) {g : E → ℝ} {s : Set E} |
| (hg : Measurable g) (hgp : ∀ x, 0 ≤ g x) (hs : IsOpen s) (hgc : ContDiffOn ℝ 2 g s) |
| (hi : ∀ x, Integrable (fun y => ‖x-y‖^(2-(Module.finrank ℝ E:ℝ))*g y)) |
| {x₀ : E} (hx₀ : x₀ ∈ s) (e : E) : |
| Integrable (fun y => kernelDir e (x₀-y)*g y) ∧ |
| HasLineDerivAt ℝ (rawPotential g) (∫ y, kernelDir e (x₀-y)*g y) x₀ e := by |
| obtain ⟨r,hr,hrs⟩ := Metric.mem_nhds_iff.mp (hs.mem_nhds hx₀) |
| let ξ : ContDiffBump x₀ := ⟨r/4,r/2,by linarith,by linarith⟩ |
| have hξs : tsupport ξ ⊆ s := by |
| apply Subset.trans (by rw [ξ.tsupport_eq] : tsupport ξ ⊆ Metric.closedBall x₀ ξ.rOut) |
| intro y hy |
| apply hrs |
| have hy' : dist y x₀ ≤ r/2 := hy |
| change dist y x₀ < r |
| linarith |
| let g₀ : E → ℝ := fun y => ξ y*g y |
| let g₁ : E → ℝ := fun y => (1-ξ y)*g y |
| have hg₀c : ContDiff ℝ 2 g₀ := contDiff_mul_cutoff hs hgc ξ.contDiff hξs |
| have hg₀k : HasCompactSupport g₀ := ξ.hasCompactSupport.mul_right |
| have hg₁m : Measurable g₁ := (measurable_const.sub ξ.continuous.measurable).mul hg |
| have hg₁p : ∀ y, 0 ≤ g₁ y := fun y => mul_nonneg (sub_nonneg.mpr (ξ.le_one (x := y))) (hgp y) |
| have hi₀ (x : E) := rawPotential_integrable_cutoff hg hgp ξ.continuous.measurable |
| (fun _ => ξ.nonneg) (fun _ => ξ.le_one) (hi x) |
| have hi₁ (x : E) : Integrable (fun y => ‖x-y‖^(2-(Module.finrank ℝ E:ℝ))*((1-ξ y)*g y)) := by |
| simpa only [Pi.sub_apply] using rawPotential_integrable_cutoff hg hgp |
| (measurable_const.sub ξ.continuous.measurable) (fun y => sub_nonneg.mpr (ξ.le_one (x := y))) |
| (fun y => by change 1-ξ y ≤ 1; linarith [ξ.nonneg (x := y)]) (hi x) |
| obtain ⟨hd₁,hfar⟩ := hasLineDerivAt_far_rawPotential hn hg₁m hg₁p (r := r/4) (by linarith) |
| (by intro y hy |
| have heq : ξ y = 1 := ξ.one_of_mem_closedBall (Metric.ball_subset_closedBall hy) |
| simp [g₁,heq]) (hi₁ x₀) e |
| have hd₀ := integrable_kernelDir_local (by omega : 1 ≤ Module.finrank ℝ E) hg₀c.continuous hg₀k e x₀ |
| have heqD : (fun y => kernelDir e (x₀-y)*g y) = |
| (fun y => kernelDir e (x₀-y)*g₀ y+kernelDir e (x₀-y)*g₁ y) := by |
| funext y; dsimp [g₀,g₁]; ring |
| refine ⟨?_,?_⟩ |
| · rw [heqD] |
| exact hd₀.add hd₁ |
| have heq : rawPotential g = fun x => rawPotential g₀ x+rawPotential g₁ x := by |
| ext x |
| change (∫ y, ‖x-y‖^(2-(Module.finrank ℝ E:ℝ))*g y) = |
| (∫ y, ‖x-y‖^(2-(Module.finrank ℝ E:ℝ))*(ξ y*g y)) + |
| (∫ y, ‖x-y‖^(2-(Module.finrank ℝ E:ℝ))*((1-ξ y)*g y)) |
| rw [← integral_add (hi₀ x) (hi₁ x)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun y => by ring |
| rw [heq,heqD,integral_add hd₀ hd₁] |
| exact (hasLineDerivAt_rawPotential_local (by omega) hg₀c hg₀k e x₀).add hfar |
| end HenonLaneEmden.WeakPDE |
|
|
| namespace HenonLaneEmden |
| open WeakPDE |
| lemma IsSolution.gradient_u {n : ℕ} (hn : 2 ≤ n) {p q A B : ℝ} |
| {u v : Space n → ℝ} (h : IsSolution n p q A B u v) (hq : 0 < q) |
| {x : Space n} (hx : x ≠ 0) (e : Space n) : |
| Integrable (fun y => kernelDir e (x-y)*source v p A y) ∧ |
| newtonDenom n*dir u e x = ∫ y, kernelDir e (x-y)*source v p A y := by |
| have : Nontrivial (Space n) := Module.nontrivial_of_finrank_pos (R := ℝ) (by simp; omega) |
| obtain ⟨hi,hd⟩ := hasLineDerivAt_rawPotential (by simpa using h.dimension_ge_three hn) |
| (measurable_source h.continuous_v p A) (source_nonneg (fun y => (h.positive_v y).le) p A) |
| isOpen_compl_singleton (regular_source h.regular_v h.positive_v p A) |
| (by simpa only [finrank_euclideanSpace_fin] using h.kernel_g_integrable hn) hx e |
| refine ⟨hi,?_⟩ |
| have hu := (h.regular_u.contDiffAt (isOpen_compl_singleton.mem_nhds hx)).differentiableAt (by norm_num) |
| have hd' : HasLineDerivAt ℝ (fun y => newtonDenom n*u y) (newtonDenom n*dir u e x) x e := by |
| simpa only [dir,_root_.smul_apply,smul_eq_mul] using (hu.hasFDerivAt.const_mul (newtonDenom n)).hasLineDerivAt e |
| apply hd'.unique |
| apply hd.congr_of_eventuallyEq |
| filter_upwards [isOpen_compl_singleton.mem_nhds hx] with y hy |
| exact h.potential_u hn hq hy |
| end HenonLaneEmden |
| end |
| end Gradients |
|
|
| end OAI |
|
|
