import OAI.Probability.ClassicalON.RotationInequality

namespace OAI

universe uE uV

noncomputable section
open scoped BigOperators ComplexConjugate
namespace ClassicalON

namespace SpinSystem
variable {V : Type uV} {E : Type uE} [Fintype V] [Fintype E]

theorem response_imaginary_multiple (S : SpinSystem 3 V E) (u : E → ℝ) (r : ℝ) :
    (S.complexSecondResponse (fun e => -Complex.I*((r*u e:ℝ):ℂ))
      (fun e => conj (-Complex.I*((r*u e:ℝ):ℂ)))).re = r^2*S.secondAxisResponse u u := by
  have hf : (fun e => -Complex.I*((r*u e:ℝ):ℂ)) = (-Complex.I*(r:ℂ)) • (fun e => (u e:ℂ)) := by
    ext e; simp only [Pi.smul_apply,smul_eq_mul,Complex.ofReal_mul]; ring
  have hg : (fun e => conj (-Complex.I*((r*u e:ℝ):ℂ))) = (Complex.I*(r:ℂ)) • (fun e => (u e:ℂ)) := by
    ext e; simp only [map_mul,map_neg,Complex.conj_I,neg_neg,Complex.conj_ofReal,Pi.smul_apply,smul_eq_mul,Complex.ofReal_mul]; ring
  rw [hf,hg,S.complexSecondResponse_smul_left,S.complexSecondResponse_smul_right,S.complexSecondResponse_ofReal]
  simp only [Complex.mul_re,Complex.mul_im,Complex.neg_re,Complex.neg_im,Complex.I_re,Complex.I_im,Complex.ofReal_re,Complex.ofReal_im]
  ring

end SpinSystem

namespace LatticeGraph

def spinSystem (G : LatticeGraph) (n : ℕ) (b : G.edges → ℝ) (P : G.vertices → Option (Spin n)) :
    SpinSystem n G.vertices G.edges := ⟨fun e => e.val.1,fun e => e.val.2,b,P⟩

def BoundaryPins (G : LatticeGraph) (k n : ℕ) (P : G.vertices → Option (Spin n)) : Prop :=
  ∀ x s, P x=some s →
    (|(scaledSite k x.val).1| ≤ 1 ∧ |(scaledSite k x.val).2| ≤ 1) ∨
    (2 ≤ |(scaledSite k x.val).1| ∨ 2 ≤ |(scaledSite k x.val).2|)

theorem modes_zero_pins (G : LatticeGraph) (k n : ℕ) (P : G.vertices → Option (Spin n))
    (hP : G.BoundaryPins k n P) (i : ModeIndex k) (x : G.vertices) (s : Spin n) (hs : P x=some s) :
    G.modes i x=0 := by
  have hp : squareProfile i.1.1 i.1.2 (scaledSite k x.val)=0 := by
    rcases hP x s hs with h | h
    · exact squareProfile_zero_inner _ _ _ h.1 h.2
    · exact squareProfile_zero_outer _ _ _ h
  simp [modes,latticeMode,hp]

theorem system_modes_commutator (G : LatticeGraph) (k : ℕ) (b : G.edges → ℝ) (P : G.vertices → Option (Spin 3)) :
    (∑ i : ModeIndex k, (G.spinSystem 3 b P).commutatorForm (G.modes i) (fun x => conj (G.modes i x))) =
      (fun e => -Complex.I*((dyadicLambda k*G.profileEdge k e:ℝ):ℂ)) := by
  ext e
  rw [Finset.sum_apply]
  convert G.modes_commutator e using 1
  apply Finset.sum_congr rfl
  intro i _
  simp only [SpinSystem.commutatorForm,SpinSystem.complexCross,Pi.smul_apply,smul_eq_mul,
    spinSystem,modes,modeCommutator]
  ring

theorem profile_response_bound (G : LatticeGraph) (k : ℕ) (hk : 0 < k) (hG : G.WithinDyadicBox k)
    (β : ℝ) (hβ : 0 ≤ β) (b : G.edges → ℝ) (hb : ∀ e, 0 ≤ b e ∧ b e ≤ β)
    (P : G.vertices → Option (Spin 3)) (hP : G.BoundaryPins k 3 P)
    (C : ℝ) (hC : 0 ≤ C) (hv : ∀ m s z, |squareProfile m s z| ≤ C)
    (hLip : ∀ m s z w, |squareProfile m s w-squareProfile m s z| ≤ C*‖w-z‖) :
    -(G.spinSystem 3 b P).secondAxisResponse (G.profileEdge k) (G.profileEdge k) ≤
      4*((6*β^2+4*β*Real.sqrt β+β)*(48*(2*modeBlockConstant C)^4)+
        β*(576*C^2*(2*modeBlockConstant C)^2))/(k:ℝ) := by
  let a := 2*modeBlockConstant C
  let M := (6*β^2+4*β*Real.sqrt β+β)*(48*a^4)+β*(576*C^2*a^2)
  have ha (m s : Bool) := G.scaledModes_squareBound hG C hv hLip m s
  have hM : 0 ≤ M := by dsimp only [M]; positivity
  have hLam : (k:ℝ)/2 ≤ dyadicLambda k := dyadicLambda_lower k
  have hkR : (0:ℝ)<k := by exact_mod_cast hk
  have hLp : 0 < dyadicLambda k := by linarith
  have h := (G.spinSystem 3 b P).rotation_family_bound β hβ hb (G.modes (k := k))
    (fun i x s hs => G.modes_zero_pins k 3 P hP i x s hs)
  have hd : (fun i : ModeIndex k => (G.spinSystem 3 b P).differential (G.modes i)) = G.modeDifferences := rfl
  rw [G.system_modes_commutator k b P, (G.spinSystem 3 b P).response_imaginary_multiple,hd] at h
  have hHS := G.modes_HS_bound a ha
  have hmin := G.modes_min_bound a C hC hv ha
  have hK : 0 ≤ 6*β^2+4*β*Real.sqrt β+β := by positivity
  have hcost : (6*β^2+4*β*Real.sqrt β+β)*familyHSSquare (G.modeDifferences (k := k))+
      β*(∑ i : ModeIndex k, ∑ j : ModeIndex k,
      min (‖G.modes i‖^2*∑ e, ‖G.modeDifferences j e‖^2)
          (‖G.modes j‖^2*∑ e, ‖G.modeDifferences i e‖^2)) ≤ M*(k:ℝ) := by
    calc _ ≤ (6*β^2+4*β*Real.sqrt β+β)*(48*a^4*(k:ℝ))+β*(576*C^2*a^2*(k:ℝ)) :=
      add_le_add (mul_le_mul_of_nonneg_left hHS hK) (mul_le_mul_of_nonneg_left hmin hβ)
         _ = _ := by dsimp only [M]; ring
  have hfinal : -(G.spinSystem 3 b P).secondAxisResponse (G.profileEdge k) (G.profileEdge k) ≤ 4*M/(k:ℝ) := by
    by_cases hr : (G.spinSystem 3 b P).secondAxisResponse (G.profileEdge k) (G.profileEdge k) ≤ 0
    · apply (le_div_iff₀ hkR).mpr
      have hsq : (k:ℝ)^2/4 ≤ (dyadicLambda k)^2 := by nlinarith
      have hh := mul_le_mul_of_nonneg_right hsq (neg_nonneg.mpr hr)
      have ht := h.trans hcost
      nlinarith
    · have hh : 0 ≤ 4*M/(k:ℝ) := by positivity
      linarith
  exact hfinal

end LatticeGraph
end ClassicalON

end

end OAI