lean/OAI/Computability/MatchingCount/FiniteStack.lean

import OAI.Combinatorics.PerfectMatching.Model

namespace OAI

section

namespace BinaryMatching.StackCode

abbrev Store (r : ℕ) := Fin r → List Bool

inductive Instr (r : ℕ) (L : Type)
  | go : L → Instr r L
  | push : Fin r → Bool → L → Instr r L
  | pop : Fin r → L → Instr r L
  | branch : Fin r → L → L → L → Instr r L

namespace Instr
variable {r : ℕ} {L L' : Type}

def map (f : L → L') : Instr r L → Instr r L'
  | .go q => .go (f q)
  | .push k b q => .push k b (f q)
  | .pop k q => .pop k (f q)
  | .branch k e z o => .branch k (f e) (f z) (f o)

def eval : Instr r L → Store r → L × Store r
  | .go q,s => (q,s)
  | .push k b q,s => (q,Function.update s k (b::s k))
  | .pop k q,s => (q,Function.update s k (s k).tail)
  | .branch k e z o,s => ((s k).head?.elim e (fun b => if b then o else z),s)

@[simp] theorem eval_map (f : L → L') (i : Instr r L) (s : Store r) :
    (i.map f).eval s = (f (i.eval s).1,(i.eval s).2) := by
  cases i <;> simp only [map,eval]
  rename_i k e z o
  cases h : (s k).head? with
  | none => rfl
  | some b => cases b <;> rfl

abbrev Stmt (r : ℕ) (L : Type) := Turing.TM2.Stmt (fun _ : Fin r => Bool) L (Option Bool)

def target (q : Option L) : Stmt r L :=
  .load (fun _ => none) (q.elim .halt (fun l => .goto (fun _ => l)))

def translate : Instr r (Option L) → Stmt r L
  | .go q => target q
  | .push k b q => .push k (fun _ => b) (target q)
  | .pop k q => .pop k (fun _ _ => none) (target q)
  | .branch k e z o => .peek k (fun _ h => h)
      (.branch Option.isNone (target e) (.branch (fun h => h.getD false) (target o) (target z)))

@[simp] theorem target_step (q : Option L) (v : Option Bool) (s : Store r) :
    Turing.TM2.stepAux (target q) v s = ⟨q,none,s⟩ := by cases q <;> rfl

@[simp] theorem translate_step (i : Instr r (Option L)) (v : Option Bool) (s : Store r) :
    Turing.TM2.stepAux i.translate v s = ⟨(i.eval s).1,none,(i.eval s).2⟩ := by
  cases i with
  | go q => exact target_step q v s
  | push k b q => simp only [translate,Turing.TM2.stepAux,target_step,eval]
  | pop k q => simp only [translate,Turing.TM2.stepAux,target_step,eval]
  | branch k e z o =>
    simp only [translate,Turing.TM2.stepAux,target_step,eval]
    cases h : (s k).head? with
    | none => rfl
    | some b => cases b <;> rfl
end Instr

structure Block (r : ℕ) where
  Label : Type
  finite : Fintype Label
  entry : Label
  code : Label → Instr r (Option Label)

attribute [instance] Block.finite

inductive Steps {r : ℕ} {L : Type} (code : L → Instr r (Option L)) :
    Option L → Store r → Option L → Store r → ℕ → Prop
  | refl (q s) : Steps code q s q s 0
  | next (q s q' s' t)
      (rest : Steps code ((code q).eval s).1 ((code q).eval s).2 q' s' t) :
      Steps code (some q) s q' s' (t+1)

namespace Steps
variable {r : ℕ} {L L' : Type} {code : L → Instr r (Option L)}

theorem trans {q s q' s' q'' s'' t u}
    (h : Steps code q s q' s' t) (h' : Steps code q' s' q'' s'' u) :
    Steps code q s q'' s'' (t+u) := by
  induction h with
  | refl => simpa using h'
  | next q s q' s' t h ih => simpa [Nat.add_right_comm] using Steps.next q s _ _ _ (ih h')

theorem map (code' : L' → Instr r (Option L')) (f : L → L') (last : Option L')
    (hcode : ∀ l, code' (f l)=(code l).map (fun q => q.elim last (some ∘ f)))
    {q s q' s' t} (h : Steps code q s q' s' t) :
    Steps code' (q.elim last (some ∘ f)) s (q'.elim last (some ∘ f)) s' t := by
  induction h with
  | refl => exact .refl _ _
  | next q s q' s' t h ih =>
    apply Steps.next
    simpa only [hcode,Instr.eval_map] using ih

abbrev cfg (q : Option L) (s : Store r) :
    Turing.TM2.Cfg (fun _ : Fin r => Bool) L (Option Bool) := ⟨q,none,s⟩

theorem simulation {q s q' s' t} (h : Steps code q s q' s' t) :
    (fun o => o.bind (Turing.TM2.step (fun l => (code l).translate)))^[t]
      (some (cfg q s)) = some (cfg q' s') := by
  induction h with
  | refl => rfl
  | next q s q' s' t h ih =>
    rw [Function.iterate_succ_apply]
    simpa only [Option.bind_some,Turing.TM2.step,Instr.translate_step] using ih
end Steps

namespace Block
variable {r : ℕ}

def primitive (i : Instr r Unit) : Block r where
  Label := Unit
  finite := inferInstance
  entry := ()
  code _ := i.map (fun _ => none)

def seq (a b : Block r) : Block r where
  Label := a.Label ⊕ b.Label
  finite := inferInstance
  entry := .inl a.entry
  code := fun l => match l with
    | .inl q => (a.code q).map (fun t => t.elim (some (.inr b.entry)) (fun u => some (.inl u)))
    | .inr q => (b.code q).map (Option.map Sum.inr)

def cases (k : Fin r) (e z o : Block r) : Block r where
  Label := Unit ⊕ (e.Label ⊕ (z.Label ⊕ o.Label))
  finite := inferInstance
  entry := .inl ()
  code := fun l => match l with
    | .inl _ => .branch k (some (.inr (.inl e.entry)))
        (some (.inr (.inr (.inl z.entry)))) (some (.inr (.inr (.inr o.entry))))
    | .inr (.inl q) => (e.code q).map (Option.map (Sum.inr ∘ Sum.inl))
    | .inr (.inr (.inl q)) => (z.code q).map (Option.map (Sum.inr ∘ Sum.inr ∘ Sum.inl))
    | .inr (.inr (.inr q)) => (o.code q).map (Option.map (Sum.inr ∘ Sum.inr ∘ Sum.inr))

def loop (k : Fin r) (b : Block r) : Block r where
  Label := Unit ⊕ b.Label
  finite := inferInstance
  entry := .inl ()
  code := fun l => match l with
    | .inl _ => .branch k none (some (.inr b.entry)) (some (.inr b.entry))
    | .inr q => (b.code q).map (fun t => t.elim (some (.inl ())) (fun u => some (.inr u)))

abbrev Runs (b : Block r) (s s' : Store r) (t : ℕ) : Prop :=
  Steps b.code (some b.entry) s none s' t

theorem primitive_runs (i : Instr r Unit) (s : Store r) :
    (primitive i).Runs s (i.eval s).2 1 := by
  apply Steps.next
  simp only [primitive,Instr.eval_map]
  exact .refl _ _

theorem seq_runs (a b : Block r) {s s' s'' : Store r} {t u : ℕ}
    (ha : a.Runs s s' t) (hb : b.Runs s' s'' u) : (a.seq b).Runs s s'' (t+u) := by
  have h₁ := ha.map (a.seq b).code Sum.inl (some (Sum.inr b.entry)) (fun _ => rfl)
  have h₂ := hb.map (a.seq b).code Sum.inr none (by
    intro l
    change (b.code l).map _ = (b.code l).map _
    congr 1
    funext t
    cases t <;> rfl)
  exact h₁.trans h₂

def machine (b : Block r) (input output : Fin r) : Turing.FinTM2 where
  K := Fin r
  k₀ := input
  k₁ := output
  Γ _ := Bool
  Λ := b.Label
  main := b.entry
  σ := Option Bool
  initialState := none
  m l := (b.code l).translate

theorem machine_finite (b : Block r) (input output : Fin r) (k : (b.machine input output).K) :
    Finite ((b.machine input output).Γ k) := by
  change Finite Bool
  infer_instance

def machine_runs (b : Block r) (input output : Fin r) (s s' : List Bool) {t : ℕ}
    (h : b.Runs (Function.update (fun _ => []) input s)
      (Function.update (fun _ => []) output s') t) :
    Turing.TM2OutputsInTime (b.machine input output) s (some s') t := by
  refine ⟨⟨t,?_⟩,le_rfl⟩
  have hini : Turing.initList (b.machine input output) s =
      Steps.cfg (some b.entry) (Function.update (fun _ => []) input s) := by
    simp only [Turing.initList,machine,Steps.cfg]
    congr 1
    funext k
    by_cases hk : k=input
    · subst k; rfl
    · simp [Function.update,hk]
  have hout : Turing.haltList (b.machine input output) s' =
      Steps.cfg none (Function.update (fun _ => []) output s') := by
    simp only [Turing.haltList,machine,Steps.cfg]
    congr 1
    funext k
    by_cases hk : k=output
    · subst k; rfl
    · simp [Function.update,hk]
  change (fun o => o.bind (Turing.TM2.step (fun l => (b.code l).translate)))^[t]
    (some (Turing.initList (b.machine input output) s)) =
    some (Turing.haltList (b.machine input output) s')
  rw [hini,hout]
  exact h.simulation
end Block
end BinaryMatching.StackCode
end

end OAI