import OAI.Computability.MeanPayoff.ArenaParsing

namespace OAI

section
namespace MeanPayoff.TreeDevice.Normalize
open BinaryData
abbrev Count := Median.Count
abbrev Edge := EdgeRead.Edge
abbrev Arena := ArenaRead.Arena

def countData := listTree Median.unitData
def edgeData := EdgeRead.edgeData
def edgesData := listTree edgeData
def ownersData := listTree boolData
def arenaData := ArenaRead.arenaData

def edge (z : Count × Edge) : Edge := (z.2.1,(z.2.2.1,Scale.transform (z.2.2.2,z.1)))
noncomputable def sourceDevice : Device (product countData edgeData) countData (fun z : Count × Edge => z.2.1) :=
  compose (second countData edgeData) (first countData (product countData wordData))
noncomputable def moreDevice : Device (product countData edgeData) (product countData wordData) (fun z : Count × Edge => z.2.2) :=
  compose (second countData edgeData) (second countData (product countData wordData))
noncomputable def targetDevice : Device (product countData edgeData) countData (fun z : Count × Edge => z.2.2.1) :=
  compose moreDevice (first countData wordData)
noncomputable def weightDevice : Device (product countData edgeData) wordData (fun z : Count × Edge => z.2.2.2) :=
  compose moreDevice (second countData wordData)
noncomputable def scaleArgsDevice : Device (product countData edgeData) (product wordData countData)
    (fun z : Count × Edge => (z.2.2.2,z.1)) := fanout weightDevice (first countData edgeData)
noncomputable def scaleDevice : Device (product countData edgeData) wordData (fun z : Count × Edge => Scale.transform (z.2.2.2,z.1)) :=
  @compose (Count × Edge) (SignedBits.Word × Count) SignedBits.Word (product countData edgeData)
    (product wordData countData) wordData (fun z => (z.2.2.2,z.1)) Scale.transform scaleArgsDevice Scale.transformDevice
noncomputable def edgeDevice : Device (product countData edgeData) edgeData edge :=
  fanout sourceDevice (fanout targetDevice scaleDevice)

def arena (z : Arena) : Arena := (z.1,(z.2.1,z.2.2.map (fun e => edge (z.1,e))))
noncomputable def nDevice : Device arenaData countData (fun z : Arena => z.1) := first countData (product ownersData edgesData)
noncomputable def restDevice : Device arenaData (product ownersData edgesData) (fun z : Arena => z.2) := second countData (product ownersData edgesData)
noncomputable def ownersDevice : Device arenaData ownersData (fun z : Arena => z.2.1) := compose restDevice (first ownersData edgesData)
noncomputable def edgesDevice : Device arenaData edgesData (fun z : Arena => z.2.2) := compose restDevice (second ownersData edgesData)
noncomputable def mapDevice : Device arenaData edgesData (fun z : Arena => z.2.2.map (fun e => edge (z.1,e))) :=
  compose (fanout nDevice edgesDevice) (EnvMap.device edgeDevice)
noncomputable def arenaDevice : Device arenaData arenaData arena :=
  fanout nDevice (fanout ownersDevice mapDevice)

def read (xs : List Bool) := arena (ArenaRead.read xs)
noncomputable def device : Device (listTree boolData) arenaData read := compose ArenaRead.device arenaDevice

def word (G : Game) (e : Fin G.m) := Scale.transform (EdgeRead.encodedWord (G.weight e),List.replicate G.n ())
def encodedEdge (G : Game) (e : Fin G.m) : Edge :=
  (List.replicate (G.tail e).val (),(List.replicate (G.head e).val (),word G e))

theorem word_val (G : Game) (e : Fin G.m) : (word G e).val=transformed G e := by
  simp only [word,Scale.transform_val,List.length_replicate,EdgeRead.encodedWord_val,transformed]

theorem edge_exact (G : Game) (e : Fin G.m) :
    edge (List.replicate G.n (),EdgesRead.lower ((G.tail e).val,(G.head e).val,G.weight e))=encodedEdge G e := rfl

theorem exact (G : Game) : read (input G) =
    (List.replicate G.n (),(List.ofFn G.maxOwner,List.ofFn (encodedEdge G))) := by
  rw [read,ArenaRead.game_exact]
  simp only [arena,BinaryInput.lower,List.map_ofFn,Function.comp_def,edge_exact]

theorem source_linear : LinearCost sourceDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _)
theorem more_linear : LinearCost moreDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.second _ _)
theorem target_linear : LinearCost targetDevice := LinearCost.compose more_linear (LinearCost.first _ _)
theorem weight_linear : LinearCost weightDevice := LinearCost.compose more_linear (LinearCost.second _ _)
theorem scaleArgs_linear : LinearCost scaleArgsDevice := LinearCost.fanout weight_linear (LinearCost.first _ _)
theorem scale_polynomial : PolynomialCost scaleDevice :=
  PolynomialCost.compose scaleArgs_linear.polynomial Scale.transform_polynomial
theorem edge_polynomial : PolynomialCost edgeDevice :=
  PolynomialCost.fanout source_linear.polynomial (PolynomialCost.fanout target_linear.polynomial scale_polynomial)
theorem n_linear : LinearCost nDevice := LinearCost.first _ _
theorem rest_linear : LinearCost restDevice := LinearCost.second _ _
theorem owners_linear : LinearCost ownersDevice := LinearCost.compose rest_linear (LinearCost.first _ _)
theorem edges_linear : LinearCost edgesDevice := LinearCost.compose rest_linear (LinearCost.second _ _)
theorem map_polynomial : PolynomialCost mapDevice :=
  PolynomialCost.compose (LinearCost.fanout n_linear edges_linear).polynomial (EnvMap.polynomial edge_polynomial)
theorem arena_polynomial : PolynomialCost arenaDevice :=
  PolynomialCost.fanout n_linear.polynomial (PolynomialCost.fanout owners_linear.polynomial map_polynomial)

theorem polynomial : PolynomialCost device := PolynomialCost.compose ArenaRead.polynomial arena_polynomial
end MeanPayoff.TreeDevice.Normalize
namespace MeanPayoff.TreeDevice.Adjacency
open BinaryData
abbrev Count := Median.Count
abbrev Edge := EdgeRead.Edge
abbrev Edges := List Edge

def countData := listTree Median.unitData
def edgeData := EdgeRead.edgeData
def edgesData := listTree edgeData

def test (p : Count × Edge) := CountTest.equal (p.1,p.2.1)
noncomputable def testArgsDevice : Device (product countData edgeData) (product countData countData)
    (fun p : Count × Edge => (p.1,p.2.1)) :=
  fanout (first countData edgeData) (compose (second countData edgeData) (first countData Graph.edgeData))
noncomputable def testDevice : Device (product countData edgeData) Compare.bitTree test :=
  @compose (Count × Edge) (Count × Count) Bool (product countData edgeData) (product countData countData)
    Compare.bitTree (fun p => (p.1,p.2.1)) CountTest.equal testArgsDevice CountTest.device

def select (z : Count × Edges) : List Graph.Edge :=
  (z.2.filter (fun e => test (z.1,e))).map Prod.snd
noncomputable def selectDevice : Device (product countData edgesData) (listTree Graph.edgeData) select :=
  compose (EnvFilter.device testDevice) (Map.device (second countData Graph.edgeData))

def defaultEdge : Graph.Edge := ([],Median.zeroWord)
def nonempty (xs : List Graph.Edge) : Graph.Edges := (xs.headD defaultEdge,xs.tail)
noncomputable def nonemptyDevice : Device (listTree Graph.edgeData) Graph.edgesData nonempty :=
  fanout (Head.device Graph.edgeData defaultEdge) (Tail.device Graph.edgeData)

def vertex (edges : Edges) (p : Count × Bool) : Graph.Vertex :=
  (p.2,nonempty (select (p.1,edges)))
abbrev Args := Edges × (Count × Bool)
def argsData := product edgesData (product countData boolData)
noncomputable def localDevice : Device argsData (product countData boolData) (fun p : Args => p.2) := second edgesData (product countData boolData)
noncomputable def ownerDevice : Device argsData Compare.bitTree (fun p : Args => p.2.2) :=
  (compose (compose localDevice (second countData boolData)) Multiply.rawTest).extFun (by intro p; rfl)
noncomputable def addressDevice : Device argsData countData (fun p : Args => p.2.1) :=
  compose localDevice (first countData boolData)
noncomputable def selectArgsDevice : Device argsData (product countData edgesData) (fun p : Args => (p.2.1,p.1)) :=
  fanout addressDevice (first edgesData (product countData boolData))
noncomputable def selectedDevice : Device argsData (listTree Graph.edgeData) (fun p : Args => select (p.2.1,p.1)) :=
  @compose Args (Count × Edges) (List Graph.Edge) argsData (product countData edgesData)
    (listTree Graph.edgeData) (fun p => (p.2.1,p.1)) select selectArgsDevice selectDevice
noncomputable def vertexDevice : Device argsData Graph.vertexData (fun p : Args => vertex p.1 p.2) :=
  fanout ownerDevice (compose selectedDevice nonemptyDevice)

theorem test_exact (G : Game) (v : Fin G.n) (e : Fin G.m) :
    test (List.replicate v.val (),Normalize.encodedEdge G e)=decide (G.tail e=v) := by
  rw [test,CountTest.equal_eq]
  simp only [Normalize.encodedEdge,List.length_replicate]
  apply Bool.eq_iff_iff.mpr
  simp only [decide_eq_true_eq]
  constructor
  · intro h; exact Fin.ext h.symm
  · intro h; exact congrArg Fin.val h.symm

theorem select_exact (G : Game) (v : Fin G.n) :
    select (List.replicate v.val (),List.ofFn (Normalize.encodedEdge G)) =
      (Graph.outList G v).map (Graph.codeEdge G (Normalize.word G)) := by
  simp only [select,List.ofFn_eq_map,List.filter_map,List.map_map,Function.comp_def,test_exact]
  rfl

theorem vertex_exact (G : Game) (v : Fin G.n) :
    vertex (List.ofFn (Normalize.encodedEdge G)) (List.replicate v.val (),G.maxOwner v) =
      Graph.codeVertex G (Normalize.word G) v := by
  rw [vertex,select_exact]
  have h := Graph.outList_ne_nil G v
  rw [show Graph.outList G v=Graph.firstEdge G v::(Graph.outList G v).tail from (List.cons_head_tail h).symm]
  rfl

theorem testArgs_linear : LinearCost testArgsDevice :=
  LinearCost.fanout (LinearCost.first _ _) (LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _))
theorem test_polynomial : PolynomialCost testDevice := PolynomialCost.compose testArgs_linear.polynomial CountTest.polynomial
theorem select_polynomial : PolynomialCost selectDevice :=
  PolynomialCost.compose (EnvFilter.polynomial test_polynomial) (PolynomialCost.map (LinearCost.second _ _).polynomial)
theorem nonempty_linear : LinearCost nonemptyDevice := LinearCost.fanout (LinearCost.head _ _) (LinearCost.tail _)
theorem local_linear : LinearCost localDevice := LinearCost.second _ _
theorem owner_linear : LinearCost ownerDevice :=
  LinearCost.compose (LinearCost.compose local_linear (LinearCost.second _ _)) Multiply.rawTest_linear
theorem address_linear : LinearCost addressDevice := LinearCost.compose local_linear (LinearCost.first _ _)
theorem selectArgs_linear : LinearCost selectArgsDevice := LinearCost.fanout address_linear (LinearCost.first _ _)
theorem selected_polynomial : PolynomialCost selectedDevice := PolynomialCost.compose selectArgs_linear.polynomial select_polynomial
theorem vertex_polynomial : PolynomialCost vertexDevice :=
  PolynomialCost.fanout owner_linear.polynomial (PolynomialCost.compose selected_polynomial nonempty_linear.polynomial)
end MeanPayoff.TreeDevice.Adjacency
namespace MeanPayoff.TreeDevice.Rows
open BinaryData
abbrev Edge := EdgeRead.Edge
abbrev Edges := List Edge
abbrev Count := Median.Count
abbrev Arena := ArenaRead.Arena
abbrev State := StreamFold.State Edges Graph.Vertex (List Bool)

def ownersData := listTree boolData
def countData := listTree Median.unitData
def edgesData := listTree EdgeRead.edgeData
def outputData := listTree Graph.vertexData
def rowArgsData := product edgesData ownersData
def rowOutputData := product Graph.vertexData ownersData
def stateData := StreamFold.stateData edgesData Graph.vertexData ownersData

def count (xs : List Bool) : Count := xs.map (fun _ => ())
noncomputable def countDevice : Device ownersData countData count :=
  Map.device (constant boolData Median.unitData ())

theorem count_eq (xs : List Bool) : count xs = List.replicate xs.length () := by simp [count]

def row (p : Edges × List Bool) : Graph.Vertex × List Bool :=
  (Adjacency.vertex p.1 (count p.2.tail,p.2.headD false),p.2.tail)
noncomputable def streamDevice : Device rowArgsData ownersData (fun p : Edges × List Bool => p.2) := second edgesData ownersData
noncomputable def remainderDevice : Device rowArgsData ownersData (fun p : Edges × List Bool => p.2.tail) :=
  compose streamDevice (Tail.device boolData)
noncomputable def addressDevice : Device rowArgsData countData (fun p : Edges × List Bool => count p.2.tail) :=
  compose remainderDevice countDevice
noncomputable def ownerDevice : Device rowArgsData boolData (fun p : Edges × List Bool => p.2.headD false) :=
  compose streamDevice (Head.device boolData false)
noncomputable def vertexArgsDevice : Device rowArgsData Adjacency.argsData
    (fun p : Edges × List Bool => (p.1,(count p.2.tail,p.2.headD false))) :=
  fanout (first edgesData ownersData) (fanout addressDevice ownerDevice)
noncomputable def vertexDevice : Device rowArgsData Graph.vertexData
    (fun p : Edges × List Bool => Adjacency.vertex p.1 (count p.2.tail,p.2.headD false)) :=
  compose vertexArgsDevice Adjacency.vertexDevice
noncomputable def rowDevice : Device rowArgsData rowOutputData row := fanout vertexDevice remainderDevice

def descending (edges : Edges) : List Bool → List Graph.Vertex
  | [] => []
  | b::bs => Adjacency.vertex edges (List.replicate bs.length (),b)::descending edges bs

theorem fold_exact (edges : Edges) (owners : List Bool) (acc : List Graph.Vertex) :
    Fold.fold (StreamFold.step row) (edges,(acc,owners)) (List.replicate owners.length ()) =
      (edges,((descending edges owners).reverse++acc,[])) := by
  induction owners generalizing acc with
  | nil => simp [Fold.fold,descending]
  | cons b bs ih =>
    simp only [List.length_cons,List.replicate_succ,Fold.fold,List.foldl_cons]
    change Fold.fold (StreamFold.step row) (StreamFold.step row ((edges,(acc,b::bs)),())) (List.replicate bs.length ())= _
    simp only [StreamFold.step,row,List.tail_cons,List.headD_cons,count_eq]
    rw [ih]
    simp [descending,List.reverse_cons,List.append_assoc]

theorem descending_ofFn (edges : Edges) {n : ℕ} (f : Fin n → Bool) :
    (descending edges (List.ofFn f).reverse).reverse=
      List.ofFn (fun i => Adjacency.vertex edges (List.replicate i.val (),f i)) := by
  induction n with
  | zero => simp [descending]
  | succ n ih =>
    rw [List.ofFn_succ_last,List.reverse_append]
    simp only [List.singleton_append,descending,List.length_reverse,List.length_ofFn,List.reverse_cons,List.reverse_nil,List.nil_append]
    rw [ih,List.ofFn_succ_last]
    rfl

def build (z : Arena) : List Graph.Vertex :=
  (Fold.fold (StreamFold.step row) (z.2.2,([],z.2.1.reverse)) z.1).2.1
noncomputable def restDevice : Device ArenaRead.arenaData (product ownersData edgesData) (fun z : Arena => z.2) := second countData (product ownersData edgesData)
noncomputable def edgesDevice : Device ArenaRead.arenaData edgesData (fun z : Arena => z.2.2) := compose restDevice (second ownersData edgesData)
noncomputable def ownersDevice : Device ArenaRead.arenaData ownersData (fun z : Arena => z.2.1) := compose restDevice (first ownersData edgesData)
noncomputable def reversedDevice : Device ArenaRead.arenaData ownersData (fun z : Arena => z.2.1.reverse) :=
  compose ownersDevice (Lists.reverseDevice boolData)
noncomputable def stateDevice : Device ArenaRead.arenaData stateData (fun z : Arena => (z.2.2,([],z.2.1.reverse))) :=
  fanout edgesDevice (compose reversedDevice (Lists.nilPrefix ownersData Graph.vertexData))
noncomputable def initDevice : Device ArenaRead.arenaData (product stateData countData)
    (fun z : Arena => ((z.2.2,([],z.2.1.reverse)),z.1)) :=
  fanout stateDevice (first countData (product ownersData edgesData))
noncomputable def resultDevice : Device stateData outputData (fun s : State => s.2.1) :=
  compose (second edgesData (product outputData ownersData)) (first outputData ownersData)
noncomputable def foldedDevice : Device (product stateData countData) outputData
    (fun z : State × Count => (Fold.fold (StreamFold.step row) z.1 z.2).2.1) :=
  @compose (State × Count) State (List Graph.Vertex) (product stateData countData) stateData outputData
    (fun z => Fold.fold (StreamFold.step row) z.1 z.2) (fun s => s.2.1)
    (Fold.device (StreamFold.stepDevice rowDevice)) resultDevice
noncomputable def buildDevice : Device ArenaRead.arenaData outputData build :=
  @compose Arena (State × Count) (List Graph.Vertex) ArenaRead.arenaData (product stateData countData) outputData
    (fun z => ((z.2.2,([],z.2.1.reverse)),z.1)) (fun z => (Fold.fold (StreamFold.step row) z.1 z.2).2.1)
    initDevice foldedDevice

def read (xs : List Bool) : List Graph.Vertex := build (Normalize.read xs)
noncomputable def device : Device (listTree boolData) outputData read := compose Normalize.device buildDevice

theorem build_exact (G : Game) :
    build (List.replicate G.n (),(List.ofFn G.maxOwner,List.ofFn (Normalize.encodedEdge G))) =
      Graph.codeVertices G (Normalize.word G) := by
  have hf := fold_exact (List.ofFn (Normalize.encodedEdge G)) (List.ofFn G.maxOwner).reverse []
  simp only [List.length_reverse,List.length_ofFn] at hf
  change (Fold.fold (StreamFold.step row) (List.ofFn (Normalize.encodedEdge G),([], (List.ofFn G.maxOwner).reverse)) (List.replicate G.n ())).2.1 = _
  rw [hf]
  simp only [List.append_nil,descending_ofFn,Graph.codeVertices]
  apply congrArg List.ofFn
  funext v
  exact Adjacency.vertex_exact G v

theorem exact (G : Game) : read (input G) = Graph.codeVertices G (Normalize.word G) := by
  rw [read,Normalize.exact,build_exact]

theorem count_polynomial : PolynomialCost countDevice := PolynomialCost.map (LinearCost.constant _ _ _).polynomial
theorem stream_linear : LinearCost streamDevice := LinearCost.second _ _
theorem remainder_linear : LinearCost remainderDevice := LinearCost.compose stream_linear (LinearCost.tail _)
theorem address_polynomial : PolynomialCost addressDevice := PolynomialCost.compose remainder_linear.polynomial count_polynomial
theorem owner_linear : LinearCost ownerDevice := LinearCost.compose stream_linear (LinearCost.head _ _)
theorem vertexArgs_polynomial : PolynomialCost vertexArgsDevice :=
  PolynomialCost.fanout (LinearCost.first _ _).polynomial (PolynomialCost.fanout address_polynomial owner_linear.polynomial)
theorem vertex_polynomial : PolynomialCost vertexDevice := PolynomialCost.compose vertexArgs_polynomial Adjacency.vertex_polynomial
theorem row_polynomial : PolynomialCost rowDevice := PolynomialCost.fanout vertex_polynomial remainder_linear.polynomial

theorem fold_polynomial : PolynomialCost (Fold.device (StreamFold.stepDevice rowDevice)) := by
  apply StreamFold.polynomial rowDevice row_polynomial
  intro edges owners
  change treeSize (ownersData owners.tail)≤treeSize (ownersData owners)
  cases owners <;> simp only [ownersData,List.tail_nil,List.tail_cons,listTree,treeSize_pair] <;> omega

theorem rest_linear : LinearCost restDevice := LinearCost.second _ _
theorem edges_linear : LinearCost edgesDevice := LinearCost.compose rest_linear (LinearCost.second _ _)
theorem owners_linear : LinearCost ownersDevice := LinearCost.compose rest_linear (LinearCost.first _ _)
theorem reversed_polynomial : PolynomialCost reversedDevice := PolynomialCost.compose owners_linear.polynomial (PolynomialCost.reverse _)
theorem state_polynomial : PolynomialCost stateDevice :=
  PolynomialCost.fanout edges_linear.polynomial (PolynomialCost.compose reversed_polynomial (LinearCost.nilPrefix _ _).polynomial)
theorem init_polynomial : PolynomialCost initDevice := PolynomialCost.fanout state_polynomial (LinearCost.first _ _).polynomial
theorem result_linear : LinearCost resultDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _)
theorem folded_polynomial : PolynomialCost foldedDevice := PolynomialCost.compose fold_polynomial result_linear.polynomial
theorem build_polynomial : PolynomialCost buildDevice := PolynomialCost.compose init_polynomial folded_polynomial

theorem polynomial : PolynomialCost device := PolynomialCost.compose Normalize.polynomial build_polynomial
end MeanPayoff.TreeDevice.Rows
end

end OAI