| import OAI.Computability.WeisfeilerLeman.Turing |
|
|
| namespace OAI |
|
|
| universe uS uA |
|
|
| namespace WLTime.StackMachine |
|
|
| inductive Command (K a q : ℕ) where |
| | next (state : Fin q) |
| | push (stack : Fin K) (letter : Fin a) (state : Fin q) |
| | pop (stack : Fin K) (state : Fin q) |
| | halt (answer : Bool) |
|
|
| structure Machine where |
| count : ℕ |
| alphabet : ℕ |
| states : ℕ |
| count_pos : 0< count |
| alphabet_ge : 2 ≤ alphabet |
| initial : Fin states |
| transition : Fin states → (Fin count → Option (Fin alphabet)) → |
| Command count alphabet states |
|
|
| namespace Machine |
| variable (M : Machine) |
|
|
| structure Config where |
| state : Bool ⊕ Fin M.states |
| stack : Fin M.count → List (Fin M.alphabet) |
|
|
| def inputLetter (b : Bool) : Fin M.alphabet := ⟨if b then 1 else 0,by have := M.alphabet_ge; split <;> omega⟩ |
|
|
| def initialConfig (w : List Bool) : M.Config where |
| state := .inr M.initial |
| stack k := if k.val=0 then w.map M.inputLetter else [] |
|
|
| def perform (C : M.Config) (a : Command M.count M.alphabet M.states) : M.Config := match a with |
| | .next q => { C with state := .inr q } |
| | .push k x q => { state := .inr q,stack := Function.update C.stack k (x::C.stack k) } |
| | .pop k q => { state := .inr q,stack := Function.update C.stack k (C.stack k).tail } |
| | .halt b => {C with state := .inl b} |
|
|
| def step (C : M.Config) : M.Config := match C.state with |
| | .inl _ => C |
| | .inr q => M.perform C (M.transition q (fun k => (C.stack k).head?)) |
|
|
| def run (w : List Bool) (t : ℕ) : M.Config := M.step^[t] (M.initialConfig w) |
|
|
| def encodeLetter : Option (Fin M.alphabet) → Fin (M.alphabet+1) |
| | none => 0 |
| | some x => x.succ |
|
|
| def decodeLetter (x : Fin (M.alphabet+1)) : Option (Fin M.alphabet) := |
| Fin.cases none some x |
|
|
| @[simp] theorem decode_encode (x : Option (Fin M.alphabet)) : M.decodeLetter (M.encodeLetter x)=x := by |
| cases x <;> rfl |
|
|
| def contents (s : List (Fin M.alphabet)) (h z : ℤ) : Fin (M.alphabet+1) := |
| if z<h then 0 else M.encodeLetter s[(z-h).toNat]? |
|
|
| @[simp] theorem contents_empty (h z : ℤ) : M.contents [] h z=0 := by |
| simp only [contents,List.getElem?_nil,encodeLetter,ite_self] |
|
|
| @[simp] theorem contents_head (s : List (Fin M.alphabet)) (h : ℤ) : |
| M.contents s h h=M.encodeLetter s.head? := by |
| simp only [contents,lt_self_iff_false,ite_false,sub_self,Int.toNat_zero] |
| exact congrArg M.encodeLetter (List.head?_eq_getElem? (l:=s)).symm |
|
|
| theorem contents_push (s : List (Fin M.alphabet)) (h : ℤ) (x : Fin M.alphabet) : |
| M.contents (x::s) (h-1)=Function.update (M.contents s h) (h-1) x.succ := by |
| funext z |
| by_cases he : z=h-1 |
| · subst z |
| simp only [Function.update_self,contents_head,List.head?_cons,encodeLetter] |
| · rw [Function.update_of_ne he] |
| by_cases hz : z<h-1 |
| · have hz' : z<h := by omega |
| simp only [contents,ite_eq_left hz,ite_eq_left hz'] |
| · have hz' : ¬z<h := by omega |
| have hi : (z-(h-1)).toNat=(z-h).toNat+1 := by omega |
| simp only [contents,ite_eq_right hz,ite_eq_right hz',hi,List.getElem?_cons_succ] |
|
|
| theorem contents_pop (s : List (Fin M.alphabet)) (h : ℤ) : |
| M.contents s.tail (h+1)=Function.update (M.contents s h) h 0 := by |
| funext z |
| by_cases he : z=h |
| · subst z |
| simp only [Function.update_self,contents,ite_eq_left (show h<h+1 by omega)] |
| · rw [Function.update_of_ne he] |
| by_cases hz : z<h |
| · have hz' : z<h+1 := by omega |
| simp only [contents,ite_eq_left hz,ite_eq_left hz'] |
| · have hz' : ¬z<h+1 := by omega |
| have hi : (z-h).toNat=(z-(h+1)).toNat+1 := by omega |
| simp only [contents,ite_eq_right hz,ite_eq_right hz',List.getElem?_tail,hi] |
|
|
| abbrev Micro := Fin 3 ⊕ (Fin M.states ⊕ (Fin M.count × Fin M.alphabet × Fin M.states)) |
|
|
| noncomputable def microEquiv : M.Micro ≃ Fin (3+Fintype.card (Fin M.states ⊕ |
| (Fin M.count × Fin M.alphabet × Fin M.states))) := |
| (Equiv.sumCongr (Equiv.refl _) (Fintype.equivFin _)).trans finSumFinEquiv |
|
|
| @[simp] theorem micro_left (i : Fin 3) : (M.microEquiv (.inl i)).val=i.val := rfl |
|
|
| theorem micro_right_ge (v : Fin M.states ⊕ (Fin M.count × Fin M.alphabet × Fin M.states)) : |
| 3 ≤ (M.microEquiv (.inr v)).val := by |
| change 3 ≤ 3+(Fintype.equivFin _ v).val |
| omega |
|
|
| def microTransition (p : M.Micro) (read : Fin M.count → Fin (M.alphabet+1)) : |
| M.Micro × (Fin M.count → Fin (M.alphabet+1)) × (Fin M.count → Move) := match p with |
| | .inl i => ((if i.val=0 then .inr (.inl M.initial) else .inl i),read,fun _ => .stay) |
| | .inr (.inr (k,x,q)) => (.inr (.inl q),Function.update read k x.succ,fun _ => .stay) |
| | .inr (.inl q) => match M.transition q (fun k => M.decodeLetter (read k)) with |
| | .next q' => (.inr (.inl q'),read,fun _ => .stay) |
| | .push k x q' => (.inr (.inr (k,x,q')),read,Function.update (fun _ => .stay) k .left) |
| | .pop k q' => (.inr (.inl q'),Function.update read k 0,Function.update (fun _ => .stay) k .right) |
| | .halt b => (.inl (if b then 1 else 2),read,fun _ => .stay) |
|
|
| noncomputable abbrev compile : TM where |
| tapes := M.count |
| states := 3+Fintype.card (Fin M.states ⊕ (Fin M.count × Fin M.alphabet × Fin M.states)) |
| symbols := M.alphabet+1 |
| tapes_pos := M.count_pos |
| states_ge := by omega |
| symbols_ge := by have := M.alphabet_ge; omega |
| transition q read := let a := M.microTransition (M.microEquiv.symm q) read |
| (M.microEquiv a.1,a.2) |
|
|
| noncomputable def stateCode : Bool ⊕ Fin M.states → Fin M.compile.states |
| | .inl b => M.microEquiv (.inl (if b then 1 else 2)) |
| | .inr q => M.microEquiv (.inr (.inl q)) |
|
|
| noncomputable def embed (C : M.Config) (h : Fin M.count → ℤ) : M.compile.Config where |
| state := M.stateCode C.state |
| head := h |
| tape k := M.contents (C.stack k) (h k) |
|
|
| theorem embed_halted (C : M.Config) (h : Fin M.count → ℤ) : |
| M.compile.halted (M.embed C h) ↔ ∃ b,C.state=.inl b := by |
| unfold TM.halted embed stateCode |
| cases C.state with |
| | inl b => cases b <;> simp |
| | inr q => |
| have he := M.micro_right_ge (.inl q) |
| simp only [reduceCtorEq,exists_false,iff_false] |
| omega |
|
|
| def cost (a : Command M.count M.alphabet M.states) : ℕ := match a with |
| | .push _ _ _ => 2 |
| | _ => 1 |
|
|
| def moveHeads (h : Fin M.count → ℤ) (a : Command M.count M.alphabet M.states) : Fin M.count → ℤ := match a with |
| | .push k _ _ => Function.update h k (h k-1) |
| | .pop k _ => Function.update h k (h k+1) |
| | _ => h |
|
|
| theorem write_same (tape : Fin M.count → ℤ → Fin (M.alphabet+1)) (h : Fin M.count → ℤ) : |
| (fun k z => if z=h k then tape k (h k) else tape k z)=tape := by |
| funext k z |
| split <;> rename_i he |
| · exact congrArg (tape k) he.symm |
| · rfl |
|
|
| theorem write_one (tape : Fin M.count → ℤ → Fin (M.alphabet+1)) (h : Fin M.count → ℤ) |
| (k : Fin M.count) (x : Fin (M.alphabet+1)) : |
| (fun j z => if z=h j then (Function.update (fun i => tape i (h i)) k x) j else tape j z)= |
| Function.update tape k (Function.update (tape k) (h k) x) := by |
| funext j z |
| by_cases hj : j=k |
| · subst j |
| simp only [Function.update_self,Function.update_apply] |
| · simp only [Function.update_of_ne hj] |
| split <;> rename_i he |
| · exact congrArg (tape j) he.symm |
| · rfl |
|
|
| theorem step_micro (p : M.Micro) (hp : (M.microEquiv p).val≠1 ∧ (M.microEquiv p).val≠2) |
| (h : Fin M.count → ℤ) (tape : Fin M.count → ℤ → Fin (M.alphabet+1)) : |
| M.compile.step {state:=M.microEquiv p,head:=h,tape:=tape}= |
| let a := M.microTransition p (fun k => tape k (h k)) |
| {state:=M.microEquiv a.1,head:=fun k => h k+(a.2.2 k).displacement, |
| tape:=fun k z => if z=h k then a.2.1 k else tape k z} := by |
| have hh : ¬M.compile.halted {state:=M.microEquiv p,head:=h,tape:=tape} := by |
| exact fun he => he.elim hp.1 hp.2 |
| rw [TM.step,ite_eq_right hh] |
| simp only [compile,Equiv.symm_apply_apply] |
|
|
| theorem heads_one (h : Fin M.count → ℤ) (k : Fin M.count) (d : Move) : |
| (fun j => h j+(Function.update (fun _ => Move.stay) k d j).displacement)= |
| Function.update h k (h k+d.displacement) := by |
| funext j |
| by_cases hj : j=k |
| · subst j; simp |
| · simp [Function.update_of_ne hj,Move.displacement] |
|
|
| theorem tame_right (p : Fin M.states ⊕ (Fin M.count × Fin M.alphabet × Fin M.states)) : |
| (M.microEquiv (.inr p)).val≠1 ∧ (M.microEquiv (.inr p)).val≠2 := by |
| have := M.micro_right_ge p |
| omega |
|
|
| theorem simulate_action (s : Fin M.count → List (Fin M.alphabet)) (q : Fin M.states) |
| (h : Fin M.count → ℤ) (a : Command M.count M.alphabet M.states) |
| (ha : M.transition q (fun k => (s k).head?)=a) : |
| M.compile.step^[M.cost a] (M.embed ⟨.inr q,s⟩ h)= |
| M.embed (M.perform ⟨.inr q,s⟩ a) (M.moveHeads h a) := by |
| have read_eq : (fun k => M.decodeLetter (M.contents (s k) (h k) (h k)))= |
| (fun k => (s k).head?) := by |
| funext k |
| rw [M.contents_head,M.decode_encode] |
| cases a with |
| | next q' => |
| change M.compile.step (M.embed ⟨.inr q,s⟩ h)=_ |
| rw [embed,stateCode,M.step_micro _ (M.tame_right _) h] |
| simp only [microTransition,read_eq,ha,Move.displacement,add_zero,M.write_same, |
| perform,moveHeads,embed,stateCode] |
| | halt b => |
| change M.compile.step (M.embed ⟨.inr q,s⟩ h)=_ |
| rw [embed,stateCode,M.step_micro _ (M.tame_right _) h] |
| simp only [microTransition,read_eq,ha,Move.displacement,add_zero,M.write_same, |
| perform,moveHeads,embed,stateCode] |
| | pop k q' => |
| change M.compile.step (M.embed ⟨.inr q,s⟩ h)=_ |
| rw [embed,stateCode,M.step_micro _ (M.tame_right _) h] |
| simp only [microTransition,read_eq,ha,Move.displacement,M.write_one, |
| perform,moveHeads,embed,stateCode] |
| congr 1 |
| · funext j |
| by_cases hj : j=k <;> simp [hj] |
| · funext j |
| by_cases hj : j=k |
| · subst j |
| simp only [Function.update_self,M.contents_pop] |
| · simp only [Function.update_of_ne hj] |
| | push k x q' => |
| change M.compile.step (M.compile.step (M.embed ⟨.inr q,s⟩ h))=_ |
| rw [embed,stateCode,M.step_micro _ (M.tame_right _) h] |
| simp only [microTransition,read_eq,ha,Move.displacement,M.write_same] |
| rw [M.step_micro _ (M.tame_right _)] |
| simp only [microTransition,Move.displacement,add_zero,M.write_one, |
| perform,moveHeads,embed,stateCode] |
| congr 1 |
| · funext j |
| by_cases hj : j=k <;> simp [hj] |
| all_goals omega |
| · funext j |
| by_cases hj : j=k |
| · subst j |
| simp only [Function.update_self] |
| rw [show h k + (-1)=h k-1 by omega,← M.contents_push] |
| · simp only [Function.update_of_ne hj] |
| |
| theorem initial_tape (w : List Bool) : (M.compile.initial w).tape= |
| (fun k => M.contents ((M.initialConfig w).stack k) 0) := by |
| funext k z |
| by_cases hk : k.val=0 |
| · simp only [TM.initial,initialConfig,hk,ite_true,true_and,contents] |
| by_cases hz : z<0 |
| · have hz' : ¬0 ≤ z := by omega |
| simp only [ite_eq_left hz,hz',false_and,ite_false] |
| rfl |
| · have hz' : 0 ≤ z := by omega |
| simp only [ite_eq_right hz,hz',true_and,sub_zero,List.getElem?_map] |
| by_cases hi : z.toNat<w.length |
| · rw [ite_eq_left hi,List.getD_eq_getElem?_getD,List.getElem?_eq_getElem hi] |
| cases w[z.toNat] <;> rfl |
| · rw [ite_eq_right hi,List.getElem?_eq_none (by omega)] |
| rfl |
| · simp only [TM.initial,initialConfig,hk,false_and,ite_false,M.contents_empty] |
| rfl |
| |
| theorem initial_step (w : List Bool) : |
| M.compile.run w 1=M.embed (M.initialConfig w) (fun _ => 0) := by |
| have hi : M.compile.initial w = |
| { state := M.microEquiv (.inl 0) |
| head := fun _ => 0 |
| tape := fun k => M.contents ((M.initialConfig w).stack k) 0 } := by |
| rw [← M.initial_tape w] |
| rfl |
| change M.compile.step (M.compile.initial w)=_ |
| rw [hi,M.step_micro _ (by simp) _] |
| simp only [microTransition,Fin.val_zero,ite_true,Move.displacement,add_zero, |
| M.write_same,embed,stateCode,initialConfig] |
| |
| theorem simulate_step (C : M.Config) (h : Fin M.count → ℤ) : |
| ∃ t ≤ 2, ∃ h',M.compile.step^[t] (M.embed C h)=M.embed (M.step C) h' := by |
| rcases C with ⟨b|q,s⟩ |
| · exact ⟨0,by omega,h,rfl⟩ |
| · let a := M.transition q (fun k => (s k).head?) |
| refine ⟨M.cost a,?_,M.moveHeads h a,M.simulate_action s q h a rfl⟩ |
| cases a <;> simp [cost] |
| |
| theorem simulate_iterate (C : M.Config) (h : Fin M.count → ℤ) (t : ℕ) : |
| ∃ u ≤ 2*t, ∃ h',M.compile.step^[u] (M.embed C h)=M.embed (M.step^[t] C) h' := by |
| induction t with |
| | zero => exact ⟨0,by omega,h,rfl⟩ |
| | succ t ih => |
| obtain ⟨u,hu,h',he⟩ := ih |
| obtain ⟨v,hv,h'',hf⟩ := M.simulate_step (M.step^[t] C) h' |
| refine ⟨v+u,by omega,h'',?_⟩ |
| rw [Function.iterate_add_apply,he,hf,Function.iterate_succ_apply'] |
|
|
| theorem simulate_run (w : List Bool) (t : ℕ) : |
| ∃ u ≤ 2*t+1, ∃ h,M.compile.run w u=M.embed (M.run w t) h := by |
| obtain ⟨u,hu,h,he⟩ := M.simulate_iterate (M.initialConfig w) (fun _ => 0) t |
| refine ⟨u+1,by omega,h,?_⟩ |
| rw [TM.run_add,M.initial_step,he] |
| rfl |
|
|
| theorem compile_correct (w : List Bool) (t : ℕ) (b : Bool) |
| (hh : (M.run w t).state=.inl b) : |
| M.compile.halts w ∧ M.compile.time w ≤ 2*t+1 ∧ (M.compile.accepts w ↔ b=true) := by |
| obtain ⟨u,hu,h,he⟩ := M.simulate_run w t |
| have hx : M.compile.halted (M.compile.run w u) := by |
| rw [he,M.embed_halted] |
| exact ⟨b,hh⟩ |
| refine ⟨⟨u,hx⟩,(M.compile.time_le_of_halted w hx).trans hu,?_⟩ |
| rw [M.compile.accepts_iff_at_halt w hx,he] |
| simp only [embed,stateCode,hh] |
| cases b <;> simp |
|
|
| end Machine |
| end WLTime.StackMachine |
|
|
| namespace WLTime.TypedTape |
|
|
| abbrev State (S : Type uS) := Fin 3 ⊕ S |
| abbrev Symbol (A : Type uA) := Fin 3 ⊕ A |
|
|
| structure Machine (S : Type uS) (A : Type uA) where |
| transition : State S → Symbol A → State S × Symbol A × Move |
|
|
| structure Config (S : Type uS) (A : Type uA) where |
| state : State S |
| head : ℤ |
| tape : ℤ → Symbol A |
|
|
| namespace Machine |
| variable {S : Type uS} {A : Type uA} (M : Machine S A) |
|
|
| def halted (_M : Machine S A) (p : State S) : Prop := p = .inl 1 ∨ p = .inl 2 |
|
|
| instance (p : State S) : Decidable (M.halted p) := by |
| cases p with |
| | inl i => exact decidable_of_iff (i=1 ∨ i=2) (by simp [halted]) |
| | inr q => exact isFalse (by simp [halted]) |
|
|
| def action (p : State S) (x : Symbol A) : State S × Symbol A × Move := |
| if M.halted p then (p,x,.stay) else M.transition p x |
|
|
| def step (C : Config S A) : Config S A := |
| let a := M.action C.state (C.tape C.head) |
| { state := a.1 |
| head := C.head+a.2.2.displacement |
| tape := Function.update C.tape C.head a.2.1 } |
|
|
| def initial (_M : Machine S A) (w : List Bool) : Config S A where |
| state := .inl 0 |
| head := 0 |
| tape z := if 0 ≤ z ∧ z.toNat<w.length then |
| .inl (if w.getD z.toNat false then 2 else 1) else .inl 0 |
|
|
| def run (w : List Bool) (t : ℕ) := M.step^[t] (M.initial w) |
|
|
| theorem step_live (p : S) (z : ℤ) (tape : ℤ → Symbol A) |
| (q : State S) (x : Symbol A) (d : Move) |
| (h : M.transition (.inr p) (tape z)=(q,x,d)) : |
| M.step ⟨.inr p,z,tape⟩=⟨q,z+d.displacement,Function.update tape z x⟩ := by |
| simp only [step,action,halted,reduceCtorEq,or_self,ite_false,h] |
|
|
| theorem step_keep (p : S) (z : ℤ) (tape : ℤ → Symbol A) |
| (q : State S) (d : Move) |
| (h : M.transition (.inr p) (tape z)=(q,tape z,d)) : |
| M.step ⟨.inr p,z,tape⟩=⟨q,z+d.displacement,tape⟩ := by |
| rw [M.step_live p z tape q (tape z) d h] |
| congr 1 |
| exact Function.update_eq_self _ _ |
|
|
| theorem path_iterate (C : ℕ → Config S A) (n : ℕ) |
| (h : ∀ i<n,M.step (C i)=C (i+1)) : M.step^[n] (C 0)=C n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| rw [Function.iterate_succ_apply',ih (fun i hi => h i (by omega))] |
| exact h n (by omega) |
| |
| theorem concat {C D E : Config S A} {a b : ℕ} |
| (h : M.step^[a] C=D) (g : M.step^[b] D=E) : M.step^[a+b] C=E := by |
| rw [Nat.add_comm,Function.iterate_add_apply,h,g] |
| |
| variable [Fintype S] [Fintype A] |
| |
| noncomputable def stateEquiv (_M : Machine S A) : State S ≃ Fin (3+Fintype.card S) := |
| (Equiv.sumCongr (Equiv.refl _) (Fintype.equivFin S)).trans finSumFinEquiv |
| |
| noncomputable def symbolEquiv (_M : Machine S A) : Symbol A ≃ Fin (3+Fintype.card A) := |
| (Equiv.sumCongr (Equiv.refl _) (Fintype.equivFin A)).trans finSumFinEquiv |
| |
| omit [Fintype A] in |
| @[simp] theorem state_left (i : Fin 3) : (M.stateEquiv (.inl i)).val=i.val := rfl |
| omit [Fintype S] in |
| @[simp] theorem symbol_left (i : Fin 3) : (M.symbolEquiv (.inl i)).val=i.val := rfl |
| |
| omit [Fintype A] in |
| theorem state_halted (p : State S) : |
| ((M.stateEquiv p).val=1 ∨ (M.stateEquiv p).val=2) ↔ M.halted p := by |
| cases p with |
| | inl i => simp [halted,Fin.ext_iff] |
| | inr q => |
| have h : 3 ≤ (M.stateEquiv (.inr q)).val := by |
| change 3 ≤ 3+(Fintype.equivFin S q).val |
| omega |
| simp only [halted,reduceCtorEq,or_self,iff_false] |
| omega |
| |
| noncomputable abbrev compile : OneTape where |
| states := 3+Fintype.card S |
| symbols := 3+Fintype.card A |
| states_ge := by omega |
| symbols_ge := by omega |
| transition p x := let a := M.transition (M.stateEquiv.symm p) (M.symbolEquiv.symm x) |
| (M.stateEquiv a.1,M.symbolEquiv a.2.1,a.2.2) |
| |
| noncomputable def embed (C : Config S A) : M.compile.Config ℤ where |
| state := M.stateEquiv C.state |
| head := C.head |
| tape z := M.symbolEquiv (C.tape z) |
| |
| theorem compile_action (p : State S) (x : Symbol A) : |
| M.compile.action (M.stateEquiv p) (M.symbolEquiv x) = |
| (M.stateEquiv (M.action p x).1,M.symbolEquiv (M.action p x).2.1,(M.action p x).2.2) := by |
| simp only [OneTape.action,M.state_halted,action] |
| split_ifs <;> simp |
| |
| theorem embed_step (C : Config S A) : |
| M.embed (M.step C)=M.compile.step OneTape.lineShift (M.embed C) := by |
| simp only [embed,step,OneTape.step,M.compile_action,OneTape.moveAt_line] |
| congr 1 |
| funext z |
| simp only [Function.update_apply] |
| split <;> rfl |
| |
| theorem embed_initial (w : List Bool) : M.embed (M.initial w)=M.compile.initial w := by |
| unfold embed initial OneTape.initial |
| congr 1 |
| funext z |
| dsimp only |
| by_cases h : 0 ≤ z ∧ z.toNat<w.length |
| · simp [h,TM.symbol] |
| split_ifs <;> rfl |
| · simp [h] |
| rfl |
| |
| theorem embed_run (w : List Bool) (t : ℕ) : |
| M.embed (M.run w t)=M.compile.run OneTape.lineShift (M.compile.initial w) t := by |
| induction t with |
| | zero => exact M.embed_initial w |
| | succ t ih => |
| simp only [run,Function.iterate_succ_apply',OneTape.run] at * |
| rw [M.embed_step,ih] |
|
|
| end Machine |
| end WLTime.TypedTape |
|
|
| end OAI |
|
|
