| import OAI.Analysis.HotSpots.Douglas |
| import OAI.Analysis.HotSpots.GreenOperator |
|
|
| namespace OAI |
|
|
| section DouglasLipschitzBase |
| noncomputable section |
| section MainVariationalCombinedLayer |
| open Set MeasureTheory Filter |
| open scoped Topology InnerProductSpace ContDiff |
| namespace StrictHotSpots |
|
|
|
|
|
|
|
|
|
|
|
|
| def MainTheorem : Prop := |
| ∀ (Ω : Set Plane), AdmissibleDomain Ω → |
| ∀ (u : Plane → ℝ), InFirstNeumannEigenspace Ω u → |
| (∃ x ∈ Ω, u x ≠ 0) → MainConclusion Ω u |
|
|
| lemma rayleighValues_nonneg {Ω : Set Plane} {r : ℝ} (hr : r ∈ rayleighValues Ω) : |
| 0 ≤ r := by |
| obtain ⟨v, g, _, _, hm, rfl⟩ := hr |
| exact div_nonneg (integral_nonneg fun x => sq_nonneg ‖g x‖) hm.le |
|
|
| lemma firstPositiveNeumannValue_nonneg (Ω : Set Plane) : |
| 0 ≤ firstPositiveNeumannValue Ω := |
| Real.sInf_nonneg fun _ hr => rayleighValues_nonneg hr |
|
|
|
|
| lemma rayleigh_inequality {Ω : Set Plane} {v : Plane → ℝ} {g : Plane → Plane} |
| (hv : HasH1Gradient Ω v g) (hm : (∫ x in Ω, v x) = 0) |
| (hpos : 0 < ∫ x in Ω, (v x) ^ 2) : |
| firstPositiveNeumannValue Ω * (∫ x in Ω, (v x) ^ 2) ≤ |
| ∫ x in Ω, ‖g x‖ ^ 2 := by |
| apply (le_div_iff₀ hpos).mp |
| apply csInf_le |
| · exact ⟨0, fun _ hr => rayleighValues_nonneg hr⟩ |
| · exact ⟨v, g, hv, hm, hpos, rfl⟩ |
|
|
| lemma eigenfunction_energy_identity {Ω : Set Plane} {u : Plane → ℝ} |
| (hu : InFirstNeumannEigenspace Ω u) : |
| (∫ x in Ω, ‖gradient u x‖ ^ 2) = |
| firstPositiveNeumannValue Ω * (∫ x in Ω, (u x) ^ 2) := by |
| simpa only [real_inner_self_eq_norm_sq, pow_two] using hu.2.2.2 u (gradient u) hu.2.1 |
|
|
|
|
|
|
| lemma strict_boundary_extrema_of_noncritical {Ω : Set Plane} {u : Plane → ℝ} |
| (hne : Ω.Nonempty) (hopen : IsOpen Ω) (hbound : Bornology.IsBounded Ω) |
| (hu : ContinuousOn u (closure Ω)) |
| (hnocrit : ∀ x ∈ Ω, gradient u x ≠ 0) : MainConclusion Ω u := by |
| have hnotmin (x : Plane) (hx : x ∈ Ω) : ¬IsMinOn u (closure Ω) x := by |
| intro hm |
| have hl := hm.isLocalMin (Filter.mem_of_superset (hopen.mem_nhds hx) subset_closure) |
| apply hnocrit x hx |
| simp [gradient, hl.fderiv_eq_zero] |
| have hnotmax (x : Plane) (hx : x ∈ Ω) : ¬IsMaxOn u (closure Ω) x := by |
| intro hm |
| have hl := hm.isLocalMax (Filter.mem_of_superset (hopen.mem_nhds hx) subset_closure) |
| apply hnocrit x hx |
| simp [gradient, hl.fderiv_eq_zero] |
| obtain ⟨a, ha, hmin⟩ := hbound.isCompact_closure.exists_isMinOn hne.closure hu |
| obtain ⟨b, hb, hmax⟩ := hbound.isCompact_closure.exists_isMaxOn hne.closure hu |
| have hfa : a ∈ frontier Ω := by |
| rw [frontier, hopen.interior_eq] |
| exact ⟨ha, fun hx => hnotmin a hx hmin⟩ |
| have hfb : b ∈ frontier Ω := by |
| rw [frontier, hopen.interior_eq] |
| exact ⟨hb, fun hx => hnotmax b hx hmax⟩ |
| have hleast : IsLeast (u '' frontier Ω) (u a) := by |
| refine ⟨⟨a, hfa, rfl⟩, ?_⟩ |
| rintro _ ⟨y, hy, rfl⟩ |
| exact hmin (frontier_subset_closure hy) |
| have hgreatest : IsGreatest (u '' frontier Ω) (u b) := by |
| refine ⟨⟨b, hfb, rfl⟩, ?_⟩ |
| rintro _ ⟨y, hy, rfl⟩ |
| exact hmax (frontier_subset_closure hy) |
| refine ⟨hnocrit, ?_⟩ |
| intro x hx |
| rw [hleast.csInf_eq, hgreatest.csSup_eq] |
| constructor |
| · by_contra hlt |
| apply hnotmin x hx |
| intro y hy |
| exact (le_of_not_gt hlt).trans (hmin hy) |
| · by_contra hlt |
| apply hnotmax x hx |
| intro y hy |
| exact (hmax hy).trans (le_of_not_gt hlt) |
|
|
|
|
| lemma eigenfunction_mass_pos {Ω : Set Plane} {u : Plane → ℝ} |
| (hopen : IsOpen Ω) (hu : InFirstNeumannEigenspace Ω u) |
| (hne : ∃ x ∈ Ω, u x ≠ 0) : 0 < ∫ x in Ω, (u x) ^ 2 := by |
| have hn : 0 ≤ ∫ x in Ω, (u x) ^ 2 := integral_nonneg fun x => sq_nonneg (u x) |
| by_contra hp |
| have hz : (∫ x in Ω, (u x) ^ 2) = 0 := le_antisymm (le_of_not_gt hp) hn |
| have hae := (integral_eq_zero_iff_of_nonneg (fun x => sq_nonneg (u x)) |
| hu.2.1.1.integrable_sq).mp hz |
| have hu0 : u =ᵐ[volume.restrict Ω] 0 := by |
| filter_upwards [hae] with x hx |
| simpa using (eq_zero_of_pow_eq_zero hx : u x = 0) |
| have hall := Measure.eqOn_open_of_ae_eq hu0 hopen |
| (hu.1.continuousOn.mono subset_closure) continuousOn_const |
| obtain ⟨x, hx, hux⟩ := hne |
| exact hux (hall hx) |
|
|
| lemma eigenfunction_gradient_continuous {Ω : Set Plane} {u : Plane → ℝ} |
| (hopen : IsOpen Ω) (hu : InFirstNeumannEigenspace Ω u) : |
| ContinuousOn (gradient u) Ω := by |
| exact (InnerProductSpace.toDual ℝ Plane).symm.continuous.comp_continuousOn |
| ((hu.1.mono subset_closure).continuousOn_fderiv_of_isOpen hopen (by simp)) |
|
|
|
|
| lemma firstPositiveNeumannValue_pos_of_eigenfunction {Ω : Set Plane} {u : Plane → ℝ} |
| (hΩ : AdmissibleDomain Ω) (hu : InFirstNeumannEigenspace Ω u) |
| (hne : ∃ x ∈ Ω, u x ≠ 0) : 0 < firstPositiveNeumannValue Ω := by |
| have hμ := firstPositiveNeumannValue_nonneg Ω |
| by_contra hp |
| have hz : firstPositiveNeumannValue Ω = 0 := le_antisymm (le_of_not_gt hp) hμ |
| have he : (∫ x in Ω, ‖gradient u x‖ ^ 2) = 0 := by |
| rw [eigenfunction_energy_identity hu, hz, zero_mul] |
| have hi : Integrable (fun x => ‖gradient u x‖ ^ 2) (volume.restrict Ω) := |
| hu.2.1.2.1.integrable_norm_pow (by norm_num) |
| have hg2 := (integral_eq_zero_iff_of_nonneg (fun x => sq_nonneg ‖gradient u x‖) hi).mp he |
| have hg : gradient u =ᵐ[volume.restrict Ω] 0 := by |
| filter_upwards [hg2] with x hx |
| simpa using (eq_zero_of_pow_eq_zero hx : ‖gradient u x‖ = 0) |
| have hg0 := Measure.eqOn_open_of_ae_eq hg hΩ.2.1 |
| (eigenfunction_gradient_continuous hΩ.2.1 hu) continuousOn_const |
| have hd0 : Ω.EqOn (fderiv ℝ u) 0 := by |
| intro x hx |
| have hh := hg0 hx |
| change (InnerProductSpace.toDual ℝ Plane).symm (fderiv ℝ u x) = 0 at hh |
| simpa using congrArg (InnerProductSpace.toDual ℝ Plane) hh |
| obtain ⟨x, hx, hux⟩ := hne |
| have hc : Ω.EqOn u (fun _ => u x) := fun y hy => |
| hΩ.2.1.is_const_of_fderiv_eq_zero |
| hΩ.2.2.2.1.isPathConnected.isConnected.isPreconnected |
| ((hu.1.mono subset_closure).differentiableOn (by simp)) hd0 hy hx |
| have hmean : (∫ y in Ω, u x) = 0 := |
| (setIntegral_congr_fun hΩ.2.1.measurableSet hc).symm.trans hu.2.2.1 |
| have hv : 0 < (volume Ω).toReal := |
| ENNReal.toReal_pos (ne_of_gt (hΩ.2.1.measure_pos volume hΩ.1)) |
| hΩ.2.2.1.measure_lt_top.ne |
| simp only [integral_const, measureReal_restrict_apply_univ, smul_eq_mul] at hmean |
| exact hux ((mul_eq_zero.mp hmean).resolve_left hv.ne') |
| |
| lemma integrable_inner_of_memLp {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| {μ : Measure Plane} {f g : Plane → E} (hf : MemLp f 2 μ) (hg : MemLp g 2 μ) : |
| Integrable (fun x => inner ℝ (f x) (g x)) μ := by |
| exact (hf.norm.integrable_mul hg.norm).mono' (hf.aestronglyMeasurable.inner hg.aestronglyMeasurable) |
| (Filter.Eventually.of_forall fun x => norm_inner_le_norm _ _) |
|
|
| lemma integral_norm_add_smul_sq {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| {μ : Measure Plane} {f g : Plane → E} (hf : MemLp f 2 μ) (hg : MemLp g 2 μ) (t : ℝ) : |
| (∫ x, ‖f x + t • g x‖ ^ 2 ∂μ) = (∫ x, ‖f x‖ ^ 2 ∂μ) + |
| 2 * t * (∫ x, inner ℝ (f x) (g x) ∂μ) + t ^ 2 * (∫ x, ‖g x‖ ^ 2 ∂μ) := by |
| have hf2 : Integrable (fun x => ‖f x‖ ^ 2) μ := hf.integrable_norm_pow (by norm_num) |
| have hg2 : Integrable (fun x => ‖g x‖ ^ 2) μ := hg.integrable_norm_pow (by norm_num) |
| have hfg := integrable_inner_of_memLp hf hg |
| calc |
| _ = ∫ x, ‖f x‖ ^ 2 + 2 * t * inner ℝ (f x) (g x) + t ^ 2 * ‖g x‖ ^ 2 ∂μ := by |
| apply integral_congr_ae |
| filter_upwards [] with x |
| simp only [← real_inner_self_eq_norm_sq, inner_add_left, inner_add_right, |
| real_inner_smul_left, real_inner_smul_right, real_inner_comm (g x) (f x)] |
| ring |
| _ = _ := by |
| have hi12 : Integrable (fun x => ‖f x‖ ^ 2 + 2 * t * inner ℝ (f x) (g x)) μ := |
| hf2.add (hfg.const_mul (2 * t)) |
| rw [integral_add hi12 (hg2.const_mul (t ^ 2)), |
| integral_add hf2 (hfg.const_mul (2 * t)), integral_const_mul, integral_const_mul] |
|
|
| lemma integral_sq_add_mul {μ : Measure Plane} {v w : Plane → ℝ} |
| (hv : MemLp v 2 μ) (hw : MemLp w 2 μ) (t : ℝ) : |
| (∫ x, (v x + t * w x) ^ 2 ∂μ) = (∫ x, (v x) ^ 2 ∂μ) + |
| 2 * t * (∫ x, v x * w x ∂μ) + t ^ 2 * (∫ x, (w x) ^ 2 ∂μ) := by |
| simpa only [smul_eq_mul, Real.norm_eq_abs, sq_abs, RCLike.inner_apply, starRingEnd_apply, star_trivial, mul_comm] using |
| integral_norm_add_smul_sq hv hw t |
|
|
| lemma rayleigh_inequality_all {Ω : Set Plane} {v : Plane → ℝ} {g : Plane → Plane} |
| (hv : HasH1Gradient Ω v g) (hm : (∫ x in Ω, v x) = 0) : |
| firstPositiveNeumannValue Ω * (∫ x in Ω, (v x) ^ 2) ≤ ∫ x in Ω, ‖g x‖ ^ 2 := by |
| have hnn : 0 ≤ ∫ x in Ω, (v x) ^ 2 := integral_nonneg fun x => sq_nonneg (v x) |
| rcases eq_or_lt_of_le hnn with hz | hp |
| · rw [← hz, mul_zero] |
| exact integral_nonneg fun x => sq_nonneg ‖g x‖ |
| · exact rayleigh_inequality hv hm hp |
|
|
|
|
|
|
| lemma minimizer_euler_mean_zero {Ω : Set Plane} {u v : Plane → ℝ} |
| {g k : Plane → Plane} (hb : Bornology.IsBounded Ω) |
| (hu : HasH1Gradient Ω u g) (hv : HasH1Gradient Ω v k) |
| (hmu : (∫ x in Ω, u x) = 0) (hmv : (∫ x in Ω, v x) = 0) |
| (he : (∫ x in Ω, ‖g x‖ ^ 2) = |
| firstPositiveNeumannValue Ω * (∫ x in Ω, (u x) ^ 2)) : |
| (∫ x in Ω, inner ℝ (g x) (k x)) = |
| firstPositiveNeumannValue Ω * (∫ x in Ω, u x * v x) := by |
| let : IsFiniteMeasure (volume.restrict Ω) := ⟨by simpa using hb.measure_lt_top⟩ |
| have hui : Integrable u (volume.restrict Ω) := hu.1.integrable (by norm_num) |
| have hvi : Integrable v (volume.restrict Ω) := hv.1.integrable (by norm_num) |
| have hvar (t : ℝ) := rayleigh_inequality_all (hu.add (hv.smul t)) (by |
| show (∫ x in Ω, u x + t * v x) = 0 |
| rw [integral_add hui (hvi.const_mul t), integral_const_mul, hmu, hmv] |
| ring) |
| have hpoly : ∀ t : ℝ, 0 ≤ |
| ((∫ x in Ω, ‖k x‖ ^ 2) - firstPositiveNeumannValue Ω * (∫ x in Ω, (v x) ^ 2)) * (t * t) + |
| (2 * ((∫ x in Ω, inner ℝ (g x) (k x)) - |
| firstPositiveNeumannValue Ω * (∫ x in Ω, u x * v x))) * t + 0 := by |
| intro t |
| have ht := hvar t |
| simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul] at ht |
| rw [integral_norm_add_smul_sq hu.2.1 hv.2.1 t, |
| integral_sq_add_mul hu.1 hv.1 t, he] at ht |
| nlinarith |
| have hd := discrim_le_zero hpoly |
| simp only [discrim, mul_zero, sub_zero] at hd |
| nlinarith [sq_nonneg ((∫ x in Ω, inner ℝ (g x) (k x)) - |
| firstPositiveNeumannValue Ω * (∫ x in Ω, u x * v x))] |
|
|
|
|
|
|
| lemma minimizer_euler {Ω : Set Plane} {u v : Plane → ℝ} {g k : Plane → Plane} |
| (hb : Bornology.IsBounded Ω) (hvol : 0 < (volume Ω).toReal) |
| (hu : HasH1Gradient Ω u g) (hv : HasH1Gradient Ω v k) |
| (hmu : (∫ x in Ω, u x) = 0) |
| (he : (∫ x in Ω, ‖g x‖ ^ 2) = |
| firstPositiveNeumannValue Ω * (∫ x in Ω, (u x) ^ 2)) : |
| (∫ x in Ω, inner ℝ (g x) (k x)) = |
| firstPositiveNeumannValue Ω * (∫ x in Ω, u x * v x) := by |
| let : IsFiniteMeasure (volume.restrict Ω) := ⟨by simpa using hb.measure_lt_top⟩ |
| let c := (∫ x in Ω, v x) / (volume Ω).toReal |
| have hui : Integrable u (volume.restrict Ω) := hu.1.integrable (by norm_num) |
| have hvi : Integrable v (volume.restrict Ω) := hv.1.integrable (by norm_num) |
| have hw : HasH1Gradient Ω (fun x => v x - c) k := by |
| change HasH1Gradient Ω (v - fun _ => c) k |
| simpa only [sub_zero] using hv.sub (HasH1Gradient.const hb c) |
| have hm : (∫ x in Ω, v x - c) = 0 := by |
| rw [integral_sub hvi (integrable_const c)] |
| simp only [integral_const, measureReal_restrict_apply_univ, smul_eq_mul] |
| change (∫ x in Ω, v x) - (volume Ω).toReal * c = 0 |
| dsimp [c] |
| field_simp |
| ring |
| have hh := minimizer_euler_mean_zero hb hu hw hmu hm he |
| have hi : (∫ x in Ω, u x * (v x - c)) = (∫ x in Ω, u x * v x) := by |
| simp only [mul_sub] |
| have huv : Integrable (fun x => u x * v x) (volume.restrict Ω) := hu.1.integrable_mul hv.1 |
| rw [integral_sub huv (hui.mul_const c), |
| integral_mul_const, hmu, zero_mul, sub_zero] |
| rwa [hi] at hh |
|
|
| lemma inFirstNeumannEigenspace_of_minimizer {Ω : Set Plane} {u : Plane → ℝ} |
| (hΩ : AdmissibleDomain Ω) (hs : ContDiffOn ℝ ∞ u (closure Ω)) |
| (hu : HasH1Gradient Ω u (gradient u)) (hm : (∫ x in Ω, u x) = 0) |
| (he : (∫ x in Ω, ‖gradient u x‖ ^ 2) = |
| firstPositiveNeumannValue Ω * (∫ x in Ω, (u x) ^ 2)) : |
| InFirstNeumannEigenspace Ω u := by |
| refine ⟨hs, hu, hm, fun v g hv => minimizer_euler hΩ.2.2.1 ?_ hu hv hm he⟩ |
| exact ENNReal.toReal_pos (ne_of_gt (hΩ.2.1.measure_pos volume hΩ.1)) |
| hΩ.2.2.1.measure_lt_top.ne |
|
|
|
|
| end StrictHotSpots |
| end MainVariationalCombinedLayer |
|
|
| section C1WeakGradientWeightedCombinedLayer |
| open Set MeasureTheory |
| open scoped ContDiff InnerProductSpace |
| namespace StrictHotSpots |
| lemma integral_mul_test_hasFDerivAt {Ω : Set Plane} {f φ : Plane → ℝ} |
| {D : Plane → Plane →L[ℝ] ℝ} (ho : IsOpen Ω) |
| (hcF : ContinuousOn f Ω) (hcD : ContinuousOn D Ω) |
| (hd : ∀ x ∈ Ω, HasFDerivAt f (D x) x) |
| (hφ : ContDiff ℝ ∞ φ) (hk : HasCompactSupport φ) (hs : tsupport φ ⊆ Ω) |
| (e : Plane) : |
| (∫ x in Ω, f x * (fderiv ℝ φ x) e) = -(∫ x in Ω, D x e * φ x) := by |
| have hdφ : Continuous (fun x => (fderiv ℝ φ x) e) := |
| (hφ.continuous_fderiv (by simp)).clm_apply continuous_const |
| have hcDf : ContinuousOn (fun x => fderiv ℝ f x e) Ω := by |
| apply (hcD.clm_apply continuousOn_const).congr |
| intro x hx |
| exact congrArg (fun A : Plane →L[ℝ] ℝ => A e) (hd x hx).fderiv |
| have hds : tsupport (fun x => (fderiv ℝ φ x) e) ⊆ Ω := |
| (tsupport_fderiv_apply_subset ℝ e).trans hs |
| have hi := integral_mul_fderiv_eq_neg_fderiv_mul_of_integrable |
| (integrable_mul_test ho hcDf hφ.continuous hk hs) |
| (integrable_mul_test ho hcF hdφ (hk.fderiv_apply ℝ e) hds) |
| (integrable_mul_test ho hcF hφ.continuous hk hs) |
| (fun x hx => (hd x (hs hx)).differentiableAt) |
| (fun x _ => hφ.differentiable (by simp) x) |
| rw [setIntegral_mul_test hds] |
| rw [hi,← setIntegral_mul_test hs] |
| congr 1 |
| apply setIntegral_congr_fun ho.measurableSet |
| intro x hx |
| change fderiv ℝ f x e * φ x = D x e * φ x |
| rw [(hd x hx).fderiv] |
|
|
| lemma HasH1Gradient.of_hasFDerivAt {Ω : Set Plane} {f : Plane → ℝ} {g : Plane → Plane} |
| (ho : IsOpen Ω) (hf : ContinuousOn f Ω) (hg : ContinuousOn g Ω) |
| (hd : ∀ x ∈ Ω, HasFDerivAt f (InnerProductSpace.toDual ℝ Plane (g x)) x) |
| (hmf : MemLp f 2 (volume.restrict Ω)) (hmg : MemLp g 2 (volume.restrict Ω)) : |
| HasH1Gradient Ω f g := by |
| refine ⟨hmf,hmg,fun φ hφ hk hs e => ?_⟩ |
| exact integral_mul_test_hasFDerivAt ho hf |
| ((InnerProductSpace.toDual ℝ Plane).continuous.comp_continuousOn hg) hd hφ hk hs e |
| end StrictHotSpots |
| end C1WeakGradientWeightedCombinedLayer |
|
|
| section DouglasH1CombinedLayer |
| open Set MeasureTheory Filter Metric AddCircle |
| open scoped Topology ComplexConjugate ContDiff InnerProductSpace |
| namespace StrictHotSpots.Douglas |
| open PlaneGreen DiskH10 |
|
|
| def planeSeries (a : ℤ → ℂ) (x : Plane) : ℝ := |
| (harmonicSeries a (complexIso.symm x)).re |
|
|
| def planeD (a : ℤ → ℂ) (x : Plane) : Plane →L[ℝ] ℝ := |
| (Complex.reCLM.comp (harmonicD a (complexIso.symm x))).comp |
| complexIso.symm.toContinuousLinearEquiv.toContinuousLinearMap |
|
|
| def planeGrad (a : ℤ → ℂ) (x : Plane) : Plane := |
| (InnerProductSpace.toDual ℝ Plane).symm (planeD a x) |
|
|
| lemma planeSeries_continuousOn {a : ℤ → ℂ} (ha : Summable (fun m => ‖a m‖)) : |
| ContinuousOn (planeSeries a) (closedBall 0 1) := by |
| apply Complex.continuous_re.comp_continuousOn |
| apply (harmonicSeries_continuousOn ha).comp complexIso.symm.continuous.continuousOn |
| intro x hx |
| simpa only [mem_closedBall_zero_iff,LinearIsometryEquiv.norm_map] using hx |
|
|
| lemma planeD_continuousOn {a : ℤ → ℂ} |
| (ha : Summable (fun m => (m.natAbs:ℝ)*‖a m‖)) : |
| ContinuousOn (planeD a) (closedBall 0 1) := by |
| have hc : ContinuousOn (fun x : Plane => harmonicD a (complexIso.symm x)) (closedBall 0 1) := by |
| apply (harmonicD_continuousOn ha).comp complexIso.symm.continuous.continuousOn |
| intro x hx |
| simpa only [mem_closedBall_zero_iff,LinearIsometryEquiv.norm_map] using hx |
| exact (continuousOn_const.clm_comp hc).clm_comp continuousOn_const |
|
|
| lemma planeGrad_continuousOn {a : ℤ → ℂ} |
| (ha : Summable (fun m => (m.natAbs:ℝ)*‖a m‖)) : |
| ContinuousOn (planeGrad a) (closedBall 0 1) := |
| (InnerProductSpace.toDual ℝ Plane).symm.continuous.comp_continuousOn (planeD_continuousOn ha) |
|
|
| lemma planeSeries_hasFDerivAt {a : ℤ → ℂ} |
| (h0 : Summable (fun m => ‖a m‖)) |
| (h1 : Summable (fun m => (m.natAbs:ℝ)*‖a m‖)) {x : Plane} (hx : x ∈ disk) : |
| HasFDerivAt (planeSeries a) (planeD a x) x := by |
| have hz : complexIso.symm x ∈ ball (0:ℂ) 1 := by |
| simpa only [disk,mem_ball_zero_iff,LinearIsometryEquiv.norm_map] using hx |
| exact (Complex.reCLM.hasFDerivAt.comp _ (harmonicSeries_hasFDerivAt h0 h1 hz)).comp x |
| complexIso.symm.toContinuousLinearEquiv.hasFDerivAt |
|
|
| lemma disk_memLp_of_continuousOn {F : Type*} [NormedAddCommGroup F] |
| {f : Plane → F} (hf : ContinuousOn f (closedBall 0 1)) : MemLp f 2 (volume.restrict disk) := by |
| let : IsFiniteMeasure (volume.restrict (ball (0:Plane) 1)) := |
| isFiniteMeasure_restrict.mpr (isBounded_ball (x := (0:Plane)) (r := 1)).measure_lt_top.ne |
| obtain ⟨C,hC⟩ := (isCompact_closedBall (0:Plane) 1).exists_bound_of_continuousOn hf |
| apply MemLp.of_bound ((hf.mono ball_subset_closedBall).aestronglyMeasurable measurableSet_ball) C |
| filter_upwards [ae_restrict_mem measurableSet_ball] with x hx |
| exact hC x (ball_subset_closedBall hx) |
|
|
|
|
|
|
| theorem planeSeries_hasH1Gradient {a : ℤ → ℂ} |
| (h0 : Summable (fun m => ‖a m‖)) |
| (h1 : Summable (fun m => (m.natAbs:ℝ)*‖a m‖)) : |
| HasH1Gradient disk (planeSeries a) (planeGrad a) := by |
| apply HasH1Gradient.of_hasFDerivAt isOpen_ball |
| ((planeSeries_continuousOn h0).mono ball_subset_closedBall) |
| ((planeGrad_continuousOn h1).mono ball_subset_closedBall) |
| · intro x hx |
| simpa only [planeGrad,LinearIsometryEquiv.apply_symm_apply] using planeSeries_hasFDerivAt h0 h1 hx |
| · exact disk_memLp_of_continuousOn (planeSeries_continuousOn h0) |
| · exact disk_memLp_of_continuousOn (planeGrad_continuousOn h1) |
|
|
| lemma planeSeries_gradient {a : ℤ → ℂ} |
| (h0 : Summable (fun m => ‖a m‖)) |
| (h1 : Summable (fun m => (m.natAbs:ℝ)*‖a m‖)) : |
| HasH1Gradient disk (planeSeries a) (gradient (planeSeries a)) := by |
| have h := planeSeries_hasH1Gradient h0 h1 |
| have he : planeGrad a =ᵐ[volume.restrict disk] gradient (planeSeries a) := by |
| filter_upwards [ae_restrict_mem measurableSet_ball] with x hx |
| unfold planeGrad gradient |
| rw [(planeSeries_hasFDerivAt h0 h1 hx).fderiv] |
| exact ⟨h.1,h.2.1.ae_eq he,fun φ hφ hc hs e => by |
| rw [h.2.2 φ hφ hc hs e] |
| congr 1 |
| apply integral_congr_ae |
| filter_upwards [he] with x hx |
| rw [hx]⟩ |
|
|
| end StrictHotSpots.Douglas |
| end DouglasH1CombinedLayer |
|
|
| section DouglasInteriorCombinedLayer |
| open Set MeasureTheory Filter Metric AddCircle |
| open scoped Topology ComplexConjugate ContDiff InnerProductSpace |
| namespace StrictHotSpots.Douglas |
| open PlaneGreen DiskH10 |
|
|
| lemma harmonicSeries_re_poisson {a : ℤ → ℂ} (ha : Summable (fun m => ‖a m‖)) |
| {z : ℂ} (hz : z ∈ ball 0 1) : |
| Real.circleAverage (poissonKernel 0 z • (fun w => (harmonicSeries a w).re)) 0 1 = |
| (harmonicSeries a z).re := by |
| have hc := (harmonicSeries_continuousOn ha).mono sphere_subset_closedBall |
| have hi := ((poissonKernel_continuousOn_sphere hz).smul hc).circleIntegrable (by norm_num : (0:ℝ) ≤ 1) |
| have he := Complex.reCLM.circleAverage_comp_comm hi |
| calc |
| _ = (Real.circleAverage (poissonKernel 0 z • harmonicSeries a) 0 1).re := by |
| convert he using 1 |
| · congr 1 |
| funext w |
| simp [Pi.smul_apply'] |
| · rfl |
| _ = _ := congrArg Complex.re (harmonicSeries_poisson ha hz) |
| |
| lemma poissonAverage_contDiffOn {f : ℂ → ℝ} (hf : CircleIntegrable f 0 1) : |
| ContDiffOn ℝ ∞ (fun z => Real.circleAverage (poissonKernel 0 z • f) 0 1) (ball 0 1) := by |
| have hfc : CircleIntegrable (fun z => (f z : ℂ)) 0 1 := by |
| simp only [CircleIntegrable,intervalIntegrable_iff] at hf ⊢ |
| exact Complex.ofRealCLM.integrable_comp hf |
| have hball : ball (0 : ℂ) 1 ⊆ (sphere (0 : ℂ) |(1 : ℝ)|)ᶜ := by |
| intro z hz |
| rw [Set.mem_compl_iff, abs_one, Metric.mem_sphere] |
| exact ne_of_lt (Metric.mem_ball.mp hz) |
| have ha := (analyticOnNhd_circleAverage_herglotzRieszKernel_smul hfc).mono hball |
| have hc : ContDiffOn ℝ ∞ (fun z => |
| (Real.circleAverage (fun ζ => herglotzRieszKernel 0 z ζ • (f ζ : ℂ)) 0 1).re) |
| (ball 0 1) := |
| Complex.reCLM.contDiff.comp_contDiffOn (ha.contDiffOn_of_completeSpace.restrict_scalars ℝ) |
| apply hc.congr |
| intro z hz |
| rw [re_circleAverage_herglotzRieszKernel_smul hf (hball hz)] |
| congr 1 |
| funext ζ |
| simp only [poissonKernel_eq_re_herglotzRieszKernel] |
| |
| lemma harmonicSeries_re_contDiffOn {a : ℤ → ℂ} (ha : Summable (fun m => ‖a m‖)) : |
| ContDiffOn ℝ ∞ (fun z => (harmonicSeries a z).re) (ball 0 1) := by |
| have hc := Complex.continuous_re.comp_continuousOn |
| ((harmonicSeries_continuousOn ha).mono sphere_subset_closedBall) |
| apply (poissonAverage_contDiffOn (hc.circleIntegrable (by norm_num : (0:ℝ) ≤ 1))).congr |
| intro z hz |
| exact (harmonicSeries_re_poisson ha hz).symm |
| |
| lemma planeSeries_contDiffOn {a : ℤ → ℂ} (ha : Summable (fun m => ‖a m‖)) : |
| ContDiffOn ℝ ∞ (planeSeries a) disk := by |
| apply (harmonicSeries_re_contDiffOn ha).comp complexIso.symm.contDiff.contDiffOn |
| intro x hx |
| simpa only [disk,mem_ball_zero_iff,LinearIsometryEquiv.norm_map] using hx |
| |
| end StrictHotSpots.Douglas |
| end DouglasInteriorCombinedLayer |
| |
| section PlaneWavesCombinedLayer |
| open Set MeasureTheory Filter |
| open scoped Topology InnerProductSpace ContDiff Laplacian |
| namespace StrictHotSpots.PlaneWaves |
| |
| def cosine (k : Plane) (x : Plane) : ℝ := Real.cos (inner ℝ k x) |
| def sine (k : Plane) (x : Plane) : ℝ := Real.sin (inner ℝ k x) |
| |
| lemma cosine_smooth (k : Plane) : ContDiff ℝ ∞ (cosine k) := |
| (innerSL ℝ k).contDiff.cos |
| lemma sine_smooth (k : Plane) : ContDiff ℝ ∞ (sine k) := |
| (innerSL ℝ k).contDiff.sin |
| |
| lemma fderiv_cosine (k x : Plane) : |
| fderiv ℝ (cosine k) x = (-sine k x) • innerSL ℝ k := by |
| exact ((innerSL ℝ k).hasFDerivAt.cos).fderiv |
| lemma fderiv_sine (k x : Plane) : |
| fderiv ℝ (sine k) x = cosine k x • innerSL ℝ k := by |
| exact ((innerSL ℝ k).hasFDerivAt.sin).fderiv |
| |
| lemma gradient_cosine (k x : Plane) : gradient (cosine k) x = (-sine k x) • k := by |
| apply ext_inner_right ℝ |
| intro v |
| rw [inner_gradient_left,real_inner_smul_left,fderiv_cosine] |
| rfl |
| lemma gradient_sine (k x : Plane) : gradient (sine k) x = cosine k x • k := by |
| apply ext_inner_right ℝ |
| intro v |
| rw [inner_gradient_left,real_inner_smul_left,fderiv_sine] |
| rfl |
| |
| lemma cosine_memLp {Ω : Set Plane} (hb : Bornology.IsBounded Ω) (k : Plane) : |
| MemLp (cosine k) 2 (volume.restrict Ω) := by |
| let : IsFiniteMeasure (volume.restrict Ω) := isFiniteMeasure_restrict.mpr hb.measure_lt_top.ne |
| exact MemLp.of_bound (cosine_smooth k).continuous.aestronglyMeasurable 1 |
| (Eventually.of_forall fun x => Real.norm_eq_abs _ ▸ Real.abs_cos_le_one _) |
| lemma sine_memLp {Ω : Set Plane} (hb : Bornology.IsBounded Ω) (k : Plane) : |
| MemLp (sine k) 2 (volume.restrict Ω) := by |
| let : IsFiniteMeasure (volume.restrict Ω) := isFiniteMeasure_restrict.mpr hb.measure_lt_top.ne |
| exact MemLp.of_bound (sine_smooth k).continuous.aestronglyMeasurable 1 |
| (Eventually.of_forall fun x => Real.norm_eq_abs _ ▸ Real.abs_sin_le_one _) |
| |
| lemma cosine_h1 {Ω : Set Plane} (hΩ : IsOpen Ω) (hb : Bornology.IsBounded Ω) (k : Plane) : |
| HasH1Gradient Ω (cosine k) (fun x => (-sine k x) • k) := by |
| have he : gradient (cosine k) = fun x => (-sine k x) • k := funext (gradient_cosine k) |
| rw [← he] |
| apply HasH1Gradient.of_contDiffOn hΩ (cosine_smooth k).contDiffOn (cosine_memLp hb k) |
| rw [he] |
| exact (ContinuousLinearMap.smulRight (ContinuousLinearMap.id ℝ ℝ) k).comp_memLp' (sine_memLp hb k).neg |
| lemma sine_h1 {Ω : Set Plane} (hΩ : IsOpen Ω) (hb : Bornology.IsBounded Ω) (k : Plane) : |
| HasH1Gradient Ω (sine k) (fun x => cosine k x • k) := by |
| have he : gradient (sine k) = fun x => cosine k x • k := funext (gradient_sine k) |
| rw [← he] |
| apply HasH1Gradient.of_contDiffOn hΩ (sine_smooth k).contDiffOn (sine_memLp hb k) |
| rw [he] |
| exact (ContinuousLinearMap.smulRight (ContinuousLinearMap.id ℝ ℝ) k).comp_memLp' (cosine_memLp hb k) |
| |
| lemma cosine_sine_sq (k x : Plane) : cosine k x ^ 2 + sine k x ^ 2 = 1 := |
| Real.cos_sq_add_sin_sq _ |
| |
| lemma laplacian_cosine (k x : Plane) : Δ (cosine k) x = -‖k‖^2 * cosine k x := by |
| let b := stdOrthonormalBasis ℝ Plane |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis _ b] |
| have hd : ∀ i, iteratedFDeriv ℝ 2 (cosine k) x ![b i, b i] = |
| -(inner ℝ k (b i))^2 * cosine k x := by |
| intro i |
| simp only [iteratedFDeriv_two_apply, Matrix.cons_val_zero, Matrix.cons_val_one] |
| have hc : fderiv ℝ (cosine k) = fun y => (-sine k y) • innerSL ℝ k := |
| funext (fderiv_cosine k) |
| rw [hc, fderiv_smul_const (c := fun y : Plane => -(sine k y)) ((sine_smooth k).differentiable (by simp) x).neg (innerSL ℝ k : Plane →L[ℝ] ℝ), |
| fderiv_fun_neg, fderiv_sine] |
| simp |
| ring |
| change (∑ i, iteratedFDeriv ℝ 2 _ x ![b i, b i]) = _ |
| simp_rw [hd] |
| rw [← Finset.sum_mul] |
| have hs : ∑ i, (inner ℝ k (b i))^2 = ‖k‖^2 := by |
| simpa only [pow_two,real_inner_self_eq_norm_sq,real_inner_comm (b _) k] using (b.sum_inner_mul_inner k k) |
| rw [Finset.sum_neg_distrib,hs] |
| |
| lemma laplacian_sine (k x : Plane) : Δ (sine k) x = -‖k‖^2 * sine k x := by |
| let b := stdOrthonormalBasis ℝ Plane |
| rw [InnerProductSpace.laplacian_eq_iteratedFDeriv_orthonormalBasis _ b] |
| have hd : ∀ i, iteratedFDeriv ℝ 2 (sine k) x ![b i, b i] = |
| -(inner ℝ k (b i))^2 * sine k x := by |
| intro i |
| simp only [iteratedFDeriv_two_apply, Matrix.cons_val_zero, Matrix.cons_val_one] |
| have hc : fderiv ℝ (sine k) = fun y => cosine k y • innerSL ℝ k := |
| funext (fderiv_sine k) |
| rw [hc, fderiv_smul_const ((cosine_smooth k).differentiable (by simp) x) (innerSL ℝ k : Plane →L[ℝ] ℝ), |
| fderiv_cosine] |
| simp |
| ring |
| change (∑ i, iteratedFDeriv ℝ 2 _ x ![b i, b i]) = _ |
| simp_rw [hd] |
| rw [← Finset.sum_mul] |
| have hs : ∑ i, (inner ℝ k (b i))^2 = ‖k‖^2 := by |
| simpa only [pow_two,real_inner_self_eq_norm_sq,real_inner_comm (b _) k] using (b.sum_inner_mul_inner k k) |
| rw [Finset.sum_neg_distrib,hs] |
| |
| end StrictHotSpots.PlaneWaves |
| end PlaneWavesCombinedLayer |
| |
| section LowerEulerCombinedLayer |
| open Set MeasureTheory Filter |
| open scoped Topology InnerProductSpace |
| namespace StrictHotSpots |
| lemma lower_rayleigh {Ω : Set Plane} {v : Plane → ℝ} {g : Plane → Plane} {lam : ℝ} |
| (hle : lam ≤ firstPositiveNeumannValue Ω) |
| (hv : HasH1Gradient Ω v g) (hm : (∫ x in Ω, v x) = 0) : |
| lam * (∫ x in Ω, (v x)^2) ≤ ∫ x in Ω, ‖g x‖^2 := |
| (mul_le_mul_of_nonneg_right hle (integral_nonneg fun x => sq_nonneg (v x))).trans |
| (rayleigh_inequality_all hv hm) |
| |
| |
| lemma lower_euler_mean_zero {Ω : Set Plane} {u v : Plane → ℝ} |
| {g k : Plane → Plane} {lam : ℝ} |
| (hle : lam ≤ firstPositiveNeumannValue Ω) (hb : Bornology.IsBounded Ω) |
| (hu : HasH1Gradient Ω u g) (hv : HasH1Gradient Ω v k) |
| (hmu : (∫ x in Ω, u x) = 0) (hmv : (∫ x in Ω, v x) = 0) |
| (he : (∫ x in Ω, ‖g x‖ ^ 2) = |
| lam * (∫ x in Ω, (u x) ^ 2)) : |
| (∫ x in Ω, inner ℝ (g x) (k x)) = |
| lam * (∫ x in Ω, u x * v x) := by |
| let : IsFiniteMeasure (volume.restrict Ω) := ⟨by simpa using hb.measure_lt_top⟩ |
| have hui : Integrable u (volume.restrict Ω) := hu.1.integrable (by norm_num) |
| have hvi : Integrable v (volume.restrict Ω) := hv.1.integrable (by norm_num) |
| have hvar (t : ℝ) := lower_rayleigh hle (hu.add (hv.smul t)) (by |
| show (∫ x in Ω, u x + t * v x) = 0 |
| rw [integral_add hui (hvi.const_mul t), integral_const_mul, hmu, hmv] |
| ring) |
| have hpoly : ∀ t : ℝ, 0 ≤ |
| ((∫ x in Ω, ‖k x‖ ^ 2) - lam * (∫ x in Ω, (v x) ^ 2)) * (t * t) + |
| (2 * ((∫ x in Ω, inner ℝ (g x) (k x)) - |
| lam * (∫ x in Ω, u x * v x))) * t + 0 := by |
| intro t |
| have ht := hvar t |
| simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul] at ht |
| rw [integral_norm_add_smul_sq hu.2.1 hv.2.1 t, |
| integral_sq_add_mul hu.1 hv.1 t, he] at ht |
| nlinarith |
| have hd := discrim_le_zero hpoly |
| simp only [discrim, mul_zero, sub_zero] at hd |
| nlinarith [sq_nonneg ((∫ x in Ω, inner ℝ (g x) (k x)) - |
| lam * (∫ x in Ω, u x * v x))] |
| |
| |
| |
| lemma lower_euler {Ω : Set Plane} {u v : Plane → ℝ} {g k : Plane → Plane} {lam : ℝ} |
| (hle : lam ≤ firstPositiveNeumannValue Ω) |
| (hb : Bornology.IsBounded Ω) (hvol : 0 < (volume Ω).toReal) |
| (hu : HasH1Gradient Ω u g) (hv : HasH1Gradient Ω v k) |
| (hmu : (∫ x in Ω, u x) = 0) |
| (he : (∫ x in Ω, ‖g x‖ ^ 2) = |
| lam * (∫ x in Ω, (u x) ^ 2)) : |
| (∫ x in Ω, inner ℝ (g x) (k x)) = |
| lam * (∫ x in Ω, u x * v x) := by |
| let : IsFiniteMeasure (volume.restrict Ω) := ⟨by simpa using hb.measure_lt_top⟩ |
| let c := (∫ x in Ω, v x) / (volume Ω).toReal |
| have hui : Integrable u (volume.restrict Ω) := hu.1.integrable (by norm_num) |
| have hvi : Integrable v (volume.restrict Ω) := hv.1.integrable (by norm_num) |
| have hw : HasH1Gradient Ω (fun x => v x - c) k := by |
| change HasH1Gradient Ω (v - fun _ => c) k |
| simpa only [sub_zero] using hv.sub (HasH1Gradient.const hb c) |
| have hm : (∫ x in Ω, v x - c) = 0 := by |
| rw [integral_sub hvi (integrable_const c)] |
| simp only [integral_const, measureReal_restrict_apply_univ, smul_eq_mul] |
| change (∫ x in Ω, v x) - (volume Ω).toReal * c = 0 |
| dsimp [c] |
| field_simp |
| ring |
| have hh := lower_euler_mean_zero hle hb hu hw hmu hm he |
| have hi : (∫ x in Ω, u x * (v x - c)) = (∫ x in Ω, u x * v x) := by |
| simp only [mul_sub] |
| have huv : Integrable (fun x => u x * v x) (volume.restrict Ω) := hu.1.integrable_mul hv.1 |
| rw [integral_sub huv (hui.mul_const c), |
| integral_mul_const, hmu, zero_mul, sub_zero] |
| rwa [hi] at hh |
| |
| |
| end StrictHotSpots |
| end LowerEulerCombinedLayer |
| |
| section L2InnerToLpCombinedLayer |
| open MeasureTheory Filter |
| open scoped ENNReal InnerProductSpace |
| namespace StrictHotSpots.L2Inner |
| lemma toLp_pair {α E : Type*} [MeasurableSpace α] {μ : Measure α} |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| {f g : α → E} (hf : MemLp f 2 μ) (hg : MemLp g 2 μ) : |
| inner ℝ (hf.toLp f) (hg.toLp g) = ∫ x, inner ℝ (f x) (g x) ∂μ := by |
| rw [L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [hf.coeFn_toLp,hg.coeFn_toLp] with x hx hy |
| rw [hx,hy] |
| lemma toLp_left {α E : Type*} [MeasurableSpace α] {μ : Measure α} |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| {f : α → E} (hf : MemLp f 2 μ) (g : Lp E 2 μ) : |
| inner ℝ (hf.toLp f) g = ∫ x, inner ℝ (f x) (g x) ∂μ := by |
| rw [L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [hf.coeFn_toLp] with x hx |
| rw [hx] |
| lemma toLp_right {α E : Type*} [MeasurableSpace α] {μ : Measure α} |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| {g : α → E} (f : Lp E 2 μ) (hg : MemLp g 2 μ) : |
| inner ℝ f (hg.toLp g) = ∫ x, inner ℝ (f x) (g x) ∂μ := by |
| rw [L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [hg.coeFn_toLp] with x hx |
| rw [hx] |
| end StrictHotSpots.L2Inner |
| end L2InnerToLpCombinedLayer |
| |
| section H1RayleighFormCombinedLayer |
| open Set MeasureTheory Filter |
| open scoped InnerProductSpace Topology |
| namespace StrictHotSpots |
| private lemma two_inner_sub_left {A B : Type*} [NormedAddCommGroup A] [InnerProductSpace ℝ A] |
| [NormedAddCommGroup B] [InnerProductSpace ℝ B] (lam : ℝ) (a b c : A) (x y z : B) : |
| inner ℝ (a-b) c - lam * inner ℝ (x-y) z = |
| (inner ℝ a c - lam * inner ℝ x z) - (inner ℝ b c - lam * inner ℝ y z) := by |
| rw [inner_sub_left,inner_sub_left] |
| ring |
| private lemma two_inner_sub_right {A B : Type*} [NormedAddCommGroup A] [InnerProductSpace ℝ A] |
| [NormedAddCommGroup B] [InnerProductSpace ℝ B] (lam : ℝ) (a b c : A) (x y z : B) : |
| inner ℝ a (b-c) - lam * inner ℝ x (y-z) = |
| (inner ℝ a b - lam * inner ℝ x y) - (inner ℝ a c - lam * inner ℝ x z) := by |
| rw [inner_sub_right,inner_sub_right] |
| ring |
| end StrictHotSpots |
| namespace StrictHotSpots.H1 |
| variable {Ω : Set Plane} |
| local instance : NormedSpace ℝ (H1 Ω) := (h1Graph Ω).normedSpace |
| def form (lam : ℝ) (u v : H1 Ω) : ℝ := |
| inner ℝ (grad u) (grad v) - lam * inner ℝ (value u) (value v) |
| |
| lemma form_symm (lam : ℝ) (u v : H1 Ω) : form lam u v = form lam v u := by |
| exact congrArg₂ (fun a b : ℝ => a - lam * b) |
| (real_inner_comm (grad u) (grad v)).symm (real_inner_comm (value u) (value v)).symm |
| lemma form_sub_left (lam : ℝ) (u v w : H1 Ω) : |
| form lam (u-v) w = form lam u w - form lam v w := by |
| exact StrictHotSpots.two_inner_sub_left lam (grad u) (grad v) (grad w) (value u) (value v) (value w) |
| lemma form_sub_right (lam : ℝ) (u v w : H1 Ω) : |
| form lam u (v-w) = form lam u v - form lam u w := by |
| exact StrictHotSpots.two_inner_sub_right lam (grad u) (grad v) (grad w) (value u) (value v) (value w) |
| lemma form_smul_left (lam c : ℝ) (u v : H1 Ω) : |
| form lam (c • u) v = c * form lam u v := by |
| unfold form |
| change inner ℝ (c • grad u) (grad v) - lam * inner ℝ (c • value u) (value v) = _ |
| rw [real_inner_smul_left,real_inner_smul_left] |
| ring |
| lemma form_smul_right (lam c : ℝ) (u v : H1 Ω) : |
| form lam u (c • v) = c * form lam u v := by |
| unfold form |
| change inner ℝ (grad u) (c • grad v) - lam * inner ℝ (value u) (c • value v) = _ |
| rw [real_inner_smul_right,real_inner_smul_right] |
| ring |
| lemma form_diag_sub (lam c : ℝ) (u v : H1 Ω) |
| (hv : form lam v v = 0) (huv : form lam u v = 0) : |
| form lam (u-c•v) (u-c•v) = form lam u u := by |
| rw [form_sub_left,form_sub_right,form_sub_right,form_smul_right, |
| form_smul_left,form_smul_left,form_smul_right,hv,huv,← form_symm lam u v,huv] |
| ring |
| |
| variable (hb : Bornology.IsBounded Ω) |
| def mean : H1 Ω →L[ℝ] ℝ := by |
| let : IsFiniteMeasure (volume.restrict Ω) := isFiniteMeasure_restrict.mpr hb.measure_lt_top.ne |
| exact (innerSL ℝ ((memLp_const (1 : ℝ)).toLp (fun _ : Plane => (1 : ℝ)))).comp value |
| |
| lemma mean_eq (u : H1 Ω) : mean hb u = ∫ x in Ω, value u x := by |
| let : IsFiniteMeasure (volume.restrict Ω) := isFiniteMeasure_restrict.mpr hb.measure_lt_top.ne |
| change inner ℝ ((memLp_const (1 : ℝ)).toLp _) (value u) = _ |
| rw [L2Inner.toLp_left] |
| simp only [RCLike.inner_apply,RCLike.conj_to_real,mul_one] |
| |
| lemma form_self_integral (lam : ℝ) (u : H1 Ω) : |
| form lam u u = (∫ x in Ω, ‖grad u x‖^2) - lam * (∫ x in Ω, (value u x)^2) := by |
| simp only [form,L2.inner_def,real_inner_self_eq_norm_sq,Real.norm_eq_abs,sq_abs] |
| |
| lemma form_nonneg {lam : ℝ} (hle : lam ≤ firstPositiveNeumannValue Ω) |
| (u : H1 Ω) (hm : mean hb u = 0) : 0 ≤ form lam u u := by |
| rw [form_self_integral] |
| exact sub_nonneg.mpr (lower_rayleigh hle (hasH1Gradient u) ((mean_eq hb u).symm.trans hm)) |
| |
| lemma form_zero_euler {lam : ℝ} (hle : lam ≤ firstPositiveNeumannValue Ω) |
| (hvol : 0 < (volume Ω).toReal) (u : H1 Ω) (hm : mean hb u = 0) |
| (hz : form lam u u = 0) (v : H1 Ω) : form lam u v = 0 := by |
| rw [form_self_integral,sub_eq_zero] at hz |
| have he := lower_euler hle hb hvol (hasH1Gradient u) (hasH1Gradient v) |
| ((mean_eq hb u).symm.trans hm) hz |
| rw [form,L2.inner_def,L2.inner_def] |
| simp only [RCLike.inner_apply,RCLike.conj_to_real] |
| rw [show (fun x => value v x * value u x) = (fun x => value u x * value v x) by funext; ring,he,sub_self] |
| |
| end StrictHotSpots.H1 |
| end H1RayleighFormCombinedLayer |
| |
| section CompactRowsCombinedLayer |
| |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology InnerProductSpace |
| namespace StrictHotSpots.CompactRows |
| variable {α H : Type*} [MeasurableSpace α] {μ : Measure α} |
| [NormedAddCommGroup H] [InnerProductSpace ℝ H] |
| |
| def rowOperator : Lp H 2 μ →L[ℝ] H →L[ℝ] Lp ℝ 2 μ := |
| (ContinuousLinearMap.compLpL₂ 2 μ (innerSL ℝ)).flip |
| |
| lemma rowOperator_apply_ae (r : Lp H 2 μ) (v : H) : |
| rowOperator r v =ᵐ[μ] fun x => inner ℝ v (r x) := |
| (innerSL ℝ v).coeFn_compLp r |
| |
| lemma rowOperator_compact_simple (r : Lp.simpleFunc H 2 μ) : |
| IsCompactOperator (rowOperator (r : Lp H 2 μ)) := by |
| let V : Submodule ℝ H := Submodule.span ℝ (Set.range (Lp.simpleFunc.toSimpleFunc r)) |
| have : FiniteDimensional ℝ V := FiniteDimensional.span_of_finite ℝ (Lp.simpleFunc.toSimpleFunc r).finite_range |
| have he : rowOperator (r : Lp H 2 μ) = |
| ((rowOperator (r : Lp H 2 μ)).comp V.subtypeL).comp V.orthogonalProjectionOnto := by |
| apply ContinuousLinearMap.ext |
| intro v |
| apply Lp.ext |
| filter_upwards [rowOperator_apply_ae (r : Lp H 2 μ) v, |
| rowOperator_apply_ae (r : Lp H 2 μ) (V.orthogonalProjectionOnto v), |
| Lp.simpleFunc.toSimpleFunc_eq_toFun r] with x hx hy hr |
| change rowOperator (r : Lp H 2 μ) v x = |
| rowOperator (r : Lp H 2 μ) (V.orthogonalProjectionOnto v) x |
| rw [hx, hy, ← hr] |
| have hmem : (Lp.simpleFunc.toSimpleFunc r) x ∈ V := Submodule.subset_span ⟨x, rfl⟩ |
| exact (V.inner_orthogonalProjectionOnto_eq_of_mem_right ⟨_,hmem⟩ v).symm |
| rw [he] |
| exact (isCompactOperator_of_locallyCompactSpace_dom V.orthogonalProjectionOnto).clm_comp |
| ((rowOperator (r : Lp H 2 μ)).comp V.subtypeL) |
| |
| |
| |
| theorem rowOperator_compact (r : Lp H 2 μ) : IsCompactOperator (rowOperator r) := by |
| have hc : IsClosed {f : Lp H 2 μ | IsCompactOperator (rowOperator f)} := |
| isClosed_setOfPred_isCompactOperator.preimage |
| (rowOperator (μ := μ) (H := H)).continuous |
| apply closure_minimal (fun f hf => rowOperator_compact_simple ⟨f,hf⟩) hc |
| exact Lp.simpleFunc.dense (by norm_num) r |
| |
| end StrictHotSpots.CompactRows |
| end CompactRowsCombinedLayer |
| |
| section MeasurableRowsCombinedLayer |
| |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology InnerProductSpace |
| namespace StrictHotSpots.CompactRows |
| |
| lemma measurable_of_dist {α E : Type*} [MeasurableSpace α] [MetricSpace E] |
| [MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E] |
| {f : α → E} (h : ∀ y, Measurable (fun x => dist (f x) y)) : Measurable f := by |
| let B : Set (Set E) := {s | ∃ y r, s = Metric.ball y r} |
| have hb : TopologicalSpace.IsTopologicalBasis B := |
| TopologicalSpace.isTopologicalBasis_of_isOpen_of_nhds |
| (by rintro s ⟨y,r,rfl⟩; exact Metric.isOpen_ball) |
| (by intro x s hx hs |
| obtain ⟨r,hr,hrs⟩ := Metric.isOpen_iff.mp hs x hx |
| exact ⟨Metric.ball x r, ⟨x,r,rfl⟩, Metric.mem_ball_self hr, hrs⟩) |
| rw [BorelSpace.measurable_eq (α := E), hb.borel_eq_generateFrom] |
| apply measurable_generateFrom |
| rintro s ⟨y,r,rfl⟩ |
| exact measurableSet_lt (h y) measurable_const |
| |
| variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| {ν : Measure Y} [SFinite ν] [IsSeparable ν] |
| |
| local instance : Fact ((2 : ℝ≥0∞) ≠ ∞) := ⟨by norm_num⟩ |
| |
| local instance : MeasurableSpace (Lp ℝ 2 ν) := borel _ |
| local instance : BorelSpace (Lp ℝ 2 ν) := ⟨rfl⟩ |
| |
| lemma measurable_toLp_rows (K : X × Y → ℝ) (hK : Measurable K) |
| (hrow : ∀ x, MemLp (fun y => K (x,y)) 2 ν) : |
| Measurable (fun x => (hrow x).toLp (fun y => K (x,y))) := by |
| apply measurable_of_dist |
| intro f |
| let R := fun x => (hrow x).toLp (fun y => K (x,y)) |
| have he (x : X) : dist (R x) f = Real.sqrt (∫ y, (K (x,y) - f y)^2 ∂ν) := by |
| rw [dist_eq_norm] |
| have hs : ∫ y, (K (x,y) - f y)^2 ∂ν = ‖R x - f‖^2 := by |
| rw [← real_inner_self_eq_norm_sq, L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [Lp.coeFn_sub (R x) f, (hrow x).coeFn_toLp] with y hy hz |
| simp only [Pi.sub_apply] at hy |
| rw [real_inner_self_eq_norm_sq, hy, hz, Real.norm_eq_abs, sq_abs] |
| rw [hs, Real.sqrt_sq (norm_nonneg _)] |
| have hm : Measurable (fun p : X × Y => (K p - f p.2)^2) := |
| (hK.sub ((Lp.stronglyMeasurable f).measurable.comp measurable_snd)).pow_const 2 |
| simpa only [← he] using ((hm.stronglyMeasurable.integral_prod_right' (ν := ν)).measurable).sqrt |
|
|
| end StrictHotSpots.CompactRows |
| end MeasurableRowsCombinedLayer |
|
|
| section CompactCoerciveCombinedLayer |
| open Set |
| open scoped InnerProductSpace Topology |
| namespace StrictHotSpots.CompactCoercive |
| variable {E H V : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup H] [InnerProductSpace ℝ H] |
| [NormedAddCommGroup V] [InnerProductSpace ℝ V] |
|
|
| lemma finite_projection_approx (T : E →L[ℝ] H) (hT : IsCompactOperator T) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∃ U : Submodule ℝ H, ∃ _ : FiniteDimensional ℝ U, |
| ‖T - U.starProjection.comp T‖ ≤ ε := by |
| obtain ⟨s,hs,hcover⟩ := Metric.totallyBounded_iff.mp |
| (hT.isCompact_closure_image_closedBall 1).totallyBounded ε hε |
| let U := Submodule.span ℝ s |
| let : FiniteDimensional ℝ U := FiniteDimensional.span_of_finite ℝ hs |
| refine ⟨U,inferInstance,ContinuousLinearMap.opNorm_le_of_unit_norm hε.le ?_⟩ |
| intro x hx |
| have hmem : T x ∈ closure (T '' Metric.closedBall 0 1) := |
| subset_closure ⟨x,by simpa using hx.le,rfl⟩ |
| obtain ⟨y,hy,hxy⟩ := mem_iUnion₂.mp (hcover hmem) |
| change ‖T x - U.starProjection (T x)‖ ≤ ε |
| have hmin := U.starProjection_minimal (T x) |
| rw [hmin] |
| exact (ciInf_le (by exact ⟨0, by rintro _ ⟨z,rfl⟩; exact norm_nonneg _⟩) |
| (⟨y,Submodule.subset_span hy⟩ : U)).trans (by exact (show ‖T x - y‖ < ε by simpa [Metric.mem_ball, dist_eq_norm] using hxy).le) |
|
|
|
|
|
|
| lemma observation_compact [CompleteSpace H] (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) |
| (J : V →L[ℝ] H) (S : H →L[ℝ] V) |
| (hS : ∀ f v, B (S f) v = inner ℝ f (J v)) |
| (hc : IsCompactOperator (J.comp S)) : IsCompactOperator J := by |
| obtain ⟨C,hC,hcoer⟩ := hB |
| have hcl : J ∈ closure {A : V →L[ℝ] H | IsCompactOperator A} := by |
| rw [Metric.mem_closure_iff] |
| intro δ hδ |
| let q : ℝ := δ / (2 * (‖B‖ + 1)) |
| have hq : 0 < q := div_pos hδ (mul_pos (by norm_num) (by positivity)) |
| obtain ⟨U,hU,happrox⟩ := finite_projection_approx (J.comp S) hc |
| (mul_pos hC (sq_pos_of_pos hq)) |
| let : FiniteDimensional ℝ U := hU |
| let A : V →L[ℝ] H := U.starProjection.comp J |
| have hAc : IsCompactOperator A := |
| ((isCompactOperator_of_locallyCompactSpace_rng U.subtypeL).comp_clm |
| U.orthogonalProjectionOnto).comp_clm J |
| refine ⟨A,hAc,?_⟩ |
| have ha : ‖J - A‖ ≤ ‖B‖ * q := by |
| apply ContinuousLinearMap.opNorm_le_bound (J - A) (mul_nonneg (norm_nonneg B) hq.le) |
| intro v |
| let w := J v - U.starProjection (J v) |
| have hwproj : inner ℝ w (U.starProjection (J v)) = 0 := |
| U.starProjection_inner_eq_zero (J v) _ (U.orthogonalProjectionOnto (J v)).property |
| have hwJ : inner ℝ w (J v) = ‖w‖^2 := by |
| calc |
| _ = inner ℝ w (w + U.starProjection (J v)) := by |
| congr 1; dsimp [w]; abel |
| _ = _ := by rw [inner_add_right, hwproj, add_zero, real_inner_self_eq_norm_sq] |
| have hwTproj : inner ℝ w (U.starProjection ((J.comp S) w)) = 0 := |
| U.starProjection_inner_eq_zero (J v) _ (U.orthogonalProjectionOnto ((J.comp S) w)).property |
| have ht : inner ℝ w ((J.comp S) w) ≤ C * q^2 * ‖w‖^2 := by |
| calc |
| _ = inner ℝ w (((J.comp S) - U.starProjection.comp (J.comp S)) w) := by |
| change inner ℝ w (J (S w)) = inner ℝ w (J (S w) - U.starProjection (J (S w))) |
| have hz : inner ℝ w (U.starProjection (J (S w))) = 0 := hwTproj |
| rw [inner_sub_right, hz, sub_zero] |
| _ ≤ ‖w‖ * ‖((J.comp S) - U.starProjection.comp (J.comp S)) w‖ := |
| real_inner_le_norm _ _ |
| _ ≤ ‖w‖ * ((C * q^2) * ‖w‖) := by |
| gcongr |
| exact (((J.comp S) - U.starProjection.comp (J.comp S)).le_opNorm w).trans |
| (mul_le_mul_of_nonneg_right happrox (norm_nonneg _)) |
| _ = _ := by ring |
| have hs : ‖S w‖ ≤ q * ‖w‖ := by |
| have h0 := (hcoer (S w)).trans (by simpa only [hS, ContinuousLinearMap.comp_apply] using ht) |
| have h1 : ‖S w‖^2 ≤ (q * ‖w‖)^2 := by nlinarith |
| nlinarith [norm_nonneg (S w), mul_nonneg hq.le (norm_nonneg w)] |
| have hv : ‖w‖^2 ≤ ‖B‖ * ‖S w‖ * ‖v‖ := by |
| calc |
| _ = B (S w) v := (hS w v).trans hwJ |>.symm |
| _ ≤ ‖B (S w) v‖ := le_abs_self _ |
| _ ≤ ‖B (S w)‖ * ‖v‖ := (B (S w)).le_opNorm v |
| _ ≤ _ := mul_le_mul_of_nonneg_right (B.le_opNorm (S w)) (norm_nonneg _) |
| have hv' : ‖w‖^2 ≤ (‖B‖ * q * ‖v‖) * ‖w‖ := by |
| calc |
| _ ≤ ‖B‖ * ‖S w‖ * ‖v‖ := hv |
| _ ≤ ‖B‖ * (q * ‖w‖) * ‖v‖ := by gcongr |
| _ = _ := by ring |
| change ‖w‖ ≤ ‖B‖ * q * ‖v‖ |
| by_cases hw0 : ‖w‖ = 0 |
| · rw [hw0]; positivity |
| · have hwpos : 0 < ‖w‖ := lt_of_le_of_ne (norm_nonneg _) (Ne.symm hw0) |
| rw [pow_two] at hv' |
| exact (mul_le_mul_iff_left₀ hwpos).mp (by simpa only [mul_comm] using hv') |
| rw [dist_eq_norm] |
| have he : ‖B‖ * q < δ := by |
| dsimp [q] |
| have hd : 0 < 2 * (‖B‖ + 1) := by positivity |
| rw [← mul_div_assoc, div_lt_iff₀ hd] |
| nlinarith [norm_nonneg B] |
| simpa only [norm_sub_rev] using ha.trans_lt he |
| exact isClosed_setOfPred_isCompactOperator.closure_subset hcl |
| |
| end StrictHotSpots.CompactCoercive |
| end CompactCoerciveCombinedLayer |
| |
| section DiskCompactEmbeddingCombinedLayer |
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology InnerProductSpace |
| namespace StrictHotSpots.PlaneGreen |
| open DiskH10 |
| local instance : Fact ((2 : ℝ≥0∞) ≠ ∞) := ⟨by norm_num⟩ |
| |
| private def boundedKernel (p : Plane × Plane) : ℝ := by |
| classical |
| exact if p.1 ∈ disk then kernel p.1 p.2 else 0 |
| |
| private lemma boundedKernel_measurable : Measurable boundedKernel := |
| Measurable.ite (diskOpen.measurableSet.preimage measurable_fst) measurable_kernel measurable_const |
| |
| private lemma boundedKernel_memLp (x : Plane) : |
| MemLp (fun y => boundedKernel (x,y)) 2 (volume.restrict disk) := by |
| by_cases hx : x ∈ disk |
| · simpa only [boundedKernel, ite_eq_left hx] using kernel_memLp x hx |
| · simp only [boundedKernel, ite_eq_right hx] |
| exact MemLp.zero |
| |
| private def compactRow (x : Plane) : Lp ℝ 2 (volume.restrict disk) := |
| (boundedKernel_memLp x).toLp (fun y => boundedKernel (x,y)) |
| |
| private lemma compactRow_memLp : MemLp compactRow 2 (volume.restrict disk) := by |
| let : MeasurableSpace (Lp ℝ 2 (volume.restrict disk)) := borel _ |
| let : BorelSpace (Lp ℝ 2 (volume.restrict disk)) := ⟨rfl⟩ |
| have hm : Measurable compactRow := CompactRows.measurable_toLp_rows boundedKernel |
| boundedKernel_measurable boundedKernel_memLp |
| apply MemLp.of_bound hm.aestronglyMeasurable kernel_bound.choose |
| filter_upwards [ae_restrict_mem diskOpen.measurableSet] with x hx |
| rw [compactRow, Lp.norm_toLp] |
| simpa only [boundedKernel, ite_eq_left hx] using kernel_bound.choose_spec.2 x hx |
| |
| |
| |
| lemma integralOperator_compact : IsCompactOperator integralOperator := by |
| let r := compactRow_memLp.toLp compactRow |
| have he : integralOperator = CompactRows.rowOperator r := by |
| apply ContinuousLinearMap.ext |
| intro f |
| apply Lp.ext |
| filter_upwards [integralOperator_ae f, CompactRows.rowOperator_apply_ae r f, |
| compactRow_memLp.coeFn_toLp, ae_restrict_mem diskOpen.measurableSet] with x hx hy hr hxd |
| rw [hx,hy,hr,L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [(boundedKernel_memLp x).coeFn_toLp] with y hxy |
| change kernel x y * f y = inner ℝ (f y) (compactRow x y) |
| rw [RCLike.inner_apply] |
| change kernel x y * f y = compactRow x y * f y |
| congr 1 |
| have ht : compactRow x y = kernel x y := by |
| simpa only [compactRow, boundedKernel, ite_eq_left hxd] using hxy |
| exact ht.symm |
| rw [he] |
| exact CompactRows.rowOperator_compact r |
| |
| |
| |
| lemma value_compact : IsCompactOperator (H10.value diskOpen) := by |
| let B := H10.energy diskOpen |
| let hB := H10.energy_coercive diskOpen diskBounded |
| let J := H10.value diskOpen |
| let S := DirichletOperator.solution B hB J |
| apply CompactCoercive.observation_compact B hB J S |
| · exact DirichletOperator.solution_spec B hB J |
| · change IsCompactOperator variationalOperator |
| rw [← integralOperator_eq_variationalOperator] |
| exact integralOperator_compact |
| |
| end StrictHotSpots.PlaneGreen |
| end DiskCompactEmbeddingCombinedLayer |
| |
| section H10InclusionCombinedLayer |
| open Set MeasureTheory Filter |
| open scoped ENNReal Topology InnerProductSpace |
| namespace StrictHotSpots |
| |
| def smoothTestToH10 {Ω : Set Plane} (hΩ : IsOpen Ω) : smoothTestSpace Ω →ₗ[ℝ] H10 hΩ := |
| (smoothTestToH1 hΩ).codRestrict (h10Submodule hΩ) |
| (fun f => Submodule.le_topologicalClosure _ (LinearMap.mem_range_self _ f)) |
| |
| lemma dense_smoothTestToH10 {Ω : Set Plane} (hΩ : IsOpen Ω) : |
| DenseRange (smoothTestToH10 hΩ) := by |
| intro u |
| rw [Metric.mem_closure_iff] |
| intro ε hε |
| have hu : (u : H1 Ω) ∈ closure (Set.range (smoothTestToH1 hΩ)) := u.property |
| obtain ⟨v,⟨f,rfl⟩,hv⟩ := Metric.mem_closure_iff.mp hu ε hε |
| exact ⟨smoothTestToH10 hΩ f, ⟨f,rfl⟩, hv⟩ |
| |
| namespace H10 |
| variable {Ω Λ : Set Plane} (hΩ : IsOpen Ω) (hΛ : IsOpen Λ) (hsub : Ω ⊆ Λ) |
| |
| def includeTest : smoothTestSpace Ω →ₗ[ℝ] smoothTestSpace Λ where |
| toFun f := ⟨f.val,f.property.1,f.property.2.1,f.property.2.2.trans hsub⟩ |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
| |
| lemma includeTest_norm (f : smoothTestSpace Ω) : |
| ‖smoothTestToH10 hΛ (includeTest hsub f)‖ = ‖smoothTestToH10 hΩ f‖ := by |
| apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp |
| change ‖(smoothTestToH1 hΛ (includeTest hsub f))‖^2 = ‖smoothTestToH1 hΩ f‖^2 |
| rw [H1.norm_sq, H1.norm_sq] |
| rw [smoothTestToH1_value_norm, smoothTestToH1_grad_norm, |
| smoothTestToH1_value_norm, smoothTestToH1_grad_norm] |
| have hf : Function.support (f : Plane → ℝ) ⊆ Ω := (subset_tsupport _).trans f.property.2.2 |
| have hg : Function.support (gradient (f : Plane → ℝ)) ⊆ Ω := by |
| intro x hx |
| apply f.property.2.2 |
| by_contra hn |
| apply hx |
| rw [gradient, fderiv_of_notMem_tsupport ℝ hn, map_zero] |
| dsimp [includeTest] |
| have hfm := f.property.1.continuous.aestronglyMeasurable (μ := volume) |
| have hgm : AEStronglyMeasurable (gradient (f : Plane → ℝ)) volume := |
| ((InnerProductSpace.toDual ℝ Plane).symm.continuous.comp |
| (f.property.1.continuous_fderiv (by simp))).aestronglyMeasurable |
| rw [eLpNorm_restrict_eq_of_support_subset hfm (hf.trans hsub), |
| eLpNorm_restrict_eq_of_support_subset hgm (hg.trans hsub), |
| eLpNorm_restrict_eq_of_support_subset hfm hf, eLpNorm_restrict_eq_of_support_subset hgm hg] |
| |
| def inclusion : H10 hΩ →L[ℝ] H10 hΛ := |
| ((smoothTestToH10 hΛ).comp (includeTest hsub)).extendOfNorm (smoothTestToH10 hΩ) |
| |
| lemma inclusion_test (f : smoothTestSpace Ω) : |
| inclusion hΩ hΛ hsub (smoothTestToH10 hΩ f) = |
| smoothTestToH10 hΛ (includeTest hsub f) := |
| LinearMap.extendOfNorm_eq (dense_smoothTestToH10 hΩ) |
| ⟨1,fun f => by |
| rw [one_mul] |
| change ‖smoothTestToH10 hΛ (includeTest hsub f)‖ ≤ ‖smoothTestToH10 hΩ f‖ |
| exact le_of_eq (includeTest_norm hΩ hΛ hsub f)⟩ f |
| |
| def restriction : Lp ℝ 2 (volume.restrict Λ) →L[ℝ] Lp ℝ 2 (volume.restrict Ω) := |
| Lp.LpToLpOfMeasureLeSMul (by norm_num : (1 : ℝ≥0∞) ≠ ∞) |
| (by simpa using Measure.restrict_mono hsub (le_refl (volume : Measure Plane))) |
| |
| lemma value_inclusion : value hΩ = |
| (restriction hsub).comp ((value hΛ).comp (inclusion hΩ hΛ hsub)) := by |
| apply DFunLike.coe_injective |
| apply (dense_smoothTestToH10 hΩ).equalizer (value hΩ).continuous |
| ((restriction hsub).comp ((value hΛ).comp (inclusion hΩ hΛ hsub))).continuous |
| funext f |
| simp only [Function.comp_apply, ContinuousLinearMap.comp_apply, inclusion_test] |
| apply Lp.ext |
| have hs := Lp.coeFn_LpToLpOfMeasureLeSMul (by norm_num : (1 : ℝ≥0∞) ≠ ∞) |
| (show volume.restrict Ω ≤ (1 : ℝ≥0∞) • volume.restrict Λ by |
| simpa using Measure.restrict_mono hsub (le_refl (volume : Measure Plane))) |
| (value hΛ (smoothTestToH10 hΛ (includeTest hsub f))) |
| have hf := (test_memLp (Ω := Ω) f.property.1 f.property.2.1).coeFn_toLp |
| have hg := ((Measure.absolutelyContinuous_of_le (Measure.restrict_mono hsub le_rfl)).ae_eq |
| (test_memLp (Ω := Λ) f.property.1 f.property.2.1).coeFn_toLp) |
| exact hf.trans (hg.symm.trans hs.symm) |
| |
| include hsub in |
| lemma value_compact_of_subset (hc : IsCompactOperator (value hΛ)) : |
| IsCompactOperator (value hΩ) := by |
| rw [value_inclusion hΩ hΛ hsub] |
| exact (hc.comp_clm (inclusion hΩ hΛ hsub)).clm_comp (restriction hsub) |
| |
| end H10 |
| end StrictHotSpots |
| end H10InclusionCombinedLayer |
| |
| section H10HelmholtzCombinedLayer |
| open Set MeasureTheory Filter |
| open scoped ENNReal Topology InnerProductSpace Laplacian ContDiff |
| namespace StrictHotSpots.H10 |
| variable {Ω : Set Plane} (hΩ : IsOpen Ω) |
| local instance : NormedSpace ℝ (H10 hΩ) := (H10.innerProductSpace hΩ).toNormedSpace |
| |
| |
| |
| lemma helmholtz_pair {f : Plane → ℝ} {lam : ℝ} |
| (hf : ContDiffOn ℝ ∞ f Ω) |
| (hv : MemLp f 2 (volume.restrict Ω)) |
| (hg : MemLp (gradient f) 2 (volume.restrict Ω)) |
| (hp : ∀ x ∈ Ω, Δ f x = -lam * f x) (u : H10 hΩ) : |
| inner ℝ (hg.toLp _) (grad hΩ u) = lam * inner ℝ (hv.toLp _) (value hΩ u) := by |
| let A : H10 hΩ →L[ℝ] ℝ := (innerSL ℝ (hg.toLp _)).comp (grad hΩ) |
| let B : H10 hΩ →L[ℝ] ℝ := lam • (innerSL ℝ (hv.toLp _)).comp (value hΩ) |
| change A u = B u |
| apply isClosed_property (dense_smoothTestToH10 hΩ) (isClosed_eq A.continuous B.continuous) _ u |
| intro t |
| change inner ℝ (hg.toLp _) ((test_gradient_memLp t.property.1 t.property.2.1).toLp _) = |
| lam * inner ℝ (hv.toLp _) ((test_memLp t.property.1 t.property.2.1).toLp _) |
| rw [L2Inner.toLp_pair, L2Inner.toLp_pair] |
| rw [integral_inner_gradient_test hΩ hf t.property.1 t.property.2.1 t.property.2.2] |
| have he : (∫ x in Ω, Δ f x * (t : Plane → ℝ) x) = |
| -lam * ∫ x in Ω, f x * (t : Plane → ℝ) x := by |
| rw [← integral_const_mul] |
| apply integral_congr_ae |
| filter_upwards [ae_restrict_mem hΩ.measurableSet] with x hx |
| rw [hp x hx] |
| ring |
| rw [he] |
| simp only [RCLike.inner_apply, RCLike.conj_to_real] |
| rw [show (fun x => (t : Plane → ℝ) x * f x) = (fun x => f x * (t : Plane → ℝ) x) by funext; ring] |
| ring |
| |
| end StrictHotSpots.H10 |
| end H10HelmholtzCombinedLayer |
| |
| |
| end |
| |
| end DouglasLipschitzBase |
| |
| end OAI |
| |
