| import Mathlib |
| import OAI.Computability.MinUncut.Search.CodeFoldComputable |
| import OAI.Computability.MinUncut.Estimates.HeapInitializationMath |
|
|
| namespace OAI |
|
|
| section |
| namespace MinUncut.CodeEffective.Layout |
| open Turing.ToPartrec MinUncut.Costed.Arena |
| abbrev Cell := ℕ × ℕ × ℕ × ℕ |
| def shift (b : ℕ) (x : Cell) : Cell := |
| (x.1,rebasePointer b x.2.1,rebasePointer b x.2.2.1,x.2.2.2) |
| lemma p_pointer : Primrec₂ rebasePointer := |
| Primrec.ite (Primrec.eq.comp Primrec.snd (Primrec.const 0)) (Primrec.const 0) |
| (Primrec.nat_add.comp Primrec.fst Primrec.snd) |
| lemma p_shift : Primrec₂ shift := |
| (Primrec.fst.comp Primrec.snd).pair |
| ((p_pointer.comp Primrec.fst (Primrec.fst.comp (Primrec.snd.comp Primrec.snd))).pair |
| ((p_pointer.comp Primrec.fst (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))).pair |
| (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))))) |
| def binary (tag : ℕ) (l r : List Cell) : List Cell := |
| (tag,l.length,l.length+r.length,0)::(r.map (shift l.length)++l) |
| def unary (l : List Cell) : List Cell := (6,l.length,0,0)::l |
| lemma p_binary (tag : ℕ) : Primrec₂ (binary tag) := by |
| have hl : Primrec (fun p : List Cell × List Cell=>p.1.length) := Primrec.list_length.comp Primrec.fst |
| have hr : Primrec (fun p : List Cell × List Cell=>p.2.length) := Primrec.list_length.comp Primrec.snd |
| have hm : Primrec (fun p : List Cell × List Cell=>p.2.map (shift p.1.length)) := |
| Primrec.list_map Primrec.snd (p_shift.comp (hl.comp Primrec.fst) Primrec.snd).to₂ |
| exact Primrec.list_cons.comp |
| ((Primrec.const tag).pair (hl.pair ((Primrec.nat_add.comp hl hr).pair (Primrec.const 0)))) |
| (Primrec.list_append.comp hm Primrec.fst) |
| lemma p_unary : Primrec unary := |
| Primrec.list_cons.comp |
| ((Primrec.const 6).pair (Primrec.list_length.pair ((Primrec.const 0).pair (Primrec.const 0)))) Primrec.id |
|
|
| def cells : Code → List Cell := fold [(0,0,0,0)] [(1,0,0,0)] [(2,0,0,0)] (binary 3) (binary 4) (binary 5) unary |
| lemma p_cells : Primrec cells := primrec_fold _ _ _ (p_binary 3) (p_binary 4) (p_binary 5) p_unary |
|
|
| def pack (n : Node) : Cell := (n 0,n 1,n 2,n 3) |
| lemma pack_rebase (d : ℕ) (h : Heap) : |
| (h.map (rebaseNode d)).map pack=(h.map pack).map (shift d) := by |
| simp only [List.map_map] |
| rfl |
| lemma cells_eq (c : Code) : cells c=(codeCells c 0).map pack := by |
| induction c with |
| | zero' | succ | tail => rfl |
| | cons f g ih ih' | comp f g ih ih' | case f g ih ih' => |
| have hg:=codeCells_rebase g 0 (codeCells f 0).length |
| simp only [Nat.zero_add] at hg |
| change binary _ (cells f) (cells g)=_ |
| rw [binary,ih,ih'] |
| simp only [codeCells,Nat.zero_add,List.length_map,hg,List.map_cons,List.map_append, |
| pack_rebase,pack,node_zero,node_one,node_two,node_three] |
| | fix f ih => |
| change unary (cells f)=_ |
| rw [unary,ih] |
| simp only [codeCells,Nat.zero_add,List.length_map,List.map_cons,pack,node_zero,node_one,node_two,node_three] |
| |
| def flattenCell (x : Cell) : List ℕ := [x.1,x.2.1,x.2.2.1,x.2.2.2] |
| lemma p_flattenCell : Primrec flattenCell := |
| Primrec.list_cons.comp Primrec.fst (Primrec.list_cons.comp (Primrec.fst.comp Primrec.snd) |
| (Primrec.list_cons.comp (Primrec.fst.comp (Primrec.snd.comp Primrec.snd)) |
| (Primrec.list_cons.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)) (Primrec.const [])))) |
| lemma p_words : Primrec (fun c=>words (codeCells c 0)) := by |
| have hh : Primrec (fun c=>(cells c).flatMap flattenCell) := |
| Primrec.list_flatMap p_cells (p_flattenCell.comp Primrec.snd).to₂ |
| exact hh.of_eq (by intro c; simp only [cells_eq,List.flatMap_map,words]; congr 1) |
| lemma p_count : Primrec (fun c=>(codeCells c 0).length) := |
| (Primrec.list_length.comp p_cells).of_eq (by intro c; simp only [cells_eq,List.length_map]) |
| lemma c_prefix : Computable (fun c=>(codeCells c 0).length::words (codeCells c 0)) := |
| (Primrec.list_cons.comp p_count p_words).to_comp |
| end MinUncut.CodeEffective.Layout |
| |
| end |
| |
| end OAI |
| |
