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