import Mathlib
import OAI.Probability.SKRatio.FiniteChain.Spin

namespace OAI

section
noncomputable section
open scoped BigOperators Topology Matrix
open ContinuousLinearMap
namespace SKRatio.Calculus
abbrev Interaction (n : ℕ) := Fin n → Fin n → ℝ

def spin {n : ℕ} (x : Spin n) (i : Fin n) : ℝ := if x i then 1 else -1

def replace {n : ℕ} (x : Spin n) (i : Fin n) (b : Bool) : Spin n :=
  Function.update x i b

noncomputable def halfDiff {n : ℕ} (i : Fin n) (f : Spin n → ℝ)
    (x : Spin n) : ℝ := (f (replace x i true) - f (replace x i false)) / 2

noncomputable def field {n : ℕ} (J : Interaction n) (x : Spin n) (i : Fin n) : ℝ :=
  ∑ j, J i j * spin x j

noncomputable def mean {n : ℕ} (J : Interaction n) (x : Spin n) (i : Fin n) : ℝ :=
  Real.tanh (field J x i)

noncomputable def generator {n : ℕ} (J : Interaction n) (f : Spin n → ℝ)
    (x : Spin n) : ℝ := ∑ j, (mean J x j - spin x j) * halfDiff j f x

noncomputable def gradientGenerator {n : ℕ} (J : Interaction n)
    (p : Spin n → Fin n → ℝ) (x : Spin n) (i : Fin n) : ℝ :=
  generator J (fun y => p y i) x - p x i -
    2 * spin x i * ∑ j, halfDiff i (fun y => mean J y j) x *
      halfDiff j (fun y => p y i) x +
    ∑ j, halfDiff i (fun y => mean J y j) x * p x j

@[simp] theorem replace_same {n : ℕ} (x : Spin n) (i : Fin n) (b : Bool) :
    replace x i b i = b := by
  simp [replace]

@[simp] theorem replace_replace {n : ℕ} (x : Spin n) (i : Fin n) (a b : Bool) :
    replace (replace x i a) i b = replace x i b := by
  simp [replace, Function.update_idem]

@[simp] theorem replace_self {n : ℕ} (x : Spin n) (i : Fin n) :
    replace x i (x i) = x := by
  simp [replace]

theorem replace_comm {n : ℕ} (x : Spin n) {i j : Fin n} (h : i ≠ j)
    (a b : Bool) : replace (replace x i a) j b = replace (replace x j b) i a := by
  exact Function.update_comm h a b x

@[simp] theorem halfDiff_replace {n : ℕ} (i : Fin n) (f : Spin n → ℝ)
    (x : Spin n) (b : Bool) : halfDiff i f (replace x i b) = halfDiff i f x := by
  simp [halfDiff]

@[simp] theorem halfDiff_self {n : ℕ} (i : Fin n) (f : Spin n → ℝ)
    (x : Spin n) : halfDiff i (halfDiff i f) x = 0 := by
  simp [halfDiff]

theorem halfDiff_mul {n : ℕ} (i : Fin n) (f g : Spin n → ℝ) (x : Spin n) :
    halfDiff i (fun y => f y * g y) x =
      f x * halfDiff i g x + g x * halfDiff i f x -
        2 * spin x i * halfDiff i f x * halfDiff i g x := by
  have hx : replace x i (x i) = x := replace_self x i
  cases h : x i <;> simp only [h] at hx
  · simp only [halfDiff, spin, h, Bool.false_eq_true, ↓reduceIte]
    rw [hx]
    ring
  · simp only [halfDiff, spin, h, ↓reduceIte]
    rw [hx]
    ring

theorem halfDiff_comm {n : ℕ} (i j : Fin n) (f : Spin n → ℝ) (x : Spin n) :
    halfDiff i (halfDiff j f) x = halfDiff j (halfDiff i f) x := by
  by_cases h : i = j
  · subst j
    rfl
  · simp only [halfDiff]
    rw [replace_comm x h true true, replace_comm x h true false,
      replace_comm x h false true, replace_comm x h false false]
    ring

@[simp] theorem halfDiff_const {n : ℕ} (i : Fin n) (c : ℝ) (x : Spin n) :
    halfDiff i (fun _ => c) x = 0 := by
  simp [halfDiff]

theorem halfDiff_sub {n : ℕ} (i : Fin n) (f g : Spin n → ℝ) (x : Spin n) :
    halfDiff i (fun y => f y - g y) x = halfDiff i f x - halfDiff i g x := by
  simp only [halfDiff]
  ring

theorem halfDiff_sum {n : ℕ} {α : Type*} [Fintype α] (i : Fin n)
    (f : α → Spin n → ℝ) (x : Spin n) :
    halfDiff i (fun y => ∑ a, f a y) x = ∑ a, halfDiff i (f a) x := by
  simp only [halfDiff, sub_div, Finset.sum_sub_distrib, Finset.sum_div]

@[simp] theorem halfDiff_spin {n : ℕ} (i j : Fin n) (x : Spin n) :
    halfDiff i (fun y => spin y j) x = if i = j then 1 else 0 := by
  by_cases h : i = j
  · subst j
    norm_num [halfDiff, spin]
  · simp [halfDiff, spin, replace, Function.update_of_ne (Ne.symm h), h]

theorem halfDiff_generator {n : ℕ} (J : Interaction n) (f : Spin n → ℝ)
    (x : Spin n) (i : Fin n) :
    halfDiff i (generator J f) x =
      gradientGenerator J (fun y j => halfDiff j f y) x i := by
  change halfDiff i (fun y => generator J f y) x = _
  unfold gradientGenerator
  simp only [generator, halfDiff_sum, halfDiff_mul, halfDiff_sub, halfDiff_spin]
  simp_rw [halfDiff_comm i]
  simp only [mul_sub, sub_mul, Finset.sum_add_distrib, Finset.sum_sub_distrib]
  simp only [mul_ite, mul_one, mul_zero, ite_mul, zero_mul,
    Fintype.sum_ite_eq, halfDiff_self, sub_zero]
  rw [Finset.mul_sum]
  simp only [mul_assoc]
  simp_rw [mul_comm (halfDiff _ f x)]
  ring

abbrev Observables (n : ℕ) := Spin n → ℝ
abbrev VectorFields (n : ℕ) := Spin n → Fin n → ℝ

noncomputable def gradientLM (n : ℕ) : Observables n →ₗ[ℝ] VectorFields n where
  toFun f x i := halfDiff i f x
  map_add' f g := by
    funext x i
    simp only [halfDiff, Pi.add_apply]
    ring
  map_smul' a f := by
    funext x i
    simp only [halfDiff, Pi.smul_apply, smul_eq_mul, RingHom.id_apply]
    ring

noncomputable def generatorLM {n : ℕ} (J : Interaction n) :
    Observables n →ₗ[ℝ] Observables n where
  toFun := generator J
  map_add' f g := by
    funext x
    simp only [generator]
    change (∑ j, (mean J x j - spin x j) *
      (gradientLM n (f + g) x j)) = _
    simp [map_add, gradientLM, generator, mul_add, Finset.sum_add_distrib]
  map_smul' a f := by
    funext x
    simp only [generator]
    change (∑ j, (mean J x j - spin x j) *
      (gradientLM n (a • f) x j)) = _
    simp [map_smul, gradientLM, generator, mul_left_comm, Finset.mul_sum]

noncomputable def generatorCLM {n : ℕ} (J : Interaction n) :
    Observables n →L[ℝ] Observables n := (generatorLM J).toContinuousLinearMap

noncomputable def semigroup {n : ℕ} (J : Interaction n) (t : ℝ) :
    Observables n →L[ℝ] Observables n := NormedSpace.exp (t • generatorCLM J)

@[simp] lemma spin_sq {n : ℕ} (x : Spin n) (i : Fin n) : spin x i ^ 2 = 1 := by
  cases h : x i <;> simp [spin, h]

lemma generator_mul {n : ℕ} (J : Interaction n) (f g : Observables n) (x : Spin n) :
    generator J (fun y => f y * g y) x =
      f x * generator J g x + g x * generator J f x +
        2 * ∑ i, (1 - mean J x i * spin x i) * halfDiff i f x * halfDiff i g x := by
  simp only [generator, halfDiff_mul, Finset.mul_sum, ← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro i _
  have hx := spin_sq x i
  linear_combination 2 * halfDiff i f x * halfDiff i g x * hx

lemma semigroup_hasDerivAt {n : ℕ} (J : Interaction n) (t : ℝ) :
    HasDerivAt (fun s : ℝ => semigroup J s)
      (semigroup J t * generatorCLM J) t :=
  hasDerivAt_exp_smul_const (generatorCLM J) t

lemma semigroup_hasDerivAt' {n : ℕ} (J : Interaction n) (t : ℝ) :
    HasDerivAt (fun s : ℝ => semigroup J s)
      (generatorCLM J * semigroup J t) t :=
  hasDerivAt_exp_smul_const' (generatorCLM J) t

lemma semigroup_apply_hasDerivAt {n : ℕ} (J : Interaction n) (f : Observables n) (t : ℝ) :
    HasDerivAt (fun s : ℝ => semigroup J s f) (semigroup J t (generator J f)) t := by
  simpa only [mul_apply_eq_comp, map_zero, add_zero, generatorCLM, generatorLM,
    LinearMap.coe_toContinuousLinearMap', LinearMap.coe_mk, AddHom.coe_mk] using
    (semigroup_hasDerivAt J t).clm_apply (hasDerivAt_const t f)

lemma semigroup_apply_hasDerivAt' {n : ℕ} (J : Interaction n) (f : Observables n) (t : ℝ) :
    HasDerivAt (fun s : ℝ => semigroup J s f) (generator J (semigroup J t f)) t := by
  simpa only [mul_apply_eq_comp, map_zero, add_zero, generatorCLM, generatorLM,
    LinearMap.coe_toContinuousLinearMap', LinearMap.coe_mk, AddHom.coe_mk] using
    (semigroup_hasDerivAt' J t).clm_apply (hasDerivAt_const t f)

lemma semigroup_continuous {n : ℕ} (J : Interaction n) :
    Continuous (fun s : ℝ => semigroup J s) := by
  have hd : Differentiable ℝ (fun s : ℝ => semigroup J s) :=
    fun t => (semigroup_hasDerivAt J t).differentiableAt
  exact hd.continuous

@[simp] lemma semigroup_zero {n : ℕ} (J : Interaction n) : semigroup J 0 = 1 := by
  simp [semigroup]

noncomputable def jumpEnergy {n : ℕ} (J : Interaction n) (f : Observables n) (x : Spin n) : ℝ :=
  2 * ∑ i, (1 - mean J x i * spin x i) * (halfDiff i f x) ^ 2

lemma generator_square {n : ℕ} (J : Interaction n) (f : Observables n) :
    generator J (fun x => f x ^ 2) =
      fun x => 2 * f x * generator J f x + jumpEnergy J f x := by
  funext x
  simpa only [pow_two, mul_assoc, ← two_mul, jumpEnergy] using generator_mul J f f x

lemma spin_flip_self {n : ℕ} (x : Spin n) (i : Fin n) :
    spin (flip i x) i = -spin x i := by
  cases h : x i <;> simp [SKRatio.flip, spin, h]

lemma spin_flip {n : ℕ} (x : Spin n) (i j : Fin n) :
    spin (flip i x) j = spin x j - if j = i then 2 * spin x i else 0 := by
  by_cases h : j = i
  · subst j; rw [spin_flip_self]; simp; ring
  · simp [flip, spin, h]

lemma field_flip {n : ℕ} (J : Interaction n) (hdiag : ∀ i, J i i = 0)
    (x : Spin n) (i : Fin n) : field J (flip i x) i = field J x i := by
  simp only [field, spin_flip, mul_sub, Finset.sum_sub_distrib]
  simp [mul_ite, hdiag]

lemma hamiltonian_flip {n : ℕ} (g : Disorder n) (x : Spin n) (i : Fin n) :
    hamiltonian g 0 (flip i x) = hamiltonian g 0 x -
      2 * spin x i * field (coupling g) x i := by
  have hr : ∑ j, spin x j * coupling g j i = field (coupling g) x i := by
    simp only [field, coupling_symm, mul_comm]
  have he (y : Spin n) : hamiltonian g 0 y =
      (∑ j, ∑ k, spin y j * coupling g j k * spin y k) / 2 := by
    simp only [hamiltonian, Pi.zero_apply, zero_mul, Finset.sum_const_zero, add_zero]
    simp only [spinValue, spin]
    ring
  rw [he, he]
  simp only [spin_flip, sub_mul, mul_sub, Finset.sum_sub_distrib]
  simp only [mul_ite, ite_mul, mul_zero, zero_mul, Finset.sum_ite_irrel,
    Finset.sum_const_zero, Finset.sum_ite_eq', Finset.mem_univ,
    ↓reduceIte, coupling_diag]
  simp only [← Finset.sum_mul, hr]
  simp only [mul_assoc, ← Finset.mul_sum, field]
  ring

lemma mass_flip {n : ℕ} (g : Disorder n) (x : Spin n) (i : Fin n) :
    mass g 0 (flip i x) = mass g 0 x * Real.exp (-2 * spin x i * field (coupling g) x i) := by
  unfold mass weight
  rw [hamiltonian_flip, Real.exp_sub, neg_mul, neg_mul, Real.exp_neg]
  ring

lemma exp_two_mul_one_sub_tanh (a : ℝ) :
    Real.exp (2 * a) * (1 - Real.tanh a) = 1 + Real.tanh a := by
  rw [Real.tanh_eq, show 2 * a = a + a by ring, Real.exp_add, Real.exp_neg]
  have he := Real.exp_pos a
  field_simp
  nlinarith

lemma exp_neg_two_mul_one_add_tanh (a : ℝ) :
    Real.exp (-2 * a) * (1 + Real.tanh a) = 1 - Real.tanh a := by
  simpa only [mul_neg, neg_mul, Real.tanh_neg, sub_neg_eq_add, sub_eq_add_neg, neg_neg] using
    exp_two_mul_one_sub_tanh (-a)

def flipRate {n : ℕ} (J : Interaction n) (x : Spin n) (i : Fin n) : ℝ :=
  (1 - spin x i * mean J x i) / 2

lemma mass_flip_ratio {n : ℕ} (g : Disorder n) (x : Spin n) (i : Fin n) :
    mass g 0 (flip i x) / (mass g 0 x + mass g 0 (flip i x)) =
      flipRate (coupling g) x i := by
  have hx := mass_pos g 0 x
  rw [mass_flip]
  have he := Real.exp_pos (-2 * spin x i * field (coupling g) x i)
  have hden : mass g 0 x + mass g 0 x * Real.exp (-2 * spin x i * field (coupling g) x i) ≠ 0 := by
    positivity
  apply (div_eq_iff hden).mpr
  cases hi : x i
  · have h := exp_two_mul_one_sub_tanh (field (coupling g) x i)
    simp only [flipRate, mean, spin, hi, Bool.false_eq_true, ↓reduceIte, mul_neg,
      mul_one, sub_neg_eq_add, neg_mul, neg_neg]
    linear_combination (mass g 0 x / 2) * h
  · have h := exp_neg_two_mul_one_add_tanh (field (coupling g) x i)
    simp only [flipRate, mean, spin, hi, ↓reduceIte, mul_one, one_mul]
    linear_combination (mass g 0 x / 2) * h

lemma siteKernel_apply {n : ℕ} (g : Disorder n) (i : Fin n) (f : Observables n) (x : Spin n) :
    ∑ y, siteKernel g i x y * f y =
      f x + flipRate (coupling g) x i * (f (flip i x) - f x) := by
  have hd : mass g 0 x + mass g 0 (flip i x) ≠ 0 :=
    (add_pos (mass_pos g 0 x) (mass_pos g 0 (flip i x))).ne'
  have hs : mass g 0 x / (mass g 0 x + mass g 0 (flip i x)) +
      mass g 0 (flip i x) / (mass g 0 x + mass g 0 (flip i x)) = 1 := by
    rw [← add_div, div_self hd]
  simp only [siteKernel, add_mul, Finset.sum_add_distrib, ite_mul, zero_mul,
    Finset.sum_ite_eq', Finset.mem_univ, ite_true]
  rw [← mass_flip_ratio]
  linear_combination f x * hs

lemma generator_flip {n : ℕ} (J : Interaction n) (f : Observables n) (x : Spin n) :
    generator J f x = ∑ i, flipRate J x i * (f (flip i x) - f x) := by
  apply Finset.sum_congr rfl
  intro i _
  have hx := replace_self x i
  cases hi : x i <;> simp only [hi] at hx
  · simp only [spin, hi, Bool.false_eq_true, ↓reduceIte, flipRate, flip, Bool.not_false,
      halfDiff]
    rw [hx]
    simp only [replace]
    ring
  · simp only [spin, hi, ↓reduceIte, flipRate, flip, Bool.not_true, halfDiff]
    rw [hx]
    simp only [replace]
    ring

theorem generator_eq_transition {n : ℕ} (g : Disorder n) (f : Observables n) (x : Spin n) :
    generator (coupling g) f x = (n : ℝ) * ((∑ y, transition g x y * f y) - f x) := by
  by_cases hn : n = 0
  · subst n; simp [generator]
  have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn
  have hP : transition g = fun x y => (∑ i, siteKernel g i x y) / (n : ℝ) := by
    simp only [transition, hn, ↓reduceIte]
    rfl
  rw [hP]
  simp only [div_mul_eq_mul_div, ← Finset.sum_div]
  rw [mul_sub, mul_div_cancel₀ _ hn']
  simp_rw [Finset.sum_mul]
  rw [Finset.sum_comm]
  simp_rw [siteKernel_apply]
  rw [Finset.sum_add_distrib]
  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
  rw [generator_flip]
  ring

def unweightedGradient {n : ℕ} (f : Observables n) (x : Spin n) : ℝ :=
  ∑ i, (halfDiff i f x) ^ 2

def gradientWeight {n : ℕ} (J : Interaction n) (x : Spin n) (i : Fin n) : ℝ :=
  1 - spin x i * mean J x i

def weightedGradient {n : ℕ} (J : Interaction n) (f : Observables n) (x : Spin n) : ℝ :=
  ∑ i, gradientWeight J x i * (halfDiff i f x)^2

lemma variance_density {n : ℕ} (J : Interaction n) (f : Observables n) (x : Spin n) :
    generator J (fun y => f y ^ 2) x - 2 * f x * generator J f x =
      2 * weightedGradient J f x := by
  rw [generator_square]
  simp only [jumpEnergy, weightedGradient, gradientWeight, mul_comm (mean J x _)]
  ring

lemma halfDiff_flow_hasDerivAt {n : ℕ} (J : Interaction n) (f : Observables n)
    (i : Fin n) (x : Spin n) (t : ℝ) :
    HasDerivAt (fun s : ℝ => halfDiff i (semigroup J s f) x)
      (halfDiff i (generator J (semigroup J t f)) x) t := by
  have h := semigroup_apply_hasDerivAt' J f t
  exact ((hasDerivAt_pi.mp h (replace x i true)).sub
    (hasDerivAt_pi.mp h (replace x i false))).div_const 2

lemma unweightedGradient_hasDerivAt {n : ℕ} (J : Interaction n) (f : Observables n)
    (x : Spin n) (t : ℝ) :
    HasDerivAt (fun s : ℝ => unweightedGradient (semigroup J s f) x)
      (∑ i, 2 * halfDiff i (semigroup J t f) x *
        halfDiff i (generator J (semigroup J t f)) x) t := by
  have hs := HasDerivAt.fun_sum (u := Finset.univ)
    (fun i _ => (halfDiff_flow_hasDerivAt J f i x t).pow 2)
  simpa only [unweightedGradient, Nat.cast_ofNat, Nat.reduceSub, pow_one, Pi.pow_apply] using hs

lemma generator_unweightedGradient {n : ℕ} (J : Interaction n) (f : Observables n)
    (x : Spin n) :
    generator J (unweightedGradient f) x =
      ∑ i, generator J (fun y => halfDiff i f y ^ 2) x := by
  have hu : unweightedGradient f = ∑ i, (fun y => halfDiff i f y ^ 2) := by
    funext y; simp only [unweightedGradient, Finset.sum_apply]
  rw [hu]
  change generatorLM J (∑ i, (fun y => halfDiff i f y ^ 2)) x = _
  simp only [map_sum, Finset.sum_apply]
  rfl

lemma unweightedGradient_commutator {n : ℕ} (J : Interaction n) (f : Observables n)
    (x : Spin n) :
    (1 / 2 : ℝ) * ((∑ i, 2 * halfDiff i f x * halfDiff i (generator J f) x) -
      generator J (unweightedGradient f) x) =
    -unweightedGradient f x +
      (∑ i, ∑ j, halfDiff i f x * halfDiff i (fun y => mean J y j) x *
        (halfDiff j f x - 2 * spin x i * halfDiff i (halfDiff j f) x)) -
      (∑ i, ∑ j, gradientWeight J x j * (halfDiff i (halfDiff j f) x)^2) := by
  rw [generator_unweightedGradient, ← Finset.sum_sub_distrib, Finset.mul_sum]
  have hloc (i : Fin n) :
      (1 / 2 : ℝ) * (2 * halfDiff i f x * halfDiff i (generator J f) x -
        generator J (fun y => halfDiff i f y ^ 2) x) =
      -(halfDiff i f x)^2 +
        (∑ j, halfDiff i f x * halfDiff i (fun y => mean J y j) x *
          (halfDiff j f x - 2 * spin x i * halfDiff i (halfDiff j f) x)) -
        ∑ j, gradientWeight J x j * (halfDiff i (halfDiff j f) x)^2 := by
    have hsum : (∑ j, halfDiff i f x * halfDiff i (fun y => mean J y j) x *
        (halfDiff j f x - 2 * spin x i * halfDiff i (halfDiff j f) x)) =
        halfDiff i f x * (∑ j, halfDiff i (fun y => mean J y j) x * halfDiff j f x) -
          2 * halfDiff i f x * spin x i *
            (∑ j, halfDiff i (fun y => mean J y j) x * halfDiff i (halfDiff j f) x) := by
      simp only [Finset.mul_sum, ← Finset.sum_sub_distrib]
      apply Finset.sum_congr rfl
      intro j _
      ring
    rw [hsum, halfDiff_generator, generator_square]
    simp only [gradientGenerator, jumpEnergy, gradientWeight]
    simp_rw [halfDiff_comm _ i, mul_comm (mean J x _)]
    ring
  simp_rw [hloc]
  simp only [Finset.sum_sub_distrib, Finset.sum_add_distrib, Finset.sum_neg_distrib,
    unweightedGradient]

end SKRatio.Calculus
end
end

end OAI