File size: 2,977 Bytes
2f887db | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | 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
|