import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.TreeDPProgram

namespace OAI

namespace MatchingFPRAS.ExecutableDP
open TreeTyped

def initial (x : ℕ×ℕ) : Table :=
  tabulate (fun ar : ℕ×(ℕ×ℕ)=>UnitRefresh.pairingCount ar.2.2) (0,x)

def initialRealizer : Realizer initial :=
  composition (pair (constant 0) identity)
    (tabulateRealizer (composition second.snd pairingNumber))

lemma initial_eq (m B : ℕ) : initial (m,B)=UnitRefresh.Materialized.initial m B := by
  exact tabulate_materialized (fun x : ℕ×(ℕ×ℕ)=>UnitRefresh.pairingCount x.2.2) 0 m B

def finish (x : Table×ℕ) : ℕ := ((List.range x.2).map fun a=>read (x.1,(a,0))).prod

def finishRealizer : Realizer finish :=
  composition (composition (pair first (composition second range))
    (mapWith (composition (pair first (pair second (constant 0))) readRealizer))) listProd

lemma map_range_ofFn {A : Type} (f : ℕ → A) (n : ℕ) :
    (List.range n).map f=List.ofFn (fun i : Fin n=>f i.val) := by
  apply List.ext_getElem
  · simp
  · intro i hi hi'; simp only [List.getElem_map,List.getElem_range,List.getElem_ofFn]

lemma finish_eq (t : Table) (m : ℕ) :
    finish (t,m)=∏ a : Fin m,UnitRefresh.Materialized.read t a.val 0 := by
  rw [finish,map_range_ofFn,List.prod_ofFn]
  rfl

abbrev CountInput := (Bags×Parents)×List ℕ

def count (x : CountInput) : ℕ :=
  let n:=x.1.1.length
  let m:=x.1.2.length
  finish (run ((n,(m,x.1.2)),(x.2,(x.1.1,initial (m,n*m)))),m)

def countRealizer : Realizer count := by
  let bs : Realizer (fun x : CountInput=>x.1.1) := first.fst
  let ps : Realizer (fun x : CountInput=>x.1.2) := first.snd
  let ls : Realizer (fun x : CountInput=>x.2) := second
  let n := composition bs listLength
  let m := composition ps listLength
  let B := composition (pair n m) multiply
  let t := composition (pair m B) initialRealizer
  let p := pair n (pair m ps)
  let table := composition (pair p (pair ls (pair bs t))) runRealizer
  exact (composition (pair table m) finishRealizer).congr (fun _=>rfl)

lemma count_eq {V : Type} [Fintype V] [DecidableEq V] {m : ℕ}
    (bags : V → Finset (Fin m)) (parent : Fin m → Option (Fin m)) (ls : List (Fin m)) :
    count ((activeRep bags Finset.univ,parentRep parent),ls.map Fin.val)=
      UnitRefresh.Materialized.count bags parent ls := by
  unfold count
  rw [show (activeRep bags Finset.univ).length=Fintype.card V by simp [activeRep]]
  rw [parentRep_length]
  dsimp only
  rw [initial_eq]
  unfold run
  rw [run_eq bags parent ls Finset.univ _ _ (List.Perm.refl _),finish_eq]
  rfl

theorem count_coloredPairings {V : Type} [Fintype V] [DecidableEq V] {m : ℕ}
    (bags : V → Finset (Fin m)) (rank : Fin m → ℕ) (parent : Fin m → Option (Fin m))
    (hb : UnitRefresh.RankedBags bags rank parent) (hne : ∀ x,(bags x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) :
    count ((activeRep bags Finset.univ,parentRep parent),(UnitRefresh.rankOrder rank).map Fin.val)=
      Fintype.card (UnitRefresh.ColoredPairing bags) := by
  rw [count_eq]
  exact UnitRefresh.Materialized.count_eq bags rank parent hb hne hp

end MatchingFPRAS.ExecutableDP

end OAI