import Mathlib
import OAI.Computability.Interspersed.Rules

namespace OAI

/-! Finite scans and simulation of individual work instructions. -/

noncomputable section
open scoped ContDiff
namespace PrefixFlows
namespace Interspersed
variable {Q A : Type*} {H : Set Q}
inductive Exec (δ : Q → A → Q × A × Move) : ℕ → Config Q A H → Config Q A H → Prop
  | zero (c) : Exec δ 0 c c
  | succ {n c d e} : Step δ c d → Exec δ n d e → Exec δ (n + 1) c e

 

theorem right_scan (δ : Q → A → Q × A × Move) (q : Q) (a : A)
    (gs : List (Record Q A H)) (L R : Stack (Symbol Q A H)) :
    Exec δ (gs.length + 1)
      (.scanRight q, L, prepend (gs.map Sum.inr) (push (.inl a) R))
      (.main q .right, prepend (gs.reverse.map Sum.inr) L, push (.inl a) R) := by
  induction gs generalizing L with
  | nil =>
    exact Exec.succ (Step.of_branch δ (.rightWork q a) L R) (Exec.zero _)
  | cons g gs ih =>
    have h := Exec.succ
      (Step.of_branch δ (.rightRecord q g) L (prepend (gs.map Sum.inr) (push (.inl a) R)))
      (ih (push (.inr g) L))
    simpa [source, target, List.reverse_cons, prepend_append] using h

 

theorem left_scan (δ : Q → A → Q × A × Move) (q : Q) (a : A)
    (gs : List (Record Q A H)) (L R : Stack (Symbol Q A H)) :
    Exec δ (gs.length + 1)
      (.scanLeft q, prepend (gs.map Sum.inr) (push (.inl a) L), R)
      (.main q .left, L, push (.inl a) (prepend (gs.reverse.map Sum.inr) R)) := by
  induction gs generalizing R with
  | nil =>
    exact Exec.succ (Step.of_branch δ (.leftWork q a) L R) (Exec.zero _)
  | cons g gs ih =>
    have h := Exec.succ
      (Step.of_branch δ (.leftRecord q g) (prepend (gs.map Sum.inr) (push (.inl a) L)) R)
      (ih (push (.inr g) R))
    simpa [source, target, List.reverse_cons, prepend_append] using h

 
theorem main_stay (δ : Q → A → Q × A × Move) (q : {q : Q // q ∉ H})
    (h : Move) (a b : A) (q' : Q) (hd : δ q a = (q', b, .stay))
    (L R : Stack (Symbol Q A H)) :
    Exec δ 1 (.main q h, L, push (.inl a) R)
      (.main q' .stay, push (.inr (q, h, a)) L, push (.inl b) R) := by
  have hs := Step.of_branch δ (.main q h a) L R
  simp only [source, target, hd] at hs
  exact Exec.succ hs (Exec.zero _)

 

theorem main_right (δ : Q → A → Q × A × Move) (q : {q : Q // q ∉ H})
    (h : Move) (a b c : A) (q' : Q) (hd : δ q a = (q', b, .right))
    (gs : List (Record Q A H)) (L R : Stack (Symbol Q A H)) :
    Exec δ (gs.length + 2)
      (.main q h, L, push (.inl a) (prepend (gs.map Sum.inr) (push (.inl c) R)))
      (.main q' .right,
        prepend (gs.reverse.map Sum.inr) (push (.inl b) (push (.inr (q, h, a)) L)),
        push (.inl c) R) := by
  have hs := Step.of_branch δ (.main q h a) L
    (prepend (gs.map Sum.inr) (push (.inl c) R))
  simp only [source, target, hd] at hs
  exact Exec.succ hs (right_scan δ q' c gs (push (.inl b) (push (.inr (q, h, a)) L)) R)

 

theorem main_left (δ : Q → A → Q × A × Move) (q : {q : Q // q ∉ H})
    (h : Move) (a b c : A) (q' : Q) (hd : δ q a = (q', b, .left))
    (gs : List (Record Q A H)) (L R : Stack (Symbol Q A H)) :
    Exec δ (gs.length + 2)
      (.main q h, prepend (gs.map Sum.inr) (push (.inl c) L), push (.inl a) R)
      (.main q' .left, L,
        push (.inl c) (prepend (gs.reverse.map Sum.inr) (push (.inl b) (push (.inr (q, h, a)) R)))) := by
  have hs := Step.of_branch δ (.main q h a)
    (prepend (gs.map Sum.inr) (push (.inl c) L)) R
  simp only [source, target, hd] at hs
  exact Exec.succ hs (left_scan δ q' c gs L (push (.inl b) (push (.inr (q, h, a)) R)))
end Interspersed
end PrefixFlows
end

end OAI