lean/OAI/Analysis/HotSpots/GreenOperator.lean

import OAI.Analysis.HotSpots.Green

namespace OAI

section DouglasLipschitzBase
noncomputable section
section FullBoundaryCombinedLayer
section WeightedLayer
open Set MeasureTheory
open scoped ContDiff InnerProductSpace ENNReal NNReal
open Set Filter MeasureTheory InnerProductSpace NormedSpace
open scoped Topology ContDiff
open scoped Laplacian
open Set MeasureTheory Filter InnerProductSpace Bornology
open scoped Topology Laplacian ContDiff RealInnerProductSpace
open scoped Convolution
open Set MeasureTheory Filter InnerProductSpace
open scoped Topology ContDiff Convolution Laplacian
open InnerProductSpace
open scoped Laplacian ContDiff

open Filter Set
open scoped Topology
namespace StrictHotSpots.DiskFormula

def poisson (s x : ℂ) : ℝ := (1 - ‖x‖ ^ 2) / (2 * Real.pi * ‖s-x‖ ^ 2)

def boundaryInteraction (s t : ℂ) : ℝ := 1 / (Real.pi * ‖s-t‖ ^ 2)

private def logRatio (u : ℝ) : ℝ := dslope Real.log 1 (1+u)

private lemma logRatio_zero : logRatio 0 = 1 := by
  simp [logRatio, Real.deriv_log]

private lemma logRatio_continuousAt_zero : ContinuousAt logRatio 0 := by
  have hd : ContinuousAt (dslope Real.log 1) 1 :=
    continuousAt_dslope_same.mpr (Real.differentiableAt_log one_ne_zero)
  exact hd.comp_of_eq (show ContinuousAt (fun t : ℝ => 1+t) 0 from
    continuousAt_const.add continuousAt_id) (by simp)

private lemma log_eq_mul_ratio (u : ℝ) : Real.log (1+u) = u * logRatio u := by
  have h := sub_smul_dslope Real.log 1 (1+u)
  simpa [logRatio, smul_eq_mul] using h.symm

lemma tendsto_log_mul_div {α : Type*} {l : Filter α} {a b : α → ℝ} {B : ℝ}
    (ha : Tendsto a l (𝓝 0)) (hb : Tendsto b l (𝓝 B))
    (hne : ∀ᶠ z in l, a z ≠ 0) :
    Tendsto (fun z => Real.log (1 + a z * b z) / a z) l (𝓝 B) := by
  have hu : Tendsto (fun z => a z * b z) l (𝓝 0) := by simpa using ha.mul hb
  have ht := (logRatio_continuousAt_zero.tendsto.comp hu).mul hb
  rw [logRatio_zero, one_mul] at ht
  apply ht.congr'
  filter_upwards [hne] with z hz
  rw [log_eq_mul_ratio]
  dsimp only [Function.comp_def]
  field_simp [hz]

lemma radial_one_formula (s x : ℂ) (hs : ‖s‖ = 1) (r : ℝ) :
    green (r • s) x = Real.log (1 + (1-r^2) * (1-‖x‖^2) / ‖r • s-x‖^2) /
      (4 * Real.pi) := by
  simp only [green, norm_smul, Real.norm_eq_abs, hs, mul_one, sq_abs]

lemma radial_one (s x : ℂ) (hs : ‖s‖ = 1) (hx : ‖x‖ < 1) :
    Tendsto (fun r : ℝ => green (r • s) x / (1-r)) (𝓝[<] 1) (𝓝 (poisson s x)) := by
  have hne : s-x ≠ 0 := by
    intro h
    have he : s = x := sub_eq_zero.mp h
    rw [← he, hs] at hx
    exact lt_irrefl _ hx
  have hden : ‖s-x‖^2 ≠ 0 := pow_ne_zero _ (norm_ne_zero_iff.mpr hne)
  have hd : ContinuousAt (fun r : ℝ => ‖r • s-x‖^2) 1 := by fun_prop
  have hb : Tendsto (fun r : ℝ => (1+r)*(1-‖x‖^2)/‖r • s-x‖^2)
      (𝓝[<] 1) (𝓝 (2*(1-‖x‖^2)/‖s-x‖^2)) := by
    have hh : ContinuousAt (fun r : ℝ => (1+r)*(1-‖x‖^2)/‖r • s-x‖^2) 1 :=
      ((continuousAt_const.add continuousAt_id).mul continuousAt_const).div hd
        (by simpa using hden)
    convert hh.tendsto.mono_left nhdsWithin_le_nhds using 1; norm_num
  have ha : Tendsto (fun r : ℝ => 1-r) (𝓝[<] 1) (𝓝 0) := by
    simpa using (tendsto_const_nhds.sub (tendsto_id.mono_left nhdsWithin_le_nhds) :
      Tendsto (fun r : ℝ => 1-r) (𝓝[<] 1) (𝓝 (1-1)))
  have hevent : ∀ᶠ r : ℝ in 𝓝[<] 1, (1-r) ≠ 0 := by
    filter_upwards [self_mem_nhdsWithin] with r hr
    exact (sub_pos.mpr hr).ne'
  have ht := (tendsto_log_mul_div ha hb hevent).div_const (4*Real.pi)
  have hv : 2*(1-‖x‖^2)/‖s-x‖^2/(4*Real.pi) = poisson s x := by
    simp only [poisson]
    field_simp
    ring
  rw [hv] at ht
  apply ht.congr'
  exact Filter.Eventually.of_forall fun r => by
    dsimp only
    rw [radial_one_formula s x hs]
    have he : (1-r^2)*(1-‖x‖^2)/‖r • s-x‖^2 =
        (1-r)*((1+r)*(1-‖x‖^2)/‖r • s-x‖^2) := by ring
    rw [he]
    ring

lemma radial_two_formula (s t : ℂ) (hs : ‖s‖ = 1) (ht : ‖t‖ = 1) (r : ℝ) :
    green (r • s) (r • t) =
      Real.log (1 + (1-r^2)^2 / (r^2 * ‖s-t‖^2)) / (4*Real.pi) := by
  simp only [green, ← smul_sub, norm_smul, Real.norm_eq_abs, hs, ht, mul_one,
    mul_pow, sq_abs, ← pow_two]

lemma radial_two (s t : ℂ) (hs : ‖s‖ = 1) (ht : ‖t‖ = 1) (hne : s ≠ t) :
    Tendsto (fun r : ℝ => green (r • s) (r • t) / (1-r)^2)
      (𝓝[<] 1) (𝓝 (boundaryInteraction s t)) := by
  have hden : ‖s-t‖^2 ≠ 0 := pow_ne_zero _ (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hne))
  have hb : Tendsto (fun r : ℝ => (1+r)^2 / (r^2 * ‖s-t‖^2))
      (𝓝[<] 1) (𝓝 (4 / ‖s-t‖^2)) := by
    have hh : ContinuousAt (fun r : ℝ => (1+r)^2 / (r^2 * ‖s-t‖^2)) 1 := by
      apply ContinuousAt.div (by fun_prop) (by fun_prop)
      simpa using hden
    convert hh.tendsto.mono_left nhdsWithin_le_nhds using 1; norm_num
  have ha : Tendsto (fun r : ℝ => (1-r)^2) (𝓝[<] 1) (𝓝 0) := by
    have hh : ContinuousAt (fun r : ℝ => (1-r)^2) 1 := by fun_prop
    convert hh.tendsto.mono_left nhdsWithin_le_nhds using 1; norm_num
  have hevent : ∀ᶠ r : ℝ in 𝓝[<] 1, (1-r)^2 ≠ 0 := by
    filter_upwards [self_mem_nhdsWithin] with r hr
    exact pow_ne_zero _ (sub_pos.mpr hr).ne'
  have hz := (tendsto_log_mul_div ha hb hevent).div_const (4*Real.pi)
  have hv : 4/‖s-t‖^2/(4*Real.pi) = boundaryInteraction s t := by
    simp only [boundaryInteraction]
    field_simp
  rw [hv] at hz
  apply hz.congr'
  exact Filter.Eventually.of_forall fun r => by
    dsimp only
    rw [radial_two_formula s t hs ht]
    have he : (1-r^2)^2/(r^2*‖s-t‖^2) =
        (1-r)^2*((1+r)^2/(r^2*‖s-t‖^2)) := by ring
    rw [he]
    ring

end StrictHotSpots.DiskFormula




open MeasureTheory Filter
open scoped Topology ENNReal


namespace StrictHotSpots.DiskFormula
open MeasureTheory

lemma log_mul_div_bounds {a b : ℝ} (ha : 0 < a) (hb : 0 ≤ b) :
    0 ≤ Real.log (1+a*b)/a ∧ Real.log (1+a*b)/a ≤ b := by
  have h1 : 1 ≤ 1+a*b := by linarith [mul_nonneg ha.le hb]
  constructor
  · exact div_nonneg (Real.log_nonneg h1) ha.le
  · apply (div_le_iff₀ ha).mpr
    have hh := Real.log_le_sub_one_of_pos (lt_of_lt_of_le zero_lt_one h1)
    nlinarith

lemma radial_one_bounded (s x : ℂ) (hs : ‖s‖ = 1)
    {R rmin r : ℝ} (hR : ‖x‖ ≤ R) (hRmin : R < rmin)
    (hrmin : rmin ≤ r) (hr : r < 1) :
    0 ≤ green (r • s) x / (1-r) ∧
      green (r • s) x / (1-r) ≤ (2/(rmin-R)^2)/(4*Real.pi) := by
  have hR0 : 0 ≤ R := (norm_nonneg x).trans hR
  have hr0 : 0 ≤ r := hR0.trans (hRmin.le.trans hrmin)
  have hx1 : ‖x‖ < 1 := hR.trans_lt (hRmin.trans_le hrmin |>.trans hr)
  have hx2 : 0 ≤ 1-‖x‖^2 := by nlinarith [norm_nonneg x]
  have hδ : 0 < rmin-R := sub_pos.mpr hRmin
  have hdist : rmin-R ≤ ‖r • s-x‖ := by
    have hh := norm_sub_norm_le (r • s) x
    rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hr0, hs, mul_one] at hh
    linarith
  have hdist0 : 0 < ‖r • s-x‖ := hδ.trans_le hdist
  have hd2 : (rmin-R)^2 ≤ ‖r • s-x‖^2 := sq_le_sq₀ hδ.le (norm_nonneg _) |>.mpr hdist
  have hnum : (1+r)*(1-‖x‖^2) ≤ 2 := by nlinarith [sq_nonneg ‖x‖]
  have hb0 : 0 ≤ (1+r)*(1-‖x‖^2)/‖r • s-x‖^2 := by positivity
  have hb : (1+r)*(1-‖x‖^2)/‖r • s-x‖^2 ≤ 2/(rmin-R)^2 := by
    calc
      _ ≤ 2/‖r • s-x‖^2 := div_le_div_of_nonneg_right hnum (sq_nonneg _)
      _ ≤ _ := div_le_div_of_nonneg_left (by norm_num) (sq_pos_of_pos hδ) hd2
  have hlog := log_mul_div_bounds (sub_pos.mpr hr) hb0
  have he : green (r • s) x/(1-r) =
      (Real.log (1 + (1-r)*((1+r)*(1-‖x‖^2)/‖r • s-x‖^2))/(1-r))/(4*Real.pi) := by
    rw [radial_one_formula s x hs]
    have hh : (1-r^2)*(1-‖x‖^2)/‖r • s-x‖^2 =
        (1-r)*((1+r)*(1-‖x‖^2)/‖r • s-x‖^2) := by ring
    rw [hh]
    ring
  rw [he]
  exact ⟨div_nonneg hlog.1 (by positivity),
    div_le_div_of_nonneg_right (hlog.2.trans hb) (by positivity)⟩

end StrictHotSpots.DiskFormula

namespace StrictHotSpots.DiskFormula
open MeasureTheory
variable {X : Type*} [MeasurableSpace X] (ν : Measure X) [IsFiniteMeasure ν]

lemma poisson_nonneg (s x : ℂ) (hx : ‖x‖ < 1) : 0 ≤ poisson s x := by
  have hh : 0 ≤ 1-‖x‖^2 := by nlinarith [norm_nonneg x]
  exact div_nonneg hh (by positivity)

lemma poisson_bounded (s x : ℂ) (hs : ‖s‖ = 1)
    {R : ℝ} (hR : ‖x‖ ≤ R) (hR1 : R < 1) :
    poisson s x ≤ 1 / (2*Real.pi*(1-R)^2) := by
  have hh := norm_sub_norm_le s x
  rw [hs] at hh
  have hd : 1-R ≤ ‖s-x‖ := by linarith
  have hd0 : 0 < 1-R := sub_pos.mpr hR1
  have hd2 : (1-R)^2 ≤ ‖s-x‖^2 := (sq_le_sq₀ hd0.le (norm_nonneg _)).mpr hd
  have hn : 1-‖x‖^2 ≤ 1 := by nlinarith [sq_nonneg ‖x‖]
  unfold poisson
  calc
    _ ≤ 1/(2*Real.pi*‖s-x‖^2) := div_le_div_of_nonneg_right hn (by positivity)
    _ ≤ _ := div_le_div_of_nonneg_left (by norm_num) (by positivity)
      (mul_le_mul_of_nonneg_left hd2 (by positivity))

lemma poisson_memLp (s : ℂ) (hs : ‖s‖ = 1) (x : X → ℂ) (hm : Measurable x)
    {R : ℝ} (hR : ∀ z, ‖x z‖ ≤ R) (hR1 : R < 1) :
    MemLp (fun z => poisson s (x z)) 2 ν := by
  refine MemLp.of_bound ?_ (1 / (2*Real.pi*(1-R)^2)) ?_
  · apply Measurable.aestronglyMeasurable
    unfold poisson
    fun_prop
  · exact Filter.Eventually.of_forall fun z => by
      rw [Real.norm_eq_abs, abs_of_nonneg (poisson_nonneg s (x z) ((hR z).trans_lt hR1))]
      exact poisson_bounded s (x z) hs (hR z) hR1

lemma radial_one_memLp (s : ℂ) (hs : ‖s‖ = 1) (x : X → ℂ) (hm : Measurable x)
    {R rmin r : ℝ} (hR : ∀ z, ‖x z‖ ≤ R) (hRmin : R < rmin)
    (hrmin : rmin ≤ r) (hr : r < 1) :
    MemLp (fun z => green (r • s) (x z)/(1-r)) 2 ν := by
  refine MemLp.of_bound ?_ ((2/(rmin-R)^2)/(4*Real.pi)) ?_
  · apply Measurable.aestronglyMeasurable
    unfold green
    fun_prop
  · exact Filter.Eventually.of_forall fun z => by
      obtain ⟨h0,hb⟩ := radial_one_bounded s (x z) hs (hR z) hRmin hrmin hr
      simpa only [Real.norm_eq_abs, abs_of_nonneg h0] using hb



theorem radial_one_L2 (s : ℂ) (hs : ‖s‖ = 1) (x : X → ℂ) (hm : Measurable x)
    {R rmin : ℝ} (hR : ∀ z, ‖x z‖ ≤ R) (hRmin : R < rmin) (hrmin1 : rmin < 1)
    (r : ℕ → ℝ) (hrmin : ∀ n, rmin ≤ r n) (hr : ∀ n, r n < 1)
    (hlim : Tendsto r atTop (𝓝 1)) :
    Tendsto (fun n => (radial_one_memLp ν s hs x hm hR hRmin (hrmin n) (hr n)).toLp
      (fun z => green (r n • s) (x z) / (1-r n))) atTop
      (𝓝 ((poisson_memLp ν s hs x hm hR (hRmin.trans hrmin1)).toLp
        (fun z => poisson s (x z)))) := by
  apply L2Limits.tendsto_toLp_of_dominated
    (hb := memLp_const ((2/(rmin-R)^2)/(4*Real.pi)))
  · apply Filter.Eventually.of_forall
    intro n
    exact Filter.Eventually.of_forall fun z => by
      obtain ⟨h0,hb⟩ := radial_one_bounded s (x z) hs (hR z) hRmin (hrmin n) (hr n)
      simpa only [Real.norm_eq_abs, abs_of_nonneg h0] using hb
  · exact Filter.Eventually.of_forall fun z =>
      (radial_one s (x z) hs ((hR z).trans_lt (hRmin.trans hrmin1))).comp
        (tendsto_nhdsWithin_iff.mpr ⟨hlim, Filter.Eventually.of_forall fun n => hr n⟩)

end StrictHotSpots.DiskFormula





open MeasureTheory Filter Metric Set
open scoped Topology ENNReal
namespace StrictHotSpots.GreenLp

def logPole (z : ℂ) : ℝ := Real.log (1 + 1 / ‖z‖^2)

lemma logPole_nonneg (z : ℂ) : 0 ≤ logPole z := by
  apply Real.log_nonneg
  have : 0 ≤ 1 / ‖z‖^2 := one_div_nonneg.mpr (sq_nonneg _)
  linarith

lemma measurable_logPole : Measurable logPole := by
  unfold logPole
  fun_prop

lemma logPole_cube_bound {t : ℝ} (ht : 0 < t) (ht2 : t ≤ 2) :
    (Real.log (1 + 1/t^2))^3 ≤ 648 / t := by
  have harg : 1 + 1/t^2 ≤ (3/t)^2 := by
    rw [div_pow]
    apply (le_div_iff₀ (sq_pos_of_pos ht)).2
    field_simp
    nlinarith
  have hl : Real.log (1 + 1/t^2) ≤ 2 * Real.log (3/t) := by
    have hh := Real.log_le_log (by positivity : 0 < 1 + 1/t^2) harg
    simpa only [Real.log_pow, Nat.cast_ofNat] using hh
  have hp : 0 < 3/t := by positivity
  have hr := Real.log_le_rpow_div hp.le (show 0 < (3:ℝ)⁻¹ by norm_num)
  have he : Real.log (1 + 1/t^2) ≤ 6 * (3/t)^((3:ℝ)⁻¹) := by
    norm_num at hr
    linarith
  have hnon : 0 ≤ Real.log (1 + 1/t^2) := by
    apply Real.log_nonneg
    have := one_div_nonneg.mpr (sq_nonneg t)
    linarith
  have hh := pow_le_pow_left₀ hnon he 3
  have hh3 : ((3/t)^((3:ℝ)⁻¹))^3 = 3/t := by
    simpa only [Nat.cast_ofNat] using
      Real.rpow_inv_natCast_pow hp.le (show (3:ℕ) ≠ 0 by decide)
  rw [mul_pow, hh3] at hh
  calc
    _ ≤ 6^3 * (3/t) := hh
    _ = 648/t := by ring

lemma logPole_cube_integrable : IntegrableOn (fun z : ℂ => (logPole z)^3) (ball 0 2) := by
  apply integrableOn_ball_of_norm_le_rpow (C := 648) (α := 1)
    (by norm_num : 1 ≤ Module.finrank ℝ ℂ) (by norm_num : (1:ℝ) < Module.finrank ℝ ℂ)
  · filter_upwards [self_mem_ae_restrict measurableSet_ball] with z hz
    rw [Real.norm_of_nonneg (pow_nonneg (logPole_nonneg z) _), Real.rpow_neg_one]
    by_cases hzero : z = 0
    · simp [hzero, logPole]
    · have hp := norm_pos_iff.mpr hzero
      have hlt : ‖z‖ < 2 := by simpa using hz
      simpa only [logPole, div_eq_mul_inv] using logPole_cube_bound hp hlt.le
  · exact (measurable_logPole.pow_const 3).aestronglyMeasurable

lemma logPole_memLp_three : MemLp logPole 3 (volume.restrict (ball 0 2)) := by
  apply (integrable_norm_rpow_iff measurable_logPole.aestronglyMeasurable
    (by norm_num : (3:ℝ≥0∞) ≠ 0) (by simp : (3:ℝ≥0∞) ≠ (∞ : ℝ≥0∞))).1
  simpa only [IntegrableOn, ENNReal.toReal_ofNat, ← Real.rpow_natCast, Nat.cast_ofNat,
    Real.norm_of_nonneg (logPole_nonneg _)] using logPole_cube_integrable

lemma shifted_logPole_memLp_three (x : ℂ) (hx : ‖x‖ < 1) :
    MemLp (fun y => logPole (x-y)) 3 (volume.restrict (ball 0 1)) := by
  have hpres := (measurePreserving_sub_right (volume : Measure ℂ) x).restrict_preimage
    (show MeasurableSet (ball (0:ℂ) 2) from measurableSet_ball)
  have hh := logPole_memLp_three.comp_measurePreserving hpres
  have hsub : ball (0:ℂ) 1 ⊆ (fun y => y-x) ⁻¹' ball 0 2 := by
    intro y hy
    have hy' : ‖y‖ < 1 := by simpa using hy
    have hd := norm_sub_le y x
    change y-x ∈ ball (0:ℂ) 2
    rw [mem_ball_zero_iff]
    linarith
  have hm := MemLp.mono_measure (Measure.restrict_mono hsub le_rfl) hh
  convert hm using 1
  funext y
  dsimp only [Function.comp_def, logPole]
  rw [norm_sub_rev]

end StrictHotSpots.GreenLp


open MeasureTheory Filter Metric Set
open scoped Topology ENNReal
namespace StrictHotSpots.DiskFormula
open GreenLp

lemma measurable_green_left (x : ℂ) : Measurable (green x) := by
  unfold green
  fun_prop

lemma green_bounds {x y : ℂ} (hx : ‖x‖ ≤ 1) (hy : ‖y‖ ≤ 1) :
    0 ≤ green x y ∧ green x y ≤ logPole (x-y) / (4*Real.pi) := by
  have hwx : 0 ≤ 1-‖x‖^2 := by nlinarith [norm_nonneg x]
  have hwy : 0 ≤ 1-‖y‖^2 := by nlinarith [norm_nonneg y]
  have hn : (1-‖x‖^2)*(1-‖y‖^2) ≤ 1 := by
    nlinarith [sq_nonneg ‖x‖, sq_nonneg ‖y‖, mul_nonneg hwx (sq_nonneg ‖y‖)]
  have hdiv : 0 ≤ (1-‖x‖^2)*(1-‖y‖^2)/‖x-y‖^2 := by positivity
  have hdiv' := div_le_div_of_nonneg_right hn (sq_nonneg ‖x-y‖)
  have hlog : 0 ≤ Real.log (1+(1-‖x‖^2)*(1-‖y‖^2)/‖x-y‖^2) :=
    Real.log_nonneg (by linarith)
  refine ⟨div_nonneg hlog (by positivity), ?_⟩
  apply div_le_div_of_nonneg_right _ (by positivity : 0 ≤ 4*Real.pi)
  exact Real.log_le_log (by linarith) (by simpa only [logPole] using add_le_add_right hdiv' 1)

lemma green_pos {x y : ℂ} (hx : ‖x‖ < 1) (hy : ‖y‖ < 1) (hne : x ≠ y) :
    0 < green x y := by
  apply div_pos _ (by positivity)
  apply Real.log_pos
  have hwx : 0 < 1-‖x‖^2 := by nlinarith [norm_nonneg x]
  have hwy : 0 < 1-‖y‖^2 := by nlinarith [norm_nonneg y]
  have hd : 0 < ‖x-y‖^2 := sq_pos_of_pos (norm_pos_iff.mpr (sub_ne_zero.mpr hne))
  have := div_pos (mul_pos hwx hwy) hd
  linarith

lemma green_memLp_three (x : ℂ) (hx : ‖x‖ < 1) :
    MemLp (green x) 3 (volume.restrict (ball 0 1)) := by
  have hm : MemLp (fun y => logPole (x-y)/(4*Real.pi)) 3
      (volume.restrict (ball 0 1)) := by
    simpa only [div_eq_mul_inv] using
      (shifted_logPole_memLp_three x hx).mul_const (4*Real.pi)⁻¹
  apply hm.mono (measurable_green_left x).aestronglyMeasurable
  filter_upwards [self_mem_ae_restrict measurableSet_ball] with y hy
  have hy' : ‖y‖ ≤ 1 := (by simpa using hy : ‖y‖ < 1).le
  have hb := green_bounds hx.le hy'
  rw [Real.norm_of_nonneg hb.1, Real.norm_of_nonneg (div_nonneg (logPole_nonneg (x-y)) (by positivity :
    0 ≤ 4*Real.pi))]
  exact hb.2

lemma green_memLp_two (x : ℂ) (hx : ‖x‖ < 1) :
    MemLp (green x) 2 (volume.restrict (ball 0 1)) := by
  have : IsFiniteMeasure (volume.restrict (ball (0:ℂ) 1)) :=
    ⟨by simpa only [Measure.restrict_apply_univ] using measure_ball_lt_top (x := (0:ℂ)) (r := 1)⟩
  exact (green_memLp_three x hx).mono_exponent (by norm_num)

lemma green_memLp_three_of_le (ν : Measure ℂ) {A : ℝ≥0∞} (hA : A ≠ (∞ : ℝ≥0∞))
    (hν : ν ≤ A • volume.restrict (ball 0 1)) (x : ℂ) (hx : ‖x‖ < 1) :
    MemLp (green x) 3 ν :=
  MemLp.mono_measure hν ((green_memLp_three x hx).smul_measure hA)

lemma green_memLp_two_of_le (ν : Measure ℂ) {A : ℝ≥0∞} (hA : A ≠ (∞ : ℝ≥0∞))
    (hν : ν ≤ A • volume.restrict (ball 0 1)) (x : ℂ) (hx : ‖x‖ < 1) :
    MemLp (green x) 2 ν :=
  MemLp.mono_measure hν ((green_memLp_two x hx).smul_measure hA)

end StrictHotSpots.DiskFormula


open MeasureTheory Filter Metric Set
open scoped Topology ENNReal
namespace StrictHotSpots.GreenLp

lemma logPole_memLp_two : MemLp logPole 2 (volume.restrict (ball (0 : ℂ) 2)) := by
  let : IsFiniteMeasure (volume.restrict (ball (0 : ℂ) 2)) :=
    isFiniteMeasure_restrict.mpr Metric.isBounded_ball.measure_lt_top.ne
  exact logPole_memLp_three.mono_exponent (by norm_num)

lemma shifted_logPole_norm_bound (x : ℂ) (hx : ‖x‖ < 1) :
    eLpNorm (fun y => logPole (x-y)) 2 (volume.restrict (ball 0 1)) ≤
      eLpNorm logPole 2 (volume.restrict (ball (0 : ℂ) 2)) := by
  have hm := (measurePreserving_sub_right (volume : Measure ℂ) x).restrict_preimage
    (show MeasurableSet (ball (0 : ℂ) 2) from measurableSet_ball)
  have hs : ball (0 : ℂ) 1 ⊆ (fun y => y-x) ⁻¹' ball 0 2 := by
    intro y hy
    have hy' : ‖y‖ < 1 := by simpa using hy
    have hd := norm_sub_le y x
    change y-x ∈ ball (0 : ℂ) 2
    rw [mem_ball_zero_iff]
    linarith
  calc
    _ = eLpNorm (logPole ∘ fun y => y-x) 2 (volume.restrict (ball 0 1)) := by
      congr 1
      funext y
      simp only [Function.comp_apply, logPole, norm_sub_rev x y]
    _ ≤ eLpNorm (logPole ∘ fun y => y-x) 2
        (volume.restrict ((fun y => y-x) ⁻¹' ball 0 2)) :=
      eLpNorm_mono_measure _ (Measure.restrict_mono hs le_rfl)
    _ = _ := eLpNorm_comp_measurePreserving logPole_memLp_two.aestronglyMeasurable hm

end StrictHotSpots.GreenLp
namespace StrictHotSpots.DiskFormula
open GreenLp

lemma green_uniform_L2_bound : ∃ B : ℝ, 0 ≤ B ∧ ∀ x : ℂ, ‖x‖ < 1 →
    (eLpNorm (green x) 2 (volume.restrict (ball 0 1))).toReal ≤ B := by
  let C := ENNReal.ofReal (4*Real.pi)⁻¹ *
    eLpNorm logPole 2 (volume.restrict (ball (0 : ℂ) 2))
  have hC : C ≠ (∞ : ℝ≥0∞) := ENNReal.mul_ne_top ENNReal.ofReal_ne_top logPole_memLp_two.eLpNorm_ne_top
  refine ⟨C.toReal, ENNReal.toReal_nonneg, fun x hx => ?_⟩
  apply ENNReal.toReal_mono hC
  calc
    _ ≤ ENNReal.ofReal (4*Real.pi)⁻¹ *
        eLpNorm (fun y => logPole (x-y)) 2 (volume.restrict (ball 0 1)) := by
      apply eLpNorm_le_mul_eLpNorm_of_ae_le_mul
        (measurable_green_left x).aestronglyMeasurable
      filter_upwards [ae_restrict_mem measurableSet_ball] with y hy
      have hy' : ‖y‖ ≤ 1 := (by simpa using hy : ‖y‖ < 1).le
      have hh := green_bounds hx.le hy'
      rw [Real.norm_of_nonneg hh.1, Real.norm_of_nonneg (logPole_nonneg _)]
      simpa only [div_eq_mul_inv, mul_comm] using hh.2
    _ ≤ C := by
      dsimp [C]
      gcongr
      exact shifted_logPole_norm_bound x hx

end StrictHotSpots.DiskFormula



open MeasureTheory Filter
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.MeasurableL2Kernel

lemma integral_mul_eq_inner {X : Type*} [MeasurableSpace X] {ν : Measure X}
    {f g : X → ℝ} (hf : MemLp f 2 ν) (hg : MemLp g 2 ν) :
    (∫ x, f x * g x ∂ν) = inner ℝ (hf.toLp f) (hg.toLp g) := by
  rw [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [hf.coeFn_toLp, hg.coeFn_toLp] with x hx hy
  simp only [hx,hy, RCLike.inner_apply, conj_trivial]
  ring

lemma norm_integral_mul_le {X : Type*} [MeasurableSpace X] {ν : Measure X}
    {f g : X → ℝ} (hf : MemLp f 2 ν) (hg : MemLp g 2 ν) :
    ‖∫ x, f x * g x ∂ν‖ ≤ (eLpNorm f 2 ν).toReal * (eLpNorm g 2 ν).toReal := by
  rw [integral_mul_eq_inner hf hg]
  simpa only [Lp.norm_toLp] using norm_inner_le_norm (hf.toLp f) (hg.toLp g)

variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
  {μ : Measure X} {ν : Measure Y} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
  (K : X × Y → ℝ) (hK : AEStronglyMeasurable K (μ.prod ν))
  (hrow : ∀ᵐ x ∂μ, MemLp (fun y => K (x,y)) 2 ν)
  {B : ℝ} (hB : 0 ≤ B)
  (hbound : ∀ᵐ x ∂μ, (eLpNorm (fun y => K (x,y)) 2 ν).toReal ≤ B)

omit [IsFiniteMeasure μ] [IsFiniteMeasure ν] in
include hrow hbound in
lemma apply_bound (f : Lp ℝ 2 ν) :
    ∀ᵐ x ∂μ, ‖∫ y, K (x,y) * f y ∂ν‖ ≤ B * ‖f‖ := by
  filter_upwards [hrow, hbound] with x hx hb
  have hh := norm_integral_mul_le hx (Lp.memLp f)
  have he : (eLpNorm (fun y => f y) 2 ν).toReal = ‖f‖ := rfl
  rw [he] at hh
  exact hh.trans (mul_le_mul_of_nonneg_right hb (norm_nonneg f))

include hK hrow hbound in
lemma apply_memLp (f : Lp ℝ 2 ν) :
    MemLp (fun x => ∫ y, K (x,y) * f y ∂ν) 2 μ := by
  have hm : AEStronglyMeasurable (fun z : X × Y => K z * f z.2) (μ.prod ν) :=
    hK.mul (Lp.aestronglyMeasurable f).comp_snd
  exact MemLp.of_bound hm.integral_prod_right' (B * ‖f‖)
    (apply_bound K hrow hbound f)



def operator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 μ := by
  let T : Lp ℝ 2 ν →ₗ[ℝ] Lp ℝ 2 μ :=
    { toFun := fun f => (apply_memLp K hK hrow hbound f).toLp _
      map_add' := by
        intro f g
        apply Lp.ext
        filter_upwards [(apply_memLp K hK hrow hbound (f+g)).coeFn_toLp,
          (apply_memLp K hK hrow hbound f).coeFn_toLp,
          (apply_memLp K hK hrow hbound g).coeFn_toLp,
          Lp.coeFn_add ((apply_memLp K hK hrow hbound f).toLp _)
            ((apply_memLp K hK hrow hbound g).toLp _), hrow] with x hx hf hg ha hr
        rw [hx,ha, Pi.add_apply,hf,hg]
        have he : (fun y => K (x,y) * (f+g) y) =ᵐ[ν]
            (fun y => K (x,y) * f y + K (x,y) * g y) := by
          filter_upwards [Lp.coeFn_add f g] with y hy
          rw [hy, Pi.add_apply, mul_add]
        rw [integral_congr_ae he, integral_add]
        · exact hr.integrable_mul (Lp.memLp f)
        · exact hr.integrable_mul (Lp.memLp g)
      map_smul' := by
        intro c f
        apply Lp.ext
        filter_upwards [(apply_memLp K hK hrow hbound (c • f)).coeFn_toLp,
          (apply_memLp K hK hrow hbound f).coeFn_toLp,
          Lp.coeFn_smul c ((apply_memLp K hK hrow hbound f).toLp _)] with x hx hf hs
        simp only [RingHom.id_apply]
        rw [hx,hs, Pi.smul_apply,hf]
        have he : (fun y => K (x,y) * (c • f) y) =ᵐ[ν]
            (fun y => c * (K (x,y) * f y)) := by
          filter_upwards [Lp.coeFn_smul c f] with y hy
          rw [hy, Pi.smul_apply, smul_eq_mul]
          ring
        rw [integral_congr_ae he, integral_const_mul, smul_eq_mul] }
  refine T.mkContinuous ((measureUnivNNReal μ : ℝ) ^ (2 : ℝ≥0∞).toReal⁻¹ * B) ?_
  intro f
  have hh := Lp.norm_le_of_ae_bound (mul_nonneg hB (norm_nonneg f))
    (show ∀ᵐ x ∂μ, ‖T f x‖ ≤ B * ‖f‖ from by
      filter_upwards [(apply_memLp K hK hrow hbound f).coeFn_toLp,
        apply_bound K hrow hbound f] with x hx hb
      change ‖((apply_memLp K hK hrow hbound f).toLp _) x‖ ≤ _
      rw [hx]
      exact hb)
  exact hh.trans_eq (mul_assoc _ _ _).symm

lemma operator_apply_ae (f : Lp ℝ 2 ν) :
    operator K hK hrow hB hbound f =ᵐ[μ] fun x => ∫ y, K (x,y) * f y ∂ν :=
  (apply_memLp K hK hrow hbound f).coeFn_toLp

end StrictHotSpots.MeasurableL2Kernel



open MeasureTheory Filter InnerProductSpace
open scoped ENNReal Topology
namespace StrictHotSpots

lemma eq_zero_of_inner_smoothTest_eq_zero {Ω : Set Plane} (hΩ : IsOpen Ω)
    (u : Lp ℝ 2 (volume.restrict Ω))
    (h : ∀ φ : smoothTestSpace Ω, inner ℝ (H1.value (smoothTestToH1 hΩ φ)) u = 0) :
    u = 0 := by
  have hl := (Lp.memLp u).locallyIntegrable (by norm_num : (1 : ℝ≥0∞) ≤ 2)
  have hh := hΩ.ae_eq_zero_of_integral_contDiff_smul_eq_zero
    (μ := volume.restrict Ω) (hl.locallyIntegrableOn Ω)
    (fun φ hp hc hs => show (∫ x in Ω, φ x • u x) = 0 from by
      have ht := h ⟨φ,hp,hc,hs⟩
      have hv : H1.value (smoothTestToH1 hΩ ⟨φ,hp,hc,hs⟩) =
          (test_memLp (Ω := Ω) hp hc).toLp φ := rfl
      rw [hv, L2.inner_def] at ht
      convert ht using 1
      apply integral_congr_ae
      filter_upwards [(test_memLp (Ω := Ω) hp hc).coeFn_toLp] with x hx
      simp only [hx, smul_eq_mul, RCLike.inner_apply, conj_trivial]
      ring)
  apply Lp.ext
  filter_upwards [hh, ae_restrict_mem hΩ.measurableSet, Lp.coeFn_zero ℝ 2 (volume.restrict Ω)]
    with x hx hΩx hz
  rw [hz]
  exact hx hΩx

lemma smoothTest_dense_L2 {Ω : Set Plane} (hΩ : IsOpen Ω) :
    DenseRange (fun φ : smoothTestSpace Ω => H1.value (smoothTestToH1 hΩ φ)) := by
  let T : smoothTestSpace Ω →ₗ[ℝ] Lp ℝ 2 (volume.restrict Ω) :=
    H1.value.toLinearMap.comp (smoothTestToH1 hΩ)
  have hz : T.rangeᗮ = ⊥ := by
    apply eq_bot_iff.mpr
    intro u hu
    change u = 0
    apply eq_zero_of_inner_smoothTest_eq_zero hΩ u
    intro φ
    exact (Submodule.mem_orthogonal _ _).mp hu (T φ) ⟨φ,rfl⟩
  have ht : T.range.topologicalClosure = ⊤ := by
    rw [← Submodule.orthogonal_orthogonal_eq_closure, hz, Submodule.bot_orthogonal_eq_top]
  have hd : closure (Set.range T) = Set.univ := by
    change closure (T.range : Set (Lp ℝ 2 (volume.restrict Ω))) = Set.univ
    rw [← Submodule.topologicalClosure_coe, ht, Submodule.top_coe]
  exact dense_iff_closure_eq.mpr hd

end StrictHotSpots







open scoped InnerProductSpace
namespace StrictHotSpots.DirichletOperator

variable {V H : Type*}
  [NormedAddCommGroup V] [InnerProductSpace ℝ V] [CompleteSpace V]
  [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H]


def solution (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) :
    H →L[ℝ] V :=
  hB.continuousLinearEquivOfBilin.symm.toContinuousLinearMap.comp J.adjoint

lemma solution_spec (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H)
    (f : H) (v : V) : B (solution B hB J f) v = ⟪f, J v⟫_ℝ := by
  rw [← hB.continuousLinearEquivOfBilin_apply]
  simp only [solution, ContinuousLinearMap.comp_apply, ContinuousLinearEquiv.coe_coe,
    ContinuousLinearEquiv.apply_symm_apply, ContinuousLinearMap.adjoint_inner_left]


def green (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) :
    H →L[ℝ] H := J.comp (solution B hB J)

lemma green_apply (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H)
    (f : H) : green B hB J f = J (solution B hB J f) := rfl

lemma green_symmetric (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B)
    (hsym : ∀ u v, B u v = B v u) (J : V →L[ℝ] H) (f g : H) :
    ⟪green B hB J f, g⟫_ℝ = ⟪f, green B hB J g⟫_ℝ := by
  calc
    _ = ⟪g, J (solution B hB J f)⟫_ℝ := real_inner_comm _ _
    _ = B (solution B hB J g) (solution B hB J f) := (solution_spec B hB J g _).symm
    _ = B (solution B hB J f) (solution B hB J g) := hsym _ _
    _ = _ := solution_spec B hB J f _

lemma green_nonneg (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B)
    (J : V →L[ℝ] H) (f : H) : 0 ≤ ⟪f, green B hB J f⟫_ℝ := by
  rw [green_apply, ← solution_spec B hB J f (solution B hB J f)]
  obtain ⟨C, hC, h⟩ := hB
  exact (mul_nonneg (mul_nonneg hC.le (norm_nonneg _)) (norm_nonneg _)).trans (h _)



lemma green_norm_le (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B)
    (J : V →L[ℝ] H) {d : ℝ} (hd : 0 ≤ d)
    (hsub : ∀ v : V, ‖J v‖ ^ 2 ≤ d * B v v) : ‖green B hB J‖ ≤ d := by
  apply ContinuousLinearMap.opNorm_le_bound _ hd
  intro f
  let u := solution B hB J f
  have h0 := hsub u
  have hs : B u u = ⟪f, J u⟫_ℝ := solution_spec B hB J f u
  rw [hs] at h0
  have hi : ⟪f, J u⟫_ℝ ≤ ‖f‖ * ‖J u‖ := real_inner_le_norm _ _
  have ht : ‖J u‖ ^ 2 ≤ d * (‖f‖ * ‖J u‖) :=
    h0.trans (mul_le_mul_of_nonneg_left hi hd)
  change ‖J u‖ ≤ d * ‖f‖
  by_cases hz : ‖J u‖ = 0
  · rw [hz]
    positivity
  · have hp : 0 < ‖J u‖ := lt_of_le_of_ne (norm_nonneg _) (Ne.symm hz)
    nlinarith

lemma green_norm_lt_one (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B)
    (J : V →L[ℝ] H) {d : ℝ} (hd : 0 ≤ d) (hd1 : d < 1)
    (hsub : ∀ v : V, ‖J v‖ ^ 2 ≤ d * B v v) : ‖green B hB J‖ < 1 :=
  (green_norm_le B hB J hd hsub).trans_lt hd1

end StrictHotSpots.DirichletOperator


open MeasureTheory Set Filter
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.PlaneGreen
open DiskH10

lemma diskBounded : Bornology.IsBounded disk := Metric.isBounded_ball

instance diskFinite : IsFiniteMeasure (volume.restrict disk) :=
  isFiniteMeasure_restrict.mpr diskBounded.measure_lt_top.ne

def kernel (x y : Plane) : ℝ := DiskFormula.green (complexIso.symm x) (complexIso.symm y)

lemma complexIso_disk_preserving : MeasurePreserving complexIso.symm
    (volume.restrict disk) (volume.restrict (Metric.ball (0 : ℂ) 1)) := by
  have h := complexIso.symm.measurePreserving.restrict_preimage
    (show MeasurableSet (Metric.ball (0 : ℂ) 1) from measurableSet_ball)
  have he : complexIso.symm ⁻¹' Metric.ball (0 : ℂ) 1 = disk := by
    ext x
    simp [disk]
  rwa [he] at h

lemma kernel_memLp (x : Plane) (hx : x ∈ disk) :
    MemLp (kernel x) 2 (volume.restrict disk) := by
  have hx' : ‖complexIso.symm x‖ < 1 := by simpa [disk] using hx
  exact (DiskFormula.green_memLp_two _ hx').comp_measurePreserving complexIso_disk_preserving

lemma measurable_kernel : Measurable (fun p : Plane × Plane => kernel p.1 p.2) := by
  unfold kernel DiskFormula.green
  fun_prop

lemma kernel_bound : ∃ B : ℝ, 0 ≤ B ∧ ∀ x ∈ disk,
    (eLpNorm (kernel x) 2 (volume.restrict disk)).toReal ≤ B := by
  obtain ⟨B,hB,h⟩ := DiskFormula.green_uniform_L2_bound
  refine ⟨B,hB,fun x hx => ?_⟩
  have hx' : ‖complexIso.symm x‖ < 1 := by simpa [disk] using hx
  have he := eLpNorm_comp_measurePreserving (p := 2)
    (DiskFormula.green_memLp_two _ hx').aestronglyMeasurable complexIso_disk_preserving
  change (eLpNorm (DiskFormula.green (complexIso.symm x) ∘ complexIso.symm) 2
    (volume.restrict disk)).toReal ≤ B
  rw [he]
  exact h _ hx'

lemma kernel_rows : ∀ᵐ x ∂volume.restrict disk, MemLp (kernel x) 2 (volume.restrict disk) := by
  filter_upwards [ae_restrict_mem diskOpen.measurableSet] with x hx
  exact kernel_memLp x hx

def integralOperator : Lp ℝ 2 (volume.restrict disk) →L[ℝ] Lp ℝ 2 (volume.restrict disk) :=
  MeasurableL2Kernel.operator (fun p => kernel p.1 p.2) measurable_kernel.aestronglyMeasurable
    kernel_rows kernel_bound.choose_spec.1
    (by filter_upwards [ae_restrict_mem diskOpen.measurableSet] with x hx
        exact kernel_bound.choose_spec.2 x hx)

lemma integralOperator_ae (f : Lp ℝ 2 (volume.restrict disk)) :
    integralOperator f =ᵐ[volume.restrict disk] fun x => ∫ y in disk, kernel x y * f y :=
  MeasurableL2Kernel.operator_apply_ae _ _ _ _ _ f

lemma potential_eq_integral {f : Plane → ℝ} (hf : ContDiff ℝ ∞ f)
    (hc : HasCompactSupport f) (hs : tsupport f ⊆ disk) {x : Plane} (hx : x ∈ disk) :
    potential f x = ∫ y in disk, kernel x y * f y := by
  obtain ⟨R,hR,hn⟩ := GreenPotential.exists_regular_neighborhood (source_compact hc)
    (source_support hs)
  have hx' : complexIso.symm x ∈ Metric.ball (0 : ℂ) R := by
    have : ‖x‖ < 1 := by simpa [disk] using hx
    simpa using this.trans hR
  have hh := GreenPotential.potential_eq_integral (source_contDiff hf) (source_compact hc)
    Metric.isOpen_ball hn hx'
  change GreenPotential.potential (source f) (complexIso.symm x) = _
  rw [hh]
  have he := complexIso.symm.measurePreserving.integral_comp
    complexIso.symm.toMeasurableEquiv.measurableEmbedding
    (fun z => DiskFormula.green (complexIso.symm x) z * source f z)
  simp only [source, complexIso.apply_symm_apply] at he
  simp only [source]
  rw [← he]
  symm
  apply setIntegral_eq_integral_of_forall_compl_eq_zero
  intro y hy
  have hfy : f y = 0 := image_eq_zero_of_notMem_tsupport (fun h => hy (hs h))
  simp [hfy, kernel]

def variationalOperator : Lp ℝ 2 (volume.restrict disk) →L[ℝ] Lp ℝ 2 (volume.restrict disk) :=
  @DirichletOperator.green (H10 diskOpen) (Lp ℝ 2 (volume.restrict disk))
    (H10.normedAddCommGroup diskOpen) (H10.innerProductSpace diskOpen)
    (H10.completeSpace diskOpen) inferInstance inferInstance inferInstance
    (H10.energy diskOpen) (H10.energy_coercive diskOpen diskBounded) (H10.value diskOpen)

lemma variationalOperator_test (f : smoothTestSpace disk) :
    variationalOperator (H1.value (smoothTestToH1 diskOpen f)) =ᵐ[volume.restrict disk]
      potential f := by
  obtain ⟨u,hu,he⟩ := exists_dirichlet_representative f.property.1 f.property.2.1 f.property.2.2
  let w := DirichletOperator.solution (H10.energy diskOpen)
    (H10.energy_coercive diskOpen diskBounded) (H10.value diskOpen)
    (H1.value (smoothTestToH1 diskOpen f))
  have hw : ∀ v, H10.energy diskOpen w v = inner ℝ
      (H1.value (smoothTestToH1 diskOpen f)) (H10.value diskOpen v) :=
    DirichletOperator.solution_spec _ _ _ _
  have he' : ∀ v, H10.energy diskOpen u v = inner ℝ
      (H1.value (smoothTestToH1 diskOpen f)) (H10.value diskOpen v) := he
  obtain ⟨_,_,hun⟩ := H10.existsUnique_energy_solution diskOpen diskBounded
    ((innerSL ℝ (H1.value (smoothTestToH1 diskOpen f))).comp (H10.value diskOpen))
  have heq : w = u := (hun w hw).trans (hun u he').symm
  change H10.value diskOpen w =ᵐ[volume.restrict disk] potential f
  rw [heq]
  exact hu



lemma integralOperator_eq_variationalOperator : integralOperator = variationalOperator := by
  apply DFunLike.coe_injective
  apply (smoothTest_dense_L2 diskOpen).equalizer integralOperator.continuous
    variationalOperator.continuous
  funext f
  simp only [Function.comp_apply]
  apply Lp.ext
  filter_upwards [integralOperator_ae (H1.value (smoothTestToH1 diskOpen f)),
    variationalOperator_test f, ae_restrict_mem diskOpen.measurableSet] with x hx hu hxd
  rw [hx,hu,potential_eq_integral f.property.1 f.property.2.1 f.property.2.2 hxd]
  apply integral_congr_ae
  have hf : H1.value (smoothTestToH1 diskOpen f) =ᵐ[volume.restrict disk] f :=
    (test_memLp (Ω := disk) f.property.1 f.property.2.1).coeFn_toLp
  filter_upwards [hf] with y hy
  rw [hy]

end StrictHotSpots.PlaneGreen


open MeasureTheory
open scoped InnerProductSpace ENNReal
namespace StrictHotSpots.H10
variable {Ω : Set Plane} (hΩ : IsOpen Ω) (hb : Bornology.IsBounded Ω)
variable {ν : Measure Plane} {C : ℝ≥0∞} (hC : C ≠ (∞ : ℝ≥0∞))
  (hν : ν ≤ C • volume.restrict Ω)


def weightedValue : H10 hΩ →L[ℝ] Lp ℝ 2 ν :=
  (Lp.LpToLpOfMeasureLeSMul hC hν).comp (value hΩ)

lemma weightedValue_ae (u : H10 hΩ) :
    weightedValue hΩ hC hν u =ᵐ[ν] value hΩ u :=
  Lp.coeFn_LpToLpOfMeasureLeSMul hC hν (value hΩ u)



def greenOperator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν :=
  @DirichletOperator.green (H10 hΩ) (Lp ℝ 2 ν)
    (H10.normedAddCommGroup hΩ) (H10.innerProductSpace hΩ) (H10.completeSpace hΩ)
    inferInstance inferInstance inferInstance
    (energy hΩ) (energy_coercive hΩ hb) (weightedValue hΩ hC hν)

lemma energy_symmetric (u v : H10 hΩ) : energy hΩ u v = energy hΩ v u := by
  calc
    energy hΩ u v = inner ℝ (grad hΩ u) (grad hΩ v) := energy_apply hΩ u v
    _ = inner ℝ (grad hΩ v) (grad hΩ u) := real_inner_comm _ _
    _ = energy hΩ v u := (energy_apply hΩ v u).symm

lemma greenOperator_symmetric (f g : Lp ℝ 2 ν) :
    inner ℝ (greenOperator hΩ hb hC hν f) g =
      inner ℝ f (greenOperator hΩ hb hC hν g) :=
  DirichletOperator.green_symmetric (energy hΩ) (energy_coercive hΩ hb)
    (energy_symmetric hΩ) (weightedValue hΩ hC hν) f g

lemma greenOperator_nonneg (f : Lp ℝ 2 ν) :
    0 ≤ inner ℝ f (greenOperator hΩ hb hC hν f) :=
  DirichletOperator.green_nonneg (energy hΩ) (energy_coercive hΩ hb)
    (weightedValue hΩ hC hν) f


lemma greenOperator_norm_le {d : ℝ} (hd : 0 ≤ d)
    (hsub : ∀ u : H10 hΩ, ‖weightedValue hΩ hC hν u‖ ^ 2 ≤
      d * ‖grad hΩ u‖ ^ 2) : ‖greenOperator hΩ hb hC hν‖ ≤ d := by
  apply DirichletOperator.green_norm_le (energy hΩ) (energy_coercive hΩ hb)
    (weightedValue hΩ hC hν) hd
  intro u
  simpa only [energy_apply, real_inner_self_eq_norm_sq] using hsub u

end StrictHotSpots.H10


open MeasureTheory Filter
open scoped ENNReal InnerProductSpace
namespace StrictHotSpots.DirichletOperator

lemma green_comp {V H K : Type*}
    [NormedAddCommGroup V] [InnerProductSpace ℝ V] [CompleteSpace V]
    [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H]
    [NormedAddCommGroup K] [InnerProductSpace ℝ K] [CompleteSpace K]
    (B : V →L[ℝ] V →L[ℝ] ℝ) (hB : IsCoercive B) (J : V →L[ℝ] H) (S : H →L[ℝ] K) :
    green B hB (S.comp J) = (S.comp (green B hB J)).comp S.adjoint := by
  simp only [green, solution, ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.comp_assoc]

end StrictHotSpots.DirichletOperator
namespace StrictHotSpots.PlaneGreen
open DiskH10
variable {ν : Measure Plane} {C : ℝ≥0∞} (hC : C ≠ (∞ : ℝ≥0∞))
  (hν : ν ≤ C • volume.restrict disk)

def inclusion : Lp ℝ 2 (volume.restrict disk) →L[ℝ] Lp ℝ 2 ν :=
  Lp.LpToLpOfMeasureLeSMul hC hν

lemma inclusion_ae (f : Lp ℝ 2 (volume.restrict disk)) : inclusion hC hν f =ᵐ[ν] f :=
  Lp.coeFn_LpToLpOfMeasureLeSMul hC hν f

include hC hν in
lemma kernel_memLp_weighted (x : Plane) (hx : x ∈ disk) : MemLp (kernel x) 2 ν :=
  ((kernel_memLp x hx).smul_measure hC).mono_measure hν

lemma inclusion_row (x : Plane) (hx : x ∈ disk) :
    inclusion hC hν ((kernel_memLp x hx).toLp (kernel x)) =
      (kernel_memLp_weighted hC hν x hx).toLp (kernel x) := by
  apply Lp.ext
  exact (inclusion_ae hC hν _).trans
    (((Measure.absolutelyContinuous_of_le_smul hν).ae_eq (kernel_memLp x hx).coeFn_toLp).trans
      (kernel_memLp_weighted hC hν x hx).coeFn_toLp.symm)

lemma integral_adjoint_row (f : Lp ℝ 2 ν) (x : Plane) (hx : x ∈ disk) :
    (∫ y in disk, kernel x y * (inclusion hC hν).adjoint f y) =
      ∫ y, kernel x y * f y ∂ν := by
  rw [MeasurableL2Kernel.integral_mul_eq_inner (kernel_memLp x hx)
    (Lp.memLp ((inclusion hC hν).adjoint f)), Lp.toLp_coeFn,
    ContinuousLinearMap.adjoint_inner_right, inclusion_row hC hν x hx]
  rw [MeasurableL2Kernel.integral_mul_eq_inner (kernel_memLp_weighted hC hν x hx)
    (Lp.memLp f), Lp.toLp_coeFn]



def weightedIntegralOperator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν :=
  ((inclusion hC hν).comp integralOperator).comp (inclusion hC hν).adjoint

lemma weightedIntegralOperator_ae (f : Lp ℝ 2 ν) :
    weightedIntegralOperator hC hν f =ᵐ[ν] fun x => ∫ y, kernel x y * f y ∂ν := by
  have ha := (Measure.absolutelyContinuous_of_le_smul hν)
  filter_upwards [inclusion_ae hC hν (integralOperator ((inclusion hC hν).adjoint f)),
    ha.ae_eq (integralOperator_ae ((inclusion hC hν).adjoint f)),
    (ae_restrict_mem diskOpen.measurableSet).filter_mono ha.ae_le] with x hx hi hxd
  change inclusion hC hν (integralOperator ((inclusion hC hν).adjoint f)) x = _
  rw [hx,hi,integral_adjoint_row hC hν f x hxd]

lemma weightedIntegralOperator_eq_greenOperator : weightedIntegralOperator hC hν =
    H10.greenOperator diskOpen diskBounded hC hν := by
  unfold weightedIntegralOperator H10.greenOperator H10.weightedValue

  rw [DirichletOperator.green_comp, integralOperator_eq_variationalOperator]
  rfl



lemma weightedIntegralOperator_norm_le {d : ℝ} (hd : 0 ≤ d)
    (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2) : ‖weightedIntegralOperator hC hν‖ ≤ d := by
  rw [weightedIntegralOperator_eq_greenOperator]
  exact H10.greenOperator_norm_le diskOpen diskBounded hC hν hd hsub

lemma weightedIntegralOperator_symmetric (f g : Lp ℝ 2 ν) :
    inner ℝ (weightedIntegralOperator hC hν f) g =
      inner ℝ f (weightedIntegralOperator hC hν g) := by
  rw [weightedIntegralOperator_eq_greenOperator]
  exact H10.greenOperator_symmetric diskOpen diskBounded hC hν f g

lemma weightedIntegralOperator_nonneg (f : Lp ℝ 2 ν) :
    0 ≤ inner ℝ f (weightedIntegralOperator hC hν f) := by
  rw [weightedIntegralOperator_eq_greenOperator]
  exact H10.greenOperator_nonneg diskOpen diskBounded hC hν f

end StrictHotSpots.PlaneGreen

end WeightedLayer


end FullBoundaryCombinedLayer

end

end DouglasLipschitzBase

end OAI