import Mathlib
import OAI.Computability.DirectedFeedback.RankGraph.Store

namespace OAI


namespace DirectedFeedback.BoundedExpr
open StackDSL StackDSL.Code StackDSL.Ops

structure Layout (r : Nat) where
  input : Nat
  args : Fin r → Nat
  output : Nat
  fresh : Nat
  input_lt : input < fresh
  args_lt : ∀ i, args i < fresh
  output_lt : output < fresh
  input_ne : input ≠ output
  args_ne : ∀ i, args i ≠ output

namespace Layout
variable {r : Nat} (L : Layout r)

def temp (j d : Nat) (h : j < d) : Layout r where
  input := L.input
  args := L.args
  output := L.fresh+j
  fresh := L.fresh+d
  input_lt := by have := L.input_lt; omega
  args_lt := by intro i; have := L.args_lt i; omega
  output_lt := by omega
  input_ne := by have := L.input_lt; omega
  args_ne := by intro i; have := L.args_lt i; omega

def sumBody : Layout (r+1) where
  input := L.input
  args := Fin.cons (L.fresh+1) L.args
  output := L.output
  fresh := L.fresh+2
  input_lt := by have := L.input_lt; omega
  args_lt := by intro i; refine Fin.cases ?_ (fun i => ?_) i
                · simp
                · simpa using (L.args_lt i).trans (by omega : L.fresh < L.fresh+2)
  output_lt := by have := L.output_lt; omega
  input_ne := L.input_ne
  args_ne := by intro i; refine Fin.cases ?_ (fun i => ?_) i
                · simp; have := L.output_lt; omega
                · simpa using L.args_ne i

structure Ready (s : Store Nat Bool) (input : List Bool) (args : Fin r → Nat) : Prop where
  input_eq : s.tape L.input = input
  args_eq : ∀ i, s.tape (L.args i) = List.replicate (args i) true
  clean : ∀ k, L.fresh ≤ k → s.tape k = []

namespace Ready
variable {L : Layout r} {s : Store Nat Bool} {x : List Bool} {a : Fin r → Nat}

 theorem flag (h : L.Ready s x a) (b : Bool) : L.Ready (s.flag b) x a := ⟨h.input_eq,h.args_eq,h.clean⟩

 theorem temp (h : L.Ready s x a) (j d : Nat) (hjd : j<d) : (L.temp j d hjd).Ready s x a where
  input_eq := h.input_eq
  args_eq := h.args_eq
  clean := by intro k hk; apply h.clean; change L.fresh+d ≤ k at hk; omega

 theorem put (h : L.Ready s x a) (k : Nat) (v : List Bool) (hk : k<L.fresh)
    (hki : L.input ≠ k) (hka : ∀ i, L.args i ≠ k) : L.Ready (s.put k v) x a where
  input_eq := by simpa [hki] using h.input_eq
  args_eq := by intro i; simpa [hka i] using h.args_eq i
  clean := by intro j hj; rw [Store.put_tape_other _ (by omega)]; exact h.clean j hj

 theorem output (h : L.Ready s x a) (v : List Bool) : L.Ready (s.put L.output v) x a :=
  h.put L.output v L.output_lt L.input_ne L.args_ne

 theorem temp_put (h : L.Ready s x a) (j d k : Nat) (hjd : j<d) (hkd : k<d) (v : List Bool) :
    (L.temp j d hjd).Ready (s.put (L.fresh+k) v) x a := by
  apply (h.temp j d hjd).put (L.fresh+k) v
  · change L.fresh+k < L.fresh+d; omega
  · change L.input ≠ L.fresh+k; have := L.input_lt; omega
  · intro i; change L.args i ≠ L.fresh+k; have := L.args_lt i; omega

end Ready
end Layout

namespace Expr

def Correct {r : Nat} (e : Expr r) : Prop :=
  ∀ (L : Layout r) (x : List Bool) (a : Fin r → Nat) (s : Store Nat Bool), L.Ready s x a →
    (e.compile L.input L.args L.output L.fresh).Exec s (e.cost x a)
      ((s.put L.output (List.replicate (e.eval x a) true ++ s.tape L.output)).flag false)

theorem correct_lit {r : Nat} (n : Nat) : Correct (Expr.lit (r := r) n) := by
  intro L x a s h
  exact pushN_run L.output n s

theorem correct_arg {r : Nat} (i : Fin r) : Correct (Expr.arg i) := by
  intro L x a s h
  have ht := h.clean L.fresh (by omega)
  have hr := copy_run (L.args i) L.output L.fresh (L.args_ne i)
    (Nat.ne_of_lt (L.args_lt i)) (Nat.ne_of_lt L.output_lt) s ht
  simpa [h.args_eq i,eval,cost] using hr

theorem correct_length {r : Nat} : Correct (Expr.length (r := r)) := by
  intro L x a s h
  have ht := h.clean L.fresh (by omega)
  have hr := count_run L.input L.output L.fresh L.input_ne
    (Nat.ne_of_lt L.input_lt) (Nat.ne_of_lt L.output_lt) s ht
  simpa [h.input_eq,eval,cost] using hr

theorem correct_add {r : Nat} {e f : Expr r} (he : e.Correct) (hf : f.Correct) : (e.add f).Correct := by
  intro L x a s h
  have h1 := he L x a s h
  have h2 := hf L x a _ ((h.output (List.replicate (e.eval x a) true ++ s.tape L.output)).flag false)
  have hh := Exec.seq h1 h2
  convert hh using 1 <;> try rfl
  simp only [eval,Store.put_tape_same,Store.flag_tape,Store.put_flag,Store.put_put,Store.flag_flag]
  rw [← List.append_assoc,← List.replicate_add, Nat.add_comm]

end Expr
end DirectedFeedback.BoundedExpr


namespace DirectedFeedback.BoundedExpr.Expr
open StackDSL StackDSL.Code StackDSL.Ops
open scoped BigOperators

theorem correct_mul {r : Nat} {e g : Expr r} (he : e.Correct) (hg : g.Correct) : (e.mul g).Correct := by
  intro L x a s h
  let u := e.eval x a
  let v := g.eval x a
  have hfo : L.fresh ≠ L.output := (Nat.ne_of_lt L.output_lt).symm
  have h1o : L.fresh+1 ≠ L.output := by have := L.output_lt; omega
  have h2o : L.fresh+2 ≠ L.output := by have := L.output_lt; omega
  have hs0 := h.clean L.fresh (by omega)
  have hs1 := h.clean (L.fresh+1) (by omega)
  have hs2 := h.clean (L.fresh+2) (by omega)
  have h1 := he (L.temp 0 2 (by omega)) x a s (h.temp 0 2 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  have h2 := hg (L.temp 1 2 (by omega)) x a
    ((s.put L.fresh (List.replicate u true)).flag false)
    ((h.temp_put 1 2 0 (by omega) (by omega) (List.replicate u true)).flag false)
  simp only [Layout.temp,Store.flag_tape,Store.put_tape_other _ (by omega : L.fresh+1 ≠ L.fresh),
    hs1,List.append_nil,Store.put_flag,Store.flag_flag] at h2
  let states := fun i : Nat =>
    ((((s.put (L.fresh+1) (List.replicate v true)).put L.fresh (List.replicate (u-i) true)).put
      L.output (List.replicate (i*v) true ++ s.tape L.output)).flag false)
  have hp : ∀ i, (copy (L.fresh+1) L.output (L.fresh+2)).Exec
      ((states i).put L.fresh (List.replicate (u-(i+1)) true)) (5*v+4) (states (i+1)) := by
    intro i
    have hr := copy_run (L.fresh+1) L.output (L.fresh+2) h1o (by omega) (by omega : L.output ≠ L.fresh+2)
      ((states i).put L.fresh (List.replicate (u-(i+1)) true)) (by simp [states,hs2,h2o])
    have hb : (((states i).put L.fresh (List.replicate (u-(i+1)) true)).tape (L.fresh+1)) =
        List.replicate v true := by simp [states,h1o]
    rw [hb,List.length_replicate] at hr
    convert hr using 1
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hk : k=L.output
    · subst k
      simp only [states,Store.flag_tape,Store.put_tape_same,Store.put_tape_other _ (Ne.symm hfo)]
      rw [← List.append_assoc,← List.replicate_add]
      congr 2
      ring
    · by_cases h0 : k=L.fresh <;> by_cases h1 : k=L.fresh+1 <;>
        simp_all [states,Store.put,Store.flag]
  have hlo := scan_indexed L.fresh (copy (L.fresh+1) L.output (L.fresh+2)) u states
    (fun _ => 5*v+4) (by intro i hi; simp [states,hfo]) (by intro i hi; exact hp i)
  have hstart : states 0 = (((s.put L.fresh (List.replicate u true)).put
      (L.fresh+1) (List.replicate v true)).flag false) := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hk : k=L.output <;> by_cases h0 : k=L.fresh <;> by_cases h1 : k=L.fresh+1 <;>
      simp_all [states,Store.put,Store.flag]
  rw [hstart] at hlo
  have hc := clear_run (L.fresh+1) (states u)
  have hcval : (states u).tape (L.fresh+1) = List.replicate v true := by simp [states,h1o]
  rw [hcval,List.length_replicate] at hc
  have hend : (states u).put (L.fresh+1) [] =
      (s.put L.output (List.replicate (u*v) true ++ s.tape L.output)).flag false := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hk : k=L.output <;> by_cases h0 : k=L.fresh <;> by_cases h1 : k=L.fresh+1 <;>
      simp_all [states,Store.put,Store.flag]
  rw [hend] at hc
  have hh := Exec.seq h1 (Exec.seq h2 (Exec.seq hlo hc))
  convert hh using 1 <;> try rfl
  simp only [cost,Finset.sum_const,Finset.card_range,smul_eq_mul]
  dsimp [u,v]
  ring

end DirectedFeedback.BoundedExpr.Expr


namespace DirectedFeedback.BoundedExpr.Expr
open StackDSL StackDSL.Code StackDSL.Ops

theorem correct_sub {r : Nat} {e g : Expr r} (he : e.Correct) (hg : g.Correct) : (e.sub g).Correct := by
  intro L x a s h
  let u := e.eval x a
  let v := g.eval x a
  have hfo : L.fresh ≠ L.output := (Nat.ne_of_lt L.output_lt).symm
  have h1o : L.fresh+1 ≠ L.output := by have := L.output_lt; omega
  have hs0 := h.clean L.fresh (by omega)
  have hs1 := h.clean (L.fresh+1) (by omega)
  have h1 := he (L.temp 0 2 (by omega)) x a s (h.temp 0 2 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  have h2 := hg (L.temp 1 2 (by omega)) x a
    ((s.put L.fresh (List.replicate u true)).flag false)
    ((h.temp_put 1 2 0 (by omega) (by omega) (List.replicate u true)).flag false)
  simp only [Layout.temp,Store.flag_tape,Store.put_tape_other _ (by omega : L.fresh+1 ≠ L.fresh),
    hs1,List.append_nil,Store.put_flag,Store.flag_flag] at h2
  have hr := subtract_run L.fresh (L.fresh+1) (by omega) u v (s.flag false)
  simp only [Store.put_flag] at hr
  have ht := transfer_run L.fresh L.output hfo
    (((s.put L.fresh (List.replicate (u-v) true)).put (L.fresh+1) []).flag false)
  have hv : (((s.put L.fresh (List.replicate (u-v) true)).put (L.fresh+1) []).flag false).tape L.fresh =
      List.replicate (u-v) true := by simp
  rw [hv,List.length_replicate,List.reverse_replicate] at ht
  have hend : (((((s.put L.fresh (List.replicate (u-v) true)).put (L.fresh+1) []).flag false).put L.fresh []).put
      L.output (List.replicate (u-v) true ++
        (((s.put L.fresh (List.replicate (u-v) true)).put (L.fresh+1) []).flag false).tape L.output)).flag false =
      (s.put L.output (List.replicate (u-v) true ++ s.tape L.output)).flag false := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hk : k=L.output <;> by_cases h0 : k=L.fresh <;> by_cases h1 : k=L.fresh+1 <;>
      simp_all [Store.put,Store.flag]
  rw [hend] at ht
  have hh := Exec.seq h1 (Exec.seq h2 (Exec.seq hr ht))
  convert hh using 1 <;> try rfl
  dsimp [cost,u,v]
  omega

end DirectedFeedback.BoundedExpr.Expr


namespace DirectedFeedback.BoundedExpr.Expr
open StackDSL StackDSL.Code StackDSL.Ops
open scoped BigOperators

theorem correct_sum {r : Nat} {b : Expr r} {e : Expr (r+1)}
    (hb : b.Correct) (he : e.Correct) : (b.sum e).Correct := by
  intro L x a s h
  let n := b.eval x a
  let sums := fun i => ∑ j ∈ Finset.range i, e.eval x (Fin.cons j a)
  have hfo : L.fresh ≠ L.output := (Nat.ne_of_lt L.output_lt).symm
  have h1o : L.fresh+1 ≠ L.output := by have := L.output_lt; omega
  have hfi : L.input ≠ L.fresh := Nat.ne_of_lt L.input_lt
  have h1i : L.input ≠ L.fresh+1 := by have := L.input_lt; omega
  have hfa : ∀ j, L.args j ≠ L.fresh := fun j => Nat.ne_of_lt (L.args_lt j)
  have h1a : ∀ j, L.args j ≠ L.fresh+1 := by intro j; have := L.args_lt j; omega
  have hs0 := h.clean L.fresh (by omega)
  have hs1 := h.clean (L.fresh+1) (by omega)
  have h1 := hb (L.temp 0 2 (by omega)) x a s (h.temp 0 2 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  let states := fun i =>
    ((((s.put (L.fresh+1) (List.replicate i true)).put L.fresh (List.replicate (n-i) true)).put
      L.output (List.replicate (sums i) true ++ s.tape L.output)).flag false)
  have hrdy : ∀ i, L.sumBody.Ready ((states i).put L.fresh (List.replicate (n-(i+1)) true))
      x (Fin.cons i a) := by
    intro i
    constructor
    · simp [states,Layout.sumBody,hfi,h1i,L.input_ne,h.input_eq]
    · intro j
      refine Fin.cases ?_ (fun j => ?_) j
      · simp [states,Layout.sumBody,h1o]
      · simp [states,Layout.sumBody,hfa,h1a,L.args_ne,h.args_eq]
    · intro k hk
      change L.fresh+2 ≤ k at hk
      have hk0 : k≠L.fresh := by omega
      have hk1 : k≠L.fresh+1 := by omega
      have hko : k≠L.output := by have := L.output_lt; omega
      simp [states,hk0,hk1,hko,h.clean k (by omega)]
  have hp : ∀ i, (Code.seq (e.compile L.input (Fin.cons (L.fresh+1) L.args) L.output (L.fresh+2))
      (push (L.fresh+1) true)).Exec
      ((states i).put L.fresh (List.replicate (n-(i+1)) true))
      (e.cost x (Fin.cons i a)+1) (states (i+1)) := by
    intro i
    have hbody := he L.sumBody x (Fin.cons i a)
      ((states i).put L.fresh (List.replicate (n-(i+1)) true)) (hrdy i)
    have hpush := push_run ((((states i).put L.fresh (List.replicate (n-(i+1)) true)).put L.output
      (List.replicate (e.eval x (Fin.cons i a)) true ++
        ((states i).put L.fresh (List.replicate (n-(i+1)) true)).tape L.output)).flag false)
      (L.fresh+1) true
    have hh := Exec.seq hbody hpush
    convert hh using 1 <;> try rfl
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hko : k=L.output
    · subst k
      simp only [states,Store.flag_tape,Store.put_tape_same,Store.put_tape_other _ (Ne.symm hfo),
        Store.put_tape_other _ (Ne.symm h1o)]
      rw [← List.append_assoc,← List.replicate_add]
      congr 2
      simp only [sums,Finset.sum_range_succ]
      omega
    · by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
        simp_all [states,Store.put,Store.flag,List.replicate_succ]
  have hlo := scan_indexed L.fresh
    (Code.seq (e.compile L.input (Fin.cons (L.fresh+1) L.args) L.output (L.fresh+2)) (push (L.fresh+1) true))
    n states (fun i => e.cost x (Fin.cons i a)+1)
    (by intro i hi; simp [states,hfo]) (by intro i hi; exact hp i)
  have hstart : states 0 = (s.put L.fresh (List.replicate n true)).flag false := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hko : k=L.output <;> by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
      simp_all [states,sums,Store.put,Store.flag]
  rw [hstart] at hlo
  have hc := clear_run (L.fresh+1) (states n)
  have hcval : (states n).tape (L.fresh+1) = List.replicate n true := by simp [states,h1o]
  rw [hcval,List.length_replicate] at hc
  have hend : (states n).put (L.fresh+1) [] =
      (s.put L.output (List.replicate (sums n) true ++ s.tape L.output)).flag false := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hko : k=L.output <;> by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
      simp_all [states,Store.put,Store.flag]
  rw [hend] at hc
  have hh := Exec.seq h1 (Exec.seq hlo hc)
  convert hh using 1 <;> try rfl
  simp only [cost,Finset.sum_add_distrib,Finset.sum_const,Finset.card_range,smul_eq_mul,mul_one]
  dsimp [n]
  omega

end DirectedFeedback.BoundedExpr.Expr


namespace DirectedFeedback.BoundedExpr.Expr
open StackDSL StackDSL.Code StackDSL.Ops

theorem terminal_run (output : Nat) (s : Store Nat Bool) :
    (Code.seq (.branch id (push output true) idle) reset).Exec s 3
      ((s.put output (List.replicate (if s.state then 1 else 0) true ++ s.tape output)).flag false) := by
  cases hb : s.state with
  | false =>
    have h1 := Exec.branch_false (f := id) (c := push output true) (d := idle) hb (idle_run s)
    have h2 := Exec.seq h1 (reset_run s)
    simpa [hb] using h2
  | true =>
    have h1 := Exec.branch_true (f := id) (c := push output true) (d := idle) hb (push_run s output true)
    have h2 := Exec.seq h1 (reset_run _)
    simpa [hb] using h2

theorem correct_zero {r : Nat} {e : Expr r} (he : e.Correct) : e.zero.Correct := by
  intro L x a s h
  let u := e.eval x a
  have hfo : L.fresh ≠ L.output := (Nat.ne_of_lt L.output_lt).symm
  have hs0 := h.clean L.fresh (by omega)
  have h1 := he (L.temp 0 1 (by omega)) x a s (h.temp 0 1 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  let s1 := (s.put L.fresh (List.replicate u true)).flag false
  have hp : (Code.atom (.peek L.fresh (fun _ x => x.isNone))).Exec s1 1
      ((s.put L.fresh (List.replicate u true)).flag (decide (u=0))) := by
    convert Exec.atom (.peek L.fresh (fun _ x => x.isNone)) s1 using 1
    dsimp [s1,Prim.run,Store.put,Store.flag]
    cases u <;> simp
  have hc := clear_run L.fresh ((s.put L.fresh (List.replicate u true)).flag (decide (u=0)))
  simp only [Store.flag_tape,Store.put_tape_same,List.length_replicate,Store.put_flag,Store.put_put] at hc
  have hz : s.put L.fresh [] = s := by rw [← hs0,Store.put_self]
  rw [hz] at hc
  have ht := terminal_run L.output (s.flag (decide (u=0)))
  have hh := Exec.seq h1 (Exec.seq hp (Exec.seq hc ht))
  convert hh using 1 <;> try rfl
  · dsimp [cost,u]; omega
  · simp [eval,u]

end DirectedFeedback.BoundedExpr.Expr


namespace DirectedFeedback.BoundedExpr.Expr
open StackDSL StackDSL.Code StackDSL.Ops

theorem correct_bit {r : Nat} {e : Expr r} (he : e.Correct) : e.bit.Correct := by
  intro L x a s h
  let u := e.eval x a
  have hfi : L.input ≠ L.fresh := Nat.ne_of_lt L.input_lt
  have h1i : L.input ≠ L.fresh+1 := by have := L.input_lt; omega
  have h2i : L.input ≠ L.fresh+2 := by have := L.input_lt; omega
  have hs0 := h.clean L.fresh (by omega)
  have hs1 := h.clean (L.fresh+1) (by omega)
  have hs2 := h.clean (L.fresh+2) (by omega)
  have h1 := he (L.temp 0 1 (by omega)) x a s (h.temp 0 1 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  have hcopy := copy_run L.input (L.fresh+1) (L.fresh+2) h1i h2i (by omega)
    ((s.put L.fresh (List.replicate u true)).flag false) (by simp [hs2])
  simp only [Store.flag_tape,Store.put_tape_other _ hfi,h.input_eq,
    Store.put_tape_other _ (by omega : L.fresh+1 ≠ L.fresh),hs1,List.append_nil,
    Store.put_flag,Store.flag_flag] at hcopy
  have hr := drop_run (L.fresh+1) L.fresh (by omega) x u (s.flag false)
  simp only [Store.put_flag] at hr
  rw [Store.put_comm _ (by omega : L.fresh+1 ≠ L.fresh)] at hr
  let s2 := ((s.put (L.fresh+1) (x.drop u)).put L.fresh []).flag false
  have hp : (Code.atom (.peek (L.fresh+1) (fun _ x => x.getD false))).Exec s2 1
      (((s.put (L.fresh+1) (x.drop u)).put L.fresh []).flag (x[u]?.getD false)) := by
    convert Exec.atom (.peek (L.fresh+1) (fun _ x => x.getD false)) s2 using 1
    dsimp [s2,Prim.run,Store.put,Store.flag]
    simp
  have hc := clear_run (L.fresh+1)
    (((s.put (L.fresh+1) (x.drop u)).put L.fresh []).flag (x[u]?.getD false))
  have htape : (((s.put (L.fresh+1) (x.drop u)).put L.fresh []).flag (x[u]?.getD false)).tape
      (L.fresh+1) = x.drop u := by simp
  rw [htape,List.length_drop] at hc
  have hz : ((((s.put (L.fresh+1) (x.drop u)).put L.fresh []).flag (x[u]?.getD false)).put
      (L.fresh+1) []) = s.flag (x[u]?.getD false) := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
      simp_all [Store.put,Store.flag]
  rw [hz] at hc
  have ht := terminal_run L.output (s.flag (x[u]?.getD false))
  have hh := Exec.seq h1 (Exec.seq hcopy (Exec.seq hr (Exec.seq hp (Exec.seq hc ht))))
  convert hh using 1 <;> try rfl
  dsimp [cost,u]
  omega

end DirectedFeedback.BoundedExpr.Expr


namespace DirectedFeedback.BoundedExpr.Expr

theorem correct {r : Nat} (e : Expr r) : e.Correct := by
  induction e with
  | lit n => exact correct_lit n
  | arg i => exact correct_arg i
  | length => exact correct_length
  | add e f ihe ihf => exact correct_add ihe ihf
  | mul e f ihe ihf => exact correct_mul ihe ihf
  | sub e f ihe ihf => exact correct_sub ihe ihf
  | zero e ih => exact correct_zero ih
  | bit e ih => exact correct_bit ih
  | sum b e ihb ihe => exact correct_sum ihb ihe

end DirectedFeedback.BoundedExpr.Expr


namespace DirectedFeedback.BoundedExpr
open StackDSL StackDSL.Code StackDSL.Ops
open scoped BigOperators

inductive Output : Nat → Type
  | nil {r : Nat} : Output r
  | bit {r : Nat} (b : Bool) : Output r
  | nat {r : Nat} (e : Expr r) : Output r
  | append {r : Nat} (a b : Output r) : Output r
  | loop {r : Nat} (bound : Expr r) (body : Output (r+1)) : Output r
  | when {r : Nat} (test : Expr r) (body : Output r) : Output r

namespace Output

def eval {r : Nat} (o : Output r) (input : List Bool) (args : Fin r → Nat) : List Bool :=
  match o with
  | .nil => []
  | .bit b => [b]
  | .nat e => List.replicate (e.eval input args) true ++ [false]
  | .append a b => a.eval input args ++ b.eval input args
  | .loop b e => (List.range (b.eval input args)).flatMap (fun i => e.eval input (Fin.cons i args))
  | .when t b => if t.eval input args = 0 then [] else b.eval input args

@[reducible] def compile {r : Nat} (o : Output r) (input : Nat) (args : Fin r → Nat)
    (out fresh : Nat) : Code Nat Bool :=
  match o with
  | .nil => reset
  | .bit b => .seq (push out b) reset
  | .nat e => .seq (e.compile input args out fresh) (push out false)
  | .append a b => .seq (a.compile input args out fresh) (b.compile input args out fresh)
  | .loop b e =>
    .seq (b.compile input args fresh (fresh+2))
      (.seq (.scan fresh (fun s _ => s)
        (.seq (e.compile input (Fin.cons (fresh+1) args) out (fresh+2)) (push (fresh+1) true)))
        (clear (fresh+1)))
  | .when t b =>
    .seq (t.compile input args fresh (fresh+1))
      (.seq (.atom (.peek fresh (fun _ x => x.isSome)))
        (.seq (clear fresh) (.branch id (b.compile input args out fresh) reset)))

def cost {r : Nat} (o : Output r) (input : List Bool) (args : Fin r → Nat) : Nat :=
  match o with
  | .nil => 1
  | .bit _ => 2
  | .nat e => e.cost input args+1
  | .append a b => a.cost input args+b.cost input args
  | .loop b e => b.cost input args+
      (∑ i ∈ Finset.range (b.eval input args), e.cost input (Fin.cons i args))+4*b.eval input args+2
  | .when t b => t.cost input args+2*t.eval input args+3+
      (if t.eval input args=0 then 1 else b.cost input args)

noncomputable def bound {r : Nat} : Output r → Polynomial Nat
  | .nil => 0
  | .bit _ => 1
  | .nat e => e.bound+1
  | .append a b => a.bound+b.bound
  | .loop b e => b.bound*e.bound.comp (Polynomial.X+b.bound)
  | .when _ b => b.bound

noncomputable def costBound {r : Nat} : Output r → Polynomial Nat
  | .nil => 1
  | .bit _ => 2
  | .nat e => e.costBound+1
  | .append a b => a.costBound+b.costBound
  | .loop b e => b.costBound+b.bound*e.costBound.comp (Polynomial.X+b.bound)+4*b.bound+2
  | .when t b => t.costBound+2*t.bound+4+b.costBound

theorem length_range_flatMap {α : Type} (n : Nat) (f : Nat → List α) :
    ((List.range n).flatMap f).length = ∑ i ∈ Finset.range n, (f i).length := by
  induction n with
  | zero => simp
  | succ n ih => simp [List.range_succ,Finset.sum_range_succ,List.flatMap_append,ih]

theorem length_le_bound {r : Nat} (o : Output r) (x : List Bool) (args : Fin r → Nat)
    (n : Nat) (hi : x.length ≤ n) (ha : ∀ i, args i ≤ n) : (o.eval x args).length ≤ o.bound.eval n := by
  induction o generalizing x n with
  | nil => simp [eval,bound]
  | bit b => simp [eval,bound]
  | nat e => simpa [eval,bound] using Nat.add_le_add_right (e.eval_le_bound x args n hi ha) 1
  | append a b iha ihb => simpa [eval,bound] using Nat.add_le_add (iha x args n hi ha) (ihb x args n hi ha)
  | when t b ih =>
    have hb := ih x args n hi ha
    simp only [eval,bound]
    split <;> simp_all
  | @loop r b e ihe =>
    have hb := b.eval_le_bound x args n hi ha
    have heach : ∀ i ∈ Finset.range (b.eval x args),
        (e.eval x (Fin.cons i args)).length ≤ e.bound.eval (n+b.bound.eval n) := by
      intro i hm
      have hsmall : i < b.eval x args := Finset.mem_range.mp hm
      apply ihe x (Fin.cons i args) (n+b.bound.eval n) (by omega)
      intro j
      refine Fin.cases ?_ (fun j => ?_) j
      · simpa using (show i ≤ n+b.bound.eval n by omega)
      · simpa using (ha j).trans (Nat.le_add_right n _)
    simp only [eval,bound,Polynomial.eval_mul,Polynomial.eval_comp,Polynomial.eval_add,Polynomial.eval_X,
      length_range_flatMap]
    calc
      _ ≤ ∑ _i ∈ Finset.range (b.eval x args), e.bound.eval (n+b.bound.eval n) := Finset.sum_le_sum heach
      _ = b.eval x args * e.bound.eval (n+b.bound.eval n) := by simp
      _ ≤ _ := Nat.mul_le_mul_right _ hb

theorem cost_le_bound {r : Nat} (o : Output r) (x : List Bool) (args : Fin r → Nat)
    (n : Nat) (hi : x.length ≤ n) (ha : ∀ i, args i ≤ n) : o.cost x args ≤ o.costBound.eval n := by
  induction o generalizing x n with
  | nil => simp [cost,costBound]
  | bit b => simp [cost,costBound]
  | nat e => simpa [cost,costBound] using Nat.add_le_add_right (e.cost_le_bound x args n hi ha) 1
  | append a b iha ihb => simpa [cost,costBound] using Nat.add_le_add (iha x args n hi ha) (ihb x args n hi ha)
  | when t b ih =>
    have h1 := t.cost_le_bound x args n hi ha
    have h2 := t.eval_le_bound x args n hi ha
    have h3 := ih x args n hi ha
    simp only [cost,costBound,Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat]
    split <;> omega
  | @loop r b e ihe =>
    have hb := b.eval_le_bound x args n hi ha
    have hbc := b.cost_le_bound x args n hi ha
    have heach : ∀ i ∈ Finset.range (b.eval x args),
        e.cost x (Fin.cons i args) ≤ e.costBound.eval (n+b.bound.eval n) := by
      intro i hm
      have hsmall : i < b.eval x args := Finset.mem_range.mp hm
      apply ihe x (Fin.cons i args) (n+b.bound.eval n) (by omega)
      intro j
      refine Fin.cases ?_ (fun j => ?_) j
      · simpa using (show i ≤ n+b.bound.eval n by omega)
      · simpa using (ha j).trans (Nat.le_add_right n _)
    have hs : (∑ i ∈ Finset.range (b.eval x args), e.cost x (Fin.cons i args)) ≤
        b.bound.eval n * e.costBound.eval (n+b.bound.eval n) := by
      calc
        _ ≤ ∑ _i ∈ Finset.range (b.eval x args), e.costBound.eval (n+b.bound.eval n) := Finset.sum_le_sum heach
        _ = b.eval x args * e.costBound.eval (n+b.bound.eval n) := by simp
        _ ≤ _ := Nat.mul_le_mul_right _ hb
    simp only [cost,costBound,Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,
      Polynomial.eval_comp,Polynomial.eval_X]
    omega

end Output
end DirectedFeedback.BoundedExpr


namespace DirectedFeedback.BoundedExpr.Output
open StackDSL StackDSL.Code StackDSL.Ops
open scoped BigOperators

def Correct {r : Nat} (e : Output r) : Prop :=
  ∀ (L : Layout r) (x : List Bool) (a : Fin r → Nat) (s : Store Nat Bool), L.Ready s x a →
    (e.compile L.input L.args L.output L.fresh).Exec s (e.cost x a)
      ((s.put L.output ((e.eval x a).reverse ++ s.tape L.output)).flag false)

theorem correct_nil {r : Nat} : Correct (Output.nil (r := r)) := by
  intro L x a s h
  simpa [cost,eval] using reset_run s

theorem correct_bit {r : Nat} (b : Bool) : Correct (Output.bit (r := r) b) := by
  intro L x a s h
  have hh := Exec.seq (push_run s L.output b) (reset_run _)
  simpa [cost,eval] using hh

theorem correct_nat {r : Nat} (e : Expr r) : Correct (Output.nat e) := by
  intro L x a s h
  have he := e.correct L x a s h
  have hh := Exec.seq he (push_run _ L.output false)
  convert hh using 1 <;> try rfl
  simp [eval,List.reverse_append]

theorem correct_append {r : Nat} {e f : Output r} (he : e.Correct) (hf : f.Correct) : (e.append f).Correct := by
  intro L x a s h
  have h1 := he L x a s h
  have h2 := hf L x a _ ((h.output ((e.eval x a).reverse ++ s.tape L.output)).flag false)
  have hh := Exec.seq h1 h2
  convert hh using 1 <;> try rfl
  simp [eval,List.reverse_append,List.append_assoc]

theorem correct_when {r : Nat} (t : Expr r) {o : Output r} (ho : o.Correct) : (Output.when t o).Correct := by
  intro L x a s h
  let u := t.eval x a
  have hs0 := h.clean L.fresh (by omega)
  have h1 := t.correct (L.temp 0 1 (by omega)) x a s (h.temp 0 1 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  let s1 := (s.put L.fresh (List.replicate u true)).flag false
  have hp : (Code.atom (.peek L.fresh (fun _ x => x.isSome))).Exec s1 1
      ((s.put L.fresh (List.replicate u true)).flag (decide (u≠0))) := by
    convert Exec.atom (.peek L.fresh (fun _ x => x.isSome)) s1 using 1
    dsimp [s1,Prim.run,Store.put,Store.flag]
    cases u <;> simp
  have hc := clear_run L.fresh ((s.put L.fresh (List.replicate u true)).flag (decide (u≠0)))
  simp only [Store.flag_tape,Store.put_tape_same,List.length_replicate,Store.put_flag,Store.put_put] at hc
  have hz : s.put L.fresh [] = s := by rw [← hs0,Store.put_self]
  rw [hz] at hc
  have hbranch : (Code.branch id (o.compile L.input L.args L.output L.fresh) reset).Exec
      (s.flag (decide (u≠0))) (1+(if u=0 then 1 else o.cost x a))
      ((s.put L.output (((Output.when t o).eval x a).reverse ++ s.tape L.output)).flag false) := by
    by_cases hu : u=0
    · have hh := Exec.branch_false (f := id) (c := o.compile L.input L.args L.output L.fresh)
        (d := reset) (s := s.flag (decide (u≠0))) (by simp [hu]) (reset_run _)
      simpa [eval,show t.eval x a = u from rfl,hu] using hh
    · have hh := Exec.branch_true (f := id) (c := o.compile L.input L.args L.output L.fresh)
        (d := reset) (s := s.flag (decide (u≠0))) (by simp [hu]) (ho L x a _ (h.flag _))
      simpa [eval,show t.eval x a = u from rfl,hu] using hh
  have hh := Exec.seq h1 (Exec.seq hp (Exec.seq hc hbranch))
  convert hh using 1; try rfl
  dsimp [cost,u]
  omega

theorem correct_loop {r : Nat} (b : Expr r) {e : Output (r+1)}
    (he : e.Correct) : (Output.loop b e).Correct := by
  intro L x a s h
  let n := b.eval x a
  let outputs := fun i => (List.range i).flatMap (fun j => e.eval x (Fin.cons j a))
  have hfo : L.fresh ≠ L.output := (Nat.ne_of_lt L.output_lt).symm
  have h1o : L.fresh+1 ≠ L.output := by have := L.output_lt; omega
  have hfi : L.input ≠ L.fresh := Nat.ne_of_lt L.input_lt
  have h1i : L.input ≠ L.fresh+1 := by have := L.input_lt; omega
  have hfa : ∀ j, L.args j ≠ L.fresh := fun j => Nat.ne_of_lt (L.args_lt j)
  have h1a : ∀ j, L.args j ≠ L.fresh+1 := by intro j; have := L.args_lt j; omega
  have hs0 := h.clean L.fresh (by omega)
  have hs1 := h.clean (L.fresh+1) (by omega)
  have h1 := b.correct (L.temp 0 2 (by omega)) x a s (h.temp 0 2 (by omega))
  simp only [Layout.temp,Nat.add_zero,hs0,List.append_nil] at h1
  let states := fun i =>
    ((((s.put (L.fresh+1) (List.replicate i true)).put L.fresh (List.replicate (n-i) true)).put
      L.output ((outputs i).reverse ++ s.tape L.output)).flag false)
  have hrdy : ∀ i, L.sumBody.Ready ((states i).put L.fresh (List.replicate (n-(i+1)) true))
      x (Fin.cons i a) := by
    intro i
    constructor
    · simp [states,Layout.sumBody,hfi,h1i,L.input_ne,h.input_eq]
    · intro j
      refine Fin.cases ?_ (fun j => ?_) j
      · simp [states,Layout.sumBody,h1o]
      · simp [states,Layout.sumBody,hfa,h1a,L.args_ne,h.args_eq]
    · intro k hk
      change L.fresh+2 ≤ k at hk
      have hk0 : k≠L.fresh := by omega
      have hk1 : k≠L.fresh+1 := by omega
      have hko : k≠L.output := by have := L.output_lt; omega
      simp [states,hk0,hk1,hko,h.clean k (by omega)]
  have hp : ∀ i, (Code.seq (e.compile L.input (Fin.cons (L.fresh+1) L.args) L.output (L.fresh+2))
      (push (L.fresh+1) true)).Exec
      ((states i).put L.fresh (List.replicate (n-(i+1)) true))
      (e.cost x (Fin.cons i a)+1) (states (i+1)) := by
    intro i
    have hbody := he L.sumBody x (Fin.cons i a)
      ((states i).put L.fresh (List.replicate (n-(i+1)) true)) (hrdy i)
    have hpush := push_run ((((states i).put L.fresh (List.replicate (n-(i+1)) true)).put L.output
      ((e.eval x (Fin.cons i a)).reverse ++
        ((states i).put L.fresh (List.replicate (n-(i+1)) true)).tape L.output)).flag false)
      (L.fresh+1) true
    have hh := Exec.seq hbody hpush
    convert hh using 1 <;> try rfl
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hko : k=L.output
    · subst k
      simp only [states,Store.flag_tape,Store.put_tape_same,Store.put_tape_other _ (Ne.symm hfo),
        Store.put_tape_other _ (Ne.symm h1o)]
      simp [outputs,List.range_succ,List.flatMap_append,List.reverse_append,List.append_assoc]
    · by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
        simp_all [states,Store.put,Store.flag,List.replicate_succ]
  have hlo := scan_indexed L.fresh
    (Code.seq (e.compile L.input (Fin.cons (L.fresh+1) L.args) L.output (L.fresh+2)) (push (L.fresh+1) true))
    n states (fun i => e.cost x (Fin.cons i a)+1)
    (by intro i hi; simp [states,hfo]) (by intro i hi; exact hp i)
  have hstart : states 0 = (s.put L.fresh (List.replicate n true)).flag false := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hko : k=L.output <;> by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
      simp_all [states,outputs,Store.put,Store.flag]
  rw [hstart] at hlo
  have hc := clear_run (L.fresh+1) (states n)
  have hcval : (states n).tape (L.fresh+1) = List.replicate n true := by simp [states,h1o]
  rw [hcval,List.length_replicate] at hc
  have hend : (states n).put (L.fresh+1) [] =
      (s.put L.output ((outputs n).reverse ++ s.tape L.output)).flag false := by
    refine Store.ext _ _ rfl ?_
    funext k
    by_cases hko : k=L.output <;> by_cases hk0 : k=L.fresh <;> by_cases hk1 : k=L.fresh+1 <;>
      simp_all [states,Store.put,Store.flag]
  rw [hend] at hc
  have hh := Exec.seq h1 (Exec.seq hlo hc)
  convert hh using 1 <;> try rfl
  simp only [cost,Finset.sum_add_distrib,Finset.sum_const,Finset.card_range,smul_eq_mul,mul_one]
  dsimp [n]
  omega

theorem correct {r : Nat} (o : Output r) : o.Correct := by
  induction o with
  | nil => exact correct_nil
  | bit b => exact correct_bit b
  | nat e => exact correct_nat e
  | append a b iha ihb => exact correct_append iha ihb
  | loop b e ihe => exact correct_loop b ihe
  | when t b ih => exact correct_when t ih

end DirectedFeedback.BoundedExpr.Output

end OAI