import OAI.Computability.MeanPayoff.PolynomialCosts

namespace OAI

section

namespace MeanPayoff.TreeDevice.EnvMap
open BinaryData

abbrev Acc (α γ : Type) := α × List γ

def step {α β γ : Type} (f : α × β → γ) (z : Acc α γ × β) : Acc α γ :=
  (z.1.1,f (z.1.1,z.2)::z.1.2)

noncomputable def argument {α β γ : Type} (ea : α → Data) (eb : β → Data) (ec : γ → Data) :
    Device (product (product ea (listTree ec)) eb) (product ea eb)
      (fun z : Acc α γ × β => (z.1.1,z.2)) :=
  fanout (compose (first (product ea (listTree ec)) eb) (first ea (listTree ec)))
    (second (product ea (listTree ec)) eb)

noncomputable def stepDevice {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} (F : Device (product ea eb) ec f) :
    Device (product (product ea (listTree ec)) eb) (product ea (listTree ec)) (step f) :=
  fanout (compose (first (product ea (listTree ec)) eb) (first ea (listTree ec)))
    (compose (fanout (compose (argument ea eb ec) F)
      (compose (first (product ea (listTree ec)) eb) (second ea (listTree ec)))) (Lists.consDevice ec))

theorem fold_eq {α β γ : Type} (f : α × β → γ) (p : α) (xs : List β) (acc : List γ) :
    Fold.fold (step f) (p,acc) xs = (p,(xs.map (fun x => f (p,x))).reverse++acc) := by
  induction xs generalizing acc with
  | nil => simp [Fold.fold]
  | cons x xs ih =>
    change Fold.fold (step f) (p,f (p,x)::acc) xs = _
    rw [ih]
    simp [List.reverse_cons,List.append_assoc]

noncomputable def device {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} (F : Device (product ea eb) ec f) :
    Device (product ea (listTree eb)) (listTree ec)
      (fun z : α × List β => z.2.map (fun x => f (z.1,x))) := by
  let initial := fanout (compose (first ea (listTree eb)) (Lists.nilSuffix ea ec))
    (second ea (listTree eb))
  let P := compose initial (compose (Fold.device (stepDevice F))
    (compose (second ea (listTree ec)) (Lists.reverseDevice ec)))
  exact P.extFun (by
    rintro ⟨p,xs⟩
    change (Fold.fold (step f) (p,[]) xs).2.reverse = _
    rw [fold_eq]
    simp)

end MeanPayoff.TreeDevice.EnvMap

namespace MeanPayoff.TreeDevice.Graph
open BinaryData

abbrev W := SignedBits.Word
abbrev Count := Median.Count
abbrev Pot := List W
abbrev Edge := Count × W
abbrev Edges := Edge × List Edge
abbrev Vertex := Bool × Edges
abbrev Batch := EdgeScan.Pair × List EdgeScan.Pair

def countData := listTree Median.unitData
def potData := listTree wordData
def edgeData := product countData wordData
def edgesData := product edgeData (listTree edgeData)
def vertexData := product Compare.bitTree edgesData
def valuePairData := product wordData wordData
def batchData := product valuePairData (listTree valuePairData)

def lookup (z : Pot × Count) : W := (z.1.drop z.2.length).headD Median.zeroWord

noncomputable def lookupDevice : Device (product potData countData) wordData lookup :=
  compose (Median.dropDevice wordData) (Head.device wordData Median.zeroWord)

def edgePair (z : Pot × Edge) : EdgeScan.Pair := (z.2.2,lookup (z.1,z.2.1))

noncomputable def edgeDevice : Device (product potData edgeData) valuePairData edgePair :=
  fanout (compose (second potData edgeData) (second countData wordData))
    (compose (fanout (first potData edgeData)
      (compose (second potData edgeData) (first countData wordData))) lookupDevice)

def batch (z : Pot × Edges) : Batch :=
  (edgePair (z.1,z.2.1),z.2.2.map (fun e => edgePair (z.1,e)))

noncomputable def batchDevice : Device (product potData edgesData) batchData batch :=
  fanout (compose (fanout (first potData edgesData)
      (compose (second potData edgesData) (first edgeData (listTree edgeData)))) edgeDevice)
    (compose (fanout (first potData edgesData)
      (compose (second potData edgesData) (second edgeData (listTree edgeData)))) (EnvMap.device edgeDevice))

def vertex (z : Pot × Vertex) : W :=
  if z.2.1 then EdgeScan.maxScan (batch (z.1,z.2.2)) else EdgeScan.minScan (batch (z.1,z.2.2))

noncomputable def vertexDevice : Device (product potData vertexData) wordData vertex := by
  let B := compose (fanout (first potData vertexData)
    (compose (second potData vertexData) (second Compare.bitTree edgesData))) batchDevice
  exact branch (compose (second potData vertexData) (first Compare.bitTree edgesData))
    (compose B EdgeScan.maxDevice) (compose B EdgeScan.minDevice)

noncomputable def device : Device (product potData (listTree vertexData)) potData
    (fun z : Pot × List Vertex => z.2.map (fun v => vertex (z.1,v))) := EnvMap.device vertexDevice

def codeEdge (G : Game) (w : Fin G.m → W) (e : Fin G.m) : Edge :=
  (List.replicate (G.head e).val (),w e)

def codePot {n : ℕ} (p : Fin n → W) : Pot := List.ofFn p

theorem lookup_exact {n : ℕ} (p : Fin n → W) (i : Fin n) :
    lookup (codePot p,List.replicate i.val ()) = p i := by
  unfold lookup codePot
  rw [List.length_replicate,List.headD_eq_head?_getD,List.head?_drop,List.getElem?_ofFn]
  simp [i.isLt]

theorem edgePair_exact (G : Game) (p : Fin G.n → W) (w : Fin G.m → W) (e : Fin G.m) :
    edgePair (codePot p,codeEdge G w e) = (w e,p (G.head e)) := by
  simp only [edgePair,codeEdge,lookup_exact]

theorem batch_represents (G : Game) (p : Fin G.n → W) (w : Fin G.m → W)
    (hw : ∀ e, (w e).val = transformed G e) (v : Fin G.n)
    (e : Fin G.m) (es : List (Fin G.m))
    (hes : ∀ f, f∈e::es ↔ f∈outgoing G v) :
    EdgeScan.Represents G (fun i => (p i).val) v
      (batch (codePot p,(codeEdge G w e,es.map (codeEdge G w)))) := by
  have eqs : (batch (codePot p,(codeEdge G w e,es.map (codeEdge G w)))).1::
      (batch (codePot p,(codeEdge G w e,es.map (codeEdge G w)))).2 =
      (e::es).map (fun f => (w f,p (G.head f))) := by
    simp only [batch,edgePair_exact,List.map_map,List.map_cons,Function.comp_def]
  constructor
  · intro ab hab
    rw [eqs] at hab
    obtain ⟨f,hf,rfl⟩ := List.mem_map.mp hab
    exact ⟨f,(hes f).mp hf,by rw [hw]⟩
  · intro f hf
    refine ⟨(w f,p (G.head f)),?_,?_⟩
    · rw [eqs]
      exact List.mem_map.mpr ⟨f,(hes f).mpr hf,rfl⟩
    · rw [hw]

theorem vertex_exact (G : Game) (p : Fin G.n → W) (w : Fin G.m → W)
    (hw : ∀ e, (w e).val = transformed G e) (v : Fin G.n)
    (e : Fin G.m) (es : List (Fin G.m)) (hes : ∀ f, f∈e::es ↔ f∈outgoing G v) :
    (vertex (codePot p,(G.maxOwner v,(codeEdge G w e,es.map (codeEdge G w))))).val =
      operator G (fun i => (p i).val) v := by
  have hh := EdgeScan.operator_exact G (fun i => (p i).val) v _ (batch_represents G p w hw v e es hes)
  simpa only [vertex,apply_ite] using hh

end MeanPayoff.TreeDevice.Graph

namespace MeanPayoff.TreeDevice.EnvMap
open BinaryData

theorem step_limit {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} (F : Device (product ea eb) ec f) (p : α) (acc : List γ) (b : β) :
    (stepDevice F).limit ((p,acc),b) ≤
      1000*(treeSize (ea p)+treeSize (listTree ec acc)+treeSize (eb b)+F.limit (p,b)+1) := by
  have ho := output_size F (p,b)
  simp only [product,treeSize_pair] at ho
  simp only [stepDevice,argument,fanout_limit,compose_limit,first_limit,second_limit,
    Function.comp_def,product,treeSize_pair,listTree_cons,Lists.consDevice,Device.recode,identity]
  nlinarith

def resource {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} (F : Device (product ea eb) ec f) (p : α) (acc : List γ) (xs : List β) : ℕ :=
  treeSize (ea p)+treeSize (listTree ec acc)+treeSize (listTree eb xs)+
    xs.length*(treeSize (ea p)+1)+(xs.map (fun b => F.limit (p,b))).sum+1

theorem resource_decrease {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} (F : Device (product ea eb) ec f) (p : α) (acc : List γ) (b : β) (bs : List β) :
    resource F p (f (p,b)::acc) bs ≤ resource F p acc (b::bs) := by
  have ho := output_size F (p,b)
  simp only [product,treeSize_pair] at ho
  simp only [resource,listTree,treeSize_pair,List.length_cons,List.map_cons,List.sum_cons]
  nlinarith

theorem fold_time {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} (F : Device (product ea eb) ec f) (p : α) (acc : List γ) (xs : List β) :
    Fold.time (stepDevice F) (p,acc) xs ≤ 1200*(xs.length+1)*resource F p acc xs := by
  induction xs generalizing acc with
  | nil =>
    simp only [Fold.time,resource,product,treeSize_pair,listTree,treeSize_nil,List.length_nil,List.map_nil,List.sum_nil]
    nlinarith
  | cons b bs ih =>
    have hs := step_limit F p acc b
    have hd := resource_decrease F p acc b bs
    have hr := ih (f (p,b)::acc)
    have hm := Nat.mul_le_mul_left (1200*(bs.length+1)) hd
    have hlocal : treeSize (ea p)+treeSize (listTree ec acc)+treeSize (eb b)+F.limit (p,b)+1 ≤ resource F p acc (b::bs) := by
      simp only [resource,listTree,treeSize_pair,List.length_cons,List.map_cons,List.sum_cons]
      omega
    change 12*treeSize (product ea (listTree ec) (p,acc))+(stepDevice F).limit ((p,acc),b)+11+
      Fold.time (stepDevice F) (step f ((p,acc),b)) bs ≤ _
    dsimp only [step]
    simp only [product,treeSize_pair,List.length_cons]
    have hp : 1 ≤ resource F p acc (b::bs) := by unfold resource; omega
    nlinarith

theorem fold_polynomial {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} {F : Device (product ea eb) ec f} (hF : PolynomialCost F) :
    PolynomialCost (Fold.device (stepDevice F)) := by
  obtain ⟨K,d,hK⟩ := hF
  refine ⟨1200*(K+3)+2,d+3,?_⟩
  rintro ⟨⟨p,acc⟩,xs⟩
  let N := treeSize (product (product ea (listTree ec)) (listTree eb) ((p,acc),xs))+1
  have hN : N = treeSize (ea p)+treeSize (listTree ec acc)+treeSize (listTree eb xs)+3 := by
    simp [N,product,treeSize_pair]; omega
  have hn : 1 ≤ N := by omega
  have hlen : xs.length+1 ≤ N := (list_length_le_size eb xs).trans (by omega)
  have he : ∀ x∈xs, F.limit (p,x) ≤ K*N^d := by
    intro x hx
    have hh := element_size_le eb hx
    have hi : treeSize (product ea eb (p,x))+1 ≤ N := by
      simp only [product,treeSize_pair]; omega
    exact (hK (p,x)).trans (Nat.mul_le_mul_left K (Nat.pow_le_pow_left hi d))
  have hsum : (xs.map (fun b => F.limit (p,b))).sum ≤ xs.length*(K*N^d) := by
    have hh := List.sum_le_length_nsmul (xs.map (fun b => F.limit (p,b))) (K*N^d) (by
      intro y hy
      obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hy
      exact he b hb)
    simpa using hh
  have hs := hsum.trans (Nat.mul_le_mul_right (K*N^d) (show xs.length ≤ N by omega))
  have hd : N^(d+1) ≤ N^(d+2) := pow_le_pow_right' hn (by omega)
  have htwo : N^2 ≤ N^(d+2) := pow_le_pow_right' hn (by omega)
  have hlin : N ≤ N^(d+2) := by simpa using pow_le_pow_right' hn (show 1 ≤ d+2 by omega)
  have hpm := Nat.mul_le_mul (show xs.length ≤ N by omega) (show treeSize (ea p)+1 ≤ N by omega)
  have hcost : resource F p acc xs ≤ (K+3)*N^(d+2) := by
    unfold resource
    rw [pow_succ] at hd
    rw [pow_two] at htwo
    have hh := Nat.mul_le_mul_left K hd
    nlinarith
  have ht := fold_time F p acc xs
  have hl := Nat.mul_le_mul (show 1200*(xs.length+1) ≤ 1200*N from Nat.mul_le_mul_left _ hlen) hcost
  have hpos : 1 ≤ N^(d+3) := one_le_pow₀ hn
  change Fold.time (stepDevice F) (p,acc) xs+2 ≤ (1200*(K+3)+2)*N^(d+3)
  rw [show d+3=(d+2)+1 by omega,pow_succ] at hpos ⊢
  nlinarith

theorem polynomial {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
    {f : α × β → γ} {F : Device (product ea eb) ec f} (hF : PolynomialCost F) :
    PolynomialCost (device F) := by
  apply PolynomialCost.compose
    (LinearCost.fanout (LinearCost.compose (LinearCost.first _ _) (LinearCost.nilSuffix _ _))
      (LinearCost.second _ _)).polynomial
  apply PolynomialCost.compose (fold_polynomial hF)
  exact PolynomialCost.compose (LinearCost.second _ _).polynomial (PolynomialCost.reverse _)

end MeanPayoff.TreeDevice.EnvMap

namespace MeanPayoff.TreeDevice
open BinaryData
namespace PolynomialCost

theorem branch {α β : Type} {ea : α → Data} {eb : β → Data}
    {test : α → Bool} {f g : α → β} {T : Device ea Compare.bitTree test}
    {F : Device ea eb f} {G : Device ea eb g}
    (hT : PolynomialCost T) (hF : PolynomialCost F) (hG : PolynomialCost G) :
    PolynomialCost (TreeDevice.branch T F G) :=
  compose (fanout hT (fanout hF hG)) (LinearCost.select _).polynomial

end PolynomialCost
namespace EdgeScan

theorem max_polynomial : PolynomialCost maxDevice := by
  apply PolynomialCost.compose
    (PolynomialCost.pairMap LinearCost.add.polynomial (PolynomialCost.map LinearCost.add.polynomial))
  apply Fold.polynomial LinearCost.max.polynomial
  intro a b
  rcases high_mem (a,b) with h | h <;> rw [h] <;> dsimp only <;> omega

theorem min_polynomial : PolynomialCost minDevice := by
  apply PolynomialCost.compose
    (PolynomialCost.pairMap LinearCost.add.polynomial (PolynomialCost.map LinearCost.add.polynomial))
  apply Fold.polynomial LinearCost.min.polynomial
  intro a b
  rcases low_mem (a,b) with h | h <;> rw [h] <;> dsimp only <;> omega

end EdgeScan
namespace Graph

theorem lookup_polynomial : PolynomialCost lookupDevice :=
  PolynomialCost.compose (Median.drop_polynomial _) (LinearCost.head _ _).polynomial

theorem edge_polynomial : PolynomialCost edgeDevice := by
  refine PolynomialCost.fanout ?_ ?_
  · exact (LinearCost.compose (LinearCost.second _ _) (LinearCost.second _ _)).polynomial
  · exact PolynomialCost.compose
      (LinearCost.fanout (LinearCost.first _ _)
        (LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _))).polynomial lookup_polynomial

theorem batch_polynomial : PolynomialCost batchDevice := by
  refine PolynomialCost.fanout ?_ ?_
  · exact PolynomialCost.compose
      (LinearCost.fanout (LinearCost.first _ _)
        (LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _))).polynomial edge_polynomial
  · exact PolynomialCost.compose
      (LinearCost.fanout (LinearCost.first _ _)
        (LinearCost.compose (LinearCost.second _ _) (LinearCost.second _ _))).polynomial
      (EnvMap.polynomial edge_polynomial)

theorem vertex_polynomial : PolynomialCost vertexDevice := by
  have hB := PolynomialCost.compose
    (LinearCost.fanout (LinearCost.first potData vertexData)
      (LinearCost.compose (LinearCost.second potData vertexData)
        (LinearCost.second Compare.bitTree edgesData))).polynomial batch_polynomial
  exact PolynomialCost.branch
    (LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _)).polynomial
    (PolynomialCost.compose hB EdgeScan.max_polynomial)
    (PolynomialCost.compose hB EdgeScan.min_polynomial)

theorem polynomial : PolynomialCost device := EnvMap.polynomial vertex_polynomial

end Graph
end MeanPayoff.TreeDevice
end

end OAI