| import Mathlib |
| import OAI.Computability.MinUncut.Estimates.CodeContinuations |
|
|
| namespace OAI |
|
|
| section |
| namespace MinUncut.Costed.Arena |
|
|
| def keepTick (v : List ℕ) : List ℕ := v.headI::rawTick v.tail |
| noncomputable def keepTickProgram : PolyProgram keepTick := |
| PolyProgram.head.cons (tickProgram.comp PolyProgram.tail) |
|
|
| lemma keepTick_safe (v : List ℕ) : |
| (keepTick v).length≤v.length+10 ∧ maximum (keepTick v)≤ maximum v+3 := by |
| have hh := rawTick_safe v.tail |
| have ht : v.tail=v.drop 1 := (List.drop_one (l := v)).symm |
| have hm := maximum_drop v 1 |
| have hl : v.tail.length≤v.length := by cases v <;> simp |
| have he := head_le_maximum v |
| rw [←ht] at hm |
| simp only [keepTick,List.length_cons,maximum_cons] |
| constructor |
| · omega |
| · exact max_le (by omega) (by omega) |
|
|
| lemma keepTick_iter (B i : ℕ) (v : List ℕ) : |
| keepTick^[i] (B::v)=B::rawTick^[i] v := by |
| induction i with |
| | zero => rfl |
| | succ i ih => rw [Function.iterate_succ_apply',ih]; |
| change B::rawTick (rawTick^[i] v)=_; rw [Function.iterate_succ_apply'] |
|
|
| def control (v : List ℕ) : List ℕ := keepTick^[3*v.headI+1] v |
| noncomputable def controlProgram : PolyProgram control := |
| (PolyProgram.safeIterate keepTickProgram 10 3 keepTick_safe).comp |
| ((Expr.add (.mul (c 3) (r 0)) (c 1)).program.cons PolyProgram.id) |
|
|
| lemma outputStep_safe (v : List ℕ) : |
| (outputStep v).length≤v.length+4 ∧ maximum (outputStep v)≤ maximum v+1 := by |
| have hr (j : Fin 4) : (outRead j).eval v≤ maximum v := by |
| change (v.drop _).headI≤_ |
| exact (head_le_maximum _).trans (maximum_drop v _) |
| have h1 := reg_le_maximum v 1 |
| have h2 := reg_le_maximum v 2 |
| have h0 := hr 0 |
| have h3 := hr 1 |
| have ht := maximum_drop v 3 |
| simp only [outputStep] |
| split_ifs |
| · constructor <;> omega |
| · simp only [List.cons_append,List.nil_append,List.length_cons,List.length_drop,maximum_cons] |
| constructor |
| · omega |
| · exact max_le (by omega) (max_le (by omega) (max_le (by omega) (max_le (by omega) (by omega)))) |
|
|
| noncomputable def outputLoopProgram : PolyProgram (fun v=>outputStep^[v.headI] v.tail) := |
| PolyProgram.safeIterate outputStepProgram 4 1 outputStep_safe |
|
|
| def prepareOutput (v : List ℕ) : List ℕ := |
| [v.headI,(r 3).eval v,(r 5).eval v,0,2]++v.drop 6 |
| noncomputable def prepareOutputProgram : PolyProgram prepareOutput := |
| PolyProgram.head.cons ((r 3).program.cons ((r 5).program.cons |
| ((c 0).program.cons ((c 2).program.cons (PolyProgram.drop 6))))) |
|
|
| def universalRaw (v : List ℕ) : List ℕ := |
| let z := prepareOutput (control v) |
| (outputStep^[z.headI] z.tail).drop 3 |
|
|
| noncomputable def universalProgram : PolyProgram universalRaw := |
| (PolyProgram.drop 3).comp (outputLoopProgram.comp (prepareOutputProgram.comp controlProgram)) |
|
|
| lemma universalRaw_spec {c v w B} (hr : Runs c v w B) (hl : w.length≤B) (base : Heap) : |
| ∃h,universalRaw (B::(initialState c v base).encode)=w.reverse++2::words h := by |
| obtain ⟨t,ht,hc⟩ := hr |
| obtain ⟨h,out,ho,he⟩ := CodeRun.interpreted hc base ht |
| refine ⟨h,?_⟩ |
| have hh : control (B::(initialState c v base).encode)=B::(State.mk 2 0 out 0 h).encode := by |
| simpa only [control,List.headI_cons,keepTick_iter] using congrArg (List.cons B) he |
| simp only [universalRaw,hh] |
| have hp : prepareOutput (B::(State.mk 2 0 out 0 h).encode)=B::(OutputState.mk out h []).encode := rfl |
| rw [hp] |
| simp only [List.headI_cons,List.tail_cons] |
| rw [ho.output_padded [] hl] |
| simp only [List.append_nil,OutputState.encode,List.cons_append,List.nil_append] |
| rfl |
|
|
| end MinUncut.Costed.Arena |
|
|
| end |
|
|
| end OAI |
|
|
