math / data /lean /OAI /Computability /MeanPayoff /Comparison.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
16.7 kB
import OAI.Computability.MeanPayoff.BinaryData
namespace OAI
section
namespace MeanPayoff.ArithmeticForest
open RegisterBits
open BinaryData
open WorkStack
def placeA : Fin 3 → Fin 5 := ![0,2,4]
def placeB : Fin 3 → Fin 5 := ![0,3,4]
def placeAdd : Fin 3 → Fin 5 := ![2,3,4]
def placeBox : Fin 3 → Fin 5 := ![2,1,4]
theorem injectA : Function.Injective placeA := by intro i j h; fin_cases i <;> fin_cases j <;> simp_all [placeA]
theorem injectB : Function.Injective placeB := by intro i j h; fin_cases i <;> fin_cases j <;> simp_all [placeB]
theorem injectAdd : Function.Injective placeAdd := by intro i j h; fin_cases i <;> fin_cases j <;> simp_all [placeAdd]
theorem injectBox : Function.Injective placeBox := by intro i j h; fin_cases i <;> fin_cases j <;> simp_all [placeBox]
theorem installA (s : Fin 5 → List Bool) (a b c : List Bool) :
install placeA s ![a,b,c] = ![a,s 1,b,s 3,c] := by
funext i; fin_cases i
· exact install_at placeA injectA s _ 0
· exact install_off placeA s _ _ (by intro j; fin_cases j <;> decide)
· exact install_at placeA injectA s _ 1
· exact install_off placeA s _ _ (by intro j; fin_cases j <;> decide)
· exact install_at placeA injectA s _ 2
theorem installB (s : Fin 5 → List Bool) (a b c : List Bool) :
install placeB s ![a,b,c] = ![a,s 1,s 2,b,c] := by
funext i; fin_cases i
· exact install_at placeB injectB s _ 0
· exact install_off placeB s _ _ (by intro j; fin_cases j <;> decide)
· exact install_off placeB s _ _ (by intro j; fin_cases j <;> decide)
· exact install_at placeB injectB s _ 1
· exact install_at placeB injectB s _ 2
theorem installAdd (s : Fin 5 → List Bool) (a b c : List Bool) :
install placeAdd s ![a,b,c] = ![s 0,s 1,a,b,c] := by
funext i; fin_cases i
· exact install_off placeAdd s _ _ (by intro j; fin_cases j <;> decide)
· exact install_off placeAdd s _ _ (by intro j; fin_cases j <;> decide)
· exact install_at placeAdd injectAdd s _ 0
· exact install_at placeAdd injectAdd s _ 1
· exact install_at placeAdd injectAdd s _ 2
theorem installBox (s : Fin 5 → List Bool) (a b c : List Bool) :
install placeBox s ![a,b,c] = ![s 0,b,a,s 3,c] := by
funext i; fin_cases i
· exact install_off placeBox s _ _ (by intro j; fin_cases j <;> decide)
· exact install_at placeBox injectBox s _ 1
· exact install_at placeBox injectBox s _ 0
· exact install_off placeBox s _ _ (by intro j; fin_cases j <;> decide)
· exact install_at placeBox injectBox s _ 2
noncomputable abbrev flow : Flow.Program 5 where
nodes := 4
start := 0
block q := match q with
| 0 => rename Unbox.program placeA
| 1 => rename Unbox.program placeB
| 2 => rename (RegisterCompile.program WorkStack.SignedAddition.program) placeAdd
| 3 => rename Box.program placeBox
read _ := 4
next q _ _ := match q with
| 0 => some ⟨1,.keep,none⟩
| 1 => some ⟨2,.keep,none⟩
| 2 => some ⟨3,.keep,none⟩
| 3 => none
noncomputable def program := Flow.compile flow
def unboxTime (xs : List Bool) := feedCost xs+1+(2*xs.length+1)
def addTime (a b : SignedBits.Word) := 6*(2*max a.digits.length b.digits.length+5)
def boxTime (xs : List Bool) := 2*xs.length+2+feedCost xs+1
def addWord (a b : SignedBits.Word) := SignedBits.add a.sign b.sign false a.digits b.digits
def store0 (a b : SignedBits.Word) (xs ys : List Bool) : Fin 5 → List Bool :=
![encode (wordData a) ++ encode (wordData b) ++ xs, ys, [],[],[]]
def store1 (a b : SignedBits.Word) (xs ys : List Bool) : Fin 5 → List Bool :=
![encode (wordData b) ++ xs, ys, a.sign::a.digits,[],[]]
def store2 (a b : SignedBits.Word) (xs ys : List Bool) : Fin 5 → List Bool :=
![xs, ys, a.sign::a.digits,b.sign::b.digits,[]]
def store3 (a b : SignedBits.Word) (xs ys : List Bool) : Fin 5 → List Bool :=
![xs, ys, (addWord a b).sign::(addWord a b).digits,[],[]]
def store4 (a b : SignedBits.Word) (xs ys : List Bool) : Fin 5 → List Bool :=
![xs, encode (wordData (addWord a b))++ys, [],[],[]]
theorem stage0 (a b : SignedBits.Word) (xs ys out : List Bool) (bits : ℕ → Bool) :
advance (flow.block 0) bits ⟨some (flow.block 0).start, store0 a b xs ys, out⟩
(unboxTime (a.sign::a.digits)) = ⟨none,store1 a b xs ys,out⟩ := by
have h := rename_advance Unbox.program placeA injectA (store0 a b xs ys)
(Unbox.cfg .read (encode (wordData a)++(encode (wordData b)++xs)) [] [] out)
bits (unboxTime (a.sign::a.digits))
rw [show unboxTime (a.sign::a.digits) = feedCost (a.sign::a.digits)+1+(2*(a.sign::a.digits).length+1) by rfl,
show wordData a = listData (a.sign::a.digits) by rfl, Unbox.unboxes] at h
simp only [renamed, Unbox.cfg, Unbox.stopped, installA, store0, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_three,
List.append_nil, List.append_assoc] at h
simp only [store0, List.append_assoc]
convert h using 1 <;> rfl
theorem stage1 (a b : SignedBits.Word) (xs ys out : List Bool) (bits : ℕ → Bool) :
advance (flow.block 1) bits ⟨some (flow.block 1).start, store1 a b xs ys, out⟩
(unboxTime (b.sign::b.digits)) = ⟨none,store2 a b xs ys,out⟩ := by
have h := rename_advance Unbox.program placeB injectB (store1 a b xs ys)
(Unbox.cfg .read (encode (wordData b)++xs) [] [] out)
bits (unboxTime (b.sign::b.digits))
rw [show unboxTime (b.sign::b.digits) = feedCost (b.sign::b.digits)+1+(2*(b.sign::b.digits).length+1) by rfl,
show wordData b = listData (b.sign::b.digits) by rfl, Unbox.unboxes] at h
simp only [renamed, Unbox.cfg, Unbox.stopped, installB, store1, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, List.append_nil] at h
convert h using 1 <;> rfl
theorem stage2 (a b : SignedBits.Word) (xs ys out : List Bool) (bits : ℕ → Bool) :
advance (flow.block 2) bits ⟨some (flow.block 2).start, store2 a b xs ys, out⟩
(addTime a b) = ⟨none,store3 a b xs ys,out⟩ := by
have h := rename_advance (RegisterCompile.program WorkStack.SignedAddition.program) placeAdd injectAdd
(store2 a b xs ys) (RegisterCompile.lift WorkStack.SignedAddition.program out
(WorkStack.SignedAddition.state .start (a.sign::a.digits) (b.sign::b.digits) []))
bits (addTime a b)
rw [show addTime a b = 6*(2*max a.digits.length b.digits.length+5) by rfl,
RegisterCompile.signed_adds] at h
simp only [renamed, RegisterCompile.lift, WorkStack.SignedAddition.state,
WorkStack.SignedAddition.stopped, installAdd, store2, Matrix.cons_val_zero, Matrix.cons_val_one] at h
convert h using 1 <;> rfl
theorem stage3 (a b : SignedBits.Word) (xs ys out : List Bool) (bits : ℕ → Bool) :
advance (flow.block 3) bits ⟨some (flow.block 3).start, store3 a b xs ys, out⟩
(boxTime ((addWord a b).sign::(addWord a b).digits)) = ⟨none,store4 a b xs ys,out⟩ := by
have h := rename_advance Box.program placeBox injectBox (store3 a b xs ys)
(Box.cfg .reverse ((addWord a b).sign::(addWord a b).digits) ys [] out)
bits (boxTime ((addWord a b).sign::(addWord a b).digits))
rw [show boxTime ((addWord a b).sign::(addWord a b).digits) =
2*((addWord a b).sign::(addWord a b).digits).length+2+
feedCost ((addWord a b).sign::(addWord a b).digits)+1 by rfl, Box.boxes] at h
simp only [renamed, Box.cfg, Box.stopped, installBox, store3, Matrix.cons_val_zero, Matrix.cons_val_three] at h
convert h using 1 <;> rfl
end MeanPayoff.ArithmeticForest
namespace MeanPayoff.ArithmeticForest
open RegisterBits
open BinaryData
open BinaryData.Take (advance_add)
theorem addWord_val (a b : SignedBits.Word) : (addWord a b).val = a.val+b.val := by
cases a; cases b
simpa [addWord] using
SignedBits.add_val _ _ false _ _
theorem total_bound (a b : SignedBits.Word) :
(unboxTime (a.sign::a.digits)+1) + (unboxTime (b.sign::b.digits)+1) +
(addTime a b+1) + (boxTime ((addWord a b).sign::(addWord a b).digits)+1) ≤
30*(a.digits.length+b.digits.length+3) := by
have ha := Unbox.unboxes_bound (a.sign::a.digits)
have hb := Unbox.unboxes_bound (b.sign::b.digits)
have hc := Box.boxes_bound ((addWord a b).sign::(addWord a b).digits)
have hl := SignedBits.add_length a.sign b.sign false a.digits b.digits
change (addWord a b).digits.length = _ at hl
simp only [List.length_cons] at ha hb hc
unfold unboxTime addTime boxTime
simp only [List.length_cons]
omega
theorem program_adds (a b : SignedBits.Word) (xs ys out : List Bool) (bits : ℕ → Bool) :
∃ t ≤ 30*(a.digits.length+b.digits.length+3),
advance program bits ⟨some program.start,store0 a b xs ys,out⟩ t =
⟨none,store4 a b xs ys,out⟩ := by
obtain ⟨t₀,h₀,e₀⟩ := Flow.hop flow 0 1 (store0 a b xs ys) (store1 a b xs ys) out bits
(unboxTime (a.sign::a.digits)) (stage0 a b xs ys out bits) (by intros; rfl)
obtain ⟨t₁,h₁,e₁⟩ := Flow.hop flow 1 2 (store1 a b xs ys) (store2 a b xs ys) out
(fun j => bits (t₀+j)) (unboxTime (b.sign::b.digits))
(stage1 a b xs ys out _) (by intros; rfl)
obtain ⟨t₂,h₂,e₂⟩ := Flow.hop flow 2 3 (store2 a b xs ys) (store3 a b xs ys) out
(fun j => bits (t₀+t₁+j)) (addTime a b) (stage2 a b xs ys out _) (by intros; rfl)
obtain ⟨t₃,h₃,e₃⟩ := Flow.finish flow 3 (store3 a b xs ys) (store4 a b xs ys) out
(fun j => bits (t₀+t₁+t₂+j)) (boxTime ((addWord a b).sign::(addWord a b).digits))
(stage3 a b xs ys out _) (by intros; rfl)
refine ⟨t₀+t₁+t₂+t₃, le_trans (by omega) (total_bound a b), ?_⟩
change advance (Flow.compile flow) bits (Flow.state flow 0 (store0 a b xs ys) out) _ = _
rw [advance_add _ _ _ (t₀+t₁+t₂) t₃, advance_add _ _ _ (t₀+t₁) t₂,
advance_add _ _ _ t₀ t₁, e₀, e₁, e₂, e₃]
rfl
end MeanPayoff.ArithmeticForest
namespace MeanPayoff.SignedBits
def compareBit (x y c : Bool) : Bool := if x = y then c else !x && y
def compare (a b c : Bool) : List Bool → List Bool → Bool
| [], [] => if a = b then c else a
| x::xs, [] => compare a b (compareBit x b c) xs []
| [], y::ys => compare a b (compareBit a y c) [] ys
| x::xs, y::ys => compare a b (compareBit x y c) xs ys
termination_by xs ys => xs.length+ys.length
theorem compare_bit_correct (x y c : Bool) (A B : ℤ) :
(A < B ∨ A = B ∧ compareBit x y c = true) ↔
((x.toNat : ℤ)+2*A < (y.toNat : ℤ)+2*B ∨
(x.toNat : ℤ)+2*A = (y.toNat : ℤ)+2*B ∧ c = true) := by
cases x <;> cases y <;> cases c <;> simp [compareBit] <;> omega
theorem compare_correct (a b c : Bool) (xs ys : List Bool) :
compare a b c xs ys = true ↔
(Word.mk a xs).val < (Word.mk b ys).val ∨
(Word.mk a xs).val = (Word.mk b ys).val ∧ c = true := by
cases xs with
| nil =>
cases ys with
| nil => cases a <;> cases b <;> cases c <;> norm_num [compare, Word.val, BinaryStack.Addition.value]
| cons y ys =>
rw [compare, compare_correct, compare_bit_correct]
have hx := val_uncons a []
have hy := val_uncons b (y::ys)
simp only [head, List.head?_nil, List.head?_cons, Option.getD_none, Option.getD_some,
List.tail_nil, List.tail_cons] at hx hy
rw [← hx, ← hy]
| cons x xs =>
cases ys with
| nil =>
rw [compare, compare_correct, compare_bit_correct]
have hx := val_uncons a (x::xs)
have hy := val_uncons b []
simp only [head, List.head?_nil, List.head?_cons, Option.getD_none, Option.getD_some,
List.tail_nil, List.tail_cons] at hx hy
rw [← hx, ← hy]
| cons y ys =>
rw [compare, compare_correct, compare_bit_correct]
have hx := val_uncons a (x::xs)
have hy := val_uncons b (y::ys)
simp only [head, List.head?_cons, Option.getD_some, List.tail_cons] at hx hy
rw [← hx, ← hy]
termination_by xs.length+ys.length
theorem compare_lt (a b : Word) : compare a.sign b.sign false a.digits b.digits = true ↔ a.val < b.val := by
cases a; cases b; simp [compare_correct]
end MeanPayoff.SignedBits
namespace MeanPayoff.WorkStack.SignedCompare
open SignedBits (compare compareBit)
inductive Label where
| start
| feed (a b c : Bool)
| halt
deriving DecidableEq, Fintype
noncomputable def equiv : Label ≃ Fin (Fintype.card Label) := Fintype.equivFin _
noncomputable def enc (q : Label) := equiv q
@[simp] theorem decode (q : Label) : equiv.symm (enc q) = q := equiv.symm_apply_apply _
noncomputable def program : Program where
states := Fintype.card Label
start := enc .start
transition q top _ := match equiv.symm q with
| .start => some ⟨enc (.feed ((top 0).getD false) ((top 1).getD false) false), ![.pop,.pop,.keep]⟩
| .feed a b c =>
if top 0 = none ∧ top 1 = none then
some ⟨enc .halt, ![.push (if a=b then c else a),.keep,.keep]⟩
else some ⟨enc (.feed a b (compareBit ((top 0).getD a) ((top 1).getD b) c)), ![.pop,.pop,.keep]⟩
| .halt => none
noncomputable def state (q : Label) (xs ys zs : List Bool) : Config program :=
⟨some (enc q), ![xs,ys,zs]⟩
def stopped (r : Bool) (zs : List Bool) : Config program := ⟨none, ![[r],[],zs]⟩
@[simp] theorem step_start (a b : Bool) (xs ys zs : List Bool) (bit : Bool) :
step program (state .start (a::xs) (b::ys) zs) bit = state (.feed a b false) xs ys zs := by
simp only [step,state,program,decode]
apply Config.ext
· rfl
· funext k; fin_cases k <;> rfl
@[simp] theorem step_nil (a b c : Bool) (zs : List Bool) (bit : Bool) :
step program (state (.feed a b c) [] [] zs) bit = state .halt [if a=b then c else a] [] zs := by
simp only [step,state,program,decode]
apply Config.ext
· rfl
· funext k; fin_cases k <;> rfl
@[simp] theorem step_left (a b c x : Bool) (xs zs : List Bool) (bit : Bool) :
step program (state (.feed a b c) (x::xs) [] zs) bit = state (.feed a b (compareBit x b c)) xs [] zs := by
simp only [step,state,program,decode]
apply Config.ext
· rfl
· funext k; fin_cases k <;> rfl
@[simp] theorem step_right (a b c y : Bool) (ys zs : List Bool) (bit : Bool) :
step program (state (.feed a b c) [] (y::ys) zs) bit = state (.feed a b (compareBit a y c)) [] ys zs := by
simp only [step,state,program,decode]
apply Config.ext
· rfl
· funext k; fin_cases k <;> rfl
@[simp] theorem step_both (a b c x y : Bool) (xs ys zs : List Bool) (bit : Bool) :
step program (state (.feed a b c) (x::xs) (y::ys) zs) bit = state (.feed a b (compareBit x y c)) xs ys zs := by
simp only [step,state,program,decode]
apply Config.ext
· rfl
· funext k; fin_cases k <;> rfl
@[simp] theorem step_halt (r : Bool) (zs : List Bool) (bit : Bool) :
step program (state .halt [r] [] zs) bit = stopped r zs := by
simp only [step,state,program,decode]; rfl
theorem feed_runs (a b c : Bool) (xs ys zs : List Bool) (bits : ℕ → Bool) :
advance program bits (state (.feed a b c) xs ys zs) (max xs.length ys.length+1) =
state .halt [compare a b c xs ys] [] zs := by
cases xs with
| nil =>
cases ys with
| nil => simp [advance,SignedBits.compare]
| cons y ys =>
rw [show max [].length (y::ys).length+1 = max [].length ys.length+1+1 by simp,
advance_front, step_right, feed_runs]
simp only [SignedBits.compare]
| cons x xs =>
cases ys with
| nil =>
rw [show max (x::xs).length [].length+1 = max xs.length [].length+1+1 by simp,
advance_front, step_left, feed_runs]
simp only [SignedBits.compare]
| cons y ys =>
rw [show max (x::xs).length (y::ys).length+1 = max xs.length ys.length+1+1 by simp,
advance_front, step_both, feed_runs]
simp only [SignedBits.compare]
termination_by xs.length+ys.length
theorem program_compares (a b : SignedBits.Word) (zs : List Bool) (bits : ℕ → Bool) :
advance program bits (state .start (a.sign::a.digits) (b.sign::b.digits) zs)
(max a.digits.length b.digits.length+3) =
stopped (compare a.sign b.sign false a.digits b.digits) zs := by
rw [show max a.digits.length b.digits.length+3 = (max a.digits.length b.digits.length+1+1)+1 by omega,
advance_front, step_start, advance, feed_runs, step_halt]
theorem output_correct (a b : SignedBits.Word) (zs : List Bool) (bits : ℕ → Bool) :
let c := advance program bits (state .start (a.sign::a.digits) (b.sign::b.digits) zs)
(max a.digits.length b.digits.length+3)
c.control = none ∧ (c.stack 0 = [true] ↔ a.val < b.val) ∧ c.stack 1 = [] ∧ c.stack 2 = zs := by
simp only [program_compares,stopped,Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_two,
List.cons.injEq, and_true]
exact ⟨True.intro, SignedBits.compare_lt a b, True.intro, rfl⟩
end MeanPayoff.WorkStack.SignedCompare
end
end OAI