import OAI.Computability.SpaceSimulation.StackMachine

namespace OAI

/-! Renamings / framing extra stacks, and presence of extra RO arguments. -/

namespace Fifths
variable {X J K L Y : Type}
namespace StChange
noncomputable def pad (e : K ↪ L) (s : StChange J K) : StChange J L :=
  ⟨s.advance, Function.extend e s.ops (fun _ => .keep)⟩
end StChange

namespace Store
noncomputable def pad (e : K ↪ L) (d : L → List Bool) (s : Store J K) : Store J L :=
  ⟨s.ro, Function.extend e s.st d⟩

@[simp] theorem pad_st (e : K ↪ L) (d) (s : Store J K) (k) :
    (s.pad e d).st (e k) = s.st k :=
  e.injective.extend_apply ..
theorem pad_st' (e : K ↪ L) (d) (s : Store J K) (l)
    (h : ¬∃ k, e k = l) : (s.pad e d).st l = d l :=
  Function.extend_apply' _ _ _ h

theorem pad_perform (e : K ↪ L) (d) (s : Store J K) (i : Inputs X J)
    (m : StChange J K) :
    (s.pad e d).perform i (m.pad e) = (s.perform i m).pad e d := by
  classical
  dsimp only [pad, perform, StChange.pad]
  congr 1
  funext l
  by_cases h : ∃ k, e k = l
  · obtain ⟨k,rfl⟩ := h
    rw [e.injective.extend_apply, e.injective.extend_apply, e.injective.extend_apply]
  · rw [Function.extend_apply' _ _ _ h,
        Function.extend_apply' _ _ _ h, Function.extend_apply' _ _ _ h]
    rfl
theorem pad_ok {e : K ↪ L} {d} {s : Store J K} {B} (o : s.ok B)
    (p : ∀ l : L, (d l).length ≤ B) : (s.pad e d).ok B := by
  classical
  intro l
  by_cases h : ∃ k, e k = l
  · obtain ⟨k,rfl⟩ := h
    rw [pad_st]; exact o k
  · rw [pad_st' _ _ _ _ h]; exact p l
end Store

namespace SM
section Pads
variable (M : SM X J K Y) (e : K ↪ L)

noncomputable def pad : SM X J L Y where
  Q := M.Q
  start := M.start
  table := fun q r t =>
    match M.table q r (t ∘ e) with
    | .inl y => .inl y
    | .inr c => .inr (.withState (c.toStChange.pad e) c.next)

noncomputable def padCfg (d : L → List Bool) (w : M.Cfg) : (M.pad e).Cfg :=
  (w.1, w.2.pad e d)

theorem pad_step (i : Inputs X J) (w : M.Cfg) (d : L → List Bool) :
    (M.pad e).step i (M.padCfg e d w) =
      match M.step i w with
      | Sum.inl y => Sum.inl y
      | Sum.inr s => Sum.inr (M.padCfg e d s) := by
  dsimp only [step, padCfg, pad]
  have a : (w.2.pad e d).ro = w.2.ro := rfl
  have b : (w.2.pad e d).see ∘ e = w.2.see := by
    funext k; simp [Store.see]
  rw [a,b]
  cases M.table w.1 (w.2.ro.see i) w.2.see with
  | inl => rfl
  | inr => simp only [SAction.withState, Store.pad_perform]

theorem pad_run {d : L → List Bool} {i : Inputs X J} {s t : M.Cfg} {B y}
    (r : M.Run i B s t y) (p : ∀ l : L, (d l).length ≤ B) :
    (M.pad e).Run i B (M.padCfg e d s) (M.padCfg e d t) y := by
  induction r with
  | stop o a => exact .stop (Store.pad_ok o p) (by rw [pad_step, a])
  | step o a _ ih => exact .step (Store.pad_ok o p) (by rw [pad_step, a]) ih

theorem pad_exec {d : L → List Bool} {i : Inputs X J} {s t : Store J K} {B y}
    (r : M.Exec i B s t y) (p : ∀ l : L, (d l).length ≤ B) :
    (M.pad e).Exec i B (s.pad e d) (t.pad e d) y := by
  obtain ⟨q,r⟩ := r
  exact ⟨q, M.pad_run e r p⟩
end Pads

section Args
variable (M : SM X Empty K Y)

/-- Preserve a program that never reads any arg tapes. -/
def withArgs (J : Type) : SM X J K Y where
  Q := M.Q
  start := M.start
  table := fun q r t =>
    match M.table q ⟨r.sx, Empty.elim⟩ t with
    | .inl y => .inl y
    | .inr c => .inr (.withState ⟨{dx := c.advance.dx}, c.ops⟩ c.next)

def storeArgs {J : Type} (p : J → ℕ) (s : Store Empty K) : Store J K :=
  ⟨⟨s.ro.px,p⟩, s.st⟩

def argsCfg {J : Type} (p : J → ℕ) (s : M.Cfg) : (M.withArgs J).Cfg :=
  (s.1, storeArgs p s.2)

theorem args_step (i : Inputs X J) (w : M.Cfg) (p : J → ℕ) :
    (M.withArgs J).step i (M.argsCfg p w) =
      match M.step ⟨i.publicWord, Empty.elim⟩ w with
      | Sum.inl y => Sum.inl y
      | Sum.inr s => Sum.inr (M.argsCfg p s) := by
  dsimp only [step, argsCfg, withArgs]
  have a :
      (Reads.mk ((storeArgs p w.2).ro.see i).sx Empty.elim : Reads X Empty) =
        w.2.ro.see ⟨i.publicWord, Empty.elim⟩ := by
    dsimp only [Readers.see, storeArgs]
    congr
    exact Subsingleton.elim _ _
  rw [a, show (storeArgs p w.2).see = w.2.see from rfl]
  cases M.table w.1 (w.2.ro.see ⟨i.publicWord, Empty.elim⟩) w.2.see <;> rfl

theorem args_exec {i : Inputs X J} {s t : Store Empty K} {B y}
    (p : J → ℕ) (r : M.Exec ⟨i.publicWord, Empty.elim⟩ B s t y) :
    (M.withArgs J).Exec i B (storeArgs p s) (storeArgs p t) y := by
  have h : ∀ y v w, M.Run ⟨i.publicWord, Empty.elim⟩ B v w y →
      (M.withArgs J).Run i B (M.argsCfg p v) (M.argsCfg p w) y := by
    intro y v w r
    induction r with
    | stop o a => exact .stop o (by rw [args_step, a])
    | step o a _ ih => exact .step o (by rw [args_step, a]) ih
  obtain ⟨q,r⟩ := r
  exact ⟨q, h _ _ _ r⟩
end Args
end SM
end Fifths

end OAI