lean/OAI/Analysis/HotSpots/KernelLimit.lean

import OAI.Analysis.HotSpots.BoundaryKernel

namespace OAI

section DouglasLipschitzBase
noncomputable section
section FullBoundaryCombinedLayer
section L2CutoffLayer

open MeasureTheory Set Filter
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.L2Cutoff
variable {X : Type*} [MeasurableSpace X] {ν : Measure X} (s : Set X) (hs : MeasurableSet s)

include hs in
lemma extension_memLp (f : Lp ℝ 2 (ν.restrict s)) : MemLp (s.indicator f) 2 ν :=
  (memLp_indicator_iff_restrict hs).2 (Lp.memLp f)

def extension : Lp ℝ 2 (ν.restrict s) →L[ℝ] Lp ℝ 2 ν := by
  let J : Lp ℝ 2 (ν.restrict s) →ₗ[ℝ] Lp ℝ 2 ν :=
    { toFun := fun f => (extension_memLp s hs f).toLp _
      map_add' := by
        intro f g
        apply Lp.ext
        filter_upwards [(extension_memLp s hs (f+g)).coeFn_toLp,
          (extension_memLp s hs f).coeFn_toLp, (extension_memLp s hs g).coeFn_toLp,
          Lp.coeFn_add ((extension_memLp s hs f).toLp _) ((extension_memLp s hs g).toLp _),
          ae_imp_of_ae_restrict (Lp.coeFn_add f g)] with x hfg hf hg ha he
        rw [hfg,ha,Pi.add_apply,hf,hg]
        by_cases hx : x ∈ s
        · simp only [indicator_of_mem hx, he hx, Pi.add_apply]
        · simp [indicator_of_notMem hx]
      map_smul' := by
        intro c f
        apply Lp.ext
        filter_upwards [(extension_memLp s hs (c • f)).coeFn_toLp,
          (extension_memLp s hs f).coeFn_toLp,
          Lp.coeFn_smul c ((extension_memLp s hs f).toLp _),
          ae_imp_of_ae_restrict (Lp.coeFn_smul c f)] with x hcf hf hc he
        simp only [RingHom.id_apply]
        rw [hcf,hc,Pi.smul_apply,hf]
        by_cases hx : x ∈ s
        · simp only [indicator_of_mem hx, he hx, Pi.smul_apply]
        · simp [indicator_of_notMem hx] }
  refine J.mkContinuous 1 (fun f => ?_)
  change ‖(extension_memLp s hs f).toLp _‖ ≤ 1 * ‖f‖
  rw [Lp.norm_toLp, eLpNorm_indicator_eq_eLpNorm_restrict hs, one_mul]
  rfl

lemma extension_ae (f : Lp ℝ 2 (ν.restrict s)) :
    extension s hs f =ᵐ[ν] s.indicator f := (extension_memLp s hs f).coeFn_toLp

lemma extension_norm (f : Lp ℝ 2 (ν.restrict s)) : ‖extension s hs f‖ = ‖f‖ := by
  change ‖(extension_memLp s hs f).toLp _‖ = _
  rw [Lp.norm_toLp, eLpNorm_indicator_eq_eLpNorm_restrict hs]
  rfl

lemma extension_norm_le : ‖extension (ν := ν) s hs‖ ≤ 1 := by
  apply (extension (ν := ν) s hs).opNorm_le_bound (by norm_num)
  intro f
  simp [extension_norm]

def restriction : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 (ν.restrict s) :=
  Lp.LpToLpOfMeasureLeSMul (by norm_num : (1 : ℝ≥0∞) ≠ ⊤)
    (show ν.restrict s ≤ 1 • ν by simpa using Measure.restrict_le_self)

lemma restriction_ae (f : Lp ℝ 2 ν) : restriction s f =ᵐ[ν.restrict s] f :=
  Lp.coeFn_LpToLpOfMeasureLeSMul _ _ f

lemma restriction_norm (f : Lp ℝ 2 ν) : ‖restriction s f‖ ≤ ‖f‖ := by
  change (eLpNorm (restriction s f) 2 (ν.restrict s)).toReal ≤ (eLpNorm f 2 ν).toReal
  rw [eLpNorm_congr_ae (restriction_ae s f)]
  exact ENNReal.toReal_mono (Lp.memLp f).eLpNorm_ne_top (eLpNorm_restrict_le _ _ _ _)

lemma restriction_norm_le : ‖restriction (ν := ν) s‖ ≤ 1 := by
  apply (restriction (ν := ν) s).opNorm_le_bound (by norm_num)
  intro f
  simpa only [one_mul] using restriction_norm s f

lemma restriction_extension (f : Lp ℝ 2 (ν.restrict s)) :
    restriction s (extension s hs f) = f := by
  apply Lp.ext
  filter_upwards [restriction_ae s (extension s hs f), (extension_ae s hs f).restrict,
    ae_restrict_mem hs] with x hx he hxs
  rw [hx,he,indicator_of_mem hxs]

lemma extension_inner (f : Lp ℝ 2 (ν.restrict s)) (g : Lp ℝ 2 ν) :
    inner ℝ (extension s hs f) g = inner ℝ f (restriction s g) := by
  simp only [L2.inner_def, RCLike.inner_apply, conj_trivial]
  have he : (fun x => g x * extension s hs f x) =ᵐ[ν]
      s.indicator (fun x => g x * f x) := by
    filter_upwards [extension_ae s hs f] with x hx
    rw [hx]
    by_cases hxs : x ∈ s <;> simp [hxs]
  rw [integral_congr_ae he, integral_indicator hs]
  apply integral_congr_ae
  filter_upwards [restriction_ae s g] with x hx
  rw [hx]

lemma extension_eq_adjoint : extension (ν := ν) s hs = (restriction s).adjoint := by
  exact (ContinuousLinearMap.eq_adjoint_iff _ _).2 (extension_inner s hs)

lemma extension_inner_extension (f g : Lp ℝ 2 (ν.restrict s)) :
    inner ℝ (extension s hs f) (extension s hs g) = inner ℝ f g := by
  rw [extension_inner, restriction_extension]

def projection : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν := (extension s hs).comp (restriction s)

lemma projection_ae (f : Lp ℝ 2 ν) : projection s hs f =ᵐ[ν] s.indicator f := by
  filter_upwards [extension_ae s hs (restriction s f),
    ae_imp_of_ae_restrict (restriction_ae s f)] with x hx hr
  change extension s hs (restriction s f) x = _
  rw [hx]
  by_cases hxs : x ∈ s
  · simp [hxs, hr hxs]
  · simp [hxs]

lemma projection_norm (f : Lp ℝ 2 ν) : ‖projection s hs f‖ ≤ ‖f‖ := by
  exact (extension_norm s hs _).le.trans (restriction_norm s f)

lemma projection_norm_le : ‖projection (ν := ν) s hs‖ ≤ 1 := by
  apply (projection (ν := ν) s hs).opNorm_le_bound (by norm_num)
  intro f
  simpa only [one_mul] using projection_norm s hs f

lemma projection_idempotent (f : Lp ℝ 2 ν) :
    projection s hs (projection s hs f) = projection s hs f := by
  exact congrArg (extension s hs) (restriction_extension s hs (restriction s f))

lemma projection_symmetric (f g : Lp ℝ 2 ν) :
    inner ℝ (projection s hs f) g = inner ℝ f (projection s hs g) := by
  change inner ℝ (extension s hs (restriction s f)) g =
    inner ℝ f (extension s hs (restriction s g))
  calc
    _ = inner ℝ (restriction s f) (restriction s g) := extension_inner s hs _ _
    _ = inner ℝ (restriction s g) (restriction s f) := real_inner_comm _ _
    _ = inner ℝ (extension s hs (restriction s g)) f := (extension_inner s hs _ _).symm
    _ = _ := real_inner_comm _ _

end StrictHotSpots.L2Cutoff

end L2CutoffLayer

section CutoffConvergenceLayer
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.L2Cutoff
variable {X : Type*} [MeasurableSpace X] {ν : Measure X}

lemma projection_tendsto (s : ℕ → Set X) (hs : ∀ n, MeasurableSet (s n))
    (hex : ∀ᵐ x ∂ν, ∀ᶠ n in atTop, x ∈ s n) (f : Lp ℝ 2 ν) :
    Tendsto (fun n => projection (s n) (hs n) f) atTop (𝓝 f) := by
  let hf : ∀ n, MemLp ((s n).indicator f) 2 ν :=
    fun n => (Lp.memLp f).indicator (hs n)
  have ht := L2Limits.tendsto_toLp_of_dominated hf (Lp.memLp f) (Lp.memLp f).norm
    (Eventually.of_forall fun n => Eventually.of_forall fun x => by
      by_cases hx : x ∈ s n <;> simp [hx])
    (by
      filter_upwards [hex] with x hx
      apply tendsto_const_nhds.congr'
      filter_upwards [hx] with n hn
      simp [hn])
  have he (n : ℕ) : projection (s n) (hs n) f = (hf n).toLp _ :=
    Lp.ext ((projection_ae (s n) (hs n) f).trans (hf n).coeFn_toLp.symm)
  simpa only [← he, Lp.toLp_coeFn] using ht

end StrictHotSpots.L2Cutoff
namespace StrictHotSpots.BanachResolvent
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma bounded_strong_tendsto_moving (Q : ℕ → E →L[ℝ] E) (A : E →L[ℝ] E)
    {d : ℝ} (hQ : ∀ᶠ n in atTop, ‖Q n‖ ≤ d)
    (hs : ∀ v, Tendsto (fun n => Q n v) atTop (𝓝 (A v)))
    {v : ℕ → E} {w : E} (hv : Tendsto v atTop (𝓝 w)) :
    Tendsto (fun n => Q n (v n)) atTop (𝓝 (A w)) := by
  have hz : Tendsto (fun n => Q n (v n-w)) atTop (𝓝 0) := by
    have hb : Tendsto (fun n => d * ‖v n-w‖) atTop (𝓝 0) := by
      simpa using (hv.sub_const w).norm.const_mul d
    apply squeeze_zero_norm' _ hb
    filter_upwards [hQ] with n hn
    exact (ContinuousLinearMap.le_opNorm _ _).trans
      (mul_le_mul_of_nonneg_right hn (norm_nonneg _))
  simpa only [map_sub, sub_add_cancel, zero_add] using hz.add (hs w)

lemma compression_norm_le (T P : E →L[ℝ] E) (hP : ‖P‖ ≤ 1) :
    ‖P.comp (T.comp P)‖ ≤ ‖T‖ := by
  calc
    _ ≤ ‖P‖ * (‖T‖ * ‖P‖) := (ContinuousLinearMap.opNorm_comp_le _ _).trans
      (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _))
    _ ≤ 1 * (‖T‖ * 1) := mul_le_mul hP
      (mul_le_mul_of_nonneg_left hP (norm_nonneg _))
      (mul_nonneg (norm_nonneg _) (norm_nonneg _)) (by norm_num)
    _ = ‖T‖ := by ring

lemma compression_strong_tendsto (T : E →L[ℝ] E) (P : ℕ → E →L[ℝ] E)
    (hP : ∀ᶠ n in atTop, ‖P n‖ ≤ 1)
    (hs : ∀ v, Tendsto (fun n => P n v) atTop (𝓝 v)) (f : E) :
    Tendsto (fun n => (P n).comp (T.comp (P n)) f) atTop (𝓝 (T f)) := by
  exact bounded_strong_tendsto_moving P (ContinuousLinearMap.id ℝ E) hP hs
    (T.continuous.continuousAt.tendsto.comp (hs f))

end StrictHotSpots.BanachResolvent
end
end CutoffConvergenceLayer

section CutoffOperatorsLayer
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.L2Cutoff
variable {X : Type*} [MeasurableSpace X] {ν : Measure X}
  (s : Set X) (hs : MeasurableSet s)

def restrictedOperator (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) :
    Lp ℝ 2 (ν.restrict s) →L[ℝ] Lp ℝ 2 (ν.restrict s) :=
  (restriction s).comp (T.comp (extension s hs))

def compressedOperator (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν :=
  (projection s hs).comp (T.comp (projection s hs))

lemma restrictedOperator_norm_le (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) :
    ‖restrictedOperator s hs T‖ ≤ ‖T‖ := by
  calc
    _ ≤ ‖restriction (ν := ν) s‖ * (‖T‖ * ‖extension (ν := ν) s hs‖) :=
      (ContinuousLinearMap.opNorm_comp_le _ _).trans
        (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _))
    _ ≤ 1 * (‖T‖ * 1) := mul_le_mul (restriction_norm_le s)
      (mul_le_mul_of_nonneg_left (extension_norm_le s hs) (norm_nonneg _))
      (mul_nonneg (norm_nonneg _) (norm_nonneg _)) (by norm_num)
    _ = ‖T‖ := by ring

lemma compressedOperator_norm_le (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) :
    ‖compressedOperator s hs T‖ ≤ ‖T‖ :=
  BanachResolvent.compression_norm_le T (projection s hs) (projection_norm_le s hs)

lemma extension_intertwine (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) (f : Lp ℝ 2 (ν.restrict s)) :
    extension s hs (restrictedOperator s hs T f) =
      compressedOperator s hs T (extension s hs f) := by
  change extension s hs (restriction s (T (extension s hs f))) =
    extension s hs (restriction s (T (extension s hs (restriction s (extension s hs f)))))
  rw [restriction_extension]

lemma resolvent_extension (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) (hT : ‖T‖ < 1)
    (f : Lp ℝ 2 (ν.restrict s)) :
    BanachResolvent.resolvent (compressedOperator s hs T) (extension s hs f) =
      extension s hs (BanachResolvent.resolvent (restrictedOperator s hs T) f) := by
  symm
  apply BanachResolvent.resolvent_solution _ ((compressedOperator_norm_le s hs T).trans_lt hT)
  rw [← extension_intertwine, ← map_sub]
  congr 1
  exact congrArg (fun A : Lp ℝ 2 (ν.restrict s) →L[ℝ] Lp ℝ 2 (ν.restrict s) => A f)
    (BanachResolvent.resolvent_left _ ((restrictedOperator_norm_le s hs T).trans_lt hT))

lemma resolvent_inner_extension (T : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν) (hT : ‖T‖ < 1)
    (f g : Lp ℝ 2 (ν.restrict s)) :
    inner ℝ (extension s hs f)
      (BanachResolvent.resolvent (compressedOperator s hs T) (extension s hs g)) =
      inner ℝ f (BanachResolvent.resolvent (restrictedOperator s hs T) g) := by
  rw [resolvent_extension s hs T hT, extension_inner_extension]

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

include hν in
lemma restrictDensity : ν.restrict s ≤ C • volume.restrict disk :=
  Measure.restrict_le_self.trans hν

lemma inclusion_restrict : inclusion hC (restrictDensity hν s) =
    (L2Cutoff.restriction s).comp (inclusion hC hν) := by
  apply ContinuousLinearMap.ext
  intro f
  apply Lp.ext
  filter_upwards [inclusion_ae hC (restrictDensity hν s) f,
    L2Cutoff.restriction_ae s (inclusion hC hν f), (inclusion_ae hC hν f).restrict]
    with x hx hr hi
  rw [hx, show ((L2Cutoff.restriction s).comp (inclusion hC hν)) f x = f x from hr.trans hi]

lemma weightedIntegralOperator_restrict (hs : MeasurableSet s) :
    weightedIntegralOperator hC (restrictDensity hν s) =
      L2Cutoff.restrictedOperator s hs (weightedIntegralOperator hC hν) := by
  unfold weightedIntegralOperator L2Cutoff.restrictedOperator
  rw [inclusion_restrict hC hν s, ContinuousLinearMap.adjoint_comp, L2Cutoff.extension_eq_adjoint]
  simp only [ContinuousLinearMap.comp_assoc]

lemma weightedValue_restrict (u : H10 diskOpen) :
    H10.weightedValue diskOpen hC (restrictDensity hν s) u =
      L2Cutoff.restriction s (H10.weightedValue diskOpen hC hν u) := by
  exact congrArg (fun T => T (H10.value diskOpen u)) (inclusion_restrict hC hν s)

lemma subcritical_restrict {d : ℝ}
    (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2) :
    ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC (restrictDensity hν s) u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2 := by
  intro u
  rw [weightedValue_restrict hC hν s]
  exact (pow_le_pow_left₀ (norm_nonneg _) (L2Cutoff.restriction_norm s _) 2).trans (hsub u)

lemma row_restrict (p : disk) : row hC (restrictDensity hν s) p =
    L2Cutoff.restriction s (row hC hν p) := by
  apply Lp.ext
  exact (column_memLp hC (restrictDensity hν s) p).coeFn_toLp.trans
    (((L2Cutoff.restriction_ae s (row hC hν p)).trans
      (column_memLp hC hν p).coeFn_toLp.restrict).symm)

end StrictHotSpots.PlaneGreen
end
end CutoffOperatorsLayer

section DiskCutoffLayer
noncomputable section
open MeasureTheory Set Filter Metric
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.PlaneGreen
open DiskH10

def cutoffRadius (n : ℕ) : ℝ := 1 - 1 / ((n : ℝ) + 1)
def cutoffSet (n : ℕ) : Set Plane := closedBall 0 (cutoffRadius n)

lemma cutoffRadius_nonneg (n : ℕ) : 0 ≤ cutoffRadius n := by
  unfold cutoffRadius
  have hn : 1 ≤ (n : ℝ) + 1 := by linarith [Nat.cast_nonneg (α := ℝ) n]
  have hh : 1 / ((n : ℝ) + 1) ≤ 1 := (div_le_one (by positivity)).2 hn
  linarith

lemma cutoffRadius_lt_one (n : ℕ) : cutoffRadius n < 1 := by
  unfold cutoffRadius
  exact sub_lt_self _ (one_div_pos.mpr (by positivity))

lemma cutoffRadius_tendsto : Tendsto cutoffRadius atTop (𝓝 1) := by
  change Tendsto (fun n : ℕ => 1 - 1 / ((n : ℝ) + 1)) atTop (𝓝 1)
  simpa only [sub_zero] using
    ((tendsto_const_nhds (x := (1:ℝ))).sub (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)))

lemma cutoffSet_compact (n : ℕ) : IsCompact (cutoffSet n) := isCompact_closedBall _ _
lemma cutoffSet_measurable (n : ℕ) : MeasurableSet (cutoffSet n) := measurableSet_closedBall
lemma cutoffSet_subset (n : ℕ) : cutoffSet n ⊆ disk := by
  intro x hx
  simpa [disk] using (show ‖x‖ ≤ cutoffRadius n by simpa [cutoffSet] using hx).trans_lt
    (cutoffRadius_lt_one n)

lemma eventually_mem_cutoffSet (x : Plane) (hx : x ∈ disk) :
    ∀ᶠ n in atTop, x ∈ cutoffSet n := by
  have ht := cutoffRadius_tendsto.eventually (eventually_gt_nhds (show ‖x‖ < 1 by simpa [disk] using hx))
  filter_upwards [ht] with n hn
  simpa [cutoffSet] using hn.le

variable {ν : Measure Plane} {C : ℝ≥0∞} (hC : C ≠ ∞)
  (hν : ν ≤ C • volume.restrict disk)

include hν in
lemma ae_eventually_mem_cutoffSet : ∀ᵐ x ∂ν, ∀ᶠ n in atTop, x ∈ cutoffSet n := by
  filter_upwards [ae_mem_disk hν] with x hx
  exact eventually_mem_cutoffSet x hx

include hν in
lemma cutoffProjection_tendsto (f : Lp ℝ 2 ν) :
    Tendsto (fun n => L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) f)
      atTop (𝓝 f) :=
  L2Cutoff.projection_tendsto cutoffSet cutoffSet_measurable (ae_eventually_mem_cutoffSet hν) f

include hν in
lemma cutoff_integral_tendsto {f : Plane → ℝ} (hf : Integrable f ν) :
    Tendsto (fun n => ∫ x in cutoffSet n, f x ∂ν) atTop (𝓝 (∫ x, f x ∂ν)) := by
  have hm : ∀ n, AEStronglyMeasurable ((cutoffSet n).indicator f) ν :=
    fun n => hf.aestronglyMeasurable.indicator (cutoffSet_measurable n)
  have ht := tendsto_integral_filter_of_dominated_convergence (f := f) (fun x => ‖f x‖)
    (Eventually.of_forall hm)
    (Eventually.of_forall fun n => Eventually.of_forall fun x => by
      by_cases hx : x ∈ cutoffSet n <;> simp [hx]) hf.norm
    (by
      filter_upwards [ae_eventually_mem_cutoffSet hν] with x hx
      apply tendsto_const_nhds.congr'
      filter_upwards [hx] with n hn
      simp [hn])
  simpa only [integral_indicator (cutoffSet_measurable _)] using ht

include hν in
lemma smoothedPoisson_nonneg (s : Boundary) {x : Plane} (hx : x ∈ disk) :
    0 ≤ smoothedPoisson (ν := ν) s x := by
  apply integral_nonneg_of_ae
  filter_upwards [ae_mem_disk hν] with y hy
  exact mul_nonneg (kernel_nonneg hx hy) (poisson_nonneg s ⟨y,hy⟩)

include hC hν in
lemma smoothedPoisson_restrict_le (s : Boundary) (E : Set Plane) {x : Plane} (hx : x ∈ disk) :
    smoothedPoisson (ν := ν.restrict E) s x ≤ smoothedPoisson (ν := ν) s x := by
  apply setIntegral_le_integral (product_green_poisson_integrable hC hν x hx s)
  filter_upwards [ae_mem_disk hν] with y hy
  exact mul_nonneg (kernel_nonneg hx hy) (poisson_nonneg s ⟨y,hy⟩)

include hC hν in
lemma smoothedPoisson_full_memLp [IsFiniteMeasure ν] (s : Boundary) (E : Set Plane) :
    MemLp (smoothedPoisson (ν := ν.restrict E) s) 2 ν := by
  obtain ⟨B,_,hB⟩ := green_poisson_uniform_bound hC hν
  apply MemLp.of_bound (smoothedPoisson_measurable s).aestronglyMeasurable B
  filter_upwards [ae_mem_disk hν] with x hx
  rw [Real.norm_of_nonneg (smoothedPoisson_nonneg (restrictDensity hν E) s hx)]
  exact (smoothedPoisson_restrict_le hC hν s E hx).trans
    (le_abs_self _ |>.trans (hB x hx s))

include hC hν in
lemma smoothedPoisson_cutoff_tendsto (s : Boundary) {x : Plane} (hx : x ∈ disk) :
    Tendsto (fun n => smoothedPoisson (ν := ν.restrict (cutoffSet n)) s x)
      atTop (𝓝 (smoothedPoisson (ν := ν) s x)) :=
  cutoff_integral_tendsto hν (product_green_poisson_integrable hC hν x hx s)

lemma smoothedPoisson_cutoff_L2_tendsto [IsFiniteMeasure ν] (s : Boundary) :
    Tendsto (fun n => (smoothedPoisson_full_memLp hC hν s (cutoffSet n)).toLp
      (smoothedPoisson (ν := ν.restrict (cutoffSet n)) s)) atTop
      (𝓝 ((smoothedPoisson_memLp hC hν s).toLp (smoothedPoisson (ν := ν) s))) := by
  apply L2Limits.tendsto_toLp_of_dominated
    (fun n => smoothedPoisson_full_memLp hC hν s (cutoffSet n))
    (smoothedPoisson_memLp hC hν s) (smoothedPoisson_memLp hC hν s)
  · apply Eventually.of_forall
    intro n
    filter_upwards [ae_mem_disk hν] with x hx
    rw [Real.norm_of_nonneg (smoothedPoisson_nonneg (restrictDensity hν (cutoffSet n)) s hx)]
    exact smoothedPoisson_restrict_le hC hν s (cutoffSet n) hx
  · filter_upwards [ae_mem_disk hν] with x hx
    exact smoothedPoisson_cutoff_tendsto hC hν s hx

end StrictHotSpots.PlaneGreen
end
end DiskCutoffLayer

section FullBoundaryKernelLayer
noncomputable section
open MeasureTheory Set Filter Metric
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.BanachResolvent
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℝ H] [CompleteSpace H]

lemma apply_eq_add (T : H →L[ℝ] H) (hT : ‖T‖ < 1) (f : H) :
    resolvent T f = f + resolvent T (T f) := by
  have he := congrArg (fun A : H →L[ℝ] H => A f) (resolvent_right T hT)
  have hh : resolvent T f - resolvent T (T f) = f := by
    simpa only [mul_apply_eq_comp, sub_apply,
      one_apply_eq_self, map_sub] using he
  exact sub_eq_iff_eq_add.mp hh

lemma apply_eq_add_left (T : H →L[ℝ] H) (hT : ‖T‖ < 1) (f : H) :
    resolvent T f = f + T (resolvent T f) := by
  have he := congrArg (fun A : H →L[ℝ] H => A f) (resolvent_left T hT)
  have hh : resolvent T f - T (resolvent T f) = f := by
    simpa only [mul_apply_eq_comp, sub_apply,
      one_apply_eq_self] using he
  exact sub_eq_iff_eq_add.mp hh

lemma inner_two_terms (T : H →L[ℝ] H) (hT : ‖T‖ < 1)
    (hsym : ∀ f g, inner ℝ (T f) g = inner ℝ f (T g)) (f g : H) :
    inner ℝ f (resolvent T g) = inner ℝ f g + inner ℝ f (T g) +
      inner ℝ (T f) (resolvent T (T g)) := by
  have h1 := congrArg (fun v => inner ℝ f v) (apply_eq_add T hT g)
  have h2 := congrArg (fun v => inner ℝ f v) (apply_eq_add_left T hT (T g))
  rw [inner_add_right] at h1 h2
  rw [← hsym f (resolvent T (T g))] at h2
  rw [h1, h2]
  ring

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

def smoothedRow (s : Boundary) : Lp ℝ 2 ν :=
  (smoothedPoisson_memLp hC hν s).toLp (smoothedPoisson (ν := ν) s)

def cutoffSmoothedRow (n : ℕ) (s : Boundary) : Lp ℝ 2 ν :=
  (smoothedPoisson_full_memLp hC hν s (cutoffSet n)).toLp
    (smoothedPoisson (ν := ν.restrict (cutoffSet n)) s)

omit [IsFiniteMeasure ν] in
lemma cutoff_ae_norm (n : ℕ) : ∀ᵐ x ∂ν.restrict (cutoffSet n), ‖x‖ ≤ cutoffRadius n := by
  filter_upwards [ae_restrict_mem (cutoffSet_measurable n)] with x hx
  simpa [cutoffSet] using hx

lemma compactSmoothedRow_eq (n : ℕ) (s : Boundary) :
    weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s) =
    L2Cutoff.restriction (cutoffSet n) (cutoffSmoothedRow hC hν n s) := by
  apply Lp.ext
  filter_upwards [weightedIntegralOperator_ae hC (restrictDensity hν (cutoffSet n))
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s),
    L2Cutoff.restriction_ae (cutoffSet n) (cutoffSmoothedRow hC hν n s),
    ((smoothedPoisson_full_memLp hC hν s (cutoffSet n)).coeFn_toLp).restrict] with x hx hr hs
  rw [hx,hr,show cutoffSmoothedRow hC hν n s x =
    smoothedPoisson (ν := ν.restrict (cutoffSet n)) s x from hs]
  apply integral_congr_ae
  filter_upwards [(poisson_memLp (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s).coeFn_toLp]
    with y hy
  rw [show poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s y = poisson s y from hy]

lemma extendedSmoothedRow_tendsto (s : Boundary) :
    Tendsto (fun n => L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n)
      (cutoffSmoothedRow hC hν n s)) atTop (𝓝 (smoothedRow hC hν s)) := by
  apply BanachResolvent.bounded_strong_tendsto_moving
    (fun n => L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n))
    (ContinuousLinearMap.id ℝ (Lp ℝ 2 ν))
    (Eventually.of_forall fun n => L2Cutoff.projection_norm_le _ _)
    (cutoffProjection_tendsto hν)
  exact smoothedPoisson_cutoff_L2_tendsto hC hν s



def fullBoundaryK (p : disk) (s : Boundary) : ℝ := poisson s p + smoothedPoisson (ν := ν) s p +
  inner ℝ (row hC hν p) (BanachResolvent.resolvent (weightedIntegralOperator hC hν)
    (smoothedRow hC hν s))



def fullBoundaryN (s t : Boundary) : ℝ := boundaryInteraction s t +
  (∫ x, poisson s x * poisson t x ∂ν) +
  (∫ x, poisson s x * smoothedPoisson (ν := ν) t x ∂ν) +
  inner ℝ (smoothedRow hC hν s) (BanachResolvent.resolvent (weightedIntegralOperator hC hν)
    (smoothedRow hC hν t))

lemma smoothedRow_nonneg (s : Boundary) : 0 ≤ smoothedRow hC hν s := by
  apply (Lp.coeFn_nonneg _).mp
  filter_upwards [(smoothedPoisson_memLp hC hν s).coeFn_toLp, ae_mem_disk hν] with x hx hxd
  rw [show smoothedRow hC hν s x = smoothedPoisson (ν := ν) s x from hx]
  exact smoothedPoisson_nonneg hν s hxd

lemma fullBoundaryK_pos (hT : ‖weightedIntegralOperator hC hν‖ < 1) (p : disk) (s : Boundary) :
    0 < fullBoundaryK hC hν p s := by
  apply add_pos_of_pos_of_nonneg
  · exact add_pos_of_pos_of_nonneg (poisson_pos s p) (smoothedPoisson_nonneg hν s p.property)
  · apply L2Limits.inner_nonneg (row_nonneg hC hν p)
    exact BanachResolvent.resolvent_nonneg _ hT (weightedIntegralOperator_order_nonneg hC hν)
      (smoothedRow_nonneg hC hν s)

lemma fullBoundaryN_pos (hT : ‖weightedIntegralOperator hC hν‖ < 1) (s t : Boundary) (hst : s ≠ t) :
    0 < fullBoundaryN hC hν s t := by
  apply add_pos_of_pos_of_nonneg
  · apply add_pos_of_pos_of_nonneg
    · apply add_pos_of_pos_of_nonneg (boundaryInteraction_pos s t hst)
      apply integral_nonneg_of_ae
      filter_upwards [ae_mem_disk hν] with x hx
      exact mul_nonneg (poisson_nonneg s ⟨x,hx⟩) (poisson_nonneg t ⟨x,hx⟩)
    · apply integral_nonneg_of_ae
      filter_upwards [ae_mem_disk hν] with x hx
      exact mul_nonneg (poisson_nonneg s ⟨x,hx⟩) (smoothedPoisson_nonneg hν t hx)
  · apply L2Limits.inner_nonneg (smoothedRow_nonneg hC hν s)
    exact BanachResolvent.resolvent_nonneg _ hT (weightedIntegralOperator_order_nonneg hC hν)
      (smoothedRow_nonneg hC hν t)

end StrictHotSpots.PlaneGreen
end
end FullBoundaryKernelLayer

section PoissonProductsLayer
noncomputable section
open MeasureTheory Set Filter Metric
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.PlaneGreen
open DiskH10

lemma poisson_measurable (s : Boundary) : Measurable (poisson s) := by
  unfold poisson DiskFormula.poisson
  fun_prop

lemma poisson_invnorm_bound (s : Boundary) {x : Plane} (hx : x ∈ disk) :
    poisson s x ≤ Real.pi⁻¹ * ‖(s : Plane)-x‖⁻¹ := by
  have hh := DiskFormula.poisson_invnorm_bound (complexIso.symm s) (complexIso.symm x)
    (by simpa using s.property) (by simpa [disk] using hx)
  simpa only [poisson, ← map_sub, LinearIsometryEquiv.norm_map] using hh

lemma poisson_product_bound (s t : Boundary) (hst : s ≠ t) : ∃ A : ℝ, 0 ≤ A ∧
    ∀ x ∈ disk, poisson s x * poisson t x ≤ A * (poisson s x + poisson t x) := by
  let D : ℝ := ‖(s : Plane)-(t : Plane)‖ / 2
  have hD : 0 < D := div_pos (norm_pos_iff.mpr (sub_ne_zero.mpr
    (fun h => hst (Subtype.ext h)))) (by norm_num)
  let A : ℝ := Real.pi⁻¹ * D⁻¹
  refine ⟨A, mul_nonneg (inv_nonneg.mpr Real.pi_pos.le) (inv_nonneg.mpr hD.le), fun x hx => ?_⟩
  have hdist : 2*D ≤ ‖(s : Plane)-x‖ + ‖(t : Plane)-x‖ := by
    have hh := norm_add_le ((s : Plane)-x) (x-(t : Plane))
    have he : (s : Plane)-x+(x-(t : Plane)) = (s : Plane)-(t : Plane) := by abel
    rw [he, norm_sub_rev x (t : Plane)] at hh
    dsimp [D]
    linarith
  have hb (v : Boundary) (hv : D ≤ ‖(v : Plane)-x‖) : poisson v x ≤ A := by
    apply (poisson_invnorm_bound v hx).trans
    exact mul_le_mul_of_nonneg_left
      (by simpa only [one_div] using one_div_le_one_div_of_le hD hv) (inv_nonneg.mpr Real.pi_pos.le)
  have hs := poisson_nonneg s ⟨x,hx⟩
  have ht := poisson_nonneg t ⟨x,hx⟩
  by_cases hd : D ≤ ‖(s : Plane)-x‖
  · have h1 := mul_le_mul_of_nonneg_right (hb s hd) ht
    have h2 : A * poisson t x ≤ A * (poisson s x + poisson t x) :=
      mul_le_mul_of_nonneg_left (by linarith) (by dsimp [A]; positivity)
    exact h1.trans h2
  · have h1 := mul_le_mul_of_nonneg_left (hb t (by linarith)) hs
    have h2 : poisson s x * A ≤ A * (poisson s x + poisson t x) := by
      have hA : 0 ≤ A := by dsimp [A]; positivity
      nlinarith
    exact h1.trans h2

variable {ν : Measure Plane} [IsFiniteMeasure ν] {C : ℝ≥0∞}
  (hC : C ≠ ∞) (hν : ν ≤ C • volume.restrict disk)

include hC hν in
lemma poisson_integrable (s : Boundary) : Integrable (poisson s) ν :=
  (poisson_memLp_three_halves_weighted hC hν s).integrable (by rw [ENNReal.le_div_iff_mul_le (by norm_num) (by norm_num)]; norm_num)

include hC hν in
lemma poisson_product_integrable (s t : Boundary) (hst : s ≠ t) :
    Integrable (fun x => poisson s x * poisson t x) ν := by
  obtain ⟨A,_,hA⟩ := poisson_product_bound s t hst
  apply (((poisson_integrable hC hν s).add (poisson_integrable hC hν t)).const_mul A).mono'
    ((poisson_measurable s).mul (poisson_measurable t)).aestronglyMeasurable
  filter_upwards [ae_mem_disk hν] with x hx
  change ‖poisson s x * poisson t x‖ ≤ A * (poisson s x + poisson t x)
  rw [Real.norm_of_nonneg (mul_nonneg (poisson_nonneg s ⟨x,hx⟩) (poisson_nonneg t ⟨x,hx⟩))]
  exact hA x hx

include hC hν in
lemma poisson_smoothed_integrable (s t : Boundary) :
    Integrable (fun x => poisson s x * smoothedPoisson (ν := ν) t x) ν := by
  obtain ⟨B,_,hB⟩ := green_poisson_uniform_bound hC hν
  apply ((poisson_integrable hC hν s).norm.mul_const B).mono'
    ((poisson_measurable s).mul (smoothedPoisson_measurable t)).aestronglyMeasurable
  filter_upwards [ae_mem_disk hν] with x hx
  change ‖poisson s x * smoothedPoisson (ν := ν) t x‖ ≤ ‖poisson s x‖ * B
  rw [norm_mul]
  exact mul_le_mul_of_nonneg_left (hB x hx t) (norm_nonneg _)

include hC hν in
lemma poisson_smoothed_cutoff_tendsto (s t : Boundary) :
    Tendsto (fun n => ∫ x in cutoffSet n, poisson s x *
      smoothedPoisson (ν := ν.restrict (cutoffSet n)) t x ∂ν) atTop
      (𝓝 (∫ x, poisson s x * smoothedPoisson (ν := ν) t x ∂ν)) := by
  obtain ⟨B,_,hB⟩ := green_poisson_uniform_bound hC hν
  let f (n : ℕ) (x : Plane) := (cutoffSet n).indicator (fun x => poisson s x *
    smoothedPoisson (ν := ν.restrict (cutoffSet n)) t x) x
  have hm n : AEStronglyMeasurable (f n) ν :=
    (((poisson_measurable s).mul (smoothedPoisson_measurable t)).indicator
      (cutoffSet_measurable n)).aestronglyMeasurable
  have hd n : ∀ᵐ x ∂ν, ‖f n x‖ ≤ ‖poisson s x‖ * B := by
    filter_upwards [ae_mem_disk hν] with x hx
    by_cases he : x ∈ cutoffSet n
    · dsimp only [f]
      rw [indicator_of_mem he, norm_mul]
      apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
      rw [Real.norm_of_nonneg (smoothedPoisson_nonneg (restrictDensity hν (cutoffSet n)) t hx)]
      exact (smoothedPoisson_restrict_le hC hν t (cutoffSet n) hx).trans
        (le_abs_self _ |>.trans (hB x hx t))
    · simp only [f, indicator_of_notMem he, norm_zero]
      exact mul_nonneg (norm_nonneg _) (norm_nonneg _ |>.trans (hB x hx t))
  have hl : ∀ᵐ x ∂ν, Tendsto (fun n => f n x) atTop
      (𝓝 (poisson s x * smoothedPoisson (ν := ν) t x)) := by
    filter_upwards [ae_mem_disk hν, ae_eventually_mem_cutoffSet hν] with x hx he
    apply ((smoothedPoisson_cutoff_tendsto hC hν t hx).const_mul (poisson s x)).congr'
    filter_upwards [he] with n hn
    simp [f,hn]
  have hh := tendsto_integral_filter_of_dominated_convergence (fun x => ‖poisson s x‖ * B)
    (Eventually.of_forall hm) (Eventually.of_forall hd)
    ((poisson_integrable hC hν s).norm.mul_const B) hl
  simpa only [f, integral_indicator (cutoffSet_measurable _)] using hh

end StrictHotSpots.PlaneGreen
end
end PoissonProductsLayer

section CutoffBoundaryLimitsLayer
noncomputable section
open MeasureTheory Set Filter Metric
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.PlaneGreen
open DiskH10
variable {ν : Measure Plane} [IsFiniteMeasure ν] {C : ℝ≥0∞}
  (hC : C ≠ ∞) (hν : ν ≤ C • volume.restrict disk)

abbrev cutoffOperator (n : ℕ) : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 ν :=
  L2Cutoff.compressedOperator (cutoffSet n) (cutoffSet_measurable n) (weightedIntegralOperator hC hν)

abbrev cutoffK (n : ℕ) (p : disk) (s : Boundary) : ℝ :=
  boundaryK (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) hC
    (restrictDensity hν (cutoffSet n)) p s

abbrev cutoffN (n : ℕ) (s t : Boundary) : ℝ :=
  boundaryN (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) hC
    (restrictDensity hν (cutoffSet n)) s t

lemma cutoff_row_inner (n : ℕ) (p : disk) (s : Boundary) :
    inner ℝ (row hC (restrictDensity hν (cutoffSet n)) p)
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s) =
      smoothedPoisson (ν := ν.restrict (cutoffSet n)) s p := by
  rw [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [(column_memLp hC (restrictDensity hν (cutoffSet n)) p).coeFn_toLp,
    (poisson_memLp (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s).coeFn_toLp] with x hx hs
  change poissonRow _ _ s x * row hC _ p x = _
  rw [show row hC (restrictDensity hν (cutoffSet n)) p x = kernel x p from hx,
    show poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s x = poisson s x from hs,
    kernel_symm, mul_comm]

lemma cutoff_poisson_inner (n : ℕ) (s t : Boundary) :
    inner ℝ (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s)
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) t) =
      ∫ x in cutoffSet n, poisson s x * poisson t x ∂ν :=
  (MeasurableL2Kernel.integral_mul_eq_inner
    (poisson_memLp (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s)
    (poisson_memLp (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) t)).symm

lemma cutoff_poisson_smoothed_inner (n : ℕ) (s t : Boundary) :
    inner ℝ (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s)
      (weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))
        (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) t)) =
      ∫ x in cutoffSet n, poisson s x *
        smoothedPoisson (ν := ν.restrict (cutoffSet n)) t x ∂ν := by
  rw [compactSmoothedRow_eq hC hν, L2.inner_def]
  apply integral_congr_ae
  filter_upwards [(poisson_memLp (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s).coeFn_toLp,
    L2Cutoff.restriction_ae (cutoffSet n) (cutoffSmoothedRow hC hν n t),
    ((smoothedPoisson_full_memLp hC hν t (cutoffSet n)).coeFn_toLp).restrict] with x hs hr ht
  change L2Cutoff.restriction (cutoffSet n) (cutoffSmoothedRow hC hν n t) x *
    poissonRow _ _ s x = _
  rw [hr,show cutoffSmoothedRow hC hν n t x =
    smoothedPoisson (ν := ν.restrict (cutoffSet n)) t x from ht,
    show poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s x = poisson s x from hs,
    mul_comm]

lemma cutoffK_expansion (hT : ‖weightedIntegralOperator hC hν‖ < 1)
    (n : ℕ) (p : disk) (s : Boundary) :
    cutoffK hC hν n p s = poisson s p + smoothedPoisson (ν := ν.restrict (cutoffSet n)) s p +
      inner ℝ (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (row hC hν p))
        (BanachResolvent.resolvent (cutoffOperator hC hν n)
          (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n s))) := by
  have hn : ‖weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))‖ < 1 := by
    rw [weightedIntegralOperator_restrict hC hν _ (cutoffSet_measurable n)]
    exact (L2Cutoff.restrictedOperator_norm_le _ _ _).trans_lt hT
  have he := L2Cutoff.resolvent_inner_extension (cutoffSet n) (cutoffSet_measurable n)
    (weightedIntegralOperator hC hν) hT (row hC (restrictDensity hν (cutoffSet n)) p)
    (weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s))
  rw [← weightedIntegralOperator_restrict hC hν _ (cutoffSet_measurable n)] at he
  rw [row_restrict hC hν, compactSmoothedRow_eq hC hν] at he
  change inner ℝ (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (row hC hν p))
    (BanachResolvent.resolvent (cutoffOperator hC hν n)
      (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n s))) = _ at he
  unfold cutoffK boundaryK
  rw [BanachResolvent.apply_eq_add _ hn, inner_add_right, cutoff_row_inner hC hν]
  rw [compactSmoothedRow_eq hC hν, row_restrict hC hν]
  rw [← he]
  ring

lemma cutoffN_expansion (hT : ‖weightedIntegralOperator hC hν‖ < 1)
    (n : ℕ) (s t : Boundary) :
    cutoffN hC hν n s t = boundaryInteraction s t +
      (∫ x in cutoffSet n, poisson s x * poisson t x ∂ν) +
      (∫ x in cutoffSet n, poisson s x * smoothedPoisson (ν := ν.restrict (cutoffSet n)) t x ∂ν) +
      inner ℝ (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n s))
        (BanachResolvent.resolvent (cutoffOperator hC hν n)
          (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n t))) := by
  have hn : ‖weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))‖ < 1 := by
    rw [weightedIntegralOperator_restrict hC hν _ (cutoffSet_measurable n)]
    exact (L2Cutoff.restrictedOperator_norm_le _ _ _).trans_lt hT
  have he := L2Cutoff.resolvent_inner_extension (cutoffSet n) (cutoffSet_measurable n)
    (weightedIntegralOperator hC hν) hT
    (weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) s))
    (weightedIntegralOperator hC (restrictDensity hν (cutoffSet n))
      (poissonRow (cutoff_ae_norm (ν := ν) n) (cutoffRadius_lt_one n) t))
  rw [← weightedIntegralOperator_restrict hC hν _ (cutoffSet_measurable n)] at he
  simp only [compactSmoothedRow_eq hC hν] at he
  change inner ℝ (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n s))
    (BanachResolvent.resolvent (cutoffOperator hC hν n)
      (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n t))) = _ at he
  unfold cutoffN boundaryN
  rw [BanachResolvent.inner_two_terms _ hn (weightedIntegralOperator_symmetric hC _),
    cutoff_poisson_inner, cutoff_poisson_smoothed_inner hC hν]
  simp only [compactSmoothedRow_eq hC hν]
  rw [← he]
  ring

omit [IsFiniteMeasure ν] in
lemma cutoffOperator_strong_tendsto (f : Lp ℝ 2 ν) :
    Tendsto (fun n => cutoffOperator hC hν n f) atTop (𝓝 (weightedIntegralOperator hC hν f)) :=
  BanachResolvent.compression_strong_tendsto _ _
    (Eventually.of_forall fun n => L2Cutoff.projection_norm_le (cutoffSet n) (cutoffSet_measurable n)) (cutoffProjection_tendsto hν) f

lemma cutoff_resolvent_smoothed_tendsto (hT : ‖weightedIntegralOperator hC hν‖ < 1) (s : Boundary) :
    Tendsto (fun n => BanachResolvent.resolvent (cutoffOperator hC hν n)
      (L2Cutoff.projection (cutoffSet n) (cutoffSet_measurable n) (cutoffSmoothedRow hC hν n s)))
      atTop (𝓝 (BanachResolvent.resolvent (weightedIntegralOperator hC hν) (smoothedRow hC hν s))) := by
  apply BanachResolvent.resolvent_strong_tendsto_moving _ _ hT hT
    (Eventually.of_forall fun n => L2Cutoff.compressedOperator_norm_le _ _ _)
    (cutoffOperator_strong_tendsto hC hν)
  exact extendedSmoothedRow_tendsto hC hν s

lemma cutoffK_tendsto (hT : ‖weightedIntegralOperator hC hν‖ < 1) (p : disk) (s : Boundary) :
    Tendsto (fun n => cutoffK hC hν n p s) atTop (𝓝 (fullBoundaryK hC hν p s)) := by
  have ht := ((tendsto_const_nhds (x := poisson s p)).add
    (smoothedPoisson_cutoff_tendsto hC hν s p.property)).add
    ((cutoffProjection_tendsto hν (row hC hν p)).inner
      (cutoff_resolvent_smoothed_tendsto hC hν hT s))
  simpa only [cutoffK_expansion hC hν hT, fullBoundaryK] using ht

lemma cutoffN_tendsto (hT : ‖weightedIntegralOperator hC hν‖ < 1) (s t : Boundary) (hst : s ≠ t) :
    Tendsto (fun n => cutoffN hC hν n s t) atTop (𝓝 (fullBoundaryN hC hν s t)) := by
  have ht := (((tendsto_const_nhds (x := boundaryInteraction s t)).add
    (cutoff_integral_tendsto hν (poisson_product_integrable hC hν s t hst))).add
    (poisson_smoothed_cutoff_tendsto hC hν s t)).add
    ((extendedSmoothedRow_tendsto hC hν s).inner (cutoff_resolvent_smoothed_tendsto hC hν hT t))
  simpa only [cutoffN_expansion hC hν hT, fullBoundaryN] using ht

end StrictHotSpots.PlaneGreen
end
end CutoffBoundaryLimitsLayer

section FullBoundaryReciprocalLayer
noncomputable section
open MeasureTheory Filter Set
open scoped ENNReal Topology InnerProductSpace
namespace StrictHotSpots.PlaneGreen
open DiskH10
variable {ν : Measure Plane} [IsFiniteMeasure ν] {C : ℝ≥0∞}
  (hC : C ≠ ∞) (hν : ν ≤ C • volume.restrict disk)



theorem boundary_reciprocal {d : ℝ} (hd0 : 0 ≤ d) (hd1 : d < 1)
    (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2) (p : disk)
    {ι : Type} [Fintype ι] (s : ι → Boundary) :
    ReciprocalKernel.OnePositiveSquare (ReciprocalKernel.bordered
      (Matrix.of fun i j => if s i = s j then 0 else (fullBoundaryN hC hν (s i) (s j))⁻¹)
      (fun i => (fullBoundaryK hC hν p (s i))⁻¹)) := by
  classical
  have hn : ‖weightedIntegralOperator hC hν‖ < 1 :=
    (weightedIntegralOperator_norm_le hC hν hd0 hsub).trans_lt hd1
  let A (n : ℕ) := ReciprocalKernel.bordered
    (Matrix.of fun i j => if s i = s j then 0 else (cutoffN hC hν n (s i) (s j))⁻¹)
    (fun i => (cutoffK hC hν n p (s i))⁻¹)
  have hA n : ReciprocalKernel.OnePositiveSquare (A n) := by
    exact boundary_reciprocal_compact_support (cutoff_ae_norm (ν := ν) n)
      (cutoffRadius_lt_one n) hC (restrictDensity hν (cutoffSet n))
      (cutoffSet n) (cutoffSet_compact n) (cutoffSet_subset n)
      (by rw [Measure.restrict_apply (cutoffSet_measurable n).compl]; simp)
      hd0 hd1 (subcritical_restrict hC hν (cutoffSet n) hsub) p s
  apply ReciprocalKernel.onePositiveSquare_of_entrywise_tendsto hA
  intro i j
  rcases i with i | i <;> rcases j with j | j
  · by_cases he : s i = s j
    · simp [A, ReciprocalKernel.bordered, he]
    · simpa only [A, ReciprocalKernel.bordered, Matrix.of_apply, Matrix.fromBlocks_apply₁₁, he, ite_false] using
        (cutoffN_tendsto hC hν hn (s i) (s j) he).inv₀
          (fullBoundaryN_pos hC hν hn (s i) (s j) he).ne'
  · simpa only [A, ReciprocalKernel.bordered, Matrix.of_apply, Matrix.fromBlocks_apply₁₂] using
      (cutoffK_tendsto hC hν hn p (s i)).inv₀ (fullBoundaryK_pos hC hν hn p (s i)).ne'
  · simpa only [A, ReciprocalKernel.bordered, Matrix.of_apply, Matrix.fromBlocks_apply₂₁] using
      (cutoffK_tendsto hC hν hn p (s j)).inv₀ (fullBoundaryK_pos hC hν hn p (s j)).ne'
  · simp [A, ReciprocalKernel.bordered]


def fullDistanceKernel (p : disk) (s t : Boundary) : ℝ :=
  if s = t then 0 else fullBoundaryK hC hν p s * fullBoundaryK hC hν p t /
    fullBoundaryN hC hν s t



theorem negative_kernel {d : ℝ} (hd0 : 0 ≤ d) (hd1 : d < 1)
    (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2) (p : disk)
    {ι : Type} [Fintype ι] (s : ι → Boundary) :
    ReciprocalKernel.ConditionallyNegative (Matrix.of fun i j =>
      fullDistanceKernel hC hν p (s i) (s j)) := by
  classical
  have hn : ‖weightedIntegralOperator hC hν‖ < 1 :=
    (weightedIntegralOperator_norm_le hC hν hd0 hsub).trans_lt hd1
  have h := ReciprocalKernel.conditionalNegative_scaled_of_bordered
    (fun i => fullBoundaryK hC hν p (s i))
    (fun i => (fullBoundaryK_pos hC hν hn p (s i)).ne')
    (boundary_reciprocal hC hν hd0 hd1 hsub p s)
  convert h using 1
  ext i j
  by_cases he : s i = s j
  · simp [fullDistanceKernel, he]
  · simp only [fullDistanceKernel, he, ite_false, Matrix.of_apply, div_eq_mul_inv]
    ring

end StrictHotSpots.PlaneGreen
end
end FullBoundaryReciprocalLayer



end FullBoundaryCombinedLayer

end

end DouglasLipschitzBase

section DouglasLipschitzBase
noncomputable section
section FullBoundaryCombinedLayer
section FullBoundaryEmbeddingLayer
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology InnerProductSpace
namespace StrictHotSpots.PlaneGreen
open DiskH10
variable {ν : Measure Plane} [IsFiniteMeasure ν] {C : ℝ≥0∞}
  (hC : C ≠ ∞) (hν : ν ≤ C • volume.restrict disk)

lemma fullBoundaryK_bounded (p : disk) : ∃ B : ℝ, 0 ≤ B ∧ ∀ s : Boundary,
    fullBoundaryK hC hν p s ≤ B := by
  obtain ⟨B,hB,h⟩ := green_poisson_uniform_bound hC hν
  let M : ℝ := (measureUnivNNReal ν : ℝ) ^ (2 : ℝ≥0∞).toReal⁻¹ * B
  have hM : 0 ≤ M := mul_nonneg (Real.rpow_nonneg (by positivity) _) hB
  have hs (s : Boundary) : ‖smoothedRow hC hν s‖ ≤ M := by
    apply Lp.norm_le_of_ae_bound hB
    filter_upwards [(smoothedPoisson_memLp hC hν s).coeFn_toLp, ae_mem_disk hν] with x hx hxd
    rw [show smoothedRow hC hν s x = smoothedPoisson (ν := ν) s x from hx]
    exact h x hxd s
  let A : ℝ := 1 / (2 * Real.pi * (1 - ‖(p : Plane)‖) ^ 2)
  refine ⟨A + B + ‖row hC hν p‖ * ‖BanachResolvent.resolvent (weightedIntegralOperator hC hν)‖ * M,
    by dsimp [A]; positivity, fun s => ?_⟩
  unfold fullBoundaryK
  apply add_le_add
  · apply add_le_add
    · exact DiskFormula.poisson_bounded _ _ (by simpa using s.property)
        (by simp) (by simpa [disk] using p.property)
    · exact (le_abs_self _).trans (h p p.property s)
  · calc
      _ ≤ ‖row hC hν p‖ * ‖BanachResolvent.resolvent (weightedIntegralOperator hC hν)
          (smoothedRow hC hν s)‖ := real_inner_le_norm _ _
      _ ≤ ‖row hC hν p‖ * (‖BanachResolvent.resolvent (weightedIntegralOperator hC hν)‖ * M) := by
        gcongr
        exact (ContinuousLinearMap.le_opNorm _ _).trans (mul_le_mul_of_nonneg_left (hs s) (norm_nonneg _))
      _ = _ := (mul_assoc _ _ _).symm

lemma boundaryInteraction_eq_dist (s t : Boundary) :
    boundaryInteraction s t = 1 / (Real.pi * dist s t ^ 2) := by
  simp only [boundaryInteraction, DiskFormula.boundaryInteraction, ← map_sub,
    LinearIsometryEquiv.norm_map, Subtype.dist_eq, dist_eq_norm]

lemma boundaryInteraction_le_fullBoundaryN (hT : ‖weightedIntegralOperator hC hν‖ < 1)
    (s t : Boundary) : boundaryInteraction s t ≤ fullBoundaryN hC hν s t := by
  have h1 : 0 ≤ ∫ x, poisson s x * poisson t x ∂ν := by
    apply integral_nonneg_of_ae
    filter_upwards [ae_mem_disk hν] with x hx
    exact mul_nonneg (poisson_nonneg s ⟨x,hx⟩) (poisson_nonneg t ⟨x,hx⟩)
  have h2 : 0 ≤ ∫ x, poisson s x * smoothedPoisson (ν := ν) t x ∂ν := by
    apply integral_nonneg_of_ae
    filter_upwards [ae_mem_disk hν] with x hx
    exact mul_nonneg (poisson_nonneg s ⟨x,hx⟩) (smoothedPoisson_nonneg hν t hx)
  have h3 := L2Limits.inner_nonneg (smoothedRow_nonneg hC hν s)
    (BanachResolvent.resolvent_nonneg _ hT (weightedIntegralOperator_order_nonneg hC hν)
      (smoothedRow_nonneg hC hν t))
  unfold fullBoundaryN
  linarith

lemma fullDistanceKernel_pos (hT : ‖weightedIntegralOperator hC hν‖ < 1)
    (p : disk) (s t : Boundary) (hst : s ≠ t) : 0 < fullDistanceKernel hC hν p s t := by
  rw [fullDistanceKernel, ite_eq_right hst]
  exact div_pos (mul_pos (fullBoundaryK_pos hC hν hT p s) (fullBoundaryK_pos hC hν hT p t))
    (fullBoundaryN_pos hC hν hT s t hst)

lemma fullDistanceKernel_bound (hT : ‖weightedIntegralOperator hC hν‖ < 1)
    (p : disk) : ∃ L : ℝ≥0, ∀ s t, fullDistanceKernel hC hν p s t ≤ (L : ℝ)^2 * dist s t ^ 2 := by
  obtain ⟨B,hB,hK⟩ := fullBoundaryK_bounded hC hν p
  let L : ℝ≥0 := ⟨Real.sqrt Real.pi * B, mul_nonneg (Real.sqrt_nonneg _) hB⟩
  refine ⟨L, fun s t => ?_⟩
  by_cases hst : s = t
  · subst t; simp [fullDistanceKernel]
  have hd : 0 < dist s t := dist_pos.mpr hst
  have hn := boundaryInteraction_le_fullBoundaryN hC hν hT s t
  rw [boundaryInteraction_eq_dist] at hn
  have hp := fullBoundaryN_pos hC hν hT s t hst
  have hkk : fullBoundaryK hC hν p s * fullBoundaryK hC hν p t ≤ B^2 := by
    exact (mul_le_mul (hK s) (hK t) (fullBoundaryK_pos hC hν hT p t).le hB).trans_eq (pow_two B).symm
  rw [fullDistanceKernel, ite_eq_right hst]
  calc
    _ ≤ B^2 / fullBoundaryN hC hν s t := div_le_div_of_nonneg_right hkk hp.le
    _ ≤ B^2 / (1 / (Real.pi * dist s t ^ 2)) :=
      div_le_div_of_nonneg_left (sq_nonneg _) (by positivity) hn
    _ = (L : ℝ)^2 * dist s t ^ 2 := by
      change B^2 / (1 / (Real.pi * dist s t ^ 2)) =
        (Real.sqrt Real.pi * B)^2 * dist s t ^ 2
      rw [mul_pow, Real.sq_sqrt Real.pi_pos.le]
      field_simp

lemma fullDistanceKernel_conditionallyNegative {d : ℝ} (hd0 : 0 ≤ d) (hd1 : d < 1)
    (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2) (p : disk) :
    SquaredDistanceKernel.ConditionallyNegative (Matrix.of (fullDistanceKernel hC hν p)) := by
  classical
  refine ⟨?_, fun s => by simp [fullDistanceKernel], ?_⟩
  · ext s t
    have hh := (negative_kernel hC hν hd0 hd1 hsub p (fun b : Bool => if b then s else t)).1.apply false true
    simpa [Matrix.conjTranspose_apply] using hh.symm
  · intro c hc
    let a : c.support → ℝ := fun i => c i
    have ha : (∑ i, a i) = 0 := by
      change (∑ i : c.support, c i) = 0
      rw [Finset.sum_coe_sort c.support (fun x : Boundary => c x)]
      exact hc
    have hh := (negative_kernel hC hν hd0 hd1 hsub p (fun i : c.support => (i : Boundary))).2 a ha
    simp only [ReciprocalKernel.pairing, dotProduct, Matrix.mulVec, Matrix.of_apply,
      Finset.mul_sum, ← mul_assoc, a] at hh
    have he : (∑ i : c.support, ∑ j : c.support,
        c i * fullDistanceKernel hC hν p i j * c j) =
        c.sum (fun x a => c.sum (fun y b => a * fullDistanceKernel hC hν p x y * b)) := by
      calc
        _ = ∑ i : c.support, ∑ j ∈ c.support, c i * fullDistanceKernel hC hν p i j * c j := by
          apply Finset.sum_congr rfl
          intro i _
          exact Finset.sum_coe_sort c.support (fun j => c i * fullDistanceKernel hC hν p i j * c j)
        _ = _ := Finset.sum_coe_sort c.support (fun i =>
          ∑ j ∈ c.support, c i * fullDistanceKernel hC hν p i j * c j)
    rw [he] at hh
    exact hh



theorem full_boundary_hilbert_embedding {d : ℝ} (hd0 : 0 ≤ d) (hd1 : d < 1)
    (hsub : ∀ u : H10 diskOpen, ‖H10.weightedValue diskOpen hC hν u‖ ^ 2 ≤
      d * ‖H10.grad diskOpen u‖ ^ 2) (p : disk) :
    ∃ (H : Type) (_ : NormedAddCommGroup H) (_ : InnerProductSpace ℝ H)
      (_ : CompleteSpace H) (_ : TopologicalSpace.SeparableSpace H) (b : Boundary → H) (L : ℝ≥0),
      Function.Injective b ∧ LipschitzWith L b ∧
        ∀ s t, ‖b s - b t‖ ^ 2 = fullDistanceKernel hC hν p s t := by
  have hT : ‖weightedIntegralOperator hC hν‖ < 1 :=
    (weightedIntegralOperator_norm_le hC hν hd0 hsub).trans_lt hd1
  obtain ⟨L,hL⟩ := fullDistanceKernel_bound hC hν hT p
  let o : Boundary := ⟨complexIso 1, by simp⟩
  obtain ⟨H,hn,hi,hc,hs,b,hb,hl,hd⟩ := SquaredDistanceKernel.separable_lipschitz_embedding
    (fullDistanceKernel_conditionallyNegative hC hν hd0 hd1 hsub p) o
    (fullDistanceKernel_pos hC hν hT p) hL
  exact ⟨H,hn,hi,hc,hs,b,L,hb,hl,hd⟩

end StrictHotSpots.PlaneGreen
end
end FullBoundaryEmbeddingLayer
end FullBoundaryCombinedLayer


end

end DouglasLipschitzBase

end OAI