import OAI.Computability.DepthThree.LanguageBitConvolutionUpdates

namespace OAI

namespace DepthThreeLowerBound

def modulusUpdateLoop (p : List Bool) (v : Bool) (shift : ℕ) : ℕ → List Bool → List Bool
  | 0, c => c
  | j + 1, c => xorListAt (modulusUpdateLoop p v shift j c)
      (shift + j) (v && p.getD j false)

@[simp] theorem modulusUpdateLoop_zero (p : List Bool) (v : Bool)
    (shift : ℕ) (c : List Bool) : modulusUpdateLoop p v shift 0 c = c := rfl

theorem modulusUpdateLoop_step (p : List Bool) (v : Bool) (shift j : ℕ) (c : List Bool) :
    modulusUpdateLoop p v shift (j + 1) c =
      xorListAt (modulusUpdateLoop p v shift j c) (shift + j) (v && p.getD j false) := rfl

@[simp] theorem modulusUpdateLoop_length (p : List Bool) (v : Bool)
    (shift j : ℕ) (c : List Bool) :
    (modulusUpdateLoop p v shift j c).length = c.length := by
  induction j with
  | zero => rfl
  | succ j ih => rw [modulusUpdateLoop_step, xorListAt_length, ih]

theorem modulusUpdateLoop_getD (p : List Bool) (v : Bool) (shift j : ℕ)
    (c : List Bool) (hbound : shift + j ≤ c.length) (k : ℕ) :
    (modulusUpdateLoop p v shift j c).getD k false =
      Bool.xor (c.getD k false)
        (if shift ≤ k ∧ k < shift + j then v && p.getD (k - shift) false else false) := by
  revert hbound
  induction j with
  | zero =>
      intro hbound
      have hk : ¬(shift ≤ k ∧ k < shift + 0) := by omega
      simp only [modulusUpdateLoop_zero, ite_eq_right hk, Bool.xor_false]
  | succ j ih =>
      intro hbound
      have hj : shift + j < (modulusUpdateLoop p v shift j c).length := by
        rw [modulusUpdateLoop_length]
        omega
      rw [modulusUpdateLoop_step, xorListAt_getD _ _ _ hj k, ih (by omega)]
      by_cases he : shift + j = k
      · have hprev : ¬(shift ≤ k ∧ k < shift + j) := by omega
        have hnext : shift ≤ k ∧ k < shift + (j + 1) := by omega
        have hsub : k - shift = j := by omega
        simp [he, hnext, hsub]
      · have hrange : (shift ≤ k ∧ k < shift + (j + 1)) ↔
            (shift ≤ k ∧ k < shift + j) := by omega
        simp only [ite_eq_right he, Bool.xor_false, hrange]

theorem modulusUpdateLoop_above (p : List Bool) (v : Bool) (shift j : ℕ)
    (c : List Bool) (hbound : shift + j ≤ c.length) (k : ℕ) (hk : shift + j ≤ k) :
    (modulusUpdateLoop p v shift j c).getD k false = c.getD k false := by
  rw [modulusUpdateLoop_getD p v shift j c hbound k]
  have hnot : ¬(shift ≤ k ∧ k < shift + j) := by omega
  simp only [ite_eq_right hnot, Bool.xor_false]

theorem modulusUpdateLoop_high (p : List Bool) (v : Bool) (shift : ℕ)
    (c : List Bool) (hbound : shift + p.length ≤ c.length) :
    (modulusUpdateLoop p v shift p.length c).getD (shift + p.length) false =
      c.getD (shift + p.length) false :=
  modulusUpdateLoop_above p v shift p.length c hbound _ le_rfl

def cancelByUpdates (p c : List Bool) (shift : ℕ) : List Bool :=
  (modulusUpdateLoop p (c.getD (shift + p.length) false) shift p.length c).set
    (shift + p.length) false

@[simp] theorem cancelByUpdates_length (p c : List Bool) (shift : ℕ) :
    (cancelByUpdates p c shift).length = c.length := by
  simp [cancelByUpdates]

theorem cancelByUpdates_getD (p c : List Bool) (shift : ℕ)
    (hbound : shift + p.length < c.length) (k : ℕ) :
    (cancelByUpdates p c shift).getD k false =
      if shift + p.length = k then false else
        Bool.xor (c.getD k false)
          (if shift ≤ k ∧ k < shift + p.length then
            c.getD (shift + p.length) false && p.getD (k - shift) false else false) := by
  have ht : shift + p.length <
      (modulusUpdateLoop p (c.getD (shift + p.length) false) shift p.length c).length := by
    simpa only [modulusUpdateLoop_length] using hbound
  by_cases he : shift + p.length = k
  · subst k
    rw [ite_eq_left rfl]
    unfold cancelByUpdates
    exact List.getD_eq_getElem?_getD.trans
      (congrArg (fun o : Option Bool => o.getD false)
        (List.getElem?_set_self (a := false) ht))
  · have hset : (cancelByUpdates p c shift).getD k false =
        (modulusUpdateLoop p (c.getD (shift + p.length) false) shift p.length c).getD k false := by
      simp only [cancelByUpdates, List.getD_eq_getElem?_getD, List.getElem?_set_ne he]
    rw [hset, modulusUpdateLoop_getD _ _ _ _ _ (Nat.le_of_lt hbound) k, ite_eq_right he]

def reduceByUpdates (p : List Bool) : ℕ → List Bool → List Bool
  | 0, c => c
  | s + 1, c => reduceByUpdates p s (cancelByUpdates p c s)

@[simp] theorem reduceByUpdates_zero (p c : List Bool) : reduceByUpdates p 0 c = c := rfl

theorem reduceByUpdates_step (p c : List Bool) (s : ℕ) :
    reduceByUpdates p (s + 1) c = reduceByUpdates p s (cancelByUpdates p c s) := rfl

@[simp] theorem reduceByUpdates_length (p c : List Bool) (s : ℕ) :
    (reduceByUpdates p s c).length = c.length := by
  induction s generalizing c with
  | zero => rfl
  | succ s ih => rw [reduceByUpdates_step, ih, cancelByUpdates_length]

theorem cancelStep_read {r m : ℕ} (p : BitWord r) (a : BitWord m)
    (shift : ℕ) (hbound : shift + r < m) (i : Fin m) :
    cancelStep p (shift + r) a i =
      if shift + r = i.val then false else
        Bool.xor (a i)
          (if shift ≤ i.val ∧ i.val < shift + r then
            a ⟨shift + r, hbound⟩ && wordGet p (i.val - shift) else false) := by
  by_cases he : shift + r = i.val
  · rw [ite_eq_left he, he]
    exact cancelStep_at p a i (by omega)
  · have hk : r ≤ shift + r ∧ shift + r < m := ⟨by omega, hbound⟩
    have hsub : shift + r - r = shift := by omega
    by_cases ht : a ⟨shift + r, hbound⟩ = true
    · by_cases hw : shift ≤ i.val ∧ i.val < shift + r
      · have hj : i.val - shift < r := by omega
        simp [cancelStep, hk, ht, wordXor, shiftModulus, hsub,
          he, Ne.symm he, hw, wordGet, hj]
      · simp [cancelStep, hk, ht, wordXor, shiftModulus, hsub,
          he, Ne.symm he, hw]
    · have hf : a ⟨shift + r, hbound⟩ = false := Bool.eq_false_of_not_eq_true ht
      simp [cancelStep, hk, ht, he]

theorem cancelByUpdates_eq_cancelStep {r m : ℕ} (p : BitWord r) (a : BitWord m)
    (shift : ℕ) (hbound : shift + r < m) :
    cancelByUpdates (wordList p) (wordList a) shift =
      wordList (cancelStep p (shift + r) a) := by
  have hw : listWord m (cancelByUpdates (wordList p) (wordList a) shift) =
      cancelStep p (shift + r) a := by
    funext i
    change (cancelByUpdates (wordList p) (wordList a) shift).getD i.val false = _
    rw [cancelByUpdates_getD _ _ _ (by simpa only [wordList_length] using hbound)]
    rw [cancelStep_read p a shift hbound i]
    simp only [wordList_length, wordList_getD, wordGet_fin, wordGet_of_lt a hbound]
  calc
    cancelByUpdates (wordList p) (wordList a) shift =
        wordList (listWord m (cancelByUpdates (wordList p) (wordList a) shift)) :=
      (wordList_listWord _ (by simp)).symm
    _ = wordList (cancelStep p (shift + r) a) := congrArg wordList hw

theorem reduceLoop_below {r m : ℕ} (p : BitWord r) (k : ℕ) (a : BitWord m)
    (hk : k ≤ r) : reduceLoop p k a = a := by
  revert hk
  induction k generalizing a with
  | zero => intro hk; rfl
  | succ k ih =>
      intro hk
      have hskip : ¬(r ≤ k ∧ k < m) := by omega
      simpa only [reduceLoop, cancelStep, dite_eq_right hskip] using ih a (by omega)

theorem reduceByUpdates_word_eq {r m : ℕ} (p : BitWord r) (s : ℕ)
    (a : BitWord m) (hbound : r + s ≤ m) :
    reduceByUpdates (wordList p) s (wordList a) =
      wordList (reduceLoop p (r + s) a) := by
  revert hbound
  induction s generalizing a with
  | zero =>
      intro hbound
      simp only [reduceByUpdates_zero, Nat.add_zero, reduceLoop_below p r a le_rfl]
  | succ s ih =>
      intro hbound
      have hs : s + r < m := by omega
      have hs' : r + s ≤ m := by omega
      have hnext : r + (s + 1) = (r + s) + 1 := by omega
      calc
        reduceByUpdates (wordList p) (s + 1) (wordList a) =
            reduceByUpdates (wordList p) s (wordList (cancelStep p (s + r) a)) := by
          rw [reduceByUpdates_step, cancelByUpdates_eq_cancelStep p a s hs]
        _ = wordList (reduceLoop p (r + s) (cancelStep p (s + r) a)) := ih _ hs'
        _ = wordList (reduceLoop p (r + (s + 1)) a) := by
          rw [hnext, reduceLoop, Nat.add_comm s r]

theorem reduceByUpdates_eq_reduceLoop (p c : List Bool) (s : ℕ)
    (hbound : p.length + s ≤ c.length) :
    reduceByUpdates p s c =
      wordList (reduceLoop (listWord p.length p) (p.length + s) (listWord c.length c)) := by
  simpa only [wordList_listWord_length] using
    reduceByUpdates_word_eq (listWord p.length p) s (listWord c.length c) hbound

theorem reduceByUpdates_tail_false (p c : List Bool) (s : ℕ)
    (hfull : p.length + s = c.length) (i : ℕ) (hi : p.length ≤ i) :
    (reduceByUpdates p s c).getD i false = false := by
  rw [reduceByUpdates_eq_reduceLoop p c s (by omega), hfull, wordList_getD]
  by_cases him : i < c.length
  · rw [wordGet_of_lt _ him]
    exact reduceLoop_tail_false (listWord p.length p) c.length (listWord c.length c)
      (by
        intro j _ hj
        exact False.elim (Nat.not_le.mpr j.is_lt hj)) ⟨i, him⟩ hi
  · exact wordGet_of_le _ (Nat.le_of_not_lt him)

theorem wordList_wordResize_take {r m : ℕ} (a : BitWord m) (hr : r ≤ m) :
    wordList (wordResize r a) = (wordList a).take r := by
  apply List.ext_getElem
  · simp only [wordList_length, List.length_take, Nat.min_eq_left hr]
  · intro i hi hj
    have hir : i < r := by simpa only [wordList_length] using hi
    have hleft : (wordList (wordResize r a)).getD i false = wordGet a i := by
      rw [wordList_getD, wordGet_of_lt _ hir]
      rfl
    have hright : ((wordList a).take r).getD i false = wordGet a i := by
      simpa only [List.getD_eq_getElem?_getD, List.getElem?_take_of_lt hir] using
        wordList_getD a i
    rw [List.getD_eq_getElem _ false hi] at hleft
    rw [List.getD_eq_getElem _ false hj] at hright
    exact hleft.trans hright.symm

theorem reduceByUpdates_take_eq_wordReduce (p c : List Bool)
    (hwidth : c.length = p.length + p.length) :
    (reduceByUpdates p p.length c).take p.length =
      wordList (wordReduce (listWord p.length p) (listWord c.length c)) := by
  rw [reduceByUpdates_eq_reduceLoop p c p.length (by omega), ← hwidth]
  rw [wordReduce, wordFreeze_eq, wordList_wordResize_take _ (by omega)]

theorem reduceByUpdates_convolve_eq_multiplyBitLists (r : ℕ) (p a b : List Bool)
    (hp : p.length = r) (ha : a.length = r) (hb : b.length = r) :
    (reduceByUpdates p r (convolveBitLists a b)).take r = multiplyBitLists r p a b := by
  have hwidth : (convolveBitLists a b).length = p.length + p.length := by
    simp only [convolveBitLists_length, ha, hb, hp]
  have h := reduceByUpdates_take_eq_wordReduce p (convolveBitLists a b) hwidth
  rw [convolveBitLists_length, hp] at h
  rw [convolveBitLists_eq, ha, hb] at h ⊢
  simpa only [listWord_wordList, multiplyBitLists, wordMulMod] using h

theorem reduceByUpdates_convolveByUpdates_eq_multiplyBitLists (r : ℕ)
    (p a b : List Bool) (hp : p.length = r) (ha : a.length = r) (hb : b.length = r) :
    (reduceByUpdates p r (convolveByUpdates a b)).take r = multiplyBitLists r p a b := by
  rw [convolveByUpdates_eq]
  exact reduceByUpdates_convolve_eq_multiplyBitLists r p a b hp ha hb

end DepthThreeLowerBound

end OAI