| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.TreeDPCounts |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.ExecutableDP |
| open TreeTyped |
|
|
| abbrev Params := ℕ×(ℕ×Parents) |
| abbrev State := ℕ×(Bags×Table) |
|
|
| def update (x : ((Bags×Parents)×(ℕ×Table))×(ℕ×ℕ)) : Table := |
| tabulate entry (context x.1,x.2) |
| def updateProgram : Realizer update := |
| composition (pair (composition first contextRealizer) second) updateRealizer |
|
|
| def step (x : ℕ×(Params×State)) : Params×State := |
| let p:=x.2.1 |
| let st:=x.2.2 |
| let l:=x.1 |
| let rem:=st.1-1 |
| (p,(rem,(trim st.2.1 l, |
| update (((st.2.1,p.2.2),(l,st.2.2)),(p.2.1,p.1*rem))))) |
|
|
| def stepRealizer : Realizer step := by |
| let p : Realizer (fun x : ℕ×(Params×State)=>x.2.1) := second.fst |
| let st : Realizer (fun x : ℕ×(Params×State)=>x.2.2) := second.snd |
| let l : Realizer (fun x : ℕ×(Params×State)=>x.1) := first |
| let rem := composition st.fst predecessor |
| let bs := composition (pair st.snd.fst l) trimRealizer |
| let B := composition (pair p.fst rem) multiply |
| let inp := pair (pair (pair st.snd.fst p.snd.snd) (pair l st.snd.snd)) (pair p.snd.fst B) |
| let tbl := composition inp updateProgram |
| exact (pair p (pair rem (pair bs tbl))).congr (fun _=>rfl) |
|
|
| def runState (p : Params) : List ℕ → Bags → Table → Bags×Table |
| | [],bs,t => (bs,t) |
| | l::ls,bs,t => runState p ls (trim bs l) |
| (update (((bs,p.2.2),(l,t)),(p.2.1,p.1*ls.length))) |
|
|
| def run (x : Params×(List ℕ×(Bags×Table))) : Table := (runState x.1 x.2.1 x.2.2.1 x.2.2.2).2 |
|
|
| lemma step_fold (p : Params) (ls : List ℕ) (bs : Bags) (t : Table) : |
| ls.foldl (fun z l=>step (l,z)) (p,(ls.length,(bs,t)))= |
| (p,(0,runState p ls bs t)) := by |
| induction ls generalizing bs t with |
| | nil => rfl |
| | cons l ls ih => |
| simp only [List.foldl_cons,List.length_cons,step,Nat.add_sub_cancel] |
| exact ih _ _ |
|
|
| def runRealizer : Realizer run := by |
| let init : Realizer (fun x : Params×(List ℕ×(Bags×Table))=> |
| (x.2.1,(x.1,(x.2.1.length,x.2.2)))) := |
| pair second.fst (pair first (pair (composition second.fst listLength) second.snd)) |
| exact (composition (composition init (fold stepRealizer)) second.snd.snd).congr (by |
| intro x |
| change ((x.2.1.foldl (fun z l=>step (l,z)) (x.1,(x.2.1.length,x.2.2))).2.2).2=_ |
| rw [step_fold] |
| rfl) |
|
|
| lemma tabulate_materialized {X : Type} (f : X×(ℕ×ℕ) → ℕ) (x : X) (m B : ℕ) : |
| tabulate f (x,(m,B))=UnitRefresh.Materialized.tabulate m B (fun a r=>f (x,(a.val,r))) := |
| tabulate_eq (fun ar=>f (x,ar)) |
|
|
| lemma update_eq {V : Type} [Fintype V] [DecidableEq V] {m : ℕ} |
| (bags : V → Finset (Fin m)) (R : Finset V) (parent : Fin m → Option (Fin m)) |
| (l : Fin m) (t : Table) (B : ℕ) (ps : Parents) |
| (hps : ps.getD l.val (false,0)=match parent l with | none=>(false,0) | some p=>(true,p.val)) : |
| update (((activeRep bags R,ps),(l.val,t)),(m,B))= |
| UnitRefresh.Materialized.update bags R parent l B t := by |
| unfold update context |
| simp only [hps,privateNumber_activeRep,sharedNumber_activeRep,totalNumber_activeRep] |
| rw [tabulate_materialized] |
| unfold UnitRefresh.Materialized.update |
| congr 1 |
| funext a r |
| exact entry_eq bags R parent l a t r |
|
|
| lemma privateNumber_perm {a b : Bags} (h : a.Perm b) (l : ℕ) : privateNumber a l=privateNumber b l := |
| (h.filter _).length_eq |
| lemma sharedNumber_perm {a b : Bags} (h : a.Perm b) (l : ℕ) : sharedNumber a l=sharedNumber b l := |
| (h.filter _).length_eq |
| lemma totalNumber_perm {a b : Bags} (h : a.Perm b) (l : ℕ) : totalNumber a l=totalNumber b l := |
| (h.filter _).length_eq |
| lemma context_perm {a b : Bags} (h : a.Perm b) (ps : Parents) (l : ℕ) (t : Table) : |
| context ((a,ps),(l,t))=context ((b,ps),(l,t)) := by |
| simp only [context,privateNumber_perm h,sharedNumber_perm h,totalNumber_perm h] |
| lemma update_perm {a b : Bags} (h : a.Perm b) (ps : Parents) (l m B : ℕ) (t : Table) : |
| update (((a,ps),(l,t)),(m,B))=update (((b,ps),(l,t)),(m,B)) := by |
| simp only [update,context_perm h] |
|
|
| def parentTag {m : ℕ} : Option (Fin m) → Bool×ℕ |
| | none => (false,0) |
| | some p => (true,p.val) |
| def parentRep {m : ℕ} (p : Fin m → Option (Fin m)) : Parents := List.ofFn (parentTag ∘ p) |
| @[simp] lemma parentRep_length {m : ℕ} (p : Fin m → Option (Fin m)) : (parentRep p).length=m := by |
| simp [parentRep] |
| @[simp] lemma parentRep_getD {m : ℕ} (p : Fin m → Option (Fin m)) (l : Fin m) : |
| (parentRep p).getD l.val (false,0)=parentTag (p l) := by |
| simp [parentRep,List.getD,l.isLt] |
|
|
| lemma run_eq {V : Type} [Fintype V] [DecidableEq V] {m : ℕ} |
| (bags : V → Finset (Fin m)) (parent : Fin m → Option (Fin m)) |
| (ls : List (Fin m)) (R : Finset V) (t : Table) (bs : Bags) |
| (hbs : bs.Perm (activeRep bags R)) : |
| (runState (Fintype.card V,(m,parentRep parent)) (ls.map Fin.val) bs t).2= |
| UnitRefresh.Materialized.run bags parent ls R t := by |
| induction ls generalizing R bs t with |
| | nil => rfl |
| | cons l ls ih => |
| simp only [List.map_cons,runState,UnitRefresh.Materialized.run,List.length_map] |
| rw [update_perm hbs] |
| rw [update_eq bags R parent l t _ _ (parentRep_getD parent l)] |
| apply ih |
| exact ((hbs.filter _).trans (trim_activeRep bags R l)) |
|
|
| end MatchingFPRAS.ExecutableDP |
|
|
| end OAI |
|
|
