lean/OAI/Computability/MeanPayoff/BitProgram.lean

import OAI.Computability.MeanPayoff.FiniteSuccess

namespace OAI

section

namespace MeanPayoff
namespace BinaryStack

inductive Op where
  | keep | pop | push (b : Bool)
  deriving DecidableEq, Fintype

structure Act (q : ℕ) where
  next : Fin q
  work : Fin 2 → Op
  emit : Option Bool

structure Program where
  states : ℕ
  start : Fin states
  transition : Fin states → (Fin 2 → Option Bool) → Bool → Option (Act states)

structure Config (P : Program) where
  control : Option (Fin P.states)
  stack : Fin 2 → List Bool
  output : List Bool

def applyOp : Op → List Bool → List Bool
  | .keep, xs => xs
  | .pop, xs => xs.tail
  | .push b, xs => b :: xs

def shiftOp : Op → List Bool → Direction
  | .keep, _ => .stay
  | .pop, [] => .stay
  | .pop, _ :: _ => .right
  | .push _, _ => .left

def firstWrite : Op → Symbol → Symbol
  | .pop, _ => none
  | _, a => a

def pendingWrite : Op → Option Bool
  | .push b => some b
  | _ => none

def step (P : Program) (c : Config P) (bit : Bool) : Config P :=
  match c.control with
  | none => c
  | some q =>
    match P.transition q (fun k => (c.stack k).head?) bit with
    | none => { c with control := none }
    | some a =>
      ⟨some a.next, fun k => applyOp (a.work k) (c.stack k),
        c.output ++ a.emit.toList⟩

def initial (P : Program) (code : List Bool) : Config P :=
  ⟨some P.start, fun k => if k = 0 then code else [], []⟩

def run (P : Program) (code : List Bool) (random : ℕ → Bool) : ℕ → Config P
  | 0 => initial P code
  | t + 1 => step P (run P code random t) (random t)

def cells (xs : List Bool) (h : ℤ) (j : ℤ) : Symbol :=
  if 0 ≤ j - h then xs[(j - h).toNat]? else none

@[simp] theorem cells_top (xs : List Bool) (h : ℤ) : cells xs h h = xs.head? := by
  cases xs <;> simp [cells]

@[simp] theorem cells_nil (h : ℤ) : cells [] h = fun _ => none := by
  funext j; simp [cells]

theorem cells_push (xs : List Bool) (b : Bool) (h : ℤ) :
    cells (b :: xs) (h - 1) = Function.update (cells xs h) (h - 1) (some b) := by
  funext j
  by_cases he : j = h - 1
  · subst j; simp [cells]
  · rw [Function.update_of_ne he]
    by_cases hj : h ≤ j
    · have hn : (j - (h - 1)).toNat = (j - h).toNat + 1 := by omega
      simp only [cells, show 0 ≤ j - (h - 1) by omega, show 0 ≤ j - h by omega,
        ↓reduceIte, hn, List.getElem?_cons_succ]
    · have hn : j < h - 1 := by omega
      simp only [cells, show ¬0 ≤ j - (h - 1) by omega, show ¬0 ≤ j - h by omega, ↓reduceIte]

theorem cells_pop (xs : List Bool) (b : Bool) (h : ℤ) :
    cells xs (h + 1) = Function.update (cells (b :: xs) h) h none := by
  funext j
  by_cases he : j = h
  · subst j; simp [cells]
  · rw [Function.update_of_ne he]
    by_cases hj : h < j
    · have hn : (j - h).toNat = (j - (h + 1)).toNat + 1 := by omega
      simp only [cells, show 0 ≤ j - (h + 1) by omega, show 0 ≤ j - h by omega,
        ↓reduceIte, hn, List.getElem?_cons_succ]
    · simp only [cells, show ¬0 ≤ j - (h + 1) by omega, show ¬0 ≤ j - h by omega, ↓reduceIte]

theorem cells_emit (xs : List Bool) (b : Bool) :
    cells (xs ++ [b]) 0 = Function.update (cells xs 0) (xs.length : ℤ) (some b) := by
  funext j
  by_cases he : j = xs.length
  · subst j; simp [cells]
  · rw [Function.update_of_ne he]
    by_cases hj : 0 ≤ j
    · simp only [cells, sub_zero, hj, ↓reduceIte]
      by_cases hk : j.toNat < xs.length
      · rw [List.getElem?_append_left hk]
      · have hg : xs.length < j.toNat := by omega
        simp only [List.getElem?_eq_none (by omega : xs.length ≤ j.toNat),
          List.getElem?_eq_none (by simp only [List.length_append, List.length_singleton]; omega :
            (xs ++ [b]).length ≤ j.toNat)]
    · simp only [cells, sub_zero, hj, ↓reduceIte]

abbrev Control (P : Program) := Fin P.states ⊕ (Fin P.states × (Fin 2 → Option Bool))

noncomputable def controlEquiv (P : Program) : Control P ≃ Fin (Fintype.card (Control P)) :=
  Fintype.equivFin _

noncomputable def normal (P : Program) (q : Fin P.states) : Fin (Fintype.card (Control P)) :=
  controlEquiv P (.inl q)

noncomputable def pending (P : Program) (q : Fin P.states) (w : Fin 2 → Option Bool) :
    Fin (Fintype.card (Control P)) := controlEquiv P (.inr (q, w))

noncomputable def machine (P : Program) : Machine where
  states := Fintype.card (Control P)
  start := normal P P.start
  transition q top bit :=
    match (controlEquiv P).symm q with
    | .inl q =>
      (P.transition q (fun k => top ⟨k.val, by omega⟩) bit).map fun a =>
        ⟨pending P a.next (fun k => pendingWrite (a.work k)),
          fun k => if hk : k.val < 2 then firstWrite (a.work ⟨k.val, hk⟩) (top k)
            else a.emit,
          fun k => if hk : k.val < 2 then
            match a.work ⟨k.val, hk⟩ with
            | .keep => .stay
            | .pop => if (top k).isSome then .right else .stay
            | .push _ => .left
          else if a.emit.isSome then .right else .stay⟩
    | .inr (q, w) =>
      some ⟨normal P q, fun k => if hk : k.val < 2 then
          (w ⟨k.val, hk⟩).or (top k) else top k,
        fun _ => .stay⟩

noncomputable def concrete (P : Program) (c : Config P) (h : Fin 2 → ℤ) : Configuration (machine P) where
  control := c.control.map (normal P)
  head k := if hk : k.val < 2 then h ⟨k.val, hk⟩ else c.output.length
  tape k := if hk : k.val < 2 then cells (c.stack ⟨k.val, hk⟩) (h ⟨k.val, hk⟩)
    else cells c.output 0

@[simp] theorem cells_end (xs : List Bool) : cells xs 0 (xs.length : ℤ) = none := by
  simp [cells]

theorem cells_applyOp (op : Op) (xs : List Bool) (h : ℤ) :
    let h' := h + (shiftOp op xs).offset
    let t := Function.update (cells xs h) h (firstWrite op xs.head?)
    Function.update t h' ((pendingWrite op).or (t h')) =
      cells (applyOp op xs) h' := by
  cases op with
  | keep => simp [shiftOp, Direction.offset, firstWrite, pendingWrite, applyOp]
  | pop =>
    cases xs with
    | nil => simp [shiftOp, Direction.offset, firstWrite, pendingWrite, applyOp]
    | cons b xs =>
      simp only [shiftOp, Direction.offset, firstWrite, pendingWrite, Option.none_or,
        Function.update_eq_self, applyOp, List.tail_cons]
      exact (cells_pop xs b h).symm
  | push b =>
    simp only [shiftOp, Direction.offset, firstWrite, pendingWrite,
      ← cells_top xs h, Function.update_eq_self, Option.some_or, applyOp]
    simpa only [sub_eq_add_neg] using (cells_push xs b h).symm

def newHeads {P : Program} (c : Config P) (h : Fin 2 → ℤ) (a : Act P.states) : Fin 2 → ℤ :=
  fun k => h k + (shiftOp (a.work k) (c.stack k)).offset

@[ext] theorem concrete_ext {M : Machine} {a b : Configuration M}
    (hc : a.control = b.control) (hh : a.head = b.head) (ht : a.tape = b.tape) : a = b := by
  cases a; cases b; simp_all

@[simp] theorem decode_normal (P : Program) (q : Fin P.states) :
    (controlEquiv P).symm (normal P q) = .inl q := by
  exact (controlEquiv P).symm_apply_apply _
@[simp] theorem decode_pending (P : Program) (q : Fin P.states) (w : Fin 2 → Option Bool) :
    (controlEquiv P).symm (pending P q w) = .inr (q,w) := by
  exact (controlEquiv P).symm_apply_apply _

@[simp] theorem shiftOp_formula (op : Op) (xs : List Bool) :
    (match op with
     | .keep => Direction.stay
     | .pop => if xs = [] then Direction.stay else Direction.right
     | .push _ => Direction.left) = shiftOp op xs := by
  cases op <;> cases xs <;> rfl

theorem double_step (P : Program) (c : Config P) (h : Fin 2 → ℤ) (b₁ b₂ : Bool) :
    ∃ h', MeanPayoff.step (machine P)
      (MeanPayoff.step (machine P) (concrete P c h) b₁) b₂ =
        concrete P (step P c b₁) h' := by
  rcases c with ⟨q, xs, out⟩
  cases q with
  | none => exact ⟨h, rfl⟩
  | some q =>
    let top : Fin 2 → Option Bool := fun k => (xs k).head?
    cases ha : P.transition q top b₁ with
    | none =>
      refine ⟨h, ?_⟩
      simp only [MeanPayoff.step, concrete, Option.map_some, machine, decode_normal]
      have ht : (fun k : Fin 2 =>
          (if hk : k.val < 2 then cells (xs ⟨k.val, hk⟩) (h ⟨k.val, hk⟩)
            else cells out 0)
          (if hk : k.val < 2 then h ⟨k.val, hk⟩ else out.length)) = top := by
        funext k
        simp only [Fin.isLt, ↓reduceDIte, Fin.eta, cells_top, top]
      simp only [ht, ha, Option.map_none]
      simp only [top] at ha
      simp only [step]
      rw [ha]
      rfl
    | some a =>
      refine ⟨newHeads ⟨some q, xs, out⟩ h a, ?_⟩

      simp only [MeanPayoff.step, concrete, Option.map_some, machine, decode_normal]
      have ht : (fun k : Fin 2 =>
          (if hk : k.val < 2 then cells (xs ⟨k.val, hk⟩) (h ⟨k.val, hk⟩)
            else cells out 0)
          (if hk : k.val < 2 then h ⟨k.val, hk⟩ else out.length)) = top := by
        funext k
        simp only [Fin.isLt, ↓reduceDIte, Fin.eta, cells_top, top]
      simp only [ht, ha, Option.map_some, decode_pending]
      simp only [top] at ha
      simp only [step]
      rw [ha]
      apply concrete_ext
      · rfl
      · funext k
        fin_cases k
        · simp [newHeads, Direction.offset]
        · simp [newHeads, Direction.offset]
        · cases he : a.emit <;> simp [Direction.offset, he]
      · funext k
        fin_cases k
        · simpa [newHeads] using cells_applyOp (a.work 0) (xs 0) (h 0)
        · simpa [newHeads] using cells_applyOp (a.work 1) (xs 1) (h 1)
        · cases he : a.emit with
          | none =>
            have hu : Function.update (cells out 0) (out.length : ℤ) none = cells out 0 := by
              simpa only [cells_end] using Function.update_eq_self (out.length : ℤ) (cells out 0)
            simp [he, hu]
          | some b => simpa [newHeads, he] using (cells_emit out b).symm

theorem concrete_initial (P : Program) (code : List Bool) :
    MeanPayoff.initial (machine P) code = concrete P (initial P code) (fun _ => 0) := by
  apply concrete_ext
  · rfl
  · funext k; fin_cases k <;> rfl
  · funext k j
    fin_cases k
    · simp [MeanPayoff.initial, concrete, initial, cells]
    · simp [MeanPayoff.initial, concrete, initial, cells]
    · simp [MeanPayoff.initial, concrete, initial]

theorem simulate (P : Program) (code : List Bool) (bits : ℕ → Bool) (t : ℕ) :
    ∃ h, MeanPayoff.run (machine P) code bits (2 * t) =
      concrete P (run P code (fun j => bits (2 * j)) t) h := by
  induction t with
  | zero => exact ⟨fun _ => 0, concrete_initial P code⟩
  | succ t ih =>
    obtain ⟨h, hh⟩ := ih
    rw [show 2 * (t + 1) = 2 * t + 1 + 1 by omega, MeanPayoff.run, MeanPayoff.run, hh]
    obtain ⟨h', he⟩ := double_step P (run P code (fun j => bits (2 * j)) t) h
      (bits (2 * t)) (bits (2 * t + 1))
    exact ⟨h', he⟩

@[simp] theorem concrete_halted (P : Program) (c : Config P) (h : Fin 2 → ℤ) :
    (concrete P c h).control = none ↔ c.control = none := by
  change c.control.map (normal P) = none ↔ c.control = none
  exact Option.map_eq_none_iff

theorem concrete_output (P : Program) (c : Config P) (h : Fin 2 → ℤ) (j : ℤ) :
    (concrete P c h).tape 2 j = cells c.output 0 j := rfl

theorem cells_ofFn (n : ℕ) (f : Fin n → Bool) (v : Fin n) :
    cells (List.ofFn f) 0 (v.val : ℤ) = some (f v) := by
  simp [cells]

theorem cells_outside (xs : List Bool) (j : ℤ)
    (hj : j < 0 ∨ (xs.length : ℤ) ≤ j) : cells xs 0 j = none := by
  rcases hj with hj | hj
  · simp [cells, show ¬0 ≤ j by omega]
  · simp [cells, show 0 ≤ j by omega, List.getElem?_eq_none (by omega : xs.length ≤ j.toNat)]

theorem concrete_correct (P : Program) (c : Config P) (h : Fin 2 → ℤ)
    (G : Game) (out : Fin G.n → Bool) (hh : c.control = none)
    (hc : c.output = List.ofFn out) (ho : CorrectSet G out) :
    CorrectOutput G (concrete P c h) := by
  refine ⟨(concrete_halted P c h).2 hh, ?_, ?_, ?_⟩
  · intro v
    simpa only [concrete_output, hc, cells_ofFn, Option.some.injEq] using ho v
  · intro v
    simp only [concrete_output, hc, cells_ofFn, Option.some.injEq]
    rw [← ho v]
    cases out v <;> simp
  · intro j hj
    rw [concrete_output, hc]
    apply cells_outside
    simpa only [List.length_ofFn] using hj

end BinaryStack
end MeanPayoff
end

end OAI