| import Mathlib |
| import OAI.Computability.MinUncut.Machines.MachineSubstitution |
| import OAI.Computability.MinUncut.Estimates.TM2Costed |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace MinUncut.Costed |
| open _root_.Turing _root_.OAI.Turing _root_.Turing.PartrecToTM2 _root_.OAI.Turing.PartrecToTM2 Turing.ToPartrec |
| noncomputable section |
|
|
| local instance : Fintype K' := ⟨{.main,.rev,.aux,.stack}, by intro k; cases k <;> simp⟩ |
| |
| def codeMachine (c : Code) : FinTM2 where |
| K := K' |
| k₀ := .main |
| k₁ := .main |
| Γ _ := Γ' |
| Λ := codeSupp c .halt |
| main := ⟨trNormal c .halt,codeSupp_self c .halt (trStmts₁_self _)⟩ |
| σ := Option Γ' |
| initialState := none |
| m := FiniteControl.program (codeSupp c .halt) tr |
| (fun _ h => codeSupp_supports (Finset.Subset.refl _) _ h) |
|
|
| lemma codeMachine_finiteAlphabet (c : Code) (k : (codeMachine c).K) : |
| Finite ((codeMachine c).Γ k) := inferInstanceAs (Finite Γ') |
|
|
| lemma codeMachine_init (c : Code) (v : List ℕ) : |
| FiniteControl.project (codeSupp c .halt) (initList (codeMachine c) (trList v))= |
| ⟨some (trNormal c .halt),none,K'.elim (trList v) [] [] []⟩ := by |
| change TM2.Cfg.mk _ _ _=TM2.Cfg.mk _ _ _ |
| congr 1 |
| funext k |
| cases k <;> rfl |
| |
| lemma codeMachine_halt (c : Code) (v : List ℕ) : |
| FiniteControl.project (codeSupp c .halt) (haltList (codeMachine c) (trList v))= |
| ⟨none,none,K'.elim (trList v) [] [] []⟩ := by |
| change TM2.Cfg.mk _ _ _=TM2.Cfg.mk _ _ _ |
| congr 1 |
| funext k |
| cases k <;> rfl |
| |
| def CodeRun.finiteMachine {c v w t} (h : CodeRun c v w t) : |
| TM2OutputsInTime (codeMachine c) (trList v) (some (trList w)) (t+1) := by |
| apply Classical.choice |
| obtain ⟨s,ht⟩ := h.compiled .halt none [] |
| have he : Within (TM2.step tr) (t+1) |
| ⟨some (trNormal c .halt),none,K'.elim (trList v) [] [] []⟩ |
| ⟨none,none,K'.elim (trList w) [] [] []⟩ := |
| ht.trans (within_one rfl) |
| obtain ⟨n,hn,hsteps⟩ := he |
| have hi := FiniteControl.projected_iterate (codeMachine c).step (TM2.step tr) |
| (FiniteControl.project (codeSupp c .halt)) |
| (FiniteControl.project_step _ _ (fun _ h => codeSupp_supports (Finset.Subset.refl _) _ h)) n (some (initList (codeMachine c) (trList v))) |
| have hs : Steps (codeMachine c).step n |
| (initList (codeMachine c) (trList v)) (haltList (codeMachine c) (trList w)) := by |
| apply Option.map_injective (FiniteControl.project_injective (codeSupp c .halt)) |
| dsimp only [Steps] at hsteps ⊢ |
| exact hi.trans ((congrArg |
| (fun cfg : Option (TM2.Cfg (fun _ : K' => Γ') Λ' (Option Γ')) => |
| (fun x => x.bind (TM2.step tr))^[n] cfg) |
| (congrArg some (codeMachine_init c v))).trans |
| (hsteps.trans (congrArg some (codeMachine_halt c w)).symm)) |
| exact ⟨steps_timed hs hn⟩ |
|
|
| end |
| end MinUncut.Costed |
|
|
| end |
| section |
| namespace MinUncut.Costed |
| open _root_.Turing _root_.OAI.Turing _root_.Turing.PartrecToTM2 _root_.OAI.Turing.PartrecToTM2 Turing.ToPartrec |
| open MinUncutGames.Foundations.Complexity |
| noncomputable section |
| namespace BooleanAdapter |
|
|
| def encodedWord (b : Bool) : List Γ' := if b then [.bit1,.cons] else [.cons] |
| def encodeMachine : FinTM2 := WordTransducer.machine () (fun (_ : Unit) (_ : Bool) => ()) |
| (fun _ b => encodedWord b) |
|
|
| lemma encode_output (v : List Bool) : |
| WordTransducer.output (fun (_ : Unit) (_ : Bool) => ()) (fun _ b => encodedWord b) () v= |
| trList (v.map Bool.toNat) := by |
| induction v with |
| | nil => rfl |
| | cons b v ih => |
| simp only [List.map_cons,trList,WordTransducer.output] |
| rw [ih] |
| cases b <;> rfl |
| |
| def next (q : Bool) : Γ' → Bool |
| | .bit1 => true |
| | .cons | .consₗ => false |
| | .bit0 => q |
|
|
| def emit (q : Bool) : Γ' → List Bool |
| | .cons => [q] |
| | _ => [] |
|
|
| def decodeMachine : FinTM2 := WordTransducer.machine false next emit |
|
|
| lemma decode_output (v : List Bool) : |
| WordTransducer.output next emit false (trList (v.map Bool.toNat))=v := by |
| induction v with |
| | nil => rfl |
| | cons b v ih => |
| cases b <;> simp [WordTransducer.output,next,emit,trList,trNat,trNum,trPosNum,ih] |
| |
| lemma trList_bool_length (v : List Bool) : |
| (trList (v.map Bool.toNat)).length≤2*v.length := by |
| induction v with |
| | nil => rfl |
| | cons b v ih => |
| cases b <;> simp [trList,trNat,trNum,trPosNum] <;> omega |
| |
| def encode_run (v : List Bool) : |
| TM2OutputsInTime encodeMachine v (some (trList (v.map Bool.toNat))) |
| (2*v.length+(trList (v.map Bool.toNat)).length+2) := by |
| have h := WordTransducer.outputsInTime () (fun (_ : Unit) (_ : Bool) => ()) (fun _ b => encodedWord b) v |
| erw [encode_output] at h |
| exact h |
|
|
| def decode_run (v : List Bool) : |
| TM2OutputsInTime decodeMachine (trList (v.map Bool.toNat)) (some v) |
| (2*(trList (v.map Bool.toNat)).length+v.length+2) := by |
| have h := WordTransducer.outputsInTime false next emit (trList (v.map Bool.toNat)) |
| erw [decode_output] at h |
| exact h |
|
|
| end BooleanAdapter |
| open BooleanAdapter |
|
|
| def booleanCodeMachine (c : Code) : FinTM2 := |
| MachineSequential.machine |
| (MachineSequential.machine encodeMachine (codeMachine c) id .cons) |
| decodeMachine id .cons |
|
|
| lemma sequential_finiteAlphabet (a b : FinTM2) (r : a.Γ a.k₁→b.Γ b.k₀) |
| (fallback : b.Γ b.k₀) (ha : ∀k,Finite (a.Γ k)) (hb : ∀k,Finite (b.Γ k)) |
| (k : (MachineSequential.machine a b r fallback).K) : |
| Finite ((MachineSequential.machine a b r fallback).Γ k) := by |
| rcases k with k | k |
| · exact ha k |
| · rcases k with k | k |
| · exact hb k |
| · exact hb b.k₀ |
|
|
| lemma booleanCodeMachine_finiteAlphabet (c : Code) (k : (booleanCodeMachine c).K) : |
| Finite ((booleanCodeMachine c).Γ k) := |
| sequential_finiteAlphabet _ _ _ _ |
| (sequential_finiteAlphabet _ _ _ _ |
| (WordTransducer.finiteAlphabet _ _ _) (codeMachine_finiteAlphabet c)) |
| (WordTransducer.finiteAlphabet _ _ _) k |
|
|
| def CodeRun.booleanMachine {c : Code} {v w : List Bool} {t : ℕ} |
| (h : CodeRun c (v.map Bool.toNat) (w.map Bool.toNat) t) : |
| TM2OutputsInTime (booleanCodeMachine c) v (some w) (t+8*v.length+9*w.length+9) := by |
| have h₁ := MachineSequential.execute encodeMachine (codeMachine c) id Γ'.cons v _ _ _ _ (encode_run v) (by erw [List.map_id]; exact h.finiteMachine) |
| have h₂ := MachineSequential.execute (MachineSequential.machine encodeMachine (codeMachine c) id .cons) |
| decodeMachine id Γ'.cons v _ _ _ _ h₁ (by erw [List.map_id]; exact decode_run w) |
| have hv := trList_bool_length v |
| have hw := trList_bool_length w |
| have bound : h₂.steps ≤ |
| (2 * v.length + (trList (v.map Bool.toNat)).length + 2) + |
| 2 * ((trList (v.map Bool.toNat)).length + 1) + (t + 1) + |
| 2 * ((trList (w.map Bool.toNat)).length + 1) + |
| (2 * (trList (w.map Bool.toNat)).length + w.length + 2) := h₂.steps_le_m |
| refine ⟨h₂.toEvalsTo, le_trans bound ?_⟩ |
| omega |
|
|
| end |
| end MinUncut.Costed |
|
|
| end |
|
|
| end OAI |
|
|
