import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.TreeDPCounts
import OAI.Combinatorics.MatchingCount.Arithmetic.TreeFraction
import OAI.Combinatorics.MatchingCount.Machines.TreeListMore

namespace OAI

namespace MatchingFPRAS.TreeFraction
open TreeTyped

def sum (xs : List Fraction) : Fraction := xs.foldl (fun a b=>add (b,a)) (0,1)
def sumRealizer : Realizer sum :=
  (composition (pair (identity (A:=List Fraction)) (constant (0,1))) (fold addRealizer)).congr (fun _=>rfl)

lemma fold_den (xs : List Fraction) (a : Fraction) (ha : 0<a.2) :
    0<(xs.foldl (fun a b=>add (b,a)) a).2 := by
  induction xs generalizing a with
  | nil => exact ha
  | cons _ _ ih => exact ih _ (normalize_den_pos _)
lemma fold_val (xs : List Fraction) (a : Fraction) (ha : 0<a.2)
    (hx : ∀ b∈xs,0<b.2) :
    val (xs.foldl (fun a b=>add (b,a)) a)=val a+(xs.map val).sum := by
  induction xs generalizing a with
  | nil => simp
  | cons b bs ih =>
    have hab : 0<(add (b,a)).2 := normalize_den_pos _
    rw [List.foldl_cons,ih _ hab (fun c hc=>hx c (by simp [hc])),
      add_val b a (Nat.ne_of_gt (hx b (by simp))) (Nat.ne_of_gt ha)]
    simp only [List.map_cons,List.sum_cons]
    ring
lemma sum_den (xs : List Fraction) : 0<(sum xs).2 := fold_den xs (0,1) (by decide)
lemma sum_val (xs : List Fraction) (hx : ∀ b∈xs,0<b.2) :
    val (sum xs)=(xs.map val).sum := by
  rw [sum,fold_val xs (0,1) (by decide) hx]
  simp [val]

def cumulativeFraction (x : List Fraction×ℕ) : Fraction := sum (x.1.take x.2)
def cumulativeFractionRealizer : Realizer cumulativeFraction := (composition (take (0,1)) sumRealizer).congr (fun _=>rfl)
lemma cumulativeFraction_val {r : ℕ} (p : Fin r → ℚ) (hp : ∀ i,0≤p i) (n : ℕ) :
    val (cumulativeFraction (List.ofFn (fun i=>repr (p i)),n))=FiniteChoice.cumulative p n := by
  rw [cumulativeFraction,sum_val]
  · simp only [List.map_take,List.map_ofFn,Function.comp_apply,val_repr (hp _),List.sum_take_ofFn,
      FiniteChoice.cumulative,Finset.sum_filter]
  · intro b hb
    obtain ⟨i,hi⟩ := List.mem_ofFn.mp (List.mem_of_mem_take hb)
    subst b
    exact (p i).pos

end MatchingFPRAS.TreeFraction

namespace MatchingFPRAS.TreeTyped

def bitValue : Realizer StackAddition.value :=
  (composition (composition (pair (reverse (A:=Bool)) (constant (1,0)))
    (fold mulStepRealizer)) second).congr (by
      intro bs
      change (bs.reverse.foldl (fun z b=>mulStep (b,z)) (1,0)).2=_
      rw [mulStep_fold]
      simp)

def bitDenominator (bs : List Bool) : ℕ := bs.foldl (fun a _=>2*a) 1
lemma bitDenominator_eq (bs : List Bool) : bitDenominator bs=2^bs.length := by
  have h : ∀ a,bs.foldl (fun a _=>2*a) a=a*2^bs.length := by
    induction bs with
    | nil => intro a; simp
    | cons _ _ ih => intro a; simp only [List.foldl_cons,ih,List.length_cons,pow_succ]; ring
  simpa [bitDenominator] using h 1

def bitDenominatorRealizer : Realizer bitDenominator :=
  (composition (pair (identity (A:=List Bool)) (constant 1))
    (fold (composition second double))).congr (fun _=>rfl)
end MatchingFPRAS.TreeTyped

namespace MatchingFPRAS.ExecutableChoice
open TreeTyped TreeFraction

def predicate (x : (List Fraction×Fraction)×ℕ) : Bool :=
  TreeFraction.less (x.1.2,cumulativeFraction (x.1.1,x.2+1))
def predicateRealizer : Realizer predicate := by
  let C : Realizer (fun x : (List Fraction×Fraction)×ℕ=>cumulativeFraction (x.1.1,x.2+1)) :=
    (composition (pair first.fst (composition second successor)) cumulativeFractionRealizer).congr (fun _=>rfl)
  exact (composition (pair first.snd C) lessRealizer).congr (fun _=>rfl)

def choose (x : List Fraction×Fraction) : ℕ :=
  listMin ((List.range x.1.length).filter (fun i=>predicate (x,i)),x.1.length)

def chooseRealizer : Realizer choose := by
  let rs : Realizer (fun x : List Fraction×Fraction=>List.range x.1.length) :=
    composition (composition first listLength) range
  let good := composition (pair identity rs) (filterWith predicateRealizer)
  exact (composition (pair good (composition first listLength)) listMinRealizer).congr (fun _=>rfl)

lemma choose_eq {r K : ℕ} (p : Fin r → ℚ) (hp : ∀ i,0≤p i)
    (hs : ∑ i,p i=1) (hK : 0<K) (J : Fin K) :
    choose (List.ofFn (fun i=>repr (p i)),(J.val,K))=(FiniteChoice.choose p hs hK J).val := by
  let j := FiniteChoice.choose p hs hK J
  have hpred (i : ℕ) : predicate ((List.ofFn (fun i=>repr (p i)),(J.val,K)),i)=
      decide ((J.val:ℚ)/K<FiniteChoice.cumulative p (i+1)) := by
    rw [predicate,less_val (J.val,K) (cumulativeFraction (List.ofFn (fun i=>repr (p i)),i+1)) hK (sum_den _),cumulativeFraction_val p hp]
    rfl
  unfold choose
  simp only [List.length_ofFn]
  apply le_antisymm
  · apply listMin_le
    simp only [List.mem_filter,List.mem_range,hpred,decide_eq_true_eq]
    exact ⟨j.isLt,FiniteChoice.choose_upper p hs hK J⟩
  · apply le_listMin j.isLt.le
    intro i hi
    simp only [List.mem_filter,List.mem_range,hpred,decide_eq_true_eq] at hi
    exact FiniteChoice.choose_le p hs hK J ⟨i,hi.1⟩ hi.2

def chooseBits (x : List Fraction×List Bool) : ℕ :=
  choose (x.1,(StackAddition.value x.2,bitDenominator x.2))
def chooseBitsRealizer : Realizer chooseBits :=
  composition (pair first (pair (composition second bitValue) (composition second bitDenominatorRealizer)))
    chooseRealizer

lemma chooseBits_eq {r k : ℕ} (p : Fin r → ℚ) (hp : ∀ i,0≤p i)
    (hs : ∑ i,p i=1) (bits : Fin k → Bool) :
    chooseBits (List.ofFn (fun i=>repr (p i)),List.ofFn bits)=
      (FiniteChoice.chooseBits p hs k bits).val := by
  have hv' (k : ℕ) (bits : Fin k → Bool) :
      StackAddition.value (List.ofFn bits)=∑ i, (if bits i then 1 else 0)*2^i.val := by
    induction k with
    | zero => simp [StackAddition.value]
    | succ k ih =>
      rw [List.ofFn_succ,StackAddition.value,ih,Fin.sum_univ_succ]
      simp only [Fin.val_zero,pow_zero,Nat.mul_one,Fin.val_succ,pow_succ]
      rw [Finset.mul_sum]
      have hn : (bits 0).toNat=(if bits 0 then 1 else 0) := by cases bits 0 <;> rfl
      rw [hn]
      congr 1
      apply Finset.sum_congr rfl
      intro i _
      ring
  have hv : StackAddition.value (List.ofFn bits)=(FiniteChoice.tapeIndex k bits).val := by
    rw [FiniteChoice.tapeIndex_value,hv']
  rw [chooseBits,bitDenominator_eq,List.length_ofFn,hv]
  exact choose_eq p hp hs (by positivity) (FiniteChoice.tapeIndex k bits)
end MatchingFPRAS.ExecutableChoice

end OAI