import OAI.Computability.DepthThree.LanguageBitLoopInvariants
import Mathlib.Data.List.GetD

namespace OAI

namespace DepthThreeLowerBound

def xorListAt (c : List Bool) (k : ℕ) (v : Bool) : List Bool :=
  c.set k (Bool.xor (c.getD k false) v)

@[simp] theorem xorListAt_length (c : List Bool) (k : ℕ) (v : Bool) :
    (xorListAt c k v).length = c.length := by
  simp [xorListAt]

theorem xorListAt_getD (c : List Bool) (j : ℕ) (v : Bool)
    (hj : j < c.length) (k : ℕ) :
    (xorListAt c j v).getD k false =
      Bool.xor (c.getD k false) (if j = k then v else false) := by
  by_cases h : j = k
  · subst k
    simp [xorListAt, List.getElem?_set_self hj]
  · simp [xorListAt, h, List.getElem?_set_ne h]

theorem xorListAt_split («prefix» suffix : List Bool) (old v : Bool) :
    xorListAt («prefix» ++ old :: suffix) «prefix».length v =
      «prefix» ++ Bool.xor old v :: suffix := by
  unfold xorListAt
  rw [List.getD_append_right «prefix» (old :: suffix) false «prefix».length le_rfl]
  simp

def convolutionUpdateRow (a b : List Bool) (i : ℕ) :
    List ℕ → List Bool → List Bool
  | [], c => c
  | j :: js, c => convolutionUpdateRow a b i js
      (xorListAt c (i + j) (a.getD i false && b.getD j false))

@[simp] theorem convolutionUpdateRow_nil (a b : List Bool) (i : ℕ) (c : List Bool) :
    convolutionUpdateRow a b i [] c = c := rfl

theorem convolutionUpdateRow_step (a b : List Bool) (i j : ℕ)
    (js : List ℕ) (c : List Bool) :
    convolutionUpdateRow a b i (j :: js) c =
      convolutionUpdateRow a b i js
        (xorListAt c (i + j) (a.getD i false && b.getD j false)) := rfl

@[simp] theorem convolutionUpdateRow_length (a b : List Bool) (i : ℕ)
    (js : List ℕ) (c : List Bool) :
    (convolutionUpdateRow a b i js c).length = c.length := by
  induction js generalizing c with
  | nil => rfl
  | cons j js ih =>
      rw [convolutionUpdateRow_step, ih, xorListAt_length]

theorem convolutionUpdateRow_getD (a b : List Bool) (i : ℕ)
    (js : List ℕ) (c : List Bool) (k : ℕ)
    (hbound : ∀ j ∈ js, i + j < c.length) :
    (convolutionUpdateRow a b i js c).getD k false =
      Bool.xor (c.getD k false)
        (xorBits (js.map fun j =>
          if i + j = k then a.getD i false && b.getD j false else false)) := by
  induction js generalizing c with
  | nil => simp
  | cons j js ih =>
      have hj : i + j < c.length := hbound j (by simp)
      have hrest : ∀ j' ∈ js, i + j' <
          (xorListAt c (i + j) (a.getD i false && b.getD j false)).length := by
        intro j' hj'
        rw [xorListAt_length]
        exact hbound j' (List.mem_cons_of_mem j hj')
      rw [convolutionUpdateRow_step, ih _ hrest,
        xorListAt_getD c (i + j) (a.getD i false && b.getD j false) hj k]
      simp only [List.map_cons, xorBits_cons, Bool.xor_assoc]

def convolutionUpdateRows (a b : List Bool) : List ℕ → List Bool → List Bool
  | [], c => c
  | i :: is, c => convolutionUpdateRows a b is
      (convolutionUpdateRow a b i (List.range b.length) c)

@[simp] theorem convolutionUpdateRows_nil (a b : List Bool) (c : List Bool) :
    convolutionUpdateRows a b [] c = c := rfl

theorem convolutionUpdateRows_step (a b : List Bool) (i : ℕ)
    (is : List ℕ) (c : List Bool) :
    convolutionUpdateRows a b (i :: is) c =
      convolutionUpdateRows a b is
        (convolutionUpdateRow a b i (List.range b.length) c) := rfl

@[simp] theorem convolutionUpdateRows_length (a b : List Bool)
    (is : List ℕ) (c : List Bool) :
    (convolutionUpdateRows a b is c).length = c.length := by
  induction is generalizing c with
  | nil => rfl
  | cons i is ih =>
      rw [convolutionUpdateRows_step, ih, convolutionUpdateRow_length]

theorem convolutionUpdateRows_getD (a b : List Bool)
    (is : List ℕ) (c : List Bool) (k : ℕ)
    (hbound : ∀ i ∈ is, ∀ j < b.length, i + j < c.length) :
    (convolutionUpdateRows a b is c).getD k false =
      Bool.xor (c.getD k false)
        (xorBits (is.map fun i => xorBits (convolutionRow a b i k))) := by
  induction is generalizing c with
  | nil => simp
  | cons i is ih =>
      have hcols : ∀ j ∈ List.range b.length, i + j < c.length := by
        intro j hj
        exact hbound i (by simp) j (List.mem_range.mp hj)
      have hrest : ∀ i' ∈ is, ∀ j < b.length, i' + j <
          (convolutionUpdateRow a b i (List.range b.length) c).length := by
        intro i' hi' j hj
        rw [convolutionUpdateRow_length]
        exact hbound i' (List.mem_cons_of_mem i hi') j hj
      rw [convolutionUpdateRows_step, ih _ hrest,
        convolutionUpdateRow_getD a b i (List.range b.length) c k hcols]
      simp only [List.map_cons, xorBits_cons, convolutionRow, Bool.xor_assoc]

def convolveByUpdates (a b : List Bool) : List Bool :=
  convolutionUpdateRows a b (List.range a.length)
    (List.replicate (a.length + b.length) false)

@[simp] theorem convolveByUpdates_length (a b : List Bool) :
    (convolveByUpdates a b).length = a.length + b.length := by
  simp [convolveByUpdates]

theorem convolutionUpdate_index_lt (a b : List Bool) {i j : ℕ}
    (hi : i < a.length) (hj : j < b.length) :
    i + j < a.length + b.length :=
  Nat.add_lt_add hi hj

theorem convolveByUpdates_getD (a b : List Bool) (k : ℕ) :
    (convolveByUpdates a b).getD k false = convolutionBit a b k := by
  have hbound : ∀ i ∈ List.range a.length, ∀ j < b.length,
      i + j < (List.replicate (a.length + b.length) false).length := by
    intro i hi j hj
    simpa only [List.length_replicate] using
      convolutionUpdate_index_lt a b (List.mem_range.mp hi) hj
  unfold convolveByUpdates
  rw [convolutionUpdateRows_getD a b (List.range a.length)
    (List.replicate (a.length + b.length) false) k hbound]
  simp [convolutionBit, convolutionRows]

theorem convolveByUpdates_eq (a b : List Bool) :
    convolveByUpdates a b = convolveBitLists a b := by
  apply List.ext_getElem
  · simp
  · intro k hk hl
    have hk' : k < a.length + b.length := by
      simpa only [convolveBitLists_length] using hl
    have hleft := convolveByUpdates_getD a b k
    have hright : (convolveBitLists a b).getD k false = convolutionBit a b k := by
      simp [convolveBitLists, List.getElem?_range hk']
    rw [List.getD_eq_getElem _ _ hk] at hleft
    rw [List.getD_eq_getElem _ _ hl] at hright
    exact hleft.trans hright.symm

end DepthThreeLowerBound

end OAI