File size: 10,472 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 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 | import Mathlib
import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialCollections
namespace OAI
namespace MatchingFPRAS.TreeTyped
open Polynomial
variable {A : Type} [Codec A]
def contains [DecidableEq A] (E : Realizer (fun x : A×A=>decide (x.1=x.2))) :
Realizer (fun x : A×List A=>decide (x.1∈x.2)) :=
(composition (mapWith E) any).congr (by
intro x
apply Bool.eq_iff_iff.mpr
simp only [Function.comp_apply,List.any_map,List.any_eq_true,id_eq,decide_eq_true_eq]
constructor
· rintro ⟨a,ha,he⟩; simpa [he] using ha
· intro h; exact ⟨x.1,h,rfl⟩)
lemma polynomial_contains [DecidableEq A] {E : Realizer (fun x : A×A=>decide (x.1=x.2))}
(hE : PolynomialTime E) : PolynomialTime (contains E) := by
unfold contains
exact polynomial_congr _ (polynomial_composition (polynomial_mapWith hE) polynomial_any)
def dedupStep [DecidableEq A] (x : A×List A) : List A := if x.1∈x.2 then x.2 else x.1::x.2
def dedupStepRealizer [DecidableEq A] (E : Realizer (fun x : A×A=>decide (x.1=x.2))) :
Realizer (dedupStep (A:=A)) :=
(choose (contains E) second listCons).congr (by intro x; simp [dedupStep])
omit [Codec A] in
lemma dedup_fold [DecidableEq A] (as : List A) :
as.reverse.foldl (fun bs a=>dedupStep (a,bs)) []=as.dedup := by
induction as with
| nil => rfl
| cons a as ih =>
rw [List.reverse_cons,List.foldl_append,List.foldl_cons,List.foldl_nil,ih]
exact (List.dedup_cons' a as).symm
def dedup [DecidableEq A] (E : Realizer (fun x : A×A=>decide (x.1=x.2))) : Realizer (List.dedup (α:=A)) :=
(composition (pair reverse (constant [])) (fold (dedupStepRealizer E))).congr dedup_fold
lemma weight_dedupFold [DecidableEq A] (as bs : List A) :
weight (as.foldl (fun bs a=>dedupStep (a,bs)) bs)≤weight as+weight bs := by
induction as generalizing bs with
| nil => simp
| cons a as ih =>
rw [List.foldl_cons]
have hh:=ih (dedupStep (a,bs))
simp only [weight_cons]
have hs : weight (dedupStep (a,bs))≤1+weight a+weight bs := by
change weight (if a∈bs then bs else a::bs)≤_
split_ifs
· omega
· rw [weight_cons]
omega
lemma polynomial_dedup [DecidableEq A] {E : Realizer (fun x : A×A=>decide (x.1=x.2))}
(hE : PolynomialTime E) : PolynomialTime (dedup E) := by
unfold dedup
apply polynomial_congr
apply polynomial_composition (polynomial_pair polynomial_reverse (polynomial_constant []))
apply polynomial_fold (polynomial_congr _ (polynomial_choose (polynomial_contains hE) polynomial_second polynomial_listCons)) (2*X+1)
intro as bs pre post he
have hh:=weight_dedupFold pre bs
have hp:=weight_prefix he
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
omega
variable (r : A → A → Prop) [DecidableRel r]
def insertStep (x : A×(A×(List A×List A))) : A×(List A×List A) :=
(x.2.1,(x.1::x.2.2.1,if r x.2.1 x.1 then x.2.1::x.1::x.2.2.1 else x.1::x.2.2.2))
def insertStepRealizer (R : Realizer (fun x : A×A=>decide (r x.1 x.2))) : Realizer (insertStep r) :=
(pair (composition second first) (pair (composition (pair first (composition (composition second second) first)) listCons)
(choose (composition (pair (composition second first) first) R)
(composition (pair (composition second first) (composition (pair first (composition (composition second second) first)) listCons)) listCons)
(composition (pair first (composition (composition second second) second)) listCons)))).congr (by intro x; simp [insertStep])
omit [Codec A] in
lemma insert_fold (as bs : List A) (a : A) :
as.reverse.foldl (fun z b=>insertStep r (b,z)) (a,(bs,List.orderedInsert r a bs))=
(a,(as++bs,List.orderedInsert r a (as++bs))) := by
induction as with
| nil => rfl
| cons b as ih =>
rw [List.reverse_cons,List.foldl_append,List.foldl_cons,List.foldl_nil,ih]
rfl
def orderedInsert (R : Realizer (fun x : A×A=>decide (r x.1 x.2))) :
Realizer (fun x : A×List A=>List.orderedInsert r x.1 x.2) :=
(composition (composition (pair (composition second reverse)
(pair first (pair (constant []) (composition (pair first (constant [])) listCons))))
(fold (insertStepRealizer r R))) (composition second second)).congr (by
intro x
change (x.2.reverse.foldl (fun z b=>insertStep r (b,z)) (x.1,([],[x.1]))).2.2=_
have h:=insert_fold r x.2 [] x.1
simpa only [List.append_nil,List.orderedInsert_nil] using congrArg (fun x=>x.2.2) h)
lemma weight_perm {as bs : List A} (h : as.Perm bs) : weight as=weight bs := by
simp only [weight,size_encode_list,h.length_eq,(h.map (fun a=>TreeFunction.size (encode a))).sum_eq]
lemma weight_orderedInsert (a : A) (as : List A) :
weight (List.orderedInsert r a as)=1+weight a+weight as := by
rw [weight_perm (List.perm_orderedInsert r a as),weight_cons]
lemma polynomial_insertStep {R : Realizer (fun x : A×A=>decide (r x.1 x.2))}
(hR : PolynomialTime R) : PolynomialTime (insertStepRealizer r R) := by
unfold insertStepRealizer
apply polynomial_congr
apply polynomial_pair (polynomial_fst polynomial_second)
apply polynomial_pair (polynomial_composition (polynomial_pair polynomial_first (polynomial_fst (polynomial_snd polynomial_second))) polynomial_listCons)
exact polynomial_choose (polynomial_composition (polynomial_pair (polynomial_fst polynomial_second) polynomial_first) hR)
(polynomial_composition (polynomial_pair (polynomial_fst polynomial_second)
(polynomial_composition (polynomial_pair polynomial_first (polynomial_fst (polynomial_snd polynomial_second))) polynomial_listCons)) polynomial_listCons)
(polynomial_composition (polynomial_pair polynomial_first (polynomial_snd (polynomial_snd polynomial_second))) polynomial_listCons)
lemma insert_fold_bound (as bs cs : List A) (a : A) :
weight ((as.foldl (fun z b=>insertStep r (b,z)) (a,(bs,cs))).2.1)≤weight as+weight bs ∧
weight ((as.foldl (fun z b=>insertStep r (b,z)) (a,(bs,cs))).2.2)≤2*weight as+weight bs+weight cs+weight a+1 ∧
(as.foldl (fun z b=>insertStep r (b,z)) (a,(bs,cs))).1=a := by
induction as generalizing bs cs with
| nil =>
change weight bs≤1+weight bs ∧ weight cs≤2+weight bs+weight cs+weight a+1 ∧ a=a
exact ⟨by omega,by omega,rfl⟩
| cons b as ih =>
rw [List.foldl_cons]
by_cases h : r a b
· have hs : insertStep r (b,(a,(bs,cs)))=(a,(b::bs,a::b::bs)) := by simp [insertStep,h]
rw [hs]
have he:=insert_fold r as.reverse (b::bs) a
simp only [List.reverse_reverse] at he
have ho : List.orderedInsert r a (b::bs)=a::b::bs := by simp [h]
rw [ho] at he
rw [he]
have hw:=weight_append as.reverse (b::bs)
rw [weight_reverse,weight_cons] at hw
simp only [weight_orderedInsert,weight_cons]
exact ⟨by omega,by omega,trivial⟩
· have hs : insertStep r (b,(a,(bs,cs)))=(a,(b::bs,b::cs)) := by simp [insertStep,h]
rw [hs]
have hh:=ih (b::bs) (b::cs)
simp only [weight_cons] at hh ⊢
exact ⟨by omega,by omega,hh.2.2⟩
lemma polynomial_orderedInsert {R : Realizer (fun x : A×A=>decide (r x.1 x.2))}
(hR : PolynomialTime R) : PolynomialTime (orderedInsert r R) := by
unfold orderedInsert
apply polynomial_congr
apply polynomial_composition _ (polynomial_snd polynomial_second)
apply polynomial_composition (polynomial_pair (polynomial_composition polynomial_second polynomial_reverse)
(polynomial_pair polynomial_first (polynomial_pair (polynomial_constant [])
(polynomial_composition (polynomial_pair polynomial_first (polynomial_constant [])) polynomial_listCons))))
apply polynomial_fold (polynomial_insertStep r hR) (5*X+10)
rintro as ⟨a,bs,cs⟩ pre post he
have hh:=insert_fold_bound r pre bs cs a
have hp:=weight_prefix he
rw [weight_prod,hh.2.2,weight_prod]
calc
_ ≤ 1+weight a+(1+(weight pre+weight bs)+(2*weight pre+weight bs+weight cs+weight a+1)) := by
gcongr
· exact hh.1
· exact hh.2.1
_ ≤ _ := by
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
omega
def insertionSort (R : Realizer (fun x : A×A=>decide (r x.1 x.2))) :
Realizer (List.insertionSort r) :=
(composition (pair reverse (constant [])) (fold (orderedInsert r R))).congr (by
intro as
change as.reverse.foldl (fun bs a=>List.orderedInsert r a bs) []=as.insertionSort r
rw [List.foldl_reverse]
rfl)
lemma weight_insertFold (as bs : List A) :
weight (as.foldl (fun bs a=>List.orderedInsert r a bs) bs)+1=weight as+weight bs := by
induction as generalizing bs with
| nil => simp only [List.foldl_nil,weight_nil]; omega
| cons a as ih =>
rw [List.foldl_cons]
have hh:=ih (List.orderedInsert r a bs)
rw [weight_orderedInsert] at hh
rw [weight_cons]
omega
lemma polynomial_insertionSort {R : Realizer (fun x : A×A=>decide (r x.1 x.2))}
(hR : PolynomialTime R) : PolynomialTime (insertionSort r R) := by
unfold insertionSort
apply polynomial_congr
apply polynomial_composition (polynomial_pair polynomial_reverse (polynomial_constant []))
apply polynomial_fold (polynomial_orderedInsert r hR) (2*X+1)
intro as bs pre post he
have hh:=weight_insertFold r pre bs
have hp:=weight_prefix he
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
omega
variable [DecidableEq A]
def canonical (E : Realizer (fun x : A×A=>decide (x.1=x.2)))
(R : Realizer (fun x : A×A=>decide (r x.1 x.2))) :
Realizer (fun as : List A=>as.dedup.insertionSort r) := composition (dedup E) (insertionSort r R)
lemma polynomial_canonical {E : Realizer (fun x : A×A=>decide (x.1=x.2))}
{R : Realizer (fun x : A×A=>decide (r x.1 x.2))}
(hE : PolynomialTime E) (hR : PolynomialTime R) : PolynomialTime (canonical r E R) :=
polynomial_composition (polynomial_dedup hE) (polynomial_insertionSort r hR)
omit [Codec A] in
lemma canonical_eq_sort [IsTrans A r] [Std.Total r] [Std.Antisymm r] (as : List A) :
as.dedup.insertionSort r=as.toFinset.sort r := by
have hn:=(List.perm_insertionSort r as.dedup).nodup_iff.mpr (List.nodup_dedup as)
have hh:=(List.toFinset_sort (r:=r) hn).mpr (List.pairwise_insertionSort r as.dedup)
have he : (as.dedup.insertionSort r).toFinset=as.toFinset := by ext a; simp
rw [he] at hh
exact hh.symm
end MatchingFPRAS.TreeTyped
end OAI
|