import Mathlib
import OAI.Probability.SKRatio.FiniteChain.Mean
import OAI.Probability.SKRatio.Matrices.Spin
import OAI.Probability.SKRatio.Matrices.MatrixCoordinates
import OAI.Probability.SKRatio.Matrices.GaussianCoordinates

namespace OAI

section
section

noncomputable section
open MeasureTheory ProbabilityTheory Matrix
open scoped BigOperators ENNReal
namespace SKRatioGaussian.GaussianRegression

theorem law_eq_of_mean_covariance {Ω Ω' ι : Type*}
    [MeasurableSpace Ω] [MeasurableSpace Ω'] [Fintype ι] [DecidableEq ι]
    {P : Measure Ω} {P' : Measure Ω'} {X : Ω → ι → ℝ} {Y : Ω' → ι → ℝ}
    (hX : HasGaussianLaw X P) (hY : HasGaussianLaw Y P')
    (hm : ∀ i, (∫ w, X w i ∂P) = ∫ w, Y w i ∂P')
    (hc : ∀ i k, cov[fun w => X w i, fun w => X w k; P] =
      cov[fun w => Y w i, fun w => Y w k; P']) :
    P.map X = P'.map Y := by
  classical
  have := hX.isProbabilityMeasure
  have := hY.isProbabilityMeasure
  apply Measure.ext_of_charFunDual
  ext L
  rw [hX.charFunDual_map_eq,hY.charFunDual_map_eq]
  let c : ι → ℝ := fun i => L (fun k => if i=k then 1 else 0)
  have hL (x : ι → ℝ) : L x = ∑ i, x i * c i := by
    simpa only [c, smul_eq_mul, ContinuousLinearMap.coe_coe] using L.toLinearMap.pi_apply_eq_sum_univ x
  have hLX : L ∘ X = fun w => ∑ i, X w i*c i := funext (fun w => hL (X w))
  have hLY : L ∘ Y = fun w => ∑ i, Y w i*c i := funext (fun w => hL (Y w))
  have hiX (i : ι) := (hX.eval i).memLp_two
  have hiY (i : ι) := (hY.eval i).memLp_two
  have hem : (∫ w, (L ∘ X) w ∂P) = ∫ w, (L ∘ Y) w ∂P' := by
    rw [hLX,hLY]
    rw [integral_finsetSum _ (fun i _ => ((hX.eval i).integrable.mul_const _)),
      integral_finsetSum _ (fun i _ => ((hY.eval i).integrable.mul_const _))]
    simp only [integral_mul_const,hm]
  have hev : Var[L ∘ X; P] = Var[L ∘ Y; P'] := by
    rw [← covariance_self (hX.map L).aemeasurable,
      ← covariance_self (hY.map L).aemeasurable]
    rw [hLX,hLY]
    rw [covariance_fun_sum_fun_sum (fun i => (hiX i).mul_const _) (fun i => (hiX i).mul_const _),
      covariance_fun_sum_fun_sum (fun i => (hiY i).mul_const _) (fun i => (hiY i).mul_const _)]
    simp only [covariance_mul_const_left,covariance_mul_const_right,hc]
  rw [hev,hem]

def matrixCLM {ι κ : Type*} [Fintype κ] (A : Matrix ι κ ℝ) :
    (κ → ℝ) →L[ℝ] (ι → ℝ) := A.mulVecLin.toContinuousLinearMap

@[simp] lemma matrixCLM_apply {ι κ : Type*} [Fintype κ] (A : Matrix ι κ ℝ) (x : κ → ℝ) :
    matrixCLM A x = A *ᵥ x := rfl

theorem residual_independent {Ω ι κ : Type*} [MeasurableSpace Ω]
    [Fintype ι] [Fintype κ] {P : Measure Ω} {X : Ω → ι → ℝ} {Y : Ω → κ → ℝ}
    (hXY : HasGaussianLaw (fun w => (X w,Y w)) P) (K : Matrix ι κ ℝ)
    (hcov : ∀ i k, cov[fun w => X w i, fun w => Y w k; P] =
      ∑ l, K i l * cov[fun w => Y w l,fun w => Y w k; P]) :
    IndepFun (fun w => X w-K*ᵥ Y w) Y P := by
  have := hXY.isProbabilityMeasure
  have hR : HasGaussianLaw (fun w => (X w-K*ᵥ Y w,Y w)) P := by
    exact hXY.map_fun (((ContinuousLinearMap.fst ℝ (ι → ℝ) (κ → ℝ))-
      (matrixCLM K).comp (ContinuousLinearMap.snd ℝ (ι → ℝ) (κ → ℝ))).prod
      (ContinuousLinearMap.snd ℝ (ι → ℝ) (κ → ℝ)))
  apply hR.indepFun_of_covariance_eval
  intro i k
  change cov[fun w => X w i-∑ l, K i l*Y w l,fun w => Y w k; P]=0
  have hK : MemLp (fun w => ∑ l, K i l*Y w l) 2 P :=
    ((hXY.snd.map (matrixCLM K)).eval i).memLp_two
  rw [covariance_fun_sub_left (hXY.fst.eval i).memLp_two hK (hXY.snd.eval k).memLp_two]
  rw [covariance_fun_sum_left (fun l => (hXY.snd.eval l).memLp_two.const_mul _)
    (hXY.snd.eval k).memLp_two]
  simp only [covariance_const_mul_left,hcov,sub_self]

end SKRatioGaussian.GaussianRegression
end
end

section
noncomputable section
namespace SKRatioGaussian
open MeasureTheory ProbabilityTheory Matrix
open scoped BigOperators ENNReal

lemma coordinate_hasLaw {κ : Type*} [Fintype κ] (i : κ) :
    HasLaw (fun g : κ → ℝ => g i) (gaussianReal 0 1) (gaussianCoordinates κ) :=
  ⟨(measurable_pi_apply i).aemeasurable,
    (measurePreserving_eval (fun _ : κ => gaussianReal 0 1) i).map_eq⟩

lemma coordinates_gaussian {κ : Type*} [Fintype κ] :
    HasGaussianLaw (fun g : κ → ℝ => g) (gaussianCoordinates κ) :=
  (iIndepFun_pi (fun _ : κ => aemeasurable_id)).hasGaussianLaw
    (fun i => (coordinate_hasLaw i).hasGaussianLaw)

lemma coordinate_covariance {κ : Type*} [Fintype κ] [DecidableEq κ] (i k : κ) :
    cov[fun g : κ → ℝ => g i,fun g : κ → ℝ => g k;gaussianCoordinates κ] =
      if i=k then 1 else 0 := by
  by_cases h : i=k
  · subst k
    rw [ite_eq_left rfl,covariance_self (measurable_pi_apply i).aemeasurable,
      (coordinate_hasLaw i).variance_eq]
    simp
  · rw [ite_eq_right h]
    exact ((iIndepFun_pi (fun _ : κ => aemeasurable_id)).indepFun h).covariance_eq_zero
      (coordinate_hasLaw i).hasGaussianLaw.memLp_two (coordinate_hasLaw k).hasGaussianLaw.memLp_two

lemma linear_gaussian_mean {κ : Type*} [Fintype κ] (a : κ → ℝ) :
    (∫ g, ∑ i, a i*g i ∂gaussianCoordinates κ) = 0 := by
  rw [integral_finsetSum _ (fun i _ => (coordinate_hasLaw i).hasGaussianLaw.integrable.const_mul _)]
  simp [integral_const_mul,(coordinate_hasLaw _).integral_eq]

lemma linear_gaussian_covariance {κ : Type*} [Fintype κ] [DecidableEq κ] (a b : κ → ℝ) :
    cov[fun g => ∑ i, a i*g i,fun g => ∑ i, b i*g i;gaussianCoordinates κ] =
      ∑ i, a i*b i := by
  rw [covariance_fun_sum_fun_sum
    (fun i => (coordinate_hasLaw i).hasGaussianLaw.memLp_two.const_mul _)
    (fun i => (coordinate_hasLaw i).hasGaussianLaw.memLp_two.const_mul _)]
  simp only [covariance_const_mul_left,covariance_const_mul_right,coordinate_covariance]
  simp [mul_comm]

lemma matrix_sample_gaussian {ι κ : Type*} [Fintype ι] [Fintype κ] (A : Matrix ι κ ℝ) :
    HasGaussianLaw (fun g => A*ᵥg) (gaussianCoordinates κ) :=
  coordinates_gaussian.map_fun (GaussianRegression.matrixCLM A)

lemma matrix_sample_covariance {ι κ : Type*} [Fintype κ] [DecidableEq κ]
    (A : Matrix ι κ ℝ) (i k : ι) :
    cov[fun g => (A*ᵥg) i,fun g => (A*ᵥg) k;gaussianCoordinates κ] = (A*Aᵀ) i k :=
  linear_gaussian_covariance (A i) (A k)

end SKRatioGaussian
end
end

section
noncomputable section
namespace SKRatioGaussian
open MeasureTheory ProbabilityTheory Matrix Real
open scoped BigOperators ENNReal

variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def goeEntryCoeff (r : ℝ) : Matrix (ι × ι) (MatrixCoordinates ι) ℝ :=
  fun p a => sqrt (2*r)/2 * ((if a=Sum.inl p then 1 else 0)+
    (if a=Sum.inl (p.2,p.1) then 1 else 0))

lemma goeEntryCoeff_sample (r : ℝ) (g : MatrixCoordinates ι → ℝ) (i k : ι) :
    (goeEntryCoeff r*ᵥg) (i,k) = goeMatrix r g i k := by
  simp only [mulVec,dotProduct,goeEntryCoeff,mul_assoc,add_mul]
  rw [← Finset.mul_sum,Finset.sum_add_distrib]
  simp [goeMatrix]

lemma goe_matrix_gaussian (r : ℝ) :
    HasGaussianLaw (fun (g : MatrixCoordinates ι → ℝ) (p : ι × ι) => goeMatrix r g p.1 p.2) (gaussianCoordinates (MatrixCoordinates ι)) := by
  have hh := matrix_sample_gaussian (goeEntryCoeff (ι := ι) r)
  simpa only [show (fun g => goeEntryCoeff (ι := ι) r*ᵥg) =
    (fun g p => goeMatrix r g p.1 p.2) from funext (fun g => funext (fun p => goeEntryCoeff_sample r g p.1 p.2))] using hh

lemma goe_mean_zero (r : ℝ) (i k : ι) :
    (∫ g, goeMatrix r g i k ∂gaussianCoordinates (MatrixCoordinates ι))=0 := by
  simpa only [← goeEntryCoeff_sample,mulVec,dotProduct] using linear_gaussian_mean (goeEntryCoeff (ι := ι) r (i,k))

lemma goe_entry_cov {r : ℝ} (hr : 0 ≤ r) (i k l m : ι) :
    cov[fun g => goeMatrix r g i k,fun g => goeMatrix r g l m;
      gaussianCoordinates (MatrixCoordinates ι)] =
    r*((if i=l then 1 else 0)*(if k=m then 1 else 0)+
       (if i=m then 1 else 0)*(if k=l then 1 else 0)) := by
  let μ := gaussianCoordinates (MatrixCoordinates ι)
  have hm (a : MatrixCoordinates ι) := (coordinate_hasLaw a).hasGaussianLaw.memLp_two
  change cov[fun g : MatrixCoordinates ι → ℝ => sqrt (2*r)/2*(g (.inl (i,k))+g (.inl (k,i))),
    fun g => sqrt (2*r)/2*(g (.inl (l,m))+g (.inl (m,l))); μ]=_
  rw [covariance_const_mul_left,covariance_const_mul_right]
  change sqrt (2*r)/2*(sqrt (2*r)/2*cov[(fun g => g (.inl (i,k))) + (fun g => g (.inl (k,i))),
    (fun g => g (.inl (l,m))) + (fun g => g (.inl (m,l)));gaussianCoordinates (MatrixCoordinates ι)]) = _
  rw [covariance_add_left (hm _) (hm _) ((hm _).add (hm _)),
    covariance_add_right (hm _) (hm _) (hm _),
    covariance_add_right (hm _) (hm _) (hm _)]
  simp only [coordinate_covariance,Sum.inl.injEq,Prod.mk.injEq]
  have hs : (sqrt (2*r)/2)^2=r/2 := by rw [div_pow,sq_sqrt (by positivity)]; ring
  have hs' : sqrt (2*r)/2*(sqrt (2*r)/2)=r/2 := by nlinarith only [hs]
  rw [← mul_assoc,hs']
  have hind (p q : Prop) [Decidable p] [Decidable q] :
      (if p ∧ q then (1:ℝ) else 0)=(if p then 1 else 0)*(if q then 1 else 0) := by
    split_ifs <;> simp_all
  simp_rw [hind]
  ring

end SKRatioGaussian
end
end

section
noncomputable section
namespace SKRatioGaussian
open MeasureTheory ProbabilityTheory Matrix Real
open scoped BigOperators
variable {n : ℕ}

def goeDisorder (r : ℝ) (g : MatrixCoordinates (Fin n)→ℝ) : Disorder n :=
  fun e=>goeMatrix r g e.1.1 e.1.2

lemma goeDisorder_gaussian (r : ℝ) :
    HasGaussianLaw (goeDisorder (n:=n) r) (gaussianCoordinates (MatrixCoordinates (Fin n))) :=
  (goe_matrix_gaussian (ι:=Fin n) r).map_fun (ContinuousLinearMap.pi (fun e : Edge n=>ContinuousLinearMap.proj e.1))

lemma goeDisorder_mean (r : ℝ) (e : Edge n) :
    (∫ g,goeDisorder r g e ∂gaussianCoordinates (MatrixCoordinates (Fin n)))=0 :=
  goe_mean_zero r e.1.1 e.1.2

lemma goeDisorder_cov {r : ℝ} (hr : 0 ≤ r) (e f : Edge n) :
    cov[fun g=>goeDisorder r g e,fun g=>goeDisorder r g f;
      gaussianCoordinates (MatrixCoordinates (Fin n))]=if e=f then r else 0 := by
  change cov[fun g=>goeMatrix r g e.1.1 e.1.2,fun g=>goeMatrix r g f.1.1 f.1.2;
    gaussianCoordinates (MatrixCoordinates (Fin n))]=_
  rw [goe_entry_cov hr]
  have heq : e=f ↔ e.1.1=f.1.1 ∧ e.1.2=f.1.2 := by simp only [Subtype.ext_iff,Prod.ext_iff]
  have hcross : ¬(e.1.1=f.1.2 ∧ e.1.2=f.1.1) := by
    rintro ⟨h1,h2⟩
    have he := e.2
    rw [h1,h2] at he
    exact (lt_asymm f.2 he)
  split_ifs <;> simp_all

lemma goeDisorder_hasLaw {r : ℝ} (hr : 0 ≤ r) :
    HasLaw (goeDisorder (n:=n) r) (Measure.pi (fun _ : Edge n=>gaussianReal 0 (Real.toNNReal r)))
      (gaussianCoordinates (MatrixCoordinates (Fin n))) := by
  have hg := goeDisorder_gaussian (n:=n) r
  have hl (e : Edge n) : HasLaw (fun g=>goeDisorder r g e)
      (gaussianReal 0 (Real.toNNReal r)) (gaussianCoordinates (MatrixCoordinates (Fin n))) := by
    refine ⟨(hg.eval e).aemeasurable,?_⟩
    rw [(hg.eval e).map_eq_gaussianReal,goeDisorder_mean,
      ← covariance_self (hg.eval e).aemeasurable,goeDisorder_cov hr,ite_eq_left rfl]
  exact iIndepFun.hasLaw_pi hl (hg.iIndepFun_of_covariance_eq_zero
    (fun e f h=>by rw [goeDisorder_cov hr,ite_eq_right h]))

lemma goe_actual_disorder_hasLaw (β : ℝ) (n : ℕ) :
    HasLaw (goeDisorder (n:=n) (β^2/(n:ℝ))) (disorderLaw β n)
      (gaussianCoordinates (MatrixCoordinates (Fin n))) :=
  goeDisorder_hasLaw (by positivity)

lemma coupling_goeDisorder (r : ℝ) (g : MatrixCoordinates (Fin n)→ℝ) :
    Matrix.of (coupling (goeDisorder r g))=goeMatrix r g-Matrix.diagonal (fun i=>goeMatrix r g i i) := by
  ext i k
  by_cases hik : i=k
  · subst k
    simp [coupling]
  · rcases lt_or_gt_of_ne hik with h | h
    · simp [coupling,h,hik,goeDisorder]
    · simp [coupling,h,not_lt_of_gt h,hik,goeDisorder,goeMatrix,add_comm]
end SKRatioGaussian

end
end

section
noncomputable section
namespace SKRatioGaussian
open MeasureTheory ProbabilityTheory Matrix Real
open scoped BigOperators
variable {ι κ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]

omit [DecidableEq κ] in
lemma goe_row_gaussian (r : ℝ) (i : ι) (e : κ→ι) :
    HasGaussianLaw (fun g : MatrixCoordinates ι→ℝ=>fun k=>goeMatrix r g i (e k))
      (gaussianCoordinates (MatrixCoordinates ι)) := by
  exact (goe_matrix_gaussian r).map_fun
    (ContinuousLinearMap.pi (fun k=>ContinuousLinearMap.proj (i,e k)) :
      ((ι × ι)→ℝ) →L[ℝ] (κ→ℝ))

omit [Fintype κ] in
lemma goe_row_cov {r : ℝ} (hr : 0 ≤ r) (i : ι) (e : κ ↪ ι)
    (he : ∀ k,e k≠i) (k l : κ) :
    cov[fun g=>goeMatrix r g i (e k),fun g=>goeMatrix r g i (e l);
      gaussianCoordinates (MatrixCoordinates ι)]=if k=l then r else 0 := by
  classical
  rw [goe_entry_cov hr]
  have hi : ∀ k,¬i=e k := fun k=>Ne.symm (he k)
  simp only [ite_true,hi,he,e.injective.eq_iff]
  simp only [ite_false,mul_zero,add_zero]
  split_ifs <;> simp_all

lemma goe_row_hasLaw {r : ℝ} (hr : 0 ≤ r) (i : ι) (e : κ ↪ ι)
    (he : ∀ k,e k≠i) :
    HasLaw (fun g : MatrixCoordinates ι→ℝ=>fun k=>goeMatrix r g i (e k))
      (Measure.pi (fun _ : κ=>gaussianReal 0 (Real.toNNReal r)))
      (gaussianCoordinates (MatrixCoordinates ι)) := by
  classical
  have hg := goe_row_gaussian r i e
  have hl (k : κ) : HasLaw (fun g=>goeMatrix r g i (e k))
      (gaussianReal 0 (Real.toNNReal r)) (gaussianCoordinates (MatrixCoordinates ι)) := by
    refine ⟨(hg.eval k).aemeasurable,?_⟩
    rw [(hg.eval k).map_eq_gaussianReal,goe_mean_zero,
      ← covariance_self (hg.eval k).aemeasurable,goe_row_cov hr i e he,ite_eq_left rfl]
  exact iIndepFun.hasLaw_pi hl (hg.iIndepFun_of_covariance_eq_zero
    (fun k l h=>by rw [goe_row_cov hr i e he,ite_eq_right h]))
end SKRatioGaussian

end
end

end

end OAI