| import Mathlib |
| import OAI.Computability.MinUncut.Estimates.CodeContinuations |
|
|
| namespace OAI |
|
|
| section |
| namespace MinUncut.Costed.Arena |
| open Turing.ToPartrec |
|
|
| def rebasePointer (d a : ℕ) : ℕ := if a=0 then 0 else d+a |
| def rebaseNode (d : ℕ) (n : Node) : Node := |
| node (n 0) (rebasePointer d (n 1)) (rebasePointer d (n 2)) (n 3) |
|
|
| lemma codeCells_length_eq (c : Code) (a b : ℕ) : |
| (codeCells c a).length=(codeCells c b).length := by |
| induction c generalizing a b with |
| | zero' | succ | tail => rfl |
| | cons f g ih ih' | comp f g ih ih' | case f g ih ih' => |
| simp only [codeCells,List.length_cons,List.length_append] |
| rw [ih a b, ih'] |
| | fix f ih => simp only [codeCells,List.length_cons,ih a b] |
|
|
| lemma codeCells_pos (c : Code) (b : ℕ) : 0<(codeCells c b).length := by |
| cases c <;> simp [codeCells] |
|
|
| lemma codeCells_rebase (c : Code) (b d : ℕ) : |
| codeCells c (b+d)=(codeCells c b).map (rebaseNode d) := by |
| induction c generalizing b with |
| | zero' | succ | tail => simp [codeCells,rebaseNode,rebasePointer] |
| | cons f g ih ih' | comp f g ih ih' | case f g ih ih' => |
| have hf := codeCells_pos f b |
| have hg := codeCells_pos g (b+(codeCells f b).length) |
| have he := codeCells_length_eq f (b+d) b |
| simp only [codeCells,List.map_cons,List.map_append] |
| rw [he,show b+d+(codeCells f b).length=(b+(codeCells f b).length)+d by omega] |
| rw [codeCells_length_eq g ((b+(codeCells f b).length)+d) (b+(codeCells f b).length), |
| ih,ih'] |
| congr 1 |
| simp only [rebaseNode,node_zero,node_one,node_two,node_three,rebasePointer] |
| erw [ite_eq_right (by omega : b+(codeCells f b).length≠0), |
| ite_eq_right (by omega : b+(codeCells f b).length+(codeCells g (b+(codeCells f b).length)).length≠0)] |
| congr 1 <;> omega |
| | fix f ih => |
| have hf:=codeCells_pos f b |
| simp only [codeCells,List.map_cons,ih] |
| congr 1 |
| simp only [rebaseNode,node_zero,node_one,node_two,node_three,rebasePointer] |
| erw [ite_eq_right (by omega : b+(codeCells f b).length≠0)] |
| congr 1 |
| simp only [List.length_map] |
| omega |
|
|
| lemma words_append (h g : Heap) : words (h++g)=words h++words g := by |
| simp only [words,List.flatMap_append] |
|
|
| lemma listCells_ptr (v : List ℕ) (h : Heap) : |
| (listCells v h).1=if v=[] then 0 else v.length+h.length := by |
| cases v with |
| | nil => rfl |
| | cons a v => simp only [listCells,listCells_length,List.cons_ne_nil,ite_false,List.length_cons]; omega |
|
|
| def groupWords (v : List ℕ) : Heap := |
| (List.range (v.length/4)).map (fun i j=>((v.drop (4*i+j.val)).headI)) |
| lemma groupWords_length (v : List ℕ) : (groupWords v).length=v.length/4 := by |
| simp [groupWords] |
| lemma groupWords_words (v : List ℕ) (h : 4∣v.length) : words (groupWords v)=v := by |
| apply List.ext_getElem |
| · simp only [length_words,groupWords_length] |
| omega |
| · intro i hi hv |
| have hq : i/4<v.length/4 := by omega |
| have hr : i%4<4 := Nat.mod_lt _ (by decide) |
| have hat:=words_at (groupWords v) (i/4) ⟨i%4,hr⟩ |
| have he : 4*(i/4)+i%4=i := by omega |
| rw [he,List.drop_eq_getElem_cons hi] at hat |
| simp only [List.headI_cons] at hat |
| rw [hat] |
| have hn : i/4<(groupWords v).length := by simpa only [groupWords_length] using hq |
| rw [List.drop_eq_getElem_cons hn,List.headD_cons] |
| simp only [groupWords] |
| erw [List.getElem_map,List.getElem_range] |
| rw [he,List.drop_eq_getElem_cons hv] |
| rfl |
|
|
| end MinUncut.Costed.Arena |
|
|
| end |
|
|
| end OAI |
|
|
