import OAI.Computability.MeanPayoff.WordDecoding

namespace OAI

section
namespace MeanPayoff.TreeDevice.Address
open BinaryData
abbrev W := SignedBits.Word
abbrev Count := Median.Count
abbrev State := W × Count
def countData := listTree Median.unitData
def stateData := product wordData countData
def inputData := product stateData boolData

def dec (w : W) : W := Add.sumPair (w,IntegerRead.minusOne)
def test (w : W) : Bool := Compare.testPair (Median.zeroWord,w)
def step (z : State × Bool) : State :=
  if test z.1.1 then (dec z.1.1,()::z.1.2) else z.1

theorem dec_val (w : W) : (dec w).val = w.val-1 := by
  rw [dec,Add.sumPair_val]
  simp [IntegerRead.minusOne,SignedBits.Word.val,sub_eq_add_neg,BinaryStack.Addition.value]
theorem test_eq (w : W) : test w = decide (0<w.val) := by
  rw [test,Compare.testPair_eq]
  rfl

noncomputable def wordDevice : Device inputData wordData (fun z : State × Bool => z.1.1) :=
  compose (first stateData boolData) (first wordData countData)
noncomputable def listDevice : Device inputData countData (fun z : State × Bool => z.1.2) :=
  compose (first stateData boolData) (second wordData countData)
noncomputable def decDevice : Device wordData wordData dec :=
  compose (fanout (identity wordData) (constant wordData wordData IntegerRead.minusOne)) Add.device
noncomputable def testDevice : Device inputData Compare.bitTree (fun z : State × Bool => test z.1.1) :=
  compose (fanout (constant inputData wordData Median.zeroWord) wordDevice) Compare.device
noncomputable def newWordDevice : Device inputData wordData (fun z : State × Bool => dec z.1.1) :=
  @compose _ _ _ inputData wordData wordData (fun z : State × Bool => z.1.1) dec wordDevice decDevice
noncomputable def newCountDevice : Device inputData countData (fun z : State × Bool => ()::z.1.2) :=
  compose listDevice Median.incrementDevice
noncomputable def nextDevice : Device inputData stateData
    (fun z : State × Bool => (dec z.1.1,()::z.1.2)) :=
  fanout newWordDevice newCountDevice
noncomputable def stepDevice : Device inputData stateData step :=
  branch testDevice nextDevice (first stateData boolData)

def read (z : W × List Bool) : Count := (Fold.fold step (z.1,[]) z.2).2
noncomputable def initDevice : Device (product wordData (listTree boolData))
    (product stateData (listTree boolData)) (fun z : W × List Bool => ((z.1,[]),z.2)) :=
  pairMap (Lists.nilSuffix wordData Median.unitData) (identity (listTree boolData))
noncomputable def finishDevice : Device (product stateData (listTree boolData)) countData
    (fun z : State × List Bool => (Fold.fold step z.1 z.2).2) :=
  @compose _ _ _ (product stateData (listTree boolData)) stateData countData
    (fun z : State × List Bool => Fold.fold step z.1 z.2) (fun s : State => s.2)
    (Fold.device stepDevice) (second wordData countData)
noncomputable def device : Device (product wordData (listTree boolData)) countData read :=
  @compose _ _ _ (product wordData (listTree boolData)) (product stateData (listTree boolData)) countData
    (fun z : W × List Bool => ((z.1,[]),z.2))
    (fun z : State × List Bool => (Fold.fold step z.1 z.2).2) initDevice finishDevice

theorem fold_stopped (w : W) (hw : w.val ≤ 0) (c : Count) (xs : List Bool) :
    Fold.fold step (w,c) xs = (w,c) := by
  induction xs with
  | nil => rfl
  | cons x xs ih =>
    change Fold.fold step (step ((w,c),x)) xs = _
    simpa only [step,test_eq,decide_eq_true_eq,not_lt_of_ge hw,↓reduceIte] using ih

theorem fold_count (n : ℕ) (w : W) (hw : w.val=n) (c : Count) (xs : List Bool)
    (hn : n ≤ xs.length) :
    (Fold.fold step (w,c) xs).2 = List.replicate n ()++c := by
  induction n generalizing w c xs with
  | zero => simp [fold_stopped w (by omega) c xs]
  | succ n ih =>
    cases xs with
    | nil => simp at hn
    | cons x xs =>
      have hp : test w = true := by simp [test_eq,hw]
      change (Fold.fold step (step ((w,c),x)) xs).2 = _
      simp only [step,hp,↓reduceIte]
      rw [ih (dec w) (by rw [dec_val,hw]; omega) (()::c) xs (by simpa using hn)]
      apply List.ext_getElem <;> simp [Nat.add_comm,Nat.add_left_comm]

theorem exact (n : ℕ) (w : W) (hw : w.val=n) (xs : List Bool) (hn : n≤xs.length) :
    read (w,xs) = List.replicate n () := by
  simp only [read,fold_count n w hw [] xs hn,List.append_nil]

theorem word_linear : LinearCost wordDevice := LinearCost.compose (LinearCost.first _ _) (LinearCost.first _ _)
theorem list_linear : LinearCost listDevice := LinearCost.compose (LinearCost.first _ _) (LinearCost.second _ _)
theorem dec_linear : LinearCost decDevice :=
  LinearCost.compose (LinearCost.fanout (LinearCost.identity _) (LinearCost.constant _ _ _)) LinearCost.add
theorem test_linear : LinearCost testDevice :=
  LinearCost.compose (LinearCost.fanout (LinearCost.constant _ _ _) word_linear) LinearCost.compare
theorem newWord_linear : LinearCost newWordDevice := LinearCost.compose word_linear dec_linear
theorem newCount_linear : LinearCost newCountDevice := LinearCost.compose list_linear Prefix.increment_linear
theorem next_linear : LinearCost nextDevice := LinearCost.fanout newWord_linear newCount_linear
theorem step_linear : LinearCost stepDevice :=
  LinearCost.branch test_linear next_linear (LinearCost.first _ _)

theorem step_word_length (s : State) (b : Bool) :
    (step (s,b)).1.digits.length ≤ s.1.digits.length+1 := by
  unfold step
  split
  · change (SignedBits.add s.1.sign true false s.1.digits []).digits.length ≤ _
    rw [SignedBits.add_length]
    simp
  · simp

theorem step_count_length (s : State) (b : Bool) :
    (step (s,b)).2.length ≤ s.2.length+1 := by
  unfold step
  split <;> simp

theorem fold_length (s : State) (xs : List Bool) :
    (Fold.fold step s xs).1.digits.length ≤ s.1.digits.length+xs.length ∧
    (Fold.fold step s xs).2.length ≤ s.2.length+xs.length := by
  induction xs generalizing s with
  | nil => simp [Fold.fold]
  | cons x xs ih =>
    have hh := ih (step (s,x))
    have hw := step_word_length s x
    have hc := step_count_length s x
    change (Fold.fold step (step (s,x)) xs).1.digits.length ≤ _ ∧
      (Fold.fold step (step (s,x)) xs).2.length ≤ _
    simp only [List.length_cons]
    omega

theorem count_size (c : Count) : treeSize (countData c)=2*c.length+1 := by
  induction c with
  | nil => rfl
  | cons u c ih => simp only [countData,listTree,treeSize_pair,Median.unitData,treeSize_nil,List.length_cons] at *; omega

theorem fold_polynomial : PolynomialCost (Fold.device stepDevice) := by
  obtain ⟨K,hK⟩ := step_linear
  refine ⟨402+40*K,2,?_⟩
  rintro ⟨s,xs⟩
  let N := treeSize (product stateData (listTree boolData) (s,xs))+1
  have hN : 1 ≤ N := by dsimp [N]; omega
  have hs₀ : treeSize (wordData s.1)+treeSize (countData s.2)+treeSize (listTree boolData xs)+3 = N := by
    simp only [N,product,stateData,treeSize_pair]; omega
  have hw : s.1.digits.length ≤ N := by have := digits_le_wordSize s.1; omega
  have ha : s.2.length ≤ N := by have := count_size s.2; omega
  have hl : xs.length+1 ≤ N := by have := list_length_le_size boolData xs; omega
  have he : treeSize (listTree boolData xs) ≤ N := by omega
  have hp : ∀ k ≤ xs.length, treeSize (stateData (Fold.fold step s (xs.take k))) ≤ 32*N := by
    intro k hk
    have hw' := wordSize_bound (Fold.fold step s (xs.take k)).1
    have ha' := count_size (Fold.fold step s (xs.take k)).2
    have hd := fold_length s (xs.take k)
    have hx : (xs.take k).length ≤ k := List.length_take_le _ _
    simp only [stateData,product,treeSize_pair]
    omega
  have ht := Fold.time_of_prefix_bound stepDevice K 1 (32*N) N
    (by intro z; simpa only [pow_one,inputData] using hK z) s xs he hp
  have hc : 12*(32*N)+K*(32*N+N+2)^1+11 ≤ (400+40*K)*N := by
    simp only [pow_one]
    nlinarith
  have hbig := Nat.mul_le_mul hl hc
  have htime := ht.trans hbig
  have hpos : 1 ≤ N^2 := one_le_pow₀ hN
  change Fold.time stepDevice s xs+2 ≤ (402+40*K)*N^2
  rw [pow_two] at hpos ⊢
  nlinarith

theorem init_polynomial : PolynomialCost initDevice :=
  (LinearCost.pairMap (LinearCost.nilSuffix _ _) (LinearCost.identity _)).polynomial
theorem finish_polynomial : PolynomialCost finishDevice :=
  PolynomialCost.compose fold_polynomial (LinearCost.second _ _).polynomial
theorem polynomial : PolynomialCost device :=
  PolynomialCost.compose init_polynomial finish_polynomial
end MeanPayoff.TreeDevice.Address
namespace MeanPayoff.TreeDevice.Header
open BinaryData
abbrev W := SignedBits.Word
abbrev Count := Median.Count
abbrev Numbers := W × (W × List Bool)
abbrev Fields := List Bool × Numbers
abbrev Result := Count × (Count × (List Bool × List Bool))
def restData := listTree boolData
def countData := listTree Median.unitData
def numbersData := product wordData (product wordData restData)
def fieldsData := product restData numbersData
def resultData := product countData (product countData (product restData restData))

def numbers (xs : List Bool) : Numbers :=
  let p := IntegerRead.readNat xs
  (p.1,IntegerRead.readNat p.2)
def nCount (p : Fields) := Address.read (p.2.1,p.1)
def mCount (p : Fields) := Address.read (p.2.2.1,p.1)
def partition (p : Fields) := Split.split (p.2.2.2,nCount p)
def finish (p : Fields) : Result := (nCount p,(mCount p,partition p))
def read (xs : List Bool) := finish (xs,numbers xs)

noncomputable def numbersDevice : Device restData numbersData numbers :=
  compose IntegerRead.natDevice (pairMap (identity wordData) IntegerRead.natDevice)
noncomputable def inputDevice : Device fieldsData restData (fun p : Fields => p.1) := first restData numbersData
noncomputable def nWordDevice : Device fieldsData wordData (fun p : Fields => p.2.1) :=
  compose (second restData numbersData) (first wordData (product wordData restData))
noncomputable def moreDevice : Device fieldsData (product wordData restData) (fun p : Fields => p.2.2) :=
  compose (second restData numbersData) (second wordData (product wordData restData))
noncomputable def mWordDevice : Device fieldsData wordData (fun p : Fields => p.2.2.1) :=
  compose moreDevice (first wordData restData)
noncomputable def remainderDevice : Device fieldsData restData (fun p : Fields => p.2.2.2) :=
  compose moreDevice (second wordData restData)
noncomputable def nCountDevice : Device fieldsData countData nCount :=
  compose (fanout nWordDevice inputDevice) Address.device
noncomputable def mCountDevice : Device fieldsData countData mCount :=
  compose (fanout mWordDevice inputDevice) Address.device
noncomputable def partitionDevice : Device fieldsData (product restData restData) partition :=
  compose (fanout remainderDevice nCountDevice) Split.device
noncomputable def finishDevice : Device fieldsData resultData finish :=
  fanout nCountDevice (fanout mCountDevice partitionDevice)
noncomputable def device : Device restData resultData read :=
  compose (fanout (identity restData) numbersDevice) finishDevice

theorem numbers_exact (n m : ℕ) (suffix : List Bool) :
    numbers (encodeNat n++encodeNat m++suffix) =
      (IntegerRead.decrement (n+1).bits,(IntegerRead.decrement (m+1).bits,suffix)) := by
  simp [numbers,List.append_assoc,IntegerRead.nat_encode]

theorem word_val (n : ℕ) : (IntegerRead.decrement (n+1).bits).val = n := by
  rw [IntegerRead.decrement_val,BinaryStack.Addition.value_bits]
  simp

theorem exact (n m : ℕ) (owners suffix : List Bool) (ho : owners.length=n)
    (hm : m ≤ (encodeNat n++encodeNat m++owners++suffix).length) :
    read (encodeNat n++encodeNat m++owners++suffix) =
      (List.replicate n (),(List.replicate m (),(owners,suffix))) := by
  let xs := encodeNat n++encodeNat m++owners++suffix
  have hn : n≤xs.length := by simp only [xs,List.length_append]; omega
  have hn' := Address.exact n (IntegerRead.decrement (n+1).bits) (word_val n) xs hn
  have hm' := Address.exact m (IntegerRead.decrement (m+1).bits) (word_val m) xs hm
  have hnum : numbers xs = (IntegerRead.decrement (n+1).bits,(IntegerRead.decrement (m+1).bits,owners++suffix)) := by
    simpa only [xs,List.append_assoc] using numbers_exact n m (owners++suffix)
  change finish (xs,numbers xs)=_
  rw [hnum]
  change (Address.read (IntegerRead.decrement (n+1).bits,xs),
    Address.read (IntegerRead.decrement (m+1).bits,xs),
    Split.split (owners++suffix,Address.read (IntegerRead.decrement (n+1).bits,xs))) = _
  rw [hn',hm',Split.exact _ _ (by simp; omega)]
  simp [← ho]

theorem input_linear : LinearCost inputDevice := LinearCost.first _ _
theorem nWord_linear : LinearCost nWordDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _)
theorem more_linear : LinearCost moreDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.second _ _)
theorem mWord_linear : LinearCost mWordDevice := LinearCost.compose more_linear (LinearCost.first _ _)
theorem remainder_linear : LinearCost remainderDevice := LinearCost.compose more_linear (LinearCost.second _ _)
theorem nCount_polynomial : PolynomialCost nCountDevice :=
  PolynomialCost.compose (LinearCost.fanout nWord_linear input_linear).polynomial Address.polynomial
theorem mCount_polynomial : PolynomialCost mCountDevice :=
  PolynomialCost.compose (LinearCost.fanout mWord_linear input_linear).polynomial Address.polynomial
theorem partition_polynomial : PolynomialCost partitionDevice :=
  PolynomialCost.compose (PolynomialCost.fanout remainder_linear.polynomial nCount_polynomial) Split.polynomial
theorem finish_polynomial : PolynomialCost finishDevice :=
  PolynomialCost.fanout nCount_polynomial (PolynomialCost.fanout mCount_polynomial partition_polynomial)
theorem numbers_polynomial : PolynomialCost numbersDevice :=
  PolynomialCost.compose IntegerRead.nat_polynomial
    (PolynomialCost.pairMap (LinearCost.identity _).polynomial IntegerRead.nat_polynomial)
theorem polynomial : PolynomialCost device :=
  PolynomialCost.compose (PolynomialCost.fanout (LinearCost.identity _).polynomial numbers_polynomial) finish_polynomial

end MeanPayoff.TreeDevice.Header
namespace MeanPayoff.TreeDevice.EdgeRead
open BinaryData
abbrev W := SignedBits.Word
abbrev Count := Median.Count
abbrev Edge := Count × (Count × W)
abbrev Words := W × (W × (W × List Bool))
abbrev Fields := List Bool × Words
def restData := listTree boolData
def countData := listTree Median.unitData
def edgeData := product countData (product countData wordData)
def wordsData := product wordData (product wordData (product wordData restData))
def fieldsData := product restData wordsData

def words (xs : List Bool) : Words :=
  let p := IntegerRead.readNat xs
  let q := IntegerRead.readNat p.2
  (p.1,(q.1,IntegerRead.readInt q.2))
def source (p : Fields) := Address.read (Address.dec p.2.1,p.1)
def target (p : Fields) := Address.read (Address.dec p.2.2.1,p.1)
def edge (p : Fields) : Edge := (source p,(target p,p.2.2.2.1))
def finish (p : Fields) : Edge × List Bool := (edge p,p.2.2.2.2)
def read (z : List Bool × List Bool) := finish (z.1,words z.2)

noncomputable def wordsDevice : Device restData wordsData words :=
  compose IntegerRead.natDevice
    (pairMap (identity wordData) (compose IntegerRead.natDevice (pairMap (identity wordData) IntegerRead.intDevice)))
noncomputable def inputDevice : Device fieldsData restData (fun p : Fields => p.1) := first restData wordsData
noncomputable def sourceWordDevice : Device fieldsData wordData (fun p : Fields => p.2.1) :=
  compose (second restData wordsData) (first wordData (product wordData (product wordData restData)))
noncomputable def moreDevice : Device fieldsData (product wordData (product wordData restData)) (fun p : Fields => p.2.2) :=
  compose (second restData wordsData) (second wordData (product wordData (product wordData restData)))
noncomputable def targetWordDevice : Device fieldsData wordData (fun p : Fields => p.2.2.1) :=
  compose moreDevice (first wordData (product wordData restData))
noncomputable def lastDevice : Device fieldsData (product wordData restData) (fun p : Fields => p.2.2.2) :=
  compose moreDevice (second wordData (product wordData restData))
noncomputable def weightDevice : Device fieldsData wordData (fun p : Fields => p.2.2.2.1) :=
  compose lastDevice (first wordData restData)
noncomputable def remainderDevice : Device fieldsData restData (fun p : Fields => p.2.2.2.2) :=
  compose lastDevice (second wordData restData)
noncomputable def sourceDecDevice : Device fieldsData wordData (fun p : Fields => Address.dec p.2.1) :=
  @compose _ _ _ fieldsData wordData wordData (fun p : Fields => p.2.1) Address.dec sourceWordDevice Address.decDevice
noncomputable def targetDecDevice : Device fieldsData wordData (fun p : Fields => Address.dec p.2.2.1) :=
  @compose _ _ _ fieldsData wordData wordData (fun p : Fields => p.2.2.1) Address.dec targetWordDevice Address.decDevice
noncomputable def sourceDevice : Device fieldsData countData source :=
  compose (fanout sourceDecDevice inputDevice) Address.device
noncomputable def targetDevice : Device fieldsData countData target :=
  compose (fanout targetDecDevice inputDevice) Address.device
noncomputable def edgeDevice : Device fieldsData edgeData edge :=
  fanout sourceDevice (fanout targetDevice weightDevice)
noncomputable def finishDevice : Device fieldsData (product edgeData restData) finish :=
  fanout edgeDevice remainderDevice
noncomputable def device : Device (product restData restData) (product edgeData restData) read :=
  compose (pairMap (identity restData) wordsDevice) finishDevice

def encodedWord (z : ℤ) : W :=
  let w := IntegerRead.decrement (z.natAbs+1).bits
  if z<0 then Negate.negate w else w

theorem encodedWord_val (z : ℤ) : (encodedWord z).val = z := by
  unfold encodedWord
  split
  · rename_i hz
    rw [Negate.exact,IntegerRead.decrement_val,BinaryStack.Addition.value_bits]
    simp [abs_of_neg hz]
  · rename_i hz
    rw [IntegerRead.decrement_val,BinaryStack.Addition.value_bits]
    simp [abs_of_nonneg (by omega : 0≤z)]

theorem words_exact (a b : ℕ) (w : ℤ) (suffix : List Bool) :
    words (BinaryInput.encodeEdge (a,b,w)++suffix) =
      (IntegerRead.decrement (a+2).bits,(IntegerRead.decrement (b+2).bits,(encodedWord w,suffix))) := by
  simp [words,BinaryInput.encodeEdge,List.append_assoc,IntegerRead.nat_encode,
    IntegerRead.readInt,encodeInt,IntegerRead.signed,encodedWord,Nat.add_assoc]

theorem exact (a b : ℕ) (w : ℤ) (bound suffix : List Bool) (ha : a≤bound.length) (hb : b≤bound.length) :
    read (bound,BinaryInput.encodeEdge (a,b,w)++suffix) =
      ((List.replicate a (),(List.replicate b (),encodedWord w)),suffix) := by
  have ha' : (Address.dec (IntegerRead.decrement (a+2).bits)).val=a := by
    rw [Address.dec_val,IntegerRead.decrement_val,BinaryStack.Addition.value_bits]; push_cast; omega
  have hb' : (Address.dec (IntegerRead.decrement (b+2).bits)).val=b := by
    rw [Address.dec_val,IntegerRead.decrement_val,BinaryStack.Addition.value_bits]; push_cast; omega
  simp only [read,words_exact,finish,edge,source,target]
  rw [Address.exact a _ ha' _ ha,Address.exact b _ hb' _ hb]

theorem words_polynomial : PolynomialCost wordsDevice :=
  PolynomialCost.compose IntegerRead.nat_polynomial
    (PolynomialCost.pairMap (LinearCost.identity _).polynomial
      (PolynomialCost.compose IntegerRead.nat_polynomial (PolynomialCost.pairMap (LinearCost.identity _).polynomial IntegerRead.int_polynomial)))
theorem input_linear : LinearCost inputDevice := LinearCost.first _ _
theorem sourceWord_linear : LinearCost sourceWordDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.first _ _)
theorem more_linear : LinearCost moreDevice := LinearCost.compose (LinearCost.second _ _) (LinearCost.second _ _)
theorem targetWord_linear : LinearCost targetWordDevice := LinearCost.compose more_linear (LinearCost.first _ _)
theorem last_linear : LinearCost lastDevice := LinearCost.compose more_linear (LinearCost.second _ _)
theorem weight_linear : LinearCost weightDevice := LinearCost.compose last_linear (LinearCost.first _ _)
theorem remainder_linear : LinearCost remainderDevice := LinearCost.compose last_linear (LinearCost.second _ _)
theorem sourceDec_linear : LinearCost sourceDecDevice := LinearCost.compose sourceWord_linear Address.dec_linear
theorem targetDec_linear : LinearCost targetDecDevice := LinearCost.compose targetWord_linear Address.dec_linear
theorem source_polynomial : PolynomialCost sourceDevice :=
  PolynomialCost.compose (LinearCost.fanout sourceDec_linear input_linear).polynomial Address.polynomial
theorem target_polynomial : PolynomialCost targetDevice :=
  PolynomialCost.compose (LinearCost.fanout targetDec_linear input_linear).polynomial Address.polynomial
theorem edge_polynomial : PolynomialCost edgeDevice :=
  PolynomialCost.fanout source_polynomial (PolynomialCost.fanout target_polynomial weight_linear.polynomial)
theorem finish_polynomial : PolynomialCost finishDevice :=
  PolynomialCost.fanout edge_polynomial remainder_linear.polynomial
theorem polynomial : PolynomialCost device :=
  PolynomialCost.compose (PolynomialCost.pairMap (LinearCost.identity _).polynomial words_polynomial) finish_polynomial
end MeanPayoff.TreeDevice.EdgeRead
end

end OAI