math / data /lean /OAI /Computability /MeanPayoff /LoopDevices.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
17.5 kB
import OAI.Computability.MeanPayoff.VectorDevices
namespace OAI
section
namespace MeanPayoff.TreeDevice.Forest
open RegisterBits BinaryData
open BinaryData.Take (advance_add)
def encode (xs : List Data) : List Bool := xs.flatMap BinaryData.encode
@[simp] theorem encode_nil : encode [] = [] := rfl
@[simp] theorem encode_cons (x : Data) (xs : List Data) :
encode (x::xs) = BinaryData.encode x++encode xs := rfl
@[simp] theorem encode_append (a b : List Data) : encode (a++b) = encode a++encode b := List.flatMap_append
structure Layout where
a : List Data
b : List Data
c : List Data
def stack (x : Layout) (suffix : List Bool) := core (encode x.a++suffix) (encode x.b) (encode x.c)
structure Segment {α : Type} (s t : α → Layout) where
program : RegisterBits.Program 5
limit : α → ℕ
correct : ∀ x suffix out bits,
advance program bits ⟨some program.start,stack (s x) suffix,out⟩ (limit x) =
⟨none,stack (t x) suffix,out⟩
noncomputable abbrev seqFlow {α : Type} {s t u : α → Layout} (P : Segment s t) (Q : Segment t u) :
Flow.Program 5 where
nodes := 2
start := 0
block := ![P.program,Q.program]
read _ := 0
next p _ _ := if p=0 then some ⟨1,.keep,none⟩ else none
noncomputable def Segment.seq {α : Type} {s t u : α → Layout} (P : Segment s t) (Q : Segment t u) :
Segment s u where
program := Flow.compile (seqFlow P Q)
limit x := P.limit x+Q.limit x+2
correct x suffix out bits := by
obtain ⟨m,hm,he⟩ := Flow.hop (seqFlow P Q) 0 1 _ _ out bits _
(P.correct x suffix out bits) (by intros; rfl)
obtain ⟨n,hn,he'⟩ := Flow.finish (seqFlow P Q) 1 _ _ out (fun j => bits (m+j)) _
(Q.correct x suffix out _) (by intros; rfl)
apply advance_pad _ _ _ bits (n := m+n) (by omega) ?_ rfl
change advance _ bits (Flow.state (seqFlow P Q) 0 _ out) _ = _
rw [advance_add,he,he']
def Segment.cast {α : Type} {s t s' t' : α → Layout} (P : Segment s t)
(hs : s'=s) (ht : t'=t) : Segment s' t' := hs ▸ ht ▸ P
noncomputable def move01 {α : Type} (x : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨x z::a z,b z,c z⟩) (fun z => ⟨a z,x z::b z,c z⟩) where
program := moveCode 0 1
limit z := 6*treeSize (x z)+3
correct z suffix out bits := by
simpa only [stack,encode_cons,List.append_assoc] using
TreeDevice.move01 (x z) (encode (a z)++suffix) (encode (b z)) (encode (c z)) out bits
noncomputable def move02 {α : Type} (x : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨x z::a z,b z,c z⟩) (fun z => ⟨a z,b z,x z::c z⟩) where
program := moveCode 0 2
limit z := 6*treeSize (x z)+3
correct z suffix out bits := by
simpa only [stack,encode_cons,List.append_assoc] using
TreeDevice.move02 (x z) (encode (a z)++suffix) (encode (b z)) (encode (c z)) out bits
noncomputable def move10 {α : Type} (x : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨a z,x z::b z,c z⟩) (fun z => ⟨x z::a z,b z,c z⟩) where
program := moveCode 1 0
limit z := 6*treeSize (x z)+3
correct z suffix out bits := by
simpa only [stack,encode_cons,List.append_assoc] using
TreeDevice.move10 (x z) (encode (b z)) (encode (a z)++suffix) (encode (c z)) out bits
noncomputable def move20 {α : Type} (x : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨a z,b z,x z::c z⟩) (fun z => ⟨x z::a z,b z,c z⟩) where
program := moveCode 2 0
limit z := 6*treeSize (x z)+3
correct z suffix out bits := by
simpa only [stack,encode_cons,List.append_assoc] using
TreeDevice.move20 (x z) (encode (c z)) (encode (a z)++suffix) (encode (b z)) out bits
noncomputable def swap {α : Type} (x y : α → Data) (a : α → List Data) :
Segment (fun z => ⟨x z::y z::a z,[],[]⟩) (fun z => ⟨y z::x z::a z,[],[]⟩) :=
(move01 x (fun z => y z::a z) (fun _ => []) (fun _ => [])).seq
((move02 y a (fun z => [x z]) (fun _ => [])).seq
((move10 x a (fun _ => []) (fun z => [y z])).seq
(move20 y (fun z => x z::a z) (fun _ => []) (fun _ => []))))
def bitOp (i : Fin 5) (op : BinaryStack.Op) : RegisterBits.Program 5 where
states := 2
start := 0
read _ := i
transition q _ _ := if q=0 then some ⟨1,op,none⟩ else none
theorem bitOp_runs (i : Fin 5) (op : BinaryStack.Op) (s : Fin 5 → List Bool)
(out : List Bool) (bits : ℕ → Bool) :
advance (bitOp i op) bits ⟨some (bitOp i op).start,s,out⟩ 2 =
⟨none,Function.update s i (BinaryStack.applyOp op (s i)),out⟩ := by
simp [advance,RegisterBits.step,bitOp]
def unpair {α : Type} (x y : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨Data.pair (x z) (y z)::a z,b z,c z⟩)
(fun z => ⟨x z::y z::a z,b z,c z⟩) where
program := bitOp 0 .pop
limit _ := 2
correct z suffix out bits := by
rw [bitOp_runs]
simp only [stack,encode_cons,BinaryData.encode,List.cons_append,List.append_assoc,core_zero,
BinaryStack.applyOp,List.tail_cons]
congr 1
funext i; fin_cases i <;> rfl
def pair {α : Type} (x y : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨x z::y z::a z,b z,c z⟩)
(fun z => ⟨Data.pair (x z) (y z)::a z,b z,c z⟩) where
program := bitOp 0 (.push true)
limit _ := 2
correct z suffix out bits := by
rw [bitOp_runs]
simp only [stack,encode_cons,BinaryData.encode,List.cons_append,List.append_assoc,core_zero,
BinaryStack.applyOp]
congr 1
funext i; fin_cases i <;> rfl
noncomputable def applyDevice {α β γ : Type} {ea : β → Data} {eb : γ → Data} {f : β → γ}
(F : Device ea eb f) (x : α → β) (a : α → List Data) :
Segment (fun z => ⟨ea (x z)::a z,[],[]⟩) (fun z => ⟨eb (f (x z))::a z,[],[]⟩) where
program := F.program
limit z := F.limit (x z)
correct z suffix out bits := by
simpa only [store,stack,encode_cons,encode_nil,core,List.append_assoc] using
F.correct (x z) (encode (a z)++suffix) out bits
noncomputable def toDevice {α β : Type} (ea : α → Data) (eb : β → Data) (f : α → β)
(P : Segment (fun z => ⟨[ea z],[],[]⟩) (fun z => ⟨[eb (f z)],[],[]⟩)) : Device ea eb f :=
ofProgram ea eb f P.program P.limit (by
intros x suffix out bits
simpa only [stack,encode_cons,encode_nil,List.append_nil,core,store] using P.correct x suffix out bits)
end MeanPayoff.TreeDevice.Forest
namespace MeanPayoff.TreeDevice.Forest
open RegisterBits BinaryData
noncomputable def copy01 {α : Type} (x : α → Data) (a b c : α → List Data) :
Segment (fun z => ⟨x z::a z,b z,c z⟩) (fun z => ⟨x z::a z,x z::b z,c z⟩) where
program := rename Copy.program (slots (0:Fin 3) 1)
limit z := 7*treeSize (x z)+3
correct z suffix out bits := by
have h := copy_tree (0:Fin 3) 1 (by decide)
(core (BinaryData.encode (x z)++(encode (a z)++suffix)) (encode (b z)) (encode (c z)))
out (x z) (encode (a z)++suffix) (encode (b z)) rfl rfl rfl rfl bits
simp only [stack,encode_cons,List.append_assoc]
refine h.trans ?_
apply Take.config_ext
· rfl
· funext i; fin_cases i <;> rfl
· rfl
noncomputable def duplicate {α : Type} (x : α → Data) (a : α → List Data) :
Segment (fun z => ⟨x z::a z,[],[]⟩) (fun z => ⟨x z::x z::a z,[],[]⟩) :=
(copy01 x a (fun _ => []) (fun _ => [])).seq
(move10 x (fun z => x z::a z) (fun _ => []) (fun _ => []))
def erase (i : Fin 5) : RegisterBits.Program 5 where
states := 1
start := 0
read _ := i
transition _ top _ := match top with
| none => none
| some _ => some ⟨0,.pop,none⟩
theorem erase_runs (i : Fin 5) (s : Fin 5 → List Bool) (out : List Bool) (bits : ℕ → Bool) :
advance (erase i) bits ⟨some (erase i).start,s,out⟩ ((s i).length+1) =
⟨none,Function.update s i [],out⟩ := by
generalize hx : s i = xs
induction xs generalizing s bits with
| nil => simp [hx,advance,RegisterBits.step,erase]
| cons b xs ih =>
rw [show (b::xs).length+1 = 1+(xs.length+1) by simp; omega,Take.advance_add]
have hs : advance (erase i) bits ⟨some (erase i).start,s,out⟩ 1 =
⟨some (erase i).start,Function.update s i xs,out⟩ := by
simp [advance,RegisterBits.step,erase,hx,BinaryStack.applyOp]
rw [hs,ih _ _ (by simp)]
simp
noncomputable def drop {α : Type} (x : α → Data) (a : α → List Data) :
Segment (fun z => ⟨x z::a z,[],[]⟩) (fun z => ⟨a z,[],[]⟩) :=
(move01 x a (fun _ => []) (fun _ => [])).seq {
program := erase 1
limit z := treeSize (x z)+1
correct := by
intro z suffix out bits
have h := erase_runs (1:Fin 5) (stack ⟨a z,[x z],[]⟩ suffix) out bits
simp only [stack,encode_cons,encode_nil,List.append_nil] at h ⊢
refine h.trans ?_
apply Take.config_ext
· rfl
· funext i; fin_cases i <;> rfl
· rfl }
end MeanPayoff.TreeDevice.Forest
namespace MeanPayoff.TreeDevice
open BinaryData Forest
def product {α β : Type} (ea : α → Data) (eb : β → Data) (x : α × β) : Data := .pair (ea x.1) (eb x.2)
noncomputable def pairMap {α β γ δ : Type} {ea : α → Data} {eb : β → Data}
{ec : γ → Data} {ed : δ → Data} {f : α → β} {g : γ → δ}
(F : Device ea eb f) (G : Device ec ed g) :
Device (product ea ec) (product eb ed) (fun z : α × γ => (f z.1,g z.2)) :=
toDevice _ _ _ <|
(unpair (fun z : α × γ => ea z.1) (fun z : α × γ => ec z.2) (fun _ => []) (fun _ => []) (fun _ => [])).seq
((applyDevice F Prod.fst (fun z : α × γ => [ec z.2])).seq
((swap (fun z : α × γ => eb (f z.1)) (fun z : α × γ => ec z.2) (fun _ => [])).seq
((applyDevice G Prod.snd (fun z : α × γ => [eb (f z.1)])).seq
((swap (fun z : α × γ => ed (g z.2)) (fun z : α × γ => eb (f z.1)) (fun _ => [])).seq
(pair (fun z : α × γ => eb (f z.1)) (fun z : α × γ => ed (g z.2)) (fun _ => []) (fun _ => []) (fun _ => []))))))
noncomputable def dup {α : Type} (ea : α → Data) : Device ea (product ea ea) (fun x => (x,x)) :=
toDevice _ _ _ <| (duplicate ea (fun _ => [])).seq
(pair ea ea (fun _ => []) (fun _ => []) (fun _ => []))
noncomputable def fanout {α β γ : Type} {ea : α → Data} {eb : β → Data} {ec : γ → Data}
{f : α → β} {g : α → γ} (F : Device ea eb f) (G : Device ea ec g) :
Device ea (product eb ec) (fun x => (f x,g x)) :=
compose (dup ea) (pairMap F G)
noncomputable def first {α β : Type} (ea : α → Data) (eb : β → Data) :
Device (product ea eb) ea Prod.fst :=
toDevice _ _ _ <|
(unpair (fun z : α × β => ea z.1) (fun z : α × β => eb z.2) (fun _ => []) (fun _ => []) (fun _ => [])).seq
((swap (fun z : α × β => ea z.1) (fun z : α × β => eb z.2) (fun _ => [])).seq
(drop (fun z : α × β => eb z.2) (fun z : α × β => [ea z.1])))
noncomputable def second {α β : Type} (ea : α → Data) (eb : β → Data) :
Device (product ea eb) eb Prod.snd :=
toDevice _ _ _ <|
(unpair (fun z : α × β => ea z.1) (fun z : α × β => eb z.2) (fun _ => []) (fun _ => []) (fun _ => [])).seq
(drop (fun z : α × β => ea z.1) (fun z : α × β => [eb z.2]))
end MeanPayoff.TreeDevice
namespace MeanPayoff.TreeDevice.Fold
open RegisterBits BinaryData
noncomputable abbrev flow {α β : Type} {ea : α → Data} {eb : β → Data} {f : α × β → α}
(F : Device (product ea eb) ea f) : Flow.Program 5 where
nodes := 6
start := 0
block := ![skip,moveCode 0 1,skip,moveCode 1 0,F.program,moveCode 1 0]
read _ := 0
next p top _ := match p.val with
| 0 => some ⟨1,.pop,none⟩
| 1 => some ⟨2,.keep,none⟩
| 2 => some ⟨if top=some true then 3 else 5,.pop,none⟩
| 3 => some ⟨4,.push true,none⟩
| 4 => some ⟨1,.keep,none⟩
| _ => none
noncomputable abbrev program {α β : Type} {ea : α → Data} {eb : β → Data} {f : α × β → α}
(F : Device (product ea eb) ea f) := Flow.compile (flow F)
noncomputable abbrev cfg {α β : Type} {ea : α → Data} {eb : β → Data} {f : α × β → α}
(F : Device (product ea eb) ea f) (q : Fin 6) (a b out : List Bool) : Config (program F) :=
Flow.state (flow F) q (core a b []) out
def fold {α β : Type} (f : α × β → α) (a : α) (xs : List β) := xs.foldl (fun a x => f (a,x)) a
def time {α β : Type} {ea : α → Data} {eb : β → Data} {f : α × β → α}
(F : Device (product ea eb) ea f) (a : α) : List β → ℕ
| [] => 12*treeSize (ea a)+10
| b::bs => 12*treeSize (ea a)+F.limit (a,b)+11+time F (f (a,b)) bs
theorem loop {α β : Type} {ea : α → Data} {eb : β → Data} {f : α × β → α}
(F : Device (product ea eb) ea f) (a : α) (xs : List β) (suffix out : List Bool) :
Reaches (program F)
(cfg F 1 (encode (ea a)++encode (listTree eb xs)++suffix) [] out)
⟨none,core (encode (ea (fold f a xs))++suffix) [] [],out⟩ (time F a xs) := by
induction xs generalizing a with
| nil =>
have h₁ : Reaches (program F) (cfg F 1 (encode (ea a)++encode Data.nil++suffix) [] out)
(cfg F 2 (encode Data.nil++suffix) (encode (ea a)) out) (6*treeSize (ea a)+4) := by
intro bits
simpa only [List.append_nil,List.append_assoc] using Flow.hop (flow F) 1 2 _ _ out bits _
(move01 (ea a) (encode Data.nil++suffix) [] [] out bits) (by intros; rfl)
have h₂ : Reaches (program F) (cfg F 2 (encode Data.nil++suffix) (encode (ea a)) out)
(cfg F 5 suffix (encode (ea a)) out) 2 := by
intro bits
apply Flow.hop_update (flow F) 2 5 _ _ _ out bits 1 .pop rfl (by intros; rfl)
change Function.update (core _ _ _) 0 (BinaryStack.applyOp .pop _) = _
simp only [flow,advance,core_zero,core_update]; rfl
have h₃ : Reaches (program F) (cfg F 5 suffix (encode (ea a)) out)
⟨none,core (encode (ea a)++suffix) [] [],out⟩ (6*treeSize (ea a)+4) := by
intro bits
simpa only [List.append_nil] using Flow.finish (flow F) 5 _ _ out bits _
(move10 (ea a) [] suffix [] out bits) (by intros; rfl)
exact (h₁.trans (h₂.trans h₃)).mono (by simp [time]; omega)
| cons b bs ih =>
let tail := encode (listTree eb bs)++suffix
have h₁ : Reaches (program F)
(cfg F 1 (encode (ea a)++encode (listTree eb (b::bs))++suffix) [] out)
(cfg F 2 (encode (listTree eb (b::bs))++suffix) (encode (ea a)) out)
(6*treeSize (ea a)+4) := by
intro bits
simpa only [List.append_nil,List.append_assoc] using Flow.hop (flow F) 1 2 _ _ out bits _
(move01 (ea a) (encode (listTree eb (b::bs))++suffix) [] [] out bits) (by intros; rfl)
have h₂ : Reaches (program F)
(cfg F 2 (encode (listTree eb (b::bs))++suffix) (encode (ea a)) out)
(cfg F 3 (encode (eb b)++tail) (encode (ea a)) out) 2 := by
intro bits
apply Flow.hop_update (flow F) 2 3 _ _ _ out bits 1 .pop rfl (by intros; rfl)
change Function.update (core _ _ _) 0 (BinaryStack.applyOp .pop _) = _
simp only [flow,advance,core_zero,core_update]
simp only [listTree,BinaryData.encode,List.cons_append,BinaryStack.applyOp,List.tail_cons,
List.append_assoc,tail]
have h₃ : Reaches (program F) (cfg F 3 (encode (eb b)++tail) (encode (ea a)) out)
(cfg F 4 (encode (product ea eb (a,b))++tail) [] out) (6*treeSize (ea a)+4) := by
intro bits
apply Flow.hop_update (flow F) 3 4 (core (encode (eb b)++tail) (encode (ea a)) [])
(core (encode (ea a)++(encode (eb b)++tail)) [] [])
(core (encode (product ea eb (a,b))++tail) [] []) out bits (6*treeSize (ea a)+3) (.push true)
(by convert move10 (ea a) [] (encode (eb b)++tail) [] out bits using 1 <;> simp [flow])
(by intros; rfl)
change Function.update (core _ _ _) 0 (BinaryStack.applyOp (.push true) _) = _
simp only [core_zero,core_update]
simp only [product,BinaryData.encode,BinaryStack.applyOp,List.cons_append,List.append_assoc]
have h₄ : Reaches (program F) (cfg F 4 (encode (product ea eb (a,b))++tail) [] out)
(cfg F 1 (encode (ea (f (a,b)))++encode (listTree eb bs)++suffix) [] out)
(F.limit (a,b)+1) := by
intro bits
simpa only [store,core,tail,List.append_assoc,cfg] using Flow.hop (flow F) 4 1 _ _ out bits _
(F.correct (a,b) tail out bits) (by intros; rfl)
exact (h₁.trans (h₂.trans (h₃.trans (h₄.trans (ih (f (a,b))))))).mono (by simp [time]; omega)
noncomputable def device {α β : Type} {ea : α → Data} {eb : β → Data} {f : α × β → α}
(F : Device (product ea eb) ea f) :
Device (product ea (listTree eb)) ea (fun z => fold f z.1 z.2) :=
ofProgram _ _ _ (program F) (fun z => time F z.1 z.2+2) (by
intro z suffix out bits
have h₀ : Reaches (program F)
⟨some (program F).start,store (product ea (listTree eb) z) suffix,out⟩
(cfg F 1 (encode (ea z.1)++encode (listTree eb z.2)++suffix) [] out) 2 := by
intro bits
apply Flow.hop_update (flow F) 0 1 _ _ _ out bits 1 .pop rfl (by intros; rfl)
change Function.update (core _ _ _) 0 (BinaryStack.applyOp .pop _) = _
simp only [flow,advance]
simp only [product,BinaryData.encode,BinaryStack.applyOp,List.cons_append,List.append_assoc]
funext i; fin_cases i <;> simp [store,core,BinaryData.encode,List.append_assoc]
exact ((h₀.trans (loop F z.1 z.2 suffix out)).mono (by omega)).pad rfl bits)
end MeanPayoff.TreeDevice.Fold
end
end OAI