import Mathlib

namespace OAI

/-! Finite transition tables and two-sided machine executions. -/

noncomputable section
open scoped ContDiff
namespace PrefixFlows
inductive Move where
  | stay | right | left
  deriving DecidableEq, Repr

def Move.displacement : Move → ℤ
  | .stay => 0
  | .right => 1
  | .left => -1

def Move.code : Move → ℕ
  | .stay => 0
  | .right => 1
  | .left => 2

structure Instruction where
  nextState : ℕ
  writeSymbol : ℕ
  motion : Move
  deriving DecidableEq, Repr

 

structure Machine where
  alphabetSize : ℕ
  blank : ℕ
  initialState : ℕ
  haltStates : List ℕ
  table : List (List (Option Instruction))
  deriving DecidableEq, Repr

namespace Machine

def WellFormed (M : Machine) : Prop :=
  0 < M.alphabetSize ∧ M.blank < M.alphabetSize ∧
  M.initialState < M.table.length ∧
  (∀ q ∈ M.haltStates, q < M.table.length) ∧
  (∀ row ∈ M.table, row.length = M.alphabetSize ∧
    ∀ instruction ∈ row, ∀ a, instruction = some a →
      a.nextState < M.table.length ∧ a.writeSymbol < M.alphabetSize)

def ValidInput (M : Machine) (w : List ℕ) : Prop :=
  ∀ a ∈ w, a < M.alphabetSize

 
def code (M : Machine) : ℕ :=
  Encodable.encode (M.alphabetSize, M.blank, M.initialState, M.haltStates,
    M.table.map (List.map (Option.map fun a =>
      (a.nextState, a.writeSymbol, a.motion.code))))

def instruction (M : Machine) (q a : ℕ) : Option Instruction :=
  (M.table[q]?).bind fun row => (row[a]?).join

structure Configuration where
  state : ℕ
  head : ℤ
  tape : ℤ → ℕ

 

def initial (M : Machine) (w : List ℕ) : Configuration where
  state := M.initialState
  head := 0
  tape := fun j => if 0 ≤ j then (w[j.toNat]?).getD M.blank else M.blank

def step (M : Machine) (c : Configuration) : Option Configuration :=
  if c.state ∈ M.haltStates then none else
    (M.instruction c.state (c.tape c.head)).map fun a =>
      { state := a.nextState
        head := c.head + a.motion.displacement
        tape := Function.update c.tape c.head a.writeSymbol }

def run (M : Machine) (w : List ℕ) : ℕ → Option Configuration
  | 0 => some (M.initial w)
  | n + 1 => (M.run w n).bind M.step

 
def Halts (M : Machine) (w : List ℕ) : Prop :=
  ∃ n c, M.run w n = some c ∧ M.step c = none

end Machine
end PrefixFlows
end

end OAI