import OAI.Computability.MeanPayoff.EncodedArithmetic

namespace OAI

section
namespace MeanPayoff.TreeDevice.Certified
open BinaryData Code
local infixl:80 " ≫ₚ " => Code.comp
local infixr:70 " ⋏ₚ " => Code.pair
namespace Array
noncomputable def choose : Code (List Bool × List W × List W) (List W) :=
  (fst ⋏ₚ ((snd ≫ₚ fst ⋏ₚ snd ≫ₚ snd) ≫ₚ zip zero zero (fst ⋏ₚ snd))) ≫ₚ
    zip false (zero,zero) (Code.branch fst (snd ≫ₚ fst) (snd ≫ₚ snd))
noncomputable def replicate : Code (W × Count) (List W) := envMap fst
noncomputable def anyLE : Code (W × List W) Bool := envMap Word.le ≫ₚ any Code.id
noncomputable def anyGE : Code (W × List W) Bool := envMap ((snd ⋏ₚ fst) ≫ₚ Word.le) ≫ₚ any Code.id

theorem map_rep {n : ℕ} (f : Code W W) (g : ℤ → ℤ)
    (hf : ∀ w, (f w).val=g w.val) {v : Fin n → ℤ} {xs : List W} (h : VectorRep v xs) :
    VectorRep (fun i => g (v i)) (map f xs) := by
  obtain ⟨ws,rfl,hw⟩ := h
  refine ⟨f.eval ∘ ws,by simp,?_⟩
  intro i
  simp only [Function.comp_apply,hf,hw]

theorem scale_rep {n : ℕ} {v : Fin n → ℤ} {xs : List W} (h : VectorRep v xs) (w : W) :
    VectorRep (fun i => w.val*v i) (scale (w,xs)) := by
  obtain ⟨ws,rfl,hw⟩ := h
  refine ⟨fun i => Word.mul (w,ws i),by simp [scale,Function.comp_def],?_⟩
  intro i
  simp [hw]

theorem translate_rep {n : ℕ} {v : Fin n → ℤ} {xs : List W} (h : VectorRep v xs) (w : W) :
    VectorRep (fun i => w.val+v i) (translate (w,xs)) := by
  obtain ⟨ws,rfl,hw⟩ := h
  refine ⟨fun i => Word.add (w,ws i),by simp [translate,Function.comp_def],?_⟩
  intro i
  simp [hw]

theorem choose_rep {n : ℕ} {H : Finset (Fin n)} {hs : List Bool}
    {a b : Fin n → ℤ} {as bs : List W} (hH : MaskRep H hs) (ha : VectorRep a as) (hb : VectorRep b bs) :
    VectorRep (fun i => if i∈H then a i else b i) (choose (hs,as,bs)) := by
  obtain ⟨ws,rfl,hw⟩ := ha
  obtain ⟨vs,rfl,hv⟩ := hb
  rw [hH]
  refine ⟨fun i => if i∈H then ws i else vs i,?_,?_⟩
  · change Zip.zip _ _ (List.ofFn _) (Zip.zip _ _ (List.ofFn ws) (List.ofFn vs))=_
    rw [zip_ofFn,zip_ofFn]
    congr 1
    funext i
    simp [comp,fst,snd]
  · intro i
    dsimp only
    split_ifs <;> simp_all

theorem lt_rep {n : ℕ} {a b : Fin n → ℤ} {as bs : List W}
    (ha : VectorRep a as) (hb : VectorRep b bs) :
    MaskRep (Finset.univ.filter (fun i => a i<b i)) (lt (as,bs)) := by
  obtain ⟨ws,rfl,hw⟩ := ha
  obtain ⟨vs,rfl,hv⟩ := hb
  change Zip.zip _ _ (List.ofFn ws) (List.ofFn vs)=_
  rw [zip_ofFn]
  simp [Word.lt_eval,hw,hv]
theorem le_rep {n : ℕ} {a b : Fin n → ℤ} {as bs : List W}
    (ha : VectorRep a as) (hb : VectorRep b bs) :
    MaskRep (Finset.univ.filter (fun i => a i≤b i)) (le (as,bs)) := by
  obtain ⟨ws,rfl,hw⟩ := ha
  obtain ⟨vs,rfl,hv⟩ := hb
  change Zip.zip _ _ (List.ofFn ws) (List.ofFn vs)=_
  rw [zip_ofFn]
  simp [Word.le_eval,hw,hv]

theorem complement_rep {n : ℕ} {H : Finset (Fin n)} {hs : List Bool} (h : MaskRep H hs) :
    MaskRep Hᶜ (complement hs) := by
  rw [h]
  simp [MaskRep,complement,Code.not,List.map_ofFn,Function.comp_def]

theorem repeat_rep {n : ℕ} (w : W) (xs : Count) (h : xs.length=n) :
    VectorRep (fun _ : Fin n => w.val) (replicate (w,xs)) := by
  refine ⟨fun _ => w,?_,fun _ => rfl⟩
  simp [replicate,h,List.ofFn_const]

theorem anyLE_eq {n : ℕ} (w : W) {v : Fin n → ℤ} {xs : List W} (h : VectorRep v xs) :
    anyLE (w,xs)=decide (∃ i, w.val≤v i) := by
  obtain ⟨ws,rfl,hw⟩ := h
  simp [anyLE,Code.any,Code.filter,Code.empty,Word.le_eval,hw,← decide_not]

theorem anyGE_eq {n : ℕ} (w : W) {v : Fin n → ℤ} {xs : List W} (h : VectorRep v xs) :
    anyGE (w,xs)=decide (∃ i, v i≤w.val) := by
  obtain ⟨ws,rfl,hw⟩ := h
  simp [anyGE,Code.any,Code.filter,Code.empty,Word.le_eval,hw,← decide_not]
end Array

namespace RawBudget
theorem smallMask_eq {n : ℕ} {P : Budgets n} {p : Data} (h : Rep P p) :
    MaskRep (Finset.univ.filter (fun i => P.m < P.beta i)) (smallMask p) := by
  obtain ⟨a,b,ha,hb,hap,hbp,hea,heb⟩ := h.coords
  change Zip.zip _ _ (List.map _ p.2.2.2) (List.map _ p.2.2.2)=_
  rw [hb,List.map_ofFn,List.map_ofFn,Array.zip_ofFn]
  apply congrArg List.ofFn
  funext i
  simp only [Function.comp_apply,Word.mul_val,Word.lt_eval,Finset.mem_filter,Finset.mem_univ,true_and]
  apply decide_eq_decide.mpr
  have hd : (0:ℚ)<p.2.1.2.val := by exact_mod_cast h.md_pos
  have hp : (0:ℚ)<(b i).val := by exact_mod_cast hbp i
  rw [h.m_eq,heb,div_lt_div_iff₀ hd hp]
  simp only [one_mul]
  change p.2.1.1.val*(b i).val<p.2.1.2.val ↔ _
  exact_mod_cast (Iff.rfl : p.2.1.1.val*(b i).val<p.2.1.2.val ↔ _)
end RawBudget
end MeanPayoff.TreeDevice.Certified

end

section
namespace MeanPayoff.TreeDevice.Certified
open BinaryData Code
local infixl:80 " ≫ₚ " => Code.comp
local infixr:70 " ⋏ₚ " => Code.pair

namespace RawBox
abbrev Data := W × List W × List W
noncomputable def width : Code Data W := fst
noncomputable def lower : Code Data (List W) := snd ≫ₚ fst
noncomputable def upper : Code Data (List W) := snd ≫ₚ snd
noncomputable def withFloor : Code (Data × List W) Data :=
  (fst ≫ₚ width) ⋏ₚ snd ⋏ₚ (fst ≫ₚ upper)
noncomputable def withCeiling : Code (Data × List W) Data :=
  (fst ≫ₚ width) ⋏ₚ (fst ≫ₚ lower) ⋏ₚ snd
noncomputable def clip : Code (Data × List W) (List W) :=
  ((fst ≫ₚ upper) ⋏ₚ (((fst ≫ₚ lower) ⋏ₚ snd) ≫ₚ Array.max)) ≫ₚ Array.min
noncomputable def midpoint : Code Data (List W) := (lower ⋏ₚ upper) ≫ₚ Array.average
noncomputable def averageClipped : Code (Data × List W × List W) (List W) :=
  (fst ⋏ₚ (snd ≫ₚ Array.average)) ≫ₚ clip
noncomputable def centered : Code (W × List W) Data :=
  (fst ≫ₚ Word.double) ⋏ₚ
    (((fst ≫ₚ Word.neg) ⋏ₚ snd) ≫ₚ Array.translate) ⋏ₚ (Code.id ≫ₚ Array.translate)
noncomputable def capLow : Code (Data × W) Data :=
  snd ⋏ₚ (fst ≫ₚ lower) ⋏ₚ
    (((fst ≫ₚ upper) ⋏ₚ ((snd ⋏ₚ (fst ≫ₚ lower)) ≫ₚ Array.translate)) ≫ₚ Array.min)
noncomputable def capHigh : Code (Data × W) Data :=
  snd ⋏ₚ (((fst ≫ₚ lower) ⋏ₚ (((snd ≫ₚ Word.neg) ⋏ₚ (fst ≫ₚ upper)) ≫ₚ Array.translate)) ≫ₚ Array.max) ⋏ₚ
    (fst ≫ₚ upper)
noncomputable def smallVector : Code (RawBudget.Data × Data) (List W) :=
  ((fst ≫ₚ RawBudget.smallMask) ⋏ₚ (snd ≫ₚ upper) ⋏ₚ (snd ≫ₚ lower)) ≫ₚ Array.choose
noncomputable def dividedWidth : Code (Data × Count) W := ((fst ≫ₚ width) ⋏ₚ snd) ≫ₚ Word.shiftRight
noncomputable def remainderWidth : Code (Data × Count) W :=
  ((fst ≫ₚ width) ⋏ₚ dividedWidth) ≫ₚ Word.sub
noncomputable def movedFloor : Code (Data × List W × W) Bool :=
  ((snd ≫ₚ snd) ⋏ₚ (((snd ≫ₚ fst) ⋏ₚ (fst ≫ₚ lower)) ≫ₚ Array.sub)) ≫ₚ Array.anyLE
noncomputable def movedCeiling : Code (Data × List W × W) Bool :=
  ((snd ≫ₚ snd) ⋏ₚ (((fst ≫ₚ upper) ⋏ₚ (snd ≫ₚ fst)) ≫ₚ Array.sub)) ≫ₚ Array.anyLE

structure Rep {n B : ℕ} (I : SolveBox n B) (b : Data) : Prop where
  width : b.1.val=I.width
  lower : VectorRep I.a b.2.1
  upper : VectorRep I.b b.2.2

theorem floor_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    (v : BoxVector I) {vs : List W} (hv : VectorRep v.val vs) :
    Rep (I.withFloor v) (withFloor (b,vs)) := ⟨h.width,hv,h.upper⟩
theorem ceiling_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    (v : BoxVector I) {vs : List W} (hv : VectorRep v.val vs) :
    Rep (I.withCeiling v) (withCeiling (b,vs)) := ⟨h.width,h.lower,hv⟩

theorem clip_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {v : Fin n → ℤ} {vs : List W} (hv : VectorRep v vs) :
    VectorRep (MeanPayoff.clip I.a I.b v) (clip (b,vs)) := by
  exact Array.zip_rep Word.min Min.min (fun _ _ => Word.min_val _ _) h.upper
    (Array.zip_rep Word.max Max.max (fun _ _ => Word.max_val _ _) h.lower hv)

theorem midpoint_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b) :
    VectorRep I.midpoint.val (midpoint b) := by
  exact Array.zip_rep Word.average (fun a b => (a+b)/2) (fun _ _ => Word.average_val _ _) h.lower h.upper

theorem average_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {v w : Fin n → ℤ} {vs ws : List W} (hv : VectorRep v vs) (hw : VectorRep w ws) :
    VectorRep (I.averageClipped v w).val (averageClipped (b,vs,ws)) := by
  exact clip_rep h (Array.zip_rep Word.average (fun a b => (a+b)/2)
    (fun _ _ => Word.average_val _ _) hv hw)

theorem centered_rep {n B : ℕ} (v : Fin n → ℤ) {vs : List W} (hv : VectorRep v vs)
    {A : ℕ} (hA : 0<A) (hB : 2*A≤B) (a : W) (ha : a.val=A) :
    Rep (SolveBox.centered v A hA hB) (centered (a,vs)) := by
  refine ⟨?_,?_,?_⟩
  · simp [centered,Word.double_val,ha,SolveBox.centered]
  · convert Array.translate_rep hv (Word.neg a) using 1 <;> try rfl
    funext i
    simp [SolveBox.centered,Word.neg_val,ha]
    ring
  · convert Array.translate_rep hv a using 1 <;> try rfl
    funext i
    simp [SolveBox.centered,ha,add_comm]

theorem capLow_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {C : ℕ} (hC : 0<C) (hCI : C≤I.width) (c : W) (hc : c.val=C) :
    Rep (I.capLow C hC hCI) (capLow (b,c)) := by
  refine ⟨hc,h.lower,?_⟩
  convert Array.zip_rep Word.min Min.min (fun _ _ => Word.min_val _ _) h.upper
    (Array.translate_rep h.lower c) using 1 <;> try rfl
  funext i
  simp [SolveBox.capLow,hc,add_comm]

theorem capHigh_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {C : ℕ} (hC : 0<C) (hCI : C≤I.width) (c : W) (hc : c.val=C) :
    Rep (I.capHigh C hC hCI) (capHigh (b,c)) := by
  refine ⟨hc,?_,h.upper⟩
  convert Array.zip_rep Word.max Max.max (fun _ _ => Word.max_val _ _) h.lower
    (Array.translate_rep h.upper (Word.neg c)) using 1 <;> try rfl
  funext i
  simp [SolveBox.capHigh,Word.neg_val,hc,sub_eq_neg_add]

theorem smallVector_rep {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {P : Budgets n} {p : RawBudget.Data} (hp : RawBudget.Rep P p) :
    VectorRep (I.smallVector P).val (smallVector (p,b)) := by
  convert Array.choose_rep (RawBudget.smallMask_eq hp) h.upper h.lower using 1 <;> try rfl
  funext i
  simp [SolveBox.smallVector,smallRankAnswer]

theorem dividedWidth_eq {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b) (c : Count) :
    (dividedWidth (b,c)).val=(I.width:ℤ)/(2^c.length) := by
  simp [dividedWidth,Word.shiftRight_val,width,h.width]

theorem dividedWidth_nat {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    (c : Count) (d : ℕ) (hc : 2^c.length=d) :
    (dividedWidth (b,c)).val=(I.width/d:ℕ) := by
  rw [dividedWidth_eq h]
  norm_cast
  rw [hc]

theorem remainderWidth_nat {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    (c : Count) (d : ℕ) (hc : 2^c.length=d) :
    (remainderWidth (b,c)).val=(I.width-I.width/d:ℕ) := by
  change (Word.sub (b.1,dividedWidth (b,c))).val=_
  rw [Word.sub_val,h.width,dividedWidth_nat h c d hc,Int.ofNat_sub (Nat.div_le_self _ _)]

theorem movedFloor_eq {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {v : Fin n → ℤ} {vs : List W} (hv : VectorRep v vs) (d : W) :
    movedFloor (b,vs,d)=decide (∃ i, d.val≤v i-I.a i) := by
  exact Array.anyLE_eq d (Array.zip_rep Word.sub (·-·) (fun _ _ => Word.sub_val _ _) hv h.lower)
theorem movedCeiling_eq {n B : ℕ} {I : SolveBox n B} {b : Data} (h : Rep I b)
    {v : Fin n → ℤ} {vs : List W} (hv : VectorRep v vs) (d : W) :
    movedCeiling (b,vs,d)=decide (∃ i, d.val≤I.b i-v i) := by
  exact Array.anyLE_eq d (Array.zip_rep Word.sub (·-·) (fun _ _ => Word.sub_val _ _) h.upper hv)
end RawBox
end MeanPayoff.TreeDevice.Certified

end

section
namespace MeanPayoff

theorem box_iterate_fixed {n : ℕ} (F : Vec (Fin n) → Vec (Fin n)) (hF : Monotone F)
    (a b : Vec (Fin n)) (hab : a≤b) (p : Vec (Fin n)) (_hp : InBox a b p)
    (hi : p≤boxStep F a b p) (t : ℕ) (ht : volume b p≤t) :
    boxStep F a b ((boxStep F a b)^[t] p)=(boxStep F a b)^[t] p := by
  by_cases heq : boxStep F a b p=p
  · have hit : ∀ k, (boxStep F a b)^[k] p=p := by
      intro k
      induction k with
      | zero => rfl
      | succ k ih => rw [Function.iterate_succ_apply',ih,heq]
    rw [hit,heq]
  · have hq := boxStep_in_box F hab p
    have hnext := boxStep_mono hF a b hi
    have hv := volume_decreases hi hq.2 (Ne.symm heq)
    cases t with
    | zero => omega
    | succ t =>
      rw [Function.iterate_succ_apply]
      exact box_iterate_fixed F hF a b hab (boxStep F a b p) hq hnext t (by omega)
termination_by volume b p

theorem SolveBox.volume_bound {n B : ℕ} (I : SolveBox n B) : volume I.b I.a≤n*I.width := by
  unfold volume
  calc
    ∑ i : Fin n, (I.b i-I.a i).toNat ≤ ∑ _i : Fin n, I.width := by
      apply Finset.sum_le_sum
      intro i _
      exact Int.toNat_le.mpr (by exact_mod_cast I.width_bound i)
    _ = n*I.width := by simp

theorem SolveBox.iterate_exact (G : Game) {B : ℕ} (I : SolveBox G.n B)
    (t : ℕ) (ht : G.n*I.width≤t) :
    (boxStep (operator G) I.a I.b)^[t] I.a = (I.exactVector G).val := by
  have hf := box_iterate_fixed (operator G) (operator_laws G).mono I.a I.b I.ordered I.a
    ⟨le_rfl,I.ordered⟩ (boxStep_in_box (operator G) I.ordered I.a).1 t (I.volume_bound.trans ht)
  have hs := (fixed_iff_comparisons (operator G) I.ordered).mp hf
  exact le_antisymm (box_comparison G hs.1 (basic_spec G I.a I.b I.ordered).2.1)
    (box_comparison G (basic_spec G I.a I.b I.ordered).1 hs.2)
end MeanPayoff
end

end OAI