File size: 3,956 Bytes
2f887db | 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 | 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
|