import OAI.Computability.MeanPayoff.SizeBounds namespace OAI namespace MeanPayoff.TreeDevice.Certified open BinaryData Code local infixl:80 " ≫ₚ " => Code.comp local infixr:70 " ⋏ₚ " => Code.pair namespace Code variable {α β : Type} [Encoding α] [Encoding β] noncomputable def select (tag : Code α Count) (cases : List (Code α β)) (fallback : Code α β) : Code α β := match cases with | [] => fallback | c::cs => Code.branch (tag ≫ₚ empty) c (select (tag ≫ₚ tail) cs fallback) theorem select_eval (tag : Code α Count) (cases : List (Code α β)) (fallback : Code α β) (x : α) : select tag cases fallback x=(cases.getD (tag x).length fallback) x := by induction cases generalizing tag with | nil => simp [select,List.getD] | cons c cs ih => simp only [select,branch_eval,comp_eval,empty_eval,ih] cases h : tag x with | nil => simp [] | cons u us => simp [tail_eval,List.getD] end Code namespace DetDriver open DetRaw abbrev Frame := Count × Input × List W × List W abbrev State := (Bool × Input × List Bool) × List Frame abbrev Env := RawBasic.Arena × State def zeroInput : Input := ((Array.zero,[]), (Array.zero,[]), (Array.zero,[])) def zeroFrame : Frame := ([],zeroInput,[],[]) def call (x : Input) (ks : List Frame) : State := ((false,x,[]),ks) def ret (ls : List Bool) (ks : List Frame) : State := ((true,zeroInput,ls),ks) def frame (tag : ℕ) (x : Input) (kd k : List W) : Frame := (List.replicate tag (),x,kd,k) noncomputable def state : Code Env State := snd noncomputable def arena : Code Env RawBasic.Arena := fst noncomputable def returning : Code Env Bool := state ≫ₚ fst ≫ₚ fst noncomputable def input : Code Env Input := state ≫ₚ fst ≫ₚ snd ≫ₚ fst noncomputable def labels : Code Env (List Bool) := state ≫ₚ fst ≫ₚ snd ≫ₚ snd noncomputable def stack : Code Env (List Frame) := state ≫ₚ snd noncomputable def top : Code Env Frame := stack ≫ₚ head zeroFrame noncomputable def rest : Code Env (List Frame) := stack ≫ₚ tail noncomputable def tag : Code Env Count := top ≫ₚ fst noncomputable def parent : Code Env Input := top ≫ₚ snd ≫ₚ fst noncomputable def kd : Code Env (List W) := top ≫ₚ snd ≫ₚ snd ≫ₚ fst noncomputable def pivot : Code Env (List W) := top ≫ₚ snd ≫ₚ snd ≫ₚ snd noncomputable def frameCode {α : Type} [Encoding α] (t : ℕ) (x : Code α Input) (kd k : Code α (List W)) : Code α Frame := const (List.replicate t ()) ⋏ₚ x ⋏ₚ kd ⋏ₚ k noncomputable def callCode {α : Type} [Encoding α] (x : Code α Input) (s : Code α (List Frame)) : Code α State := (const false ⋏ₚ x ⋏ₚ const []) ⋏ₚ s noncomputable def retCode {α : Type} [Encoding α] (ls : Code α (List Bool)) (s : Code α (List Frame)) : Code α State := (const true ⋏ₚ const zeroInput ⋏ₚ ls) ⋏ₚ s noncomputable def pushCode {α : Type} [Encoding α] (f : Code α Frame) (s : Code α (List Frame)) : Code α (List Frame) := (f ⋏ₚ s) ≫ₚ cons noncomputable def initialPivot : Code Env (List W) := input ≫ₚ center noncomputable def enter : Code Env State := Code.branch (input ≫ₚ base) (retCode (input ≫ₚ baseLabels) stack) (Code.branch (input ≫ₚ small) (retCode ((arena ⋏ₚ input) ≫ₚ DetRaw.basic) stack) (callCode ((input ⋏ₚ initialPivot) ≫ₚ child false) (pushCode (frameCode 0 input (const []) initialPivot) stack))) noncomputable def updated (u : Bool) : Code Env (List W) := (parent ⋏ₚ pivot ⋏ₚ labels) ≫ₚ (if u then up else down) noncomputable def moving (u : Bool) : Code Env Bool := (updated u ⋏ₚ pivot) ≫ₚ different noncomputable def again (u : Bool) : Code Env State := callCode ((parent ⋏ₚ updated u) ≫ₚ child u) (pushCode (frameCode (if u then 1 else 0) parent kd (updated u)) rest) noncomputable def downDone : Code Env State := callCode ((parent ⋏ₚ updated false) ≫ₚ child true) (pushCode (frameCode 1 parent (updated false) (updated false)) rest) noncomputable def upDone : Code Env State := callCode ((parent ⋏ₚ updated true) ≫ₚ provisional) (pushCode (frameCode 2 parent kd (updated true)) rest) noncomputable def provisionalDone : Code Env State := callCode ((parent ⋏ₚ labels) ≫ₚ continuation) (pushCode (frameCode 3 parent kd pivot) rest) noncomputable def continuationDone : Code Env State := retCode ((parent ⋏ₚ kd ⋏ₚ pivot ⋏ₚ labels) ≫ₚ finish) rest noncomputable def resume : Code Env State := select tag [Code.branch (moving false) (again false) downDone, Code.branch (moving true) (again true) upDone,provisionalDone,continuationDone] continuationDone noncomputable def stop : Code Env Bool := (returning ⋏ₚ (stack ≫ₚ empty)) ≫ₚ Code.and noncomputable def step : Code Env State := Code.branch returning (Code.branch (stack ≫ₚ empty) state resume) enter @[simp] theorem callCode_eval {α : Type} [Encoding α] (x : Code α Input) (s : Code α (List Frame)) (e : α) : callCode x s e=call (x e) (s e) := rfl @[simp] theorem retCode_eval {α : Type} [Encoding α] (ls : Code α (List Bool)) (s : Code α (List Frame)) (e : α) : retCode ls s e=ret (ls e) (s e) := rfl @[simp] theorem pushCode_eval {α : Type} [Encoding α] (f : Code α Frame) (s : Code α (List Frame)) (e : α) : pushCode f s e=f e::s e := rfl @[simp] theorem frameCode_eval {α : Type} [Encoding α] (t : ℕ) (x : Code α Input) (kd k : Code α (List W)) (e : α) : frameCode t x kd k e=frame t (x e) (kd e) (k e) := rfl @[simp] theorem step_call (ar : RawBasic.Arena) (x : Input) (ks : List Frame) : step (ar,call x ks)= if base x then ret (baseLabels x) ks else if small x then ret (DetRaw.basic (ar,x)) ks else call (child false (x,center x)) (frame 0 x [] (center x)::ks) := rfl @[simp] theorem step_ret_nil (ar : RawBasic.Arena) (ls : List Bool) : step (ar,ret ls [])=ret ls [] := rfl @[simp] theorem step_down (ar : RawBasic.Arena) (x : Input) (ds vs : List W) (ls : List Bool) (ks : List Frame) : step (ar,ret ls (frame 0 x ds vs::ks))= let us := down (x,vs,ls) if different (us,vs) then call (child false (x,us)) (frame 0 x ds us::ks) else call (child true (x,us)) (frame 1 x us us::ks) := rfl @[simp] theorem step_up (ar : RawBasic.Arena) (x : Input) (ds vs : List W) (ls : List Bool) (ks : List Frame) : step (ar,ret ls (frame 1 x ds vs::ks))= let us := up (x,vs,ls) if different (us,vs) then call (child true (x,us)) (frame 1 x ds us::ks) else call (provisional (x,us)) (frame 2 x ds us::ks) := rfl @[simp] theorem step_provisional (ar : RawBasic.Arena) (x : Input) (ds vs : List W) (ls : List Bool) (ks : List Frame) : step (ar,ret ls (frame 2 x ds vs::ks))= call (continuation (x,ls)) (frame 3 x ds vs::ks) := rfl @[simp] theorem step_continuation (ar : RawBasic.Arena) (x : Input) (ds vs : List W) (ls : List Bool) (ks : List Frame) : step (ar,ret ls (frame 3 x ds vs::ks))=ret (finish (x,ds,vs,ls)) ks := rfl @[simp] theorem stop_call (ar : RawBasic.Arena) (x : Input) (ks : List Frame) : stop (ar,call x ks)=false := rfl @[simp] theorem stop_ret (ar : RawBasic.Arena) (ls : List Bool) (ks : List Frame) : stop (ar,ret ls ks)=ks.isEmpty := by simp [stop,Code.and,returning,state,stack,ret] end DetDriver end MeanPayoff.TreeDevice.Certified namespace MeanPayoff.TreeDevice.Certified.DetDriver open BinaryData DetRaw structure FrameSmall (n M : ℕ) (f : Frame) : Prop where tag : f.1.length≤n input : DetRaw.Small n M f.2.1 down : Array.Small n M f.2.2.1 pivot : Array.Small n M f.2.2.2 structure Small (n M K : ℕ) (s : State) : Prop where input : DetRaw.Small n M s.1.2.1 labels : s.1.2.2.length≤n depth : s.2.length≤K frames : ∀ f∈s.2, FrameSmall n M f theorem FrameSmall.mono {n M N : ℕ} {f : Frame} (h : FrameSmall n M f) (hM : M≤N) : FrameSmall n N f := ⟨h.tag,h.input.mono hM,h.down.mono hM,h.pivot.mono hM⟩ theorem Small.mono {n M K N J : ℕ} {s : State} (h : Small n M K s) (hM : M≤N) (hK : K≤J) : Small n N J s := ⟨h.input.mono hM,h.labels,h.depth.trans hK,fun f hf => (h.frames f hf).mono hM⟩ theorem zero_small (n M : ℕ) : DetRaw.Small n M zeroInput := ⟨Nat.zero_le _,Array.Small.nil _ _,⟨Nat.zero_le _,Array.Small.nil _ _⟩,⟨Nat.zero_le _,Array.Small.nil _ _⟩⟩ theorem frame_small {n M t : ℕ} {x : Input} {ds vs : List W} (ht : t≤n) (hx : DetRaw.Small n M x) (hd : Array.Small n M ds) (hv : Array.Small n M vs) : FrameSmall n M (frame t x ds vs) := ⟨by simpa only [frame,List.length_replicate] using ht,hx,hd,hv⟩ theorem call_small {n M K : ℕ} {x : Input} {ks : List Frame} (hx : DetRaw.Small n M x) (hk : ks.length≤K) (hf : ∀ f∈ks, FrameSmall n M f) : Small n M K (call x ks) := ⟨hx,Nat.zero_le _,hk,hf⟩ theorem ret_small {n M K : ℕ} {ls : List Bool} {ks : List Frame} (hl : ls.length≤n) (hk : ks.length≤K) (hf : ∀ f∈ks, FrameSmall n M f) : Small n M K (ret ls ks) := ⟨zero_small n M,hl,hk,hf⟩ theorem call_push_small {n M K t : ℕ} {y x : Input} {ds vs : List W} {ks : List Frame} (hy : DetRaw.Small n M y) (ht : t≤n) (hx : DetRaw.Small n M x) (hd : Array.Small n M ds) (hv : Array.Small n M vs) (hk : ks.length≤K) (hf : ∀ f∈ks, FrameSmall n M f) : Small n M (K+1) (call y (frame t x ds vs::ks)) := by apply call_small hy (by simpa only [List.length_cons] using Nat.add_le_add_right hk 1) intro f hf' rcases List.mem_cons.mp hf' with rfl | hf' · exact frame_small ht hx hd hv · exact hf f hf' @[simp] theorem step_forward (ar : RawBasic.Arena) (x : Input) (ls : List Bool) (ks : List Frame) : step (ar,((false,x,ls),ks))=step (ar,call x ks) := rfl @[simp] theorem step_return_push (ar : RawBasic.Arena) (x : Input) (ls : List Bool) (f : Frame) (ks : List Frame) : step (ar,((true,x,ls),f::ks))=step (ar,ret ls (f::ks)) := rfl @[simp] theorem step_return_large (ar : RawBasic.Arena) (x : Input) (ds vs : List W) (ls : List Bool) (ks : List Frame) (t : ℕ) : step (ar,ret ls (frame (t+3) x ds vs::ks))=ret (finish (x,ds,vs,ls)) ks := by cases t <;> rfl theorem enter_small {n M K : ℕ} {x : Input} {ks : List Frame} (hn : 3≤n) (hx : DetRaw.Small n M x) (hk : ks.length≤K) (hf : ∀ f∈ks, FrameSmall n M f) (ar : RawBasic.Arena) : Small n (M+100) (K+1) (step (ar,call x ks)) := by have hfs : ∀ f∈ks, FrameSmall n (M+100) f := fun f hf' => (hf f hf').mono (by omega) rw [step_call] split · exact ret_small (baseLabels_length hx) (by omega) hfs · split · exact ret_small (basic_length hx ar) (by omega) hfs · have hc := center_small hx have hy := child_small (hx.mono (show M≤M+1 by omega)) hc false exact call_push_small (hy.mono (by omega)) (by omega) (hx.mono (by omega)) (Array.Small.nil _ _) (hc.mono (by omega)) hk hfs theorem resume_small {n M K : ℕ} {x : Input} {ds vs : List W} {ls : List Bool} {ks : List Frame} (hn : 3≤n) (hx : DetRaw.Small n M x) (hd : Array.Small n M ds) (hv : Array.Small n M vs) (hl : ls.length≤n) (hk : ks.length≤K) (hf : ∀ f∈ks, FrameSmall n M f) (ar : RawBasic.Arena) (t : ℕ) : Small n (M+100) (K+1) (step (ar,ret ls (frame t x ds vs::ks))) := by have hfs : ∀ f∈ks, FrameSmall n (M+100) f := fun f hf' => (hf f hf').mono (by omega) have hxs := hx.mono (show M≤M+100 by omega) have hds := hd.mono (show M≤M+100 by omega) have hvs := hv.mono (show M≤M+100 by omega) cases t with | zero => rw [step_down] dsimp only have hu := down_small hx hv ls hl have hux := hx.mono (show M≤M+40 by omega) have hud := (child_small hux hu false).mono (show M+40+40≤M+100 by omega) have huu := (child_small hux hu true).mono (show M+40+40≤M+100 by omega) split · exact call_push_small hud (by omega) hxs hds (hu.mono (by omega)) hk hfs · exact call_push_small huu (by omega) hxs (hu.mono (by omega)) (hu.mono (by omega)) hk hfs | succ t => cases t with | zero => rw [step_up] dsimp only have hu := up_small hx hv ls hl have hux := hx.mono (show M≤M+40 by omega) have huu := (child_small hux hu true).mono (show M+40+40≤M+100 by omega) have hup := (provisional_small hux hu).mono (show M+40+40≤M+100 by omega) split · exact call_push_small huu (by omega) hxs hds (hu.mono (by omega)) hk hfs · exact call_push_small hup (by omega) hxs hds (hu.mono (by omega)) hk hfs | succ t => cases t with | zero => rw [step_provisional] exact call_push_small ((continuation_small hx ls).mono (by omega)) (by omega) hxs hds hvs hk hfs | succ t => rw [show t+1+1+1=t+3 by omega,step_return_large] exact ret_small (finish_length hd vs ls) (by omega) hfs theorem step_small {n M K : ℕ} {s : State} (hn : 3≤n) (h : Small n M K s) (ar : RawBasic.Arena) : Small n (M+100) (K+1) (step (ar,s)) := by rcases s with ⟨⟨mode,x,ls⟩,ks⟩ cases mode with | false => rw [step_forward] exact enter_small hn h.input h.depth h.frames ar | true => cases ks with | nil => exact h.mono (by omega) (by omega) | cons f ks => rw [step_return_push] have hh := h.frames f (by simp) rcases f with ⟨tag,x,ds,vs⟩ have ht : tag=List.replicate tag.length () := List.eq_replicate_of_mem (by intro a ha; exact Subsingleton.elim _ _) have he : (tag,x,ds,vs)=frame tag.length x ds vs := by simp only [frame,←ht] rw [he] apply resume_small hn hh.input hh.down hh.pivot h.labels (K:=K) (ar:=ar) · have hhdepth : ks.length+1≤K := h.depth omega · intro f hf exact h.frames f (List.mem_cons_of_mem _ hf) end MeanPayoff.TreeDevice.Certified.DetDriver namespace MeanPayoff.Label variable {n : ℕ} theorem gridPivot_injective (A : Fin n → ℤ) {t : ℤ} (ht : 0