import Mathlib
import OAI.Computability.DeterministicSum.AxisMaps
import OAI.Computability.DeterministicSum.DegreeFilter

namespace OAI

/-! Structured Newton transform commands and memory frames. -/

namespace DeterministicThreeSum.Structured
open Command

def copyPrefix (f : ℕ → Operand) : ℕ → Command
  | 0 => .skip
  | n+1 => .seq (copyPrefix f n) (.atom (.assign n (f n)))

def patched (s : Data) (n : ℕ) (v : ℕ → ℕ) : Data :=
  {s with registers:=fun r => if r<n then v r else s.registers r}

lemma patched_zero (s : Data) (v : ℕ → ℕ) : patched s 0 v=s := by
  cases s; simp [patched]

lemma patched_succ (s : Data) (n : ℕ) (v : ℕ → ℕ) :
    put (patched s n v) n (v n)=patched s (n+1) v := by
  apply Data.ext
  · funext r
    by_cases h : r=n
    · subst r; simp [patched,put]
    · simp [patched,put,h,show (r≤n)↔r<n by omega]
  · rfl

lemma copyPrefix_correct {w N : ℕ} (f : ℕ → Operand) (s : Data) (v : ℕ → ℕ)
    (hsource : ∀ i, i<N → ∀ r, f i=.register r → N≤r)
    (hval : ∀ i, i<N → operand w s (f i)=v i) :
    Eval w (copyPrefix f N) s N (patched s N v) := by
  induction N with
  | zero => simpa [copyPrefix,patched_zero] using Eval.skip (w:=w) s
  | succ N ih =>
    have hsrc : ∀ i, i<N → ∀ r, f i=.register r → N≤r := by
      intro i hi r hr; exact Nat.le_of_succ_le (hsource i (by omega) r hr)
    have eh:=ih hsrc (fun i hi => hval i (by omega))
    have hv : operand w (patched s N v) (f N)=v N := by
      rw [← hval N (by omega)]
      cases hf : f N with
      | literal a => rfl
      | register r =>
        have hh:=hsource N (by omega) r hf
        simp [operand_register,patched,show ¬r<N by omega]
    have ea : Eval w (.atom (.assign N (f N))) (patched s N v) 1 (put (patched s N v) N (v N)) := by
      apply Eval.atom; simp [Atom.eval,hv]
    rw [patched_succ] at ea
    exact Eval.seq eh ea

lemma copyPrefix_writes (f : ℕ → Operand) (N : ℕ) :
    (copyPrefix f N).writes⊆Finset.range N := by
  induction N with
  | zero => simp [copyPrefix,Command.writes]
  | succ N ih =>
    intro r hr
    simp only [copyPrefix,Command.writes,Atom.writes,Finset.mem_union,Finset.mem_singleton] at hr
    rcases hr with hr|rfl
    · exact Finset.mem_range.mpr (lt_trans (Finset.mem_range.mp (ih hr)) (by omega))
    · simp

lemma protected_frame {w cost k : ℕ} {s t : Data} {c : Command}
    (he : Eval w c s cost t) (hk : c.writes.sup id < k) (i : ℕ) :
    t.registers (k+i)=s.registers (k+i) := by
  apply register_frame he
  intro hf
  have hle : k+i≤c.writes.sup id := Finset.le_sup (f:=id) hf
  omega
end DeterministicThreeSum.Structured
namespace DeterministicThreeSum.Structured.Indexed.NewtonPass
open Command Axis

def context (A B N Q D C T i : ℕ) : ℕ := match i with
  | 0 => A | 1 => B | 2 => N | 3 => Q | 4 => D | 5 => C | 6 => T | 7 => A*Q | _ => 0

def saveBanks (k : ℕ) : Command := straight [
  .assign (k+8) (.register 3), .assign (k+9) (.register 4)]

def savedBanks (s : Data) (k P S : ℕ) : Data := put (put s (k+8) P) (k+9) S

lemma saveBanks_correct {w k P S : ℕ} (s : Data) (_hk : 16≤k)
    (hP : P<wordModulus w) (hS : S<wordModulus w)
    (h3 : s.registers 3=P) (h4 : s.registers 4=S) :
    Eval w (saveBanks k) s 2 (savedBanks s k P S) := by
  apply straight_correct
  simp [savedBanks,execStraight,Atom.eval,operand_register,put,h3,h4,
    Nat.mod_eq_of_lt hP,Nat.mod_eq_of_lt hS]

def degreeSources (k i : ℕ) : Operand := match i with
  | 1 => .register (k+7) | 2 => .register (k+9)
  | 3 => .register (k+3) | 4 => .register (k+4) | _ => .literal 0

def degreeValues (N S Q D i : ℕ) : ℕ := match i with
  | 1 => N | 2 => S | 3 => Q | 4 => D | _ => 0

lemma degreeSetup_correct {w k N S Q D : ℕ} (s : Data) (hk : 16≤k)
    (hN : N<wordModulus w) (hS : S<wordModulus w) (hQ : Q<wordModulus w) (hD : D<wordModulus w)
    (h7 : s.registers (k+7)=N) (h9 : s.registers (k+9)=S)
    (h3 : s.registers (k+3)=Q) (h4 : s.registers (k+4)=D) :
    Eval w (copyPrefix (degreeSources k) 5) s 5 (patched s 5 (degreeValues N S Q D)) := by
  apply copyPrefix_correct
  · intro i hi r hr
    interval_cases i <;> simp only [degreeSources] at hr <;> cases hr <;> omega
  · intro i hi
    interval_cases i <;> simp [degreeSources,degreeValues,operand_register,operand_literal,
      h7,h9,h3,h4,Nat.mod_eq_of_lt hN,Nat.mod_eq_of_lt hS,Nat.mod_eq_of_lt hQ,Nat.mod_eq_of_lt hD]

def tensorSources (k i : ℕ) : Operand := match i with
  | 1 => .register (k+2) | 2 => .register (k+6) | 3 => .register (k+8)
  | 4 => .register (k+9) | 5 => .register (k+5) | 6 => .register (k+1)
  | 7 => .register k | _ => .literal 0

def tensorValues (T N P S C B A i : ℕ) : ℕ := match i with
  | 1 => N | 2 => T | 3 => P | 4 => S | 5 => C | 6 => B | 7 => A | _ => 0

lemma tensorValues_environment (T N P S C B A : ℕ) (i : Fin 8) :
    tensorValues T N P S C B A i.val=environment T N P S C B A 0 i := by
  fin_cases i <;> rfl

lemma tensorSetup_correct {w k T N P S C B A : ℕ} (s : Data) (hk : 16≤k)
    (hT : T<wordModulus w) (hN : N<wordModulus w) (hP : P<wordModulus w)
    (hS : S<wordModulus w) (hC : C<wordModulus w) (hB : B<wordModulus w) (hA : A<wordModulus w)
    (h0 : s.registers k=A) (h1 : s.registers (k+1)=B) (h2 : s.registers (k+2)=N)
    (h5 : s.registers (k+5)=C) (h6 : s.registers (k+6)=T)
    (h8 : s.registers (k+8)=P) (h9 : s.registers (k+9)=S) :
    Eval w (copyPrefix (tensorSources k) 8) s 8
      (patched s 8 (tensorValues T N P S C B A)) := by
  apply copyPrefix_correct
  · intro i hi r hr
    interval_cases i <;> simp only [tensorSources] at hr <;> cases hr <;> omega
  · intro i hi
    interval_cases i <;> simp [tensorSources,tensorValues,operand_register,operand_literal,
      h0,h1,h2,h5,h6,h8,h9,Nat.mod_eq_of_lt hT,Nat.mod_eq_of_lt hN,Nat.mod_eq_of_lt hP,
      Nat.mod_eq_of_lt hS,Nat.mod_eq_of_lt hC,Nat.mod_eq_of_lt hB,Nat.mod_eq_of_lt hA]

def command (q k : ℕ) : Command := .seq (tensorCommand q q)
  (.seq (saveBanks k) (.seq (copyPrefix (degreeSources k) 5)
    (.seq (DegreeFilter.command q) (.seq (copyPrefix (tensorSources k) 8) (tensorCommand q q)))))

def filtered (q d D : ℕ) (x : ℕ → ℕ) (i : ℕ) : ℕ :=
  if D<DigitSum.value q d (i%(q^d)) then 0 else x i

lemma banks_twice (d P S : ℕ) : banks d (banks d P S).1 (banks d P S).2=(P,S) := by
  by_cases h : Even d <;> simp [banks,h]

lemma tensorStride_le {q : ℕ} (hq : 1<q) (d : ℕ) : tensorStride q d≤q^d := by
  cases d with
  | zero => simp [tensorStride]
  | succ d => simpa [tensorStride,pow_succ] using Nat.le_mul_of_pos_right (q^d) (by omega : 0<q)

lemma initialCount_le {q A : ℕ} (_hq : 1<q) (d : ℕ) : A*q*tensorStride q d≤A*q^d := by
  cases d with
  | zero => simp [tensorStride]
  | succ d => simp [tensorStride,pow_succ',Nat.mul_assoc]
end DeterministicThreeSum.Structured.Indexed.NewtonPass
namespace DeterministicThreeSum.Structured.Indexed.NewtonPass
open Command Axis

theorem command_correct {w T q L d A P S C E D k : ℕ} (s : Data) (x c e : ℕ → ℕ)
    (hk : 16≤k) (hkw : (tensorCommand q q).writes.sup id<k)
    (hq : 1<q) (hA : 0<A) (hT : 0<T)
    (hadd : 2*T<wordModulus w) (hmul : T*T<wordModulus w)
    (hL : A*q^d≤L) (hLw : L*q+L+3<wordModulus w)
    (hP : P+L+1<wordModulus w) (hS : S+L+1<wordModulus w)
    (hC : C+q*q<wordModulus w) (hE : E+q*q<wordModulus w) (hD : D<wordModulus w)
    (hPS : S+L≤P ∨ P+L≤S)
    (hCP : C+q*q≤P ∨ P+L≤C) (hCS : C+q*q≤S ∨ S+L≤C)
    (hEP : E+q*q≤P ∨ P+L≤E) (hES : E+q*q≤S ∨ S+L≤E)
    (hregs : ∀ a : Fin 8, s.registers a.val=
      environment T (A*q*tensorStride q d) P S C (tensorStride q d) A 0 a)
    (hctx : ∀ i, i<8 → s.registers (k+i)=context A (tensorStride q d) (A*q*tensorStride q d) (q^d) D E T i)
    (hx : ∀ i, i<A*q^d → s.memory (S+i)=some (x i) ∧ x i<T)
    (hc : ∀ i, i<q*q → s.memory (C+i)=some (c i) ∧ c i<T)
    (he : ∀ i, i<q*q → s.memory (E+i)=some (e i) ∧ e i<T) :
    ∃ cost z, Eval w (command q k) s cost z ∧
      cost≤2*(((row q q).cost+5)*L+11)*d+(5*d+10)*(A*q^d)+19 ∧
      (∀ a : Fin 8, z.registers a.val=environment T 0 P S E 0 (A*q^d) 0 a) ∧
      (∀ i, i<A*q^d → z.memory (S+i)=some
        (tensorValue T q q e d (filtered q d D (tensorValue T q q c d x)) i) ∧
        tensorValue T q q e d (filtered q d D (tensorValue T q q c d x)) i<T) ∧
      (∀ a, (a<P ∨ P+L≤a) → (a<S ∨ S+L≤a) → z.memory a=s.memory a) := by
  have hq0 : 0<q := by omega
  have hQpos : 0<q^d := pow_pos hq0 _
  have hQN : q^d≤A*q^d := by simpa using Nat.mul_le_mul_right (q^d) hA
  have hAw : A<wordModulus w := by
    have hh : A≤A*q^d := by simpa using Nat.mul_le_mul_left A hQpos
    omega
  have hBw : tensorStride q d<wordModulus w := (tensorStride_le hq d).trans_lt (by omega)
  have hNw : A*q*tensorStride q d<wordModulus w := (initialCount_le hq d).trans_lt (by omega)
  have hqw : q<wordModulus w := by nlinarith
  obtain ⟨c1,t,et,hc1,htr,htm,htf⟩:=tensorCommand_correct s x c hq hq0 hA hT hadd hmul
    (by simpa only [max_self] using hL) hLw hP hS hC hPS hCP hCS hregs hx hc
  let P' := (banks d P S).1
  let S' := (banks d P S).2
  have hP' : P'+L+1<wordModulus w := by
    dsimp [P']; by_cases h : Even d <;> simp [banks,h] <;> assumption
  have hS' : S'+L+1<wordModulus w := by
    dsimp [S']; by_cases h : Even d <;> simp [banks,h] <;> assumption
  have hPS' : S'+L≤P' ∨ P'+L≤S' := by
    dsimp [P',S']; by_cases h : Even d <;> simp [banks,h]
    · exact hPS
    · exact hPS.symm
  have hEP' : E+q*q≤P' ∨ P'+L≤E := by
    dsimp [P']; by_cases h : Even d <;> simp [banks,h] <;> assumption
  have hES' : E+q*q≤S' ∨ S'+L≤E := by
    dsimp [S']; by_cases h : Even d <;> simp [banks,h] <;> assumption
  have h3t : t.registers 3=P' := by simpa [environment,P'] using htr ⟨3,by omega⟩
  have h4t : t.registers 4=S' := by simpa [environment,S'] using htr ⟨4,by omega⟩
  let u := savedBanks t k P' S'
  have eu := saveBanks_correct (w:=w) (k:=k) (P:=P') (S:=S') t hk (by omega) (by omega) h3t h4t
  have hut : ∀ i, i<8 → u.registers (k+i)=context A (tensorStride q d) (A*q*tensorStride q d) (q^d) D E T i := by
    intro i hi
    change Function.update (Function.update t.registers (k+8) P') (k+9) S' (k+i)=_
    rw [Function.update_of_ne (show k+i≠k+9 by omega),Function.update_of_ne (show k+i≠k+8 by omega),protected_frame et hkw i]
    exact hctx i hi
  have h8u : u.registers (k+8)=P' := by simp [u,savedBanks,put]
  have h9u : u.registers (k+9)=S' := by simp [u,savedBanks,put]
  let v := patched u 5 (degreeValues (A*q^d) S' (q^d) D)
  have ev := degreeSetup_correct (w:=w) (k:=k) (N:=A*q^d) (S:=S') (Q:=q^d) (D:=D) u hk (by omega) (by omega) (by omega) hD
    (by simpa [context] using hut 7 (by omega)) h9u
    (by simpa [context] using hut 3 (by omega)) (by simpa [context] using hut 4 (by omega))
  obtain ⟨c2,t2,et2,hc2,ht20,ht2m,ht2f⟩:=DegreeFilter.command_correct (w:=w) (q:=q) (d:=d) (N:=A*q^d) (P:=S') (D:=D) v
    hq hqw (by omega) (by omega) hD
    (by simp [v,patched,degreeValues]) (by simp [v,patched,degreeValues])
    (by simp [v,patched,degreeValues]) (by simp [v,patched,degreeValues])
  have h2ctx : ∀ i, t2.registers (k+i)=u.registers (k+i) := by
    intro i
    rw [ht2f (k+i) (by omega) (by omega)]
    simp [v,patched,show ¬k+i<5 by omega]
  let u2 := patched t2 8 (tensorValues T (A*q*tensorStride q d) P' S' E (tensorStride q d) A)
  have eu2 := tensorSetup_correct (w:=w) (k:=k) (T:=T) (N:=A*q*tensorStride q d) (P:=P') (S:=S') (C:=E) (B:=tensorStride q d) (A:=A) t2 hk (by omega) hNw (by omega) (by omega) (by omega) hBw hAw
    (by simpa only [Nat.add_zero] using (h2ctx 0).trans (by simpa [context] using hut 0 (by omega)))
    ((h2ctx 1).trans (by simpa [context] using hut 1 (by omega)))
    ((h2ctx 2).trans (by simpa [context] using hut 2 (by omega)))
    ((h2ctx 5).trans (by simpa [context] using hut 5 (by omega)))
    ((h2ctx 6).trans (by simpa [context] using hut 6 (by omega)))
    (by rw [h2ctx,h8u]) (by rw [h2ctx,h9u])
  have hu2regs : ∀ a : Fin 8, u2.registers a.val=
      environment T (A*q*tensorStride q d) P' S' E (tensorStride q d) A 0 a := by
    intro a
    simp only [u2,patched,a.isLt,ite_eq_left,tensorValues_environment]
  have hu2x : ∀ i, i<A*q^d → u2.memory (S'+i)=some (filtered q d D (tensorValue T q q c d x) i) ∧
      filtered q d D (tensorValue T q q c d x) i<T := by
    intro i hi
    change t2.memory _=_ ∧ _
    rw [ht2m,DegreeFilter.memory_entry _ hi]
    change (if D<DigitSum.value q d (i%(q^d)) then some 0 else t.memory (S'+i))=_ ∧ _
    have hm := htm i hi
    by_cases hh : D<DigitSum.value q d (i%(q^d))
    · simp [filtered,hh,hT]
    · simpa [filtered,hh] using hm
  have hu2e : ∀ i, i<q*q → u2.memory (E+i)=some (e i) ∧ e i<T := by
    intro i hi
    change t2.memory _=_ ∧ _
    rw [ht2m,DegreeFilter.memory_outside _ (by omega : E+i<S' ∨ S'+A*q^d≤E+i)]
    change t.memory _=_ ∧ _
    rw [htf _ (by omega) (by omega)]
    exact he i hi
  obtain ⟨c3,z,ez,hc3,hzr,hzm,hzf⟩:=tensorCommand_correct u2
    (filtered q d D (tensorValue T q q c d x)) e hq hq0 hA hT hadd hmul
    (by simpa only [max_self] using hL) hLw hP' hS' hE hPS' hEP' hES' hu2regs hu2x hu2e
  have hbank : banks d P' S'=(P,S) := banks_twice d P S
  refine ⟨c1+(2+(5+(c2+(8+c3)))),z,Eval.seq et (Eval.seq eu (Eval.seq ev (Eval.seq et2 (Eval.seq eu2 ez)))),?_,?_,?_,?_⟩
  · nlinarith
  · simpa only [hbank,Prod.fst,Prod.snd] using hzr
  · simpa only [hbank,Prod.fst,Prod.snd] using hzm
  · intro a haP haS
    have hp : a<P' ∨ P'+L≤a := by
      dsimp [P']; by_cases h : Even d <;> simp [banks,h] <;> assumption
    have hs : a<S' ∨ S'+L≤a := by
      dsimp [S']; by_cases h : Even d <;> simp [banks,h] <;> assumption
    rw [hzf _ hp hs]
    change t2.memory a=s.memory a
    rw [ht2m,DegreeFilter.memory_outside _ (by omega : a<S' ∨ S'+A*q^d≤a)]
    exact htf a haP haS
end DeterministicThreeSum.Structured.Indexed.NewtonPass

end OAI