| import Mathlib |
| import OAI.Computability.MinUncut.Search.ArithmeticExpression |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace MinUncut.Costed |
| open Turing.ToPartrec Polynomial |
|
|
| namespace PolyProgram |
|
|
| def variableDrop : PolyProgram (fun v=>v.tail.drop v.headI) where |
| code := dynamicDrop |
| 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 []) |
| exact ⟨_,by norm_num [magnitude] at ht ⊢; omega,CodeRun.fixDone (u := [0]) hc rfl⟩ |
| | cons n v => |
| apply (run_dynamicDrop 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_drop v.headI v.tail).trans (magnitude_tail v) |
| simp only [eval_mul,eval_C,eval_pow,eval_add,eval_X,eval_one] |
| nlinarith |
|
|
| def expressions {g : List ℕ → List ℕ} (G : PolyProgram g) : |
| (es : List AExpr) → PolyProgram (fun v=>es.map (fun e=>e.eval v)++g v) |
| | [] => G |
| | e::es => e.program.cons (expressions G es) |
|
|
| end PolyProgram |
|
|
| namespace Blocks |
|
|
| def block (es : List AExpr) (i : ℕ) (v : List ℕ) : List ℕ := es.map (fun e=>e.eval (i::v)) |
| def source (v : List ℕ) : List ℕ := v.drop (v.tail.headI+2) |
| def step (es : List AExpr) (v : List ℕ) : List ℕ := |
| (v.headI+1)::(v.tail.headI+es.length)::(block es v.headI (source v)++v.drop 2) |
|
|
| def extractor : PolyProgram (fun v=>v.headI::source v) := |
| PolyProgram.head.cons ((PolyProgram.variableDrop.comp |
| ((PolyProgram.addOf (PolyProgram.projection 1) (PolyProgram.const 2)).cons PolyProgram.id)).ofEq |
| (by intro v; simp only [Function.comp_def,List.headI_cons,List.tail_cons,List.drop_one,source])) |
|
|
| def stepProgram (es : List AExpr) : PolyProgram (step es) := |
|
|
| let pref : PolyProgram (fun v=>block es v.headI (source v)++v.drop 2) := by |
| let rec go (l : List AExpr) : PolyProgram (fun v=> l.map (fun e=>e.eval (v.headI::source v))++v.drop 2) := |
| match l with |
| | [] => PolyProgram.drop 2 |
| | e::l => (e.program.comp extractor).cons (go l) |
| exact go es |
| (PolyProgram.succ.cons |
| ((PolyProgram.addOf (PolyProgram.projection 1) (PolyProgram.const es.length)).cons pref)).ofEq |
| (by intro v; simp only [List.headI_cons,List.drop_one,step]) |
|
|
| @[simp] lemma length_block (es : List AExpr) (i : ℕ) (v : List ℕ) : |
| (block es i v).length=es.length := by simp [block] |
|
|
| lemma source_step (es : List AExpr) (v : List ℕ) : source (step es v)=source v := by |
| simp only [source,step,List.drop_succ_cons,List.headI_cons,List.tail_cons] |
| rw [show v.tail.headI+es.length=es.length+v.tail.headI by omega,← List.drop_drop] |
| rw [← length_block es v.headI (v.drop (v.tail.headI+2)),List.drop_left] |
| rw [List.drop_drop] |
| congr 1 |
| omega |
|
|
| @[simp] lemma head_step (es : List AExpr) (v : List ℕ) : (step es v).headI=v.headI+1 := rfl |
| @[simp] lemma second_step (es : List AExpr) (v : List ℕ) : (step es v).tail.headI=v.tail.headI+es.length := rfl |
|
|
| lemma iterate_head (es : List AExpr) (v : List ℕ) (i : ℕ) : |
| ((step es)^[i] v).headI=v.headI+i := by |
| induction i with |
| | zero => simp |
| | succ i ih => rw [Function.iterate_succ_apply',head_step,ih]; omega |
| lemma iterate_source (es : List AExpr) (v : List ℕ) (i : ℕ) : |
| source ((step es)^[i] v)=source v := by |
| induction i with |
| | zero => rfl |
| | succ i ih => rw [Function.iterate_succ_apply',source_step,ih] |
|
|
| lemma magnitude_append (v w : List ℕ) : magnitude (v++w)=magnitude v+magnitude w := by |
| induction v with |
| | nil => simp only [List.nil_append,magnitude_nil,Nat.zero_add] |
| | cons a v ih => simp only [List.cons_append,magnitude_cons,ih]; omega |
|
|
| lemma magnitude_step (es : List AExpr) (v : List ℕ) : |
| magnitude (step es v)≤ magnitude v+es.length+3+magnitude (block es v.headI (source v)) := by |
| simp only [step,magnitude_cons,magnitude_append] |
| cases v with |
| | nil => simp [magnitude]; omega |
| | cons a v => |
| cases v with |
| | nil => simp [magnitude]; omega |
| | cons b v => simp only [List.headI_cons,List.tail_cons,List.drop_succ_cons,List.drop_zero,magnitude_cons]; omega |
|
|
| lemma iterate_size (es : List AExpr) (v : List ℕ) (n i : ℕ) (hi : i≤n) : |
| magnitude ((step es)^[i] v)≤ magnitude v+ |
| i*(es.length+3+((PolyProgram.expressions PolyProgram.nil es).bound).eval |
| (n+1+2*magnitude v)) := by |
| induction i with |
| | zero => simp |
| | succ i ih => |
| have hh := ih (by omega) |
| have hs := magnitude_step es ((step es)^[i] v) |
| have hb := (PolyProgram.expressions PolyProgram.nil es).size |
| (((step es)^[i] v).headI::source ((step es)^[i] v)) |
| change magnitude (block es _ _++[])≤_ at hb |
| rw [List.append_nil,iterate_head,iterate_source] at hb |
| have hm : magnitude ((v.headI+i)::source v)≤n+1+2*magnitude v := by |
| have h1 := magnitude_head v |
| have h2 := magnitude_drop (v.tail.headI+2) v |
| simp only [magnitude_cons,source] |
| omega |
| have hb' := hb.trans (evalNat_mono _ hm) |
| rw [iterate_head,iterate_source] at hs |
| rw [Function.iterate_succ_apply'] |
| nlinarith |
|
|
| def iterationProgram (es : List AExpr) : |
| PolyProgram (fun v=>(step es)^[v.headI] v.tail) := |
| PolyProgram.iterate (stepProgram es) |
| (X+X*(C (es.length+3)+(PolyProgram.expressions PolyProgram.nil es).bound.comp (C 3*X+1))) (by |
| intro n v i hi |
| have h := iterate_size es v n i hi |
| have hv : magnitude v≤ magnitude (n::v) := by simp only [magnitude_cons]; omega |
| have hi' : i≤ magnitude (n::v) := by simp only [magnitude_cons]; omega |
| have hn : n+1+2*magnitude v≤3*magnitude (n::v)+1 := by simp only [magnitude_cons]; omega |
| have hb := evalNat_mono (PolyProgram.expressions PolyProgram.nil es).bound hn |
| simp only [eval_add,eval_mul,eval_C,eval_comp,eval_X,eval_one] |
| exact h.trans (Nat.add_le_add hv (Nat.mul_le_mul hi' (Nat.add_le_add_left hb _)))) |
|
|
| lemma iterate_accumulator (es : List AExpr) (v : List ℕ) (n : ℕ) : |
| (step es)^[n] (0::0::v)=n::(n*es.length):: |
| ((List.range n).reverse.flatMap (fun i=>block es i v)++v) := by |
| induction n with |
| | zero => simp |
| | succ n ih => |
| rw [Function.iterate_succ_apply',ih] |
| have hs : source (n::(n*es.length)::((List.range n).reverse.flatMap (fun i=>block es i v)++v))=v := by |
| rw [← ih,iterate_source] |
| rfl |
| simp only [step,List.headI_cons,List.tail_cons,hs,List.drop_succ_cons,List.drop_zero, |
| List.range_succ,List.reverse_append,List.reverse_singleton,List.flatMap_append, |
| List.flatMap_cons,List.flatMap_nil,List.append_nil,List.append_assoc] |
| simp only [Nat.add_mul,Nat.one_mul] |
| |
| def enumerate (es : List AExpr) (N : AExpr) : PolyProgram (fun v=> |
| N.eval v::(N.eval v*es.length):: |
| ((List.range (N.eval v)).reverse.flatMap (fun i=>block es i v)++v)) := |
| ((iterationProgram es).comp (N.program.cons ((PolyProgram.const 0).cons |
| ((PolyProgram.const 0).cons PolyProgram.id)))).ofEq (by |
| intro v |
| change (step es)^[N.eval v] (0::0::v)=_ |
| exact iterate_accumulator es v (N.eval v)) |
| |
| end Blocks |
| end MinUncut.Costed |
| |
| end |
| end |
| |
| end OAI |
| |
