import Mathlib
import OAI.Probability.SKGap.Localization.CoefficientRow
import OAI.Probability.SKGap.Stability.ImplicitPerturb
import OAI.Probability.SKGap.Stability.ImplicitUniform

namespace OAI

section

noncomputable section
namespace SKGap.ImplicitSystem
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] {ι : Type*} [Fintype ι]

def uniformControlBudget (j δ B : ℝ) : ℝ :=
  let L:=B+|j| *B^2+2*|j| *B
  let W:=(1+B^2*(δ/2)⁻¹*L)*B^2*(B+2*|j| *B)
  let C:=B*W+B
  let Y:=(B+|j| *B^2)*W+|j| *C
  let F:=(1+B^2*(δ/2)⁻¹*L)*(B*(B+Y+|j| *C)+B^2*B+
        |j| *B^2*W*B+|j| *B^2*C*B+|j| *B^2*2*(B*W+B))
  let G:=B*W+B+B*F
  let H:=(B+|j| *B^2)*F+|j| *W*B+|j| *C*B+|j| *G
  W+C+Y+F+G+H

lemma uniformControlBudget_nonneg {j δ B : ℝ} (hδ : 0<δ) (hB : 0≤B) :
    0≤uniformControlBudget j δ B := by unfold uniformControlBudget; positivity

theorem implicit_uniform_control (j χ b r p : ℝ) (X J : E→L[ℝ]E)
    (u m t ell q w y : E) (c : ℝ)
    (s χ' p' c' b' : ι→ℝ) (X' : ι→E→L[ℝ]E) (u' m' ell' w' y' q' : ι→E)
    {δ d B : ℝ} (hδ : 0<δ) (hd : 0<d) (hr : 0≤r) (hscale : r*d^2=1) (hB : 0≤B)
    (hX : ‖X‖≤B) (hX' : ∀i,‖X' i‖≤B) (hJ : ‖J‖≤B)
    (hχ : |χ|≤B^2) (hχ' : ∀i,|χ' i|≤B^2)
    (hu : ‖u‖≤B) (hm : ‖m‖≤d) (hm' : ∀i,‖m' i‖≤d) (ht : ‖t‖≤d)
    (hell : ‖ell‖≤B*d) (hell' : ∀i,‖ell' i‖≤B*d) (hp : d*|p|≤B)
    (hS : ∀v,δ*‖v‖^2≤ inner ℝ v (stableMatrix j b r X J q v))
    (hS' : ∀i v,δ*‖v‖^2≤ inner ℝ v (stableMatrix j (b' i) r (X' i) J (q' i) v))
    (hSmall : |j| *|χ-b| *‖X‖^2+|j*r| *‖X‖^2*
      (‖m+t-(2:ℝ) • q‖*‖ell‖+2*‖q‖*‖ell+q‖)≤δ/2)
    (hSmall' : ∀i,|j| *|χ' i-b' i| *‖X' i‖^2+|j*r| *‖X' i‖^2*
      (‖m' i+t-(2:ℝ) • q' i‖*‖ell' i‖+2*‖q' i‖*‖ell' i+q' i‖)≤δ/2)
    (h : Equations j χ r p (X*X) J u m t ell w y c)
    (h' : ∀i,Equations j (χ' i) r (p' i) (X' i*X' i) J (u' i) (m' i) t (ell' i) (w' i) (y' i) (c' i))
    (hDA : ∀V,columnNorm (fun i=>(s i • (X*X-X' i*X' i)) V)≤B*‖V‖)
    (hDu : columnNorm (fun i=>s i • (u-u' i))≤B)
    (hDχ : columnNorm (fun i=>s i*(χ-χ' i))≤B)
    (hDm : columnNorm (fun i=>s i • (m-m' i))≤B*d)
    (hDell : columnNorm (fun i=>s i • (ell-ell' i))≤B*d)
    (hDp : d*columnNorm (fun i=>s i*(p-p' i))≤B) :
    ‖w‖+d*|c|+‖y‖+columnNorm (fun i=>s i • (w-w' i))+
      d*columnNorm (fun i=>s i*(c-c' i))+columnNorm (fun i=>s i • (y-y' i))≤
        uniformControlBudget j δ B := by
  let L:=B+|j| *B^2+2*|j| *B
  let W:=(1+B^2*(δ/2)⁻¹*L)*B^2*(B+2*|j| *B)
  let C:=B*W+B
  let Y:=(B+|j| *B^2)*W+|j| *C
  let F:=(1+B^2*(δ/2)⁻¹*L)*(B*(B+Y+|j| *C)+B^2*B+
        |j| *B^2*W*B+|j| *B^2*C*B+|j| *B^2*2*(B*W+B))
  let G:=B*W+B+B*F
  let H:=(B+|j| *B^2)*F+|j| *W*B+|j| *C*B+|j| *G
  have hW0 : 0≤W := by dsimp [W,L]; positivity
  have hC0 : 0≤C := by dsimp [C]; positivity
  have hY0 : 0≤Y := by dsimp [Y]; positivity
  have hL0 : 0≤L := by dsimp [L]; positivity
  have hF0 : 0≤F := by dsimp [F]; positivity
  obtain ⟨hw,hc,hy⟩:=implicit_uniform_size j χ b r p X J u m t ell q w y c
    hδ hd hr hscale (sq_nonneg B) hB hB hB hB
    (pow_le_pow_left₀ (norm_nonneg X) hX 2) hJ hχ hu hm ht hell hp hS hSmall h
  change ‖w‖≤W at hw
  change d*|c|≤C at hc
  change ‖y‖≤Y at hy
  have hl : ∀i,‖L₂ j (χ' i) r J (m' i+t) (ell' i)‖≤L := by
    intro i
    have hv : ‖m' i+t‖≤2*d := (norm_add_le _ _).trans (by linarith [hm' i])
    convert L₂_normalized_bound j (χ' i) r J (m' i+t) (ell' i) hr hd.le hscale
      (by norm_num : (0:ℝ)≤2) hB hv (hell' i) (hχ' i) hJ using 1; dsimp [L]; ring
  have hb : ‖u+J w-(j*χ) • w-(j*c) • (m+t)‖≤B+Y+|j| *C := by
    have he : u+J w-(j*χ) • w-(j*c) • (m+t)=u+y-(j*c) • t := by
      rw [h.2.1]; module
    rw [he]
    apply (norm_sub_le _ _).trans
    have hct : ‖(j*c) • t‖≤|j| *C := by
      rw [norm_smul,Real.norm_eq_abs,abs_mul]
      calc
        _ ≤ |j| *|c| *d := mul_le_mul_of_nonneg_left ht (by positivity)
        _ = |j| *(d*|c|) := by ring
        _ ≤ _ := mul_le_mul_of_nonneg_left hc (abs_nonneg j)
    exact add_le_add ((norm_add_le _ _).trans (add_le_add hu hy)) hct
  have hf:=implicit_frobenius_estimate j χ r p X J u m t ell w y c
    s χ' p' c' X' u' m' ell' w' y' q' b' h h' hδ hB hL0 hd hr hscale
    hB hB hB hB hB hB hC0 (by norm_num : (0:ℝ)≤2) hX' hl hS' hSmall'
    hDA hDu hDχ hDm hDell hDp hc (fun i=>(norm_add_le _ _).trans (by linarith [hm' i]))
  have hf' : columnNorm (fun i=>s i • (w-w' i))≤F := by
    apply hf.trans
    apply mul_le_mul_of_nonneg_left _ (by positivity)
    exact add_le_add (add_le_add (add_le_add (add_le_add
      (mul_le_mul_of_nonneg_left hb hB) le_rfl)
      (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hw (by positivity)) hB)) le_rfl)
      (mul_le_mul_of_nonneg_left (add_le_add (mul_le_mul_of_nonneg_left hw hB) le_rfl) (by positivity))
  have hg : d*columnNorm (fun i=>s i*(c-c' i))≤G := by
    exact (implicit_scalar_columns s r p ell w c p' c' ell' w' h.2.2 (fun i=>(h' i).2.2)
      hr hd hscale hB hDell hDp hB hell').trans (add_le_add
      (add_le_add (mul_le_mul_of_nonneg_left hw hB) le_rfl) (mul_le_mul_of_nonneg_left hf' hB))
  have hh : columnNorm (fun i=>s i • (y-y' i))≤H := by
    have hh:=implicit_field_columns s j χ r p (X*X) J u m t ell w y c χ' p' c'
      (fun i=>X' i*X' i) u' m' ell' w' y' h h' hB (sq_nonneg B) hd hB hB hC0
      (by norm_num : (0:ℝ)≤1) hJ hχ' hDχ hDm hc (by simpa only [one_mul] using hm') hg
    apply hh.trans
    simp only [mul_one]
    exact add_le_add (add_le_add (add_le_add (mul_le_mul_of_nonneg_left hf' (by positivity))
      (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hw (abs_nonneg j)) hB)) le_rfl) le_rfl
  change _≤W+C+Y+F+G+H
  exact add_le_add (add_le_add (add_le_add (add_le_add (add_le_add hw hc) hy) hf') hg) hh
end SKGap.ImplicitSystem

end
end

section

noncomputable section
open scoped BigOperators Matrix.Norms.Frobenius
namespace SKGapCutoff.Recipe
open Primary SKGap.ImplicitSystem
variable {n : ℕ}

lemma halfDiff_column (U : VectorFields n) (x : Spin n) (k : Fin n) :
    ((spin x k/2) • ((WithLp.toLp 2 (U x) : Euclid n)-WithLp.toLp 2 (U (flip x k))))=
      WithLp.toLp 2 (fun i=>derivativeMatrix U x i k) := by
  ext i
  change (spin x k/2)*(U x i-U (flip x k) i)=halfDiff k (fun y=>U y i) x
  rw [halfDiff_as_flip]; ring

lemma columnNorm_halfDiff (U : VectorFields n) (x : Spin n) :
    columnNorm (fun k=>(spin x k/2) •
      ((WithLp.toLp 2 (U x) : Euclid n)-WithLp.toLp 2 (U (flip x k))))=‖derivativeMatrix U x‖ := by
  simp only [halfDiff_column]
  exact columnNorm_matrix _

lemma columnNorm_scalar_halfDiff (f : Spin n→ℝ) (x : Spin n) :
    columnNorm (fun k=>(spin x k/2)*(f x-f (flip x k)))=‖derivativeVector f x‖ := by
  have he : (fun k=>(spin x k/2)*(f x-f (flip x k)))=fun k=>halfDiff k f x := by
    ext k; rw [halfDiff_as_flip]; ring
  rw [he]
  rfl

lemma diagonal_halfDiff_columns (a : VectorFields n) (x : Spin n) {R : ℝ}
    (hR : 0≤R) (ha : ∀i,∑k,(derivativeMatrix a x i k)^2≤R^2)
    (V : Euclid n) :
    columnNorm (fun k=>((spin x k/2) •
      (Matrix.toEuclideanCLM (𝕜:=ℝ) (Matrix.diagonal (a x))-
       Matrix.toEuclideanCLM (𝕜:=ℝ) (Matrix.diagonal (a (flip x k))))) V)≤R*‖V‖ := by
  apply coefficient_diagonal_columns (fun _=>a x) (fun k=>a (flip x k)) (fun k=>spin x k/2) hR
  intro i
  convert ha i using 1
  apply Finset.sum_congr rfl
  intro k _
  congr 1
  rw [derivativeMatrix,halfDiff_as_flip]
  ring

lemma implicit_tuple_small (w y : VectorFields n) (c : Spin n→ℝ) (x : Spin n)
    {d C : ℝ} (hd : 0≤d) (hC : 0≤C)
    (h : vectorNorm (w x)+d*|c x|+vectorNorm (y x)+‖derivativeMatrix w x‖+
      d*‖derivativeVector c x‖+‖derivativeMatrix y x‖≤C) :
    SmallBound w x C ∧ SmallBound y x C ∧
      |d*c x|≤C ∧ ‖derivativeVector (fun z=>d*c z) x‖≤C := by
  have hw0:=vectorNorm_nonneg (w x)
  have hy0:=vectorNorm_nonneg (y x)
  have hc0:=mul_nonneg hd (abs_nonneg (c x))
  have hw1:=norm_nonneg (derivativeMatrix w x)
  have hy1:=norm_nonneg (derivativeMatrix y x)
  have hc1:=mul_nonneg hd (norm_nonneg (derivativeVector c x))
  refine ⟨⟨hC,by linarith,by linarith⟩,⟨hC,by linarith,by linarith⟩,?_,?_⟩
  · rw [abs_mul,abs_of_nonneg hd]; linarith
  · have he : derivativeVector (fun z=>d*c z) x=d • derivativeVector c x := by
      ext k
      change halfDiff k (fun z=>d*c z) x=d*halfDiff k c x
      simp [halfDiff]; ring
    rw [he,norm_smul,Real.norm_eq_abs,abs_of_nonneg hd]
    linarith
end SKGapCutoff.Recipe

end
end

end OAI