File size: 4,646 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeFinite
namespace OAI
namespace MatchingFPRAS.TreeTyped
open Polynomial
variable {A B C : Type} [Codec A] [Codec B] [Codec C]
omit [Codec A] [Codec B] [Codec C] in
lemma fold_prepend (as : List (List A)) (bs : List A) :
as.foldl (fun bs a=>a++bs) bs=as.reverse.flatten++bs := by
induction as generalizing bs with
| nil => rfl
| cons a as ih => simp [List.foldl_cons,ih,List.flatten_append,List.append_assoc]
lemma weight_flatten (as : List (List A)) : weight as.flatten≤weight as := by
induction as with
| nil => rfl
| cons a as ih =>
simp only [List.flatten_cons,weight_cons]
have h:=weight_append a as.flatten
omega
def flatten : Realizer (List.flatten (α:=A)) :=
(composition (pair reverse (constant ([] : List A))) (fold append)).congr (by
intro as
change as.reverse.foldl (fun bs a=>a++bs) []=as.flatten
rw [fold_prepend,List.reverse_reverse,List.append_nil])
lemma polynomial_flatten : PolynomialTime (flatten (A:=A)) := by
unfold flatten
apply polynomial_congr
apply polynomial_composition (polynomial_pair polynomial_reverse (polynomial_constant []))
apply polynomial_fold polynomial_append (2*X+1)
intro as bs pre post he
rw [fold_prepend]
have h1:=weight_append pre.reverse.flatten bs
have h2:=weight_flatten pre.reverse
rw [weight_reverse] at h2
have h3:=weight_prefix he
simp only [eval_add,eval_mul,eval_ofNat,eval_X,weight_prod]
omega
def flatMapPoly {f : A → List B} (F : Realizer f) : Realizer (List.flatMap f) :=
(composition (map F) flatten).congr (by intro as; rfl)
lemma polynomial_flatMapPoly {f : A → List B} {F : Realizer f} (hF : PolynomialTime F) :
PolynomialTime (flatMapPoly F) :=
polynomial_congr _ (polynomial_composition (polynomial_map hF) polynomial_flatten)
variable [LinearOrder A]
def finsetSingleton : Realizer (fun a : A=>({a} : Finset A)) :=
(composition (pair identity (constant ([] : List A))) listCons).recode id
(fun a=>({a} : Finset A)) (fun _=>rfl) (by intro a; simp only [Function.comp_apply,encode_finset,Finset.sort_singleton]; rfl)
lemma polynomial_finsetSingleton : PolynomialTime (finsetSingleton (A:=A)) := by
unfold finsetSingleton
exact polynomial_recode _ _ _ _ (polynomial_composition
(polynomial_pair polynomial_identity (polynomial_constant [])) polynomial_listCons)
def finsetInsert (E : Realizer (fun x : A×A=>decide (x.1=x.2)))
(R : Realizer (fun x : A×A=>decide (x.1≤x.2))) : Realizer (fun x : A×Finset A=>insert x.1 x.2) :=
(composition (pair (composition first finsetSingleton) second) (finsetUnion E R)).congr (by intro x; simp)
lemma polynomial_finsetInsert {E : Realizer (fun x : A×A=>decide (x.1=x.2))}
{R : Realizer (fun x : A×A=>decide (x.1≤x.2))}
(hE : PolynomialTime E) (hR : PolynomialTime R) : PolynomialTime (finsetInsert E R) :=
polynomial_congr _ (polynomial_composition
(polynomial_pair (polynomial_composition polynomial_first polynomial_finsetSingleton) polynomial_second)
(polynomial_finsetUnion hE hR))
variable [LinearOrder B]
def finsetBiUnion {f : C×A → Finset B} (F : Realizer f)
(E : Realizer (fun x : B×B=>decide (x.1=x.2)))
(R : Realizer (fun x : B×B=>decide (x.1≤x.2))) :
Realizer (fun x : C×Finset A=>x.2.biUnion (fun a=>f (x.1,a))) :=
(composition (composition (composition (pair first (composition second finsetList))
(mapWith (composition F finsetList))) flatten) (listFinset E R)).congr (by
intro x
ext b
simp only [Function.comp_apply,List.mem_toFinset,List.mem_flatten,List.mem_map,
Finset.mem_biUnion,Finset.mem_sort]
constructor
· rintro ⟨bs,⟨a,ha,rfl⟩,hb⟩
exact ⟨a,ha,(Finset.mem_sort (r:=fun x y : B=>x≤y)).mp hb⟩
· rintro ⟨a,ha,hb⟩
exact ⟨(f (x.1,a)).sort (·≤·),⟨a,ha,rfl⟩,(Finset.mem_sort (r:=fun x y : B=>x≤y)).mpr hb⟩)
lemma polynomial_finsetBiUnion {f : C×A → Finset B} {F : Realizer f}
{E : Realizer (fun x : B×B=>decide (x.1=x.2))}
{R : Realizer (fun x : B×B=>decide (x.1≤x.2))}
(hF : PolynomialTime F) (hE : PolynomialTime E) (hR : PolynomialTime R) :
PolynomialTime (finsetBiUnion F E R) := by
unfold finsetBiUnion
apply polynomial_congr
exact polynomial_composition (polynomial_composition (polynomial_composition
(polynomial_pair polynomial_first (polynomial_composition polynomial_second polynomial_finsetList))
(polynomial_mapWith (polynomial_composition hF polynomial_finsetList))) polynomial_flatten)
(polynomial_listFinset hE hR)
end MatchingFPRAS.TreeTyped
end OAI
|