import OAI.Geometry.ProjectionBodies.NormEstimates

namespace OAI

noncomputable section
open Set Filter Topology Function
namespace PettyProjection.Spherical

/-- Positive part to a natural power; the endpoint is fixed to zero. -/
def posPower (r : ℕ) (x : ℝ) : ℝ := if 0 < x then x^r else 0

lemma posPower_hasDerivAt {r : ℕ} (hr : 2 ≤ r) (x : ℝ) :
    HasDerivAt (posPower r) ((r : ℝ)*posPower (r-1) x) x := by
  have hd (z : ℝ) : HasDerivAt (fun a : ℝ => (a-1)^r) ((r : ℝ)*(z-1)^(r-1)) z := by
    convert! ((hasDerivAt_id z).sub_const 1).pow r using 1
    simp
  have hp := Scalar.paste_hasDerivAt (fun z _ => hd z)
    (by simp [show r ≠ 0 by omega]) (by simp [show r-1 ≠ 0 by omega]) (x+1)
  have h := hp.comp x ((hasDerivAt_id x).add_const 1)
  convert! h using 1
  · funext z; simp [posPower]
  · simp [posPower, mul_ite]

lemma posPower_contDiff_one {r : ℕ} (hr : 2 ≤ r) : ContDiff ℝ 1 (posPower r) := by
  have hd (z : ℝ) : HasDerivAt (fun a : ℝ => (a-1)^r) ((r : ℝ)*(z-1)^(r-1)) z := by
    convert! ((hasDerivAt_id z).sub_const 1).pow r using 1
    simp
  have h := Scalar.paste_contDiff_one (fun z _ => hd z)
    (by simp [show r ≠ 0 by omega]) (by simp [show r-1 ≠ 0 by omega])
    (by fun_prop)
  have hc := h.comp (contDiff_id.add contDiff_const : ContDiff ℝ 1 (fun x : ℝ => x+1))
  convert! hc using 1
  ext x
  simp [posPower]

lemma posPower_contDiff_two {r : ℕ} (hr : 3 ≤ r) : ContDiff ℝ 2 (posPower r) := by
  have he : deriv (posPower r) = fun x => (r : ℝ)*posPower (r-1) x :=
    funext fun x => (posPower_hasDerivAt (by omega) x).deriv
  change ContDiff ℝ (1+1) (posPower r)
  rw [contDiff_succ_iff_deriv]
  refine ⟨fun x => (posPower_hasDerivAt (by omega) x).differentiableAt, ?_, ?_⟩
  · simp
  · rw [he]
    exact contDiff_const.mul (posPower_contDiff_one (by omega))

lemma abs_pow_posPower {r : ℕ} (hr : 0 < r) (x : ℝ) :
    |x|^r = posPower r x + posPower r (-x) := by
  rcases lt_trichotomy x 0 with hx | rfl | hx
  · simp [posPower, abs_of_neg hx, not_lt.mpr hx.le, neg_pos.mpr hx]
  · simp [posPower, hr.ne']
  · simp [posPower, abs_of_pos hx, hx, not_lt.mpr (neg_nonpos.mpr hx.le)]

lemma abs_pow_contDiff_two {r : ℕ} (hr : 3 ≤ r) : ContDiff ℝ 2 (fun x : ℝ => |x|^r) := by
  have he : (fun x : ℝ => |x|^r) = fun x => posPower r x+posPower r (-x) :=
    funext (abs_pow_posPower (by omega))
  rw [he]
  exact (posPower_contDiff_two hr).add ((posPower_contDiff_two hr).comp contDiff_neg)

lemma abs_pow_hasDerivAt {r : ℕ} (hr : 2 ≤ r) (x : ℝ) :
    HasDerivAt (fun x : ℝ => |x|^r) ((r : ℝ)*x*|x|^(r-2)) x := by
  have h := (posPower_hasDerivAt hr x).add ((posPower_hasDerivAt hr (-x)).comp x (hasDerivAt_neg x))
  have he : (fun x : ℝ => |x|^r) = fun x => posPower r x+posPower r (-x) :=
    funext (abs_pow_posPower (by omega))
  rw [he]
  convert! h using 1
  have hp : r-1 = (r-2)+1 := by omega
  rcases lt_trichotomy x 0 with hx | rfl | hx
  · simp only [posPower, ite_eq_right (not_lt.mpr hx.le), ite_eq_left (neg_pos.mpr hx),
      abs_of_neg hx, hp, pow_succ]
    ring
  · simp [posPower]
  · simp only [posPower, ite_eq_left hx, ite_eq_right (not_lt.mpr (neg_nonpos.mpr hx.le)),
      abs_of_pos hx, hp, pow_succ]
    ring

lemma abs_pow_second_deriv {r : ℕ} (hr : 3 ≤ r) (x : ℝ) :
    HasDerivAt (fun x : ℝ => (r : ℝ)*x*|x|^(r-2))
      ((r : ℝ)*((r : ℝ)-1)*|x|^(r-2)) x := by
  have he : (fun x : ℝ => (r : ℝ)*x*|x|^(r-2)) =
      fun x => (r : ℝ)*(posPower (r-1) x - posPower (r-1) (-x)) := by
    funext z
    have hp : r-1 = (r-2)+1 := by omega
    rcases lt_trichotomy z 0 with hz | rfl | hz
    · simp only [posPower, ite_eq_right (not_lt.mpr hz.le), ite_eq_left (neg_pos.mpr hz),
        abs_of_neg hz, hp, pow_succ]; ring
    · simp [posPower]
    · simp only [posPower, ite_eq_left hz, ite_eq_right (not_lt.mpr (neg_nonpos.mpr hz.le)),
        abs_of_pos hz, hp, pow_succ]; ring
  rw [he]
  have h := ((posPower_hasDerivAt (show 2 ≤ r-1 by omega) x).sub
    ((posPower_hasDerivAt (show 2 ≤ r-1 by omega) (-x)).comp x (hasDerivAt_neg x))).const_mul (r : ℝ)
  convert! h using 1
  rw [show r-1-1 = r-2 by omega, Nat.cast_sub (by omega), Nat.cast_one,
    abs_pow_posPower (show 0 < r-2 by omega)]
  ring

end PettyProjection.Spherical
end

noncomputable section
open Set MeasureTheory Metric Filter Topology Function
open scoped ENNReal RealInnerProductSpace
namespace PettyProjection.Spherical

lemma inner_generator {n : ℕ} (u x : Space n) (i j : Fin n) :
    ⟪u, generator n i j x⟫ = x i*u j-x j*u i := by
  simp [generator_apply, inner_sub_right, inner_smul_right,
    EuclideanSpace.inner_single_right]

lemma sum_inner_generator_sq {n : ℕ} (u x : Space n) :
    ∑ i : Fin n, ∑ j : Fin n, ⟪u, generator n i j x⟫^2 =
      2*(‖u‖^2*‖x‖^2-⟪u,x⟫^2) := by
  simp_rw [inner_generator]
  have he (i j : Fin n) : (x i*u j-x j*u i)^2 =
      x i^2*u j^2+x j^2*u i^2-2*(x i*u i)*(x j*u j) := by ring
  simp_rw [he, Finset.sum_sub_distrib, Finset.sum_add_distrib,
    ← Finset.mul_sum, ← Finset.sum_mul]
  rw [← EuclideanSpace.real_norm_sq_eq, ← EuclideanSpace.real_norm_sq_eq]
  simp only [← Finset.mul_sum]
  rw [← EuclideanSpace.real_norm_sq_eq]
  have hi : ⟪u,x⟫ = ∑ i, x i*u i := by
    simp [EuclideanSpace.inner_eq_star_dotProduct, dotProduct]
  rw [hi]
  ring

lemma rotDeriv_scalar_linear {n : ℕ} (T : Space n →L[ℝ] Space n)
    (L : Space n →L[ℝ] ℝ) {f f' : ℝ → ℝ}
    (hf : ∀ t, HasDerivAt f (f' t) t) (x : Space n) :
    rotDeriv T (f ∘ L) x = f' (L x)*L (T x) := by
  have h := (hf (L x)).comp_hasFDerivAt x L.hasFDerivAt
  simp only [rotDeriv, h.fderiv, smul_apply, smul_eq_mul]

lemma rotDeriv_scalar_linear_twice {n : ℕ} (T : Space n →L[ℝ] Space n)
    (L : Space n →L[ℝ] ℝ) {f f' f'' : ℝ → ℝ}
    (hf : ∀ t, HasDerivAt f (f' t) t)
    (hf' : ∀ t, HasDerivAt f' (f'' t) t) (x : Space n) :
    rotDeriv T (rotDeriv T (f ∘ L)) x =
      f'' (L x)*(L (T x))^2+f' (L x)*L (T (T x)) := by
  have he : rotDeriv T (f ∘ L) = fun y => f' (L y)*L (T y) :=
    funext (rotDeriv_scalar_linear T L hf)
  rw [he]
  have hd := ((hf' (L x)).comp_hasFDerivAt x L.hasFDerivAt).mul
    (L.comp T).hasFDerivAt
  change fderiv ℝ ((f' ∘ L) * (fun y => (L.comp T) y)) x (T x) = _
  rw [hd.fderiv]
  simp only [add_apply, smul_apply, smul_eq_mul, ContinuousLinearMap.comp_apply, comp_apply]
  ring

lemma casimir_scalar_inner {n : ℕ} (u x : Space n) {f f' f'' : ℝ → ℝ}
    (hf : ∀ t, HasDerivAt f (f' t) t)
    (hf' : ∀ t, HasDerivAt f' (f'' t) t) :
    casimir (fun y => f ⟪u,y⟫) x =
      f'' ⟪u,x⟫*(‖u‖^2*‖x‖^2-⟪u,x⟫^2)-
        ((n : ℝ)-1)*f' ⟪u,x⟫*⟪u,x⟫ := by
  change casimir (f ∘ (innerSL ℝ u)) x = _
  unfold casimir
  simp_rw [rotDeriv_scalar_linear_twice _ (innerSL ℝ u) hf hf',
    innerSL_apply_apply, Finset.sum_add_distrib, ← Finset.mul_sum]
  rw [sum_inner_generator_sq]
  simp_rw [← inner_sum, sum_generator_square, inner_smul_right]
  ring

lemma posPower_mul {r : ℕ} (x : ℝ) :
    posPower r x*x = posPower (r+1) x := by
  by_cases hx : 0 < x <;> simp [posPower, hx, pow_succ]

lemma posPower_mul_sq {r : ℕ} (x : ℝ) :
    posPower r x*x^2 = posPower (r+2) x := by
  rw [pow_two, ← mul_assoc, posPower_mul, posPower_mul]

lemma casimir_posPower_inner {n r : ℕ} (hr : 3 ≤ r) (u x : Sphere n) :
    casimir (fun y => posPower r ⟪(u : Space n),y⟫) x =
      (r : ℝ)*((r : ℝ)-1)*posPower (r-2) ⟪(u : Space n),(x : Space n)⟫ -
      eigenvalue n r*posPower r ⟪(u : Space n),(x : Space n)⟫ := by
  have hd (t : ℝ) : HasDerivAt (fun z => (r : ℝ)*posPower (r-1) z)
      ((r : ℝ)*((r : ℝ)-1)*posPower (r-2) t) t := by
    convert! (posPower_hasDerivAt (show 2 ≤ r-1 by omega) t).const_mul (r : ℝ) using 1
    rw [show r-1-1 = r-2 by omega, Nat.cast_sub (by omega), Nat.cast_one]
    ring
  rw [casimir_scalar_inner _ _ (posPower_hasDerivAt (by omega)) hd,
    norm_coe, norm_coe]
  simp only [one_pow, mul_one]
  have h₁ := posPower_mul (r := r-1) ⟪(u : Space n),(x : Space n)⟫
  have h₂ := posPower_mul_sq (r := r-2) ⟪(u : Space n),(x : Space n)⟫
  rw [show r-1+1 = r by omega] at h₁
  rw [show r-2+2 = r by omega] at h₂
  unfold eigenvalue
  calc
    _ = (r : ℝ)*((r : ℝ)-1)*posPower (r-2) ⟪(u : Space n),(x : Space n)⟫ -
      (r : ℝ)*((r : ℝ)-1)*(posPower (r-2) ⟪(u : Space n),(x : Space n)⟫ * ⟪(u : Space n),(x : Space n)⟫^2) -
      ((n : ℝ)-1)*(r : ℝ)*(posPower (r-1) ⟪(u : Space n),(x : Space n)⟫ * ⟪(u : Space n),(x : Space n)⟫) := by ring
    _ = _ := by rw [h₁, h₂]; ring

lemma mean_casimir_comm {n : ℕ} [NeZero n] {f g : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) (hg : ContDiff ℝ 2 g) :
    mean (fun u : Sphere n => f u*casimir g u) =
      mean (fun u : Sphere n => g u*casimir f u) := by
  rw [mean_casimir (hf.of_le (by norm_num)) hg,
    mean_casimir (hg.of_le (by norm_num)) hf, energy_symm]

end PettyProjection.Spherical
end

noncomputable section
open Set MeasureTheory Metric Filter Topology Function
open scoped ENNReal RealInnerProductSpace Gradient
namespace PettyProjection.Spherical

lemma sum_inner_generator_mul {n : ℕ} (u w x : Space n) :
    ∑ i : Fin n, ∑ j : Fin n, ⟪u,generator n i j x⟫*⟪w,generator n i j x⟫ =
      2*(‖x‖^2*⟪u,w⟫-⟪u,x⟫*⟪w,x⟫) := by
  simp_rw [inner_generator]
  have he (i j : Fin n) : (x i*u j-x j*u i)*(x i*w j-x j*w i) =
      x i^2*(u j*w j)+x j^2*(u i*w i)-(x i*w i)*(x j*u j)-(x i*u i)*(x j*w j) := by ring
  simp_rw [he, Finset.sum_sub_distrib, Finset.sum_add_distrib,
    ← Finset.mul_sum, ← Finset.sum_mul]
  have hi (a b : Space n) : ⟪a,b⟫ = ∑ i, a i*b i := by
    simp [EuclideanSpace.inner_eq_star_dotProduct, dotProduct, mul_comm]
  rw [hi u w, hi u x, hi w x, EuclideanSpace.real_norm_sq_eq]
  simp_rw [mul_comm (u _) (x _), mul_comm (w _) (x _)]
  simp only [← Finset.mul_sum]
  ring

/-- Genuine tangential gradient on the unit sphere, expressed ambiently. -/
def sphereGradient {n : ℕ} (f : Space n → ℝ) (x : Space n) : Space n :=
  ∇ f x - (fderiv ℝ f x x) • x

lemma continuous_gradient_of_contDiff {n : ℕ} {f : Space n → ℝ} (hf : ContDiff ℝ 1 f) :
    Continuous (gradient f) :=
  (InnerProductSpace.toDual ℝ (Space n)).symm.continuous.comp (hf.continuous_fderiv (by norm_num))

lemma sphereGradient_continuous {n : ℕ} {f : Space n → ℝ} (hf : ContDiff ℝ 1 f) :
    Continuous (sphereGradient f) := by
  exact (continuous_gradient_of_contDiff hf).sub
    (((hf.continuous_fderiv (by norm_num)).clm_apply continuous_id).smul continuous_id)

lemma sphereGradient_inner {n : ℕ} (f : Space n → ℝ) (x w : Space n) :
    ⟪sphereGradient f x,w⟫ = fderiv ℝ f x w - fderiv ℝ f x x*⟪x,w⟫ := by
  simp only [sphereGradient, inner_sub_left, inner_smul_left, inner_gradient_left, starRingEnd_apply, star_trivial]

lemma sphereGradient_tangent {n : ℕ} (f : Space n → ℝ) (x : Sphere n) :
    ⟪sphereGradient f x,(x : Space n)⟫ = 0 := by
  rw [sphereGradient_inner, real_inner_self_eq_norm_sq, norm_coe]
  simp

lemma sum_rotDeriv_inner {n : ℕ} (f : Space n → ℝ) (x : Sphere n) (w : Space n) :
    (1/2 : ℝ)*(∑ i : Fin n, ∑ j : Fin n,
      rotDeriv (generator n i j) f x*⟪w,generator n i j x⟫) = ⟪sphereGradient f x,w⟫ := by
  simp only [rotDeriv, ← inner_gradient_left]
  rw [sum_inner_generator_mul, norm_coe, sphereGradient_inner,
    inner_gradient_left, inner_gradient_left, real_inner_comm w (x : Space n)]
  ring

lemma mean_gradient_casimir {n : ℕ} [NeZero n] {f g : Space n → ℝ}
    (hf : ContDiff ℝ 1 f) (hg : ContDiff ℝ 2 g) :
    mean (fun x : Sphere n => ⟪sphereGradient f x,sphereGradient g x⟫) =
      -mean (fun x : Sphere n => f x*casimir g x) := by
  rw [mean_casimir hf hg, neg_neg]
  have hs (x : Sphere n) : ⟪sphereGradient f x,sphereGradient g x⟫ =
      (1/2 : ℝ)*∑ i : Fin n, ∑ j : Fin n,
        rotDeriv (generator n i j) f x*rotDeriv (generator n i j) g x := by
    have h := sum_rotDeriv_inner f x (∇ g x)
    simp only [inner_gradient_left] at h
    change ⟪sphereGradient f x, ∇ g x - (fderiv ℝ g x x) • (x : Space n)⟫ = _
    rw [inner_sub_right, inner_smul_right, sphereGradient_tangent, mul_zero, sub_zero]
    exact h.symm
  simp_rw [hs]
  rw [mean, integral_const_mul]
  congr 1
  rw [integral_finsetSum]
  · apply Finset.sum_congr rfl
    intro i _
    exact integral_finsetSum _ (fun j _ => continuous_integrable
      (((continuous_rotDeriv _ hf).comp continuous_subtype_val).mul
        ((continuous_rotDeriv _ (hg.of_le (by norm_num))).comp continuous_subtype_val)))
  · intro i _
    apply continuous_integrable
    exact continuous_finsetSum _ fun j _ =>
      ((continuous_rotDeriv _ hf).comp continuous_subtype_val).mul
        ((continuous_rotDeriv _ (hg.of_le (by norm_num))).comp continuous_subtype_val)

end PettyProjection.Spherical
end

end OAI