| import Mathlib |
| import OAI.Computability.MinUncut.Machines.ArenaMachineProgram |
| import OAI.Computability.MinUncut.Search.CodeLayoutComputable |
| import OAI.Computability.MinUncut.Machines.FramedWordDecoder |
|
|
| namespace OAI |
|
|
| namespace MinUncut.Costed.UnaryWords |
| open Turing.ToPartrec Polynomial Arena |
| def finishCounted (v : List ℕ) : List ℕ := v.headI::finish v |
| def bodyCounted (v : List ℕ) : List ℕ := if symbol v=0 then 0::finishCounted v else 1::step v |
| noncomputable def finishCountedProgram : PolyProgram finishCounted := PolyProgram.head.cons finishProgram |
| noncomputable def bodyCountedProgram : PolyProgram bodyCounted := |
| (PolyProgram.branch symbolProgram (PolyProgram.zero.comp finishCountedProgram) |
| ((PolyProgram.const 1).cons stepProgram)).ofEq (by intro v; rfl) |
| def parsedCounted (v : List ℕ) : List ℕ := count v::parsed v |
| lemma finishCounted_iterate (v : List ℕ) : |
| finishCounted (step^[count v] (state 0 0 [] v))=parsedCounted v := by |
| have h:=iterate_state v [] v 0 [] (by rfl) |
| simpa only [List.length_nil,Nat.zero_add,finishCounted,finish,state,List.cons_append,List.nil_append, |
| List.drop_succ_cons,List.drop_zero,List.headI_cons,parsedCounted,parsed] using congrArg finishCounted h |
| noncomputable def parserCountedBound : Polynomial ℕ := |
| (X+1)*(bodyCountedProgram.bound.comp parseSize+C 32*(parseSize+3))+C 1000*(X+1) |
|
|
| lemma run_parserCounted (v : List ℕ) : |
| Runs (.fix bodyCountedProgram.code) (state 0 0 [] v) (parsedCounted v) (parserCountedBound.eval (magnitude v)) := by |
| have hn := (count_le v).trans (length_le_magnitude v) |
| have hh:=run_fix_bounded (body:=bodyCountedProgram.code) (out:=parsedCounted v) (state:=fun i=>step^[i] (state 0 0 [] v)) |
| (count v) (parseSize.eval (magnitude v)) (bodyCountedProgram.bound.eval (parseSize.eval (magnitude v))) |
| (iterate_size v) ?_ ?_ |
| · apply hh.mono |
| simp only [parserCountedBound,eval_add,eval_mul,eval_comp,eval_C,eval_X,eval_one,eval_ofNat] |
| have h:=Nat.mul_le_mul_right |
| (bodyCountedProgram.bound.eval (parseSize.eval (magnitude v))+32*(parseSize.eval (magnitude v)+3)) |
| (show count v+1≤ magnitude v+1 by omega) |
| omega |
| · intro i hi |
| have hh:=bodyCountedProgram.run (step^[i] (state 0 0 [] v)) |
| have he : bodyCounted (step^[i] (state 0 0 [] v))=1::step^[i+1] (state 0 0 [] v) := by |
| simp only [bodyCounted,symbol_iterate,ite_eq_right (count_drop_ne v i hi),Function.iterate_succ_apply'] |
| rw [he] at hh |
| exact hh.mono (evalNat_mono _ (iterate_size v i (by omega))) |
| · have hh:=bodyCountedProgram.run (step^[count v] (state 0 0 [] v)) |
| have he : bodyCounted (step^[count v] (state 0 0 [] v))=0::parsedCounted v := by |
| rw [bodyCounted,symbol_iterate,count_drop_head,ite_eq_left rfl,finishCounted_iterate] |
| rw [he] at hh |
| exact hh.mono (evalNat_mono _ (iterate_size v (count v) le_rfl)) |
|
|
| noncomputable def parserCountedProgram : PolyProgram parsedCounted where |
| code := .comp (.fix bodyCountedProgram.code) initializer.code |
| bound := parserCountedBound+bodyCountedProgram.bound.comp parseSize+initializer.bound+C 2000*(X+1) |
| run v := by |
| apply (run_comp (initializer.run v) (run_parserCounted v)).mono |
| simp only [eval_add,eval_comp,eval_mul,eval_C,eval_X,eval_one] |
| omega |
| size v := by |
| have hh:=bodyCountedProgram.size (step^[count v] (state 0 0 [] v)) |
| rw [bodyCounted,symbol_iterate,count_drop_head,ite_eq_left rfl,finishCounted_iterate] at hh |
| have hs:=evalNat_mono bodyCountedProgram.bound (iterate_size v (count v) le_rfl) |
| simp only [magnitude_cons] at hh |
| simp only [eval_add,eval_comp,eval_mul,eval_C,eval_X,eval_one] |
| omega |
|
|
| open MinUncutGames.Foundations.Complexity |
| lemma decodeAux_word (n c : ℕ) (acc : List ℕ) (v : List Bool) : |
| decodeAux c acc ((encodeWord n++v).map FrameDecode.symbol)= |
| decodeAux 0 ((c+n)::acc) (v.map FrameDecode.symbol) := by |
| induction n generalizing c with |
| | zero => simp [encodeWord,FrameDecode.symbol,decodeAux] |
| | succ n ih => |
| simp only [encodeWord,List.replicate_succ,List.cons_append,List.append_assoc, |
| List.map_cons,FrameDecode.symbol,Bool.toNat_true,decodeAux] |
| simp only [show ¬(1+1:ℕ)=0 by decide,show ¬(1+1:ℕ)=1 by decide,ite_false,List.nil_append] |
| simpa only [encodeWord,List.append_assoc,List.singleton_append,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using ih (c+1) |
| lemma decodeAux_words (xs acc : List ℕ) : |
| decodeAux 0 acc ((encodeWords xs).map FrameDecode.symbol)=xs.reverse++acc := by |
| induction xs generalizing acc with |
| | nil => rfl |
| | cons x xs ih => |
| rw [encodeWords,decodeAux_word,Nat.zero_add,ih] |
| simp only [List.reverse_cons,List.append_assoc,List.singleton_append] |
| lemma parsedCounted_words (xs : List ℕ) : |
| parsedCounted ((encodeWords xs).map FrameDecode.symbol)= |
| (encodeWords xs).length::xs.length::(xs.reverse++(encodeWords xs).map FrameDecode.symbol) := by |
| simp only [parsedCounted,FrameDecode.count_symbols,parsed,decodeAux_words,List.append_nil,List.length_reverse,List.cons_append] |
| end MinUncut.Costed.UnaryWords |
|
|
| noncomputable section |
| namespace MinUncut.Costed.Arena.Init |
| open Turing.ToPartrec Polynomial MinUncutGames.Foundations.Complexity |
|
|
| def parseWithKey (v : List ℕ) : List ℕ := v.headI::UnaryWords.parsedCounted v.tail |
| def parseWithKeyProgram : PolyProgram parseWithKey := |
| PolyProgram.head.cons (UnaryWords.parserCountedProgram.comp PolyProgram.tail) |
| lemma parseWithKey_spec (K : ℕ) (xs : List ℕ) : |
| parseWithKey (K::(encodeWords xs).map FrameDecode.symbol)= |
| K::(encodeWords xs).length::xs.length::(xs.reverse++(encodeWords xs).map FrameDecode.symbol) := by |
| simp only [parseWithKey,List.headI_cons,List.tail_cons,UnaryWords.parsedCounted_words] |
|
|
| lemma exists_initializer {cs : ℕ → Code} (hc : Computable cs) : |
| ∃c : Code,∀K,∃p : Polynomial ℕ,∀xs, |
| Runs c (K::(encodeWords xs).map FrameDecode.symbol) |
| (initialState (cs K) xs (base (cs K) xs K ((encodeWords xs).map FrameDecode.symbol))).encode |
| (p.eval (magnitude (K::(encodeWords xs).map FrameDecode.symbol))) ∧ |
| magnitude (initialState (cs K) xs (base (cs K) xs K ((encodeWords xs).map FrameDecode.symbol))).encode≤ |
| p.eval (magnitude (K::(encodeWords xs).map FrameDecode.symbol)) := by |
| obtain ⟨c,hc⟩:=FiberPrefix.exists_code (CodeEffective.Layout.c_prefix.comp hc) |
| refine ⟨.comp initializer.code (.comp c parseWithKeyProgram.code),fun K=>?_⟩ |
| obtain ⟨p,hp⟩:=hc K |
| let q:=p.comp parseWithKeyProgram.bound |
| let r:=parseWithKeyProgram.bound+q+initializer.bound.comp q+2 |
| refine ⟨r,fun xs=>?_⟩ |
| let v:=(encodeWords xs).map FrameDecode.symbol |
| let w:= (encodeWords xs).length::xs.length::(xs.reverse++v) |
| have he:parseWithKey (K::v)=K::w:=parseWithKey_spec K xs |
| have hinput: (codeCells (cs K) 0).length::words (codeCells (cs K) 0)++K::w=input (cs K) xs K v := by |
| simp only [input,w,v,List.length_map,List.cons_append] |
| have hrun:=run_comp (run_comp (parseWithKeyProgram.run (K::v)) (by |
| rw [he] |
| exact (hp w).1)) (by rw [hinput]; exact initializer.run (input (cs K) xs K v)) |
| have hs:=parseWithKeyProgram.size (K::v) |
| rw [he] at hs |
| have hpbound:=evalNat_mono p hs |
| have hsize: magnitude (input (cs K) xs K v)≤q.eval (magnitude (K::v)):=by |
| have hz:=(hp w).2.trans hpbound |
| simpa only [hinput,q,eval_comp] using hz |
| have hi:=evalNat_mono initializer.bound hsize |
| rw [initializer_spec] at hrun |
| dsimp only [v] at * |
| constructor |
| · apply hrun.mono |
| simp only [r,q,eval_add,eval_comp,eval_ofNat] |
| simp only [q,eval_comp] at hi |
| omega |
| · have hz:=initializer.size (input (cs K) xs K v) |
| rw [initializer_spec] at hz |
| have hz:=hz.trans hi |
| dsimp only [v] at hz |
| simp only [r,eval_add,eval_comp,eval_ofNat] |
| omega |
| end MinUncut.Costed.Arena.Init |
|
|
| end |
| namespace MinUncut.Costed |
| open Turing.ToPartrec Polynomial |
| noncomputable section |
| variable {f e : List ℕ → List ℕ} |
| def untilBody (F : PolyProgram f) (E : PolyProgram e) : |
| PolyProgram (fun v=>if (e v).headI=0 then 0::v else 1::f v) := |
| (PolyProgram.branch E ((PolyProgram.const 0).cons PolyProgram.id) |
| ((PolyProgram.const 1).cons F)).ofEq (by intro v; rfl) |
| def untilCode (F : PolyProgram f) (E : PolyProgram e) : Code := .fix (untilBody F E).code |
|
|
| def untilStateBound (L M : ℕ) : Polynomial ℕ := C ((L+1)*(M+1))*(X+1)^2 |
| def untilBound (F : PolyProgram f) (E : PolyProgram e) (L M : ℕ) : Polynomial ℕ := |
| (X+1)*((untilBody F E).bound.comp (untilStateBound L M)+C 32*(untilStateBound L M+3)) |
| lemma iterate_at_stop (hs : ∀v,(e v).headI=0 → f v=v) (v : List ℕ) (i j : ℕ) |
| (hi : (e (f^[i] v)).headI=0) (hij : i≤j) : f^[j] v=f^[i] v := by |
| have hf : ∀k,f^[k] (f^[i] v)=f^[i] v := by |
| intro k |
| induction k with |
| | zero => rfl |
| | succ k ih => rw [Function.iterate_succ_apply',ih,hs _ hi] |
| rw [show j=(j-i)+i by omega,Function.iterate_add_apply,hf] |
|
|
| lemma run_until (F : PolyProgram f) (E : PolyProgram e) (L M : ℕ) |
| (hsize : ∀v,(f v).length≤v.length+L ∧ Arena.maximum (f v)≤Arena.maximum v+M) |
| (hstop : ∀v,(e v).headI=0 → f v=v) (v : List ℕ) (B : ℕ) |
| (hend : (e (f^[B] v)).headI=0) : |
| Runs (untilCode F E) v (f^[B] v) ((untilBound F E L M).eval (magnitude (B::v))) := by |
| classical |
| let ex : ∃i,(e (f^[i] v)).headI=0 := ⟨B,hend⟩ |
| let n := Nat.find ex |
| have hn : n≤B := Nat.find_min' ex hend |
| have hdone : (e (f^[n] v)).headI=0 := Nat.find_spec ex |
| let Z := (untilStateBound L M).eval (magnitude (B::v)) |
| have hm : ∀i≤B,magnitude (f^[i] v)≤Z := by |
| intro i hi |
| simpa only [Z, untilStateBound, eval_mul, eval_C, eval_pow, eval_add, eval_X, eval_one] using Arena.iterate_magnitude L M hsize B v i hi |
| have he : f^[B] v=f^[n] v := iterate_at_stop hstop v n B hdone hn |
| have hb : ∀i≤B,Runs (untilBody F E).code (f^[i] v) |
| (if (e (f^[i] v)).headI=0 then 0::f^[i] v else 1::f^[i+1] v) |
| ((untilBody F E).bound.eval Z) := by |
| intro i hi |
| have hh := ((untilBody F E).run (f^[i] v)).mono (evalNat_mono _ (hm i hi)) |
| simpa only [Function.iterate_succ_apply'] using hh |
| have hr := run_fix_bounded n Z ((untilBody F E).bound.eval Z) |
| (fun i hi=>hm i (hi.trans hn)) (state:=fun i=>f^[i] v) (out:=f^[n] v) |
| (by intro i hi; simpa only [ite_eq_right (Nat.find_min ex hi)] using hb i (by omega)) |
| (by simpa only [hdone,ite_true] using hb n hn) |
| rw [←he] at hr |
| apply hr.mono |
| have hn' : n+1 ≤ magnitude (B::v)+1 := by simp only [magnitude_cons]; omega |
| have hp := Nat.mul_le_mul_right ((untilBody F E).bound.eval Z+32*(Z+3)) hn' |
| simpa only [untilBound,eval_mul,eval_add,eval_comp,eval_X,eval_one,eval_C,eval_ofNat,Z] using hp |
| end |
| end MinUncut.Costed |
|
|
| namespace MinUncut.Costed.Arena |
| open Turing.ToPartrec Polynomial |
| noncomputable section |
|
|
| def stoppedTick (v : List ℕ) : List ℕ := if v.headI=2 then v else rawTick v |
| def stopExpr : Expr := .sub (.const 1) (.eq (.reg 0) (.const 2)) |
| def stopProgram : PolyProgram (fun v=>[stopExpr.eval v]) := stopExpr.program |
| def stoppedTickProgram : PolyProgram stoppedTick := |
| (PolyProgram.branch stopProgram PolyProgram.id tickProgram).ofEq (by |
| intro v |
| simp only [stopExpr,Expr.eval,List.headI_cons,stoppedTick,List.drop_zero] |
| by_cases h:v.headI=2 <;> simp only [h,ite_true,ite_false,Nat.sub_self,Nat.sub_zero,Nat.one_ne_zero]) |
| lemma stop_zero (v : List ℕ) : stopExpr.eval v=0 ↔ v.headI=2 := by |
| simp only [stopExpr,Expr.eval,List.drop_zero] |
| split_ifs <;> simp_all |
| lemma stoppedTick_safe (v : List ℕ) : |
| (stoppedTick v).length≤v.length+9 ∧ maximum (stoppedTick v)≤ maximum v+3 := by |
| unfold stoppedTick |
| split_ifs |
| · exact ⟨by omega,by omega⟩ |
| · exact rawTick_safe v |
| lemma stoppedTick_encode (s : State) : stoppedTick s.encode=(s.tick).encode := by |
| by_cases h:s.mode=2 |
| · simp only [stoppedTick,State.encode,List.cons_append,List.nil_append,List.headI_cons,h,ite_true] |
| have hs : s.tick=s := by simp [State.tick,h] |
| rw [hs] |
| simp only [h] |
| · rw [stoppedTick,ite_eq_right (show s.encode.headI≠2 from h),rawTick_encode] |
| lemma stoppedTick_iter_encode (s : State) (i : ℕ) : stoppedTick^[i] s.encode=rawTick^[i] s.encode := by |
| have hh (s : State) (i : ℕ) : stoppedTick^[i] s.encode=(State.tick^[i] s).encode ∧ |
| rawTick^[i] s.encode=(State.tick^[i] s).encode := by |
| induction i with |
| | zero => exact ⟨rfl,rfl⟩ |
| | succ i ih => |
| constructor <;> rw [Function.iterate_succ_apply'] |
| · rw [ih.1,stoppedTick_encode,Function.iterate_succ_apply'] |
| · rw [ih.2,rawTick_encode,Function.iterate_succ_apply'] |
| exact (hh s i).1.trans (hh s i).2.symm |
|
|
| def unboundedControl : Code := untilCode stoppedTickProgram stopProgram |
| lemma unboundedControl_run {c v w B} (hr : Runs c v w B) (base : Heap) : |
| ∃h out,ListRep h out w ∧ |
| magnitude (State.mk 2 0 out 0 h).encode ≤ |
| (untilStateBound 9 3).eval (magnitude ((3*B+1)::(initialState c v base).encode)) ∧ |
| Runs unboundedControl (initialState c v base).encode (State.mk 2 0 out 0 h).encode |
| ((untilBound stoppedTickProgram stopProgram 9 3).eval |
| (magnitude ((3*B+1)::(initialState c v base).encode))) := by |
| obtain ⟨t,ht,hc⟩:=hr |
| obtain ⟨h,out,ho,he⟩:=CodeRun.interpreted hc base ht |
| rw [←stoppedTick_iter_encode] at he |
| refine ⟨h,out,ho,?_,?_⟩ |
| · rw [←he] |
| simpa only [untilStateBound,Polynomial.eval_mul,Polynomial.eval_C,Polynomial.eval_pow, |
| Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one] using |
| iterate_magnitude 9 3 stoppedTick_safe (3*B+1) (initialState c v base).encode (3*B+1) le_rfl |
| have hh:=run_until stoppedTickProgram stopProgram 9 3 stoppedTick_safe |
| (by intro u hu; change stopExpr.eval u=0 at hu; simp [stoppedTick,(stop_zero u).mp hu]) |
| (initialState c v base).encode (3*B+1) |
| (by rw [he]; change stopExpr.eval _=0; exact (stop_zero _).mpr rfl) |
| simpa only [he,unboundedControl] using hh |
|
|
| def prepareUnbounded (v : List ℕ) : List ℕ := |
| [(r 2).eval v,(r 4).eval v,0,2]++v.drop 5 |
| def prepareUnboundedProgram : PolyProgram prepareUnbounded := |
| (r 2).program.cons ((r 4).program.cons ((c 0).program.cons ((c 2).program.cons (PolyProgram.drop 5)))) |
| def unboundedOutput : Code := untilCode outputStepProgram PolyProgram.head |
| lemma unboundedOutput_run {h p w} (ho : ListRep h p w) (B : ℕ) (hw : w.length≤B) : |
| Runs unboundedOutput (OutputState.mk p h []).encode (OutputState.mk 0 h w.reverse).encode |
| ((untilBound outputStepProgram PolyProgram.head 4 1).eval |
| (magnitude (B::(OutputState.mk p h []).encode))) := by |
| have he := ho.output_padded [] hw |
| simp only [List.append_nil] at he |
| have hh:=run_until outputStepProgram PolyProgram.head 4 1 outputStep_safe |
| (by intro u hu; change u.headI=0 at hu; simp [outputStep,hu]) |
| (OutputState.mk p h []).encode B |
| (by rw [he]; rfl) |
| simpa only [he,unboundedOutput] using hh |
|
|
| def unboundedWordsCode : Code := |
| .comp reversePrefixProgram.code |
| (.comp (PolyProgram.drop 2).code |
| (.comp unboundedOutput (.comp prepareUnboundedProgram.code unboundedControl))) |
|
|
| end |
|
|
| open Turing.ToPartrec Polynomial |
| noncomputable section |
|
|
| def unboundedControllerInput : Polynomial ℕ := 3*X+2 |
| def unboundedControllerState : Polynomial ℕ := (untilStateBound 9 3).comp unboundedControllerInput |
| def unboundedPrepared : Polynomial ℕ := prepareUnboundedProgram.bound.comp unboundedControllerState |
| def unboundedOutputInput : Polynomial ℕ := X+unboundedPrepared+1 |
| def unboundedOutputState : Polynomial ℕ := (untilStateBound 4 1).comp unboundedOutputInput |
| def unboundedDropped : Polynomial ℕ := (PolyProgram.drop 2).bound.comp unboundedOutputState |
| def unboundedWordsBound : Polynomial ℕ := |
| (untilBound stoppedTickProgram stopProgram 9 3).comp unboundedControllerInput+ |
| unboundedPrepared+(untilBound outputStepProgram PolyProgram.head 4 1).comp unboundedOutputInput+ |
| unboundedDropped+reversePrefixProgram.bound.comp unboundedDropped+4 |
|
|
| lemma unboundedWords_run {c v w B} (hr : Runs c v w B) (hl : w.length≤B) (base : Heap) : |
| ∃h,Runs unboundedWordsCode (initialState c v base).encode (w++w.reverse++2::words h) |
| (unboundedWordsBound.eval (magnitude (B::(initialState c v base).encode))) ∧ |
| magnitude (w++w.reverse++2::words h)≤ |
| unboundedWordsBound.eval (magnitude (B::(initialState c v base).encode)) := by |
| let M:=magnitude (B::(initialState c v base).encode) |
| have hci : magnitude ((3*B+1)::(initialState c v base).encode)≤unboundedControllerInput.eval M := by |
| simp only [unboundedControllerInput,eval_add,eval_mul,eval_X,eval_ofNat,M,magnitude_cons] |
| omega |
| obtain ⟨h,out,ho,hm0,hr0⟩:=unboundedControl_run hr base |
| have hm : magnitude (State.mk 2 0 out 0 h).encode≤unboundedControllerState.eval M := |
| by simpa only [unboundedControllerState,eval_comp] using hm0.trans (evalNat_mono _ hci) |
| have hc := hr0.mono (evalNat_mono _ hci) |
| have hp := (prepareUnboundedProgram.run (State.mk 2 0 out 0 h).encode).mono (evalNat_mono _ hm) |
| have hps := (prepareUnboundedProgram.size (State.mk 2 0 out 0 h).encode).trans (evalNat_mono _ hm) |
| have hprep : prepareUnbounded (State.mk 2 0 out 0 h).encode=(OutputState.mk out h []).encode := by |
| simp only [prepareUnbounded,State.encode,OutputState.encode,Expr.eval,List.cons_append, |
| List.nil_append,List.drop_succ_cons,List.drop_zero,List.headI_cons] |
| rfl |
| rw [hprep] at hp hps |
| have hp' : Runs prepareUnboundedProgram.code (State.mk 2 0 out 0 h).encode (OutputState.mk out h []).encode (unboundedPrepared.eval M) := by |
| simpa only [unboundedPrepared,eval_comp] using hp |
| have hps' : magnitude (OutputState.mk out h []).encode≤unboundedPrepared.eval M := by |
| simpa only [unboundedPrepared,eval_comp] using hps |
| have hB : B≤M := by simp only [M,magnitude_cons]; omega |
| have hoi : magnitude (B::(OutputState.mk out h []).encode)≤unboundedOutputInput.eval M := by |
| simp only [unboundedOutputInput,eval_add,eval_X,eval_one,magnitude_cons] |
| omega |
| have hout := (unboundedOutput_run ho B hl).mono (evalNat_mono _ hoi) |
| have hes := ho.output_padded [] hl |
| simp only [List.append_nil] at hes |
| have hos : magnitude (OutputState.mk 0 h w.reverse).encode≤unboundedOutputState.eval M := by |
| have hh := iterate_magnitude 4 1 outputStep_safe B (OutputState.mk out h []).encode B le_rfl |
| rw [hes] at hh |
| have hh' : magnitude (OutputState.mk 0 h w.reverse).encode≤ |
| (untilStateBound 4 1).eval (magnitude (B::(OutputState.mk out h []).encode)) := by |
| simpa only [untilStateBound,eval_mul,eval_C,eval_pow,eval_add,eval_X,eval_one] using hh |
| simpa only [unboundedOutputState,eval_comp] using hh'.trans (evalNat_mono _ hoi) |
| have hd := ((PolyProgram.drop 2).run (OutputState.mk 0 h w.reverse).encode).mono (evalNat_mono _ hos) |
| have hds := ((PolyProgram.drop 2).size (OutputState.mk 0 h w.reverse).encode).trans (evalNat_mono _ hos) |
| have hv := (reversePrefixProgram.run ((OutputState.mk 0 h w.reverse).encode.drop 2)).mono (evalNat_mono _ hds) |
| have hvs := (reversePrefixProgram.size ((OutputState.mk 0 h w.reverse).encode.drop 2)).trans (evalNat_mono _ hds) |
| have he : (prefixStep^[((OutputState.mk 0 h w.reverse).encode.drop 2).headI] |
| (0::((OutputState.mk 0 h w.reverse).encode.drop 2).tail)).tail=w++w.reverse++2::words h := by |
| change (prefixStep^[w.reverse.length] (0::(w.reverse++2::words h))).tail=_ |
| rw [reversePrefix_spec,List.reverse_reverse] |
| rw [he] at hv hvs |
| dsimp only [M] at * |
| refine ⟨h,?_,?_⟩ |
| · apply (run_comp (run_comp (run_comp (run_comp hc hp') hout) hd) hv).mono |
| simp only [unboundedWordsBound,eval_add,eval_comp,eval_ofNat,unboundedPrepared, |
| unboundedDropped,unboundedControllerState,unboundedOutputState] |
| omega |
| · apply hvs.trans |
| simp only [unboundedWordsBound,unboundedPrepared,unboundedDropped,unboundedControllerState, |
| unboundedOutputState,eval_add,eval_comp,eval_ofNat] |
| omega |
| end |
| end MinUncut.Costed.Arena |
|
|
| end OAI |
|
|
