import OAI.Analysis.DirectCrouzeix.DiskMapping

namespace OAI

noncomputable section

open scoped Matrix Matrix.Norms.L2Operator Kronecker

noncomputable section

open MeasureTheory Set Filter Metric

open scoped Topology Interval ENNReal NNReal ComplexConjugate

noncomputable section

open Filter Metric Set

open scoped Topology ComplexConjugate

namespace DirectCrouzeix

namespace Conformal

open Function Complex

open scoped Pointwise

open InnerProductSpace Real

def poissonExtension (R : ℝ) (u : ℂ → ℝ) (z : ℂ) : ℝ :=
  Real.circleAverage (fun ζ => poissonKernel 0 z ζ * u ζ) 0 R

theorem poisson_continuous_circle {R : ℝ} {z : ℂ} (hz : z ∈ ball 0 R) :
    ContinuousOn (poissonKernel 0 z) (sphere 0 |R|) := by
  rw [poissonKernel_eq_re_herglotzRieszKernel]
  exact Complex.continuous_re.comp_continuousOn
    (continuousOn_herglotzRieszKernel_sphere
      (by simpa using ne_of_lt ((mem_ball_zero_iff.mp hz).trans_le (le_abs_self R))))

theorem poisson_nonnegative_circle {R : ℝ} {z ζ : ℂ}
    (hz : z ∈ ball 0 R) (hζ : ζ ∈ sphere 0 R) : 0 ≤ poissonKernel 0 z ζ := by
  have hz' := mem_ball_zero_iff.mp hz
  have hζ' : ‖ζ‖ = R := by simpa using hζ
  dsimp [poissonKernel]
  simp only [sub_zero]
  apply div_nonneg _ (sq_nonneg _)
  nlinarith [norm_nonneg z]

theorem poisson_average_one {R : ℝ} {z : ℂ} (hz : z ∈ ball 0 R) :
    Real.circleAverage (poissonKernel 0 z) 0 R = 1 := by
  simpa only [Pi.smul_def, Pi.mul_def, smul_eq_mul, mul_one] using (harmonicContOnCl_const (c := (1 : ℝ))
    (s := ball 0 R)).circleAverage_poissonKernel_smul hz

theorem poisson_boundary_limit {R : ℝ} (hR : 0 < R) {u : ℂ → ℝ}
    (hu : ContinuousOn u (sphere 0 R)) {p : ℂ} (hp : p ∈ sphere 0 R) :
    Tendsto (poissonExtension R u) (𝓝[ball 0 R] p) (𝓝 (u p)) := by
  have hp' : ‖p‖ = R := by simpa using hp
  have huabs : ContinuousOn (fun ζ => |u ζ - u p|) (sphere 0 R) :=
    (hu.sub continuousOn_const).abs
  obtain ⟨M, hM⟩ := (isCompact_sphere (0 : ℂ) R).exists_bound_of_continuousOn huabs
  have hM0 : 0 ≤ M := (norm_nonneg (|u p - u p|)).trans (hM p hp)
  have hbound : ∀ ζ ∈ sphere 0 R, |u ζ - u p| ≤ M := by
    intro ζ hζ
    simpa only [Real.norm_eq_abs, abs_abs] using hM ζ hζ
  rw [Metric.tendsto_nhds]
  intro ε hε
  obtain ⟨δ, hδ, hd⟩ := Metric.continuousWithinAt_iff.mp (hu p hp) (ε / 2) (half_pos hε)
  let C := 4 * M / δ ^ 2
  have hC : 0 ≤ C := by dsimp [C]; positivity
  have hnear : ∀ᶠ z in 𝓝[ball 0 R] p, dist z p < δ / 2 :=
    (show ∀ᶠ z in 𝓝 p, dist z p < δ / 2 from ball_mem_nhds p (half_pos hδ)).filter_mono nhdsWithin_le_nhds
  have hsmall : ∀ᶠ z in 𝓝[ball 0 R] p, C * (R ^ 2 - ‖z‖ ^ 2) < ε / 2 := by
    have ht : Tendsto (fun z : ℂ => C * (R ^ 2 - ‖z‖ ^ 2)) (𝓝 p) (𝓝 0) := by
      simpa only [hp', sub_self, mul_zero] using
        ((show Continuous (fun z : ℂ => C * (R ^ 2 - ‖z‖ ^ 2)) from by fun_prop).tendsto p)
    exact (ht.eventually (gt_mem_nhds (half_pos hε))).filter_mono nhdsWithin_le_nhds
  filter_upwards [hnear, hsmall, self_mem_nhdsWithin] with z hz hzs hzU
  have hP : ContinuousOn (poissonKernel 0 z) (sphere 0 R) := by
    simpa only [abs_of_pos hR] using poisson_continuous_circle hzU
  have hn (ζ : ℂ) (hζ : ζ ∈ sphere 0 R) := poisson_nonnegative_circle hzU hζ
  have hL : 0 ≤ R ^ 2 - ‖z‖ ^ 2 := by
    have hh := mem_ball_zero_iff.mp hzU
    nlinarith [norm_nonneg z]
  have hest : ∀ ζ ∈ sphere 0 R,
      poissonKernel 0 z ζ * |u ζ - u p| ≤
        poissonKernel 0 z ζ * (ε / 2) + C * (R ^ 2 - ‖z‖ ^ 2) := by
    intro ζ hζ
    by_cases hclose : dist ζ p < δ
    · have hd' : |u ζ - u p| < ε / 2 := by
        simpa only [Real.dist_eq] using hd hζ hclose
      have hh := mul_le_mul_of_nonneg_left hd'.le (hn ζ hζ)
      have hh' : 0 ≤ C * (R ^ 2 - ‖z‖ ^ 2) := mul_nonneg hC hL
      linarith
    · have hζnorm : ‖ζ‖ = R := by simpa using hζ
      have hdist : δ / 2 ≤ ‖ζ - z‖ := by
        have hh := dist_triangle ζ z p
        rw [dist_eq_norm ζ z] at hh
        linarith [le_of_not_gt hclose]
      have hden : 0 < ‖ζ - z‖ ^ 2 := sq_pos_of_pos ((half_pos hδ).trans_le hdist)
      have hpk : poissonKernel 0 z ζ ≤ 4 * (R ^ 2 - ‖z‖ ^ 2) / δ ^ 2 := by
        dsimp [poissonKernel]
        simp only [sub_zero, hζnorm]
        rw [div_le_div_iff₀ hden (sq_pos_of_pos hδ)]
        have hden' : δ ^ 2 ≤ 4 * ‖ζ - z‖ ^ 2 := by nlinarith
        nlinarith [mul_nonneg hL (sub_nonneg.mpr hden')]
      have hh := mul_le_mul (hbound ζ hζ) hpk (hn ζ hζ) hM0
      have hright : 0 ≤ poissonKernel 0 z ζ * (ε / 2) := mul_nonneg (hn ζ hζ) (half_pos hε).le
      dsimp [C]
      have halg : M * (4 * (R ^ 2 - ‖z‖ ^ 2) / δ ^ 2) =
          4 * M / δ ^ 2 * (R ^ 2 - ‖z‖ ^ 2) := by ring
      rw [mul_comm |u ζ - u p|, halg] at hh
      linarith
  have hi : CircleIntegrable (fun ζ => poissonKernel 0 z ζ * (u ζ - u p)) 0 R :=
    (hP.mul (hu.sub continuousOn_const)).circleIntegrable hR.le
  have heq : poissonExtension R u z - u p =
      Real.circleAverage (fun ζ => poissonKernel 0 z ζ * (u ζ - u p)) 0 R := by
    dsimp [poissonExtension]
    have ht := Real.circleAverage_fun_sub
      (f₁ := fun ζ => poissonKernel 0 z ζ * u ζ)
      (f₂ := fun ζ => poissonKernel 0 z ζ * u p)
      ((hP.mul hu).circleIntegrable hR.le)
      ((hP.mul_const (u p)).circleIntegrable hR.le)
    simp_rw [mul_sub]
    rw [ht]
    congr 1
    simp_rw [mul_comm _ (u p), ← smul_eq_mul]
    rw [Real.circleAverage_fun_smul, poisson_average_one hzU, smul_eq_mul, mul_one]
  rw [Real.dist_eq, heq]
  calc
    |Real.circleAverage (fun ζ => poissonKernel 0 z ζ * (u ζ - u p)) 0 R|
        ≤ Real.circleAverage (fun ζ => |poissonKernel 0 z ζ * (u ζ - u p)|) 0 R :=
      Real.abs_circleAverage_le_circleAverage_abs
    _ ≤ Real.circleAverage
        (fun ζ => poissonKernel 0 z ζ * (ε / 2) + C * (R ^ 2 - ‖z‖ ^ 2)) 0 R := by
      apply Real.circleAverage_mono hi.abs
        (((hP.mul_const (ε / 2)).add_const _).circleIntegrable hR.le)
      intro ζ hζ
      have hζ' : ζ ∈ sphere 0 R := by simpa only [abs_of_pos hR] using hζ
      change |poissonKernel 0 z ζ * (u ζ - u p)| ≤ _
      rw [abs_mul, abs_of_nonneg (hn ζ hζ')]
      exact hest ζ hζ'
    _ = ε / 2 + C * (R ^ 2 - ‖z‖ ^ 2) := by
      rw [Real.circleAverage_fun_add ((hP.mul_const (ε / 2)).circleIntegrable hR.le)
        (by exact continuousOn_const.circleIntegrable hR.le), Real.circleAverage_const]
      congr 1
      simp_rw [mul_comm _ (ε / 2), ← smul_eq_mul]
      rw [Real.circleAverage_fun_smul, poisson_average_one hzU, smul_eq_mul, mul_one]
    _ < ε := by linarith

theorem harmonic_eventually_eq_of_isLocalMax {u : ℂ → ℝ} {a : ℂ}
    (hu : HarmonicAt u a) (hm : IsLocalMax u a) :
    u =ᶠ[𝓝 a] (fun _ => u a) := by
  obtain ⟨r, hr, hB⟩ := Metric.isOpen_iff.mp (isOpen_setOfPred_harmonicAt u) a hu
  obtain ⟨F, hF, hRe⟩ := (show HarmonicOnNhd u (ball a r) from hB).exists_analyticOnNhd_ball_re_eq
  have hd : ∀ᶠ z in 𝓝 a, DifferentiableAt ℂ (fun z => Complex.exp (F z)) z := by
    filter_upwards [ball_mem_nhds a hr] with z hz
    exact (hF z hz).differentiableAt.cexp
  have hmax : IsLocalMax (norm ∘ (fun z => Complex.exp (F z))) a := by
    filter_upwards [hm, ball_mem_nhds a hr] with z hz hzB
    simpa only [Function.comp_apply, Complex.norm_exp, hRe hzB,
      hRe (mem_ball_self hr), Real.exp_le_exp] using hz
  have he := Complex.norm_eventually_eq_of_isLocalMax hd hmax
  filter_upwards [he, ball_mem_nhds a hr] with z hz hzB
  simpa only [Complex.norm_exp, hRe hzB, hRe (mem_ball_self hr), Real.exp_eq_exp] using hz

theorem harmonic_le_boundary {U : Set ℂ} (hU : IsOpen U)
    (hb : Bornology.IsBounded U) {u : ℂ → ℝ}
    (hu : HarmonicContOnCl u U) {M : ℝ}
    (hM : ∀ z ∈ frontier U, u z ≤ M) :
    ∀ z ∈ closure U, u z ≤ M := by
  intro z hz
  by_contra hle
  obtain ⟨a, ha, hmax⟩ := hb.isCompact_closure.exists_isMaxOn ⟨z, hz⟩ hu.2
  have hhigh : M < u a := (lt_of_not_ge hle).trans_le (hmax hz)
  let S := {x ∈ closure U | u x = u a}
  have hSc : IsCompact S := by
    exact hb.isCompact_closure.of_isClosed_subset
      (hu.2.preimage_isClosed_of_isClosed isClosed_closure isClosed_singleton) (by intro x hx; exact hx.1)
  have hSo : IsOpen S := by
    rw [isOpen_iff_mem_nhds]
    intro x hx
    have hxU : x ∈ U := by
      by_contra hn
      have hf : x ∈ frontier U := by
        rw [frontier, hU.interior_eq]
        exact ⟨hx.1, hn⟩
      exact (not_le_of_gt hhigh) (hx.2 ▸ hM x hf)
    have hxmax : IsLocalMax u x := by
      filter_upwards [hU.mem_nhds hxU] with y hy
      exact hx.2 ▸ hmax (subset_closure hy)
    have he := harmonic_eventually_eq_of_isLocalMax (hu.1 x hxU) hxmax
    filter_upwards [he, hU.mem_nhds hxU] with y hy hyU
    exact ⟨subset_closure hyU, hy.trans hx.2⟩
  have hSne : S.Nonempty := ⟨a, ha, rfl⟩
  have hSun : S = univ := (show IsClopen S from ⟨hSc.isClosed, hSo⟩).eq_univ hSne
  exact hSc.ne_univ hSun

def herglotzExtension (R : ℝ) (u : ℂ → ℝ) (z : ℂ) : ℂ :=
  Real.circleAverage (fun ζ => herglotzRieszKernel 0 z ζ * (u ζ : ℂ)) 0 R

theorem herglotz_analytic {R : ℝ} (hR : 0 ≤ R) {u : ℂ → ℝ}
    (hu : ContinuousOn u (sphere 0 R)) :
    AnalyticOnNhd ℂ (herglotzExtension R u) (ball 0 R) := by
  exact (analyticOnNhd_circleAverage_herglotzRieszKernel_smul
    ((Complex.continuous_ofReal.comp_continuousOn hu).circleIntegrable hR)).mono
      (by intro z hz; simpa [abs_of_nonneg hR] using ne_of_lt (mem_ball_zero_iff.mp hz))

theorem herglotz_re {R : ℝ} (hR : 0 ≤ R) {u : ℂ → ℝ}
    (hu : ContinuousOn u (sphere 0 R)) {z : ℂ} (hz : z ∈ ball 0 R) :
    (herglotzExtension R u z).re = poissonExtension R u z := by
  have hi : CircleIntegrable
      (fun ζ => herglotzRieszKernel 0 z ζ * (u ζ : ℂ)) 0 R := by
    exact ((continuousOn_herglotzRieszKernel_sphere
      (by simpa [abs_of_nonneg hR] using ne_of_lt (mem_ball_zero_iff.mp hz))).mul
      (Complex.continuous_ofReal.comp_continuousOn (by simpa only [abs_of_nonneg hR] using hu))).circleIntegrable'
  change Complex.reCLM (Real.circleAverage (fun ζ => herglotzRieszKernel 0 z ζ * (u ζ : ℂ)) 0 R) = _
  rw [← Complex.reCLM.circleAverage_comp_comm hi]
  dsimp [poissonExtension]
  congr 1
  ext ζ
  simp [poissonKernel_eq_re_herglotzRieszKernel]

theorem poisson_harmonic {R : ℝ} (hR : 0 ≤ R) {u : ℂ → ℝ}
    (hu : ContinuousOn u (sphere 0 R)) :
    HarmonicOnNhd (poissonExtension R u) (ball 0 R) := by
  intro z hz
  have he : (poissonExtension R u) =ᶠ[𝓝 z]
      (fun w => (herglotzExtension R u w).re) := by
    filter_upwards [isOpen_ball.mem_nhds hz] with w hw
    exact (herglotz_re hR hu hw).symm
  rw [harmonicAt_congr_nhds he]
  exact ((herglotz_analytic hR hu z hz).harmonicAt.comp_CLM Complex.reCLM)

end Conformal

end DirectCrouzeix

end

end

end

end OAI