math / data /lean /OAI /Computability /DepthThree /LanguageBitArithmetic.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
5.11 kB
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