import OAI.Computability.DepthThree.LanguageBitConvolution
import Mathlib.Algebra.Polynomial.Div
import Lean.Elab.Tactic.Omega

namespace OAI

namespace DepthThreeLowerBound

open BinaryAlgebra
open Polynomial

def wordFreeze {n : ℕ} (a : BitWord n) : BitWord n :=
  listWord n (wordList a)

@[simp] theorem wordFreeze_eq {n : ℕ} (a : BitWord n) : wordFreeze a = a :=
  listWord_wordList a

def cancelStep {r m : ℕ} (p : BitWord r) (k : ℕ) (a : BitWord m) : BitWord m :=
  if h : r ≤ k ∧ k < m then
    if a ⟨k, h.2⟩ = true then
      wordFreeze (wordXor a (shiftModulus p (k - r)))
    else a
  else a

theorem cancelStep_above {r m : ℕ} (p : BitWord r) (k : ℕ)
    (a : BitWord m) (i : Fin m) (hi : k < i.val) :
    cancelStep p k a i = a i := by
  by_cases hk : r ≤ k ∧ k < m
  · by_cases ha : a ⟨k, hk.2⟩ = true
    · have hs : k - r + r < i.val := by omega
      simp [cancelStep, hk, ha, wordXor, shiftModulus_above p (k - r) i hs]
    · simp [cancelStep, hk, ha]
  · simp [cancelStep, hk]

theorem cancelStep_at {r m : ℕ} (p : BitWord r) (a : BitWord m)
    (i : Fin m) (hi : r ≤ i.val) : cancelStep p i.val a i = false := by
  have hk : r ≤ i.val ∧ i.val < m := ⟨hi, i.is_lt⟩
  have hs : i.val - r + r = i.val := by omega
  by_cases ha : a i = true
  · simp [cancelStep, hk, ha, wordXor, shiftModulus, hs]
  · have hf : a i = false := Bool.eq_false_of_not_eq_true ha
    simp [cancelStep, hk, ha]

theorem wordPoly_cancelStep_mod {r m : ℕ} (p : BitWord r)
    (k : ℕ) (a : BitWord m) :
    wordPoly (cancelStep p k a) %ₘ inputPolynomialBits p =
      wordPoly a %ₘ inputPolynomialBits p := by
  by_cases hk : r ≤ k ∧ k < m
  · by_cases ha : a ⟨k, hk.2⟩ = true
    · have hs : k - r + r < m := by omega
      simp only [cancelStep, dite_eq_left hk, ite_eq_left ha, wordFreeze_eq,
        wordPoly_xor, wordPoly_shiftModulus p (k - r) hs,
        Polynomial.add_modByMonic,
        Polynomial.mul_self_modByMonic (inputPolynomialBits_monic p), add_zero]
    · simp [cancelStep, hk, ha]
  · simp [cancelStep, hk]

def reduceLoop {r m : ℕ} (p : BitWord r) : ℕ → BitWord m → BitWord m
  | 0, a => a
  | k + 1, a => reduceLoop p k (cancelStep p k a)

theorem wordPoly_reduceLoop_mod {r m : ℕ} (p : BitWord r)
    (k : ℕ) (a : BitWord m) :
    wordPoly (reduceLoop p k a) %ₘ inputPolynomialBits p =
      wordPoly a %ₘ inputPolynomialBits p := by
  induction k generalizing a with
  | zero => rfl
  | succ k ih =>
    exact (ih (cancelStep p k a)).trans (wordPoly_cancelStep_mod p k a)

theorem reduceLoop_tail_false {r m : ℕ} (p : BitWord r) (k : ℕ)
    (a : BitWord m)
    (ha : ∀ i : Fin m, r ≤ i.val → k ≤ i.val → a i = false) :
    ∀ i : Fin m, r ≤ i.val → reduceLoop p k a i = false := by
  induction k generalizing a with
  | zero =>
    intro i hi
    exact ha i hi (Nat.zero_le _)
  | succ k ih =>
    apply ih (cancelStep p k a)
    intro i hri hki
    by_cases hlt : k < i.val
    · rw [cancelStep_above p k a i hlt]
      exact ha i hri (by omega)
    · have he : k = i.val := by omega
      subst k
      exact cancelStep_at p a i hri

def wordResize {m : ℕ} (r : ℕ) (a : BitWord m) : BitWord r :=
  fun i => wordGet a i.val

theorem wordPoly_resize_of_tail_false {r m : ℕ} (a : BitWord m)
    (ha : ∀ i : Fin m, r ≤ i.val → a i = false) :
    wordPoly (wordResize r a) = wordPoly a := by
  ext i
  rw [coeff_wordPoly, coeff_wordPoly]
  apply congrArg bitValue
  by_cases hi : i < r
  · simp [wordGet, wordResize, hi]
  · rw [wordGet_of_le _ (Nat.le_of_not_lt hi)]
    by_cases hm : i < m
    · rw [wordGet_of_lt a hm, ha ⟨i, hm⟩ (Nat.le_of_not_lt hi)]
    · rw [wordGet_of_le a (Nat.le_of_not_lt hm)]

def wordReduce {r m : ℕ} (p : BitWord r) (a : BitWord m) : BitWord r :=
  wordFreeze (wordResize r (reduceLoop p m a))

theorem wordPoly_reduce {r m : ℕ} (p : BitWord r) (a : BitWord m) :
    wordPoly (wordReduce p a) = wordPoly a %ₘ inputPolynomialBits p := by
  have ht : ∀ i : Fin m, r ≤ i.val → reduceLoop p m a i = false :=
    reduceLoop_tail_false p m a (by
      intro i _ hi
      exact False.elim (Nat.not_le.mpr i.is_lt hi))
  have hd : (wordPoly (reduceLoop p m a)).degree <
      (inputPolynomialBits p).degree := by
    rw [inputPolynomialBits_degree]
    exact degree_wordPoly_lt_of_tail_false _ ht
  have hs := (Polynomial.modByMonic_eq_self_iff
    (inputPolynomialBits_monic p)).2 hd
  calc
    wordPoly (wordReduce p a) = wordPoly (reduceLoop p m a) := by
      simp only [wordReduce, wordFreeze_eq]
      exact wordPoly_resize_of_tail_false _ ht
    _ = wordPoly (reduceLoop p m a) %ₘ inputPolynomialBits p := hs.symm
    _ = wordPoly a %ₘ inputPolynomialBits p := wordPoly_reduceLoop_mod p m a

def wordMulMod {r : ℕ} (p a b : BitWord r) : BitWord r :=
  wordReduce p (wordConvolve a b)

theorem wordPoly_mulMod {r : ℕ} (p a b : BitWord r) :
    wordPoly (wordMulMod p a b) =
      (wordPoly a * wordPoly b) %ₘ inputPolynomialBits p := by
  rw [wordMulMod, wordPoly_reduce, wordPoly_convolve]

end DepthThreeLowerBound

end OAI