File size: 6,040 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeFastLookup
import OAI.Combinatorics.MatchingCount.Complexity.TreeFractionCosts
namespace OAI
namespace MatchingFPRAS.TreeTyped
open Polynomial
variable {A : Type} [Codec A]
def takeFast : Realizer (fun x : List A×ℕ=>x.1.take x.2) :=
(composition (composition (pair (composition first reverse)
(composition (pair (composition first listLength) second) subtract)) dropFast) reverse).congr (by
intro x
change (x.1.reverse.drop (x.1.length-x.2)).reverse=x.1.take x.2
rw [←List.reverse_take,List.reverse_reverse])
lemma polynomial_takeFast : PolynomialTime (takeFast (A:=A)) := by
unfold takeFast
apply polynomial_congr
exact polynomial_composition (polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_reverse)
(polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_listLength)
polynomial_second) polynomial_subtract)) polynomial_dropFast) polynomial_reverse
omit [Codec A] in
lemma polynomial_bitValue : PolynomialTime bitValue := by
unfold bitValue
apply polynomial_congr
exact polynomial_composition (polynomial_composition (polynomial_pair polynomial_reverse
(polynomial_constant (1,0))) polynomial_mulFold) polynomial_second
omit [Codec A] in
lemma polynomial_bitDenominator : PolynomialTime bitDenominatorRealizer := by
unfold bitDenominatorRealizer
apply polynomial_congr
apply polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant 1))
apply polynomial_fold (polynomial_composition polynomial_second polynomial_double) (4*X+8*X+1)
intro bs n pre post he
have hfold : ∀ z,(pre.foldl (fun a (_ : Bool)=>2*a) z).size≤z.size+pre.length*2 := by
clear he
induction pre with
| nil => intro z; simp
| cons b pre ih =>
intro z
have hh:=nat_size_mul 2 z
have ht:=ih (2*z)
simp only [List.foldl_cons,List.length_cons]
have h2 : Nat.size 2=2 := by decide
omega
let S:=weight (bs,n)
have hn : n.size≤S := (size_le_weight n).trans (weight_snd (bs,n))
have hp : pre.length≤S := (list_length_le_weight pre).trans ((weight_prefix he).trans (weight_fst (bs,n)))
have hw:=weight_nat_le (pre.foldl (fun a (_ : Bool)=>2*a) n)
have hh:=hfold n
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Polynomial.eval_one]
change weight (pre.foldl (fun a (_ : Bool)=>2*a) n)≤4*S+8*S+1
omega
omit [Codec A] in
lemma polynomial_minimum : PolynomialTime minimum := by
unfold minimum
exact polynomial_congr _ (polynomial_choose polynomial_less polynomial_first polynomial_second)
omit [Codec A] in
lemma polynomial_listMin : PolynomialTime listMinRealizer := by
unfold listMinRealizer
apply polynomial_congr
apply polynomial_fold polynomial_minimum (4*X+1)
intro as n pre post he
have hm : pre.foldl (fun z a=>min a z) n=listMin (pre,n) := by
unfold listMin
congr 1
funext z a
exact Nat.min_comm _ _
change weight (pre.foldl (fun z a=>min a z) n)≤_
rw [hm]
have hl:=listMin_le_default pre n
have hs:=(Nat.size_le_size hl).trans (size_le_weight n)
have hw:=weight_nat_le (listMin (pre,n))
have hn : weight n≤weight (as,n) := weight_snd (as,n)
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Polynomial.eval_one]
omega
end MatchingFPRAS.TreeTyped
namespace MatchingFPRAS.TreeFraction
open TreeTyped
def cumulativeFast : Realizer cumulativeFraction := composition takeFast sumRealizer
lemma polynomial_cumulativeFast : PolynomialTime cumulativeFast :=
polynomial_composition polynomial_takeFast polynomial_sum
end MatchingFPRAS.TreeFraction
namespace MatchingFPRAS.ExecutableChoice
open TreeTyped TreeFraction Polynomial
def predicateFast : Realizer predicate := by
let C : Realizer (fun x : (List Fraction×Fraction)×ℕ=>cumulativeFraction (x.1.1,x.2+1)) :=
(composition (pair first.fst (composition second successor)) cumulativeFast).congr (fun _=>rfl)
exact (composition (pair first.snd C) lessRealizer).congr (fun _=>rfl)
lemma polynomial_predicateFast : PolynomialTime predicateFast := by
unfold predicateFast
dsimp only
apply polynomial_congr
apply polynomial_composition _ TreeFraction.polynomial_less
apply polynomial_pair (polynomial_snd polynomial_first)
apply polynomial_congr
exact polynomial_composition (polynomial_pair (polynomial_fst polynomial_first)
(polynomial_composition polynomial_second polynomial_successor)) polynomial_cumulativeFast
def chooseFast : Realizer choose := by
let rs : Realizer (fun x : List Fraction×Fraction=>List.range x.1.length) :=
composition (composition first listLength) range
let good:=composition (pair identity rs) (filterWith predicateFast)
exact (composition (pair good (composition first listLength)) listMinRealizer).congr (fun _=>rfl)
lemma polynomial_chooseFast : PolynomialTime chooseFast := by
unfold chooseFast
dsimp only
apply polynomial_congr
apply polynomial_composition _ polynomial_listMin
apply polynomial_pair _ (polynomial_composition polynomial_first polynomial_listLength)
apply polynomial_composition _ (polynomial_filterWith polynomial_predicateFast)
apply polynomial_pair polynomial_identity
exact polynomial_boundedRange (polynomial_composition polynomial_first polynomial_listLength) X
(fun x=>by simpa using (list_length_le_weight x.1).trans (weight_fst x))
def chooseBitsFast : Realizer chooseBits :=
composition (pair first (pair (composition second bitValue) (composition second bitDenominatorRealizer))) chooseFast
lemma polynomial_chooseBitsFast : PolynomialTime chooseBitsFast :=
polynomial_composition (polynomial_pair polynomial_first (polynomial_pair
(polynomial_composition polynomial_second polynomial_bitValue)
(polynomial_composition polynomial_second polynomial_bitDenominator))) polynomial_chooseFast
end MatchingFPRAS.ExecutableChoice
end OAI
|