import Mathlib
import OAI.Probability.SKBarriers.SpinGlass.Basic

namespace OAI

section

section
noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter Set
namespace SK.Analytic
open scoped InnerProductSpace

theorem unit_conflict_packing {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
    {d : ℕ} (hd : 0 < d) (u : Fin d → E) (w : E) {a b : ℝ}
    (hb : 0 < b) (ha : 0 ≤ a) (hab : a < b^2/2)
    (hu : ∀ i, ‖u i‖ = 1) (hw : ‖w‖ = 1)
    (hoff : ∀ i j, i ≠ j → ⟪u i,u j⟫_ℝ ≤ a)
    (hconf : ∀ i, b < ⟪u i,w⟫_ℝ) : (d:ℝ) < 2/b^2 := by
  classical
  let U := ∑ i, u i
  have hdR : 0 < (d:ℝ) := by exact_mod_cast hd
  have hsum : (d:ℝ)*b < ⟪U,w⟫_ℝ := by
    dsimp only [U]
    rw [sum_inner]
    have H := Finset.sum_lt_sum_of_nonempty (s := (Finset.univ : Finset (Fin d)))
      (Finset.univ_nonempty_iff.mpr ⟨⟨0,hd⟩⟩) (fun i _ => hconf i)
    simpa only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] using H
  have hCS : ⟪U,w⟫_ℝ ≤ ‖U‖ := by simpa only [hw,mul_one] using real_inner_le_norm U w
  have hdiag (i : Fin d) : (∑ j : Fin d, ⟪u i,u j⟫_ℝ) ≤ 1+((d:ℝ)-1)*a := by
    have H := Finset.sum_le_sum (s := (Finset.univ : Finset (Fin d)))
      (g := fun j => if i=j then (1:ℝ) else a) (fun j _ => show ⟪u i,u j⟫_ℝ ≤ (if i=j then 1 else a) from by
        by_cases hij : i=j
        · subst j; simp only [ite_true,real_inner_self_eq_norm_sq,hu,one_pow,le_refl]
        · simp only [ite_eq_right hij]; exact hoff i j hij)
    have he : (∑ j : Fin d, if i=j then (1:ℝ) else a) = 1+((d:ℝ)-1)*a := by
      have hh (j : Fin d) : (if i=j then (1:ℝ) else a) = a+(if i=j then 1-a else 0) := by split_ifs <;> ring
      simp_rw [hh]
      simp only [Finset.sum_add_distrib,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,
        Finset.sum_ite_eq,Finset.mem_univ,ite_true]
      ring
    rwa [he] at H
  have hnorm : ‖U‖^2 ≤ (d:ℝ)+(d:ℝ)*((d:ℝ)-1)*a := by
    rw [← real_inner_self_eq_norm_sq]
    dsimp only [U]
    rw [sum_inner]
    simp_rw [inner_sum]
    have H := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin d))) => hdiag i)
    simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] at H
    nlinarith [H]
  have hqlt : ((d:ℝ)*b)^2 < ‖U‖^2 := sq_lt_sq₀ (by positivity) (norm_nonneg _) |>.mpr (hsum.trans_le hCS)
  have hdb : (d:ℝ)*b^2 < 1+((d:ℝ)-1)*a := by
    have H : (d:ℝ)*((d:ℝ)*b^2) < (d:ℝ)*(1+((d:ℝ)-1)*a) := by nlinarith [hqlt,hnorm]
    exact (mul_lt_mul_iff_right₀ hdR).mp H
  have hdiff : b^2-a > b^2/2 := by linarith
  have H : (d:ℝ)*(b^2-a) < 1-a := by nlinarith [hdb]
  have H' : (d:ℝ)*(b^2/2) < 1 := by nlinarith [mul_lt_mul_of_pos_left hdiff hdR,H]
  apply (lt_div_iff₀ (sq_pos_of_pos hb)).mpr
  nlinarith

def configVector {n : ℕ} (x : Config n) : EuclideanSpace ℝ (Fin n) :=
  WithLp.toLp 2 (fun i => spin (x i)/Real.sqrt (n:ℝ))

theorem configVector_inner {n : ℕ} (hn : 0 < n) (x y : Config n) :
    ⟪configVector x,configVector y⟫_ℝ = overlap x y := by
  rw [configVector,configVector,EuclideanSpace.inner_toLp_toLp]
  simp only [dotProduct,Pi.star_apply,star_trivial]
  have hn0 : 0 ≤ (n:ℝ) := by positivity
  have he (i : Fin n) : spin (y i)/Real.sqrt (n:ℝ)*(spin (x i)/Real.sqrt (n:ℝ)) =
      (spin (x i)*spin (y i))/(n:ℝ) := by
    rw [div_mul_div_comm,Real.mul_self_sqrt hn0,mul_comm (spin (y i))]
  simp_rw [he]
  rw [← Finset.sum_div]
  rfl

theorem configVector_norm {n : ℕ} (hn : 0 < n) (x : Config n) : ‖configVector x‖ = 1 := by
  have H := configVector_inner hn x x
  rw [real_inner_self_eq_norm_sq,overlap_self hn] at H
  nlinarith [norm_nonneg (configVector x)]

theorem config_conflict_packing {n d : ℕ} (hn : 0 < n) (hd : 0 < d)
    (x : Fin d → Config n) (w : Config n) {a b : ℝ}
    (hb : 0 < b) (ha : 0 ≤ a) (hab : a < b^2/2)
    (hoff : ∀ i j, i ≠ j → |overlap (x i) (x j)| ≤ a)
    (hconf : ∀ i, b < |overlap (x i) w|) : (d:ℝ) < 2/b^2 := by
  let u : Fin d → EuclideanSpace ℝ (Fin n) := fun i =>
    if 0 ≤ overlap (x i) w then configVector (x i) else -configVector (x i)
  apply unit_conflict_packing hd u (configVector w) hb ha hab
  · intro i
    dsimp only [u]
    split_ifs <;> simp only [norm_neg,configVector_norm hn]
  · exact configVector_norm hn w
  · intro i j hij
    have H := hoff i j hij
    have HP := (le_abs_self (overlap (x i) (x j))).trans H
    have HN := (neg_le_abs (overlap (x i) (x j))).trans H
    dsimp only [u]
    split_ifs <;> simp only [inner_neg_left,inner_neg_right,configVector_inner hn,neg_neg] <;> assumption
  · intro i
    dsimp only [u]
    split_ifs with hs
    · simpa only [configVector_inner hn,abs_of_nonneg hs] using hconf i
    · simpa only [inner_neg_left,configVector_inner hn,abs_of_neg (lt_of_not_ge hs)] using hconf i

end SK.Analytic

end
end

end

end OAI