File size: 5,395 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Arithmetic.TreeNatDivision
import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialLists
namespace OAI
namespace MatchingFPRAS.TreeTyped
open Polynomial
lemma polynomial_digitValue : PolynomialTime digitValue := by
unfold digitValue
exact polynomial_congr _ (polynomial_choose polynomial_identity (polynomial_constant 1) (polynomial_constant 0))
lemma polynomial_divStep : PolynomialTime divStepRealizer := by
unfold divStepRealizer
apply polynomial_congr
apply polynomial_pair (polynomial_fst polynomial_second)
apply polynomial_choose
· apply polynomial_composition _ polynomial_less
apply polynomial_pair
· apply polynomial_composition _ polynomial_add
exact polynomial_pair (polynomial_composition (polynomial_snd (polynomial_snd polynomial_second)) polynomial_double)
(polynomial_composition polynomial_first polynomial_digitValue)
· exact polynomial_fst polynomial_second
· apply polynomial_pair
· exact polynomial_composition (polynomial_fst (polynomial_snd polynomial_second)) polynomial_double
· apply polynomial_composition _ polynomial_add
exact polynomial_pair (polynomial_composition (polynomial_snd (polynomial_snd polynomial_second)) polynomial_double)
(polynomial_composition polynomial_first polynomial_digitValue)
· apply polynomial_pair
· apply polynomial_composition _ polynomial_add
exact polynomial_pair
(polynomial_composition (polynomial_fst (polynomial_snd polynomial_second)) polynomial_double) (polynomial_constant 1)
· apply polynomial_composition _ polynomial_subtract
apply polynomial_pair
· apply polynomial_composition _ polynomial_add
exact polynomial_pair (polynomial_composition (polynomial_snd (polynomial_snd polynomial_second)) polynomial_double)
(polynomial_composition polynomial_first polynomial_digitValue)
· exact polynomial_fst polynomial_second
lemma nat_size_double_digit (r : ℕ) (b : Bool) : (2*r+b.toNat).size≤r.size+3 := by
have h1:=nat_size_mul 2 r
have h2:=nat_size_add (2*r) b.toNat
have h3 : b.toNat.size≤1 := Nat.size_le_size (Bool.toNat_le b)
have h4 : Nat.size 2=2 := by decide
have hm : max (2*r).size b.toNat.size≤r.size+2 := max_le (by omega) (by omega)
omega
lemma divStep_sizes (b : Bool) (n q r : ℕ) :
(divStep (b,(n,q,r))).2.1.size≤q.size+3 ∧ (divStep (b,(n,q,r))).2.2.size≤r.size+3 := by
have hq:=nat_size_double_digit q true
have hq0:=nat_size_double_digit q false
have hr:=nat_size_double_digit r b
have hsub:=Nat.size_le_size (Nat.sub_le (2*r+b.toNat) n)
simp only [Bool.toNat_true] at hq
simp only [Bool.toNat_false,Nat.add_zero] at hq0
dsimp only [divStep]
split_ifs <;> simp only <;> constructor <;> omega
lemma divFold_sizes (bs : List Bool) (n q r : ℕ) :
(bs.foldl (fun z b=>divStep (b,z)) (n,q,r)).2.1.size≤q.size+3*bs.length ∧
(bs.foldl (fun z b=>divStep (b,z)) (n,q,r)).2.2.size≤r.size+3*bs.length := by
induction bs generalizing q r with
| nil => simp
| cons b bs ih =>
have hs:=divStep_sizes b n q r
have ht:=ih (divStep (b,(n,q,r))).2.1 (divStep (b,(n,q,r))).2.2
have he : divStep (b,(n,q,r))=(n,(divStep (b,(n,q,r))).2.1,(divStep (b,(n,q,r))).2.2) := by
exact Prod.ext rfl (Prod.eta _).symm
change (bs.foldl _ (divStep (b,(n,q,r)))).2.1.size≤_ ∧ (bs.foldl _ (divStep (b,(n,q,r)))).2.2.size≤_
rw [he]
simp only [List.length_cons]
constructor <;> omega
lemma polynomial_divFold : PolynomialTime (fold divStepRealizer) := by
apply polynomial_fold polynomial_divStep (40*X+10)
rintro bs ⟨n,q,r⟩ pre post he
let S:=weight (bs,(n,q,r))
have hpre : pre.length≤S := (list_length_le_weight pre).trans ((weight_prefix he).trans (by dsimp [S]; simp only [weight_prod]; omega))
have hq : q.size≤S := by have h:=size_le_weight q; dsimp [S]; simp only [weight_prod]; omega
have hr : r.size≤S := by have h:=size_le_weight r; dsimp [S]; simp only [weight_prod]; omega
have hn : weight n≤S := by dsimp [S]; simp only [weight_prod]; omega
have hs:=divFold_sizes pre n q r
have hqo:=weight_nat_le (pre.foldl (fun z b=>divStep (b,z)) (n,q,r)).2.1
have hro:=weight_nat_le (pre.foldl (fun z b=>divStep (b,z)) (n,q,r)).2.2
have hf:=divFold_first pre n q r
rw [←Prod.eta (pre.foldl (fun z b=>divStep (b,z)) (n,q,r)),weight_prod,hf,
←Prod.eta (pre.foldl (fun z b=>divStep (b,z)) (n,q,r)).2,weight_prod]
simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X]
change _≤40*S+10
omega
lemma polynomial_divCore : PolynomialTime divCore := by
unfold divCore
apply polynomial_composition _ polynomial_second
apply polynomial_composition _ polynomial_divFold
exact polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_toBits) polynomial_reverse)
(polynomial_pair polynomial_second (polynomial_pair (polynomial_constant 0) (polynomial_constant 0)))
lemma polynomial_division : PolynomialTime division := by
unfold division
apply polynomial_congr
exact polynomial_choose (polynomial_composition (polynomial_pair (polynomial_constant 0) polynomial_second) polynomial_less)
polynomial_divCore (polynomial_pair (polynomial_constant 0) polynomial_first)
end MatchingFPRAS.TreeTyped
end OAI
|