File size: 5,112 Bytes
9dbc64e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 | 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
|