| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.TreeNaturalComb |
| import OAI.Combinatorics.MatchingCount.Machines.TreePredicate |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.TreeTyped |
| variable {A B C : Type} [Codec A] [Codec B] [Codec C] |
| def Realizer.fst {f : A → B×C} (F : Realizer f) : Realizer (fun a=>(f a).1) := composition F first |
| def Realizer.snd {f : A → B×C} (F : Realizer f) : Realizer (fun a=>(f a).2) := composition F second |
| end MatchingFPRAS.TreeTyped |
|
|
| namespace MatchingFPRAS.ExecutableDP |
| open TreeTyped |
|
|
| abbrev Table := List (List ℕ) |
| def read (x : Table×(ℕ×ℕ)) : ℕ := (x.1.getD x.2.1 []).getD x.2.2 0 |
|
|
| def readRealizer : Realizer read := |
| composition (pair (composition (pair first second.fst) (getD [])) second.snd) (getD 0) |
|
|
| abbrev EntryCtx := (Bool×ℕ) × (ℕ × (Table × (ℕ × (ℕ × ℕ)))) |
| def term (x : (EntryCtx×ℕ)×ℕ) : ℕ := |
| let c := x.1.1 |
| let r := x.1.2 |
| let k := x.2 |
| c.2.2.2.2.1.choose k * read (c.2.2.1,(c.2.1,c.2.2.2.1+k)) * |
| read (c.2.2.1,(c.1.2,c.2.2.2.2.1-k+r)) |
|
|
| def termRealizer : Realizer term := by |
| let c : Realizer (fun x : (EntryCtx×ℕ)×ℕ=>x.1.1) := first.fst |
| let r : Realizer (fun x : (EntryCtx×ℕ)×ℕ=>x.1.2) := first.snd |
| let k : Realizer (fun x : (EntryCtx×ℕ)×ℕ=>x.2) := second |
| let s := c.snd.snd.snd.snd.fst |
| let u := c.snd.snd.snd.fst |
| let t := c.snd.snd.fst |
| let l := c.snd.fst |
| let p := c.fst.snd |
| let ch := composition (pair s k) natChoose |
| let L := composition (pair t (pair l (composition (pair u k) add))) readRealizer |
| let R := composition (pair t (pair p (composition (pair (composition (pair s k) subtract) r) add))) readRealizer |
| exact composition (pair (composition (pair ch L) multiply) R) multiply |
|
|
| def entry (x : EntryCtx×(ℕ×ℕ)) : ℕ := |
| let c:=x.1 |
| let a:=x.2.1 |
| let r:=x.2.2 |
| if c.1.1 then |
| if a=c.2.1 then 1 else if a=c.1.2 then |
| ((List.range (c.2.2.2.2.1+1)).map fun k=>term ((c,r),k)).sum |
| else read (c.2.2.1,(a,r)) |
| else if a=c.2.1 then read (c.2.2.1,(c.2.1,c.2.2.2.2.2)) |
| else read (c.2.2.1,(a,r)) |
|
|
| def entryRealizer : Realizer entry := by |
| let c : Realizer (fun x : EntryCtx×(ℕ×ℕ)=>x.1) := first |
| let a : Realizer (fun x : EntryCtx×(ℕ×ℕ)=>x.2.1) := second.fst |
| let r : Realizer (fun x : EntryCtx×(ℕ×ℕ)=>x.2.2) := second.snd |
| let l := c.snd.fst |
| let rd := composition (pair c.snd.snd.fst (pair a r)) readRealizer |
| let al := composition (pair a l) natEqual |
| let ap := composition (pair a c.fst.snd) natEqual |
| let ks := composition (composition c.snd.snd.snd.snd.fst successor) range |
| let sm := composition (composition (pair (pair c r) ks) (mapWith termRealizer)) listSum |
| let rt := composition (pair c.snd.snd.fst (pair l c.snd.snd.snd.snd.snd)) readRealizer |
| exact (choose c.fst.fst (choose al (constant 1) (choose ap sm rd)) (choose al rt rd)).congr (by |
| intro x; simp only [entry,Function.comp_apply,decide_eq_true_eq]) |
|
|
| variable {X Y : Type} [Codec X] [Codec Y] |
| def tabulate (f : X×(ℕ×ℕ) → Y) (x : X×(ℕ×ℕ)) : List (List Y) := |
| (List.range x.2.1).map fun a=>(List.range (x.2.2+1)).map fun r=>f (x.1,(a,r)) |
|
|
| def tabulateRealizer {f : X×(ℕ×ℕ) → Y} (F : Realizer f) : Realizer (tabulate f) := by |
| let rowF : Realizer (fun x : (X×ℕ)×ℕ=>f (x.1.1,(x.1.2,x.2))) := |
| composition (pair first.fst (pair first.snd second)) F |
| let rows : Realizer (fun x : (X×ℕ)×ℕ=> |
| (List.range (x.1.2+1)).map fun r=>f (x.1.1,(x.2,r))) := |
| composition (pair (pair first.fst second) (composition (composition first.snd successor) range)) |
| (mapWith rowF) |
| exact composition (pair (pair first second.snd) (composition second.fst range)) (mapWith rows) |
|
|
| def updateRealizer : Realizer (tabulate entry) := tabulateRealizer entryRealizer |
|
|
| lemma read_eq (t : Table) (a r : ℕ) : read (t,(a,r))=UnitRefresh.Materialized.read t a r := rfl |
|
|
| lemma entry_eq {V : Type} {m : ℕ} |
| (bags : V → Finset (Fin m)) (R : Finset V) (parent : Fin m → Option (Fin m)) |
| (l a : Fin m) (t : Table) (r : ℕ) : |
| entry (((match parent l with | none=>(false,0) | some p=>(true,p.val)), |
| (l.val,(t,(UnitRefresh.privateCount bags R l, |
| (UnitRefresh.sharedCount bags R l,(R.filter fun x=>l∈bags x).card))))),(a.val,r))= |
| UnitRefresh.Materialized.entry bags R parent l a t r := by |
| have he : (a.val=l.val) ↔ a=l := Fin.val_inj |
| cases hp : parent l with |
| | none => simp only [entry,UnitRefresh.Materialized.entry,hp,Bool.false_eq_true,↓reduceIte,he,read_eq] |
| | some p => |
| have he' : (a.val=p.val) ↔ a=p := Fin.val_inj |
| simp only [entry,UnitRefresh.Materialized.entry,hp,↓reduceIte,he,he'] |
| split_ifs <;> try rfl |
|
|
| lemma tabulate_eq {m B : ℕ} (f : ℕ×ℕ → ℕ) : |
| (List.range m).map (fun a=>(List.range (B+1)).map fun r=>f (a,r))= |
| UnitRefresh.Materialized.tabulate m B (fun a r=>f (a.val,r)) := by |
| unfold UnitRefresh.Materialized.tabulate |
| apply List.ext_getElem |
| · simp |
| · intro i hi hi' |
| simp only [List.getElem_map,List.getElem_range,List.getElem_ofFn] |
| apply List.ext_getElem |
| · simp |
| · intro j hj hj' |
| simp only [List.getElem_map,List.getElem_range,List.getElem_ofFn] |
| end MatchingFPRAS.ExecutableDP |
|
|
| end OAI |
|
|
