File size: 5,200 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | 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
|