import Mathlib
import OAI.Probability.SKGap.Matrix.PrimitiveTrace
import OAI.Probability.SKGap.Matrix.ClosedTrace

namespace OAI

section

noncomputable section
open scoped BigOperators
namespace SKGapCutoff.Recipe
open Matrix SKGap SKGap.Noncrossing SKGap.Noncrossing.Primary SKGap.Noncrossing.Diagram
variable {n : ℕ}

theorem finite_graph_trace_tested (J : Interaction n) (E F Es Ef : ℕ→Interaction n)
    (p : (a : ℕ)→Fin a→Fin n→ℝ) (r : (a : ℕ)→Fin a→ℝ)
    (hE : ∀a,E a=(∑b:Fin a,Matrix.diagonal (p a b)*F b)+Es a)
    (hF : ∀a,F a=J*E a-(∑b:Fin a,r a b • E b)+Ef a)
    {A R M : ℝ} {Cs Cf : ℕ→ℝ} {N L : ℕ}
    (_ : 0≤R) (_ : 0≤M)
    (hp : ∀a≤N,∀b i,|p a b i|≤A) (hr : ∀a≤N,∀b,|r a b|≤R)
    (hsn : ∀a≤N,0≤Cs a) (hfn : ∀a≤N,0≤Cf a)
    (hs : ∀a≤N,∀w:OrdinaryWord n,w.length≤L→wordBounded A w→
      |trace (matrixWord J w*Es a)|≤Cs a*M)
    (hf : ∀a≤N,∀w:OrdinaryWord n,w.length≤L→wordBounded A w→
      |trace (matrixWord J w*Ef a)|≤Cf a*M) :
    ∀a≤N,
      (∀w:OrdinaryWord n,w.length+2*a+1≤L→wordBounded A w→
        |trace (matrixWord J w*E a)|≤(errorBudget R Cs Cf a).1*M) ∧
      (∀w:OrdinaryWord n,w.length+2*a+2≤L→wordBounded A w→
        |trace (matrixWord J w*F a)|≤(errorBudget R Cs Cf a).2*M) := by
  intro a
  induction a using Nat.strong_induction_on with
  | h a ih =>
    intro ha
    have hs₀ : 0≤Cs a := hsn a ha
    have hf₀ : 0≤Cf a := hfn a ha
    have hprev (b : Fin a) := ih b b.isLt (b.isLt.le.trans ha)
    have hCs (w : OrdinaryWord n) (hlen : w.length≤L) (hwb : wordBounded A w) :
        |trace (matrixWord J w*Es a)|≤Cs a*M :=
      hs a ha w hlen hwb
    have hCf (w : OrdinaryWord n) (hlen : w.length≤L) (hwb : wordBounded A w) :
        |trace (matrixWord J w*Ef a)|≤Cf a*M :=
      hf a ha w hlen hwb
    have hsource : ∀w:OrdinaryWord n,w.length+2*a+1≤L→wordBounded A w→
        |trace (matrixWord J w*E a)|≤(errorBudget R Cs Cf a).1*M := by
      intro w hlen hwb
      have hterms (b : Fin a) : |trace (matrixWord J w*(Matrix.diagonal (p a b)*F b))|≤
          (errorBudget R Cs Cf b).2*M := by
        have H:=(hprev b).2 (w++[.diag (p a b)]) (by simp only [List.length_append,List.length_singleton]; omega)
          (wordBounded_diag hwb _ (hp a ha b))
        simpa only [matrixWord_append,matrixWord,List.map_cons,List.map_nil,List.prod_cons,List.prod_nil,
          matrixLetter,List.map_append,List.prod_append,mul_one,mul_assoc] using H
      rw [hE a,mul_add,trace_add,errorBudget]
      dsimp only
      have H:=(Finset.abs_sum_le_sum_abs (s:=Finset.univ) (f:=fun b:Fin a=>trace (matrixWord J w*(Matrix.diagonal (p a b)*F b)))).trans
        (Finset.sum_le_sum fun b _=>hterms b)
      rw [←trace_sum,←Matrix.mul_sum,←Finset.sum_mul] at H
      exact ((abs_add_le _ _).trans (add_le_add H (hCs w (by omega) hwb))).trans_eq (by ring)
    refine ⟨hsource,?_⟩
    intro w hlen hwb
    have hsnew:=hsource (w++[.noise]) (by simp only [List.length_append,List.length_singleton]; omega)
      (wordBounded_noise hwb)
    have Hs : |trace (matrixWord J w*(J*E a))|≤(errorBudget R Cs Cf a).1*M := by
      simpa only [matrixWord_append,matrixWord,List.map_cons,List.map_nil,List.prod_cons,List.prod_nil,
        matrixLetter,List.map_append,List.prod_append,mul_one,mul_assoc] using hsnew
    have hterms (b : Fin a) : |trace (matrixWord J w*(r a b • E b))|≤
        R*(errorBudget R Cs Cf b).1*M := by
      have H:=(hprev b).1 w (by omega) hwb
      have hB : 0≤(errorBudget R Cs Cf b).1*M := (abs_nonneg _).trans H
      rw [Matrix.mul_smul,trace_smul,smul_eq_mul,abs_mul]
      exact ((mul_le_mul_of_nonneg_left H (abs_nonneg _)).trans
        (mul_le_mul_of_nonneg_right (hr a ha b) hB)).trans_eq (by ring)
    have H:=(Finset.abs_sum_le_sum_abs (s:=Finset.univ) (f:=fun b:Fin a=>trace (matrixWord J w*(r a b • E b)))).trans
      (Finset.sum_le_sum fun b _=>hterms b)
    rw [←trace_sum,←Matrix.mul_sum] at H
    rw [hF a,mul_add,mul_sub,trace_add,trace_sub]
    apply ((abs_add_le _ _).trans (add_le_add ((abs_sub _ _).trans (add_le_add Hs H))
      (hCf w (by omega) hwb))).trans_eq
    rw [errorBudget]
    dsimp only
    rw [←Finset.sum_mul,←Finset.mul_sum]
    ring

def closedWordBounded (A : ℝ) (w : List (WordLetter (Fin n))) : Prop :=
  ∀l∈w,match l with | .diag p=>∀i,|p i|≤A | .noise=>True | .inverse=>True

def ClosedWordTestBound (j : ℝ) (a : Fin n→ℝ) (J : Interaction n)
    (A M : ℝ) (L : ℕ) : Prop :=
  ∀w:List (WordLetter (Fin n)),w.length≤L→inverseCount w≤1→closedWordBounded A w→
    testSize (exactWord j a w J)≤M

lemma closedWordBounded_append {A : ℝ} {P Q : List (WordLetter (Fin n))}
    (hP : closedWordBounded A P) (hQ : closedWordBounded A Q) : closedWordBounded A (P++Q) := by
  intro l hl;rcases List.mem_append.mp hl with hl|hl
  · exact hP l hl
  · exact hQ l hl
lemma closedWordBounded_lift {A : ℝ} {w : OrdinaryWord n} (hw : wordBounded A w) :
    closedWordBounded A (liftWord w) := by
  intro l hl
  obtain ⟨q,hq,rfl⟩:=List.mem_map.mp hl
  cases q with
  | diag p=>exact hw _ hq
  | noise=>trivial

lemma implicit_error_elimination (A J K E F Es Ef : Interaction n) (q : ℝ)
    (hK : K*(1-A*(J-q • 1))=1)
    (hE : E=A*F+Es) (hF : F=(J-q • 1)*E+Ef) :
    E=K*(Es+A*Ef) := by
  have he : (1-A*(J-q • 1))*E=Es+A*Ef := by
    rw [sub_mul,one_mul,mul_assoc]
    rw [hF,mul_add] at hE
    nth_rw 1 [hE]
    abel
  have hk:=congrArg (fun P:Interaction n=>K*P) he
  rw [←mul_assoc,hK,one_mul] at hk
  exact hk

theorem implicit_trace_bound (j : ℝ) (a : Fin n→ℝ) (J Es Ef : Interaction n)
    {C D A M : ℝ} {L : ℕ} (hs : TraceControl Es C) (hf : TraceControl Ef D)
    (ha : ∀i,|a i|≤A) (hw : ClosedWordTestBound j a J A M L)
    (w : OrdinaryWord n) (hlen : w.length+2≤L) (hwb : wordBounded A w) :
    |trace (matrixWord J w*((WordLetter.inverse.exactEval j a J)*(Es+Matrix.diagonal a*Ef)))|
      ≤(C+D)*M := by
  have hb₁ : closedWordBounded (n:=n) A [WordLetter.inverse] := by
    intro l hl;have hl₀:=List.mem_singleton.mp hl;subst l;trivial
  have hb₂ : closedWordBounded A [WordLetter.inverse,.diag a] := by
    intro l hl;simp only [List.mem_cons,List.not_mem_nil,or_false] at hl
    rcases hl with rfl|rfl
    · trivial
    · exact ha
  have h₁ := hw (liftWord w++[.inverse])
    (by simpa only [liftWord,List.length_map,List.length_append,List.length_singleton] using (show w.length+1≤L by omega))
    (by rw [inverseCount_append,inverseCount_lift];simp [inverseCount]) (closedWordBounded_append (closedWordBounded_lift hwb) hb₁)
  have h₂ := hw (liftWord w++[.inverse,.diag a])
    (by simpa only [liftWord,List.length_map,List.length_append,List.length_cons,List.length_nil] using hlen)
    (by rw [inverseCount_append,inverseCount_lift];simp [inverseCount]) (closedWordBounded_append (closedWordBounded_lift hwb) hb₂)
  rw [exactWord_append,exactWord_lift] at h₁ h₂
  simp only [exactWord,matrixFactorProduct,List.map_cons,List.map_nil,
    List.prod_cons,List.prod_nil,mul_one,WordLetter.exactEval] at h₁ h₂
  have H₁:=(hs.bound (matrixWord J w*WordLetter.inverse.exactEval j a J)).trans
    (mul_le_mul_of_nonneg_left h₁ hs.nonneg)
  have H₂:=(hf.bound (matrixWord J w*WordLetter.inverse.exactEval j a J*Matrix.diagonal a)).trans
    (mul_le_mul_of_nonneg_left (by simpa only [mul_assoc,WordLetter.exactEval] using h₂) hf.nonneg)
  rw [mul_add,mul_add,trace_add]
  exact ((abs_add_le _ _).trans (add_le_add
    (by simpa only [mul_assoc] using H₁) (by simpa only [mul_assoc] using H₂))).trans_eq (by ring)

theorem implicit_source_field_trace (j : ℝ) (a : Fin n→ℝ) (J E F Es Ef : Interaction n) (q : ℝ)
    (hE : E=WordLetter.inverse.exactEval j a J*(Es+Matrix.diagonal a*Ef))
    (hF : F=(J-q • 1)*E+Ef)
    {C D A M : ℝ} {L : ℕ} (hs : TraceControl Es C) (hf : TraceControl Ef D)
    (ha : ∀i,|a i|≤A) (hw : ClosedWordTestBound j a J A M L)
    (w : OrdinaryWord n) (hlen : w.length+3≤L) (hwb : wordBounded A w) :
    |trace (matrixWord J w*E)|≤(C+D)*M ∧
    |trace (matrixWord J w*F)|≤((1+|q|)*(C+D)+D)*M := by
  have HE : |trace (matrixWord J w*E)|≤(C+D)*M := by
    rw [hE];exact implicit_trace_bound j a J Es Ef hs hf ha hw w (by omega) hwb
  have HJ : |trace (matrixWord J w*(J*E))|≤(C+D)*M := by
    have H:=implicit_trace_bound j a J Es Ef hs hf ha hw (w++[.noise])
      (by simp only [List.length_append,List.length_singleton];omega) (wordBounded_noise hwb)
    simpa only [←hE,matrixWord_append,matrixWord,List.map_cons,List.map_nil,List.prod_cons,
      List.prod_nil,List.map_append,List.prod_append,matrixLetter,mul_one,mul_assoc] using H
  have Hf : |trace (matrixWord J w*Ef)|≤D*M := by
    have H:=hw (liftWord w) (by simp only [liftWord,List.length_map];omega)
      (by simp) (closedWordBounded_lift hwb)
    rw [exactWord_lift] at H
    exact (hf.bound _).trans (mul_le_mul_of_nonneg_left H hf.nonneg)
  refine ⟨HE,?_⟩
  rw [hF,sub_mul,smul_mul_assoc,one_mul,mul_add,mul_sub,Matrix.mul_smul,
    trace_add,trace_sub,trace_smul,smul_eq_mul]
  have HQ : |q*trace (matrixWord J w*E)|≤|q| *((C+D)*M) := by
    rw [abs_mul];exact mul_le_mul_of_nonneg_left HE (abs_nonneg _)
  exact ((abs_add_le _ _).trans (add_le_add ((abs_sub _ _).trans (add_le_add HJ HQ)) Hf)).trans_eq (by ring)

lemma ClosedWordTestBound.ordinary {j : ℝ} {a : Fin n→ℝ} {J : Interaction n}
    {A M : ℝ} {L : ℕ} (h : ClosedWordTestBound j a J A M L) : WordTestBound J A M L := by
  intro w hw hb
  have H:=h (liftWord w) (by simpa only [liftWord,List.length_map] using hw)
    (by simp) (closedWordBounded_lift hb)
  simpa only [exactWord_lift] using H

theorem closed_finite_graph_trace (j : ℝ) (a₀ : Fin n→ℝ) (J : Interaction n)
    (E F Es Ef : ℕ→Interaction n) (P Q : Interaction n) (q : ℝ)
    (p : (a : ℕ)→Fin a→Fin n→ℝ) (r : (a : ℕ)→Fin a→ℝ)
    (hE : ∀a,E a=(∑b:Fin a,Matrix.diagonal (p a b)*F b)+Es a)
    (hF : ∀a,F a=J*E a-(∑b:Fin a,r a b • E b)+Ef a)
    (hEs : Es 0=WordLetter.inverse.exactEval j a₀ J*(P+Matrix.diagonal a₀*Q))
    (hEf : Ef 0=(-q) • Es 0+Q)
    {C D A R M : ℝ} {Cs Cf : ℕ→ℝ} {N L : ℕ}
    (hP : TraceControl P C) (hQ : TraceControl Q D)
    (hR : 0≤R) (hM : 0≤M) (ha : ∀i,|a₀ i|≤A)
    (hp : ∀a≤N,∀b i,|p a b i|≤A) (hr : ∀a≤N,∀b,|r a b|≤R)
    (hs : ∀a≤N,0<a→TraceControl (Es a) (Cs a))
    (hf : ∀a≤N,0<a→TraceControl (Ef a) (Cf a))
    (hw : ClosedWordTestBound j a₀ J A M (L+2)) :
    let Bs:=fun a=>if a=0 then C+D else Cs a
    let Bf:=fun a=>if a=0 then |q| *(C+D)+D else Cf a
    ∀a≤N,
      (∀w:OrdinaryWord n,w.length+2*a+1≤L→wordBounded A w→
        |trace (matrixWord J w*E a)|≤(errorBudget R Bs Bf a).1*M) ∧
      (∀w:OrdinaryWord n,w.length+2*a+2≤L→wordBounded A w→
        |trace (matrixWord J w*F a)|≤(errorBudget R Bs Bf a).2*M) := by
  dsimp only
  have hsource (w : OrdinaryWord n) (hlen : w.length≤L) (hwb : wordBounded A w) :
      |trace (matrixWord J w*Es 0)|≤(C+D)*M := by
    rw [hEs]
    exact implicit_trace_bound j a₀ J P Q hP hQ ha hw w (by omega) hwb
  have hfield (w : OrdinaryWord n) (hlen : w.length≤L) (hwb : wordBounded A w) :
      |trace (matrixWord J w*Ef 0)|≤(|q| *(C+D)+D)*M := by
    have H₁:=hsource w hlen hwb
    have H₂:=(hQ.bound (matrixWord J w)).trans (mul_le_mul_of_nonneg_left
      (hw.ordinary w (by omega) hwb) hQ.nonneg)
    rw [hEf,mul_add,Matrix.mul_smul,trace_add,trace_smul,smul_eq_mul]
    have H₃ : |(-q)*trace (matrixWord J w*Es 0)|≤|q| *((C+D)*M) := by
      rw [abs_mul,abs_neg];exact mul_le_mul_of_nonneg_left H₁ (abs_nonneg q)
    exact ((abs_add_le _ _).trans (add_le_add H₃ H₂)).trans_eq (by ring)
  apply finite_graph_trace_tested J E F Es Ef p r hE hF hR hM hp hr
  · intro a haN;split_ifs with h
    · exact add_nonneg hP.nonneg hQ.nonneg
    · exact (hs a haN (Nat.pos_of_ne_zero h)).nonneg
  · intro a haN;split_ifs with h
    · exact add_nonneg (mul_nonneg (abs_nonneg _) (add_nonneg hP.nonneg hQ.nonneg)) hQ.nonneg
    · exact (hf a haN (Nat.pos_of_ne_zero h)).nonneg
  · intro a haN w hlen hwb
    by_cases ha0 : a=0
    · subst a;simpa only [ite_true] using hsource w hlen hwb
    · simpa only [ite_eq_right ha0] using (hs a haN (Nat.pos_of_ne_zero ha0)).bound (matrixWord J w) |>.trans
        (mul_le_mul_of_nonneg_left (hw.ordinary w (by omega) hwb) (hs a haN (Nat.pos_of_ne_zero ha0)).nonneg)
  · intro a haN w hlen hwb
    by_cases ha0 : a=0
    · subst a;simpa only [ite_true] using hfield w hlen hwb
    · simpa only [ite_eq_right ha0] using (hf a haN (Nat.pos_of_ne_zero ha0)).bound (matrixWord J w) |>.trans
        (mul_le_mul_of_nonneg_left (hw.ordinary w (by omega) hwb) (hf a haN (Nat.pos_of_ne_zero ha0)).nonneg)

end SKGapCutoff.Recipe

end
end

end OAI