File size: 7,736 Bytes
d5b7741 | 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 | import OAI.Combinatorics.ContingencyTables.Rooted.ForestJoinProgram
import OAI.Combinatorics.ContingencyTables.Rooted.LargeEdgeCatalogProgram
namespace OAI
/-! # Polynomial execution of the component-greedy forest loop
The immutable weighted edge catalog is scanned after every insertion.
There are at most the square of the stored vertex count many iterations;
all adjacency rows stay inside that fixed vertex range.
-/
namespace ContingencyTables.ForestGreedyProgram
open MatchingFPRAS.TreeTyped Polynomial FiniteGraphRootProgram WeightedArgmaxProgram
abbrev State := ForestEdgeChoiceProgram.Input
private def insert (z : State×Edge) : GraphCode := ForestJoinProgram.join (z.1.1,z.2.1)
private def insertRealizer : Realizer insert :=
composition (f := fun z : State×Edge=>(z.1.1,z.2.1)) (g := ForestJoinProgram.join)
(pair (composition first first) (composition second first)) ForestJoinProgram.joinRealizer
private lemma polynomial_insert : PolynomialTime insertRealizer :=
polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_first)
(polynomial_composition polynomial_second polynomial_first)) ForestJoinProgram.polynomial_join
def update (s : State) : GraphCode :=
(ForestEdgeChoiceProgram.choice s).elim s.1 (fun e=>insert (s,e))
def updateRealizer : Realizer update :=
composition (f := fun s : State=>(s,ForestEdgeChoiceProgram.choice s))
(g := fun z : State×Option Edge=>z.2.elim z.1.1 (fun e=>insert (z.1,e)))
(pair identity ForestEdgeChoiceProgram.choiceRealizer) (optionCases first insertRealizer)
lemma polynomial_update : PolynomialTime updateRealizer :=
polynomial_composition (polynomial_pair polynomial_identity ForestEdgeChoiceProgram.polynomial_choice)
(polynomial_optionCases polynomial_first polynomial_insert)
def advance (z : ℕ×State) : State := (update z.2,z.2.2)
def advanceRealizer : Realizer advance :=
pair (composition (f := fun z : ℕ×State=>z.2) (g := update) second updateRealizer)
(composition second second)
lemma polynomial_advance : PolynomialTime advanceRealizer :=
polynomial_pair (polynomial_composition polynomial_second polynomial_update)
(polynomial_composition polynomial_second polynomial_second)
lemma update_length (s : State) : (update s).length=s.1.length := by
unfold update
cases h : ForestEdgeChoiceProgram.choice s with
| none=>rfl
| some e=>exact ForestJoinProgram.join_length _
lemma update_weight (s : State) :
weight (update s)≤ max (weight s.1)
(s.1.length*(4*s.1.length^2+2*s.1.length+2)+1) := by
unfold update
cases h : ForestEdgeChoiceProgram.choice s with
| none=>exact le_max_left _ _
| some e=>exact (ForestJoinProgram.join_weight _).trans (le_max_right _ _)
lemma fold_edges (xs : List ℕ) (s : State) :
(xs.foldl (fun s a=>advance (a,s)) s).2=s.2 := by
induction xs generalizing s with
| nil=>rfl
| cons a xs ih=>exact ih (advance (a,s))
lemma fold_length (xs : List ℕ) (s : State) :
(xs.foldl (fun s a=>advance (a,s)) s).1.length=s.1.length := by
induction xs generalizing s with
| nil=>rfl
| cons a xs ih=>
exact (ih (advance (a,s))).trans (update_length s)
lemma fold_weight (xs : List ℕ) (s : State) :
weight (xs.foldl (fun s a=>advance (a,s)) s).1≤ max (weight s.1)
(s.1.length*(4*s.1.length^2+2*s.1.length+2)+1) := by
induction xs generalizing s with
| nil=>exact le_max_left _ _
| cons a xs ih=>
have h := ih (advance (a,s))
simp only [advance,update_length] at h
exact h.trans (max_le (update_weight s) (le_max_right _ _))
lemma polynomial_loop : PolynomialTime (fold advanceRealizer) := by
apply polynomial_fold polynomial_advance (30*(X+1)^3)
intro xs s pre post he
let S := weight (xs,s)
let out := pre.foldl (fun s a=>advance (a,s)) s
have hs : weight s≤S := weight_snd (xs,s)
have hg : weight s.1≤S := (weight_fst s).trans hs
have hec : weight s.2≤S := (weight_snd s).trans hs
have hn : s.1.length≤S := (list_length_le_weight s.1).trans hg
have hb : s.1.length*(4*s.1.length^2+2*s.1.length+2)+1≤4*S^3+2*S^2+2*S+1 := by
have hpow := Nat.pow_le_pow_left hn 2
have hmul := Nat.mul_le_mul hn (show 4*s.1.length^2+2*s.1.length+2≤4*S^2+2*S+2 by omega)
nlinarith
have ho : weight out.1≤4*S^3+2*S^2+3*S+1 :=
(fold_weight pre s).trans (max_le (by omega) (by omega))
have heq : out.2=s.2 := fold_edges pre s
have hw : weight out=1+weight out.1+weight out.2 := by
change weight (out.1,out.2)=_
exact weight_prod _ _
simp only [eval_mul,eval_ofNat,eval_add,eval_pow,eval_X,eval_one]
change weight out≤30*(S+1)^3
rw [hw,heq]
nlinarith
def slots (s : State) : List ℕ := List.range (s.1.length*s.1.length)
def slotsRealizer : Realizer slots :=
composition (f := fun s : State=>s.1.length*s.1.length) (g := List.range)
(composition (f := fun s : State=>(s.1.length,s.1.length))
(g := fun z : ℕ×ℕ=>z.1*z.2)
(pair (composition first listLength) (composition first listLength)) multiply) range
lemma polynomial_slots : PolynomialTime slotsRealizer := by
apply polynomial_boundedRange
(polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_listLength)
(polynomial_composition polynomial_first polynomial_listLength)) polynomial_multiply) (X^2)
intro s
have h : s.1.length≤weight s := (list_length_le_weight s.1).trans (weight_fst s)
simpa only [Function.comp_apply,eval_pow,eval_mul,eval_X,pow_two] using Nat.mul_self_le_mul_self h
def execute (s : State) : State := (slots s).foldl (fun s a=>advance (a,s)) s
def executeRealizer : Realizer execute :=
composition (f := fun s : State=>(slots s,s))
(g := fun z : List ℕ×State=>z.1.foldl (fun s a=>advance (a,s)) z.2)
(pair slotsRealizer identity) (fold advanceRealizer)
lemma polynomial_execute : PolynomialTime executeRealizer :=
polynomial_composition (polynomial_pair polynomial_slots polynomial_identity) polynomial_loop
def emptyGraph (z : LargeEdgeCatalogProgram.Input) : GraphCode :=
(List.range (LargeEdgeCatalogProgram.vertexCount z)).map (fun _=>[])
def emptyGraphRealizer : Realizer emptyGraph :=
composition (composition LargeEdgeCatalogProgram.vertexCountRealizer range) (map (constant []))
lemma polynomial_emptyGraph : PolynomialTime emptyGraphRealizer := by
apply polynomial_composition
· apply polynomial_boundedRange LargeEdgeCatalogProgram.polynomial_vertexCount (2*X)
intro z
have hr : z.1.1.1.length≤weight z := (list_length_le_weight z.1.1.1).trans
((weight_fst z.1.1).trans ((weight_fst z.1).trans (weight_fst z)))
have hc : z.1.1.2.length≤weight z := (list_length_le_weight z.1.1.2).trans
((weight_snd z.1.1).trans ((weight_fst z.1).trans (weight_fst z)))
simp only [LargeEdgeCatalogProgram.vertexCount,eval_mul,eval_ofNat,eval_X]
omega
· exact polynomial_map (polynomial_constant [])
def prepare (z : LargeEdgeCatalogProgram.Input) : State :=
(emptyGraph z,LargeEdgeCatalogProgram.catalog z)
def prepareRealizer : Realizer prepare :=
pair emptyGraphRealizer LargeEdgeCatalogProgram.catalogRealizer
lemma polynomial_prepare : PolynomialTime prepareRealizer :=
polynomial_pair polynomial_emptyGraph LargeEdgeCatalogProgram.polynomial_catalog
def forest (z : LargeEdgeCatalogProgram.Input) : GraphCode := (execute (prepare z)).1
def forestRealizer : Realizer forest :=
composition (composition (f:=prepare) (g:=execute) prepareRealizer executeRealizer) first
lemma polynomial_forest : PolynomialTime forestRealizer :=
polynomial_composition (polynomial_composition polynomial_prepare polynomial_execute) polynomial_first
end ContingencyTables.ForestGreedyProgram
end OAI
|