import Mathlib
import OAI.Probability.Perceptron.Interpolation.TerminalReplicaRestoration
import OAI.Probability.Perceptron.Cavity.AmbientBulkFeature
import OAI.Probability.Perceptron.Interpolation.VectorReplicaDirectionBound

namespace OAI

noncomputable section
namespace SphericalPerceptronFreeEnergy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology BigOperators BoundedContinuousFunction ContDiff

lemma bulkCovarianceDerivative_bound (N : ℕ) (v : ℕ→ℝ) {C r : ℝ}
    (hC : 0≤C) (hv : ∀ j, |v (j+1)|≤C) (hr : |r|≤1) :
    |bulkCovarianceDerivative N v r|≤C^2*bulkScale N^2 := by
  have hb (j : Fin N) : bulkAmplitude N v j^2*(j.val+1)≤C^2*bulkScale N^2*(1/2:ℝ)^(j.val+1) := by
    let w : ℝ := (1/2:ℝ)^(j.val+1)
    have hw : 0≤w := by dsimp [w]; positivity
    have hwp : w*(j.val+1)≤1 := by
      have hk : (j.val+1:ℝ)≤(2:ℝ)^(j.val+1) := by exact_mod_cast (Nat.lt_two_pow_self (n:=j.val+1)).le
      dsimp [w]
      rw [div_pow,one_pow,one_div_mul_eq_div]
      exact (div_le_one (by positivity)).mpr (by simpa only [Nat.cast_add,Nat.cast_one] using hk)
    have hv2 : v (j.val+1)^2≤C^2 := by simpa only [sq_abs] using pow_le_pow_left₀ (abs_nonneg _) (hv j.val) 2
    unfold bulkAmplitude
    rw [perturbationWeight_eq]
    change (bulkScale N*w*v (j.val+1))^2*(j.val+1)≤C^2*bulkScale N^2*w
    calc
      _ = bulkScale N^2*w^2*(j.val+1)*v (j.val+1)^2 := by ring
      _ ≤ bulkScale N^2*w^2*(j.val+1)*C^2 := mul_le_mul_of_nonneg_left hv2 (by positivity)
      _ = C^2*bulkScale N^2*w*(w*(j.val+1)) := by ring
      _ ≤ C^2*bulkScale N^2*w*1 := mul_le_mul_of_nonneg_left hwp (by positivity)
      _ = _ := mul_one _
  unfold bulkCovarianceDerivative
  apply (Finset.abs_sum_le_sum_abs _ _).trans
  calc
    _ ≤ ∑ j : Fin N, C^2*bulkScale N^2*(1/2:ℝ)^(j.val+1) := by
      apply Finset.sum_le_sum
      intro j _
      rw [abs_mul,abs_mul,abs_sq,abs_of_nonneg (by positivity : (0:ℝ)≤j.val+1),abs_pow]
      exact (mul_le_mul_of_nonneg_left (pow_le_one₀ (abs_nonneg r) hr) (by positivity)).trans (by simpa only [mul_one] using hb j)
    _ = C^2*bulkScale N^2*(∑ j : Fin N, (1/2:ℝ)^(j.val+1)) := (Finset.mul_sum _ _ _).symm
    _ ≤ C^2*bulkScale N^2*1 := mul_le_mul_of_nonneg_left (half_power_sum_le_one N)
      (mul_nonneg (pow_nonneg hC 2) (sq_nonneg _))
    _ = _ := mul_one _

def bulkTangentDirection (N : ℕ) (v : ℕ→ℝ) (G : ℝ→ᵇℝ) (x : Fin 2→NormalizedSpin N) : BulkMark N :=
  G (spinOverlap (x 0) (x 1)) •
    fderiv ℝ (ambientBulkFeature N v) (x 0).val
      ((x 1).val-spinOverlap (x 0) (x 1) • (x 0).val)

lemma bulkTangentDirection_continuous (N : ℕ) (v : ℕ→ℝ) (G : ℝ→ᵇℝ) :
    Continuous (bulkTangentDirection N v G) := by
  have hr : Continuous (fun x : Fin 2→NormalizedSpin N => spinOverlap (x 0) (x 1)) := by
    unfold spinOverlap; fun_prop
  apply (G.continuous.comp hr).smul
  have h0 : Continuous (fun x : Fin 2→NormalizedSpin N => (x 0).val) := by fun_prop
  have h1 : Continuous (fun x : Fin 2→NormalizedSpin N => (x 1).val) := by fun_prop
  exact (((ambientBulkFeature_contDiff N v).continuous_fderiv (by norm_num)).comp h0).clm_apply
    (h1.sub (hr.smul h0))

lemma bulkTangentDirection_cross (N : ℕ) (v : ℕ→ℝ) (G : ℝ→ᵇℝ)
    (x : Fin 2→NormalizedSpin N) (y : NormalizedSpin N) :
    inner ℝ (bulkTangentDirection N v G x) (bulkFeature N v y)=
      G (spinOverlap (x 0) (x 1))*bulkCovarianceDerivative N v (spinOverlap (x 0) y)*
        (spinOverlap (x 1) y-spinOverlap (x 0) (x 1)*spinOverlap (x 0) y) := by
  unfold bulkTangentDirection
  rw [← ambientBulkFeature_eq,inner_smul_left,starRingEnd_apply,star_trivial,ambientBulkFeature_deriv_inner]
  simp only [inner_sub_left,inner_smul_left,starRingEnd_apply,star_trivial,spinOverlap]
  ring

lemma bulkTangentDirection_cross_bound (N : ℕ) (v : ℕ→ℝ) (G : ℝ→ᵇℝ) {C : ℝ}
    (hC : 0≤C) (hv : ∀ j, |v (j+1)|≤C)
    (x : Fin 2→NormalizedSpin N) (y : NormalizedSpin N) :
    |inner ℝ (bulkTangentDirection N v G x) (bulkFeature N v y)|≤2*‖G‖*C^2*bulkScale N^2 := by
  rw [bulkTangentDirection_cross,abs_mul,abs_mul]
  have hb : |spinOverlap (x 1) y-spinOverlap (x 0) (x 1)*spinOverlap (x 0) y|≤2 := by
    apply (abs_sub _ _).trans
    rw [abs_mul]
    have hm := mul_le_mul (spinOverlap_abs_le (x 0) (x 1)) (spinOverlap_abs_le (x 0) y) (abs_nonneg _) (by norm_num : (0:ℝ)≤1)
    linarith [spinOverlap_abs_le (x 1) y]
  have hc := bulkCovarianceDerivative_bound N v hC hv (spinOverlap_abs_le (x 0) y)
  calc
    _ ≤ (‖G‖*(C^2*bulkScale N^2))*2 :=
      mul_le_mul (mul_le_mul (G.norm_coe_le_norm _) hc (abs_nonneg _) (norm_nonneg _)) hb (abs_nonneg _) (by positivity)
    _ = _ := by ring

lemma bulk_tangent_perturbation_bound (n M : ℕ) (f G : ℝ→ᵇℝ) (v : ℕ→ℝ)
    (a : Fin M→Fin (n+1)→ℝ) {C : ℝ} (hC : 0≤C) (hv : ∀ j, |v (j+1)|≤C) :
    |∫ g, gibbsReplicaMean (unitSphereLaw (n+1))
      (bulkHamiltonian (n+1) M f v a g) 2
      (fun x => inner ℝ (bulkTangentDirection (n+1) v G x) g) ∂stdGaussian (BulkMark (n+1))|≤
        8*‖G‖*C^2*bulkScale (n+1)^2 := by
  obtain ⟨D,hD⟩ := (isCompact_univ : IsCompact (univ : Set (Fin 2→NormalizedSpin (n+1)))).bddAbove_image
    (bulkTangentDirection_continuous (n+1) v G).norm.continuousOn
  have hWD (x : Fin 2→NormalizedSpin (n+1)) : ‖bulkTangentDirection (n+1) v G x‖≤ max D 0 :=
    (hD (mem_image_of_mem _ (mem_univ x))).trans (le_max_left _ _)
  have he := euclideanGaussian_replica_direction_bound (unitSphereLaw (n+1)) 2
    ((normalizedPatternEnergy_continuous (n+1) M f).measurable.comp (measurable_const.prodMk measurable_id))
    (bulkFeature_continuous (n+1) v).measurable
    (bulkTangentDirection_continuous (n+1) v G).measurable
    (Real.sqrt_nonneg _) (le_max_right D 0) (by positivity : 0≤2*‖G‖*C^2*bulkScale (n+1)^2)
    (normalizedPatternEnergy_bound (n+1) M f a)
    (fun x => le_of_eq (by simpa only [bulkFeatureBound] using bulkFeature_norm (n+1) v x))
    hWD (bulkTangentDirection_cross_bound (n+1) v G hC hv)
  apply he.trans_eq
  norm_num
  ring

def bulkPatternLinear {N : ℕ} (a : Fin N→ℝ) : Spin N→L[ℝ]ℝ :=
  ∑ i, a i • EuclideanSpace.proj i

lemma bulkPatternLinear_apply {N : ℕ} (a : Fin N→ℝ) (x : Spin N) :
    bulkPatternLinear a x=∑ i,a i*x i := by
  simp only [bulkPatternLinear,sum_apply,smul_apply,
    smul_eq_mul]
  rfl

def ambientBulkHamiltonian (N M : ℕ) (f : Jet3) (v : ℕ→ℝ)
    (a : Fin M→Fin N→ℝ) (g : BulkMark N) (x : Spin N) : ℝ :=
  (∑ j,f.f (bulkPatternLinear (a j) x))+inner ℝ g (ambientBulkFeature N v x)

lemma ambientBulkHamiltonian_eq (N M : ℕ) (f : Jet3) (v : ℕ→ℝ)
    (a : Fin M→Fin N→ℝ) (g : BulkMark N) (x : NormalizedSpin N) :
    ambientBulkHamiltonian N M f v a g x.val=bulkHamiltonian N M f.f v a g x := by
  simp only [ambientBulkHamiltonian,bulkHamiltonian,normalizedPatternEnergy,
    bulkPatternLinear_apply,ambientBulkFeature_eq,real_inner_comm g]

lemma ambientBulkHamiltonian_contDiff (N M : ℕ) (f : Jet3) (v : ℕ→ℝ)
    (a : Fin M→Fin N→ℝ) (g : BulkMark N) :
    ContDiff ℝ 1 (ambientBulkHamiltonian N M f v a g) := by
  apply (ContDiff.sum (fun j _ => (f.contDiff.of_le (by norm_num)).comp (bulkPatternLinear (a j)).contDiff)).add
  exact (innerSL ℝ g).contDiff.comp ((ambientBulkFeature_contDiff N v).of_le (by norm_num))

lemma ambientBulkHamiltonian_deriv (N M : ℕ) (f : Jet3) (v : ℕ→ℝ)
    (a : Fin M→Fin N→ℝ) (g : BulkMark N) (x z : Spin N) :
    fderiv ℝ (ambientBulkHamiltonian N M f v a g) x z =
      (∑ j,f.d1 (bulkPatternLinear (a j) x)*bulkPatternLinear (a j) z)+
        inner ℝ (fderiv ℝ (ambientBulkFeature N v) x z) g := by
  have hd := HasFDerivAt.fun_sum (fun j (_ : j∈(Finset.univ : Finset (Fin M))) =>
    (f.has1 (bulkPatternLinear (a j) x)).comp_hasFDerivAt x (bulkPatternLinear (a j)).hasFDerivAt)
  have hg := (innerSL ℝ g).hasFDerivAt.comp x
    (((ambientBulkFeature_contDiff N v).differentiable (by norm_num)) x).hasFDerivAt
  have he := (hd.add hg).fderiv
  change fderiv ℝ (ambientBulkHamiltonian N M f v a g) x z=_
  rw [show fderiv ℝ (ambientBulkHamiltonian N M f v a g) x = _ from he]
  simp only [add_apply,sum_apply,
    smul_apply,smul_eq_mul,ContinuousLinearMap.comp_apply,coe_innerSL_apply]
  rw [real_inner_comm g]

lemma bulk_gibbs_replica_tangent (n M : ℕ) (f : Jet3) (v : ℕ→ℝ)
    (a : Fin M→Fin (n+1)→ℝ) (g : BulkMark (n+1))
    (G : ℝ→ᵇℝ) (hG : ContDiff ℝ 1 (G : ℝ→ℝ)) :
    (n:ℝ)*gibbsReplicaMean (unitSphereLaw (n+1)) (bulkHamiltonian (n+1) M f.f v a g) 2
      (fun x => spinOverlap (x 0) (x 1)*G (spinOverlap (x 0) (x 1))) =
    gibbsReplicaMean (unitSphereLaw (n+1)) (bulkHamiltonian (n+1) M f.f v a g) 2
      (fun x => deriv (G : ℝ→ℝ) (spinOverlap (x 0) (x 1))*(1-spinOverlap (x 0) (x 1)^2)+
        (∑ j,G (spinOverlap (x 0) (x 1))*f.d1 (∑ i,a j i*(x 0).val i)*
          ((∑ i,a j i*(x 1).val i)-spinOverlap (x 0) (x 1)*(∑ i,a j i*(x 0).val i)))+
        inner ℝ (bulkTangentDirection (n+1) v G x) g) := by
  have he := unitSphere_gibbs_replica_tangent n (ambientBulkHamiltonian_contDiff (n+1) M f v a g) hG
  simp only [ambientBulkHamiltonian_eq] at he
  rw [he]
  apply congrArg (gibbsReplicaMean (unitSphereLaw (n+1)) (bulkHamiltonian (n+1) M f.f v a g) 2)
  funext x
  rw [ambientBulkHamiltonian_deriv]
  have hs : (∑ j,G (spinOverlap (x 0) (x 1))*
      (f.d1 (bulkPatternLinear (a j) (x 0).val)*
        bulkPatternLinear (a j) ((x 1).val-spinOverlap (x 0) (x 1) • (x 0).val))) =
      ∑ j,G (spinOverlap (x 0) (x 1))*f.d1 (∑ i,a j i*(x 0).val i)*
        ((∑ i,a j i*(x 1).val i)-spinOverlap (x 0) (x 1)*(∑ i,a j i*(x 0).val i)) := by
    apply Finset.sum_congr rfl
    intro j _
    simp only [map_sub,map_smul,smul_eq_mul,bulkPatternLinear_apply]
    ring
  simp only [bulkTangentDirection,inner_smul_left,starRingEnd_apply,star_trivial]
  rw [mul_add,Finset.mul_sum,hs]
  ring

end SphericalPerceptronFreeEnergy
end

end OAI