import Mathlib
import OAI.Geometry.PrescribedPotential.CircleSubmeanCalculus

namespace OAI

/-! Circle Radial Calculus. -/

section

 

noncomputable section
open Set Filter Topology Metric MeasureTheory
open scoped ContDiff
namespace PotentialABP

private def v (θ : ℝ) : ℂ := circleMap 0 1 θ
private def w (θ : ℝ) : ℂ := v θ * Complex.I

private lemma dv (θ : ℝ) : HasDerivAt v (w θ) θ := hasDerivAt_circleMap 0 1 θ
private lemma dw (θ : ℝ) : HasDerivAt w (-v θ) θ := by
  convert (dv θ).mul_const Complex.I using 1 <;> first | rfl | simp [w, mul_assoc]

private lemma cv : Continuous v := continuous_circleMap 0 1
private lemma cw : Continuous w := cv.mul continuous_const

 
def circleIntegralReal (f : ℂ → ℝ) (c : ℂ) (r : ℝ) : ℝ :=
  ∫ θ in 0..2*Real.pi, f (c + r • v θ)
def radialIntegral (f : ℂ → ℝ) (c : ℂ) (r : ℝ) : ℝ :=
  ∫ θ in 0..2*Real.pi, fderiv ℝ f (c + r • v θ) (v θ)
def secondRadialIntegral (f : ℂ → ℝ) (c : ℂ) (r : ℝ) : ℝ :=
  ∫ θ in 0..2*Real.pi, fderiv ℝ (fderiv ℝ f) (c + r • v θ) (v θ) (v θ)
def angularHessianIntegral (f : ℂ → ℝ) (c : ℂ) (r : ℝ) : ℝ :=
  ∫ θ in 0..2*Real.pi, fderiv ℝ (fderiv ℝ f) (c + r • v θ) (w θ) (w θ)

lemma circleIntegralReal_eq_circleAverage (f : ℂ → ℝ) (c : ℂ) (r : ℝ) :
    circleIntegralReal f c r = 2*Real.pi * Real.circleAverage f c r := by
  unfold circleIntegralReal Real.circleAverage
  simp only [smul_eq_mul, ← mul_assoc, mul_inv_cancel₀ (by positivity : (2:ℝ)*Real.pi ≠ 0), one_mul]
  congr 1
  funext θ
  congr 1
  simp [v, circleMap, Complex.real_smul]

lemma circleIntegralReal_hasDerivAt {f : ℂ → ℝ} (hf : ContDiff ℝ ∞ f) (c : ℂ) (r : ℝ) :
    HasDerivAt (circleIntegralReal f c) (radialIntegral f c r) r := by
  refine hasDerivAt_intervalIntegral_continuous
    (F := fun s θ => f (c + s • v θ))
    (F' := fun s θ => fderiv ℝ f (c + s • v θ) (v θ)) ?_ ?_ ?_ 0 (2*Real.pi) r
  · exact hf.continuous.comp (continuous_const.add (continuous_fst.smul (cv.comp continuous_snd)))
  · exact ((hf.continuous_fderiv (by simp)).comp
      (continuous_const.add (continuous_fst.smul (cv.comp continuous_snd)))).clm_apply (cv.comp continuous_snd)
  · intro s θ
    simpa only [one_smul, Function.comp_def, id_eq] using
      (hf.differentiable (by simp) _).hasFDerivAt.comp_hasDerivAt s
        (((hasDerivAt_id s).smul_const (v θ)).const_add c)

lemma radialIntegral_hasDerivAt {f : ℂ → ℝ} (hf : ContDiff ℝ ∞ f) (c : ℂ) (r : ℝ) :
    HasDerivAt (radialIntegral f c) (secondRadialIntegral f c r) r := by
  have hdf := hf.fderiv_right (m := ∞) (by simp)
  refine hasDerivAt_intervalIntegral_continuous
    (F := fun s θ => fderiv ℝ f (c + s • v θ) (v θ))
    (F' := fun s θ => fderiv ℝ (fderiv ℝ f) (c + s • v θ) (v θ) (v θ))
    ?_ ?_ ?_ 0 (2*Real.pi) r
  · exact (hdf.continuous.comp
      (continuous_const.add (continuous_fst.smul (cv.comp continuous_snd)))).clm_apply (cv.comp continuous_snd)
  · exact (((hdf.continuous_fderiv (by simp)).comp
      (continuous_const.add (continuous_fst.smul (cv.comp continuous_snd)))).clm_apply
      (cv.comp continuous_snd)).clm_apply (cv.comp continuous_snd)
  · intro s θ
    have h := ((hdf.differentiable (by simp) _).hasFDerivAt.comp_hasDerivAt s
      (((hasDerivAt_id s).smul_const (v θ)).const_add c)).clm_apply (hasDerivAt_const s (v θ))
    simpa only [one_smul, Function.comp_def, id_eq, map_zero, add_zero] using h

lemma radialIntegral_eq_radius_angular {f : ℂ → ℝ} (hf : ContDiff ℝ ∞ f) (c : ℂ) (r : ℝ) :
    radialIntegral f c r = r * angularHessianIntegral f c r := by
  have hdf := hf.fderiv_right (m := ∞) (by simp)
  let T : ℝ → ℝ := fun θ => fderiv ℝ f (c + r • v θ) (w θ)
  let T' : ℝ → ℝ := fun θ => r * fderiv ℝ (fderiv ℝ f) (c + r • v θ) (w θ) (w θ)
    - fderiv ℝ f (c + r • v θ) (v θ)
  have ht (θ : ℝ) : HasDerivAt T (T' θ) θ := by
    have h := ((hdf.differentiable (by simp) _).hasFDerivAt.comp_hasDerivAt θ
      (((dv θ).const_smul r).const_add c)).clm_apply (dw θ)
    simpa only [T, T', Function.comp_def, map_smul, map_neg, smul_eq_mul, sub_eq_add_neg, Pi.smul_apply, smul_apply] using h
  have hct : Continuous T' := by
    apply Continuous.sub
    · exact continuous_const.mul (((hdf.continuous_fderiv (by simp)).comp
        (continuous_const.add (cv.const_smul r))).clm_apply cw |>.clm_apply cw)
    · exact (hdf.continuous.comp (continuous_const.add (cv.const_smul r))).clm_apply cv
  have he := intervalIntegral.integral_eq_sub_of_hasDerivAt
    (fun θ _ => ht θ) (hct.intervalIntegrable 0 (2*Real.pi))
  have hp : T (2*Real.pi) = T 0 := by
    have hv : v (2*Real.pi) = v 0 := by
      simpa only [v, zero_add] using periodic_circleMap 0 1 0
    simp only [T, w, hv]
  rw [hp, sub_self] at he
  have hc1 : Continuous (fun θ => fderiv ℝ (fderiv ℝ f) (c + r • v θ) (w θ) (w θ)) :=
    (((hdf.continuous_fderiv (by simp)).comp
      (continuous_const.add (cv.const_smul r))).clm_apply cw).clm_apply cw
  have hc2 : Continuous (fun θ => fderiv ℝ f (c + r • v θ) (v θ)) :=
    (hdf.continuous.comp (continuous_const.add (cv.const_smul r))).clm_apply cv
  dsimp only [T'] at he
  have hi1 : IntervalIntegrable (fun θ => r * fderiv ℝ (fderiv ℝ f)
      (c + r • v θ) (w θ) (w θ)) volume 0 (2*Real.pi) :=
    (continuous_const.mul hc1).intervalIntegrable _ _
  rw [intervalIntegral.integral_sub hi1 (hc2.intervalIntegrable _ _),
    intervalIntegral.integral_const_mul] at he
  exact (sub_eq_zero.mp he).symm

lemma radialIntegral_continuous {f : ℂ → ℝ} (hf : ContDiff ℝ ∞ f) (c : ℂ) :
    Continuous (radialIntegral f c) :=
  continuous_iff_continuousAt.mpr (fun r => (radialIntegral_hasDerivAt hf c r).continuousAt)
lemma circleIntegralReal_continuous {f : ℂ → ℝ} (hf : ContDiff ℝ ∞ f) (c : ℂ) :
    Continuous (circleIntegralReal f c) :=
  continuous_iff_continuousAt.mpr (fun r => (circleIntegralReal_hasDerivAt hf c r).continuousAt)

private lemma hessian_circle_pair (B : ℂ →L[ℝ] ℂ →L[ℝ] ℝ) (θ : ℝ) :
    B (v θ) (v θ) + B (w θ) (w θ) = B 1 1 + B Complex.I Complex.I := by
  have hv : v θ = Real.cos θ • (1:ℂ) + Real.sin θ • Complex.I := by
    apply Complex.ext <;> simp [v, circleMap_zero_re, circleMap_zero_im, -Complex.ofReal_cos, -Complex.ofReal_sin]
  have hw : w θ = (-Real.sin θ) • (1:ℂ) + Real.cos θ • Complex.I := by
    apply Complex.ext <;> simp [w, v, circleMap_zero_re, circleMap_zero_im, Complex.mul_re, Complex.mul_im, -Complex.ofReal_cos, -Complex.ofReal_sin]
  rw [hv, hw]
  calc
    _ = (Real.sin θ ^ 2 + Real.cos θ ^ 2) * (B 1 1 + B Complex.I Complex.I) := by
      simp only [map_add, map_smul, add_apply,
        smul_apply, smul_eq_mul]
      ring
    _ = _ := by rw [Real.sin_sq_add_cos_sq, one_mul]

 

theorem smooth_circle_submean {f : ℂ → ℝ} (hf : ContDiff ℝ ∞ f)
    (c : ℂ) {R : ℝ} (hR : 0 ≤ R)
    (htrace : ∀ z ∈ closedBall c R,
      0 ≤ fderiv ℝ (fderiv ℝ f) z 1 1 +
        fderiv ℝ (fderiv ℝ f) z Complex.I Complex.I) :
    f c ≤ Real.circleAverage f c R := by
  have hdf := hf.fderiv_right (m := ∞) (by simp)
  have hpos (r : ℝ) (hr : r ∈ Icc 0 R) :
      0 ≤ secondRadialIntegral f c r + angularHessianIntegral f c r := by
    have hc1 : Continuous (fun θ => fderiv ℝ (fderiv ℝ f) (c + r • v θ) (v θ) (v θ)) :=
      (((hdf.continuous_fderiv (by simp)).comp
        (continuous_const.add (cv.const_smul r))).clm_apply cv).clm_apply cv
    have hc2 : Continuous (fun θ => fderiv ℝ (fderiv ℝ f) (c + r • v θ) (w θ) (w θ)) :=
      (((hdf.continuous_fderiv (by simp)).comp
        (continuous_const.add (cv.const_smul r))).clm_apply cw).clm_apply cw
    dsimp only [secondRadialIntegral, angularHessianIntegral]
    rw [← intervalIntegral.integral_add (hc1.intervalIntegrable _ _) (hc2.intervalIntegrable _ _)]
    apply intervalIntegral.integral_nonneg_of_forall (by positivity)
    intro θ
    rw [hessian_circle_pair]
    apply htrace
    simp only [mem_closedBall, dist_eq_norm, add_sub_cancel_left, norm_smul,
      v, norm_circleMap_zero, abs_one, mul_one, Real.norm_eq_abs, abs_of_nonneg hr.1]
    exact hr.2
  let J : ℝ → ℝ := fun r => r * radialIntegral f c r
  have hdJ (r : ℝ) : HasDerivAt J
      (radialIntegral f c r + r * secondRadialIntegral f c r) r := by
    have hh := (hasDerivAt_id r).mul (radialIntegral_hasDerivAt hf c r)
    change HasDerivAt (fun s => s * radialIntegral f c s) _ r at hh
    simpa only [J, id_eq, one_mul] using hh
  have hmJ : MonotoneOn J (Icc 0 R) := by
    apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Icc 0 R)
      ((continuous_id.mul (radialIntegral_continuous hf c)).continuousOn)
      (fun r _ => (hdJ r).hasDerivWithinAt)
    intro r hr
    have hr' := interior_subset hr
    rw [radialIntegral_eq_radius_angular hf, ← mul_add]
    exact mul_nonneg hr'.1 (by simpa only [add_comm] using hpos r hr')
  have hmF : MonotoneOn (circleIntegralReal f c) (Icc 0 R) := by
    apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Icc 0 R)
      (circleIntegralReal_continuous hf c).continuousOn
      (fun r _ => (circleIntegralReal_hasDerivAt hf c r).hasDerivWithinAt)
    intro r hr
    have hr' : r ∈ Ioo 0 R := by simpa only [interior_Icc] using hr
    have hj := hmJ ⟨le_rfl,hR⟩ ⟨hr'.1.le,hr'.2.le⟩ hr'.1.le
    simp only [J, zero_mul] at hj
    nlinarith [hr'.1]
  have he := hmF ⟨le_rfl,hR⟩ ⟨hR,le_rfl⟩ hR
  have hF0 : circleIntegralReal f c 0 = 2*Real.pi*f c := by
    simp [circleIntegralReal]
  have hFR : Real.circleAverage f c R = (2*Real.pi)⁻¹ * circleIntegralReal f c R := by
    unfold Real.circleAverage circleIntegralReal
    congr 2
    funext θ
    congr 1
    simp [v, circleMap, Complex.real_smul]
  rw [hF0] at he
  rw [hFR]
  exact (le_inv_mul_iff₀ (by positivity : 0 < 2*Real.pi)).mpr (by simpa only [mul_comm] using he)

end PotentialABP

end
end

end OAI