Blame for lean/OAI/Analysis/DirectCrouzeix/BoundaryKernel.lean

import OAI.Analysis.DirectCrouzeix.FaberPolynomials

namespace OAI

universe u_108 u_109 u_110 u_111 u_112 u_113 u_114 u_115 u_116

noncomputable section

open scoped Matrix Matrix.Norms.L2Operator Kronecker

noncomputable section

open MeasureTheory Set Filter Metric

open scoped Topology Interval ENNReal NNReal ComplexConjugate

namespace DirectCrouzeix.Faber

theorem continuous_circle_integral {α : Type u_108} {E : Type u_109} [TopologicalSpace α]
    [FirstCountableTopology α] [LocallyCompactSpace α]
    [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : α → Angle → E} (hf : Continuous f.uncurry) :
    Continuous (fun x => ∫ t, f x t ∂angularMeasure) := by
  simpa using continuous_parametric_integral_of_continuous (μ := angularMeasure) hf isCompact_univ

theorem continuous_slice_left {α : Type u_110} {β : Type u_111} {E : Type u_112}
    [TopologicalSpace α] [TopologicalSpace β]
    [TopologicalSpace E] (f : α → β → E) (hf : Continuous f.uncurry) (y : β) :
    Continuous (fun x => f x y) := by
  simpa only [Function.comp_def,Function.uncurry] using! hf.comp (continuous_id.prodMk continuous_const)

theorem continuous_slice_right {α : Type u_113} {β : Type u_114} {E : Type u_115}
    [TopologicalSpace α] [TopologicalSpace β]
    [TopologicalSpace E] (f : α → β → E) (hf : Continuous f.uncurry) (x : α) :
    Continuous (f x) := by
  simpa only [Function.comp_def,Function.uncurry] using! hf.comp (continuous_const.prodMk continuous_id)

theorem fourierCoeff_integral_swap {E : Type u_116} [NormedAddCommGroup E]
    [NormedSpace ℂ E] [CompleteSpace E] (f : Angle → Angle → E)
    (hf : Continuous f.uncurry) (k : ℤ) :
    fourierCoeff (fun s => ∫ t, f t s ∂angularMeasure) k =
      ∫ t, fourierCoeff (f t) k ∂angularMeasure := by
  unfold fourierCoeff
  simp_rw [← integral_smul]
  apply (integral_integral_swap _).symm
  exact integrable_of_continuous_compact _
    (((fourier (-k)).continuous.comp continuous_snd).smul hf)

theorem fourierCoeff_conjugate (f : Angle → ℂ) (k : ℤ) :
    fourierCoeff (fun t => conj (f t)) k = conj (fourierCoeff f (-k)) := by
  unfold fourierCoeff
  rw [← integral_conj]
  apply integral_congr_ae
  filter_upwards with t
  simp []

def boundary (c : ℂ) (g : ℂ → ℂ) (t : Angle) : ℂ := exterior c g (unitPoint t)

def boundaryCorrection (c : ℂ) (g : ℂ → ℂ) (t s : Angle) : ℂ :=
  correction c g ((unitPoint t)⁻¹) ((unitPoint s)⁻¹)

def boundaryCoefficient (c : ℂ) (g : ℂ → ℂ) (k : ℕ) (s : Angle) : ℂ :=
  fourierCoeff (fun t => boundaryCorrection c g t s) (-(k:ℤ))

def boundaryKernel (c : ℂ) (g : ℂ → ℂ) (t s : Angle) : ℝ :=
  1 + 2*(boundaryCorrection c g t s).re

theorem unitPoint_ne_zero (t : Angle) : unitPoint t ≠ 0 := by
  exact norm_ne_zero_iff.mp (by rw [unitPoint_norm]; norm_num)

theorem unitPoint_inv_mem {R : ℝ} (hR : 1 < R) (t : Angle) :
    (unitPoint t)⁻¹ ∈ ball (0:ℂ) R := by
  simpa only [mem_ball,dist_zero_right,norm_inv,unitPoint_norm,inv_one] using hR

theorem continuous_boundary {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) (c : ℂ) : Continuous (boundary c g) := by
  have hi : Continuous (fun t => (unitPoint t)⁻¹) := unitPoint_continuous.inv₀ unitPoint_ne_zero
  exact (continuous_const.mul unitPoint_continuous).add
    (hg.continuousOn.comp_continuous hi (unitPoint_inv_mem hR))

theorem continuous_boundaryCorrection {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0) :
    Continuous (boundaryCorrection c g).uncurry := by
  have hi : Continuous (fun t => (unitPoint t)⁻¹) := unitPoint_continuous.inv₀ unitPoint_ne_zero
  let f : Angle × Angle → ℂ × ℂ := fun p => ((unitPoint p.1)⁻¹,(unitPoint p.2)⁻¹)
  have hf : Continuous f := (hi.comp continuous_fst).prodMk (hi.comp continuous_snd)
  have hmaps : MapsTo f univ (ball 0 R ×ˢ ball 0 R) :=
    fun p _ => ⟨unitPoint_inv_mem hR p.1,unitPoint_inv_mem hR p.2⟩
  have he : (boundaryCorrection c g).uncurry = (fun p : ℂ × ℂ => correction c g p.1 p.2) ∘ f := rfl
  rw [he]
  exact (continuousOn_correction isOpen_ball (convex_ball 0 R) hg hH).comp_continuous hf
    (fun p => hmaps (mem_univ p))

theorem continuous_boundaryCoefficient {c : ℂ} {g : ℂ → ℂ}
    (hS : Continuous (boundaryCorrection c g).uncurry) (k : ℕ) :
    Continuous (boundaryCoefficient c g k) := by
  have hs : Continuous (fun p : Angle × Angle => boundaryCorrection c g p.2 p.1) := by
    simpa only [Function.uncurry,Function.comp_def] using! hS.comp continuous_swap
  have hf : Continuous (fun p : Angle × Angle => fourier (-(-(k:ℤ))) p.2) :=
    (fourier (-(-(k:ℤ)))).continuous.comp continuous_snd
  have hh := continuous_circle_integral (f := fun s t => fourier (-(-(k:ℤ))) t • boundaryCorrection c g t s)
    (hf.smul hs)
  exact hh

theorem boundaryCorrection_left_coeff {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0)
    (s : Angle) (j : ℤ) :
    fourierCoeff (fun t => boundaryCorrection c g t s) j =
      if j ≤ 0 then taylorCoeff (fun u => correction c g u ((unitPoint s)⁻¹)) (-j).toNat else 0 := by
  exact fourierCoeff_of_antianalytic hR
    (analyticOnNhd_correction_left isOpen_ball (convex_ball 0 R) hg (unitPoint_inv_mem hR s)
      (fun u hu => hH u hu _ (unitPoint_inv_mem hR s))) j

theorem boundaryCorrection_right_coeff {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0)
    (t : Angle) (j : ℤ) :
    fourierCoeff (boundaryCorrection c g t) j =
      if j ≤ 0 then taylorCoeff (correction c g ((unitPoint t)⁻¹)) (-j).toNat else 0 := by
  exact fourierCoeff_of_antianalytic hR
    (analyticOnNhd_correction_right isOpen_ball (convex_ball 0 R) hg (unitPoint_inv_mem hR t)
      (fun v hv => hH _ (unitPoint_inv_mem hR t) v hv)) j

theorem boundaryCoefficient_eq_taylor {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0)
    (k : ℕ) (s : Angle) :
    boundaryCoefficient c g k s = taylorCoeff (fun u => correction c g u ((unitPoint s)⁻¹)) k := by
  simp [boundaryCoefficient,boundaryCorrection_left_coeff hR hg hH]

theorem boundaryCoefficient_zero {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0) (s : Angle) :
    boundaryCoefficient c g 0 s = 0 := by
  rw [boundaryCoefficient_eq_taylor hR hg hH]; simp

theorem faberBasis_boundary {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ} (hc : c ≠ 0)
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0)
    (k : ℕ) (s : Angle) :
    (faberBasis c g k).eval (boundary c g s) = fourier (k:ℤ) s + boundaryCoefficient c g k s := by
  rw [boundaryCoefficient_eq_taylor hR hg hH]
  have he := faberBasis_exterior (by linarith : 0 < R) hg hc (unitPoint_inv_mem hR s)
    (inv_ne_zero (unitPoint_ne_zero s)) (fun u hu => hH u hu _ (unitPoint_inv_mem hR s)) k
  simpa only [inv_inv,unitPoint_pow,boundary] using he

theorem boundaryCoefficient_no_nonnegative {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0)
    (k : ℕ) (j : ℤ) (hj : 0 ≤ j) :
    fourierCoeff (boundaryCoefficient c g k) j = 0 := by
  have hS := continuous_boundaryCorrection hR hg hH
  have hcont : Continuous (fun p : Angle × Angle => fourier (k:ℤ) p.1 * boundaryCorrection c g p.1 p.2) :=
    ((fourier (k:ℤ)).continuous.comp continuous_fst).mul hS
  change fourierCoeff (fun s => ∫ t, fourier (-(-(k:ℤ))) t • boundaryCorrection c g t s ∂angularMeasure) j = 0
  simp only [neg_neg,smul_eq_mul]
  rw [fourierCoeff_integral_swap (fun t s => fourier (k:ℤ) t * boundaryCorrection c g t s) hcont]
  have hr (t : Angle) : fourierCoeff (boundaryCorrection c g t) j = 0 := by
    rw [boundaryCorrection_right_coeff hR hg hH]
    by_cases hj0 : j = 0
    · subst j; simp
    · rw [ite_eq_right (by omega)]
  have he (t : Angle) : fourierCoeff (fun s => fourier (k:ℤ) t * boundaryCorrection c g t s) j = 0 := by
    simp only [fourierCoeff,smul_eq_mul]
    rw [show (fun s => fourier (-j) s * (fourier (k:ℤ) t * boundaryCorrection c g t s)) =      (fun s => fourier (k:ℤ) t * (fourier (-j) s * boundaryCorrection c g t s)) by funext s; ring,      integral_const_mul]
    change fourier (k:ℤ) t * fourierCoeff (boundaryCorrection c g t) j = 0
    rw [hr,mul_zero]
  simp only [he,integral_zero]

theorem continuous_boundaryKernel {c : ℂ} {g : ℂ → ℂ}
    (hS : Continuous (boundaryCorrection c g).uncurry) : Continuous (boundaryKernel c g).uncurry := by
  exact continuous_const.add (continuous_const.mul (Complex.continuous_re.comp hS))

theorem boundaryCorrection_marginals {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0) :
    (∀ s, ∫ t, boundaryCorrection c g t s ∂angularMeasure = 0) ∧
      (∀ t, ∫ s, boundaryCorrection c g t s ∂angularMeasure = 0) := by
  constructor
  · intro s
    have he := boundaryCorrection_left_coeff hR hg hH s 0
    simpa [fourierCoeff] using he
  · intro t
    have he := boundaryCorrection_right_coeff hR hg hH t 0
    simpa [fourierCoeff] using he

theorem boundaryKernel_marginals {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0) :
    (∀ s, ∫ t, boundaryKernel c g t s ∂angularMeasure = 1) ∧
      (∀ t, ∫ s, boundaryKernel c g t s ∂angularMeasure = 1) := by
  have hS := continuous_boundaryCorrection hR hg hH
  have hm := boundaryCorrection_marginals hR hg hH
  have hint (f : Angle → ℂ) (hf : Continuous f) (hz : ∫ t, f t ∂angularMeasure = 0) :
      (∫ t, (1 + 2*(f t).re) ∂angularMeasure) = 1 := by
    have hfi := integrable_of_continuous_compact angularMeasure hf
    change (∫ t, (1 + 2*RCLike.re (f t)) ∂angularMeasure) = 1
    rw [integral_add (integrable_const 1) (hfi.re.const_mul 2),integral_const_mul,      integral_re hfi,hz]
    simp
  constructor
  · intro s
    change (∫ t, 1+2*(boundaryCorrection c g t s).re ∂angularMeasure) = 1
    exact hint (fun t => boundaryCorrection c g t s) (continuous_slice_left _ hS s) (hm.1 s)
  · intro t
    change (∫ s, 1+2*(boundaryCorrection c g t s).re ∂angularMeasure) = 1
    exact hint (boundaryCorrection c g t) (continuous_slice_right _ hS t) (hm.2 t)

theorem boundaryKernel_complex (c : ℂ) (g : ℂ → ℂ) (t s : Angle) :
    (boundaryKernel c g t s : ℂ) = 1+boundaryCorrection c g t s+conj (boundaryCorrection c g t s) := by
  apply Complex.ext <;> simp [boundaryKernel] ; ring

theorem boundaryKernel_character {R : ℝ} (hR : 1 < R) {g : ℂ → ℂ}
    (hg : AnalyticOnNhd ℂ g (ball 0 R)) {c : ℂ}
    (hH : ∀ u ∈ ball 0 R, ∀ v ∈ ball 0 R, chordDenominator c g u v ≠ 0)
    (k : ℕ) (hk : k ≠ 0) (s : Angle) :
    (∫ t, (boundaryKernel c g t s : ℂ) * fourier (k:ℤ) t ∂angularMeasure) =
      boundaryCoefficient c g k s := by
  have hS : Continuous (fun t => boundaryCorrection c g t s) :=
    continuous_slice_left _ (continuous_boundaryCorrection hR hg hH) s
  have hf := (fourier (T := (1:ℝ)) (k:ℤ)).continuous
  have h1 : (∫ t : Angle, fourier (k:ℤ) t ∂angularMeasure) = 0 := by
    have he := integral_character_smul 0 (k:ℤ) (1:ℂ)
    simpa [hk] using he
  have h2 : (∫ t, boundaryCorrection c g t s * fourier (k:ℤ) t ∂angularMeasure) =
      boundaryCoefficient c g k s := by
    simp only [boundaryCoefficient,fourierCoeff,neg_neg,smul_eq_mul]
    congr 1; funext t; ring
  have h3 : (∫ t, conj (boundaryCorrection c g t s) * fourier (k:ℤ) t ∂angularMeasure) = 0 := by
    have he := fourierCoeff_conjugate (fun t => boundaryCorrection c g t s) (-(k:ℤ))
    rw [neg_neg,boundaryCorrection_left_coeff hR hg hH,ite_eq_right (by omega)] at he
    simpa only [fourierCoeff,neg_neg,smul_eq_mul,mul_comm,map_zero] using he
  have hi1 : Integrable (fun t : Angle => fourier (k:ℤ) t) angularMeasure := integrable_of_continuous_compact _ hf
  have hi2 : Integrable (fun t : Angle => boundaryCorrection c g t s * fourier (k:ℤ) t) angularMeasure :=
    integrable_of_continuous_compact _ (hS.mul hf)
  have hi3 : Integrable (fun t : Angle => conj (boundaryCorrection c g t s) * fourier (k:ℤ) t) angularMeasure := by
    simpa only [starRingEnd_apply] using! integrable_of_continuous_compact angularMeasure (hS.star.mul hf)
  have ha := integral_add (hi1.add hi2) hi3
  have hb := integral_add hi1 hi2
  simp only [Pi.add_apply] at ha hb
  simp_rw [boundaryKernel_complex,add_mul,one_mul]
  rw [ha,hb,h1,h2,h3,zero_add,add_zero]

end DirectCrouzeix.Faber

end

end

end OAI