import OAI.Computability.DepthThree.LanguageBitConvolutionUpdates
import Mathlib.Data.List.Range

namespace OAI

namespace DepthThreeLowerBound

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

@[simp] theorem hashUpdateRow_nil (u x : List Bool) (i : ℕ) (c : List Bool) :
    hashUpdateRow u x i [] c = c := rfl

theorem hashUpdateRow_step (u x : List Bool) (i j : ℕ)
    (js : List ℕ) (c : List Bool) :
    hashUpdateRow u x i (j :: js) c = hashUpdateRow u x i js
      (xorListAt c i (u.getD (i + j) false && x.getD j false)) := rfl

@[simp] theorem hashUpdateRow_length (u x : List Bool) (i : ℕ)
    (js : List ℕ) (c : List Bool) :
    (hashUpdateRow u x i js c).length = c.length := by
  induction js generalizing c with
  | nil => rfl
  | cons j js ih => rw [hashUpdateRow_step, ih, xorListAt_length]

theorem hashUpdateRow_append (u x : List Bool) (i : ℕ)
    (js ks : List ℕ) (c : List Bool) :
    hashUpdateRow u x i (js ++ ks) c =
      hashUpdateRow u x i ks (hashUpdateRow u x i js c) := by
  induction js generalizing c with
  | nil => rfl
  | cons j js ih =>
      simp only [List.cons_append, hashUpdateRow_step, ih]

theorem hashUpdateRow_getD (u x : List Bool) (i : ℕ)
    (js : List ℕ) (c : List Bool) (k : ℕ) (hi : i < c.length) :
    (hashUpdateRow u x i js c).getD k false =
      Bool.xor (c.getD k false)
        (if i = k then xorBits (js.map fun j =>
          u.getD (i + j) false && x.getD j false) else false) := by
  induction js generalizing c with
  | nil => simp
  | cons j js ih =>
      have hi' : i <
          (xorListAt c i (u.getD (i + j) false && x.getD j false)).length := by
        simpa only [xorListAt_length] using hi
      rw [hashUpdateRow_step, ih _ hi',
        xorListAt_getD c i (u.getD (i + j) false && x.getD j false) hi k]
      by_cases hik : i = k <;>
        simp [hik, List.map_cons, xorBits_cons]

theorem hashUpdateRow_getD_self (u x : List Bool) (i : ℕ)
    (js : List ℕ) (c : List Bool) (hi : i < c.length) :
    (hashUpdateRow u x i js c).getD i false =
      Bool.xor (c.getD i false)
        (xorBits (js.map fun j => u.getD (i + j) false && x.getD j false)) := by
  simpa only [ite_eq_left rfl, ite_true] using hashUpdateRow_getD u x i js c i hi

theorem hashUpdateRow_getD_ne (u x : List Bool) (i : ℕ)
    (js : List ℕ) (c : List Bool) (k : ℕ) (hi : i < c.length) (hik : i ≠ k) :
    (hashUpdateRow u x i js c).getD k false = c.getD k false := by
  simpa only [ite_eq_right hik, Bool.xor_false] using hashUpdateRow_getD u x i js c k hi

def hashRowBit (u x : List Bool) (i : ℕ) : Bool :=
  xorBits ((List.range x.length).map fun j =>
    u.getD (i + j) false && x.getD j false)

def hashUpdateRows (u x : List Bool) : List ℕ → List Bool → List Bool
  | [], c => c
  | i :: is, c => hashUpdateRows u x is
      (hashUpdateRow u x i (List.range x.length) c)

@[simp] theorem hashUpdateRows_nil (u x : List Bool) (c : List Bool) :
    hashUpdateRows u x [] c = c := rfl

theorem hashUpdateRows_step (u x : List Bool) (i : ℕ)
    (is : List ℕ) (c : List Bool) :
    hashUpdateRows u x (i :: is) c = hashUpdateRows u x is
      (hashUpdateRow u x i (List.range x.length) c) := rfl

@[simp] theorem hashUpdateRows_length (u x : List Bool)
    (is : List ℕ) (c : List Bool) :
    (hashUpdateRows u x is c).length = c.length := by
  induction is generalizing c with
  | nil => rfl
  | cons i is ih => rw [hashUpdateRows_step, ih, hashUpdateRow_length]

theorem hashUpdateRows_append (u x : List Bool)
    (is ks : List ℕ) (c : List Bool) :
    hashUpdateRows u x (is ++ ks) c =
      hashUpdateRows u x ks (hashUpdateRows u x is c) := by
  induction is generalizing c with
  | nil => rfl
  | cons i is ih =>
      simp only [List.cons_append, hashUpdateRows_step, ih]

theorem hashUpdateRows_getD (u x : List Bool)
    (is : List ℕ) (c : List Bool) (k : ℕ)
    (hbound : ∀ i ∈ is, i < c.length) :
    (hashUpdateRows u x is c).getD k false =
      Bool.xor (c.getD k false)
        (xorBits (is.map fun i => if i = k then hashRowBit u x i else false)) := by
  induction is generalizing c with
  | nil => simp
  | cons i is ih =>
      have hi : i < c.length := hbound i (by simp)
      have hrest : ∀ i' ∈ is,
          i' < (hashUpdateRow u x i (List.range x.length) c).length := by
        intro i' hi'
        rw [hashUpdateRow_length]
        exact hbound i' (List.mem_cons_of_mem i hi')
      rw [hashUpdateRows_step, ih _ hrest,
        hashUpdateRow_getD u x i (List.range x.length) c k hi]
      simp only [hashRowBit, List.map_cons, xorBits_cons, Bool.xor_assoc]

theorem hashUpdateRow_range'_append (u x : List Bool) (i s m n : ℕ) (c : List Bool) :
    hashUpdateRow u x i (List.range' s (m + n)) c =
      hashUpdateRow u x i (List.range' (s + m) n)
        (hashUpdateRow u x i (List.range' s m) c) := by
  rw [← List.range'_append_1, hashUpdateRow_append]

theorem hashUpdateRow_range'_prefix (u x : List Bool) (i s m n : ℕ)
    (c : List Bool) (hm : m ≤ n) :
    hashUpdateRow u x i (List.range' (s + m) (n - m))
        (hashUpdateRow u x i (List.range' s m) c) =
      hashUpdateRow u x i (List.range' s n) c := by
  rw [← hashUpdateRow_range'_append, Nat.add_sub_of_le hm]

theorem hashUpdateRow_range'_step (u x : List Bool) (i s n : ℕ) (c : List Bool) :
    hashUpdateRow u x i (List.range' s (n + 1)) c =
      hashUpdateRow u x i (List.range' (s + 1) n)
        (xorListAt c i (u.getD (i + s) false && x.getD s false)) := by
  rw [List.range'_succ, hashUpdateRow_step]

theorem hashUpdateRow_range'_snoc (u x : List Bool) (i s n : ℕ) (c : List Bool) :
    hashUpdateRow u x i (List.range' s (n + 1)) c =
      xorListAt (hashUpdateRow u x i (List.range' s n) c) i
        (u.getD (i + (s + n)) false && x.getD (s + n) false) := by
  rw [List.range'_concat, hashUpdateRow_append]
  simp only [Nat.one_mul, hashUpdateRow_step, hashUpdateRow_nil]

theorem hashUpdateRows_range'_append (u x : List Bool) (s m n : ℕ) (c : List Bool) :
    hashUpdateRows u x (List.range' s (m + n)) c =
      hashUpdateRows u x (List.range' (s + m) n)
        (hashUpdateRows u x (List.range' s m) c) := by
  rw [← List.range'_append_1, hashUpdateRows_append]

theorem hashUpdateRows_range'_prefix (u x : List Bool) (s m n : ℕ)
    (c : List Bool) (hm : m ≤ n) :
    hashUpdateRows u x (List.range' (s + m) (n - m))
        (hashUpdateRows u x (List.range' s m) c) =
      hashUpdateRows u x (List.range' s n) c := by
  rw [← hashUpdateRows_range'_append, Nat.add_sub_of_le hm]

theorem hashUpdateRows_range'_step (u x : List Bool) (s n : ℕ) (c : List Bool) :
    hashUpdateRows u x (List.range' s (n + 1)) c =
      hashUpdateRows u x (List.range' (s + 1) n)
        (hashUpdateRow u x s (List.range x.length) c) := by
  rw [List.range'_succ, hashUpdateRows_step]

theorem hashUpdateRows_range'_snoc (u x : List Bool) (s n : ℕ) (c : List Bool) :
    hashUpdateRows u x (List.range' s (n + 1)) c =
      hashUpdateRow u x (s + n) (List.range x.length)
        (hashUpdateRows u x (List.range' s n) c) := by
  rw [List.range'_concat, hashUpdateRows_append]
  simp only [Nat.one_mul, hashUpdateRows_step, hashUpdateRows_nil]

theorem hashUpdateRow_range_succ (u x : List Bool) (i j : ℕ) (c : List Bool) :
    hashUpdateRow u x i (List.range (j + 1)) c =
      xorListAt (hashUpdateRow u x i (List.range j) c) i
        (u.getD (i + j) false && x.getD j false) := by
  simpa only [List.range_eq_range', Nat.zero_add] using
    hashUpdateRow_range'_snoc u x i 0 j c

theorem hashUpdateRows_range_succ (u x : List Bool) (i : ℕ) (c : List Bool) :
    hashUpdateRows u x (List.range (i + 1)) c =
      hashUpdateRow u x i (List.range x.length)
        (hashUpdateRows u x (List.range i) c) := by
  simpa only [List.range_eq_range', Nat.zero_add] using
    hashUpdateRows_range'_snoc u x 0 i c

theorem hashReadIndex_lt {d r i j : ℕ} (hi : i < r) (hj : j < d) :
    i + j < d + r - 1 := by omega

private theorem xorBits_map_single_index (is : List ℕ) (hn : is.Nodup)
    (k : ℕ) (f : ℕ → Bool) :
    xorBits (is.map fun i => if i = k then f i else false) =
      if k ∈ is then f k else false := by
  induction is with
  | nil => simp
  | cons i is ih =>
      have hnodup := List.nodup_cons.mp hn
      rw [List.map_cons, xorBits_cons, ih hnodup.2]
      by_cases hik : i = k
      · subst i
        simp [hnodup.1]
      · simp [hik, Ne.symm hik]

theorem hashUpdateRows_getD_nodup (u x : List Bool)
    (is : List ℕ) (c : List Bool) (k : ℕ)
    (hbound : ∀ i ∈ is, i < c.length) (hn : is.Nodup) :
    (hashUpdateRows u x is c).getD k false =
      Bool.xor (c.getD k false) (if k ∈ is then hashRowBit u x k else false) := by
  rw [hashUpdateRows_getD u x is c k hbound,
    xorBits_map_single_index is hn k (hashRowBit u x)]

def hashByUpdates (r : ℕ) (u x : List Bool) : List Bool :=
  hashUpdateRows u x (List.range r) (List.replicate r false)

@[simp] theorem hashByUpdates_length (r : ℕ) (u x : List Bool) :
    (hashByUpdates r u x).length = r := by simp [hashByUpdates]

theorem hashByUpdates_getD (r : ℕ) (u x : List Bool) (k : ℕ) :
    (hashByUpdates r u x).getD k false =
      if k < r then hashRowBit u x k else false := by
  have hbound : ∀ i ∈ List.range r, i < (List.replicate r false).length := by
    intro i hi
    simpa only [List.length_replicate] using List.mem_range.mp hi
  unfold hashByUpdates
  rw [hashUpdateRows_getD_nodup u x (List.range r) (List.replicate r false)
    k hbound List.nodup_range]
  simp

theorem hashRowBit_ofFn {d r : ℕ} (u : BitWord (d + r - 1)) (x : BitWord d)
    (i : Fin r) :
    hashRowBit (List.ofFn u) (List.ofFn x) i.val = wordHash u x i := by
  unfold hashRowBit
  rw [List.length_ofFn, ← ofFn_nat_eq_map_range]
  simp only [wordHash, wordFreeze_eq]
  apply congrArg xorBits
  apply congrArg List.ofFn
  funext j
  have hu : i.val + j.val < d + r - 1 := (BinaryHash.sumIndex i j).is_lt
  change ((wordList u).getD (i.val + j.val) false && (wordList x).getD j.val false) =
    (u (BinaryHash.sumIndex i j) && x j)
  simp only [wordList_getD, wordGet_of_lt u hu, wordGet_fin, BinaryHash.sumIndex]

theorem hashByUpdates_ofFn_eq {d r : ℕ} (u : BitWord (d + r - 1)) (x : BitWord d) :
    hashByUpdates r (List.ofFn u) (List.ofFn x) = List.ofFn (wordHash u x) := by
  apply List.ext_getElem
  · simp
  · intro k hk hl
    have hkr : k < r := by simpa only [List.length_ofFn] using hl
    have hleft := hashByUpdates_getD r (List.ofFn u) (List.ofFn x) k
    rw [ite_eq_left hkr, List.getD_eq_getElem _ _ hk] at hleft
    simpa using hleft.trans (hashRowBit_ofFn u x ⟨k, hkr⟩)

end DepthThreeLowerBound

end OAI