import Mathlib
import OAI.Probability.SKGap.Terminal.GibbsExpectation

namespace OAI

section
open scoped BigOperators
open scoped BigOperators
namespace SKGapCutoff

noncomputable def cubeWeight {n : ℕ} (z : Fin n → ℝ) (x : Spin n) : ℝ :=
  ∏ i, (1 + spin x i * z i) / 2

noncomputable def deletedWeight {n : ℕ} (z : Fin n → ℝ) (x : Spin n)
    (i : Fin n) : ℝ := ∏ j ∈ Finset.univ.erase i, (1 + spin x j * z j) / 2

noncomputable def cubeExtension {n : ℕ} (f : Observables n) (z : Fin n → ℝ) : ℝ :=
  ∑ x, cubeWeight z x * f x

lemma cubeWeight_sum {n : ℕ} (z : Fin n → ℝ) : ∑ x, cubeWeight z x = 1 := by
  change (∑ x : Fin n → Bool, ∏ i, (1 + (if x i then 1 else -1 : ℝ) * z i) / 2) = 1
  rw [← Fintype.prod_sum (fun (i : Fin n) (b : Bool) =>
    (1 + (if b then 1 else -1 : ℝ) * z i) / 2)]
  have h (i : Fin n) : (∑ b : Bool, (1 + (if b then 1 else -1 : ℝ) * z i) / 2) = 1 := by
    rw [Fintype.sum_bool]
    simp only [Bool.false_eq_true, ↓reduceIte]
    ring
  simp_rw [h]
  simp

lemma cubeWeight_nonneg {n : ℕ} (z : Fin n → ℝ)
    (hz : ∀ i, -1 ≤ z i ∧ z i ≤ 1) (x : Spin n) : 0 ≤ cubeWeight z x := by
  apply Finset.prod_nonneg
  intro i _
  apply div_nonneg _ (by norm_num)
  rcases hz i with ⟨hl, hu⟩
  cases h : x i <;> simp only [spin, h, ↓reduceIte, Bool.false_eq_true]
  · linarith
  · linarith

lemma cubeWeight_vertex {n : ℕ} (x y : Spin n) :
    cubeWeight (spin x) y = if y = x then 1 else 0 := by
  classical
  by_cases h : y = x
  · subst y
    simp [cubeWeight, ← sq, spin_sq]
  · rw [ite_eq_right h]
    obtain ⟨i, hi⟩ := Function.ne_iff.mp h
    apply Finset.prod_eq_zero (Finset.mem_univ i)
    have hs : spin y i * spin x i = -1 := by
      cases hx : x i <;> cases hy : y i <;> simp_all [spin]
    simp [hs]

lemma cubeExtension_vertex {n : ℕ} (f : Observables n) (x : Spin n) :
    cubeExtension f (spin x) = f x := by
  classical
  simp [cubeExtension, cubeWeight_vertex]

lemma deletedWeight_flip {n : ℕ} (z : Fin n → ℝ) (x : Spin n) (i : Fin n) :
    deletedWeight z (flip x i) i = deletedWeight z x i := by
  apply Finset.prod_congr rfl
  intro j hj
  simp only [Finset.mem_erase] at hj
  rw [spin_flip]
  simp [hj.1]

lemma cubeWeight_factor {n : ℕ} (z : Fin n → ℝ) (x : Spin n) (i : Fin n) :
    cubeWeight z x = (1 + spin x i * z i) / 2 * deletedWeight z x i := by
  exact (Finset.mul_prod_erase _ _ (Finset.mem_univ i)).symm

lemma cubeWeight_flip_add {n : ℕ} (z : Fin n → ℝ) (x : Spin n) (i : Fin n) :
    cubeWeight z x + cubeWeight z (flip x i) = deletedWeight z x i := by
  rw [cubeWeight_factor z x i, cubeWeight_factor z (flip x i) i,
    deletedWeight_flip, spin_flip_self]
  ring

lemma cubeWeight_halfDiff {n : ℕ} (z : Fin n → ℝ) (f : Observables n) (i : Fin n) :
    (∑ x, cubeWeight z x * halfDiff i f x) =
      ∑ x, f x * (spin x i / 2) * deletedWeight z x i := by
  have hA (x : Spin n) :
      f x * (spin x i / 2) * deletedWeight z x i +
        f (flip x i) * (spin (flip x i) i / 2) * deletedWeight z (flip x i) i =
      deletedWeight z x i * halfDiff i f x := by
    rw [spin_flip_self, deletedWeight_flip]
    have he : f (flip x i) = f x - 2 * spin x i * halfDiff i f x := by
      linarith only [flip_sub i f x]
    rw [he]
    calc
      _ = (spin x i * spin x i) * (deletedWeight z x i * halfDiff i f x) := by ring
      _ = _ := by rw [spin_mul_self, one_mul]
  have hB (x : Spin n) :
      cubeWeight z x * halfDiff i f x +
        cubeWeight z (flip x i) * halfDiff i f (flip x i) =
      deletedWeight z x i * halfDiff i f x := by
    rw [halfDiff_flip, ← add_mul, cubeWeight_flip_add]
  have ha := sum_flip i (fun x => f x * (spin x i / 2) * deletedWeight z x i)
  have hb := sum_flip i (fun x => cubeWeight z x * halfDiff i f x)
  have h : (∑ x, cubeWeight z x * halfDiff i f x) +
      (∑ x, cubeWeight z (flip x i) * halfDiff i f (flip x i)) =
      (∑ x, f x * (spin x i / 2) * deletedWeight z x i) +
        (∑ x, f (flip x i) * (spin (flip x i) i / 2) * deletedWeight z (flip x i) i) := by
    rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
    exact Finset.sum_congr rfl (fun x _ => (hB x).trans (hA x).symm)
  rw [ha, hb] at h
  linarith only [h]

lemma cubeExtension_line_deriv {n : ℕ} (f : Observables n) (a b : Fin n → ℝ) (t : ℝ) :
    HasDerivAt (fun s : ℝ => cubeExtension f (fun i => a i + s * b i))
      (∑ i, b i * ∑ x, cubeWeight (fun j => a j + t * b j) x * halfDiff i f x) t := by
  have hf (x : Spin n) (i : Fin n) :
      HasDerivAt (fun s : ℝ => (1 + spin x i * (a i + s * b i)) / 2)
        (spin x i * b i / 2) t := by
    simpa only [one_mul, id_eq] using (((((hasDerivAt_id t).mul_const (b i)).const_add (a i)).const_mul
      (spin x i)).const_add 1).div_const 2
  have hp (x : Spin n) :=
    (HasDerivAt.finsetProd (u := Finset.univ) (fun i _ => hf x i)).mul_const (f x)
  have h := HasDerivAt.sum (u := Finset.univ) (fun x _ => hp x)
  have hd : (∑ x, (∑ i, (∏ j ∈ Finset.univ.erase i,
        (1 + spin x j * (a j + t * b j)) / 2) • (spin x i * b i / 2)) * f x) =
      ∑ i, b i * ∑ x, cubeWeight (fun j => a j + t * b j) x * halfDiff i f x := by
    simp only [smul_eq_mul, Finset.sum_mul]
    rw [Finset.sum_comm]
    apply Finset.sum_congr rfl
    intro i _
    rw [cubeWeight_halfDiff, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro x _
    dsimp only [deletedWeight]
    ring
  rw [hd] at h
  have he : (∑ x, fun y : ℝ => (∏ i, (1 + spin x i * (a i + y * b i)) / 2) * f x) =
      (fun s : ℝ => cubeExtension f (fun i => a i + s * b i)) := by
    funext s
    simp only [Finset.sum_apply, cubeExtension, cubeWeight]
  simp only [Finset.prod_apply] at h
  rw [he] at h
  exact h

lemma weighted_mean_sq_le {α : Type*} [Fintype α] (p f : α → ℝ)
    (hp : ∀ x, 0 ≤ p x) (hs : ∑ x, p x = 1) :
    (∑ x, p x * f x) ^ 2 ≤ ∑ x, p x * f x ^ 2 := by
  have h : 0 ≤ ∑ x, p x * (f x - ∑ y, p y * f y) ^ 2 := by
    exact Finset.sum_nonneg (fun x _ => mul_nonneg (hp x) (sq_nonneg _))
  simp_rw [sub_sq, mul_add, mul_sub] at h
  simp only [Finset.sum_add_distrib, Finset.sum_sub_distrib] at h
  have h1 : (∑ x, p x * (2 * f x * ∑ y, p y * f y)) =
      2 * (∑ x, p x * f x) ^ 2 := by
    simp_rw [show ∀ x, p x * (2 * f x * ∑ y, p y * f y) =
      2 * (p x * f x) * (∑ y, p y * f y) by intro x; ring]
    rw [← Finset.sum_mul, ← Finset.mul_sum]
    ring
  have h2 : (∑ x, p x * (∑ y, p y * f y) ^ 2) = (∑ y, p y * f y) ^ 2 := by
    rw [← Finset.sum_mul, hs, one_mul]
  rw [h1, h2] at h
  linarith only [h]

lemma cubeExtension_gradient_sq_le {n : ℕ} (f : Observables n) (z : Fin n → ℝ)
    (hz : ∀ i, -1 ≤ z i ∧ z i ≤ 1) (C : ℝ)
    (hf : ∀ x, ∑ i, (halfDiff i f x) ^ 2 ≤ C ^ 2) :
    (∑ i, (∑ x, cubeWeight z x * halfDiff i f x) ^ 2) ≤ C ^ 2 := by
  calc
    _ ≤ ∑ i, ∑ x, cubeWeight z x * (halfDiff i f x) ^ 2 := by
      apply Finset.sum_le_sum
      intro i _
      exact weighted_mean_sq_le _ _ (cubeWeight_nonneg z hz) (cubeWeight_sum z)
    _ = ∑ x, cubeWeight z x * ∑ i, (halfDiff i f x) ^ 2 := by
      rw [Finset.sum_comm]
      simp_rw [Finset.mul_sum]
    _ ≤ ∑ x, cubeWeight z x * C ^ 2 := by
      apply Finset.sum_le_sum
      intro x _
      exact mul_le_mul_of_nonneg_left (hf x) (cubeWeight_nonneg z hz x)
    _ = C ^ 2 := by rw [← Finset.sum_mul, cubeWeight_sum, one_mul]

lemma spin_segment_mem {n : ℕ} (x y : Spin n) (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) 1)
    (i : Fin n) : -1 ≤ spin x i + t * (spin y i - spin x i) ∧
      spin x i + t * (spin y i - spin x i) ≤ 1 := by
  rcases ht with ⟨hl, hu⟩
  cases hx : x i <;> cases hy : y i <;>
    simp only [spin, hx, hy, Bool.false_eq_true, ↓reduceIte] <;> constructor <;> nlinarith

lemma spin_vertex_distance_sq {n : ℕ} (x y : Spin n) :
    (∑ i, (spin y i - spin x i) ^ 2) ≤ 4 * n := by
  calc
    _ ≤ ∑ _i : Fin n, (4 : ℝ) := by
      apply Finset.sum_le_sum
      intro i _
      cases hx : x i <;> cases hy : y i <;>
        norm_num [spin, hx, hy]
    _ = _ := by simp; ring

lemma cubeExtension_direction_bound {n : ℕ} (f : Observables n) (z b : Fin n → ℝ)
    (hz : ∀ i, -1 ≤ z i ∧ z i ≤ 1) (C : ℝ) (hC : 0 ≤ C)
    (hf : ∀ x, ∑ i, (halfDiff i f x) ^ 2 ≤ C ^ 2)
    (hb : ∑ i, (b i) ^ 2 ≤ 4 * n) :
    |∑ i, b i * ∑ x, cubeWeight z x * halfDiff i f x| ≤ 2 * Real.sqrt n * C := by
  have hn : (0 : ℝ) ≤ n := Nat.cast_nonneg n
  have hg := cubeExtension_gradient_sq_le f z hz C hf
  have hs : (∑ i, b i * ∑ x, cubeWeight z x * halfDiff i f x) ^ 2 ≤
      (2 * Real.sqrt n * C) ^ 2 := by
    calc
      _ ≤ (∑ i, (b i) ^ 2) * (∑ i, (∑ x, cubeWeight z x * halfDiff i f x) ^ 2) :=
        Finset.sum_mul_sq_le_sq_mul_sq Finset.univ _ _
      _ ≤ (4 * n) * C ^ 2 := mul_le_mul hb hg
        (Finset.sum_nonneg (fun i _ => sq_nonneg _)) (by positivity)
      _ = _ := by rw [mul_pow, mul_pow, Real.sq_sqrt hn]; ring
  exact le_of_sq_le_sq (by simpa only [sq_abs] using hs) (by positivity)

theorem euclidean_oscillation {n : ℕ} (f : Observables n) (C : ℝ) (hC : 0 ≤ C)
    (hf : ∀ x, ∑ i, (halfDiff i f x) ^ 2 ≤ C ^ 2) (x y : Spin n) :
    |f x - f y| ≤ 2 * Real.sqrt n * C := by
  let F : ℝ → ℝ := fun t => cubeExtension f (fun i => spin x i + t * (spin y i - spin x i))
  have hd (t : ℝ) := cubeExtension_line_deriv f (spin x) (fun i => spin y i - spin x i) t
  have hdiff : ∀ t ∈ Set.Icc (0 : ℝ) 1, DifferentiableAt ℝ F t :=
    fun t _ => (hd t).differentiableAt
  have hbound : ∀ t ∈ Set.Icc (0 : ℝ) 1, ‖deriv F t‖ ≤ 2 * Real.sqrt n * C := by
    intro t ht
    rw [(hd t).deriv, Real.norm_eq_abs]
    exact cubeExtension_direction_bound f _ _ (spin_segment_mem x y t ht) C hC hf
      (spin_vertex_distance_sq x y)
  have hv := (convex_Icc (0 : ℝ) 1).norm_image_sub_le_of_norm_deriv_le
    hdiff hbound (by simp : (0 : ℝ) ∈ Set.Icc (0 : ℝ) 1)
      (by simp : (1 : ℝ) ∈ Set.Icc (0 : ℝ) 1)
  have hf0 : F 0 = f x := by simp [F, cubeExtension_vertex]
  have hf1 : F 1 = f y := by simp [F, cubeExtension_vertex]
  rw [hf0, hf1, sub_zero, norm_one, mul_one, Real.norm_eq_abs, abs_sub_comm] at hv
  exact hv

end SKGapCutoff

open scoped BigOperators

end

end OAI