| import Mathlib |
| import OAI.Computability.MinUncut.Graphs.SelectedGraphEndpoint |
| import OAI.Computability.MinUncut.Encoding.DecodedGraphCore |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace MinUncut.Uniform |
| open MinUncut.Preprocess MinUncut.Costed MinUncut.Costed.Arena |
| open _root_.Turing _root_.OAI.Turing Turing.ToPartrec _root_.Turing.PartrecToTM2 _root_.OAI.Turing.PartrecToTM2 Polynomial |
| open MinUncutGames MinUncutGames.BinaryEncoding MinUncutGames.Foundations.Complexity |
|
|
| attribute [local irreducible] selectedInner selectedOuter program |
|
|
| lemma initializer_exists : ∃c : Code,∀K,∃p : Polynomial ℕ,∀xs n table k junk, |
| (MinUncut.Costed.SourceWords.completeGraphWords (selectedParameters K) (chosenEnumeration K) |
| (chosenRepetition K) (chosenNoise K)) xs=n::((table : List Bool).map Bool.toNat++2::k::junk) → |
| Nonempty (TM2OutputsInTime (initializedGraphMachine c) |
| (trList (K::(encodeWords xs).map FrameDecode.symbol)) |
| (some (nameBits n++table++nameBits k)) (p.eval (encodeWords xs).length)) := |
| by |
| have hh := exists_graph_initializer program program_computable |
| exact hh |
|
|
| def initializerCode : Code := Classical.choose initializer_exists |
| def initializerTime (K : ℕ) : Polynomial ℕ := Classical.choose (Classical.choose_spec initializer_exists K) |
| def initializer_outputs (K : ℕ) (F : BinaryFormula.Formula) : |
| TM2OutputsInTime (initializedGraphMachine initializerCode) |
| (trList (K::(formulaBits (frontend F).val).map FrameDecode.symbol)) |
| (some (output K F).bits) ((initializerTime K).eval (formulaBits (frontend F).val).length) := by |
| apply Classical.choice |
| obtain ⟨table,junk,hj,hbits⟩:=output_words K F |
| have hh:=Classical.choose_spec (Classical.choose_spec initializer_exists K) |
| (formulaWords (frontend F).val) (output K F).vertices table (output K F).threshold junk hj |
| rw [←hbits] at hh |
| exact hh |
|
|
| attribute [local irreducible] frontend output initializerCode initializerTime |
|
|
| def coreMachine : FinTM2 := |
| decodedMachine initializerCode |
| lemma core_finite (k : coreMachine.K) : Finite (coreMachine.Γ k) := |
| decodedMachine_finite _ k |
|
|
| def coreTime (K : ℕ) : Polynomial ℕ := |
| initializerTime K+C (2*(nameBits K).length+3*(K+1)+4)+C 11*X |
|
|
| def core_outputs (K : ℕ) (F : BinaryFormula.Formula) : |
| TM2OutputsInTime coreMachine (nameBits K++formulaBits (frontend F).val) |
| (some (output K F).bits) ((coreTime K).eval (formulaBits (frontend F).val).length) := by |
| have hh:=decoded_outputs initializerCode K (formulaBits (frontend F).val) (output K F).bits |
| ((initializerTime K).eval (formulaBits (frontend F).val).length) (initializer_outputs K F) |
| refine ⟨hh.toEvalsTo,hh.steps_le_m.trans ?_⟩ |
| simp only [coreTime,eval_add,eval_C,eval_mul,eval_X] |
| omega |
| end MinUncut.Uniform |
|
|
| end |
| end |
| section |
| noncomputable section |
| namespace MinUncut.Costed.Framed |
| open _root_.Turing _root_.OAI.Turing MinUncutGames.Foundations.Complexity |
| variable (M : FinTM2) (ei : M.Γ M.k₀ ≃ Bool) (eo : M.Γ M.k₁ ≃ Bool) |
| abbrev Tape := M.K ⊕ Unit |
| abbrev Alphabet : Tape M → Type := MachineEmbedding.Alphabet M.Γ (fun _ : Unit=>Bool) |
| abbrev Label := M.Λ ⊕ Option Bool |
| abbrev State := M.σ × Option Bool |
|
|
| def extra : Option Bool → TM2.Stmt (Alphabet M) (Label M) (State M) |
| | none => .pop (.inl M.k₀) (fun s a=>(s.1,a.map ei)) |
| (.push (.inr ()) (fun s=>s.2.getD false) |
| (.branch (fun s=>s.2.getD false) |
| (.load (fun s=>(s.1,none)) (.goto fun _=>.inr (some false))) |
| (.load (fun s=>(s.1,none)) (.goto fun _=>.inl M.main)))) |
| | some false => .pop (.inl M.k₀) (fun s a=>(s.1,a.map ei)) |
| (.push (.inr ()) (fun s=>s.2.getD false) |
| (.load (fun s=>(s.1,none)) (.goto fun _=>.inr none))) |
| | some true => .pop (.inr ()) (fun s a=>(s.1,a)) |
| (.branch (fun s=>s.2.isSome) |
| (.push (.inl M.k₁) (fun s=>eo.symm (s.2.getD false)) |
| (.load (fun s=>(s.1,none)) (.goto fun _=>.inr (some true)))) |
| (.load (fun s=>(s.1,none)) .halt)) |
| def program : Label M → TM2.Stmt (Alphabet M) (Label M) (State M) := |
| MachineEmbedding.program (some (.inr (some true))) M.m (extra M ei eo) |
| def machine : FinTM2 where |
| K := Tape M |
| kFin := by letI:=M.kFin; exact inferInstanceAs (Fintype (M.K ⊕ Unit)) |
| k₀ := .inl M.k₀ |
| k₁ := .inl M.k₁ |
| Γ := Alphabet M |
| Γk₀Fin := M.Γk₀Fin |
| Λ := Label M |
| ΛFin := by letI:=M.ΛFin; exact inferInstanceAs (Fintype (M.Λ ⊕ Option Bool)) |
| main := .inr none |
| σ := State M |
| σFin := by letI:=M.σFin; exact inferInstanceAs (Fintype (M.σ × Option Bool)) |
| initialState := (M.initialState,none) |
| m := program M ei eo |
| lemma finiteAlphabet (hm : MachineFiniteAlphabet.FiniteAlphabet M) |
| (k : (machine M ei eo).K) : Finite ((machine M ei eo).Γ k) := by |
| cases k with |
| | inl k => exact hm k |
| | inr k => exact inferInstanceAs (Finite Bool) |
|
|
| def readTapes (v acc : List Bool) : ∀k,List (Alphabet M k) := |
| MachineEmbedding.tapes (initList M (v.map ei.symm)).stk (fun _=>acc) |
| def readCfg (label : Option Bool) (v acc : List Bool) : (machine M ei eo).Cfg := |
| ⟨some (.inr label),(M.initialState,none),readTapes M ei v acc⟩ |
| def embedded (acc : List Bool) (c : M.Cfg) : (machine M ei eo).Cfg := |
| MachineEmbedding.configuration (some (.inr (some true))) none (fun _ : Unit=>acc) c |
| lemma read_input (v acc : List Bool) : (readTapes M ei v acc) (.inl M.k₀)=v.map ei.symm := by |
| simp [readTapes,initList] |
| lemma read_extra (v acc : List Bool) : (readTapes M ei v acc) (.inr ())=acc := rfl |
| lemma read_put_input (v acc w : List Bool) : |
| Function.update (readTapes M ei v acc) (.inl M.k₀) (w.map ei.symm)=readTapes M ei w acc := by |
| funext k |
| cases k with |
| | inl k => |
| by_cases h:k=M.k₀ |
| · subst k; simp [readTapes,initList] |
| · simp [readTapes,initList,Function.update,h] |
| | inr k => simp [readTapes,Function.update] |
| lemma read_put_extra (v acc w : List Bool) : |
| Function.update (readTapes M ei v acc) (.inr ()) w=readTapes M ei v w := by |
| funext k |
| cases k with |
| | inl k => simp [readTapes,Function.update] |
| | inr k => cases k; simp [readTapes] |
| lemma read_step (b : Bool) (v acc : List Bool) : |
| (machine M ei eo).step (readCfg M ei eo none (b::v) acc)= |
| some (if b then readCfg M ei eo (some false) v (b::acc) |
| else embedded M ei eo (b::acc) (initList M (v.map ei.symm))) := by |
| change some (TM2.stepAux (extra M ei eo none) (M.initialState,none) (readTapes M ei (b::v) acc))=_ |
| cases b <;> simp only [extra,TM2.stepAux,read_input,List.map_cons,List.head?_cons,Option.map_some, |
| Equiv.apply_symm_apply,Option.getD_some,List.tail_cons, |
| Bool.cond_false,Bool.cond_true,Bool.false_eq_true,ite_false,ite_true] |
| all_goals |
| congr 2 |
| funext k |
| cases k with |
| | inl k => |
| by_cases h:k=M.k₀ |
| · subst k; simp [readTapes,initList] |
| · simp [readTapes,initList,Function.update,h] |
| | inr k => cases k; simp [readTapes,Function.update] |
| lemma payload_step (b : Bool) (v acc : List Bool) : |
| (machine M ei eo).step (readCfg M ei eo (some false) (b::v) acc)= |
| some (readCfg M ei eo none v (b::acc)) := by |
| change some (TM2.stepAux (extra M ei eo (some false)) (M.initialState,none) (readTapes M ei (b::v) acc))=_ |
| simp only [extra,TM2.stepAux,read_input,List.map_cons,List.head?_cons,Option.map_some, |
| Equiv.apply_symm_apply,Option.getD_some,List.tail_cons] |
| congr 2 |
| funext k |
| cases k with |
| | inl k => |
| by_cases h:k=M.k₀ |
| · subst k; simp [readTapes,initList] |
| · simp [readTapes,initList,Function.update,h] |
| | inr k => cases k; simp [readTapes,Function.update] |
| open MinUncutGames.BinaryEncoding |
| lemma read_frames (bits v acc : List Bool) : |
| Steps (machine M ei eo).step (frame bits).length |
| (readCfg M ei eo none (frame bits++v) acc) |
| (embedded M ei eo ((frame bits).reverse++acc) (initList M (v.map ei.symm))) := by |
| induction bits generalizing acc with |
| | nil => exact steps_one (read_step M ei eo false v acc) |
| | cons b bits ih => |
| have h1 := steps_one (read_step M ei eo true (b::(frame bits++v)) acc) |
| have h2 := steps_one (payload_step M ei eo b (frame bits++v) (true::acc)) |
| have hh := steps_trans (steps_trans h1 h2) (ih (b::true::acc)) |
| simpa only [frame,List.cons_append,List.length_cons,List.reverse_cons,List.append_assoc, |
| List.singleton_append,List.nil_append,Nat.add_comm,Nat.add_left_comm,Nat.add_assoc] using hh |
| lemma read_init (v : List Bool) : |
| readCfg M ei eo none v []=initList (machine M ei eo) (v.map ei.symm) := by |
| change TM2.Cfg.mk _ _ _=TM2.Cfg.mk _ _ _ |
| congr 1 |
| funext k |
| cases k with |
| | inl k => |
| by_cases h:k=M.k₀ <;> simp [readTapes,initList,h,machine] |
| rfl |
| | inr k => simp [readTapes,initList,machine] |
| lemma finish_step (b : Bool) (w acc : List Bool) : |
| (machine M ei eo).step (embedded M ei eo (b::acc) (haltList M (w.map eo.symm)))= |
| some (embedded M ei eo acc (haltList M ((b::w).map eo.symm))) := by |
| change some (TM2.stepAux (extra M ei eo (some true)) (M.initialState,none) |
| (MachineEmbedding.tapes (haltList M (w.map eo.symm)).stk (fun _ : Unit=>b::acc)))=_ |
| simp only [extra,TM2.stepAux,MachineEmbedding.tapes_inr,List.head?_cons,List.tail_cons, |
| Option.isSome_some,Bool.cond_true,Option.getD_some] |
| congr 2 |
| funext k |
| cases k with |
| | inl k => |
| by_cases h:k=M.k₁ |
| · subst k; simp [haltList,Function.update] |
| · simp [haltList,Function.update,h] |
| | inr k => cases k; simp [haltList,Function.update] |
| lemma finish_empty (w : List Bool) : |
| (machine M ei eo).step (embedded M ei eo [] (haltList M (w.map eo.symm)))= |
| some (haltList (machine M ei eo) (w.map eo.symm)) := by |
| change some (TM2.stepAux (extra M ei eo (some true)) (M.initialState,none) |
| (MachineEmbedding.tapes (haltList M (w.map eo.symm)).stk (fun _ : Unit=>[])))=_ |
| simp only [extra,TM2.stepAux,MachineEmbedding.tapes_inr,List.head?_nil,List.tail_nil, |
| Option.isSome_none,Bool.cond_false] |
| congr 2 |
| funext k |
| cases k with |
| | inl k => |
| by_cases h:k=M.k₁ |
| · subst k |
| simp [haltList,Function.update,machine] |
| rfl |
| · simp [haltList,Function.update,h,machine] |
| | inr k => cases k; simp [Function.update,machine] |
| lemma finish_steps (w acc : List Bool) : |
| Steps (machine M ei eo).step (acc.length+1) |
| (embedded M ei eo acc (haltList M (w.map eo.symm))) |
| (haltList (machine M ei eo) ((acc.reverse++w).map eo.symm)) := by |
| induction acc generalizing w with |
| | nil => exact steps_one (finish_empty M ei eo w) |
| | cons b acc ih => |
| have hh:=steps_head (finish_step M ei eo b w acc) (ih (b::w)) |
| simpa only [List.length_cons,List.reverse_cons,List.append_assoc,List.singleton_append] using hh |
|
|
| def execute (K : ℕ) (v w : List Bool) (B : ℕ) |
| (h : TM2OutputsInTime M (v.map ei.symm) (some (w.map eo.symm)) B) : |
| TM2OutputsInTime (machine M ei eo) ((nameBits K++v).map ei.symm) |
| (some ((nameBits K++w).map eo.symm)) (B+2*(nameBits K).length+1) := by |
| have hr := steps_timed (read_frames M ei eo K.bits v []) le_rfl |
| simp only [List.append_nil,read_init] at hr |
| let hm := MachineComposition.embeddedExecution (some (.inr (some true))) none |
| (fun _ : Unit=>(nameBits K).reverse) M.m (extra M ei eo) h |
| have hf := steps_timed (finish_steps M ei eo w (nameBits K).reverse) le_rfl |
| simp only [List.length_reverse,List.reverse_reverse] at hf |
| let hh := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ hr hm |
| let hh' := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ hh hf |
| exact ⟨hh'.toEvalsTo,by have hb:=hh'.steps_le_m; change _≤B+2*(nameBits K).length+1; simp only [nameBits] at hb ⊢; omega⟩ |
| end MinUncut.Costed.Framed |
| |
| end |
| end |
| |
| end OAI |
| |
