lean/OAI/Computability/WLIdentification/ExpressionBounds.lean

import OAI.Computability.WLIdentification.ExpressionCompiler

namespace OAI

namespace WLIdentification

namespace WordExpressions.Expr
open StackModel.Command

def outputCode (e : Expr 1) : StackModel.Command ℕ (Option Bool) :=
  .seq (e.code (fun _ => 0) 1 2) (.seq (clear 0) (.seq (copy 1 0 2) (clear 1)))

theorem outputCode_exec (e : Expr 1) (w : Word) (B : ℕ) (hw : w.length ≤ B)
    (h : e.Bounded (fun _ => w) B) :
    ∃ t ≤ e.cost B+15*B+12, Exec e.outputCode none (Function.update (fun _ => []) 0 w) none
      (Function.update (fun _ => []) 0 (e.eval (fun _ => w))) t := by
  let S : ℕ → Word := Function.update (fun _ => []) 0 w
  have henv : S ∘ (fun _ : Fin 1 => 0) = fun _ => w := by funext i; simp [S]
  have hclean : Clean S 2 := by intro k hk; simp [S, show k ≠ 0 by omega]
  obtain ⟨a, ha, hea⟩ := e.correct B S (fun _ => 0) 1 2 (by omega) (by intro i; omega)
    hclean (by simp [S]) (by rw [henv]; exact h) none
  rw [henv] at hea
  let v := e.eval (fun _ => w)
  have hv : v.length ≤ B := e.length_le _ _ h
  let T := Function.update S 1 v
  obtain ⟨b, hb, heb⟩ := clear_exec 0 none T
  let U := Function.update T 0 []
  obtain ⟨c, hc, hec⟩ := copy_exec 1 0 2 (by omega) (by omega) (by omega) none U
  let V := Function.update (Function.update U 0 (U 1)) 2 []
  obtain ⟨d, hd, hed⟩ := clear_exec 1 none V
  have ht0 : T 0 = w := by simp [T, S]
  have hu0 : U 0 = [] := by simp [U]
  have hu1 : U 1 = v := by simp [U, T]
  have hu2 : U 2 = [] := by simp [U, T, S]
  have hv1 : V 1 = v := by simp [V, U, T]
  have hfinal : Function.update V 1 [] = Function.update (fun _ => []) 0 v := by
    funext k
    by_cases hk0 : k = 0
    · subst k; simp [V, U, T]
    by_cases hk1 : k = 1
    · subst k; simp
    by_cases hk2 : k = 2
    · subst k; simp [V]
    · simp [V, U, T, S, hk0, hk1, hk2]
  rw [hfinal] at hed
  refine ⟨d+c+b+a, ?_, ?_⟩
  · simp only [ht0] at hb
    simp only [hu0, hu1, hu2, List.length_nil, mul_zero, zero_add] at hc
    simp only [hv1] at hd
    omega
  · simpa only [outputCode, Nat.add_assoc] using Exec.seq hea (Exec.seq heb (Exec.seq hec hed))

/-- A complete local, finite-alphabet output producer from a proved bounded
word expression. Uniformity is in the expression, not in its inputs. -/
theorem computes (e : Expr 1) (B : ℕ → ℕ)
    (hw : ∀ n, n ≤ B n) (h : ∀ w, e.Bounded (fun _ => w) (B w.length)) :
    ∃ M : Machine, ComputesWithin M (fun w => e.eval (fun _ => w))
      (fun n => e.outputBound (B n)) := by
  obtain ⟨N,hN,hsmall⟩ := e.outputCode.small_exists
  let c := e.outputCode.rename (finiteIndex N (by omega))
  let input : Fin N := finiteIndex N (by omega) 0
  let P := c.program none
  refine ⟨StackModel.compile P input, ?_⟩
  intro w
  obtain ⟨t,ht,he⟩ := e.outputCode_exec w (B w.length) (hw _) (h w)
  have he' := he.restrict N (by omega) hsmall
  simp only [restrict_update (show 0 < N by omega) (show 0 < N by omega)] at he'
  have hs : (fun _ : ℕ => ([] : Word)) ∘ Fin.val = fun _ : Fin N => [] := rfl
  rw [hs] at he'
  have hr := he'.run input w rfl
  obtain ⟨T,hT,hTe⟩ := StackModel.run_execution P input w (t+1)
  change ∃ T ≤ _, _
  refine ⟨T, ?_, ?_, ?_⟩
  · apply hT.trans
    dsimp only [outputBound]
    have htp : t+1 ≤ e.cost (B w.length)+15*(B w.length)+13 := by omega
    have hn := hw w.length
    gcongr
  · rw [hTe, hr]
    rfl
  · rw [hTe, hr]
    exact StackModel.output_correct P input _ _ rfl

end WordExpressions.Expr

namespace ComputationBounds

theorem compose {f g : ℕ → ℕ} (hf : Polynomial f) (hg : Polynomial g) :
    Polynomial (fun n => f (g n)) := by
  obtain ⟨C,d,hf⟩ := hf
  obtain ⟨D,e,hg⟩ := hg
  refine ⟨C*(D+1)^d, e*d, ?_⟩
  intro n
  have hn : 1 ≤ (n+1)^e := Nat.one_le_pow _ _ (by omega)
  have hh : g n+1 ≤ (D+1)*(n+1)^e := by have := hg n; nlinarith
  calc
    f (g n) ≤ C*(g n+1)^d := hf _
    _ ≤ C*((D+1)*(n+1)^e)^d := Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hh _)
    _ = C*(D+1)^d*(n+1)^(e*d) := by rw [mul_pow, ← pow_mul]; ring

theorem dominates {f g : ℕ → ℕ} (hf : Polynomial f) (h : ∀ n, g n ≤ f n) : Polynomial g := by
  obtain ⟨C,d,hf⟩ := hf
  exact ⟨C,d,fun n => (h n).trans (hf n)⟩

end ComputationBounds

namespace WordExpressions.Expr

def liftRen {n m} (r : Fin n → Fin m) : Fin (n+1) → Fin (m+1) :=
  Fin.snoc (Fin.castSucc ∘ r) (Fin.last m)

def rename : {n m : ℕ} → (Fin n → Fin m) → Expr n → Expr m
  | _, _, r, .var i => .var (r i)
  | _, _, _, .nil => .nil
  | _, _, r, .snoc e b => .snoc (e.rename r) b
  | _, _, r, .drop e => .drop (e.rename r)
  | _, _, r, .cases e p q s => .cases (e.rename r) (p.rename r) (q.rename r) (s.rename r)
  | _, _, r, .bind e f => .bind (e.rename r) (f.rename (liftRen r))
  | _, _, r, .loop c a f => .loop (c.rename r) (a.rename r) (f.rename (liftRen (liftRen r)))

theorem snoc_liftRen {n m} (r : Fin n → Fin m) (S : Fin m → Word) (a : Word) :
    Fin.snoc S a ∘ liftRen r = Fin.snoc (S ∘ r) a := by
  funext i
  refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [liftRen]

theorem stages_rename {n m} (r : Fin n → Fin m)
    (f : (Fin (n+2) → Word) → Word) (g : (Fin (m+2) → Word) → Word)
    (h : ∀ S, g S = f (S ∘ liftRen (liftRen r))) (S : Fin m → Word) (a : Word) (k : ℕ) :
    stages g S a k = stages f (S ∘ r) a k := by
  induction k with
  | zero => rfl
  | succ k ih => simp only [stages, h, snoc_liftRen, ih]

@[simp] theorem eval_rename {n m} (e : Expr n) (r : Fin n → Fin m) (S : Fin m → Word) :
    (e.rename r).eval S = e.eval (S ∘ r) := by
  induction e generalizing m with
  | var i | nil => rfl
  | snoc e b ih | drop e ih => simp only [rename, eval, ih]
  | cases e p q s he hp hq hs =>
    simp only [rename, eval, he]
    cases (e.eval (S ∘ r)).getLast? with
    | none => exact hp _ _
    | some b => cases b <;> first | exact hq _ _ | exact hs _ _
  | bind e f he hf => simp only [rename, eval, he, hf, snoc_liftRen]
  | loop c a f hc ha hf =>
    simp only [rename, eval, hc, ha]
    exact stages_rename r _ _ (hf _) _ _ _

@[simp] theorem bounded_rename {n m} (e : Expr n) (r : Fin n → Fin m) (S : Fin m → Word) (B : ℕ) :
    (e.rename r).Bounded S B ↔ e.Bounded (S ∘ r) B := by
  induction e generalizing m with
  | var i | nil => rfl
  | snoc e b ih => simp only [rename, Bounded, ih, eval_rename]
  | drop e ih => exact ih _ _
  | cases e p q s he hp hq hs =>
    simp only [rename, Bounded, he, eval_rename]
    cases (e.eval (S ∘ r)).getLast? with
    | none => rw [hp]
    | some b => cases b <;> simp only [hq, hs]
  | bind e f he hf => simp only [rename, Bounded, he, hf, eval_rename, snoc_liftRen]
  | loop c a f hc ha hf =>
    simp only [rename, Bounded, hc, ha, hf, eval_rename, snoc_liftRen,
      stages_rename r f.eval (f.rename (liftRen (liftRen r))).eval (fun S => eval_rename _ _ S)]

theorem bounded_mono {n} (e : Expr n) {S B D} (h : e.Bounded S B) (hBD : B ≤ D) :
    e.Bounded S D := by
  induction e with
  | var i => exact h.trans hBD
  | nil => trivial
  | snoc e b ih => exact ⟨ih h.1, h.2.trans hBD⟩
  | drop e ih => exact ih h
  | cases e p q r he hp hq hr =>
    refine ⟨he h.1, ?_⟩
    cases hv : (e.eval S).getLast? with
    | none => exact hp (by simpa only [hv] using h.2)
    | some b => cases b with
      | false => exact hq (by simpa only [hv] using h.2)
      | true => exact hr (by simpa only [hv] using h.2)
  | bind e f he hf => exact ⟨he h.1, hf h.2⟩
  | loop c a f hc ha hf => exact ⟨hc h.1, ha h.2.1, fun i hi => hf (h.2.2 i hi)⟩

def liftSub {n m} (s : Fin n → Expr m) : Fin (n+1) → Expr (m+1) :=
  Fin.snoc (fun i => (s i).rename Fin.castSucc) (.var (Fin.last m))

def subst : {n m : ℕ} → (Fin n → Expr m) → Expr n → Expr m
  | _, _, s, .var i => s i
  | _, _, _, .nil => .nil
  | _, _, s, .snoc e b => .snoc (e.subst s) b
  | _, _, s, .drop e => .drop (e.subst s)
  | _, _, s, .cases e p q r => .cases (e.subst s) (p.subst s) (q.subst s) (r.subst s)
  | _, _, s, .bind e f => .bind (e.subst s) (f.subst (liftSub s))
  | _, _, s, .loop c a f => .loop (c.subst s) (a.subst s) (f.subst (liftSub (liftSub s)))

theorem eval_liftSub {n m} (s : Fin n → Expr m) (S : Fin m → Word) (a : Word) :
    (fun i => (liftSub s i).eval (Fin.snoc S a)) = Fin.snoc (fun i => (s i).eval S) a := by
  funext i
  refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [liftSub, eval, Function.comp_def]

theorem stages_subst {n m} (s : Fin n → Expr m)
    (f : (Fin (n+2) → Word) → Word) (g : (Fin (m+2) → Word) → Word)
    (h : ∀ S, g S = f (fun i => (liftSub (liftSub s) i).eval S))
    (S : Fin m → Word) (a : Word) (k : ℕ) :
    stages g S a k = stages f (fun i => (s i).eval S) a k := by
  induction k with
  | zero => rfl
  | succ k ih => simp only [stages, h, eval_liftSub, ih]

@[simp] theorem eval_subst {n m} (e : Expr n) (s : Fin n → Expr m) (S : Fin m → Word) :
    (e.subst s).eval S = e.eval (fun i => (s i).eval S) := by
  induction e generalizing m with
  | var i | nil => rfl
  | snoc e b ih | drop e ih => simp only [subst, eval, ih]
  | cases e p q r he hp hq hr =>
    simp only [subst, eval, he]
    cases (e.eval (fun i => (s i).eval S)).getLast? with
    | none => exact hp _ _
    | some b => cases b <;> first | exact hq _ _ | exact hr _ _
  | bind e f he hf => simp only [subst, eval, he, hf, eval_liftSub]
  | loop c a f hc ha hf =>
    simp only [subst, eval, hc, ha]
    exact stages_subst s _ _ (hf _) _ _ _

theorem bounded_liftSub {n m} (s : Fin n → Expr m) (S : Fin m → Word) (a : Word) (B : ℕ)
    (hs : ∀ i, (s i).Bounded S B) (ha : a.length ≤ B) :
    ∀ i, (liftSub s i).Bounded (Fin.snoc S a) B := by
  intro i
  refine Fin.lastCases ?_ (fun j => ?_) i
  · simpa [liftSub, Bounded] using ha
  · simpa [liftSub, Function.comp_def] using hs j

theorem bounded_subst {n m} (e : Expr n) (s : Fin n → Expr m) (S : Fin m → Word) (B : ℕ)
    (hs : ∀ i, (s i).Bounded S B) (he : e.Bounded (fun i => (s i).eval S) B) :
    (e.subst s).Bounded S B := by
  induction e generalizing m with
  | var i => exact hs i
  | nil => trivial
  | snoc e b ih => exact ⟨ih _ _ hs he.1, by simpa only [eval_subst] using he.2⟩
  | drop e ih => exact ih _ _ hs he
  | cases e p q r he' hp hq hr =>
    refine ⟨he' _ _ hs he.1, ?_⟩
    simp only [eval_subst]
    cases hv : (e.eval (fun i => (s i).eval S)).getLast? with
    | none => exact hp _ _ hs (by simpa only [hv] using he.2)
    | some b => cases b with
      | false => exact hq _ _ hs (by simpa only [hv] using he.2)
      | true => exact hr _ _ hs (by simpa only [hv] using he.2)
  | bind e f ih hf =>
    refine ⟨ih _ _ hs he.1, ?_⟩
    have hs' := bounded_liftSub s S ((e.subst s).eval S) B hs
      (by rw [eval_subst]; exact e.length_le _ _ he.1)
    apply hf _ _ hs'
    simpa only [eval_liftSub, eval_subst] using he.2
  | loop c a f hc ha hf =>
    refine ⟨hc _ _ hs he.1, ha _ _ hs he.2.1, ?_⟩
    intro i hi
    have hi' : i < (c.eval (fun j => (s j).eval S)).length := by simpa only [eval_subst] using hi
    have hid : i ≤ B := (Nat.le_of_lt hi').trans (c.length_le _ _ he.1)
    have hv : (stages f.eval (fun j => (s j).eval S) (a.eval (fun j => (s j).eval S)) i).length ≤ B := by
      cases i with
      | zero => exact a.length_le _ _ he.2.1
      | succ i => exact f.length_le _ _ (he.2.2 i (by omega))
    have hst := stages_subst s f.eval (f.subst (liftSub (liftSub s))).eval
      (fun S => eval_subst _ _ S) S (a.eval (fun j => (s j).eval S)) i
    simp only [eval_subst] at *
    rw [hst]
    apply hf _ _ (bounded_liftSub _ _ _ _
      (bounded_liftSub _ _ _ _ hs (by simpa using hid)) hv)
    simpa only [eval_liftSub] using he.2.2 i hi'

end WordExpressions.Expr

end WLIdentification

end OAI