import OAI.Computability.WLIdentification.ExpressionBounds

namespace OAI

namespace WLIdentification

namespace WordExpressions
open ComputationBounds

/-- Uniform polynomial boundedness of a fixed word expression. This is a
proven realizer property, not an oracle or a unit-cost word instruction. -/
def Poly {n : ℕ} (f : (Fin n → Word) → Word) : Prop :=
  ∃ (e : Expr n) (B : ℕ → ℕ), Polynomial B ∧
    (∀ S, e.eval S = f S) ∧
    ∀ S N, (∀ i, (S i).length ≤ N) → e.Bounded S (B N)

namespace Poly

variable {n m : ℕ}

theorem congr {f g : (Fin n → Word) → Word} (h : Poly f) (he : ∀ S, f S = g S) : Poly g := by
  obtain ⟨e,B,hB,heval,hb⟩ := h
  exact ⟨e,B,hB,fun S => (heval S).trans (he S),hb⟩

theorem var (i : Fin n) : Poly (fun S : Fin n → Word => S i) :=
  ⟨.var i, id, identity, fun _ => rfl, fun _ _ h => h i⟩

theorem nil : Poly (fun _ : Fin n → Word => []) :=
  ⟨.nil, fun _ => 0, constant 0, fun _ => rfl, fun _ _ _ => trivial⟩

theorem snoc {f : (Fin n → Word) → Word} (h : Poly f) (b : Bool) : Poly (fun S => f S ++ [b]) := by
  obtain ⟨e,B,hB,he,hb⟩ := h
  refine ⟨.snoc e b, fun N => B N+1, add hB (constant 1), fun S => ?_, ?_⟩
  · simp only [Expr.eval, he]
  · intro S N hS
    try dsimp only
    have hh := hb S N hS
    refine ⟨e.bounded_mono hh (by omega), ?_⟩
    simpa only [List.length_append, List.length_singleton] using
      (Nat.add_le_add_right (e.length_le _ _ hh) 1)

theorem drop {f : (Fin n → Word) → Word} (h : Poly f) : Poly (fun S => (f S).dropLast) := by
  obtain ⟨e,B,hB,he,hb⟩ := h
  exact ⟨.drop e, B,hB,fun S => congrArg List.dropLast (he S),hb⟩

theorem const (w : Word) : Poly (fun _ : Fin n → Word => w) := by
  induction w using List.reverseRecOn with
  | nil => exact nil
  | append_singleton w b ih => exact snoc ih b

theorem cases {f p q r : (Fin n → Word) → Word} (hf : Poly f) (hp : Poly p) (hq : Poly q) (hr : Poly r) :
    Poly (fun S => match (f S).getLast? with
      | none => p S
      | some false => q S
      | some true => r S) := by
  obtain ⟨e,B,hB,he,hb⟩ := hf
  obtain ⟨a,A,hA,ha,hab⟩ := hp
  obtain ⟨c,C,hC,hc,hcb⟩ := hq
  obtain ⟨d,D,hD,hd,hdb⟩ := hr
  refine ⟨.cases e a c d, fun N => B N+A N+C N+D N, add (add (add hB hA) hC) hD, ?_, ?_⟩
  · intro S
    simp only [Expr.eval, he]
    cases (f S).getLast? with
    | none => exact ha S
    | some b => cases b <;> first | exact hc S | exact hd S
  · intro S N hS
    try dsimp only
    refine ⟨e.bounded_mono (hb S N hS) (by omega), ?_⟩
    cases (e.eval S).getLast? with
    | none => exact a.bounded_mono (hab S N hS) (by omega)
    | some b => cases b with
      | false => exact c.bounded_mono (hcb S N hS) (by omega)
      | true => exact d.bounded_mono (hdb S N hS) (by omega)

theorem rename {f : (Fin n → Word) → Word} (hf : Poly f) (r : Fin n → Fin m) :
    Poly (fun S => f (S ∘ r)) := by
  obtain ⟨e,B,hB,he,hb⟩ := hf
  exact ⟨e.rename r,B,hB,fun S => (e.eval_rename r S).trans (he _),
    fun S N hS => (e.bounded_rename r S _).mpr (hb _ _ (fun i => hS (r i)))⟩

theorem bind {f : (Fin n → Word) → Word} {g : (Fin (n+1) → Word) → Word}
    (hf : Poly f) (hg : Poly g) : Poly (fun S => g (Fin.snoc S (f S))) := by
  obtain ⟨e,B,hB,he,hb⟩ := hf
  obtain ⟨a,A,hA,ha,hab⟩ := hg
  refine ⟨.bind e a, fun N => B N+A (N+B N), add hB (compose hA (add identity hB)), ?_, ?_⟩
  · intro S
    simp only [Expr.eval, ha, he]
  · intro S N hS
    try dsimp only
    have hs := hb S N hS
    refine ⟨e.bounded_mono hs (by omega), ?_⟩
    apply a.bounded_mono (hab _ (N+B N) ?_) (by omega)
    intro i
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simpa only [Fin.snoc_last] using (e.length_le _ _ hs).trans (by omega : B N ≤ N+B N)
    · simpa only [Fin.snoc_castSucc] using (hS j).trans (by omega : N ≤ N+B N)

theorem subst {f : (Fin n → Word) → Word} {g : Fin n → (Fin m → Word) → Word}
    (hf : Poly f) (hg : ∀ i, Poly (g i)) : Poly (fun S => f (fun i => g i S)) := by
  classical
  obtain ⟨e,B,hB,he,hb⟩ := hf
  choose a A hA ha hab using hg
  let D : ℕ → ℕ := fun N => ∑ i, A i N
  have hfin (s : Finset (Fin n)) : Polynomial (fun N => ∑ i ∈ s, A i N) := by
    induction s using Finset.induction_on with
    | empty => simpa using constant 0
    | @insert i s hi ih => simpa only [Finset.sum_insert hi] using add (hA i) ih
  have hD : Polynomial D := hfin Finset.univ
  have hAD (i : Fin n) (N : ℕ) : A i N ≤ D N := by
    exact Finset.single_le_sum (f := fun i => A i N) (fun j _ => Nat.zero_le _) (Finset.mem_univ i)
  refine ⟨e.subst a, fun N => D N+B (D N), add hD (compose hB hD), ?_, ?_⟩
  · intro S
    simp only [Expr.eval_subst, he, ha]
  · intro S N hS
    try dsimp only
    have hs i : (a i).Bounded S (D N) := (a i).bounded_mono (hab i S N hS) (hAD i N)
    apply e.bounded_subst a S _ (fun i => (a i).bounded_mono (hs i) (by omega))
    exact e.bounded_mono (hb _ (D N) (fun i => (a i).length_le _ _ (hs i))) (by omega)

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

/-- Polynomial bounded loop rule. The index and accumulator bounds are
mathematical invariants of the actual semantics; no execution primitive is added. -/
theorem loop {c a : (Fin n → Word) → Word} {f : (Fin (n+2) → Word) → Word}
    (hc : Poly c) (ha : Poly a) (hf : Poly f) (H : ℕ → ℕ) (hH : Polynomial H)
    (hstage : ∀ S N, (∀ j, (S j).length ≤ N) → ∀ i ≤ (c S).length,
      (Expr.stages f S (a S) i).length ≤ H N) :
    Poly (fun S => Expr.stages f S (a S) (c S).length) := by
  obtain ⟨ce,C,hC,hce,hcb⟩ := hc
  obtain ⟨ae,A,hA,hae,hab⟩ := ha
  obtain ⟨fe,F,hF,hfe,hfb⟩ := hf
  let D := fun N => C N+A N+F (N+C N+H N)
  have hp : Polynomial D := add (add hC hA) (compose hF (add (add identity hC) hH))
  refine ⟨.loop ce ae fe, D,hp,?_,?_⟩
  · intro S
    simp only [Expr.eval, hce, hae]
    exact stages_congr hfe _ _ _
  · intro S N hS
    try dsimp only
    have hcS := hcb S N hS
    have haS := hab S N hS
    refine ⟨ce.bounded_mono hcS (by dsimp [D]; omega),
      ae.bounded_mono haS (by dsimp [D]; omega), ?_⟩
    intro i hi
    apply fe.bounded_mono (hfb _ (N+C N+H N) ?_) (by dsimp [D]; omega)
    intro j
    refine Fin.lastCases ?_ (fun j => ?_) j
    · simp only [Fin.snoc_last, hae, stages_congr hfe]
      have hi' : i ≤ (c S).length := by rw [← hce]; omega
      exact (hstage S N hS i hi').trans (by omega)
    · refine Fin.lastCases ?_ (fun k => ?_) j
      · simp only [Fin.snoc_castSucc, Fin.snoc_last, List.length_replicate]
        have := ce.length_le _ _ hcS
        omega
      · simpa only [Fin.snoc_castSucc] using (hS k).trans (by omega : N ≤ N+C N+H N)

end Poly
end WordExpressions

namespace WordExpressions

abbrev unary (n : ℕ) : Word := List.replicate n false
abbrev boolWord (b : Bool) : Word := [b]

def old {n : ℕ} (i : Fin n) : Fin (n+2) := i.castSucc.castSucc
def index (n : ℕ) : Fin (n+2) := (Fin.last n).castSucc
def accum (n : ℕ) : Fin (n+2) := Fin.last (n+1)

@[simp] theorem extend_old {n} (S : Fin n → Word) (u v : Word) (i : Fin n) :
    (Fin.snoc (Fin.snoc S u) v : Fin (n+2) → Word) (old i) = S i := by simp [old]
@[simp] theorem extend_index {n} (S : Fin n → Word) (u v : Word) :
    (Fin.snoc (Fin.snoc S u) v : Fin (n+2) → Word) (index n) = u := by simp [index]
@[simp] theorem extend_accum {n} (S : Fin n → Word) (u v : Word) :
    (Fin.snoc (Fin.snoc S u) v : Fin (n+2) → Word) (accum n) = v := by simp [accum]

@[simp] theorem snoc_prefix {n} (S : Fin n → Word) (u : Word) :
    (Fin.snoc S u : Fin (n+1) → Word) ∘ Fin.castSucc = S := by
  funext i; simp
@[simp] theorem extend_prefix {n} (S : Fin n → Word) (u v : Word) :
    (Fin.snoc (Fin.snoc S u) v : Fin (n+2) → Word) ∘ Fin.castSucc = Fin.snoc S u := by
  funext i; simp
@[simp] theorem extend_base {n} (S : Fin n → Word) (u v : Word) :
    (Fin.snoc (Fin.snoc S u) v : Fin (n+2) → Word) ∘ old = S := by
  funext i; simp

namespace Poly
variable {n : ℕ}

theorem branches {p : (Fin n → Word) → Bool} {f g : (Fin n → Word) → Word}
    (hp : Poly (fun S => boolWord (p S))) (hf : Poly f) (hg : Poly g) :
    Poly (fun S => if p S then f S else g S) := by
  apply (cases hp hg hg hf).congr
  intro S
  cases p S <;> rfl

theorem emptyTest {f : (Fin n → Word) → Word} (hf : Poly f) :
    Poly (fun S => boolWord (decide (f S = []))) := by
  apply (cases hf (const [true]) (const [false]) (const [false])).congr
  intro S
  cases he : (f S).getLast? with
  | none =>
    have hz : f S = [] := List.getLast?_eq_none_iff.mp he
    simp [hz, boolWord]
  | some b =>
    have hz : f S ≠ [] := by intro h; simp [h] at he
    cases b <;> simp [hz, boolWord]

theorem length (i : Fin n) : Poly (fun S : Fin n → Word => unary (S i).length) := by
  let body : (Fin (n+2) → Word) → Word := fun T => T (accum n) ++ [false]
  have hb : Poly body := snoc (var _) false
  have hs (S : Fin n → Word) (k : ℕ) : Expr.stages body S [] k = unary k := by
    induction k with
    | zero => rfl
    | succ k ih => simp only [Expr.stages, body, extend_accum, ih, unary, List.replicate_succ']
  obtain h := loop (var i) nil hb id ComputationBounds.identity (by
    intro S N hS k hk
    rw [hs]
    simpa using hk.trans (hS i))
  exact h.congr (fun S => hs S _)

theorem unaryLength {f : (Fin n → Word) → Word} (hf : Poly f) :
    Poly (fun S => unary (f S).length) := by
  have h := (length (0 : Fin 1)).subst (g := fun _ => f) (fun _ => hf)
  exact h.congr (fun _ => rfl)

theorem stages_drop {n} (S : Fin n → Word) (w : Word) (k : ℕ) :
    Expr.stages (fun T => (T (accum n)).dropLast) S w k = w.take (w.length-k) := by
  induction k with
  | zero => simp [Expr.stages]
  | succ k ih =>
    simp only [Expr.stages, extend_accum]
    rw [ih]
    simp only [List.dropLast_eq_take, List.length_take, List.take_take]
    congr 1
    omega

theorem cut (i j : Fin n) : Poly (fun S : Fin n → Word => (S i).take ((S i).length-(S j).length)) := by
  have hstep : Poly (fun T : Fin (n+2) → Word => (T (accum n)).dropLast) := drop (var _)
  have h := loop (var j) (var i) hstep id ComputationBounds.identity (by
    intro S N hS k _
    rw [stages_drop]
    simp only [List.length_take]
    exact (min_le_right _ _).trans (hS i))
  exact h.congr (fun S => stages_drop S _ _)

theorem cutOf {f g : (Fin n → Word) → Word} (hf : Poly f) (hg : Poly g) :
    Poly (fun S => (f S).take ((f S).length-(g S).length)) := by
  have h := (cut (0 : Fin 2) 1).subst (g := ![f,g]) (by intro i; fin_cases i; exacts [hf,hg])
  exact h.congr (fun _ => rfl)

theorem sub {f g : (Fin n → Word) → Word} (hf : Poly f) (hg : Poly g) :
    Poly (fun S => unary ((f S).length-(g S).length)) := by
  apply (cutOf (unaryLength hf) hg).congr
  intro S
  simp [unary, List.take_replicate]

theorem le {f g : (Fin n → Word) → Word} (hf : Poly f) (hg : Poly g) :
    Poly (fun S => boolWord (decide ((f S).length ≤ (g S).length))) := by
  apply (emptyTest (sub hf hg)).congr
  intro S
  simp [unary, Nat.sub_eq_zero_iff_le]

theorem stages_add {n} (S : Fin n → Word) (a k : ℕ) :
    Expr.stages (fun T => T (accum n) ++ [false]) S (unary a) k = unary (a+k) := by
  induction k with
  | zero => rfl
  | succ k ih =>
    simp only [Expr.stages, extend_accum, ih, unary]
    rw [← Nat.add_assoc, List.replicate_succ']

theorem add (i j : Fin n) : Poly (fun S : Fin n → Word => unary ((S i).length+(S j).length)) := by
  have h := loop (var j) (length i) (snoc (var (accum n)) false)
    (fun N => N+N) (ComputationBounds.add ComputationBounds.identity ComputationBounds.identity) (by
      intro S N hS k hk
      rw [stages_add]
      simp only [unary, List.length_replicate]
      exact Nat.add_le_add (hS i) (hk.trans (hS j)))
  exact h.congr (fun S => stages_add S _ _)

theorem addOf {f g : (Fin n → Word) → Word} (hf : Poly f) (hg : Poly g) :
    Poly (fun S => unary ((f S).length+(g S).length)) := by
  have h := (add (0 : Fin 2) 1).subst (g := ![f,g]) (by intro i; fin_cases i; exacts [hf,hg])
  exact h.congr (fun _ => rfl)

end Poly
end WordExpressions

end WLIdentification

end OAI