| import OAI.Computability.DepthThree.LanguageBitLoopInvariants |
|
|
| namespace OAI |
|
|
| universe uDepth1 |
|
|
| namespace DepthThreeLowerBound |
|
|
| def hornerStep (r : ℕ) (p h b a : List Bool) : List Bool := |
| List.zipWith Bool.xor b (multiplyBitLists r p h a) |
|
|
| theorem hornerStep_length (r : ℕ) (p h b a : List Bool) (hb : b.length = r) : |
| (hornerStep r p h b a).length = r := by |
| simp only [hornerStep, List.length_zipWith, multiplyBitLists_length, hb, min_self] |
|
|
| theorem hornerStep_eq_word (r : ℕ) (p h b a : List Bool) (hb : b.length = r) : |
| hornerStep r p h b a = |
| wordList (wordXor (listWord r b) |
| (wordMulMod (listWord r p) (listWord r h) (listWord r a))) := by |
| have hx (u v : BitWord r) : |
| List.zipWith Bool.xor (wordList u) (wordList v) = wordList (wordXor u v) := by |
| apply List.ext_getElem |
| · simp only [wordList_length, List.length_zipWith, min_self] |
| · intro i hi hj |
| simp only [wordList, wordXor, List.getElem_zipWith, List.getElem_ofFn] |
| have heq := hx (listWord r b) |
| (wordMulMod (listWord r p) (listWord r h) (listWord r a)) |
| simpa only [wordList_listWord b hb, hornerStep, multiplyBitLists] using heq |
|
|
| def hornerFrom (r : ℕ) (p h : List Bool) (bs : List (List Bool)) |
| (a : List Bool) : List Bool := |
| bs.foldr (hornerStep r p h) a |
|
|
| @[simp] theorem hornerFrom_nil (r : ℕ) (p h a : List Bool) : |
| hornerFrom r p h [] a = a := rfl |
|
|
| theorem hornerFrom_cons (r : ℕ) (p h b : List Bool) (bs : List (List Bool)) |
| (a : List Bool) : |
| hornerFrom r p h (b :: bs) a = hornerStep r p h b (hornerFrom r p h bs a) := rfl |
|
|
| theorem hornerFrom_append (r : ℕ) (p h : List Bool) |
| (bs cs : List (List Bool)) (a : List Bool) : |
| hornerFrom r p h (bs ++ cs) a = |
| hornerFrom r p h bs (hornerFrom r p h cs a) := by |
| simp only [hornerFrom, List.foldr_append] |
|
|
| theorem hornerFrom_append_singleton (r : ℕ) (p h : List Bool) |
| (bs : List (List Bool)) (b a : List Bool) : |
| hornerFrom r p h (bs ++ [b]) a = |
| hornerFrom r p h bs (hornerStep r p h b a) := by |
| rw [hornerFrom_append, hornerFrom_cons, hornerFrom_nil] |
|
|
| theorem hornerFrom_length (r : ℕ) (p h : List Bool) |
| (bs : List (List Bool)) (a : List Bool) (ha : a.length = r) |
| (hbs : ∀ b ∈ bs, b.length = r) : |
| (hornerFrom r p h bs a).length = r := by |
| cases bs with |
| | nil => exact ha |
| | cons b bs => |
| rw [hornerFrom_cons] |
| exact hornerStep_length r p h b _ (hbs b (by simp)) |
|
|
| theorem hornerFrom_zero_eq_hornerBitLists (r : ℕ) (p h : List Bool) |
| (bs : List (List Bool)) (hbs : ∀ b ∈ bs, b.length = r) : |
| hornerFrom r p h bs (List.replicate r false) = hornerBitLists r p h bs := by |
| revert hbs |
| induction bs with |
| | nil => |
| intro hbs |
| simp only [hornerFrom_nil, hornerBitLists_nil, wordList, List.ofFn_const] |
| | cons b bs ih => |
| intro hbs |
| have hb : b.length = r := hbs b (by simp) |
| have htail : ∀ c ∈ bs, c.length = r := |
| fun c hc => hbs c (List.mem_cons_of_mem b hc) |
| rw [hornerFrom_cons, ih htail, hornerStep_eq_word r p h b _ hb, |
| hornerBitLists_cons] |
|
|
| theorem block_flatten_length {α : Type uDepth1} (r : ℕ) (bs : List (List α)) |
| (hbs : ∀ b ∈ bs, b.length = r) : bs.flatten.length = bs.length * r := by |
| revert hbs |
| induction bs with |
| | nil => intro hbs; simp |
| | cons b bs ih => |
| intro hbs |
| have hb : b.length = r := hbs b (by simp) |
| have htail : ∀ c ∈ bs, c.length = r := |
| fun c hc => hbs c (List.mem_cons_of_mem b hc) |
| simp only [List.flatten_cons, List.length_append, List.length_cons, hb, ih htail] |
| simp only [Nat.add_mul, Nat.one_mul, Nat.add_comm] |
| |
| end DepthThreeLowerBound |
|
|
| end OAI |
|
|
