import OAI.Computability.DepthThree.LanguageBitWord
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.List.OfFn

namespace OAI

namespace DepthThreeLowerBound

open scoped BigOperators

def xorBits (xs : List Bool) : Bool := xs.foldr Bool.xor false

@[simp] theorem xorBits_nil : xorBits [] = false := rfl

@[simp] theorem xorBits_cons (x : Bool) (xs : List Bool) :
    xorBits (x :: xs) = Bool.xor x (xorBits xs) := rfl

theorem bitValue_xorBits (xs : List Bool) :
    BinaryAlgebra.bitValue (xorBits xs) = (xs.map BinaryAlgebra.bitValue).sum := by
  induction xs with
  | nil => rfl
  | cons x xs ih =>
      change BinaryAlgebra.bitValue (Bool.xor x (xorBits xs)) =
        BinaryAlgebra.bitValue x + (xs.map BinaryAlgebra.bitValue).sum
      rw [BinaryAlgebra.bitValue_xor, ih]

theorem bitValue_xorBits_ofFn {n : ℕ} (f : Fin n → Bool) :
    BinaryAlgebra.bitValue (xorBits (List.ofFn f)) =
      ∑ i : Fin n, BinaryAlgebra.bitValue (f i) := by
  simp only [bitValue_xorBits, List.map_ofFn, List.sum_ofFn, Function.comp_apply]

def wordConvolve {r s : ℕ} (a : BitWord r) (b : BitWord s) : BitWord (r + s) :=
  fun k => xorBits (List.ofFn fun i : Fin r =>
    xorBits (List.ofFn fun j : Fin s =>
      if i.val + j.val = k.val then a i && b j else false))

theorem coeff_wordPoly_mul {r s : ℕ} (a : BitWord r) (b : BitWord s) (k : ℕ) :
    (wordPoly a * wordPoly b).coeff k =
      ∑ i : Fin r, ∑ j : Fin s,
        if i.val + j.val = k then
          BinaryAlgebra.bitValue (a i) * BinaryAlgebra.bitValue (b j)
        else 0 := by
  classical
  simp only [wordPoly, BinaryAlgebra.pack, Finset.sum_mul_sum,
    Polynomial.monomial_mul_monomial, Polynomial.finsetSum_coeff,
    Polynomial.coeff_monomial]

theorem wordPoly_convolve {r s : ℕ} (a : BitWord r) (b : BitWord s) :
    wordPoly (wordConvolve a b) = wordPoly a * wordPoly b := by
  ext k
  rw [coeff_wordPoly, coeff_wordPoly_mul]
  by_cases hk : k < r + s
  · rw [wordGet_of_lt _ hk]
    simp only [wordConvolve, bitValue_xorBits_ofFn, apply_ite,
      BinaryAlgebra.bitValue_and, BinaryAlgebra.bitValue_false]
  · rw [wordGet_of_le _ (Nat.le_of_not_lt hk), BinaryAlgebra.bitValue_false]
    symm
    apply Finset.sum_eq_zero
    intro i _
    apply Finset.sum_eq_zero
    intro j _
    have hsum : i.val + j.val < r + s := Nat.add_lt_add i.is_lt j.is_lt
    have hne : i.val + j.val ≠ k := by omega
    simp [hne]

def wordList {n : ℕ} (a : BitWord n) : List Bool := List.ofFn a

def listWord (n : ℕ) (xs : List Bool) : BitWord n :=
  fun i => xs.getD i.val false

@[simp] theorem wordList_length {n : ℕ} (a : BitWord n) :
    (wordList a).length = n := List.length_ofFn

theorem wordList_getD {n : ℕ} (a : BitWord n) (i : ℕ) :
    (wordList a).getD i false = wordGet a i := by
  by_cases hi : i < n <;> simp [wordList, wordGet, hi]

@[simp] theorem listWord_wordList {n : ℕ} (a : BitWord n) :
    listWord n (wordList a) = a := by
  funext i
  change (wordList a).getD i.val false = a i
  rw [wordList_getD, wordGet_fin]

theorem wordList_listWord_length (xs : List Bool) :
    wordList (listWord xs.length xs) = xs := by
  apply List.ext_getElem
  · simp [wordList]
  · intro i _ hi
    simp [wordList, listWord, List.getElem?_eq_getElem hi]

theorem wordList_listWord {n : ℕ} (xs : List Bool) (h : xs.length = n) :
    wordList (listWord n xs) = xs := by
  subst n
  exact wordList_listWord_length xs

end DepthThreeLowerBound

end OAI