import Mathlib
import OAI.Computability.MinUncut.Estimates.IterationMagnitude

namespace OAI

section
namespace MinUncut.Costed
inductive AExpr where
  | const (n : ℕ)
  | reg (i : ℕ)
  | add (a b : AExpr)
  | sub (a b : AExpr)
  | mul (a b : AExpr)
  | div (a b : AExpr)
  | mod (a b : AExpr)
  | eq (a b : AExpr)
  | le (a b : AExpr)
  | at (a : AExpr)
  | cond (e a b : AExpr)

def AExpr.eval : AExpr → List ℕ → ℕ
  | .const n,_ => n
  | .reg i,v => (v.drop i).headI
  | .add a b,v => a.eval v+b.eval v
  | .sub a b,v => a.eval v-b.eval v
  | .mul a b,v => a.eval v*b.eval v
  | .div a b,v => a.eval v/b.eval v
  | .mod a b,v => a.eval v%b.eval v
  | .eq a b,v => if a.eval v=b.eval v then 1 else 0
  | .le a b,v => if a.eval v≤b.eval v then 1 else 0
  | .at a,v => (v.drop (a.eval v)).headI
  | .cond e a b,v => if e.eval v=0 then a.eval v else b.eval v

noncomputable def AExpr.program : (a : AExpr) → PolyProgram (fun v=>[a.eval v])
  | .const n => PolyProgram.const n
  | .reg i => PolyProgram.projection i
  | .add a b => PolyProgram.addOf a.program b.program
  | .sub a b => PolyProgram.subOf a.program b.program
  | .mul a b => PolyProgram.mulOf a.program b.program
  | .div a b => Division.quotient.comp (a.program.cons (b.program.cons PolyProgram.nil))
  | .mod a b => Division.remainder.comp (a.program.cons (b.program.cons PolyProgram.nil))
  | .eq a b => PolyProgram.eqOf a.program b.program
  | .le a b => PolyProgram.leOf a.program b.program
  | .at a => PolyProgram.dynamic.comp (a.program.cons PolyProgram.id)
  | .cond e a b => (PolyProgram.branch e.program a.program b.program).ofEq (by
      intro v
      change (if e.eval v=0 then [a.eval v] else [b.eval v])=[if e.eval v=0 then a.eval v else b.eval v]
      split_ifs <;> rfl)

def AExpr.pow (a : AExpr) : ℕ → AExpr
  | 0 => .const 1
  | n+1 => .mul (a.pow n) a
lemma AExpr.eval_pow (a : AExpr) (n : ℕ) (v : List ℕ) : (a.pow n).eval v=a.eval v^n := by
  induction n with
  | zero => rfl
  | succ n ih => simp only [pow,eval,ih,pow_succ]

def AExpr.sum : List AExpr → AExpr
  | [] => .const 0
  | a::as => .add a (sum as)
lemma AExpr.eval_sum (as : List AExpr) (v : List ℕ) : (sum as).eval v=(as.map (fun a=>a.eval v)).sum := by
  induction as with
  | nil => rfl
  | cons a as ih => simp only [sum,eval,List.map_cons,List.sum_cons,ih]

def AExpr.lookup (a : AExpr) : List (ℕ × ℕ) → AExpr
  | [] => .const 0
  | (i,x)::xs => .cond (.eq a (.const i)) (a.lookup xs) (.const x)
def AExpr.lookupValue (n : ℕ) : List (ℕ × ℕ) → ℕ
  | [] => 0
  | (i,x)::xs => if n=i then x else lookupValue n xs
lemma AExpr.eval_lookup (a : AExpr) (xs : List (ℕ × ℕ)) (v : List ℕ) :
    (a.lookup xs).eval v=lookupValue (a.eval v) xs := by
  induction xs with
  | nil => rfl
  | cons p xs ih =>
    rcases p with ⟨i,x⟩
    by_cases h : a.eval v=i <;> simp only [lookup,eval,lookupValue,h,ite_true,ite_false,
      Nat.one_ne_zero,ih]

end MinUncut.Costed

end

end OAI