import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.OnlineScheduleNat
import OAI.Combinatorics.MatchingCount.Tapes.Codec

namespace OAI

namespace MatchingFPRAS.LiteralParse
open TreeTyped TreeData TreeFunction Polynomial LiteralCodec

def numStep (x : Symbol×List ℕ) : List ℕ :=
  if x.1=3 then 0::x.2
  else if x.1=1 then (2*x.2.headD 0)::x.2.tail
  else if x.1=2 then (2*x.2.headD 0+1)::x.2.tail
  else x.2

def eqSymbol (a : Symbol) : Realizer (fun b : Symbol=>decide (b=a)) :=
  (composition (pair valRealizer (constant a.val)) natEqual).congr
    (fun b=>by simp only [Function.comp_apply,Fin.ext_iff])
lemma polynomial_eqSymbol (a : Symbol) : PolynomialTime (eqSymbol a) := by
  unfold eqSymbol; apply polynomial_congr
  exact polynomial_composition (polynomial_pair polynomial_val (polynomial_constant _)) polynomial_natEqual

def numStepRealizer : Realizer numStep :=
  (choose (composition first (eqSymbol 3))
    (composition (pair (constant 0) second) listCons)
    (choose (composition first (eqSymbol 1))
      (composition (pair ((constant 2).mulNat (composition second (head 0))) (composition second tail)) listCons)
      (choose (composition first (eqSymbol 2))
        (composition (pair (((constant 2).mulNat (composition second (head 0))).addNat (constant 1)) (composition second tail)) listCons)
        second))).congr (fun x=>by simp only [Function.comp_apply,decide_eq_true_eq,numStep])
lemma polynomial_numStep : PolynomialTime numStepRealizer := by
  unfold numStepRealizer
  apply polynomial_congr
  have := polynomial_eqSymbol 3
  have := polynomial_eqSymbol 2
  have := polynomial_eqSymbol 1
  have := polynomial_head (0:ℕ)
  have := polynomial_tail (A:=ℕ)
  simp only [Realizer.mulNat, Realizer.addNat]
  tree_cost

lemma weight_double (n : ℕ) : weight (2*n)≤weight n+2 := by
  by_cases hn:n=0
  · subst n; simp only [Nat.mul_zero]; omega
  rw [weight_nat,Nat.bit0_bits n hn]
  rw [weight_cons]
  change 1+1+weight n≤_
  omega
lemma weight_double_one (n : ℕ) : weight (2*n+1)≤weight n+4 := by
  rw [weight_nat,Nat.bit1_bits,weight_cons]
  change 1+3+weight n≤_
  omega

lemma numStep_weight (a : Symbol) (ns : List ℕ) : weight (numStep (a,ns))≤weight ns+6 := by
  unfold numStep
  dsimp only
  split_ifs
  · rw [weight_cons]; change 1+1+weight ns≤_; omega
  · cases ns with
    | nil => change 3≤1+6; omega
    | cons n ns =>
      simp only [List.headD_cons,List.tail_cons,weight_cons]
      have h:=weight_double n
      omega
  · cases ns with
    | nil => change 7≤7; omega
    | cons n ns =>
      simp only [List.headD_cons,List.tail_cons,weight_cons]
      have h:=weight_double_one n
      omega
  · omega

lemma fold_weight (as : List Symbol) (ns : List ℕ) :
    weight (as.foldl (fun ns a=>numStep (a,ns)) ns)≤weight ns+6*as.length := by
  induction as generalizing ns with
  | nil => simp
  | cons a as ih =>
    have h:=ih (numStep (a,ns))
    have h':=numStep_weight a ns
    simp only [List.foldl_cons,List.length_cons]
    omega
lemma polynomial_numFold : PolynomialTime (fold numStepRealizer) := by
  apply polynomial_fold polynomial_numStep (7*X)
  intro as ns pre post he
  have h:=fold_weight pre ns
  have hlen : pre.length≤as.length := by rw [he,List.length_append]; omega
  have hlen':=list_length_le_weight as
  simp only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
  omega

def parse (as : List Symbol) : List ℕ := as.foldr (fun a ns=>numStep (a,ns)) []
def parseRealizer : Realizer parse :=
  (composition (pair reverse (constant [])) (fold numStepRealizer)).congr (fun as=>by
    simp only [Function.comp_apply,List.foldl_reverse,parse])
lemma polynomial_parse : PolynomialTime parseRealizer := by
  unfold parseRealizer
  apply polynomial_congr
  exact polynomial_composition (polynomial_pair polynomial_reverse (polynomial_constant _)) polynomial_numFold

lemma bits_fold (n : ℕ) (ns : List ℕ) :
    (n.bits.map fromBit).foldr (fun a ns=>numStep (a,ns)) (0::ns)=n::ns := by
  induction n using Nat.binaryRec' with
  | zero => rfl
  | bit b n hn ih =>
    rw [Nat.bits_append_bit n b hn,List.map_cons,List.foldr_cons,ih]
    cases b <;> simp [fromBit,numStep,Nat.bit]
lemma encodeNat_fold (n : ℕ) (ns : List ℕ) :
    (encodeNat n).foldr (fun a ns=>numStep (a,ns)) ns=n::ns := by
  change (n.bits.map fromBit++[3]).foldr _ ns=_
  rw [List.foldr_append]
  change (n.bits.map fromBit).foldr (fun a ns=>numStep (a,ns)) (0::ns)=_
  exact bits_fold n ns
lemma encodeInt_fold (z : ℤ) (ns : List ℕ) :
    (encodeInt z).foldr (fun a ns=>numStep (a,ns)) ns=z.natAbs::ns := by
  unfold encodeInt
  rw [List.foldr_append,encodeNat_fold]
  split_ifs <;> simp [numStep]
lemma encodeRat_fold (q : ℚ) (ns : List ℕ) :
    (encodeRat q).foldr (fun a ns=>numStep (a,ns)) ns=q.num.natAbs::q.den::ns := by
  rw [encodeRat,List.foldr_append,encodeNat_fold,encodeInt_fold]
end MatchingFPRAS.LiteralParse

end OAI