| import Mathlib |
| import OAI.Computability.MinUncut.Estimates.CodeComputability |
|
|
| namespace OAI |
|
|
| section |
| namespace MinUncut.Costed |
| open Turing.ToPartrec |
|
|
| def iterBody (c : Code) : Code := |
| .case .zero' (.cons (.comp .succ .zero) (.cons .head (.comp c .tail))) |
| def iterCode (c : Code) : Code := .fix (iterBody c) |
|
|
| lemma run_iterBody_zero (c : Code) (v : List ℕ) : |
| Runs (iterBody c) (0::v) (0::v) (2000*(magnitude (0::v)+1)) := |
| (run_caseZero rfl (run_zero v)).mono (by omega) |
|
|
| lemma run_iterBody_succ {c : Code} {v w : List ℕ} {B : ℕ} |
| (h : Runs c v w B) (n : ℕ) : |
| Runs (iterBody c) ((n+1)::v) (1::n::w) |
| (B+2000*(magnitude ((n+1)::v)+magnitude w+1)) := by |
| have h1 := run_comp (run_const_zero (n::v)) (run_succ [0]) |
| have hf := run_comp (run_tail (n::v)) h |
| have hh := run_caseSucc (f:=.zero') (run_cons h1 (run_cons (run_head (n::v)) hf)) |
| apply hh.mono |
| simp only [magnitude_nil,magnitude_cons,List.headI_cons] |
| omega |
|
|
| lemma run_iter {c : Code} (f : List ℕ → List ℕ) (n : ℕ) (v : List ℕ) (M B : ℕ) |
| (hs : ∀i≤n,magnitude (f^[i] v)≤M) |
| (hf : ∀i<n,Runs c (f^[i] v) (f^[i+1] v) B) : |
| Runs (iterCode c) (n::v) (f^[n] v) ((n+1)*(B+5000*(n+M+4))) := by |
| let state := fun i => (n-i)::f^[i] v |
| have hsize : ∀i≤n,magnitude (state i)≤n+M+1 := by |
| intro i hi |
| have := hs i hi |
| simp only [state,magnitude_cons] |
| omega |
| have hstep : ∀i<n,Runs (iterBody c) (state i) (1::state (i+1)) |
| (B+4000*(n+M+2)) := by |
| intro i hi |
| have hn : n-i=(n-(i+1))+1 := by omega |
| have hh := run_iterBody_succ (hf i hi) (n-(i+1)) |
| rw [← hn] at hh |
| apply hh.mono |
| have hsi := hs i (by omega) |
| have hsj := hs (i+1) (by omega) |
| simp only [magnitude_cons] |
| omega |
| have hdone : Runs (iterBody c) (state n) (0::f^[n] v) |
| (B+4000*(n+M+2)) := by |
| simp only [state,Nat.sub_self] |
|
|
| apply (run_iterBody_zero c (f^[n] v)).mono |
| have := hs n le_rfl |
| simp only [magnitude_cons]; omega |
| have hh := run_fix_bounded n (n+M+1) (B+4000*(n+M+2)) hsize hstep hdone |
| change Runs (iterCode c) (n::v) (f^[n] v) _ at hh |
| apply hh.mono |
| apply Nat.mul_le_mul_left |
| omega |
|
|
| end MinUncut.Costed |
|
|
| noncomputable section |
| namespace MinUncut.Costed.PolyProgram |
| open Turing.ToPartrec Polynomial |
|
|
| def iterate {f : List ℕ → List ℕ} (F : PolyProgram f) (p : Polynomial ℕ) |
| (hs : ∀n v i, i≤n → magnitude (f^[i] v)≤p.eval (magnitude (n::v))) : |
| PolyProgram (fun v=>f^[v.headI] v.tail) where |
| code := iterCode F.code |
| bound := p+(X+1)*(F.bound.comp p+C 5000*(X+p+4))+C 3000*(X+1) |
| run v := by |
| cases v with |
| | nil => |
| obtain ⟨t,ht,hc⟩ := run_caseZero (f:=.zero') (g:= |
| .cons (.comp .succ .zero) (.cons .head (.comp F.code .tail))) (v:=[]) rfl (run_zero []) |
| refine ⟨_,?_,CodeRun.fixDone (u := [0]) hc rfl⟩ |
| simp only [magnitude_nil] at ht |
| simp only [eval_add,eval_mul,eval_comp,eval_C,eval_X,eval_one,eval_ofNat,magnitude_nil] |
| omega |
| | cons n v => |
| have hh := run_iter (c := F.code) f n v (p.eval (magnitude (n::v))) |
| (F.bound.eval (p.eval (magnitude (n::v)))) (hs n v) (by |
| intro i hi |
| have h := F.run (f^[i] v) |
| have h' : Runs F.code (f^[i] v) (f^[i+1] v) (F.bound.eval (magnitude (f^[i] v))) := by |
| simpa only [Function.iterate_succ_apply'] using h |
| exact h'.mono (evalNat_mono F.bound (hs n v i (by omega)))) |
| apply hh.mono |
| simp only [eval_add,eval_mul,eval_comp,eval_C,eval_X,eval_one,eval_ofNat] |
| have hn : n≤ magnitude (n::v) := by simp only [magnitude_cons]; omega |
| have h₁ : (n+1)*(F.bound.eval (p.eval (magnitude (n::v)))+ |
| 5000*(n+p.eval (magnitude (n::v))+4)) ≤ |
| (magnitude (n::v)+1)*(F.bound.eval (p.eval (magnitude (n::v)))+ |
| 5000*(magnitude (n::v)+p.eval (magnitude (n::v))+4)) := by gcongr |
| omega |
| size v := by |
| cases v with |
| | nil => simp |
| | cons n v => |
| have hh := hs n v n le_rfl |
| simp only [List.headI_cons,List.tail_cons,eval_add,eval_mul,eval_comp, |
| eval_C,eval_X,eval_one,eval_ofNat] |
| omega |
|
|
| def dynamic : PolyProgram (fun v=>[(v.tail.drop v.headI).headI]) where |
| code := dynamicAt |
| bound := C 3000*(X+1)^2 |
| run v := by |
| cases v with |
| | nil => |
| obtain ⟨t,ht,hc⟩ := run_caseZero (g:=.cons (.comp .succ .zero) |
| (.cons .head (.comp .tail .tail))) (v:=[]) rfl (run_zero []) |
| have hf : Runs dynamicDrop [] [] 100 := ⟨_,by simp only [magnitude_nil] at ht; omega,CodeRun.fixDone (u := [0]) hc rfl⟩ |
| exact (run_comp hf (run_head [])).mono (by norm_num [magnitude]) |
| | cons n v => |
| apply (run_dynamicAt n v).mono |
| simp only [eval_mul,eval_C,eval_pow,eval_add,eval_X,eval_one] |
| have hn : n+1≤ magnitude (n::v)+1 := by simp only [magnitude_cons]; omega |
| nlinarith |
| size v := by |
| have h := (magnitude_head (v.tail.drop v.headI)).trans |
| ((magnitude_drop v.headI v.tail).trans (magnitude_tail v)) |
| simp only [magnitude_cons,magnitude_nil,eval_mul,eval_C,eval_pow,eval_add,eval_X,eval_one] |
| nlinarith |
|
|
| end MinUncut.Costed.PolyProgram |
|
|
| end |
| end |
|
|
| end OAI |
|
|
