lean/OAI/Analysis/HotSpots/Potentials.lean

import OAI.Analysis.HotSpots.Trace

namespace OAI

section ActualVectorSupport

noncomputable section

section HarmonicRadialRegularityBaseLayer
open Set MeasureTheory Metric Complex Function Filter Real
open scoped Topology ContDiff Laplacian
namespace StrictHotSpots.Weyl

def radialBump (R : ℝ) (z : ℂ) : ℝ := expNegInvGlue (R^2-‖z‖^2)

lemma radialBump_contDiff (R : ℝ) : ContDiff ℝ ∞ (radialBump R) :=
  expNegInvGlue.contDiff.comp (contDiff_const.sub (contDiff_norm_sq ℝ))

lemma radialBump_zero {R : ℝ} (hR : 0 ≤ R) {z : ℂ} (hz : R ≤ ‖z‖) :
    radialBump R z = 0 := by
  apply expNegInvGlue.zero_of_nonpos
  nlinarith [norm_nonneg z]

lemma radialBump_support {R : ℝ} (hR : 0 ≤ R) :
    tsupport (radialBump R) ⊆ closedBall (0:ℂ) R := by
  apply closure_minimal _ isClosed_closedBall
  intro z hz
  rw [mem_closedBall,dist_zero_right]
  by_contra h
  exact hz (radialBump_zero hR (le_of_not_ge h))

lemma radialBump_compact {R : ℝ} (hR : 0 ≤ R) : HasCompactSupport (radialBump R) :=
  (isCompact_closedBall (0:ℂ) R).of_isClosed_subset (isClosed_tsupport _) (radialBump_support hR)

lemma radialBump_integral_pos {R : ℝ} (hR : 0 < R) : 0 < ∫ z, radialBump R z := by
  apply (integral_pos_iff_support_of_nonneg (fun z => expNegInvGlue.nonneg _)
    ((radialBump_contDiff R).continuous.integrable_of_hasCompactSupport (radialBump_compact hR.le))).mpr
  have hb : ball (0:ℂ) R ⊆ support (radialBump R) := by
    intro z hz
    apply ne_of_gt
    apply expNegInvGlue.pos_of_pos
    have hn : ‖z‖ < R := by simpa only [mem_ball,dist_zero_right] using hz
    nlinarith [norm_nonneg z]
  exact (measure_ball_pos volume (0:ℂ) hR).trans_le (measure_mono hb)

lemma radialBump_polar (R r θ : ℝ) : radialBump R (Complex.polarCoord.symm (r,θ)) =
    expNegInvGlue (R^2-r^2) := by simp only [radialBump,Complex.norm_polarCoord_symm,sq_abs]

lemma polar_continuous : Continuous (Complex.polarCoord.symm : ℝ × ℝ → ℂ) := by
  have he : (Complex.polarCoord.symm : ℝ × ℝ → ℂ) =
      fun p => (p.1:ℂ) * (Real.cos p.2 + Real.sin p.2 * Complex.I) :=
    funext Complex.polarCoord_symm_apply
  rw [he]
  fun_prop

lemma polar_circle (x : ℂ) (r θ : ℝ) : x-Complex.polarCoord.symm (r,θ) = circleMap x (-r) θ := by
  rw [circleMap,Complex.polarCoord_symm_apply,Complex.exp_mul_I]
  push_cast
  ring

lemma angle_integral {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
    (f : ℂ → F) (x : ℂ) (r : ℝ) :
    (∫ θ in Ioo (-Real.pi) Real.pi, f (circleMap x r θ)) = (2*Real.pi) • circleAverage f x r := by
  have hp : Periodic (fun θ => f (circleMap x r θ)) (2*Real.pi) :=
    fun θ => congrArg f (periodic_circleMap x r θ)
  have he := hp.intervalIntegral_add_eq 0 (-Real.pi)
  rw [zero_add] at he
  have he' : (∫ θ in -Real.pi..Real.pi, f (circleMap x r θ)) =
      ∫ θ in 0..2*Real.pi, f (circleMap x r θ) := by
    convert he.symm using 1
    ring_nf
  rw [← integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by linarith [Real.pi_pos]),he',circleAverage_def]
  rw [smul_smul,mul_inv_cancel₀ (mul_ne_zero two_ne_zero Real.pi_ne_zero),one_smul]

lemma polar_bump_integrable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
    {R : ℝ} (hR : 0 < R) {f : ℂ → F} (hf : Continuous f) (x : ℂ) :
    IntegrableOn (fun p : ℝ × ℝ => p.1 • (radialBump R (Complex.polarCoord.symm p) •
      f (x-Complex.polarCoord.symm p))) (Ioi 0 ×ˢ Ioo (-Real.pi) Real.pi) := by
  apply IntegrableOn.of_inter_support (measurableSet_Ioi.prod measurableSet_Ioo)
  have hc : Continuous (fun p : ℝ × ℝ => p.1 • (radialBump R (Complex.polarCoord.symm p) •
      f (x-Complex.polarCoord.symm p))) :=
    continuous_fst.smul (((radialBump_contDiff R).continuous.comp polar_continuous).smul
      (hf.comp (continuous_const.sub polar_continuous)))
  apply (hc.continuousOn.integrableOn_compact (isCompact_Icc.prod isCompact_Icc)).mono_set
  intro p hp
  refine ⟨⟨hp.1.1.le,?_⟩,⟨hp.1.2.1.le,hp.1.2.2.le⟩⟩
  by_contra hh
  have hz : radialBump R (Complex.polarCoord.symm p) = 0 := by
    apply radialBump_zero hR.le
    rw [Complex.norm_polarCoord_symm,abs_of_pos hp.1.1]
    exact (lt_of_not_ge hh).le
  exact hp.2 (by simp only [hz,zero_smul,smul_zero])


theorem radial_average {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]
    {R : ℝ} (hR : 0 < R) {f : ℂ → F} (hf : Continuous f) (x : ℂ)
    (hh : InnerProductSpace.HarmonicOnNhd f (ball x R)) :
    (∫ z, radialBump R z • f (x-z)) = (∫ z, radialBump R z) • f x := by
  rw [← integral_smul_const]
  rw [← Complex.integral_comp_polarCoord_symm, ← Complex.integral_comp_polarCoord_symm]
  change (∫ p in Ioi 0 ×ˢ Ioo (-Real.pi) Real.pi,
    p.1 • (radialBump R (Complex.polarCoord.symm p) • f (x-Complex.polarCoord.symm p))) =
    ∫ p in Ioi 0 ×ˢ Ioo (-Real.pi) Real.pi,
    p.1 • (radialBump R (Complex.polarCoord.symm p) • f x)
  rw [Measure.volume_eq_prod]
  rw [setIntegral_prod _ (by simpa only [Measure.volume_eq_prod] using polar_bump_integrable hR hf x),
    setIntegral_prod _ (by simpa only [Measure.volume_eq_prod] using polar_bump_integrable hR (f := fun _ => f x) continuous_const (0:ℂ))]
  apply setIntegral_congr_fun measurableSet_Ioi
  intro r hr
  simp_rw [radialBump_polar,polar_circle,integral_smul]
  by_cases hrR : r < R
  · have hh' : InnerProductSpace.HarmonicOnNhd f (closedBall x |(-r)|) := by
      rw [abs_neg,abs_of_pos hr]
      exact hh.mono (closedBall_subset_ball hrR)
    rw [angle_integral,hh'.circleAverage_eq]
    simp only [integral_const]
    rw [Measure.real,Measure.restrict_apply_univ,volume_Ioo,ENNReal.toReal_ofReal (by linarith [Real.pi_pos] : 0 ≤ Real.pi- -Real.pi)]
    congr 2
    ring_nf
  · have hzero : expNegInvGlue (R^2-r^2) = 0 := by
      apply expNegInvGlue.zero_of_nonpos
      have hr' : R ≤ r := le_of_not_gt hrR
      nlinarith
    simp only [hzero,zero_smul,smul_zero]

end StrictHotSpots.Weyl
end HarmonicRadialRegularityBaseLayer

section ConvolutionShuffleRegularityBaseLayer
open Set MeasureTheory Metric Complex Function Filter ContinuousLinearMap
open scoped Topology ContDiff Laplacian Convolution
namespace StrictHotSpots.Weyl
open Helmholtz

lemma convolution_assoc_scalar {u : ℂ → ℂ} {g k : ℂ → ℝ}
    (hu : LocallyIntegrable u volume) (hg : Continuous g) (hcg : HasCompactSupport g)
    (hk : Continuous k) (hck : HasCompactSupport k) :
    (u ⋆[smulFlip] g) ⋆[smulFlip] k = u ⋆[smulFlip] (g ⋆[mul ℝ ℝ] k) := by
  funext x
  apply convolution_assoc smulFlip smulFlip smulFlip (mul ℝ ℝ)
    (fun z a b => by simp only [smulFlip,ContinuousLinearMap.flip_apply,
      ContinuousLinearMap.lsmul_apply,ContinuousLinearMap.mul_apply',smul_smul]; rw [mul_comm])
    hu.aestronglyMeasurable hg.aestronglyMeasurable hk.aestronglyMeasurable
  · exact Eventually.of_forall (hcg.convolutionExists_right _ hu hg)
  · exact Eventually.of_forall (hck.norm.convolutionExists_right _ hg.norm.locallyIntegrable hk.norm)
  · exact (hcg.norm.convolution (mul ℝ ℝ) hck.norm).convolutionExists_right _ (fun x => (hu x).norm)
      (hck.norm.continuous_convolution_right _ hg.norm.locallyIntegrable hk.norm) x

lemma convolution_shuffle {u : ℂ → ℂ} {g k : ℂ → ℝ}
    (hu : LocallyIntegrable u volume) (hg : Continuous g) (hcg : HasCompactSupport g)
    (hk : Continuous k) (hck : HasCompactSupport k) :
    (u ⋆[smulFlip] g) ⋆[smulFlip] k = (u ⋆[smulFlip] k) ⋆[smulFlip] g := by
  rw [convolution_assoc_scalar hu hg hcg hk hck,convolution_assoc_scalar hu hk hck hg hcg]
  have hh : (mul ℝ ℝ).flip = mul ℝ ℝ := by
    apply ContinuousLinearMap.ext
    intro x
    apply ContinuousLinearMap.ext
    intro y
    simp only [ContinuousLinearMap.flip_apply,ContinuousLinearMap.mul_apply']
    exact mul_comm y x
  rw [← convolution_flip (L := mul ℝ ℝ),hh]

end StrictHotSpots.Weyl
end ConvolutionShuffleRegularityBaseLayer

section WeakWeylRegularityBaseLayer
open Set MeasureTheory Metric Complex Function Filter ContinuousLinearMap
open scoped Topology ContDiff Laplacian Convolution
namespace StrictHotSpots.Weyl
open Helmholtz



theorem local_representative {u : ℂ → ℂ} {a : ℂ} {R : ℝ}
    (hu : LocallyIntegrable u volume) (hR : 0 < R) (hpde : WeakEquation (ball a R) 0 u) :
    ∃ f : ℂ → ℂ, ContDiff ℝ ∞ f ∧
      ∀ᵐ x ∂volume, x ∈ ball a (R/4) → f x = u x := by
  let φ := radialBump (R/4)
  let c : ℝ := ∫ z, φ z
  have hc : 0 < c := radialBump_integral_pos (by positivity)
  have hφ : ContDiff ℝ ∞ φ := radialBump_contDiff _
  have hcφ : HasCompactSupport φ := radialBump_compact (by positivity)
  let v := u ⋆[smulFlip] φ
  have hv : ContDiff ℝ ∞ v := hcφ.contDiff_convolution_right _ hu hφ
  refine ⟨fun x => c⁻¹ • v x,?_,?_⟩
  · simpa only [Pi.smul_apply] using! (contDiff_const (c := c⁻¹)).smul hv
  filter_upwards [smoothen_tendsto hu,smoothen_tendsto hv.continuous.locallyIntegrable] with x hx hxv
  intro hxa
  have he : ∀ᶠ n in atTop, smoothen v n x = c • smoothen u n x := by
    filter_upwards [(tendsto_order.1 mollifier_radius_tendsto).2 (R/2) (by positivity)] with n hn
    have hh : InnerProductSpace.HarmonicOnNhd (smoothen u n) (ball x (R/4)) := by
      intro y hy
      have hym : y ∈ ball a (R-(mollifier n).rOut) := by
        rw [mem_ball] at hy hxa ⊢
        have ht := dist_triangle y x a
        linarith
      refine ⟨((smoothen_contDiff hu n).of_le (show (2:ℕ∞ω) ≤ ∞ by decide)).contDiffAt,?_⟩
      filter_upwards [isOpen_ball.mem_nhds hym] with z hz
      simpa only [neg_zero,zero_smul,Pi.zero_apply] using smoothen_PDE hu hpde n hz
    calc
      smoothen v n x = (smoothen u n ⋆[smulFlip] φ) x :=
        (congrFun (convolution_shuffle hu (mollifier n).continuous_normed
          (mollifier n).hasCompactSupport_normed hφ.continuous hcφ) x).symm
      _ = c • smoothen u n x := by
        rw [← convolution_flip]
        exact radial_average (by positivity) (smoothen_contDiff hu n).continuous x hh
  have ht : Tendsto (fun n => smoothen v n x) atTop (𝓝 (c • u x)) :=
    (hx.const_smul c).congr' (he.mono (fun _ h => h.symm))
  have hvx : v x = c • u x := tendsto_nhds_unique hxv ht
  rw [hvx,smul_smul,inv_mul_cancel₀ hc.ne',one_smul]



theorem representative {u : ℂ → ℂ} {Ω : Set ℂ} (ho : IsOpen Ω)
    (hu : LocallyIntegrable u volume) (hpde : WeakEquation Ω 0 u) :
    ∃ f : ℂ → ℂ, ContDiffOn ℝ ∞ f Ω ∧ ∀ᵐ x ∂volume, x ∈ Ω → f x = u x := by
  classical
  have hball (x : Ω) : ∃ R : ℝ, 0 < R ∧ ball (x:ℂ) R ⊆ Ω :=
    Metric.isOpen_iff.mp ho x x.property
  choose R hR hRΩ using hball
  choose f hf hfu using fun x : Ω => local_representative hu (hR x) (hpde.mono (hRΩ x))
  have hsmall (x : Ω) : ball (x:ℂ) (R x/4) ⊆ Ω :=
    (ball_subset_ball (by linarith [hR x])).trans (hRΩ x)
  have heq (x y : Ω) : EqOn (f x) (f y) (ball (x:ℂ) (R x/4) ∩ ball (y:ℂ) (R y/4)) := by
    apply MeasureTheory.Measure.eqOn_open_of_ae_eq (μ := volume) _ (isOpen_ball.inter isOpen_ball)
      (hf x).continuous.continuousOn (hf y).continuous.continuousOn
    apply (ae_restrict_iff' (measurableSet_ball.inter measurableSet_ball)).mpr
    filter_upwards [hfu x,hfu y] with z hx hy
    intro hz
    exact (hx hz.1).trans (hy hz.2).symm
  let g : ℂ → ℂ := fun x => if hx : x ∈ Ω then f ⟨x,hx⟩ x else 0
  have hgf (x : Ω) {z : ℂ} (hz : z ∈ ball (x:ℂ) (R x/4)) : g z = f x z := by
    have hzΩ := hsmall x hz
    dsimp only [g]
    rw [dite_eq_left hzΩ]
    exact heq ⟨z,hzΩ⟩ x ⟨mem_ball_self (by linarith [hR ⟨z,hzΩ⟩]),hz⟩
  refine ⟨g,?_,?_⟩
  · intro x hx
    let x' : Ω := ⟨x,hx⟩
    have he : g =ᶠ[𝓝 x] f x' := by
      filter_upwards [ball_mem_nhds x (by linarith [hR x'] : 0 < R x'/4)] with z hz
      exact hgf x' hz
    exact ((hf x').contDiffAt.congr_of_eventuallyEq he).contDiffWithinAt
  · obtain ⟨T,hT,hcover⟩ := (IsLindelof.of_coe (s := Ω)).elim_nhds_subcover'
      (fun x hx => ball x (R ⟨x,hx⟩/4)) (fun x hx => ball_mem_nhds x (by linarith [hR ⟨x,hx⟩]))
    have ha : ∀ᵐ z ∂volume, ∀ x ∈ T, z ∈ ball (x:ℂ) (R x/4) → f x z = u z :=
      (eventually_countable_ball hT).mpr (fun x _ => hfu x)
    filter_upwards [ha] with z hz
    intro hzΩ
    obtain ⟨x,hx,hzB⟩ := mem_iUnion₂.mp (hcover hzΩ)
    exact (hgf x hzB).trans (hz x hx hzB)

end StrictHotSpots.Weyl
end WeakWeylRegularityBaseLayer




section PlaneDifferentialInteriorSupportLayer

open Set MeasureTheory InnerProductSpace
open scoped ContDiff Laplacian
namespace StrictHotSpots.Hodge
abbrev e (i : Fin 2) : Plane := planeBasis i
abbrev c (i : Fin 2) (x : Plane) : ℝ := inner ℝ x (e i)

lemma expand (x : Plane) : c 0 x • e 0 + c 1 x • e 1 = x := by
  simpa only [Fin.sum_univ_two, OrthonormalBasis.repr_apply_apply, real_inner_comm] using planeBasis.sum_repr x
lemma basis_inner (i j : Fin 2) : inner ℝ (e i) (e j) = if i=j then 1 else 0 :=
  planeBasis.inner_eq_ite i j
lemma inner_two (x y : Plane) : inner ℝ x y = c 0 x*c 0 y+c 1 x*c 1 y := by
  simpa only [Fin.sum_univ_two,real_inner_comm (e 0) y,real_inner_comm (e 1) y] using
    (planeBasis.sum_inner_mul_inner x y).symm

def rot : Plane →L[ℝ] Plane :=
  (innerSL ℝ (e 0)).smulRight (e 1) - (innerSL ℝ (e 1)).smulRight (e 0)
lemma rot_apply (x : Plane) : rot x = c 0 x • e 1-c 1 x • e 0 := by
  simp only [rot,sub_apply,ContinuousLinearMap.smulRight_apply,
    innerSL_apply_apply,real_inner_comm]
lemma c_rot (x : Plane) : c 0 (rot x) = -c 1 x ∧ c 1 (rot x) = c 0 x := by
  rw [rot_apply]
  simp only [c,inner_sub_left,inner_smul_left,conj_trivial,basis_inner]
  norm_num
lemma rot_rot (x : Plane) : rot (rot x) = -x := by
  rw [rot_apply,(c_rot x).1,(c_rot x).2]
  calc
    _ = -(c 0 x • e 0+c 1 x • e 1) := by module
    _ = -x := by rw [expand]
lemma rot_inner (x y : Plane) : inner ℝ (rot x) (rot y) = inner ℝ x y := by
  rw [inner_two,inner_two,(c_rot x).1,(c_rot x).2,(c_rot y).1,(c_rot y).2]
  ring
lemma rot_skew (x y : Plane) : inner ℝ (rot x) y = -inner ℝ x (rot y) := by
  rw [inner_two,inner_two,(c_rot x).1,(c_rot x).2,(c_rot y).1,(c_rot y).2]
  ring
lemma rot_norm (x : Plane) : ‖rot x‖ = ‖x‖ := by
  have hh := rot_inner x x
  simp only [real_inner_self_eq_norm_sq] at hh
  nlinarith [norm_nonneg (rot x),norm_nonneg x]

abbrev D (i : Fin 2) (φ : Plane → ℝ) := directionalDerivative φ (e i)
lemma D_smooth {φ : Plane → ℝ} (hφ : ContDiff ℝ ∞ φ) (i : Fin 2) : ContDiff ℝ ∞ (D i φ) :=
  (hφ.fderiv_right (by simp)).clm_apply contDiff_const
lemma D_compact {φ : Plane → ℝ} (hc : HasCompactSupport φ) (i : Fin 2) : HasCompactSupport (D i φ) :=
  hc.fderiv_apply ℝ (e i)
lemma D_support (φ : Plane → ℝ) (i : Fin 2) : tsupport (D i φ) ⊆ tsupport φ :=
  tsupport_fderiv_apply_subset ℝ (e i)
lemma gradient_c (φ : Plane → ℝ) (i : Fin 2) (x : Plane) : c i (gradient φ x) = D i φ x :=
  inner_gradient_left
lemma D_D {φ : Plane → ℝ} (hφ : ContDiff ℝ ∞ φ) (i j : Fin 2) (x : Plane) :
    D i (D j φ) x = D j (D i φ) x := by
  have hd : DifferentiableAt ℝ (fderiv ℝ φ) x :=
    (hφ.fderiv_right (by simp) : ContDiff ℝ ∞ (fderiv ℝ φ)).differentiable (by simp) x
  change fderiv ℝ (fun y => fderiv ℝ φ y (e j)) x (e i) =
    fderiv ℝ (fun y => fderiv ℝ φ y (e i)) x (e j)
  rw [fderiv_clm_apply hd (differentiableAt_const _),fderiv_clm_apply hd (differentiableAt_const _)]
  simp only [fderiv_fun_const,Pi.zero_apply,ContinuousLinearMap.comp_zero,zero_add,ContinuousLinearMap.flip_apply]
  exact (hφ.contDiffAt.isSymmSndFDerivAt (by
    simp only [minSmoothness_of_isRCLikeNormedField]
    exact WithTop.coe_le_coe.mpr (show (2 : ℕ∞) ≤ ⊤ from le_top))) _ _

lemma laplace_two {φ : Plane → ℝ} (hφ : ContDiff ℝ ∞ φ) (x : Plane) :
    Δ φ x = D 0 (D 0 φ) x + D 1 (D 1 φ) x := by
  simpa only [Fin.sum_univ_two] using
    laplacian_eq_sum_directional isOpen_univ hφ.contDiffOn (mem_univ x)

lemma inner_gradient (Z : Plane) (φ : Plane → ℝ) (x : Plane) :
    inner ℝ Z (gradient φ x) = c 0 Z*D 0 φ x+c 1 Z*D 1 φ x := by
  rw [inner_two,gradient_c,gradient_c]
lemma inner_rot_gradient (Z : Plane) (φ : Plane → ℝ) (x : Plane) :
    inner ℝ Z (rot (gradient φ x)) = c 1 Z*D 0 φ x-c 0 Z*D 1 φ x := by
  rw [inner_two,(c_rot _).1,(c_rot _).2,gradient_c,gradient_c]
  ring
end StrictHotSpots.Hodge


end PlaneDifferentialInteriorSupportLayer


section PlaneWeakWeylInteriorSupportLayer


open Set MeasureTheory Filter Metric
open scoped ContDiff Laplacian Topology
namespace StrictHotSpots.Weyl

private def coord : ℂ ≃ₗᵢ[ℝ] Plane := Complex.orthonormalBasisOneI.repr

private def complexExtension (Ω : Set Plane) (u : Plane → ℝ) (z : ℂ) : ℂ :=
  Complex.ofReal (Ω.indicator u (coord z))

private lemma complexExtension_integral (Ω : Set Plane) (hΩ : MeasurableSet Ω)
    (u : Plane → ℝ) (ψ : ℂ → ℝ) :
    (∫ z, ψ z • complexExtension Ω u z) =
      Complex.ofReal (∫ x in Ω, u x * ψ (coord.symm x)) := by
  have he : (fun z => ψ z • complexExtension Ω u z) =
      (fun z => ((Ω.indicator (fun x => u x * ψ (coord.symm x))) (coord z) : ℂ)) := by
    funext z
    by_cases hz : coord z ∈ Ω
    · simp [complexExtension,indicator_of_mem hz,Complex.real_smul,mul_comm]
    · simp [complexExtension,indicator_of_notMem hz]
  rw [he,integral_complex_ofReal,
    coord.measurePreserving.integral_comp coord.toHomeomorph.measurableEmbedding,
    integral_indicator hΩ]

private lemma complexExtension_integrable {Ω : Set Plane} {u : Plane → ℝ}
    (hΩ : MeasurableSet Ω) (hu : IntegrableOn u Ω) :
    Integrable (complexExtension Ω u) volume := by
  have hi := (integrable_indicator_iff hΩ).mpr hu
  have hj := coord.measurePreserving.integrable_comp_of_integrable hi
  exact Complex.ofRealCLM.integrable_comp hj

private lemma complexExtension_weak {Ω : Set Plane} {μ : ℝ} {u : Plane → ℝ}
    (hΩ : MeasurableSet Ω) (hp : PlaneWeakEquation Ω μ u) :
    Helmholtz.WeakEquation (coord ⁻¹' Ω) μ (complexExtension Ω u) := by
  intro φ hφ hc hs
  have ht : ContDiff ℝ ∞ (φ ∘ coord.symm) :=
    hφ.comp coord.symm.toContinuousLinearEquiv.contDiff
  have htc : HasCompactSupport (φ ∘ coord.symm) := hc.comp_homeomorph coord.symm.toHomeomorph
  have hts : tsupport (φ ∘ coord.symm) ⊆ Ω := by
    change tsupport (φ ∘ coord.symm.toHomeomorph) ⊆ Ω
    rw [tsupport_comp_eq_preimage φ coord.symm.toHomeomorph]
    intro x hx
    have h : coord (coord.symm x) ∈ Ω := hs hx
    simpa only [coord.apply_symm_apply] using h
  have h := hp _ ht htc hts
  simp only [laplacian_comp_linearIsometryEquiv,Function.comp_apply] at h
  rw [complexExtension_integral Ω hΩ u (Δ φ),complexExtension_integral Ω hΩ u φ,h]
  simp



theorem plane_representative {Ω : Set Plane} {u : Plane → ℝ}
    (ho : IsOpen Ω) (hu : IntegrableOn u Ω) (hp : PlaneWeakEquation Ω 0 u) :
    ∃ f : Plane → ℝ, ContDiffOn ℝ ∞ f Ω ∧ ∀ᵐ x ∂volume.restrict Ω, f x = u x := by
  obtain ⟨f,hf,hfu⟩ := representative (ho.preimage coord.continuous)
    (complexExtension_integrable ho.measurableSet hu).locallyIntegrable
    (complexExtension_weak ho.measurableSet hp)
  refine ⟨fun x => (f (coord.symm x)).re,?_,?_⟩
  · exact Complex.reCLM.contDiff.comp_contDiffOn (hf.comp
      coord.symm.toContinuousLinearEquiv.contDiff.contDiffOn
      (fun x hx => by simpa only [mem_preimage,coord.apply_symm_apply] using hx))
  · apply (ae_restrict_iff' ho.measurableSet).mpr
    filter_upwards [coord.symm.measurePreserving.quasiMeasurePreserving.ae hfu] with x hx
    intro hxm
    have he := hx (show coord.symm x ∈ coord ⁻¹' Ω by simpa using hxm)
    simpa only [complexExtension,coord.apply_symm_apply,indicator_of_mem hxm,Complex.ofReal_re] using congrArg Complex.re he

end StrictHotSpots.Weyl

end PlaneWeakWeylInteriorSupportLayer


section PrimitiveAtlasInteriorSupportLayer




open Set Filter Bundle
open scoped Topology
namespace StrictHotSpots.Primitives

structure DiscreteReal where
  val : ℝ

instance : TopologicalSpace DiscreteReal := ⊥
instance : DiscreteTopology DiscreteReal := ⟨rfl⟩

@[ext] lemma DiscreteReal.ext {x y : DiscreteReal} (h : x.val = y.val) : x = y := by
  cases x
  cases y
  cases h
  rfl

structure Atlas (X ι : Type*) [TopologicalSpace X] where
  U : ι → Set X
  isOpen_U : ∀ i, IsOpen (U i)
  idx : X → ι
  mem_U : ∀ x, x ∈ U (idx x)
  potential : ι → X → ℝ
  constant_overlap : ∀ i j x y, x ∈ U i ∩ U j → y ∈ U i ∩ U j →
    potential i x-potential j x = potential i y-potential j y

namespace Atlas
variable {X ι : Type*} [TopologicalSpace X] (A : Atlas X ι)

def core : FiberBundleCore ι X DiscreteReal where
  baseSet := A.U
  isOpen_baseSet := A.isOpen_U
  indexAt := A.idx
  mem_baseSet_at := A.mem_U
  coordChange i j x d := ⟨d.val+A.potential i x-A.potential j x⟩
  coordChange_self := by
    intro i x _ d
    ext
    dsimp
    ring
  continuousOn_coordChange := by
    intro i j
    by_cases hn : (A.U i ∩ A.U j).Nonempty
    · obtain ⟨z,hz⟩ := hn
      have hc : Continuous (fun d : DiscreteReal =>
          (⟨d.val+(A.potential i z-A.potential j z)⟩ : DiscreteReal)) := continuous_of_discreteTopology
      apply (hc.comp continuous_snd).continuousOn.congr
      intro p hp
      ext
      dsimp
      have he := A.constant_overlap i j p.1 z hp.1 hz
      linarith
    · have he : (A.U i ∩ A.U j) ×ˢ (univ : Set DiscreteReal) = ∅ := by
        rw [not_nonempty_iff_eq_empty.mp hn,empty_prod]
      rw [he]
      exact continuousOn_empty _
  coordChange_comp := by
    intro i j k x _ d
    ext
    dsimp
    ring



theorem exists_locally_potential [SimplyConnectedSpace X] [LocallyPathConnectedSpace X]
    (x₀ : X) : ∃ g : X → ℝ, ∀ x : X, ∃ c : ℝ,
      ∀ᶠ y in 𝓝 x, g y = A.potential (A.idx x) y+c := by
  let Z := A.core
  have hcov : IsCoveringMap Z.proj := IsFiberBundle.isCoveringMap (fun x =>
    ⟨Z.localTriv (Z.indexAt x),Z.mem_baseSet_at x⟩)
  let e₀ : Z.TotalSpace := ⟨x₀,⟨0⟩⟩
  obtain ⟨F,⟨_,hF⟩,_⟩ := hcov.existsUnique_continuousMap_lifts (ContinuousMap.id X) x₀ e₀ rfl
  have hproj (x : X) : (F x).1 = x := congrFun hF x
  let g : X → ℝ := fun x => (F x).2.val+A.potential (A.idx (F x).1) (F x).1
  refine ⟨g,fun x => ?_⟩
  let i := A.idx x
  let c : X → DiscreteReal := fun y => (Z.localTriv i (F y)).2
  have hc : ContinuousAt c x := by
    apply ContinuousAt.snd
    have hm : F x ∈ (Z.localTriv i).source := by
      change Z.proj (F x) ∈ Z.baseSet i
      rw [show Z.proj (F x) = x from hproj x]
      exact A.mem_U x
    exact ((Z.localTriv i).continuousAt hm).comp F.continuous.continuousAt
  have he (y : X) : g y = A.potential i y+(c y).val := by
    dsimp only [g,c]
    rw [Z.localTriv_apply]
    change (F y).2.val+A.potential (A.idx (F y).1) (F y).1 =
      A.potential i y+((F y).2.val+A.potential (A.idx (F y).1) (F y).1-A.potential i (F y).1)
    rw [hproj y]
    ring
  have hn : ∀ᶠ y in 𝓝 x, c y = c x := by
    have hh : {c x} ∈ 𝓝 (c x) := by simp
    exact hc hh
  refine ⟨(c x).val,?_⟩
  filter_upwards [hn] with y hy
  rw [he y,hy]

end Atlas
end StrictHotSpots.Primitives

end PrimitiveAtlasInteriorSupportLayer


section SimplyConnectedPoincareInteriorSupportLayer

open Set Filter Metric
open scoped Topology
namespace StrictHotSpots.Primitives



theorem exists_primitive {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {Ω : Set E} (ho : IsOpen Ω) (hs : IsSimplyConnected Ω)
    {ω : E → E →L[ℝ] ℝ} (hω : DifferentiableOn ℝ ω Ω)
    (hd : ∀ a ∈ Ω, ∀ x y, fderiv ℝ ω a x y = fderiv ℝ ω a y x) :
    ∃ f : E → ℝ, ∀ a ∈ Ω, HasFDerivAt f (ω a) a := by
  classical
  let : SimplyConnectedSpace Ω := hs
  let : LocallyPathConnectedSpace Ω := ho.locallyPathConnectedSpace
  have hb (p : Ω) : ∃ r : ℝ, 0 < r ∧ ball (p : E) r ⊆ Ω :=
    Metric.isOpen_iff.mp ho p p.property
  choose r hr hrΩ using hb
  have hprim (p : Ω) : ∃ F : E → ℝ, ∀ a ∈ ball (p : E) (r p), HasFDerivAt F (ω a) a :=
    (convex_ball (p : E) (r p)).exists_forall_hasFDerivAt_of_fderiv_symmetric isOpen_ball
      (hω.mono (hrΩ p)) (fun a ha => hd a (hrΩ p ha))
  choose F hF using hprim
  let A : Atlas Ω Ω := {
    U := fun p => Subtype.val ⁻¹' ball (p : E) (r p)
    isOpen_U := fun p => isOpen_ball.preimage continuous_subtype_val
    idx := id
    mem_U := fun p => mem_ball_self (hr p)
    potential := fun p x => F p x
    constant_overlap := by
      intro p q x y hx hy
      let U := ball (p : E) (r p) ∩ ball (q : E) (r q)
      have hu : IsOpen U := isOpen_ball.inter isOpen_ball
      have hh (z : E) (hz : z ∈ U) : HasFDerivAt (fun z => F p z-F q z) (0 : E →L[ℝ] ℝ) z := by
        simpa only [sub_self,Pi.sub_apply] using! (hF p z hz.1).sub (hF q z hz.2)
      apply ((convex_ball (p : E) (r p)).inter (convex_ball (q : E) (r q))).is_const_of_fderivWithin_eq_zero
          (fun z hz => (hh z hz).differentiableAt.differentiableWithinAt)
          (fun z hz => (hh z hz).hasFDerivWithinAt.fderivWithin (hu.uniqueDiffOn z hz)) hx hy }
  obtain ⟨x₀⟩ := (inferInstance : Nonempty Ω)
  obtain ⟨g,hg⟩ := A.exists_locally_potential x₀
  let f : E → ℝ := fun x => if hx : x ∈ Ω then g ⟨x,hx⟩ else 0
  refine ⟨f,fun a ha => ?_⟩
  let a' : Ω := ⟨a,ha⟩
  obtain ⟨c,hc⟩ := hg a'
  have he : ∀ᶠ x in 𝓝 a, f x = F a' x+c := by
    have hsub : ∀ᶠ x : Ω in 𝓝 a', g x = F a' x+c := hc
    rw [nhds_subtype_eq_comap] at hsub
    obtain ⟨s,hsn,hss⟩ := Filter.mem_comap.mp hsub
    filter_upwards [hsn,ho.mem_nhds ha] with x hx hxΩ
    have hm := hss (show (⟨x,hxΩ⟩ : Ω) ∈ Subtype.val ⁻¹' s from hx)
    change g ⟨x,hxΩ⟩ = F a' x+c at hm
    simpa only [f,dite_eq_left hxΩ] using hm
  exact ((hF a' a (mem_ball_self (hr a'))).add_const c).congr_of_eventuallyEq he

end StrictHotSpots.Primitives

end SimplyConnectedPoincareInteriorSupportLayer


section SmoothTruncationInteriorSupportLayer

open Set Filter MeasureTheory Metric
open scoped Topology ContDiff
namespace StrictHotSpots.Truncation

def trunc (n : ℕ) (t : ℝ) : ℝ := ((n:ℝ)+1) * Real.arctan (t/((n:ℝ)+1))
lemma smooth (n : ℕ) : ContDiff ℝ ∞ (trunc n) := by
  exact contDiff_const.mul (Real.contDiff_arctan.comp (contDiff_id.div_const _))
lemma derivative (n : ℕ) (t : ℝ) :
    HasDerivAt (trunc n) (1 / (1 + (t/((n:ℝ)+1))^2)) t := by
  have hn : (n:ℝ)+1 ≠ 0 := by positivity
  convert (((hasDerivAt_id t).div_const ((n:ℝ)+1)).arctan.const_mul ((n:ℝ)+1)) using 1 <;> try rfl
  simp only [id_eq]
  field_simp
lemma deriv_bound (n : ℕ) (t : ℝ) : ‖deriv (trunc n) t‖ ≤ 1 := by
  rw [(derivative n t).deriv, Real.norm_of_nonneg (by positivity)]
  exact (div_le_one (by positivity)).mpr (by nlinarith [sq_nonneg (t/((n:ℝ)+1))])
lemma norm_le (n : ℕ) (t : ℝ) : ‖trunc n t‖ ≤ ‖t‖ := by
  have h := Convex.norm_image_sub_le_of_norm_deriv_le (f := trunc n) (s := univ)
    (fun x _ => (derivative n x).differentiableAt)
    (fun x _ => deriv_bound n x) convex_univ (mem_univ t) (mem_univ (0:ℝ))
  simpa [trunc] using h
lemma bounded (n : ℕ) (t : ℝ) : ‖trunc n t‖ ≤ ((n:ℝ)+1)*(Real.pi/2) := by
  rw [trunc,norm_mul,Real.norm_of_nonneg (by positivity)]
  apply mul_le_mul_of_nonneg_left _ (by positivity)
  rw [Real.norm_eq_abs,abs_le]
  exact ⟨(Real.neg_pi_div_two_lt_arctan _).le,(Real.arctan_lt_pi_div_two _).le⟩
lemma tends (t : ℝ) : Tendsto (fun n => trunc n t) atTop (𝓝 t) := by
  by_cases ht : t = 0
  · subst t
    simp [trunc]
  have ht0 : Tendsto (fun n : ℕ => t/((n:ℝ)+1)) atTop (𝓝 0) := by
    exact tendsto_const_nhds.div_atTop (by simpa only [Function.comp_def,Nat.cast_add,Nat.cast_one] using (tendsto_natCast_atTop_atTop.comp (tendsto_add_atTop_nat 1) : Tendsto (fun n : ℕ => ((n+1:ℕ):ℝ)) atTop atTop))
  have htne : Tendsto (fun n : ℕ => t/((n:ℝ)+1)) atTop (𝓝[≠] 0) :=
    tendsto_nhdsWithin_iff.mpr ⟨ht0,Eventually.of_forall (fun n => by simpa using div_ne_zero ht (by positivity : (n:ℝ)+1 ≠ 0))⟩
  have hh := ((Real.hasDerivAt_arctan 0).tendsto_slope_zero.comp htne).const_mul t
  convert hh using 1
  · ext n
    simp only [Function.comp_apply,zero_add, Real.arctan_zero,sub_zero,smul_eq_mul,trunc]
    field_simp
  · simp
end StrictHotSpots.Truncation

end SmoothTruncationInteriorSupportLayer


section AnchoredEstimateInteriorSupportLayer

open Set MeasureTheory Filter
namespace StrictHotSpots


lemma anchored_l2_bound {α : Type*} [MeasurableSpace α] {μ : Measure α} [IsFiniteMeasure μ]
    {B : Set α} (_hB : MeasurableSet B) (hβ : 0 < (μ B).toReal)
    {f : α → ℝ} (hf : MemLp f 2 μ) {m M D : ℝ}
    (ha : ∀ᵐ x ∂μ.restrict B, ‖f x‖ ≤ M)
    (hv : (∫ x, (f x-m)^2 ∂μ) ≤ D) :
    (∫ x, (f x)^2 ∂μ) ≤ 2*D + 2*((2*D + 2*M^2*(μ B).toReal)/(μ B).toReal)*(μ univ).toReal := by
  have hfi : Integrable (fun x => (f x)^2) μ := (memLp_two_iff_integrable_sq hf.aestronglyMeasurable).mp hf
  have hfm : MemLp (fun x => f x-m) 2 μ := hf.sub (memLp_const m)
  have hvI : Integrable (fun x => (f x-m)^2) μ := (memLp_two_iff_integrable_sq hfm.aestronglyMeasurable).mp hfm
  have hvB : (∫ x in B, (f x-m)^2 ∂μ) ≤ D :=
    (setIntegral_le_integral hvI (Eventually.of_forall (fun x => sq_nonneg _))).trans hv
  have hmB : m^2*(μ B).toReal ≤ 2*D + 2*M^2*(μ B).toReal := by
    have he : (∫ _ in B, m^2 ∂μ) ≤ ∫ x in B, 2*(f x-m)^2 + 2*M^2 ∂μ := by
      apply integral_mono_ae (integrable_const _) ((hvI.restrict.const_mul 2).add (integrable_const _))
      filter_upwards [ha] with x hx
      have hM := (sq_le_sq₀ (norm_nonneg _) ((norm_nonneg _).trans hx)).mpr hx
      simp only [Real.norm_eq_abs,sq_abs] at hM
      change m^2 ≤ 2*(f x-m)^2+2*M^2
      nlinarith [sq_nonneg (2*f x-m)]
    rw [integral_add (hvI.restrict.const_mul 2) (integrable_const _),integral_const_mul] at he
    simp only [integral_const,smul_eq_mul,measureReal_def,Measure.restrict_apply_univ] at he
    nlinarith
  have hm : m^2 ≤ (2*D + 2*M^2*(μ B).toReal)/(μ B).toReal :=
    (le_div_iff₀ hβ).mpr hmB
  have he : (∫ x, (f x)^2 ∂μ) ≤ ∫ x, 2*(f x-m)^2+2*m^2 ∂μ := by
    apply integral_mono_ae hfi ((hvI.const_mul 2).add (integrable_const _))
    exact Eventually.of_forall fun x => by
      change (f x)^2 ≤ 2*(f x-m)^2+2*m^2
      nlinarith [sq_nonneg (f x-2*m)]
  rw [integral_add (hvI.const_mul 2) (integrable_const _),integral_const_mul] at he
  simp only [integral_const,smul_eq_mul,measureReal_def] at he
  exact he.trans (add_le_add (mul_le_mul_of_nonneg_left hv (by norm_num))
    (by nlinarith [mul_le_mul_of_nonneg_right hm (ENNReal.toReal_nonneg (a := μ univ))]))
end StrictHotSpots

end AnchoredEstimateInteriorSupportLayer


section FiniteEnergyPrimitiveInteriorSupportLayer

open Set Filter MeasureTheory Metric
open scoped Topology ContDiff InnerProductSpace
namespace StrictHotSpots



theorem finiteEnergy_hasH1Gradient {Ω : Set Plane} (ho : IsOpen Ω)
    (hne : Ω.Nonempty) (hb : Bornology.IsBounded Ω)
    (hμ : 0 < firstPositiveNeumannValue Ω) {r : Plane → ℝ}
    (hr : ContDiffOn ℝ ∞ r Ω) (hg : MemLp (gradient r) 2 (volume.restrict Ω)) :
    HasH1Gradient Ω r (gradient r) := by
  let : IsFiniteMeasure (volume.restrict Ω) := ⟨by simpa using hb.measure_lt_top⟩
  have hvol : 0 < (volume Ω).toReal :=
    ENNReal.toReal_pos (ne_of_gt (ho.measure_pos volume hne)) hb.measure_lt_top.ne
  have hrm : AEStronglyMeasurable r (volume.restrict Ω) := hr.continuousOn.aestronglyMeasurable ho.measurableSet
  let F (n : ℕ) (x : Plane) := Truncation.trunc n (r x)
  have hF (n : ℕ) : ContDiffOn ℝ ∞ (F n) Ω := (Truncation.smooth n).comp_contDiffOn hr
  have hmF (n : ℕ) : MemLp (F n) 2 (volume.restrict Ω) := by
    apply (memLp_const (((n:ℝ)+1)*(Real.pi/2))).mono
      ((hF n).continuousOn.aestronglyMeasurable ho.measurableSet)
    exact Eventually.of_forall fun x => (Truncation.bounded n (r x)).trans (le_abs_self _)
  have hgrad (n : ℕ) {x : Plane} (hx : x ∈ Ω) :
      gradient (F n) x = deriv (Truncation.trunc n) (r x) • gradient r x := by
    apply (InnerProductSpace.toDual ℝ Plane).injective
    simp only [gradient,map_smul,LinearIsometryEquiv.apply_symm_apply]
    have hdx := ((hr.contDiffAt (ho.mem_nhds hx)).differentiableAt (by simp)).hasFDerivAt
    exact (((Truncation.smooth n).differentiable (by simp)).differentiableAt.hasDerivAt.comp_hasFDerivAt x hdx).fderiv
  have hgradle (n : ℕ) : ∀ᵐ x ∂volume.restrict Ω, ‖gradient (F n) x‖ ≤ ‖gradient r x‖ := by
    filter_upwards [ae_restrict_mem ho.measurableSet] with x hx
    rw [hgrad n hx,norm_smul]
    exact mul_le_of_le_one_left (norm_nonneg _) (Truncation.deriv_bound n (r x))
  have hmG (n : ℕ) : MemLp (gradient (F n)) 2 (volume.restrict Ω) := by
    apply hg.mono _ (hgradle n)
    have hd : ContDiffOn ℝ ∞ (fderiv ℝ (F n)) Ω := (hF n).fderiv_of_isOpen ho (by simp)
    have hc : ContinuousOn (gradient (F n)) Ω :=
      (InnerProductSpace.toDual ℝ Plane).symm.continuous.comp_continuousOn
        hd.continuousOn
    exact hc.aestronglyMeasurable ho.measurableSet
  have hH (n : ℕ) : HasH1Gradient Ω (F n) (gradient (F n)) :=
    HasH1Gradient.of_contDiffOn ho (hF n) (hmF n) (hmG n)
  let m (n : ℕ) := (∫ x in Ω, F n x)/(volume Ω).toReal
  let G := ∫ x in Ω, ‖gradient r x‖^2
  have hm (n : ℕ) : (∫ x in Ω, F n x-m n) = 0 := by
    rw [integral_sub ((hmF n).integrable (by norm_num)) (integrable_const _)]
    simp only [integral_const,measureReal_restrict_apply_univ,smul_eq_mul]
    change (∫ x in Ω, F n x)-(volume Ω).toReal*m n = 0
    dsimp [m]
    field_simp
    ring
  have hvar (n : ℕ) : (∫ x in Ω, (F n x-m n)^2) ≤ G/firstPositiveNeumannValue Ω := by
    have hH' : HasH1Gradient Ω (fun x => F n x-m n) (gradient (F n)) := by
      simpa only [sub_zero] using! (hH n).sub (HasH1Gradient.const hb (m n))
    have he := rayleigh_inequality_all hH' (hm n)
    have he' : (∫ x in Ω, ‖gradient (F n) x‖^2) ≤ G := by
      apply integral_mono_ae ((memLp_two_iff_integrable_sq_norm (hmG n).aestronglyMeasurable).mp (hmG n))
        ((memLp_two_iff_integrable_sq_norm hg.aestronglyMeasurable).mp hg)
      exact (hgradle n).mono fun x hx => (sq_le_sq₀ (norm_nonneg _) (norm_nonneg _)).mpr hx
    exact (le_div_iff₀ hμ).mpr (by nlinarith)
  obtain ⟨a,ha⟩ := hne
  have heΩ : ∀ᶠ x in 𝓝 a, x ∈ Ω := ho.mem_nhds ha
  have he : ∀ᶠ x in 𝓝 a, x ∈ Ω ∧ ‖r x‖ < ‖r a‖+1 :=
    heΩ.and (((hr.continuousOn a ha).continuousAt (ho.mem_nhds ha)).norm.eventually
      (gt_mem_nhds (by linarith : ‖r a‖ < ‖r a‖+1)))
  obtain ⟨ε,hε,hεs⟩ := Metric.mem_nhds_iff.mp he
  have hBΩ : ball a ε ⊆ Ω := fun x hx => (hεs hx).1
  have hβ : 0 < ((volume.restrict Ω) (ball a ε)).toReal := by
    rw [Measure.restrict_apply measurableSet_ball,inter_eq_left.mpr hBΩ]
    exact ENNReal.toReal_pos (ne_of_gt (isOpen_ball.measure_pos volume (nonempty_ball.mpr hε)))
      (measure_ball_lt_top.ne)
  let C := 2*(G/firstPositiveNeumannValue Ω) +
    2*((2*(G/firstPositiveNeumannValue Ω)+2*(‖r a‖+1)^2*((volume.restrict Ω) (ball a ε)).toReal)/
      ((volume.restrict Ω) (ball a ε)).toReal)*((volume.restrict Ω) univ).toReal
  have hbound (n : ℕ) : (∫ x in Ω, (F n x)^2) ≤ C := by
    apply anchored_l2_bound measurableSet_ball hβ (hmF n) (m := m n)
    · filter_upwards [ae_restrict_mem measurableSet_ball] with x hx
      exact (Truncation.norm_le n (r x)).trans (hεs hx).2.le
    · exact hvar n
  have hLP (n : ℕ) : eLpNorm (F n) 2 (volume.restrict Ω) ≤ ENNReal.ofReal (Real.sqrt (max C 0)) := by
    rw [(hmF n).eLpNorm_eq_integral_rpow_norm (by norm_num) (by norm_num)]
    norm_num only [ENNReal.toReal_ofNat,Real.rpow_two,Real.norm_eq_abs,sq_abs]
    rw [← Real.sqrt_eq_rpow]
    exact ENNReal.ofReal_le_ofReal (Real.sqrt_le_sqrt ((hbound n).trans (le_max_left C 0)))
  have hrL : MemLp r 2 (volume.restrict Ω) := by
    exact (Lp.eLpNorm_le_of_ae_tendsto (Eventually.of_forall hLP)
      (fun n => (hmF n).aestronglyMeasurable) hrm
      (Eventually.of_forall (fun x => Truncation.tends (r x)))).trans_lt
      ENNReal.ofReal_lt_top
  exact HasH1Gradient.of_contDiffOn ho hr hrL hg
end StrictHotSpots

end FiniteEnergyPrimitiveInteriorSupportLayer


section SmoothClosedPotentialInteriorSupportLayer

open Set MeasureTheory
open scoped ContDiff InnerProductSpace
namespace StrictHotSpots



theorem closed_finiteEnergy_potential {Ω : Set Plane} (ho : IsOpen Ω)
    (hs : IsSimplyConnected Ω) (hb : Bornology.IsBounded Ω)
    (hμ : 0 < firstPositiveNeumannValue Ω)
    {Z : Plane → Plane} (hZ : ContDiffOn ℝ ∞ Z Ω)
    (hm : MemLp Z 2 (volume.restrict Ω))
    (hd : ∀ a ∈ Ω, ∀ x y,
      fderiv ℝ (fun a => innerSL ℝ (Z a)) a x y =
      fderiv ℝ (fun a => innerSL ℝ (Z a)) a y x) :
    ∃ r : Plane → ℝ, ContDiffOn ℝ ∞ r Ω ∧ HasH1Gradient Ω r Z := by
  have hw : ContDiffOn ℝ ∞ (fun a => innerSL ℝ (Z a)) Ω :=
    (innerSL ℝ (E := Plane)).contDiff.comp_contDiffOn hZ
  obtain ⟨r,hr⟩ := Primitives.exists_primitive ho hs (hw.differentiableOn (by simp)) hd
  have he : EqOn (fderiv ℝ r) (fun a => innerSL ℝ (Z a)) Ω := fun a ha => (hr a ha).fderiv
  have hrs : ContDiffOn ℝ ∞ r Ω := by
    rw [contDiffOn_infty_iff_fderiv_of_isOpen ho]
    exact ⟨fun a ha => (hr a ha).differentiableAt.differentiableWithinAt, hw.congr he⟩
  have heg : ∀ a ∈ Ω, gradient r a = Z a := by
    intro a ha
    apply (InnerProductSpace.toDual ℝ Plane).injective
    change (InnerProductSpace.toDual ℝ Plane) ((InnerProductSpace.toDual ℝ Plane).symm (fderiv ℝ r a)) = _
    rw [LinearIsometryEquiv.apply_symm_apply,he ha]
    ext y
    rfl
  have hae : gradient r =ᵐ[volume.restrict Ω] Z :=
    (ae_restrict_mem ho.measurableSet).mono fun a ha => heg a ha
  have hgr : MemLp (gradient r) 2 (volume.restrict Ω) := (memLp_congr_ae hae).mpr hm
  have hne : Ω.Nonempty := by
    let : SimplyConnectedSpace Ω := hs
    obtain ⟨x⟩ := (inferInstance : Nonempty Ω)
    exact ⟨x,x.property⟩
  refine ⟨r,hrs,?_⟩
  exact (finiteEnergy_hasH1Gradient ho hne hb hμ hrs hgr).congr (Filter.Eventually.of_forall (fun _ => rfl)) hae



theorem closed_orthogonal_gradient_zero {Ω : Set Plane} (ho : IsOpen Ω)
    (hs : IsSimplyConnected Ω) (hb : Bornology.IsBounded Ω)
    (hμ : 0 < firstPositiveNeumannValue Ω)
    {Z : Plane → Plane} (hZ : ContDiffOn ℝ ∞ Z Ω)
    (hm : MemLp Z 2 (volume.restrict Ω))
    (hd : ∀ a ∈ Ω, ∀ x y,
      fderiv ℝ (fun a => innerSL ℝ (Z a)) a x y =
      fderiv ℝ (fun a => innerSL ℝ (Z a)) a y x)
    (hz : ∀ v g, HasH1Gradient Ω v g → (∫ x in Ω, inner ℝ (Z x) (g x)) = 0) :
    ∀ x ∈ Ω, Z x = 0 := by
  obtain ⟨r,_,hr⟩ := closed_finiteEnergy_potential ho hs hb hμ hZ hm hd
  have he := hz r Z hr
  simp only [real_inner_self_eq_norm_sq] at he
  have hI := (memLp_two_iff_integrable_sq_norm hm.aestronglyMeasurable).mp hm
  have hae : ∀ᵐ x ∂volume.restrict Ω, ‖Z x‖^2 = 0 :=
    (integral_eq_zero_iff_of_nonneg_ae (Filter.Eventually.of_forall (fun x => sq_nonneg ‖Z x‖)) hI).mp he
  have hae' : Z =ᵐ[volume.restrict Ω] 0 := hae.mono fun x hx => by simpa using hx
  exact MeasureTheory.Measure.eqOn_open_of_ae_eq hae' ho hZ.continuousOn continuousOn_const
end StrictHotSpots

end SmoothClosedPotentialInteriorSupportLayer


section WeakHodgeRegularityInteriorSupportLayer

open Set MeasureTheory
open scoped ContDiff Laplacian
namespace StrictHotSpots.Hodge

def WeakDivZero (Ω : Set Plane) (Z : Plane → Plane) : Prop :=
  ∀ φ : Plane → ℝ, ContDiff ℝ ∞ φ → HasCompactSupport φ → tsupport φ ⊆ Ω →
    (∫ x in Ω, inner ℝ (Z x) (gradient φ x)) = 0

def WeakCurlZero (Ω : Set Plane) (Z : Plane → Plane) : Prop :=
  ∀ φ : Plane → ℝ, ContDiff ℝ ∞ φ → HasCompactSupport φ → tsupport φ ⊆ Ω →
    (∫ x in Ω, inner ℝ (Z x) (rot (gradient φ x))) = 0

lemma weak_harmonic_coordinates {Ω : Set Plane} (ho : IsOpen Ω)
    {Z : Plane → Plane} (hm : MemLp Z 2 (volume.restrict Ω))
    (hd : WeakDivZero Ω Z) (hc : WeakCurlZero Ω Z) (i : Fin 2) :
    PlaneWeakEquation Ω 0 (fun x => c i (Z x)) := by
  intro φ hφ hk hs
  have hI (j : Fin 2) : IntegrableOn (fun x => inner ℝ (Z x) (gradient (D j φ) x)) Ω :=
    integrable_inner_of_memLp hm (HasH1Gradient.test ho (D_smooth hφ j) (D_compact hk j)).2.1
  have hJ (j : Fin 2) : IntegrableOn (fun x => inner ℝ (Z x) (rot (gradient (D j φ) x))) Ω :=
    integrable_inner_of_memLp hm (rot.comp_memLp' (HasH1Gradient.test ho (D_smooth hφ j) (D_compact hk j)).2.1)
  have hD (j : Fin 2) := hd _ (D_smooth hφ j) (D_compact hk j) ((D_support φ j).trans hs)
  have hC (j : Fin 2) := hc _ (D_smooth hφ j) (D_compact hk j) ((D_support φ j).trans hs)
  have he0 (x : Plane) : c 0 (Z x)*Δ φ x =
      inner ℝ (Z x) (gradient (D 0 φ) x) - inner ℝ (Z x) (rot (gradient (D 1 φ) x)) := by
    rw [laplace_two hφ,inner_gradient,inner_rot_gradient,D_D hφ 1 0]
    ring
  have he1 (x : Plane) : c 1 (Z x)*Δ φ x =
      inner ℝ (Z x) (gradient (D 1 φ) x) + inner ℝ (Z x) (rot (gradient (D 0 φ) x)) := by
    rw [laplace_two hφ,inner_gradient,inner_rot_gradient,D_D hφ 1 0]
    ring
  fin_cases i
  · change (∫ x in Ω, c 0 (Z x) * Δ φ x) = _
    simp_rw [he0]
    rw [integral_sub (hI 0) (hJ 1),hD 0,hC 1]
    simp
  · change (∫ x in Ω, c 1 (Z x) * Δ φ x) = _
    simp_rw [he1]
    rw [integral_add (hI 1) (hJ 0),hD 1,hC 0]
    simp



theorem weak_divCurl_smooth {Ω : Set Plane} (ho : IsOpen Ω)
    (hb : Bornology.IsBounded Ω) {Z : Plane → Plane} (hm : MemLp Z 2 (volume.restrict Ω))
    (hd : WeakDivZero Ω Z) (hc : WeakCurlZero Ω Z) :
    ∃ W : Plane → Plane, ContDiffOn ℝ ∞ W Ω ∧ W =ᵐ[volume.restrict Ω] Z := by
  let : IsFiniteMeasure (volume.restrict Ω) := isFiniteMeasure_restrict.mpr hb.measure_lt_top.ne
  have hh (i : Fin 2) := Weyl.plane_representative ho
    ((hm.inner_const (e i)).integrable (by norm_num)) (weak_harmonic_coordinates ho hm hd hc i)
  choose f hf he using hh
  refine ⟨fun x => f 0 x • e 0+f 1 x • e 1,(hf 0).smul contDiffOn_const |>.add ((hf 1).smul contDiffOn_const),?_⟩
  filter_upwards [he 0,he 1] with x hx0 hx1
  rw [hx0,hx1,expand]

lemma smooth_curl_zero {Ω : Set Plane} (ho : IsOpen Ω)
    {W : Plane → Plane} (hW : ContDiffOn ℝ ∞ W Ω) (hc : WeakCurlZero Ω W) :
    ∀ x ∈ Ω, D 0 (fun y => c 1 (W y)) x = D 1 (fun y => c 0 (W y)) x := by
  let a : Plane → ℝ := fun x => c 0 (W x)
  let b : Plane → ℝ := fun x => c 1 (W x)
  have ha : ContDiffOn ℝ ∞ a Ω := hW.inner ℝ contDiffOn_const
  have hb : ContDiffOn ℝ ∞ b Ω := hW.inner ℝ contDiffOn_const
  have hda := directionalDerivative_contDiffOn ho ha (e 1)
  have hdb := directionalDerivative_contDiffOn ho hb (e 0)
  have hcont : ContinuousOn (fun x => D 0 b x-D 1 a x) Ω := hdb.continuousOn.sub hda.continuousOn
  have hz := ho.ae_eq_zero_of_integral_contDiff_smul_eq_zero
    (hcont.locallyIntegrableOn ho.measurableSet (μ := volume)) ?_
  · have he : (fun x => D 0 b x-D 1 a x) =ᵐ[volume.restrict Ω] 0 := (ae_restrict_iff' ho.measurableSet).mpr hz
    have hh := MeasureTheory.Measure.eqOn_open_of_ae_eq he ho hcont continuousOn_const
    intro x hx
    exact sub_eq_zero.mp (hh hx)
  · intro φ hφ hk hs
    have hi : IntegrableOn (fun x => D 0 b x*φ x) Ω := (integrable_mul_test ho hdb.continuousOn hφ.continuous hk hs).integrableOn
    have hj : IntegrableOn (fun x => D 1 a x*φ x) Ω := (integrable_mul_test ho hda.continuousOn hφ.continuous hk hs).integrableOn
    have hi' : IntegrableOn (fun x => b x*D 0 φ x) Ω := (integrable_mul_test ho hb.continuousOn (D_smooth hφ 0).continuous
      (D_compact hk 0) ((D_support φ 0).trans hs)).integrableOn
    have hj' : IntegrableOn (fun x => a x*D 1 φ x) Ω := (integrable_mul_test ho ha.continuousOn (D_smooth hφ 1).continuous
      (D_compact hk 1) ((D_support φ 1).trans hs)).integrableOn
    have h0 := integral_mul_test_fderiv ho hb hφ hk hs (e 0)
    have h1 := integral_mul_test_fderiv ho ha hφ hk hs (e 1)
    have h := hc φ hφ hk hs
    simp_rw [inner_rot_gradient] at h
    rw [integral_sub hi' hj'] at h
    change (∫ x in Ω, b x * D 0 φ x) = -(∫ x in Ω, D 0 b x * φ x) at h0
    change (∫ x in Ω, a x * D 1 φ x) = -(∫ x in Ω, D 1 a x * φ x) at h1
    rw [h0,h1] at h
    simp only [smul_eq_mul]
    simp_rw [mul_comm (φ _) _]
    rw [← setIntegral_mul_test hs]
    simp_rw [sub_mul]
    rw [integral_sub hi hj]
    linarith

lemma smooth_closed {Ω : Set Plane} (ho : IsOpen Ω)
    {W : Plane → Plane} (hW : ContDiffOn ℝ ∞ W Ω) (hc : WeakCurlZero Ω W) :
    ∀ a ∈ Ω, ∀ x y,
      fderiv ℝ (fun a => innerSL ℝ (W a)) a x y =
      fderiv ℝ (fun a => innerSL ℝ (W a)) a y x := by
  intro a ha x y
  have hw : DifferentiableAt ℝ W a :=
    (hW.differentiableOn (by simp) a ha).differentiableAt (ho.mem_nhds ha)
  have hform (x y : Plane) :
      fderiv ℝ (fun a => innerSL ℝ (W a)) a x y = inner ℝ (fderiv ℝ W a x) y := by
    have hh : HasFDerivAt (fun a => innerSL ℝ (W a))
        ((innerSL ℝ (E := Plane)).comp (fderiv ℝ W a)) a :=
      (innerSL ℝ (E := Plane)).hasFDerivAt.comp a hw.hasFDerivAt
    rw [hh.fderiv]
    rfl
  have hcoord (i j : Fin 2) : D i (fun y => c j (W y)) a =
      inner ℝ (fderiv ℝ W a (e i)) (e j) := by
    change fderiv ℝ (fun y => inner ℝ (W y) (e j)) a (e i) = _
    rw [fderiv_inner_apply ℝ hw (differentiableAt_const _)]
    simp only [fderiv_fun_const,Pi.zero_apply,zero_apply,inner_zero_right,zero_add]
  have hc' := smooth_curl_zero ho hW hc a ha
  rw [hcoord,hcoord] at hc'
  simp_rw [hform]
  conv_lhs => rw [← expand x,← expand y]
  conv_rhs => rw [← expand y,← expand x]
  simp only [map_add,map_smul,inner_add_left,inner_add_right,inner_smul_left,
    inner_smul_right,conj_trivial]
  rw [hc']
  ring




theorem weak_divCurl_zero {Ω : Set Plane} (ho : IsOpen Ω)
    (hs : IsSimplyConnected Ω) (hb : Bornology.IsBounded Ω)
    (hμ : 0 < firstPositiveNeumannValue Ω)
    {Z : Plane → Plane} (hm : MemLp Z 2 (volume.restrict Ω))
    (hc : WeakCurlZero Ω Z)
    (hz : ∀ v g, HasH1Gradient Ω v g → (∫ x in Ω, inner ℝ (Z x) (g x)) = 0) :
    Z =ᵐ[volume.restrict Ω] 0 := by
  have hd : WeakDivZero Ω Z := fun φ hφ hk _ => hz φ _ (HasH1Gradient.test ho hφ hk)
  obtain ⟨W,hW,he⟩ := weak_divCurl_smooth ho hb hm hd hc
  have hwm : MemLp W 2 (volume.restrict Ω) := (memLp_congr_ae he).mpr hm
  have heI (f : Plane → Plane) : (∫ x in Ω, inner ℝ (W x) (f x)) =
      ∫ x in Ω, inner ℝ (Z x) (f x) :=
    integral_congr_ae (he.mono fun x hx => congrArg (fun t => inner ℝ t (f x)) hx)
  have hwc : WeakCurlZero Ω W := fun φ hφ hk ht => (heI _).trans (hc φ hφ hk ht)
  have hwz : ∀ v g, HasH1Gradient Ω v g → (∫ x in Ω, inner ℝ (W x) (g x)) = 0 :=
    fun v g hv => (heI g).trans (hz v g hv)
  have hw0 := closed_orthogonal_gradient_zero ho hs hb hμ hW hwm (smooth_closed ho hW hwc) hwz
  exact he.symm.trans ((ae_restrict_mem ho.measurableSet).mono fun x hx => hw0 x hx)

end StrictHotSpots.Hodge

end WeakHodgeRegularityInteriorSupportLayer



end

end ActualVectorSupport

end OAI