| import Mathlib |
| import OAI.Computability.MinUncut.Model |
|
|
| namespace OAI |
|
|
| namespace MinUncut.CodeEffective |
| open Turing.ToPartrec |
| abbrev NCode := Nat.Partrec.Code |
|
|
| def embed : Code → NCode |
| | .zero' => .zero |
| | .succ => .succ |
| | .tail => .left |
| | .cons f g => .pair (embed f) (embed g) |
| | .comp f g => .comp (embed f) (embed g) |
| | .case f g => .prec (embed f) (embed g) |
| | .fix f => .rfind' (embed f) |
|
|
| def retract : NCode → Code |
| | .zero => .zero' |
| | .succ => .succ |
| | .left => .tail |
| | .right => .tail |
| | .pair f g => .cons (retract f) (retract g) |
| | .comp f g => .comp (retract f) (retract g) |
| | .prec f g => .case (retract f) (retract g) |
| | .rfind' f => .fix (retract f) |
| lemma retract_embed (c : Code) : retract (embed c)=c := by |
| induction c <;> simp_all [embed,retract] |
|
|
| def normalize : NCode → NCode := fun c=>embed (retract c) |
| lemma primrec_normalize : Primrec normalize := by |
| have h := Nat.Partrec.Code.primrec_recOn (α:=NCode) (σ:=NCode) (c:=id) Primrec.id |
| (z:=fun _=>Nat.Partrec.Code.zero) (Primrec.const _) (s:=fun _=>Nat.Partrec.Code.succ) (Primrec.const _) |
| (l:=fun _=>Nat.Partrec.Code.left) (Primrec.const _) (r:=fun _=>Nat.Partrec.Code.left) (Primrec.const _) |
| (pr:=fun _ _ _ x y=>Nat.Partrec.Code.pair x y) |
| (Nat.Partrec.Code.primrec₂_pair.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))) |
| (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))) |
| (co:=fun _ _ _ x y=>Nat.Partrec.Code.comp x y) |
| (Nat.Partrec.Code.primrec₂_comp.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))) |
| (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))) |
| (pc:=fun _ _ _ x y=>Nat.Partrec.Code.prec x y) |
| (Nat.Partrec.Code.primrec₂_prec.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))) |
| (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)))) |
| (rf:=fun _ _ x=>Nat.Partrec.Code.rfind' x) |
| (Nat.Partrec.Code.primrec_rfind'.comp (Primrec.snd.comp Primrec.snd)) |
| apply h.of_eq |
| intro c |
| induction c <;> simp_all [normalize,embed,retract] |
|
|
| instance : Primcodable Code where |
| __ := Encodable.ofLeftInverse embed retract retract_embed |
| prim := by |
| have h := (Primrec.succ.comp (Primrec.encode.comp |
| (primrec_normalize.comp (Primrec.ofNat NCode)))) |
| apply (Primrec.nat_iff.mp h).of_eq |
| intro n |
| change Encodable.encode (embed (retract (Denumerable.ofNat NCode n))) + 1 = |
| @Encodable.encode (Option Code) _ ((Encodable.decode (α:=NCode) n).bind (some ∘ retract)) |
| rw [Denumerable.decode_eq_ofNat] |
| rfl |
|
|
| lemma primrec_embed : Primrec embed := by |
| apply Primrec.encode_iff.mp |
| exact Primrec.encode |
|
|
| lemma primrec_retract : Primrec retract := by |
| apply Primrec.encode_iff.mp |
| exact Primrec.encode.comp primrec_normalize |
|
|
| lemma primrec_cons : Primrec₂ Code.cons := by |
| change Primrec (fun p : Code × Code=>Code.cons p.1 p.2) |
| exact (primrec_retract.comp |
| (Nat.Partrec.Code.primrec₂_pair.comp |
| (primrec_embed.comp Primrec.fst) (primrec_embed.comp Primrec.snd))).of_eq |
| (by intro p; simp [retract,retract_embed]) |
| lemma primrec_comp : Primrec₂ Code.comp := by |
| exact (primrec_retract.comp |
| (Nat.Partrec.Code.primrec₂_comp.comp |
| (primrec_embed.comp Primrec.fst) (primrec_embed.comp Primrec.snd))).of_eq |
| (by intro p; simp [retract,retract_embed]) |
| lemma primrec_case : Primrec₂ Code.case := by |
| exact (primrec_retract.comp |
| (Nat.Partrec.Code.primrec₂_prec.comp |
| (primrec_embed.comp Primrec.fst) (primrec_embed.comp Primrec.snd))).of_eq |
| (by intro p; simp [retract,retract_embed]) |
| lemma primrec_fix : Primrec Code.fix := by |
| exact (primrec_retract.comp |
| (Nat.Partrec.Code.primrec_rfind'.comp primrec_embed)).of_eq |
| (by intro c; simp [retract,retract_embed]) |
| lemma computable_cons : Computable₂ Code.cons := primrec_cons.to_comp |
| lemma computable_comp : Computable₂ Code.comp := primrec_comp.to_comp |
| lemma computable_case : Computable₂ Code.case := primrec_case.to_comp |
| lemma computable_fix : Computable Code.fix := primrec_fix.to_comp |
| end MinUncut.CodeEffective |
|
|
| namespace MinUncut.Costed |
| open Turing.ToPartrec |
|
|
| def bitsize (v : List ℕ) : ℕ := (Turing.PartrecToTM2.trList v).length |
|
|
| inductive CodeRun : Code → List ℕ → List ℕ → ℕ → Prop |
| | zero (v) : CodeRun .zero' v (0::v) 1 |
| | succ (v) : CodeRun .succ v [v.headI+1] (32*(bitsize v+1)) |
| | tail (v) : CodeRun .tail v v.tail (32*(bitsize v+1)) |
| | cons {f fs v u w t t'} : CodeRun f v u t → CodeRun fs v w t' → |
| CodeRun (.cons f fs) v (u.headI::w) (t+t'+32*(bitsize v+bitsize u+1)) |
| | comp {f g v u w t t'} : CodeRun g v u t → CodeRun f u w t' → |
| CodeRun (.comp f g) v w (t+t'+1) |
| | caseZero {f g v w t} : v.headI=0 → CodeRun f v.tail w t → |
| CodeRun (.case f g) v w (t+32*(bitsize v+1)) |
| | caseSucc {f g v a w t} : CodeRun g (a::v) w t → |
| CodeRun (.case f g) ((a+1)::v) w (t+32*(bitsize ((a+1)::v)+1)) |
| | fixDone {f v u t} : CodeRun f v u t → u.headI=0 → |
| CodeRun (.fix f) v u.tail (t+1) |
| | fixMore {f v u a w t t'} : CodeRun f v ((a+1)::u) t → |
| CodeRun (.fix f) u w t' → |
| CodeRun (.fix f) v w (t+t'+32*(bitsize ((a+1)::u)+1)) |
|
|
| theorem CodeRun.sound {c v w t} (h : CodeRun c v w t) : w ∈ c.eval v := by |
| induction h with |
| | zero => simp |
| | succ => simp |
| | tail => simp |
| | cons h h' ih ih' => |
| simp only [Code.cons_eval, Part.bind_eq_bind, Part.mem_bind_iff] |
| exact ⟨_,ih,_,ih',by simp⟩ |
| | comp h h' ih ih' => |
| exact Part.mem_bind ih ih' |
| | caseZero hz h ih => simpa only [Code.case_eval,hz,Nat.rec_zero] using ih |
| | caseSucc h ih => simpa only [Code.case_eval,List.headI_cons,List.tail_cons,Nat.rec_add_one] using ih |
| | fixDone h hz ih => |
| rw [Code.fix_eval] |
| apply PFun.mem_fix_iff.mpr |
| left |
| exact (Part.mem_map_iff _).mpr ⟨_,ih,by simp [hz]⟩ |
| | @fixMore f v u a w t t' h h' ih ih' => |
| rw [Code.fix_eval] |
| apply PFun.mem_fix_iff.mpr |
| right |
| refine ⟨u,?_,?_⟩ |
| · exact (Part.mem_map_iff _).mpr ⟨_,ih,by simp⟩ |
| · simpa only [Code.fix_eval] using ih' |
|
|
| theorem CodeRun.complete {c : Code} {v w : List ℕ} (h : w ∈ c.eval v) : |
| ∃ t, CodeRun c v w t := by |
| induction c generalizing v w with |
| | zero' => |
| have hw : w=0::v := by simpa using h |
| subst w |
| exact ⟨_, .zero _⟩ |
| | succ => |
| have hw : w=[v.headI+1] := by simpa using h |
| subst w |
| exact ⟨_, .succ _⟩ |
| | tail => |
| have hw : w=v.tail := by simpa using h |
| subst w |
| exact ⟨_, .tail _⟩ |
| | cons f fs ih ih' => |
| rcases (Part.mem_bind_iff.mp h) with ⟨u,hu,hrest⟩ |
| rcases (Part.mem_bind_iff.mp hrest) with ⟨w',hw',hw⟩ |
| have he : w=u.headI::w' := by simpa using hw |
| subst w |
| obtain ⟨t,ht⟩ := ih hu |
| obtain ⟨t',ht'⟩ := ih' hw' |
| exact ⟨_, .cons ht ht'⟩ |
| | comp f g ih ih' => |
| obtain ⟨u,hu,hw⟩ := Part.mem_bind_iff.mp h |
| obtain ⟨t,ht⟩ := ih' hu |
| obtain ⟨t',ht'⟩ := ih hw |
| exact ⟨_, .comp ht ht'⟩ |
| | case f g ih ih' => |
| cases v with |
| | nil => |
| obtain ⟨t,ht⟩ := ih (by simpa using h) |
| exact ⟨_, .caseZero rfl ht⟩ |
| | cons a v => |
| cases a with |
| | zero => |
| obtain ⟨t,ht⟩ := ih (by simpa using h) |
| exact ⟨_, .caseZero rfl ht⟩ |
| | succ a => |
| obtain ⟨t,ht⟩ := ih' (by simpa using h) |
| exact ⟨_, .caseSucc ht⟩ |
| | fix f ih => |
| rw [Code.fix_eval] at h |
| refine PFun.fixInduction' h ?_ ?_ |
| · intro v h |
| obtain ⟨u,hu,he⟩ := (Part.mem_map_iff _).mp h |
| by_cases hz : u.headI=0 |
| · rw [ite_eq_left hz] at he |
| have he' : u.tail=w := Sum.inl.inj he |
| subst w |
| obtain ⟨t,ht⟩ := ih hu |
| exact ⟨_, .fixDone ht hz⟩ |
| · rw [ite_eq_right hz] at he |
| cases he |
| · intro v u _ h hr |
| obtain ⟨z,hz,he⟩ := (Part.mem_map_iff _).mp h |
| by_cases hh : z.headI=0 |
| · rw [ite_eq_left hh] at he |
| cases he |
| · rw [ite_eq_right hh] at he |
| have he' : z.tail=u := Sum.inr.inj he |
| cases z with |
| | nil => simp at hh |
| | cons a z => |
| cases a with |
| | zero => simp at hh |
| | succ a => |
| simp only [List.tail_cons] at he' |
| subst u |
| obtain ⟨t,ht⟩ := ih hz |
| obtain ⟨t',ht'⟩ := hr |
| exact ⟨_, .fixMore ht ht'⟩ |
|
|
| open Turing.PartrecToTM2 Turing.ToPartrec |
|
|
| lemma trPosNum_length_le (n : PosNum) : (trPosNum n).length≤(n:ℕ) := by |
| induction n with |
| | one => rfl |
| | bit0 n ih => |
| have hp : 0<(n:ℕ) := PosNum.to_nat_pos n |
| simp only [trPosNum,List.length_cons,PosNum.cast_bit0] at * |
| omega |
| | bit1 n ih => |
| simp only [trPosNum,List.length_cons,PosNum.cast_bit1] at * |
| omega |
|
|
| lemma trNum_length_le (n : Num) : (trNum n).length≤(n:ℕ) := by |
| cases n with |
| | zero => rfl |
| | pos n => exact trPosNum_length_le n |
|
|
| lemma trNat_length_le (n : ℕ) : (trNat n).length≤n := by |
| have h := trNum_length_le (n:Num) |
| simpa only [trNat,Num.to_of_nat] using h |
|
|
| def magnitude (v : List ℕ) : ℕ := (v.map (·+1)).sum |
|
|
| @[simp] lemma magnitude_nil : magnitude []=0 := rfl |
| @[simp] lemma magnitude_cons (a : ℕ) (v : List ℕ) : magnitude (a::v)=a+1+magnitude v := rfl |
| lemma magnitude_head (v : List ℕ) : v.headI≤ magnitude v := by |
| cases v <;> simp only [List.headI_nil,List.headI_cons,magnitude_nil,magnitude_cons,Nat.default_eq_zero] <;> omega |
| lemma magnitude_tail (v : List ℕ) : magnitude v.tail≤ magnitude v := by |
| cases v <;> simp [magnitude] |
| lemma magnitude_drop (n : ℕ) (v : List ℕ) : magnitude (v.drop n) ≤ magnitude v := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| rw [← List.tail_drop] |
| exact (magnitude_tail _).trans ih |
| lemma bitsize_le_magnitude (v : List ℕ) : bitsize v≤ magnitude v := by |
| induction v with |
| | nil => rfl |
| | cons a v ih => |
| have ha := trNat_length_le a |
| simp only [bitsize,trList,List.length_append,List.length_cons] at * |
| simp only [magnitude_cons] |
| omega |
| lemma magnitude_length (v : List ℕ) : v.length≤ magnitude v := by |
| induction v with |
| | nil => rfl |
| | cons a v ih => simp only [List.length_cons,magnitude_cons]; omega |
|
|
| def Runs (c : Code) (v w : List ℕ) (bound : ℕ) : Prop := |
| ∃t, t≤bound ∧ CodeRun c v w t |
|
|
| lemma Runs.mono {c v w b b'} (h : Runs c v w b) (hb : b≤b') : Runs c v w b' := by |
| obtain ⟨t,ht,hc⟩ := h |
| exact ⟨t,ht.trans hb,hc⟩ |
| lemma Runs.sound {c v w b} (h : Runs c v w b) : w∈c.eval v := by |
| obtain ⟨_,_,hc⟩ := h; exact hc.sound |
| lemma run_zero (v : List ℕ) : Runs .zero' v (0::v) 1 := ⟨_,le_rfl,.zero v⟩ |
| lemma run_succ (v : List ℕ) : Runs .succ v [v.headI+1] (32*(magnitude v+1)) := |
| ⟨_,by gcongr; exact bitsize_le_magnitude v,.succ v⟩ |
| lemma run_tail (v : List ℕ) : Runs .tail v v.tail (32*(magnitude v+1)) := |
| ⟨_,by gcongr; exact bitsize_le_magnitude v,.tail v⟩ |
| lemma run_comp {f g v u w b b'} (h : Runs g v u b) (h' : Runs f u w b') : |
| Runs (.comp f g) v w (b+b'+1) := by |
| obtain ⟨t,ht,hc⟩ := h |
| obtain ⟨t',ht',hc'⟩ := h' |
| exact ⟨_,by omega,.comp hc hc'⟩ |
| lemma run_cons {f fs v u w b b'} (h : Runs f v u b) (h' : Runs fs v w b') : |
| Runs (.cons f fs) v (u.headI::w) (b+b'+32*(magnitude v+magnitude u+1)) := by |
| obtain ⟨t,ht,hc⟩ := h |
| obtain ⟨t',ht',hc'⟩ := h' |
| refine ⟨_,?_,.cons hc hc'⟩ |
| have := bitsize_le_magnitude v |
| have := bitsize_le_magnitude u |
| omega |
|
|
| lemma run_id (v : List ℕ) : Runs .id v v (70*(magnitude v+1)) := by |
| have h : Runs .id v v (1+32*(magnitude (0::v)+1)+1) := run_comp (run_zero v) (run_tail (0::v)) |
| apply h.mono |
| simp only [magnitude_cons]; omega |
| lemma run_nil (v : List ℕ) : Runs .nil v [] (140*(magnitude v+1)) := by |
| have h : Runs .nil v [] (32*(magnitude v+1)+32*(magnitude [v.headI+1]+1)+1) := |
| run_comp (run_succ v) (run_tail [v.headI+1]) |
| apply h.mono |
| have := magnitude_head v |
| simp only [magnitude_cons,magnitude_nil] |
| omega |
| lemma run_head (v : List ℕ) : Runs .head v [v.headI] (300*(magnitude v+1)) := by |
| have h := run_cons (run_id v) (run_nil v) |
| apply h.mono |
| omega |
| lemma run_const_zero (v : List ℕ) : Runs .zero v [0] (210*(magnitude v+1)) := by |
| have h := run_cons (run_zero v) (run_nil v) |
| apply h.mono |
| simp only [magnitude_cons]; omega |
|
|
| open Turing.ToPartrec |
|
|
| lemma run_caseZero {f g : Code} {v w : List ℕ} {b : ℕ} (hz : v.headI=0) |
| (h : Runs f v.tail w b) : Runs (.case f g) v w (b+32*(magnitude v+1)) := by |
| obtain ⟨t,ht,hc⟩ := h |
| exact ⟨_,by have := bitsize_le_magnitude v; omega,.caseZero hz hc⟩ |
| lemma run_caseSucc {f g : Code} {v w : List ℕ} {a b : ℕ} |
| (h : Runs g (a::v) w b) : |
| Runs (.case f g) ((a+1)::v) w (b+32*(magnitude ((a+1)::v)+1)) := by |
| obtain ⟨t,ht,hc⟩ := h |
| exact ⟨_,by have := bitsize_le_magnitude ((a+1)::v); omega,.caseSucc hc⟩ |
| lemma run_pred (v : List ℕ) : Runs .pred v [v.headI-1] (332*(magnitude v+1)) := by |
| cases v with |
| | nil => |
| apply (run_caseZero (g:=.head) rfl (run_const_zero [])).mono |
| simp only [magnitude_nil]; omega |
| | cons a v => |
| cases a with |
| | zero => |
| apply (run_caseZero (g:=.head) rfl (run_const_zero v)).mono |
| simp only [magnitude_cons]; omega |
| | succ a => |
| apply (run_caseSucc (f:=.zero) (run_head (a::v))).mono |
| simp only [magnitude_cons]; omega |
|
|
| def dropCode : ℕ → Code |
| | 0 => .id |
| | n+1 => .comp .tail (dropCode n) |
|
|
| lemma run_drop (n : ℕ) (v : List ℕ) : |
| Runs (dropCode n) v (v.drop n) ((71+33*n)*(magnitude v+1)) := by |
| induction n with |
| | zero => exact (run_id v).mono (by omega) |
| | succ n ih => |
| have hb : magnitude (v.drop n)≤ magnitude v := magnitude_drop n v |
| have h := run_comp ih (run_tail (v.drop n)) |
| rw [List.tail_drop] at h |
| apply h.mono |
| have hm : 32*(magnitude (v.drop n)+1)≤32*(magnitude v+1) := by omega |
| nlinarith |
|
|
| def atCode (n : ℕ) : Code := .comp .head (dropCode n) |
| lemma run_at (n : ℕ) (v : List ℕ) : |
| Runs (atCode n) v [(v.drop n).headI] ((372+33*n)*(magnitude v+1)) := by |
| have hb : magnitude (v.drop n)≤ magnitude v := magnitude_drop n v |
| apply (run_comp (run_drop n v) (run_head (v.drop n))).mono |
| have : 300*(magnitude (v.drop n)+1)≤300*(magnitude v+1) := by omega |
| nlinarith |
|
|
| def constCode : ℕ → Code |
| | 0 => .zero |
| | n+1 => .comp .succ (constCode n) |
|
|
| lemma run_const (n : ℕ) (v : List ℕ) : |
| Runs (constCode n) v [n] ((250*(n+1)^2)*(magnitude v+1)) := by |
| induction n with |
| | zero => exact (run_const_zero v).mono (by nlinarith) |
| | succ n ih => |
| have h := run_comp ih (run_succ [n]) |
| apply h.mono |
| simp only [magnitude_cons,magnitude_nil] |
| nlinarith |
|
|
| lemma run_fix_bounded {body : Code} {state : ℕ → List ℕ} {out : List ℕ} |
| (n M B : ℕ) |
| (hsize : ∀i≤n,magnitude (state i)≤M) |
| (hstep : ∀i<n,Runs body (state i) (1::state (i+1)) B) |
| (hdone : Runs body (state n) (0::out) B) : |
| Runs (.fix body) (state 0) out ((n+1)*(B+32*(M+3))) := by |
| have aux : ∀m i, i+m=n → Runs (.fix body) (state i) out ((m+1)*(B+32*(M+3))) := by |
| intro m |
| induction m with |
| | zero => |
| intro i hi |
| have he : i=n := by omega |
| subst i |
| obtain ⟨t,ht,hc⟩ := hdone |
| exact ⟨_,by omega,.fixDone hc rfl⟩ |
| | succ m ih => |
| intro i hi |
| obtain ⟨t,ht,hc⟩ := hstep i (by omega) |
| obtain ⟨t',ht',hc'⟩ := ih (i+1) (by omega) |
| refine ⟨_,?_,CodeRun.fixMore (a:=0) hc hc'⟩ |
| have hs := bitsize_le_magnitude (1::state (i+1)) |
| have hm := hsize (i+1) (by omega) |
| simp only [magnitude_cons] at hs |
| have hb : 32*(bitsize (1::state (i+1))+1)≤32*(M+3) := by omega |
| nlinarith |
| exact aux n 0 (by omega) |
|
|
| open Turing.ToPartrec |
|
|
| def dynamicDropBody : Code := |
| .case .zero' (.cons (.comp .succ .zero) (.cons .head (.comp .tail .tail))) |
| def dynamicDrop : Code := .fix dynamicDropBody |
|
|
| lemma run_dynamicDropBody_zero (v : List ℕ) : |
| Runs dynamicDropBody (0::v) (0::v) (2000*(magnitude (0::v)+1)) := by |
| exact (run_caseZero rfl (run_zero v)).mono (by omega) |
|
|
| lemma run_dynamicDropBody_succ (n : ℕ) (v : List ℕ) : |
| Runs dynamicDropBody ((n+1)::v) (1::n::v.tail) |
| (2000*(magnitude ((n+1)::v)+1)) := by |
| have h1 := run_comp (run_const_zero (n::v)) (run_succ [0]) |
| have ht := run_comp (run_tail (n::v)) (run_tail v) |
| have hh := run_caseSucc (f:=.zero') (run_cons h1 (run_cons (run_head (n::v)) ht)) |
| apply hh.mono |
| have hv := magnitude_tail v |
| simp only [magnitude_cons,magnitude_nil,List.headI_cons] |
| omega |
|
|
| lemma run_dynamicDrop (n : ℕ) (v : List ℕ) : |
| Runs dynamicDrop (n::v) (v.drop n) |
| ((n+1)*2100*(magnitude (n::v)+1)) := by |
| induction n generalizing v with |
| | zero => |
| obtain ⟨t,ht,hc⟩ := run_dynamicDropBody_zero v |
| exact ⟨_,by simp only [magnitude_cons] at *; omega,.fixDone hc rfl⟩ |
| | succ n ih => |
| obtain ⟨t,ht,hc⟩ := run_dynamicDropBody_succ n v |
| obtain ⟨t',ht',hc'⟩ := ih v.tail |
| have he : v.tail.drop n=v.drop (n+1) := List.drop_tail .. |
| rw [he] at hc' |
| refine ⟨_,?_,CodeRun.fixMore (a:=0) hc hc'⟩ |
| have hs := bitsize_le_magnitude (1::n::v.tail) |
| have hv := magnitude_tail v |
| simp only [magnitude_cons] at * |
| have hm : (n+1)*2100*(n+1+magnitude v.tail+1)≤ |
| (n+1)*2100*((n+1)+1+magnitude v+1) := by gcongr; omega |
| nlinarith |
|
|
| def dynamicAt : Code := .comp .head dynamicDrop |
| lemma run_dynamicAt (n : ℕ) (v : List ℕ) : |
| Runs dynamicAt (n::v) [(v.drop n).headI] |
| ((n+1)*2500*(magnitude (n::v)+1)) := by |
| have h := run_comp (run_dynamicDrop n v) (run_head (v.drop n)) |
| apply h.mono |
| have hv := magnitude_drop n v |
| simp only [magnitude_cons] |
| nlinarith |
|
|
| open Turing.ToPartrec |
|
|
| def precBody (g : Code) : Code := |
| .cons .tail <| .cons .succ <| .cons (.comp .pred .tail) <| |
| .cons (.comp g (.cons .id (.comp .tail .tail))) (.comp .tail (.comp .tail .tail)) |
|
|
| lemma run_precBody (g : Code) (a b r r' : ℕ) (v : List ℕ) (M B : ℕ) |
| (ha : a≤M) (hb : b≤M) (hr : r≤M) (hr' : r'≤M) (hv : magnitude v≤M) |
| (hg : Runs g (a::r::v) [r'] B) : |
| Runs (precBody g) (a::b::r::v) (b::(a+1)::(b-1)::r'::v) (B+10000*(M+1)) := by |
| have htail := run_tail (a::b::r::v) |
| have htt := run_comp htail (run_tail (b::r::v)) |
| have httt := run_comp htt (run_tail (r::v)) |
| have hargs := run_cons (run_id (a::b::r::v)) htt |
| have hg' := run_comp hargs hg |
| have hp := run_comp htail (run_pred (b::r::v)) |
| have h := run_cons htail (run_cons (run_succ (a::b::r::v)) |
| (run_cons hp (run_cons hg' httt))) |
| apply h.mono |
| simp only [magnitude_cons,magnitude_nil,List.headI_cons,List.tail_cons] |
| omega |
|
|
| lemma run_precLoop (g : Code) (n : ℕ) (r : ℕ → ℕ) (v : List ℕ) (M B : ℕ) |
| (hn : n+1≤M) (hr : ∀i≤n+1,r i≤M) (hv : magnitude v≤M) |
| (hg : ∀i≤n,Runs g (i::r i::v) [r (i+1)] B) (a b : ℕ) (hab : a+b=n) : |
| Runs (.fix (precBody g)) (a::b::r a::v) ((n+1)::0::r (n+1)::v) |
| ((b+1)*(B+11000*(M+1))) := by |
| induction b generalizing a with |
| | zero => |
| have han : a=n := by omega |
| subst a |
| obtain ⟨t,ht,hc⟩ := run_precBody g n 0 (r n) (r (n+1)) v M B |
| (by omega) (by omega) (hr n (by omega)) (hr (n+1) le_rfl) hv (hg n le_rfl) |
| exact ⟨_,by omega,.fixDone hc rfl⟩ |
| | succ b ih => |
| obtain ⟨t,ht,hc⟩ := run_precBody g a (b+1) (r a) (r (a+1)) v M B |
| (by omega) (by omega) (hr a (by omega)) (hr (a+1) (by omega)) hv (hg a (by omega)) |
| simp only [Nat.add_sub_cancel] at hc |
| obtain ⟨t',ht',hc'⟩ := ih (a+1) (by omega) |
| refine ⟨_,?_,CodeRun.fixMore (a:=b) hc hc'⟩ |
| have hs := bitsize_le_magnitude ((b+1)::(a+1)::b::r (a+1)::v) |
| have hm := hr (a+1) (by omega) |
| simp only [magnitude_cons] at hs |
| have hb : 32*(bitsize ((b+1)::(a+1)::b::r (a+1)::v)+1)≤1000*(M+1) := by omega |
| nlinarith |
|
|
| lemma run_prec (f g : Code) (n : ℕ) (r : ℕ → ℕ) (v : List ℕ) (M A B : ℕ) |
| (hn : n≤M) (hr : ∀i≤n,r i≤M) (hv : magnitude v≤M) |
| (hf : Runs f v [r 0] A) (hg : ∀i<n,Runs g (i::r i::v) [r (i+1)] B) : |
| Runs (.prec f g) (n::v) [r n] (A+(n+2)*(B+50000*(M+1))) := by |
| let F := Code.case .id (.comp (.comp (.comp .tail .tail) (.fix (precBody g))) .zero') |
| have hpre := run_cons (run_head (n::v)) (run_cons (run_comp (run_tail (n::v)) hf) (run_tail (n::v))) |
| have hf' : Runs F (n::r 0::v) (r n::v) ((n+1)*(B+15000*(M+1))) := by |
| cases n with |
| | zero => |
| apply (run_caseZero (g:=.comp (.comp (.comp .tail .tail) (.fix (precBody g))) .zero') |
| rfl (run_id (r 0::v))).mono |
| have := hr 0 le_rfl |
| simp only [magnitude_cons] |
| nlinarith |
| | succ n => |
| have hloop := run_precLoop g n r v M B hn hr hv (fun i hi => hg i (by omega)) 0 n (by omega) |
| have htail := run_comp (run_tail ((n+1)::0::r (n+1)::v)) (run_tail (0::r (n+1)::v)) |
| have hh := run_caseSucc (f:=.id) (run_comp (run_zero (n::r 0::v)) (run_comp hloop htail)) |
| apply hh.mono |
| have h0 := hr 0 (by omega) |
| have hend := hr (n+1) le_rfl |
| simp only [magnitude_cons] |
| nlinarith |
| have h := run_cons (run_comp hpre hf') (run_nil (n::v)) |
| change Runs (.prec f g) (n::v) [r n] _ at h |
| apply h.mono |
| have h0 := hr 0 (by omega) |
| have hend := hr n le_rfl |
| simp only [magnitude_cons,magnitude_nil,List.headI_cons] |
| nlinarith |
|
|
| end MinUncut.Costed |
|
|
| noncomputable section |
| namespace MinUncut.Costed |
| open Turing.ToPartrec Polynomial |
|
|
| lemma evalNat_mono (p : Polynomial ℕ) {x y : ℕ} (h : x≤y) : p.eval x≤p.eval y := by |
| simp only [Polynomial.eval_eq_sum,Polynomial.sum] |
| apply Finset.sum_le_sum |
| intro i hi |
| gcongr |
|
|
| structure PolyProgram (f : List ℕ → List ℕ) where |
| code : Code |
| bound : Polynomial ℕ |
| run : ∀v,Runs code v (f v) (bound.eval (magnitude v)) |
| size : ∀v,magnitude (f v)≤bound.eval (magnitude v) |
|
|
| namespace PolyProgram |
| variable {f g : List ℕ → List ℕ} |
|
|
| def id : PolyProgram (fun v=>v) where |
| code := .id |
| bound := C 70*(X+1) |
| run v := by simpa using run_id v |
| size v := by simp; omega |
|
|
| def tail : PolyProgram List.tail where |
| code := .tail |
| bound := C 32*(X+1) |
| run v := by simpa using run_tail v |
| size v := by have := magnitude_tail v; simp; omega |
|
|
| def head : PolyProgram (fun v=>[v.headI]) where |
| code := .head |
| bound := C 300*(X+1) |
| run v := by simpa using run_head v |
| size v := by have := magnitude_head v; simp; omega |
|
|
| def nil : PolyProgram (fun _=>[]) where |
| code := .nil |
| bound := C 140*(X+1) |
| run v := by simpa using run_nil v |
| size v := by simp |
|
|
| def zero : PolyProgram (fun v=>0::v) where |
| code := .zero' |
| bound := X+1 |
| run v := (run_zero v).mono (by simp) |
| size v := by simp; omega |
|
|
| def succ : PolyProgram (fun v=>[v.headI+1]) where |
| code := .succ |
| bound := C 32*(X+1) |
| run v := by simpa using run_succ v |
| size v := by have := magnitude_head v; simp; omega |
|
|
| def pred : PolyProgram (fun v=>[v.headI-1]) where |
| code := .pred |
| bound := C 332*(X+1) |
| run v := by simpa using run_pred v |
| size v := by have := magnitude_head v; simp; omega |
|
|
| def const (n : ℕ) : PolyProgram (fun _=>[n]) where |
| code := constCode n |
| bound := C (250*(n+1)^2)*(X+1) |
| run v := by simpa using run_const n v |
| size v := by simp; nlinarith |
|
|
| def drop (n : ℕ) : PolyProgram (fun v=>v.drop n) where |
| code := dropCode n |
| bound := C (71+33*n)*(X+1) |
| run v := by simpa using run_drop n v |
| size v := by have := magnitude_drop n v; simp; nlinarith |
|
|
| def projection (n : ℕ) : PolyProgram (fun v=>[(v.drop n).headI]) where |
| code := atCode n |
| bound := C (372+33*n)*(X+1) |
| run v := by simpa using run_at n v |
| size v := by have := magnitude_drop n v; have := magnitude_head (v.drop n); simp; nlinarith |
|
|
| def comp (F : PolyProgram f) (G : PolyProgram g) : PolyProgram (f ∘ g) where |
| code := .comp F.code G.code |
| bound := G.bound+F.bound.comp G.bound+1 |
| run v := by |
| have hh := run_comp (G.run v) (F.run (g v)) |
| apply hh.mono |
| have hm := evalNat_mono F.bound (G.size v) |
| simp only [eval_add,eval_comp,eval_one] |
| omega |
| size v := by |
| have hm := (F.size (g v)).trans (evalNat_mono F.bound (G.size v)) |
| simpa using (hm.trans (Nat.le_add_left _ _)).trans (Nat.le_add_right _ 1) |
|
|
| def cons (F : PolyProgram f) (G : PolyProgram g) : |
| PolyProgram (fun v=>(f v).headI::g v) where |
| code := .cons F.code G.code |
| bound := F.bound+G.bound+C 32*(X+F.bound+1)+1 |
| run v := by |
| apply (run_cons (F.run v) (G.run v)).mono |
| have hf := F.size v |
| simp only [eval_add,eval_mul,eval_C,eval_X,eval_one] |
| omega |
| size v := by |
| have hh := (magnitude_head (f v)).trans (F.size v) |
| have hg := G.size v |
| simp only [magnitude_cons,eval_add,eval_mul,eval_C,eval_X,eval_one] |
| omega |
|
|
| def ofEq (F : PolyProgram f) (h : ∀v,f v=g v) : PolyProgram g where |
| code := F.code |
| bound := F.bound |
| run v := h v ▸ F.run v |
| size v := h v ▸ F.size v |
|
|
| open Turing.ToPartrec Polynomial |
|
|
| variable {f g e : List ℕ → List ℕ} |
|
|
| def branch (E : PolyProgram e) (F : PolyProgram f) (G : PolyProgram g) : |
| PolyProgram (fun v=>if (e v).headI=0 then f v else g v) where |
| code := .comp (.case F.code (.comp G.code .tail)) (.cons E.code .id) |
| bound := E.bound+F.bound+G.bound+C 300*(X+E.bound+1)+1 |
| run v := by |
| have hp := run_cons (E.run v) (run_id v) |
| have hs := (magnitude_head (e v)).trans (E.size v) |
| by_cases he : (e v).headI=0 |
| · simp only [ite_eq_left he] |
| have hb := run_caseZero (g:=.comp G.code .tail) (v := (e v).headI::v) (by simpa using he) (F.run v) |
| have hh := run_comp hp hb |
| apply hh.mono |
| simp only [eval_add,eval_mul,eval_C,eval_X,eval_one,magnitude_cons] |
| have hh := E.size v |
| omega |
| · simp only [ite_eq_right he] |
| obtain ⟨a,ha⟩ := Nat.exists_eq_succ_of_ne_zero he |
| have hb := run_caseSucc (f:=F.code) (run_comp (run_tail (a::v)) (G.run v)) |
| change Runs _ ((a+1)::v) _ _ at hb |
| rw [← show (e v).headI=a+1 from ha] at hb |
| have hh := run_comp hp hb |
| apply hh.mono |
| have heq : (e v).headI=a+1 := ha |
| simp only [eval_add,eval_mul,eval_C,eval_X,eval_one,magnitude_cons] |
| have hh := E.size v |
| omega |
| size v := by |
| have hf := F.size v |
| have hg := G.size v |
| split_ifs <;> simp only [eval_add,eval_mul,eval_C,eval_X,eval_one] <;> omega |
|
|
| def collect : (fs : List (List ℕ → List ℕ)) → (∀f∈fs,PolyProgram f) → |
| (G : PolyProgram g) → PolyProgram (fun v=>fs.map (fun f=>(f v).headI)++g v) |
| | [], _, G => G |
| | f::fs, H, G => |
| (H f (by simp)).cons (collect fs (fun f hf=>H f (by simp [hf])) G) |
|
|
| def replace (n : ℕ) (E : PolyProgram e) : |
| PolyProgram (fun v=>(List.range n).map (fun i=>(v.drop i).headI)++ |
| (e v).headI::v.drop (n+1)) := by |
| let fs := (List.range n).map (fun i (v : List ℕ)=>[(v.drop i).headI]) |
| let P := collect fs (by |
| intro f hf |
| let ex := List.mem_map.mp hf |
| let i := Classical.choose ex |
| have hi : (fun v : List ℕ=>[(v.drop i).headI])=f := (Classical.choose_spec ex).2 |
| exact hi ▸ projection i) (E.cons (drop (n+1))) |
| exact P.ofEq (by intro v; simp [fs,List.map_map]) |
|
|
| end PolyProgram |
| end MinUncut.Costed |
|
|
| end |
|
|
| end OAI |
|
|
