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