import OAI.Computability.Superstring.Schedule

namespace OAI

namespace Superstring.BitCode

abbrev Store (K : Type) := K → List Bool

/-- A finite-control bit-stack instruction. There is no unbounded internal
state and no operation on an entire stack other than one push/pop/peek. -/
inductive Instr (K L : Type)
  | push (k : K) (b : Bool) (next : L)
  | pop (k : K) (next : L)
  | branch (k : K) (empty low high : L)
  | jump (next : L)

namespace Instr

def map {K L M : Type} (f : L → M) : Instr K L → Instr K M
  | .push k b l => .push k b (f l)
  | .pop k l => .pop k (f l)
  | .branch k e l h => .branch k (f e) (f l) (f h)
  | .jump l => .jump (f l)

def run {K L : Type} [DecidableEq K] : Instr K L → Store K → L × Store K
  | .push k b l, s => (l, Function.update s k (b :: s k))
  | .pop k l, s => (l, Function.update s k (s k).tail)
  | .branch k e l h, s => (match (s k).head? with
      | none => e
      | some false => l
      | some true => h, s)
  | .jump l, s => (l, s)

@[simp] theorem run_map {K L M : Type} [DecidableEq K] (f : L → M)
    (i : Instr K L) (s : Store K) : (i.map f).run s = Prod.map f id (i.run s) := by
  cases i with
  | branch k e l h => cases hs : (s k).head? with
    | none => simp [map, run, hs]
    | some b => cases b <;> simp [map, run, hs]
  | _ => rfl


def emit {K L : Type} : Instr K (Option L) →
    Turing.TM2.Stmt (fun _ : K => Bool) L (Option Bool)
  | .push k b l => .push k (fun _ => b) (finish l)
  | .pop k l => .pop k (fun _ _ => none) (finish l)
  | .branch k e l h => .peek k (fun _ b => b)
      (.branch Option.isNone (finish e)
        (.branch (fun b => b.getD false) (finish h) (finish l)))
  | .jump l => finish l
where
  finish {K L : Type} (l : Option L) :
      Turing.TM2.Stmt (fun _ : K => Bool) L (Option Bool) :=
    .load (fun _ => none) (match l with | none => .halt | some x => .goto (fun _ => x))

theorem finish_step {K L : Type} [DecidableEq K] (l : Option L)
    (v : Option Bool) (s : Store K) :
    Turing.TM2.stepAux (emit.finish l) v s = ⟨l, none, s⟩ := by
  cases l <;> rfl

theorem emit_step {K L : Type} [DecidableEq K] (i : Instr K (Option L))
    (v : Option Bool) (s : Store K) :
    Turing.TM2.stepAux i.emit v s = ⟨(i.run s).1, none, (i.run s).2⟩ := by
  cases i with
  | push k b l => exact finish_step l v _
  | pop k l => exact finish_step l none _
  | branch k e l h =>
    cases hs : (s k).head? with
    | none => simp [emit, Turing.TM2.stepAux, hs, finish_step, run]
    | some b => cases b <;> simp [emit, Turing.TM2.stepAux, hs, finish_step, run]
  | jump l => exact finish_step l v s

end Instr

/-- Structured bit-stack code. Loops are ordinary operational loops, not
unbounded-cost primitives. Their iteration count is charged in `Exec`. -/
inductive Block (K : Type)
  | push (k : K) (b : Bool)
  | pop (k : K)
  | skip
  | branch (k : K) (empty low high : Block K)
  | seq (first second : Block K)
  | loop (k : K) (body : Block K)

namespace Block

def Label {K : Type} : Block K → Type
  | .push _ _ | .pop _ | .skip => Unit
  | .branch _ a b c => Unit ⊕ (Label a ⊕ Label b ⊕ Label c)
  | .seq a b => Label a ⊕ Label b
  | .loop _ a => Option (Label a)

instance labelFintype {K : Type} : (b : Block K) → Fintype b.Label
  | .push _ _ | .pop _ | .skip => inferInstanceAs (Fintype Unit)
  | .branch _ a b c => by
    letI := labelFintype a
    letI := labelFintype b
    letI := labelFintype c
    exact inferInstanceAs (Fintype (Unit ⊕ (Label a ⊕ Label b ⊕ Label c)))
  | .seq a b => by
    letI := labelFintype a
    letI := labelFintype b
    exact inferInstanceAs (Fintype (Label a ⊕ Label b))
  | .loop _ a => by
    letI := labelFintype a
    exact inferInstanceAs (Fintype (Option (Label a)))

instance labelDecidableEq {K : Type} : (b : Block K) → DecidableEq b.Label
  | .push _ _ | .pop _ | .skip => inferInstanceAs (DecidableEq Unit)
  | .branch _ a b c => by
    letI := labelDecidableEq a
    letI := labelDecidableEq b
    letI := labelDecidableEq c
    exact inferInstanceAs (DecidableEq (Unit ⊕ (Label a ⊕ Label b ⊕ Label c)))
  | .seq a b => by
    letI := labelDecidableEq a
    letI := labelDecidableEq b
    exact inferInstanceAs (DecidableEq (Label a ⊕ Label b))
  | .loop _ a => by
    letI := labelDecidableEq a
    exact inferInstanceAs (DecidableEq (Option (Label a)))

def start {K : Type} : (b : Block K) → b.Label
  | .push _ _ | .pop _ | .skip => ()
  | .branch _ _ _ _ => .inl ()
  | .seq a _ => .inl a.start
  | .loop _ _ => none

def code {K : Type} : (b : Block K) → b.Label → Instr K (Option b.Label)
  | .push k b, _ => .push k b none
  | .pop k, _ => .pop k none
  | .skip, _ => .jump none
  | .branch k a b c, .inl _ => .branch k
      (some (.inr (.inl a.start))) (some (.inr (.inr (.inl b.start))))
      (some (.inr (.inr (.inr c.start))))
  | .branch _ a _ _, .inr (.inl l) => (a.code l).map (Option.map (Sum.inr ∘ Sum.inl))
  | .branch _ _ b _, .inr (.inr (.inl l)) =>
      (b.code l).map (Option.map (Sum.inr ∘ Sum.inr ∘ Sum.inl))
  | .branch _ _ _ c, .inr (.inr (.inr l)) =>
      (c.code l).map (Option.map (Sum.inr ∘ Sum.inr ∘ Sum.inr))
  | .seq a b, .inl l => (a.code l).map (fun q =>
      match q with | none => some (.inr b.start) | some x => some (.inl x))
  | .seq _ b, .inr l => (b.code l).map (Option.map Sum.inr)
  | .loop k a, none => .branch k none (some (some a.start)) (some (some a.start))
  | .loop _ a, some l => (a.code l).map (fun q => some q)

end Block

end Superstring.BitCode

namespace Superstring.BitCode

variable {K : Type} [DecidableEq K]

/-- Exact execution in the finite-control graph, stopping before a halt label
is stepped. This is a finite trace, not an oracle for a computation. -/
inductive Steps {L : Type} (code : L → Instr K (Option L)) :
    (Option L × Store K) → ℕ → (Option L × Store K) → Prop
  | refl (c) : Steps code c 0 c
  | step (l : L) (s : Store K) {n d} (h : Steps code ((code l).run s) n d) :
      Steps code (some l, s) (n + 1) d

namespace Steps

variable {L M : Type} {code : L → Instr K (Option L)}

theorem trans {a b c} {m n : ℕ} (h : Steps code a m b) (h' : Steps code b n c) :
    Steps code a (m + n) c := by
  induction h with
  | refl => simpa using h'
  | step l s h ih => simpa only [Nat.add_assoc, Nat.add_comm 1] using step l s (ih h')

theorem map (f : Option L → Option M) (j : L → M)
    {big : M → Instr K (Option M)}
    (hl : ∀ l, f (some l) = some (j l))
    (hc : ∀ l, big (j l) = (code l).map f)
    {a b} {n} (h : Steps code a n b) :
    Steps big (Prod.map f id a) n (Prod.map f id b) := by
  induction h with
  | refl => exact .refl _
  | step l s h ih =>
    simp only [Prod.map, id_eq, hl] at *
    apply Steps.step
    simpa only [hc, Instr.run_map, Prod.map, id_eq] using ih

end Steps

namespace Block

/-- Big-step semantics with the exact number of primitive bit instructions. -/
inductive Exec : Block K → Store K → Store K → ℕ → Prop
  | push (k b s) : Exec (.push k b) s (Function.update s k (b :: s k)) 1
  | pop (k s) : Exec (.pop k) s (Function.update s k (s k).tail) 1
  | skip (s) : Exec .skip s s 1
  | branch_none {k a b c s t n} (h : (s k).head? = none) (run : Exec a s t n) :
      Exec (.branch k a b c) s t (n + 1)
  | branch_false {k a b c s t n} (h : (s k).head? = some false) (run : Exec b s t n) :
      Exec (.branch k a b c) s t (n + 1)
  | branch_true {k a b c s t n} (h : (s k).head? = some true) (run : Exec c s t n) :
      Exec (.branch k a b c) s t (n + 1)
  | seq {a b s t u m n} (first : Exec a s t m) (second : Exec b t u n) :
      Exec (.seq a b) s u (m + n)
  | loop_nil {k a s} (h : s k = []) : Exec (.loop k a) s s 1
  | loop_cons {k a s t u m n} (h : s k ≠ []) (body : Exec a s t m)
      (rest : Exec (.loop k a) t u n) : Exec (.loop k a) s u (m + n + 1)

theorem exec_steps {b : Block K} {s t : Store K} {n : ℕ} (h : b.Exec s t n) :
    Steps b.code (some b.start, s) n (none, t) := by
  induction h with
  | push k b s => exact .step () s (.refl _)
  | pop k s => exact .step () s (.refl _)
  | skip s => exact .step () s (.refl _)
  | @branch_none k a b c s t n hh run ih =>
    apply Steps.step
    simp only [code, start, Instr.run, hh]
    exact ih.map (Option.map (Sum.inr ∘ Sum.inl)) (Sum.inr ∘ Sum.inl)
      (fun _ => rfl) (fun _ => rfl)
  | @branch_false k a b c s t n hh run ih =>
    apply Steps.step
    simp only [code, start, Instr.run, hh]
    exact ih.map (Option.map (Sum.inr ∘ Sum.inr ∘ Sum.inl))
      (Sum.inr ∘ Sum.inr ∘ Sum.inl) (fun _ => rfl) (fun _ => rfl)
  | @branch_true k a b c s t n hh run ih =>
    apply Steps.step
    simp only [code, start, Instr.run, hh]
    exact ih.map (Option.map (Sum.inr ∘ Sum.inr ∘ Sum.inr))
      (Sum.inr ∘ Sum.inr ∘ Sum.inr) (fun _ => rfl) (fun _ => rfl)
  | @seq a b s t u m n first second ih₁ ih₂ =>
    let f : Option a.Label → Option ((seq a b).Label) := fun q =>
      match q with | none => some (.inr b.start) | some x => some (.inl x)
    have h₁ : Steps (seq a b).code (some (.inl a.start), s) m (some (.inr b.start), t) :=
      ih₁.map f Sum.inl (fun _ => rfl) (fun _ => rfl)
    have h₂ : Steps (seq a b).code (some (.inr b.start), t) n (none, u) :=
      ih₂.map (Option.map Sum.inr) Sum.inr (fun _ => rfl) (fun _ => rfl)
    exact h₁.trans h₂
  | @loop_nil k a s hh =>
    apply Steps.step
    simpa only [code, start, Instr.run, hh, List.head?_nil] using
      (Steps.refl (code := code (.loop k a)) (none, s))
  | @loop_cons k a s t u m n hh body rest ih₁ ih₂ =>
    apply Steps.step
    have hstart : ((code (.loop k a)) none).run s = (some (some a.start), s) := by
      cases he : s k with
      | nil => exact False.elim (hh he)
      | cons x xs => cases x <;> simp only [code, Instr.run, he, List.head?_cons] <;> rfl
    dsimp only [start]
    rw [hstart]
    exact (ih₁.map some some (fun _ => rfl) (fun _ => rfl)).trans ih₂


def machine [Fintype K] (b : Block K) (input output : K) : Turing.FinTM2 where
  K := K
  k₀ := input
  k₁ := output
  Γ _ := Bool
  Λ := b.Label
  main := b.start
  σ := Option Bool
  initialState := none
  m l := (b.code l).emit

def pack {L : Type} (c : Option L × Store K) :
    Turing.TM2.Cfg (fun _ : K => Bool) L (Option Bool) := ⟨c.1, none, c.2⟩

theorem steps_iterate {L : Type} {code : L → Instr K (Option L)}
    {s t : Option L × Store K} {n : ℕ} (h : Steps code s n t) :
    (fun c => c.bind (Turing.TM2.step (fun l => (code l).emit)))^[n]
      (some (pack s)) = some (pack t) := by
  induction h with
  | refl => rfl
  | step l S h ih =>
    rw [Function.iterate_succ_apply]
    simpa only [pack, Option.bind_some, Turing.TM2.step, Instr.emit_step] using ih

def exec_machine [Fintype K] (b : Block K) (input output : K)
    {s t : Store K} {n : ℕ} (h : b.Exec s t n) :
    StateTransition.EvalsToInTime (b.machine input output).step
      (pack (some b.start, s)) (some (pack (none, t))) n :=
  ⟨⟨n, steps_iterate (exec_steps h)⟩, le_rfl⟩

end Block

end Superstring.BitCode

namespace Superstring.BitCode

variable {K : Type} [DecidableEq K]

/-- A single populated stack: the exact Mathlib initial/final convention. -/
def single (k : K) (w : List Bool) : Store K := fun j => if j = k then w else []

namespace Block

theorem init_eq [Fintype K] (b : Block K) (i o : K) (w : List Bool) :
    Turing.initList (b.machine i o) w = pack (some b.start, single i w) := by
  dsimp only [Turing.initList, machine, pack]
  apply congrArg (fun S : Store K => Turing.TM2.Cfg.mk (some b.start) none S)
  funext k
  by_cases h : k = i
  · subst k
    rfl
  · simp only [dite_eq_right h, single, ite_eq_right h]

theorem halt_eq [Fintype K] (b : Block K) (i o : K) (w : List Bool) :
    Turing.haltList (b.machine i o) w = pack (none, single o w) := by
  dsimp only [Turing.haltList, machine, pack]
  apply congrArg (fun S : Store K => Turing.TM2.Cfg.mk none none S)
  funext k
  by_cases h : k = o
  · subst k
    rfl
  · simp only [dite_eq_right h, single, ite_eq_right h]

/-- Execution with a polynomial clock gives a polynomial-time TM2 certificate. -/
noncomputable def certificate [Fintype K] {α β : Type}
    (ea : α → List Bool) (eb : β → List Bool) (f : α → β)
    (b : Block K) (i o : K) (P : Polynomial ℕ)
    (correct : ∀ a, ∃ n, n ≤ P.eval (ea a).length ∧
      b.Exec (single i (ea a)) (single o (eb (f a))) n) :
    Turing.TM2ComputableInPolyTime ea eb f where
  tm := b.machine i o
  inputAlphabet := Equiv.refl Bool
  outputAlphabet := Equiv.refl Bool
  time := P
  outputsFun a := by
    let n := (correct a).choose
    have hn := (correct a).choose_spec
    refine ⟨⟨n, ?_⟩, hn.1⟩
    change (flip bind (b.machine i o).step)^[n]
      (some (Turing.initList (b.machine i o) ((ea a).map id))) =
        some (Turing.haltList (b.machine i o) ((eb (f a)).map id))
    have hi := init_eq b i o (ea a)
    have ho := halt_eq b i o (eb (f a))
    dsimp only [machine] at *
    simp only [List.map_id]
    rw [hi, ho]
    exact steps_iterate (exec_steps hn.2)

theorem certificate_finite [Fintype K] {α β : Type}
    (ea : α → List Bool) (eb : β → List Bool) (f : α → β)
    (b : Block K) (i o : K) (P : Polynomial ℕ)
    (correct : ∀ a, ∃ n, n ≤ P.eval (ea a).length ∧
      b.Exec (single i (ea a)) (single o (eb (f a))) n)
    (k : (b.certificate ea eb f i o P correct).tm.K) :
    Finite ((b.certificate ea eb f i o P correct).tm.Γ k) := inferInstanceAs (Finite Bool)

end Block

section Size
variable [Fintype K]

def size (s : Store K) : ℕ := ∑ k, (s k).length

theorem size_update (s : Store K) (k : K) (w : List Bool) :
    size (Function.update s k w) + (s k).length = size s + w.length := by
  classical
  have h₁ := Finset.sum_erase_add Finset.univ (fun j => (Function.update s k w j).length)
    (Finset.mem_univ k)
  have h₂ := Finset.sum_erase_add Finset.univ (fun j => (s j).length) (Finset.mem_univ k)
  have he : (∑ j ∈ Finset.univ.erase k, (Function.update s k w j).length) =
      ∑ j ∈ Finset.univ.erase k, (s j).length := by
    apply Finset.sum_congr rfl
    intro j hj
    rw [Function.update_of_ne (Finset.mem_erase.mp hj).1]
  simp only [he, Function.update_self] at h₁
  dsimp only [size]
  omega

theorem size_push (s : Store K) (k : K) (b : Bool) :
    size (Function.update s k (b :: s k)) = size s + 1 := by
  have hh := size_update s k (b :: s k)
  simp only [List.length_cons] at hh
  omega

theorem size_pop (s : Store K) (k : K) :
    size (Function.update s k (s k).tail) ≤ size s := by
  have hh := size_update s k (s k).tail
  simp only [List.length_tail] at hh
  omega

/-- Every actually executed primitive bit instruction increases total stored
length by at most one; branch tests and iterations do not hide bulk operations. -/
theorem Block.Exec.size_le {b : Block K} {s t : Store K} {n : ℕ}
    (h : b.Exec s t n) : size t ≤ size s + n := by
  induction h with
  | push k b s => exact le_of_eq (size_push s k b)
  | pop k s => exact (size_pop s k).trans (Nat.le_add_right _ _)
  | skip => omega
  | branch_none _ _ ih => omega
  | branch_false _ _ ih => omega
  | branch_true _ _ ih => omega
  | seq _ _ ih₁ ih₂ => omega
  | loop_nil => omega
  | loop_cons _ _ _ ih₁ ih₂ => omega

end Size

end Superstring.BitCode

end OAI