import Mathlib
import OAI.Probability.Perceptron.Interpolation.GibbsOverlapArray

namespace OAI

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

def bulkScale (N : ℕ) : ℝ := (N:ℝ)^((3:ℝ)/8)
def bulkDegree {N : ℕ} (p : Fin N) : ℕ := p.val+1
abbrev BulkMark (N : ℕ) := EnrichedMark N N bulkDegree

def bulkAmplitude (N : ℕ) (v : ℕ → ℝ) (p : Fin N) : ℝ :=
  bulkScale N * (2:ℝ)^(-((p.val+1:ℕ):ℤ))*v (p.val+1)

def bulkFeature (N : ℕ) (v : ℕ → ℝ) : NormalizedSpin N → BulkMark N :=
  enrichedFeature N N bulkDegree 0 (bulkAmplitude N v)

def bulkCovariance (N : ℕ) (v : ℕ → ℝ) (r : ℝ) : ℝ :=
  ∑ p : Fin N, ((2:ℝ)^(-((p.val+1:ℕ):ℤ)))^2 * (v (p.val+1))^2 * r^(p.val+1)

def bulkHamiltonian (N M : ℕ) (f : ℝ →ᵇ ℝ) (v : ℕ → ℝ)
    (a : Fin M → Fin N → ℝ) (g : BulkMark N) (x : NormalizedSpin N) : ℝ :=
  normalizedPatternEnergy N M f a x + inner ℝ (bulkFeature N v x) g

def bulkLogPartition (n M : ℕ) (f : ℝ →ᵇ ℝ) (v : ℕ → ℝ)
    (a : Fin M → Fin (n+1) → ℝ) (g : BulkMark (n+1)) : ℝ :=
  vectorLogPartition (unitSphereLaw (n+1)) (normalizedPatternEnergy (n+1) M f a)
    (fun x => innerSL ℝ (bulkFeature (n+1) v x)) g

def bulkDisorderLaw (N M : ℕ) : Measure ((Fin M → Fin N → ℝ) × BulkMark N) :=
  (Measure.pi (fun _ => Measure.pi (fun _ => gaussianReal 0 1))).prod (stdGaussian (BulkMark N))

instance bulkDisorderLaw_probability (N M : ℕ) : IsProbabilityMeasure (bulkDisorderLaw N M) := by
  unfold bulkDisorderLaw
  infer_instance

def bulkExpectedLog (n M : ℕ) (f : ℝ →ᵇ ℝ) (v : ℕ → ℝ) : ℝ :=
  ∫ a, bulkLogPartition n M f v a.1 a.2 ∂bulkDisorderLaw (n+1) M

def bulkB (N M : ℕ) (f : Jet3) (a : Fin M → Fin N → ℝ)
    (x y : NormalizedSpin N) : ℝ :=
  (N:ℝ)⁻¹ * ∑ j, f.d1 (∑ i, a j i*x.val i) * f.d1 (∑ i, a j i*y.val i)

def bulkC (N M : ℕ) (f : Jet3) (a : Fin M → Fin N → ℝ)
    (x : NormalizedSpin N) : ℝ :=
  (N:ℝ)⁻¹ * ∑ j, (f.d2 (∑ i, a j i*x.val i) -
    (∑ i, a j i*x.val i)*f.d1 (∑ i, a j i*x.val i))

lemma bulkFeature_continuous (N : ℕ) (v : ℕ → ℝ) : Continuous (bulkFeature N v) :=
  enrichedFeature_continuous N N bulkDegree 0 (bulkAmplitude N v)

lemma bulkFeature_inner (N : ℕ) (v : ℕ → ℝ) (x y : NormalizedSpin N) :
    inner ℝ (bulkFeature N v x) (bulkFeature N v y) =
      bulkScale N ^ 2 * bulkCovariance N v (spinOverlap x y) := by
  rw [bulkFeature, enrichedFeature_inner]
  simp only [zero_pow two_ne_zero, zero_mul, zero_add, bulkCovariance, Finset.mul_sum,
    bulkAmplitude, bulkDegree]
  apply Finset.sum_congr rfl
  intro i _
  ring

lemma bulkFeature_norm_sq (N : ℕ) (v : ℕ → ℝ) (x : NormalizedSpin N) :
    ‖bulkFeature N v x‖^2 = ∑ p, bulkAmplitude N v p^2 := by
  rw [bulkFeature, enrichedFeature_norm_sq]
  simp

lemma bulkLogPartition_eq (n M : ℕ) (f : ℝ →ᵇ ℝ) (v : ℕ → ℝ)
    (a : Fin M → Fin (n+1) → ℝ) (g : BulkMark (n+1)) :
    bulkLogPartition n M f v a g =
      Real.log (tiltPartition (unitSphereLaw (n+1)) (bulkHamiltonian (n+1) M f v a g) 1) := by
  simp only [bulkLogPartition, vectorLogPartition, vectorPartition, tiltPartition, one_mul, bulkHamiltonian,
    innerSL_apply_apply]

lemma bulkB_bound (N M : ℕ) (f : Jet3) (a : Fin M → Fin N → ℝ)
    (x y : NormalizedSpin N) : |bulkB N M f a x y| ≤ (M:ℝ)/(N:ℝ)*‖f.d1‖^2 := by
  unfold bulkB
  rw [abs_mul, abs_of_nonneg (inv_nonneg.mpr (Nat.cast_nonneg N))]
  calc
    _ ≤ (N:ℝ)⁻¹ * ∑ _ : Fin M, ‖f.d1‖^2 := by
      apply mul_le_mul_of_nonneg_left _ (inv_nonneg.mpr (Nat.cast_nonneg N))
      exact (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum fun j _ => by
        rw [abs_mul, pow_two]
        exact mul_le_mul (f.d1.norm_coe_le_norm _) (f.d1.norm_coe_le_norm _)
          (abs_nonneg _) (norm_nonneg _))
    _ = _ := by simp; ring

abbrev BulkDisorder (N M : ℕ) := (Fin M→Fin N→ℝ) × BulkMark N

def bulkFeatureBound (N : ℕ) (v : ℕ→ℝ) : ℝ := Real.sqrt (∑ p, bulkAmplitude N v p^2)

lemma bulkFeature_norm (N : ℕ) (v : ℕ→ℝ) (x : NormalizedSpin N) :
    ‖bulkFeature N v x‖=bulkFeatureBound N v := by
  rw [bulkFeature, enrichedFeature_norm]
  simp [bulkFeatureBound]

lemma bulkHamiltonian_continuous (N M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ) :
    Continuous (fun p : BulkDisorder N M × NormalizedSpin N =>
      bulkHamiltonian N M f v p.1.1 p.1.2 p.2) := by
  unfold bulkHamiltonian
  exact ((normalizedPatternEnergy_continuous N M f).comp
    (continuous_fst.fst.prodMk continuous_snd)).add
    (((bulkFeature_continuous N v).comp continuous_snd).inner continuous_fst.snd)

lemma bulkHamiltonian_bound (N M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ) (a : BulkDisorder N M)
    (x : NormalizedSpin N) :
    |bulkHamiltonian N M f v a.1 a.2 x| ≤ M*‖f‖+bulkFeatureBound N v*‖a.2‖ := by
  apply (abs_add_le _ _).trans
  exact add_le_add (normalizedPatternEnergy_bound _ _ _ _ _) (by
    simpa only [bulkFeature_norm] using abs_real_inner_le_norm (bulkFeature N v x) a.2)

lemma bulkHamiltonian_exp_integrable (n M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ)
    (a : BulkDisorder (n+1) M) :
    Integrable (fun x => Real.exp (bulkHamiltonian (n+1) M f v a.1 a.2 x)) (unitSphereLaw (n+1)) := by
  apply Integrable.of_bound
    ((bulkHamiltonian_continuous (n+1) M f v).measurable.comp
      (measurable_const.prodMk measurable_id)).exp.aestronglyMeasurable
    (Real.exp (M*‖f‖+bulkFeatureBound (n+1) v*‖a.2‖))
  exact ae_of_all _ fun x => by
    rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
    exact Real.exp_le_exp.mpr ((le_abs_self _).trans (bulkHamiltonian_bound (n+1) M f v a x))

def bulkSpinKernel (n M : ℕ) : Kernel (BulkDisorder (n+1) M) (NormalizedSpin (n+1)) :=
  Kernel.const _ (unitSphereLaw (n+1))

instance bulkSpinKernel_markov (n M : ℕ) : IsMarkovKernel (bulkSpinKernel n M) := by
  unfold bulkSpinKernel; infer_instance

def bulkOverlap {N : ℕ} (x y : NormalizedSpin N) : CompactOverlap :=
  ⟨spinOverlap x y,abs_le.mp (spinOverlap_abs_le x y)⟩

lemma bulkOverlap_measurable (N : ℕ) : Measurable (Function.uncurry (bulkOverlap (N:=N))) := by
  apply Measurable.subtype_mk
  exact measurable_fst.subtype_val.inner measurable_snd.subtype_val

def bulkGibbsArrayLaw (n M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ) :
    ProbabilityMeasure (CompactArray CompactOverlap) :=
  gibbsOverlapArrayLaw (bulkSpinKernel n M) (bulkDisorderLaw (n+1) M)
    (fun a x => bulkHamiltonian (n+1) M f v a.1 a.2 x)
    (bulkHamiltonian_continuous (n+1) M f v).measurable bulkOverlap (bulkOverlap_measurable (n+1))

lemma bulkGibbsArray_block (n M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ) (r : ℕ)
    (F : CompactBlock CompactOverlap r →ᵇ ℝ) :
    (∫ R, F (compactBlock r R) ∂bulkGibbsArrayLaw n M f v) =
      ∫ a, gibbsReplicaMean (unitSphereLaw (n+1)) (bulkHamiltonian (n+1) M f v a.1 a.2) r
        (fun x => F (fun i j => bulkOverlap (x i) (x j))) ∂bulkDisorderLaw (n+1) M := by
  exact gibbsOverlapArray_block (bulkSpinKernel n M) (bulkDisorderLaw (n+1) M)
    (fun a x => bulkHamiltonian (n+1) M f v a.1 a.2 x)
    (bulkHamiltonian_continuous (n+1) M f v).measurable _ (bulkOverlap_measurable (n+1))
    (ae_of_all _ (bulkHamiltonian_exp_integrable n M f v)) r F

end SphericalPerceptronFreeEnergy
end

end OAI