File size: 7,464 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.RegisterControl
import OAI.Combinatorics.MatchingCount.Machines.TreeTyped
namespace OAI
namespace MatchingFPRAS.TreeTyped
open TreeData TreeMachine RegisterProc TreeFunction
variable {A B : Type} [Codec A] [Codec B]
namespace Fold
open RegisterControl (Instr Runs Effect)
inductive Point where | loop | check | splitHead | pushTail | pushArgs | body | popTail | rebuild | halt
deriving DecidableEq, Inhabited
instance : Fintype Point := ⟨{.loop,.check,.splitHead,.pushTail,.pushArgs,.body,.popTail,.rebuild,.halt},by
intro p; cases p <;> simp⟩
def code (P : Proc (K Reg)) : Point → RegisterControl.Instr Reg Point
| .loop => .call (TreeFunction.split 1 0 (by decide)) .check
| .check => .branch 1 .halt .splitHead
| .splitHead => .call (TreeFunction.split 3 1 (by decide)) .pushTail
| .pushTail => .call (TreeFunction.cons 1 2 (by decide)) .pushArgs
| .pushArgs => .call (TreeFunction.cons 3 0 (by decide)) .body
| .body => .call P .popTail
| .popTail => .call (TreeFunction.split 1 2 (by decide)) .rebuild
| .rebuild => .call (TreeFunction.cons 1 0 (by decide)) .loop
| .halt => .halt
def heads (a b r s : Data) : Env Reg := Function.update (env b r s) 3 a
lemma splitHeads (a b r s : Data) :
Exec (TreeFunction.split 3 1 (by decide)) (encodeEnv (env b (.cons a r) s)) (encodeEnv (heads a b r s))
(2*TreeFunction.size a+5) := by
have hh := split_exec (env b (.cons a r) s) 3 1 (by decide) () a r rfl
have he : putPair (env b (.cons a r) s) 3 1 a r=heads a b r s := by
funext i; fin_cases i <;> simp [heads,putPair,env]
rw [he] at hh
convert hh using 1
all_goals try rfl
simp [TreeFunction.size,env,TreeData.encode]
omega
lemma pushTail (a b r s : Data) :
Exec (TreeFunction.cons 1 2 (by decide)) (encodeEnv (heads a b r s)) (encodeEnv (heads a b .nil (.cons r s)))
(2*TreeFunction.size r+3) := by
have hh := cons_exec (heads a b r s) 1 2 (by decide) ()
have he : putPair (heads a b r s) 1 2 .nil (.cons (heads a b r s 1) (heads a b r s 2))=
heads a b .nil (.cons r s) := by
funext i; fin_cases i <;> simp [heads,putPair,env]
rw [he] at hh
exact hh
lemma pushArgs (a b r s : Data) :
Exec (TreeFunction.cons 3 0 (by decide)) (encodeEnv (heads a b .nil (.cons r s)))
(encodeEnv (env (.cons a b) .nil (.cons r s))) (2*TreeFunction.size a+3) := by
have hh := cons_exec (heads a b .nil (.cons r s)) 3 0 (by decide) ()
have he : putPair (heads a b .nil (.cons r s)) 3 0 .nil
(.cons (heads a b .nil (.cons r s) 3) (heads a b .nil (.cons r s) 0))=
env (.cons a b) .nil (.cons r s) := by
funext i; fin_cases i <;> simp [heads,putPair,env]
rw [he] at hh
exact hh
def cost (f : A×B → B) (t : A×B → ℕ) : List A → B → ℕ
| [],_ => 10
| a::as,b => t (a,b)+6*TreeFunction.size (encode a)+8*TreeFunction.size (encode as)+34+cost f t as (f (a,b))
lemma runs {f : A×B → B} (F : Realizer f) (as : List A) (b : B) (s : Data) :
Runs (code F.program) (some Point.loop) (env (encode (as,b)) .nil s)
(env (encode (as.foldl (fun b a=>f (a,b)) b)) .nil s) (cost f F.cost as b) := by
induction as generalizing b with
| nil =>
have hh : Runs (code F.program) (some Point.halt) (env (encode b) .nil s) (env (encode b) .nil s) 1 :=
Runs.step _ _ _ _ _ 0 1 (Effect.halt _) (Runs.done _)
have hc : Runs (code F.program) (some Point.check) (env (encode b) .nil s) (env (encode b) .nil s) 2 :=
Runs.step _ _ _ _ _ 1 1 (Effect.nilBranch _ 1 _ _ rfl) hh
have hs:=split10 .nil (encode b) .nil s
have hs' : Exec (TreeFunction.split 1 0 (by decide)) (encodeEnv (env (encode (([] : List A),b)) .nil s))
(encodeEnv (env (encode b) .nil s)) 7 := by simpa [size_nil,encode_prod,encode_list_nil] using hs
exact Runs.step _ _ _ _ _ 2 8 (Effect.call _ _ _ _ 7 hs') hc
| cons a as ih =>
let z:=as.foldl (fun b a=>f (a,b)) (f (a,b))
let sa:=TreeFunction.size (encode a)
let sr:=TreeFunction.size (encode as)
let rest:=cost f F.cost as (f (a,b))
have hr := ih (f (a,b))
have h1:=cons10 (encode (f (a,b))) (encode as) s
have hreb : Runs (code F.program) (some Point.rebuild) (env (encode (f (a,b))) (encode as) s)
(env (encode z) .nil s) ((2*sr+4)+rest) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h1) hr
have h2 := (split12 (encode (f (a,b))) .nil (encode as) s).mono
(show TreeFunction.size Data.nil+2*TreeFunction.size (encode as)+4 ≤ 2*sr+5 by
change 1+2*sr+4 ≤ 2*sr+5
omega)
have hpop : Runs (code F.program) (some Point.popTail) (env (encode (f (a,b))) .nil (.cons (encode as) s))
(env (encode z) .nil s) ((2*sr+6)+((2*sr+4)+rest)) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h2) hreb
have h3:=F.correct (a,b) (.cons (encode as) s)
have hbody : Runs (code F.program) (some Point.body) (env (encode (a,b)) .nil (.cons (encode as) s))
(env (encode z) .nil s) ((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest))) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h3) hpop
have h4:=pushArgs (encode a) (encode b) (encode as) s
have ha : Runs (code F.program) (some Point.pushArgs) (heads (encode a) (encode b) .nil (.cons (encode as) s))
(env (encode z) .nil s) ((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest)))) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h4) hbody
have h5:=pushTail (encode a) (encode b) (encode as) s
have ht : Runs (code F.program) (some Point.pushTail) (heads (encode a) (encode b) (encode as) s)
(env (encode z) .nil s) ((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest))))) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h5) ha
have h6:=splitHeads (encode a) (encode b) (encode as) s
have hsh : Runs (code F.program) (some Point.splitHead) (env (encode b) (encode (a::as)) s)
(env (encode z) .nil s) ((2*sa+6)+((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest)))))) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h6) ht
have hc : Runs (code F.program) (some Point.check) (env (encode b) (encode (a::as)) s)
(env (encode z) .nil s) (1+((2*sa+6)+((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest))))))) :=
Runs.step _ _ _ _ _ _ 1 (Effect.consBranch _ 1 _ _ (encode a) (encode as) rfl) hsh
have h7 := (split10 (encode (a::as)) (encode b) .nil s).mono
(show TreeFunction.size Data.nil+2*TreeFunction.size (encode (a::as))+4 ≤ 2*TreeFunction.size (encode (a::as))+5 by
change 1+2*TreeFunction.size (encode (a::as))+4 ≤ 2*TreeFunction.size (encode (a::as))+5
omega)
have hl : Runs (code F.program) (some Point.loop) (env (encode (a::as,b)) .nil s)
(env (encode z) .nil s) ((2*TreeFunction.size (encode (a::as))+6)+(1+((2*sa+6)+((2*sr+4)+((2*sa+4)+((F.cost (a,b)+1)+((2*sr+6)+((2*sr+4)+rest)))))))) :=
Runs.step _ _ _ _ _ _ _ (Effect.call _ _ _ _ _ h7) hc
convert hl using 1
all_goals try rfl
simp only [cost,encode_list_cons,size_cons,sa,sr,rest]
ring
end Fold
def fold {f : A×B → B} (F : Realizer f) : Realizer (fun ab : List A×B=>ab.1.foldl (fun b a=>f (a,b)) ab.2) where
program := RegisterControl.compile (Fold.code F.program)
cost := fun ab=>Fold.cost f F.cost ab.1 ab.2
correct := fun ab s=>RegisterControl.compile_exec _ _ _ _ (Fold.runs F ab.1 ab.2 s)
end MatchingFPRAS.TreeTyped
end OAI
|