import OAI.Analysis.HotSpots.Reciprocal

namespace OAI

section DouglasLipschitzBase
noncomputable section
section FullBoundaryCombinedLayer
section DiskFiniteLayer

open Filter Matrix
open scoped Topology
namespace StrictHotSpots.ScalarKernel

lemma choose_recurrence (a : ℝ) (n : ℕ) :
    ((n : ℝ) + 1) * Ring.choose a (n + 1) = (a - n) * Ring.choose a n := by
  have hh := Ring.descPochhammer_eq_factorial_smul_choose a (n + 1)
  rw [descPochhammer_succ_right, Polynomial.smeval_mul,
    Polynomial.smeval_sub, Polynomial.smeval_X, Polynomial.smeval_natCast,
    Ring.descPochhammer_eq_factorial_smul_choose] at hh
  simp only [nsmul_eq_mul, Nat.factorial_succ, Nat.cast_mul, Nat.cast_add,
    Nat.cast_one] at hh
  have hn : (n.factorial : ℝ) ≠ 0 := by positivity
  apply mul_left_cancel₀ hn
  nlinarith [hh]

def coeff (a : ℝ) (n : ℕ) : ℝ := -(Ring.choose a (n + 2) * (-1) ^ (n + 2))

lemma coeff_nonneg {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) (n : ℕ) : 0 ≤ coeff a n := by
  induction n with
  | zero =>
    have hh := choose_recurrence a 1
    simp only [Nat.cast_one, Ring.choose_one_right] at hh
    simp only [coeff, zero_add, even_two, Even.neg_pow, one_pow, mul_one]
    nlinarith [mul_nonneg ha (sub_nonneg.mpr ha1)]
  | succ n ih =>
    have hh := choose_recurrence a (n + 2)
    have hrec : ((n : ℝ) + 3) * coeff a (n + 1) = ((n : ℝ) + 2 - a) * coeff a n := by
      simp only [coeff, Nat.cast_add, Nat.cast_ofNat] at *
      rw [show n + 1 + 2 = (n + 2) + 1 by omega, pow_succ]
      nlinarith [congrArg (fun t : ℝ => t * (-1) ^ (n + 2)) hh]
    have hn : 0 < (n : ℝ) + 3 := by positivity
    have hmul : 0 ≤ ((n : ℝ) + 2 - a) * coeff a n :=
      mul_nonneg (by have : (0 : ℝ) ≤ n := Nat.cast_nonneg n; linarith) ih
    nlinarith

lemma binomial_hasSum {a k : ℝ} (hk : |k| < 1) :
    HasSum (fun n : ℕ => Ring.choose a n * (-k) ^ n) ((1 - k) ^ a) := by
  have hh := (Real.one_add_rpow_hasFPowerSeriesOnBall_zero (a := a)).hasSum
    (y := -k) (by simpa [Metric.mem_eball, edist_dist, Real.norm_eq_abs] using hk)
  simpa [binomialSeries, FormalMultilinearSeries.coeff_ofScalars,
    sub_eq_add_neg, mul_comm] using hh


lemma defect_hasSum {a k : ℝ} (hk0 : 0 < k) (hk1 : k < 1) :
    HasSum (fun n : ℕ => coeff a n * k ^ (n + 1))
      ((1 - (1 - k) ^ a) / k - a) := by
  have hh := binomial_hasSum (a := a) (abs_lt.mpr ⟨by linarith, hk1⟩)
  have ht := (hasSum_nat_add_iff' 2).mpr hh
  have hs := ht.mul_left (-k⁻¹)
  have he : (fun n : ℕ => -k⁻¹ * (Ring.choose a (n + 2) * (-k) ^ (n + 2))) =
      (fun n : ℕ => coeff a n * k ^ (n + 1)) := by
    funext n
    rw [neg_pow k (n + 2)]
    simp only [coeff, pow_add]
    field_simp
  rw [he] at hs
  have hv : -k⁻¹ * ((1 - k) ^ a - ∑ i ∈ Finset.range 2, Ring.choose a i * (-k) ^ i) =
      (1 - (1 - k) ^ a) / k - a := by
    simp only [Finset.sum_range_succ, Finset.sum_range_zero,
      Ring.choose_zero_right, Ring.choose_one_right, pow_zero, pow_one]
    field_simp
    ring
  rwa [hv] at hs

section Matrix
variable {ι : Type*} [Fintype ι]


lemma posSemidef_entry_pow {A : Matrix ι ι ℝ} (hA : A.PosSemidef) (n : ℕ) :
    (Matrix.of (fun i j => A i j ^ n)).PosSemidef := by
  induction n with
  | zero =>
    simpa [Matrix.vecMulVec] using
      (Matrix.posSemidef_vecMulVec_self_star (fun _ : ι => (1 : ℝ)))
  | succ n ih =>
    have he : Matrix.of (fun i j => A i j ^ (n + 1)) =
        Matrix.of (fun i j => A i j ^ n) ⊙ A := by
      ext i j
      simp [pow_succ]
    rw [he]
    exact ih.hadamard hA


lemma posSemidef_of_entrywise_tendsto {A : ℕ → Matrix ι ι ℝ} {B : Matrix ι ι ℝ}
    (hA : ∀ n, (A n).PosSemidef)
    (hlim : ∀ i j, Tendsto (fun n => A n i j) atTop (𝓝 (B i j))) : B.PosSemidef := by
  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
  · apply Matrix.isHermitian_iff_isSymm.mpr
    ext i j
    exact tendsto_nhds_unique (hlim j i)
      ((hlim i j).congr fun n => by simpa using (hA n).isHermitian.apply j i)
  · intro x
    have hlimq : Tendsto (fun n => star x ⬝ᵥ A n *ᵥ x) atTop
        (𝓝 (star x ⬝ᵥ B *ᵥ x)) := by
      unfold dotProduct Matrix.mulVec
      exact tendsto_finsetSum _ (fun i _ => tendsto_const_nhds.mul
        (tendsto_finsetSum _ fun j _ => (hlim i j).mul tendsto_const_nhds))
    exact ge_of_tendsto hlimq (Filter.Eventually.of_forall fun n =>
      (hA n).dotProduct_mulVec_nonneg x)


lemma defect_posSemidef {A : Matrix ι ι ℝ} (hA : A.PosSemidef)
    (hpos : ∀ i j, 0 < A i j) (hlt : ∀ i j, A i j < 1)
    {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) :
    (Matrix.of (fun i j => (1 - (1 - A i j) ^ a) / A i j - a)).PosSemidef := by
  apply posSemidef_of_entrywise_tendsto
    (A := fun n => ∑ m ∈ Finset.range n,
      coeff a m • Matrix.of (fun i j => A i j ^ (m + 1)))
  · intro n
    exact Matrix.posSemidef_sum _ (fun m _ =>
      (posSemidef_entry_pow hA _).smul (coeff_nonneg ha ha1 m))
  · intro i j
    simpa only [Matrix.sum_apply, Matrix.smul_apply, Matrix.of_apply, smul_eq_mul]
      using (defect_hasSum (a := a) (hpos i j) (hlt i j)).tendsto_sum_nat

lemma integral_posSemidef {F : ℝ → Matrix ι ι ℝ}
    (hF : ∀ a ∈ Set.Icc (0 : ℝ) 1, (F a).PosSemidef)
    (hi : ∀ i j, IntervalIntegrable (fun a => F a i j) MeasureTheory.volume 0 1) :
    (Matrix.of (fun i j => ∫ a in (0 : ℝ)..1, F a i j)).PosSemidef := by
  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
  · apply Matrix.isHermitian_iff_isSymm.mpr
    ext i j
    apply intervalIntegral.integral_congr
    intro a ha
    have ha' : a ∈ Set.Icc (0 : ℝ) 1 := by simpa using ha
    simpa using (hF a ha').isHermitian.apply i j
  · intro v
    have he : (star v ⬝ᵥ (Matrix.of (fun i j => ∫ a in (0 : ℝ)..1, F a i j)) *ᵥ v) =
        ∫ a in (0 : ℝ)..1, star v ⬝ᵥ F a *ᵥ v := by
      simp only [dotProduct, Matrix.mulVec, star_trivial, Matrix.of_apply]
      rw [intervalIntegral.integral_finsetSum]
      · apply Finset.sum_congr rfl
        intro i _
        rw [intervalIntegral.integral_const_mul, intervalIntegral.integral_finsetSum]
        · simp only [intervalIntegral.integral_mul_const]
        · intro j _
          exact (hi i j).mul_const _
      · intro i _
        simpa only [Finset.sum_apply] using
          (IntervalIntegrable.sum Finset.univ fun j _ => (hi i j).mul_const (v j)).const_mul (v i)
    rw [he]
    apply intervalIntegral.integral_nonneg (by norm_num)
    intro a ha
    exact (hF a ha).dotProduct_mulVec_nonneg v

end Matrix


lemma integral_rpow_parameter {x : ℝ} (hx : 0 < x) (hx1 : x < 1) :
    (∫ a in (0 : ℝ)..1, x ^ a) = (x - 1) / Real.log x := by
  have hl : Real.log x ≠ 0 := ne_of_lt (Real.log_neg hx hx1)
  have hh := intervalIntegral.mul_integral_comp_mul_left
    (f := Real.exp) (a := 0) (b := 1) (Real.log x)
  simp only [mul_zero, mul_one, integral_exp, Real.exp_zero, Real.exp_log hx] at hh
  rw [eq_div_iff hl]
  convert hh using 1
  · simp only [Real.rpow_def_of_pos hx, mul_comm]

lemma integral_defect {k : ℝ} (hk0 : 0 < k) (hk1 : k < 1) :
    (∫ a in (0 : ℝ)..1, ((1 - (1 - k) ^ a) / k - a)) =
      k⁻¹ - 1 / 2 + (Real.log (1 - k))⁻¹ := by
  have hb : 0 < 1 - k := sub_pos.mpr hk1
  have hcont : Continuous (fun a : ℝ => (1 - k) ^ a) :=
    Real.continuous_const_rpow hb.ne'
  have hi := hcont.intervalIntegrable (μ := MeasureTheory.volume) 0 1
  have hi1 : IntervalIntegrable (fun a : ℝ => (1 - (1 - k) ^ a) / k)
      MeasureTheory.volume 0 1 :=
    ((continuous_const.sub hcont).div_const k).intervalIntegrable 0 1
  have hiid : IntervalIntegrable (fun a : ℝ => a) MeasureTheory.volume 0 1 :=
    continuous_id.intervalIntegrable 0 1
  rw [intervalIntegral.integral_sub hi1 hiid]
  rw [intervalIntegral.integral_div, intervalIntegral.integral_sub
    (continuous_const.intervalIntegrable 0 1) hi]
  rw [integral_rpow_parameter hb (by linarith)]
  norm_num [intervalIntegral.integral_const, integral_id]
  field_simp
  ring

section Matrix
variable {ι : Type*} [Fintype ι]

lemma logDefect_posSemidef {A : Matrix ι ι ℝ} (hA : A.PosSemidef)
    (hpos : ∀ i j, 0 < A i j) (hlt : ∀ i j, A i j < 1) :
    (Matrix.of (fun i j => (A i j)⁻¹ - 1 / 2 + (Real.log (1 - A i j))⁻¹)).PosSemidef := by
  have hh := integral_posSemidef
    (F := fun a => Matrix.of (fun i j => (1 - (1 - A i j) ^ a) / A i j - a))
    (fun a ha => defect_posSemidef hA hpos hlt ha.1 ha.2)
    (fun i j => (((continuous_const.sub
      (Real.continuous_const_rpow (sub_pos.mpr (hlt i j)).ne')).div_const
        (A i j)).sub continuous_id).intervalIntegrable 0 1)
  simpa only [Matrix.of_apply, integral_defect (hpos _ _) (hlt _ _)] using hh

end Matrix


def dilation (n : ℕ) : ℝ := 1 - ((n : ℝ) + 2)⁻¹

lemma dilation_pos (n : ℕ) : 0 < dilation n := by
  have hn : 1 < (n : ℝ) + 2 := by have := Nat.cast_nonneg (α := ℝ) n; linarith
  exact sub_pos.mpr (inv_lt_one_of_one_lt₀ hn)

lemma dilation_lt_one (n : ℕ) : dilation n < 1 := by
  have hn : 0 < ((n : ℝ) + 2)⁻¹ := by positivity
  dsimp [dilation]
  linarith

lemma dilation_tendsto : Tendsto dilation atTop (𝓝 1) := by
  have ht : Tendsto (fun n : ℕ => (n : ℝ) + 2) atTop atTop :=
    tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds
  unfold dilation
  simpa only [sub_zero] using (tendsto_const_nhds.sub ht.inv_tendsto_atTop :
    Tendsto (fun n : ℕ => 1 - ((n : ℝ) + 2)⁻¹) atTop (𝓝 (1 - 0)))

lemma invLog_continuousAt_zero : ContinuousAt (fun x : ℝ => (Real.log x)⁻¹) 0 := by
  rw [continuousAt_iff_punctured_nhds]
  simpa only [one_div, Real.log_zero, _root_.inv_zero] using
    Real.tendsto_log_nhdsNE_zero.const_div_atBot 1

lemma logDefect_tendsto {a : ℝ} (ha : 0 < a) (ha1 : a ≤ 1) :
    Tendsto (fun n => (dilation n * a)⁻¹ - 1 / 2 +
        (Real.log (1 - dilation n * a))⁻¹) atTop
      (𝓝 (a⁻¹ - 1 / 2 + (Real.log (1 - a))⁻¹)) := by
  have ht : Tendsto (fun n => dilation n * a) atTop (𝓝 a) :=
    by simpa using dilation_tendsto.mul_const a
  apply (ht.inv₀ ha.ne').sub_const (1 / 2) |>.add
  have ht' : Tendsto (fun n => 1 - dilation n * a) atTop (𝓝 (1 - a)) :=
    tendsto_const_nhds.sub ht
  by_cases he : a = 1
  · subst a
    simpa only [Function.comp_def, mul_one, sub_self, Real.log_zero, _root_.inv_zero] using
      invLog_continuousAt_zero.tendsto.comp (by simpa using ht')
  · have hb : 0 < 1 - a := sub_pos.mpr (lt_of_le_of_ne ha1 he)
    have hl : Real.log (1 - a) ≠ 0 := ne_of_lt (Real.log_neg hb (by linarith))
    exact (Real.continuousAt_log hb.ne').tendsto.comp ht' |>.inv₀ hl

lemma logDefect_posSemidef_le {ι : Type*} [Fintype ι] {A : Matrix ι ι ℝ}
    (hA : A.PosSemidef) (hpos : ∀ i j, 0 < A i j) (hle : ∀ i j, A i j ≤ 1) :
    (Matrix.of (fun i j => (A i j)⁻¹ - 1 / 2 + (Real.log (1 - A i j))⁻¹)).PosSemidef := by
  apply posSemidef_of_entrywise_tendsto
    (A := fun n => Matrix.of (fun i j => (dilation n * A i j)⁻¹ - 1 / 2 +
      (Real.log (1 - dilation n * A i j))⁻¹))
  · intro n
    exact logDefect_posSemidef (hA.smul (dilation_pos n).le)
      (fun i j => mul_pos (dilation_pos n) (hpos i j))
      (fun i j => lt_of_le_of_lt
      (mul_le_mul_of_nonneg_left (hle i j) (dilation_pos n).le)
      (by simpa using dilation_lt_one n))
  · intro i j
    exact logDefect_tendsto (hpos i j) (hle i j)

end StrictHotSpots.ScalarKernel





open Matrix Filter Complex
open scoped Topology ComplexOrder ENNReal
namespace StrictHotSpots.DiskKernel

abbrev Disk := {z : ℂ // ‖z‖ < 1}

def h (x y : Disk) : ℝ :=
  ‖(x : ℂ) - y‖ ^ 2 / ((1 - ‖(x : ℂ)‖ ^ 2) * (1 - ‖(y : ℂ)‖ ^ 2))

def logMean (t : ℝ) : ℝ := (Real.log (1 + 1 / t))⁻¹

def f (t : ℝ) : ℝ := t + 1 / 2 - logMean t


def green (x y : Disk) : ℝ :=
  (4 * Real.pi)⁻¹ * Real.log (1 + 1 / h x y)


def greenExtended (x y : Disk) : ℝ≥0∞ :=
  if x = y then ∞ else ENNReal.ofReal (green x y)


def regularized (ε : ℝ) (x y : Disk) : ℝ :=
  (4 * Real.pi * (h x y + 1 / 2 - (1 - ε) * f (h x y)))⁻¹

lemma disk_weight_pos (x : Disk) : 0 < 1 - ‖(x : ℂ)‖ ^ 2 := by
  have hn := norm_nonneg (x : ℂ)
  have hx := x.property
  nlinarith

lemma h_nonneg (x y : Disk) : 0 ≤ h x y :=
  div_nonneg (sq_nonneg _) (mul_pos (disk_weight_pos x) (disk_weight_pos y)).le

lemma h_pos {x y : Disk} (hxy : x ≠ y) : 0 < h x y := by
  apply div_pos _ (mul_pos (disk_weight_pos x) (disk_weight_pos y))
  exact sq_pos_of_pos (norm_pos_iff.mpr (sub_ne_zero.mpr (Subtype.coe_ne_coe.mpr hxy)))

@[simp] lemma h_self (x : Disk) : h x x = 0 := by simp [h]
@[simp] lemma logMean_zero : logMean 0 = 0 := by simp [logMean]
@[simp] lemma f_zero : f 0 = 1 / 2 := by simp [f]

lemma complex_posSemidef_of_entrywise_tendsto {ι : Type*} [Fintype ι]
    {A : ℕ → Matrix ι ι ℂ} {B : Matrix ι ι ℂ}
    (hA : ∀ n, (A n).PosSemidef)
    (hlim : ∀ i j, Tendsto (fun n => A n i j) atTop (𝓝 (B i j))) : B.PosSemidef := by
  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
  · ext i j
    have hl := (hlim j i).star
    exact tendsto_nhds_unique (hl.congr fun n => (hA n).isHermitian.apply i j) (hlim i j)
  · intro v
    have hq : Tendsto (fun n => star v ⬝ᵥ A n *ᵥ v) atTop (𝓝 (star v ⬝ᵥ B *ᵥ v)) := by
      unfold dotProduct Matrix.mulVec
      exact tendsto_finsetSum _ (fun i _ => tendsto_const_nhds.mul
        (tendsto_finsetSum _ fun j _ => (hlim i j).mul tendsto_const_nhds))
    exact ge_of_tendsto hq (Filter.Eventually.of_forall fun n =>
      (hA n).dotProduct_mulVec_nonneg v)


lemma szego_posSemidef {ι : Type*} [Fintype ι] (x : ι → Disk) :
    (Matrix.of (fun i j => (1 - (x i : ℂ) * star (x j : ℂ))⁻¹)).PosSemidef := by
  let A (n : ℕ) : Matrix ι ι ℂ :=
    Matrix.vecMulVec (fun i => (x i : ℂ) ^ n) (star (fun j => (x j : ℂ) ^ n))
  apply complex_posSemidef_of_entrywise_tendsto
    (A := fun n => ∑ m ∈ Finset.range n, A m)
  · intro n
    exact Matrix.posSemidef_sum _ (fun m _ => Matrix.posSemidef_vecMulVec_self_star _)
  · intro i j
    have hn : ‖(x i : ℂ) * star (x j : ℂ)‖ < 1 := by
      rw [norm_mul, norm_star]
      exact lt_of_le_of_lt
        (mul_le_mul_of_nonneg_left (x j).property.le (norm_nonneg _))
        (by simpa using (x i).property)
    have hs := (hasSum_geometric_of_norm_lt_one hn).tendsto_sum_nat
    simpa [A, Matrix.sum_apply, Matrix.vecMulVec, mul_pow] using hs

lemma realPart_posSemidef {ι : Type*} [Fintype ι] {A : Matrix ι ι ℂ}
    (hA : A.PosSemidef) : (Matrix.of (fun i j => (A i j).re)).PosSemidef := by
  apply Matrix.PosSemidef.of_dotProduct_mulVec_nonneg
  · ext i j
    have hh := congrArg Complex.re (hA.isHermitian.apply i j)
    simpa using hh
  · intro v
    have hh := (Complex.nonneg_iff.mp
      (hA.dotProduct_mulVec_nonneg (fun i => (v i : ℂ)))).1
    simpa [dotProduct, Matrix.mulVec, map_sum, Complex.mul_re] using hh

lemma disk_cross_identity (x y : ℂ) :
    ‖1 - x * star y‖ ^ 2 = (1 - ‖x‖ ^ 2) * (1 - ‖y‖ ^ 2) + ‖x - y‖ ^ 2 := by
  simp only [Complex.sq_norm, Complex.normSq_apply, Complex.sub_re, Complex.sub_im,
    Complex.mul_re, Complex.mul_im, Complex.one_re, Complex.one_im,
    Complex.star_def, Complex.conj_re, Complex.conj_im]
  ring

lemma normSzego_posSemidef {ι : Type*} [Fintype ι] (x : ι → Disk) :
    (Matrix.of (fun i j => (‖1 - (x i : ℂ) * star (x j : ℂ)‖ ^ 2)⁻¹)).PosSemidef := by
  have hh := realPart_posSemidef ((szego_posSemidef x).hadamard
    (szego_posSemidef x).transpose)
  convert hh using 1
  ext i j
  change _ = (((1 - (x i : ℂ) * star (x j : ℂ))⁻¹) *
    (1 - (x j : ℂ) * star (x i : ℂ))⁻¹).re
  rw [show 1 - (x j : ℂ) * star (x i : ℂ) =
    star (1 - (x i : ℂ) * star (x j : ℂ)) by simp [mul_comm]]
  rw [← star_inv₀, Complex.star_def, Complex.mul_conj]
  simp only [Matrix.of_apply, Complex.ofReal_re, Complex.normSq_eq_norm_sq, norm_inv, inv_pow]

lemma k_identity (x y : Disk) :
    (1 + h x y)⁻¹ = (1 - ‖(x : ℂ)‖ ^ 2) *
      (‖1 - (x : ℂ) * star (y : ℂ)‖ ^ 2)⁻¹ * (1 - ‖(y : ℂ)‖ ^ 2) := by
  rw [disk_cross_identity]
  unfold h
  have hx := disk_weight_pos x
  have hy := disk_weight_pos y
  have hn := sq_nonneg ‖(x : ℂ) - y‖
  field_simp

lemma k_posSemidef {ι : Type*} [Fintype ι] (x : ι → Disk) :
    (Matrix.of (fun i j => (1 + h (x i) (x j))⁻¹)).PosSemidef := by
  classical
  have hh := (normSzego_posSemidef x).mul_mul_conjTranspose_same
    (Matrix.diagonal (fun i => (1 - ‖(x i : ℂ)‖ ^ 2)))
  convert hh using 1
  ext i j
  simp [k_identity]

end StrictHotSpots.DiskKernel

namespace StrictHotSpots.DiskKernel

lemma f_eq_logDefect {t : ℝ} (ht : 0 ≤ t) :
    f t = ((1 + t)⁻¹)⁻¹ - 1 / 2 + (Real.log (1 - (1 + t)⁻¹))⁻¹ := by
  rcases eq_or_lt_of_le ht with he | hp
  · subst t
    norm_num [f, logMean]
  · have hh : 1 - (1 + t)⁻¹ = (1 + 1 / t)⁻¹ := by
      have : 1 + t ≠ 0 := by positivity
      field_simp
      ring
    rw [hh, Real.log_inv, inv_neg, inv_inv]
    simp only [f, logMean]
    ring

lemma f_posSemidef {ι : Type*} [Fintype ι] (x : ι → Disk) :
    (Matrix.of (fun i j => f (h (x i) (x j)))).PosSemidef := by
  have hh := ScalarKernel.logDefect_posSemidef_le (k_posSemidef x)
    (fun i j => inv_pos.mpr (by have := h_nonneg (x i) (x j); linarith))
    (fun i j => inv_le_one_of_one_le₀ (by have := h_nonneg (x i) (x j); linarith))
  simpa only [Matrix.of_apply, ← f_eq_logDefect (h_nonneg _ _)] using hh

lemma logMean_nonneg {t : ℝ} (ht : 0 ≤ t) : 0 ≤ logMean t := by
  apply inv_nonneg.mpr
  exact Real.log_nonneg (by have := one_div_nonneg.mpr ht; linarith)

lemma logMean_pos {t : ℝ} (ht : 0 < t) : 0 < logMean t := by
  apply inv_pos.mpr
  exact Real.log_pos (by have := one_div_pos.mpr ht; linarith)

lemma f_nonneg {t : ℝ} (ht : 0 ≤ t) : 0 ≤ f t := by
  rcases eq_or_lt_of_le ht with he | hp
  · subst t; rw [f_zero]; norm_num
  · have hlo := Real.le_log_one_add_of_nonneg (one_div_nonneg.mpr ht)
    have hi : 2 * (1 / t) / (1 / t + 2) = (t + 1 / 2)⁻¹ := by
      have : 1 / t + 2 ≠ 0 := by positivity
      have : t + 1 / 2 ≠ 0 := by positivity
      field_simp
      ring
    rw [hi] at hlo
    have hbound := (inv_le_inv₀ (lt_of_lt_of_le (by positivity : 0 < (t + 1 / 2)⁻¹) hlo)
      (by positivity : 0 < (t + 1 / 2)⁻¹)).mpr hlo
    simpa only [inv_inv, f, logMean, sub_nonneg] using hbound

lemma f_le_half {t : ℝ} (ht : 0 ≤ t) : f t ≤ 1 / 2 := by
  rcases eq_or_lt_of_le ht with he | hp
  · subst t; exact le_of_eq f_zero
  · have hlo := Real.log_le_sub_one_of_pos (by positivity : 0 < 1 + 1 / t)
    have hlog : 0 < Real.log (1 + 1 / t) := by
      exact Real.log_pos (by have := one_div_pos.mpr hp; linarith)
    have hbound := (inv_le_inv₀ (inv_pos.mpr hp) hlog).mpr
      (show Real.log (1 + 1 / t) ≤ t⁻¹ by
      simpa only [add_sub_cancel_left, one_div] using hlo)
    simp only [inv_inv] at hbound
    dsimp [f, logMean]
    linarith

end StrictHotSpots.DiskKernel

namespace StrictHotSpots.DiskKernel

lemma f_alt (t : ℝ) : f t = t + 1 / 2 + (Real.log (t / (1 + t)))⁻¹ := by
  by_cases ht : t = 0
  · subst t
    norm_num [f, logMean]
  · have he : 1 + 1 / t = (t / (1 + t))⁻¹ := by
      rw [inv_div]
      field_simp
      ring
    rw [f, logMean, he, Real.log_inv, inv_neg]
    ring

lemma f_continuousAt {t : ℝ} (ht : 0 ≤ t) : ContinuousAt f t := by
  rw [show f = fun t => t + 1 / 2 + (Real.log (t / (1 + t)))⁻¹ from funext f_alt]
  apply (continuousAt_id.add continuousAt_const).add
  have hden : 1 + t ≠ 0 := by positivity
  have hquot : ContinuousAt (fun t : ℝ => t / (1 + t)) t :=
    continuousAt_id.div (continuousAt_const.add continuousAt_id) hden
  rcases eq_or_lt_of_le ht with he | hp
  · subst t
    exact ScalarKernel.invLog_continuousAt_zero.comp_of_eq hquot (by simp)
  · have hq : 0 < t / (1 + t) := div_pos hp (by positivity)
    have hql : t / (1 + t) < 1 := (div_lt_one (by positivity)).mpr (by linarith)
    exact ((Real.continuousAt_log hq.ne').comp (f := fun t : ℝ => t / (1 + t)) hquot).inv₀
      (ne_of_lt (Real.log_neg hq hql))

lemma h_continuous : Continuous (fun p : Disk × Disk => h p.1 p.2) := by
  apply ((continuous_subtype_val.comp continuous_fst).sub
    (continuous_subtype_val.comp continuous_snd)).norm.pow 2 |>.div
  · exact (continuous_const.sub ((continuous_subtype_val.comp continuous_fst).norm.pow 2)).mul
      (continuous_const.sub ((continuous_subtype_val.comp continuous_snd).norm.pow 2))
  · intro p
    exact (mul_pos (disk_weight_pos p.1) (disk_weight_pos p.2)).ne'

lemma regularized_denominator {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) (x y : Disk) :
    ε / 2 ≤ h x y + 1 / 2 - (1 - ε) * f (h x y) := by
  have ht := h_nonneg x y
  have hl := logMean_nonneg ht
  have he : h x y + 1 / 2 - (1 - ε) * f (h x y) =
      ε * (h x y + 1 / 2) + (1 - ε) * logMean (h x y) := by
    dsimp [f]; ring
  rw [he]
  nlinarith [mul_nonneg hε.le ht, mul_nonneg (sub_nonneg.mpr hε1) hl]

lemma regularized_pos {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) (x y : Disk) :
    0 < regularized ε x y := by
  apply inv_pos.mpr
  exact mul_pos (mul_pos (by norm_num) Real.pi_pos)
    (lt_of_lt_of_le (by positivity : 0 < ε / 2) (regularized_denominator hε hε1 x y))

lemma regularized_le {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) (x y : Disk) :
    regularized ε x y ≤ (2 * Real.pi * ε)⁻¹ := by
  apply inv_anti₀ (by positivity)
  have hh := mul_le_mul_of_nonneg_left (regularized_denominator hε hε1 x y)
    (le_of_lt (mul_pos (by norm_num : 0 < (4 : ℝ)) Real.pi_pos))
  nlinarith

lemma regularized_continuous {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
    Continuous (fun p : Disk × Disk => regularized ε p.1 p.2) := by
  have hf : Continuous (fun p : Disk × Disk => f (h p.1 p.2)) :=
    continuous_iff_continuousAt.mpr fun p =>
      (f_continuousAt (h_nonneg p.1 p.2)).comp
        (f := fun p : Disk × Disk => h p.1 p.2) h_continuous.continuousAt
  apply (continuous_const.mul ((h_continuous.add continuous_const).sub
    (continuous_const.mul hf))).inv₀
  intro p
  exact (mul_pos (mul_pos (by norm_num) Real.pi_pos)
    (lt_of_lt_of_le (by positivity : 0 < ε / 2)
      (regularized_denominator hε hε1 p.1 p.2))).ne'

lemma regularized_self (ε : ℝ) (x : Disk) :
    regularized ε x x = (2 * Real.pi * ε)⁻¹ := by
  rw [regularized, h_self, f_zero]
  congr 1
  ring

lemma regularized_antitone {ε δ : ℝ} (hε : 0 < ε) (hδ : ε ≤ δ) (hδ1 : δ ≤ 1)
    (x y : Disk) : regularized δ x y ≤ regularized ε x y := by
  apply inv_anti₀
  · exact mul_pos (mul_pos (by norm_num) Real.pi_pos)
      (lt_of_lt_of_le (by positivity : 0 < ε / 2)
        (regularized_denominator hε (hδ.trans hδ1) x y))
  · apply mul_le_mul_of_nonneg_left _ (by positivity : 0 ≤ 4 * Real.pi)
    nlinarith [mul_nonneg (sub_nonneg.mpr hδ) (f_nonneg (h_nonneg x y))]

lemma regularized_tendsto_offDiagonal {x y : Disk} (hxy : x ≠ y) :
    Tendsto (fun ε : ℝ => regularized ε x y) (𝓝 0) (𝓝 (green x y)) := by
  have hl := logMean_pos (h_pos hxy)
  have hh : ContinuousAt (fun ε : ℝ => regularized ε x y) 0 := by
    apply (continuousAt_const.mul (continuousAt_const.sub
      ((continuousAt_const.sub continuousAt_id).mul continuousAt_const))).inv₀
    have he : h x y + 1 / 2 - (1 - (0 : ℝ)) * f (h x y) = logMean (h x y) := by
      dsimp [f]; ring
    change 4 * Real.pi * (h x y + 1 / 2 - (1 - (0 : ℝ)) * f (h x y)) ≠ 0
    rw [he]
    positivity
  convert hh.tendsto using 1
  congr 1
  dsimp [regularized, f, logMean, green]
  rw [show h x y + 1 / 2 - (1 - (0 : ℝ)) *
      (h x y + 1 / 2 - (Real.log (1 + 1 / h x y))⁻¹) =
        (Real.log (1 + 1 / h x y))⁻¹ by ring]
  simp only [_root_.mul_inv_rev, inv_inv]
  ring

end StrictHotSpots.DiskKernel




namespace ReciprocalKernel
open Matrix
variable {ι : Type*} [Fintype ι]

lemma onePositiveSquare_smul {A : Matrix ι ι ℝ} (hA : OnePositiveSquare A)
    {a : ℝ} (ha : 0 < a) : OnePositiveSquare (a • A) := by
  have he (x y : ι → ℝ) : pairing (a • A) x y = a * pairing A x y := by
    simp [pairing, Matrix.smul_mulVec, dotProduct_smul]
  refine ⟨?_, ?_⟩
  · ext i j
    simpa only [Matrix.transpose_apply, Matrix.smul_apply, smul_eq_mul] using
      congrArg (a * ·) (hA.1.apply i j)
  · intro x y hx hxy
    rw [he] at hx hxy ⊢
    exact mul_nonpos_of_nonneg_of_nonpos ha.le
      (hA.2 x y ((mul_pos_iff_of_pos_left ha).mp hx)
        ((mul_eq_zero.mp hxy).resolve_left ha.ne'))

end ReciprocalKernel

namespace StrictHotSpots.DiskKernel
open ReciprocalKernel

lemma lorentz_identity (x y : Disk) :
    (1 - ‖(x : ℂ)‖ ^ 2) * (h x y + 1 / 2) * (1 - ‖(y : ℂ)‖ ^ 2) =
      (1 / 2) * (1 + ‖(x : ℂ)‖ ^ 2) * (1 + ‖(y : ℂ)‖ ^ 2) -
        2 * ((x : ℂ) * star (y : ℂ)).re := by
  have hx := (disk_weight_pos x).ne'
  have hy := (disk_weight_pos y).ne'
  dsimp [h]
  field_simp
  simp only [Complex.sq_norm, Complex.normSq_apply, Complex.sub_re, Complex.sub_im,
    Complex.mul_re, Complex.conj_re, Complex.conj_im]
  ring

lemma regularized_reciprocal_onePositiveSquare {ι : Type*} [Fintype ι]
    (x : ι → Disk) {ε : ℝ} (hε1 : ε ≤ 1) :
    OnePositiveSquare (Matrix.of (fun i j => (regularized ε (x i) (x j))⁻¹)) := by
  classical
  let w : ι → ℝ := fun i => 1 - ‖(x i : ℂ)‖ ^ 2
  let v : ι → ℝ := fun i => Real.sqrt (1 / 2) * (1 + ‖(x i : ℂ)‖ ^ 2)
  let G : Matrix ι ι ℝ := Matrix.of fun i j => ((x i : ℂ) * star (x j : ℂ)).re
  let F : Matrix ι ι ℝ := Matrix.of fun i j => f (h (x i) (x j))
  have hG : G.PosSemidef := realPart_posSemidef
    (Matrix.posSemidef_vecMulVec_self_star (fun i => (x i : ℂ)))
  have hF : (Matrix.diagonal w * F * (Matrix.diagonal w).conjTranspose).PosSemidef :=
    (f_posSemidef x).mul_mul_conjTranspose_same _
  have hU := (hG.smul (by norm_num : 0 ≤ (2 : ℝ))).add (hF.smul (sub_nonneg.mpr hε1))
  have hP := onePositiveSquare_rankOne_sub_psd v hU
  have hsqrt : Real.sqrt (1 / 2) * Real.sqrt (1 / 2) = (1 / 2 : ℝ) :=
    Real.mul_self_sqrt (by norm_num)
  have hn : Matrix.vecMulVec v v - ((2 : ℝ) • G + (1 - ε) •
      (Matrix.diagonal w * F * (Matrix.diagonal w).conjTranspose)) =
      Matrix.of (fun i j => w i *
        (h (x i) (x j) + 1 / 2 - (1 - ε) * f (h (x i) (x j))) * w j) := by
    ext i j
    simp only [Matrix.sub_apply, Matrix.vecMulVec_apply, Matrix.add_apply,
      Matrix.smul_apply, smul_eq_mul, Matrix.diagonal_conjTranspose,
      star_trivial, Matrix.diagonal_mul, Matrix.mul_diagonal, Matrix.of_apply]
    dsimp [v, G, F]
    have hv : Real.sqrt (1 / 2) * (1 + ‖(x i : ℂ)‖ ^ 2) *
        (Real.sqrt (1 / 2) * (1 + ‖(x j : ℂ)‖ ^ 2)) =
        (1 / 2) * (1 + ‖(x i : ℂ)‖ ^ 2) * (1 + ‖(x j : ℂ)‖ ^ 2) := by
      calc
        _ = (Real.sqrt (1 / 2) * Real.sqrt (1 / 2)) *
            (1 + ‖(x i : ℂ)‖ ^ 2) * (1 + ‖(x j : ℂ)‖ ^ 2) := by ring
        _ = _ := by rw [hsqrt]
    rw [hv]
    have hh := lorentz_identity (x i) (x j)
    dsimp [w]
    simp only [starRingEnd_apply]
    rw [sub_add_eq_sub_sub, ← hh]
    ring
  rw [hn] at hP
  have hres := onePositiveSquare_smul (onePositiveSquare_scale hP (fun i => (w i)⁻¹))
    (mul_pos (by norm_num : 0 < (4 : ℝ)) Real.pi_pos)
  convert hres using 1
  ext i j
  simp only [Matrix.of_apply, Matrix.smul_apply, smul_eq_mul, regularized, inv_inv]
  have hi := (disk_weight_pos (x i)).ne'
  have hj := (disk_weight_pos (x j)).ne'
  dsimp [w]
  field_simp

end StrictHotSpots.DiskKernel

namespace StrictHotSpots.DiskKernel

lemma regularized_zero (x y : Disk) : regularized 0 x y = green x y := by
  dsimp [regularized, green, f, logMean]
  rw [show h x y + 1 / 2 - (1 - (0 : ℝ)) *
      (h x y + 1 / 2 - (Real.log (1 + 1 / h x y))⁻¹) =
        (Real.log (1 + 1 / h x y))⁻¹ by ring]
  simp only [_root_.mul_inv_rev, inv_inv]
  ring

lemma regularized_le_green {ε : ℝ} (hε : 0 ≤ ε) {x y : Disk} (hxy : x ≠ y) :
    regularized ε x y ≤ green x y := by
  rw [← regularized_zero]
  apply inv_anti₀
  · have hh := logMean_pos (h_pos hxy)
    have he : h x y + 1 / 2 - (1 - (0 : ℝ)) * f (h x y) = logMean (h x y) := by
      dsimp [f]; ring
    rw [he]
    positivity
  · apply mul_le_mul_of_nonneg_left _ (by positivity : 0 ≤ 4 * Real.pi)
    nlinarith [mul_nonneg hε (f_nonneg (h_nonneg x y))]

lemma regularized_tendsto_diagonal (x : Disk) :
    Tendsto (fun ε : ℝ => regularized ε x x) (𝓝[>] 0) atTop := by
  simp only [regularized_self]
  have hh := tendsto_inv_nhdsGT_zero.const_mul_atTop
    (by positivity : 0 < (2 * Real.pi)⁻¹)
  simpa only [_root_.mul_inv_rev, mul_comm] using hh


lemma regularized_tendsto (x y : Disk) :
    Tendsto (fun ε : ℝ => ENNReal.ofReal (regularized ε x y))
      (𝓝[>] 0) (𝓝 (greenExtended x y)) := by
  by_cases hxy : x = y
  · subst y
    simpa [greenExtended, Function.comp_def] using
      ENNReal.tendsto_ofReal_atTop.comp (regularized_tendsto_diagonal x)
  · simpa only [greenExtended, ite_eq_right hxy, Function.comp_def] using
      (ENNReal.continuous_ofReal.tendsto (green x y)).comp
        ((regularized_tendsto_offDiagonal hxy).mono_left nhdsWithin_le_nhds)


theorem bounded_green_regularization :
    ∃ C : ℝ → Disk → Disk → ℝ,
      (∀ ε ∈ Set.Ioc (0 : ℝ) 1,
        Continuous (fun p : Disk × Disk => C ε p.1 p.2) ∧
        (∀ x y, 0 < C ε x y ∧ C ε x y ≤ (2 * Real.pi * ε)⁻¹) ∧
        (∀ {ι : Type} [Fintype ι] (x : ι → Disk),
          ReciprocalKernel.OnePositiveSquare (Matrix.of (fun i j => (C ε (x i) (x j))⁻¹)))) ∧
      (∀ ε δ, 0 < ε → ε ≤ δ → δ ≤ 1 → ∀ x y, C δ x y ≤ C ε x y) ∧
      (∀ x y, Tendsto (fun ε => ENNReal.ofReal (C ε x y))
        (𝓝[>] 0) (𝓝 (greenExtended x y))) := by
  refine ⟨regularized, ?_, ?_, regularized_tendsto⟩
  · intro ε hε
    exact ⟨regularized_continuous hε.1 hε.2,
      fun x y => ⟨regularized_pos hε.1 hε.2 x y, regularized_le hε.1 hε.2 x y⟩,
      fun {_} [_] x => regularized_reciprocal_onePositiveSquare x hε.2⟩
  · intro ε δ hε hεδ hδ
    exact regularized_antitone hε hεδ hδ

end StrictHotSpots.DiskKernel
end DiskFiniteLayer


end FullBoundaryCombinedLayer

end

end DouglasLipschitzBase

end OAI