import Mathlib
import OAI.Probability.Perceptron.Cavity.BulkAnnealedTangent
import OAI.Probability.Perceptron.Cavity.BulkPairLaw
import OAI.Probability.Perceptron.Interpolation.AnnealedMarkedReplica

namespace OAI

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

lemma bulkB_measurable (N M : ℕ) (f : Jet3) :
    Measurable (fun p : BulkDisorder N M×(NormalizedSpin N×NormalizedSpin N) =>
      bulkB N M f p.1.1 p.2.1 p.2.2) := by
  unfold bulkB
  fun_prop

lemma bulkB_pairAverage (n M : ℕ) (f : Jet3) (a : BulkDisorder (n+1) M)
    (x : Fin 2→NormalizedSpin (n+1)) :
    bulkB (n+1) M f a.1 (x 0) (x 1)=bulkPairAverage n M f.d1 a x := by
  simp only [bulkB,bulkPairAverage,pairFieldMark,Fin.prod_univ_two,bulkPatternFields]

lemma bulkB_symm (N M : ℕ) (f : Jet3) (a : Fin M→Fin N→ℝ) (x y : NormalizedSpin N) :
    bulkB N M f a x y=bulkB N M f a y x := by
  unfold bulkB
  simp_rw [mul_comm (f.d1 _) (f.d1 _)]

def bulkMarkedEntry (n M : ℕ) (f : Jet3) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) (a : BulkDisorder (n+1) M)
    (x y : NormalizedSpin (n+1)) : BulkPairRange K :=
  (bulkOverlap x y,⟨bulkB (n+1) M f a.1 x y,abs_le.mp ((bulkB_bound _ _ _ _ _ _).trans hK)⟩)

def bulkMarkedArray (n M : ℕ) (f : Jet3) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K)
    (p : BulkDisorder (n+1) M×(ℕ→NormalizedSpin (n+1))) : CompactArray (BulkPairRange K) :=
  fun i j => bulkMarkedEntry n M f K hK p.1 (p.2 i) (p.2 j)

lemma bulkMarkedArray_measurable (n M : ℕ) (f : Jet3) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) : Measurable (bulkMarkedArray n M f K hK) := by
  refine Measurable.of_eval fun i => Measurable.of_eval fun j => ?_
  have hm : Measurable (fun p : BulkDisorder (n+1) M×(ℕ→NormalizedSpin (n+1)) => (p.2 i,p.2 j)) := by fun_prop
  exact ((bulkOverlap_measurable _).comp hm).prodMk
    (((bulkB_measurable _ _ _).comp (measurable_fst.prodMk hm)).subtype_mk)

def bulkGibbsHamiltonian (n M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ) :
    BulkDisorder (n+1) M→NormalizedSpin (n+1)→ℝ :=
  fun a => bulkHamiltonian (n+1) M f v a.1 a.2

lemma bulkGibbsHamiltonian_measurable (n M : ℕ) (f : ℝ→ᵇℝ) (v : ℕ→ℝ) :
    Measurable (Function.uncurry (bulkGibbsHamiltonian n M f v)) :=
  (bulkHamiltonian_continuous (n+1) M f v).measurable

def bulkMarkedArrayLaw (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) : ProbabilityMeasure (CompactArray (BulkPairRange K)) :=
  ⟨(annealedInfiniteReplicaMeasure (bulkSpinKernel n M) (bulkDisorderLaw (n+1) M)
      (bulkGibbsHamiltonian n M f.f v) (bulkGibbsHamiltonian_measurable n M f.f v)).map
        (bulkMarkedArray n M f K hK),
    (Measure.isProbabilityMeasure_map_iff (bulkMarkedArray_measurable _ _ _ _ _).aemeasurable).2 inferInstance⟩

lemma bulkMarkedArray_block (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) (r : ℕ) (F : CompactBlock (BulkPairRange K) r→ᵇℝ) :
    (∫ Q,F (compactBlock r Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _))=
      bulkReplicaMean n M f.f v r (fun a x => F (fun i j => bulkMarkedEntry n M f K hK a (x i) (x j))) := by
  change (∫ Q,F (compactBlock r Q) ∂Measure.map (bulkMarkedArray n M f K hK)
    (annealedInfiniteReplicaMeasure (bulkSpinKernel n M) (bulkDisorderLaw (n+1) M)
      (bulkGibbsHamiltonian n M f.f v) (bulkGibbsHamiltonian_measurable n M f.f v)))=_
  have hm : Measurable (fun Q : CompactArray (BulkPairRange K) => F (compactBlock r Q)) :=
    F.measurable.comp (compactBlock_continuous r).measurable
  rw [integral_map (bulkMarkedArray_measurable n M f K hK).aemeasurable hm.aestronglyMeasurable]
  unfold bulkReplicaMean
  apply annealedInfiniteReplica_marked_prefix (bulkSpinKernel n M) (bulkDisorderLaw (n+1) M)
    (bulkGibbsHamiltonian n M f.f v) (bulkGibbsHamiltonian_measurable n M f.f v)
    (ae_of_all _ (bulkHamiltonian_exp_integrable n M f.f v)) r
    (G := fun a x => F (fun i j => bulkMarkedEntry n M f K hK a (x i) (x j)))
  · apply F.measurable.comp
    refine Measurable.of_eval fun i => Measurable.of_eval fun j => ?_
    have hm : Measurable (fun p : BulkDisorder (n+1) M×(Fin r→NormalizedSpin (n+1)) => (p.2 i,p.2 j)) := by fun_prop
    exact ((bulkOverlap_measurable _).comp hm).prodMk
      (((bulkB_measurable _ _ _).comp (measurable_fst.prodMk hm)).subtype_mk)
  · intro a x
    exact F.norm_coe_le_norm _

lemma bulkMarkedArray_exchangeable (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) (e : Equiv.Perm ℕ) :
    MeasurePreserving (compactRelabel (K:=BulkPairRange K) e)
      (bulkMarkedArrayLaw n M f v K hK : Measure _) (bulkMarkedArrayLaw n M f v K hK : Measure _) := by
  have hr := annealedInfiniteReplica_reindex (bulkSpinKernel n M) (bulkDisorderLaw (n+1) M)
    (bulkGibbsHamiltonian n M f.f v) (bulkGibbsHamiltonian_measurable n M f.f v) e
  have hm := bulkMarkedArray_measurable n M f K hK
  refine ⟨(compactRelabel_continuous e).measurable,?_⟩
  change Measure.map _ (Measure.map (bulkMarkedArray n M f K hK) _)=_
  rw [Measure.map_map (compactRelabel_continuous e).measurable hm]
  change Measure.map ((bulkMarkedArray n M f K hK) ∘
    (fun a : BulkDisorder (n+1) M×(ℕ→NormalizedSpin (n+1)) => (a.1,fun i => a.2 (e i)))) _=_
  rw [←Measure.map_map hm hr.measurable,hr.map_eq]
  rfl

lemma bulkMarkedArray_overlap (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) :
    compactMapLaw Prod.fst continuous_fst (bulkMarkedArrayLaw n M f v K hK)=bulkGibbsArrayLaw n M f.f v := by
  apply Subtype.ext
  change Measure.map (fun Q : CompactArray (BulkPairRange K) => fun i j => (Q i j).1)
    (Measure.map (bulkMarkedArray n M f K hK) _) = _
  rw [Measure.map_map (by fun_prop) (bulkMarkedArray_measurable _ _ _ _ _)]
  rfl

lemma bulkMarkedArray_pair (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) :
    (bulkMarkedArrayLaw n M f v K hK).map (fun Q => Q 1 0)=
      bulkPairLaw n M f.f f.d1 v K hK := by
  apply ProbabilityMeasure.toMeasure_injective
  apply ext_of_forall_integral_eq_of_IsFiniteMeasure
  intro F
  rw [ProbabilityMeasure.toMeasure_map,integral_map (by fun_prop : Measurable (fun Q : CompactArray (BulkPairRange K)=>Q 1 0)).aemeasurable F.continuous.aestronglyMeasurable,
    bulkPairLaw_integral]
  let T : CompactBlock (BulkPairRange K) 2→ᵇℝ := F.compContinuous ⟨fun Q=>Q 1 0,by fun_prop⟩
  have he := bulkMarkedArray_block n M f v K hK 2 T
  change (∫ Q : CompactArray (BulkPairRange K),F (Q 1 0) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _))=_ at he
  rw [he]
  unfold bulkReplicaMean
  apply integral_congr_ae
  exact ae_of_all _ fun a => by
    apply congrArg (gibbsReplicaMean (unitSphereLaw (n+1)) (bulkHamiltonian (n+1) M f.f v a.1 a.2) 2)
    funext x
    apply congrArg F
    change bulkMarkedEntry n M f K hK a (x 1) (x 0) = bulkCompactPair n M f.d1 K hK (a,x)
    apply Prod.ext
    · rfl
    · apply Subtype.ext
      exact (bulkB_symm _ _ _ _ _ _).trans (bulkB_pairAverage _ _ _ a x)

def markedTangentR (K : ℝ) (G : ℝ→ᵇℝ) : CompactBlock (BulkPairRange K) 2→ᵇℝ :=
  BoundedContinuousFunction.mkOfCompact ⟨fun Q => (Q 0 1).1.val*G (Q 0 1).1.val,by fun_prop⟩
def markedTangentPair (K : ℝ) (G : ℝ→ᵇℝ) : CompactBlock (BulkPairRange K) 2→ᵇℝ :=
  BoundedContinuousFunction.mkOfCompact ⟨fun Q => G (Q 0 1).1.val*(Q 0 1).2.val*(1-(Q 0 1).1.val^2),by fun_prop⟩
def markedTangentTriple (K : ℝ) (G : ℝ→ᵇℝ) : CompactBlock (BulkPairRange K) 3→ᵇℝ :=
  BoundedContinuousFunction.mkOfCompact ⟨fun Q => G (Q 1 2).1.val*(Q 1 0).2.val*((Q 2 0).1.val-(Q 1 2).1.val*(Q 1 0).1.val),by fun_prop⟩

lemma bulk_tangent_pair_sum (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (G : ℝ→ᵇℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) :
    (∑ j : Fin M,bulkReplicaMean n M f.f v 2 (fun a => freshTangentPair (n+1) f G (WithLp.toLp 2 (a.1 j))))=
      (n+1:ℕ)*(∫ Q,markedTangentPair K G (compactBlock 2 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _)) := by
  have hm (j : Fin M) : Measurable (Function.uncurry (fun a : BulkDisorder (n+1) M => freshTangentPair (n+1) f G (WithLp.toLp 2 (a.1 j)))) := by
    have hc : Continuous (Function.uncurry (fun a : BulkDisorder (n+1) M => freshTangentPair (n+1) f G (WithLp.toLp 2 (a.1 j)))) := by
      unfold Function.uncurry freshTangentPair spinOverlap
      fun_prop
    exact hc.measurable
  have hs := bulkReplicaMean_sum n M 2 f.f v Finset.univ
    (fun j a => freshTangentPair (n+1) f G (WithLp.toLp 2 (a.1 j)))
    (fun j _ => hm j)
    (fun _ => 2*‖G‖*‖f.d1‖^2) (by intros; positivity)
    (fun j _ a x => freshTangentPair_bound _ _ _ _ x)
  rw [←hs,bulkMarkedArray_block,←bulkReplicaMean_const_mul]
  apply congrArg (bulkReplicaMean n M f.f v 2)
  funext a x
  change (∑ j : Fin M,G (spinOverlap (x 0) (x 1))*f.d1 (inner ℝ (x 0).val (WithLp.toLp 2 (a.1 j)))*
    f.d1 (inner ℝ (x 1).val (WithLp.toLp 2 (a.1 j)))*(1-spinOverlap (x 0) (x 1)^2))=
    ((n+1:ℕ):ℝ)*(G (spinOverlap (x 0) (x 1))*bulkB (n+1) M f a.1 (x 0) (x 1)*(1-spinOverlap (x 0) (x 1)^2))
  have he (z : NormalizedSpin (n+1)) (j : Fin M) : inner ℝ z.val (WithLp.toLp 2 (a.1 j))=∑ i,a.1 j i*z.val i := by
    simp only [EuclideanSpace.inner_eq_star_dotProduct,star_trivial,dotProduct]
  simp_rw [he]
  unfold bulkB
  have hn : ((n+1:ℕ):ℝ)≠0 := by positivity
  simp_rw [mul_assoc (G _)]
  rw [←Finset.mul_sum,←Finset.sum_mul]
  field_simp

lemma bulk_tangent_triple_sum (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (G : ℝ→ᵇℝ) (K : ℝ)
    (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K) :
    (∑ j : Fin M,bulkReplicaMean n M f.f v 3 (fun a => freshTangentTriple (n+1) f G (WithLp.toLp 2 (a.1 j))))=
      (n+1:ℕ)*(∫ Q,markedTangentTriple K G (compactBlock 3 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _)) := by
  have hm (j : Fin M) : Measurable (Function.uncurry (fun a : BulkDisorder (n+1) M => freshTangentTriple (n+1) f G (WithLp.toLp 2 (a.1 j)))) := by
    have hc : Continuous (Function.uncurry (fun a : BulkDisorder (n+1) M => freshTangentTriple (n+1) f G (WithLp.toLp 2 (a.1 j)))) := by
      unfold Function.uncurry freshTangentTriple spinOverlap
      fun_prop
    exact hc.measurable
  have hs := bulkReplicaMean_sum n M 3 f.f v Finset.univ
    (fun j a => freshTangentTriple (n+1) f G (WithLp.toLp 2 (a.1 j)))
    (fun j _ => hm j)
    (fun _ => 2*‖G‖*‖f.d1‖^2) (by intros; positivity)
    (fun j _ a x => freshTangentTriple_bound _ _ _ _ x)
  rw [←hs,bulkMarkedArray_block,←bulkReplicaMean_const_mul]
  apply congrArg (bulkReplicaMean n M f.f v 3)
  funext a x
  change (∑ j : Fin M,G (spinOverlap (x 1) (x 2))*f.d1 (inner ℝ (x 1).val (WithLp.toLp 2 (a.1 j)))*
    f.d1 (inner ℝ (x 0).val (WithLp.toLp 2 (a.1 j)))*(spinOverlap (x 2) (x 0)-spinOverlap (x 1) (x 2)*spinOverlap (x 1) (x 0)))=
    ((n+1:ℕ):ℝ)*(G (spinOverlap (x 1) (x 2))*bulkB (n+1) M f a.1 (x 1) (x 0)*(spinOverlap (x 2) (x 0)-spinOverlap (x 1) (x 2)*spinOverlap (x 1) (x 0)))
  have he (z : NormalizedSpin (n+1)) (j : Fin M) : inner ℝ z.val (WithLp.toLp 2 (a.1 j))=∑ i,a.1 j i*z.val i := by
    simp only [EuclideanSpace.inner_eq_star_dotProduct,star_trivial,dotProduct]
  simp_rw [he]
  unfold bulkB
  have hn : ((n+1:ℕ):ℝ)≠0 := by positivity
  simp_rw [mul_assoc (G _)]
  rw [←Finset.mul_sum,←Finset.sum_mul]
  field_simp

lemma bulk_marked_tangent_bound (n M : ℕ) (f : Jet3) (v : ℕ→ℝ) (G : ℝ→ᵇℝ)
    (hG : ContDiff ℝ 1 (G : ℝ→ℝ)) {C : ℝ} (hC : 0≤C) (hv : ∀ j,|v (j+1)|≤C)
    (K : ℝ) (hK : M/(n+1:ℕ)*‖f.d1‖^2≤K)
    {D : ℝ} (hD : 0≤D) (hbD : ∀ r : CompactOverlap,|deriv (G : ℝ→ℝ) r.val*(1-r.val^2)|≤D) :
    |(∫ Q,markedTangentR K G (compactBlock 2 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _))-
        (∫ Q,markedTangentPair K G (compactBlock 2 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _))+
        2*(∫ Q,markedTangentTriple K G (compactBlock 3 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _))|≤
      (‖G‖+D+8*‖G‖*C^2*bulkScale (n+1)^2)/(n+1:ℕ) := by
  have ht := bulk_tangent_annealed n M f v G hG hC hv
  rw [Finset.sum_sub_distrib,←Finset.mul_sum,bulk_tangent_pair_sum n M f v G K hK,bulk_tangent_triple_sum n M f v G K hK] at ht
  have hr := bulkMarkedArray_block n M f v K hK 2 (markedTangentR K G)
  change (∫ Q,markedTangentR K G (compactBlock 2 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _))=
    bulkReplicaMean n M f.f v 2 (fun _ x => spinOverlap (x 0) (x 1)*G (spinOverlap (x 0) (x 1))) at hr
  rw [←hr] at ht
  have hdb := bulkReplicaMean_bound n M 2 f.f v (fun _ => tangentDerivTest (n+1) G)
    ((tangentDerivTest_continuous (n+1) G hG).measurable.comp measurable_snd) hD (fun _ x => hbD (bulkOverlap (x 0) (x 1)))
  have hrb : |∫ Q,markedTangentR K G (compactBlock 2 Q) ∂(bulkMarkedArrayLaw n M f v K hK : Measure _)|≤‖G‖ := by
    have hb : ∀ Q : CompactArray (BulkPairRange K),‖markedTangentR K G (compactBlock 2 Q)‖≤‖G‖ := by
      intro Q
      change |(Q 0 1).1.val*G (Q 0 1).1.val|≤‖G‖
      rw [abs_mul]
      exact (mul_le_mul (abs_le.mpr (Q 0 1).1.property) (G.norm_coe_le_norm _) (abs_nonneg _) (by norm_num : (0:ℝ)≤1)).trans (by simp)
    simpa [Real.norm_eq_abs,Measure.real] using norm_integral_le_of_norm_le_const (ae_of_all (bulkMarkedArrayLaw n M f v K hK : Measure _) hb)
  have hn : (0:ℝ)<(n+1:ℕ) := by positivity
  rw [le_div_iff₀ hn,←abs_of_pos hn,←abs_mul]
  have halg (X Y Z W : ℝ) : (X-Y+2*Z)*(n+1:ℕ)=X+W+((n:ℝ)*X-W-((n+1:ℕ)*Y-2*((n+1:ℕ)*Z))) := by push_cast; ring
  rw [halg]
  exact (abs_add_le _ _).trans (add_le_add ((abs_add_le _ _).trans (add_le_add hrb hdb)) ht)

end SphericalPerceptronFreeEnergy
end

end OAI