lean/OAI/Computability/WLIdentification/ExpressionCompiler.lean

import OAI.Computability.WLIdentification.WordExpressions

namespace OAI

namespace WLIdentification

namespace WordExpressions.Expr
open StackModel.Command

theorem correct_cases {n} {e p q r : Expr n} (he : Correct e) (hp : Correct p)
    (hq : Correct q) (hr : Correct r) : Correct (.cases e p q r) := by
  intro B S env out base ho henv hc hb h s
  have hb0 := hc base le_rfl
  obtain ⟨a, ha, hea⟩ := he B S env base (base+1) (by omega)
    (fun i => ⟨by have := (henv i).1; omega, by have := (henv i).1; omega⟩)
    (hc.mono (by omega)) (by simp only [hb0, List.length_nil]; omega) h.1 s
  let v := e.eval (S ∘ env)
  let T := Function.update S base v.dropLast
  have hread : Exec (StackModel.Command.read base) none (Function.update S base v)
      v.getLast? T 1 := by
    simpa only [StackModel.Command.read, Function.update_self, Function.update_idem, T] using
      Exec.pop base (fun _ b => b) none (Function.update S base v)
  have henv' : ∀ i, env i < base+1 ∧ env i ≠ out := by
    intro i; have := henv i; omega
  have henvEq : T ∘ env = S ∘ env := env_update S env base _ (fun i => (henv i).1)
  have hout : T out = S out := Function.update_of_ne (by omega) _ _
  have hex : ∃ b ≤ max (p.cost B) (max (q.cost B) (r.cost B))+2,
      Exec (.branch Option.isSome
        (.branch (fun x : Option Bool => x.getD false) (r.code env out (base+1)) (q.code env out (base+1)))
        (p.code env out (base+1))) v.getLast? T none
        (Function.update T out ((Expr.cases e p q r).eval (S ∘ env))) b := by
    cases hv : v.getLast? with
    | none =>
      obtain ⟨b, hb', heb⟩ := hp B T env out (base+1) (by omega) henv' (update_clean hc)
        (hout ▸ hb) (by rw [henvEq]; simpa only [show (e.eval (S ∘ env)).getLast? = none from hv] using h.2) none
      refine ⟨b+1, by have := le_max_left (p.cost B) (max (q.cost B) (r.cost B)); omega, ?_⟩
      simpa only [eval, show (e.eval (S ∘ env)).getLast? = none from hv, henvEq] using
        (Exec.branch_false (c := .branch (fun x : Option Bool => x.getD false)
          (r.code env out (base+1)) (q.code env out (base+1))) (test := Option.isSome) (by rfl) heb)
    | some b => cases b with
      | false =>
        obtain ⟨b, hb', heb⟩ := hq B T env out (base+1) (by omega) henv' (update_clean hc)
          (hout ▸ hb) (by rw [henvEq]; simpa only [show (e.eval (S ∘ env)).getLast? = some false from hv] using h.2) (some false)
        have hh := Exec.branch_true (test := Option.isSome) (d := p.code env out (base+1)) (by rfl)
          (Exec.branch_false (test := fun x : Option Bool => x.getD false) (c := r.code env out (base+1)) (by rfl) heb)
        refine ⟨b+2, ?_, ?_⟩
        · have := (le_max_left (q.cost B) (r.cost B)).trans (le_max_right (p.cost B) _); omega
        · simpa only [eval, show (e.eval (S ∘ env)).getLast? = some false from hv,
            henvEq, Nat.add_assoc, Nat.reduceAdd] using hh
      | true =>
        obtain ⟨b, hb', heb⟩ := hr B T env out (base+1) (by omega) henv' (update_clean hc)
          (hout ▸ hb) (by rw [henvEq]; simpa only [show (e.eval (S ∘ env)).getLast? = some true from hv] using h.2) (some true)
        have hh := Exec.branch_true (test := Option.isSome) (d := p.code env out (base+1)) (by rfl)
          (Exec.branch_true (test := fun x : Option Bool => x.getD false) (d := q.code env out (base+1)) (by rfl) heb)
        refine ⟨b+2, ?_, ?_⟩
        · have := (le_max_right (q.cost B) (r.cost B)).trans (le_max_right (p.cost B) _); omega
        · simpa only [eval, show (e.eval (S ∘ env)).getLast? = some true from hv,
            henvEq, Nat.add_assoc, Nat.reduceAdd] using hh
  obtain ⟨b, hb', heb⟩ := hex
  obtain ⟨c, hc', hec⟩ := clear_exec base none (Function.update T out ((Expr.cases e p q r).eval (S ∘ env)))
  have hv := e.length_le (S ∘ env) B h.1
  have hlen : (Function.update T out ((Expr.cases e p q r).eval (S ∘ env)) base).length ≤ B := by
    rw [Function.update_of_ne (by omega)]
    simp only [T, Function.update_self]
    exact (List.dropLast_sublist v).length_le.trans hv
  have hlast : Function.update (Function.update T out ((Expr.cases e p q r).eval (S ∘ env))) base [] =
      Function.update S out ((Expr.cases e p q r).eval (S ∘ env)) := by
    rw [Function.update_comm (by omega : out ≠ base), Function.update_idem, ← hb0, Function.update_eq_self]
  refine ⟨c+b+1+a, ?_, ?_⟩
  · dsimp only [cost]; omega
  · simpa only [code, hlast, Nat.add_assoc] using Exec.seq hea (Exec.seq hread (Exec.seq heb hec))

end WordExpressions.Expr
namespace WordExpressions.Expr
open StackModel.Command

theorem correct_loop {n} {c a : Expr n} {f : Expr (n+2)} (hcorr : Correct c)
    (haCorr : Correct a) (hf : Correct f) : Correct (.loop c a f) := by
  intro B S env out base ho henv hc hb h s
  let ec := c.eval (S ∘ env)
  let stage := stages f.eval (S ∘ env) (a.eval (S ∘ env))
  have hb0 := hc base le_rfl
  have henvlo : ∀ i, env i < base := fun i => (henv i).1
  have hcB : ec.length ≤ B := c.length_le _ _ h.1
  have hstage : ∀ i ≤ ec.length, (stage i).length ≤ B := by
    intro i hi
    cases i with
    | zero => exact a.length_le _ _ h.2.1
    | succ i => exact f.length_le _ _ (h.2.2 i (by change i < ec.length; omega))
  obtain ⟨u, hu, heu⟩ := hcorr B S env base (base+1) (by omega)
    (fun i => ⟨by have := henvlo i; omega, by have := henvlo i; omega⟩)
    (hc.mono (by omega)) (by simp only [hb0, List.length_nil]; omega) h.1 s
  let S₁ := Function.update S base ec
  have hS₁env : S₁ ∘ env = S ∘ env := env_update S env base ec henvlo
  have hS₁out : S₁ out = S out := Function.update_of_ne (by omega) _ _
  obtain ⟨v, hv, hev⟩ := haCorr B S₁ env out (base+1) (by omega)
    (fun i => ⟨by have := henvlo i; omega, (henv i).2⟩)
    (update_clean hc) (hS₁out ▸ hb) (by rw [hS₁env]; exact h.2.1) none
  let X (i : ℕ) := Function.update (Function.update S out (stage i)) (base+1) (List.replicate i false)
  have hX : ∀ i, X i base = [] := by
    intro i
    simpa only [X, Function.update_of_ne (by omega : base ≠ base+1),
      Function.update_of_ne (by omega : base ≠ out)] using hb0
  let body := StackModel.Command.seq (copy out (base+2) (base+3))
    (.seq (f.code (Fin.snoc (Fin.snoc env (base+1)) (base+2)) out (base+3))
      (.seq (clear (base+2)) (.push (base+1) (fun _ => false))))
  have hbody : ∀ i, 0 ≤ i → i < 0+ec.length → ∀ w s,
      ∃ t ≤ f.cost B+12*B+11, Exec body s (Function.update (X i) base w) none
        (Function.update (X (i+1)) base w) t := by
    intro i _ hi w s
    simp only [zero_add] at hi
    let T := Function.update (X i) base w
    have hTclean : Clean T (base+2) :=
      (((hc.mono (by omega)).update (by omega : out < base+2)).update (by omega : base+1 < base+2)).update (by omega)
    have hTstash := hTclean (base+2) le_rfl
    have hTtmp := hTclean (base+3) (by omega)
    have hTidx : T (base+1) = List.replicate i false := by simp [T, X]
    have hTout : T out = stage i := by
      simp only [T, X, Function.update_of_ne (by omega : out ≠ base),
        Function.update_of_ne (by omega : out ≠ base+1), Function.update_self]
    obtain ⟨u, hu, heu⟩ := copy_exec out (base+2) (base+3) (by omega) (by omega) (by omega) s T
    let W := Function.update T (base+2) (stage i)
    have hcopy : Function.update (Function.update T (base+2) (T out)) (base+3) [] = W := by
      rw [hTout]
      apply Function.update_eq_self_iff.mpr
      simp only [Function.update_of_ne (by omega : base+3 ≠ base+2), hTtmp]
    rw [hcopy] at heu
    have henv' : ∀ j : Fin (n+2),
        (Fin.snoc (Fin.snoc env (base+1)) (base+2) : Fin (n+2) → ℕ) j < base+3 ∧
        (Fin.snoc (Fin.snoc env (base+1)) (base+2) : Fin (n+2) → ℕ) j ≠ out := by
      intro j
      refine Fin.lastCases ?_ (fun j => ?_) j
      · simp only [Fin.snoc_last]; omega
      · simp only [Fin.snoc_castSucc]
        refine Fin.lastCases ?_ (fun k => ?_) j
        · simp only [Fin.snoc_last]; omega
        · simp only [Fin.snoc_castSucc]; have := henv k; omega
    have hWenv : W ∘ Fin.snoc (Fin.snoc env (base+1)) (base+2) =
        Fin.snoc (Fin.snoc (S ∘ env) (List.replicate i false)) (stage i) := by
      funext j
      refine Fin.lastCases ?_ (fun j => ?_) j
      · simp [W]
      · simp only [Function.comp_apply, Fin.snoc_castSucc]
        refine Fin.lastCases ?_ (fun k => ?_) j
        · simpa only [Fin.snoc_last, W, Function.update_of_ne (by omega : base+1 ≠ base+2)] using hTidx
        · simp only [Fin.snoc_castSucc, Function.comp_apply, W, T, X,
            Function.update_of_ne (by have := henvlo k; omega : env k ≠ base+2),
            Function.update_of_ne (by have := henvlo k; omega : env k ≠ base),
            Function.update_of_ne (by have := henvlo k; omega : env k ≠ base+1),
            Function.update_of_ne (henv k).2]
    have hWout : W out = stage i := by
      simpa only [W, Function.update_of_ne (by omega : out ≠ base+2)] using hTout
    have hWclean : Clean W (base+3) := (hTclean.mono (by omega)).update (by omega)
    obtain ⟨v, hv, hev⟩ := hf B W (Fin.snoc (Fin.snoc env (base+1)) (base+2)) out (base+3)
      (by omega) henv' hWclean (hWout ▸ hstage i (by omega)) (by rw [hWenv]; exact h.2.2 i hi) none
    have hnext : f.eval (W ∘ Fin.snoc (Fin.snoc env (base+1)) (base+2)) = stage (i+1) := by
      rw [hWenv]; rfl
    rw [hnext] at hev
    obtain ⟨z, hz, hez⟩ := clear_exec (base+2) none (Function.update W out (stage (i+1)))
    have hZlen : (Function.update W out (stage (i+1)) (base+2)).length ≤ B := by
      rw [Function.update_of_ne (by omega)]
      simpa only [W, Function.update_self] using hstage i (by omega)
    let Z := Function.update (Function.update W out (stage (i+1))) (base+2) []
    have hZ : Z = Function.update T out (stage (i+1)) := by
      dsimp only [Z, W]
      rw [Function.update_comm (by omega : out ≠ base+2), Function.update_idem,
        ← hTstash, Function.update_eq_self]
    have hpush := Exec.push (base+1) (fun _ : Option Bool => false) none Z
    have hfinal : Function.update Z (base+1) (Z (base+1) ++ [false]) = Function.update (X (i+1)) base w := by
      rw [hZ]
      funext j
      by_cases hj : j = base
      · subst j; simp only [T, X, Function.update_self, Function.update_of_ne (by omega : base ≠ base+1),
          Function.update_of_ne (by omega : base ≠ out)]
      by_cases hj' : j = base+1
      · subst j
        simp only [Function.update_self, Function.update_of_ne (by omega : base+1 ≠ base),
          Function.update_of_ne (by omega : base+1 ≠ out), hTidx, X]
        exact List.replicate_succ'.symm
      by_cases hj'' : j = out
      · subst j
        simp only [T, X, Function.update_self, Function.update_of_ne hj, Function.update_of_ne hj']
      · simp only [T, X, Function.update_of_ne hj, Function.update_of_ne hj', Function.update_of_ne hj'']
    rw [hfinal] at hpush
    refine ⟨1+z+v+u, ?_, ?_⟩
    · simp only [hTstash, hTtmp, hTout, List.length_nil, mul_zero, zero_add] at hu
      have hs := hstage i (by omega)
      omega
    · simpa only [body, Nat.add_assoc] using Exec.seq heu (Exec.seq hev (Exec.seq hez hpush))
  obtain ⟨w, hw, hew⟩ := drain_indexed body base X hX (f.cost B+12*B+11) 0 ec hbody none
  have hstart : Function.update (X 0) base ec = Function.update S₁ out (a.eval (S₁ ∘ env)) := by
    rw [hS₁env]
    dsimp only [X, stage, stages, List.replicate_zero, S₁]
    rw [Function.update_comm (by omega : out ≠ base+1)]
    have hh := hc (base+1) (by omega)
    rw [← hh, Function.update_eq_self, Function.update_comm (by omega : out ≠ base)]
  rw [hstart] at hew
  simp only [zero_add] at hew
  obtain ⟨z, hz, hez⟩ := clear_exec (base+1) none (X ec.length)
  have hlast : Function.update (X ec.length) (base+1) [] =
      Function.update S out ((Expr.loop c a f).eval (S ∘ env)) := by
    dsimp only [X]
    rw [Function.update_idem, Function.update_comm (by omega : out ≠ base+1)]
    have hh := hc (base+1) (by omega)
    rw [← hh, Function.update_eq_self]
    rfl
  have hlen : (X ec.length (base+1)).length = ec.length := by simp only [X, Function.update_self, List.length_replicate]
  rw [hlen] at hz
  rw [hlast] at hez
  refine ⟨z+w+v+u, ?_, ?_⟩
  · have hm := Nat.mul_le_mul_left (f.cost B+12*B+11+2) hcB
    dsimp only [cost]
    nlinarith
  · simpa only [code, body, Nat.add_assoc] using Exec.seq heu (Exec.seq hev (Exec.seq hew hez))

/-- The finite word language executes on literal stacks, with polynomial cost
in the lengths of all values in its evaluation. -/
theorem correct {n} (e : Expr n) : e.Correct := by
  induction e with
  | var i => exact correct_var i
  | nil => exact correct_nil
  | snoc e b ih => exact correct_snoc ih b
  | drop e ih => exact correct_drop ih
  | cases e p q r he hp hq hr => exact correct_cases he hp hq hr
  | bind e f he hf => exact correct_bind he hf
  | loop c a f hc ha hf => exact correct_loop hc ha hf

end WordExpressions.Expr
namespace StackModel.Command
variable {R : Type}

def registers : Command ℕ R → Finset ℕ
  | .skip | .modify _ => ∅
  | .push k _ | .pop k _ => {k}
  | .seq c d | .branch _ c d => c.registers ∪ d.registers
  | .while _ c => c.registers

def small (c : Command ℕ R) (N : ℕ) : Prop := ∀ k ∈ c.registers, k < N

def finiteIndex (N : ℕ) (h : 0 < N) (k : ℕ) : Fin N := ⟨k % N, Nat.mod_lt _ h⟩

@[simp] theorem finiteIndex_val {N k} (h : 0 < N) (hk : k < N) :
    (finiteIndex N h k).val = k := Nat.mod_eq_of_lt hk

theorem restrict_update {N k} (h : 0 < N) (hk : k < N) (S : ℕ → Word) (v : Word) :
    Function.update S k v ∘ Fin.val = Function.update (S ∘ Fin.val) (finiteIndex N h k) v := by
  funext j
  by_cases hj : j.val = k
  · have he : j = finiteIndex N h k := Fin.ext (hj.trans (finiteIndex_val h hk).symm)
    simp only [Function.comp_apply, hj, Function.update_self]
    rw [he, Function.update_self]
  · have he : j ≠ finiteIndex N h k := by intro he; exact hj (congrArg Fin.val he |>.trans (finiteIndex_val h hk))
    simp only [Function.comp_apply, Function.update_of_ne hj, Function.update_of_ne he]

/-- A syntactically finite register program has the same counted execution on
its finite set of tracks, even though its correctness was proved with convenient
natural register names. -/
theorem Exec.restrict {c : Command ℕ R} {s S t T n} (hex : Exec c s S t T n)
    (N : ℕ) (hN : 0 < N) (hc : c.small N) :
    Exec (c.rename (finiteIndex N hN)) s (S ∘ Fin.val) t (T ∘ Fin.val) n := by
  induction hex with
  | skip s S => exact .skip _ _
  | modify f s S => exact .modify _ _ _
  | push k f s S =>
    have hk := hc k (by simp [registers])
    simpa only [Command.rename, restrict_update hN hk, Function.comp_apply, finiteIndex_val hN hk] using
      Exec.push (finiteIndex N hN k) f s (S ∘ Fin.val)
  | pop k f s S =>
    have hk := hc k (by simp [registers])
    simpa only [Command.rename, restrict_update hN hk, Function.comp_apply, finiteIndex_val hN hk] using
      Exec.pop (finiteIndex N hN k) f s (S ∘ Fin.val)
  | seq _ _ ihc ihd =>
    exact .seq (ihc (fun k hk => hc k (Finset.mem_union_left _ hk)))
      (ihd (fun k hk => hc k (Finset.mem_union_right _ hk)))
  | branch_true ht _ ih => exact .branch_true ht (ih (fun k hk => hc k (Finset.mem_union_left _ hk)))
  | branch_false ht _ ih => exact .branch_false ht (ih (fun k hk => hc k (Finset.mem_union_right _ hk)))
  | while_false test c s S ht => exact .while_false _ _ _ _ ht
  | while_true ht _ _ ihc ihw => exact .while_true ht (ihc hc) (ihw hc)

theorem small_exists (c : Command ℕ R) : ∃ N, 1 < N ∧ c.small N := by
  refine ⟨c.registers.sup id+2, by omega, ?_⟩
  intro k hk
  have h := Finset.le_sup (f := id) hk
  dsimp only [id_eq] at h
  omega

/-- A three-instruction output test after a structured command, followed by a
literal accepting or rejecting stack-machine halt. -/
def testProgram {K : Type} (c : Command K (Option Bool)) (s : Option Bool) (out : K) :
    Program K (Option (Control c) ⊕ (Bool ⊕ Unit)) (Option Bool) where
  main := .inl (some c.entry)
  initialStore := s
  code
    | .inl (some x) => (c.code x).map Sum.inl
    | .inl none => .pop out (fun _ b => b) (.inr (.inr ()))
    | .inr (.inr _) => .branch (fun b => b.getD false) (.inr (.inl true)) (.inr (.inl false))
    | .inr (.inl b) => .halt b

theorem testProgram_embeds {K : Type} (c : Command K (Option Bool)) (s : Option Bool) (out : K) :
    Embeds (c.testProgram s out) c (Sum.inl ∘ some) (.inl none) := by
  intro x
  simp only [testProgram, Function.comp_apply]
  congr 1
  funext a
  cases a <;> rfl

theorem Exec.testRun {K : Type} [DecidableEq K] {c : Command K (Option Bool)} {s S t T n}
    (h : Exec c s S t T n) (input out : K) (w : Word)
    (hS : S = Function.update (fun _ => []) input w) :
    (StackModel.run (c.testProgram s out) input w (3+n)).control =
      .inl ((T out).getLast?.getD false) := by
  have he := h.execution (c.testProgram s out) (Sum.inl ∘ some) (.inl none)
    (c.testProgram_embeds s out)
  subst S
  unfold StackModel.run
  rw [Function.iterate_add_apply]
  change ((StackModel.step (c.testProgram s out))^[3]
    ((StackModel.step (c.testProgram s out))^[n]
      ⟨.inr ((Sum.inl ∘ some) c.entry), s, Function.update (fun _ => []) input w⟩)).control = _
  rw [he]
  change (StackModel.step (c.testProgram s out) (StackModel.step (c.testProgram s out)
    (StackModel.step (c.testProgram s out) ⟨.inr (.inl none), t, T⟩))).control = _
  cases hb : (T out).getLast?.getD false <;> simp [StackModel.step, testProgram, hb]

end StackModel.Command
namespace ComputationBounds

def Polynomial (f : ℕ → ℕ) : Prop := ∃ C d : ℕ, ∀ n, f n ≤ C*(n+1)^d

theorem constant (c : ℕ) : Polynomial (fun _ => c) := ⟨c, 0, by simp⟩
theorem identity : Polynomial id := ⟨1, 1, by intro n; simp⟩

theorem add {f g} (hf : Polynomial f) (hg : Polynomial g) : Polynomial (fun n => f n+g n) := by
  obtain ⟨C,d,hf⟩ := hf
  obtain ⟨D,e,hg⟩ := hg
  refine ⟨C+D, max d e, ?_⟩
  intro n
  have h1 := (hf n).trans (Nat.mul_le_mul_left C (Nat.pow_le_pow_right (by omega) (le_max_left d e)))
  have h2 := (hg n).trans (Nat.mul_le_mul_left D (Nat.pow_le_pow_right (by omega) (le_max_right d e)))
  nlinarith

theorem mul {f g} (hf : Polynomial f) (hg : Polynomial g) : Polynomial (fun n => f n*g n) := by
  obtain ⟨C,d,hf⟩ := hf
  obtain ⟨D,e,hg⟩ := hg
  refine ⟨C*D, d+e, ?_⟩
  intro n
  have hh := Nat.mul_le_mul (hf n) (hg n)
  calc
    f n*g n ≤ (C*(n+1)^d)*(D*(n+1)^e) := hh
    _ = (C*D)*(n+1)^(d+e) := by rw [pow_add]; ring

theorem maximum {f g} (hf : Polynomial f) (hg : Polynomial g) : Polynomial (fun n => max (f n) (g n)) := by
  obtain ⟨C,d,h⟩ := add hf hg
  exact ⟨C,d,fun n => (max_le (Nat.le_add_right _ _) (Nat.le_add_left _ _)).trans (h n)⟩

end ComputationBounds

namespace WordExpressions.Expr
open ComputationBounds

theorem cost_polynomial {n} (e : Expr n) : Polynomial e.cost := by
  induction e with
  | var _ => exact add (mul (constant 12) identity) (constant 8)
  | nil => exact add (mul (constant 3) identity) (constant 2)
  | snoc _ _ ih | drop _ ih => exact add ih (constant 1)
  | cases _ _ _ _ he hp hq hr =>
    exact add (add (add he (maximum hp (maximum hq hr))) (mul (constant 3) identity)) (constant 5)
  | bind _ _ he hf => exact add (add (add he hf) (mul (constant 3) identity)) (constant 2)
  | loop _ _ _ hc ha hf =>
    exact add (add (add (add hc ha) (mul (add (add hf (mul (constant 12) identity)) (constant 13)) identity))
      (mul (constant 3) identity)) (constant 4)

def outputBound {n} (e : Expr n) (B : ℕ) : ℕ :=
  2+(e.cost B+15*B+13)*(2*(B+(e.cost B+15*B+13))+3)

theorem outputBound_polynomial {n} (e : Expr n) : Polynomial e.outputBound := by
  have h := add (add e.cost_polynomial (mul (constant 15) identity)) (constant 13)
  exact add (constant 2) (mul h (add (mul (constant 2) (add identity h)) (constant 3)))

end WordExpressions.Expr

end WLIdentification

end OAI