math / data /lean /OAI /Computability /MeanPayoff /DriverExecution.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
13.4 kB
import OAI.Computability.MeanPayoff.Driver
namespace OAI
namespace MeanPayoff.TreeDevice.Certified.DetDriver
open BinaryData DetRaw
noncomputable def advance (ar : RawBasic.Arena) (s : State) : State := step (ar,s)
def Exec (ar : RawBasic.Arena) (s t : State) (k : ℕ) : Prop := (advance ar)^[k] s=t
theorem Exec.refl (ar : RawBasic.Arena) (s : State) : Exec ar s s 0 := rfl
theorem Exec.one (ar : RawBasic.Arena) (s : State) : Exec ar s (step (ar,s)) 1 := rfl
theorem Exec.trans {ar : RawBasic.Arena} {s t u : State} {k l : ℕ}
(hs : Exec ar s t k) (ht : Exec ar t u l) : Exec ar s u (k+l) := by
unfold Exec at *
rw [Nat.add_comm, Function.iterate_add_apply, hs, ht]
variable {n d : ℕ} {A a b : Fin n → ℚ}
theorem down_pass {n d : ℕ} {A : Fin n → ℤ} {a b : Fin n → ℚ} {x : Input}
(h : Rep A d a b x) (hd : 12≤d) (ar : RawBasic.Arena)
(o : Label.Grid n → Fin n → Bool) (T : ℕ)
(ho : ∀ (g : Label.Grid n) (vs : List W), VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) g) vs →
∀ ks : List Frame, ∃ k, k+1≤T ∧
Exec ar (call (child false (x,vs)) ks) (ret (List.ofFn (o g)) ks) k)
(g : Label.Grid n) (vs ds : List W) (hv : VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) g) vs)
(ks : List Frame) :
∃ us k, VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) (Label.downRun o g).val.1) us ∧
k≤(Label.downRank g+1)*T ∧
Exec ar (call (child false (x,vs)) (frame 0 x ds vs::ks))
(call (child true (x,us)) (frame 1 x us us::ks)) k := by
let g' := Label.gridDown g (o g)
let us := down (x,vs,List.ofFn (o g))
have hu : VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) g') us := by
rw [Label.gridPivot_down A (by positivity)]
exact down_rep h hd hv (o g)
have hc : different (us,vs)=decide (g'≠g) := by
rw [different_eq hu hv]
exact decide_eq_decide.mpr (not_congr (Label.gridPivot_injective A (by positivity)).eq_iff)
obtain ⟨j,hj,hjexec⟩ := ho g vs hv (frame 0 x ds vs::ks)
by_cases he : g'=g
· refine ⟨us,j+1,?_,?_,?_⟩
· rw [Label.downRun_fixed o g he]
simpa only [he] using hu
· exact hj.trans (Nat.le_mul_of_pos_left _ (by omega))
· apply hjexec.trans
have heq : step (ar,ret (List.ofFn (o g)) (frame 0 x ds vs::ks))=
call (child true (x,us)) (frame 1 x us us::ks) := by
rw [step_down]
change (if different (us,vs) then _ else _)=_
rw [hc,ite_eq_right (by simp [he])]
simpa only [heq] using Exec.one ar (ret (List.ofFn (o g)) (frame 0 x ds vs::ks))
· obtain ⟨zs,k,hz,hk,hkexec⟩ := down_pass h hd ar o T ho g' us ds hu ks
refine ⟨zs,(j+1)+k,?_,?_,?_⟩
· rw [Label.downRun_next o g he]
exact hz
· have hr : Label.downRank g'+1≤Label.downRank g :=
Label.downRank_strict (Label.gridDown_le g (o g)) he
have hm := Nat.mul_le_mul_right T hr
nlinarith
· apply Exec.trans (t:=call (child false (x,us)) (frame 0 x ds us::ks))
· apply hjexec.trans
have heq : step (ar,ret (List.ofFn (o g)) (frame 0 x ds vs::ks))=
call (child false (x,us)) (frame 0 x ds us::ks) := by
rw [step_down]
change (if different (us,vs) then _ else _)=_
rw [hc,ite_eq_left (by simpa using he)]
simpa only [heq] using Exec.one ar (ret (List.ofFn (o g)) (frame 0 x ds vs::ks))
· exact hkexec
termination_by Label.downRank g
decreasing_by exact Label.downRank_strict (Label.gridDown_le g (o g)) he
theorem up_pass {n d : ℕ} {A : Fin n → ℤ} {a b : Fin n → ℚ} {x : Input}
(h : Rep A d a b x) (hd : 12≤d) (ar : RawBasic.Arena)
(o : Label.Grid n → Fin n → Bool) (T : ℕ)
(ho : ∀ (g : Label.Grid n) (vs : List W), VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) g) vs →
∀ ks : List Frame, ∃ k, k+1≤T ∧
Exec ar (call (child true (x,vs)) ks) (ret (List.ofFn (o g)) ks) k)
(g : Label.Grid n) (vs ds : List W) (hv : VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) g) vs)
(ks : List Frame) :
∃ us k, VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) (Label.upRun o g).val.1) us ∧
k≤(Label.upRank g+1)*T ∧
Exec ar (call (child true (x,vs)) (frame 1 x ds vs::ks))
(call (provisional (x,us)) (frame 2 x ds us::ks)) k := by
let g' := Label.gridUp g (o g)
let us := up (x,vs,List.ofFn (o g))
have hu : VectorRep (Label.gridPivot A ((2:ℤ)^(d-12)) g') us := by
rw [Label.gridPivot_up A (by positivity)]
exact up_rep h hd hv (o g)
have hc : different (us,vs)=decide (g'≠g) := by
rw [different_eq hu hv]
exact decide_eq_decide.mpr (not_congr (Label.gridPivot_injective A (by positivity)).eq_iff)
obtain ⟨j,hj,hjexec⟩ := ho g vs hv (frame 1 x ds vs::ks)
by_cases he : g'=g
· refine ⟨us,j+1,?_,?_,?_⟩
· rw [Label.upRun_fixed o g he]
simpa only [he] using hu
· exact hj.trans (Nat.le_mul_of_pos_left _ (by omega))
· apply hjexec.trans
have heq : step (ar,ret (List.ofFn (o g)) (frame 1 x ds vs::ks))=
call (provisional (x,us)) (frame 2 x ds us::ks) := by
rw [step_up]
change (if different (us,vs) then _ else _)=_
rw [hc,ite_eq_right (by simp [he])]
simpa only [heq] using Exec.one ar (ret (List.ofFn (o g)) (frame 1 x ds vs::ks))
· obtain ⟨zs,k,hz,hk,hkexec⟩ := up_pass h hd ar o T ho g' us ds hu ks
refine ⟨zs,(j+1)+k,?_,?_,?_⟩
· rw [Label.upRun_next o g he]
exact hz
· have hr : Label.upRank g'+1≤Label.upRank g :=
Label.upRank_strict (Label.le_gridUp g (o g)) he
have hm := Nat.mul_le_mul_right T hr
nlinarith
· apply Exec.trans (t:=call (child true (x,us)) (frame 1 x ds us::ks))
· apply hjexec.trans
have heq : step (ar,ret (List.ofFn (o g)) (frame 1 x ds vs::ks))=
call (child true (x,us)) (frame 1 x ds us::ks) := by
rw [step_up]
change (if different (us,vs) then _ else _)=_
rw [hc,ite_eq_left (by simpa using he)]
simpa only [heq] using Exec.one ar (ret (List.ofFn (o g)) (frame 1 x ds vs::ks))
· exact hkexec
termination_by Label.upRank g
decreasing_by exact Label.upRank_strict (Label.le_gridUp g (o g)) he
end MeanPayoff.TreeDevice.Certified.DetDriver
namespace MeanPayoff.TreeDevice.Certified
open BinaryData Code
namespace Size
@[simp] theorem pair {α β : Type} [Encoding α] [Encoding β] (x : α) (y : β) :
treeSize (encode (x,y))=treeSize (encode x)+treeSize (encode y)+1 := by
change treeSize (product encode encode (x,y))=_
simp only [product,treeSize_pair]
theorem bool (b : Bool) : treeSize (encode b)≤5 := by cases b <;> decide
theorem list_bound {α : Type} [Encoding α] {xs : List α} {M : ℕ}
(h : ∀ x∈xs, treeSize (encode x)≤M) : treeSize (encode xs)≤xs.length*(M+1)+1 := by
induction xs with
| nil => change 1≤0*(M+1)+1; omega
| cons x xs ih =>
have hx := h x (by simp)
have ht := ih (fun y hy => h y (by simp [hy]))
change treeSize (listTree encode (x::xs))≤_
rw [listTree,treeSize_pair,List.length_cons]
change treeSize (listTree encode xs)≤_ at ht
nlinarith
theorem unit_list (xs : Count) : treeSize (encode xs)≤2*xs.length+1 := by
have h := list_bound (xs:=xs) (M:=1) (by intro x _; rfl)
omega
theorem bool_list (xs : List Bool) : treeSize (encode xs)≤6*xs.length+1 := by
have h := list_bound (xs:=xs) (M:=5) (by intro x _; exact bool x)
omega
end Size
namespace Array
theorem Small.size {n M : ℕ} {xs : List W} (h : Small n M xs) :
treeSize (encode xs)≤n*(4*M+6)+1 :=
(size_bound h.digits).trans (Nat.add_le_add_right (Nat.mul_le_mul_right _ h.length) 1)
theorem small_of_size {S : ℕ} (xs : List W) (h : treeSize (encode xs)≤S) : Small S S xs :=
⟨(Size.length xs).trans h,(bounded_size xs).mono h⟩
end Array
namespace DetMass
theorem small_of_size {S : ℕ} (x : Data) (h : treeSize (encode x)≤S) : Small S S x :=
⟨(digits_le_wordSize x.1).trans ((Size.fst x).trans h),Array.small_of_size x.2 ((Size.snd x).trans h)⟩
theorem Small.size {n M : ℕ} {x : Data} (h : Small n M x) :
treeSize (encode x)≤20*(n+1)*(M+1) := by
have ha := h.nums.size
have hw := wordSize_bound x.1
have hd := h.den
rcases x with ⟨w,ws⟩
rw [Size.pair]
dsimp only at ha hd
change treeSize (encode w)≤4*w.digits.length+5 at hw
nlinarith
end DetMass
namespace DetRaw
theorem small_of_size {S : ℕ} (x : Input) (h : treeSize (encode x)≤S) : Small S S x := by
have h1 := (Size.fst x).trans h
have h2 := (Size.snd x).trans h
exact ⟨(digits_le_wordSize x.1.1).trans ((Size.fst x.1).trans h1),
Array.small_of_size x.1.2 ((Size.snd x.1).trans h1),
DetMass.small_of_size x.2.1 ((Size.fst x.2).trans h2),
DetMass.small_of_size x.2.2 ((Size.snd x.2).trans h2)⟩
theorem Small.size {n M : ℕ} {x : Input} (h : Small n M x) :
treeSize (encode x)≤100*(n+1)*(M+1) := by
have ha := h.lower.size
have hw := wordSize_bound x.1.1
have hd := h.width
have hb := h.a.size
have hc := h.b.size
rcases x with ⟨⟨w,ws⟩,a,b⟩
simp only [Size.pair]
dsimp only at ha hd hb hc
change treeSize (encode w)≤4*w.digits.length+5 at hw
nlinarith
end DetRaw
namespace DetDriver
theorem FrameSmall.size {n M : ℕ} {f : Frame} (h : FrameSmall n M f) :
treeSize (encode f)≤200*(n+1)*(M+1) := by
have ht := (Size.unit_list f.1).trans (Nat.add_le_add_right (Nat.mul_le_mul_left 2 h.tag) 1)
have hi := h.input.size
have hd := h.down.size
have hv := h.pivot.size
rcases f with ⟨t,x,ds,vs⟩
simp only [Size.pair]
nlinarith
theorem frameSmall_of_size {S : ℕ} (f : Frame) (h : treeSize (encode f)≤S) : FrameSmall S S f := by
have h1 := (Size.snd f).trans h
have h2 := (Size.snd f.2).trans h1
exact ⟨(Size.length f.1).trans ((Size.fst f).trans h),
DetRaw.small_of_size f.2.1 ((Size.fst f.2).trans h1),
Array.small_of_size f.2.2.1 ((Size.fst f.2.2).trans h2),
Array.small_of_size f.2.2.2 ((Size.snd f.2.2).trans h2)⟩
theorem Small.size {n M K : ℕ} {s : State} (h : Small n M K s) :
treeSize (encode s)≤400*(n+1)*(M+1)*(K+1) := by
have hb := Size.bool s.1.1
have hi := h.input.size
have hl := (Size.bool_list s.1.2.2).trans (Nat.add_le_add_right (Nat.mul_le_mul_left 6 h.labels) 1)
have hf := Size.list_bound (fun f hf => (h.frames f hf).size)
have hk := h.depth
have hfs : treeSize (encode s.2)≤K*(200*(n+1)*(M+1)+1)+1 :=
hf.trans (Nat.add_le_add_right (Nat.mul_le_mul_right _ hk) 1)
rcases s with ⟨⟨b,x,ls⟩,ks⟩
simp only [Size.pair]
nlinarith [Nat.zero_le (n*M*K),Nat.zero_le (n*K),Nat.zero_le (M*K)]
theorem small_of_size {S : ℕ} (s : State) (h : treeSize (encode s)≤S) : Small S S S s := by
have h1 := (Size.fst s).trans h
have h2 := (Size.snd s.1).trans h1
have h3 := (Size.snd s).trans h
exact ⟨DetRaw.small_of_size s.1.2.1 ((Size.fst s.1.2).trans h2),
(Size.length s.1.2.2).trans ((Size.snd s.1.2).trans h2),
(Size.length s.2).trans h3,fun f hf => frameSmall_of_size f ((Size.mem hf).trans h3)⟩
theorem iterate_small {n M K : ℕ} {s : State} (hn : 3≤n) (h : Small n M K s)
(ar : RawBasic.Arena) (k : ℕ) : Small n (M+100*k) (K+k) ((advance ar)^[k] s) := by
induction k with
| zero => simpa using h
| succ k ih =>
rw [Function.iterate_succ_apply']
have hs := step_small hn ih ar
simpa only [Nat.mul_succ,Nat.add_assoc,advance] using hs
local infixl:80 " ≫ₚ " => Code.comp
local infixr:70 " ⋏ₚ " => Code.pair
noncomputable def tick : Code (Env×Unit) Env := fst ≫ₚ (arena ⋏ₚ step)
@[simp] theorem tick_eval (e : Env) (u : Unit) : tick (e,u)=(e.1,advance e.1 e.2) := rfl
theorem fold_tick (e : Env) (xs : Count) :
Fold.fold tick.eval e xs=(e.1,(advance e.1)^[xs.length] e.2) := by
induction xs generalizing e with
| nil => rfl
| cons u xs ih =>
change Fold.fold tick.eval (tick (e,u)) xs=_
rw [tick_eval,ih]
simp only [List.length_cons,Function.iterate_succ_apply]
theorem tick_prefix (e : Env) (xs : Count) (k : ℕ) (hk : k≤xs.length) :
treeSize (encode (Fold.fold tick.eval e (xs.take k)))≤1000000*(treeSize (encode (e,xs))+1)^3 := by
let P := treeSize (encode (e,xs))+1
have hp : 1≤P := by dsimp [P]; omega
have he : treeSize (encode e)≤P := (Size.fst (e,xs)).trans (by dsimp [P]; omega)
have hs : treeSize (encode e.2)≤3*P := (Size.snd e).trans (he.trans (by omega))
have ha : treeSize (encode e.1)≤P := (Size.fst e).trans he
have hx : xs.length≤P := (Size.length xs).trans ((Size.snd (e,xs)).trans (by dsimp [P]; omega))
have hg := iterate_small (show 3≤3*P by omega) (small_of_size e.2 hs) e.1 k
have hgg := hg.mono (show 3*P+100*k≤103*P by omega) (show 3*P+k≤4*P by omega)
have hz := hgg.size
have hprod : 400*(3*P+1)*(103*P+1)*(4*P+1)≤832000*P^3 := by
calc
_≤400*(4*P)*(104*P)*(5*P) := by gcongr <;> omega
_=832000*P^3 := by ring
rw [fold_tick,List.length_take,Nat.min_eq_left hk,Size.pair]
change _≤1000000*P^3
have hp3 : P≤P^3 := by nlinarith [Nat.mul_self_le_mul_self hp]
nlinarith
noncomputable def run : Code (Env×Count) Env := foldPrefix tick 1000000 3 tick_prefix
@[simp] theorem run_eval (e : Env) (xs : Count) : run (e,xs)=(e.1,(advance e.1)^[xs.length] e.2) := fold_tick e xs
end DetDriver
end MeanPayoff.TreeDevice.Certified
end OAI