import Mathlib
import OAI.Probability.SKGap.Gaussian.GaussianRecipeEvent

namespace OAI

section

noncomputable section
open scoped BigOperators Topology
open Filter MeasureTheory ProbabilityTheory Real
namespace SKGapCutoff.Recipe
open SKGap SKGap.Noncrossing SKGap.Noncrossing.Primary

def physicalNormBound (j : ℝ) : ℝ := 2*Real.sqrt j+1+1

lemma physicalNormBound_pos (j : ℝ) : 0<physicalNormBound j := by
  unfold physicalNormBound
  positivity

theorem gaussian_fixed_norm_recipe_probability {j A : ℝ} (hj : 0<j) (hj1 : j<1)
    (hA : 1≤A) (M Nmax : ℕ) : ∃B W C : ℝ,0≤B ∧ 0≤W ∧ 0<C ∧
      Tendsto (fun n=>(Measure.pi (fun _ : MatrixCoordinates (Fin n)=>gaussianReal 0 1))
        {g | ¬RecipeMatrixEvent j (physicalNormBound j) A B W C M Nmax
          (removeDiagonal (goeMatrix (j/n) g))}) atTop (𝓝 0) := by
  obtain ⟨R,B,W,C,hR,hB,hW,hC,hprob⟩:=gaussian_recipe_event_probability hj hj1 hA M Nmax
  refine ⟨B,W,C,hB,hW,hC,?_⟩
  have hup := hprob.add (recipeNormTail_limit hj)
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds (by simpa using hup)
    (Filter.Eventually.of_forall (fun _=>bot_le))
  filter_upwards [eventually_ge_atTop 1] with n hn
  let μ:=Measure.pi (fun _ : MatrixCoordinates (Fin n)=>gaussianReal 0 1)
  let E : Set (MatrixCoordinates (Fin n)→ℝ):={g | ¬RecipeMatrixEvent j R A B W C M Nmax
    (removeDiagonal (goeMatrix (j/n) g))}
  let F : Set (MatrixCoordinates (Fin n)→ℝ):={g | physicalNormBound j<SKGap.opNorm (removeDiagonal (goeMatrix (j/n) g))}
  have hF : μ F≤recipeNormTail j n:=zeroDiagGOE_norm_tail hj hn
  apply (measure_mono (t:=E∪F) ?_).trans ((measure_union_le E F).trans (add_le_add_right hF _))
  intro g hg
  by_contra hh
  have ho : SKGap.opNorm (removeDiagonal (goeMatrix (j/n) g))≤physicalNormBound j:=
    le_of_not_gt fun hbad=>hh (.inr hbad)
  have he : RecipeMatrixEvent j R A B W C M Nmax (removeDiagonal (goeMatrix (j/n) g)):= by
    by_contra hbad;exact hh (.inl hbad)
  exact hg ⟨ho,he.2⟩

end SKGapCutoff.Recipe

end
end

section

noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter

namespace SKGapCutoff
namespace GapBridge

def restrictUpper {n : ℕ} (g : GaussianCoordinates n) : SKGap.Disorder n :=
  fun e => g e.val

lemma measurable_restrictUpper (n : ℕ) : Measurable (restrictUpper (n := n)) := by
  exact Measurable.of_eval (fun edge => measurable_pi_apply edge.val)

lemma coupling_restrictUpper {n : ℕ} (g : GaussianCoordinates n) :
    SKGap.coupling (restrictUpper g) = sampledInteraction g := by
  funext i k
  rcases lt_trichotomy i k with h | rfl | h
  · simp [SKGap.coupling, restrictUpper, sampledInteraction, h, ne_of_lt h,
      min_eq_left h.le, max_eq_right h.le]
  · simp [SKGap.coupling, sampledInteraction]
  · simp [SKGap.coupling, restrictUpper, sampledInteraction, h, ne_of_gt h,
      not_lt_of_gt h, min_eq_right h.le, max_eq_left h.le]

def edgeInteraction {n : ℕ} (g : SKGap.Disorder n) : Interaction n := Matrix.of (SKGap.coupling g)

lemma edgeInteraction_restrictUpper {n : ℕ} (g : GaussianCoordinates n) :
    edgeInteraction (restrictUpper g) = sampledInteraction g := coupling_restrictUpper g

lemma coupling_symmetric {n : ℕ} (g : SKGap.Disorder n) (i k : Fin n) :
    SKGap.coupling g i k = SKGap.coupling g k i := by
  rcases lt_trichotomy i k with h | rfl | h
  · simp [SKGap.coupling, h, not_lt_of_gt h]
  · rfl
  · simp [SKGap.coupling, h, not_lt_of_gt h]

lemma coupling_diagonal {n : ℕ} (g : SKGap.Disorder n) (i : Fin n) :
    SKGap.coupling g i i = 0 := by simp [SKGap.coupling]

lemma hamiltonian_zero {n : ℕ} (g : SKGap.Disorder n) (x : Spin n) :
    SKGap.hamiltonian g 0 x = energy (edgeInteraction g) x := by
  simp only [SKGap.hamiltonian, Pi.zero_apply, zero_mul, Finset.sum_const_zero,
    add_zero, SKGap.spinValue, energy, spin, edgeInteraction, Matrix.of_apply]
  ring

lemma weight_zero {n : ℕ} (g : SKGap.Disorder n) (x : Spin n) :
    SKGap.weight g 0 x = Real.exp (energy (edgeInteraction g) x) := by
  rw [SKGap.weight, hamiltonian_zero]

lemma partition_zero {n : ℕ} (g : SKGap.Disorder n) :
    SKGap.partition g 0 = partition (edgeInteraction g) := by
  simp only [SKGap.partition, partition, weight_zero]

lemma mass_zero {n : ℕ} (g : SKGap.Disorder n) (x : Spin n) :
    SKGap.mass g 0 x = gibbs (edgeInteraction g) x := by
  simp only [SKGap.mass, weight_zero, partition_zero]
  rfl

lemma expectation_zero {n : ℕ} (g : SKGap.Disorder n) (f : Observables n) :
    SKGap.expectation g 0 f = gibbsExpectation (edgeInteraction g) f := by
  simp only [SKGap.expectation, gibbsExpectation, mass_zero]

lemma variance_zero {n : ℕ} (g : SKGap.Disorder n) (f : Observables n) :
    SKGap.variance g 0 f = gibbsVariance (edgeInteraction g) f := by
  simp only [SKGap.variance, gibbsVariance, expectation_zero]

lemma flip_eq {n : ℕ} (i : Fin n) (x : Spin n) : SKGap.flip i x = flip x i := rfl

def pairConditional {n : ℕ} (J : Interaction n) (i : Fin n)
    (f : Observables n) (x : Spin n) : ℝ :=
  (gibbs J x * f x + gibbs J (flip x i) * f (flip x i)) /
    (gibbs J x + gibbs J (flip x i))

lemma conditionalExpectation_zero {n : ℕ} (g : SKGap.Disorder n) (i : Fin n)
    (f : Observables n) (x : Spin n) :
    SKGap.conditionalExpectation g 0 i f x = pairConditional (edgeInteraction g) i f x := by
  simp only [SKGap.conditionalExpectation, weight_zero, flip_eq, pairConditional, gibbs]
  field_simp [ne_of_gt (partition_pos (edgeInteraction g))]

lemma pairConditional_flip {n : ℕ} (J : Interaction n) (i : Fin n)
    (f : Observables n) (x : Spin n) :
    pairConditional J i f (flip x i) = pairConditional J i f x := by
  simp only [pairConditional, flip_flip, add_comm]

lemma flipRate_complement {n : ℕ} (J : Interaction n) (hd : ∀ i, J i i = 0)
    (i : Fin n) (x : Spin n) : flipRate J (flip x i) i = 1 - flipRate J x i := by
  simp only [flipRate, spin_flip_self, mean_flip J hd]
  ring

lemma flipRate_eq_mass {n : ℕ} (J : Interaction n)
    (hJ : ∀ i k, J i k = J k i) (hd : ∀ i, J i i = 0)
    (i : Fin n) (x : Spin n) :
    flipRate J x i = gibbs J (flip x i) / (gibbs J x + gibbs J (flip x i)) := by
  apply (eq_div_iff (ne_of_gt (add_pos (gibbs_pos J x) (gibbs_pos J (flip x i))))).2
  have hb := gibbs_detailed_balance J hJ hd x i
  rw [flipRate_complement J hd] at hb
  nlinarith only [hb]

lemma pairConditional_residual {n : ℕ} (J : Interaction n)
    (hJ : ∀ i k, J i k = J k i) (hd : ∀ i, J i i = 0)
    (i : Fin n) (f : Observables n) (x : Spin n) :
    f x - pairConditional J i f x = flipRate J x i * (f x - f (flip x i)) := by
  rw [flipRate_eq_mass J hJ hd]
  unfold pairConditional
  field_simp [ne_of_gt (add_pos (gibbs_pos J x) (gibbs_pos J (flip x i)))]
  ring

lemma conditional_variance_projection {n : ℕ} (J : Interaction n)
    (i : Fin n) (f : Observables n) :
    (∑ x, gibbs J x * (f x - pairConditional J i f x) ^ 2) =
      ∑ x, gibbs J x * f x * (f x - pairConditional J i f x) := by
  let l : Observables n := fun x => gibbs J x * (f x - pairConditional J i f x) ^ 2
  let r : Observables n := fun x => gibbs J x * f x * (f x - pairConditional J i f x)
  have hp (x : Spin n) : l x + l (flip x i) = r x + r (flip x i) := by
    dsimp only [l, r]
    rw [pairConditional_flip]
    simp only [pairConditional]
    field_simp [ne_of_gt (add_pos (gibbs_pos J x) (gibbs_pos J (flip x i)))]
    ring
  have hh := congrArg (fun u : Observables n => ∑ x, u x) (funext hp)
  simp only [Finset.sum_add_distrib, sum_flip] at hh
  change (∑ x, l x) = ∑ x, r x
  linarith

theorem dirichlet_zero {n : ℕ} (g : SKGap.Disorder n) (f : Observables n) :
    SKGap.dirichlet g 0 f = dirichlet (edgeInteraction g) f f := by
  simp only [SKGap.dirichlet, expectation_zero, conditionalExpectation_zero, gibbsExpectation]
  simp_rw [conditional_variance_projection,
    pairConditional_residual (edgeInteraction g) (coupling_symmetric g) (coupling_diagonal g)]
  simp_rw [gibbs_edge_dirichlet (edgeInteraction g) (coupling_symmetric g) (coupling_diagonal g)]
  simp only [dirichlet, gibbsExpectation, Finset.mul_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro x _
  apply Finset.sum_congr rfl
  intro i _
  ring

theorem measurePreserving_restrictUpper (β : ℝ) (n : ℕ) :
    MeasurePreserving (restrictUpper (n := n)) (disorderLaw β n) (SKGap.disorderLaw β n) := by
  let μ : (Fin n × Fin n) → Measure ℝ := fun _ =>
    gaussianReal 0 (Real.toNNReal (β ^ 2 / (n : ℝ)))
  have h := measurePreserving_fst.comp
    (measurePreserving_piEquivPiSubtypeProd μ (fun e : Fin n × Fin n => e.1 < e.2))
  change MeasurePreserving (fun g : Fin n × Fin n → ℝ => fun e : SKGap.Edge n => g e.val)
    (Measure.pi μ) (Measure.pi (fun e : SKGap.Edge n => μ e.val))
  simpa only [MeasurableEquiv.piEquivPiSubtypeProd_apply, Function.comp_def] using h

lemma continuous_coupling (n : ℕ) : Continuous (edgeInteraction (n := n)) := by
  apply continuous_pi
  intro i
  apply continuous_pi
  intro k
  change Continuous (fun g : SKGap.Disorder n => SKGap.coupling g i k)
  by_cases hik : i < k
  · simp only [SKGap.coupling, dite_eq_left hik]
    exact continuous_apply _
  · simp only [SKGap.coupling, dite_eq_right hik]
    by_cases hki : k < i
    · simp only [dite_eq_left hki]
      exact continuous_apply _
    · simp only [dite_eq_right hki]
      exact continuous_const

lemma poincare_iff_hasGap {n : ℕ} (g : SKGap.Disorder n) {C : ℝ} (hC : 0 < C) :
    g ∈ SKGap.poincareEvent n C ↔ HasGap (edgeInteraction g) (1 / C) := by
  simp only [SKGap.poincareEvent, Set.mem_ofPred_eq, HasGap, variance_zero, dirichlet_zero]
  apply forall_congr'
  intro f
  rw [show (1 / C) * gibbsVariance (edgeInteraction g) f =
    gibbsVariance (edgeInteraction g) f / C by ring, div_le_iff₀ hC, mul_comm]

lemma measurableSet_poincareEvent (n : ℕ) {C : ℝ} (hC : 0 < C) :
    MeasurableSet (SKGap.poincareEvent n C) := by
  have he : SKGap.poincareEvent n C =
      edgeInteraction ⁻¹' {J : Interaction n | HasGap J (1/C)} := by
    ext g
    exact poincare_iff_hasGap g hC
  rw [he]
  exact ((isClosed_hasGap (1/C)).preimage (continuous_coupling n)).measurableSet

theorem probability_poincare_eq (β : ℝ) (n : ℕ) {C : ℝ} (hC : 0 < C) :
    (SKGap.disorderLaw β n) (SKGap.poincareEvent n C) =
      (disorderLaw β n) {g | HasGap (sampledInteraction g) (1/C)} := by
  rw [← (measurePreserving_restrictUpper β n).measure_preimage
    (measurableSet_poincareEvent n hC).nullMeasurableSet]
  congr 1
  ext g
  simpa only [Set.mem_preimage, Set.mem_ofPred_eq, edgeInteraction_restrictUpper] using
    poincare_iff_hasGap (restrictUpper g) hC

theorem quenchedGap_iff_edgePoincare (β : ℝ) : QuenchedGap β ↔
    ∃ C : ℝ, 0 < C ∧ Tendsto (fun n => SKGap.disorderLaw β n (SKGap.poincareEvent n C))
      atTop (nhds 1) := by
  constructor
  · rintro ⟨γ, hγ, h⟩
    refine ⟨1/γ, one_div_pos.mpr hγ, ?_⟩
    have he (n : ℕ) : SKGap.disorderLaw β n (SKGap.poincareEvent n (1/γ)) =
        disorderLaw β n {g | HasGap (sampledInteraction g) γ} := by
      simpa only [one_div_one_div] using probability_poincare_eq β n (one_div_pos.mpr hγ)
    simpa only [he] using h
  · rintro ⟨C, hC, h⟩
    refine ⟨1/C, one_div_pos.mpr hC, ?_⟩
    simpa only [probability_poincare_eq β _ hC] using h

end GapBridge
end SKGapCutoff
end
end

end OAI