| import OAI.Computability.SpaceSimulation.Machine |
|
|
| namespace OAI |
|
|
| /-! The computation to be simulated. Coordinates on each source |
| are relative to its head's fixed origin, on two-sided tapes. Tags |
| may be correlated however one likes (same tape read, etc.). |
| Single alphabet, with no loss of different read-only components from |
| a fixed common alphabet. -/ |
| namespace Fifths |
|
|
| structure SingleAct (Q A : Type) (r : ℕ) where |
| out : Q |
| write : WriteMove A |
| others : Fin r → Dir |
|
|
| structure Single (X : Type) where |
| Q : Type |
| [states : Fintype Q] |
| A : Type |
| [symbols : Fintype A] |
| beginState : Q |
| halted : Q → Bool |
| heads : ℕ |
| program : Q → A → (Fin heads → A) → SingleAct Q A heads |
| / |
| sensor : List X → Option (Fin heads) → ℤ → A |
|
|
| attribute [instance] Single.states Single.symbols |
|
|
| namespace Single |
| variable {X : Type} (M : Single X) |
| instance : Nonempty M.A := ⟨M.sensor [] none 0⟩ |
| instance : Nonempty M.Q := ⟨M.beginState⟩ |
| abbrev Tag := Option (Fin M.heads) |
|
|
| structure At where |
| state : M.Q |
| tape : Tape M.A |
| ro : Fin M.heads → ℤ |
|
|
| def move (q : M.Q) (s : M.A) (r : Fin M.heads → M.A) : |
| SingleAct M.Q M.A M.heads := |
| if M.halted q then |
| ⟨q,⟨s,.N⟩,fun _ => .N⟩ |
| else M.program q s r |
|
|
| def initial (x : List X) : M.At := |
| ⟨M.beginState,⟨0,M.sensor x none⟩, fun _ => 0⟩ |
|
|
| def next (x : List X) (s : M.At) : M.At := |
| let t := M.move s.state s.tape.see (fun i => M.sensor x (some i) (s.ro i)) |
| ⟨t.out,s.tape.perform t.write,fun i => s.ro i + (t.others i).delta⟩ |
|
|
| def atTime (M : Single X) (x : List X) : ℕ → M.At := |
| Nat.rec (M.initial x) (fun _ s => M.next x s) |
|
|
| abbrev Outcome := M.Q × Bool |
| / |
| def finish (q : M.Q) : M.Outcome := |
| (q, M.halted q) |
| def outcome (x : List X) (n : ℕ) : M.Outcome := |
| M.finish (M.atTime x n).state |
|
|
| theorem immobile (x : List X) {s : M.At} (h : M.halted s.state = true) : |
| M.next x s = s := by |
| simp [next, move,h,Tape.perform,Tape.see] |
|
|
| theorem absorbed (x : List X) {n : ℕ} (p : (M.outcome x n).2 = true) (d : ℕ) : |
| M.atTime x (n+d) = M.atTime x n := by |
| change M.halted _ = true at p |
| induction d with |
| | zero => rfl |
| | succ d ih => |
| rw [← Nat.add_assoc] |
| change M.next x (M.atTime x (n+d)) = M.atTime x n |
| rw [ih,M.immobile x p] |
|
|
| def Inside (t : ℕ) (q : ℤ) : Prop := -(t:ℤ) ≤ q ∧ q ≤ (t:ℤ) |
| theorem inches {t : ℕ} {q : ℤ} (h : Inside t q) (v : Dir) : |
| Inside (t+1) (q+v.delta) := by |
| have := v.bounds |
| unfold Inside at * |
| omega |
| theorem nearby (x : List X) (n : ℕ) : |
| Inside n (M.atTime x n).tape.pos ∧ ∀ i, Inside n ((M.atTime x n).ro i) := by |
| induction n with |
| | zero => |
| simp [Inside,atTime,initial] |
| | succ n ih => |
| rw [atTime] |
| exact ⟨inches ih.1 _,fun i => inches (ih.2 i) _⟩ |
| end Single |
| end Fifths |
|
|
| end OAI |
|
|
