| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.TreeDPCount |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.ExecutableDP |
|
|
| lemma privateFlag_perm {b c : Bag} (h : b.Perm c) (l : ℕ) : |
| privateFlag (l,b)=privateFlag (l,c) := by simp only [privateFlag,h.length_eq,h.mem_iff] |
| lemma sharedFlag_perm {b c : Bag} (h : b.Perm c) (l : ℕ) : |
| sharedFlag (l,b)=sharedFlag (l,c) := by simp only [sharedFlag,privateFlag_perm h,h.mem_iff] |
| lemma totalFlag_perm {b c : Bag} (h : b.Perm c) (l : ℕ) : |
| totalFlag (l,b)=totalFlag (l,c) := by simp only [totalFlag,h.mem_iff] |
|
|
| lemma forall₂_filter {A B : Type} {R : A → B → Prop} {as : List A} {bs : List B} |
| (h : List.Forall₂ R as bs) (p : A → Bool) (q : B → Bool) |
| (he : ∀ a b,R a b → p a=q b) : List.Forall₂ R (as.filter p) (bs.filter q) := by |
| induction h with |
| | nil => exact .nil |
| | @cons a b as bs hab hs ih => |
| simp only [List.filter_cons,he a b hab] |
| cases q b <;> simp only [Bool.false_eq_true,↓reduceIte] |
| · exact ih |
| · exact .cons hab ih |
|
|
| lemma privateNumber_rows {a b : Bags} (h : List.Forall₂ List.Perm a b) (l : ℕ) : |
| privateNumber a l=privateNumber b l := |
| (forall₂_filter h _ _ (fun _ _ hh=>privateFlag_perm hh l)).length_eq |
| lemma sharedNumber_rows {a b : Bags} (h : List.Forall₂ List.Perm a b) (l : ℕ) : |
| sharedNumber a l=sharedNumber b l := |
| (forall₂_filter h _ _ (fun _ _ hh=>sharedFlag_perm hh l)).length_eq |
| lemma totalNumber_rows {a b : Bags} (h : List.Forall₂ List.Perm a b) (l : ℕ) : |
| totalNumber a l=totalNumber b l := |
| (forall₂_filter h _ _ (fun _ _ hh=>totalFlag_perm hh l)).length_eq |
| lemma trim_rows {a b : Bags} (h : List.Forall₂ List.Perm a b) (l : ℕ) : |
| List.Forall₂ List.Perm (trim a l) (trim b l) := |
| forall₂_filter h _ _ (fun _ _ hh=>congrArg Bool.not (totalFlag_perm hh l)) |
| lemma update_rows {a b : Bags} (h : List.Forall₂ List.Perm a 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,privateNumber_rows h,sharedNumber_rows h,totalNumber_rows h] |
| lemma run_rows {a b : Bags} (h : List.Forall₂ List.Perm a b) |
| (p : Params) (ls : List ℕ) (t : Table) : |
| (runState p ls a t).2=(runState p ls b t).2 := by |
| induction ls generalizing a b t with |
| | nil => rfl |
| | cons l ls ih => |
| simp only [runState,update_rows h] |
| exact ih (trim_rows h l) _ |
| lemma count_rows {a b : Bags} (h : List.Forall₂ List.Perm a b) (ps : Parents) (ls : List ℕ) : |
| count ((a,ps),ls)=count ((b,ps),ls) := by |
| simp only [count,run,h.length_eq,run_rows h] |
| lemma run_perm {a b : Bags} (h : a.Perm b) (p : Params) (ls : List ℕ) (t : Table) : |
| (runState p ls a t).2=(runState p ls b t).2 := by |
| induction ls generalizing a b t with |
| | nil => rfl |
| | cons l ls ih => |
| simp only [runState,update_perm h] |
| exact ih (h.filter _) _ |
| lemma count_perm {a b : Bags} (h : a.Perm b) (ps : Parents) (ls : List ℕ) : |
| count ((a,ps),ls)=count ((b,ps),ls) := by |
| simp only [count,run,h.length_eq,run_perm h] |
|
|
| noncomputable def orderedRep {n m : ℕ} (bags : Fin n → Finset (Fin m)) : Bags := |
| List.ofFn (fun i=>bagRep (bags i)) |
|
|
| lemma orderedRep_perm {n m : ℕ} (bags : Fin n → Finset (Fin m)) : |
| (orderedRep bags).Perm (activeRep bags Finset.univ) := by |
| unfold orderedRep activeRep |
| change (List.ofFn ((bagRep ∘ bags) ∘ id)).Perm _ |
| rw [← List.map_ofFn] |
| apply List.Perm.map |
| apply List.perm_of_nodup_nodup_toFinset_eq |
| · exact List.nodup_ofFn.mpr Function.injective_id |
| · exact Finset.nodup_toList _ |
| · ext i; simp |
|
|
| lemma count_ordered {n m : ℕ} (bags : Fin n → Finset (Fin m)) |
| (parent : Fin m → Option (Fin m)) (ls : List (Fin m)) : |
| count ((orderedRep bags,parentRep parent),ls.map Fin.val)=UnitRefresh.Materialized.count bags parent ls := by |
| rw [count_perm (orderedRep_perm bags),count_eq] |
|
|
| lemma count_represented {n m : ℕ} (bags : Fin n → Finset (Fin m)) |
| (parent : Fin m → Option (Fin m)) (ls : List (Fin m)) (bs : Bags) |
| (hbs : List.Forall₂ List.Perm bs (orderedRep bags)) : |
| count ((bs,parentRep parent),ls.map Fin.val)=UnitRefresh.Materialized.count bags parent ls := by |
| rw [count_rows hbs,count_ordered] |
|
|
| end MatchingFPRAS.ExecutableDP |
|
|
| end OAI |
|
|
