| import OAI.Analysis.HotSpots.Green |
|
|
| namespace OAI |
|
|
| section DouglasLipschitzBase |
| noncomputable section |
| section FullBoundaryCombinedLayer |
| section WeightedLayer |
| open Set MeasureTheory |
| open scoped ContDiff InnerProductSpace ENNReal NNReal |
| open Set Filter MeasureTheory InnerProductSpace NormedSpace |
| open scoped Topology ContDiff |
| open scoped Laplacian |
| open Set MeasureTheory Filter InnerProductSpace Bornology |
| open scoped Topology Laplacian ContDiff RealInnerProductSpace |
| open scoped Convolution |
| open Set MeasureTheory Filter InnerProductSpace |
| open scoped Topology ContDiff Convolution Laplacian |
| open InnerProductSpace |
| open scoped Laplacian ContDiff |
|
|
| open Filter Set |
| open scoped Topology |
| namespace StrictHotSpots.DiskFormula |
|
|
| def poisson (s x : ℂ) : ℝ := (1 - ‖x‖ ^ 2) / (2 * Real.pi * ‖s-x‖ ^ 2) |
|
|
| def boundaryInteraction (s t : ℂ) : ℝ := 1 / (Real.pi * ‖s-t‖ ^ 2) |
|
|
| private def logRatio (u : ℝ) : ℝ := dslope Real.log 1 (1+u) |
|
|
| private lemma logRatio_zero : logRatio 0 = 1 := by |
| simp [logRatio, Real.deriv_log] |
|
|
| private lemma logRatio_continuousAt_zero : ContinuousAt logRatio 0 := by |
| have hd : ContinuousAt (dslope Real.log 1) 1 := |
| continuousAt_dslope_same.mpr (Real.differentiableAt_log one_ne_zero) |
| exact hd.comp_of_eq (show ContinuousAt (fun t : ℝ => 1+t) 0 from |
| continuousAt_const.add continuousAt_id) (by simp) |
|
|
| private lemma log_eq_mul_ratio (u : ℝ) : Real.log (1+u) = u * logRatio u := by |
| have h := sub_smul_dslope Real.log 1 (1+u) |
| simpa [logRatio, smul_eq_mul] using h.symm |
|
|
| lemma tendsto_log_mul_div {α : Type*} {l : Filter α} {a b : α → ℝ} {B : ℝ} |
| (ha : Tendsto a l (𝓝 0)) (hb : Tendsto b l (𝓝 B)) |
| (hne : ∀ᶠ z in l, a z ≠ 0) : |
| Tendsto (fun z => Real.log (1 + a z * b z) / a z) l (𝓝 B) := by |
| have hu : Tendsto (fun z => a z * b z) l (𝓝 0) := by simpa using ha.mul hb |
| have ht := (logRatio_continuousAt_zero.tendsto.comp hu).mul hb |
| rw [logRatio_zero, one_mul] at ht |
| apply ht.congr' |
| filter_upwards [hne] with z hz |
| rw [log_eq_mul_ratio] |
| dsimp only [Function.comp_def] |
| field_simp [hz] |
| |
| lemma radial_one_formula (s x : ℂ) (hs : ‖s‖ = 1) (r : ℝ) : |
| green (r • s) x = Real.log (1 + (1-r^2) * (1-‖x‖^2) / ‖r • s-x‖^2) / |
| (4 * Real.pi) := by |
| simp only [green, norm_smul, Real.norm_eq_abs, hs, mul_one, sq_abs] |
| |
| lemma radial_one (s x : ℂ) (hs : ‖s‖ = 1) (hx : ‖x‖ < 1) : |
| Tendsto (fun r : ℝ => green (r • s) x / (1-r)) (𝓝[<] 1) (𝓝 (poisson s x)) := by |
| have hne : s-x ≠ 0 := by |
| intro h |
| have he : s = x := sub_eq_zero.mp h |
| rw [← he, hs] at hx |
| exact lt_irrefl _ hx |
| have hden : ‖s-x‖^2 ≠ 0 := pow_ne_zero _ (norm_ne_zero_iff.mpr hne) |
| have hd : ContinuousAt (fun r : ℝ => ‖r • s-x‖^2) 1 := by fun_prop |
| have hb : Tendsto (fun r : ℝ => (1+r)*(1-‖x‖^2)/‖r • s-x‖^2) |
| (𝓝[<] 1) (𝓝 (2*(1-‖x‖^2)/‖s-x‖^2)) := by |
| have hh : ContinuousAt (fun r : ℝ => (1+r)*(1-‖x‖^2)/‖r • s-x‖^2) 1 := |
| ((continuousAt_const.add continuousAt_id).mul continuousAt_const).div hd |
| (by simpa using hden) |
| convert hh.tendsto.mono_left nhdsWithin_le_nhds using 1; norm_num |
| have ha : Tendsto (fun r : ℝ => 1-r) (𝓝[<] 1) (𝓝 0) := by |
| simpa using (tendsto_const_nhds.sub (tendsto_id.mono_left nhdsWithin_le_nhds) : |
| Tendsto (fun r : ℝ => 1-r) (𝓝[<] 1) (𝓝 (1-1))) |
| have hevent : ∀ᶠ r : ℝ in 𝓝[<] 1, (1-r) ≠ 0 := by |
| filter_upwards [self_mem_nhdsWithin] with r hr |
| exact (sub_pos.mpr hr).ne' |
| have ht := (tendsto_log_mul_div ha hb hevent).div_const (4*Real.pi) |
| have hv : 2*(1-‖x‖^2)/‖s-x‖^2/(4*Real.pi) = poisson s x := by |
| simp only [poisson] |
| field_simp |
| ring |
| rw [hv] at ht |
| apply ht.congr' |
| exact Filter.Eventually.of_forall fun r => by |
| dsimp only |
| rw [radial_one_formula s x hs] |
| have he : (1-r^2)*(1-‖x‖^2)/‖r • s-x‖^2 = |
| (1-r)*((1+r)*(1-‖x‖^2)/‖r • s-x‖^2) := by ring |
| rw [he] |
| ring |
| |
| lemma radial_two_formula (s t : ℂ) (hs : ‖s‖ = 1) (ht : ‖t‖ = 1) (r : ℝ) : |
| green (r • s) (r • t) = |
| Real.log (1 + (1-r^2)^2 / (r^2 * ‖s-t‖^2)) / (4*Real.pi) := by |
| simp only [green, ← smul_sub, norm_smul, Real.norm_eq_abs, hs, ht, mul_one, |
| mul_pow, sq_abs, ← pow_two] |
| |
| lemma radial_two (s t : ℂ) (hs : ‖s‖ = 1) (ht : ‖t‖ = 1) (hne : s ≠ t) : |
| Tendsto (fun r : ℝ => green (r • s) (r • t) / (1-r)^2) |
| (𝓝[<] 1) (𝓝 (boundaryInteraction s t)) := by |
| have hden : ‖s-t‖^2 ≠ 0 := pow_ne_zero _ (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hne)) |
| have hb : Tendsto (fun r : ℝ => (1+r)^2 / (r^2 * ‖s-t‖^2)) |
| (𝓝[<] 1) (𝓝 (4 / ‖s-t‖^2)) := by |
| have hh : ContinuousAt (fun r : ℝ => (1+r)^2 / (r^2 * ‖s-t‖^2)) 1 := by |
| apply ContinuousAt.div (by fun_prop) (by fun_prop) |
| simpa using hden |
| convert hh.tendsto.mono_left nhdsWithin_le_nhds using 1; norm_num |
| have ha : Tendsto (fun r : ℝ => (1-r)^2) (𝓝[<] 1) (𝓝 0) := by |
| have hh : ContinuousAt (fun r : ℝ => (1-r)^2) 1 := by fun_prop |
| convert hh.tendsto.mono_left nhdsWithin_le_nhds using 1; norm_num |
| have hevent : ∀ᶠ r : ℝ in 𝓝[<] 1, (1-r)^2 ≠ 0 := by |
| filter_upwards [self_mem_nhdsWithin] with r hr |
| exact pow_ne_zero _ (sub_pos.mpr hr).ne' |
| have hz := (tendsto_log_mul_div ha hb hevent).div_const (4*Real.pi) |
| have hv : 4/‖s-t‖^2/(4*Real.pi) = boundaryInteraction s t := by |
| simp only [boundaryInteraction] |
| field_simp |
| rw [hv] at hz |
| apply hz.congr' |
| exact Filter.Eventually.of_forall fun r => by |
| dsimp only |
| rw [radial_two_formula s t hs ht] |
| have he : (1-r^2)^2/(r^2*‖s-t‖^2) = |
| (1-r)^2*((1+r)^2/(r^2*‖s-t‖^2)) := by ring |
| rw [he] |
| ring |
| |
| end StrictHotSpots.DiskFormula |
| |
| |
| |
| |
| open MeasureTheory Filter |
| open scoped Topology ENNReal |
| |
| |
| namespace StrictHotSpots.DiskFormula |
| open MeasureTheory |
| |
| lemma log_mul_div_bounds {a b : ℝ} (ha : 0 < a) (hb : 0 ≤ b) : |
| 0 ≤ Real.log (1+a*b)/a ∧ Real.log (1+a*b)/a ≤ b := by |
| have h1 : 1 ≤ 1+a*b := by linarith [mul_nonneg ha.le hb] |
| constructor |
| · exact div_nonneg (Real.log_nonneg h1) ha.le |
| · apply (div_le_iff₀ ha).mpr |
| have hh := Real.log_le_sub_one_of_pos (lt_of_lt_of_le zero_lt_one h1) |
| nlinarith |
| |
| lemma radial_one_bounded (s x : ℂ) (hs : ‖s‖ = 1) |
| {R rmin r : ℝ} (hR : ‖x‖ ≤ R) (hRmin : R < rmin) |
| (hrmin : rmin ≤ r) (hr : r < 1) : |
| 0 ≤ green (r • s) x / (1-r) ∧ |
| green (r • s) x / (1-r) ≤ (2/(rmin-R)^2)/(4*Real.pi) := by |
| have hR0 : 0 ≤ R := (norm_nonneg x).trans hR |
| have hr0 : 0 ≤ r := hR0.trans (hRmin.le.trans hrmin) |
| have hx1 : ‖x‖ < 1 := hR.trans_lt (hRmin.trans_le hrmin |>.trans hr) |
| have hx2 : 0 ≤ 1-‖x‖^2 := by nlinarith [norm_nonneg x] |
| have hδ : 0 < rmin-R := sub_pos.mpr hRmin |
| have hdist : rmin-R ≤ ‖r • s-x‖ := by |
| have hh := norm_sub_norm_le (r • s) x |
| rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hr0, hs, mul_one] at hh |
| linarith |
| have hdist0 : 0 < ‖r • s-x‖ := hδ.trans_le hdist |
| have hd2 : (rmin-R)^2 ≤ ‖r • s-x‖^2 := sq_le_sq₀ hδ.le (norm_nonneg _) |>.mpr hdist |
| have hnum : (1+r)*(1-‖x‖^2) ≤ 2 := by nlinarith [sq_nonneg ‖x‖] |
| have hb0 : 0 ≤ (1+r)*(1-‖x‖^2)/‖r • s-x‖^2 := by positivity |
| have hb : (1+r)*(1-‖x‖^2)/‖r • s-x‖^2 ≤ 2/(rmin-R)^2 := by |
| calc |
| _ ≤ 2/‖r • s-x‖^2 := div_le_div_of_nonneg_right hnum (sq_nonneg _) |
| _ ≤ _ := div_le_div_of_nonneg_left (by norm_num) (sq_pos_of_pos hδ) hd2 |
| have hlog := log_mul_div_bounds (sub_pos.mpr hr) hb0 |
| have he : green (r • s) x/(1-r) = |
| (Real.log (1 + (1-r)*((1+r)*(1-‖x‖^2)/‖r • s-x‖^2))/(1-r))/(4*Real.pi) := by |
| rw [radial_one_formula s x hs] |
| have hh : (1-r^2)*(1-‖x‖^2)/‖r • s-x‖^2 = |
| (1-r)*((1+r)*(1-‖x‖^2)/‖r • s-x‖^2) := by ring |
| rw [hh] |
| ring |
| rw [he] |
| exact ⟨div_nonneg hlog.1 (by positivity), |
| div_le_div_of_nonneg_right (hlog.2.trans hb) (by positivity)⟩ |
| |
| end StrictHotSpots.DiskFormula |
| |
| namespace StrictHotSpots.DiskFormula |
| open MeasureTheory |
| variable {X : Type*} [MeasurableSpace X] (ν : Measure X) [IsFiniteMeasure ν] |
| |
| lemma poisson_nonneg (s x : ℂ) (hx : ‖x‖ < 1) : 0 ≤ poisson s x := by |
| have hh : 0 ≤ 1-‖x‖^2 := by nlinarith [norm_nonneg x] |
| exact div_nonneg hh (by positivity) |
| |
| lemma poisson_bounded (s x : ℂ) (hs : ‖s‖ = 1) |
| {R : ℝ} (hR : ‖x‖ ≤ R) (hR1 : R < 1) : |
| poisson s x ≤ 1 / (2*Real.pi*(1-R)^2) := by |
| have hh := norm_sub_norm_le s x |
| rw [hs] at hh |
| have hd : 1-R ≤ ‖s-x‖ := by linarith |
| have hd0 : 0 < 1-R := sub_pos.mpr hR1 |
| have hd2 : (1-R)^2 ≤ ‖s-x‖^2 := (sq_le_sq₀ hd0.le (norm_nonneg _)).mpr hd |
| have hn : 1-‖x‖^2 ≤ 1 := by nlinarith [sq_nonneg ‖x‖] |
| unfold poisson |
| calc |
| _ ≤ 1/(2*Real.pi*‖s-x‖^2) := div_le_div_of_nonneg_right hn (by positivity) |
| _ ≤ _ := div_le_div_of_nonneg_left (by norm_num) (by positivity) |
| (mul_le_mul_of_nonneg_left hd2 (by positivity)) |
| |
| lemma poisson_memLp (s : ℂ) (hs : ‖s‖ = 1) (x : X → ℂ) (hm : Measurable x) |
| {R : ℝ} (hR : ∀ z, ‖x z‖ ≤ R) (hR1 : R < 1) : |
| MemLp (fun z => poisson s (x z)) 2 ν := by |
| refine MemLp.of_bound ?_ (1 / (2*Real.pi*(1-R)^2)) ?_ |
| · apply Measurable.aestronglyMeasurable |
| unfold poisson |
| fun_prop |
| · exact Filter.Eventually.of_forall fun z => by |
| rw [Real.norm_eq_abs, abs_of_nonneg (poisson_nonneg s (x z) ((hR z).trans_lt hR1))] |
| exact poisson_bounded s (x z) hs (hR z) hR1 |
| |
| lemma radial_one_memLp (s : ℂ) (hs : ‖s‖ = 1) (x : X → ℂ) (hm : Measurable x) |
| {R rmin r : ℝ} (hR : ∀ z, ‖x z‖ ≤ R) (hRmin : R < rmin) |
| (hrmin : rmin ≤ r) (hr : r < 1) : |
| MemLp (fun z => green (r • s) (x z)/(1-r)) 2 ν := by |
| refine MemLp.of_bound ?_ ((2/(rmin-R)^2)/(4*Real.pi)) ?_ |
| · apply Measurable.aestronglyMeasurable |
| unfold green |
| fun_prop |
| · exact Filter.Eventually.of_forall fun z => by |
| obtain ⟨h0,hb⟩ := radial_one_bounded s (x z) hs (hR z) hRmin hrmin hr |
| simpa only [Real.norm_eq_abs, abs_of_nonneg h0] using hb |
| |
| |
| |
| theorem radial_one_L2 (s : ℂ) (hs : ‖s‖ = 1) (x : X → ℂ) (hm : Measurable x) |
| {R rmin : ℝ} (hR : ∀ z, ‖x z‖ ≤ R) (hRmin : R < rmin) (hrmin1 : rmin < 1) |
| (r : ℕ → ℝ) (hrmin : ∀ n, rmin ≤ r n) (hr : ∀ n, r n < 1) |
| (hlim : Tendsto r atTop (𝓝 1)) : |
| Tendsto (fun n => (radial_one_memLp ν s hs x hm hR hRmin (hrmin n) (hr n)).toLp |
| (fun z => green (r n • s) (x z) / (1-r n))) atTop |
| (𝓝 ((poisson_memLp ν s hs x hm hR (hRmin.trans hrmin1)).toLp |
| (fun z => poisson s (x z)))) := by |
| apply L2Limits.tendsto_toLp_of_dominated |
| (hb := memLp_const ((2/(rmin-R)^2)/(4*Real.pi))) |
| · apply Filter.Eventually.of_forall |
| intro n |
| exact Filter.Eventually.of_forall fun z => by |
| obtain ⟨h0,hb⟩ := radial_one_bounded s (x z) hs (hR z) hRmin (hrmin n) (hr n) |
| simpa only [Real.norm_eq_abs, abs_of_nonneg h0] using hb |
| · exact Filter.Eventually.of_forall fun z => |
| (radial_one s (x z) hs ((hR z).trans_lt (hRmin.trans hrmin1))).comp |
| (tendsto_nhdsWithin_iff.mpr ⟨hlim, Filter.Eventually.of_forall fun n => hr n⟩) |
| |
| end StrictHotSpots.DiskFormula |
| |
| |
| |
| |
| |
| open MeasureTheory Filter Metric Set |
| open scoped Topology ENNReal |
| namespace StrictHotSpots.GreenLp |
| |
| def logPole (z : ℂ) : ℝ := Real.log (1 + 1 / ‖z‖^2) |
| |
| lemma logPole_nonneg (z : ℂ) : 0 ≤ logPole z := by |
| apply Real.log_nonneg |
| have : 0 ≤ 1 / ‖z‖^2 := one_div_nonneg.mpr (sq_nonneg _) |
| linarith |
| |
| lemma measurable_logPole : Measurable logPole := by |
| unfold logPole |
| fun_prop |
| |
| lemma logPole_cube_bound {t : ℝ} (ht : 0 < t) (ht2 : t ≤ 2) : |
| (Real.log (1 + 1/t^2))^3 ≤ 648 / t := by |
| have harg : 1 + 1/t^2 ≤ (3/t)^2 := by |
| rw [div_pow] |
| apply (le_div_iff₀ (sq_pos_of_pos ht)).2 |
| field_simp |
| nlinarith |
| have hl : Real.log (1 + 1/t^2) ≤ 2 * Real.log (3/t) := by |
| have hh := Real.log_le_log (by positivity : 0 < 1 + 1/t^2) harg |
| simpa only [Real.log_pow, Nat.cast_ofNat] using hh |
| have hp : 0 < 3/t := by positivity |
| have hr := Real.log_le_rpow_div hp.le (show 0 < (3:ℝ)⁻¹ by norm_num) |
| have he : Real.log (1 + 1/t^2) ≤ 6 * (3/t)^((3:ℝ)⁻¹) := by |
| norm_num at hr |
| linarith |
| have hnon : 0 ≤ Real.log (1 + 1/t^2) := by |
| apply Real.log_nonneg |
| have := one_div_nonneg.mpr (sq_nonneg t) |
| linarith |
| have hh := pow_le_pow_left₀ hnon he 3 |
| have hh3 : ((3/t)^((3:ℝ)⁻¹))^3 = 3/t := by |
| simpa only [Nat.cast_ofNat] using |
| Real.rpow_inv_natCast_pow hp.le (show (3:ℕ) ≠ 0 by decide) |
| rw [mul_pow, hh3] at hh |
| calc |
| _ ≤ 6^3 * (3/t) := hh |
| _ = 648/t := by ring |
| |
| lemma logPole_cube_integrable : IntegrableOn (fun z : ℂ => (logPole z)^3) (ball 0 2) := by |
| apply integrableOn_ball_of_norm_le_rpow (C := 648) (α := 1) |
| (by norm_num : 1 ≤ Module.finrank ℝ ℂ) (by norm_num : (1:ℝ) < Module.finrank ℝ ℂ) |
| · filter_upwards [self_mem_ae_restrict measurableSet_ball] with z hz |
| rw [Real.norm_of_nonneg (pow_nonneg (logPole_nonneg z) _), Real.rpow_neg_one] |
| by_cases hzero : z = 0 |
| · simp [hzero, logPole] |
| · have hp := norm_pos_iff.mpr hzero |
| have hlt : ‖z‖ < 2 := by simpa using hz |
| simpa only [logPole, div_eq_mul_inv] using logPole_cube_bound hp hlt.le |
| · exact (measurable_logPole.pow_const 3).aestronglyMeasurable |
| |
| lemma logPole_memLp_three : MemLp logPole 3 (volume.restrict (ball 0 2)) := by |
| apply (integrable_norm_rpow_iff measurable_logPole.aestronglyMeasurable |
| (by norm_num : (3:ℝ≥0∞) ≠ 0) (by simp : (3:ℝ≥0∞) ≠ (∞ : ℝ≥0∞))).1 |
| simpa only [IntegrableOn, ENNReal.toReal_ofNat, ← Real.rpow_natCast, Nat.cast_ofNat, |
| Real.norm_of_nonneg (logPole_nonneg _)] using logPole_cube_integrable |
| |
| lemma shifted_logPole_memLp_three (x : ℂ) (hx : ‖x‖ < 1) : |
| MemLp (fun y => logPole (x-y)) 3 (volume.restrict (ball 0 1)) := by |
| have hpres := (measurePreserving_sub_right (volume : Measure ℂ) x).restrict_preimage |
| (show MeasurableSet (ball (0:ℂ) 2) from measurableSet_ball) |
| have hh := logPole_memLp_three.comp_measurePreserving hpres |
| have hsub : ball (0:ℂ) 1 ⊆ (fun y => y-x) ⁻¹' ball 0 2 := by |
| intro y hy |
| have hy' : ‖y‖ < 1 := by simpa using hy |
| have hd := norm_sub_le y x |
| change y-x ∈ ball (0:ℂ) 2 |
| rw [mem_ball_zero_iff] |
| linarith |
| have hm := MemLp.mono_measure (Measure.restrict_mono hsub le_rfl) hh |
| convert hm using 1 |
| funext y |
| dsimp only [Function.comp_def, logPole] |
| rw [norm_sub_rev] |
| |
| end StrictHotSpots.GreenLp |
| |
| |
| open MeasureTheory Filter Metric Set |
| open scoped Topology ENNReal |
| namespace StrictHotSpots.DiskFormula |
| open GreenLp |
| |
| lemma measurable_green_left (x : ℂ) : Measurable (green x) := by |
| unfold green |
| fun_prop |
| |
| lemma green_bounds {x y : ℂ} (hx : ‖x‖ ≤ 1) (hy : ‖y‖ ≤ 1) : |
| 0 ≤ green x y ∧ green x y ≤ logPole (x-y) / (4*Real.pi) := by |
| have hwx : 0 ≤ 1-‖x‖^2 := by nlinarith [norm_nonneg x] |
| have hwy : 0 ≤ 1-‖y‖^2 := by nlinarith [norm_nonneg y] |
| have hn : (1-‖x‖^2)*(1-‖y‖^2) ≤ 1 := by |
| nlinarith [sq_nonneg ‖x‖, sq_nonneg ‖y‖, mul_nonneg hwx (sq_nonneg ‖y‖)] |
| have hdiv : 0 ≤ (1-‖x‖^2)*(1-‖y‖^2)/‖x-y‖^2 := by positivity |
| have hdiv' := div_le_div_of_nonneg_right hn (sq_nonneg ‖x-y‖) |
| have hlog : 0 ≤ Real.log (1+(1-‖x‖^2)*(1-‖y‖^2)/‖x-y‖^2) := |
| Real.log_nonneg (by linarith) |
| refine ⟨div_nonneg hlog (by positivity), ?_⟩ |
| apply div_le_div_of_nonneg_right _ (by positivity : 0 ≤ 4*Real.pi) |
| exact Real.log_le_log (by linarith) (by simpa only [logPole] using add_le_add_right hdiv' 1) |
| |
| lemma green_pos {x y : ℂ} (hx : ‖x‖ < 1) (hy : ‖y‖ < 1) (hne : x ≠ y) : |
| 0 < green x y := by |
| apply div_pos _ (by positivity) |
| apply Real.log_pos |
| have hwx : 0 < 1-‖x‖^2 := by nlinarith [norm_nonneg x] |
| have hwy : 0 < 1-‖y‖^2 := by nlinarith [norm_nonneg y] |
| have hd : 0 < ‖x-y‖^2 := sq_pos_of_pos (norm_pos_iff.mpr (sub_ne_zero.mpr hne)) |
| have := div_pos (mul_pos hwx hwy) hd |
| linarith |
| |
| lemma green_memLp_three (x : ℂ) (hx : ‖x‖ < 1) : |
| MemLp (green x) 3 (volume.restrict (ball 0 1)) := by |
| have hm : MemLp (fun y => logPole (x-y)/(4*Real.pi)) 3 |
| (volume.restrict (ball 0 1)) := by |
| simpa only [div_eq_mul_inv] using |
| (shifted_logPole_memLp_three x hx).mul_const (4*Real.pi)⁻¹ |
| apply hm.mono (measurable_green_left x).aestronglyMeasurable |
| filter_upwards [self_mem_ae_restrict measurableSet_ball] with y hy |
| have hy' : ‖y‖ ≤ 1 := (by simpa using hy : ‖y‖ < 1).le |
| have hb := green_bounds hx.le hy' |
| rw [Real.norm_of_nonneg hb.1, Real.norm_of_nonneg (div_nonneg (logPole_nonneg (x-y)) (by positivity : |
| 0 ≤ 4*Real.pi))] |
| exact hb.2 |
| |
| lemma green_memLp_two (x : ℂ) (hx : ‖x‖ < 1) : |
| MemLp (green x) 2 (volume.restrict (ball 0 1)) := by |
| have : IsFiniteMeasure (volume.restrict (ball (0:ℂ) 1)) := |
| ⟨by simpa only [Measure.restrict_apply_univ] using measure_ball_lt_top (x := (0:ℂ)) (r := 1)⟩ |
| exact (green_memLp_three x hx).mono_exponent (by norm_num) |
| |
| lemma green_memLp_three_of_le (ν : Measure ℂ) {A : ℝ≥0∞} (hA : A ≠ (∞ : ℝ≥0∞)) |
| (hν : ν ≤ A • volume.restrict (ball 0 1)) (x : ℂ) (hx : ‖x‖ < 1) : |
| MemLp (green x) 3 ν := |
| MemLp.mono_measure hν ((green_memLp_three x hx).smul_measure hA) |
| |
| lemma green_memLp_two_of_le (ν : Measure ℂ) {A : ℝ≥0∞} (hA : A ≠ (∞ : ℝ≥0∞)) |
| (hν : ν ≤ A • volume.restrict (ball 0 1)) (x : ℂ) (hx : ‖x‖ < 1) : |
| MemLp (green x) 2 ν := |
| MemLp.mono_measure hν ((green_memLp_two x hx).smul_measure hA) |
| |
| end StrictHotSpots.DiskFormula |
| |
| |
| open MeasureTheory Filter Metric Set |
| open scoped Topology ENNReal |
| namespace StrictHotSpots.GreenLp |
| |
| lemma logPole_memLp_two : MemLp logPole 2 (volume.restrict (ball (0 : ℂ) 2)) := by |
| let : IsFiniteMeasure (volume.restrict (ball (0 : ℂ) 2)) := |
| isFiniteMeasure_restrict.mpr Metric.isBounded_ball.measure_lt_top.ne |
| exact logPole_memLp_three.mono_exponent (by norm_num) |
| |
| lemma shifted_logPole_norm_bound (x : ℂ) (hx : ‖x‖ < 1) : |
| eLpNorm (fun y => logPole (x-y)) 2 (volume.restrict (ball 0 1)) ≤ |
| eLpNorm logPole 2 (volume.restrict (ball (0 : ℂ) 2)) := by |
| have hm := (measurePreserving_sub_right (volume : Measure ℂ) x).restrict_preimage |
| (show MeasurableSet (ball (0 : ℂ) 2) from measurableSet_ball) |
| have hs : ball (0 : ℂ) 1 ⊆ (fun y => y-x) ⁻¹' ball 0 2 := by |
| intro y hy |
| have hy' : ‖y‖ < 1 := by simpa using hy |
| have hd := norm_sub_le y x |
| change y-x ∈ ball (0 : ℂ) 2 |
| rw [mem_ball_zero_iff] |
| linarith |
| calc |
| _ = eLpNorm (logPole ∘ fun y => y-x) 2 (volume.restrict (ball 0 1)) := by |
| congr 1 |
| funext y |
| simp only [Function.comp_apply, logPole, norm_sub_rev x y] |
| _ ≤ eLpNorm (logPole ∘ fun y => y-x) 2 |
| (volume.restrict ((fun y => y-x) ⁻¹' ball 0 2)) := |
| eLpNorm_mono_measure _ (Measure.restrict_mono hs le_rfl) |
| _ = _ := eLpNorm_comp_measurePreserving logPole_memLp_two.aestronglyMeasurable hm |
|
|
| end StrictHotSpots.GreenLp |
| namespace StrictHotSpots.DiskFormula |
| open GreenLp |
|
|
| lemma green_uniform_L2_bound : ∃ B : ℝ, 0 ≤ B ∧ ∀ x : ℂ, ‖x‖ < 1 → |
| (eLpNorm (green x) 2 (volume.restrict (ball 0 1))).toReal ≤ B := by |
| let C := ENNReal.ofReal (4*Real.pi)⁻¹ * |
| eLpNorm logPole 2 (volume.restrict (ball (0 : ℂ) 2)) |
| have hC : C ≠ (∞ : ℝ≥0∞) := ENNReal.mul_ne_top ENNReal.ofReal_ne_top logPole_memLp_two.eLpNorm_ne_top |
| refine ⟨C.toReal, ENNReal.toReal_nonneg, fun x hx => ?_⟩ |
| apply ENNReal.toReal_mono hC |
| calc |
| _ ≤ ENNReal.ofReal (4*Real.pi)⁻¹ * |
| eLpNorm (fun y => logPole (x-y)) 2 (volume.restrict (ball 0 1)) := by |
| apply eLpNorm_le_mul_eLpNorm_of_ae_le_mul |
| (measurable_green_left x).aestronglyMeasurable |
| filter_upwards [ae_restrict_mem measurableSet_ball] with y hy |
| have hy' : ‖y‖ ≤ 1 := (by simpa using hy : ‖y‖ < 1).le |
| have hh := green_bounds hx.le hy' |
| rw [Real.norm_of_nonneg hh.1, Real.norm_of_nonneg (logPole_nonneg _)] |
| simpa only [div_eq_mul_inv, mul_comm] using hh.2 |
| _ ≤ C := by |
| dsimp [C] |
| gcongr |
| exact shifted_logPole_norm_bound x hx |
|
|
| end StrictHotSpots.DiskFormula |
|
|
|
|
|
|
| open MeasureTheory Filter |
| open scoped ENNReal Topology InnerProductSpace |
| namespace StrictHotSpots.MeasurableL2Kernel |
|
|
| lemma integral_mul_eq_inner {X : Type*} [MeasurableSpace X] {ν : Measure X} |
| {f g : X → ℝ} (hf : MemLp f 2 ν) (hg : MemLp g 2 ν) : |
| (∫ x, f x * g x ∂ν) = inner ℝ (hf.toLp f) (hg.toLp g) := by |
| rw [L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [hf.coeFn_toLp, hg.coeFn_toLp] with x hx hy |
| simp only [hx,hy, RCLike.inner_apply, conj_trivial] |
| ring |
|
|
| lemma norm_integral_mul_le {X : Type*} [MeasurableSpace X] {ν : Measure X} |
| {f g : X → ℝ} (hf : MemLp f 2 ν) (hg : MemLp g 2 ν) : |
| ‖∫ x, f x * g x ∂ν‖ ≤ (eLpNorm f 2 ν).toReal * (eLpNorm g 2 ν).toReal := by |
| rw [integral_mul_eq_inner hf hg] |
| simpa only [Lp.norm_toLp] using norm_inner_le_norm (hf.toLp f) (hg.toLp g) |
|
|
| variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| {μ : Measure X} {ν : Measure Y} [IsFiniteMeasure μ] [IsFiniteMeasure ν] |
| (K : X × Y → ℝ) (hK : AEStronglyMeasurable K (μ.prod ν)) |
| (hrow : ∀ᵐ x ∂μ, MemLp (fun y => K (x,y)) 2 ν) |
| {B : ℝ} (hB : 0 ≤ B) |
| (hbound : ∀ᵐ x ∂μ, (eLpNorm (fun y => K (x,y)) 2 ν).toReal ≤ B) |
|
|
| omit [IsFiniteMeasure μ] [IsFiniteMeasure ν] in |
| include hrow hbound in |
| lemma apply_bound (f : Lp ℝ 2 ν) : |
| ∀ᵐ x ∂μ, ‖∫ y, K (x,y) * f y ∂ν‖ ≤ B * ‖f‖ := by |
| filter_upwards [hrow, hbound] with x hx hb |
| have hh := norm_integral_mul_le hx (Lp.memLp f) |
| have he : (eLpNorm (fun y => f y) 2 ν).toReal = ‖f‖ := rfl |
| rw [he] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_right hb (norm_nonneg f)) |
|
|
| include hK hrow hbound in |
| lemma apply_memLp (f : Lp ℝ 2 ν) : |
| MemLp (fun x => ∫ y, K (x,y) * f y ∂ν) 2 μ := by |
| have hm : AEStronglyMeasurable (fun z : X × Y => K z * f z.2) (μ.prod ν) := |
| hK.mul (Lp.aestronglyMeasurable f).comp_snd |
| exact MemLp.of_bound hm.integral_prod_right' (B * ‖f‖) |
| (apply_bound K hrow hbound f) |
| |
| |
| |
| def operator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 μ := by |
| let T : Lp ℝ 2 ν →ₗ[ℝ] Lp ℝ 2 μ := |
| { toFun := fun f => (apply_memLp K hK hrow hbound f).toLp _ |
| map_add' := by |
| intro f g |
| apply Lp.ext |
| filter_upwards [(apply_memLp K hK hrow hbound (f+g)).coeFn_toLp, |
| (apply_memLp K hK hrow hbound f).coeFn_toLp, |
| (apply_memLp K hK hrow hbound g).coeFn_toLp, |
| Lp.coeFn_add ((apply_memLp K hK hrow hbound f).toLp _) |
| ((apply_memLp K hK hrow hbound g).toLp _), hrow] with x hx hf hg ha hr |
| rw [hx,ha, Pi.add_apply,hf,hg] |
| have he : (fun y => K (x,y) * (f+g) y) =ᵐ[ν] |
| (fun y => K (x,y) * f y + K (x,y) * g y) := by |
| filter_upwards [Lp.coeFn_add f g] with y hy |
| rw [hy, Pi.add_apply, mul_add] |
| rw [integral_congr_ae he, integral_add] |
| · exact hr.integrable_mul (Lp.memLp f) |
| · exact hr.integrable_mul (Lp.memLp g) |
| map_smul' := by |
| intro c f |
| apply Lp.ext |
| filter_upwards [(apply_memLp K hK hrow hbound (c • f)).coeFn_toLp, |
| (apply_memLp K hK hrow hbound f).coeFn_toLp, |
| Lp.coeFn_smul c ((apply_memLp K hK hrow hbound f).toLp _)] with x hx hf hs |
| simp only [RingHom.id_apply] |
| rw [hx,hs, Pi.smul_apply,hf] |
| have he : (fun y => K (x,y) * (c • f) y) =ᵐ[ν] |
| (fun y => c * (K (x,y) * f y)) := by |
| filter_upwards [Lp.coeFn_smul c f] with y hy |
| rw [hy, Pi.smul_apply, smul_eq_mul] |
| ring |
| rw [integral_congr_ae he, integral_const_mul, smul_eq_mul] } |
| refine T.mkContinuous ((measureUnivNNReal μ : ℝ) ^ (2 : ℝ≥0∞).toReal⁻¹ * B) ?_ |
| intro f |
| have hh := Lp.norm_le_of_ae_bound (mul_nonneg hB (norm_nonneg f)) |
| (show ∀ᵐ x ∂μ, ‖T f x‖ ≤ B * ‖f‖ from by |
| filter_upwards [(apply_memLp K hK hrow hbound f).coeFn_toLp, |
| apply_bound K hrow hbound f] with x hx hb |
| change ‖((apply_memLp K hK hrow hbound f).toLp _) x‖ ≤ _ |
| rw [hx] |
| exact hb) |
| exact hh.trans_eq (mul_assoc _ _ _).symm |
| |
| lemma operator_apply_ae (f : Lp ℝ 2 ν) : |
| operator K hK hrow hB hbound f =ᵐ[μ] fun x => ∫ y, K (x,y) * f y ∂ν := |
| (apply_memLp K hK hrow hbound f).coeFn_toLp |
| |
| end StrictHotSpots.MeasurableL2Kernel |
| |
| |
| |
| open MeasureTheory Filter InnerProductSpace |
| open scoped ENNReal Topology |
| namespace StrictHotSpots |
| |
| lemma eq_zero_of_inner_smoothTest_eq_zero {Ω : Set Plane} (hΩ : IsOpen Ω) |
| (u : Lp ℝ 2 (volume.restrict Ω)) |
| (h : ∀ φ : smoothTestSpace Ω, inner ℝ (H1.value (smoothTestToH1 hΩ φ)) u = 0) : |
| u = 0 := by |
| have hl := (Lp.memLp u).locallyIntegrable (by norm_num : (1 : ℝ≥0∞) ≤ 2) |
| have hh := hΩ.ae_eq_zero_of_integral_contDiff_smul_eq_zero |
| (μ := volume.restrict Ω) (hl.locallyIntegrableOn Ω) |
| (fun φ hp hc hs => show (∫ x in Ω, φ x • u x) = 0 from by |
| have ht := h ⟨φ,hp,hc,hs⟩ |
| have hv : H1.value (smoothTestToH1 hΩ ⟨φ,hp,hc,hs⟩) = |
| (test_memLp (Ω := Ω) hp hc).toLp φ := rfl |
| rw [hv, L2.inner_def] at ht |
| convert ht using 1 |
| apply integral_congr_ae |
| filter_upwards [(test_memLp (Ω := Ω) hp hc).coeFn_toLp] with x hx |
| simp only [hx, smul_eq_mul, RCLike.inner_apply, conj_trivial] |
| ring) |
| apply Lp.ext |
| filter_upwards [hh, ae_restrict_mem hΩ.measurableSet, Lp.coeFn_zero ℝ 2 (volume.restrict Ω)] |
| with x hx hΩx hz |
| rw [hz] |
| exact hx hΩx |
| |
| lemma smoothTest_dense_L2 {Ω : Set Plane} (hΩ : IsOpen Ω) : |
| DenseRange (fun φ : smoothTestSpace Ω => H1.value (smoothTestToH1 hΩ φ)) := by |
| let T : smoothTestSpace Ω →ₗ[ℝ] Lp ℝ 2 (volume.restrict Ω) := |
| H1.value.toLinearMap.comp (smoothTestToH1 hΩ) |
| have hz : T.rangeᗮ = ⊥ := by |
| apply eq_bot_iff.mpr |
| intro u hu |
| change u = 0 |
| apply eq_zero_of_inner_smoothTest_eq_zero hΩ u |
| intro φ |
| exact (Submodule.mem_orthogonal _ _).mp hu (T φ) ⟨φ,rfl⟩ |
| have ht : T.range.topologicalClosure = ⊤ := by |
| rw [← Submodule.orthogonal_orthogonal_eq_closure, hz, Submodule.bot_orthogonal_eq_top] |
| have hd : closure (Set.range T) = Set.univ := by |
| change closure (T.range : Set (Lp ℝ 2 (volume.restrict Ω))) = Set.univ |
| rw [← Submodule.topologicalClosure_coe, ht, Submodule.top_coe] |
| exact dense_iff_closure_eq.mpr hd |
| |
| end StrictHotSpots |
| |
| |
| |
| |
| |
| |
| |
| open scoped InnerProductSpace |
| namespace StrictHotSpots.DirichletOperator |
| |
| variable {V H : Type*} |
| [NormedAddCommGroup V] [InnerProductSpace ℝ V] [CompleteSpace V] |
| [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H] |
| |
| |
| def solution (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) : |
| H →L[ℝ] V := |
| hB.continuousLinearEquivOfBilin.symm.toContinuousLinearMap.comp J.adjoint |
| |
| lemma solution_spec (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) |
| (f : H) (v : V) : B (solution B hB J f) v = ⟪f, J v⟫_ℝ := by |
| rw [← hB.continuousLinearEquivOfBilin_apply] |
| simp only [solution, ContinuousLinearMap.comp_apply, ContinuousLinearEquiv.coe_coe, |
| ContinuousLinearEquiv.apply_symm_apply, ContinuousLinearMap.adjoint_inner_left] |
| |
| |
| def green (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) : |
| H →L[ℝ] H := J.comp (solution B hB J) |
| |
| lemma green_apply (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) |
| (f : H) : green B hB J f = J (solution B hB J f) := rfl |
| |
| lemma green_symmetric (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) |
| (hsym : ∀ u v, B u v = B v u) (J : V →L[ℝ] H) (f g : H) : |
| ⟪green B hB J f, g⟫_ℝ = ⟪f, green B hB J g⟫_ℝ := by |
| calc |
| _ = ⟪g, J (solution B hB J f)⟫_ℝ := real_inner_comm _ _ |
| _ = B (solution B hB J g) (solution B hB J f) := (solution_spec B hB J g _).symm |
| _ = B (solution B hB J f) (solution B hB J g) := hsym _ _ |
| _ = _ := solution_spec B hB J f _ |
| |
| lemma green_nonneg (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) |
| (J : V →L[ℝ] H) (f : H) : 0 ≤ ⟪f, green B hB J f⟫_ℝ := by |
| rw [green_apply, ← solution_spec B hB J f (solution B hB J f)] |
| obtain ⟨C, hC, h⟩ := hB |
| exact (mul_nonneg (mul_nonneg hC.le (norm_nonneg _)) (norm_nonneg _)).trans (h _) |
| |
| |
| |
| lemma green_norm_le (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) |
| (J : V →L[ℝ] H) {d : ℝ} (hd : 0 ≤ d) |
| (hsub : ∀ v : V, ‖J v‖ ^ 2 ≤ d * B v v) : ‖green B hB J‖ ≤ d := by |
| apply ContinuousLinearMap.opNorm_le_bound _ hd |
| intro f |
| let u := solution B hB J f |
| have h0 := hsub u |
| have hs : B u u = ⟪f, J u⟫_ℝ := solution_spec B hB J f u |
| rw [hs] at h0 |
| have hi : ⟪f, J u⟫_ℝ ≤ ‖f‖ * ‖J u‖ := real_inner_le_norm _ _ |
| have ht : ‖J u‖ ^ 2 ≤ d * (‖f‖ * ‖J u‖) := |
| h0.trans (mul_le_mul_of_nonneg_left hi hd) |
| change ‖J u‖ ≤ d * ‖f‖ |
| by_cases hz : ‖J u‖ = 0 |
| · rw [hz] |
| positivity |
| · have hp : 0 < ‖J u‖ := lt_of_le_of_ne (norm_nonneg _) (Ne.symm hz) |
| nlinarith |
| |
| lemma green_norm_lt_one (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) |
| (J : V →L[ℝ] H) {d : ℝ} (hd : 0 ≤ d) (hd1 : d < 1) |
| (hsub : ∀ v : V, ‖J v‖ ^ 2 ≤ d * B v v) : ‖green B hB J‖ < 1 := |
| (green_norm_le B hB J hd hsub).trans_lt hd1 |
| |
| end StrictHotSpots.DirichletOperator |
| |
| |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology InnerProductSpace |
| namespace StrictHotSpots.PlaneGreen |
| open DiskH10 |
| |
| lemma diskBounded : Bornology.IsBounded disk := Metric.isBounded_ball |
| |
| instance diskFinite : IsFiniteMeasure (volume.restrict disk) := |
| isFiniteMeasure_restrict.mpr diskBounded.measure_lt_top.ne |
| |
| def kernel (x y : Plane) : ℝ := DiskFormula.green (complexIso.symm x) (complexIso.symm y) |
| |
| lemma complexIso_disk_preserving : MeasurePreserving complexIso.symm |
| (volume.restrict disk) (volume.restrict (Metric.ball (0 : ℂ) 1)) := by |
| have h := complexIso.symm.measurePreserving.restrict_preimage |
| (show MeasurableSet (Metric.ball (0 : ℂ) 1) from measurableSet_ball) |
| have he : complexIso.symm ⁻¹' Metric.ball (0 : ℂ) 1 = disk := by |
| ext x |
| simp [disk] |
| rwa [he] at h |
|
|
| lemma kernel_memLp (x : Plane) (hx : x ∈ disk) : |
| MemLp (kernel x) 2 (volume.restrict disk) := by |
| have hx' : ‖complexIso.symm x‖ < 1 := by simpa [disk] using hx |
| exact (DiskFormula.green_memLp_two _ hx').comp_measurePreserving complexIso_disk_preserving |
|
|
| lemma measurable_kernel : Measurable (fun p : Plane × Plane => kernel p.1 p.2) := by |
| unfold kernel DiskFormula.green |
| fun_prop |
|
|
| lemma kernel_bound : ∃ B : ℝ, 0 ≤ B ∧ ∀ x ∈ disk, |
| (eLpNorm (kernel x) 2 (volume.restrict disk)).toReal ≤ B := by |
| obtain ⟨B,hB,h⟩ := DiskFormula.green_uniform_L2_bound |
| refine ⟨B,hB,fun x hx => ?_⟩ |
| have hx' : ‖complexIso.symm x‖ < 1 := by simpa [disk] using hx |
| have he := eLpNorm_comp_measurePreserving (p := 2) |
| (DiskFormula.green_memLp_two _ hx').aestronglyMeasurable complexIso_disk_preserving |
| change (eLpNorm (DiskFormula.green (complexIso.symm x) ∘ complexIso.symm) 2 |
| (volume.restrict disk)).toReal ≤ B |
| rw [he] |
| exact h _ hx' |
| |
| lemma kernel_rows : ∀ᵐ x ∂volume.restrict disk, MemLp (kernel x) 2 (volume.restrict disk) := by |
| filter_upwards [ae_restrict_mem diskOpen.measurableSet] with x hx |
| exact kernel_memLp x hx |
| |
| def integralOperator : Lp ℝ 2 (volume.restrict disk) →L[ℝ] Lp ℝ 2 (volume.restrict disk) := |
| MeasurableL2Kernel.operator (fun p => kernel p.1 p.2) measurable_kernel.aestronglyMeasurable |
| kernel_rows kernel_bound.choose_spec.1 |
| (by filter_upwards [ae_restrict_mem diskOpen.measurableSet] with x hx |
| exact kernel_bound.choose_spec.2 x hx) |
| |
| lemma integralOperator_ae (f : Lp ℝ 2 (volume.restrict disk)) : |
| integralOperator f =ᵐ[volume.restrict disk] fun x => ∫ y in disk, kernel x y * f y := |
| MeasurableL2Kernel.operator_apply_ae _ _ _ _ _ f |
| |
| lemma potential_eq_integral {f : Plane → ℝ} (hf : ContDiff ℝ ∞ f) |
| (hc : HasCompactSupport f) (hs : tsupport f ⊆ disk) {x : Plane} (hx : x ∈ disk) : |
| potential f x = ∫ y in disk, kernel x y * f y := by |
| obtain ⟨R,hR,hn⟩ := GreenPotential.exists_regular_neighborhood (source_compact hc) |
| (source_support hs) |
| have hx' : complexIso.symm x ∈ Metric.ball (0 : ℂ) R := by |
| have : ‖x‖ < 1 := by simpa [disk] using hx |
| simpa using this.trans hR |
| have hh := GreenPotential.potential_eq_integral (source_contDiff hf) (source_compact hc) |
| Metric.isOpen_ball hn hx' |
| change GreenPotential.potential (source f) (complexIso.symm x) = _ |
| rw [hh] |
| have he := complexIso.symm.measurePreserving.integral_comp |
| complexIso.symm.toMeasurableEquiv.measurableEmbedding |
| (fun z => DiskFormula.green (complexIso.symm x) z * source f z) |
| simp only [source, complexIso.apply_symm_apply] at he |
| simp only [source] |
| rw [← he] |
| symm |
| apply setIntegral_eq_integral_of_forall_compl_eq_zero |
| intro y hy |
| have hfy : f y = 0 := image_eq_zero_of_notMem_tsupport (fun h => hy (hs h)) |
| simp [hfy, kernel] |
| |
| def variationalOperator : Lp ℝ 2 (volume.restrict disk) →L[ℝ] Lp ℝ 2 (volume.restrict disk) := |
| @DirichletOperator.green (H10 diskOpen) (Lp ℝ 2 (volume.restrict disk)) |
| (H10.normedAddCommGroup diskOpen) (H10.innerProductSpace diskOpen) |
| (H10.completeSpace diskOpen) inferInstance inferInstance inferInstance |
| (H10.energy diskOpen) (H10.energy_coercive diskOpen diskBounded) (H10.value diskOpen) |
| |
| lemma variationalOperator_test (f : smoothTestSpace disk) : |
| variationalOperator (H1.value (smoothTestToH1 diskOpen f)) =ᵐ[volume.restrict disk] |
| potential f := by |
| obtain ⟨u,hu,he⟩ := exists_dirichlet_representative f.property.1 f.property.2.1 f.property.2.2 |
| let w := DirichletOperator.solution (H10.energy diskOpen) |
| (H10.energy_coercive diskOpen diskBounded) (H10.value diskOpen) |
| (H1.value (smoothTestToH1 diskOpen f)) |
| have hw : ∀ v, H10.energy diskOpen w v = inner ℝ |
| (H1.value (smoothTestToH1 diskOpen f)) (H10.value diskOpen v) := |
| DirichletOperator.solution_spec _ _ _ _ |
| have he' : ∀ v, H10.energy diskOpen u v = inner ℝ |
| (H1.value (smoothTestToH1 diskOpen f)) (H10.value diskOpen v) := he |
| obtain ⟨_,_,hun⟩ := H10.existsUnique_energy_solution diskOpen diskBounded |
| ((innerSL ℝ (H1.value (smoothTestToH1 diskOpen f))).comp (H10.value diskOpen)) |
| have heq : w = u := (hun w hw).trans (hun u he').symm |
| change H10.value diskOpen w =ᵐ[volume.restrict disk] potential f |
| rw [heq] |
| exact hu |
| |
| |
| |
| lemma integralOperator_eq_variationalOperator : integralOperator = variationalOperator := by |
| apply DFunLike.coe_injective |
| apply (smoothTest_dense_L2 diskOpen).equalizer integralOperator.continuous |
| variationalOperator.continuous |
| funext f |
| simp only [Function.comp_apply] |
| apply Lp.ext |
| filter_upwards [integralOperator_ae (H1.value (smoothTestToH1 diskOpen f)), |
| variationalOperator_test f, ae_restrict_mem diskOpen.measurableSet] with x hx hu hxd |
| rw [hx,hu,potential_eq_integral f.property.1 f.property.2.1 f.property.2.2 hxd] |
| apply integral_congr_ae |
| have hf : H1.value (smoothTestToH1 diskOpen f) =ᵐ[volume.restrict disk] f := |
| (test_memLp (Ω := disk) f.property.1 f.property.2.1).coeFn_toLp |
| filter_upwards [hf] with y hy |
| rw [hy] |
| |
| end StrictHotSpots.PlaneGreen |
| |
| |
| open MeasureTheory |
| open scoped InnerProductSpace ENNReal |
| namespace StrictHotSpots.H10 |
| variable {Ω : Set Plane} (hΩ : IsOpen Ω) (hb : Bornology.IsBounded Ω) |
| variable {ν : Measure Plane} {C : ℝ≥0∞} (hC : C ≠ (∞ : ℝ≥0∞)) |
| (hν : ν ≤ C • volume.restrict Ω) |
| |
| |
| def weightedValue : H10 hΩ →L[ℝ] Lp ℝ 2 ν := |
| (Lp.LpToLpOfMeasureLeSMul hC hν).comp (value hΩ) |
| |
| lemma weightedValue_ae (u : H10 hΩ) : |
| weightedValue hΩ hC hν u =ᵐ[ν] value hΩ u := |
| Lp.coeFn_LpToLpOfMeasureLeSMul hC hν (value hΩ u) |
| |
| |
| |
| def greenOperator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν := |
| @DirichletOperator.green (H10 hΩ) (Lp ℝ 2 ν) |
| (H10.normedAddCommGroup hΩ) (H10.innerProductSpace hΩ) (H10.completeSpace hΩ) |
| inferInstance inferInstance inferInstance |
| (energy hΩ) (energy_coercive hΩ hb) (weightedValue hΩ hC hν) |
| |
| lemma energy_symmetric (u v : H10 hΩ) : energy hΩ u v = energy hΩ v u := by |
| calc |
| energy hΩ u v = inner ℝ (grad hΩ u) (grad hΩ v) := energy_apply hΩ u v |
| _ = inner ℝ (grad hΩ v) (grad hΩ u) := real_inner_comm _ _ |
| _ = energy hΩ v u := (energy_apply hΩ v u).symm |
| |
| lemma greenOperator_symmetric (f g : Lp ℝ 2 ν) : |
| inner ℝ (greenOperator hΩ hb hC hν f) g = |
| inner ℝ f (greenOperator hΩ hb hC hν g) := |
| DirichletOperator.green_symmetric (energy hΩ) (energy_coercive hΩ hb) |
| (energy_symmetric hΩ) (weightedValue hΩ hC hν) f g |
| |
| lemma greenOperator_nonneg (f : Lp ℝ 2 ν) : |
| 0 ≤ inner ℝ f (greenOperator hΩ hb hC hν f) := |
| DirichletOperator.green_nonneg (energy hΩ) (energy_coercive hΩ hb) |
| (weightedValue hΩ hC hν) f |
| |
| |
| lemma greenOperator_norm_le {d : ℝ} (hd : 0 ≤ d) |
| (hsub : ∀ u : H10 hΩ, ‖weightedValue hΩ hC hν u‖ ^ 2 ≤ |
| d * ‖grad hΩ u‖ ^ 2) : ‖greenOperator hΩ hb hC hν‖ ≤ d := by |
| apply DirichletOperator.green_norm_le (energy hΩ) (energy_coercive hΩ hb) |
| (weightedValue hΩ hC hν) hd |
| intro u |
| simpa only [energy_apply, real_inner_self_eq_norm_sq] using hsub u |
| |
| end StrictHotSpots.H10 |
| |
| |
| open MeasureTheory Filter |
| open scoped ENNReal InnerProductSpace |
| namespace StrictHotSpots.DirichletOperator |
| |
| lemma green_comp {V H K : Type*} |
| [NormedAddCommGroup V] [InnerProductSpace ℝ V] [CompleteSpace V] |
| [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H] |
| [NormedAddCommGroup K] [InnerProductSpace ℝ K] [CompleteSpace K] |
| (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) (S : H →L[ℝ] K) : |
| green B hB (S.comp J) = (S.comp (green B hB J)).comp S.adjoint := by |
| simp only [green, solution, ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.comp_assoc] |
| |
| end StrictHotSpots.DirichletOperator |
| namespace StrictHotSpots.PlaneGreen |
| open DiskH10 |
| variable {ν : Measure Plane} {C : ℝ≥0∞} (hC : C ≠ (∞ : ℝ≥0∞)) |
| (hν : ν ≤ C • volume.restrict disk) |
| |
| def inclusion : Lp ℝ 2 (volume.restrict disk) →L[ℝ] Lp ℝ 2 ν := |
| Lp.LpToLpOfMeasureLeSMul hC hν |
| |
| lemma inclusion_ae (f : Lp ℝ 2 (volume.restrict disk)) : inclusion hC hν f =ᵐ[ν] f := |
| Lp.coeFn_LpToLpOfMeasureLeSMul hC hν f |
| |
| include hC hν in |
| lemma kernel_memLp_weighted (x : Plane) (hx : x ∈ disk) : MemLp (kernel x) 2 ν := |
| ((kernel_memLp x hx).smul_measure hC).mono_measure hν |
| |
| lemma inclusion_row (x : Plane) (hx : x ∈ disk) : |
| inclusion hC hν ((kernel_memLp x hx).toLp (kernel x)) = |
| (kernel_memLp_weighted hC hν x hx).toLp (kernel x) := by |
| apply Lp.ext |
| exact (inclusion_ae hC hν _).trans |
| (((Measure.absolutelyContinuous_of_le_smul hν).ae_eq (kernel_memLp x hx).coeFn_toLp).trans |
| (kernel_memLp_weighted hC hν x hx).coeFn_toLp.symm) |
| |
| lemma integral_adjoint_row (f : Lp ℝ 2 ν) (x : Plane) (hx : x ∈ disk) : |
| (∫ y in disk, kernel x y * (inclusion hC hν).adjoint f y) = |
| ∫ y, kernel x y * f y ∂ν := by |
| rw [MeasurableL2Kernel.integral_mul_eq_inner (kernel_memLp x hx) |
| (Lp.memLp ((inclusion hC hν).adjoint f)), Lp.toLp_coeFn, |
| ContinuousLinearMap.adjoint_inner_right, inclusion_row hC hν x hx] |
| rw [MeasurableL2Kernel.integral_mul_eq_inner (kernel_memLp_weighted hC hν x hx) |
| (Lp.memLp f), Lp.toLp_coeFn] |
| |
| |
| |
| def weightedIntegralOperator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν := |
| ((inclusion hC hν).comp integralOperator).comp (inclusion hC hν).adjoint |
| |
| lemma weightedIntegralOperator_ae (f : Lp ℝ 2 ν) : |
| weightedIntegralOperator hC hν f =ᵐ[ν] fun x => ∫ y, kernel x y * f y ∂ν := by |
| have ha := (Measure.absolutelyContinuous_of_le_smul hν) |
| filter_upwards [inclusion_ae hC hν (integralOperator ((inclusion hC hν).adjoint f)), |
| ha.ae_eq (integralOperator_ae ((inclusion hC hν).adjoint f)), |
| (ae_restrict_mem diskOpen.measurableSet).filter_mono ha.ae_le] with x hx hi hxd |
| change inclusion hC hν (integralOperator ((inclusion hC hν).adjoint f)) x = _ |
| rw [hx,hi,integral_adjoint_row hC hν f x hxd] |
| |
| lemma weightedIntegralOperator_eq_greenOperator : weightedIntegralOperator hC hν = |
| H10.greenOperator diskOpen diskBounded hC hν := by |
| unfold weightedIntegralOperator H10.greenOperator H10.weightedValue |
| |
| rw [DirichletOperator.green_comp, integralOperator_eq_variationalOperator] |
| rfl |
| |
| |
| |
| lemma weightedIntegralOperator_norm_le {d : ℝ} (hd : 0 ≤ d) |
| (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤ |
| d * ‖H10.grad diskOpen u‖ ^ 2) : ‖weightedIntegralOperator hC hν‖ ≤ d := by |
| rw [weightedIntegralOperator_eq_greenOperator] |
| exact H10.greenOperator_norm_le diskOpen diskBounded hC hν hd hsub |
| |
| lemma weightedIntegralOperator_symmetric (f g : Lp ℝ 2 ν) : |
| inner ℝ (weightedIntegralOperator hC hν f) g = |
| inner ℝ f (weightedIntegralOperator hC hν g) := by |
| rw [weightedIntegralOperator_eq_greenOperator] |
| exact H10.greenOperator_symmetric diskOpen diskBounded hC hν f g |
| |
| lemma weightedIntegralOperator_nonneg (f : Lp ℝ 2 ν) : |
| 0 ≤ inner ℝ f (weightedIntegralOperator hC hν f) := by |
| rw [weightedIntegralOperator_eq_greenOperator] |
| exact H10.greenOperator_nonneg diskOpen diskBounded hC hν f |
| |
| end StrictHotSpots.PlaneGreen |
| |
| end WeightedLayer |
| |
| |
| end FullBoundaryCombinedLayer |
| |
| end |
| |
| end DouglasLipschitzBase |
| |
| end OAI |
| |
